@digitaldefiance/node-express-suite 3.6.20 → 3.6.21

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Digital Defiance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitaldefiance/node-express-suite",
-  "version": "3.6.20",
+  "version": "3.6.21",
   "homepage": "https://github.com/Digital-Defiance/node-express-suite",
   "repository": {
     "type": "git",
@@ -80,6 +80,5 @@
   ],
   "author": "Digital Defiance",
   "license": "MIT",
-  "packageManager": "yarn@4.12.0",
-  "type": "commonjs"
-}
+  "packageManager": "yarn@4.12.0"
+}

package/src/__tests__/fixtures/{index.d.ts → index.ts}

@@ -1,2 +1 @@
 export * from './model-mocks.mock';
-//# sourceMappingURL=index.d.ts.map

package/src/__tests__/fixtures/model-mocks.mock.ts

@@ -0,0 +1,164 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-return */
+interface MockChainable {
+  session: any;
+  lean?: any;
+  collation?: any;
+  select?: any;
+  populate?: any;
+  exec: any;
+  then: any;
+  catch: any;
+  finally: any;
+}
+
+interface MockModel {
+  find: any;
+  findOne: any;
+  create: any;
+}
+
+export const mockFunctions: (jest: typeof import('@jest/globals').jest) => {
+  makeRoleModel: (doc?: unknown) => MockModel;
+  makeUserModel: (doc?: unknown) => MockModel;
+  makeUserRoleModel: (docs?: unknown[] | null) => MockModel;
+} = (jest: typeof import('@jest/globals').jest) => {
+  return {
+    makeRoleModel: (doc?: unknown) => {
+      const chainable: Partial<MockChainable> = {
+        session: jest.fn().mockReturnThis(),
+        lean: jest.fn().mockReturnThis(),
+        exec: jest.fn<() => Promise<unknown>>().mockResolvedValue(doc ?? null),
+      };
+      chainable.then = jest
+        .fn<
+          (
+            onFulfilled?: (value: unknown) => unknown,
+            onRejected?: (reason: unknown) => unknown,
+          ) => Promise<unknown>
+        >()
+        .mockImplementation(
+          (
+            onFulfilled?: (value: unknown) => unknown,
+            onRejected?: (reason: unknown) => unknown,
+          ) => Promise.resolve(doc ?? null).then(onFulfilled, onRejected),
+        );
+      chainable.catch = jest
+        .fn<(onRejected?: (reason: unknown) => unknown) => Promise<unknown>>()
+        .mockImplementation((onRejected?: (reason: unknown) => unknown) =>
+          Promise.resolve(doc ?? null).catch(onRejected),
+        );
+      chainable.finally = jest
+        .fn<(onFinally?: () => void) => Promise<unknown>>()
+        .mockImplementation((onFinally?: () => void) =>
+          Promise.resolve(doc ?? null).finally(onFinally),
+        );
+      // For getUserRoles which uses find().session() and expects array
+      const findChainable = {
+        session: jest
+          .fn<() => Promise<unknown[]>>()
+          .mockResolvedValue(doc ? [doc] : []),
+      };
+      return {
+        find: jest.fn().mockReturnValue(findChainable),
+        findOne: jest.fn().mockReturnValue(chainable),
+        create: jest.fn(),
+      };
+    },
+
+    makeUserModel: (doc?: unknown) => {
+      const chainable: Partial<MockChainable> = {
+        session: jest.fn().mockReturnThis(),
+        collation: jest.fn().mockReturnThis(),
+        select: jest.fn().mockReturnThis(),
+        lean: jest.fn().mockReturnThis(),
+        exec: jest.fn<() => Promise<unknown>>().mockResolvedValue(doc ?? null),
+      };
+      chainable.then = jest
+        .fn<
+          (
+            onFulfilled?: (value: unknown) => unknown,
+            onRejected?: (reason: unknown) => unknown,
+          ) => Promise<unknown>
+        >()
+        .mockImplementation(
+          (
+            onFulfilled?: (value: unknown) => unknown,
+            onRejected?: (reason: unknown) => unknown,
+          ) => Promise.resolve(doc ?? null).then(onFulfilled, onRejected),
+        );
+      chainable.catch = jest
+        .fn<(onRejected?: (reason: unknown) => unknown) => Promise<unknown>>()
+        .mockImplementation((onRejected?: (reason: unknown) => unknown) =>
+          Promise.resolve(doc ?? null).catch(onRejected),
+        );
+      chainable.finally = jest
+        .fn<(onFinally?: () => void) => Promise<unknown>>()
+        .mockImplementation((onFinally?: () => void) =>
+          Promise.resolve(doc ?? null).finally(onFinally),
+        );
+      // For loginWithMnemonic which uses .lean().session() without .exec()
+      (chainable.lean as any).mockReturnValue({
+        session: jest
+          .fn<() => Promise<unknown>>()
+          .mockResolvedValue(doc ?? null),
+      });
+      return {
+        find: jest.fn().mockReturnValue(chainable),
+        findOne: jest.fn().mockReturnValue(chainable),
+        create: jest.fn(),
+      };
+    },
+
+    makeUserRoleModel: (docs?: unknown[] | null) => {
+      const chainable: Partial<MockChainable> = {
+        session: jest.fn().mockReturnThis(),
+        populate: jest.fn().mockReturnThis(),
+        lean: jest.fn().mockReturnThis(),
+        select: jest.fn().mockReturnThis(),
+        exec: jest.fn<() => Promise<unknown[]>>().mockResolvedValue(docs ?? []),
+      };
+      chainable.then = jest
+        .fn<
+          (
+            onFulfilled?: (value: unknown) => unknown,
+            onRejected?: (reason: unknown) => unknown,
+          ) => Promise<unknown>
+        >()
+        .mockImplementation(
+          (
+            onFulfilled?: (value: unknown) => unknown,
+            onRejected?: (reason: unknown) => unknown,
+          ) => Promise.resolve(docs ?? []).then(onFulfilled, onRejected),
+        );
+      chainable.catch = jest
+        .fn<(onRejected?: (reason: unknown) => unknown) => Promise<unknown>>()
+        .mockImplementation((onRejected?: (reason: unknown) => unknown) =>
+          Promise.resolve(docs ?? []).catch(onRejected),
+        );
+      chainable.finally = jest
+        .fn<(onFinally?: () => void) => Promise<unknown[]>>()
+        .mockImplementation((onFinally?: () => void) =>
+          Promise.resolve(docs ?? []).finally(onFinally),
+        );
+      // For getUserRoles which uses .select().session() - should return the docs array
+      (chainable.select as any).mockImplementation(() => ({
+        session: jest
+          .fn<() => Promise<unknown[]>>()
+          .mockResolvedValue(docs ?? []),
+      }));
+      // For getUserRoles which uses .populate().lean().exec()
+      (chainable.populate as any).mockReturnValue({
+        lean: jest.fn().mockReturnValue({
+          exec: jest
+            .fn<() => Promise<unknown[]>>()
+            .mockResolvedValue(docs ?? []),
+        }),
+      });
+      return {
+        find: jest.fn().mockReturnValue(chainable),
+        findOne: jest.fn().mockReturnValue(chainable),
+        create: jest.fn(),
+      };
+    },
+  };
+};

package/src/__tests__/helpers/application.mock.ts

@@ -0,0 +1,89 @@
+import { SecureString } from '@digitaldefiance/ecies-lib';
+import mongoose, { Document, Model } from '@digitaldefiance/mongoose-types';
+import { LocalhostConstants } from '../../../src/constants';
+import { ServiceContainer } from '../../../src/container';
+import { Environment } from '../../../src/environment';
+import { IApplication } from '../../../src/interfaces/application';
+import { PluginManager } from '../../../src/plugins';
+
+export function createApplicationMock(
+  overrides?: Partial<IApplication>,
+  envOverrides?: Partial<Environment>,
+): IApplication {
+  const mockEnvironment = {
+    jwtSecret: new SecureString('test-jwt-secret'),
+    mnemonicHmacSecret: new SecureString('test-hmac-secret'),
+    mnemonicEncryptionKey: new SecureString('test-encryption-key'),
+    timezone: { value: 'UTC' },
+    mongo: { useTransactions: false },
+    disableEmailSend: true,
+    devDatabase: true,
+    ...overrides?.environment,
+    ...envOverrides,
+  } as Environment;
+
+  const defaultGetModel = <T extends Document>(name: string): Model<T> =>
+    ({} as Model<T>);
+
+  return {
+    environment: mockEnvironment,
+    constants: LocalhostConstants,
+    disableEmailSend: true,
+    db: overrides?.db || ({} as typeof mongoose),
+    ready: true,
+    async start() {
+      /* noop */
+    },
+    getModel: overrides?.getModel || defaultGetModel,
+    services: new ServiceContainer(),
+    plugins: new PluginManager(),
+  } as IApplication;
+}
+
+/**
+ * Create a minimal IApplication mock suitable for router/middleware tests.
+ */
+export function createApplicationMock2(
+  apiDistDir: string,
+  reactDistDir: string,
+  serverUrl: string = 'http://localhost:3000',
+  overrides?: Partial<IApplication>,
+  envOverrides?: Partial<Environment>,
+): IApplication {
+  // minimal environment-like object with only fields used by constructors
+  const env: Partial<Environment> = {
+    debug: false,
+    detailedDebug: false,
+    serverUrl: serverUrl,
+    disableEmailSend: true,
+    basePath: '/',
+    apiDistDir: apiDistDir,
+    reactDistDir: reactDistDir,
+    ...envOverrides,
+  };
+
+  const application: IApplication = {
+    get environment() {
+      return { ...env } as Environment;
+    },
+    get db() {
+      return mongoose;
+    },
+    get ready() {
+      return true;
+    },
+    async start() {
+      /* noop */
+    },
+    getModel<T extends Document>(): Model<T> {
+      throw new Error('getModel not implemented in test mock');
+    },
+    services: new ServiceContainer(),
+    plugins: new PluginManager(),
+    constants: LocalhostConstants,
+    disableEmailSend: true,
+    ...(overrides as object),
+  } as IApplication;
+
+  return application;
+}

package/src/__tests__/helpers/{index.d.ts → index.ts}

@@ -1,4 +1,3 @@
 export * from '../fixtures/model-mocks.mock';
 export * from './application.mock';
 export * from './setup-test-env';
-//# sourceMappingURL=index.d.ts.map

package/src/__tests__/helpers/setup-test-env.ts

@@ -0,0 +1,190 @@
+import {
+  CoreLanguageCode,
+  GlobalActiveContext,
+  IActiveContext,
+} from '@digitaldefiance/i18n-lib';
+import { Connection } from '@digitaldefiance/mongoose-types';
+import { IFailableResult } from '@digitaldefiance/suite-core-lib';
+import { HelmetOptions } from 'helmet';
+import { Application } from '../../application';
+import { BaseApplication } from '../../application-base';
+import { IBaseDocument } from '../../documents';
+import { Environment } from '../../environment';
+import {
+  IApplication,
+  IConstants,
+  ICSPConfig,
+  IFlexibleCSP,
+  IServerInitResult,
+} from '../../interfaces';
+import { ITestEnvironment } from '../../interfaces/test-environment';
+import { initMiddleware } from '../../middlewares';
+import { AppRouter, BaseRouter } from '../../routers';
+import { DatabaseInitializationService } from '../../services';
+import { SchemaMap } from '../../types';
+
+export async function setupTestEnvironment<
+  TModelDocs extends Record<string, IBaseDocument<any>>,
+  TConstants extends IConstants = IConstants,
+  TAppRouter extends AppRouter = AppRouter,
+>(
+  constants: TConstants,
+  apiRouterFactory: (app: IApplication) => BaseRouter,
+  schemaMapFactory: (connection: Connection) => SchemaMap<TModelDocs>,
+  appRouterFactory: (apiRouter: BaseRouter) => TAppRouter = (apiRouter) =>
+    new AppRouter(apiRouter) as TAppRouter,
+  customInitMiddleware: typeof initMiddleware = initMiddleware,
+  envLocation?: string,
+  databaseInitFunction?: (
+    application: BaseApplication<TModelDocs, IServerInitResult>,
+  ) => Promise<IFailableResult<IServerInitResult>>,
+  initResultHashFunction?: (initResults: IServerInitResult) => string,
+  cspConfig: ICSPConfig | HelmetOptions | IFlexibleCSP = {
+    corsWhitelist: [],
+    csp: {
+      defaultSrc: [],
+      imgSrc: [],
+      connectSrc: [],
+      scriptSrc: [],
+      styleSrc: [],
+      fontSrc: [],
+      frameSrc: [],
+    },
+  },
+): Promise<ITestEnvironment> {
+  // Make runtime deterministic for tests
+  process.env.NODE_ENV = 'test';
+  process.env['DEV_DATABASE'] = 'test';
+  // Increase libuv threadpool for concurrent pbkdf2 work
+  if (!process.env['UV_THREADPOOL_SIZE']) {
+    process.env['UV_THREADPOOL_SIZE'] = '16';
+  }
+
+  // Optimize MongoDB settings for test performance while maintaining reliability
+  if (!process.env['MONGO_MAX_POOL_SIZE']) {
+    process.env['MONGO_MAX_POOL_SIZE'] = '5'; // Increased for better concurrency
+  }
+  if (!process.env['MONGO_MIN_POOL_SIZE']) {
+    process.env['MONGO_MIN_POOL_SIZE'] = '2'; // Increased for better performance
+  }
+  if (!process.env['MONGO_SERVER_SELECTION_TIMEOUT_MS']) {
+    process.env['MONGO_SERVER_SELECTION_TIMEOUT_MS'] = '5000'; // Increased for stability
+  }
+  if (!process.env['MONGO_SOCKET_TIMEOUT_MS']) {
+    process.env['MONGO_SOCKET_TIMEOUT_MS'] = '15000'; // Increased for stability
+  }
+  if (!process.env['MONGO_TRANSACTION_TIMEOUT']) {
+    process.env['MONGO_TRANSACTION_TIMEOUT'] = '15000'; // Increased for stability
+  }
+  if (!process.env['MONGO_TRANSACTION_LOCK_REQUEST_TIMEOUT']) {
+    process.env['MONGO_TRANSACTION_LOCK_REQUEST_TIMEOUT'] = '8000'; // Increased for stability
+  }
+  if (!process.env['MONGO_TRANSACTION_RETRY_BASE_DELAY']) {
+    process.env['MONGO_TRANSACTION_RETRY_BASE_DELAY'] = '100'; // Increased for stability
+  }
+  // Disable transactions in test environment for better reliability
+  if (!process.env['MONGO_USE_TRANSACTIONS']) {
+    process.env['MONGO_USE_TRANSACTIONS'] = 'false'; // Disable transactions for tests
+  }
+
+  // Ensure language is set to English for consistent test behavior
+  process.env.LANGUAGE = 'English (US)';
+
+  // Use a random high port to avoid conflicts
+  process.env['PORT'] = String(Math.floor(Math.random() * 10000) + 50000);
+
+  // Use unique database name for each test to avoid conflicts
+  const uniqueDbName = `test_${Date.now()}_${Math.floor(
+    Math.random() * 10000,
+  )}`;
+  process.env['DEV_DATABASE'] = uniqueDbName;
+
+  // Reset global language context to English
+  const setAdminLanguage = (language: CoreLanguageCode) => {
+    const context = GlobalActiveContext.getInstance<
+      CoreLanguageCode,
+      IActiveContext<CoreLanguageCode>
+    >();
+    context.setAdminLanguage(language);
+  };
+  setAdminLanguage('en-US');
+
+  const env = new Environment(envLocation, true);
+
+  const application = new Application(
+    env,
+    apiRouterFactory,
+    schemaMapFactory,
+    databaseInitFunction ??
+      DatabaseInitializationService.initUserDb.bind(
+        DatabaseInitializationService,
+      ),
+    initResultHashFunction ??
+      DatabaseInitializationService.serverInitResultHash.bind(
+        DatabaseInitializationService,
+      ),
+    cspConfig,
+    constants,
+    appRouterFactory,
+    customInitMiddleware,
+  );
+
+  const initResult: IFailableResult<IServerInitResult> =
+    await DatabaseInitializationService.initUserDb(application);
+  if (!initResult.success || !initResult.data) {
+    throw new Error('Failed to initialize database for tests');
+  }
+  const accountData = initResult.data;
+
+  // Create and start your app
+  try {
+    await application.start();
+
+    const command = {
+      ...(application.environment.mongo.setParameterSupported
+        ? { setParameter: 1 }
+        : {}),
+      ...(application.environment.mongo.useTransactions &&
+      application.environment.mongo.transactionLifetimeLimitSecondsSupported
+        ? {
+            transactionLifetimeLimitSeconds:
+              application.environment.mongo.transactionTimeout,
+          }
+        : {}),
+      ...(application.environment.mongo.useTransactions &&
+      application.environment.mongo
+        .maxTransactionLockRequestTimeoutMillisSupported
+        ? {
+            maxTransactionLockRequestTimeoutMillis:
+              application.environment.mongo.transactionLockRequestTimeout,
+          }
+        : {}),
+    };
+
+    if (Object.keys(command).length > 0 && application.db.connection.db) {
+      // Configure MongoDB for better concurrency
+      await application.db.connection.db
+        .admin()
+        .command(command)
+        .catch(() => undefined);
+    }
+  } catch (error) {
+    console.error(
+      'Failed to start application with MongoDB URI:',
+      application.environment.mongo.uri,
+    );
+    console.error('Connection error:', error);
+    throw error;
+  }
+
+  // Ensure the test process uses the same JWT secret as the application
+  process.env.JWT_SECRET = application.environment.jwtSecret;
+
+  return {
+    application,
+    mongoServer: application.devDatabase!,
+    mongoUri: application.environment.mongo.uri,
+    accountData,
+    dbName: application.environment.devDatabase!,
+  };
+}

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

@@ -1,3 +1,2 @@
 export * from './fixtures';
 export * from './helpers';
-//# sourceMappingURL=index.d.ts.map