@digitaldefiance/node-express-suite 3.6.6 → 3.6.8

package/src/middlewares/set-global-context-language.ts

@@ -0,0 +1,24 @@
+// src/middlewares/injectMongooseContext.ts
+
+import {
+  GlobalActiveContext,
+  LanguageRegistry,
+} from '@digitaldefiance/i18n-lib';
+import { NextFunction, Request, Response } from 'express';
+
+export function setGlobalContextLanguageFromRequest(
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) {
+  // Use fallback chain: accept-language -> user preference -> site default
+  const language = LanguageRegistry.getMatchingLanguageCode(
+    req.headers['accept-language'] as string,
+    req.user?.siteLanguage as string,
+  );
+
+  const context = GlobalActiveContext.getInstance();
+  context.setUserLanguage(language);
+  context.setLanguageContextSpace('user');
+  next();
+}

package/src/middlewares.ts

@@ -0,0 +1,105 @@
+import cors from 'cors';
+import { randomBytes } from 'crypto';
+import {
+  Application,
+  json,
+  NextFunction,
+  Request,
+  Response,
+  urlencoded,
+} from 'express';
+import helmet, { HelmetOptions } from 'helmet';
+import { IncomingMessage, ServerResponse } from 'http';
+import { ISimpleCSPDef, isSimpleCSPDef } from './interfaces/csp-definition';
+import { SuiteCoreStringKey, TranslatableSuiteError } from '@digitaldefiance/suite-core-lib';
+
+export const corsOptionsDelegate = (corsWhitelist: string[]) => {
+  return (
+    req: cors.CorsRequest,
+    callback: (
+      error: Error | null,
+      options: cors.CorsOptions | undefined,
+    ) => void,
+  ) => {
+    let corsOptions: cors.CorsOptions;
+    const origin = req.headers.origin;
+    if (
+      origin &&
+      corsWhitelist.find((w: string | RegExp) => {
+        if (w instanceof RegExp) {
+          return w.test(origin);
+        } else {
+          return w === origin;
+        }
+      })
+    ) {
+      corsOptions = { origin: true };
+    } else {
+      corsOptions = { origin: false };
+    }
+    callback(null, corsOptions);
+  };
+};
+
+
+export const isHelmetOptions = (obj: any): boolean => {
+  // A very basic check; in real scenarios, you might want to be more thorough
+  return obj && typeof obj === 'object' && (
+    ('contentSecurityPolicy' in obj) ||
+    ('crossOriginEmbedderPolicy' in obj) ||
+    ('crossOriginOpenerPolicy' in obj) ||
+    ('crossOriginResourcePolicy' in obj) ||
+    ('originAgentCluster' in obj) ||
+    ('referrerPolicy' in obj));
+}
+
+export const initMiddleware = (
+    app: Application,
+    corsWhitelist: string[],
+    csp: ISimpleCSPDef | HelmetOptions,
+  ): void => {
+    // Helmet helps you secure your Express apps by setting various HTTP headers
+    // CSP nonce
+    app.use((req: Request, res: Response, next: NextFunction) => {
+      res.locals['cspNonce'] = randomBytes(32).toString('hex');
+      next();
+    });
+    if (isSimpleCSPDef(csp)) {
+      app.use(
+        helmet({
+          contentSecurityPolicy: {
+            directives: {
+              defaultSrc: ["'self'", ...csp.defaultSrc],
+              imgSrc: ["'self'", 'data:', 'blob:', ...csp.imgSrc],
+              connectSrc: ["'self'", ...csp.connectSrc],
+              scriptSrc: [
+                "'self'",
+                //"'unsafe-inline'",
+                "'strict-dynamic'",
+                (req: IncomingMessage, res: ServerResponse) =>
+                  `'nonce-${(res as Response).locals['cspNonce']}'`,
+                ...csp.scriptSrc,
+              ],
+              styleSrc: [
+                "'self'",
+                // "'unsafe-inline'",
+                ...csp.styleSrc,
+              ],
+              fontSrc: ["'self'", ...csp.fontSrc],
+              frameSrc: ["'self'", ...csp.frameSrc],
+            },
+          },
+        }),
+      );
+    } else if (isHelmetOptions(csp)) {
+      app.use(helmet(csp));
+    } else {
+      throw new TranslatableSuiteError(SuiteCoreStringKey.Error_InvalidCspOrHelmetOptionsProvided);
+    }
+    // Enable CORS
+    app.use(cors(corsOptionsDelegate(corsWhitelist)));
+    // Parse incoming requests with JSON payloads
+    app.use(json());
+    // Parse incoming requests with urlencoded payloads
+    app.use(urlencoded({ extended: true }));
+  };

package/src/model-registry.ts

@@ -0,0 +1,75 @@
+import { Model, Document as MongooseDocument, Schema } from '@digitaldefiance/mongoose-types';
+import { IBaseDocument } from './documents/base';
+import { InvalidModelError } from './errors';
+
+export type ModelRegistration<T, U extends IBaseDocument<T>> = {
+  modelName: string;
+  schema: Schema;
+  model: Model<U>;
+  collection: string;
+  discriminators?: unknown;
+};
+
+class ModelRegistry {
+  protected static _instance: ModelRegistry;
+  protected _models: Map<string, ModelRegistration<any, IBaseDocument<any>>> =
+    new Map();
+
+  private constructor() {}
+
+  public static get instance(): ModelRegistry {
+    if (!ModelRegistry._instance) {
+      ModelRegistry._instance = new ModelRegistry();
+    }
+    return ModelRegistry._instance;
+  }
+
+  public register<T, U extends IBaseDocument<T>>(
+    registration: ModelRegistration<T, U>,
+  ): void {
+    this._models.set(
+      registration.modelName,
+      registration as ModelRegistration<T, U>,
+    );
+  }
+
+  public get<T, U extends IBaseDocument<T>>(
+    modelName: string,
+  ): ModelRegistration<T, U> {
+    const result = this._models.get(modelName) as ModelRegistration<T, U>;
+    if (result === undefined) {
+      throw new InvalidModelError(modelName);
+    }
+    return result;
+  }
+
+  public getTypedModel<TDoc extends MongooseDocument>(
+    modelName: string,
+  ): Model<TDoc> {
+    const result = this._models.get(modelName);
+    if (result === undefined) {
+      throw new InvalidModelError(modelName);
+    }
+    return result.model as Model<TDoc>;
+  }
+
+  public getTypedSchema<TDoc extends MongooseDocument>(
+    modelName: string,
+  ): Schema<TDoc> {
+    const result = this._models.get(modelName);
+    if (result === undefined) {
+      throw new InvalidModelError(modelName);
+    }
+    return result.schema as Schema<TDoc>;
+  }
+
+  public has(modelName: string): boolean {
+    return this._models.has(modelName);
+  }
+
+  public list(): string[] {
+    return Array.from(this._models.keys());
+  }
+}
+
+export { ModelRegistry };

package/src/models/email-token.d.ts

@@ -1,36 +1,12 @@
-import { Connection, Schema } from '@digitaldefiance/mongoose-types';
-export declare function EmailTokenModel(connection: Connection, modelName?: string, collection?: string, schema?: Schema): import("mongoose").Model<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, {}, {}, {}, import("mongoose").Document<unknown, {}, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, {}, {}> & {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-} & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}, Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}> & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}>>;
+import { Connection, Model, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IEmailTokenDocument } from '../documents/email-token';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+
+export function EmailTokenModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  I extends string | Types.ObjectId = Types.ObjectId
+>(connection: Connection, modelName?: TModelName, collection?: TCollection, schema?: Schema): Model<IEmailTokenDocument<I>>;
+
 export default EmailTokenModel;
-//# sourceMappingURL=email-token.d.ts.map

package/src/models/email-token.ts

@@ -0,0 +1,16 @@
+import { Connection, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IEmailTokenDocument } from '../documents/email-token';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { EmailTokenSchema } from '../schemas/email-token';
+
+export function EmailTokenModel(
+  connection: Connection,
+  modelName: string = BaseModelName.EmailToken,
+  collection: string = SchemaCollection.EmailToken,
+  schema: Schema = EmailTokenSchema,
+) {
+  return connection.model(modelName, schema, collection);
+}
+
+export default EmailTokenModel;

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

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

package/src/models/mnemonic.d.ts

@@ -1,36 +1,12 @@
-import { Connection, Schema } from '@digitaldefiance/mongoose-types';
-export declare function MnemonicModel(connection: Connection, modelName?: string, collection?: string, schema?: Schema): import("mongoose").Model<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, {}, {}, {}, import("mongoose").Document<unknown, {}, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, {}, {}> & {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-} & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}, Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}> & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}>>;
+import { Connection, Model, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IMnemonicDocument } from '../documents/mnemonic';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+
+export function MnemonicModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  I extends string | Types.ObjectId = Types.ObjectId
+>(connection: Connection, modelName?: TModelName, collection?: TCollection, schema?: Schema): Model<IMnemonicDocument<I>>;
+
 export default MnemonicModel;
-//# sourceMappingURL=mnemonic.d.ts.map

package/src/models/mnemonic.ts

@@ -0,0 +1,16 @@
+import { Connection, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IMnemonicDocument } from '../documents/mnemonic';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { MnemonicSchema } from '../schemas/mnemonic';
+
+export function MnemonicModel(
+  connection: Connection,
+  modelName: string = BaseModelName.Mnemonic,
+  collection: string = SchemaCollection.Mnemonic,
+  schema: Schema = MnemonicSchema,
+) {
+  return connection.model(modelName, schema, collection);
+}
+
+export default MnemonicModel;

package/src/models/role.d.ts

@@ -1,36 +1,12 @@
-import { Connection, Schema } from '@digitaldefiance/mongoose-types';
-export declare function RoleModel(connection: Connection, modelName?: string, collection?: string, schema?: Schema): import("mongoose").Model<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, {}, {}, {}, import("mongoose").Document<unknown, {}, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, {}, {}> & {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-} & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}, Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}> & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}>>;
+import { Connection, Model, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IRoleDocument } from '../documents/role';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+
+export function RoleModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  I extends string | Types.ObjectId = Types.ObjectId
+>(connection: Connection, modelName?: TModelName, collection?: TCollection, schema?: Schema): Model<IRoleDocument<I>>;
+
 export default RoleModel;
-//# sourceMappingURL=role.d.ts.map

package/src/models/role.ts

@@ -0,0 +1,16 @@
+import { Connection, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IRoleDocument } from '../documents/role';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { RoleSchema } from '../schemas/role';
+
+export function RoleModel(
+  connection: Connection,
+  modelName: string = BaseModelName.Role,
+  collection: string = SchemaCollection.Role,
+  schema: Schema = RoleSchema,
+) {
+  return connection.model(modelName, schema, collection);
+}
+
+export default RoleModel;

package/src/models/used-direct-login-token.d.ts

@@ -1,36 +1,12 @@
-import { Connection, Schema } from '@digitaldefiance/mongoose-types';
-export declare function UsedDirectLoginTokenModel(connection: Connection, modelName?: string, collection?: string, schema?: Schema): import("mongoose").Model<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, {}, {}, {}, import("mongoose").Document<unknown, {}, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, {}, {}> & {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-} & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}, Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}> & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}>>;
+import { Connection, Model, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IUsedDirectLoginTokenDocument } from '../documents/used-direct-login-token';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+
+export function UsedDirectLoginTokenModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  I extends string | Types.ObjectId = Types.ObjectId
+>(connection: Connection, modelName?: TModelName, collection?: TCollection, schema?: Schema): Model<IUsedDirectLoginTokenDocument<I>>;
+
 export default UsedDirectLoginTokenModel;
-//# sourceMappingURL=used-direct-login-token.d.ts.map

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

@@ -0,0 +1,16 @@
+import { Connection, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IUsedDirectLoginTokenDocument } from '../documents/used-direct-login-token';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { UsedDirectLoginTokenSchema } from '../schemas/used-direct-login-token';
+
+export function UsedDirectLoginTokenModel(
+  connection: Connection,
+  modelName: string = BaseModelName.UsedDirectLoginToken,
+  collection: string = SchemaCollection.UsedDirectLoginToken,
+  schema: Schema = UsedDirectLoginTokenSchema,
+) {
+  return connection.model(modelName, schema, collection);
+}
+
+export default UsedDirectLoginTokenModel;

package/src/models/user-role.d.ts

@@ -1,3 +1,10 @@
-import { Connection, Model, Schema } from '@digitaldefiance/mongoose-types';
-export default function UserRoleModel(connection: Connection, modelName?: string, collection?: string, schema?: Schema): Model<any>;
-//# sourceMappingURL=user-role.d.ts.map
+import { Connection, Model, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IUserRoleDocument } from '../documents/user-role';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+
+export default function UserRoleModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  I extends string | Types.ObjectId = Types.ObjectId
+>(connection: Connection, modelName?: TModelName, collection?: TCollection, schema?: Schema): Model<IUserRoleDocument<I>>;

package/src/models/user-role.ts

@@ -0,0 +1,14 @@
+import { Connection, Model, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IUserRoleDocument } from '../documents/user-role';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { UserRoleSchema } from '../schemas/user-role';
+
+export default function UserRoleModel(
+  connection: Connection,
+  modelName: string = BaseModelName.UserRole,
+  collection: string = SchemaCollection.UserRole,
+  schema: Schema = UserRoleSchema,
+): Model<any> {
+  return connection.model(modelName, schema, collection);
+}

package/src/models/user.d.ts

@@ -1,4 +1,17 @@
-import { Connection, Model, Schema } from '@digitaldefiance/mongoose-types';
-export declare function UserModel(connection: Connection, modelName?: string, collection?: string, schema?: Schema): Model<any>;
+import { Connection, Model, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IUserDocument } from '../documents/user';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+
+export function UserModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  I extends string | Types.ObjectId = Types.ObjectId
+>(
+  connection: Connection,
+  modelName?: TModelName,
+  collection?: TCollection,
+  schema?: Schema,
+): Model<IUserDocument<string, I>>;
+
 export default UserModel;
-//# sourceMappingURL=user.d.ts.map

package/src/models/user.ts

@@ -0,0 +1,16 @@
+import { Connection, Model, Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IUserDocument } from '../documents/user';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { UserSchema } from '../schemas/user';
+
+export function UserModel(
+  connection: Connection,
+  modelName: string = BaseModelName.User,
+  collection: string = SchemaCollection.User,
+  schema: Schema = UserSchema,
+): Model<any> {
+  return connection.model(modelName, schema, collection);
+}
+
+export default UserModel;

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

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

package/src/pipeline/pipeline-builder.ts

@@ -0,0 +1,18 @@
+import { RequestHandler } from 'express';
+
+export class Pipeline {
+  private middleware: RequestHandler[] = [];
+
+  static create(): Pipeline {
+    return new Pipeline();
+  }
+
+  use(handler: RequestHandler): this {
+    this.middleware.push(handler);
+    return this;
+  }
+
+  build(): RequestHandler[] {
+    return this.middleware;
+  }
+}

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

@@ -1,3 +1,2 @@
 export * from './plugin-interface';
 export * from './plugin-manager';
-//# sourceMappingURL=index.d.ts.map

package/src/plugins/plugin-interface.ts

@@ -0,0 +1,8 @@
+import { IApplication } from '../interfaces/application';
+
+export interface IApplicationPlugin {
+  readonly name: string;
+  readonly version?: string;
+  init(app: IApplication): Promise<void>;
+  stop?(): Promise<void>;
+}

package/src/plugins/plugin-manager.ts

@@ -0,0 +1,40 @@
+import { IApplication } from '../interfaces/application';
+import { IApplicationPlugin } from './plugin-interface';
+
+export class PluginManager {
+  private plugins = new Map<string, IApplicationPlugin>();
+  private initialized = false;
+
+  register(plugin: IApplicationPlugin): void {
+    if (this.initialized) {
+      throw new Error(`Cannot register plugin ${plugin.name} after initialization`);
+    }
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin ${plugin.name} already registered`);
+    }
+    this.plugins.set(plugin.name, plugin);
+  }
+
+  async initAll(app: IApplication): Promise<void> {
+    for (const plugin of this.plugins.values()) {
+      await plugin.init(app);
+    }
+    this.initialized = true;
+  }
+
+  async stopAll(): Promise<void> {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.stop) {
+        await plugin.stop();
+      }
+    }
+  }
+
+  get(name: string): IApplicationPlugin | undefined {
+    return this.plugins.get(name);
+  }
+
+  has(name: string): boolean {
+    return this.plugins.has(name);
+  }
+}