feat(json-api-nestjs-typeorm): Adapter for typerorm

Move adapter for typeorm as separate package

Author: klerick

libs/json-api/json-api-nestjs-typeorm/.eslintrc.json

@@ -0,0 +1,30 @@
+{
+  "extends": ["../../../.eslintrc.base.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {
+        "@nx/dependency-checks": [
+          "error",
+          {
+            "ignoredFiles": ["{projectRoot}/eslint.config.{js,cjs,mjs}"]
+          }
+        ]
+      }
+    }
+  ]
+}

libs/json-api/json-api-nestjs-typeorm/README.md

@@ -0,0 +1,11 @@
+# json-api-nestjs-typeorm
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build json-api-nestjs-typeorm` to build the library.
+
+## Running unit tests
+
+Run `nx test json-api-nestjs-typeorm` to execute the unit tests via [Jest](https://jestjs.io).

libs/json-api/json-api-nestjs-typeorm/jest.config.ts

@@ -0,0 +1,10 @@
+export default {
+  displayName: 'json-api-nestjs-typeorm',
+  preset: '../../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../../coverage/libs/json-api/json-api-nestjs-typeorm',
+};

libs/json-api/json-api-nestjs-typeorm/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@klerick/json-api-nestjs-typeorm",
+  "version": "0.0.1",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts"
+}

libs/json-api/json-api-nestjs-typeorm/project.json

@@ -0,0 +1,36 @@
+{
+  "name": "json-api-nestjs-typeorm",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/json-api/json-api-nestjs-typeorm/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "generatorOptions": {
+        "packageRoot": "dist/{projectRoot}",
+        "currentVersionResolver": "git-tag"
+      }
+    }
+  },
+  "tags": ["type:lib", "lib:json-api-nestjs", "lib:json-api-nestjs-typeorm", "type:publish"],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/json-api/json-api-nestjs-typeorm",
+        "tsConfig": "libs/json-api/json-api-nestjs-typeorm/tsconfig.lib.json",
+        "packageJson": "libs/json-api/json-api-nestjs-typeorm/package.json",
+        "main": "libs/json-api/json-api-nestjs-typeorm/src/index.ts",
+        "assets": ["libs/json-api/json-api-nestjs-typeorm/*.md"],
+        "buildableProjectDepsInPackageJsonType": "peerDependencies",
+        "generateExportsField": true
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  },
+  "implicitDependencies": ["json-api-nestjs"]
+}

libs/json-api/json-api-nestjs-typeorm/src/index.ts

@@ -0,0 +1 @@
+export * from './lib/type-orm-json-api.module';

libs/json-api/json-api-nestjs-typeorm/src/lib/constants/index.ts

@@ -0,0 +1,8 @@
+export const SUB_QUERY_ALIAS_FOR_PAGINATION = 'subQueryWithLimitOffset';
+export const ALIAS_FOR_PAGINATION = 'aliasForPagination';
+export const DEFAULT_CONNECTION_NAME = 'default';
+export const CURRENT_ENTITY_REPOSITORY = Symbol('CURRENT_ENTITY_REPOSITORY');
+export const CURRENT_DATA_SOURCE_TOKEN = Symbol('CURRENT_DATA_SOURCE_TOKEN');
+export const CURRENT_ENTITY_MANAGER_TOKEN = Symbol(
+  'CURRENT_ENTITY_MANAGER_TOKEN'
+);

libs/json-api/json-api-nestjs-typeorm/src/lib/factory/index.ts

@@ -0,0 +1,183 @@
+import { FactoryProvider } from '@nestjs/common';
+import { getDataSourceToken } from '@nestjs/typeorm';
+import {
+  EntityParam,
+  CheckRelationName,
+  FindOneRowEntity,
+  RunInTransaction,
+  PrepareParams,
+  FIND_ONE_ROW_ENTITY,
+  CHECK_RELATION_NAME,
+  RUN_IN_TRANSACTION_FUNCTION,
+  ORM_SERVICE,
+  MODULE_OPTIONS_TOKEN,
+  ENTITY_PARAM_MAP,
+} from '@klerick/json-api-nestjs';
+import { getEntityName } from '@klerick/json-api-nestjs-shared';
+
+import { kebabCase } from 'change-case-commonjs';
+import { DataSource, EntityManager, EntityTarget, Repository } from 'typeorm';
+
+import {
+  CURRENT_DATA_SOURCE_TOKEN,
+  CURRENT_ENTITY_MANAGER_TOKEN,
+  CURRENT_ENTITY_REPOSITORY,
+} from '../constants';
+
+import { TypeOrmService, TypeormUtilsService } from '../service';
+
+import { TypeOrmParam } from '../type';
+
+import {
+  getProps,
+  getRelation,
+  getPropsType,
+  getPropsNullable,
+  getPrimaryColumnName,
+  getPrimaryColumnType,
+  getRelationProperty,
+  getArrayType,
+} from '../orm-helper';
+import { EntityClass } from '@mikro-orm/core';
+
+export function CurrentDataSourceProvider(
+  connectionName?: string
+): FactoryProvider<DataSource> {
+  return {
+    provide: CURRENT_DATA_SOURCE_TOKEN,
+    useFactory: (dataSource: DataSource) => dataSource,
+    inject: [getDataSourceToken(connectionName)],
+  };
+}
+
+export function CurrentEntityManager(): FactoryProvider<EntityManager> {
+  return {
+    provide: CURRENT_ENTITY_MANAGER_TOKEN,
+    useFactory: (dataSource: DataSource) => dataSource.manager,
+    inject: [CURRENT_DATA_SOURCE_TOKEN],
+  };
+}
+
+export function CurrentEntityRepository<E extends object>(
+  entity: E
+): FactoryProvider<Repository<E>> {
+  return {
+    provide: CURRENT_ENTITY_REPOSITORY,
+    useFactory: (entityManager: EntityManager) =>
+      entityManager.getRepository(entity as unknown as EntityTarget<E>),
+    inject: [CURRENT_ENTITY_MANAGER_TOKEN],
+  };
+}
+
+export function EntityPropsMap<E extends object>(entities: EntityClass<E>[]) {
+  return {
+    provide: ENTITY_PARAM_MAP,
+    inject: [CURRENT_ENTITY_MANAGER_TOKEN],
+    useFactory: (entityManager: EntityManager) => {
+      const mapProperty = new Map<EntityClass<E>, EntityParam<E>>();
+
+      for (const item of entities) {
+        const entityRepo = entityManager.getRepository<E>(item);
+
+        const className = getEntityName(item);
+        mapProperty.set(item, {
+          props: getProps(entityRepo),
+          propsType: getPropsType(entityRepo),
+          propsNullable: getPropsNullable(entityRepo),
+          primaryColumnName: getPrimaryColumnName(entityRepo),
+          primaryColumnType: getPrimaryColumnType(entityRepo),
+          propsArrayType: getArrayType(entityRepo),
+          typeName: kebabCase(className),
+          className: className,
+          relations: getRelation(entityRepo),
+          relationProperty: getRelationProperty(entityRepo),
+        });
+      }
+      return mapProperty;
+    },
+  };
+}
+
+export function FindOneRowEntityFactory<E extends object>(): FactoryProvider<
+  FindOneRowEntity<E>
+> {
+  return {
+    provide: FIND_ONE_ROW_ENTITY,
+    inject: [CURRENT_ENTITY_REPOSITORY, TypeormUtilsService],
+    useFactory: (
+      repository: Repository<E>,
+      typeormUtilsService: TypeormUtilsService<E>
+    ) => {
+      return async (entity, value) => {
+        const params = 'params';
+        return await repository
+          .createQueryBuilder(typeormUtilsService.currentAlias)
+          .where(
+            `${typeormUtilsService.getAliasPath(
+              typeormUtilsService.currentPrimaryColumn
+            )} = :${params}`
+          )
+          .setParameters({
+            [params]: value,
+          })
+          .getOne();
+      };
+    },
+  };
+}
+
+export function CheckRelationNameFactory<
+  E extends object,
+  IdKey extends string = 'id'
+>(): FactoryProvider<CheckRelationName<E>> {
+  return {
+    provide: CHECK_RELATION_NAME,
+    inject: [TypeormUtilsService],
+    useFactory(typeormUtilsService: TypeormUtilsService<E, IdKey>) {
+      return (entity, value) =>
+        !!(typeormUtilsService.relationFields as any).find(
+          (i: any) => i === value
+        );
+    },
+  };
+}
+
+export function RunInTransactionFactory(): FactoryProvider<RunInTransaction> {
+  return {
+    provide: RUN_IN_TRANSACTION_FUNCTION,
+    inject: [MODULE_OPTIONS_TOKEN, CURRENT_DATA_SOURCE_TOKEN],
+    useFactory(options: PrepareParams<TypeOrmParam>, dataSource: DataSource) {
+      const {
+        options: { runInTransaction },
+      } = options;
+
+      if (runInTransaction && typeof runInTransaction === 'function') {
+        return (callback) =>
+          runInTransaction('READ COMMITTED', () => callback());
+      }
+
+      return async (callback) => {
+        const queryRunner = dataSource.createQueryRunner();
+        await queryRunner.startTransaction('READ UNCOMMITTED');
+        let result: unknown;
+        try {
+          result = await callback();
+          await queryRunner.commitTransaction();
+        } catch (e) {
+          await queryRunner.rollbackTransaction();
+          throw e;
+        } finally {
+          await queryRunner.release();
+        }
+        return result;
+      };
+    },
+  };
+}
+
+export function OrmServiceFactory() {
+  return {
+    provide: ORM_SERVICE,
+    useClass: TypeOrmService,
+  };
+}

libs/json-api/json-api-nestjs-typeorm/src/lib/index.ts

@@ -0,0 +1,2 @@
+export * from './type-orm-json-api.module';
+export * from './type';

libs/json-api/json-api-nestjs-typeorm/src/lib/mock-utils/entities/addresses.ts

@@ -0,0 +1,69 @@
+import {
+  PrimaryGeneratedColumn,
+  OneToOne,
+  Column,
+  Entity,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import { Users, IUsers } from './index';
+
+export type IAddresses = Addresses;
+
+@Entity('addresses')
+export class Addresses {
+  @PrimaryGeneratedColumn()
+  public id!: number;
+
+  @Column({
+    type: 'varchar',
+    length: 70,
+    nullable: true,
+    default: 'NULL',
+  })
+  public city!: string;
+
+  @Column({
+    type: 'varchar',
+    length: 70,
+    nullable: true,
+    default: 'NULL',
+  })
+  public state!: string;
+
+  @Column({
+    type: 'varchar',
+    length: 68,
+    nullable: true,
+    default: 'NULL',
+  })
+  public country!: string;
+
+  @Column({
+    name: 'array_field',
+    type: 'varchar',
+    nullable: true,
+    default: () => 'NULL',
+    array: true,
+  })
+  public arrayField!: string[];
+
+  @Column({
+    name: 'created_at',
+    type: 'timestamp',
+    nullable: true,
+    default: () => 'CURRENT_TIMESTAMP(0)',
+  })
+  public createdAt!: Date;
+
+  @UpdateDateColumn({
+    name: 'updated_at',
+    type: 'timestamp',
+    nullable: true,
+    default: () => 'CURRENT_TIMESTAMP(0)',
+  })
+  public updatedAt!: Date;
+
+  @OneToOne(() => Users, (item) => item.addresses)
+  public user!: IUsers;
+}