@node-c/core 1.0.0-alpha9 → 1.0.0-beta1

package/src/app.spec.ts

@@ -0,0 +1,138 @@
+import * as path from 'path';
+
+import { INestApplication, Module, NestModule } from '@nestjs/common';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  APP_CONFIG_FROM_ENV_KEYS,
+  AppEnvironment,
+  ConfigProviderModule,
+  ConfigProviderService,
+  NodeCApp,
+  NodeCAppStartOptions
+} from './index';
+
+const BASE_PATH = path.join(__dirname, '../test');
+
+const appModuleOptions = {
+  appConfigs: {
+    appConfigCommon: {
+      general: {
+        projectName: 'TestProject',
+        projectRootPath: BASE_PATH,
+        projectVersion: '1.0.0'
+      },
+      api: { test: {} },
+      domain: {},
+      data: { db: { type: 'mysql', extra: 'foo' }, notADb: { type: 'unsupported' } }
+    },
+    appConfigProfileLocal: {
+      general: { environment: AppEnvironment.Local }
+    }
+  },
+  envKeys: APP_CONFIG_FROM_ENV_KEYS,
+  envKeysParentNames: {
+    API: {
+      children: { TEST: 'test' },
+      name: 'api'
+    }
+  }
+};
+
+@Module({})
+class TestAPIModule {}
+
+@Module({
+  imports: [ConfigProviderModule.register(appModuleOptions)]
+})
+class AppModule {}
+
+@Module({
+  imports: [ConfigProviderModule.register(appModuleOptions), TestAPIModule]
+})
+class AppModuleWithAPI {}
+
+@Module({
+  imports: [
+    ConfigProviderModule.register({
+      ...appModuleOptions,
+      envKeys: { API: { HTTP: { HOST: 'hostname', PORT: 'port' } } },
+      envKeysParentNames: { API: { children: { TEST: 'test' }, name: 'api' } }
+    }),
+    TestAPIModule
+  ]
+})
+class AppModuleWithAPIStartable {}
+
+describe('NodeCApp.start', () => {
+  let apps: INestApplication<unknown>[];
+  process.env.NODE_ENV = 'local';
+  afterEach(() => {
+    apps?.forEach(app => app.close());
+  });
+  it('should start apps without options (no loadConfigOptions, no apiModulesOptions)', async () => {
+    const apps = await NodeCApp.start([AppModule] as unknown as NestModule[]);
+    expect(apps).toHaveLength(1);
+  });
+  it('should call loadConfig and generateOrmconfig when loadConfigOptions and generateOrmConfig are provided', async () => {
+    const generateOrmconfigSpy = vi.spyOn(ConfigProviderService, 'generateOrmconfig');
+    const loadConfigSpy = vi.spyOn(ConfigProviderService, 'loadConfig');
+    const options: NodeCAppStartOptions = {
+      generateOrmConfig: true,
+      generateOrmConfigModuleOptions: {
+        db: {
+          entitiesPathInModule: 'entities',
+          migrationsPathInModule: 'migrations',
+          modulePathInProject: 'src/data/db'
+        }
+      },
+      loadConfigOptions: appModuleOptions
+    };
+    apps = await NodeCApp.start([AppModule] as unknown as NestModule[], options);
+    // The loadConfig method should be called once with the provided options.
+    expect(loadConfigSpy).toHaveBeenCalledTimes(2);
+    // For each key in data (here just 1 - "db"), generateOrmconfig should be called.
+    expect(generateOrmconfigSpy).toHaveBeenCalledTimes(1);
+    expect(apps).toHaveLength(1);
+  });
+  it('should call loadConfig and generateOrmconfig when loadConfigOptions and generateOrmConfig are provided, but generateOrmConfigModuleOptions are not provided', async () => {
+    const generateOrmconfigSpy = vi.spyOn(ConfigProviderService, 'generateOrmconfig');
+    const loadConfigSpy = vi.spyOn(ConfigProviderService, 'loadConfig');
+    const options: NodeCAppStartOptions = {
+      generateOrmConfig: true,
+      loadConfigOptions: appModuleOptions
+    };
+    generateOrmconfigSpy.mockClear();
+    loadConfigSpy.mockClear();
+    apps = await NodeCApp.start([AppModule] as unknown as NestModule[], options);
+    // The loadConfig method should be called once with the provided options.
+    expect(loadConfigSpy).toHaveBeenCalledTimes(2);
+    // For each key in data (here just 1 - "db"), generateOrmconfig should be called.
+    expect(generateOrmconfigSpy).toHaveBeenCalledTimes(1);
+    expect(apps).toHaveLength(1);
+  });
+  it('should configure API server for a module with matching apiModulesOptions', async () => {
+    // Provide an apiModulesOptions mapping module index "1" to "test".
+    const options: NodeCAppStartOptions = {
+      apiModulesOptions: [{ appModuleIndex: 1, apiModuleName: 'test' }],
+      loadConfigOptions: {
+        appConfigs: appModuleOptions.appConfigs,
+        envKeys: { API: { TEST: { HOST: 'hostname', PORT: 'port' } } },
+        envKeysParentNames: { API: { children: { TEST: 'test' }, name: 'api' } }
+      }
+    };
+    // Call start with two modules.
+    apps = await NodeCApp.start([AppModule, AppModuleWithAPIStartable] as unknown as NestModule[], options);
+    expect(apps).toHaveLength(2);
+    const response = await fetch('http://localhost:3000');
+    expect(response.status).toEqual(404);
+  });
+  it('should not call app.listen if the API config lacks hostname or port', async () => {
+    const options: NodeCAppStartOptions = {
+      apiModulesOptions: [{ appModuleIndex: 0, apiModuleName: 'users' }]
+    };
+    apps = await NodeCApp.start([AppModule, AppModuleWithAPI] as unknown as NestModule[], options);
+    expect(apps).toHaveLength(2);
+    await expect(fetch('http://localhost:3000')).rejects.toThrow('fetch failed');
+  });
+});

package/src/app.ts

@@ -0,0 +1,120 @@
+import { DynamicModule, INestApplication } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+
+import {
+  AppConfig,
+  AppConfigDataRDB,
+  ConfigProviderModuleOptions,
+  ConfigProviderService,
+  RDBType
+} from './common/configProvider';
+import { LoggerService } from './common/logger';
+
+export interface NodeCAppGenerateOrmConfigModuleOptions {
+  [moduleName: string]: {
+    entitiesPathInModule: string;
+    migrationsPathInModule: string;
+    modulePathInProject: string;
+  };
+}
+
+export interface NodeCAppStartOptions {
+  apiModulesOptions?: { appModuleIndex: number; apiModuleName: string }[];
+  generateOrmConfig?: boolean;
+  generateOrmConfigModuleOptions?: NodeCAppGenerateOrmConfigModuleOptions;
+  loadConfigOptions?: ConfigProviderModuleOptions;
+}
+
+export class NodeCApp {
+  // TODO: start each server in a different process
+  static async start(
+    appModules: DynamicModule[],
+    options?: NodeCAppStartOptions
+  ): Promise<INestApplication<unknown>[]> {
+    console.info(`[Node-C]: Launching ${appModules.length} applications...`);
+    const { apiModulesOptions, generateOrmConfig, generateOrmConfigModuleOptions, loadConfigOptions } = options || {};
+    const apiModulesOptionsMap = new Map<string, string>();
+    const apps: INestApplication<unknown>[] = [];
+    let config: AppConfig | undefined;
+    // generate the ormconfig.json files for the RDB data modules that use TypeOrm, such as MySQL and PostgreSQL
+    if (loadConfigOptions) {
+      console.info('[Node-C]: Loading configurations...');
+      const { appConfigs, ...otherOptions } = loadConfigOptions;
+      config = await ConfigProviderService.loadConfig(appConfigs, otherOptions);
+      if (generateOrmConfig) {
+        const moduleOptionsPerName = generateOrmConfigModuleOptions || {};
+        const { data } = config;
+        for (const moduleName in data) {
+          const { type } = data[moduleName] as AppConfigDataRDB;
+          if (type === RDBType.ClickHouse || !Object.values(RDBType).includes(type as RDBType)) {
+            continue;
+          }
+          await ConfigProviderService.generateOrmconfig(config, {
+            ...(moduleOptionsPerName[moduleName] || {
+              entitiesPathInModule: 'entities',
+              migrationsPathInModule: 'migrations',
+              modulePathInProject: `src/data/${moduleName}`,
+              seedsPathInModule: 'seeds'
+            }),
+            moduleName
+          });
+        }
+      }
+      console.info('[Node-C]: Configurations loaded.');
+    }
+    if (apiModulesOptions && apiModulesOptions.length) {
+      apiModulesOptions.forEach(item => {
+        apiModulesOptionsMap.set(`${item.appModuleIndex}`, item.apiModuleName);
+      });
+    }
+    for (const i in appModules) {
+      console.info(`[Node-C]: Preparing app module no. ${i}...`);
+      // create the nest app from the module
+      const apiModuleName = apiModulesOptionsMap.get(i);
+      if (!apiModuleName) {
+        console.info(`[Node-C][${i}]: No api module found. Creating standalone app...`);
+        const app = await NestFactory.createApplicationContext(appModules[i]);
+        app.useLogger(app.get(LoggerService));
+        apps.push(app as INestApplication);
+        console.info(`[Node-C][${i}]: Standalone created successfully.`);
+        continue;
+      }
+      console.info(`[Node-C][${i}]: Api module found. Creating network app...`);
+      const app = await NestFactory.create(appModules[i], { bodyParser: false });
+      app.useLogger(app.get(LoggerService));
+      console.info(`[Node-C]: Created a network app for module no ${i} (API module name "${apiModuleName}").`);
+      // TODO: starting the network app will potentially cause problems, so we can't rely on the config being loaded after the app
+      if (!config) {
+        config = app.get(ConfigProviderService).config;
+      }
+      const { api: apiConfigs } = config;
+      const apiConfig = apiConfigs[apiModuleName];
+      // start an API server, if requested in the options
+      if (apiConfig) {
+        const { hostname, port } = apiConfig;
+        if (hostname && port) {
+          console.info(`[Node-C][${i}/${apiModuleName}]: Starting listeners...`);
+          // TODO: move the following app.set and app.use to the http module
+          // eslint-disable-next-line no-unused-vars
+          (app as unknown as { set: (...args: unknown[]) => void }).set('query parser', 'extended');
+          app.use((req: { query: unknown }, _res: unknown, next: () => void) => {
+            Object.defineProperty(req, 'query', {
+              ...Object.getOwnPropertyDescriptor(req, 'query'),
+              value: req.query,
+              writable: true
+            });
+            next();
+          });
+          await app.listen(port as number, hostname as string);
+          console.info(`[NODE-C][${i}/${apiModuleName}] Server listening at ${hostname}:${port}.`);
+        } else {
+          console.info(`[Node-C][${i}/${apiModuleName}]: No listener configuration found.`);
+        }
+      } else {
+        console.info(`[Node-C][${i}/${apiModuleName}]: No API config found.`);
+      }
+      apps.push(app as INestApplication);
+    }
+    return apps;
+  }
+}

package/src/common/configProvider/configProvider.definitions.ts

@@ -0,0 +1,444 @@
+import { GenericObject, HttpMethod } from '../definitions';
+
+/*
+ * This object contains the names of the fields within the modules, by module category.
+ */
+export const APP_CONFIG_FROM_ENV_KEYS: AppConfigFromEnvKeys = {
+  API: {
+    HTTP: {
+      API_KEY: 'apiKey',
+      API_SECRET: 'apiSecret',
+      API_SECRET_ALGORITHM: 'apiSecretAlgorithm',
+      HOSTNAME: 'hostname',
+      PORT: 'port'
+    },
+    REST: {
+      API_KEY: 'apiKey',
+      API_SECRET: 'apiSecret',
+      API_SECRET_ALGORITHM: 'apiSecretAlgorithm',
+      HOSTNAME: 'hostname',
+      PORT: 'port'
+    }
+  },
+  DOMAIN: {
+    IAM: {
+      JWT_ACCESS_SECRET: 'jwtAccessSecret',
+      JWT_REFRESH_SECRET: 'jwtRefreshSecret'
+    }
+  },
+  DATA: {
+    NOSQL: {
+      HOST: 'host',
+      PASSWORD: 'password',
+      SENTINEL_PASSWORD: 'sentinelPassword',
+      PORT: 'port',
+      USER: 'user'
+    },
+    RDB: {
+      DATABASE_NAME: 'database',
+      HOST: 'host',
+      PASSWORD: 'password',
+      PORT: 'port',
+      USER: 'user'
+    }
+  }
+};
+
+/*
+ * This object contains the names of the module categories and the modules themselves.
+ * The module names here are examples, corresponding to the object above.
+ * In order for this to work, each module in the .env files should have a key ending with
+ * _MODULE_TYPE, whose value correesponds to the values define in the 'children' here.
+ */
+export const APP_CONFIG_FROM_ENV_KEYS_PARENT_NAMES: AppConfigFromEnvKeysParentNames = {
+  API: {
+    children: {
+      HTTP: 'http',
+      REST: 'rest'
+    },
+    name: 'api'
+  },
+  DOMAIN: {
+    children: {
+      IAM: 'iam'
+    },
+    name: 'domain'
+  },
+  DATA: {
+    children: {
+      DB: 'db',
+      REDIS: 'redis',
+      VALKEY: 'valkey'
+    },
+    name: 'data'
+  }
+};
+
+type AppConfigIntermediate = AppConfigCommon & AppConfigProfile & AppConfigFromEnv;
+export type AppConfig = AppConfigIntermediate & Required<Pick<AppConfigIntermediate, 'api'>>;
+type AppConfigAPIHTTPIntermediate = AppConfigCommonAPIHTTP & AppConfigFromEnvAPIHTTP;
+export type AppConfigAPIHTTP = AppConfigAPIHTTPIntermediate &
+  Required<Pick<AppConfigAPIHTTPIntermediate, 'allowedOrigins' | 'anonymousAccessRoutes' | 'hostname' | 'port'>>;
+export type AppConfigAPIREST = AppConfigCommonAPIREST & AppConfigFromEnvAPIREST;
+
+export type AppConfigDomainIAM = AppConfigCommonDomainIAM & AppConfigFromEnvDomainIAM & AppConfigProfileDomainIAM;
+
+export enum AppConfigDomainIAMAuthenticationStep {
+  // eslint-disable-next-line no-unused-vars
+  Complete = 'complete',
+  // eslint-disable-next-line no-unused-vars
+  Initiate = 'initiate'
+}
+
+export type AppConfigDataNoSQL = AppConfigCommonDataNoSQL & AppConfigFromEnvDataNoSQL & AppConfigProfileDataNoSQL;
+export type AppConfigDataRDB = AppConfigCommonDataClickHouse &
+  AppConfigCommonDataRDB &
+  AppConfigCommonDataClickHouse &
+  AppConfigFromEnvDataRDB &
+  AppConfigProfileDataClickHouse &
+  AppConfigProfileDataRDB;
+
+/*
+ * Config data held in the common config file.
+ */
+
+export interface AppConfigCommon {
+  api?: { [apiName: string]: GenericObject | AppConfigCommonAPIHTTP | AppConfigCommonAPIREST };
+  domain: { [domainName: string]: GenericObject | AppConfigCommonDomainIAM };
+  general: {
+    projectName: string;
+    projectRootPath: string;
+    projectVersion: string;
+  };
+  data: {
+    [moduleName: string]:
+      | GenericObject
+      | AppConfigCommonDataClickHouse
+      | AppConfigCommonDataNoSQL
+      | AppConfigCommonDataRDB;
+  };
+}
+
+export interface AppConfigCommonAPIHTTP {
+  allowedOrigins?: string[];
+  anonymousAccessRoutes?: Record<string, HttpMethod[]>;
+  endpointSecurityMode?: EndpointSecurityMode;
+  hostname?: string;
+  port?: number;
+}
+export type AppConfigCommonAPIREST = AppConfigCommonAPIHTTP;
+
+export interface AppConfigCommonDomainIAM {
+  accessTokenExpiryTimeInMinutes?: number;
+  authServiceSettings?: GenericObject<{
+    secretKey?: {
+      secretKeyHMACAlgorithm?: string;
+    };
+    oauth2?: {
+      accessTokenAudiences?: string[];
+      accessTokenEmailField?: string;
+      accessTokenGrantUrl?: string;
+      authorizationUrl?: string;
+      codeChallengeMethod: string; // code_challenge_method
+      defaultScope?: string;
+      issuerUri?: string;
+      redirectUri?: string; // redirect_uri
+      verifyTokensLocally?: boolean;
+    };
+    processExternalTokensOnVerify?: boolean;
+    steps: AppConfigCommonDomainIAMAuthServiceConfigStepSettings;
+  }>;
+  defaultUserIdentifierField: string;
+  refreshTokenExpiryTimeInMinutes?: number;
+}
+
+export interface AppConfigCommonDomainIAMAuthServiceConfigBaseStepSettings {
+  findUser?: boolean;
+  findUserBeforeAuth?: boolean;
+  stepResultPublicFields?: string[];
+  validWithoutUser?: boolean;
+}
+
+export interface AppConfigCommonDomainIAMAuthServiceConfigCacheSettings {
+  cacheFieldName: string;
+  inputFieldName: string;
+}
+
+export interface AppConfigCommonDomainIAMAuthServiceConfigCachePopulationSettings {
+  data?: boolean | AppConfigCommonDomainIAMAuthServiceConfigCacheSettings[];
+  options?: boolean | AppConfigCommonDomainIAMAuthServiceConfigCacheSettings[];
+  result?: boolean | AppConfigCommonDomainIAMAuthServiceConfigCacheSettings[];
+}
+
+export interface AppConfigCommonDomainIAMAuthServiceConfigCacheUsageSettings {
+  data?: AppConfigCommonDomainIAMAuthServiceConfigCacheUsageSettingsItem;
+  options?: AppConfigCommonDomainIAMAuthServiceConfigCacheUsageSettingsItem;
+  result?: AppConfigCommonDomainIAMAuthServiceConfigCacheUsageSettingsItem;
+}
+
+export interface AppConfigCommonDomainIAMAuthServiceConfigCacheUsageSettingsItem {
+  overwrite?: boolean;
+  use: boolean;
+}
+
+export interface AppConfigCommonDomainIAMAuthServiceConfigCompleteSettings extends AppConfigCommonDomainIAMAuthServiceConfigBaseStepSettings {
+  authReturnsTokens?: boolean;
+  cache?: {
+    settings: AppConfigCommonDomainIAMAuthServiceConfigCacheSettings;
+    use?: AppConfigCommonDomainIAMAuthServiceConfigCacheUsageSettings;
+  };
+  createUser?: boolean;
+  decodeReturnedTokens?: boolean;
+  findUserInAuthResultBy?: { userFieldName: string; resultFieldName: string };
+  useReturnedTokens?: boolean;
+}
+
+export interface AppConfigCommonDomainIAMAuthServiceConfigInitiateSettings extends AppConfigCommonDomainIAMAuthServiceConfigBaseStepSettings {
+  cache?: {
+    populate?: AppConfigCommonDomainIAMAuthServiceConfigCachePopulationSettings;
+    settings: AppConfigCommonDomainIAMAuthServiceConfigCacheSettings;
+  };
+}
+
+export interface AppConfigCommonDomainIAMAuthServiceConfigStepSettings {
+  [AppConfigDomainIAMAuthenticationStep.Complete]: AppConfigCommonDomainIAMAuthServiceConfigCompleteSettings;
+  [AppConfigDomainIAMAuthenticationStep.Initiate]: AppConfigCommonDomainIAMAuthServiceConfigInitiateSettings;
+}
+
+export type AppConfigCommonData = {
+  failOnConnectionError?: boolean;
+  settingsPerEntity?: Record<string, AppConfigCommonDataEntityServiceSettings>;
+} & AppConfigCommonDataEntityServiceSettings;
+
+export interface AppConfigCommonDataEntityServiceSettings {
+  processFiltersAllowedFieldsEnabled?: boolean;
+  processInputAllowedFieldsEnabled?: boolean;
+}
+
+export interface AppConfigCommonDataClickHouse extends AppConfigCommonData {
+  application?: string;
+  requestTimeout?: number;
+  type: RDBType;
+  useHostParam?: boolean;
+}
+
+export interface AppConfigCommonDataNoSQL extends AppConfigCommonData {
+  clusterMode?: boolean;
+  defaultIndividualSearchEnabled?: boolean;
+  defaultTTL?: number;
+  sentinelMasterName?: string;
+  sentinelMode?: boolean;
+  sentinelRole?: 'master' | 'slave';
+  storeDelimiter?: string;
+  storeKey: string;
+  settingsPerEntity?: Record<string, AppConfigCommonDataNoSQLEntityServiceSettings>;
+  type: NoSQLType;
+  useHashmap?: boolean;
+  usePasswordForSentinelPassword?: boolean;
+  validationSettings?: AppConfigCommonDataNoSQLValidationSettings;
+}
+
+export interface AppConfigCommonDataNoSQLEntityServiceSettings extends AppConfigCommonDataEntityServiceSettings {
+  defaultIndividualSearchEnabled?: boolean;
+  ttl?: number;
+  validationSettings?: AppConfigCommonDataNoSQLValidationSettings;
+}
+
+export interface AppConfigCommonDataNoSQLValidationSettings {
+  throwErrorOnExtraProperies?: boolean;
+  isEnabled?: boolean;
+  whitelistProperties?: boolean;
+}
+
+export interface AppConfigCommonDataRDB extends AppConfigCommonData {
+  connectionName: string;
+  type: RDBType;
+}
+
+/*
+ * Config data coming from env files.
+ */
+
+export interface AppConfigFromEnv {
+  api?: { [apiName: string]: GenericObject | AppConfigFromEnvAPIHTTP | AppConfigFromEnvAPIREST };
+  domain?: { [domainName: string]: GenericObject | AppConfigFromEnvDomainIAM };
+  data?: {
+    [moduleName: string]: GenericObject | AppConfigFromEnvDataNoSQL | AppConfigFromEnvDataRDB;
+  };
+}
+
+export interface AppConfigFromEnvAPIHTTP extends AppConfigCommonAPIHTTP {
+  apiKey?: string;
+  apiSecret?: string;
+  apiSecretAlgorithm?: string;
+}
+
+export type AppConfigFromEnvAPIREST = AppConfigFromEnvAPIHTTP;
+
+export interface AppConfigFromEnvDomainIAM {
+  jwtAccessSecret: string;
+  jwtRefreshSecret: string;
+  authServiceSettings?: GenericObject<{
+    secretKey?: {
+      hashingSecret?: string;
+    };
+    oauth2?: {
+      clientId: string; // client_id
+      clientSecret: string; // client_secret
+    };
+  }>;
+}
+
+export interface AppConfigFromEnvKeys {
+  [moduleCategory: string]: {
+    [moduleType: string]: Record<string, string>;
+  };
+}
+
+export interface AppConfigFromEnvKeysParentNames {
+  [moduleCategory: string]: {
+    children: Record<string, string>;
+    name: string;
+  };
+}
+
+export interface AppConfigFromEnvDataNoSQL {
+  host: string;
+  password: string;
+  port: number;
+  sentinelPassword?: string;
+  user?: string;
+}
+
+export interface AppConfigFromEnvDataRDB {
+  database: string;
+  host: string;
+  password: string;
+  port: number;
+  user: string;
+}
+
+/*
+ * Config data coming from configProfile files.
+ */
+
+export interface AppConfigProfile {
+  api?: { [apiName: string]: GenericObject | AppConfigProfileAPIHTTP | AppConfigProfileAPIREST };
+  domain?: { [domainName: string]: GenericObject | AppConfigProfileDomainIAM };
+  general: {
+    environment: AppEnvironment;
+    projectName?: string;
+    projectVersion?: string;
+  };
+  data?: {
+    [dataModuleName: string]:
+      | GenericObject
+      | AppConfigProfileDataClickHouse
+      | AppConfigProfileDataNoSQL
+      | AppConfigProfileDataRDB;
+  };
+}
+
+export type AppConfigProfileAPIHTTP = AppConfigCommonAPIHTTP;
+export type AppConfigProfileAPIREST = AppConfigProfileAPIHTTP;
+
+export interface AppConfigProfileDomainIAM {
+  accessTokenExpiryTimeInMinutes?: number;
+  authServiceSettings?: GenericObject<{
+    oauth2?: {
+      accessTokenAudiences?: string[];
+      accessTokenEmailField?: string;
+      accessTokenGrantUrl?: string;
+      authorizationUrl?: string;
+      codeChallengeMethod: string; // code_challenge_method
+      defaultScope?: string;
+      issuerUri?: string;
+      redirectUri?: string; // redirect_uri
+      verifyTokensLocally?: boolean;
+    };
+    processExternalTokensOnVerify?: boolean;
+  }>;
+  refreshTokenExpiryTimeInMinutes?: number;
+}
+
+export type AppConfigProfileDataClickHouse = AppConfigCommonDataClickHouse & {
+  protocol?: string;
+};
+export type AppConfigProfileDataNoSQL = AppConfigCommonDataNoSQL;
+export type AppConfigProfileDataRDB = AppConfigCommonDataRDB & {
+  typeormExtraOptions?: GenericObject;
+};
+
+export enum AppEnvironment {
+  // eslint-disable-next-line no-unused-vars
+  Development = 'development',
+  // eslint-disable-next-line no-unused-vars
+  Local = 'local',
+  // eslint-disable-next-line no-unused-vars
+  Production = 'production',
+  // eslint-disable-next-line no-unused-vars
+  Staging = 'staging',
+  // eslint-disable-next-line no-unused-vars
+  Test = 'endToEndTests'
+}
+
+/*
+ * Other config-related definitions.
+ */
+
+export interface ConfigProviderModuleOptions extends LoadConfigOptions {
+  appConfigs: LoadConfigAppConfigs;
+}
+
+// TODO: figure out how to move this to the Domain-IAM package
+export enum EndpointSecurityMode {
+  // eslint-disable-next-line no-unused-vars
+  Lax = 'lax',
+  // eslint-disable-next-line no-unused-vars
+  Strict = 'strict'
+}
+
+export interface GenerateOrmconfigOptions {
+  entitiesPathInModule: string;
+  migrationsPathInModule: string;
+  moduleName: string;
+  modulePathInProject: string;
+  seedsPathInModule?: string;
+}
+
+// TODO: figure out how to move this to the Redis package
+export enum NoSQLType {
+  // eslint-disable-next-line no-unused-vars
+  Redis = 'redis',
+  // eslint-disable-next-line no-unused-vars
+  Valkey = 'valkey'
+}
+
+// TODO: figure out how to move this to the RDB package
+export enum RDBType {
+  // eslint-disable-next-line no-unused-vars
+  Aurora = 'aurora',
+  // eslint-disable-next-line no-unused-vars
+  ClickHouse = 'clickhouse',
+  // eslint-disable-next-line no-unused-vars
+  MySQL = 'mysql',
+  // eslint-disable-next-line no-unused-vars
+  PG = 'postgres'
+}
+
+export type LoadConfigAppConfigs<
+  AppConfigCommonType extends AppConfigCommon = AppConfigCommon,
+  AppConfigProfileType extends AppConfigProfile = AppConfigProfile
+> =
+  | {
+      appConfigCommon: AppConfigCommonType;
+    }
+  | GenericObject<AppConfigProfileType>;
+
+export interface LoadConfigOptions {
+  envKeys?: AppConfigFromEnvKeys;
+  envKeysParentNames?: AppConfigFromEnvKeysParentNames;
+  envName?: AppEnvironment;
+  useEnvFile?: boolean;
+  useEnvFileWithPriority?: boolean;
+}