@digitaldefiance/node-express-suite 3.6.6 → 3.6.8

package/src/routing/route-builder.ts

@@ -0,0 +1,126 @@
+import { RequestHandler } from 'express';
+import { ValidationChain } from 'express-validator';
+import { z } from 'zod';
+
+export class RouteBuilder<TLanguage extends string = string> {
+  private config: {
+    method?: 'get' | 'post' | 'put' | 'delete' | 'patch';
+    path?: string;
+    handler?: Function;
+    auth?: boolean;
+    cryptoAuth?: boolean;
+    validation?: ValidationChain[] | ((lang: TLanguage) => ValidationChain[]);
+    schema?: z.ZodSchema;
+    middleware?: RequestHandler[];
+    transaction?: boolean;
+    transactionTimeout?: number;
+    rawJson?: boolean;
+  } = {};
+
+  static create<T extends string = string>(): RouteBuilder<T> {
+    return new RouteBuilder<T>();
+  }
+
+  get(path: string): this {
+    this.config.method = 'get';
+    this.config.path = path;
+    return this;
+  }
+
+  post(path: string): this {
+    this.config.method = 'post';
+    this.config.path = path;
+    return this;
+  }
+
+  put(path: string): this {
+    this.config.method = 'put';
+    this.config.path = path;
+    return this;
+  }
+
+  delete(path: string): this {
+    this.config.method = 'delete';
+    this.config.path = path;
+    return this;
+  }
+
+  patch(path: string): this {
+    this.config.method = 'patch';
+    this.config.path = path;
+    return this;
+  }
+
+  auth(enabled = true): this {
+    this.config.auth = enabled;
+    return this;
+  }
+
+  cryptoAuth(enabled = true): this {
+    this.config.cryptoAuth = enabled;
+    return this;
+  }
+
+  validate(validation: ValidationChain[] | ((lang: TLanguage) => ValidationChain[])): this {
+    this.config.validation = validation;
+    return this;
+  }
+
+  schema(schema: z.ZodSchema): this {
+    this.config.schema = schema;
+    return this;
+  }
+
+  use(...middleware: RequestHandler[]): this {
+    this.config.middleware = [...(this.config.middleware || []), ...middleware];
+    return this;
+  }
+
+  transaction(enabled = true, timeout?: number): this {
+    this.config.transaction = enabled;
+    if (timeout) this.config.transactionTimeout = timeout;
+    return this;
+  }
+
+  rawJson(enabled = true): this {
+    this.config.rawJson = enabled;
+    return this;
+  }
+
+  handle(handler: Function): RouteConfig<TLanguage> {
+    if (!this.config.method || !this.config.path) {
+      throw new Error('Method and path must be set before calling handle()');
+    }
+    return {
+      method: this.config.method,
+      path: this.config.path,
+      handler,
+      options: {
+        auth: this.config.auth,
+        cryptoAuth: this.config.cryptoAuth,
+        validation: this.config.validation,
+        schema: this.config.schema,
+        middleware: this.config.middleware,
+        transaction: this.config.transaction,
+        transactionTimeout: this.config.transactionTimeout,
+        rawJson: this.config.rawJson,
+      },
+    };
+  }
+}
+
+export interface RouteConfig<TLanguage extends string = string> {
+  method: 'get' | 'post' | 'put' | 'delete' | 'patch';
+  path: string;
+  handler: Function;
+  options: {
+    auth?: boolean;
+    cryptoAuth?: boolean;
+    validation?: ValidationChain[] | ((lang: TLanguage) => ValidationChain[]);
+    schema?: z.ZodSchema;
+    middleware?: RequestHandler[];
+    transaction?: boolean;
+    transactionTimeout?: number;
+    rawJson?: boolean;
+  };
+}

package/src/schemas/email-token.d.ts

@@ -1,49 +1,15 @@
-import { Schema } from '@digitaldefiance/mongoose-types';
-import { EmailTokenType } from '@digitaldefiance/suite-core-lib';
+import { Schema, Types } from '@digitaldefiance/mongoose-types';
+import { EmailTokenType, IEmailTokenBase } from '@digitaldefiance/suite-core-lib';
+import { IEmailTokenDocument } from '../documents/email-token';
 import { BaseModelName } from '../enumerations';
 import { IConstants } from '../interfaces';
-/**
- * Configuration options for creating an email token schema
- */
-export interface EmailTokenSchemaOptions<TTokenType extends string = EmailTokenType, TModelName extends string = BaseModelName, TConstants extends IConstants = IConstants> {
-    /** Token type enum values to use */
-    tokenTypeEnum?: TTokenType[];
-    /** Model name for user reference */
-    userModelName?: TModelName;
-    /** Token expiration time (default: '1d') */
-    expiresIn?: string;
-    /** Custom email validator function */
-    emailValidator?: (v: string) => boolean;
-    /** Custom validation error message function */
-    validationMessage?: (props: {
-        value: string;
-    }) => string;
-    constants?: TConstants;
-    /** ID type for references */
-    idType?: any;
-}
-/**
- * Factory function to create an extensible email token schema
- */
-export declare function createEmailTokenSchema<TTokenType extends string = EmailTokenType, TModelName extends string = BaseModelName, TConstants extends IConstants = IConstants>(options?: EmailTokenSchemaOptions<TTokenType, TModelName>, constants?: TConstants): Schema;
-/**
- * Default email token schema with base configuration
- */
-export declare const EmailTokenSchema: 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=email-token.d.ts.map
+import { EmailTokenSchemaOptions } from './email-token';
+
+export function createEmailTokenSchema<
+  TTokenType extends string = EmailTokenType,
+  TModelName extends string = BaseModelName,
+  TConstants extends IConstants = IConstants,
+  I extends Types.ObjectId | string = Types.ObjectId
+>(options?: EmailTokenSchemaOptions<TTokenType, TModelName>, constants?: TConstants): Schema<IEmailTokenBase<I, Date, TTokenType>, IEmailTokenDocument<I>>;
+
+export const EmailTokenSchema: Schema<IEmailTokenBase<Types.ObjectId, Date, EmailTokenType>, IEmailTokenDocument<Types.ObjectId>>;

package/src/schemas/email-token.ts

@@ -0,0 +1,97 @@
+import { Schema, Types } from '@digitaldefiance/mongoose-types';
+import {
+  EmailTokenType,
+  getSuiteCoreTranslation,
+  IEmailTokenBase,
+  SuiteCoreStringKey,
+} from '@digitaldefiance/suite-core-lib';
+import validator from 'validator';
+import { IEmailTokenDocument } from '../documents/email-token';
+import { BaseModelName } from '../enumerations';
+import { IConstants } from '../interfaces';
+
+/**
+ * Configuration options for creating an email token schema
+ */
+export interface EmailTokenSchemaOptions<
+  TTokenType extends string = EmailTokenType,
+  TModelName extends string = BaseModelName,
+  TConstants extends IConstants = IConstants,
+> {
+  /** Token type enum values to use */
+  tokenTypeEnum?: TTokenType[];
+  /** Model name for user reference */
+  userModelName?: TModelName;
+  /** Token expiration time (default: '1d') */
+  expiresIn?: string;
+  /** Custom email validator function */
+  emailValidator?: (v: string) => boolean;
+  /** Custom validation error message function */
+  validationMessage?: (props: { value: string }) => string;
+  constants?: TConstants;
+  /** ID type for references */
+  idType?: any;
+}
+
+/**
+ * Factory function to create an extensible email token schema
+ */
+export function createEmailTokenSchema<
+  TTokenType extends string = EmailTokenType,
+  TModelName extends string = BaseModelName,
+  TConstants extends IConstants = IConstants
+>(
+  options: EmailTokenSchemaOptions<TTokenType, TModelName> = {},
+  constants?: TConstants,
+): Schema {
+  const {
+    tokenTypeEnum = Object.values(EmailTokenType) as TTokenType[],
+    userModelName = BaseModelName.User as TModelName,
+    expiresIn = '1d',
+    validationMessage = (props: { value: string }) =>
+      getSuiteCoreTranslation(SuiteCoreStringKey.Error_InvalidEmailTemplate, {
+        email: props.value,
+      }),
+    idType = Schema.Types.ObjectId,
+  } = options;
+
+  const definition = {
+    userId: {
+      type: idType,
+      required: true,
+      ref: userModelName,
+      immutable: true,
+    },
+    type: {
+      type: String,
+      enum: tokenTypeEnum,
+      required: true,
+      immutable: true,
+    },
+    token: { type: String, required: true, immutable: true, unique: true },
+    email: {
+      type: String,
+      required: true,
+      immutable: true,
+      validate: {
+        validator: (v: string) => validator.isEmail(v),
+        message: validationMessage,
+      },
+    },
+    lastSent: { type: Date, required: false },
+    expiresAt: {
+      type: Date,
+      default: Date.now,
+      index: { expires: expiresIn },
+    },
+  };
+
+  const schema = new Schema(definition, { timestamps: true });
+  schema.index({ userId: 1, email: 1, type: 1 }, { unique: true });
+  return schema;
+}
+
+/**
+ * Default email token schema with base configuration
+ */
+export const EmailTokenSchema = createEmailTokenSchema();

package/src/schemas/{index.d.ts → index.ts}

@@ -5,4 +5,3 @@ export * from './schema';
 export * from './used-direct-login-token';
 export * from './user';
 export * from './user-role';
-//# sourceMappingURL=index.d.ts.map

package/src/schemas/mnemonic.d.ts

@@ -1,27 +1,11 @@
-import { Schema } from '@digitaldefiance/mongoose-types';
+import { Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IMnemonicBase } from '@digitaldefiance/suite-core-lib';
+import { IMnemonicDocument } from '../documents/mnemonic';
 import { IConstants } from '../interfaces/constants';
-/**
- * Create a mnemonic schema with custom or default constants
- */
-export declare function createMnemonicSchema<T extends IConstants = IConstants>(validationMessage?: () => string, constants?: T): Schema;
-/**
- * Default mnemonic schema using AppConstants
- */
-export declare const MnemonicSchema: 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=mnemonic.d.ts.map
+
+export function createMnemonicSchema<
+  T extends IConstants = IConstants,
+  I extends string | Types.ObjectId = Types.ObjectId
+>(validationMessage?: () => string, constants?: T): Schema<IMnemonicBase<I>, IMnemonicDocument<I>>;
+
+export const MnemonicSchema: Schema<IMnemonicBase<Types.ObjectId>, IMnemonicDocument<Types.ObjectId>>;

package/src/schemas/mnemonic.ts

@@ -0,0 +1,39 @@
+import { Schema, Types } from '@digitaldefiance/mongoose-types';
+import {
+  getSuiteCoreTranslation,
+  IMnemonicBase,
+  SuiteCoreStringKey,
+} from '@digitaldefiance/suite-core-lib';
+import { LocalhostConstants 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>(
+  validationMessage?: () => string,
+  constants: T = AppConstants as T,
+): Schema {
+  const definition = {
+    hmac: {
+      type: String,
+      required: true,
+      unique: true,
+      index: true,
+      validate: {
+        validator: (v: string) => constants.MnemonicHmacRegex.test(v),
+        message:
+          validationMessage ||
+          (() =>
+            getSuiteCoreTranslation(SuiteCoreStringKey.Validation_HmacRegex)),
+      },
+    },
+  };
+  return new Schema(definition);
+}
+
+/**
+ * Default mnemonic schema using AppConstants
+ */
+export const MnemonicSchema = createMnemonicSchema();

package/src/schemas/role.d.ts

@@ -1,42 +1,15 @@
-import { CallbackWithoutResultAndOptionalError, Schema } from '@digitaldefiance/mongoose-types';
-import { Role } from '@digitaldefiance/suite-core-lib';
+import { Schema, Types } from '@digitaldefiance/mongoose-types';
+import { IRoleBase, Role } 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 declare function createRoleSchema<TRole extends string = Role, TModelName extends string = BaseModelName, TConstants extends IConstants = IConstants>(options?: RoleSchemaOptions<TRole, TModelName>, constants?: TConstants): Schema;
-/**
- * Default role schema with base configuration
- */
-export declare const RoleSchema: 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=role.d.ts.map
+import { RoleSchemaOptions } from './role';
+
+export function createRoleSchema<
+  TRole extends string = Role,
+  TModelName extends string = BaseModelName,
+  TConstants extends IConstants = IConstants,
+  I extends Types.ObjectId | string = Types.ObjectId
+>(options?: RoleSchemaOptions<TRole, TModelName>, constants?: TConstants): Schema<IRoleBase<I, Date>, IRoleDocument<I>>;
+
+export const RoleSchema: Schema<IRoleBase<Types.ObjectId, Date>, IRoleDocument<Types.ObjectId>>;

package/src/schemas/role.ts

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