@digitaldefiance/node-express-suite 3.6.14 → 3.6.16

package/src/schemas/role.ts

@@ -1,132 +0,0 @@
-import { CallbackWithoutResultAndOptionalError, Schema, Types } from '@digitaldefiance/mongoose-types';
-import {
-  IRoleBase,
-  Role,
-  SuiteCoreStringKey,
-  TranslatableSuiteError,
-} from '@digitaldefiance/suite-core-lib';
-import { IRoleDocument } from '../documents/role';
-import { BaseModelName } from '../enumerations';
-import { IConstants } from '../interfaces';
-
-/**
- * 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?: <T = any>(
-    doc: T,
-    next: CallbackWithoutResultAndOptionalError,
-  ) => void;
-  /** ID type for references */
-  idType?: any;
-}
-
-/**
- * Factory function to create an extensible role schema
- */
-export function createRoleSchema<
-  TRole extends string = Role,
-  TModelName extends string = BaseModelName,
-  TConstants extends IConstants = IConstants
->(options: RoleSchemaOptions<TRole, TModelName> = {}, constants: TConstants = {} as TConstants): Schema {
-  const {
-    roleEnum = Object.values(Role) as TRole[],
-    userModelName = BaseModelName.User as TModelName,
-    customValidation,
-    idType = Schema.Types.ObjectId,
-  } = options;
-
-  const definition = {
-    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: idType,
-      ref: userModelName,
-      required: true,
-      immutable: true,
-    },
-    updatedBy: {
-      type: idType,
-      ref: userModelName,
-      required: true,
-    },
-    deletedAt: {
-      type: Date,
-      optional: true,
-      get: (v: Date) => v,
-      set: (v: Date) => new Date(v.toUTCString()),
-    },
-    deletedBy: {
-      type: idType,
-      ref: userModelName,
-      required: false,
-      optional: true,
-    },
-  };
-
-  const schema = new Schema(definition, { timestamps: true });
-  schema.index({ name: 1 }, { unique: true });
-
-  schema.pre('save', function (next: CallbackWithoutResultAndOptionalError) {
-    const doc = this;
-    if (customValidation) {
-      customValidation(doc, next);
-    } else {
-      // Default validation
-      if (doc.admin && doc.child) {
-        return next(
-          new TranslatableSuiteError(
-            SuiteCoreStringKey.Error_ChildRoleCannotBeAnAdminRole,
-          ),
-        );
-      }
-      if (doc.system && doc.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

@@ -1,150 +0,0 @@
-import { Connection, Schema } from '@digitaldefiance/mongoose-types';
-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, createEmailTokenSchema } from './email-token';
-import { MnemonicSchema, createMnemonicSchema } from './mnemonic';
-import { RoleSchema, createRoleSchema } from './role';
-import { UsedDirectLoginTokenSchema, createUsedDirectLoginTokenSchema } from './used-direct-login-token';
-import { UserSchema, createUserSchema } from './user';
-import { UserRoleSchema, createUserRoleSchema } from './user-role';
-import { IConstants } from '../interfaces';
-
-export interface BaseModelDocs {
-  EmailToken: IEmailTokenDocument;
-  Mnemonic: IMnemonicDocument;
-  Role: IRoleDocument;
-  UsedDirectLoginToken: IUsedDirectLoginTokenDocument;
-  User: IUserDocument;
-  UserRole: IUserRoleDocument;
-}
-
-export interface SchemaMapOptions {
-  constants?: IConstants;
-  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 = options.schemas ?? {
-    EmailToken: createEmailTokenSchema(undefined, options?.constants),
-    Mnemonic: createMnemonicSchema(undefined, options?.constants),
-    Role: createRoleSchema(undefined, options?.constants),
-    UsedDirectLoginToken: createUsedDirectLoginTokenSchema(undefined, options?.constants),
-    User: createUserSchema(undefined, undefined, undefined, undefined, undefined, undefined, options?.constants),
-    UserRole: createUserRoleSchema(undefined, options?.constants),
-  };
-  const { 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 unknown as SchemaMap<BaseModelDocs>;
-}

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

@@ -1,44 +0,0 @@
-import { Schema, Types } from '@digitaldefiance/mongoose-types';
-import { IUsedDirectLoginTokenBase } from '@digitaldefiance/suite-core-lib';
-import { IUsedDirectLoginTokenDocument } from '../documents/used-direct-login-token';
-import { BaseModelName } from '../enumerations';
-import { IConstants } from '../interfaces';
-
-/**
- * Configuration options for creating a used direct login token schema
- */
-export interface UsedDirectLoginTokenSchemaOptions<
-  TModelName extends string = BaseModelName,
-> {
-  /** Model name for user reference */
-  userModelName?: TModelName;
-  /** ID type for references */
-  idType?: any;
-}
-
-/**
- * Factory function to create an extensible used direct login token schema
- */
-export function createUsedDirectLoginTokenSchema<
-  TModelName extends string = BaseModelName,
-  TConstants extends IConstants = IConstants
->(
-  options: UsedDirectLoginTokenSchemaOptions<TModelName> = {},
-  constants?: TConstants,
-): Schema {
-  const { userModelName = BaseModelName.User as TModelName, idType = Schema.Types.ObjectId } = options;
-
-  const definition = {
-    userId: { type: idType, required: true, ref: userModelName },
-    token: { type: String, required: true },
-  };
-
-  const schema = new Schema(definition);
-  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

@@ -1,81 +0,0 @@
-import { Schema, Types } from '@digitaldefiance/mongoose-types';
-import { IUserRoleBase } from '@digitaldefiance/suite-core-lib';
-import { IUserRoleDocument } from '../documents/user-role';
-import { BaseModelName } from '../enumerations';
-import { IConstants } from '../interfaces';
-
-/**
- * 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;
-  /** ID type for references */
-  idType?: any;
-}
-
-/**
- * Factory function to create an extensible user-role schema
- */
-export function createUserRoleSchema<
-  TModelName extends string = BaseModelName,
-  TConstants extends IConstants = IConstants
->(
-  options: UserRoleSchemaOptions<TModelName> = {},
-  constants?: TConstants
-): Schema {
-  const {
-    userModelName = BaseModelName.User as TModelName,
-    roleModelName = BaseModelName.Role as TModelName,
-    idType = Schema.Types.ObjectId,
-  } = options;
-
-  const definition = {
-    userId: {
-      type: idType,
-      ref: userModelName,
-      required: true,
-    },
-    roleId: {
-      type: idType,
-      ref: roleModelName,
-      required: true,
-    },
-    createdBy: {
-      type: idType,
-      ref: userModelName,
-      required: true,
-      immutable: true,
-    },
-    updatedBy: {
-      type: idType,
-      ref: userModelName,
-      required: true,
-    },
-    deletedAt: {
-      type: Date,
-      optional: true,
-    },
-    deletedBy: {
-      type: idType,
-      ref: userModelName,
-      required: false,
-      optional: true,
-    },
-  };
-
-  const schema = new Schema(definition, { 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

@@ -1,224 +0,0 @@
-import { Schema, Types } from '@digitaldefiance/mongoose-types';
-import { isValidTimezone, LanguageCodes } from '@digitaldefiance/i18n-lib';
-import {
-  AccountStatus,
-  getSuiteCoreTranslation,
-  IUserBase,
-  SuiteCoreStringKey,
-} from '@digitaldefiance/suite-core-lib';
-import { codes } from 'currency-codes';
-import validator from 'validator';
-import { LocalhostConstants as AppConstants } from '../constants';
-import { IUserDocument } from '../documents/user';
-import { BaseModelName } from '../enumerations';
-import { IConstants } from '../interfaces/constants';
-
-export function createUserSchema<T extends IConstants = IConstants>(
-  usernameValidationMessage?: () => string,
-  emailValidationMessage?: () => string,
-  timezoneValidationMessage?: () => string,
-  currencyValidationMessage?: () => string,
-  supportedLanguages?: readonly string[],
-  idType: any = Schema.Types.ObjectId,
-  constants: T = AppConstants as T,
-): Schema {
-  const definition = {
-    /**
-     * 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 },
-              )),
-        },
-      },
-      currency: {
-        type: String,
-        required: true,
-        default: 'USD',
-        validate: {
-          validator: function (v: string) {
-            return codes().includes(v);
-          },
-          message: currencyValidationMessage || ((props: { value: string }) =>
-            getSuiteCoreTranslation(
-              SuiteCoreStringKey.Common_NotValidCurrencyTemplate,
-              { currency: props.value },
-            )),
-        }
-      },
-      /**
-       * The language of the site for the user
-       */
-      siteLanguage: {
-        type: String,
-        enum: supportedLanguages || Object.values(LanguageCodes),
-        default: LanguageCodes.EN_US,
-        required: true,
-      },
-      /**
-       * Whether the user prefers dark mode
-       */
-      darkMode: {
-        type: Boolean,
-        default: false,
-        required: true,
-      },
-      /**
-       * Whether to enable direct challenge login for the user
-       */
-      directChallenge: {
-        type: Boolean,
-        default: true,
-        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: idType,
-        ref: BaseModelName.User,
-        required: true,
-        immutable: true,
-      },
-      /**
-       * The user who last updated the user.
-       */
-      updatedBy: {
-        type: idType,
-        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: idType,
-        ref: BaseModelName.User,
-        optional: true,
-      },
-      /**
-       * Reference to the mnemonic document
-       */
-      mnemonicId: {
-        type: idType,
-        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: [],
-      },
-    };
-
-  return new Schema(definition, { timestamps: true });
-}
-
-/**
- * Default user schema with base configuration
- */
-export const UserSchema = createUserSchema();