@digitaldefiance/node-express-suite 1.0.22 → 1.0.23

package/src/schemas/mnemonic.ts

@@ -0,0 +1,37 @@
+import {
+  getSuiteCoreTranslation,
+  SuiteCoreStringKey,
+} from '@digitaldefiance/suite-core-lib';
+import { Schema } from 'mongoose';
+import { Constants as AppConstants } from '../constants';
+import { IMnemonicDocument } from '../documents/mnemonic';
+import { IConstants } from '../interfaces/constants';
+
+/**
+ * Create a mnemonic schema with custom or default constants
+ */
+export function createMnemonicSchema<T extends IConstants = IConstants>(
+  constants: T = AppConstants as T,
+  validationMessage?: () => string,
+): Schema<IMnemonicDocument> {
+  return new Schema<IMnemonicDocument>({
+    hmac: {
+      type: String,
+      required: true,
+      unique: true,
+      index: true,
+      validate: {
+        validator: (v: string) => constants.HmacRegex.test(v),
+        message:
+          validationMessage ||
+          (() =>
+            getSuiteCoreTranslation(SuiteCoreStringKey.Validation_HmacRegex)),
+      },
+    },
+  });
+}
+
+/**
+ * Default mnemonic schema using AppConstants
+ */
+export const MnemonicSchema = createMnemonicSchema();

package/src/schemas/role.ts

@@ -0,0 +1,127 @@
+import {
+  Role,
+  SuiteCoreStringKey,
+  TranslatableSuiteError,
+} from '@digitaldefiance/suite-core-lib';
+import { CallbackWithoutResultAndOptionalError, Schema } from 'mongoose';
+import { IRoleDocument } from '../documents/role';
+import { BaseModelName } from '../enumerations';
+
+/**
+ * Configuration options for creating a role schema
+ */
+export interface RoleSchemaOptions<
+  TRole extends string = Role,
+  TModelName extends string = BaseModelName,
+> {
+  /** Role enum values to use */
+  roleEnum?: TRole[];
+  /** Model name for user reference */
+  userModelName?: TModelName;
+  /** Custom pre-save validation function */
+  customValidation?: (
+    doc: IRoleDocument,
+    next: CallbackWithoutResultAndOptionalError,
+  ) => void;
+}
+
+/**
+ * Factory function to create an extensible role schema
+ */
+export function createRoleSchema<
+  TRole extends string = Role,
+  TModelName extends string = BaseModelName,
+>(options: RoleSchemaOptions<TRole, TModelName> = {}): Schema<IRoleDocument> {
+  const {
+    roleEnum = Object.values(Role) as TRole[],
+    userModelName = BaseModelName.User as TModelName,
+    customValidation,
+  } = options;
+
+  const schema = new Schema<IRoleDocument>(
+    {
+      name: {
+        type: String,
+        enum: roleEnum,
+        required: true,
+        immutable: true,
+      },
+      admin: {
+        type: Boolean,
+        default: false,
+        immutable: true,
+      },
+      member: {
+        type: Boolean,
+        default: false,
+        immutable: true,
+      },
+      child: {
+        type: Boolean,
+        default: false,
+        immutable: true,
+      },
+      system: {
+        type: Boolean,
+        default: false,
+        immutable: true,
+      },
+      createdBy: {
+        type: Schema.Types.ObjectId,
+        ref: userModelName,
+        required: true,
+        immutable: true,
+      },
+      updatedBy: {
+        type: Schema.Types.ObjectId,
+        ref: userModelName,
+        required: true,
+      },
+      deletedAt: {
+        type: Date,
+        optional: true,
+        get: (v: Date) => v,
+        set: (v: Date) => new Date(v.toUTCString()),
+      },
+      deletedBy: {
+        type: Schema.Types.ObjectId,
+        ref: userModelName,
+        required: false,
+        optional: true,
+      },
+    },
+    { timestamps: true },
+  );
+
+  schema.index({ name: 1 }, { unique: true });
+
+  schema.pre('save', function (next: CallbackWithoutResultAndOptionalError) {
+    if (customValidation) {
+      customValidation(this, next);
+    } else {
+      // Default validation
+      if (this.admin && this.child) {
+        return next(
+          new TranslatableSuiteError(
+            SuiteCoreStringKey.Error_ChildRoleCannotBeAnAdminRole,
+          ),
+        );
+      }
+      if (this.system && this.child) {
+        return next(
+          new TranslatableSuiteError(
+            SuiteCoreStringKey.Error_ChildRoleCannotBeASystemRole,
+          ),
+        );
+      }
+      next();
+    }
+  });
+
+  return schema;
+}
+
+/**
+ * Default role schema with base configuration
+ */
+export const RoleSchema = createRoleSchema();

package/src/schemas/schema.ts

@@ -0,0 +1,140 @@
+import { Connection, Schema } from 'mongoose';
+import {
+  IEmailTokenDocument,
+  IMnemonicDocument,
+  IRoleDocument,
+  IUserDocument,
+  IUserRoleDocument,
+} from '../documents';
+import { IUsedDirectLoginTokenDocument } from '../documents/used-direct-login-token';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import EmailTokenModel from '../models/email-token';
+import MnemonicModel from '../models/mnemonic';
+import RoleModel from '../models/role';
+import UsedDirectLoginTokenModel from '../models/used-direct-login-token';
+import UserModel from '../models/user';
+import UserRoleModel from '../models/user-role';
+import { SchemaMap } from '../types';
+import { EmailTokenSchema } from './email-token';
+import { MnemonicSchema } from './mnemonic';
+import { RoleSchema } from './role';
+import { UsedDirectLoginTokenSchema } from './used-direct-login-token';
+import { UserSchema } from './user';
+import { UserRoleSchema } from './user-role';
+
+export interface BaseModelDocs {
+  EmailToken: IEmailTokenDocument;
+  Mnemonic: IMnemonicDocument;
+  Role: IRoleDocument;
+  UsedDirectLoginToken: IUsedDirectLoginTokenDocument;
+  User: IUserDocument;
+  UserRole: IUserRoleDocument;
+}
+
+export interface SchemaMapOptions {
+  schemas?: {
+    EmailToken?: Schema<IEmailTokenDocument>;
+    Mnemonic?: Schema<IMnemonicDocument>;
+    Role?: Schema<IRoleDocument>;
+    UsedDirectLoginToken?: Schema<IUsedDirectLoginTokenDocument>;
+    User?: Schema<IUserDocument>;
+    UserRole?: Schema<IUserRoleDocument>;
+  };
+  modelNames?: {
+    EmailToken?: string;
+    Mnemonic?: string;
+    Role?: string;
+    UsedDirectLoginToken?: string;
+    User?: string;
+    UserRole?: string;
+  };
+  collections?: {
+    EmailToken?: string;
+    Mnemonic?: string;
+    Role?: string;
+    UsedDirectLoginToken?: string;
+    User?: string;
+    UserRole?: string;
+  };
+}
+
+export function getSchemaMap(
+  connection: Connection,
+  options: SchemaMapOptions = {},
+): SchemaMap<BaseModelDocs> {
+  const { schemas = {}, modelNames = {}, collections = {} } = options;
+
+  return {
+    EmailToken: {
+      collection: collections.EmailToken ?? SchemaCollection.EmailToken,
+      model: EmailTokenModel(
+        connection,
+        modelNames.EmailToken ?? BaseModelName.EmailToken,
+        collections.EmailToken ?? SchemaCollection.EmailToken,
+        schemas.EmailToken,
+      ),
+      modelName: modelNames.EmailToken ?? BaseModelName.EmailToken,
+      schema: schemas.EmailToken ?? EmailTokenSchema,
+    },
+    Mnemonic: {
+      collection: collections.Mnemonic ?? SchemaCollection.Mnemonic,
+      model: MnemonicModel(
+        connection,
+        modelNames.Mnemonic ?? BaseModelName.Mnemonic,
+        collections.Mnemonic ?? SchemaCollection.Mnemonic,
+        schemas.Mnemonic,
+      ),
+      modelName: modelNames.Mnemonic ?? BaseModelName.Mnemonic,
+      schema: schemas.Mnemonic ?? MnemonicSchema,
+    },
+    Role: {
+      collection: collections.Role ?? SchemaCollection.Role,
+      model: RoleModel(
+        connection,
+        modelNames.Role ?? BaseModelName.Role,
+        collections.Role ?? SchemaCollection.Role,
+        schemas.Role,
+      ),
+      modelName: modelNames.Role ?? BaseModelName.Role,
+      schema: schemas.Role ?? RoleSchema,
+    },
+    UsedDirectLoginToken: {
+      collection:
+        collections.UsedDirectLoginToken ??
+        SchemaCollection.UsedDirectLoginToken,
+      model: UsedDirectLoginTokenModel(
+        connection,
+        modelNames.UsedDirectLoginToken ?? BaseModelName.UsedDirectLoginToken,
+        collections.UsedDirectLoginToken ??
+          SchemaCollection.UsedDirectLoginToken,
+        schemas.UsedDirectLoginToken,
+      ),
+      modelName:
+        modelNames.UsedDirectLoginToken ?? BaseModelName.UsedDirectLoginToken,
+      schema: schemas.UsedDirectLoginToken ?? UsedDirectLoginTokenSchema,
+    },
+    User: {
+      collection: collections.User ?? SchemaCollection.User,
+      model: UserModel(
+        connection,
+        modelNames.User ?? BaseModelName.User,
+        collections.User ?? SchemaCollection.User,
+        schemas.User,
+      ),
+      modelName: modelNames.User ?? BaseModelName.User,
+      schema: schemas.User ?? UserSchema,
+    },
+    UserRole: {
+      collection: collections.UserRole ?? SchemaCollection.UserRole,
+      model: UserRoleModel(
+        connection,
+        modelNames.UserRole ?? BaseModelName.UserRole,
+        collections.UserRole ?? SchemaCollection.UserRole,
+        schemas.UserRole,
+      ),
+      modelName: modelNames.UserRole ?? BaseModelName.UserRole,
+      schema: schemas.UserRole ?? UserRoleSchema,
+    },
+  } as SchemaMap<BaseModelDocs>;
+}

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

@@ -0,0 +1,38 @@
+import { Schema } from 'mongoose';
+import { IUsedDirectLoginTokenDocument } from '../documents/used-direct-login-token';
+import { BaseModelName } from '../enumerations';
+
+/**
+ * Configuration options for creating a used direct login token schema
+ */
+export interface UsedDirectLoginTokenSchemaOptions<
+  TModelName extends string = BaseModelName,
+> {
+  /** Model name for user reference */
+  userModelName?: TModelName;
+}
+
+/**
+ * Factory function to create an extensible used direct login token schema
+ */
+export function createUsedDirectLoginTokenSchema<
+  TModelName extends string = BaseModelName,
+>(
+  options: UsedDirectLoginTokenSchemaOptions<TModelName> = {},
+): Schema<IUsedDirectLoginTokenDocument> {
+  const { userModelName = BaseModelName.User as TModelName } = options;
+
+  const schema = new Schema<IUsedDirectLoginTokenDocument>({
+    userId: { type: Schema.Types.ObjectId, required: true, ref: userModelName },
+    token: { type: String, required: true },
+  });
+
+  schema.index({ userId: 1, token: 1 }, { unique: true });
+
+  return schema;
+}
+
+/**
+ * Default used direct login token schema with base configuration
+ */
+export const UsedDirectLoginTokenSchema = createUsedDirectLoginTokenSchema();

package/src/schemas/user-role.ts

@@ -0,0 +1,75 @@
+import { Schema } from 'mongoose';
+import { IUserRoleDocument } from '../documents/user-role';
+import { BaseModelName } from '../enumerations';
+
+/**
+ * Configuration options for creating a user-role schema
+ */
+export interface UserRoleSchemaOptions<
+  TModelName extends string = BaseModelName,
+> {
+  /** Model name for user reference */
+  userModelName?: TModelName;
+  /** Model name for role reference */
+  roleModelName?: TModelName;
+}
+
+/**
+ * Factory function to create an extensible user-role schema
+ */
+export function createUserRoleSchema<TModelName extends string = BaseModelName>(
+  options: UserRoleSchemaOptions<TModelName> = {},
+): Schema<IUserRoleDocument> {
+  const {
+    userModelName = BaseModelName.User as TModelName,
+    roleModelName = BaseModelName.Role as TModelName,
+  } = options;
+
+  const schema = new Schema<IUserRoleDocument>(
+    {
+      userId: {
+        type: Schema.Types.ObjectId,
+        ref: userModelName,
+        required: true,
+      },
+      roleId: {
+        type: Schema.Types.ObjectId,
+        ref: roleModelName,
+        required: true,
+      },
+      createdBy: {
+        type: Schema.Types.ObjectId,
+        ref: userModelName,
+        required: true,
+        immutable: true,
+      },
+      updatedBy: {
+        type: Schema.Types.ObjectId,
+        ref: userModelName,
+        required: true,
+      },
+      deletedAt: {
+        type: Date,
+        optional: true,
+      },
+      deletedBy: {
+        type: Schema.Types.ObjectId,
+        ref: userModelName,
+        required: false,
+        optional: true,
+      },
+    },
+    { timestamps: true },
+  );
+
+  schema.index({ userId: 1, roleId: 1 }, { unique: true });
+  schema.index({ userId: 1 });
+  schema.index({ roleId: 1 });
+
+  return schema;
+}
+
+/**
+ * Default user-role schema with base configuration
+ */
+export const UserRoleSchema = createUserRoleSchema();

package/src/schemas/user.ts

@@ -0,0 +1,202 @@
+import { isValidTimezone, LanguageCodes } from '@digitaldefiance/i18n-lib';
+import {
+  AccountStatus,
+  DefaultLanguageCode,
+  getSuiteCoreTranslation,
+  SuiteCoreStringKey,
+} from '@digitaldefiance/suite-core-lib';
+import { Schema } from 'mongoose';
+import validator from 'validator';
+import { Constants as AppConstants } from '../constants';
+import { IUserDocument } from '../documents/user';
+import { BaseModelName } from '../enumerations';
+import { IConstants } from '../interfaces/constants';
+
+/**
+ * Create a user schema with custom or default constants
+ */
+export function createUserSchema<T extends IConstants = IConstants>(
+  constants: T = AppConstants as T,
+  usernameValidationMessage?: () => string,
+  emailValidationMessage?: () => string,
+  timezoneValidationMessage?: () => string,
+  supportedLanguages?: readonly string[],
+): Schema<IUserDocument> {
+  /**
+   * Schema for users
+   */
+  return new Schema<IUserDocument>(
+    {
+      /**
+       * The unique identifier for the user
+       */
+      username: {
+        type: String,
+        required: true,
+        unique: true,
+        validate: {
+          validator: (v: string) => constants.UsernameRegex.test(v),
+          message:
+            usernameValidationMessage ||
+            (() =>
+              getSuiteCoreTranslation(
+                SuiteCoreStringKey.Validation_UsernameRegexErrorTemplate,
+              )),
+        },
+      },
+      /**
+       * The email address for the user
+       */
+      email: {
+        type: String,
+        required: true,
+        unique: true,
+        validate: {
+          validator: (v: string) => validator.isEmail(v),
+          message:
+            emailValidationMessage ||
+            ((props: { value: string }) =>
+              getSuiteCoreTranslation(
+                SuiteCoreStringKey.Error_InvalidEmailTemplate,
+                { email: props.value },
+              )),
+        },
+      },
+      /**
+       * The user's public key, stored in hex format.
+       */
+      publicKey: {
+        type: String,
+        required: true,
+        unique: true,
+      },
+      /**
+       * The timezone for the user
+       */
+      timezone: {
+        type: String,
+        required: true,
+        default: 'UTC',
+        validate: {
+          validator: function (v: string) {
+            return isValidTimezone(v);
+          },
+          message:
+            timezoneValidationMessage ||
+            ((props: { value: string }) =>
+              getSuiteCoreTranslation(
+                SuiteCoreStringKey.Common_NotValidTimeZoneTemplate,
+                { timezone: props.value },
+              )),
+        },
+      },
+      /**
+       * The language of the site for the user
+       */
+      siteLanguage: {
+        type: String,
+        enum: supportedLanguages || Object.values(LanguageCodes),
+        default: DefaultLanguageCode,
+        required: true,
+      },
+      directChallenge: {
+        type: Boolean,
+        default: false,
+        required: true,
+      },
+      /**
+       * The date the user last logged in
+       */
+      lastLogin: { type: Date, required: false },
+      /**
+       * Whether the user has verified their email address
+       */
+      emailVerified: { type: Boolean, default: false },
+      /**
+       * The status of the user's account
+       */
+      accountStatus: {
+        type: String,
+        enum: Object.values(AccountStatus),
+        default: AccountStatus.PendingEmailVerification,
+      },
+      /**
+       * The user who created the user.
+       */
+      createdBy: {
+        type: Schema.Types.ObjectId,
+        ref: BaseModelName.User,
+        required: true,
+        immutable: true,
+      },
+      /**
+       * The user who last updated the user.
+       */
+      updatedBy: {
+        type: Schema.Types.ObjectId,
+        ref: BaseModelName.User,
+        optional: true,
+      },
+      /**
+       * The date/time the user was deleted.
+       */
+      deletedAt: { type: Date, optional: true },
+      /**
+       * The user who deleted the user.
+       */
+      deletedBy: {
+        type: Schema.Types.ObjectId,
+        ref: BaseModelName.User,
+        optional: true,
+      },
+      /**
+       * Reference to the mnemonic document
+       */
+      mnemonicId: {
+        type: Schema.Types.ObjectId,
+        ref: BaseModelName.Mnemonic,
+        required: false,
+      },
+      /**
+       * Copy of the mnemonic encrypted with the user's public key
+       */
+      mnemonicRecovery: {
+        type: String,
+        required: false,
+      },
+      /**
+       * Password-wrapped ECIES private key (Option B)
+       */
+      passwordWrappedPrivateKey: {
+        type: {
+          salt: { type: String, required: true },
+          iv: { type: String, required: true },
+          authTag: { type: String, required: true },
+          ciphertext: { type: String, required: true },
+          iterations: { type: Number, required: true },
+        },
+        required: false,
+      },
+      /**
+       * Array of backup codes to recover mnemonic/private key
+       */
+      backupCodes: {
+        type: [
+          {
+            version: { type: String, required: true },
+            checksumSalt: { type: String, required: true },
+            checksum: { type: String, required: true },
+            encrypted: { type: String, required: true },
+          },
+        ],
+        default: [],
+      },
+    },
+    { timestamps: true },
+  );
+}
+
+/**
+ * Default user schema with base configuration
+ */
+export const UserSchema = createUserSchema();