express-generator-typescript 2.4.6 → 2.4.8

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

@@ -1,4 +1,5 @@
-import supertest, { SuperTest, Test, Response } from 'supertest';
+import supertest, { Test, Response } from 'supertest';
+import TestAgent from 'supertest/lib/agent';
 
 import app from '@src/server';
 
@@ -11,29 +12,21 @@ import EnvVars from '@src/constants/EnvVars';
 import HttpStatusCodes from '@src/constants/HttpStatusCodes';
 
 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,
-  UNAUTHORIZED,
-} = HttpStatusCodes;
-
-// Login credentials
+// Login Creds
 const LoginCreds = {
   email: 'jsmith@gmail.com',
   password: 'Password@1',
 } as const;
 
 
-// **** Tests **** //
-
+// Tests
 describe('AuthRouter', () => {
 
-  let agent: SuperTest<Test>;
+  let agent: TestAgent<Test>;
 
   // Run before all tests
   beforeAll((done) => {
@@ -41,82 +34,82 @@ describe('AuthRouter', () => {
     done();
   });
 
-  // ** Test login ** //
+  // Login
   describe(`"POST:${Paths.Auth.Login}"`, () => {
 
     const EMAIL_NOT_FOUND_ERR = Errors.EmailNotFound(LoginCreds.email);
 
-    const callApi = (reqBody: TReqBody) => 
+    // Setup API 
+    const callApi = (creds: typeof LoginCreds, cb: TApiCb) => 
       agent
         .post(Paths.Auth.Login)
-        .type('form')
-        .send(reqBody);
+        .send(creds)
+        .end(apiCb(cb));
 
     // Success
-    it(`should return a response with a status of "${OK}" and a cookie with ` + 
-      'a jwt if the login was successful.', (done) => {
+    it(`should return a response with a status of "${HttpStatusCodes.OK}" ` + 
+      'and a cookie with a jwt if the login was successful.', done => {
       // Setup data
-      const role = UserRoles.Standard,
-        pwdHash = PwdUtil.hashSync(LoginCreds.password),
-        loginUser = User.new('john smith', LoginCreds.email, role, pwdHash);
+      const pwdHash = PwdUtil.hashSync(LoginCreds.password),
+        loginUser = User.new('john smith', LoginCreds.email, new Date(), 
+          UserRoles.Standard, pwdHash);
       // Add spy
       spyOn(UserRepo, 'getOne').and.resolveTo(loginUser);
       // Call API
-      callApi(LoginCreds)
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(OK);
-          const cookie = res.headers['set-cookie'][0];
-          expect(cookie).toContain(EnvVars.CookieProps.Key);
-          done();
-        });
+      callApi(LoginCreds, res => {
+        expect(res.status).toBe(HttpStatusCodes.OK);
+        const cookie = res.headers['set-cookie'][0];
+        expect(cookie).toContain(EnvVars.CookieProps.Key);
+        done();
+      });
     });
 
     // Email not found error
-    it(`should return a response with a status of "${UNAUTHORIZED}" and a ` + 
-    `json with an error message of "${EMAIL_NOT_FOUND_ERR}" if the email ` + 
-    'was not found.', (done) => {
+    it('should return a response with a status of ' + 
+    `"${HttpStatusCodes.UNAUTHORIZED}" and a json with an error message of ` + 
+    `"${EMAIL_NOT_FOUND_ERR}" if the email was not found.`, done => {
       // Spy
       spyOn(UserRepo, 'getOne').and.resolveTo(null);
       // Call
-      callApi(LoginCreds)
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(UNAUTHORIZED);
-          expect(res.body.error).toBe(EMAIL_NOT_FOUND_ERR);
-          done();
-        });
+      callApi(LoginCreds, res => {
+        expect(res.status).toBe(HttpStatusCodes.UNAUTHORIZED);
+        expect(res.body.error).toBe(EMAIL_NOT_FOUND_ERR);
+        done();
+      });
     });
 
     // Password failed
-    it(`should return a response with a status of "${UNAUTHORIZED}" and a ` + 
-    `json with the error "${Errors.Unauth}" if the password failed.`, 
-    (done) => {
+    it('should return a response with a status of ' + 
+    `"${HttpStatusCodes.UNAUTHORIZED}" and a json with the error ` + 
+    `"${Errors.Unauth}" if the password failed.`, done => {
       // Setup data
-      const role = UserRoles.Standard,
-        pwdHash = PwdUtil.hashSync('bad password'),
-        loginUser = User.new('john smith', LoginCreds.email, role, pwdHash);
+      const pwdHash = PwdUtil.hashSync('bad password'),
+        loginUser = User.new('john smith', LoginCreds.email, new Date(), 
+          UserRoles.Standard, pwdHash);
       // Add spy
       spyOn(UserRepo, 'getOne').and.resolveTo(loginUser);
       // Call API
-      callApi(LoginCreds)
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(UNAUTHORIZED);
-          expect(res.body.error).toBe(Errors.Unauth);
-          done();
-        });
+      callApi(LoginCreds, res => {
+        expect(res.status).toBe(HttpStatusCodes.UNAUTHORIZED);
+        expect(res.body.error).toBe(Errors.Unauth);
+        done();
+      });
     });
 
   });
 
-  // ** Test logout ** //
+  // Test logout
   describe(`"GET:${Paths.Auth.Logout}"`, () => {
 
     // Successful logout
-    it(`should return a response with a status of ${OK}`, (done) => {
-      agent.get(Paths.Auth.Logout)
-        .end((_: Error, res: Response) => {
-          expect(res.status).toBe(HttpStatusCodes.OK);
-          done();
-        });
-    });
+    it(`should return a response with a status of ${HttpStatusCodes.OK}`, 
+      done => {
+        agent
+          .get(Paths.Auth.Logout)
+          .end((_: Error, res: Response) => {
+            expect(res.status).toBe(HttpStatusCodes.OK);
+            done();
+          });
+      });
   });
 });

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

@@ -1,222 +1,190 @@
-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 login from '../support/login';
 import Paths from 'spec/support/Paths';
-import { TReqBody } from 'spec/support/types';
+import apiCb from 'spec/support/apiCb';
+import login from 'spec/support/login';
+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>,
-    jwtCookie: string;
+  let agent: TestAgent<Test>;
 
   // Run before all tests
   beforeAll((done) => {
     agent = supertest.agent(app);
-    login(agent, (cookie: string) => {
-      jwtCookie = cookie;
+    login(agent, cookie => {
+      agent.set('Cookie', cookie);
       done();
     });
   });
 
-  // ** Get all users ** //
+  // Get all users
   describe(`"GET:${Paths.Users.Get}"`, () => {
 
-    const callApi = () => 
+    // Setup API
+    const api = (cb: TApiCb) => 
       agent
         .get(Paths.Users.Get)
-        .set('Cookie', jwtCookie);
+        .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)
-        .set('Cookie', jwtCookie)
-        .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)
-        .set('Cookie', jwtCookie)
-        .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 }))
-        .set('Cookie', jwtCookie);
+        .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-auth/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-auth/src/models/User.ts

@@ -1,7 +1,10 @@
+import moment from 'moment';
+
+
 // **** Variables **** //
 
-const INVALID_CONSTRUCTOR_PARAM = 'nameOrObj arg must a string or an ' + 
-  'object with the appropriate user keys.';
+const INVALID_CONSTRUCTOR_PARAM = 'nameOrObj arg must a string or an object ' + 
+  'with the appropriate user keys.';
 
 export enum UserRoles {
   Standard,
@@ -15,15 +18,15 @@ export interface IUser {
   id: number;
   name: string;
   email: string;
+  created: Date;
+  role: UserRoles;
   pwdHash?: string;
-  role?: UserRoles;
 }
 
 export interface ISessionUser {
   id: number;
   email: string;
   name: string;
-  role: IUser['role'];
 }
 
 
@@ -35,6 +38,7 @@ export interface ISessionUser {
 function new_(
   name?: string,
   email?: string,
+  created?: Date,
   role?: UserRoles,
   pwdHash?: string,
   id?: number, // id last cause usually set by db
@@ -43,8 +47,9 @@ function new_(
     id: (id ?? -1),
     name: (name ?? ''),
     email: (email ?? ''),
+    created: (created ? new Date(created) : new Date()),
     role: (role ?? UserRoles.Standard),
-    pwdHash: (pwdHash ?? ''),
+    ...( pwdHash ? { pwdHash } : {}),
   };
 }
 
@@ -52,13 +57,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,14 +71,16 @@ 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()
   );
 }
 
 
+
+
 // **** Export default **** //
 
 export default {

package/lib/project-files-auth/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')),

package/lib/project-files-auth/src/public/scripts/login.js

@@ -10,8 +10,6 @@ document.addEventListener('click', (event) => {
     };
     Http
       .post('/api/auth/login', data)
-      .then(() => {
-        window.location.href = '/users';
-      });
+      .then(() => (window.location.href = '/users'));
   }
 }, false);