express-generator-typescript 2.4.23 → 2.5.0

package/lib/project-files/src/util/validators.ts

@@ -0,0 +1,322 @@
+/**
+ * NOTE: These functions were copied from here: 
+ * https://github.com/seanpmaxwell/ts-validators/blob/master/src/validators.ts
+ */
+
+/* eslint-disable max-len */
+
+
+// **** Types **** //
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type TFunc = (...args: any[]) => any;
+type TBasicObj = Record<string, unknown>;
+type TEnum = Record<string, string | number>;
+
+// Add modifiers
+type AddNull<T, N> = (N extends true ? T | null : T);
+type AddNullables<T, O, N> = (O extends true ? AddNull<T, N> | undefined  : AddNull<T, N>);
+type AddMods<T, O, N, A> = A extends true ? AddNullables<T[], O, N> : AddNullables<T, O, N>;
+export type TValidateWithTransform<T> = (arg: unknown, cb?: (arg: T) => void) => arg is T;
+
+
+// **** Functions **** //
+
+// Nullables
+export const isUndef = ((arg: unknown): arg is undefined => arg === undefined);
+export const isNull = ((arg: unknown): arg is null => arg === null);
+
+// Base types
+export const isStr = _checkType<string>('string');
+export const isNum = _checkType<number>('number');
+export const isBool = _checkType<boolean>('boolean');
+export const isObj = _checkType<object>('object');
+
+// Misc
+export const parseObj = <U extends TSchema>(arg: U, onError?: TParseOnError<false>) => 
+  _parseObj<U, false, false, false>(arg, false, false, false, onError);
+export const isEnumVal = <T>(arg: T) => _isEnumValBase<T, false, false>(arg, false, false);
+
+// Util
+export const transform = _transform;
+export const safeJsonParse = _safeJsonParse;
+
+
+// **** Helpers **** //
+
+/**
+ * Check if unknown is a valid enum object.
+ * NOTE: this does not work for mixed enums see: "eslint@typescript-eslint/no-mixed-enums"
+ */
+function _isEnum(arg: unknown): arg is TEnum {
+  // Check is non-array object
+  if (!(isObj(arg) && !Array.isArray(arg))) {
+    return false;
+  }
+  // Check if string or number enum
+  const param = (arg as TBasicObj),
+    keys = Object.keys(param),
+    middle = Math.floor(keys.length / 2);
+  // ** String Enum ** //
+  if (!isNum(param[keys[middle]])) {
+    return _checkObjEntries(arg, (key, val) => {
+      return isStr(key) && isStr(val);
+    });
+  }
+  // ** Number Enum ** //
+  // Enum key length will always be even
+  if (keys.length % 2 !== 0) {
+    return false;
+  }
+  // Check key/values
+  for (let i = 0; i < middle; i++) {
+    const thisKey = keys[i],
+      thisVal = param[thisKey],
+      thatKey = keys[i + middle],
+      thatVal = param[thatKey];
+    if (!(thisVal === thatKey && thisKey === String(thatVal))) {
+      return false;
+    }
+  }
+  // Return
+  return true;
+}
+
+/**
+ * Check is value satisfies enum.
+ */
+function _isEnumValBase<T, 
+  O extends boolean,
+  N extends boolean
+>(
+  enumArg: T,
+  optional: O,
+  nullable: N,
+): ((arg: unknown) => arg is AddNullables<T[keyof T], O, N>) {
+  // Check is enum
+  if (!_isEnum(enumArg)) {
+    throw Error('Item to check from must be an enum.');
+  }
+  // Get keys
+  let resp = Object.keys(enumArg).reduce((arr: unknown[], key) => {
+    if (!arr.includes(key)) {
+      arr.push(enumArg[key]);
+    }
+    return arr;
+  }, []);
+  // Check if string or number enum
+  if (isNum(enumArg[resp[0] as string])) {
+    resp = resp.map(item => enumArg[item as string]);
+  }
+  // Return validator function
+  return (arg: unknown): arg is AddNullables<T[keyof T], O, N> => {
+    if (isUndef(arg)) {
+      return !!optional;
+    }
+    if (isNull(arg)) {
+      return !!nullable;
+    }
+    return resp.some(val => arg === val);
+  };
+}
+
+/**
+ * Do a validator callback function for each object key/value pair.
+ */
+function _checkObjEntries(
+  val: unknown,
+  cb: (key: string, val: unknown) => boolean,
+): val is NonNullable<object> {
+  if (isObj(val)) {
+    for (const entry of Object.entries(val)) {
+      if (!cb(entry[0], entry[1])) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+/**
+ * Wrapper to check basic type.
+ */
+function _checkType<T>(type: string) {
+  return (arg: unknown): arg is T => {
+    return typeof arg === type && (type === 'object' ? (arg !== null) : true);
+  };
+}
+
+/**
+ * Transform a value before checking it.
+ */
+function _transform<T>(
+  transFn: TFunc,
+  vldt: ((arg: unknown) => arg is T),
+): TValidateWithTransform<T> {
+  return (arg: unknown, cb?: (arg: T) => void): arg is T => {
+    if (arg !== undefined) {
+      arg = transFn(arg);
+    }
+    cb?.(arg as T);
+    return vldt(arg);
+  };
+}
+
+/**
+ * Safe JSON parse
+ */
+function _safeJsonParse<T>(arg: unknown): T {
+  if (isStr(arg)) {
+    return JSON.parse(arg) as T;
+  } else {
+    throw Error('JSON parse argument must be a string');
+  }
+}
+
+
+// **** Parse Object **** //
+
+export interface TSchema {
+  [key: string]: TValidateWithTransform<unknown> | TSchema;
+}
+
+type TInferParseRes<U, O, N, A, Schema = TInferParseResHelper<U>> = (
+  AddMods<Schema, O, N, A>
+);
+
+type TInferParseResHelper<U> = {
+  [K in keyof U]: (
+    U[K] extends TValidateWithTransform<infer X> 
+    ? X 
+    : U[K] extends TSchema
+    ? TInferParseResHelper<U[K]>
+    : never
+  );
+};
+
+type TParseOnError<A> = (
+  A extends true 
+  ? ((property?: string, value?: unknown, index?: number, caughtErr?: unknown) => void) 
+  : ((property?: string, value?: unknown, caughtErr?: unknown) => void)
+);
+
+/**
+ * validates an object schema, calls an error function is supplied one, returns 
+ * "undefined" if the parse fails, and works recursively too.
+ */
+function _parseObj<
+  U extends TSchema,
+  O extends boolean,
+  N extends boolean,
+  A extends boolean,
+>(
+  schema: U,
+  optional: O,
+  nullable: N,
+  isArr: A,
+  onError?: TParseOnError<A>,
+) {
+  return (arg: unknown) => _parseObjCore(
+    !!optional,
+    !!nullable,
+    !!isArr,
+    schema,
+    arg,
+    onError,
+  ) as TInferParseRes<U, O, N, A>;
+}
+
+/**
+ * Validate the schema. 
+ */
+function _parseObjCore(
+  optional: boolean,
+  nullable: boolean,
+  isArr: boolean,
+  schema: TSchema,
+  arg: unknown,
+  onError?: TFunc,
+) {
+  // Check "undefined"
+  if (arg === undefined) {
+    if (!optional) {
+      onError?.('object value was undefined but not optional', arg);
+      return undefined;
+    }
+  }
+  // Check "null"
+  if (arg === null) {
+    if (!nullable) {
+      onError?.('object value was null but not nullable', arg);
+      return undefined;
+    }
+    return null;
+  }
+  // Check "array"
+  if (isArr) {
+    if (!Array.isArray(arg)) {
+      onError?.('object not an array', arg);
+      return null;
+    }
+    // Iterate array
+    const resp = [];
+    for (let i = 0; i < arg.length; i++) {
+      const item: unknown = arg[i];
+      const parsedItem = _parseObjCoreHelper(schema, item, (prop, val, caughtErr) => {
+        onError?.(prop, val, i, caughtErr);
+      });
+      if (parsedItem === undefined) {
+        return undefined;
+      } else {
+        resp.push(parsedItem);
+      }
+    }
+    return resp;
+  }
+  // Default
+  return _parseObjCoreHelper(schema, arg, onError);
+}
+
+/**
+ * Iterate an object, apply a validator function to to each property in an 
+ * object using the schema.
+ */
+function _parseObjCoreHelper(
+  schema: TSchema,
+  arg: unknown,
+  onError?: TParseOnError<false>,
+) {
+  if (!isObj(arg)) {
+    return;
+  }
+  const retVal: TBasicObj = {};
+  for (const key in schema) {
+    const schemaProp = schema[key];
+    let val = (arg as TBasicObj)[key];
+    // Nested object
+    if (typeof schemaProp === 'object') {
+      const childVal = _parseObjCoreHelper(schemaProp, val, onError);
+      if (childVal !== undefined) {
+        val = childVal;
+      } else {
+        return undefined;
+      }
+    // Run validator
+    } else if (typeof schemaProp === 'function') {
+      try {
+        if (!schemaProp(val, (tval: unknown) => val = tval)) {
+          return onError?.(key, val);
+        }
+      } catch (err) {
+        if (err instanceof Error) {
+          return onError?.(key, val, err.message);
+        } else {
+          return onError?.(key, val, err);
+        }
+      }
+    }
+    retVal[key] = val;
+  }
+  // Return
+  return retVal;
+}

package/lib/project-files/tsconfig.json

@@ -1,88 +1,36 @@
 {
   "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig.json to read more about this file */
-
-    /* Basic Options */
-    // "incremental": true,                   /* Enable incremental compilation */
-    "target": "es6",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
-    "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
-    // "lib": [],                             /* Specify library files to be included in the compilation. */
-    // "allowJs": true,                       /* Allow javascript files to be compiled. */
-    // "checkJs": true,                       /* Report errors in .js files. */
-    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
-    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
-    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
-    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
-    // "outFile": "./",                       /* Concatenate and emit output to single file. */
-    "outDir": "dist",                        /* Redirect output structure to the directory. */
-    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
-    // "composite": true,                     /* Enable project compilation */
-    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
-    // "removeComments": true,                /* Do not emit comments to output. */
-    // "noEmit": true,                        /* Do not emit outputs. */
-    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
-    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
-    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-
-    /* Strict Type-Checking Options */
-    "strict": true,                           /* Enable all strict type-checking options. */
-    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
-    // "strictNullChecks": true,              /* Enable strict null checks. */
-    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
-    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
-    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
-    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
-    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-
-    /* Additional Checks */
-    // "noUnusedLocals": true,                /* Report errors on unused locals. */
-    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
-    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
-    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-
-    /* Module Resolution Options */
-    // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
-    "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
-    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
-    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
-    // "typeRoots": [],                       /* List of folders to include type definitions from. */
-    // "types": [],                           /* Type declaration files to be included in compilation. */
-    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-    "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
-    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
-    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
-
-    /* Source Map Options */
-    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
-    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
-    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-
-    /* Experimental Options */
-    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
-    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
-
-    /* Advanced Options */
-    "skipLibCheck": true,                     /* Skip type checking of declaration files. */
-    "forceConsistentCasingInFileNames": true,  /* Disallow inconsistently-cased references to the same file. */
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": [
+      "ES2020"
+    ],                    
+    "strict": true,
+    "moduleResolution": "node",
+    "baseUrl": "./",
+    "esModuleInterop": true,                 
+    "skipLibCheck": true,                     
+    "forceConsistentCasingInFileNames": true,
     "paths": {
-      "@src/*": [
-        "src/*"
-      ],
+      "@src/*": ["src/*"]
     },
     "useUnknownInCatchVariables": false
   },
   "ts-node": {
-    "require": ["tsconfig-paths/register", "./preload.js"]
+    "swc": true,
+    "require": [
+      "tsconfig-paths/register",
+      "./config.ts"
+    ],
   },
   "include": [
     "src/**/*.ts",
     "spec/**/*.ts",
+    "config.ts",
     "scripts",
-    "eslint.config.js",
-    "preload.js"
+    "eslint.config.ts"
   ],
   "exclude": [
     "src/public/*"
   ]
-}
+}

package/lib/project-files/tsconfig.prod.json

@@ -1,12 +1,32 @@
 {
-  "extends": "./tsconfig.json",
   "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": [
+      "ES2020"
+    ],                  
+    "strict": true,
+    "moduleResolution": "node",
+    "baseUrl": "./",
+    "outDir": "temp",
+    "esModuleInterop": true,                 
+    "skipLibCheck": true,                     
+    "forceConsistentCasingInFileNames": true,
+    "paths": {
+      "@src/*": ["src/*"]
+    },
+    "useUnknownInCatchVariables": false,
     "sourceMap": false,
     "removeComments": true
   },
+  "include": [
+    "src/**/*.ts",
+    "config.ts"
+  ],
   "exclude": [
     "spec",
     "src/public/",
-    "scripts"
+    "scripts",
+    "eslint.config.ts"
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "express-generator-typescript",
-  "version": "2.4.23",
+  "version": "2.5.00",
   "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/env/development.env

@@ -1,24 +0,0 @@
-## Environment ##
-NODE_ENV=development
-
-
-## Server ##
-PORT=3000
-HOST=localhost
-
-
-## Setup jet-logger ##
-JET_LOGGER_MODE=CONSOLE
-JET_LOGGER_FILEPATH=jet-logger.log
-JET_LOGGER_TIMESTAMP=TRUE
-JET_LOGGER_FORMAT=LINE
-
-
-## Authentication ##
-COOKIE_DOMAIN=localhost
-COOKIE_PATH=/
-SECURE_COOKIE=false
-JWT_SECRET=xxxxxxxxxxxxxx
-COOKIE_SECRET=xxxxxxxxxxxxxx
-# expires in 3 days
-COOKIE_EXP=259200000

package/lib/project-files/env/production.env

@@ -1,25 +0,0 @@
-## Environment ##
-NODE_ENV=production
-
-
-## Server ##
-PORT=8081
-HOST=localhost
-
-
-## Setup jet-logger ##
-JET_LOGGER_MODE=FILE
-JET_LOGGER_FILEPATH=jet-logger.log
-JET_LOGGER_TIMESTAMP=TRUE
-JET_LOGGER_FORMAT=LINE
-
-
-## Authentication ##
-# SECURE_COOKIE 'false' here for demo-ing. But ideally should be true.
-COOKIE_DOMAIN=localhost
-COOKIE_PATH=/
-SECURE_COOKIE=false
-JWT_SECRET=xxxxxxxxxxxxxx
-COOKIE_SECRET=xxxxxxxxxxxxxx
-# expires in 3 days
-COOKIE_EXP=259200000

package/lib/project-files/eslint.config.js

@@ -1,55 +0,0 @@
-/* eslint-disable */
-// @ts-nocheck
-
-const eslint = require('@eslint/js');
-const tseslint = require('typescript-eslint');
-const stylisticTs = require('@stylistic/eslint-plugin-ts');
-const nodePlugin = require('eslint-plugin-n');
-
-
-module.exports = tseslint.config(
-  eslint.configs.recommended,
-  nodePlugin.configs['flat/recommended-script'],
-  ...tseslint.configs.strictTypeChecked,
-  ...tseslint.configs.stylisticTypeChecked,
-  {
-    languageOptions: {
-      parserOptions: {
-        project: './tsconfig.json',
-        warnOnUnsupportedTypeScriptVersion: false,
-      },
-    },
-  },
-  {
-    plugins: {
-      '@stylistic/ts': stylisticTs,
-    }
-  },
-  {
-    files: ['**/*.ts'],
-    ignores: ['**/*.js'],
-    rules: {
-      '@typescript-eslint/explicit-member-accessibility': 'warn',
-      '@typescript-eslint/no-misused-promises': 0,
-      '@typescript-eslint/no-floating-promises': 0,
-      '@typescript-eslint/no-confusing-void-expression': 0,
-      '@typescript-eslint/no-unnecessary-condition': 0,
-      '@typescript-eslint/restrict-template-expressions': [ 'error', { allowNumber: true }],
-      'max-len': [
-        'warn',
-        {
-          'code': 80
-        }
-      ],
-      '@stylistic/ts/semi': ['warn'],
-      'comma-dangle': ['warn', 'always-multiline'],
-      'no-console': 1,
-      'no-extra-boolean-cast': 0,
-      'indent': ['warn', 2],
-      'quotes': ['warn', 'single'],
-      'n/no-process-env': 1,
-      'n/no-missing-import': 0,
-      'n/no-unpublished-import': 0
-    },
-  }
-)

package/lib/project-files/preload.js

@@ -1,23 +0,0 @@
-/* eslint-disable */
-
-const dotenv = require('dotenv');
-const path = require('path');
-const moduleAlias = require('module-alias');
-
-
-// Check the env
-const NODE_ENV = (process.env.NODE_ENV || 'development');
-
-// Configure "dotenv"
-const result2 = dotenv.config({
-  path: path.join(__dirname, `./env/${NODE_ENV}.env`),
-});
-if (result2.error) {
-  throw result2.error;
-}
-
-// Configure module-alias
-if (NODE_ENV === 'production') {
-  moduleAlias.addAlias('@src', __dirname + '/dist');
-}
-

package/lib/project-files/src/common/EnvVars.ts

@@ -1,24 +0,0 @@
-/* eslint-disable n/no-process-env */
-
-
-export default {
-  NodeEnv: (process.env.NODE_ENV ?? ''),
-  Port: (process.env.PORT ?? 0),
-  CookieProps: {
-    Key: 'ExpressGeneratorTs',
-    Secret: (process.env.COOKIE_SECRET ?? ''),
-    // Casing to match express cookie options
-    Options: {
-      httpOnly: true,
-      signed: true,
-      path: (process.env.COOKIE_PATH ?? ''),
-      maxAge: Number(process.env.COOKIE_EXP ?? 0),
-      domain: (process.env.COOKIE_DOMAIN ?? ''),
-      secure: (process.env.SECURE_COOKIE === 'true'),
-    },
-  },
-  Jwt: {
-    Secret: (process.env.JWT_SECRET ??  ''),
-    Exp: (process.env.COOKIE_EXP ?? ''), // exp at the same time as the cookie
-  },
-} as const;

package/lib/project-files/src/common/classes.ts

@@ -1,32 +0,0 @@
-import HttpStatusCodes from '@src/common/HttpStatusCodes';
-
-
-/**
- * Error with status code and message.
- */
-export class RouteError extends Error {
-
-  public status: HttpStatusCodes;
-
-  public constructor(status: HttpStatusCodes, message: string) {
-    super(message);
-    this.status = status;
-  }
-}
-
-/**
- * If route validation fails.
- */
-export class ValidationErr extends RouteError {
-
-  public static MSG = 'The follow parameter were missing or invalid "';
-
-  public constructor(paramName: string) {
-    super(HttpStatusCodes.BAD_REQUEST, ValidationErr.GetMsg(paramName));
-  }
-
-  public static GetMsg(param: string) {
-    return ValidationErr.MSG + param + '".';
-  }
-}
-

package/lib/project-files/src/common/misc.ts

@@ -1,5 +0,0 @@
-export enum NodeEnvs {
-  Dev = 'development',
-  Test = 'test',
-  Production = 'production'
-}