feat(generators): create new app :with-mongo

Author: phatpham9

generators/with-mongo/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-mongo/templates/<%= compNameParamCasePlural %>/constants.ts

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

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

@@ -0,0 +1,129 @@
+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);
+      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 updatePartial = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): Promise<void> => {
+  try {
+    console.log((req as MyRequest)[ENTITY]);
+    // update partial object
+    const object = await repository.updatePartial(
+      (req as MyRequest)[ENTITY].id,
+      req.body,
+    );
+
+    res.send(object);
+  } 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, updatePartial, update, del };

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

@@ -0,0 +1,26 @@
+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.updatePartial)
+    .put(controller.update)
+    .delete(controller.del);
+
+  return router;
+};
+
+export default { path, routes };

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

@@ -0,0 +1,18 @@
+import mongoose, {
+  Schema,
+  Document as MongooseDocument,
+  Model as MongooseModel,
+} from 'mongoose';
+
+import { <%= compNamePascalCase %> } from './types';
+import { ENTITY } from './constants';
+
+interface Document extends MongooseDocument, Omit<<%= compNamePascalCase %>, 'id'> {}
+interface Model extends MongooseModel<Document> {}
+
+const schema = new Schema<Document>({
+  name: String,
+});
+
+export default mongoose.model<Document, Model>(ENTITY, schema);
+export { Model, Document };

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

@@ -0,0 +1,81 @@
+import { MyError } from '@boringcodes/utils/error';
+
+import { <%= compNamePascalCase %> } from './types';
+import Model, { Document } from './model';
+
+const transform = (document: Document): <%= compNamePascalCase %> => {
+  const { _id, ...restObject } = document.toObject({
+    virtuals: true,
+    versionKey: false,
+  });
+
+  return restObject;
+};
+
+const list = async (): Promise<<%= compNamePascalCase %>[]> => {
+  // list documents
+  const documents = await Model.find();
+
+  return documents.map(transform);
+};
+
+const create = async (object: Omit<<%= compNamePascalCase %>, 'id'>): Promise<<%= compNamePascalCase %>> => {
+  // create document
+  const document = new Model(object);
+  await document.save();
+
+  return transform(document);
+};
+
+const get = async (id: string): Promise<<%= compNamePascalCase %>> => {
+  // get document
+  const document = await Model.findById(id).exec();
+  if (document === null) {
+    throw new MyError('Document not found');
+  }
+
+  return transform(document);
+};
+
+const updatePartial = async (id: string, object: <%= compNamePascalCase %>): Promise<<%= compNamePascalCase %>> => {
+  // get document
+  const document = await Model.findById(id).exec();
+  if (document === null) {
+    throw new MyError('Document not found');
+  }
+
+  // update partial document
+  document.set(object);
+  await document.save();
+
+  return transform(document);
+};
+
+const update = async (id: string, object: <%= compNamePascalCase %>): Promise<<%= compNamePascalCase %>> => {
+  // get document
+  const document = await Model.findById(id).exec();
+  if (document === null) {
+    throw new MyError('Document not found');
+  }
+
+  // update document
+  document.overwrite(object);
+  await document.save();
+
+  return transform(document);
+};
+
+const del = async (id: string): Promise<<%= compNamePascalCase %>> => {
+  // get document
+  const document = await Model.findById(id).exec();
+  if (document === null) {
+    throw new MyError('Document not found');
+  }
+
+  // delete document
+  await Model.deleteOne({ _id: id }).exec();
+
+  return transform(document);
+};
+
+export default { list, create, get, updatePartial, update, del };

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

@@ -0,0 +1,6 @@
+interface <%= compNamePascalCase %> {
+  readonly id?: string;
+  readonly name?: string;
+}
+
+export { <%= compNamePascalCase %> };