feat(generators): create new app :with-postgres-typeorm

Author: phatpham9

README.md

@@ -63,6 +63,9 @@ $ yo create-service-component:with-mongo
 
 # or :with-postgres
 $ yo create-service-component:with-postgres
+
+# or :with-postgres-typeorm
+$ yo create-service-component:with-postgres-typeorm
 ```
 
 This scaffolds out:
@@ -74,8 +77,8 @@ This scaffolds out:
 │   │   │   ├── constants.ts
 │   │   │   ├── controller.ts
 │   │   │   ├── index.ts
-│   │   │   ├── model.ts        (:with-mongo/:with-postgres)
-│   │   │   ├── repository.ts   (:with-mongo/:with-postgres)
+│   │   │   ├── model.ts        (:with-mongo, :with-postgres or :with-postgres-typeorm)
+│   │   │   ├── repository.ts   (:with-mongo, :with-postgres or :with-postgres-typeorm)
 │   │   │   ├── types.ts
 │   │   └── ...
 │   ├── ...

generators/with-postgres-typeorm/index.js

@@ -0,0 +1,42 @@
+const Generator = require('yeoman-generator');
+const chalk = require('chalk');
+const yosay = require('yosay');
+const changeCase = require('change-case');
+const pluralize = require('pluralize');
+
+const pkg = require('../../package.json');
+
+module.exports = class extends Generator {
+  async prompting() {
+    this.log(yosay(`Welcome to the ${chalk.red(pkg.name)} generator!`));
+
+    const prompts = [
+      {
+        type: 'input',
+        name: 'compName',
+        message: 'Name of the new component (singular)?',
+        default: 'thing',
+      },
+    ];
+
+    return this.prompt(prompts).then((props) => {
+      const compNameParamCase = changeCase.paramCase(props.compName);
+      const compNamePascalCase = changeCase.pascalCase(props.compName);
+
+      this.props = {
+        ...props,
+        compNameParamCase,
+        compNamePascalCase,
+        compNameParamCasePlural: pluralize(compNameParamCase),
+      };
+    });
+  }
+
+  writing() {
+    this.fs.copyTpl(
+      [this.templatePath('**/*'), this.templatePath('**/.*')],
+      this.destinationPath('src/components'),
+      this.props,
+    );
+  }
+};

generators/with-postgres-typeorm/templates/<%= compNameParamCasePlural %>/constants.ts

@@ -0,0 +1,4 @@
+const ENTITY = '<%= compNameParamCase %>';
+const RESOURCE = '<%= compNameParamCasePlural %>';
+
+export { ENTITY, RESOURCE };

generators/with-postgres-typeorm/templates/<%= compNameParamCasePlural %>/controller.ts

@@ -0,0 +1,112 @@
+import { Request, Response, NextFunction } from 'express';
+import { StatusCodes } from 'http-status-codes';
+import { HttpError } from '@boringcodes/utils/error';
+
+import { <%= compNamePascalCase %> } from './types';
+import { ENTITY } from './constants';
+import repository from './repository';
+
+interface MyRequest extends Request {
+  readonly [ENTITY]: Required<<%= compNamePascalCase %>>;
+}
+
+const getById = async (
+  req: Request,
+  _: Response,
+  next: NextFunction,
+): Promise<void> => {
+  try {
+    const { id = '' } = req.params;
+    if (id === '') {
+      throw new HttpError(StatusCodes.BAD_REQUEST, 'Invalid resource Id');
+    }
+
+    try {
+      // get object by id
+      const object = await repository.get(+id);
+
+      // assign object to request for using in the next handlers
+      Object.assign(req, { [ENTITY]: object });
+
+      next();
+    } catch (err) {
+      throw new HttpError(StatusCodes.NOT_FOUND, 'Resource not found');
+    }
+  } catch (err) {
+    next(new HttpError(err.code ?? StatusCodes.INTERNAL_SERVER_ERROR, err));
+  }
+};
+
+const list = async (
+  _: Request,
+  res: Response,
+  next: NextFunction,
+): Promise<void> => {
+  try {
+    // list objects
+    const objects = await repository.list();
+
+    res.send(objects);
+  } catch (err) {
+    next(new HttpError(err.code ?? StatusCodes.INTERNAL_SERVER_ERROR, err));
+  }
+};
+
+const create = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): Promise<void> => {
+  try {
+    // create object
+    const object = await repository.create(req.body);
+
+    res.send(object);
+  } catch (err) {
+    next(new HttpError(err.code ?? StatusCodes.INTERNAL_SERVER_ERROR, err));
+  }
+};
+
+const get = (req: Request, res: Response, next: NextFunction): void => {
+  try {
+    // get object
+    res.send((req as MyRequest)[ENTITY]);
+  } catch (err) {
+    next(new HttpError(err.code ?? StatusCodes.INTERNAL_SERVER_ERROR, err));
+  }
+};
+
+const update = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): Promise<void> => {
+  try {
+    // update object
+    const object = await repository.update(
+      (req as MyRequest)[ENTITY].id,
+      req.body,
+    );
+
+    res.send(object);
+  } catch (err) {
+    next(new HttpError(err.code ?? StatusCodes.INTERNAL_SERVER_ERROR, err));
+  }
+};
+
+const del = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): Promise<void> => {
+  try {
+    // delete object
+    const object = await repository.del((req as MyRequest)[ENTITY].id);
+
+    res.send(object);
+  } catch (err) {
+    next(new HttpError(err.code ?? StatusCodes.INTERNAL_SERVER_ERROR, err));
+  }
+};
+
+export default { getById, list, create, get, update, del };

generators/with-postgres-typeorm/templates/<%= compNameParamCasePlural %>/index.ts

@@ -0,0 +1,25 @@
+import { Router } from 'express';
+
+import { RouteOptions } from '../types';
+import { RESOURCE } from './constants';
+import controller from './controller';
+
+const path = `/${RESOURCE}`;
+
+const routes = (_: RouteOptions): Router => {
+  const router = Router();
+
+  router.param('id', controller.getById);
+
+  router.route('/').get(controller.list).post(controller.create);
+
+  router
+    .route('/:id')
+    .get(controller.get)
+    .patch(controller.update)
+    .delete(controller.del);
+
+  return router;
+};
+
+export default { path, routes };

generators/with-postgres-typeorm/templates/<%= compNameParamCasePlural %>/model.ts

@@ -0,0 +1,17 @@
+import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+
+import { <%= compNamePascalCase %> } from './types';
+import { ENTITY } from './constants';
+
+@Entity(ENTITY)
+class Model implements <%= compNamePascalCase %> {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column()
+  name!: string;
+
+  // TODO: add more fields
+}
+
+export default Model;

generators/with-postgres-typeorm/templates/<%= compNameParamCasePlural %>/repository.ts

@@ -0,0 +1,67 @@
+import { getRepository } from 'typeorm';
+import { MyError } from '@boringcodes/utils/error';
+
+import { <%= compNamePascalCase %> } from './types';
+import Model from './model';
+
+const list = async (): Promise<<%= compNamePascalCase %>[]> => {
+  // list documents
+  const documents = await getRepository(Model).find();
+
+  return documents.map(transform);
+};
+
+const create = async (object: Omit<<%= compNamePascalCase %>, 'id'>): Promise<<%= compNamePascalCase %>> => {
+  // create document
+  const document = getRepository(Model).create(object);
+  await getRepository(Model).save(document);
+
+  return transform(document);
+};
+
+const get = async (id: number): Promise<<%= compNamePascalCase %>> => {
+  // get document
+  const document = await getRepository(Model).findOne(id);
+  if (document === undefined) {
+    throw new MyError('Row not found');
+  }
+
+  return transform(document);
+};
+
+const update = async (
+  id: number,
+  object: Omit<<%= compNamePascalCase %>, 'id'>,
+): Promise<<%= compNamePascalCase %>> => {
+  // get document
+  const document = await getRepository(Model).findOne(id);
+  if (document === undefined) {
+    throw new MyError('Row not found');
+  }
+
+  // update document
+  getRepository(Model).merge(document, object);
+  await getRepository(Model).save(document);
+
+  return transform(document);
+};
+
+const del = async (id: number): Promise<<%= compNamePascalCase %>> => {
+  // get document
+  const document = await getRepository(Model).findOne(id);
+  if (document === undefined) {
+    throw new MyError('Row not found');
+  }
+
+  // delete document
+  await getRepository(Model).remove(document);
+
+  return transform(document);
+};
+
+// transform document to <%= compNamePascalCase %>
+const transform = (document: Model): <%= compNamePascalCase %> => {
+  return document;
+};
+
+export default { list, create, get, update, del };

generators/with-postgres-typeorm/templates/<%= compNameParamCasePlural %>/types.ts

@@ -0,0 +1,7 @@
+interface <%= compNamePascalCase %> {
+  readonly id: number;
+  readonly name: string;
+  // TODO: add more props here
+}
+
+export { <%= compNamePascalCase %> };