express-generator-typescript 2.1.1 → 2.1.3

package/lib/project-files/spec/tests/users.spec.ts

@@ -9,7 +9,8 @@ import User, { IUser } from '@models/user-model';
 
 import { p as userPaths } from '@routes/user-router';
 import {
-  ParamMissingError,
+  ParamInvalidError,
+  // ParamMissingError,
   UserNotFoundError,
   ValidatorFnError,
 } from '@shared/errors';
@@ -47,15 +48,15 @@ const msgs = {
   addUserSuccess: `should return a status code of "${CREATED}" if the request 
     was successful.`,
   addUserFailedMissingParam: `should return a JSON object with an error 
-    message of "${ParamMissingError.Msg}" and a status code of "${BAD_REQUEST}" 
-    if the user param was missing.`,
+    message of "${ValidatorFnError.Msg + 'instanceOf'}" and a status code 
+    of "${BAD_REQUEST}" if the user param was missing.`,
   addUserFallbackErr: `should return a JSON object with an error message and a 
     status code of "${BAD_REQUEST}" if the request was unsuccessful.`,
   updateSuccess: `should return a status code of "${OK}" if the request was 
     successful.`,
   updateParamMissing: `should return a JSON object with an error message of 
-    "${ParamMissingError.Msg}" and a status code of "${BAD_REQUEST}" if the 
-    user param was missing.`,
+    "${ValidatorFnError.Msg + 'instanceOf'}" and a status code of 
+    "${BAD_REQUEST}" if the user param was missing.`,
   updateUserNotFound: `should return a JSON object with the error message of 
     ${UserNotFoundError.Msg} and a status code of 
     "${UserNotFoundError.HttpStatus}" if the id was not found.`,
@@ -274,6 +275,17 @@ describe('user-router', () => {
         });
     });
 
+    // Delete, not a valid number error
+    it(msgs.deleteUserNotFound, (done) => {
+      callApi('horse' as unknown as number)
+        .end((err: Error, res: Response) => {
+          !!err && logger.err(err);
+          expect(res.status).toBe(ParamInvalidError.HttpStatus);
+          expect(res.body.error).toBe(ParamInvalidError.Msg);
+          done();
+        });
+    });
+
     // Delete user fallback error
     it(msgs.deleteFallbackErr, (done) => {
       spyOn(userRepo, 'persists').and.returnValue(Promise.resolve(true));

package/lib/project-files/src/models/user-model.ts

@@ -1,3 +1,6 @@
+import { TAll } from '@shared/types';
+
+
 // **** Variables **** //
 
 export enum UserRoles {
@@ -53,8 +56,9 @@ function copy(user: IUser): IUser {
 /**
  * See if an object is an instance of User.
  */
-function instanceOf(arg: object): boolean {
+function instanceOf(arg: TAll): boolean {
   return (
+    !!arg &&
     typeof arg === 'object' &&
     'id' in arg &&
     'email' in arg &&

package/lib/project-files/src/routes/auth-router.ts

@@ -4,7 +4,7 @@ import StatusCodes from 'http-status-codes';
 import authService from '@services/auth-service';
 import envVars from 'src/shared/env-vars';
 import { IReq, IRes } from '@shared/types';
-import validate from './validators';
+import { vld } from './middleware';
 
 
 // **** Types **** //
@@ -17,8 +17,6 @@ interface ILoginReq {
 
 // **** Variables **** //
 
-const router = Router();
-
 // Status codes
 const { OK } = StatusCodes;
 
@@ -30,30 +28,36 @@ export const p = {
 } as const;
 
 
-// **** Routes **** //
+// **** Setup Router **** //
+
+const router = Router();
+router.post(p.login, vld('email', 'password'), login);
+router.get(p.logout, logout);
+
+
+// **** Functions **** //
 
 /**
  * Login a user.
  */
-router.post(p.login, async (req: IReq<ILoginReq>, res: IRes) => {
+async function login(req: IReq<ILoginReq>, res: IRes) {
   const { email, password } = req.body;
-  validate(email, password);
   // Add jwt to cookie
-  const jwt = await authService.login(email, password);
+  const jwt = await authService.getJwt(email, password);
   const { key, options } = envVars.cookieProps;
   res.cookie(key, jwt, options);
   // Return
   return res.status(OK).end();
-});
+}
 
 /**
  * Logout the user.
  */
-router.get(p.logout, (_: IReq, res: IRes) => {
+function logout(_: IReq, res: IRes) {
   const { key, options } = envVars.cookieProps;
   res.clearCookie(key, options);
   return res.status(OK).end();
-});
+}
 
 
 // **** Export router **** //

package/lib/project-files/src/routes/middleware.ts

@@ -1,10 +1,12 @@
 import StatusCodes from 'http-status-codes';
-import { Request, Response, NextFunction } from 'express';
+import { Request, Response, NextFunction, RequestHandler } from 'express';
 import { JwtPayload } from 'jsonwebtoken';
 
-import { IUser, UserRoles } from '@models/user-model';
 import envVars from 'src/shared/env-vars';
 import jwtUtil from '@util/jwt-util';
+import { IUser, UserRoles } from '@models/user-model';
+import { ParamInvalidError, ValidatorFnError } from '@shared/errors';
+import { TAll } from '@shared/types';
 
 
 // **** Variables **** //
@@ -15,6 +17,13 @@ const jwtNotPresentErr = 'JWT not present in signed cookie.';
 
 // **** Types **** //
 
+type TValidatorFn =  ((arg: TAll) => boolean);
+type TParamArr = {
+  0: string,
+  1?: string | TValidatorFn,
+  2?: 'body' | 'query' | 'params',
+}
+
 export interface ISessionUser extends JwtPayload {
   id: number;
   email: string;
@@ -28,7 +37,11 @@ export interface ISessionUser extends JwtPayload {
 /**
  * Middleware to verify if user logged in.
  */
-export async function adminMw(req: Request, res: Response, next: NextFunction) {
+export async function adminMw(
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) {
   try {
     // Extract the token
     const cookieName = envVars.cookieProps.key,
@@ -55,3 +68,93 @@ export async function adminMw(req: Request, res: Response, next: NextFunction) {
   }
 }
 
+/**
+ * vld stands for 'validate'. This function returns a middleware-function
+ * that validates the parameters provided. Each argument can be a string or 
+ * array. If an array the format is:
+ * 
+ * ['paramName', '(optional) type or validator function (default is string)', 
+ * '(optional) property on "req" to extract the value from (default is body')]
+ * 
+ * If a string, vld makes sure the param is of type string on req.body. For
+ * the array, vld makes sure parameter is of the specified type or that the
+ * parameter satifies the validator function. The validator function must 
+ * return 'true' or 'false'.
+ * 
+ * **NOTE**: For numbers, strings which evalute to (!isNaN('string') => true)
+ * are valid for req.query and req.params. But on req.body a number should be
+ * 'typeof toCheck === "number"'
+ * 
+ * Sample argument: ['id', 'number'], id is the incoming variable, 'number' 
+ * is the type, and body is where to extract 'id' from.
+ * 
+ * Example 1: vld('email', ['user', 'object'], ['id', 'number', 'params']) |
+ *  will check that 'email' is a string in req.body, that user is of type 
+ *  object in req.body, and that 'id' is a boolean in req.params.
+ * Example 2: vld('password') | will check that 'password' is a string on
+ *  req.body.
+ * Example 3: vld(['isAdmin', 'boolean']) | will check that 'isAdmin' is a 
+ *  boolean on req.body
+ * Example 4: vld(['user', isInstanceOfUser]) | will check that 'user' 
+ *  satifies the 'isInstanceOfUser()' function.
+ * Example 5: val(['email']), will check that 'email' is a string in req.body,
+ */
+export function vld(...params: Array<string | TParamArr>): RequestHandler {
+  return (req: Request, _: Response, next: NextFunction) => {
+    for (const param of params) {
+      // Check params
+      if (typeof param !== 'string' && !(param instanceof Array)) {
+        throw Error('vld() arg must be a string or array');
+      }
+      // If param is a string, make sure param is of type string on req.body
+      if (typeof param === 'string') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (typeof req.body[param] !== 'string') {
+          throw new ParamInvalidError();
+        }
+        continue;
+      }
+      // Get the value to validate from the express Request object.
+      const paramName = param[0];
+      const reqObjProp = (param.length >= 3 ? param[2] : 'body');
+      // Validate request object property
+      if (
+        reqObjProp !== 'body' &&
+        reqObjProp !== 'params' &&
+        reqObjProp !== 'query'
+      ) {
+        throw Error('param[1] must be "body", "query", or "params"');
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      const toValidate = req[reqObjProp][paramName] as TAll;
+      // If type is not present, check it's a string by default
+      if (param.length === 1) {
+        if (typeof toValidate !== 'string') {
+          throw new ParamInvalidError();
+        }
+      // If a validator function is given, validate it with that
+      } else if (typeof param[1] === 'function') {
+        const fn = param[1];
+        if (!fn(toValidate)) {
+          throw new ValidatorFnError(fn.name);
+        }
+      // If type is a number, need to do isNaN() to account for 
+      // number-strings (i.e. '1243') in req.query or req.params. But in
+      // req.body, numbers should be 'typeof toCheck === "number"'
+      } else if (param[1] === 'number') {
+        if (reqObjProp === 'query' || reqObjProp === 'params') {
+          if (isNaN(toValidate as number)) {
+            throw new ParamInvalidError();
+          }
+        } else if (typeof toValidate !== 'number') {
+          throw new ParamInvalidError();
+        }
+      // Check the param is the provided type
+      } else if (typeof toValidate !== param[1]) {
+        throw new ParamInvalidError();
+      }
+    }
+    // Call next() if no errors thrown
+    next();
+  };
+}

package/lib/project-files/src/routes/user-router.ts

@@ -4,14 +4,14 @@ import { Router } from 'express';
 import userService from '@services/user-service';
 import User, { IUser } from '@models/user-model';
 import { IReq, IRes } from '@shared/types';
-import validate from './validators';
+import { vld } from './middleware';
+
 
 
 // **** Variables **** //
 
 // Misc
-const router = Router(),
-  { CREATED, OK } = StatusCodes;
+const { CREATED, OK } = StatusCodes;
 
 // Paths
 export const p = {
@@ -23,48 +23,55 @@ export const p = {
 } as const;
 
 
-// **** Routes **** //
+// **** Setup Router **** //
+
+// Validators (place shared or really long ones here)
+const validateUser = vld(['user', User.instanceOf]);
+
+// Add routes to express
+const router = Router();
+router.get(p.get, getAll);
+router.post(p.add, validateUser, add);
+router.put(p.update, validateUser, update);
+router.delete(p.delete, vld(['id', 'number', 'params']), _delete);
+
+
+// **** Functions **** //
 
 /**
  * Get all users.
  */
-router.get(p.get, async (_: IReq, res: IRes) => {
+async function getAll(_: IReq, res: IRes) {
   const users = await userService.getAll();
   return res.status(OK).json({ users });
-});
+}
 
 /**
  * Add one user.
  */
-router.post(p.add, async (req: IReq<{user: IUser}>, res: IRes) => {
+async function add(req: IReq<{user: IUser}>, res: IRes) {
   const { user } = req.body;
-  validate([user, User.instanceOf]);
-  // Add user
   await userService.addOne(user);
   return res.status(CREATED).end();
-});
+}
 
 /**
  * Update one user.
  */
-router.put(p.update, async (req: IReq<{user: IUser}>, res: IRes) => {
+async function update(req: IReq<{user: IUser}>, res: IRes) {
   const { user } = req.body;
-  validate([user, User.instanceOf]);
-  // Edit user
   await userService.updateOne(user);
   return res.status(OK).end();
-});
+}
 
 /**
  * Delete one user.
  */
-router.delete(p.delete, async (req: IReq, res: IRes) => {
-  const id = Number(req.params.id);
-  validate([id, 'number']);
-  // Delete user
+async function _delete(req: IReq, res: IRes) {
+  const id = +req.params.id;
   await userService.delete(id);
   return res.status(OK).end();
-});
+}
 
 
 // **** Export default **** //

package/lib/project-files/src/services/auth-service.ts

@@ -10,7 +10,7 @@ import { UnauthorizedError } from '@shared/errors';
 /**
  * Login a user.
  */
-async function login(email: string, password: string): Promise<string> {
+async function getJwt(email: string, password: string): Promise<string> {
   // Fetch user
   const user = await userRepo.getOne(email);
   if (!user) {
@@ -35,5 +35,5 @@ async function login(email: string, password: string): Promise<string> {
 // **** Export default **** //
 
 export default {
-  login,
+  getJwt,
 } as const;

package/lib/project-files/src/shared/errors.ts

@@ -11,17 +11,6 @@ export abstract class CustomError extends Error {
   }
 }
 
-export class ParamMissingError extends CustomError {
-
-  public static readonly Msg = 'One or more of the required parameters ' + 
-    'was missing.';
-  public static readonly HttpStatus = HttpStatusCodes.BAD_REQUEST;
-
-  constructor() {
-    super(ParamMissingError.Msg, ParamMissingError.HttpStatus);
-  }
-}
-
 export class ParamInvalidError extends CustomError {
 
   public static readonly Msg = 'One or more of the required was missing ' + 
@@ -29,7 +18,7 @@ export class ParamInvalidError extends CustomError {
   public static readonly HttpStatus = HttpStatusCodes.BAD_REQUEST;
 
   constructor() {
-    super(ParamInvalidError.Msg, ParamMissingError.HttpStatus);
+    super(ParamInvalidError.Msg, ParamInvalidError.HttpStatus);
   }
 }
 
@@ -39,7 +28,7 @@ export class ValidatorFnError extends CustomError {
   public static readonly HttpStatus = HttpStatusCodes.BAD_REQUEST;
 
   constructor(fnName: string) {
-    super(ValidatorFnError.Msg + fnName, ParamMissingError.HttpStatus);
+    super(ValidatorFnError.Msg + fnName, ValidatorFnError.HttpStatus);
   }
 }
 

package/lib/project-files/src/shared/types.ts

@@ -4,6 +4,11 @@ import { Query } from 'express-serve-static-core';
 import { ISessionUser } from '@routes/middleware';
 
 
+// **** Misc **** //
+
+export type TAll = string | number | boolean | null | object;
+
+
 // **** Express **** //
 
 export interface IReq<T = void> extends e.Request {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "express-generator-typescript",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "Generate new Express applications similar to express-generate which but sets it up to use TypeScript instead",
   "scripts": {
     "express-generator-typescript": "node bin/cli.js",

package/lib/project-files/src/routes/validators.ts

@@ -1,63 +0,0 @@
-/**
- * Put other validator functions here too that may be passed to the validate() 
- * function.
- */
-
-import { ParamInvalidError, ValidatorFnError } from '@shared/errors';
-
-
-// **** Types **** //
-
-type TParam = string | number | boolean | null | object;
-type TValidatorFn =  ((arg: TParam) => boolean);
-type TParamFull = TParam | TValidatorFn;
-
-
-// **** Functions **** //
-
-/**
- * Make sure parameter is of the specified type. If the type is not provided 
- * then 'string' is used as the default type. Instead of a type you can also 
- * pass a validator function which must return 'true' or 'false'. Return false 
- * if invalid.
- * 
- * Example argument: [id, 'number'], id is the incoming variable, 'number' is 
- * the type.
- * 
- * Example 1: validate(email, [user, 'object'], [isAdmin, 'boolean'])
- * Example 2: validate(password) // will check that password is a string
- * Example 3: validate([isAdmin, 'boolean'])
- * Example 4: validate([user, isInstanceOfUser])
- */
-function validate(...params: Array<TParam | TParamFull[]>): void {
-  for (const param of params) {
-    // If param is array check provided type
-    if (param instanceof Array) {
-      // Validator function provided
-      if (typeof param[1] === 'function') {
-        const fn = param[1];
-        if (!fn(param[0])) {
-          throw new ValidatorFnError(fn.name);
-        }
-      // If type is a number, need to do isNaN, cause type NaN is a 'number'. 
-      // This could be an issue if you do Number(undefined)
-      } else if (param[1] === 'number') {
-        if (isNaN(param[0] as number)) {
-          throw new ParamInvalidError();
-        }
-      } else if (typeof param[0] !== param[1]) {
-        throw new ParamInvalidError();
-      }
-    // String is default if type is not provided
-    } else {
-      if (typeof param !== 'string') {
-        throw new ParamInvalidError();
-      }
-    }
-  } 
-}
-
-
-// **** Export default **** //
-
-export default validate;