@digitaldefiance/node-express-suite 1.0.21 → 1.0.23

package/src/decorators/base-controller.ts

@@ -0,0 +1,61 @@
+import 'reflect-metadata';
+import { BaseController } from '../controllers/base';
+import { IApplication } from '../interfaces/application';
+import { ApiResponse } from '../types';
+import { ROUTES_METADATA, RouteMetadata } from './controller';
+import { zodToExpressValidator } from './zod-validation';
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { Types } from 'mongoose';
+import { IBaseDocument } from '../documents';
+import { Environment } from '../environment';
+import { IConstants } from '../interfaces';
+
+export abstract class DecoratorBaseController<
+  TLanguage extends CoreLanguageCode = CoreLanguageCode,
+> extends BaseController<ApiResponse, Record<string, any>, TLanguage> {
+  constructor(application: IApplication<any, Types.ObjectId, IBaseDocument<any, Types.ObjectId>, Environment, IConstants>) {
+    super(application);
+  }
+
+  protected initRouteDefinitions(): void {
+    const routes = (Reflect.getMetadata(ROUTES_METADATA, this.constructor) ||
+      []) as RouteMetadata<TLanguage>[];
+
+    this.routeDefinitions = routes.map((route) => {
+      let validation = route.options.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)) as typeof route.options.validation;
+        }
+      }
+
+      return {
+        method: route.method,
+        path: route.path,
+        handlerKey: route.handlerName,
+        useAuthentication: route.options.auth ?? false,
+        useCryptoAuthentication: route.options.cryptoAuth ?? false,
+        validation: validation as any,
+        middleware: route.options.middleware,
+        rawJsonHandler: route.options.rawJson ?? false,
+      };
+    });
+
+    // Create handlers object from decorated methods
+    this.handlers = {};
+    routes.forEach((route) => {
+      const handler = (this as any)[route.handlerName];
+      if (typeof handler === 'function') {
+        this.handlers[route.handlerName] = handler.bind(this);
+      }
+    });
+  }
+}

package/src/decorators/controller.ts

@@ -0,0 +1,109 @@
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { RequestHandler } from 'express';
+import { ValidationChain } from 'express-validator';
+import 'reflect-metadata';
+import { z } from 'zod';
+
+// Metadata keys for storing decorator information
+export const CONTROLLER_METADATA = Symbol('controller');
+export const ROUTES_METADATA = Symbol('routes');
+
+// Route decorator options
+export interface RouteOptions<TLanguage extends CoreLanguageCode = CoreLanguageCode> {
+  validation?: ValidationChain[] | ((lang: TLanguage) => ValidationChain[]);
+  schema?: z.ZodSchema;
+  middleware?: RequestHandler[];
+  auth?: boolean;
+  cryptoAuth?: boolean;
+  rawJson?: boolean;
+}
+
+// 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 = '') {
+  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/{dist/decorators/index.d.ts → src/decorators/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,57 @@
+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<any>,
+): (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: any) => {
+            if (check.kind === 'min') {
+              chain = chain.isLength({ min: check.value });
+            }
+          });
+        }
+      }
+
+      chains.push(chain);
+    });
+
+    return chains;
+  };
+}
+
+// Decorator that uses Zod schema
+export function ZodValidate(schema: z.ZodType<any>) {
+  return function (
+    target: any,
+    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,94 @@
+import { ECIES as BaseECIES } from '@digitaldefiance/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 defaultConfig: IConstants = Object.freeze({
+  ...CoreConstants,
+  CHECKSUM: CHECKSUM,
+  JWT: JWT,
+  ECIES: ECIES,
+  FEC: FEC,
+});
+
+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 ?? {}),
+    UsernameRegex: (overrides?.UsernameRegex ?? base.UsernameRegex) as RegExp,
+    PasswordRegex: (overrides?.PasswordRegex ?? base.PasswordRegex) as RegExp,
+    MnemonicRegex: (overrides?.MnemonicRegex ?? base.MnemonicRegex) as RegExp,
+    HmacRegex: (overrides?.HmacRegex ?? base.HmacRegex) as RegExp,
+    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 ?? {}),
+    },
+    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 ?? {}),
+    },
+  };
+  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,7 @@
+import { Document, Types } from 'mongoose';
+
+// Base document interface that extends Mongoose Document
+export type IBaseDocument<
+  T,
+  I extends Types.ObjectId | string = Types.ObjectId,
+> = Document<I> & T;

package/src/documents/email-token.ts

@@ -0,0 +1,14 @@
+import {
+  EmailTokenType,
+  IEmailTokenBase,
+} from '@digitaldefiance/suite-core-lib';
+import { Types } from 'mongoose';
+import { IBaseDocument } from './base';
+
+/**
+ * Composite interface for email token collection documents
+ */
+export type IEmailTokenDocument = IBaseDocument<
+  IEmailTokenBase<Types.ObjectId, Date, EmailTokenType>,
+  Types.ObjectId
+>;

package/{dist/documents/index.d.ts → src/documents/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/{dist/documents/mnemonic.d.ts → src/documents/mnemonic.ts}

@@ -1,8 +1,11 @@
 import { IMnemonicBase } from '@digitaldefiance/suite-core-lib';
 import { Types } from 'mongoose';
 import { IBaseDocument } from './base';
+
 /**
  * Composite interface for user collection documents
  */
-export type IMnemonicDocument = IBaseDocument<IMnemonicBase<Types.ObjectId>, Types.ObjectId>;
-//# sourceMappingURL=mnemonic.d.ts.map
+export type IMnemonicDocument = IBaseDocument<
+  IMnemonicBase<Types.ObjectId>,
+  Types.ObjectId
+>;

package/{dist/documents/role.d.ts → src/documents/role.ts}

@@ -1,8 +1,11 @@
 import { IRoleBase } from '@digitaldefiance/suite-core-lib';
 import { Types } from 'mongoose';
 import { IBaseDocument } from './base';
+
 /**
  * Composite interface for role collection documents
  */
-export type IRoleDocument = IBaseDocument<IRoleBase<Types.ObjectId, Date>, Types.ObjectId>;
-//# sourceMappingURL=role.d.ts.map
+export type IRoleDocument = IBaseDocument<
+  IRoleBase<Types.ObjectId, Date>,
+  Types.ObjectId
+>;

package/src/documents/used-direct-login-token.ts

@@ -0,0 +1,7 @@
+import { IUsedDirectLoginTokenBase } from '@digitaldefiance/suite-core-lib';
+import { Types } from 'mongoose';
+import { IBaseDocument } from './base';
+
+export type IUsedDirectLoginTokenDocument = IBaseDocument<
+  IUsedDirectLoginTokenBase<Types.ObjectId>
+>;

package/{dist/documents/user-role.d.ts → src/documents/user-role.ts}

@@ -1,8 +1,11 @@
 import { IUserRoleBase } from '@digitaldefiance/suite-core-lib';
 import { Types } from 'mongoose';
 import { IBaseDocument } from './base';
+
 /**
  * Composite interface for user-role collection documents
  */
-export type IUserRoleDocument = IBaseDocument<IUserRoleBase<Types.ObjectId, Date>, Types.ObjectId>;
-//# sourceMappingURL=user-role.d.ts.map
+export type IUserRoleDocument = IBaseDocument<
+  IUserRoleBase<Types.ObjectId, Date>,
+  Types.ObjectId
+>;

package/{dist/documents/user.d.ts → src/documents/user.ts}

@@ -2,8 +2,10 @@ import { Language } from '@digitaldefiance/i18n-lib';
 import { AccountStatus, IUserBase } from '@digitaldefiance/suite-core-lib';
 import { Types } from 'mongoose';
 import { IBaseDocument } from './base';
+
 /**
  * Composite interface for user collection documents
  */
-export type IUserDocument<S extends string = Language> = IBaseDocument<IUserBase<Types.ObjectId, Date, S, AccountStatus>>;
-//# sourceMappingURL=user.d.ts.map
+export type IUserDocument<S extends string = Language> = IBaseDocument<
+  IUserBase<Types.ObjectId, Date, S, AccountStatus>
+>;

package/src/enumerations/base-model-name.ts

@@ -0,0 +1,41 @@
+/**
+ * Base enumeration of required model names for the node-express-suite.
+ */
+export enum BaseModelName {
+  /**
+   * Model name for email tokens sent to users
+   */
+  EmailToken = 'EmailToken',
+  /**
+   * Model name for roles in the application
+   */
+  Role = 'Role',
+  /**
+   * Model name for users in the application
+   */
+  User = 'User',
+  /**
+   * Model name for mnemonics used in the application
+   */
+  Mnemonic = 'Mnemonic',
+  /**
+   * Model name for user-role relationships
+   */
+  UserRole = 'UserRole',
+  /**
+   * Model name for used direct login tokens
+   */
+  UsedDirectLoginToken = 'UsedDirectLoginToken',
+}
+
+/**
+ * Type for extending BaseModelName with additional models
+ */
+export type ExtendedModelName<T extends Record<string, string>> =
+  | BaseModelName
+  | T[keyof T];
+
+/**
+ * Default model name type for backward compatibility
+ */
+export type ModelName = BaseModelName;

package/{dist/enumerations/index.d.ts → src/enumerations/index.ts}

@@ -2,4 +2,3 @@ export * from './base-model-name';
 export * from './length-encoding-type';
 export * from './schema-collection';
 export * from './symmetric-error-type';
-//# sourceMappingURL=index.d.ts.map

package/src/enumerations/length-encoding-type.ts

@@ -0,0 +1,6 @@
+export enum LengthEncodingType {
+  UInt8 = 0,
+  UInt16 = 1,
+  UInt32 = 2,
+  UInt64 = 3,
+}

package/src/enumerations/schema-collection.ts

@@ -0,0 +1,33 @@
+/**
+ * Enumerations for the schema collections.
+ */
+export enum SchemaCollection {
+  /**
+   * Collection for email tokens sent to users
+   */
+  EmailToken = 'email-tokens',
+  /**
+   * Collection for roles in the application
+   */
+  Role = 'roles',
+  /**
+   * Collection for user tokens
+   */
+  UserToken = 'user-tokens',
+  /**
+   * Collection for users in the application
+   */
+  User = 'users',
+  /**
+   * Collection for mnemonics used in the application
+   */
+  Mnemonic = 'mnemonics',
+  /**
+   * Collection for user-role relationships
+   */
+  UserRole = 'user-roles',
+  /**
+   * Collection for used direct login tokens
+   */
+  UsedDirectLoginToken = 'used-direct-login-tokens',
+}

package/src/enumerations/symmetric-error-type.ts

@@ -0,0 +1,4 @@
+export enum SymmetricErrorType {
+  DataNullOrUndefined = 'DataNullOrUndefined',
+  InvalidKeyLength = 'InvalidKeyLength',
+}