@digitaldefiance/node-express-suite 1.0.23 → 1.0.24

package/src/schemas/schema.ts

@@ -1,140 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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();