express-generator-typescript 2.0.15 → 2.1.2

package/lib/project-files/.eslintrc.json

@@ -14,9 +14,9 @@
   },
   "rules": {
     "max-len": [
-      "error",
+      "warn",
       {
-        "code": 100
+        "code": 80
       }
     ],
     "comma-dangle": ["warn", "always-multiline"],

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

@@ -22,14 +22,15 @@ const authPath = ('/api' + paths.basePath),
 
 // Test message
 const msgs = {
-  goodLogin: `should return a response with a status of ${OK} and a cookie with a jwt if the login
-    was successful.`,
-  emailNotFound: `should return a response with a status of ${UNAUTHORIZED} and a json with the 
-    "error ${UnauthorizedError.Msg}" if the email was not found.`,
-  pwdFailed: `should return a response with a status of ${UNAUTHORIZED} and a json with the error
-    "${UnauthorizedError.Msg}" if the password failed.`,
-  fallbackErr: `should return a response with a status of ${BAD_REQUEST} and a json with an error
-    for all other bad responses.`,
+  goodLogin: `should return a response with a status of ${OK} and a cookie 
+    with a jwt if the login was successful.`,
+  emailNotFound: `should return a response with a status of ${UNAUTHORIZED} 
+    and a json with the "error ${UnauthorizedError.Msg}" if the email was 
+    not found.`,
+  pwdFailed: `should return a response with a status of ${UNAUTHORIZED} and a 
+    json with the error "${UnauthorizedError.Msg}" if the password failed.`,
+  fallbackErr: `should return a response with a status of ${BAD_REQUEST} and 
+    a json with an error for all other bad responses.`,
   goodLogout: `should return a response with a status of ${OK}.`,
 } as const;
 

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

@@ -8,8 +8,13 @@ import userRepo from '@repos/user-repo';
 import User, { IUser } from '@models/user-model';
 
 import { p as userPaths } from '@routes/user-router';
+import {
+  ParamInvalidError,
+  // ParamMissingError,
+  UserNotFoundError,
+  ValidatorFnError,
+} from '@shared/errors';
 import loginAgent from '../support/login-agent';
-import { ParamMissingError, UserNotFoundError, ValidatorFnError } from '@shared/errors';
 
 
 // **** Variables **** //
@@ -36,31 +41,34 @@ const dummyUserData = {
 
 // Test messages
 const msgs = {
-  getUsersSuccess: `should return a JSON object with all the users and a status code of 
-    "${OK}" if the request was successful.`,
-  getUsersBad: `should return a JSON object containing an error message and a status code of
-    "${BAD_REQUEST}" if the request was unsuccessful.`,
-  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.`,
-  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.`,
+  getUsersSuccess: `should return a JSON object with all the users and a 
+    status code of "${OK}" if the request was successful.`,
+  getUsersBad: `should return a JSON object containing an error message and a 
+    status code of "${BAD_REQUEST}" if the request was unsuccessful.`,
+  addUserSuccess: `should return a status code of "${CREATED}" if the request 
+    was successful.`,
+  addUserFailedMissingParam: `should return a JSON object with an error 
+    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.`,
-  updateFallbackErr: `should return a JSON object with an error message and a status code of 
-    "${BAD_REQUEST}" if the request was unsuccessful.`,
-  deleteSuccessful: `should return a status code of "${OK}" if the request was successful.`,
+    ${UserNotFoundError.Msg} and a status code of 
+    "${UserNotFoundError.HttpStatus}" if the id was not found.`,
+  updateFallbackErr: `should return a JSON object with an error message and a 
+    status code of "${BAD_REQUEST}" if the request was unsuccessful.`,
+  deleteSuccessful: `should return a status code of "${OK}" if the request was 
+    successful.`,
   deleteUserNotFound: `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.`,
-  deleteFallbackErr: `should return a JSON object with an error message and a status code of 
-    "${BAD_REQUEST}" if the request was unsuccessful.`,
+    ${UserNotFoundError.Msg} and a status code of 
+    "${UserNotFoundError.HttpStatus}" if the id was not found.`,
+  deleteFallbackErr: `should return a JSON object with an error message and a 
+    status code of "${BAD_REQUEST}" if the request was unsuccessful.`,
 };
 
 
@@ -267,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/pre-start/index.ts

@@ -1,6 +1,7 @@
 /**
- * Pre-start is where we want to place things that must run BEFORE the express server is started.
- * This is useful for environment variables, command-line arguments, and cron-jobs.
+ * Pre-start is where we want to place things that must run BEFORE the express 
+ * server is started. This is useful for environment variables, command-line 
+ * arguments, and cron-jobs.
  */
 
 import path from 'path';

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,95 @@ 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,56 @@ 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/server.ts

@@ -40,11 +40,22 @@ if (envVars.nodeEnv === 'production') {
 // Add APIs
 app.use('/api', BaseRouter);
 
-// Error handling
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-app.use((err: Error | CustomError, req: Request, res: Response, _: NextFunction) => {
+// Setup error handler
+app.use((
+  err: Error | CustomError,
+  _: Request,
+  res: Response,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  __: NextFunction,
+) => {
   logger.err(err, true);
-  const status = (err instanceof CustomError ? err.HttpStatus : StatusCodes.BAD_REQUEST);
+  // Status
+  const status = (
+    err instanceof CustomError 
+      ? err.HttpStatus 
+      : StatusCodes.BAD_REQUEST
+  );
+  // Return
   return res.status(status).json({
     error: err.message,
   });

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,23 +11,14 @@ 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 or invalid.';
+  public static readonly Msg = 'One or more of the required was missing ' + 
+    'or invalid.';
   public static readonly HttpStatus = HttpStatusCodes.BAD_REQUEST;
 
   constructor() {
-    super(ParamInvalidError.Msg, ParamMissingError.HttpStatus);
+    super(ParamInvalidError.Msg, ParamInvalidError.HttpStatus);
   }
 }
 
@@ -37,13 +28,14 @@ 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);
   }
 }
 
 export class UserNotFoundError extends CustomError {
 
-  public static readonly Msg = 'A user with the given id does not exists in the database.';
+  public static readonly Msg = 'A user with the given id does not exists ' + 
+    'in the database.';
   public static readonly HttpStatus = HttpStatusCodes.NOT_FOUND;
 
   constructor() {

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/lib/project-files/src/util/jwt-util.ts

@@ -1,4 +1,4 @@
-import jsonwebtoken, { JwtPayload } from 'jsonwebtoken';
+import jsonwebtoken from 'jsonwebtoken';
 import envVars from '../shared/env-vars';
 
 
@@ -31,7 +31,7 @@ function sign(data: string | object | Buffer): Promise<string> {
 /**
  * Decrypt JWT and extract client data.
  */
-async function decode<T extends JwtPayload>(jwt: string): Promise<string | undefined | T> {
+async function decode<T>(jwt: string): Promise<string | undefined | T> {
   return new Promise((res, rej) => {
     jsonwebtoken.verify(jwt, envVars.jwt.secret, (err, decoded) => {
       return err ? rej(errors.validation) : res(decoded as T);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "express-generator-typescript",
-  "version": "2.0.15",
+  "version": "2.1.2",
   "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,60 +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;