@digitaldefiance/node-express-suite 3.6.21 → 3.6.22

package/src/application-base.ts

@@ -1,536 +0,0 @@
-// Avoid importing from the barrel (../index) here to prevent circular deps
-import mongoose, { Model } from '@digitaldefiance/mongoose-types';
-import {
-  Constants,
-  getSuiteCoreI18nEngine,
-  getSuiteCoreTranslation,
-  SuiteCoreComponentId,
-  SuiteCoreStringKey,
-  TranslatableSuiteError,
-} from '@digitaldefiance/suite-core-lib';
-import { MongoMemoryReplSet } from 'mongodb-memory-server';
-import { join } from 'path';
-import { ServiceContainer } from './container';
-import { IBaseDocument } from './documents/base';
-import { Environment } from './environment';
-import { IApplication } from './interfaces/application';
-import { IConstants } from './interfaces/constants';
-import { IFailableResult } from './interfaces/failable-result';
-import { ISchema } from './interfaces/schema';
-import { ModelRegistry } from './model-registry';
-import { PluginManager } from './plugins';
-import { SchemaMap } from './types';
-import { debugLog } from './utils';
-
-/**
- * Base Application class with core functionality
- */
-export class BaseApplication<
-  TModelDocs extends Record<string, IBaseDocument<any>>,
-  TInitResults,
-  TConstants extends IConstants = IConstants,
-> implements IApplication
-{
-  /**
-   * Application environment
-   */
-  private _environment: Environment;
-  /**
-   * In-memory MongoDB instance for development
-   */
-  private _devDatabase?: MongoMemoryReplSet;
-  /**
-   * Constants for the application
-   */
-  private _constants: TConstants;
-  /**
-   * Function to create the schema map given a Mongoose connection
-   */
-  private readonly _schemaMapFactory: (
-    connection: mongoose.Connection,
-  ) => SchemaMap<TModelDocs>;
-  /**
-   * Function to initialize the database with default data
-   */
-  private readonly _databaseInitFunction: (
-    application: BaseApplication<TModelDocs, TInitResults>,
-  ) => Promise<IFailableResult<TInitResults>>;
-  /**
-   * Function to create a hash from the database initialization results (for logging purposes)
-   */
-  private readonly _initResultHashFunction: (
-    initResults: TInitResults,
-  ) => string;
-
-  /**
-   * Get the application environment
-   */
-  public get environment(): Environment {
-    return this._environment;
-  }
-
-  public get constants(): TConstants {
-    return this._constants;
-  }
-
-  /**
-   * Reload the environment from file
-   */
-  public reloadEnvironment(path?: string, override = true): void {
-    this._environment = new Environment(path, false, override);
-  }
-
-  /**
-   * Get the path to the dist directory
-   */
-  public static get distDir(): string {
-    const cwd = process.cwd();
-    const distPath = join(cwd, 'dist');
-    return distPath;
-  }
-
-  /**
-   * Mongoose database instance
-   */
-  protected _db?: typeof mongoose;
-
-  /**
-   * Schema map for all models
-   */
-  protected _schemaMap: SchemaMap<TModelDocs> | undefined;
-  public get schemaMap(): SchemaMap<TModelDocs> {
-    if (!this._schemaMap) {
-      throw new TranslatableSuiteError(
-        SuiteCoreStringKey.Admin_Error_SchemaMapIsNotLoadedYet,
-      );
-    }
-    return this._schemaMap;
-  }
-
-  /**
-   * Flag indicating whether the application is ready to handle requests
-   */
-  protected _ready: boolean;
-
-  /**
-   * Service container for dependency injection
-   */
-  public readonly services: ServiceContainer;
-
-  /**
-   * Plugin manager for extensibility
-   */
-  public readonly plugins: PluginManager;
-
-  /**
-   * Get the connected MongoDB database instance
-   */
-  public get db(): typeof mongoose {
-    if (!this._db) {
-      throw new TranslatableSuiteError(
-        SuiteCoreStringKey.Admin_Error_DatabaseNotConnectedYet,
-      );
-    }
-    return this._db;
-  }
-
-  /**
-   * Get whether the application is ready to handle requests
-   */
-  public get ready(): boolean {
-    return this._ready;
-  }
-
-  constructor(
-    environment: Environment,
-    schemaMapFactory: (
-      connection: mongoose.Connection,
-    ) => SchemaMap<TModelDocs>,
-    databaseInitFunction: (
-      application: BaseApplication<TModelDocs, TInitResults>,
-    ) => Promise<IFailableResult<TInitResults>>,
-    initResultHashFunction: (initResults: TInitResults) => string,
-    constants: TConstants = Constants as TConstants,
-  ) {
-    this._ready = false;
-    this._environment = environment;
-    this._constants = constants;
-    this._schemaMapFactory = schemaMapFactory;
-    this._databaseInitFunction = databaseInitFunction;
-    this._initResultHashFunction = initResultHashFunction;
-    this.services = new ServiceContainer();
-    this.plugins = new PluginManager();
-  }
-
-  /**
-   * Validate MongoDB URI to prevent SSRF attacks
-   */
-  private validateMongoUri(uri: string): void {
-    // Validate protocol
-    if (!uri.startsWith('mongodb://') && !uri.startsWith('mongodb+srv://')) {
-      throw new TranslatableSuiteError(
-        SuiteCoreStringKey.Admin_Error_InvalidMongoUri,
-      );
-    }
-
-    // In production, block private IPs and localhost
-    if (this._environment.production) {
-      // Updated regex to handle IPv6 addresses with brackets
-      const urlMatch = uri.match(
-        /^mongodb(?:\+srv)?:\/\/(?:[^@]+@)?(\[[^\]]+\]|[^:/]+)/,
-      );
-      if (urlMatch) {
-        // Remove brackets from hostname for IPv6 addresses
-        const hostname = urlMatch[1].replace(/[[\]]/g, '');
-        // Block localhost and private IP ranges
-        if (
-          hostname === 'localhost' ||
-          hostname === '127.0.0.1' ||
-          hostname.startsWith('10.') ||
-          hostname.startsWith('192.168.') ||
-          /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(hostname) ||
-          hostname.startsWith('169.254.') || // Link-local
-          hostname === '::1' || // IPv6 localhost
-          hostname.startsWith('fc00:') || // IPv6 private
-          hostname.startsWith('fd00:') // IPv6 private
-        ) {
-          throw new TranslatableSuiteError(
-            SuiteCoreStringKey.Admin_Error_InvalidMongoUri,
-          );
-        }
-      }
-    }
-  }
-
-  /**
-   * Connect to MongoDB and initialize schemas
-   */
-  protected async connectDatabase(
-    mongoUri: string,
-    debug = false,
-  ): Promise<void> {
-    this.validateMongoUri(mongoUri);
-
-    debugLog(
-      debug,
-      'log',
-      `[ ${getSuiteCoreTranslation(
-        SuiteCoreStringKey.Common_Connecting,
-        undefined,
-        undefined,
-        { constants: this.constants },
-      )} ] ${getSuiteCoreTranslation(
-        SuiteCoreStringKey.Common_MongoDB,
-        undefined,
-        undefined,
-        { constants: this.constants },
-      )}: ${mongoUri}`,
-    );
-
-    // Always disconnect first to ensure clean state
-    if (mongoose.connection.readyState !== 0) {
-      await mongoose.disconnect();
-    }
-
-    // amazonq-ignore-next-line solved above with validateMongoUri call
-    await mongoose.connect(mongoUri, {
-      maxPoolSize: this._environment.mongo.maxPoolSize,
-      minPoolSize: this._environment.mongo.minPoolSize,
-      maxIdleTimeMS: this._environment.mongo.maxIdleTimeMS,
-      serverSelectionTimeoutMS:
-        this._environment.mongo.serverSelectionTimeoutMS,
-      socketTimeoutMS: this._environment.mongo.socketTimeoutMS,
-      retryWrites: this._environment.mongo.retryWrites,
-      retryReads: this._environment.mongo.retryReads,
-      readConcern: this._environment.mongo.readConcern,
-      writeConcern: this._environment.mongo.writeConcern,
-    });
-    this._db = mongoose;
-
-    await new Promise<void>((resolve) => {
-      if (mongoose.connection.readyState === 1) {
-        resolve();
-      } else {
-        mongoose.connection.once('connected', resolve);
-      }
-    });
-
-    const engine = getSuiteCoreI18nEngine({ constants: this.constants });
-    debugLog(
-      debug,
-      'log',
-      engine.t(
-        '[ {{SuiteCoreStringKey.Common_Connected}} ] {{SuiteCoreStringKey.Common_MongoDB}}',
-      ),
-    );
-
-    debugLog(
-      debug,
-      'log',
-      engine.t(
-        '[ {{SuiteCoreStringKey.Common_Loading}} ] {{SuiteCoreStringKey.Common_Schemas}}',
-      ),
-    );
-    this._schemaMap = this._schemaMapFactory(this.db.connection);
-    // Register all base models in ModelRegistry for extensibility
-    if (this._schemaMap) {
-      Object.values(this._schemaMap).forEach((schema) => {
-        ModelRegistry.instance.register({
-          modelName: schema.modelName,
-          schema: schema.schema,
-          model: schema.model,
-          collection: schema.collection,
-          discriminators: schema.discriminators,
-        });
-      });
-    }
-
-    if (debug) {
-      (Object.values(this._schemaMap) as ISchema<IBaseDocument<any>>[]).forEach(
-        (schema) => {
-          console.log(
-            engine.t(
-              `[ {{SuiteCoreStringKey.Common_Loaded}} ] {{SuiteCoreStringKey.Common_Schema}} '${schema.modelName.replace(
-                /[\r\n]/g,
-                '',
-              )}'`,
-            ),
-          );
-        },
-      );
-    }
-
-    if (!this._db.connection.db) {
-      console.error(
-        engine.translate(
-          SuiteCoreComponentId,
-          SuiteCoreStringKey.Admin_Error_FailedToSetTransactionTimeout,
-        ),
-      );
-    } else {
-      const command = {
-        ...(this._environment.mongo.setParameterSupported
-          ? { setParameter: 1 }
-          : {}),
-        ...(this._environment.mongo.useTransactions &&
-        this._environment.mongo.transactionLifetimeLimitSecondsSupported
-          ? {
-              transactionLifetimeLimitSeconds:
-                this._environment.mongo.transactionTimeout,
-            }
-          : {}),
-        ...(this._environment.mongo.useTransactions &&
-        this._environment.mongo.maxTransactionLockRequestTimeoutMillisSupported
-          ? {
-              maxTransactionLockRequestTimeoutMillis:
-                this._environment.mongo.transactionLockRequestTimeout,
-            }
-          : {}),
-      };
-      if (Object.keys(command).length > 0) {
-        await this._db.connection.db
-          .admin()
-          .command(command)
-          .catch(() => undefined);
-      }
-      debugLog(
-        debug,
-        'log',
-        engine.translate(
-          SuiteCoreComponentId,
-          SuiteCoreStringKey.Admin_SetTransactionTimeoutSuccessfully,
-        ),
-      );
-    }
-  }
-
-  /**
-   * Disconnect from database
-   */
-  protected async disconnectDatabase(debug = false): Promise<void> {
-    if (this._db && mongoose.connection.readyState !== 0) {
-      await this._db.disconnect();
-    }
-    const engine = getSuiteCoreI18nEngine({ constants: this.constants });
-    this._db = undefined;
-    debugLog(
-      debug,
-      'log',
-      `[ ${engine.translate(
-        SuiteCoreComponentId,
-        SuiteCoreStringKey.Common_Disconnected,
-      )} ] ${engine.translate(
-        SuiteCoreComponentId,
-        SuiteCoreStringKey.Common_MongoDB,
-      )}`,
-    );
-  }
-
-  /**
-   * Set up an in-memory MongoDB instance for development
-   * @returns The MongoDB connection URI
-   */
-  protected async setupDevDatabase(): Promise<string> {
-    this._devDatabase = await MongoMemoryReplSet.create({
-      replSet: { count: 1, storageEngine: 'wiredTiger' },
-    });
-    await this._devDatabase.waitUntilRunning();
-    const mongoUri =
-      this._devDatabase.getUri(this._environment.devDatabase) +
-      '&maxPoolSize=20&minPoolSize=4';
-    this._environment.setEnvironment('mongo.uri', mongoUri);
-    debugLog(
-      this._environment.debug,
-      'log',
-      `MongoDB Memory Server with transactions: ${mongoUri}`,
-    );
-    return mongoUri;
-  }
-
-  /**
-   * Initialize the development database with default data
-   */
-  protected async initializeDevDatabase(): Promise<TInitResults> {
-    const engine = getSuiteCoreI18nEngine({ constants: this.constants });
-    debugLog(
-      this._environment.debug,
-      'log',
-      `${engine.translate(
-        SuiteCoreComponentId,
-        SuiteCoreStringKey.Admin_StartingDatabaseInitialization,
-      )}: ${engine.translate(
-        SuiteCoreComponentId,
-        SuiteCoreStringKey.Admin_TransactionsEnabledDisabledTemplate,
-        {
-          STATE: this._environment.mongo.useTransactions
-            ? engine.translate(
-                SuiteCoreComponentId,
-                SuiteCoreStringKey.Common_Enabled,
-              )
-            : engine.translate(
-                SuiteCoreComponentId,
-                SuiteCoreStringKey.Common_Disabled,
-              ),
-        },
-      )}`,
-    );
-    let initTimeout: NodeJS.Timeout | undefined;
-    const initTimeoutMs = 300000;
-
-    const accountDataResult: IFailableResult<TInitResults> = await Promise.race(
-      [
-        this._databaseInitFunction(this),
-        new Promise<never>((_, reject) => {
-          initTimeout = setTimeout(() => {
-            const logMsg = engine.translate(
-              SuiteCoreComponentId,
-              SuiteCoreStringKey.Admin_Error_FailedToInitializeUserDatabaseTimeoutTemplate,
-              { timeMs: initTimeoutMs.toString() },
-            );
-            console.error(logMsg);
-            reject(new Error(logMsg));
-          }, initTimeoutMs);
-        }),
-      ],
-    );
-    if (initTimeout) clearTimeout(initTimeout);
-
-    if (accountDataResult.success && accountDataResult.data) {
-      if (this._environment.detailedDebug) {
-        const initHash = this._initResultHashFunction(accountDataResult.data);
-        debugLog(
-          true,
-          'log',
-          engine.translate(
-            SuiteCoreComponentId,
-            SuiteCoreStringKey.Admin_DatabaseInitializedWithOptionsHashTemplate,
-            { hash: initHash },
-          ),
-        );
-      }
-      return accountDataResult.data;
-    } else {
-      if (this._environment.detailedDebug && accountDataResult.error) {
-        debugLog(true, 'log', accountDataResult.error);
-      }
-      throw new TranslatableSuiteError(
-        SuiteCoreStringKey.Admin_Error_FailedToInitializeUserDatabase,
-      );
-    }
-  }
-
-  /**
-   * Get the in-memory MongoDB instance (if any)
-   */
-  public get devDatabase(): MongoMemoryReplSet | undefined {
-    return this._devDatabase;
-  }
-
-  /**
-   * Start the application and connect to the database
-   */
-  public async start(mongoUri?: string, delayReady?: boolean): Promise<void> {
-    if (this._ready) {
-      console.error(
-        'Failed to start the application:',
-        'Application is already running',
-      );
-      const err = new Error('Application is already running');
-      if (process.env['NODE_ENV'] === 'test') {
-        throw err;
-      }
-      process.exit(1);
-    }
-    if (this._environment.devDatabase && !this._devDatabase) {
-      mongoUri = await this.setupDevDatabase();
-    }
-    try {
-      await this.connectDatabase(
-        mongoUri ?? this.environment.mongo.uri,
-        this.environment.debug,
-      );
-
-      // Initialize plugins
-      await this.plugins.initAll(this);
-
-      // Database initialization should be handled by the consuming application
-    } catch (err) {
-      const sanitizedErr =
-        err instanceof Error
-          ? err.message.replace(/[\r\n]/g, ' ')
-          : String(err).replace(/[\r\n]/g, ' ');
-      console.error('Failed to start the application:', sanitizedErr);
-      if (process.env['NODE_ENV'] === 'test') {
-        throw err;
-      }
-      process.exit(1);
-    }
-    this._ready = delayReady ? false : true;
-  }
-
-  /**
-   * Stop the application
-   */
-  public async stop(): Promise<void> {
-    await this.plugins.stopAll();
-    await this.disconnectDatabase();
-    if (this._devDatabase) {
-      await this._devDatabase.stop();
-      this._devDatabase = undefined;
-    }
-    this._ready = false;
-  }
-
-  /**
-   * Get a Mongoose model by name
-   * @param modelName Name of the model
-   * @returns
-   */
-  public getModel<T extends IBaseDocument<any>>(modelName: string): Model<T> {
-    // if (!this.db) {
-    //   throw new TranslatableError('Admin_Error_DatabaseNotConnectedYet');
-    // }
-    return ModelRegistry.instance.get<any, T>(modelName).model;
-    //return this.db.connection.model<T>(modelName);
-  }
-}

package/src/application-concrete.ts

@@ -1,42 +0,0 @@
-import { Application } from './application';
-import { LocalhostConstants } from './constants';
-import { Environment } from './environment';
-import { IConstants, IServerInitResult } from './interfaces';
-import { emailServiceRegistry } from './registry';
-import { ApiRouter, AppRouter } from './routers';
-import { BaseModelDocs, getSchemaMap } from './schemas';
-import { DatabaseInitializationService } from './services';
-import { DummyEmailService } from './services/dummy-email-service';
-
-/**
- * Test application concrete class
- */
-export class ApplicationConcrete extends Application<
-  IServerInitResult,
-  BaseModelDocs,
-  Environment,
-  IConstants,
-  AppRouter
-> {
-  constructor(
-    environment: Environment,
-    constants: IConstants = LocalhostConstants,
-  ) {
-    super(
-      environment,
-      () => new ApiRouter(this),
-      getSchemaMap,
-      DatabaseInitializationService.initUserDb.bind(
-        DatabaseInitializationService,
-      ),
-      DatabaseInitializationService.serverInitResultHash.bind(
-        DatabaseInitializationService,
-      ),
-      undefined,
-      constants,
-      (apiRouter) => new AppRouter(apiRouter),
-      undefined,
-    );
-    emailServiceRegistry.setService(new DummyEmailService(this));
-  }
-}