@digitaldefiance/node-express-suite 3.6.21 → 3.6.24

package/src/schemas/role.ts

@@ -1,137 +0,0 @@
-import {
-  CallbackWithoutResultAndOptionalError,
-  Schema,
-} from '@digitaldefiance/mongoose-types';
-import {
-  Role,
-  SuiteCoreStringKey,
-  TranslatableSuiteError,
-} from '@digitaldefiance/suite-core-lib';
-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) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    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,164 +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 { IConstants } from '../interfaces';
-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';
-
-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,45 +0,0 @@
-import { Schema } from '@digitaldefiance/mongoose-types';
-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,79 +0,0 @@
-import { Schema } from '@digitaldefiance/mongoose-types';
-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 { isValidTimezone, LanguageCodes } from '@digitaldefiance/i18n-lib';
-import { Schema } from '@digitaldefiance/mongoose-types';
-import {
-  AccountStatus,
-  getSuiteCoreTranslation,
-  SuiteCoreStringKey,
-} from '@digitaldefiance/suite-core-lib';
-import { codes } from 'currency-codes';
-import validator from 'validator';
-import { LocalhostConstants as AppConstants } from '../constants';
-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();