@digitaldefiance/node-express-suite 1.0.21 → 1.0.23

package/src/models/mnemonic.ts

@@ -0,0 +1,19 @@
+import { Connection, Schema } from 'mongoose';
+import { IMnemonicDocument } from '../documents/mnemonic';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { MnemonicSchema } from '../schemas/mnemonic';
+
+export function MnemonicModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+>(
+  connection: Connection,
+  modelName: TModelName = BaseModelName.Mnemonic as TModelName,
+  collection: TCollection = SchemaCollection.Mnemonic as TCollection,
+  schema: Schema<IMnemonicDocument> = MnemonicSchema,
+) {
+  return connection.model<IMnemonicDocument>(modelName, schema, collection);
+}
+
+export default MnemonicModel;

package/src/models/role.ts

@@ -0,0 +1,19 @@
+import { Connection, Schema } from 'mongoose';
+import { IRoleDocument } from '../documents/role';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { RoleSchema } from '../schemas/role';
+
+export function RoleModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+>(
+  connection: Connection,
+  modelName: TModelName = BaseModelName.Role as TModelName,
+  collection: TCollection = SchemaCollection.Role as TCollection,
+  schema: Schema<IRoleDocument> = RoleSchema,
+) {
+  return connection.model<IRoleDocument>(modelName, schema, collection);
+}
+
+export default RoleModel;

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

@@ -0,0 +1,23 @@
+import { Connection, Schema } from 'mongoose';
+import { IUsedDirectLoginTokenDocument } from '../documents/used-direct-login-token';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { UsedDirectLoginTokenSchema } from '../schemas/used-direct-login-token';
+
+export function UsedDirectLoginTokenModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+>(
+  connection: Connection,
+  modelName: TModelName = BaseModelName.UsedDirectLoginToken as TModelName,
+  collection: TCollection = SchemaCollection.UsedDirectLoginToken as TCollection,
+  schema: Schema<IUsedDirectLoginTokenDocument> = UsedDirectLoginTokenSchema,
+) {
+  return connection.model<IUsedDirectLoginTokenDocument>(
+    modelName,
+    schema,
+    collection,
+  );
+}
+
+export default UsedDirectLoginTokenModel;

package/src/models/user-role.ts

@@ -0,0 +1,17 @@
+import { Connection, Model, Schema } from 'mongoose';
+import { IUserRoleDocument } from '../documents/user-role';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { UserRoleSchema } from '../schemas/user-role';
+
+export default function UserRoleModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+>(
+  connection: Connection,
+  modelName: TModelName = BaseModelName.UserRole as TModelName,
+  collection: TCollection = SchemaCollection.UserRole as TCollection,
+  schema: Schema<IUserRoleDocument> = UserRoleSchema,
+): Model<IUserRoleDocument> {
+  return connection.model<IUserRoleDocument>(modelName, schema, collection);
+}

package/src/models/user.ts

@@ -0,0 +1,19 @@
+import { Connection, Model, Schema } from 'mongoose';
+import { IUserDocument } from '../documents/user';
+import { BaseModelName } from '../enumerations';
+import { SchemaCollection } from '../enumerations/schema-collection';
+import { UserSchema } from '../schemas/user';
+
+export function UserModel<
+  TModelName extends string = BaseModelName,
+  TCollection extends string = SchemaCollection,
+>(
+  connection: Connection,
+  modelName: TModelName = BaseModelName.User as TModelName,
+  collection: TCollection = SchemaCollection.User as TCollection,
+  schema: Schema<IUserDocument> = UserSchema,
+): Model<IUserDocument> {
+  return connection.model<IUserDocument>(modelName, schema, collection);
+}
+
+export default UserModel;

package/src/registry/email-service-registry.ts

@@ -0,0 +1,24 @@
+import {
+  SuiteCoreStringKey,
+  TranslatableSuiteError,
+} from '@digitaldefiance/suite-core-lib';
+import { IEmailService } from '../interfaces/email-service';
+
+class EmailServiceRegistry {
+  private service?: IEmailService;
+
+  setService(service: IEmailService): void {
+    this.service = service;
+  }
+
+  getService(): IEmailService {
+    if (!this.service) {
+      throw new TranslatableSuiteError(
+        SuiteCoreStringKey.Error_EmailService_NotConfigured,
+      );
+    }
+    return this.service;
+  }
+}
+
+export const emailServiceRegistry = new EmailServiceRegistry();

package/{dist/registry/index.d.ts → src/registry/index.ts}

@@ -1,2 +1 @@
 export { emailServiceRegistry } from './email-service-registry';
-//# sourceMappingURL=index.d.ts.map

package/src/routers/api.ts

@@ -0,0 +1,151 @@
+import { IECIESConfig } from '@digitaldefiance/ecies-lib';
+import { ECIESService } from '@digitaldefiance/node-ecies-lib';
+import {
+  ITokenRole,
+  ITokenUser,
+  IUserBase,
+} from '@digitaldefiance/suite-core-lib';
+import { UserController } from '../controllers/user';
+import { IApplication } from '../interfaces/application';
+import { IEmailService } from '../interfaces/email-service';
+import { emailServiceRegistry } from '../registry';
+import { BackupCodeService } from '../services/backup-code';
+import { JwtService } from '../services/jwt';
+import { KeyWrappingService } from '../services/key-wrapping';
+import { RoleService } from '../services/role';
+import { UserService } from '../services/user';
+import { BaseRouter } from './base';
+import { Types } from 'mongoose';
+import { IBaseDocument } from '../documents';
+import { Environment } from '../environment';
+import { IConstants } from '../interfaces';
+
+/**
+ * Router for the API
+ */
+export class ApiRouter<
+  I extends Types.ObjectId | string,
+  D extends Date,
+  S extends string,
+  A extends string,
+  TUser extends IUserBase<I, D, S, A> = IUserBase<I, D, S, A>,
+  TTokenRole extends ITokenRole<I, D> = ITokenRole<I, D>,
+  TBaseDocument extends IBaseDocument<any, Types.ObjectId> = IBaseDocument<any, Types.ObjectId>,
+  TTokenUser extends ITokenUser = ITokenUser,
+  TConstants extends IConstants = IConstants,
+  TEnvironment extends Environment = Environment,
+  TApplication extends IApplication<any, Types.ObjectId, TBaseDocument, TEnvironment, TConstants> = IApplication<any, Types.ObjectId, TBaseDocument, TEnvironment, TConstants>,
+> extends BaseRouter<TApplication> {
+  private readonly userController: UserController<
+    I,
+    D,
+    S,
+    A,
+    TUser,
+    TTokenRole,
+    TTokenUser,
+    TApplication
+  >;
+  private readonly jwtService: JwtService<
+    I,
+    D,
+    TTokenRole,
+    TTokenUser,
+    TApplication
+  >;
+  private readonly emailService: IEmailService;
+  private readonly userService: UserService<
+    any,
+    I,
+    D,
+    S,
+    A,
+    TEnvironment,
+    TConstants,
+    TBaseDocument,
+    TUser,
+    TTokenRole,
+    TApplication
+  >;
+  private readonly roleService: RoleService<I, D, TTokenRole>;
+  private readonly keyWrappingService: KeyWrappingService;
+  private readonly eciesService: ECIESService;
+  private readonly backupCodeService: BackupCodeService<
+    I,
+    D,
+    TTokenRole,
+    TApplication
+  >;
+  /**
+   * Constructor for the API router
+   * @param connection The mongoose connection
+   * @param getModel The function to get a mongoose model by name
+   */
+  constructor(application: TApplication) {
+    super(application);
+    this.jwtService = new JwtService(application);
+    this.roleService = new RoleService<I, D, TTokenRole>(application);
+    this.emailService = emailServiceRegistry.getService();
+    this.keyWrappingService = new KeyWrappingService();
+    const config: IECIESConfig = {
+      curveName: application.constants.ECIES.CURVE_NAME,
+      primaryKeyDerivationPath:
+        application.constants.ECIES.PRIMARY_KEY_DERIVATION_PATH,
+      mnemonicStrength: application.constants.ECIES.MNEMONIC_STRENGTH,
+      symmetricAlgorithm:
+        application.constants.ECIES.SYMMETRIC_ALGORITHM_CONFIGURATION,
+      symmetricKeyBits: application.constants.ECIES.SYMMETRIC.KEY_BITS,
+      symmetricKeyMode: application.constants.ECIES.SYMMETRIC.MODE,
+    };
+    this.eciesService = new ECIESService(config);
+    this.backupCodeService = new BackupCodeService<
+      I,
+      D,
+      TTokenRole,
+      TApplication
+    >(
+      application,
+      this.eciesService,
+      this.keyWrappingService,
+      this.roleService,
+    );
+
+    this.userService = new UserService<
+      any,
+      I,
+      D,
+      S,
+      A,
+      TEnvironment,
+      TConstants,
+      TBaseDocument,
+      TUser,
+      TTokenRole,
+      TApplication
+    >(
+      application,
+      this.roleService,
+      this.emailService,
+      this.keyWrappingService,
+      this.backupCodeService,
+    );
+    this.userController = new UserController<
+      I,
+      D,
+      S,
+      A,
+      TUser,
+      TTokenRole,
+      TTokenUser,
+      TApplication
+    >(
+      application,
+      this.jwtService,
+      this.userService,
+      this.backupCodeService,
+      this.roleService,
+      this.eciesService,
+    );
+    this.router.use('/user', this.userController.router);
+  }
+}

package/src/routers/app.ts

@@ -0,0 +1,258 @@
+import {
+  CoreI18nComponentId,
+  PluginTranslatableGenericError,
+} from '@digitaldefiance/i18n-lib';
+import {
+  getSuiteCoreTranslation,
+  SuiteCoreStringKey,
+  TranslatableSuiteError,
+} from '@digitaldefiance/suite-core-lib';
+import ejs from 'ejs';
+import {
+  Application,
+  static as expressStatic,
+  Request,
+  Response,
+} from 'express';
+import { existsSync, readdirSync } from 'fs';
+import { basename, join, resolve, sep } from 'path';
+import { IApplication } from '../interfaces/application';
+import { debugLog, handleError, sendApiMessageResponse } from '../utils';
+import { BaseRouter } from './base';
+import { Types } from 'mongoose';
+import { IBaseDocument } from '../documents';
+import { Environment } from '../environment';
+import { IConstants } from '../interfaces';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function keepEJS() {
+  ejs.compile(''); // Compile an empty string, doesn't generate anything meaningful
+}
+
+/**
+ * Application router
+ * Sets up the API and static file serving
+ */
+export class AppRouter<TApplication extends IApplication<any, Types.ObjectId, IBaseDocument<any, Types.ObjectId>, Environment, IConstants> = IApplication<any, Types.ObjectId, IBaseDocument<any, Types.ObjectId>, Environment, IConstants>> {
+  private readonly viewsPath: string;
+  private readonly indexPath: string;
+  private readonly assetsDir: string;
+  private readonly reactDistDir: string;
+
+  private readonly apiRouter: BaseRouter<TApplication>;
+  private readonly application: TApplication;
+
+  constructor(apiRouter: BaseRouter<TApplication>) {
+    this.application = apiRouter.application;
+    this.apiRouter = apiRouter;
+
+    // Validate paths don't contain traversal sequences
+    if (
+      this.application.environment.apiDistDir.includes('..') ||
+      this.application.environment.reactDistDir.includes('..')
+    ) {
+      throw new TranslatableSuiteError(SuiteCoreStringKey.Error_InvalidPathContainsParentDirectoryReference);
+    }
+
+    const normalizedApiDistDir = resolve(this.application.environment.apiDistDir);
+    const viewsPath = resolve(normalizedApiDistDir, 'views');
+    if (
+      !viewsPath.startsWith(normalizedApiDistDir + sep) &&
+      viewsPath !== normalizedApiDistDir
+    ) {
+      throw new TranslatableSuiteError(SuiteCoreStringKey.Error_InvalidViewsPathEscapesBaseDirectory);
+    }
+    this.viewsPath = viewsPath;
+
+    const normalizedReactDistDir = resolve(
+      this.application.environment.reactDistDir,
+    );
+    this.reactDistDir = normalizedReactDistDir;
+    
+    const indexPath = resolve(normalizedReactDistDir, 'index.html');
+    if (
+      !indexPath.startsWith(normalizedReactDistDir + sep) &&
+      indexPath !== normalizedReactDistDir
+    ) {
+      throw new TranslatableSuiteError(SuiteCoreStringKey.Error_InvalidIndexPathEscapesBaseDirectory);
+    }
+    this.indexPath = indexPath;
+
+    const assetsPath = resolve(normalizedReactDistDir, 'assets');
+    if (
+      !assetsPath.startsWith(normalizedReactDistDir + sep) &&
+      assetsPath !== normalizedReactDistDir
+    ) {
+      throw new TranslatableSuiteError(SuiteCoreStringKey.Error_InvalidAssetsPathEscapesBaseDirectory);
+    }
+    this.assetsDir = assetsPath;
+  }
+
+  public getAssetFilename(
+    assetDir: string,
+    pattern: RegExp,
+  ): string | undefined {
+    try {
+      // Prevent path traversal by validating assetDir is within expected directory
+      // amazonq-ignore-next-line already addressed
+      if (
+        // amazonq-ignore-next-line
+        assetDir.includes('..') ||
+        !assetDir.startsWith(this.reactDistDir)
+      ) {
+        return undefined;
+      }
+      const files = readdirSync(assetDir, 'utf8');
+      return files.find((f) => pattern.test(f));
+    } catch {
+      return undefined;
+    }
+  }
+
+  /**
+   * Initialize the application router
+   * @param app Express application
+   * @param debugRoutes Whether to log routes
+   */
+  public init(app: Application) {
+    if (
+      basename(this.apiRouter.application.environment.reactDistDir) !== 'dist')
+   {
+      throw new PluginTranslatableGenericError<SuiteCoreStringKey, string>(
+        CoreI18nComponentId,
+        SuiteCoreStringKey.Error_AppDoesNotAppearToBeRunningWithinDistTemplate,
+        { dir: this.apiRouter.application.environment.reactDistDir },
+      );
+    }
+    if (!existsSync(this.indexPath)) {
+      throw new PluginTranslatableGenericError<SuiteCoreStringKey, string>(
+        CoreI18nComponentId,
+        SuiteCoreStringKey.Error_IndexFileNotFoundTemplate,
+        { path: this.indexPath },
+      );
+    }
+
+    if (this.apiRouter.application.environment.debug) {
+      app.use((req, res, next) => {
+        const port =
+          (req.socket.localPort === 443 && req.protocol === 'https') ||
+          (req.socket.localPort === 80 && req.protocol === 'http')
+            ? ''
+            : `:${req.socket.localPort}`;
+        // amazonq-ignore-next-line
+        console.log(
+          getSuiteCoreTranslation(SuiteCoreStringKey.Admin_ServingRoute) +
+            ': method=' +
+            req.method +
+            ' url=' +
+            req.protocol +
+            '://' +
+            req.hostname +
+            port +
+            (req.url || '').replace(/[\r\n]/g, ' '),
+        );
+        next();
+      });
+    }
+
+    app.use('/api', this.apiRouter.router);
+
+    app.set('views', this.viewsPath);
+    app.set('view engine', 'ejs');
+
+    // Serve static files from the React app build directory (validated in constructor)
+    app.use('/assets', expressStatic(this.assetsDir));
+    const serveStaticWithLogging = expressStatic(this.reactDistDir);
+    app.use('/static/js', expressStatic(this.reactDistDir));
+    app.use((req, res, next) => {
+      if (req.url === '/') {
+        next();
+        return;
+      }
+      debugLog(
+        this.apiRouter.application.environment.debug,
+        'log',
+        `Trying to serve static for ${(req.url || '')
+          .replace(/[\r\n]/g, ' ')}`,
+      );
+      if (req.url.endsWith('.js')) {
+        res.type('application/javascript');
+      }
+      serveStaticWithLogging(req, res, (err) => {
+        if (err) {
+          const sanitizedErr =
+            err instanceof Error
+              ? err.message.replace(/[\r\n]/g, ' ')
+              : String(err)
+                  .replace(/[\r\n]/g, ' ');
+          debugLog(
+            this.apiRouter.application.environment.debug,
+            'error',
+            'Error serving static file:',
+            sanitizedErr,
+          );
+          handleError(err, res, sendApiMessageResponse, next);
+          return;
+        }
+        next();
+      });
+    });
+
+    // The "catchall" handler: for any request that doesn't
+    // match one above, send back React's index.html file.
+    // app.get('*', (req, res) => {
+    //   res.sendFile(path.join(__dirname,'..', '..', '..', 'myapp-react', 'index.html'));
+    // });
+    app.use((req: Request, res: Response) => {
+      const cspNonce = res.locals['cspNonce'];
+      if (req.url.endsWith('.js')) {
+        res.type('application/javascript');
+      }
+
+      const SiteName = this.application.constants.Site;
+      const SiteTagline = this.application.constants.SiteTagline;
+      const SiteDescription = this.application.constants.SiteDescription;
+      const hostname = req.hostname;
+      const jsFile = this.getAssetFilename(this.assetsDir, /^index-.*\.js$/);
+      const cssFile = this.getAssetFilename(this.assetsDir, /^index-.*\.css$/);
+      const server =
+        (req.socket.localPort === 443 && req.protocol === 'https') ||
+        (req.socket.localPort === 80 && req.protocol === 'http')
+          ? `${req.protocol}://${hostname}`
+          : `${req.protocol}://${hostname}:${req.socket.localPort}`;
+
+      res.render(
+        'index',
+        {
+          cspNonce,
+          title: SiteName,
+          tagline: SiteTagline,
+          description: SiteDescription,
+          server: server,
+          siteUrl: this.apiRouter.application.environment.serverUrl,
+          baseHref: this.apiRouter.application.environment.basePath,
+          hostname: hostname,
+          siteTitle: SiteName,
+          jsFile: jsFile ? `assets/${jsFile}` : undefined,
+          cssFile: cssFile ? `assets/${cssFile}` : undefined,
+        },
+        (err, html) => {
+          // Render 'index.ejs'
+          if (err) {
+            const errMsg =
+              err && typeof err === 'object' && 'message' in err
+                ? String(err.message)
+                    .replace(/[\r\n]/g, ' ')
+                : 'Unknown error';
+            console.error('Error rendering: ' + errMsg);
+            if (!res.headersSent) {
+              res.status(500).send('An error occurred'); // Send a generic error message or render a separate error view
+            }
+            return;
+          }
+          res.send(html);
+        },
+      );
+    });
+  }
+}

package/src/routers/base.ts

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+import { IApplication } from '../interfaces/application';
+import { Types } from 'mongoose';
+import { IBaseDocument } from '../documents';
+import { Environment } from '../environment';
+import { IConstants } from '../interfaces';
+
+export abstract class BaseRouter<
+  TApplication extends IApplication<any, Types.ObjectId, IBaseDocument<any, Types.ObjectId>, Environment, IConstants> = IApplication<any, Types.ObjectId, IBaseDocument<any, Types.ObjectId>, Environment, IConstants>,
+> {
+  public readonly router: Router;
+  public readonly application: TApplication;
+  protected constructor(application: TApplication) {
+    this.application = application;
+    this.router = Router();
+  }
+}

package/{dist/routers/index.d.ts → src/routers/index.ts}

@@ -1,4 +1,3 @@
 export * from './api';
 export * from './app';
 export * from './base';
-//# sourceMappingURL=index.d.ts.map

package/src/schemas/email-token.ts

@@ -0,0 +1,91 @@
+import {
+  EmailTokenType,
+  getSuiteCoreTranslation,
+  SuiteCoreStringKey,
+} from '@digitaldefiance/suite-core-lib';
+import { Schema } from 'mongoose';
+import validator from 'validator';
+import { IEmailTokenDocument } from '../documents/email-token';
+import { BaseModelName } from '../enumerations';
+
+/**
+ * Configuration options for creating an email token schema
+ */
+export interface EmailTokenSchemaOptions<
+  TTokenType extends string = EmailTokenType,
+  TModelName extends string = BaseModelName,
+> {
+  /** 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;
+}
+
+/**
+ * Factory function to create an extensible email token schema
+ */
+export function createEmailTokenSchema<
+  TTokenType extends string = EmailTokenType,
+  TModelName extends string = BaseModelName,
+>(
+  options: EmailTokenSchemaOptions<TTokenType, TModelName> = {},
+): Schema<IEmailTokenDocument> {
+  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,
+      }),
+  } = options;
+
+  const schema = new Schema<IEmailTokenDocument>(
+    {
+      userId: {
+        type: Schema.Types.ObjectId,
+        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 },
+      },
+    },
+    { 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/{dist/schemas/index.d.ts → src/schemas/index.ts}

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