@invariant--labs/foundation 1.1.2 → 1.1.4

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/index.ts

@@ -1,5 +0,0 @@
-export * from "./app-logger";
-export * from "./log";
-export * from "./logger.module";
-export * from "./logger.service";
-export * from "./transports";

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 });
-  }
-}

package/src/modules/logger/logger.service.ts

@@ -1,131 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access */
-import * as cls from "cls-hooked";
-import { merge } from "lodash";
-
-import { ArchitectureLayer, ArchitectureLevel } from "../../core/types";
-import { LoggerTransport } from "./transports/logger-transport";
-import { CtxLog, DataLog, LogLevel } from "./log";
-
-const NSID = "fb8b817a-4824-4abc-a1b1-e7cbb7f420eb";
-
-export const SECRET_KEYS = [
-  "pass", "password", "token", "pendingToken",
-  "authToken", "accessToken", "refreshToken", "secret",
-] as const;
-
-const IGNORED_MESSAGES = ["Successfully connected to RMQ broker"] as const;
-
-export class LoggerService {
-  private readonly transports: LoggerTransport[];
-  private readonly service: string;
-
-  constructor({ transports, service }: { transports: LoggerTransport[]; service: string }) {
-    this.transports = transports;
-    this.service = service;
-  }
-
-  log(level: LogLevel, arg1: string | DataLog, arg2?: string | DataLog) {
-    const message = typeof arg1 === "string" ? arg1 : "";
-    if (IGNORED_MESSAGES.includes(message as any)) {return;}
-
-    const obj = typeof arg1 === "string" ? arg2 : arg1;
-    const { data, stack } = this.extractLogData(obj, message);
-    const ctx = this.getCtx();
-
-    for (const transport of this.transports) {
-      transport.add({
-        level,
-        message,
-        service: this.service,
-        stack,
-        data: { ...data, ...ctx },
-      });
-    }
-  }
-
-  error(arg1: string | DataLog, arg2?: string | DataLog) { this.log("error", arg1, arg2); }
-  warn(arg1: string | DataLog, arg2?: string | DataLog) { this.log("warn", arg1, arg2); }
-  info(arg1: string | DataLog, arg2?: string | DataLog) { this.log("info", arg1, arg2); }
-  http(arg1: string | DataLog, arg2?: string | DataLog) { this.log("http", arg1, arg2); }
-  verbose(arg1: string | DataLog, arg2?: string | DataLog) { this.log("verbose", arg1, arg2); }
-  debug(arg1: string | DataLog, arg2?: string | DataLog) { this.log("debug", arg1, arg2); }
-  silly(arg1: string | DataLog, arg2?: string | DataLog) { this.log("silly", arg1, arg2); }
-
-  init(req: any, res: any, next: any) {
-    const ns = cls.getNamespace(NSID) ?? cls.createNamespace(NSID);
-    ns.bind(req);
-    ns.bind(res);
-    ns.run(() => next());
-  }
-
-  clearCtx() {
-    const ns = cls.getNamespace(NSID);
-    if (ns?.active) {ns.set("ctx", {});}
-  }
-
-  ctx(layer: ArchitectureLayer, log?: CtxLog) {
-    const ns = cls.getNamespace(NSID);
-    const levelKeys = Object.keys(layer) as ArchitectureLevel[];
-
-    if (levelKeys.length <= 0) {
-      this.warn("[Logger] Error: layer has no architecture level, cannot set any logger context");
-      return;
-    }
-
-    try {
-      const anyLayer = layer as any;
-      const level = levelKeys[0] as string;
-      const trace = Object.keys(anyLayer[level])[0];
-      anyLayer[level][trace].meta = { ...anyLayer[level][trace].meta, ...log };
-    } catch {
-      this.warn("[Logger] Error: unable to define logger context, logging will be uncoherent", { error: "ctx parse failed" });
-    }
-
-    if (ns?.active) {
-      return ns.set("ctx", { ...merge(this.getCtx(), layer) });
-    }
-  }
-
-  private getCtx(): CtxLog {
-    return cls.getNamespace(NSID)?.active ? cls.getNamespace(NSID)!.get("ctx") : {};
-  }
-
-  private extractLogData(obj: string | DataLog | undefined, message: string) {
-    let stack: string | undefined;
-    const data: DataLog = {};
-
-    if (Array.isArray(obj)) {
-      data["list"] = this.stringifyValue(obj);
-    } else if (obj instanceof Error) {
-      stack = obj.stack;
-      if (!message) {data["text"] = obj.message;}
-    } else if (typeof obj === "object" && obj !== null) {
-      for (const [key, value] of Object.entries(obj)) {
-        if (key === "metrics") {data.metrics = { ...obj.metrics };}
-        else if (key === "stack" && typeof value === "string") {stack = this.stringifyValue(value);}
-        else {data[key] = this.sanitizeLog(key, value);}
-      }
-    } else if (typeof obj === "string") {
-      data["text"] = obj;
-    }
-
-    return { data, stack };
-  }
-
-  private stringifyValue(value: any): string {
-    try {
-      const content = value === undefined ? "" : typeof value === "string" ? value : JSON.stringify(value);
-      const secretPattern = new RegExp(`"(${SECRET_KEYS.join("|")})":"([^"]*)"`, "gm");
-      return content
-        .replace(/Bearer [^ "'\\]*/gm, "Bearer ***")
-        .replace(secretPattern, '"$1": "***"')
-        .replace(/(\.eyJ[^\s"]+\.[^\s"]+\.[^\s"]+)/, (_: string, match: string) => match.substring(0, 5) + "***");
-    } catch {
-      return "JSON.stringify did not work";
-    }
-  }
-
-  private sanitizeLog(key: string, value: any) {
-    return SECRET_KEYS.includes(key as any) ? "***" : this.stringifyValue(value);
-  }
-}

package/src/modules/logger/transports/console-color.transport.ts

@@ -1,41 +0,0 @@
-import { Log } from "../log";
-import { LoggerTransport } from "./logger-transport";
-
-const COLORS = {
-  Reset: "\x1b[0m",
-  Bright: "\x1b[1m",
-  Dim: "\x1b[2m",
-  FgRed: "\x1b[31m",
-  FgGreen: "\x1b[32m",
-  FgYellow: "\x1b[33m",
-  FgBlue: "\x1b[34m",
-  FgCyan: "\x1b[36m",
-  FgWhite: "\x1b[37m",
-} as const;
-
-const LEVEL_COLOR: Record<string, string> = {
-  warn: COLORS.FgYellow,
-  info: COLORS.FgCyan,
-  error: COLORS.FgRed,
-  http: COLORS.FgGreen,
-};
-
-export class ConsoleColorTransport extends LoggerTransport {
-  send(log: Log): void {
-    const level = this.bracket(log.level.toUpperCase(), LEVEL_COLOR[log.level] ?? COLORS.FgBlue);
-    const date = `${COLORS.Dim}${new Date().toISOString().substring(11, 19)}${COLORS.Reset}`;
-    const message = `${COLORS.Bright}${log.message}`;
-    const data = log.data && Object.keys(log.data).length > 0
-      ? `\n${COLORS.Dim}${JSON.stringify(log.data, null, 2)}${COLORS.Reset}`
-      : "";
-    const stack = log.stack
-      ? `\n-----\n${COLORS.Reset}${COLORS.Dim}${log.stack}${COLORS.Reset}\n-----\n`
-      : "";
-    // eslint-disable-next-line no-console
-    console.log(`${level} ${date} ${message}${data}${stack}`);
-  }
-
-  private bracket(message: string, color: string) {
-    return `${COLORS.FgWhite}[${color}${message}${COLORS.FgWhite}]${COLORS.Reset}`;
-  }
-}

package/src/modules/logger/transports/console-json.transport.ts

@@ -1,23 +0,0 @@
-import { Log } from "../log";
-import { LoggerTransport } from "./logger-transport";
-
-export class ConsoleJSONTransport extends LoggerTransport {
-  format(log: Log): string {
-    const { data = {}, message, service, stack, level } = log;
-    const { metrics, ...otherData } = data;
-    return JSON.stringify({
-      timestamp: new Date().toISOString(),
-      level,
-      service,
-      message,
-      data: otherData,
-      metrics,
-      stack,
-    });
-  }
-
-  send(log: Log): void {
-    // eslint-disable-next-line no-console
-    console.log(this.format(log));
-  }
-}

package/src/modules/logger/transports/console.transport.ts

@@ -1,10 +0,0 @@
-/* eslint-disable no-console */
-import { Log } from "../log";
-import { LoggerTransport } from "./logger-transport";
-
-export class ConsoleTransport extends LoggerTransport {
-  send(log: Log): void {
-    console.log(`[${log.level}] ${log.message}`);
-    console.log(JSON.stringify(log.data, null, 2));
-  }
-}

package/src/modules/logger/transports/fake.transport.ts

@@ -1,18 +0,0 @@
-import { Log } from "../log";
-import { LoggerTransport } from "./logger-transport";
-
-export class FakeTransport extends LoggerTransport {
-  public logs: Log[] = [];
-
-  send(log: Log) {
-    this.logs.push(log);
-  }
-
-  clear(): void {
-    this.logs = [];
-  }
-
-  getLastLog(): Log | undefined {
-    return this.logs.at(-1);
-  }
-}

package/src/modules/logger/transports/index.ts

@@ -1,5 +0,0 @@
-export * from "./console.transport";
-export * from "./console-color.transport";
-export * from "./console-json.transport";
-export * from "./fake.transport";
-export * from "./logger-transport";

package/src/modules/logger/transports/logger-transport.ts

@@ -1,22 +0,0 @@
-import { Log, LogLevel, LOG_LEVEL_PRIORITY } from "../log";
-
-export type LoggerTransportOptions = {
-  level: LogLevel;
-};
-
-export abstract class LoggerTransport {
-  readonly levelPriority: number;
-
-  constructor(public readonly options: LoggerTransportOptions = { level: "silly" }) {
-    this.levelPriority = LOG_LEVEL_PRIORITY[options.level];
-  }
-
-  add(log: Log): void {
-    if (this.levelPriority < LOG_LEVEL_PRIORITY[log.level]) {
-      return;
-    }
-    this.send(log);
-  }
-
-  abstract send(log: Log): void;
-}

package/src/modules/messaging/index.ts

@@ -1,2 +0,0 @@
-export * from "./messaging.module";
-export * from "../../core/infrastructure/messaging";

package/src/modules/messaging/messaging.module.ts

@@ -1,92 +0,0 @@
-import { DynamicModule, Module } from "@nestjs/common";
-import { ClientProxy, ClientProxyFactory, Transport } from "@nestjs/microservices";
-
-import { MessagingService, FakeMessagingService, RabbitMessagingService } from "../../core/infrastructure/messaging";
-import { ConfigModule, ConfigService } from "../config";
-import { LoggerModule, LoggerService } from "../logger";
-
-const clientProxyCache = new Map<string, ClientProxy>();
-
-function buildRmqUrl(config: ConfigService): string {
-  const protocol = config.get("RMQ_PROTOCOL");
-  const user = config.get("RMQ_USER");
-  const password = config.get("RMQ_PASSWORD");
-  const host = config.get("RMQ_HOST");
-  const port = config.get("RMQ_PORT");
-  return `${protocol}://${user}:${password}@${host}:${port}`;
-}
-
-async function closeAllCachedProxies(logger?: { info: (msg: string) => void; error: (msg: string, data?: object) => void }) {
-  for (const [queue, proxy] of clientProxyCache) {
-    try {
-      await proxy.close();
-      logger?.info(`Closed cached client proxy for queue: ${queue}`);
-    } catch (error) {
-      logger?.error(`Error closing cached client proxy for queue ${queue}:`, { error });
-    }
-  }
-  clientProxyCache.clear();
-}
-
-@Module({})
-export class MessagingModule {
-  static register(queueName: string): DynamicModule {
-    return {
-      module: MessagingModule,
-      imports: [ConfigModule, LoggerModule],
-      providers: [
-        {
-          provide: MessagingService,
-          useFactory: (configService: ConfigService, optionalProvider: ClientProxy) => {
-            return configService.isTest() ? new FakeMessagingService() : new RabbitMessagingService(optionalProvider);
-          },
-          inject: [ConfigService, { token: queueName, optional: false }],
-        },
-        {
-          provide: queueName,
-          useFactory: async (configService: ConfigService) => {
-            if (configService.isTest()) {return {};}
-
-            const cached = clientProxyCache.get(queueName);
-            if (cached) {return cached;}
-
-            const clientProxy = ClientProxyFactory.create({
-              transport: Transport.RMQ,
-              options: {
-                urls: [buildRmqUrl(configService)],
-                queue: queueName,
-                queueOptions: {
-                  durable: configService.getBoolean("RMQ_IS_DURABLE"),
-                  exclusive: false,
-                  autoDelete: false,
-                },
-                prefetchCount: 1,
-                socketOptions: {
-                  heartbeatIntervalInSeconds: 30,
-                  reconnectTimeInSeconds: 5,
-                },
-              },
-            });
-
-            await clientProxy.connect();
-            clientProxyCache.set(queueName, clientProxy);
-            return clientProxy;
-          },
-          inject: [ConfigService],
-        },
-        {
-          provide: "MESSAGING_MODULE_CLEANUP",
-          useFactory: (logger: LoggerService) => ({
-            async onModuleDestroy() { await closeAllCachedProxies(logger); },
-          }),
-          inject: [LoggerService],
-        },
-      ],
-      exports: [MessagingService],
-    };
-  }
-}
-
-export async function cleanupMessagingConnections() {
-  await closeAllCachedProxies();
-}

package/src/modules/queue/default-queue-name.resolver.ts

@@ -1,5 +0,0 @@
-import { ConfigService } from "../../core/infrastructure/config";
-import { QueueName, QueueNameResolver } from "../../core/infrastructure/messaging/types";
-
-export const defaultQueueNameResolverFactory = (configService: ConfigService): QueueNameResolver =>
-  (queueName: QueueName) => configService.get(`${queueName}_QUEUE_RMQ`) ?? "default";

package/src/modules/queue/index.ts

@@ -1,3 +0,0 @@
-export * from "./queue.module";
-export * from "../../core/infrastructure/messaging/types";
-export * from "../../core/infrastructure/messaging/queue-manager.service";

package/src/modules/queue/queue.module.ts

@@ -1,73 +0,0 @@
-import { DynamicModule, Global, Module } from "@nestjs/common";
-
-import {
-  QueueManagerService,
-  FakeQueueManagerService,
-  CLIENT_PROXY_OPTIONS,
-  ClientProxyOptions,
-  QUEUE_CORE_OPTIONS_TOKEN,
-  QUEUE_NAME_RESOLVER,
-  QueueModuleAsyncOptions,
-  QueueModuleOptions,
-  QueueNameResolver,
-} from "../../core/infrastructure/messaging";
-import { ConfigModule, ConfigService } from "../config";
-import { LoggerModule, LoggerService } from "../logger";
-import { defaultQueueNameResolverFactory } from "./default-queue-name.resolver";
-import { RabbitQueueManagerService } from "./rabbit-queue-manager.service";
-
-@Module({})
-@Global()
-export class QueueModule {
-  static forRootAsync(options?: QueueModuleAsyncOptions): DynamicModule {
-    return {
-      module: QueueModule,
-      imports: [QueueCoreModule.forRootAsync(options)],
-      exports: [QueueCoreModule],
-    };
-  }
-}
-
-@Module({})
-class QueueCoreModule {
-  static forRootAsync(options?: QueueModuleAsyncOptions): DynamicModule {
-    return {
-      module: QueueCoreModule,
-      imports: [...(options?.imports ?? []), ConfigModule, LoggerModule],
-      providers: [
-        {
-          provide: QUEUE_NAME_RESOLVER,
-          useFactory: (configService: ConfigService, option?: QueueModuleOptions) =>
-            option?.queueNameResolver ?? defaultQueueNameResolverFactory(configService),
-          inject: [ConfigService, { token: QUEUE_CORE_OPTIONS_TOKEN, optional: true }],
-        },
-        {
-          provide: CLIENT_PROXY_OPTIONS,
-          useFactory: (option?: QueueModuleOptions) => option?.clientProxyOptions,
-          inject: [QUEUE_CORE_OPTIONS_TOKEN],
-        },
-        ...(options
-          ? [{
-              provide: QUEUE_CORE_OPTIONS_TOKEN,
-              useFactory: options.useFactory,
-              inject: options.inject ?? [],
-            }]
-          : []),
-        {
-          provide: QueueManagerService,
-          useFactory: (
-            queueNameResolver: QueueNameResolver,
-            clientProxyOptions: ClientProxyOptions,
-            configService: ConfigService,
-            logger: LoggerService,
-          ) =>
-            configService.isTest()
-              ? new FakeQueueManagerService()
-              : new RabbitQueueManagerService(queueNameResolver, clientProxyOptions, logger),
-          inject: [QUEUE_NAME_RESOLVER, CLIENT_PROXY_OPTIONS, ConfigService, LoggerService],
-        },
-      ],
-      exports: [QueueManagerService],
-    };
-  }
-}