express-generator-typescript 2.4.6 → 2.4.8

package/lib/express-generator-typescript.js

@@ -20,7 +20,7 @@ const PROJECT_FOLDER_PATH = './project-files';
 // Project-folder dependencies
 const DEPENDENCIES = 'express dotenv morgan cookie-parser jet-logger ' +
   'module-alias express-async-errors helmet jsonfile inserturlparams ' + 
-  'jet-validator ts-command-line-args jet-paths',
+  'jet-validator ts-command-line-args jet-paths moment',
   DEPENDENCIES_AUTH = ' bcrypt jsonwebtoken',
   DEV_DEPENDENCIES = 'ts-node typescript nodemon find jasmine supertest ' +
     '@types/node @types/express @types/jasmine @types/find @types/morgan  ' +

package/lib/project-files/package.json

@@ -35,11 +35,12 @@
     "helmet": "^6.0.0",
     "inserturlparams": "^1.0.1",
     "jet-logger": "^1.3.1",
-    "jet-validator": "^1.0.3",
     "jet-paths": "^1.0.5",
+    "jet-validator": "^1.0.3",
     "jsonfile": "^6.1.0",
     "jsonwebtoken": "^8.5.1",
     "module-alias": "^2.2.2",
+    "moment": "^2.30.1",
     "morgan": "^1.10.0",
     "ts-command-line-args": "^2.4.2"
   },
@@ -54,7 +55,7 @@
     "@types/jsonwebtoken": "^8.5.9",
     "@types/morgan": "^1.9.3",
     "@types/node": "^18.7.14",
-    "@types/supertest": "^2.0.12",
+    "@types/supertest": "^6.0.2",
     "@typescript-eslint/eslint-plugin": "^5.36.1",
     "@typescript-eslint/parser": "^5.36.1",
     "eslint": "^8.23.0",
@@ -63,7 +64,7 @@
     "fs-extra": "^10.1.0",
     "jasmine": "^4.3.0",
     "nodemon": "^2.0.19",
-    "supertest": "^6.2.4",
+    "supertest": "^6.3.4",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.1.0",
     "typescript": "^4.8.2"

package/lib/project-files/spec/support/apiCb.ts

@@ -0,0 +1,76 @@
+import { CallbackHandler } from 'supertest';
+import moment from 'moment';
+import logger from 'jet-logger';
+
+import { TApiCb, TRes } from 'spec/types/misc';
+
+
+/**
+ * API callback function.
+ */
+function apiCb(
+  cb: TApiCb,
+  dateParam = 'created',
+  printErr?: boolean,
+): CallbackHandler {
+  return (err: Error, res: TRes) => {
+    if (printErr) {
+      logger.err(err);
+    }
+    _strToDate(res.body, dateParam);
+    return cb(res);
+  };
+}
+
+/**
+ * When date objects get sent through supertest they are converted to 
+ * iso-strings. This will cause "toEqual()"" tests to fail, so we need to 
+ * convert them back to Date objects.
+ */
+function _strToDate(
+  param: unknown,
+  prop: string,
+): void {
+  return _iterate(param, prop);
+}
+
+/**
+ * Interate object recursively and convert string-dates to "Date" objects.
+ */
+function _iterate(param: unknown, prop: string): void {
+  if (!param || typeof param !== 'object') {
+    return;
+  }
+  const paramF = param as Record<string, unknown>;
+  // For Arrays
+  if (Array.isArray(paramF)) {
+    for (const item of paramF) {
+      _iterate(item, prop);
+    }
+    return;
+  }
+  // Check valid string or Date object. If undefined just skip
+  const val = paramF[prop];
+  if (
+    (typeof val !== 'undefined') && 
+    !((typeof val === 'string') || (val instanceof Date)) && 
+    !moment(val as string | Date).isValid()
+  ) {
+    throw new Error('Property must be a valid date-string or Date() object');
+  }
+  // Convert and iterate
+  if (typeof val !== 'undefined') {
+    paramF[prop] = new Date(val as string | Date);
+  }
+  for (const key in paramF) {
+    const oval = paramF[key];
+    if (typeof oval === 'object' && key !== prop) {
+      _iterate(oval, prop);
+    }
+  }
+}
+
+
+// **** Export default **** //
+
+export default apiCb;

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

@@ -1,211 +1,186 @@
-import supertest, { SuperTest, Test, Response } from 'supertest';
+import supertest, { Test } from 'supertest';
+import TestAgent from 'supertest/lib/agent';
 import { defaultErrMsg as ValidatorErr } from 'jet-validator';
 import insertUrlParams from 'inserturlparams';
 
 import app from '@src/server';
 
 import UserRepo from '@src/repos/UserRepo';
-import User from '@src/models/User';
+import User, { IUser } from '@src/models/User';
 import HttpStatusCodes from '@src/constants/HttpStatusCodes';
 import { USER_NOT_FOUND_ERR } from '@src/services/UserService';
 
 import Paths from 'spec/support/Paths';
-import { TReqBody } from 'spec/support/types';
+import apiCb from 'spec/support/apiCb';
+import { TApiCb } from 'spec/types/misc';
 
 
-// **** Variables **** //
-
-// StatusCodes
-const {
-  OK,
-  CREATED,
-  NOT_FOUND,
-  BAD_REQUEST,
-} = HttpStatusCodes;
-
 // Dummy users for GET req
-const DummyGetAllUsers = [
-  User.new('Sean Maxwell', 'sean.maxwell@gmail.com'),
-  User.new('John Smith', 'john.smith@gmail.com'),
-  User.new('Gordan Freeman', 'gordan.freeman@gmail.com'),
-] as const;
-
-// Dummy update user
-const DummyUserData = {
-  user: User.new('Gordan Freeman', 'gordan.freeman@gmail.com'),
-} as const;
+const getDummyUsers = () => {
+  return [
+    User.new('Sean Maxwell', 'sean.maxwell@gmail.com'),
+    User.new('John Smith', 'john.smith@gmail.com'),
+    User.new('Gordan Freeman', 'gordan.freeman@gmail.com'),
+  ];
+};
 
 
-// **** Tests **** //
-
+// Tests
 describe('UserRouter', () => {
 
-  let agent: SuperTest<Test>;
+  let agent: TestAgent<Test>;
 
   // Run before all tests
-  beforeAll((done) => {
+  beforeAll(done => {
     agent = supertest.agent(app);
     done();
   });
 
-  // ** Get all users ** //
+  // Get all users
   describe(`"GET:${Paths.Users.Get}"`, () => {
 
-    const callApi = () => agent.get(Paths.Users.Get);
+    // Setup API
+    const api = (cb: TApiCb) => 
+      agent
+        .get(Paths.Users.Get)
+        .end(apiCb(cb));
 
     // Success
     it('should return a JSON object with all the users and a status code ' + 
-    `of "${OK}" if the request was successful.`, (done) => {
+    `of "${HttpStatusCodes.OK}" if the request was successful.`, (done) => {
       // Add spy
-      spyOn(UserRepo, 'getAll').and.resolveTo([...DummyGetAllUsers]);
+      const data = getDummyUsers();
+      spyOn(UserRepo, 'getAll').and.resolveTo(data);
       // Call API
-      callApi()
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(OK);
-          for (let i = 0; i < res.body.users.length; i++) {
-            const user = res.body.users[i];
-            expect(user).toEqual(DummyGetAllUsers[i]);
-          }
-          done();
-        });
+      api(res => {
+        expect(res.status).toBe(HttpStatusCodes.OK);
+        expect(res.body).toEqual({ users: data });
+        done();
+      });
     });
   });
 
   // Test add user
   describe(`"POST:${Paths.Users.Add}"`, () => {
 
-    const ERROR_MSG = `${ValidatorErr}"user".`;
+    const ERROR_MSG = `${ValidatorErr}"user".`,
+      DUMMY_USER = getDummyUsers()[0];
 
-    const callApi = (reqBody: TReqBody) => 
+    // Setup API
+    const callApi = (user: IUser | null, cb: TApiCb) => 
       agent
         .post(Paths.Users.Add)
-        .type('form').send(reqBody);
+        .send({ user })
+        .end(apiCb(cb));
 
     // Test add user success
-    it(`should return a status code of "${CREATED}" if the request was ` + 
-    'successful.', (done) => {
+    it(`should return a status code of "${HttpStatusCodes.CREATED}" if the ` + 
+    'request was successful.', (done) => {
       // Spy
       spyOn(UserRepo, 'add').and.resolveTo();
       // Call api
-      callApi(DummyUserData)
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(CREATED);
-          expect(res.body.error).toBeUndefined();
-          done();
-        });
+      callApi(DUMMY_USER, res => {
+        expect(res.status).toBe(HttpStatusCodes.CREATED);
+        done();
+      });
     });
 
     // Missing param
-    it('should return a JSON object with an error message of ' + 
-    `"${ERROR_MSG}" and a status code of "${BAD_REQUEST}" if the user ` + 
+    it(`should return a JSON object with an error message of "${ERROR_MSG}" ` + 
+    `and a status code of "${HttpStatusCodes.BAD_REQUEST}" if the user ` + 
     'param was missing.', (done) => {
       // Call api
-      callApi({})
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(BAD_REQUEST);
-          expect(res.body.error).toBe(ERROR_MSG);
-          done();
-        });
+      callApi(null, res => {
+        expect(res.status).toBe(HttpStatusCodes.BAD_REQUEST);
+        expect(res.body.error).toBe(ERROR_MSG);
+        done();
+      });
     });
   });
 
-  // ** Update users ** //
+  // Update users
   describe(`"PUT:${Paths.Users.Update}"`, () => {
 
-    const ERROR_MSG = `${ValidatorErr}"user".`;
+    const ERROR_MSG = `${ValidatorErr}"user".`,
+      DUMMY_USER = getDummyUsers()[0];
 
-    const callApi = (reqBody: TReqBody) => 
+    // Setup API
+    const callApi = (user: IUser | null, cb: TApiCb) => 
       agent
         .put(Paths.Users.Update)
-        .type('form').send(reqBody);
+        .send({ user })
+        .end(apiCb(cb));
 
     // Success
-    it(`should return a status code of "${OK}" if the request was successful.`, 
-      (done) => {
-        // Setup spies
-        spyOn(UserRepo, 'update').and.resolveTo();
-        spyOn(UserRepo, 'persists').and.resolveTo(true);
-        // Call api
-        callApi(DummyUserData)
-          .end((_: Error, res: Response) => {
-            expect(res.status).toBe(OK);
-            expect(res.body.error).toBeUndefined();
-            done();
-          });
+    it(`should return a status code of "${HttpStatusCodes.OK}" if the ` + 
+    'request was successful.', (done) => {
+      // Setup spies
+      spyOn(UserRepo, 'update').and.resolveTo();
+      spyOn(UserRepo, 'persists').and.resolveTo(true);
+      // Call api
+      callApi(DUMMY_USER, res => {
+        expect(res.status).toBe(HttpStatusCodes.OK);
+        done();
       });
+    });
 
     // Param missing
-    it('should return a JSON object with an error message of ' +
-    `"${ERROR_MSG}" and a status code of "${BAD_REQUEST}" if the user ` + 
+    it(`should return a JSON object with an error message of "${ERROR_MSG}" ` +
+    `and a status code of "${HttpStatusCodes.BAD_REQUEST}" if the user ` + 
     'param was missing.', (done) => {
       // Call api
-      callApi({})
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(BAD_REQUEST);
-          expect(res.body.error).toBe(ERROR_MSG);
-          done();
-        });
+      callApi(null, res => {
+        expect(res.status).toBe(HttpStatusCodes.BAD_REQUEST);
+        expect(res.body.error).toBe(ERROR_MSG);
+        done();
+      });
     });
 
     // User not found
     it('should return a JSON object with the error message of ' + 
-    `"${USER_NOT_FOUND_ERR}" and a status code of "${NOT_FOUND}" if the id ` + 
-    'was not found.', (done) => {
+    `"${USER_NOT_FOUND_ERR}" and a status code of ` + 
+    `"${HttpStatusCodes.NOT_FOUND}" if the id was not found.`, (done) => {
       // Call api
-      callApi(DummyUserData)
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(NOT_FOUND);
-          expect(res.body.error).toBe(USER_NOT_FOUND_ERR);
-          done();
-        });
+      callApi(DUMMY_USER, res => {
+        expect(res.status).toBe(HttpStatusCodes.NOT_FOUND);
+        expect(res.body.error).toBe(USER_NOT_FOUND_ERR);
+        done();
+      });
     });
   });
 
-  // ** Delete user ** //
+  // Delete User
   describe(`"DELETE:${Paths.Users.Delete}"`, () => {
 
-    const VALIDATOR_ERR = `${ValidatorErr}"id".`;
-
-    const callApi = (id: number) => 
+    // Call API
+    const callApi = (id: number, cb: TApiCb) => 
       agent
-        .delete(insertUrlParams(Paths.Users.Delete, { id }));
+        .delete(insertUrlParams(Paths.Users.Delete, { id }))
+        .end(apiCb(cb));
 
     // Success
-    it(`should return a status code of "${OK}" if the request was successful.`, 
-      (done) => {
-        // Setup spies
-        spyOn(UserRepo, 'delete').and.resolveTo();
-        spyOn(UserRepo, 'persists').and.resolveTo(true);
-        // Call api
-        callApi(5)
-          .end((_: Error, res: Response) => {
-            expect(res.status).toBe(OK);
-            expect(res.body.error).toBeUndefined();
-            done();
-          });
+    it(`should return a status code of "${HttpStatusCodes.OK}" if the ` + 
+    'request was successful.', (done) => {
+      // Setup spies
+      spyOn(UserRepo, 'delete').and.resolveTo();
+      spyOn(UserRepo, 'persists').and.resolveTo(true);
+      // Call api
+      callApi(5, res => {
+        expect(res.status).toBe(HttpStatusCodes.OK);
+        done();
       });
+    });
 
     // User not found
     it('should return a JSON object with the error message of ' + 
-    `"${USER_NOT_FOUND_ERR}" and a status code of "${NOT_FOUND}" if the id ` + 
-    'was not found.', (done) => {
-      callApi(-1)
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(NOT_FOUND);
-          expect(res.body.error).toBe(USER_NOT_FOUND_ERR);
-          done();
-        });
-    });
-
-    // Invalid param
-    it(`should return a status code of "${BAD_REQUEST}" and return an error ` + 
-    `message of "${VALIDATOR_ERR}" if the id was not a valid number`, (done) => {
-      callApi('horse' as unknown as number)
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(BAD_REQUEST);
-          expect(res.body.error).toBe(VALIDATOR_ERR);
-          done();
-        });
+    `"${USER_NOT_FOUND_ERR}" and a status code of ` + 
+    `"${HttpStatusCodes.NOT_FOUND}" if the id was not found.`, done => {
+      // Setup spies
+      callApi(-1, res => {
+        expect(res.status).toBe(HttpStatusCodes.NOT_FOUND);
+        expect(res.body.error).toBe(USER_NOT_FOUND_ERR);
+        done();
+      });
     });
   });
 });

package/lib/project-files/spec/types/misc.ts

@@ -0,0 +1,18 @@
+import { Response } from 'supertest';
+
+import { IUser } from '@src/models/User';
+
+
+// Misc
+export type TReqBody = Record<string, unknown>;
+export type TRes = Omit<Response, 'body'> & { body: TBody };
+export type TApiCb = (res: TRes) => void;
+
+
+// Response Body: Add things to the body here over time to prevent 
+// typescript errors.
+type TBody = {
+  [key: string]: unknown;
+  user?: IUser;
+  users?: IUser[];
+}

package/lib/project-files/src/models/User.ts

@@ -1,12 +1,10 @@
-// **** Variables **** //
+import moment from 'moment';
 
-const INVALID_CONSTRUCTOR_PARAM = 'nameOrObj arg must a string or an ' + 
-  'object with the appropriate user keys.';
 
-export enum UserRoles {
-  Standard,
-  Admin,
-}
+// **** Variables **** //
+
+const INVALID_CONSTRUCTOR_PARAM = 'nameOrObj arg must a string or an object ' + 
+  'with the appropriate user keys.';
 
 
 // **** Types **** //
@@ -15,15 +13,7 @@ export interface IUser {
   id: number;
   name: string;
   email: string;
-  pwdHash?: string;
-  role?: UserRoles;
-}
-
-export interface ISessionUser {
-  id: number;
-  email: string;
-  name: string;
-  role: IUser['role'];
+  created: Date;
 }
 
 
@@ -35,16 +25,14 @@ export interface ISessionUser {
 function new_(
   name?: string,
   email?: string,
-  role?: UserRoles,
-  pwdHash?: string,
+  created?: Date,
   id?: number, // id last cause usually set by db
 ): IUser {
   return {
     id: (id ?? -1),
     name: (name ?? ''),
     email: (email ?? ''),
-    role: (role ?? UserRoles.Standard),
-    pwdHash: (pwdHash ?? ''),
+    created: (created ? new Date(created) : new Date()),
   };
 }
 
@@ -52,13 +40,11 @@ function new_(
  * Get user instance from object.
  */
 function from(param: object): IUser {
-  // Check is user
   if (!isUser(param)) {
     throw new Error(INVALID_CONSTRUCTOR_PARAM);
   }
-  // Get user instance
   const p = param as IUser;
-  return new_(p.name, p.email, p.role, p.pwdHash, p.id);
+  return new_(p.name, p.email, p.created, p.id);
 }
 
 /**
@@ -68,10 +54,10 @@ function isUser(arg: unknown): boolean {
   return (
     !!arg &&
     typeof arg === 'object' &&
-    'id' in arg &&
-    'email' in arg &&
-    'name' in arg &&
-    'role' in arg
+    'id' in arg && typeof arg.id === 'number' && 
+    'email' in arg && typeof arg.email === 'string' && 
+    'name' in arg && typeof arg.name === 'string' &&
+    'created' in arg && moment(arg.created as string | Date).isValid()
   );
 }
 

package/lib/project-files/src/public/scripts/http.js

@@ -1,4 +1,5 @@
 var Http = (() => {
+
   // Setup request for json
   var getOptions = (verb, data) => {
     var options = {
@@ -9,11 +10,12 @@ var Http = (() => {
         'Content-Type': 'application/json',
       },
     };
-    if (data) {
+    if (!!data) {
       options.body = JSON.stringify(data);
     }
     return options;
   };
+
   // Set Http methods
   return {
     get: (path) => fetch(path, getOptions('GET')),