@node-c/data-typeorm 1.0.0-alpha64 → 1.0.0-beta1

package/src/entityService/typeorm.entity.service.ts

@@ -0,0 +1,23 @@
+import { ConfigProviderService, DataDefaultData, LoggerService } from '@node-c/core';
+import { RDBEntityService, SQLQueryBuilderService } from '@node-c/data-rdb';
+
+import { EntitySchema, ObjectLiteral } from 'typeorm';
+
+import { TypeORMDBRepository } from '../repository';
+
+export class TypeORMDBEntityService<
+  Entity extends ObjectLiteral,
+  Data extends DataDefaultData<Entity> = DataDefaultData<Entity>
+> extends RDBEntityService<Entity, Data> {
+  protected primaryKeys: string[];
+
+  constructor(
+    protected configProvider: ConfigProviderService,
+    protected logger: LoggerService,
+    protected qb: SQLQueryBuilderService,
+    protected repository: TypeORMDBRepository<Entity>,
+    protected schema: EntitySchema
+  ) {
+    super(configProvider, logger, qb, repository, schema);
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './common/definitions';
+export * from './entityService';
+export * from './module';
+export * from './repository';

package/src/module/index.ts

@@ -0,0 +1,2 @@
+export * from './typeorm.module.definitions';
+export * from './typeorm.module';

package/src/module/typeorm.module.definitions.ts

@@ -0,0 +1,19 @@
+import { ModuleMetadata } from '@nestjs/common';
+
+import { GenericObject } from '@node-c/core';
+
+export interface TypeORMDBModuleOptions {
+  connectionName: string;
+  entityModuleRegisterOptions?: unknown;
+  exports?: ModuleMetadata['exports'];
+  folderData: GenericObject<unknown>;
+  imports?: {
+    atEnd?: ModuleMetadata['imports'];
+    postORM?: ModuleMetadata['imports'];
+    preORM?: ModuleMetadata['imports'];
+  };
+  moduleClass: unknown;
+  moduleName: string;
+  providers?: ModuleMetadata['providers'];
+  registerOptionsPerEntityModule?: GenericObject;
+}

package/src/module/typeorm.module.spec.ts

@@ -0,0 +1,148 @@
+import { DynamicModule } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+// import { ConfigProviderService } from '@node-c/core';
+import { SQLQueryBuilderModule } from '@node-c/data-rdb';
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { TypeORMDBModule } from './index';
+
+// Dummy classes to use in tests.
+class AtEndModule {}
+// class DummyEntity {}
+class DummyModule {}
+class LoadedModule {}
+class PostORMModule {}
+class PreORMModule {}
+
+describe('TypeORMDBModule.register', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+  it('should register a module with minimal options', () => {
+    // const fakeEntities = [DummyEntity];
+    const fakeLoadedModules = [LoadedModule];
+    // Spy on SQLQueryBuilderModule.register and provide a dummy implementation.
+    const sqlQueryRegisterSpy = vi
+      .spyOn(SQLQueryBuilderModule, 'register')
+      .mockImplementation((options: { dataModuleName: string }) => {
+        return { module: 'SQLQueryBuilderModule', options } as unknown as DynamicModule;
+      });
+    const options = {
+      connectionName: 'testConnection',
+      folderData: {
+        loadedModule: LoadedModule
+      },
+      moduleClass: DummyModule,
+      moduleName: 'testModule'
+    };
+    const dynamicModule: DynamicModule = TypeORMDBModule.register(options);
+    expect(dynamicModule.module).toBe(DummyModule);
+    expect(dynamicModule.providers).toEqual([]);
+    expect(dynamicModule.exports).toEqual(fakeLoadedModules);
+    // The imports array is composed as:
+    // [ ...preORM, TypeOrmModule.forRootAsync({ ... }), SQLQueryBuilderModule.register({ ... }), ...postORM, ...loadedModules, ...atEnd ]
+    // Since no additional imports were provided, expect:
+    //   index 0: TypeOrmModule.forRootAsync config
+    //   index 1: SQLQueryBuilderModule.register result
+    //   index 2: LoadedModule (from fakeLoadedModules)
+    expect(dynamicModule.imports).toHaveLength(3);
+    // Verify the TypeOrmModule.forRootAsync configuration.
+    const typeOrmAsyncModule = dynamicModule.imports![0] as unknown as {
+      imports: unknown[];
+      module: TypeOrmModule;
+      providers: unknown[];
+    };
+    expect(typeOrmAsyncModule.module).toBe(TypeOrmModule);
+    expect((dynamicModule.imports![1] as unknown as { module: string }).module).toEqual('SQLQueryBuilderModule');
+    // Verify that SQLQueryBuilderModule.register was called with the proper argument.
+    expect(sqlQueryRegisterSpy).toHaveBeenCalledWith({ dataModuleName: 'testModule' });
+    const sqlQueryModule = dynamicModule.imports![1];
+    expect(sqlQueryModule).toEqual({
+      module: 'SQLQueryBuilderModule',
+      options: { dataModuleName: 'testModule' }
+    });
+    // Finally, check that the loaded module from loadDynamicModules is included.
+    expect(dynamicModule.imports![2]).toBe(LoadedModule);
+  });
+  it('should register a module with additional imports, providers, and exports', () => {
+    // const fakeEntities = [DummyEntity];
+    const fakeLoadedModules = [LoadedModule];
+    // Spy on SQLQueryBuilderModule.register.
+    const sqlQueryRegisterSpy = vi
+      .spyOn(SQLQueryBuilderModule, 'register')
+      .mockImplementation((options: { dataModuleName: string }) => {
+        return { module: 'SQLQueryBuilderModule', options } as unknown as DynamicModule;
+      });
+    const dummyProvider = { provide: 'DUMMY', useValue: 123 };
+    const dummyExport = { export: 'DUMMY_EXPORT' } as unknown as DynamicModule;
+    const options = {
+      connectionName: 'customConnection',
+      folderData: {
+        loadedModule: LoadedModule
+      },
+      moduleClass: DummyModule,
+      moduleName: 'customModule',
+      providers: [dummyProvider],
+      exports: [dummyExport],
+      imports: {
+        preORM: [PreORMModule],
+        postORM: [PostORMModule],
+        atEnd: [AtEndModule]
+      }
+    };
+    const dynamicModule: DynamicModule = TypeORMDBModule.register(options);
+    // Verify module and providers.
+    expect(dynamicModule.module).toBe(DummyModule);
+    expect(dynamicModule.providers).toEqual([dummyProvider]);
+    // Exports should be the concatenation of loaded modules and provided exports.
+    expect(dynamicModule.exports).toEqual([...fakeLoadedModules, dummyExport]);
+    // Expected imports ordering:
+    // index 0: PreORMModule (from imports.preORM)
+    // index 1: TypeOrmModule.forRootAsync configuration
+    // index 2: SQLQueryBuilderModule.register result
+    // index 3: PostORMModule (from imports.postORM)
+    // index 4: LoadedModule (from loadDynamicModules.modules)
+    // index 5: AtEndModule (from imports.atEnd)
+    expect(dynamicModule.imports).toHaveLength(6);
+    expect(dynamicModule.imports![0]).toBe(PreORMModule);
+    // const typeOrmAsyncModule = dynamicModule.imports![1] as unknown as {
+    //   useFactory: (_configProvider: ConfigProviderService) => unknown;
+    //   inject: unknown[];
+    // };
+    // expect(typeOrmAsyncModule.useFactory).toBeDefined();
+    // expect(typeOrmAsyncModule.inject).toEqual([ConfigProviderService]);
+    // Supply a fake config for customModule.
+    // const fakeConfigProvider: ConfigProviderService = {
+    //   config: {
+    //     data: {
+    //       customModule: {
+    //         host: '192.168.1.100',
+    //         password: 'topsecret',
+    //         port: 27017
+    //       }
+    //     }
+    //   }
+    // } as unknown as ConfigProviderService;
+    // const typeOrmConfig = typeOrmAsyncModule.useFactory(fakeConfigProvider);
+    // expect(typeOrmConfig).toEqual({
+    //   host: '192.168.1.100',
+    //   password: 'topsecret',
+    //   port: 27017,
+    //   entities: fakeEntities,
+    //   name: 'customConnection'
+    // });
+    // Verify SQLQueryBuilderModule.register call.
+    expect(sqlQueryRegisterSpy).toHaveBeenCalledWith({ dataModuleName: 'customModule' });
+    const sqlQueryModule = dynamicModule.imports![2];
+    expect(sqlQueryModule).toEqual({
+      module: 'SQLQueryBuilderModule',
+      options: { dataModuleName: 'customModule' }
+    });
+    // Check the rest of the ordering.
+    expect(dynamicModule.imports![3]).toBe(PostORMModule);
+    expect(dynamicModule.imports![4]).toBe(LoadedModule);
+    expect(dynamicModule.imports![5]).toBe(AtEndModule);
+  });
+});

package/src/module/typeorm.module.ts

@@ -0,0 +1,90 @@
+import { DynamicModule } from '@nestjs/common';
+import { TypeOrmModule, TypeOrmModuleOptions } from '@nestjs/typeorm';
+import { EntityClassOrSchema } from '@nestjs/typeorm/dist/interfaces/entity-class-or-schema.type';
+
+import { AppConfigDataRDB, ConfigProviderService, LoggerService, RDBType, loadDynamicModules } from '@node-c/core';
+import { SQLQueryBuilderModule } from '@node-c/data-rdb';
+
+import { DataSource } from 'typeorm';
+
+import { TypeORMDBModuleOptions } from './typeorm.module.definitions';
+
+export class TypeORMDBModule {
+  static register(options: TypeORMDBModuleOptions): DynamicModule {
+    const { connectionName, folderData, imports: additionalImports, moduleClass, moduleName } = options;
+    const { atEnd: importsAtEnd, postORM: importsPostORM, preORM: importsPreORM } = additionalImports || {};
+    const { entities, modules } = loadDynamicModules(folderData, {
+      moduleRegisterOptions: options.entityModuleRegisterOptions,
+      registerOptionsPerModule: options.registerOptionsPerEntityModule
+    });
+    let lastRetryAt = new Date().valueOf();
+    return {
+      global: true,
+      module: moduleClass as DynamicModule['module'],
+      imports: [
+        ...(importsPreORM || []),
+        TypeOrmModule.forRootAsync({
+          dataSourceFactory: async options => {
+            let dataSource: DataSource;
+            try {
+              dataSource = new DataSource(options!);
+              await dataSource.initialize();
+            } catch (err) {
+              const { failOnConnectionError = true, nodeCAppLoggerService } = (options || {}) as {
+                failOnConnectionError?: boolean;
+                nodeCAppLoggerService: LoggerService;
+              };
+              nodeCAppLoggerService.error(`[TypeORMDBModule][${moduleName}]: Error connecting to the DB Server:`, err);
+              if (failOnConnectionError) {
+                throw err;
+              }
+            }
+            return dataSource!;
+          },
+          name: connectionName,
+          useFactory: (configProvider: ConfigProviderService, logger: LoggerService) => {
+            const dataConfig = configProvider.config.data;
+            // example : configProvider.config.data.db
+            const { database, failOnConnectionError, host, password, port, type, typeormExtraOptions, user } =
+              dataConfig[moduleName as keyof typeof dataConfig] as AppConfigDataRDB;
+            const dataSourceOptions: { toRetry?: TypeOrmModuleOptions['toRetry'] } = {};
+            if (!failOnConnectionError) {
+              dataSourceOptions.toRetry = () => {
+                const now = new Date().valueOf();
+                // 1 minute retry interval
+                if (Math.abs(lastRetryAt - now) > 60000) {
+                  lastRetryAt = now;
+                  return true;
+                }
+                return false;
+              };
+            }
+            return {
+              ...dataSourceOptions,
+              database,
+              entities: entities as EntityClassOrSchema[],
+              failOnConnectionError,
+              host,
+              manualInitialization: true,
+              name: connectionName,
+              nodeCAppLoggerService: logger,
+              password,
+              port,
+              synchronize: false,
+              type: type === RDBType.Aurora ? RDBType.MySQL : type,
+              username: user,
+              ...(typeormExtraOptions || {})
+            } as TypeOrmModuleOptions;
+          },
+          inject: [ConfigProviderService]
+        }),
+        SQLQueryBuilderModule.register({ dataModuleName: moduleName }),
+        ...(importsPostORM || []),
+        ...(modules || []),
+        ...(importsAtEnd || [])
+      ],
+      providers: [...(options.providers || [])],
+      exports: [...(modules || []), ...(options.exports || [])]
+    };
+  }
+}

package/src/repository/index.ts

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

package/src/repository/typeorm.repository.definitions.ts

@@ -0,0 +1,7 @@
+import { EntityClassOrSchema } from '@nestjs/typeorm/dist/interfaces/entity-class-or-schema.type';
+
+export interface TypeORMDBRepositoryModuleOptions {
+  connectionName: string;
+  entityClass: EntityClassOrSchema;
+  dataModuleName: string;
+}

package/src/repository/typeorm.repository.module.spec.ts

@@ -0,0 +1,68 @@
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { describe, expect, it } from 'vitest';
+
+import { RDBRepositoryModule } from './index';
+
+import { Constants } from '../common/definitions/common.constants';
+import { SQLQueryBuilderService } from '../sqlQueryBuilder';
+
+class DummyEntity {}
+
+describe('RDBRepositoryModule', () => {
+  describe('register', () => {
+    const dataModuleName = 'TestModule';
+    const options = {
+      entityClass: DummyEntity,
+      dataModuleName
+    };
+    const dynamicModule = RDBRepositoryModule.register<DummyEntity>(options);
+    it('should return a DynamicModule with the correct module property', () => {
+      expect(dynamicModule.module).toBe(RDBRepositoryModule);
+    });
+    it('should include the correct imports', () => {
+      expect(dynamicModule.imports).toBeDefined();
+      expect(Array.isArray(dynamicModule.imports)).toBe(true);
+      expect(dynamicModule.imports!.length).toBe(1);
+      // The import should be the result of TypeOrmModule.forFeature, which we can assume is valid if defined.
+      expect(dynamicModule.imports![0]).toBeDefined();
+    });
+    it('should include the correct providers', () => {
+      expect(dynamicModule.providers).toBeDefined();
+      expect(Array.isArray(dynamicModule.providers)).toBe(true);
+      expect(dynamicModule.providers!.length).toBe(2);
+      // Find the provider for SQLQueryBuilderService.
+      const sqlProvider = dynamicModule.providers!.find(
+        (
+          provider
+        ): provider is {
+          provide: typeof SQLQueryBuilderService;
+          useFactory: (_dep: SQLQueryBuilderService) => SQLQueryBuilderService;
+          inject: string[];
+        } =>
+          typeof provider === 'object' &&
+          provider !== null &&
+          'provide' in provider &&
+          provider.provide === SQLQueryBuilderService
+      );
+      expect(sqlProvider).toBeDefined();
+      if (sqlProvider) {
+        expect(typeof sqlProvider.useFactory).toBe('function');
+        // Verify that the factory returns its argument.
+        const dummyService = {} as SQLQueryBuilderService;
+        expect(sqlProvider.useFactory(dummyService)).toBe(dummyService);
+        // Check that the inject token is formed correctly.
+        expect(sqlProvider.inject).toEqual([`${dataModuleName}${Constants.SQL_BUILDER_SERVICE_TOKEN_SUFFIX}`]);
+      }
+      // Check that the Repository provider is present.
+      const repositoryProvider = dynamicModule.providers!.find(provider => provider === Repository);
+      expect(repositoryProvider).toBe(Repository);
+    });
+    it('should include the correct exports', () => {
+      expect(dynamicModule.exports).toBeDefined();
+      expect(Array.isArray(dynamicModule.exports)).toBe(true);
+      // The module exports TypeOrmModule, Repository, and SQLQueryBuilderService.
+      expect(dynamicModule.exports).toEqual([TypeOrmModule, Repository, SQLQueryBuilderService]);
+    });
+  });
+});

package/src/repository/typeorm.repository.module.ts

@@ -0,0 +1,58 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { TypeOrmModule, getDataSourceToken } from '@nestjs/typeorm';
+
+import { Constants, SQLQueryBuilderService } from '@node-c/data-rdb';
+
+import { DataSource, ObjectLiteral } from 'typeorm';
+
+import { TypeORMDBRepository } from './typeorm.repository';
+import { TypeORMDBRepositoryModuleOptions } from './typeorm.repository.definitions';
+
+@Module({})
+export class TypeORMDBRepositoryModule {
+  static register<Entity extends ObjectLiteral>(options: TypeORMDBRepositoryModuleOptions): DynamicModule {
+    const { connectionName, entityClass, dataModuleName } = options;
+    return {
+      module: TypeORMDBRepositoryModule,
+      imports: [TypeOrmModule.forFeature([entityClass], connectionName)],
+      providers: [
+        {
+          provide: Constants.RDB_REPOSITORY_CONNECTION_NAME,
+          useValue: connectionName
+        },
+        {
+          provide: SQLQueryBuilderService,
+          useFactory: (sqlQueryBuilderService: SQLQueryBuilderService) => sqlQueryBuilderService,
+          inject: [`${dataModuleName}${Constants.SQL_BUILDER_SERVICE_TOKEN_SUFFIX}`]
+        },
+        {
+          provide: Constants.RDB_REPOSITORY_ENTITY_CLASS,
+          useValue: entityClass
+        },
+        {
+          provide: Constants.RDB_REPOSITORY_DATASOURCE,
+          useFactory: (dataSource: DataSource) => dataSource,
+          inject: [getDataSourceToken(connectionName)]
+        },
+        TypeORMDBRepository<Entity>,
+        {
+          provide: Constants.RDB_ENTITY_REPOSITORY,
+          useExisting: TypeORMDBRepository<Entity>
+        }
+      ],
+      exports: [
+        TypeOrmModule,
+        SQLQueryBuilderService,
+        {
+          provide: Constants.RDB_ENTITY_REPOSITORY,
+          useExisting: TypeORMDBRepository<Entity>
+        },
+        {
+          provide: Constants.RDB_REPOSITORY_DATASOURCE,
+          useFactory: (dataSource: DataSource) => dataSource,
+          inject: [getDataSourceToken(connectionName)]
+        }
+      ]
+    };
+  }
+}

package/src/repository/typeorm.repository.ts

@@ -0,0 +1,18 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { EntityClassOrSchema } from '@nestjs/typeorm/dist/interfaces/entity-class-or-schema.type';
+
+import { Constants } from '@node-c/data-rdb';
+
+import { DataSource, ObjectLiteral, Repository } from 'typeorm';
+
+@Injectable()
+export class TypeORMDBRepository<Entity extends ObjectLiteral> extends Repository<Entity> {
+  constructor(
+    @Inject(Constants.RDB_REPOSITORY_DATASOURCE)
+    protected dataSource: DataSource,
+    @Inject(Constants.RDB_REPOSITORY_ENTITY_CLASS)
+    protected entityClass: EntityClassOrSchema
+  ) {
+    super(entityClass, dataSource.createEntityManager());
+  }
+}

package/src/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      exclude: ['dist', 'src/index.ts', 'src/vitest.config.ts', 'src/**/*/*definitions.ts', 'test']
+    },
+    exclude: ['src/sqlQueryBuilder/sqlQueryBuilder.service.helpers.spec.ts']
+  }
+});