express-generator-typescript 3.0.3 → 3.1.0

package/lib/template/tests/users.test.ts

@@ -1,29 +1,56 @@
-import jetid from 'jet-id';
-
 import HttpStatusCodes from '@src/common/constants/HttpStatusCodes';
 import Paths from '@src/common/constants/Paths';
-import { ValidationError } from '@src/common/classes/route-errors';
 import User, { type UserEntity } from '@src/entities/User';
-import UserRepo from '@src/repos/UserRepo';
+import UserRepo, { UserRepoTestOnly } from '@src/repos/UserRepo';
 import UserService from '@src/services/UserService';
 
-import { compareUserArrays } from './common/comparators';
-import type { TestRes } from './common/supertest-types';
 import { agent } from './support/agent';
+import {
+  extractErrMsg,
+  type TypedErrRes,
+  type TypedRes,
+} from './support/utils';
 
 // ========================================================================= //
 //                                 CONSTANTS                                 //
 // ========================================================================= //
 
+// Shorthand the `Paths`
+const P = {
+  Get: {
+    CALL: Paths.Users.Get.FULL_PATH,
+    DISPLAY: Paths.Users.Get.DISPLAY,
+  },
+  Add: {
+    CALL: Paths.Users.Add.FULL_PATH,
+    DISPLAY: Paths.Users.Add.DISPLAY,
+  },
+  Update: {
+    CALL: Paths.Users.Update.FULL_PATH,
+    DISPLAY: Paths.Users.Update.DISPLAY,
+  },
+  Delete: {
+    CALL: Paths.Users.Delete.format,
+    DISPLAY: Paths.Users.Delete.DISPLAY,
+    FULL_PATH: Paths.Users.Delete.FULL_PATH,
+  },
+} as const;
+
+// Errors
+const Errors = {
+  ...UserService.Errors,
+} as const;
+
+// Status codes
+const { BAD_REQUEST, CREATED, INTERNAL_SERVER_ERROR, OK, NOT_FOUND } =
+  HttpStatusCodes;
+
 const DUMMY_USERS = [
   User.of('Sean Maxwell', 'sean.maxwell@gmail.com'),
   User.of('John Smith', 'john.smith@gmail.com'),
   User.of('Gordan Freeman', 'gordan.freeman@gmail.com'),
 ] as const;
 
-const { BAD_REQUEST, CREATED, INTERNAL_SERVER_ERROR, OK, NOT_FOUND } =
-  HttpStatusCodes;
-
 // ========================================================================= //
 //                                   TESTS                                   //
 // ========================================================================= //
@@ -35,171 +62,186 @@ describe('UserRouter', () => {
   let dbUsers: UserEntity[] = [];
 
   beforeEach(async () => {
-    await UserRepo.deleteAllUsers();
-    dbUsers = await UserRepo.insertMultiple(DUMMY_USERS);
+    await UserRepoTestOnly.deleteAllUsers();
+    dbUsers = await UserRepoTestOnly.insertMultiple(DUMMY_USERS);
   });
 
   afterEach(() => {
     vi.restoreAllMocks();
   });
 
-  // ---- `Get`
-  describe(`"GET:${Paths.Users.Get()}"`, () => {
-    it(
-      'should return a JSON object with all the users and a status code of ' +
-        `"${OK}" if the request was successful.`,
-      async () => {
-        const res: TestRes<{ users: UserEntity[] }> = await agent.get(
-          Paths.Users.Get(),
+  // --- `Get` ---
+  describe(P.Get.DISPLAY, () => {
+    describe('on success', () => {
+      it(`returns all users as JSON with status "${OK}"`, async () => {
+        const res: TypedRes<{ users: UserEntity[] }> = await agent.get(
+          P.Get.CALL,
         );
         expect(res.status).toBe(OK);
-        expect(compareUserArrays(res.body.users, DUMMY_USERS)).toBeTruthy();
-      },
-    );
-
-    it(
-      `should return a JSON error and a status code of ` +
-        `"${INTERNAL_SERVER_ERROR}" if an unexpected error is thrown.`,
-      async () => {
-        vi.spyOn(UserService, 'getAll').mockRejectedValueOnce(
-          new Error('boom'),
-        );
-        const res: TestRes = await agent.get(Paths.Users.Get());
+        expect(res.body.users).toStrictEqual(DUMMY_USERS);
+      });
+    });
+
+    describe('when an unexpected error is thrown', () => {
+      it(`returns status "${INTERNAL_SERVER_ERROR}"`, async () => {
+        const error = new Error('boom');
+        const getAllSpy = vi.spyOn(UserService, 'getAll');
+        getAllSpy.mockRejectedValueOnce(error);
+        const res: TypedErrRes = await agent.get(P.Get.CALL);
         expect(res.status).toBe(INTERNAL_SERVER_ERROR);
         expect(res.body.error).toBe('Internal Server Error');
-      },
-    );
+      });
+    });
   });
 
-  // ---- `Add`
-  describe(`"POST:${Paths.Users.Add()}"`, () => {
-    it(
-      `should return a status code of "${CREATED}" and persist the user ` +
-        'with a server-generated id if the request was successful.',
-      async () => {
+  // --- `Add` ---
+  describe(P.Add.DISPLAY, () => {
+    describe('on success', () => {
+      it(`persists the user and returns status "${CREATED}"`, async () => {
         // Same payload shape the front-end sends
         const input = { name: 'a', email: 'a@a.com' };
-        const res: TestRes<{ user: UserEntity }> = await agent
-          .post(Paths.Users.Add())
+        const res: TypedRes<{ user: UserEntity }> = await agent
+          .post(P.Add.CALL)
           .send({ user: input });
         expect(res.status).toBe(CREATED);
-        expect(User.isId(res.body.user.id)).toBe(true);
+        const isId = User.is.id(res.body.user.id);
+        expect(isId).toBe(true);
         const all = await UserRepo.getAll();
         expect(all).toHaveLength(DUMMY_USERS.length + 1);
         expect(all).toContainEqual(res.body.user);
-      },
-    );
-
-    it(
-      'should return a JSON object with an error message and a status ' +
-        `code of "${BAD_REQUEST}" if the user param was missing.`,
-      async () => {
-        const res: TestRes = await agent
-          .post(Paths.Users.Add())
-          .send({ user: null });
+      });
+    });
+
+    describe('when the user param is missing', () => {
+      it('returns a validation error', async () => {
+        const res = await agent.post(P.Add.CALL).send({ user: null });
         expect(res.status).toBe(BAD_REQUEST);
-        expect(res.body.error).toBe(ValidationError.MESSAGE);
-        expect(res.body.errors?.[0].key).toStrictEqual('user');
-      },
-    );
-
-    it(
-      `should return a status code of "${BAD_REQUEST}" if the name is ` +
-        'empty.',
-      async () => {
-        const res: TestRes = await agent
-          .post(Paths.Users.Add())
+        const errMsg = extractErrMsg(res);
+        expect(errMsg).toBe('Invalid input: expected object, received null');
+      });
+    });
+
+    describe('when the name is empty', () => {
+      it(`returns status "${BAD_REQUEST}"`, async () => {
+        const res = await agent
+          .post(P.Add.CALL)
           .send({ user: { name: '', email: 'a@a.com' } });
         expect(res.status).toBe(BAD_REQUEST);
-        expect(await UserRepo.getAll()).toHaveLength(DUMMY_USERS.length);
-      },
-    );
+        // Verify it didn't persist in the database
+        const allUsers = await UserRepo.getAll();
+        expect(allUsers).toHaveLength(DUMMY_USERS.length);
+      });
+    });
+
+    describe('when the request body cannot be parsed', () => {
+      it('returns 400 for malformed JSON without persisting a user', async () => {
+        const res: TypedErrRes = await agent
+          .post(P.Add.CALL)
+          .set('Content-Type', 'application/json')
+          .send('{"user":');
+        expect(res.status).toBe(BAD_REQUEST);
+        expect(res.body).toStrictEqual({ error: 'Invalid JSON' });
+        expect(await UserRepo.getAll()).toStrictEqual(DUMMY_USERS);
+      });
+
+      it.each([
+        [
+          'application/json',
+          JSON.stringify({ user: { name: 'a'.repeat(110000) } }),
+        ],
+        [
+          'application/x-www-form-urlencoded',
+          `user[name]=${'a'.repeat(110000)}`,
+        ],
+      ])('returns 413 for an oversized %s body', async (contentType, body) => {
+        const res: TypedErrRes = await agent
+          .post(P.Add.CALL)
+          .set('Content-Type', contentType)
+          .send(body);
+        expect(res.status).toBe(HttpStatusCodes.PAYLOAD_TOO_LARGE);
+        expect(res.body).toStrictEqual({ error: 'Request body too large' });
+        expect(await UserRepo.getAll()).toStrictEqual(DUMMY_USERS);
+      });
+    });
   });
 
-  // ---- `Update`
-  describe(`"PUT:${Paths.Users.Update()}"`, () => {
-    it(
-      `should return a status code of "${OK}" and save the change if the ` +
-        'request was successful.',
-      async () => {
+  // --- `Update` ---
+  describe(P.Update.DISPLAY, () => {
+    describe('on success', () => {
+      it(`saves the change and returns status "${OK}"`, async () => {
         const user = { ...dbUsers[0], name: 'Bill' };
-        const res = await agent.put(Paths.Users.Update()).send({ user });
+        const res = await agent.put(P.Update.CALL).send({ user });
         expect(res.status).toBe(OK);
-        const saved = (await UserRepo.getAll()).find((u) => u.id === user.id);
+        const allUsers = await UserRepo.getAll();
+        const saved = allUsers.find((u) => u.id === user.id);
         expect(saved?.name).toBe('Bill');
-      },
-    );
-
-    it(
-      'should return a JSON object with an error message and a status code ' +
-        `of "${BAD_REQUEST}" if id is not a valid id`,
-      async () => {
-        const user = { ...User.create(), name: 'a', email: 'a@a.com', id: '5' };
-        const res: TestRes = await agent
-          .put(Paths.Users.Update())
-          .send({ user });
+      });
+    });
+
+    describe('when the id is invalid', () => {
+      it('returns a validation error', async () => {
+        const newUser = User.create();
+        const user = {
+          ...newUser,
+          name: 'a',
+          email: 'a@a.com',
+          id: '5',
+        };
+        const res = await agent.put(P.Update.CALL).send({ user });
         expect(res.status).toBe(BAD_REQUEST);
-        expect(res.body.error).toBe(ValidationError.MESSAGE);
-        expect(res.body.errors?.[0].keyPath).toStrictEqual(['user', 'id']);
-      },
-    );
-
-    it(
-      'should return a JSON object with the error message of ' +
-        `"${UserService.Errors.USER_NOT_FOUND}" and a status code of ` +
-        `"${NOT_FOUND}" if the id was not found.`,
-      async () => {
-        const user = User.create({ id: jetid(), name: 'a', email: 'a@a.com' }),
-          res: TestRes = await agent.put(Paths.Users.Update()).send({ user });
+        const errMsg = extractErrMsg(res);
+        expect(errMsg).toBe(errMsg);
+      });
+    });
+
+    describe('when the user is not found', () => {
+      it(`returns status "${NOT_FOUND}"`, async () => {
+        const user = User.create({ name: 'a', email: 'a@a.com' });
+        const res: TypedErrRes = await agent.put(P.Update.CALL).send({ user });
         expect(res.status).toBe(NOT_FOUND);
-        expect(res.body.error).toBe(UserService.Errors.USER_NOT_FOUND);
-      },
-    );
+        expect(res.body.error).toBe(Errors.USER_NOT_FOUND);
+      });
+    });
   });
 
-  // ---- `Delete`
-  describe(`"DELETE:${Paths.Users.Delete()}"`, () => {
-    it(
-      `should return a status code of "${OK}" and remove the user if the ` +
-        'request was successful.',
-      async () => {
-        const id = dbUsers[0].id,
-          res = await agent.delete(Paths.Users.Delete({ id }));
+  // --- `Delete` ---
+  describe(P.Delete.DISPLAY, () => {
+    describe('on success', () => {
+      it(`removes the user and returns status "${OK}"`, async () => {
+        const id = dbUsers[0].id;
+        const path = P.Delete.CALL(id);
+        const res = await agent.delete(path);
         expect(res.status).toBe(OK);
-        expect(await UserRepo.persists(id)).toBe(false);
-      },
-    );
-
-    it(
-      'should return a JSON object with the error message of ' +
-        `"${UserService.Errors.USER_NOT_FOUND}" and a status code of ` +
-        `"${NOT_FOUND}" if the id was not found.`,
-      async () => {
-        const res: TestRes = await agent.delete(
-          Paths.Users.Delete({ id: jetid() }),
-        );
+        const persists = await UserRepo.persists(id);
+        expect(persists).toBe(false);
+      });
+    });
+
+    describe('when the user is not found', () => {
+      it(`returns status "${NOT_FOUND}"`, async () => {
+        const id = User.genId();
+        const path = P.Delete.CALL(id);
+        const res: TypedErrRes = await agent.delete(path);
         expect(res.status).toBe(NOT_FOUND);
-        expect(res.body.error).toBe(UserService.Errors.USER_NOT_FOUND);
-      },
-    );
-
-    it(
-      `should return a status code of "${BAD_REQUEST}" if the id is not a ` +
-        'valid id.',
-      async () => {
-        const res = await agent.delete(Paths.Users.Delete({ id: -1 }));
+        expect(res.body.error).toBe(Errors.USER_NOT_FOUND);
+      });
+    });
+
+    describe('when the id is invalid', () => {
+      it(`returns status "${BAD_REQUEST}"`, async () => {
+        const path = P.Delete.CALL('asdf');
+        const res = await agent.delete(path);
         expect(res.status).toBe(BAD_REQUEST);
-      },
-    );
-
-    it(
-      `should return a status code of "${BAD_REQUEST}" if the id query ` +
-        'param is missing.',
-      async () => {
-        const res: TestRes = await agent.delete(Paths.Users.Delete());
+      });
+    });
+
+    describe('when the id path param is missing', () => {
+      it(`returns status "${BAD_REQUEST}"`, async () => {
+        const res = await agent.delete(P.Delete.FULL_PATH);
         expect(res.status).toBe(BAD_REQUEST);
-        expect(res.body.errors?.[0].key).toStrictEqual('id');
-      },
-    );
+        const errMsg = extractErrMsg(res);
+        expect(errMsg).toStrictEqual('Not a valid uuid7 id');
+      });
+    });
   });
 });

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "express-generator-typescript",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "description": "Generate new Express applications similar to express-generate which but sets it up to use TypeScript instead",
   "scripts": {
-    "commit": "git add -A && git commit -m \"dev commit\"",
-    "commit:push": "npm run commit && git push",
     "install:clean": "rm -rf node_modules && rm -rf package-lock.json && npm i",
     "test": "node --test \"tests/**/*.test.js\"",
-    "test:e2e": "node scripts/e2e.js"
+    "test:e2e": "node scripts/e2e.js",
+    "_local:commit": "tsx --tsconfig ../my-tools/tsconfig.json ../my-tools/src/workflows/commit/run.ts",
+    "_local:commit:push": "npm run _local:commit -- -p",
+    "_local:squash-history": "tsx --tsconfig ../my-tools/tsconfig.json ../my-tools/src/workflows/squash-history/run.ts"
   },
   "main": "lib/express-generator-typescript.js",
   "bin": {
@@ -25,7 +26,7 @@
     "!lib/template/src/repos/common/database.test.json"
   ],
   "engines": {
-    "node": ">=22.12.0"
+    "node": "^22.13.0 || ^24.0.0 || >=26.0.0"
   },
   "repository": {
     "type": "git",

package/lib/template/src/common/constants/env-inv.ts

@@ -1,32 +0,0 @@
-import jetEnv, { num } from 'jet-env';
-
-import type { ValueOf } from '../types/utility-types';
-
-// ========================================================================= //
-//                                 CONSTANTS                                 //
-// ========================================================================= //
-
-// NOTE: These need to match the names of your ".env" files
-export const NodeEnvs = {
-  DEV: 'development',
-  TEST: 'test',
-  PRODUCTION: 'production',
-} as const;
-export type NodeEnvs = ValueOf<typeof NodeEnvs>;
-
-// ========================================================================= //
-//                                   EXEC                                    //
-// ========================================================================= //
-
-// Setup the is `NodeEnvs` validator
-const isNodeEnv = (() => {
-  const vals = Object.values(NodeEnvs);
-  const valsFin = vals.map((item) => item.toLowerCase());
-  const set = new Set(valsFin);
-  return (val: unknown): val is NodeEnvs => set.has(val as NodeEnvs);
-})();
-
-export const EnvVars = jetEnv({
-  NodeEnv: isNodeEnv,
-  Port: num,
-});

package/lib/template/src/entities/User/_internal/validators.ts

@@ -1,47 +0,0 @@
-import jetid from 'jet-id';
-import { isNonEmptyString, isString } from 'jet-validators';
-import { parseObject, type Schema, testObject } from 'jet-validators/utils';
-
-import { isISOString } from '@src/common/utils/date-utils';
-
-import type { UserEntity, UserInput } from '../types';
-
-// ========================================================================= //
-//                                 FUNCTIONS                                 //
-// ========================================================================= //
-
-const schema: Schema<UserEntity> = {
-  id: isUserId,
-  name: isString,
-  email: isString,
-  created: isISOString,
-};
-
-/**
- * Validate the `User` schema.
- */
-export const parseUser = parseObject<UserEntity>(schema);
-
-/**
- * For the APIs make sure the right fields are complete
- */
-export const isCompleteUser = testObject<UserEntity>({
-  ...schema,
-  name: isNonEmptyString,
-  email: isNonEmptyString,
-});
-
-/**
- * Validate the fields a client sends to create a user.
- */
-export const isUserInput = testObject<UserInput>({
-  name: isNonEmptyString,
-  email: isNonEmptyString,
-});
-
-/**
- * Test if an id is a valid user id.
- */
-export function isUserId(val: unknown): val is string {
-  return jetid.test(val);
-}

package/lib/template/src/routes/common/express-types.ts

@@ -1,9 +0,0 @@
-import type { Request, Response } from 'express';
-
-// ========================================================================= //
-//                                   TYPES                                   //
-// ========================================================================= //
-
-// Body is `unknown` until it has been validated with `parseReq`.
-export type Req = Request<Record<string, string>, unknown, unknown>;
-export type Res = Response;

package/lib/template/src/routes/common/parseReq.ts

@@ -1,23 +0,0 @@
-import { parseObject, type Schema } from 'jet-validators/utils';
-
-import { ValidationError } from '@src/common/classes/route-errors';
-
-// ========================================================================= //
-//                                 FUNCTIONS                                 //
-// ========================================================================= //
-
-/**
- * Build a request parser for `schema` that throws a `ValidationError`
- * (400) listing every failed field.
- */
-function parseReq<U extends Schema>(schema: U) {
-  return parseObject(schema, (errors) => {
-    throw new ValidationError(errors);
-  });
-}
-
-// ========================================================================= //
-//                                  EXPORT                                   //
-// ========================================================================= //
-
-export default parseReq;

package/lib/template/tests/common/comparators.ts

@@ -1,38 +0,0 @@
-import type { UserEntity } from '@src/entities/User';
-
-// ========================================================================= //
-//                                   TYPES                                   //
-// ========================================================================= //
-
-type UserArray = UserEntity[] | readonly UserEntity[];
-
-// ========================================================================= //
-//                                 FUNCTIONS                                 //
-// ========================================================================= //
-
-/**
- * Compare to user arrays. Order does not matter and this assumes the email
- * field is unique
- */
-export function compareUserArrays(a: UserArray, b: UserArray): boolean {
-  if (a.length !== b.length) return false;
-  const aSorted = sortByEmail(a),
-    bSorted = sortByEmail(b);
-  for (let i = 0; i < aSorted.length; i++) {
-    const a = aSorted[i],
-      b = bSorted[i];
-    if (a.email !== b.email || a.name !== b.name) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
- * Sort user array by email.
- */
-function sortByEmail(arr: UserArray): UserEntity[] {
-  return [...arr].sort((x, y) => {
-    return x.email.localeCompare(y.email);
-  });
-}

package/lib/template/tests/common/supertest-types.ts

@@ -1,11 +0,0 @@
-import type { ParseError } from 'jet-validators/utils';
-import type { Response } from 'supertest';
-
-// ========================================================================= //
-//                                   TYPES                                   //
-// ========================================================================= //
-
-// Use generics to add properties to 'body'
-export interface TestRes<T = object> extends Omit<Response, 'body'> {
-  body: T & { error?: string; errors?: ParseError[] };
-}