@digitaldefiance/node-express-suite 3.7.3 → 3.7.5

package/src/middlewares/authenticate-token.ts

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview JWT token authentication middleware.
+ * Validates bearer tokens, loads user data, and sets up request context.
+ * @module middlewares/authenticate-token
+ */
+
+import type { Timezone as TimezoneType } from '@digitaldefiance/i18n-lib';
+import { GlobalActiveContext } from '@digitaldefiance/i18n-lib';
+import { ClientSession } from '@digitaldefiance/mongoose-types';
+import {
+  AccountStatus,
+  getSuiteCoreTranslation,
+  ITokenRole,
+  ITokenUser,
+  SuiteCoreStringKey,
+} from '@digitaldefiance/suite-core-lib';
+import { NextFunction, Request, Response } from 'express';
+import { IncomingHttpHeaders } from 'http';
+import { IUserDocument } from '../documents/user';
+import { BaseModelName } from '../enumerations/base-model-name';
+import { TokenExpiredError } from '../errors/token-expired';
+import { IApplication } from '../interfaces/application';
+import { JwtService } from '../services/jwt';
+import { RequestUserService } from '../services/request-user';
+import { RoleService } from '../services/role';
+import { withTransaction } from '../utils';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+// Type for Timezone constructor
+type TimezoneConstructor = new (tz: string) => TimezoneType;
+
+// Helper to create Timezone from the same module instance as GlobalActiveContext
+function createTimezone(tz: string): TimezoneType {
+  const context = GlobalActiveContext.getInstance();
+  const TimezoneConstructor = context.adminTimezone
+    .constructor as TimezoneConstructor;
+  return new TimezoneConstructor(tz);
+}
+
+/**
+ * Extracts bearer token from HTTP request headers.
+ * @param {IncomingHttpHeaders} headers - HTTP request headers
+ * @returns {string | null} Bearer token if found, null otherwise
+ */
+export function findAuthToken(headers: IncomingHttpHeaders): string | null {
+  const authHeader = headers['Authorization'] || headers['authorization'];
+  if (authHeader && typeof authHeader === 'string') {
+    const parts = authHeader.split(' ');
+    if (parts.length === 2 && parts[0].toLowerCase() === 'bearer') {
+      return parts[1];
+    }
+  }
+  return null;
+}
+
+/**
+ * Express middleware for JWT token authentication.
+ * Validates token, loads user from database, checks account status,
+ * and populates req.user with authenticated user data.
+ * @template TID - Platform ID type (defaults to Buffer)
+ * @template D - Date type (defaults to Date)
+ * @template TTokenRole - Token role interface type
+ * @template TTokenUser - Token user interface type
+ * @template TApplication - Application interface type
+ * @param {TApplication} application - Application instance
+ * @param {Request} req - Express request object
+ * @param {Response} res - Express response object
+ * @param {NextFunction} next - Express next function
+ * @returns {Promise<Response>} Response object
+ * @throws {TokenExpiredError} When token has expired
+ */
+export async function authenticateToken<
+  TID extends PlatformID = Buffer,
+  D extends Date = Date,
+  TTokenRole extends ITokenRole<TID, D> = ITokenRole<TID, D>,
+  TTokenUser extends ITokenUser = ITokenUser,
+  TApplication extends IApplication<TID> = IApplication<TID>,
+>(
+  application: TApplication,
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): Promise<Response> {
+  const UserModel = application.getModel<IUserDocument<string, TID>>(
+    BaseModelName.User,
+  );
+  const token = findAuthToken(req.headers);
+  if (token == null) {
+    return res
+      .status(401)
+      .send(
+        getSuiteCoreTranslation(SuiteCoreStringKey.Validation_InvalidToken),
+      );
+  }
+
+  try {
+    return await withTransaction<Response>(
+      application.db.connection,
+      application.environment.mongo.useTransactions,
+      undefined,
+      async (sess: ClientSession | undefined) => {
+        const jwtService = new JwtService<
+          TID,
+          D,
+          TTokenRole,
+          TTokenUser,
+          TApplication
+        >(application);
+        const user: TTokenUser | null = await jwtService.verifyToken(token);
+        if (user === null) {
+          return res.status(403).send(
+            // amazonq-ignore-next-line false positive, hardcoded string
+            getSuiteCoreTranslation(SuiteCoreStringKey.Validation_UserNotFound),
+          );
+        }
+        const userDoc = await UserModel.findById(user.userId)
+          .select('-password')
+          .session(sess ?? null)
+          .exec();
+        if (!userDoc || userDoc.accountStatus !== AccountStatus.Active) {
+          return res.status(403).send(
+            // amazonq-ignore-next-line false positive, hardcoded string
+            getSuiteCoreTranslation(SuiteCoreStringKey.Validation_UserNotFound),
+          );
+        }
+        const roleService = new RoleService<TID, D, TTokenRole>(application);
+        const roles = await roleService.getUserRoles(userDoc._id as TID, sess);
+        const tokenRoles = roleService.rolesToTokenRoles(roles);
+        req.user = RequestUserService.makeRequestUserDTO(userDoc, tokenRoles);
+        const context = GlobalActiveContext.getInstance();
+        context.userLanguage = userDoc.siteLanguage ?? context.userLanguage;
+        context.setLanguageContextSpace('user');
+        context.userTimezone = createTimezone(userDoc.timezone);
+        next();
+        return res;
+      },
+      {
+        timeoutMs: application.environment.mongo.transactionTimeout,
+      },
+    );
+  } catch (err) {
+    if (err instanceof TokenExpiredError) {
+      return res.status(401).send({
+        message: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Validation_TokenExpired,
+        ),
+        error: err,
+      });
+    } else if (err instanceof Error && err.name === 'JsonWebTokenError') {
+      return res.status(400).send({
+        message: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Validation_InvalidToken,
+        ),
+        error: err,
+      });
+    } else {
+      return res.status(500).send({
+        message: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Common_UnexpectedError,
+        ),
+        error: err,
+      });
+    }
+  }
+}

package/src/middlewares/cleanup-crypto.ts

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Cleanup middleware for disposing cryptographic resources.
+ * Ensures private keys and sensitive material are properly disposed after request completion.
+ * @module middlewares/cleanup-crypto
+ */
+
+import { NextFunction, Request, Response } from 'express';
+
+/**
+ * Express middleware to cleanup cryptographic resources after request completion.
+ * Wraps response.end() to dispose of req.eciesUser before sending response.
+ * Should be registered early in middleware chain to ensure cleanup on all responses.
+ * @param {Request} req - Express request object
+ * @param {Response} res - Express response object
+ * @param {NextFunction} next - Express next function
+ */
+export function cleanupCrypto(
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): void {
+  // Store original end function
+  const originalEnd = res.end;
+
+  // Override end function to cleanup before response
+  const wrappedEnd = function (this: Response, ...args: unknown[]) {
+    // Cleanup eciesUser if it exists
+    if (req.eciesUser) {
+      try {
+        // Dispose of sensitive cryptographic material
+        req.eciesUser.dispose();
+        req.eciesUser = undefined;
+      } catch (error) {
+        console.error('Error cleaning up crypto resources:', error);
+      }
+    }
+    // Do not dispose system user here; it may be a process-wide singleton
+
+    // Call original end function
+    // Type assertion needed because we're wrapping the end function
+    return originalEnd.apply(this, args as Parameters<typeof originalEnd>);
+  } as typeof res.end;
+
+  res.end = wrappedEnd;
+
+  next();
+}

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

@@ -2,4 +2,3 @@ export * from './authenticate-crypto';
 export * from './authenticate-token';
 export * from './cleanup-crypto';
 export * from './set-global-context-language';
-//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview Middleware to set global language context from request.
+ * Determines user language from Accept-Language header and user preferences.
+ * @module middlewares/set-global-context-language
+ */
+
+// src/middlewares/injectMongooseContext.ts
+
+import {
+  GlobalActiveContext,
+  LanguageRegistry,
+} from '@digitaldefiance/i18n-lib';
+import { NextFunction, Request, Response } from 'express';
+
+/**
+ * Express middleware to set global language context for the request.
+ * Uses fallback chain: Accept-Language header → user preference → site default.
+ * Sets both user language and language context space in GlobalActiveContext.
+ * @param {Request} req - Express request object
+ * @param {Response} res - Express response object
+ * @param {NextFunction} next - Express next function
+ */
+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/model-registry.ts

@@ -0,0 +1,142 @@
+/**
+ * @fileoverview Model registry for dynamic Mongoose model management.
+ * Singleton registry for registering and retrieving Mongoose models.
+ * @module model-registry
+ */
+
+import {
+  Model,
+  Document as MongooseDocument,
+  Schema,
+} from '@digitaldefiance/mongoose-types';
+import { IBaseDocument } from './documents/base';
+import { InvalidModelError } from './errors';
+import { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Model registration information.
+ * @template T - Document Data type
+ * @template U - Document type extending IBaseDocument
+ */
+export type ModelRegistration<
+  TID extends PlatformID,
+  T,
+  U extends IBaseDocument<T, TID>,
+> = {
+  modelName: string;
+  schema: Schema;
+  model: Model<U>;
+  collection: string;
+  discriminators?: unknown;
+};
+
+/**
+ * Singleton registry for Mongoose models.
+ * Manages model registration and retrieval across the application.
+ */
+class ModelRegistry<TID extends PlatformID> {
+  protected static _instance: ModelRegistry<PlatformID>;
+  protected _models: Map<
+    string,
+    ModelRegistration<TID, any, IBaseDocument<any, TID>>
+  > = new Map();
+
+  private constructor() {}
+
+  /**
+   * Gets the singleton instance of ModelRegistry.
+   * @returns {ModelRegistry} The singleton instance
+   */
+  public static get instance(): ModelRegistry<PlatformID> {
+    if (!ModelRegistry._instance) {
+      ModelRegistry._instance = new ModelRegistry();
+    }
+    return ModelRegistry._instance;
+  }
+
+  /**
+   * Registers a model with the registry.
+   * @template T - Document ID type
+   * @template U - Document type extending IBaseDocument
+   * @param {ModelRegistration<T, U>} registration - Model registration information
+   */
+  public register<T, U extends IBaseDocument<T, TID>>(
+    registration: ModelRegistration<TID, T, U>,
+  ): void {
+    this._models.set(
+      registration.modelName,
+      registration as ModelRegistration<TID, T, U>,
+    );
+  }
+
+  /**
+   * Retrieves a model registration by name.
+   * @template T - Document ID type
+   * @template U - Document type extending IBaseDocument
+   * @param {string} modelName - Name of the model
+   * @returns {ModelRegistration<T, U>} Model registration
+   * @throws {InvalidModelError} If model is not registered
+   */
+  public get<T, U extends IBaseDocument<T, TID>>(
+    modelName: string,
+  ): ModelRegistration<TID, T, U> {
+    const result = this._models.get(modelName) as ModelRegistration<TID, T, U>;
+    if (result === undefined) {
+      throw new InvalidModelError(modelName);
+    }
+    return result;
+  }
+
+  /**
+   * Retrieves a typed Mongoose model by name.
+   * @template TDoc - Mongoose document type
+   * @param {string} modelName - Name of the model
+   * @returns {Model<TDoc>} Mongoose model
+   * @throws {InvalidModelError} If model is not registered
+   */
+  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>;
+  }
+
+  /**
+   * Retrieves a typed Mongoose schema by name.
+   * @template TDoc - Mongoose document type
+   * @param {string} modelName - Name of the model
+   * @returns {Schema<TDoc>} Mongoose schema
+   * @throws {InvalidModelError} If model is not registered
+   */
+  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>;
+  }
+
+  /**
+   * Checks if a model is registered.
+   * @param {string} modelName - Name of the model
+   * @returns {boolean} True if model exists
+   */
+  public has(modelName: string): boolean {
+    return this._models.has(modelName);
+  }
+
+  /**
+   * Lists all registered model names.
+   * @returns {string[]} Array of model names
+   */
+  public list(): string[] {
+    return Array.from(this._models.keys());
+  }
+}
+
+export { ModelRegistry };

package/src/models/email-token.ts

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Email token model factory for MongoDB.
+ * Creates Mongoose model for email verification and password reset tokens.
+ * @module models/email-token
+ */
+
+import { Connection, Model, Schema } 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';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Creates a Mongoose model for email token documents.
+ * @template TModelName - Model name type (defaults to BaseModelName)
+ * @template TCollection - Collection name type (defaults to SchemaCollection)
+ * @template TID - Platform ID type (defaults to Buffer)
+ * @param {Connection} connection - Mongoose connection instance
+ * @param {TModelName} [modelName] - Model name (defaults to 'EmailToken')
+ * @param {TCollection} [collection] - Collection name (defaults to 'emailTokens')
+ * @param {Schema} [schema] - Mongoose schema (defaults to EmailTokenSchema)
+ * @returns {Model<IEmailTokenDocument<TID>>} Configured Mongoose model
+ */
+export function EmailTokenModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  TID extends PlatformID = Buffer,
+>(
+  connection: Connection,
+  modelName?: TModelName,
+  collection?: TCollection,
+  schema?: Schema,
+): Model<IEmailTokenDocument<TID>>;
+
+export function EmailTokenModel<TID extends PlatformID = Buffer>(
+  connection: Connection,
+  modelName: string = BaseModelName.EmailToken,
+  collection: string = SchemaCollection.EmailToken,
+  schema: Schema = EmailTokenSchema,
+) {
+  return connection.model<IEmailTokenDocument<TID>>(
+    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.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Mnemonic model factory for MongoDB.
+ * Creates Mongoose model for mnemonic hash storage.
+ * @module models/mnemonic
+ */
+
+import { Connection, Model, Schema } from '@digitaldefiance/mongoose-types';
+import { IMnemonicDocument } from '../documents/mnemonic';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { MnemonicSchema } from '../schemas/mnemonic';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Creates a Mongoose model for mnemonic documents.
+ * @template TModelName - Model name type (defaults to BaseModelName)
+ * @template TCollection - Collection name type (defaults to SchemaCollection)
+ * @template TID - Platform ID type (defaults to Buffer)
+ * @param {Connection} connection - Mongoose connection instance
+ * @param {TModelName} modelName - Model name (defaults to 'Mnemonic')
+ * @param {TCollection} collection - Collection name (defaults to 'mnemonics')
+ * @param {Schema} schema - Mongoose schema (defaults to MnemonicSchema)
+ * @returns {Model<IMnemonicDocument<TID>>} Configured Mongoose model
+ */
+export function MnemonicModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  TID extends PlatformID = Buffer,
+>(
+  connection: Connection,
+  modelName: TModelName = BaseModelName.Mnemonic as TModelName,
+  collection: TCollection = SchemaCollection.Mnemonic as TCollection,
+  schema: Schema = MnemonicSchema,
+): Model<IMnemonicDocument<TID>> {
+  return connection.model<IMnemonicDocument<TID>>(
+    modelName,
+    schema,
+    collection,
+  );
+}
+
+export default MnemonicModel;

package/src/models/role.ts

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview Role model factory for MongoDB.
+ * Creates Mongoose model for role management with RBAC.
+ * @module models/role
+ */
+
+import { Connection, Model, Schema } from '@digitaldefiance/mongoose-types';
+import { IRoleDocument } from '../documents/role';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { RoleSchema } from '../schemas/role';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Creates a Mongoose model for role documents.
+ * @template TModelName - Model name type (defaults to BaseModelName)
+ * @template TCollection - Collection name type (defaults to SchemaCollection)
+ * @template TID - Platform ID type (defaults to Buffer)
+ * @param {Connection} connection - Mongoose connection instance
+ * @param {TModelName} modelName - Model name (defaults to 'Role')
+ * @param {TCollection} collection - Collection name (defaults to 'roles')
+ * @param {Schema} schema - Mongoose schema (defaults to RoleSchema)
+ * @returns {Model<IRoleDocument<TID>>} Configured Mongoose model
+ */
+export function RoleModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  TID extends PlatformID = Buffer,
+>(
+  connection: Connection,
+  modelName: TModelName = BaseModelName.Role as TModelName,
+  collection: TCollection = SchemaCollection.Role as TCollection,
+  schema: Schema = RoleSchema,
+): Model<IRoleDocument<TID>> {
+  return connection.model<IRoleDocument<TID>>(modelName, schema, collection);
+}
+
+export default RoleModel;

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

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Used direct login token model factory for MongoDB.
+ * Creates Mongoose model for tracking consumed direct login tokens.
+ * @module models/used-direct-login-token
+ */
+
+import { Connection, Model, Schema } 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';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Creates a Mongoose model for used direct login token documents.
+ * @template TModelName - Model name type (defaults to BaseModelName)
+ * @template TCollection - Collection name type (defaults to SchemaCollection)
+ * @template TID - Platform ID type (defaults to Buffer)
+ * @param {Connection} connection - Mongoose connection instance
+ * @param {TModelName} [modelName] - Model name (defaults to 'UsedDirectLoginToken')
+ * @param {TCollection} [collection] - Collection name (defaults to 'usedDirectLoginTokens')
+ * @param {Schema} [schema] - Mongoose schema (defaults to UsedDirectLoginTokenSchema)
+ * @returns {Model<IUsedDirectLoginTokenDocument<TID>>} Configured Mongoose model
+ */
+export function UsedDirectLoginTokenModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  TID extends PlatformID = Buffer,
+>(
+  connection: Connection,
+  modelName?: TModelName,
+  collection?: TCollection,
+  schema?: Schema,
+): Model<IUsedDirectLoginTokenDocument<TID>>;
+
+export function UsedDirectLoginTokenModel<TID extends PlatformID = Buffer>(
+  connection: Connection,
+  modelName?: string,
+  collection?: string,
+  schema?: Schema,
+): Model<IUsedDirectLoginTokenDocument<TID>> {
+  return connection.model<IUsedDirectLoginTokenDocument<TID>>(
+    modelName ?? BaseModelName.UsedDirectLoginToken,
+    schema ?? UsedDirectLoginTokenSchema,
+    collection ?? SchemaCollection.UsedDirectLoginToken,
+  );
+}
+
+export default UsedDirectLoginTokenModel;

package/src/models/user-role.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview User-role relationship model factory for MongoDB.
+ * Creates Mongoose model for many-to-many user-role associations.
+ * @module models/user-role
+ */
+
+import { Connection, Model, Schema } 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';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Creates a Mongoose model for user-role relationship documents.
+ * @template TModelName - Model name type (defaults to BaseModelName)
+ * @template TCollection - Collection name type (defaults to SchemaCollection)
+ * @template TID - Platform ID type (defaults to Buffer)
+ * @param {Connection} connection - Mongoose connection instance
+ * @param {TModelName} modelName - Model name (defaults to 'UserRole')
+ * @param {TCollection} collection - Collection name (defaults to 'userRoles')
+ * @param {Schema} schema - Mongoose schema (defaults to UserRoleSchema)
+ * @returns {Model<IUserRoleDocument<TID>>} Configured Mongoose model
+ */
+export default function UserRoleModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  TID extends PlatformID = Buffer,
+>(
+  connection: Connection,
+  modelName: TModelName = BaseModelName.UserRole as TModelName,
+  collection: TCollection = SchemaCollection.UserRole as TCollection,
+  schema: Schema = UserRoleSchema,
+): Model<IUserRoleDocument<TID>> {
+  return connection.model<IUserRoleDocument<TID>>(
+    modelName,
+    schema,
+    collection,
+  );
+}

package/src/models/user.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview User model factory for MongoDB.
+ * Creates Mongoose model for user management with authentication.
+ * @module models/user
+ */
+
+import { Connection, Model, Schema } from '@digitaldefiance/mongoose-types';
+import { IUserDocument } from '../documents/user';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { UserSchema } from '../schemas/user';
+import type { PlatformID } from '@digitaldefiance/node-ecies-lib';
+
+/**
+ * Creates a Mongoose model for user documents.
+ * @template TModelName - Model name type (defaults to BaseModelName)
+ * @template TCollection - Collection name type (defaults to SchemaCollection)
+ * @template TID - Platform ID type (defaults to Buffer)
+ * @param {Connection} connection - Mongoose connection instance
+ * @param {TModelName} modelName - Model name (defaults to 'User')
+ * @param {TCollection} collection - Collection name (defaults to 'users')
+ * @param {Schema} schema - Mongoose schema (defaults to UserSchema)
+ * @returns {Model<IUserDocument<string, TID>>} Configured Mongoose model
+ */
+export function UserModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+  TID extends PlatformID = Buffer,
+>(
+  connection: Connection,
+  modelName: TModelName = BaseModelName.User as TModelName,
+  collection: TCollection = SchemaCollection.User as TCollection,
+  schema: Schema = UserSchema,
+): Model<IUserDocument<string, TID>> {
+  return connection.model<IUserDocument<string, TID>>(
+    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