@invariant--labs/foundation 1.1.2 → 1.1.5

package/src/core/infrastructure/persistence/write-side/entity-typeorm-repository.ts

@@ -1,64 +0,0 @@
-import { DataSource, EntityManager, ObjectLiteral, SelectQueryBuilder } from "typeorm";
-
-import { Repository } from "../../../application";
-import { Entity, EntityProps } from "../../../domain";
-import { ArchitectureLevel } from "../../../types";
-import { EntityNotFoundError } from "../../../errors";
-
-export abstract class EntityTypeormRepository<DomainEntity extends Entity<EntityProps>, OrmModel extends ObjectLiteral>
-  implements Repository<Entity<EntityProps>>
-{
-  protected manager: EntityManager;
-
-  constructor(
-    dataSource: DataSource,
-    private readonly entityName: string,
-  ) {
-    this.manager = dataSource.manager;
-  }
-
-  async count(): Promise<number> {
-    return this.createDefaultQueryBuilder().getCount();
-  }
-
-  async exists(id: string): Promise<boolean> {
-    const count = await this.createDefaultQueryBuilder().where({ id }).getCount();
-    return count === 1;
-  }
-
-  async findOne(id: string): Promise<DomainEntity | null> {
-    const model = await this.createDefaultQueryBuilder().where({ id }).getOne();
-    return model ? this.toEntity(model) : null;
-  }
-
-  async findOneOrFail(entityId: string): Promise<DomainEntity> {
-    const entity = await this.findOne(entityId);
-    if (!entity) {
-      throw new EntityNotFoundError(
-        this.entityName,
-        { [ArchitectureLevel.INFRASTRUCTURE]: { "persistence-sql": { className: "EntityTypeormRepository" } } },
-        { id: entityId },
-      );
-    }
-    return entity;
-  }
-
-  async findByIds(ids: string[]): Promise<DomainEntity[]> {
-    const models = await this.createDefaultQueryBuilder().whereInIds(ids).getMany();
-    return models.map((model) => this.toEntity(model));
-  }
-
-  async save(entity: DomainEntity): Promise<DomainEntity> {
-    const model = await this.manager.save(await this.toModel(entity));
-    return this.toEntity(model);
-  }
-
-  async saveAll(entities: DomainEntity[]): Promise<void> {
-    const models = await Promise.all(entities.map((e) => Promise.resolve(this.toModel(e))));
-    await this.manager.save(models);
-  }
-
-  protected abstract createDefaultQueryBuilder(): SelectQueryBuilder<OrmModel>;
-  protected abstract toEntity(model: OrmModel): DomainEntity;
-  protected abstract toModel(entity: DomainEntity): OrmModel | Promise<OrmModel>;
-}

package/src/core/infrastructure/persistence/write-side/in-memory.repository.ts

@@ -1,82 +0,0 @@
-/* eslint-disable @typescript-eslint/require-await */
-import _ from "lodash";
-
-import { FindManyOptions, Repository } from "../../../application/persistence/repository";
-import { AggregateRoot } from "../../../domain";
-import { Entity, EntityProps } from "../../../domain/entities/entity";
-import { ArchitectureLevel } from "../../../types";
-import { EntityNotFoundError } from "../../../errors";
-
-export class InMemoryRepository<DomainEntity extends Entity<EntityProps> | AggregateRoot<EntityProps>>
-  implements Repository<DomainEntity>
-{
-  protected store: Map<string, DomainEntity>;
-
-  constructor(
-    defaultEntities: DomainEntity[] = [],
-    protected error?: Error,
-  ) {
-    this.store = new Map(defaultEntities.map((e) => [e.id.toString(), e]));
-  }
-
-  async save(entity: DomainEntity): Promise<DomainEntity> {
-    this.checkError();
-    this.store.set(entity.id.toString(), entity);
-    return entity;
-  }
-
-  async saveAll(entities: DomainEntity[]): Promise<void> {
-    this.checkError();
-    for (const entity of entities) {await this.save(entity);}
-  }
-
-  async findOne(id: string): Promise<DomainEntity | null> {
-    return this.store.get(id) ?? null;
-  }
-
-  async findOneOrFail(id: string): Promise<DomainEntity> {
-    const entity = await this.findOne(id);
-    if (!entity) {
-      throw new EntityNotFoundError("InMemoryEntity", {
-        [ArchitectureLevel.INFRASTRUCTURE]: { "persistence-fake": { className: "InMemoryRepository" } },
-      });
-    }
-    return entity;
-  }
-
-  async findByIds(ids: string[]): Promise<DomainEntity[]> {
-    return this.toArray().filter((entity) => ids.includes(entity.id.toString()));
-  }
-
-  async delete(entity: DomainEntity): Promise<void> {
-    this.checkError();
-    this.store.delete(entity.id.toString());
-  }
-
-  async exists(id: string): Promise<boolean> {
-    this.checkError();
-    return this.store.has(id);
-  }
-
-  async count(options: FindManyOptions<DomainEntity>): Promise<number> {
-    this.checkError();
-    return _.filter(this.toArray(), options.filters).length;
-  }
-
-  clear(): void {
-    this.store.clear();
-    this.error = undefined;
-  }
-
-  setError(error: Error): void {
-    this.error = error;
-  }
-
-  protected checkError(): void {
-    if (this.error) {throw this.error;}
-  }
-
-  protected toArray(): DomainEntity[] {
-    return [...this.store.values()];
-  }
-}

package/src/core/infrastructure/persistence/write-side/index.ts

@@ -1 +0,0 @@
-export * from "./typeorm";

package/src/core/infrastructure/persistence/write-side/model-attributes.ts

@@ -1,4 +0,0 @@
-export type ModelAttributes<T> = Omit<
-  T,
-  "createdAt" | "updatedAt" | "updateDateCreation" | "updateDateUpdate" | "deletedAt" | "updateDateDelete"
->;

package/src/core/infrastructure/persistence/write-side/orm-embedded-mapper.ts

@@ -1,11 +0,0 @@
-import { ValueObject } from "../../../domain";
-
-export interface OrmEmbeddedMapper<
-  DomainValueObject extends ValueObject,
-  OrmEmbeddedModel,
-  ToPersistenceArgs extends unknown[] = [],
-  ToDomainArgs extends unknown[] = [],
-> {
-  toObjectValue(embeddedModel: OrmEmbeddedModel | null, ...args: ToDomainArgs): DomainValueObject | undefined;
-  toEmbeddedModel(valueObject?: DomainValueObject, ...args: ToPersistenceArgs): OrmEmbeddedModel | null;
-}

package/src/core/infrastructure/persistence/write-side/orm-mapper.ts

@@ -1,11 +0,0 @@
-import { AggregateRoot, Entity } from "../../../domain";
-
-export interface OrmMapper<
-  DomainObject extends AggregateRoot | Entity,
-  OrmModel,
-  ToPersistenceArgs extends unknown[] = [],
-  ToDomainArgs extends unknown[] = [],
-> {
-  toEntity(model: OrmModel, ...args: ToDomainArgs): DomainObject;
-  toModel(entity: DomainObject, ...args: ToPersistenceArgs): OrmModel;
-}

package/src/core/infrastructure/persistence/write-side/typeorm/aggregate-typeorm.repository.ts

@@ -1,87 +0,0 @@
-import { DataSource, EntityManager, ObjectLiteral, SelectQueryBuilder } from "typeorm";
-
-import { Repository } from "../../../../application";
-import { AggregateRoot, EntityProps } from "../../../../domain";
-import { ArchitectureLevel } from "../../../../types";
-import { EntityNotFoundError } from "../../../../errors";
-import { typeormMetadataParser } from "../../../../../nestjs/errors/parsers/typeorm-metadata.parser";
-import { PersistenceError } from "../../errors/persistence.error";
-
-export abstract class AggregateTypeormRepository<
-  DomainAggregate extends AggregateRoot<EntityProps>,
-  OrmModel extends ObjectLiteral,
-> implements Repository<AggregateRoot<EntityProps>>
-{
-  protected abstract createDefaultQueryBuilder(): SelectQueryBuilder<OrmModel>;
-  protected abstract toEntity(model: OrmModel): DomainAggregate;
-  protected abstract toModel(aggregate: DomainAggregate): OrmModel | Promise<OrmModel>;
-  protected manager: EntityManager;
-
-  constructor(
-    dataSource: DataSource,
-    private readonly aggregateName: string,
-  ) {
-    this.manager = dataSource.manager;
-  }
-
-  async count(): Promise<number> {
-    return this.createDefaultQueryBuilder().getCount();
-  }
-
-  async exists(id: string): Promise<boolean> {
-    const count = await this.createDefaultQueryBuilder().where({ id }).getCount();
-    return count === 1;
-  }
-
-  async findOne(id: string): Promise<DomainAggregate | null> {
-    const model = await this.createDefaultQueryBuilder().where({ id }).getOne();
-    return model ? this.toEntity(model) : null;
-  }
-
-  async findOneOrFail(aggregateId: string): Promise<DomainAggregate> {
-    const aggregate = await this.findOne(aggregateId);
-    if (!aggregate) {
-      throw new EntityNotFoundError(
-        this.aggregateName,
-        { [ArchitectureLevel.INFRASTRUCTURE]: { "persistence-sql": { className: "AggregateTypeormRepository" } } },
-        { id: aggregateId },
-      );
-    }
-    return aggregate;
-  }
-
-  async findByIds(ids: string[]): Promise<DomainAggregate[]> {
-    const models = await this.createDefaultQueryBuilder().whereInIds(ids).getMany();
-    return models.map((model) => this.toEntity(model));
-  }
-
-  async save(aggregate: DomainAggregate): Promise<DomainAggregate> {
-    try {
-      const model = await this.manager.save(this.toModel(aggregate));
-      aggregate.commit();
-      return this.toEntity(model);
-    } catch (error) {
-      throw new PersistenceError("Failed to save aggregate", {
-        "aggregate-root": {
-          className: AggregateTypeormRepository.name,
-          meta: typeormMetadataParser(error, { method: this.save.name }),
-        },
-      });
-    }
-  }
-
-  async saveAll(aggregates: DomainAggregate[]): Promise<void> {
-    try {
-      const models = await Promise.all(aggregates.map((a) => Promise.resolve(this.toModel(a))));
-      await this.manager.save(models);
-      aggregates.forEach((a) => a.commit());
-    } catch (error) {
-      throw new PersistenceError("Failed to save aggregates", {
-        "aggregate-root": {
-          className: AggregateTypeormRepository.name,
-          meta: typeormMetadataParser(error, { method: this.saveAll.name }),
-        },
-      });
-    }
-  }
-}

package/src/core/infrastructure/persistence/write-side/typeorm/entity-typeorm.repository.ts

@@ -1,64 +0,0 @@
-import { DataSource, EntityManager, ObjectLiteral, SelectQueryBuilder } from "typeorm";
-
-import { Repository } from "../../../../application";
-import { Entity, EntityProps } from "../../../../domain";
-import { ArchitectureLevel } from "../../../../types";
-import { EntityNotFoundError } from "../../../../errors";
-
-export abstract class EntityTypeormRepository<DomainEntity extends Entity<EntityProps>, OrmModel extends ObjectLiteral>
-  implements Repository<Entity<EntityProps>>
-{
-  protected manager: EntityManager;
-
-  constructor(
-    dataSource: DataSource,
-    private readonly entityName: string,
-  ) {
-    this.manager = dataSource.manager;
-  }
-
-  async count(): Promise<number> {
-    return this.createDefaultQueryBuilder().getCount();
-  }
-
-  async exists(id: string): Promise<boolean> {
-    const count = await this.createDefaultQueryBuilder().where({ id }).getCount();
-    return count === 1;
-  }
-
-  async findOne(id: string): Promise<DomainEntity | null> {
-    const model = await this.createDefaultQueryBuilder().where({ id }).getOne();
-    return model ? this.toEntity(model) : null;
-  }
-
-  async findOneOrFail(entityId: string): Promise<DomainEntity> {
-    const entity = await this.findOne(entityId);
-    if (!entity) {
-      throw new EntityNotFoundError(
-        this.entityName,
-        { [ArchitectureLevel.INFRASTRUCTURE]: { "persistence-sql": { className: "EntityTypeormRepository" } } },
-        { id: entityId },
-      );
-    }
-    return entity;
-  }
-
-  async findByIds(ids: string[]): Promise<DomainEntity[]> {
-    const models = await this.createDefaultQueryBuilder().whereInIds(ids).getMany();
-    return models.map((model) => this.toEntity(model));
-  }
-
-  async save(entity: DomainEntity): Promise<DomainEntity> {
-    const model = await this.manager.save(await this.toModel(entity));
-    return this.toEntity(model);
-  }
-
-  async saveAll(entities: DomainEntity[]): Promise<void> {
-    const models = await Promise.all(entities.map((e) => Promise.resolve(this.toModel(e))));
-    await this.manager.save(models);
-  }
-
-  protected abstract createDefaultQueryBuilder(): SelectQueryBuilder<OrmModel>;
-  protected abstract toEntity(model: OrmModel): DomainEntity;
-  protected abstract toModel(entity: DomainEntity): OrmModel | Promise<OrmModel>;
-}

package/src/core/infrastructure/persistence/write-side/typeorm/model-attributes.ts

@@ -1,4 +0,0 @@
-export type ModelAttributes<T> = Omit<
-  T,
-  "createdAt" | "updatedAt" | "updateDateCreation" | "updateDateUpdate" | "deletedAt" | "updateDateDelete"
->;

package/src/core/infrastructure/persistence/write-side/typeorm/orm-embedded.mapper.ts

@@ -1,11 +0,0 @@
-import { ValueObject } from "../../../../domain";
-
-export interface OrmEmbeddedMapper<
-  DomainValueObject extends ValueObject,
-  OrmEmbeddedModel,
-  ToPersistenceArgs extends unknown[] = [],
-  ToDomainArgs extends unknown[] = [],
-> {
-  toObjectValue(embeddedModel: OrmEmbeddedModel | null, ...args: ToDomainArgs): DomainValueObject | undefined;
-  toEmbeddedModel(valueObject?: DomainValueObject, ...args: ToPersistenceArgs): OrmEmbeddedModel | null;
-}

package/src/core/infrastructure/persistence/write-side/typeorm/orm.mapper.ts

@@ -1,11 +0,0 @@
-import { AggregateRoot, Entity } from "../../../../domain";
-
-export interface OrmMapper<
-  DomainObject extends AggregateRoot | Entity,
-  OrmModel,
-  ToPersistenceArgs extends unknown[] = [],
-  ToDomainArgs extends unknown[] = [],
-> {
-  toEntity(model: OrmModel, ...args: ToDomainArgs): DomainObject;
-  toModel(entity: DomainObject, ...args: ToPersistenceArgs): OrmModel;
-}

package/src/core/types/architecture-layer.ts

@@ -1,52 +0,0 @@
-type Values<V> = V[keyof V];
-type OneOf<V> = Values<{
-  [K in keyof V]: { [K1 in K]: V[K1] };
-}>;
-
-export enum ArchitectureLevel {
-  DOMAIN = "DOMAIN",
-  APPLICATION = "APPLICATION",
-  INFRASTRUCTURE = "INFRASTRUCTURE",
-  UNDEFINED = "UNDEFINED",
-}
-
-export type ArchitectureLayerType =
-  | "aggregate-root"
-  | "entity"
-  | "value-object"
-  | "query"
-  | "command"
-  | "event-handler"
-  | "event-saga"
-  | "service"
-  | "authorization"
-  | "authentication"
-  | "web-dto"
-  | "web-rest"
-  | "web-graphql"
-  | "web-socket"
-  | "web-rpc"
-  | "persistence-sql"
-  | "persistence-saas"
-  | "persistence-fake"
-  | "persistence-other"
-  | "persistence-s3"
-  | "persistence-disk"
-  | "messaging-inmem"
-  | "messaging-pubsub"
-  | "unknown";
-
-export type ArchitectureLayerTraceBase = {
-  [Type in ArchitectureLayerType]: {
-    className: string;
-    meta?: unknown;
-  };
-};
-
-export type ArchitectureLayerTrace = OneOf<ArchitectureLayerTraceBase>;
-
-export type DDD = {
-  [key in `${ArchitectureLevel}`]: ArchitectureLayerTrace;
-};
-
-export type ArchitectureLayer = OneOf<DDD>;

package/src/modules/config/config.module.ts

@@ -1,9 +0,0 @@
-import { Module } from "@nestjs/common";
-
-import { ConfigProvider, ConfigService } from "../../core/infrastructure/config";
-
-@Module({
-  providers: [{ provide: ConfigService, useClass: ConfigProvider }],
-  exports: [ConfigService],
-})
-export class ConfigModule {}

package/src/modules/graphql/paginated-response.object-type.ts

@@ -1,23 +0,0 @@
-import { Type } from "@nestjs/common";
-import { Field, Int, ObjectType } from "@nestjs/graphql";
-
-export type PaginatedResponse<TItem> = {
-  items: TItem[];
-  total: number;
-  hasMore: boolean;
-};
-
-export function PaginatedResponse<T>(classRef: Type<T>): Type<PaginatedResponse<T>> {
-  @ObjectType(`${classRef.name}Edge`, { isAbstract: true })
-  abstract class PaginatedType {
-    @Field(() => [classRef])
-    items: T[];
-
-    @Field(() => Int)
-    total: number;
-
-    @Field()
-    hasMore: boolean;
-  }
-  return PaginatedType as unknown as Type<PaginatedResponse<T>>;
-}

package/src/modules/healthcheck/healthcheck-out.dto.ts

@@ -1,43 +0,0 @@
-import { Expose, Type } from "class-transformer";
-import { IsOptional } from "class-validator";
-
-export class HealthStatus {
-  @Expose()
-  status: "up" | "down";
-}
-
-export class HealthIndicatorResult {
-  @Expose()
-  @Type(() => HealthStatus)
-  @IsOptional()
-  database?: HealthStatus;
-
-  @Expose()
-  @Type(() => HealthStatus)
-  @IsOptional()
-  memory_heap?: HealthStatus;
-
-  @Expose()
-  @Type(() => HealthStatus)
-  @IsOptional()
-  rabbitmq?: HealthStatus;
-}
-
-export class HealthcheckOutDto {
-  @Expose()
-  status: "error" | "ok" | "shutting_down";
-
-  @Expose()
-  @Type(() => HealthIndicatorResult)
-  details: HealthIndicatorResult;
-
-  @Expose()
-  @Type(() => HealthIndicatorResult)
-  @IsOptional()
-  info?: HealthIndicatorResult;
-
-  @Expose()
-  @Type(() => HealthIndicatorResult)
-  @IsOptional()
-  error?: HealthIndicatorResult;
-}

package/src/modules/knex/knex-core.module.ts

@@ -1,30 +0,0 @@
-import { DynamicModule, Global, Module, Provider } from "@nestjs/common";
-import knex from "knex";
-
-import { KnexModuleAsyncOptions, KnexModuleOptions } from "./knex.interface";
-import { KNEX_CONNECTION_TOKEN, KNEX_OPTIONS_TOKEN } from "./knex.token";
-
-@Global()
-@Module({})
-export class KnexCoreModule {
-  static forRootAsync(options: KnexModuleAsyncOptions): DynamicModule {
-    const knexConnectionProvider: Provider = {
-      provide: KNEX_CONNECTION_TOKEN,
-      useFactory: (opts: KnexModuleOptions) => knex(opts),
-      inject: [KNEX_OPTIONS_TOKEN],
-    };
-
-    const knexOptionsProvider: Provider = {
-      provide: KNEX_OPTIONS_TOKEN,
-      useFactory: options.useFactory,
-      inject: options.inject ?? [],
-    };
-
-    return {
-      module: KnexCoreModule,
-      imports: options.imports,
-      providers: [knexOptionsProvider, knexConnectionProvider],
-      exports: [knexConnectionProvider],
-    };
-  }
-}

package/src/modules/knex/knex.decorator.ts

@@ -1,5 +0,0 @@
-import { Inject } from "@nestjs/common";
-
-import { KNEX_CONNECTION_TOKEN } from "./knex.token";
-
-export const InjectKnexConnection = () => Inject(KNEX_CONNECTION_TOKEN);

package/src/modules/knex/knex.interface.ts

@@ -1,12 +0,0 @@
-/* nestjs uses any for the inject and useFactory parameters */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ModuleMetadata } from "@nestjs/common";
-import knex from "knex";
-
-export interface KnexModuleAsyncOptions extends Pick<ModuleMetadata, "imports"> {
-  inject: any[];
-  useFactory: (...args: any[]) => Promise<KnexModuleOptions> | KnexModuleOptions;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface KnexModuleOptions extends knex.Knex.Config {}

package/src/modules/knex/knex.module.ts

@@ -1,14 +0,0 @@
-import { DynamicModule } from "@nestjs/common";
-
-import { KnexCoreModule } from "./knex-core.module";
-import { KnexModuleAsyncOptions } from "./knex.interface";
-
-export class KnexModule {
-  public static forRootAsync(options: KnexModuleAsyncOptions): DynamicModule {
-    return {
-      module: KnexModule,
-      imports: [KnexCoreModule.forRootAsync(options)],
-      exports: [KnexCoreModule],
-    };
-  }
-}

package/src/modules/knex/knex.token.ts

@@ -1,2 +0,0 @@
-export const KNEX_CONNECTION_TOKEN = Symbol("KNEX_CONNECTION_TOKEN");
-export const KNEX_OPTIONS_TOKEN = Symbol("KNEX_OPTIONS_TOKEN");

package/src/modules/logger/app-logger.ts

@@ -1,28 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument */
-import { LoggerService as NestLoggerService } from "@nestjs/common";
-
-import { LogLevel } from "./log";
-import { LoggerService } from "./logger.service";
-
-export class AppLogger implements NestLoggerService {
-  constructor(private readonly loggerService: LoggerService) {}
-
-  error(message: any, meta?: any) {
-    this.runLog("error", message, typeof meta === "string" ? { stack: meta } : meta);
-  }
-
-  log(message: any, meta?: any) { this.runLog("info", message, meta); }
-  warn(message: any, meta?: any) { this.runLog("warn", message, meta); }
-  debug(message: any, meta?: any) { this.runLog("debug", message, meta); }
-  verbose(message: any, meta?: any) { this.runLog("verbose", message, meta); }
-
-  private runLog(level: LogLevel, message: any, meta?: any) {
-    if (typeof message === "string" && typeof meta === "string") {
-      this.loggerService.log(level, message, { meta });
-    } else if (typeof message === "string") {
-      this.loggerService.log(level, message, meta);
-    } else {
-      this.loggerService.log(level, { message, meta });
-    }
-  }
-}

package/src/modules/logger/log.ts

@@ -1,26 +0,0 @@
-type RawLog = Record<string, unknown>;
-type MetricsLog = Record<string, number>;
-
-export type CtxLog = Record<string, unknown>;
-export type DataLog = Partial<{ metrics: MetricsLog } & RawLog>;
-
-export const LOG_LEVELS = ["error", "warn", "info", "http", "verbose", "debug", "silly"] as const;
-export type LogLevel = (typeof LOG_LEVELS)[number];
-
-export type Log = {
-  service: string;
-  level: LogLevel;
-  message: string;
-  data?: DataLog;
-  stack?: string;
-};
-
-export const LOG_LEVEL_PRIORITY = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  http: 3,
-  verbose: 4,
-  debug: 5,
-  silly: 6,
-} as const satisfies Record<LogLevel, number>;

package/src/modules/logger/logger.module.ts

@@ -1,47 +0,0 @@
-import { MiddlewareConsumer, Module, RequestMethod } from "@nestjs/common";
-import { APP_INTERCEPTOR } from "@nestjs/core";
-
-import { ConfigModule } from "../config";
-import { LogAppCtxInterceptor } from "../../nestjs/http/interceptors/log-app-ctx.interceptor";
-import { HttpLoggerMiddleware } from "../../nestjs/http/middleware/http-logger.middleware";
-import { LoggerMiddleware } from "../../nestjs/http/middleware/logger.middleware";
-import { LoggerService } from "./logger.service";
-import { LogLevel } from "./log";
-import { ConsoleJSONTransport } from "./transports/console-json.transport";
-import { ConsoleTransport } from "./transports/console.transport";
-import { LoggerTransport } from "./transports/logger-transport";
-
-function createTransports(): LoggerTransport[] {
-  const { NODE_ENV, PHARADAY_TRANSPORT_LOGGER, PHARADAY_LEVEL_LOGGER } = process.env;
-
-  if (PHARADAY_TRANSPORT_LOGGER === "json") {
-    return [new ConsoleJSONTransport({ level: (PHARADAY_LEVEL_LOGGER as LogLevel) ?? "info" })];
-  }
-  if (PHARADAY_TRANSPORT_LOGGER) {
-    return [new ConsoleTransport()];
-  }
-
-  if (NODE_ENV === "production") {return [new ConsoleJSONTransport({ level: "info" })];}
-  if (NODE_ENV === "test" || NODE_ENV === "ci") {return [];}
-  return [new ConsoleTransport()];
-}
-
-@Module({
-  imports: [ConfigModule],
-  providers: [
-    {
-      provide: LoggerService,
-      useFactory: () => new LoggerService({ service: "pharaday-platform", transports: createTransports() }),
-    },
-    {
-      provide: APP_INTERCEPTOR,
-      useClass: LogAppCtxInterceptor,
-    },
-  ],
-  exports: [LoggerService],
-})
-export class LoggerModule {
-  configure(consumer: MiddlewareConsumer) {
-    consumer.apply(LoggerMiddleware, HttpLoggerMiddleware).forRoutes({ path: "*", method: RequestMethod.ALL });
-  }
-}