@pcg/core 1.0.0-alpha.0 → 1.0.0-alpha.2

package/src/logger/classes/logger.ts

@@ -1,340 +0,0 @@
-;
-import { isObject } from '#/tools/is-object.js';
-import { ApolloError } from '@apollo/client/core';
-import { HttpException } from '@nestjs/common';
-import { GraphQLError } from 'graphql';
-import { LogEntry, Logger as WinstonLogger } from 'winston';
-
-import { BaseServiceMethodContext } from '#/context';
-import { NestError } from '#/errors/index.js';
-import { HttpExceptionResponse } from '#/exceptions/http-exception-response';
-// import { getErrorMessages as getApolloErrorMessages } from '@deep/graphql-kit';
-import type {
-  DestructuredError,
-  InfoObject, LoggerContext,
-  WinstonLogLevel,
-} from '../logger.interfaces.js';
-
-/**
- * Logger with context for NestJS (from NestKit)
- */
-export class Logger {
-  constructor(
-    private readonly winstonLogger: WinstonLogger,
-    private context: LoggerContext = {
-    },
-  ) {}
-
-  /**
-   * Created child logger with specific context
-   * @param context - object with scope, action and other data
-   * @returns - new logger with context
-   * @example
-   * ```ts
-   * class SomeService {
-   *  logger: Logger;
-   *
-   *  constructor(
-   *   @InjectLoggerFactory() private readonly loggerFactory: LoggerFactory,
-   * ) {
-   *  // Create logger for this service
-   *  this.winstonLogger = this.winstonLoggerFactory.create({
-   *   scope: SomeService.name,
-   *  })
-   * }
-   *
-   * // Create child logger for some method
-   * getOne(id: string) {
-   *   const logger = this.winstonLogger.child({
-   *    action: this.someMethod.name,
-   *    id,
-   *   });
-   * }
-   * ```
-   */
-  // https://www.npmjs.com/package/json-log#log2--logchilddata
-  child(context: LoggerContext): Logger {
-    return new Logger(this.winstonLogger, {
-      ...this.context,
-      ...context,
-    });
-  }
-
-  /**
-   * Created child logger for nest service method
-   * Automatically parse service method context and add it to logger context
-   * @param name - service method name
-   * @param ctx - service method context
-   * @param other - custom logger context
-   * @returns - new logger with context
-   */
-  forMethod(name: string, ctx?: BaseServiceMethodContext, other?: LoggerContext) {
-    const context: LoggerContext = {
-      action: name,
-    };
-
-    if (ctx) {
-      Object.assign(context, {
-        requestId: ctx.requestId,
-      });
-
-      if (!ctx.user) {
-        throw new Error('User is required for strict method context. Use guards: @UseGuards(JwtAuthGuard) or @UseGuards(GraphQLJwtAuthGuard)');
-      }
-
-      Object.assign(context, {
-        requestId: ctx.requestId,
-        userId: ctx.user.id,
-      });
-    }
-
-    if (other) {
-      Object.assign(context, other);
-    }
-
-    return this.child(context);
-  }
-
-  /**
-   * Set data to logger context
-   * @param key - context data key (ex: 'firstName')
-   * @param value - context data value (ex: 'John')
-   */
-  setContext(key: string, value: unknown): void;
-  setContext(context: LoggerContext): void;
-  setContext(...args: unknown[]): void {
-    if (
-      args.length === 2 &&
-      typeof args[0] === 'string' &&
-      typeof args[1] !== 'undefined'
-    ) {
-      const key = args[0];
-      const value = args[1];
-      this.context[key] = value;
-    } else {
-      this.context = {
-        ...this.context,
-        ...(args[0] as LoggerContext),
-      };
-    }
-  }
-
-  /**
-   * Get logger context data
-   * @returns - logger context
-   */
-  getContext(): LoggerContext {
-    return structuredClone(this.context);
-  }
-
-  /**
-   * Write a 'log' level log.
-   */
-  log(entry: LogEntry): void;
-  log(level: WinstonLogLevel, message: string, context?: LoggerContext): void;
-  log(...args: unknown[]): void {
-    if (isObject(args[0])) {
-      this.winstonLogger.log({
-        ...this.context,
-        ...(args[0] as LogEntry),
-      });
-    } else {
-      this.winstonLogger.log({
-        level: args[0] as WinstonLogLevel,
-        message: args[1] as string,
-        ...this.context,
-        ...(args[2] as LoggerContext),
-      });
-    }
-  }
-
-  /**
-   * Write a 'info' level log.
-   */
-  info(message: string, context?: LoggerContext): void;
-  info(infoObject: InfoObject): void;
-  info(...args: unknown[]): void {
-    if (typeof args[0] === 'string') {
-      this.winstonLogger.info({
-        message: args[0],
-        ...this.context,
-        ...(args[1] as LoggerContext),
-      });
-    } else {
-      this.winstonLogger.info({
-        ...this.context,
-        ...(args[0] as InfoObject),
-      });
-    }
-  }
-
-  /**
-   * Write an 'error' level log.
-   */
-  error(message: string, context?: LoggerContext): void;
-  error(message: string, error: Error, context?: LoggerContext): void;
-  error(error: NestError): void;
-  error(error: Error, context?: LoggerContext): void;
-  error(...args: unknown[]): void {
-    if (args[0] instanceof NestError) {
-      const err = args[0];
-      this.winstonLogger.error({
-        ...this.context,
-        ...(args[1] as LoggerContext),
-        ...this.destructureError(err),
-      });
-    } else if (args[0] instanceof Error) {
-      const err = args[0];
-      this.winstonLogger.error({
-        ...this.context,
-        ...(args[1] as LoggerContext),
-        ...this.destructureError(err),
-      });
-    } else if (typeof args[0] === 'string' && args[1] instanceof Error) {
-      const message = args[0];
-      const err = args[1];
-      this.winstonLogger.error({
-        message: message,
-        ...this.context,
-        ...(args[2] as LoggerContext),
-        error: this.destructureError(err),
-      });
-    } else if (typeof args[0] === 'string') {
-      const message = args[0];
-      this.winstonLogger.error({
-        message,
-        ...this.context,
-        ...(args[1] as LoggerContext),
-      });
-    }
-  }
-
-  /**
-   * Creates plain object from error
-   * @see {@link DestructuredError}
-   */
-  protected destructureError(error: unknown): DestructuredError {
-    const errorObject: DestructuredError = {
-    };
-
-    if (error instanceof NestError) {
-      errorObject.message = error.message;
-      errorObject.stack = error.stack;
-      errorObject.context = error.context;
-      errorObject.statusCode = error.httpStatusCode;
-      errorObject.errorKey = error.key;
-      if (error.cause instanceof Error) {
-        errorObject.cause = this.destructureError(error.cause);
-      }
-    } else if (error instanceof Error) {
-      errorObject.message = error.message;
-      errorObject.stack = error.stack;
-    }
-
-    if (error instanceof HttpException) {
-      errorObject.statusCode = error.getStatus();
-
-      const response = error.getResponse() as HttpExceptionResponse;
-
-      if (isObject(response)) {
-        if (response.key) {
-          errorObject.errorKey = response.key;
-        }
-
-        if (response.context) {
-          if (!errorObject.context) {
-            errorObject.context = {
-            };
-          }
-
-          errorObject.context = {
-            ...errorObject.context,
-            ...response.context,
-          };
-        }
-
-        if (response.error) {
-          errorObject.cause = this.destructureError(response.error);
-        }
-      }
-
-      return errorObject;
-    } else if (error instanceof GraphQLError) {
-      const ctx = JSON.parse(JSON.stringify({
-        locations: error.locations,
-        positions: error.positions,
-        source: error.source,
-      }));
-
-      errorObject.context = {
-        ...errorObject.context,
-        ...ctx,
-      };
-    // } else if (error instanceof ApolloError) {
-    //   const messages = getApolloErrorMessages(error);
-    //   errorObject.message = messages.join('\n');
-    }
-
-    return errorObject;
-  }
-
-  /**
-   * Write a 'warn' level log.
-   */
-  warn(message: string, context?: LoggerContext): void;
-  warn(infoObject: InfoObject): void;
-  warn(...args: unknown[]): void {
-    if (typeof args[0] === 'string') {
-      this.winstonLogger.warn({
-        message: args[0],
-        ...this.context,
-        ...(args[1] as LoggerContext),
-      });
-    } else {
-      this.winstonLogger.warn({
-        ...this.context,
-        ...(args[0] as InfoObject),
-      });
-    }
-  }
-
-  /**
-   * Write a 'debug' level log.
-   */
-  debug(message: string, context?: LoggerContext): void;
-  debug(infoObject: InfoObject): void;
-  debug(...args: unknown[]): void {
-    if (typeof args[0] === 'string') {
-      this.winstonLogger.debug({
-        message: args[0],
-        ...this.context,
-        ...(args[1] as LoggerContext),
-      });
-    } else {
-      this.winstonLogger.debug({
-        ...this.context,
-        ...(args[0] as InfoObject),
-      });
-    }
-  }
-
-  /**
-   * Write a 'verbose' level log.
-   */
-  verbose(message: string, context?: LoggerContext): void;
-  verbose(infoObject: InfoObject): void;
-  verbose(...args: unknown[]): void {
-    if (typeof args[0] === 'string') {
-      this.winstonLogger.verbose({
-        message: args[0],
-        ...this.context,
-        ...(args[1] as LoggerContext),
-      });
-    } else {
-      this.winstonLogger.verbose({
-        ...this.context,
-        ...(args[0] as InfoObject),
-      });
-    }
-  }
-}

package/src/logger/classes/nest-system-logger.ts

@@ -1,63 +0,0 @@
-;
-
-import {
-  ConsoleLogger, Inject, Injectable, LogLevel as NestLogLevel,
-} from '@nestjs/common';
-import { isFunction, isPlainObject } from '@nestjs/common/utils/shared.utils';
-
-import { NESTKIT_LOGGER_PROVIDER } from '../logger.constants.js';
-import type { WinstonLogLevel } from '../logger.interfaces.js';
-import { Logger } from './logger.js';
-
-@Injectable()
-export class NestSystemLogger extends ConsoleLogger {
-  @Inject(NESTKIT_LOGGER_PROVIDER) private readonly logger!: Logger;
-
-  protected printMessages(messages: unknown[], context?: string | undefined, logLevel?: NestLogLevel | undefined): void {
-    for (const message of messages) {
-      this.logger.log(this.getWinstonLogLevel(logLevel), this.stringifyMessage(message), {
-        scope: context,
-      });
-    }
-  }
-
-  protected stringifyMessage(message: unknown): string {
-    // If the message is a function, call it and re-resolve its value.
-    if (isFunction(message)) {
-      return this.stringifyMessage(message());
-    }
-
-    if (isPlainObject(message) || Array.isArray(message)) {
-      return JSON.stringify(
-        message,
-        (key, value) =>
-          typeof value === 'bigint' ? value.toString() : value,
-        2,
-      );
-    }
-
-    return String(message);
-  }
-
-  private getWinstonLogLevel(level?: NestLogLevel): WinstonLogLevel {
-    switch (level) {
-      case 'log':
-        return 'info';
-
-      case 'verbose':
-        return 'verbose';
-
-      case 'debug':
-        return 'debug';
-
-      case 'warn':
-        return 'warn';
-
-      case 'error':
-        return 'error';
-
-      default:
-        return 'info';
-    }
-  }
-}

package/src/logger/classes/typeorm-logger.ts

@@ -1,83 +0,0 @@
-import type { LogLevel, LogMessage } from 'typeorm';
-import { AbstractLogger } from 'typeorm/logger/AbstractLogger.js';
-import type { LoggerOptions } from 'typeorm/logger/LoggerOptions.js';
-
-import { type LoggerContext } from '../logger.interfaces.js';
-import { Logger } from './logger.js';
-
-export class TypeOrmLoggerOptions {
-  enabled?: boolean;
-  logger!: Logger;
-  levels?: LoggerOptions;
-}
-
-export class TypeOrmLogger extends AbstractLogger {
-  logger: Logger;
-
-  constructor(opts: TypeOrmLoggerOptions) {
-    super(opts.enabled && opts.levels ? opts.levels : false);
-
-    this.logger = opts.logger;
-  }
-
-  /**
-   * Write log to specific output.
-   */
-  protected writeLog(
-    level: LogLevel, // "query" | "schema" | "error" | "warn" | "info" | "log" | "migration";
-    logMessage: LogMessage | LogMessage[],
-  ) {
-    const messages = this.prepareLogMessages(logMessage, {
-      highlightSql: false,
-    });
-
-    for (const message of messages) {
-      switch (message.type ?? level) {
-        case 'log':
-        case 'query':
-        case 'schema-build':
-          this.logger.debug(String(message.message), this.getCtx(message));
-          break;
-
-        case 'migration':
-        case 'info':
-          if (message.prefix) {
-            this.logger.info(`${message.prefix} ${message.message}`, this.getCtx(message));
-          } else {
-            this.logger.info(String(message.message), this.getCtx(message));
-          }
-          break;
-
-        case 'warn':
-        case 'query-slow':
-          if (message.prefix) {
-            this.logger.warn(`${message.prefix} ${message.message}`, this.getCtx(message));
-          } else {
-            this.logger.warn(String(message.message), this.getCtx(message));
-          }
-          break;
-
-        case 'error':
-        case 'query-error':
-          if (message.prefix) {
-            this.logger.error(`[${message.prefix}] ${message.message}`, this.getCtx(message));
-          } else {
-            this.logger.error(String(message.message), this.getCtx(message));
-          }
-          break;
-      }
-    }
-  }
-
-  private getCtx(message: LogMessage): LoggerContext {
-    const ctx = {
-      ...message.additionalInfo,
-    };
-
-    if (Array.isArray(ctx.parameters)) {
-      ctx.parameters = message.parameters;
-    }
-
-    return ctx;
-  }
-}

package/src/logger/index.ts

@@ -1,20 +0,0 @@
-;
-export * from './classes/nest-system-logger.js';
-
-export * from './classes/typeorm-logger.js';
-
-export * from './classes/logger.js';
-
-export * from './classes/logger-factory.js';
-
-export * from './logger.constants.js';
-
-export * from './logger.interfaces.js';
-
-export * from './logger.module.js';
-
-export * from './logger.providers.js';
-
-export * from './winston.tools.js';
-
-export * from '../configs/logger.config.js';

package/src/logger/logger.constants.ts

@@ -1,24 +0,0 @@
-/**
- * Injection token for Winston logger module configuration options
- */
-export const NESTKIT_LOGGER_MODULE_OPTIONS = 'NestKitLoggerModuleOptions';
-
-/**
- * Injection token for the Winston logger instance provider
- */
-export const NESTKIT_WINSTON_LOGGER_PROVIDER = 'NestKitLogger';
-
-/**
- * Injection token for the main NestKit logger provider
- */
-export const NESTKIT_LOGGER_PROVIDER = 'NestKitLogger';
-
-/**
- * Injection token for the NestJS system logger provider
- */
-export const NESTKIT_SYSTEM_LOGGER_PROVIDER = 'NestKitSystemLogger';
-
-/**
- * Injection token for the logger factory provider
- */
-export const NESTKIT_LOGGER_FACTORY_PROVIDER = 'NestKitLoggerFactory';

package/src/logger/logger.interfaces.ts

@@ -1,98 +0,0 @@
-import { Type } from '@nestjs/common';
-import { ModuleMetadata } from '@nestjs/common/interfaces';
-import { LoggerOptions } from 'winston';
-
-export type LoggerModuleOptions = LoggerOptions;
-export type WinstonLogLevel = 'error' | 'warn' | 'info' | 'http' | 'verbose' | 'debug' | 'silly';
-
-/**
- * Logger logger context with specific data for logging
- */
-export interface LoggerContext {
-  /**
-   * Scope where the message was logged
-   * @example 'VideoService'
-   */
-  scope?: string;
-
-  /**
-   * Action where the message was logged
-   * @example 'createOutput'
-   */
-  action?: string;
-
-  /**
-   * Request ID
-   * Special marker to identify request in logs
-   */
-  requestId?: string;
-
-  /**
-   * Additional data
-   */
-  [key: string]: unknown;
-}
-
-export interface InfoObject extends LoggerContext {
-  message: string;
-}
-
-export interface LoggerModuleOptionsFactory {
-  createLoggerModuleOptions():
-  | Promise<LoggerModuleOptions>
-  | LoggerModuleOptions;
-}
-
-export interface LoggerModuleAsyncOptions
-  extends Pick<ModuleMetadata, 'imports'> {
-  useFactory?: (
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ...args: any[]
-  ) => Promise<LoggerModuleOptions> | LoggerModuleOptions;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  inject?: any[];
-  useClass?: Type<LoggerModuleOptionsFactory>;
-}
-
-/**
- * Error object that is destructured and logged by Logger
- */
-export interface DestructuredError {
-  /**
-   * Error message text
-   */
-  message?: string;
-
-  /**
-   * Error stack from Error object (`Error.stack`)
-   */
-  stack?: string;
-
-  /**
-   * Error key from 'enum'
-   * @example 'NST_SA_EMAIL_NOT_UNIQUE'
-   */
-  errorKey?: string;
-
-  /**
-   * HTTP status code
-   * @example 400
-   */
-  statusCode?: number;
-
-  /**
-   * Child error.
-   */
-  cause?: DestructuredError;
-
-  /**
-   * Error context (additional data)
-   */
-  context?: LoggerContext;
-
-  /**
-   * Response body if error is HTTPError
-   */
-  body?: unknown;
-}
-

package/src/logger/logger.module.ts

@@ -1,45 +0,0 @@
-import {
-  DynamicModule, Global, LoggerService, Module,
-} from '@nestjs/common';
-
-import {
-  LoggerModuleAsyncOptions,
-  LoggerModuleOptions,
-} from './logger.interfaces.js';
-import {
-  createLoggerAsyncProviders,
-  createLoggerProviders,
-  createNestLogger,
-} from './logger.providers.js';
-
-@Global()
-@Module({
-})
-export class LoggerModule {
-  public static forRoot(options: LoggerModuleOptions): DynamicModule {
-    const providers = createLoggerProviders(options);
-
-    return {
-      module: LoggerModule,
-      providers: providers,
-      exports: providers,
-    };
-  }
-
-  public static forRootAsync(
-    options: LoggerModuleAsyncOptions,
-  ): DynamicModule {
-    const providers = createLoggerAsyncProviders(options);
-
-    return {
-      module: LoggerModule,
-      imports: options.imports,
-      providers: providers,
-      exports: providers,
-    } as DynamicModule;
-  }
-
-  public static createLogger(options: LoggerModuleOptions): LoggerService {
-    return createNestLogger(options);
-  }
-}