@digitaldefiance/node-express-suite 3.7.3 → 3.7.5

package/src/database/database-initializer.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Database initializer interface.
+ * Defines contract for database initialization implementations.
+ * @module database/database-initializer
+ */
+
+import { IApplication } from '../interfaces/application';
+import { IFailableResult } from '../interfaces/failable-result';
+
+export interface IDatabaseInitializer<T = unknown> {
+  initialize(app: IApplication): Promise<IFailableResult<T>>;
+  hash(results: T): string;
+}

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

@@ -1,2 +1 @@
 export * from './database-initializer';
-//# sourceMappingURL=index.d.ts.map

package/src/decorators/base-controller.ts

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview Base controller with decorator support.
+ * Extends BaseController to support route decorators.
+ * @module decorators/base-controller
+ */
+
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import 'reflect-metadata';
+import { BaseController } from '../controllers/base';
+import { IApplication } from '../interfaces/application';
+import { ApiResponse } from '../types';
+import {
+  ROUTES_METADATA,
+  RouteMetadata,
+  ValidationContext,
+} from './controller';
+import { zodToExpressValidator } from './zod-validation';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Abstract base controller with decorator support.
+ * Automatically initializes routes from decorator metadata.
+ * @template TLanguage - Language code type (defaults to CoreLanguageCode)
+ * @template TID - Platform ID type (defaults to Buffer)
+ */
+export abstract class DecoratorBaseController<
+  TLanguage extends CoreLanguageCode = CoreLanguageCode,
+  TID extends PlatformID = Buffer,
+> extends BaseController<ApiResponse, Record<string, any>, TLanguage, TID> {
+  constructor(application: IApplication<TID>) {
+    super(application);
+  }
+
+  protected initRouteDefinitions(): void {
+    const routes = (Reflect.getMetadata(ROUTES_METADATA, this.constructor) ||
+      []) as RouteMetadata<TLanguage>[];
+    const constants = this.application.constants;
+
+    this.routeDefinitions = routes.map((route) => {
+      let validation = route.options.validation;
+
+      // Bind validation function to preserve 'this' context and inject constants
+      if (typeof validation === 'function') {
+        const context: ValidationContext = { constants };
+        const originalValidation = validation;
+        validation = ((lang: TLanguage) => {
+          return (
+            originalValidation as (
+              this: ValidationContext,
+              lang: TLanguage,
+            ) => any
+          ).call(context, lang);
+        }) as typeof validation;
+      }
+
+      // Convert Zod schema to validation if present
+      if (route.options.schema && !validation) {
+        const schemaValidation = zodToExpressValidator<TLanguage>(
+          route.options.schema,
+        );
+        if (Array.isArray(schemaValidation)) {
+          validation = schemaValidation;
+        } else {
+          validation = (lang: TLanguage) => schemaValidation(lang);
+        }
+      }
+
+      return {
+        method: route.method,
+        path: route.path,
+        handlerKey: route.handlerName,
+        useAuthentication: route.options.auth ?? false,
+        useCryptoAuthentication: route.options.cryptoAuth ?? false,
+        validation: validation,
+        middleware: route.options.middleware,
+        rawJsonHandler: route.options.rawJson ?? false,
+        useTransaction: route.options.transaction ?? false,
+        transactionTimeout: route.options.transactionTimeout,
+      };
+    });
+
+    // Create handlers object from decorated methods
+    this.handlers = {};
+    routes.forEach((route) => {
+      const handler = (this as Record<string, unknown>)[route.handlerName];
+      if (typeof handler === 'function') {
+        this.handlers[route.handlerName] = handler.bind(this);
+      }
+    });
+  }
+}

package/src/decorators/controller.ts

@@ -0,0 +1,152 @@
+/**
+ * @fileoverview Controller and route decorators.
+ * Provides TypeScript decorators for defining Express routes.
+ * @module decorators/controller
+ */
+
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { RequestHandler } from 'express';
+import { ValidationChain } from 'express-validator';
+import 'reflect-metadata';
+import { z } from 'zod';
+import { IConstants } from '../interfaces';
+
+// Metadata keys for storing decorator information
+export const CONTROLLER_METADATA = Symbol('controller');
+export const ROUTES_METADATA = Symbol('routes');
+
+// Validation context with constants - all properties are guaranteed to exist at runtime
+// The constants object is injected by the base controller during route initialization
+export type ValidationContext<TConstants extends IConstants = IConstants> = {
+  constants: TConstants;
+};
+
+// Route decorator options
+export interface RouteOptions<
+  TLanguage extends CoreLanguageCode = CoreLanguageCode,
+  TConstants extends IConstants = IConstants,
+> {
+  validation?:
+    | ValidationChain[]
+    | ((
+        this: ValidationContext<TConstants>,
+        lang: TLanguage,
+      ) => ValidationChain[]);
+  schema?: z.ZodSchema;
+  middleware?: RequestHandler[];
+  auth?: boolean;
+  cryptoAuth?: boolean;
+  rawJson?: boolean;
+  transaction?: boolean;
+  transactionTimeout?: number;
+}
+
+// Route metadata structure
+export interface RouteMetadata<
+  TLanguage extends CoreLanguageCode = CoreLanguageCode,
+> {
+  method: 'get' | 'post' | 'put' | 'delete' | 'patch';
+  path: string;
+  handlerName: string;
+  options: RouteOptions<TLanguage>;
+}
+
+// Controller decorator
+export function Controller(basePath: string = '') {
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  return function <T extends { new (...args: any[]): {} }>(constructor: T) {
+    Reflect.defineMetadata(CONTROLLER_METADATA, { basePath }, constructor);
+    return constructor;
+  };
+}
+
+// HTTP method decorators
+export function Get<TLanguage extends CoreLanguageCode = CoreLanguageCode>(
+  path: string,
+  options: RouteOptions<TLanguage> = {},
+) {
+  return createRouteDecorator('get', path, options);
+}
+
+export function Post<TLanguage extends CoreLanguageCode = CoreLanguageCode>(
+  path: string,
+  options: RouteOptions<TLanguage> = {},
+) {
+  return createRouteDecorator('post', path, options);
+}
+
+export function Put<TLanguage extends CoreLanguageCode = CoreLanguageCode>(
+  path: string,
+  options: RouteOptions<TLanguage> = {},
+) {
+  return createRouteDecorator('put', path, options);
+}
+
+export function Delete<TLanguage extends CoreLanguageCode = CoreLanguageCode>(
+  path: string,
+  options: RouteOptions<TLanguage> = {},
+) {
+  return createRouteDecorator('delete', path, options);
+}
+
+export function Patch<TLanguage extends CoreLanguageCode = CoreLanguageCode>(
+  path: string,
+  options: RouteOptions<TLanguage> = {},
+) {
+  return createRouteDecorator('patch', path, options);
+}
+
+// Helper to create route decorators
+function createRouteDecorator<
+  TLanguage extends CoreLanguageCode = CoreLanguageCode,
+>(
+  method: 'get' | 'post' | 'put' | 'delete' | 'patch',
+  path: string,
+  options: RouteOptions<TLanguage>,
+) {
+  return function (
+    target: any,
+    propertyKey: string,
+    descriptor: PropertyDescriptor,
+  ) {
+    const existingRoutes: RouteMetadata<CoreLanguageCode>[] =
+      Reflect.getMetadata(ROUTES_METADATA, target.constructor) || [];
+
+    const route: RouteMetadata<CoreLanguageCode> = {
+      method,
+      path,
+      handlerName: propertyKey,
+      options: options as RouteOptions<CoreLanguageCode>,
+    };
+
+    existingRoutes.push(route);
+    Reflect.defineMetadata(ROUTES_METADATA, existingRoutes, target.constructor);
+
+    return descriptor;
+  };
+}
+
+// Convenience decorators
+export function Auth(_cryptoAuth: boolean = false) {
+  return function (
+    target: any,
+    propertyKey: string,
+    descriptor: PropertyDescriptor,
+  ) {
+    // This would be combined with route decorators
+    return descriptor;
+  };
+}
+
+export function Validate<TLanguage extends CoreLanguageCode = CoreLanguageCode>(
+  _validation: ValidationChain[] | ((lang: TLanguage) => ValidationChain[]),
+) {
+  return function (
+    target: any,
+    propertyKey: string,
+    descriptor: PropertyDescriptor,
+  ) {
+    // This would be combined with route decorators
+    return descriptor;
+  };
+}

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

@@ -1,4 +1,3 @@
 export * from './base-controller';
 export * from './controller';
 export * from './zod-validation';
-//# sourceMappingURL=index.d.ts.map

package/src/decorators/zod-validation.ts

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview Zod schema validation decorator.
+ * Converts Zod schemas to express-validator chains.
+ * @module decorators/zod-validation
+ */
+
+import { ValidationChain, body } from 'express-validator';
+import { z } from 'zod';
+
+// Convert Zod schema to express-validator chains
+export function zodToExpressValidator<TLanguage extends string>(
+  schema: z.ZodType<unknown>,
+): (_lang: TLanguage) => ValidationChain[] {
+  return (_lang: TLanguage) => {
+    const chains: ValidationChain[] = [];
+
+    // Only process if it's a ZodObject with shape
+    if (!(schema instanceof z.ZodObject)) {
+      return chains;
+    }
+
+    Object.entries(schema.shape).forEach(([key, zodType]) => {
+      let chain = body(key);
+
+      // Handle optional fields
+      if (zodType instanceof z.ZodOptional) {
+        chain = chain.optional();
+        zodType = zodType._def.innerType;
+      }
+
+      // Handle string validations
+      if (zodType instanceof z.ZodString) {
+        chain = chain.isString();
+
+        // Handle min length
+        if (zodType._def.checks) {
+          zodType._def.checks.forEach((check: unknown) => {
+            const checkObj = check as { kind?: string; value?: number };
+            if (checkObj.kind === 'min') {
+              chain = chain.isLength({ min: checkObj.value });
+            }
+          });
+        }
+      }
+
+      chains.push(chain);
+    });
+
+    return chains;
+  };
+}
+
+// Decorator that uses Zod schema
+export function ZodValidate(schema: z.ZodType<unknown>) {
+  return function (
+    target: object,
+    propertyKey: string,
+    descriptor: PropertyDescriptor,
+  ) {
+    // Store Zod schema metadata for runtime validation
+    Reflect.defineMetadata('zodSchema', schema, target, propertyKey);
+    return descriptor;
+  };
+}

package/src/defaults.ts

@@ -0,0 +1,259 @@
+/**
+ * @fileoverview Default runtime configuration for Express application constants.
+ * Provides configuration registry and factory functions for creating customized constant sets.
+ * @module defaults
+ */
+
+import {
+  ECIES as BaseECIES,
+  IIdProviderBase,
+} from '@digitaldefiance/ecies-lib';
+import {
+  KEYRING_ALGORITHM_CONFIGURATION,
+  Constants as NodeEciesConstants,
+} from '@digitaldefiance/node-ecies-lib';
+import { Constants as CoreConstants } from '@digitaldefiance/suite-core-lib';
+import { CHECKSUM, ECIES, FEC, JWT } from './constants';
+import { IConstants } from './interfaces/constants';
+import { DeepPartial } from './interfaces/deep-partial';
+
+export const EXPRESS_RUNTIME_CONFIGURATION_KEY = Symbol.for(
+  'digitaldefiance.node.express.defaults',
+);
+
+const UINT8_SIZE = 1;
+const UINT16_SIZE = 2;
+const UINT16_MAX = 65535;
+const UINT32_SIZE = 4;
+const UINT32_MAX = 4294967295;
+const UINT64_SIZE = 8;
+const UINT64_MAX = 18446744073709551615n;
+const HEX_RADIX = 16;
+const OBJECT_ID_LENGTH = 24;
+
+const defaultConfig: IConstants = Object.freeze({
+  ...CoreConstants,
+  ...NodeEciesConstants,
+  UINT8_SIZE,
+  UINT16_SIZE,
+  UINT16_MAX,
+  UINT32_SIZE,
+  UINT32_MAX,
+  UINT64_SIZE,
+  UINT64_MAX,
+  HEX_RADIX,
+  OBJECT_ID_LENGTH,
+  MEMBER_ID_LENGTH: 8,
+  KEYRING_ALGORITHM_CONFIGURATION,
+  ECIES_VERSION_SIZE: 1,
+  ECIES_CIPHER_SUITE_SIZE: 1,
+  CHECKSUM: CHECKSUM,
+  JWT: JWT,
+  ECIES: ECIES,
+  FEC: FEC,
+  PBKDF2: {
+    ALGORITHM: 'sha256',
+    SALT_BYTES: 32,
+    ITERATIONS_PER_SECOND: 10000,
+  },
+});
+
+const registry = new Map<symbol, IConstants>();
+registry.set(EXPRESS_RUNTIME_CONFIGURATION_KEY, defaultConfig);
+
+export function createExpressRuntimeConfiguration(
+  overrides?: DeepPartial<IConstants>,
+  base: IConstants = defaultConfig,
+): IConstants {
+  const merged: IConstants = {
+    ...base,
+    ...(overrides ?? {}),
+    idProvider: (overrides?.idProvider ?? base.idProvider) as IIdProviderBase,
+    UsernameRegex: (overrides?.UsernameRegex ?? base.UsernameRegex) as RegExp,
+    PasswordRegex: (overrides?.PasswordRegex ?? base.PasswordRegex) as RegExp,
+    MnemonicRegex: (overrides?.MnemonicRegex ?? base.MnemonicRegex) as RegExp,
+    JwtSecretRegex: (overrides?.JwtSecretRegex ??
+      base.JwtSecretRegex) as RegExp,
+    MnemonicEncryptionKeyRegex: (overrides?.MnemonicEncryptionKeyRegex ??
+      base.MnemonicEncryptionKeyRegex) as RegExp,
+    MnemonicHmacRegex: (overrides?.MnemonicHmacRegex ??
+      base.MnemonicHmacRegex) as RegExp,
+    KEYRING: {
+      ALGORITHM: overrides?.KEYRING?.ALGORITHM ?? base.KEYRING.ALGORITHM,
+      KEY_BITS: overrides?.KEYRING?.KEY_BITS ?? base.KEYRING.KEY_BITS,
+      MODE: overrides?.KEYRING?.MODE ?? base.KEYRING.MODE,
+    },
+    ENCRYPTION: {
+      ENCRYPTION_TYPE_SIZE:
+        overrides?.ENCRYPTION?.ENCRYPTION_TYPE_SIZE ??
+        base.ENCRYPTION.ENCRYPTION_TYPE_SIZE,
+      RECIPIENT_ID_SIZE:
+        overrides?.ENCRYPTION?.RECIPIENT_ID_SIZE ??
+        base.ENCRYPTION.RECIPIENT_ID_SIZE,
+    },
+    BACKUP_CODES: {
+      ...base.BACKUP_CODES,
+      ...(overrides?.BACKUP_CODES ?? {}),
+      NormalizedHexRegex: (overrides?.BACKUP_CODES?.NormalizedHexRegex ??
+        base.BACKUP_CODES.NormalizedHexRegex) as RegExp,
+      DisplayRegex: (overrides?.BACKUP_CODES?.DisplayRegex ??
+        base.BACKUP_CODES.DisplayRegex) as RegExp,
+    },
+    CHECKSUM: {
+      ...base.CHECKSUM,
+      ...(overrides?.CHECKSUM ?? {}),
+    },
+    JWT: {
+      ...base.JWT,
+      ...(overrides?.JWT ?? {}),
+    },
+    PBKDF2: {
+      ...base.PBKDF2,
+      ...(overrides?.PBKDF2 ?? {}),
+      ALGORITHM:
+        overrides?.PBKDF2?.ALGORITHM ?? base.PBKDF2.ALGORITHM ?? 'sha256',
+    },
+    PBKDF2_PROFILES: {
+      USER_LOGIN: {
+        hashBytes:
+          overrides?.PBKDF2_PROFILES?.USER_LOGIN?.hashBytes ??
+          base.PBKDF2_PROFILES.USER_LOGIN.hashBytes,
+        iterations:
+          overrides?.PBKDF2_PROFILES?.USER_LOGIN?.iterations ??
+          base.PBKDF2_PROFILES.USER_LOGIN.iterations,
+        saltBytes:
+          overrides?.PBKDF2_PROFILES?.USER_LOGIN?.saltBytes ??
+          base.PBKDF2_PROFILES.USER_LOGIN.saltBytes,
+        algorithm:
+          overrides?.PBKDF2_PROFILES?.USER_LOGIN?.algorithm ??
+          base.PBKDF2_PROFILES.USER_LOGIN.algorithm,
+      },
+      KEY_WRAPPING: {
+        hashBytes:
+          overrides?.PBKDF2_PROFILES?.KEY_WRAPPING?.hashBytes ??
+          base.PBKDF2_PROFILES.KEY_WRAPPING.hashBytes,
+        iterations:
+          overrides?.PBKDF2_PROFILES?.KEY_WRAPPING?.iterations ??
+          base.PBKDF2_PROFILES.KEY_WRAPPING.iterations,
+        saltBytes:
+          overrides?.PBKDF2_PROFILES?.KEY_WRAPPING?.saltBytes ??
+          base.PBKDF2_PROFILES.KEY_WRAPPING.saltBytes,
+        algorithm:
+          overrides?.PBKDF2_PROFILES?.KEY_WRAPPING?.algorithm ??
+          base.PBKDF2_PROFILES.KEY_WRAPPING.algorithm,
+      },
+      BACKUP_CODES: {
+        hashBytes:
+          overrides?.PBKDF2_PROFILES?.BACKUP_CODES?.hashBytes ??
+          base.PBKDF2_PROFILES.BACKUP_CODES.hashBytes,
+        iterations:
+          overrides?.PBKDF2_PROFILES?.BACKUP_CODES?.iterations ??
+          base.PBKDF2_PROFILES.BACKUP_CODES.iterations,
+        saltBytes:
+          overrides?.PBKDF2_PROFILES?.BACKUP_CODES?.saltBytes ??
+          base.PBKDF2_PROFILES.BACKUP_CODES.saltBytes,
+        algorithm:
+          overrides?.PBKDF2_PROFILES?.BACKUP_CODES?.algorithm ??
+          base.PBKDF2_PROFILES.BACKUP_CODES.algorithm,
+      },
+      HIGH_SECURITY: {
+        hashBytes:
+          overrides?.PBKDF2_PROFILES?.HIGH_SECURITY?.hashBytes ??
+          base.PBKDF2_PROFILES.HIGH_SECURITY.hashBytes,
+        iterations:
+          overrides?.PBKDF2_PROFILES?.HIGH_SECURITY?.iterations ??
+          base.PBKDF2_PROFILES.HIGH_SECURITY.iterations,
+        saltBytes:
+          overrides?.PBKDF2_PROFILES?.HIGH_SECURITY?.saltBytes ??
+          base.PBKDF2_PROFILES.HIGH_SECURITY.saltBytes,
+        algorithm:
+          overrides?.PBKDF2_PROFILES?.HIGH_SECURITY?.algorithm ??
+          base.PBKDF2_PROFILES.HIGH_SECURITY.algorithm,
+      },
+      BROWSER_PASSWORD: {
+        hashBytes:
+          overrides?.PBKDF2_PROFILES?.BROWSER_PASSWORD?.hashBytes ??
+          base.PBKDF2_PROFILES.BROWSER_PASSWORD.hashBytes,
+        iterations:
+          overrides?.PBKDF2_PROFILES?.BROWSER_PASSWORD?.iterations ??
+          base.PBKDF2_PROFILES.BROWSER_PASSWORD.iterations,
+        saltBytes:
+          overrides?.PBKDF2_PROFILES?.BROWSER_PASSWORD?.saltBytes ??
+          base.PBKDF2_PROFILES.BROWSER_PASSWORD.saltBytes,
+        algorithm:
+          overrides?.PBKDF2_PROFILES?.BROWSER_PASSWORD?.algorithm ??
+          base.PBKDF2_PROFILES.BROWSER_PASSWORD.algorithm,
+      },
+      TEST_FAST: {
+        hashBytes:
+          overrides?.PBKDF2_PROFILES?.TEST_FAST?.hashBytes ??
+          base.PBKDF2_PROFILES.TEST_FAST.hashBytes,
+        iterations:
+          overrides?.PBKDF2_PROFILES?.TEST_FAST?.iterations ??
+          base.PBKDF2_PROFILES.TEST_FAST.iterations,
+        saltBytes:
+          overrides?.PBKDF2_PROFILES?.TEST_FAST?.saltBytes ??
+          base.PBKDF2_PROFILES.TEST_FAST.saltBytes,
+        algorithm:
+          overrides?.PBKDF2_PROFILES?.TEST_FAST?.algorithm ??
+          base.PBKDF2_PROFILES.TEST_FAST.algorithm,
+      },
+    },
+    ECIES: {
+      ...BaseECIES,
+      ...(overrides?.ECIES ?? {}),
+      SYMMETRIC: {
+        ...BaseECIES.SYMMETRIC,
+        ...(overrides?.ECIES?.SYMMETRIC ?? {}),
+      },
+      SIMPLE: {
+        ...BaseECIES.SIMPLE,
+        ...(overrides?.ECIES?.SIMPLE ?? {}),
+      },
+      SINGLE: {
+        ...BaseECIES.SINGLE,
+        ...(overrides?.ECIES?.SINGLE ?? {}),
+      },
+      MULTIPLE: {
+        ...BaseECIES.MULTIPLE,
+        ...(overrides?.ECIES?.MULTIPLE ?? {}),
+      },
+      ENCRYPTION_TYPE: {
+        ...BaseECIES.ENCRYPTION_TYPE,
+        ...(overrides?.ECIES?.ENCRYPTION_TYPE ?? {}),
+      },
+    },
+    FEC: {
+      ...base.FEC,
+      ...(overrides?.FEC ?? {}),
+    },
+    WRAPPED_KEY: {
+      SALT_SIZE:
+        overrides?.WRAPPED_KEY?.SALT_SIZE ?? base.WRAPPED_KEY.SALT_SIZE,
+      IV_SIZE: overrides?.WRAPPED_KEY?.IV_SIZE ?? base.WRAPPED_KEY.IV_SIZE,
+      MASTER_KEY_SIZE:
+        overrides?.WRAPPED_KEY?.MASTER_KEY_SIZE ??
+        base.WRAPPED_KEY.MASTER_KEY_SIZE,
+      MIN_ITERATIONS:
+        overrides?.WRAPPED_KEY?.MIN_ITERATIONS ??
+        base.WRAPPED_KEY.MIN_ITERATIONS,
+    },
+    VOTING: base.VOTING,
+  };
+  return Object.freeze(merged);
+}
+
+export function registerExpressRuntimeConfiguration(
+  key: symbol,
+  overrides?: DeepPartial<IConstants>,
+): IConstants {
+  const config = createExpressRuntimeConfiguration(overrides);
+  registry.set(key, config);
+  return config;
+}
+
+export function getExpressRuntimeConfiguration(
+  key: symbol = EXPRESS_RUNTIME_CONFIGURATION_KEY,
+): IConstants {
+  return registry.get(key) ?? defaultConfig;
+}

package/src/documents/base.ts

@@ -0,0 +1,17 @@
+/**
+ * @fileoverview Base document interface for Mongoose models.
+ * Provides common document structure for all database models.
+ * @module documents/base
+ */
+
+import { Document } from '@digitaldefiance/mongoose-types';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Base document interface combining Mongoose Document with custom type.
+ * @template T - Document data type
+ * @template TID - Platform ID type (defaults to Buffer)
+ * @typedef {Document<I> & T} IBaseDocument
+ */
+export type IBaseDocument<T, TID extends PlatformID = Buffer> = Document<TID> &
+  T;

package/src/documents/email-token.ts

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview Email token document interface for MongoDB collections.
+ * Combines base document properties with email token-specific fields.
+ * @module documents/email-token
+ */
+
+import {
+  EmailTokenType,
+  IEmailTokenBase,
+} from '@digitaldefiance/suite-core-lib';
+import { IBaseDocument } from './base';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Composite interface for email token collection documents.
+ * Extends base document with email token properties including token type, user ID, and expiration.
+ * @template TID Platform-specific ID type (Buffer, ObjectId, etc.)
+ */
+export type IEmailTokenDocument<TID extends PlatformID = Buffer> =
+  IBaseDocument<IEmailTokenBase<TID, Date, EmailTokenType>, TID>;

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

@@ -5,4 +5,3 @@ export type { IRoleDocument } from './role';
 export type { IUsedDirectLoginTokenDocument } from './used-direct-login-token';
 export type { IUserDocument } from './user';
 export type { IUserRoleDocument } from './user-role';
-//# sourceMappingURL=index.d.ts.map

package/src/documents/mnemonic.ts

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview Mnemonic document interface for MongoDB collections.
+ * Combines base document properties with mnemonic storage fields.
+ * @module documents/mnemonic
+ */
+
+import { IMnemonicBase } from '@digitaldefiance/suite-core-lib';
+import { IBaseDocument } from './base';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Composite interface for mnemonic collection documents.
+ * Extends base document with mnemonic properties including HMAC-protected mnemonic phrases.
+ * Used for secure storage and retrieval of user recovery mnemonics.
+ * @template TID Platform-specific ID type (Buffer, ObjectId, etc.)
+ */
+export type IMnemonicDocument<TID extends PlatformID = Buffer> = IBaseDocument<
+  IMnemonicBase<TID>,
+  TID
+>;

package/src/documents/role.ts

@@ -0,0 +1,19 @@
+/**
+ * @fileoverview Role document interface for Mongoose role model.
+ * Combines base document with role-specific fields and permissions.
+ * @module documents/role
+ */
+
+import { IRoleBase } from '@digitaldefiance/suite-core-lib';
+import { IBaseDocument } from './base';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Role document interface for MongoDB role collection.
+ * @template TID - Platform ID type (defaults to Buffer)
+ * @typedef {IBaseDocument<IRoleBase<TID, Date>, TID>} IRoleDocument
+ */
+export type IRoleDocument<TID extends PlatformID = Buffer> = IBaseDocument<
+  IRoleBase<TID, Date>,
+  TID
+>;