@digitaldefiance/node-express-suite 3.6.6 → 3.6.8

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/README.md

@@ -1315,6 +1315,10 @@ The following v1.x patterns still work in v2.0:
 
 ## ChangeLog
 
+### Version 3.6.7
+
+- Update mongoose-types
+
 ### Version 3.6.6
 
 - Update suite-core

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@digitaldefiance/node-express-suite",
-  "version": "3.6.6",
+  "version": "3.6.8",
+  "homepage": "https://github.com/Digital-Defiance/node-express-suite",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Digital-Defiance/node-express-suite.git"
+  },
   "description": "Generic express application and routing library with decorator support",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -32,11 +37,11 @@
     "publish:public": "npm publish --access public"
   },
   "dependencies": {
-    "@digitaldefiance/ecies-lib": "4.4.2",
-    "@digitaldefiance/i18n-lib": "3.8.0",
-    "@digitaldefiance/mongoose-types": "8.20.4",
-    "@digitaldefiance/node-ecies-lib": "4.4.2",
-    "@digitaldefiance/suite-core-lib": "3.6.6",
+    "@digitaldefiance/ecies-lib": "4.4.6",
+    "@digitaldefiance/i18n-lib": "3.8.2",
+    "@digitaldefiance/mongoose-types": "8.20.6",
+    "@digitaldefiance/node-ecies-lib": "4.4.3",
+    "@digitaldefiance/suite-core-lib": "3.6.7",
     "@noble/curves": "^2.0.1",
     "@noble/hashes": "^2.0.1",
     "@subspace/reed-solomon-erasure.wasm": "^0.2.5",
@@ -75,6 +80,5 @@
   ],
   "author": "Digital Defiance",
   "license": "MIT",
-  "packageManager": "yarn@4.10.3",
-  "type": "commonjs"
-}
+  "packageManager": "yarn@4.10.3"
+}

package/src/__tests__/fixtures/index.ts

@@ -0,0 +1 @@
+export * from './model-mocks.mock';

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

@@ -0,0 +1,122 @@
+export const mockFunctions: (jest: any) => {
+  makeRoleModel: (doc?: unknown) => any;
+  makeUserModel: (doc?: unknown) => any;
+  makeUserRoleModel: (docs?: unknown[] | null) => any;
+}  = (jest: any) => {
+  return {
+    makeRoleModel: (doc?: unknown) => {
+    const chainable: any = {
+      session: jest.fn().mockReturnThis(),
+      lean: jest.fn().mockReturnThis(),
+      exec: jest.fn().mockResolvedValue(doc ?? null),
+    };
+    chainable.then = jest
+      .fn()
+      .mockImplementation(
+        (
+          onFulfilled?: (value: unknown) => unknown,
+          onRejected?: (reason: unknown) => unknown,
+        ) => Promise.resolve(doc ?? null).then(onFulfilled, onRejected),
+      );
+    chainable.catch = jest
+      .fn()
+      .mockImplementation((onRejected?: (reason: unknown) => unknown) =>
+        Promise.resolve(doc ?? null).catch(onRejected),
+      );
+    chainable.finally = jest
+      .fn()
+      .mockImplementation((onFinally?: () => void) =>
+        Promise.resolve(doc ?? null).finally(onFinally),
+      );
+    // For getUserRoles which uses find().session() and expects array
+    const findChainable = {
+      session: jest.fn().mockResolvedValue(doc ? [doc] : []),
+    };
+    return {
+      find: jest.fn().mockReturnValue(findChainable),
+      findOne: jest.fn().mockReturnValue(chainable),
+      create: jest.fn(),
+    };
+  },
+  
+  makeUserModel: (doc?: unknown) => {
+    const chainable: any = {
+      session: jest.fn().mockReturnThis(),
+      collation: jest.fn().mockReturnThis(),
+      select: jest.fn().mockReturnThis(),
+      lean: jest.fn().mockReturnThis(),
+      exec: jest.fn().mockResolvedValue(doc ?? null),
+    };
+    chainable.then = jest
+      .fn()
+      .mockImplementation(
+        (
+          onFulfilled?: (value: unknown) => unknown,
+          onRejected?: (reason: unknown) => unknown,
+        ) => Promise.resolve(doc ?? null).then(onFulfilled, onRejected),
+      );
+    chainable.catch = jest
+      .fn()
+      .mockImplementation((onRejected?: (reason: unknown) => unknown) =>
+        Promise.resolve(doc ?? null).catch(onRejected),
+      );
+    chainable.finally = jest
+      .fn()
+      .mockImplementation((onFinally?: () => void) =>
+        Promise.resolve(doc ?? null).finally(onFinally),
+      );
+    // For loginWithMnemonic which uses .lean().session() without .exec()
+    chainable.lean.mockReturnValue({
+      session: jest.fn().mockResolvedValue(doc ?? null),
+    });
+    return {
+      find: jest.fn().mockReturnValue(chainable),
+      findOne: jest.fn().mockReturnValue(chainable),
+      create: jest.fn(),
+    };
+  },
+
+  makeUserRoleModel: (docs?: unknown[] | null) => {
+    const chainable: any = {
+      session: jest.fn().mockReturnThis(),
+      populate: jest.fn().mockReturnThis(),
+      lean: jest.fn().mockReturnThis(),
+      select: jest.fn().mockReturnThis(),
+      exec: jest.fn().mockResolvedValue(docs ?? []),
+    };
+    chainable.then = jest
+      .fn()
+      .mockImplementation(
+        (
+          onFulfilled?: (value: unknown) => unknown,
+          onRejected?: (reason: unknown) => unknown,
+        ) => Promise.resolve(docs ?? []).then(onFulfilled, onRejected),
+      );
+    chainable.catch = jest
+      .fn()
+      .mockImplementation((onRejected?: (reason: unknown) => unknown) =>
+        Promise.resolve(docs ?? []).catch(onRejected),
+      );
+    chainable.finally = jest
+      .fn()
+      .mockImplementation((onFinally?: () => void) =>
+        Promise.resolve(docs ?? []).finally(onFinally),
+      );
+    // For getUserRoles which uses .select().session() - should return the docs array
+    chainable.select.mockImplementation(() => ({
+      session: jest.fn().mockResolvedValue(docs ?? []),
+    }));
+    // For getUserRoles which uses .populate().lean().exec()
+    chainable.populate.mockReturnValue({
+      lean: jest.fn().mockReturnValue({
+        exec: jest.fn().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,90 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import mongoose from '@digitaldefiance/mongoose-types';
+import { SecureString } from '@digitaldefiance/ecies-lib';
+import { 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 any),
+    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?: any,
+  envOverrides?: any,
+): any {
+  // minimal environment-like object with only fields used by constructors
+  const env: any = {
+    debug: false,
+    detailedDebug: false,
+    serverUrl: serverUrl,
+    disableEmailSend: true,
+    basePath: '/',
+    apiDistDir: apiDistDir,
+    reactDistDir: reactDistDir,
+    // mock nested aws config to satisfy email service ctor if used indirectly
+    transactionTimeout: 1000,
+    useTransactions: false,
+    ...envOverrides,
+  };
+
+  const application: any = {
+    get environment() {
+      return { ...env } as any;
+    },
+    get db() {
+      return mongoose;
+    },
+    get ready() {
+      return true;
+    },
+    async start() {
+      /* noop */
+    },
+    getModel(): any {
+      throw new Error('getModel not implemented in test mock');
+    },
+    ...(overrides as object),
+  } as any;
+
+  return application;
+}

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

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

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

@@ -0,0 +1,163 @@
+import { Connection } from '@digitaldefiance/mongoose-types';
+import { Application } from '../../application';
+import { IBaseDocument } from '../../documents';
+import { Environment } from '../../environment';
+import { IApplication, IConstants, ICSPConfig, IFlexibleCSP, IServerInitResult } from '../../interfaces';
+import { ITestEnvironment } from '../../interfaces/test-environment';
+import { SchemaMap } from '../../types';
+import { BaseApplication } from '../../application-base';
+import { AppRouter, BaseRouter } from '../../routers';
+import { HelmetOptions } from 'helmet';
+import { initMiddleware } from '../../middlewares';
+import { DatabaseInitializationService } from '../../services';
+import { IFailableResult } from '@digitaldefiance/suite-core-lib';
+import { CoreLanguageCode, GlobalActiveContext, IActiveContext } from '@digitaldefiance/i18n-lib';
+
+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.ts

@@ -0,0 +1,2 @@
+export * from './fixtures';
+export * from './helpers';