express-generator-typescript 2.1.9 → 2.1.10

package/lib/project-files/spec/index.ts

@@ -1,4 +1,4 @@
-import './loadEnv';
+import './load-env';
 import find from 'find';
 import Jasmine from 'jasmine';
 import commandLineArgs from 'command-line-args';

package/lib/project-files/spec/{loadEnv.ts → load-env.ts}

@@ -1,8 +1,10 @@
 import dotenv from 'dotenv';
 
 
+// **** Load test env file **** //
+
 const result2 = dotenv.config({
-  path: `./src/pre-start/env/test.env`,
+  path: `./env/test.env`,
 });
 
 if (result2.error) {

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

@@ -1,6 +1,7 @@
 import { Router } from 'express';
 
-import { adminMw, validate } from './middleware';
+import adminMw from './middlware/adminMw';
+import validate from './middlware/validate';
 import User from '@models/user-model';
 import authRoutes from './auth-routes';
 import userRoutes from './user-routes';

package/lib/project-files/src/routes/middlware/adminMw.ts

@@ -0,0 +1,69 @@
+/**
+ * Middleware to verify user logged in and is an an admin.
+ */
+
+import StatusCodes from 'http-status-codes';
+import { Request, Response, NextFunction } from 'express';
+import { JwtPayload } from 'jsonwebtoken';
+
+import envVars from '@shared/env-vars';
+import jwtUtil from '@util/jwt-util';
+import { IUser, UserRoles } from '@models/user-model';
+
+
+// **** Variables **** //
+
+const { UNAUTHORIZED } = StatusCodes;
+const jwtNotPresentErr = 'JWT not present in signed cookie.';
+
+
+// **** Types **** //
+
+export interface ISessionUser extends JwtPayload {
+  id: number;
+  email: string;
+  name: string;
+  role: IUser['role'];
+}
+
+
+// **** Functions **** //
+
+/**
+ * See note at beginning of file.
+ */
+async function adminMw(
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) {
+  try {
+    // Extract the token
+    const cookieName = envVars.cookieProps.key,
+      jwt = req.signedCookies[cookieName];
+    if (!jwt) {
+      throw Error(jwtNotPresentErr);
+    }
+    // Make sure user role is an admin
+    const clientData = await jwtUtil.decode<ISessionUser>(jwt);
+    if (typeof clientData === 'object' && clientData.role === UserRoles.Admin) {
+      res.locals.sessionUser = clientData;
+      next();
+    } else {
+      throw Error(jwtNotPresentErr);
+    }
+  } catch (err: unknown) {
+    let error;
+    if (typeof err === 'string') {
+      error = err;
+    } else if (err instanceof Error) {
+      error = err.message;
+    }
+    return res.status(UNAUTHORIZED).json({ error });
+  }
+}
+
+
+// **** Export Default **** //
+
+export default adminMw;

package/lib/project-files/src/routes/middlware/validate.ts

@@ -0,0 +1,240 @@
+/**
+ * This function returns a middleware-function that validates the parameters 
+ * provided. Each argument can be a string or array.
+ * 
+ * If the argument is 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, 'validate' makes sure the param is of type string on req.body.
+ * For the array, 'validate' makes sure the 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"'
+ * 
+ * **NOTE**: For booleans, on req.body must be true or false, on req.query or
+ * req.params must be 'true' or 'false'.
+ * 
+ * Sample argument: ['id', 'number'], id is the incoming variable, 'number' 
+ * is the type, and body is where to extract 'id' from.
+ * 
+ * Example 1: validate('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: validate('password') will check that 'password' is a string on
+ *  req.body.
+ * Example 3: validate(['isAdmin', 'boolean']) will check that 'isAdmin' is a 
+ *  boolean on req.body
+ * Example 4: validate(['user', isInstanceOfUser]) will check that 'user' 
+ *  satifies the 'isInstanceOfUser()' function.
+ * Example 5: validate(['email']) will check that 'email' is a string in 
+ *  req.body,
+ */
+
+import { Request, Response, NextFunction, RequestHandler } from 'express';
+
+import { ParamInvalidError, ValidatorFnError } from '@shared/errors';
+import { TAll } from '@shared/types';
+
+
+// **** Types **** //
+
+type TLoopFn = (req: Request) => void;
+type TValidatorFn =  ((arg: TAll) => boolean);
+type TReqObjProps = 'body' | 'query' | 'params';
+
+type TParamArr = {
+  0: string,
+  1?: string | TValidatorFn,
+  2?: TReqObjProps,
+}
+
+interface IParamFields {
+  paramName: string; 
+  type: string; 
+  reqObjProp: TReqObjProps;
+}
+
+
+// **** Functions **** //
+
+/**
+ * See comments at beginning of file on usage.
+ */
+function validate(...params: Array<string | TParamArr>): RequestHandler {
+  // Setup loop-function array
+  const loopFns: TLoopFn[] = [];
+  for (const param of params) {
+    const { paramName, type, reqObjProp } = getParamFields(param);
+    let loopFn: TLoopFn = () => { return; };
+    if (type === 'string') {
+      loopFn = checkStr(reqObjProp, paramName);
+    } else if (type === 'number') {
+      loopFn = checkNum(reqObjProp, paramName);
+    } else if (type === 'boolean') {
+      loopFn = checkBool(reqObjProp, paramName);
+    } else if (type === 'function') {
+      const fn = param[1] as TValidatorFn;
+      loopFn = checkValidatorFn(reqObjProp, paramName, fn);
+    } else {
+      loopFn = checkDefault(reqObjProp, paramName, type);
+    }
+    loopFns.push(loopFn);
+  }
+  // Return middlware function
+  return (req: Request, _: Response, next: NextFunction) => {
+    for (const loopFn of loopFns) {
+      loopFn(req);
+    }
+    next();
+  };
+}
+
+/**
+ * Get the param name, type to check against, and the request object property
+ * as well as validating the format of the param.
+ */
+function getParamFields(param: string | TParamArr): IParamFields {
+  let paramName = '';
+  let type = 'string';
+  let reqObjProp: TReqObjProps = 'body';
+  // Param is string
+  if (typeof param === 'string') {
+    paramName = param;
+  // Param is array
+  } else if (param instanceof Array) {
+    // Get the param name
+    paramName = param[0];
+    if (typeof paramName !== 'string') {
+      throw Error('param name must be a string');
+    }
+    // Get the type
+    if (typeof param[1] === 'string') {
+      type = param[1];
+    } else if (typeof param[1] === 'function') {
+      type = 'function';
+    } else {
+      throw Error('param[1] must be a string or a validator function');
+    }
+    // Get the request object property
+    const prop = (param.length >= 3 ? param[2] : 'body');
+    if (prop !== 'body' && prop !== 'params' && prop !== 'query') {
+      throw Error('param[2] must be "body", "query", or "params"');
+    } else {
+      reqObjProp = prop;
+    }
+  // Throw error if not string or array
+  } else {
+    throw Error('"validate()" argument must be a string or array');
+  }
+  // Return
+  return { paramName, type, reqObjProp };
+}
+
+/**
+ * Check param is a valid string.
+ */
+function checkStr(reqObjProp: TReqObjProps, paramName: string): TLoopFn {
+  return getLoopFn(reqObjProp, paramName, (toCheck) => {
+    if (typeof toCheck !== 'string') {
+      throw new ParamInvalidError();
+    }
+  });
+}
+
+/**
+ * Check param is a valid number. See notes at beginning of file.
+ */
+function checkNum(reqObjProp: TReqObjProps, paramName: string): TLoopFn {
+  return getLoopFn(reqObjProp, paramName, (toCheck) => {
+    if (reqObjProp === 'query' || reqObjProp === 'params') {
+      if (isNaN(toCheck as number)) {
+        throw new ParamInvalidError();
+      }
+    } else if (reqObjProp === 'body' && typeof toCheck !== 'number') {
+      throw new ParamInvalidError();
+    }
+  });
+}
+
+/**
+ * Check param is a valid boolean. See notes at beginning of file.
+ */
+function checkBool(reqObjProp: TReqObjProps, paramName: string): TLoopFn {
+  return getLoopFn(reqObjProp, paramName, (toCheck) => {
+    if (reqObjProp === 'query' || reqObjProp === 'params') {
+      if (!isBool(toCheck as boolean)) {
+        throw new ParamInvalidError();
+      }
+    } else if (reqObjProp === 'body' && typeof toCheck !== 'boolean') {
+      throw new ParamInvalidError();
+    }
+  });
+}
+
+/**
+ * Checks if arg is a boolean, or a string that is 'true', or 'false'.
+ */
+function isBool(arg: string | boolean): boolean {
+  if (typeof arg === 'boolean') {
+    return true;
+  } else if (typeof arg === 'string') {
+    arg = arg.toLowerCase();
+    return (arg === 'true' || arg === 'false');
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Make sure the parameter satifies the supplied validator function.
+ */
+function checkValidatorFn(
+  reqObjProp: TReqObjProps,
+  paramName: string,
+  validatorFn: TValidatorFn,
+) {
+  return getLoopFn(reqObjProp, paramName, (toCheck) => {
+    if (!validatorFn(toCheck)) {
+      throw new ValidatorFnError(validatorFn.name);
+    }
+  });
+}
+
+/**
+ * For all other type make sure the param equals the type.
+ */
+function checkDefault(
+  reqObjProp: TReqObjProps,
+  paramName: string,
+  type: string,
+): TLoopFn {
+  return getLoopFn(reqObjProp, paramName, (toCheck) => {
+    if (typeof toCheck !== type) {
+      throw new ParamInvalidError();
+    }
+  });
+}
+
+/**
+ * Extract the value to check and get the loop function.
+ */
+function getLoopFn(
+  reqObjProp: TReqObjProps,
+  paramName: string,
+  cb: (toCheck: TAll) => void,
+): TLoopFn {
+  return (req: Request) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const toCheck = req[reqObjProp][paramName] as TAll;
+    return cb(toCheck);
+  };
+}
+
+
+// **** Export Default **** //
+
+export default validate;

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

@@ -1,7 +1,7 @@
 import * as e from 'express';
 import { Query } from 'express-serve-static-core';
 
-import { ISessionUser } from '@routes/middleware';
+import { ISessionUser } from '@routes/middlware/adminMw';
 
 
 // **** Misc **** //

package/lib/project-files/tsconfig.json

@@ -93,7 +93,7 @@
   "include": [
     "src/**/*.ts",
     "spec/**/*.ts"
-  ],
+, "src/routes/middlware"  ],
   "exclude": [
     "src/public/"
   ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "express-generator-typescript",
-  "version": "2.1.9",
+  "version": "2.1.10",
   "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/middleware.ts

@@ -1,187 +0,0 @@
-import StatusCodes from 'http-status-codes';
-import { Request, Response, NextFunction, RequestHandler } from 'express';
-import { JwtPayload } from 'jsonwebtoken';
-
-import envVars from '@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 **** //
-
-const { UNAUTHORIZED } = StatusCodes;
-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;
-  name: string;
-  role: IUser['role'];
-}
-
-
-// **** Functions **** //
-
-/**
- * Middleware to verify user logged in and is an an admin.
- */
-export async function adminMw(
-  req: Request,
-  res: Response,
-  next: NextFunction,
-) {
-  try {
-    // Extract the token
-    const cookieName = envVars.cookieProps.key,
-      jwt = req.signedCookies[cookieName];
-    if (!jwt) {
-      throw Error(jwtNotPresentErr);
-    }
-    // Make sure user role is an admin
-    const clientData = await jwtUtil.decode<ISessionUser>(jwt);
-    if (typeof clientData === 'object' && clientData.role === UserRoles.Admin) {
-      res.locals.sessionUser = clientData;
-      next();
-    } else {
-      throw Error(jwtNotPresentErr);
-    }
-  } catch (err: unknown) {
-    let error;
-    if (typeof err === 'string') {
-      error = err;
-    } else if (err instanceof Error) {
-      error = err.message;
-    }
-    return res.status(UNAUTHORIZED).json({ error });
-  }
-}
-
-/**
- * This function returns a middleware-function that validates the parameters 
- * provided. Each argument can be a string or array.
- * 
- * If the argument is 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"'
- * 
- * **NOTE**: For booleans, on req.body must be true or false, on req.query or
- * req.params must be 'true' or 'false'.
- * 
- * Sample argument: ['id', 'number'], id is the incoming variable, 'number' 
- * is the type, and body is where to extract 'id' from.
- * 
- * Example 1: validate('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: validate('password') will check that 'password' is a string on
- *  req.body.
- * Example 3: validate(['isAdmin', 'boolean']) will check that 'isAdmin' is a 
- *  boolean on req.body
- * Example 4: validate(['user', isInstanceOfUser]) will check that 'user' 
- *  satifies the 'isInstanceOfUser()' function.
- * Example 5: validate(['email']) will check that 'email' is a string in 
- *  req.body,
- */
-export function validate(...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('"validate()" 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[2] 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);
-        } else {
-          continue;
-        }
-      // If type is a number, see note above.
-      } else if (param[1] === 'number') {
-        if (reqObjProp === 'query' || reqObjProp === 'params') {
-          if (isNaN(toValidate as number)) {
-            throw new ParamInvalidError();
-          }
-        } else if (reqObjProp === 'body' && typeof toValidate !== 'number') {
-          throw new ParamInvalidError();
-        }
-      // If type is a boolean, see note above.
-      } else if (param[1] === 'boolean') {
-        if (reqObjProp === 'query' || reqObjProp === 'params') {
-          if (!isBool(toValidate as boolean)) {
-            throw new ParamInvalidError();
-          }
-        } else if (reqObjProp === 'body' && typeof toValidate !== 'boolean') {
-          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();
-  };
-}
-
-/**
- * Checks if arg is a boolean, or a string that is 'true', or 'false'.
- */
-function isBool(arg: string | boolean): boolean {
-  if (typeof arg === 'boolean') {
-    return true;
-  } else if (typeof arg === 'string') {
-    arg = arg.toLowerCase();
-    return (arg === 'true' || arg === 'false');
-  } else {
-    return false;
-  }
-}