@rsdk/db.typeorm 2.5.1

package/src/internal/test/util.ts

@@ -0,0 +1,51 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+import { Initializer } from '../initializer';
+
+export const secondCat = {
+  id: 2,
+  name: 'Barsik',
+};
+export const cat = {
+  id: 1,
+  name: 'Pushistik',
+};
+
+@Entity()
+export class Cat {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column()
+  name!: string;
+}
+
+@Entity()
+export class Account {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column('int')
+  balance!: number;
+
+  @Column({ default: new Date() })
+  balanceLastUpdateAt!: Date;
+}
+
+export class SyntheticException extends Error {
+  override name = this.constructor.name;
+}
+
+export const contextTransactionMustBeInitialized = (): void => {
+  const transactionActive =
+    Initializer.storage.getContext()?.queryRunner?.isTransactionActive;
+
+  expect(transactionActive).toBe(true);
+};
+
+export const contextTransactionMustNotInitialized = (): void => {
+  const transactionActive =
+    Initializer.storage.getContext()?.queryRunner?.isTransactionActive;
+
+  expect(transactionActive).toBeFalsy();
+};

package/src/providers/index.ts

@@ -0,0 +1,3 @@
+export * from './typeorm-logger.adapter';
+export * from './typeorm.config';
+export * from './typeorm.healthcheck';

package/src/providers/typeorm-logger.adapter.ts

@@ -0,0 +1,59 @@
+import { Injectable } from '@nestjs/common';
+import { InjectLogger } from '@rsdk/core';
+import { ILogger } from '@rsdk/logging';
+import type { Logger } from 'typeorm';
+
+@Injectable()
+export class TypeormLoggerAdapter implements Logger {
+  constructor(@InjectLogger('TypeOrm') private platformLogger: ILogger) {}
+
+  logQuery(query: string, parameters?: any[]): any {
+    const message = this.formatParts(
+      `query: ${query}`,
+      parameters && `parameters: ${JSON.stringify(parameters)}`,
+    );
+
+    this.platformLogger.debug(message);
+  }
+
+  logMigration(message: string): any {
+    this.platformLogger.info('Migration: ' + message);
+  }
+
+  formatParts(...parts: (string | boolean | undefined)[]): string {
+    return parts.filter(Boolean).join(' ');
+  }
+
+  logQuerySlow(time: number, query: string, parameters?: any[]): any {
+    const message = this.formatParts(
+      `query: ${query}`,
+      parameters && 'parameters: ' + parameters,
+      `time: ${time}`,
+    );
+
+    this.platformLogger.warn(message);
+  }
+
+  logQueryError(error: string | Error, query: string, parameters?: any[]): any {
+    const parts = [
+      `error: ${JSON.stringify(error)}`,
+      `query: ${query}`,
+      parameters && `parameters: ${JSON.stringify(parameters)}`,
+    ];
+    const message = this.formatParts(...parts);
+
+    this.platformLogger.error(message);
+  }
+
+  logSchemaBuild(message: string): any {
+    this.platformLogger.info(`SchemaBuild: ${message}`);
+  }
+
+  log(level: 'log' | 'info' | 'warn', message: any): any {
+    if (level === 'log') {
+      return this.platformLogger.info(message);
+    }
+
+    return this.platformLogger[level](message);
+  }
+}

package/src/providers/typeorm.config.ts

@@ -0,0 +1,61 @@
+import { text, Timespan } from '@rsdk/common';
+import {
+  Config,
+  ConfigSection,
+  ConfigTag,
+  IntParser,
+  Property,
+  StringParser,
+  TimespanParser,
+  UrlParser,
+} from '@rsdk/core';
+
+@ConfigSection({
+  name: 'typeorm database config',
+  tags: [ConfigTag.infrastructure, ConfigTag.storage],
+})
+export class TypeOrmPluginConfig extends Config {
+  @Property('DB_URL', new UrlParser(), {
+    description: 'Database server url',
+  })
+  url!: URL;
+
+  @Property('DB_SCHEMA', new StringParser(), {
+    description: text`
+      Use schema for all entities.
+      **Only for postgres at the moment!**
+    `,
+    defaultValue: undefined,
+  })
+  schema!: string;
+
+  @Property('DB_POOL_MIN', new IntParser(), {
+    defaultValue: 1,
+    description: text`
+      Minimum connection pool size.
+      **Only for postgres at the moment!**
+    `,
+  })
+  poolMin!: number;
+
+  @Property('DB_POOL_MAX', new IntParser(), {
+    defaultValue: 10,
+    description: text`
+      Maximum connection pool size.
+      **Only for postgres at the moment!**
+    `,
+  })
+  poolMax!: number;
+
+  @Property('DB_RECONNECT_ATTEMPTS', new IntParser(), {
+    defaultValue: Number.POSITIVE_INFINITY,
+    description: 'Retry attempt count before give up',
+  })
+  reconnectAttempts!: number;
+
+  @Property('DB_RECONNECT_INTERVAL', new TimespanParser(), {
+    defaultValue: new Timespan(1, 's'),
+    description: 'Delay between retries',
+  })
+  reconnectInterval!: Timespan;
+}

package/src/providers/typeorm.healthcheck.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import type { HealthIndicator } from '@rsdk/core';
+import { CheckResult, Indicator } from '@rsdk/core';
+import { EntityManager } from 'typeorm';
+
+@Injectable()
+@Indicator('typeorm')
+export class TypeOrmHealthIndicator implements HealthIndicator {
+  constructor(private manager: EntityManager) {}
+
+  async check(): Promise<CheckResult> {
+    try {
+      const result = await this.manager.query('select 1 + 1');
+
+      return CheckResult.up(result);
+    } catch (error: any) {
+      return CheckResult.down(error);
+    }
+  }
+}

package/src/typeorm.errors-transformer.ts

@@ -0,0 +1,35 @@
+import type { IErrorsTransformer, PipelineException } from '@rsdk/core';
+import { InternalException, NotFoundException } from '@rsdk/core';
+import { EntityNotFoundError, TypeORMError } from 'typeorm';
+
+const DEFAULT_MESSAGE = 'Something went wrong';
+
+export class TypeormErrorTransformer implements IErrorsTransformer {
+  match(ex: unknown): boolean {
+    return ex instanceof TypeORMError;
+  }
+
+  transform(ex: any): PipelineException {
+    /**
+     * Потому что в `message` typeorm exception может быть информация о таблицах и сущностях, которую не хочется лишний раз светить
+     */
+    const message = ex.message;
+
+    ex.message = DEFAULT_MESSAGE;
+    ex._message = message;
+
+    if (ex instanceof EntityNotFoundError) {
+      return new NotFoundException(DEFAULT_MESSAGE, {
+        cause: ex,
+      });
+    }
+
+    if (ex instanceof TypeORMError) {
+      return new InternalException(DEFAULT_MESSAGE, {
+        cause: ex,
+      });
+    }
+
+    throw new Error('unknown exception');
+  }
+}

package/src/typeorm.plugin.ts

@@ -0,0 +1,83 @@
+import type { DynamicModule } from '@nestjs/common';
+import type { TypeOrmModuleOptions } from '@nestjs/typeorm';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import type { Constructor } from '@rsdk/common';
+import type {
+  AppropriateTransports,
+  IErrorsTransformer,
+  PlatformAppPlugin,
+} from '@rsdk/core';
+import { APP_NAME, PlatformConfigModule } from '@rsdk/core';
+
+import { Initializer } from './internal/initializer';
+import {
+  TypeOrmHealthIndicator,
+  TypeormLoggerAdapter,
+  TypeOrmPluginConfig,
+} from './providers';
+import { TypeormErrorTransformer } from './typeorm.errors-transformer';
+import type { TypeOrmPluginOptions } from './types';
+
+export class TypeOrmPlugin implements PlatformAppPlugin {
+  /**
+   * По умолчанию парсит тип драйвера из env %PACKAGE_NAME%_DB_URL
+   */
+  constructor(private readonly options: TypeOrmPluginOptions) {
+    Initializer.initialize();
+  }
+
+  get entities(): (string | any)[] | undefined {
+    return this?.options?.entities;
+  }
+
+  forTransports(): AppropriateTransports {
+    return 'any';
+  }
+
+  modules(): (Constructor | DynamicModule)[] {
+    return [
+      TypeOrmModule.forRootAsync({
+        imports: [
+          PlatformConfigModule.forFeature(TypeOrmPluginConfig),
+          {
+            module: TypeOrmModule,
+            providers: [TypeOrmHealthIndicator, TypeormLoggerAdapter],
+            exports: [TypeormLoggerAdapter],
+          },
+        ],
+        inject: [TypeOrmPluginConfig, TypeormLoggerAdapter, APP_NAME],
+        useFactory: (
+          config: TypeOrmPluginConfig,
+          logger: TypeormLoggerAdapter,
+          appName: string,
+        ): TypeOrmModuleOptions => ({
+          /**
+           * Так как typeorm поддерживает целый зоопарк не совместимых друг с другом СУБД, для всего нужны разные опции
+           * И он начинает ругаться на то что какие-то поля должны быть, каких то не должно быть
+           * Принято волевое решение пока остановиться на нашей основной СУБД, а именно `postgres`
+           */
+          type: this.options.type,
+          url: config.url.toString(),
+          ...(config.schema && {
+            schema: config.schema,
+          }),
+          logger,
+          ...(this.entities && { entities: this.entities }),
+          autoLoadEntities: !this.entities,
+          retryDelay: config.reconnectInterval.millis(),
+          retryAttempts: config.reconnectAttempts,
+          applicationName: appName + ':typeorm',
+          extra: {
+            min: config.poolMin,
+            max: config.poolMax,
+          },
+          ...(this.options.overrideConfig as any),
+        }),
+      }),
+    ];
+  }
+
+  errorTransformers(): IErrorsTransformer[] {
+    return [new TypeormErrorTransformer()];
+  }
+}

package/src/types.ts

@@ -0,0 +1,23 @@
+import type { TypeOrmModuleOptions } from '@nestjs/typeorm';
+
+export interface TypeOrmPluginOptions {
+  type: NonNullable<TypeOrmModuleOptions['type']>;
+  entities?: (string | any)[];
+  overrideConfig?: Partial<Omit<TypeOrmModuleOptions, 'type'>>;
+}
+
+export enum IsolationLevel {
+  READ_UNCOMMITTED = 'READ UNCOMMITTED',
+  READ_COMMITTED = 'READ COMMITTED',
+  REPEATABLE_READ = 'REPEATABLE READ',
+  SERIALIZABLE = 'SERIALIZABLE',
+}
+
+export const isolationLevels: readonly IsolationLevel[] = [
+  IsolationLevel.READ_UNCOMMITTED,
+  IsolationLevel.READ_COMMITTED,
+  IsolationLevel.REPEATABLE_READ,
+  IsolationLevel.SERIALIZABLE,
+];
+
+export const DEFAULT_ISOLATION_LEVEL = IsolationLevel.READ_UNCOMMITTED;

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "incremental": false,
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts", "**/*test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+
+  "extends": "@rsdk/tsconfig/base.json",
+  "compilerOptions": {
+    "declaration": true,
+    "incremental": false,
+    "outDir": "dist"
+  }
+}