@invariant--labs/foundation 1.1.2

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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,43 @@
+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/healthcheck/index.ts

@@ -0,0 +1 @@
+export * from "./healthcheck-out.dto";

package/src/modules/knex/index.ts

@@ -0,0 +1,3 @@
+export * from "./knex.decorator";
+export * from "./knex.module";
+export * from "./knex.token";

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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,12 @@
+/* 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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,28 @@
+/* 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

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

package/src/modules/logger/log.ts

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,131 @@
+/* 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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,10 @@
+/* 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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,22 @@
+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

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

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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,5 @@
+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

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