@digitaldefiance/node-express-suite 3.6.20 → 3.6.21

package/src/schemas/schema.ts

@@ -0,0 +1,164 @@
+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.d.ts

@@ -1,37 +1,14 @@
-import { Schema } from '@digitaldefiance/mongoose-types';
+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 declare function createUsedDirectLoginTokenSchema<TModelName extends string = BaseModelName, TConstants extends IConstants = IConstants>(options?: UsedDirectLoginTokenSchemaOptions<TModelName>, _constants?: TConstants): Schema;
-/**
- * Default used direct login token schema with base configuration
- */
-export declare const UsedDirectLoginTokenSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}> & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}>;
-//# sourceMappingURL=used-direct-login-token.d.ts.map
+import { UsedDirectLoginTokenSchemaOptions } from './used-direct-login-token';
+
+export function createUsedDirectLoginTokenSchema<
+  TModelName extends string = BaseModelName,
+  TConstants extends IConstants = IConstants,
+  I extends Types.ObjectId | string = Types.ObjectId
+>(options?: UsedDirectLoginTokenSchemaOptions<TModelName>, constants?: TConstants): Schema<IUsedDirectLoginTokenBase<I>, IUsedDirectLoginTokenDocument<I>>;
+
+export const UsedDirectLoginTokenSchema: Schema<IUsedDirectLoginTokenBase<Types.ObjectId>, IUsedDirectLoginTokenDocument<Types.ObjectId>>;

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

@@ -0,0 +1,45 @@
+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.d.ts

@@ -1,39 +1,14 @@
-import { Schema } from '@digitaldefiance/mongoose-types';
+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 declare function createUserRoleSchema<TModelName extends string = BaseModelName, TConstants extends IConstants = IConstants>(options?: UserRoleSchemaOptions<TModelName>, _constants?: TConstants): Schema;
-/**
- * Default user-role schema with base configuration
- */
-export declare const UserRoleSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}> & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}>;
-//# sourceMappingURL=user-role.d.ts.map
+import { UserRoleSchemaOptions } from './user-role';
+
+export function createUserRoleSchema<
+  TModelName extends string = BaseModelName,
+  TConstants extends IConstants = IConstants,
+  I extends string | Types.ObjectId = Types.ObjectId
+>(options?: UserRoleSchemaOptions<TModelName>, constants?: TConstants): Schema<IUserRoleBase<I, Date>, IUserRoleDocument<I>>;
+
+export const UserRoleSchema: Schema<IUserRoleBase<Types.ObjectId, Date>, IUserRoleDocument<Types.ObjectId>>;

package/src/schemas/user-role.ts

@@ -0,0 +1,79 @@
+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.d.ts

@@ -1,24 +1,19 @@
-import { Schema } from '@digitaldefiance/mongoose-types';
+import { Schema, Types } from '@digitaldefiance/mongoose-types';
+import { AccountStatus, IUserBase } from '@digitaldefiance/suite-core-lib';
+import { IUserDocument } from '../documents/user';
 import { IConstants } from '../interfaces/constants';
-export declare function createUserSchema<T extends IConstants = IConstants>(usernameValidationMessage?: () => string, emailValidationMessage?: () => string, timezoneValidationMessage?: () => string, currencyValidationMessage?: () => string, supportedLanguages?: readonly string[], idType?: any, constants?: T): Schema;
-/**
- * Default user schema with base configuration
- */
-export declare const UserSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<{
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    [x: string]: unknown;
-}> & Required<{
-    _id: unknown;
-}> & {
-    __v: number;
-}>;
-//# sourceMappingURL=user.d.ts.map
+
+export function createUserSchema<
+  T extends IConstants = IConstants,
+  I extends string | Types.ObjectId = Types.ObjectId
+>(
+  usernameValidationMessage?: () => string,
+  emailValidationMessage?: () => string,
+  timezoneValidationMessage?: () => string,
+  currencyValidationMessage?: () => string,
+  supportedLanguages?: readonly string[],
+  idType?: any,
+  constants?: T,
+): Schema<IUserBase<I, Date, string, AccountStatus>, IUserDocument<string, I>>;
+
+export const UserSchema: Schema<IUserBase<Types.ObjectId, Date, string, AccountStatus>, IUserDocument<string, Types.ObjectId>>;

package/src/schemas/user.ts

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