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

package/src/common/configProvider/configProvider.module.spec.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { AppConfig, AppEnvironment, ConfigProviderModuleOptions } from './configProvider.definitions';
+import { ConfigProviderModule } from './configProvider.module';
+import { ConfigProviderService } from './configProvider.service';
+
+import { Constants } from '../definitions';
+
+// Helper type predicate: checks if a provider is a factory provider for a given token.
+function isFactoryProvider<T, U>(
+  provider: unknown,
+  token: T
+): provider is { provide: T; useFactory: () => Promise<U> } {
+  if (typeof provider !== 'object' || provider === null) {
+    return false;
+  }
+  const p = provider as { provide?: T; useFactory?: unknown };
+  return p.provide === token && typeof p.useFactory === 'function';
+}
+
+describe('ConfigProviderModule', () => {
+  // Create a fake AppConfig with full type information.
+  const fakeAppConfig: AppConfig = {
+    api: {},
+    domain: {},
+    general: {
+      environment: AppEnvironment.Local,
+      projectName: 'TestProject',
+      projectRootPath: '/fake/path',
+      projectVersion: '1.0.0'
+    },
+    data: {}
+  };
+  const fakeEnvKeys = {
+    API: {
+      HTTP: { HOST: 'hostname', PORT: 'port' }
+    }
+  };
+  const fakeEnvKeysParentNames = {
+    API: {
+      children: { TEST: 'test' },
+      name: 'api'
+    }
+  };
+  const fakeModuleOptions: ConfigProviderModuleOptions = {
+    appConfigs: { appConfigCommon: fakeAppConfig },
+    envKeys: fakeEnvKeys,
+    envKeysParentNames: fakeEnvKeysParentNames
+  };
+
+  describe('register()', () => {
+    it('should return a dynamic module with proper configuration', async () => {
+      // Spy on loadConfig so that the factory returns our fake config.
+      const loadConfigSpy = vi.spyOn(ConfigProviderService, 'loadConfig').mockResolvedValue(fakeAppConfig);
+      const dynamicModule = ConfigProviderModule.register(fakeModuleOptions);
+      // Verify dynamic module properties.
+      expect(dynamicModule.global).toBe(true);
+      expect(dynamicModule.module).toBe(ConfigProviderModule);
+      expect(dynamicModule.providers).toEqual(
+        expect.arrayContaining([expect.objectContaining({ provide: Constants.CONFIG }), ConfigProviderService])
+      );
+      expect(dynamicModule.exports).toEqual([Constants.CONFIG, ConfigProviderService]);
+      // Locate the provider with the injection token.
+      const configProvider = dynamicModule.providers?.find(p =>
+        isFactoryProvider<Constants, AppConfig>(p, Constants.CONFIG)
+      ) as unknown as { useFactory: () => Promise<ConfigProviderService> };
+      expect(configProvider).toBeDefined();
+      // Call the useFactory and verify it returns the fake config.
+      const producedConfig = await configProvider.useFactory();
+      expect(producedConfig).toEqual(fakeAppConfig);
+      expect(loadConfigSpy).toHaveBeenCalledWith(
+        { appConfigCommon: fakeAppConfig },
+        {
+          envKeys: fakeEnvKeys,
+          envKeysParentNames: fakeEnvKeysParentNames
+        }
+      );
+    });
+    it('should propagate errors from the loadConfig factory', async () => {
+      const error = new Error('Load config failed');
+      vi.spyOn(ConfigProviderService, 'loadConfig').mockRejectedValue(error);
+      const dynamicModule = ConfigProviderModule.register(fakeModuleOptions);
+      const configProvider = dynamicModule.providers?.find(p =>
+        isFactoryProvider<Constants, AppConfig>(p, Constants.CONFIG)
+      ) as unknown as { useFactory: () => Promise<ConfigProviderService> };
+      expect(configProvider).toBeDefined();
+      await expect(configProvider.useFactory()).rejects.toThrow('Load config failed');
+    });
+  });
+});

package/src/common/configProvider/configProvider.module.ts

@@ -0,0 +1,25 @@
+import { DynamicModule, Module } from '@nestjs/common';
+
+import { ConfigProviderModuleOptions } from './configProvider.definitions';
+import { ConfigProviderService } from './configProvider.service';
+
+import { Constants } from '../definitions';
+
+@Module({})
+export class ConfigProviderModule {
+  static register(options: ConfigProviderModuleOptions): DynamicModule {
+    const { appConfigs, ...otherOptions } = options;
+    return {
+      global: true,
+      module: ConfigProviderModule,
+      providers: [
+        {
+          provide: Constants.CONFIG,
+          useFactory: async () => await ConfigProviderService.loadConfig(appConfigs, { ...otherOptions })
+        },
+        ConfigProviderService
+      ],
+      exports: [Constants.CONFIG, ConfigProviderService]
+    };
+  }
+}

package/src/common/configProvider/configProvider.service.spec.ts

@@ -0,0 +1,206 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+import im from 'immutable';
+import { mergeDeepRight } from 'ramda';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  AppConfig,
+  AppConfigCommon,
+  AppEnvironment,
+  GenerateOrmconfigOptions,
+  LoadConfigAppConfigs
+} from './configProvider.definitions';
+import { ConfigProviderService } from './configProvider.service';
+
+const BASE_PATH = path.join(__dirname, '../../../test');
+
+describe('ConfigProviderService', () => {
+  describe('constructor', () => {
+    it('should assign the passed config to the service', () => {
+      const fakeConfig: AppConfig = {
+        api: {},
+        domain: {},
+        general: {
+          environment: AppEnvironment.Local,
+          projectName: 'TestProject',
+          projectRootPath: '/some/path',
+          projectVersion: '1.0.0'
+        },
+        data: {}
+      };
+      const service = new ConfigProviderService(fakeConfig);
+      expect(service.config).toEqual(fakeConfig);
+    });
+  });
+
+  // generateOrmconfig
+  describe('generateOrmconfig', () => {
+    const defaultFakeModuleName = 'db';
+    const defaultFakeOptions: GenerateOrmconfigOptions = {
+      entitiesPathInModule: 'entities',
+      migrationsPathInModule: 'migrations',
+      moduleName: defaultFakeModuleName,
+      modulePathInProject: 'src/data/db'
+    };
+    const defaultFakeConfig: AppConfig = {
+      api: {},
+      domain: {},
+      general: {
+        environment: AppEnvironment.Local,
+        projectName: 'TestProject',
+        projectRootPath: BASE_PATH,
+        projectVersion: '1.0.0'
+      },
+      data: {
+        [defaultFakeModuleName]: { type: 'mysql', extra: 'foo' }
+      }
+    };
+    let fakeModuleName: string;
+    let fakeOptions: GenerateOrmconfigOptions;
+    let fakeConfig: AppConfig;
+    let entitiesDirPath: string;
+    let migrationsPath: string;
+    let ormConfigPath: string;
+    // clean up before each test
+    beforeEach(async () => {
+      fakeModuleName = defaultFakeModuleName;
+      fakeOptions = im.fromJS(defaultFakeOptions).toJS() as unknown as GenerateOrmconfigOptions;
+      fakeConfig = im.fromJS(defaultFakeConfig).toJS() as unknown as AppConfig;
+      entitiesDirPath = path.join(BASE_PATH, fakeOptions.modulePathInProject, fakeOptions.entitiesPathInModule);
+      migrationsPath = path.join(BASE_PATH, fakeOptions.modulePathInProject, fakeOptions.migrationsPathInModule);
+      ormConfigPath = path.join(BASE_PATH, `ormconfig-${fakeModuleName}.json`);
+      try {
+        await fs.unlink(ormConfigPath);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      } catch (_e: unknown) {}
+    });
+    it('should generate ormconfig file with entities and subscribers arrays correctly', async () => {
+      await ConfigProviderService.generateOrmconfig(fakeConfig, fakeOptions);
+      const expectedEntities = [
+        path.join(entitiesDirPath, 'orders', 'orders.entity.ts'),
+        path.join(entitiesDirPath, 'users', 'users.entity.ts')
+      ];
+      const expectedSubscribers = [
+        path.join(entitiesDirPath, 'orders', 'orders.subscriber.ts'),
+        path.join(entitiesDirPath, 'users', 'users.subscriber.ts')
+      ];
+      const expectedMergedConfig = mergeDeepRight(fakeConfig.data[fakeModuleName], {
+        entities: expectedEntities,
+        subscribers: expectedSubscribers,
+        migrations: [`${migrationsPath}/**/*.ts`],
+        cli: { migrationsDir: migrationsPath }
+      });
+      expect((await fs.readFile(ormConfigPath)).toString()).toEqual(JSON.stringify(expectedMergedConfig));
+    });
+    it('should handle case with empty entities directory (no folders)', async () => {
+      fakeOptions.entitiesPathInModule = 'entitiesEmpty';
+      await ConfigProviderService.generateOrmconfig(fakeConfig, fakeOptions);
+      const expectedMergedConfig = mergeDeepRight(fakeConfig.data[fakeModuleName], {
+        entities: [],
+        subscribers: [],
+        migrations: [`${migrationsPath}/**/*.ts`],
+        cli: { migrationsDir: migrationsPath }
+      });
+      expect((await fs.readFile(ormConfigPath)).toString()).toEqual(JSON.stringify(expectedMergedConfig));
+    });
+    it('should ignore files that do not match entity or subscriber patterns', async () => {
+      await ConfigProviderService.generateOrmconfig(fakeConfig, fakeOptions);
+      const writtenConfig = JSON.parse((await fs.readFile(ormConfigPath)).toString());
+      expect(writtenConfig.entities).toEqual(
+        expect.arrayContaining([
+          path.join(entitiesDirPath, 'users', 'users.entity.ts'),
+          path.join(entitiesDirPath, 'orders', 'orders.entity.ts')
+        ])
+      );
+      expect(writtenConfig.entities).not.toEqual(
+        expect.arrayContaining([
+          path.join(entitiesDirPath, 'misc', 'note.txt'),
+          path.join(entitiesDirPath, 'misc', 'helper.ts')
+        ])
+      );
+    });
+    it('should propagate error if fs.readdir fails', async () => {
+      fakeOptions.entitiesPathInModule = 'entitiesNotExistent';
+      await expect(ConfigProviderService.generateOrmconfig(fakeConfig, fakeOptions)).rejects.toThrow('ENOENT');
+    });
+  });
+
+  // loadConfig
+  describe('loadConfig', () => {
+    const defaultAppConfigs: LoadConfigAppConfigs = {
+      appConfigCommon: {
+        general: {
+          projectName: 'TestProject',
+          projectRootPath: BASE_PATH,
+          projectVersion: '1.0.0'
+        },
+        api: {
+          test: {}
+        },
+        domain: {},
+        data: {}
+      },
+      appConfigProfileLocal: {
+        general: { environment: AppEnvironment.Local }
+      }
+    };
+    const defaultEnvKeys = {
+      API: {
+        HTTP: { HOST: 'hostname', PORT: 'port' }
+      }
+    };
+    const defaultEnvKeysParentNames = {
+      API: {
+        children: { TEST: 'test' },
+        name: 'api'
+      }
+    };
+    let appConfigs: LoadConfigAppConfigs;
+
+    beforeEach(() => {
+      process.env.NODE_ENV = 'local';
+      appConfigs = im.fromJS(defaultAppConfigs).toJS() as unknown as LoadConfigAppConfigs;
+    });
+    it('should load and merge configuration from env file and populate nested values', async () => {
+      delete process.env['NODE_ENV'];
+      const loadedConfig = await ConfigProviderService.loadConfig(appConfigs, {
+        envKeys: defaultEnvKeys,
+        envKeysParentNames: defaultEnvKeysParentNames
+      });
+      expect(loadedConfig.general.environment).toBe('local');
+      expect(loadedConfig.api).toBeDefined();
+      expect(loadedConfig.api.rest).toBeUndefined();
+      expect(loadedConfig.api.test).toBeDefined();
+      expect(loadedConfig.api.test.hostname).toBe('127.0.0.1');
+      expect(loadedConfig.api.test.port).toBe('3000');
+    });
+    it('should use default envKeys and envKeysParentNames if options not provided', async () => {
+      appConfigs.appConfigCommon.api!.rest = {};
+      const loadedConfig = await ConfigProviderService.loadConfig(appConfigs);
+      expect(loadedConfig.general.environment).toBe('local');
+      expect(loadedConfig.api.rest).toBeDefined();
+      expect(loadedConfig.api.rest.hostname).toBe('localhost');
+      expect(loadedConfig.api.test.hostname).toBeUndefined();
+    });
+    it('should throw an error if the .env file is missing', async () => {
+      (appConfigs.appConfigCommon as AppConfigCommon).general.projectRootPath = '/fake/path';
+      await expect(
+        ConfigProviderService.loadConfig(appConfigs, {
+          envKeys: defaultEnvKeys,
+          envKeysParentNames: defaultEnvKeysParentNames
+        })
+      ).rejects.toThrow('ENOENT');
+    });
+    it('should skip env keys that do not match expected pattern', async () => {
+      const loadedConfig = await ConfigProviderService.loadConfig(appConfigs, {
+        envKeys: defaultEnvKeys,
+        envKeysParentNames: defaultEnvKeysParentNames
+      });
+      expect(loadedConfig.api.test.hostname).toBe('127.0.0.1');
+      expect(loadedConfig.api.test.port).toBe('3000');
+      expect(loadedConfig.api.something).toBeUndefined();
+    });
+  });
+});

package/src/common/configProvider/configProvider.service.ts

@@ -0,0 +1,204 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+import { Inject, Injectable } from '@nestjs/common';
+import dotenv from 'dotenv';
+import ld from 'lodash';
+
+import {
+  APP_CONFIG_FROM_ENV_KEYS as APP_CONFIG_FROM_ENV_KEYS_DEFAULT,
+  APP_CONFIG_FROM_ENV_KEYS_PARENT_NAMES as APP_CONFIG_FROM_ENV_KEYS_PARENT_NAMES_DEFAULT,
+  AppConfigDataRDB,
+  AppConfig as AppConfigDefault,
+  AppEnvironment,
+  GenerateOrmconfigOptions,
+  LoadConfigAppConfigs,
+  LoadConfigOptions,
+  RDBType
+} from './configProvider.definitions';
+
+import { Constants } from '../definitions';
+import { setNested } from '../utils';
+
+@Injectable()
+export class ConfigProviderService<AppConfig extends AppConfigDefault = AppConfigDefault> {
+  constructor(
+    @Inject(Constants.CONFIG)
+    // eslint-disable-next-line no-unused-vars
+    public config: AppConfig
+  ) {}
+
+  // TODO: consider moving this into the data-rdb package
+  static async generateOrmconfig<AppConfig extends AppConfigDefault = AppConfigDefault>(
+    config: AppConfig,
+    options: GenerateOrmconfigOptions
+  ): Promise<void> {
+    const {
+      general: { environment, projectRootPath },
+      data
+    } = config;
+    const { entitiesPathInModule, migrationsPathInModule, moduleName, modulePathInProject, seedsPathInModule } =
+      options;
+    const entitiesDirPath = path.join(projectRootPath, modulePathInProject, entitiesPathInModule);
+    const entitiesDirData = await fs.readdir(entitiesDirPath);
+    const entities: string[] = [];
+    const migrationsPath = path.join(projectRootPath, modulePathInProject, migrationsPathInModule);
+    const moduleConfig = data[moduleName] as AppConfigDataRDB;
+    const subscribers: string[] = [];
+    for (const i in entitiesDirData) {
+      const entityName = entitiesDirData[i];
+      if (entityName.match(/^base$/)) {
+        continue;
+      }
+      const entityFolderPath = path.join(entitiesDirPath, entityName);
+      const entityFolderChildItemStat = await fs.lstat(entityFolderPath);
+      if (!entityFolderChildItemStat.isDirectory()) {
+        continue;
+      }
+      const entityFolderData = await fs.readdir(entityFolderPath);
+      for (const j in entityFolderData) {
+        const entityFolderFileName = entityFolderData[j];
+        if (entityFolderFileName.match(/\.entity\./)) {
+          entities.push(path.join(entityFolderPath, entityFolderFileName));
+          continue;
+        }
+        if (entityFolderFileName.match(/\.subscriber\./)) {
+          subscribers.push(path.join(entityFolderPath, entityFolderFileName));
+          continue;
+        }
+      }
+    }
+    // write the ORM Config file
+    const ormconfigMigrations: string[] = [`${migrationsPath}/**/*.ts`];
+    if (seedsPathInModule) {
+      const baseSeedsPath = path.join(projectRootPath, modulePathInProject, seedsPathInModule);
+      ormconfigMigrations.push(`${baseSeedsPath}/common/**/*.ts`);
+    }
+    await fs.writeFile(
+      path.join(projectRootPath, `ormconfig-${moduleName}-${environment}.json`),
+      JSON.stringify(
+        ld.merge(data[moduleName], {
+          cli: {
+            migrationsDir: migrationsPath
+          },
+          entities: [...entities],
+          migrations: ormconfigMigrations,
+          name: moduleConfig.connectionName,
+          synchronize: moduleConfig.type === RDBType.Aurora ? true : false,
+          subscribers: [...subscribers],
+          type: moduleConfig.type === RDBType.Aurora ? RDBType.MySQL : moduleConfig.type,
+          ...(moduleConfig.typeormExtraOptions || {})
+        })
+      )
+    );
+    // write the Datasource file
+    const entitiesPathInProject = path.join(modulePathInProject, entitiesPathInModule);
+    await fs.writeFile(
+      path.join(projectRootPath, `datasource-${moduleName}-${environment}.ts`),
+      "import { loadDynamicModules } from '@node-c/core';\n" +
+        '\n' +
+        "import { DataSource } from 'typeorm';\n" +
+        '\n' +
+        `import * as FolderData from './${entitiesPathInProject}';\n` +
+        '\n' +
+        'const { entities } = loadDynamicModules(FolderData);\n' +
+        '\n' +
+        'export default new DataSource({\n' +
+        `  database: '${moduleConfig.database}',\n` +
+        '  entities: entities as unknown as string[],\n' +
+        `  host: '${moduleConfig.host}',\n` +
+        '  logging: false,\n' +
+        `  migrations: [${ormconfigMigrations.map(item => `'${item.replace(projectRootPath.replace(/\/$/, ''), '.')}'`).join(', ')}],\n` +
+        `  name: '${moduleConfig.connectionName}',\n` +
+        `  password: '${moduleConfig.password}',\n` +
+        `  port: ${moduleConfig.port},\n` +
+        '  subscribers: [],\n' +
+        `  synchronize: ${moduleConfig.type === RDBType.Aurora ? true : false},\n` +
+        `  type: '${moduleConfig.type === RDBType.Aurora ? RDBType.MySQL : moduleConfig.type}',\n` +
+        `  username: '${moduleConfig.user}'\n` +
+        '});\n'
+    );
+  }
+
+  // TODO: logging about invalid config values
+  static async loadConfig<AppConfig extends AppConfigDefault = AppConfigDefault>(
+    appConfigs: LoadConfigAppConfigs,
+    options?: LoadConfigOptions
+  ): Promise<AppConfig> {
+    const { useEnvFile, useEnvFileWithPriority, ...optionsData } = options || ({} as LoadConfigOptions);
+    const envKeys = optionsData.envKeys || APP_CONFIG_FROM_ENV_KEYS_DEFAULT;
+    const envKeysParentNames = optionsData.envKeysParentNames || APP_CONFIG_FROM_ENV_KEYS_PARENT_NAMES_DEFAULT;
+    const processEnv = process.env;
+    const envName = optionsData.envName || (processEnv['NODE_ENV'] as AppEnvironment) || AppEnvironment.Local;
+    const config = ld.merge(
+      appConfigs.appConfigCommon,
+      appConfigs[
+        `appConfigProfile${envName.charAt(0).toUpperCase()}${envName.substring(
+          1,
+          envName.length
+        )}` as keyof typeof appConfigs
+      ]
+    ) as AppConfig;
+    const moduleNamesByCategoryAndType: {
+      [moduleCategory: string]: { [moduleType: string]: string[] };
+    } = {};
+    const moduleTypesRegex = new RegExp(`^((${Object.keys(envKeys).join(')|(')}))_`);
+    config.general.environment = envName;
+    let envVars: Record<string, unknown> = processEnv;
+    if (useEnvFile) {
+      // populate the data from the .env file into the config object
+      const envVarsFromFile = dotenv.parse(
+        (await fs.readFile(path.join(config.general.projectRootPath, `envFiles/.${envName}.env`))).toString()
+      );
+      if (useEnvFileWithPriority) {
+        envVars = ld.merge(envVars, envVarsFromFile);
+      } else {
+        envVars = ld.merge(envVarsFromFile, envVars);
+      }
+    }
+    // first pass - create a list of modules by name and map them by module type
+    for (const envKey in envVars) {
+      const [, moduleCategory] = envKey.match(moduleTypesRegex) || [];
+      if (!moduleCategory) {
+        continue;
+      }
+      const [, moduleName] = envKey.match(new RegExp(`^${moduleCategory}_(.+)_MODULE_TYPE$`)) || [];
+      if (!moduleName) {
+        continue;
+      }
+      const moduleFields = envKeys[moduleCategory as keyof typeof envKeys];
+      const moduleType = envVars[envKey] as keyof typeof moduleFields;
+      if (!moduleFields[moduleType]) {
+        continue;
+      }
+      if (!moduleNamesByCategoryAndType[moduleCategory]) {
+        moduleNamesByCategoryAndType[moduleCategory] = {};
+      }
+      if (!moduleNamesByCategoryAndType[moduleCategory][moduleType]) {
+        moduleNamesByCategoryAndType[moduleCategory][moduleType] = [];
+      }
+      moduleNamesByCategoryAndType[moduleCategory][moduleType].push(moduleName);
+    }
+    // second pass - actually go through the env vars and populate them in the config accordingly
+    for (const moduleCategory in moduleNamesByCategoryAndType) {
+      const { children: moduleConfigKeysForCategory, name: categoryConfigKey } = envKeysParentNames[moduleCategory];
+      const moduleFieldsForCategory = envKeys[moduleCategory as keyof typeof envKeys];
+      const moduleNamesByType = moduleNamesByCategoryAndType[moduleCategory];
+      for (const moduleType in moduleNamesByType) {
+        const moduleFieldsForType = moduleFieldsForCategory[
+          moduleType as keyof typeof moduleFieldsForCategory
+        ] as Record<string, string>;
+        const moduleNames = moduleNamesByType[moduleType];
+        moduleNames.forEach(moduleName => {
+          const moduleConfigKey = moduleConfigKeysForCategory[moduleName];
+          for (const fieldName in moduleFieldsForType) {
+            const configKey = `${categoryConfigKey}.${moduleConfigKey}.${moduleFieldsForType[fieldName]}`;
+            const envKey = `${moduleCategory}_${moduleName}_${fieldName}`;
+            setNested(config, configKey, envVars[envKey]);
+          }
+        });
+      }
+    }
+    return config;
+  }
+}

package/src/common/configProvider/index.ts

@@ -0,0 +1,3 @@
+export * from './configProvider.definitions';
+export * from './configProvider.module';
+export * from './configProvider.service';

package/src/common/definitions/common.constants.ts

@@ -0,0 +1,27 @@
+export enum Constants {
+  // eslint-disable-next-line no-unused-vars
+  API_MODULE_NAME = 'API_MODULE_NAME',
+  // eslint-disable-next-line no-unused-vars
+  CONFIG = 'CONFIG',
+  // eslint-disable-next-line no-unused-vars
+  DOMAIN_MODULE_NAME = 'DOMAIN_MODULE_NAME',
+  // eslint-disable-next-line no-unused-vars
+  DATA_MODULE_NAME = 'DATA_MODULE_NAME'
+}
+
+export enum HttpMethod {
+  // eslint-disable-next-line no-unused-vars
+  DELETE = 'delete',
+  // eslint-disable-next-line no-unused-vars
+  GET = 'get',
+  // eslint-disable-next-line no-unused-vars
+  HEAD = 'head',
+  // eslint-disable-next-line no-unused-vars
+  OPTIONS = 'options',
+  // eslint-disable-next-line no-unused-vars
+  PATCH = 'patch',
+  // eslint-disable-next-line no-unused-vars
+  POST = 'post',
+  // eslint-disable-next-line no-unused-vars
+  PUT = 'put'
+}

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

@@ -0,0 +1,13 @@
+export interface GenericObject<Values = unknown> {
+  [fieldName: string]: Values;
+}
+
+export class GenericObjectClass<Values = unknown> implements GenericObject<Values> {
+  [fieldName: string]: Values;
+}
+
+export type GenericObjectType<Type> =
+  | {
+      new (): Type;
+    }
+  | ((..._args: unknown[]) => unknown);

package/src/common/definitions/common.errors.ts

@@ -0,0 +1,13 @@
+import { GenericObject } from './common.definitions';
+
+export class ApplicationError implements Error {
+  data?: { errorCode?: number } | GenericObject;
+  message: string;
+  name: string;
+
+  constructor(message: string, data?: GenericObject) {
+    this.message = message;
+    this.name = 'ApplicationError';
+    this.data = data || {};
+  }
+}

package/src/common/definitions/index.ts

@@ -0,0 +1,3 @@
+export * from './common.constants';
+export * from './common.definitions';
+export * from './common.errors';

package/src/common/logger/index.ts

@@ -0,0 +1,3 @@
+export * from './logger.definitions';
+export * from './logger.module';
+export * from './logger.service';

package/src/common/logger/logger.definitions.ts

@@ -0,0 +1,5 @@
+import { Params } from 'nestjs-pino';
+
+export interface LoggerModuleOptions {
+  pinoParams?: Params;
+}

package/src/common/logger/logger.module.ts

@@ -0,0 +1,21 @@
+import { DynamicModule, Module } from '@nestjs/common';
+
+import ld from 'lodash';
+import { LoggerModule as PinoLoggerModule } from 'nestjs-pino';
+
+import { LoggerModuleOptions } from './logger.definitions';
+import { DEFAULT_PINO_PARAMS, LoggerService } from './logger.service';
+
+@Module({})
+export class LoggerModule {
+  static register(options?: LoggerModuleOptions): DynamicModule {
+    const { pinoParams } = options || {};
+    return {
+      global: true,
+      module: LoggerModule,
+      imports: [PinoLoggerModule.forRoot(ld.merge(DEFAULT_PINO_PARAMS, pinoParams || {}))],
+      providers: [LoggerService],
+      exports: [LoggerService]
+    };
+  }
+}

package/src/common/logger/logger.service.ts

@@ -0,0 +1,40 @@
+import path from 'path';
+
+import { Inject, Injectable } from '@nestjs/common';
+
+import { Logger, PARAMS_PROVIDER_TOKEN, Params, PinoLogger } from 'nestjs-pino';
+import { v4 as uuid } from 'uuid';
+
+export const DEFAULT_PINO_PARAMS: Params = {
+  pinoHttp: {
+    // autoLogging: false,
+    genReqId: () => uuid(),
+    quietReqLogger: true,
+    quietResLogger: true,
+    transport: {
+      targets: [
+        {
+          options: { destination: path.resolve(process.cwd(), 'logs/app_logs.txt'), sync: false },
+          target: 'pino/file'
+        },
+        {
+          // level: 'info',
+          options: { destination: 1, sync: false },
+          target: 'pino-pretty'
+        }
+      ]
+    }
+  }
+};
+
+@Injectable()
+export class LoggerService extends Logger {
+  constructor(logger: PinoLogger, @Inject(PARAMS_PROVIDER_TOKEN) params: Params) {
+    super(logger, params);
+  }
+
+  info(...args: unknown[]): void {
+    // eslint-disable-next-line prefer-spread
+    this.logger.info.apply(this, args as [unknown, string, ...unknown[]]);
+  }
+}

package/src/common/utils/base64UrlEncode/base64UrlEncode.method.ts

@@ -0,0 +1,4 @@
+export const base64UrlEncode = (buffer: ArrayBuffer | string): string => {
+  const actualBuffer = typeof buffer === 'string' ? Buffer.from(buffer, 'utf-8') : Buffer.from(buffer);
+  return actualBuffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+};

package/src/common/utils/base64UrlEncode/index.ts

@@ -0,0 +1 @@
+export * from './base64UrlEncode.method';