@digitaldefiance/node-express-suite 3.6.7 → 3.6.8

package/src/interfaces/constants.ts

@@ -0,0 +1,103 @@
+import { IECIESConstants, IPBkdf2Consts } from '@digitaldefiance/ecies-lib';
+import {
+  IEncryptionConsts,
+  IKeyringConsts,
+  IWrappedKeyConsts,
+  PbkdfProfiles,
+} from '@digitaldefiance/node-ecies-lib';
+import { IConstants as IBaseConstants } from '@digitaldefiance/suite-core-lib';
+import { CipherGCMTypes } from 'crypto';
+import { IChecksumConsts } from './checksum-consts';
+import { IFECConsts } from './fec-consts';
+import { IJwtConsts } from './jwt-consts';
+
+/**
+ * Combination of all constants from all libraries
+ * Ecies, Node Ecies, Suite Core, and Node Express Suite
+ */
+export interface IConstants extends IBaseConstants {
+  UINT8_SIZE: number;
+  UINT16_SIZE: number;
+  UINT16_MAX: number;
+  UINT32_SIZE: number;
+  UINT32_MAX: number;
+  UINT64_SIZE: number;
+  UINT64_MAX: bigint;
+  HEX_RADIX: number;
+  /**
+   * Number of rounds for bcrypt hashing. Higher values increase security but also consume more CPU resources.
+   */
+  BcryptRounds: number;
+  /**
+   * Minimum password length
+   */
+  PasswordMinLength: number;
+  /**
+   * The regular expression for valid passwords.
+   */
+  PasswordRegex: RegExp;
+  /**
+   * The regular expression for valid JWT tokens.
+   */
+  JwtSecretRegex: RegExp;
+  /**
+   * The regular expression for valid mnemonic phrases.
+   * BIP39
+   */
+  MnemonicRegex: RegExp;
+  /**
+   * The regular expression for valid HMAC keys.
+   */
+  MnemonicHmacRegex: RegExp;
+  /**
+   * The regular expression for valid encryption keys.
+   */
+  MnemonicEncryptionKeyRegex: RegExp;
+  /**
+   * JWT constants
+   */
+  JWT: IJwtConsts;
+  /**
+   * Forward Error Correction constants
+   */
+  FEC: IFECConsts;
+  /**
+   * ECIES encryption constants
+   */
+  ECIES: IECIESConstants;
+  /**
+   * The length of a raw object ID (not the hex string representation)
+   */
+  OBJECT_ID_LENGTH: number;
+  /**
+   * PBKDF2 key derivation function constants
+   */
+  PBKDF2: IPBkdf2Consts;
+  /**
+   * Predefined PBKDF2 configuration profiles for different use cases
+   */
+  PBKDF2_PROFILES: PbkdfProfiles;
+  /**
+   * Checksum constants used for data integrity
+   */
+  CHECKSUM: IChecksumConsts;
+  /**
+   * Wrapped Key constants used for the key wrapping service
+   */
+  WRAPPED_KEY: IWrappedKeyConsts;
+  /**
+   * Keyring constants used for key management
+   */
+  KEYRING: IKeyringConsts;
+  /**
+   * Encryption constants used for encrypted data
+   */
+  ENCRYPTION: IEncryptionConsts;
+  /**
+   * Algorithm configuration string for keyring operations
+   */
+  KEYRING_ALGORITHM_CONFIGURATION: CipherGCMTypes;
+  ECIES_VERSION_SIZE: number;
+  ECIES_CIPHER_SUITE_SIZE: number;
+  MEMBER_ID_LENGTH: number;
+}

package/src/interfaces/controller-config.ts

@@ -0,0 +1,27 @@
+import { Types } from '@digitaldefiance/mongoose-types';
+import { ITokenRole, ITokenUser, IUserBase } from '@digitaldefiance/suite-core-lib';
+import { IBaseDocument } from '../documents';
+import { Environment } from '../environment';
+import { IConstants } from './constants';
+import { IApplication } from './application';
+
+export interface IControllerConfig<
+  I extends Types.ObjectId | string = Types.ObjectId,
+  D extends Date = Date,
+  S extends string = string,
+  A extends string = string
+> {
+  idType: I;
+  dateType: D;
+  stringType: S;
+  accountStatusType: A;
+  userType: IUserBase<I, D, S, A>;
+  tokenRoleType: ITokenRole<I, D>;
+  tokenUserType: ITokenUser;
+  baseDocumentType: IBaseDocument<any, Types.ObjectId>;
+  environmentType: Environment;
+  constantsType: IConstants;
+  applicationType: IApplication;
+}
+
+export type DefaultControllerConfig = IControllerConfig<Types.ObjectId, Date, string, string>;

package/src/interfaces/create-user-basics.ts

@@ -0,0 +1,17 @@
+/**
+ * Partial interface for creating a new user
+ */
+export interface ICreateUserBasics {
+  /**
+   * The username of the user
+   */
+  username: string;
+  /**
+   * The email address of the user
+   */
+  email: string;
+  /**
+   * The timezone of the user
+   */
+  timezone?: string;
+}

package/src/interfaces/csp-config.ts

@@ -0,0 +1,16 @@
+import { ISimpleCSPDef, isSimpleCSPDef } from './csp-definition';
+
+export interface ICSPConfig {
+  corsWhitelist: string[];
+  csp: ISimpleCSPDef;
+}
+
+export const isCSPConfig = (obj: any): obj is ICSPConfig => {
+  return (
+    !!obj &&
+    typeof obj === 'object' &&
+    'corsWhitelist' in obj &&
+    'csp' in obj &&
+    isSimpleCSPDef(obj.csp)
+  );
+}

package/src/interfaces/csp-definition.ts

@@ -0,0 +1,53 @@
+import { HelmetOptions } from 'helmet';
+import { IncomingMessage, ServerResponse } from 'http';
+
+export interface ISimpleCSPDef {
+      defaultSrc: (
+        | string
+        | ((req: IncomingMessage, res: ServerResponse) => string)
+      )[];
+      imgSrc: (
+        | string
+        | ((req: IncomingMessage, res: ServerResponse) => string)
+      )[];
+      connectSrc: (
+        | string
+        | ((req: IncomingMessage, res: ServerResponse) => string)
+      )[];
+      scriptSrc: (
+        | string
+        | ((req: IncomingMessage, res: ServerResponse) => string)
+      )[];
+      styleSrc: (
+        | string
+        | ((req: IncomingMessage, res: ServerResponse) => string)
+      )[];
+      fontSrc: (
+        | string
+        | ((req: IncomingMessage, res: ServerResponse) => string)
+      )[];
+      frameSrc: (
+        | string
+        | ((req: IncomingMessage, res: ServerResponse) => string)
+      )[];
+    };
+
+export const isSimpleCSPDef = (obj: ISimpleCSPDef | HelmetOptions): obj is ISimpleCSPDef => {
+  return (
+    obj &&
+    'defaultSrc' in obj &&
+    'imgSrc' in obj &&
+    'connectSrc' in obj &&
+    'scriptSrc' in obj &&
+    'styleSrc' in obj &&
+    'fontSrc' in obj &&
+    'frameSrc' in obj &&
+    Array.isArray(obj.defaultSrc) &&
+    Array.isArray(obj.imgSrc) &&
+    Array.isArray(obj.connectSrc) &&
+    Array.isArray(obj.scriptSrc) &&
+    Array.isArray(obj.styleSrc) &&
+    Array.isArray(obj.fontSrc) &&
+    Array.isArray(obj.frameSrc)
+  );
+}

package/src/interfaces/{db-init-result.d.ts → db-init-result.ts}

@@ -1,5 +1,5 @@
 import { IFailableResult } from './failable-result';
+
 export interface IDBInitResult<T> extends IFailableResult<T> {
-    alreadyInitialized: boolean;
-}
-//# sourceMappingURL=db-init-result.d.ts.map
+  alreadyInitialized: boolean;
+}

package/src/interfaces/deep-partial.ts

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};

package/src/interfaces/{discriminator-collections.d.ts → discriminator-collections.ts}

@@ -1,7 +1,7 @@
 import { Model } from '@digitaldefiance/mongoose-types';
 import { IBaseDocument } from '../documents/base';
+
 export interface IDiscriminatorCollections<T extends IBaseDocument<any>> {
-    byType: Record<string, Model<T>>;
-    array: Array<Model<T>>;
+  byType: Record<string, Model<T>>;
+  array: Array<Model<T>>;
 }
-//# sourceMappingURL=discriminator-collections.d.ts.map

package/src/interfaces/email-service.ts

@@ -0,0 +1,8 @@
+export interface IEmailService {
+  sendEmail(
+    to: string,
+    subject: string,
+    text: string,
+    html: string,
+  ): Promise<void>;
+}

package/src/interfaces/environment-mongo.ts

@@ -0,0 +1,76 @@
+import { ReadConcernLike, WriteConcern } from 'mongodb';
+
+export interface IMongoEnvironment {
+  /**
+   * The URI of the MongoDB database
+   */
+  uri: string;
+  /**
+   * The name of the MongoDB database
+   */
+  dbName: string;
+  /**
+   * The maximum number of connections in the connection pool (default: 10)
+   */
+  maxPoolSize: number;
+  /**
+   * The minimum number of connections in the connection pool (default: 2)
+   */
+  minPoolSize: number;
+  /**
+   * The maximum number of milliseconds that a connection can remain idle in the connection pool (default: 30000)
+   */
+  maxIdleTimeMS: number;
+  /**
+   * The maximum time in milliseconds to wait for a connection to be established (default: 5000)
+   */
+  serverSelectionTimeoutMS: number;
+  /**
+   * The maximum time in milliseconds to wait for a socket to be established (default: 30000)
+   */
+  socketTimeoutMS: number;
+  /**
+   * Whether to retry writes (default: true)
+   */
+  retryWrites: boolean;
+  /**
+   * Whether to retry reads (default: true)
+   */
+  retryReads: boolean;
+  /**
+   * The read concern for the MongoDB database
+   */
+  readConcern: ReadConcernLike;
+  /**
+   * The write concern for the MongoDB database (default: { w: 'majority', j: true })
+   */
+  writeConcern: WriteConcern;
+  /**
+   * Whether the MongoDB server supports the setParameter command (MongoDB 4.4+)
+   */
+  setParameterSupported: boolean;
+  /**
+   * Whether the MongoDB server supports setting transactionLifetimeLimitSeconds (MongoDB 4.2+)
+   */
+  transactionLifetimeLimitSecondsSupported: boolean;
+  /**
+   * Whether the MongoDB server supports setting maxTransactionLockRequestTimeoutMillis (MongoDB 4.4+)
+   */
+  maxTransactionLockRequestTimeoutMillisSupported: boolean;
+  /**
+   * How long for transactions to timeout
+   */
+  transactionTimeout: number;
+  /**
+   * The maximum time to wait for a lock when using transactions (MongoDB 4.4+)
+   */
+  transactionLockRequestTimeout: number;
+  /**
+   * Use transactions
+   */
+  useTransactions: boolean;
+  /**
+   * Base delay in milliseconds for transaction retry backoff
+   */
+  transactionRetryBaseDelay: number;
+}

package/src/interfaces/environment.ts

@@ -0,0 +1,185 @@
+import { SecureBuffer, SecureString } from '@digitaldefiance/ecies-lib';
+import { Types } from '@digitaldefiance/mongoose-types';
+import { BackupCode } from '../backup-code';
+import { IMongoEnvironment } from './environment-mongo';
+
+export interface IEnvironment<I = Types.ObjectId> {
+  /**
+   * Whether to use a memory database for local development (eg with MongoMemoryServer)
+   * If set, this will create a new in-memory database instance on application start with the given database name
+   */
+  devDatabase?: string;
+  /**
+   * Whether to print certain console debug messages
+   */
+  debug: boolean;
+  /**
+   * Whether to enable super verbose debug messags
+   */
+  detailedDebug: boolean;
+  /**
+   * The host name of the server
+   */
+  host: string;
+  /**
+   * The port the server is running on
+   */
+  port: number;
+  /**
+   * The base path of the server
+   */
+  basePath: string;
+  /**
+   * The URL of the server
+   */
+  serverUrl: string;
+  /**
+   * The secret used to sign JWTs
+   */
+  jwtSecret: string;
+  /**
+   * The email address to send notifications from
+   */
+  emailSender: string;
+  /**
+   * API distribution directory
+   */
+  apiDistDir: string;
+  /**
+   * react dist dir
+   */
+  reactDistDir: string;
+  /**
+   * The directory and root filename to store HTTPS development certificates
+   */
+  httpsDevCertRoot?: string;
+  /**
+   * The port to use for HTTPS development certificates
+   */
+  httpsDevPort: number;
+  /**
+   * Disable email sending
+   */
+  disableEmailSend: boolean;
+  /**
+   * MongoDB configuration
+   */
+  mongo: IMongoEnvironment;
+  /**
+   * Mnemonic for the admin user
+   */
+  adminMnemonic?: SecureString;
+  /**
+   * The ID of the admin user
+   */
+  adminId?: I;
+  /**
+   * The creation date of the admin user
+   */
+  adminCreatedAt?: Date;
+  /**
+   * The password of the admin user
+   */
+  adminPassword?: SecureString;
+  /**
+   * The ID of the admin user role object
+   */
+  adminRoleId?: I;
+  /**
+   * The ID of the admin user's user role object
+   */
+  adminUserRoleId?: I;
+  /**
+   * Backup codes for the admin user
+   */
+  adminBackupCodes?: BackupCode[];
+  /**
+   * Mnemonic for the member user
+   */
+  memberMnemonic?: SecureString;
+  /**
+   * The ID of the member user
+   */
+  memberId?: I;
+  /**
+   * The creation date of the member user
+   */
+  memberCreatedAt?: Date;
+  /**
+   * The password of the member user
+   */
+  memberPassword?: SecureString;
+  /**
+   * The ID of the member user role object
+   */
+  memberRoleId?: I;
+  /**
+   * The ID of the member user's user role object
+   */
+  memberUserRoleId?: I;
+  /**
+   * Backup codes for the member user
+   */
+  memberBackupCodes?: BackupCode[];
+  /**
+   * Mnemonic for the system user
+   */
+  systemMnemonic?: SecureString;
+  /**
+   * The ID of the system user
+   */
+  systemId?: I;
+  /**
+   * The creation date of the system user
+   */
+  systemCreatedAt?: Date;
+  /**
+   * The public key of the system user
+   */
+  systemPublicKeyHex?: string;
+  /**
+   * The password of the system user
+   */
+  systemPassword?: SecureString;
+  /**
+   * The ID of the system user role object
+   */
+  systemRoleId?: I;
+  /**
+   * The ID of the system user's user role object
+   */
+  systemUserRoleId?: I;
+  /**
+   * Backup codes for the system user
+   */
+  systemBackupCodes?: BackupCode[];
+  /**
+   * HMAC secret for mnemonic encryption
+   */
+  mnemonicHmacSecret: SecureBuffer;
+  /**
+   * Encryption key for mnemonics
+   */
+  mnemonicEncryptionKey: SecureBuffer;
+  /**
+   * The timezone for the server
+   */
+  timezone: string;
+  /**
+   * The default language for the admin interface/CLI
+   */
+  adminLanguage: string;
+  /**
+   * The number of PBKDF2 iterations for key wrapping
+   */
+  pbkdf2Iterations: number;
+  /**
+   * Whether this is a production environment
+   */
+  production: boolean;
+
+  /**
+   * Adapter to convert raw ID bytes to the application ID type I
+   */
+  idAdapter: (bytes: Uint8Array) => I;
+}

package/src/interfaces/failable-result.ts

@@ -0,0 +1,6 @@
+export interface IFailableResult<T> {
+  success: boolean;
+  data?: T;
+  message?: string;
+  error?: string | Error;
+}

package/src/interfaces/fec-consts.ts

@@ -0,0 +1,4 @@
+export interface IFECConsts {
+  /** Maximum size of a single shard */
+  MAX_SHARD_SIZE: number;
+}

package/src/interfaces/flexible-csp.ts

@@ -0,0 +1,18 @@
+import { HelmetOptions } from 'helmet';
+import { isHelmetOptions } from '../middlewares';
+import { ISimpleCSPDef, isSimpleCSPDef } from './csp-definition';
+
+export interface IFlexibleCSP {
+  corsWhitelist: string[],
+  csp: ISimpleCSPDef| HelmetOptions,
+}
+
+export const isFlexibleCSP = (obj: any): obj is IFlexibleCSP => {
+  return (
+    !!obj &&
+    typeof obj === 'object' &&
+    'corsWhitelist' in obj &&
+    'csp' in obj &&
+    (isSimpleCSPDef(obj.csp) || isHelmetOptions(obj.csp))
+  );
+}

package/src/interfaces/handleable-error-options.ts

@@ -0,0 +1,6 @@
+export interface HandleableErrorOptions {
+  cause?: Error;
+  handled?: boolean;
+  statusCode?: number;
+  sourceData?: unknown;
+}

package/src/interfaces/{index.d.ts → index.ts}

@@ -32,4 +32,3 @@ export * from './server-init-result';
 export * from './status-code-response';
 export * from './symmetric-encryption-results';
 export * from './token-response';
-//# sourceMappingURL=index.d.ts.map

package/src/interfaces/jwt-consts.ts

@@ -0,0 +1,23 @@
+export interface IJwtConsts {
+  /**
+   * Algorithm to use for JWT
+   */
+  ALGORITHM:
+    | 'HS256'
+    | 'HS384'
+    | 'HS512'
+    | 'RS256'
+    | 'RS384'
+    | 'RS512'
+    | 'ES256'
+    | 'ES384'
+    | 'ES512'
+    | 'PS256'
+    | 'PS384'
+    | 'PS512';
+
+  /**
+   * The expiration time for a JWT token in seconds
+   */
+  EXPIRATION_SEC: number;
+}

package/src/interfaces/jwt-sign-response.ts

@@ -0,0 +1,19 @@
+import {
+  ITokenRole,
+  ITokenRoleDTO,
+  ITokenUser,
+} from '@digitaldefiance/suite-core-lib';
+import { Types } from '@digitaldefiance/mongoose-types';
+
+export interface IJwtSignResponse<
+  I = Types.ObjectId,
+  D extends Date = Date,
+  TTokenRole extends ITokenRole<I, D> = ITokenRole<I, D>,
+> {
+  token: string;
+  tokenUser: ITokenUser;
+  roleNames: string[];
+  roleTranslatedNames: string[];
+  roles: TTokenRole[];
+  roleDTOs: ITokenRoleDTO[];
+}

package/src/interfaces/models/{email-token.d.ts → email-token.ts}

@@ -1,6 +1,6 @@
 import { IEmailTokenBase } from '@digitaldefiance/suite-core-lib';
+
 /**
  * Front-End Base interface for email token collection documents
  */
 export type IFrontendEmailToken = IEmailTokenBase<string, Date, string>;
-//# sourceMappingURL=email-token.d.ts.map

package/src/interfaces/models/{index.d.ts → index.ts}

@@ -5,4 +5,3 @@ export * from './token-role';
 export * from './used-direct-login-token';
 export * from './user';
 export * from './user-role';
-//# sourceMappingURL=index.d.ts.map

package/src/interfaces/models/{mnemonic.d.ts → mnemonic.ts}

@@ -1,6 +1,6 @@
 import { IMnemonicBase } from '@digitaldefiance/suite-core-lib';
+
 /**
  * Represents a front-end mnemonic hash being stored to check for uniqueness
  */
 export type IFrontendMnemonic = IMnemonicBase<string>;
-//# sourceMappingURL=mnemonic.d.ts.map

package/src/interfaces/models/{role.d.ts → role.ts}

@@ -1,6 +1,6 @@
 import { IRoleBase } from '@digitaldefiance/suite-core-lib';
+
 /**
  * Front-end Base interface for role collection documents
  */
 export type IFrontendRole = IRoleBase<string, Date>;
-//# sourceMappingURL=role.d.ts.map

package/src/interfaces/models/{token-role.d.ts → token-role.ts}

@@ -1,5 +1,6 @@
 import { Types } from '@digitaldefiance/mongoose-types';
 import { ITokenRole } from '@digitaldefiance/suite-core-lib';
+
 /**
  * Front-end Base interface for token role collection documents
  */
@@ -8,4 +9,3 @@ export type IFrontendTokenRole = ITokenRole<string, Date>;
  * Back-end Base interface for token role collection documents
  */
 export type IBackendTokenRole<I = Types.ObjectId> = ITokenRole<I, Date>;
-//# sourceMappingURL=token-role.d.ts.map

package/src/interfaces/models/{used-direct-login-token.d.ts → used-direct-login-token.ts}

@@ -1,5 +1,6 @@
 import { Types } from '@digitaldefiance/mongoose-types';
 import { IUsedDirectLoginTokenBase } from '@digitaldefiance/suite-core-lib';
+
 /**
  * Base interface for front-end used direct login token collection documents
  */
@@ -7,5 +8,5 @@ export type IFrontendUsedDirectLoginToken = IUsedDirectLoginTokenBase<string>;
 /**
  * Base interface for back-end used direct login token collection documents
  */
-export type IBackendUsedDirectLoginToken<I = Types.ObjectId> = IUsedDirectLoginTokenBase<I>;
-//# sourceMappingURL=used-direct-login-token.d.ts.map
+export type IBackendUsedDirectLoginToken<I = Types.ObjectId> =
+  IUsedDirectLoginTokenBase<I>;

package/src/interfaces/models/{user-role.d.ts → user-role.ts}

@@ -1,5 +1,6 @@
 import { Types } from '@digitaldefiance/mongoose-types';
 import { IUserRoleBase } from '@digitaldefiance/suite-core-lib';
+
 /**
  * Front-end Base interface for user role collection documents
  */
@@ -8,4 +9,3 @@ export type IFrontendUserRole = IUserRoleBase<string, Date>;
  * Back-end Base interface for user role collection documents
  */
 export type IBackendUserRole<I = Types.ObjectId> = IUserRoleBase<I, Date>;
-//# sourceMappingURL=user-role.d.ts.map