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

package/src/logger/logger.providers.ts

@@ -1,140 +0,0 @@
-import {
-  Inject, Provider, Type,
-} from '@nestjs/common';
-import {
-  createLogger,
-  Logger,
-  LoggerOptions,
-} from 'winston';
-
-import { LoggerFactory } from './classes/logger-factory.js';
-import { NestSystemLogger } from './classes/nest-system-logger.js';
-import {
-  NESTKIT_LOGGER_FACTORY_PROVIDER,
-  NESTKIT_LOGGER_MODULE_OPTIONS,
-  NESTKIT_LOGGER_PROVIDER,
-  NESTKIT_SYSTEM_LOGGER_PROVIDER,
-  NESTKIT_WINSTON_LOGGER_PROVIDER,
-} from './logger.constants.js';
-import {
-  LoggerModuleAsyncOptions,
-  LoggerModuleOptions,
-  LoggerModuleOptionsFactory,
-} from './logger.interfaces.js';
-
-/**
- * Syntax sugar. Injects logger via NESTKIT_LOGGER_PROVIDER token
- * @example
- * ```ts
- * class SomeService {
- *  constructor(
- *   @InjectLogger() private readonly logger: Logger
- *  ) {}
- * ```
- */
-export const InjectLogger = () => Inject(NESTKIT_LOGGER_PROVIDER);
-
-/**
- * Syntax sugar. Injects winston logger factory by WINSTON_MODULE_FACTORY_PROVIDER token
- * @example
- * ```ts
- * class SomeService {
- *  constructor(
- *   @InjectLoggerFactory() private readonly loggerFactory: LoggerFactory
- *  ) {}
- * ```
- */
-export const InjectLoggerFactory = () => Inject(NESTKIT_LOGGER_FACTORY_PROVIDER);
-
-export const createNestLogger = (
-  loggerOpts: LoggerModuleOptions,
-): Logger => {
-  return new Logger(createLogger(loggerOpts));
-};
-
-export const createLoggerProviders = (
-  loggerOpts: LoggerModuleOptions,
-): Provider[] => {
-  return [
-    {
-      provide: NESTKIT_WINSTON_LOGGER_PROVIDER,
-      useFactory: () => createLogger(loggerOpts),
-    },
-    {
-      provide: NESTKIT_LOGGER_PROVIDER,
-      useFactory: (logger: Logger) => {
-        return new Logger(logger);
-      },
-      inject: [NESTKIT_WINSTON_LOGGER_PROVIDER],
-    },
-    {
-      provide: NESTKIT_SYSTEM_LOGGER_PROVIDER,
-      useClass: NestSystemLogger,
-    },
-    {
-      provide: NESTKIT_LOGGER_FACTORY_PROVIDER,
-      useFactory: (logger: Logger) => {
-        return new LoggerFactory(logger);
-      },
-      inject: [NESTKIT_WINSTON_LOGGER_PROVIDER],
-    },
-  ];
-};
-
-export const createLoggerAsyncProviders = (
-  options: LoggerModuleAsyncOptions,
-): Provider[] => {
-  const providers: Provider[] = [
-    {
-      provide: NESTKIT_WINSTON_LOGGER_PROVIDER,
-      useFactory: (loggerOpts: LoggerOptions) => createLogger(loggerOpts),
-      inject: [NESTKIT_LOGGER_MODULE_OPTIONS],
-    },
-    {
-      provide: NESTKIT_LOGGER_PROVIDER,
-      useFactory: (logger: Logger) => {
-        return new Logger(logger);
-      },
-      inject: [NESTKIT_WINSTON_LOGGER_PROVIDER],
-    },
-    {
-      provide: NESTKIT_SYSTEM_LOGGER_PROVIDER,
-      useClass: NestSystemLogger,
-    },
-    {
-      provide: NESTKIT_LOGGER_FACTORY_PROVIDER,
-      useFactory: (logger: Logger) => {
-        return new LoggerFactory(logger);
-      },
-      inject: [NESTKIT_WINSTON_LOGGER_PROVIDER],
-    },
-  ];
-
-  if (options.useClass) {
-    const useClass = options.useClass as Type<LoggerModuleOptionsFactory>;
-    providers.push(
-      ...[
-        {
-          provide: NESTKIT_LOGGER_MODULE_OPTIONS,
-          useFactory: async (optionsFactory: LoggerModuleOptionsFactory) =>
-            await optionsFactory.createLoggerModuleOptions(),
-          inject: [useClass],
-        },
-        {
-          provide: useClass,
-          useClass,
-        },
-      ],
-    );
-  }
-
-  if (options.useFactory) {
-    providers.push({
-      provide: NESTKIT_LOGGER_MODULE_OPTIONS,
-      useFactory: options.useFactory,
-      inject: options.inject || [],
-    });
-  }
-
-  return providers;
-};

package/src/logger/winston.tools.ts

@@ -1,241 +0,0 @@
-import { LogLevel } from '@nestjs/common';
-import clc from 'cli-color';
-import bare from 'cli-color/bare';
-import { Format } from 'logform';
-import { format } from 'winston';
-import { DestructuredError } from './logger.interfaces.js';
-
-const nestLikeColorScheme: Record<string, bare.Format> = {
-  log: clc.greenBright,
-  info: clc.greenBright,
-  error: clc.red,
-  warn: clc.yellow,
-  debug: clc.magentaBright,
-  verbose: clc.cyanBright,
-};
-
-/**
- * Options for nest-like formatting
- */
-export interface CreatePrettyMessageOptions {
-  /**
-   * Application name
-   * @example 'Jetstream'
-   */
-  appName: string;
-
-  /**
-   * Log level (info, error, warn, debug, verbose, log)
-   * @example 'info'
-   */
-  level: LogLevel;
-
-  /**
-   * Timestamp in ISO 8601 format
-   * @example '2021-06-10T16:33:42.000Z'
-   */
-  timestamp: string;
-
-  /**
-   * Message text
-   * @example 'Failed to create cloudlfare output'
-   */
-  message: string;
-
-  /**
-   * Scope where the message was logged
-   * @example 'VideoService'
-   */
-  scope?: string;
-
-  /**
-   * Action where the message was logged
-   * @example 'createOutput'
-   */
-  action?: string;
-
-  /**
-   * Error stack from Error object (`Error.stack`)
-   */
-  stack?: string;
-
-  /**
-   * Message context (additional data)
-   * @example { id: 'xxx' }
-   */
-  context: Record<string, unknown>;
-
-  /**
-   * Error key from 'enum'
-   * @example 'NST_SA_EMAIL_NOT_UNIQUE'
-   */
-  errorKey?: string;
-
-  /**
-   * HTTP status code
-   * @example '400'
-   */
-  statusCode?: string;
-
-  /**
-   * Parent path for child errors
-   * @example 'MainService.start --> VideoService.createOutput'
-   */
-  parentPath?: string;
-
-  /**
-   * Error cause
-   */
-  cause?: DestructuredError;
-
-  /**
-   * Recursion depth
-   * @example 0
-   */
-  deep?: number;
-}
-
-/**
- * Create a pretty message for the logger with nest-like formatting
- * Use recursion to print child errors
- * @param vars - message variables
- * @returns - formatted message
- * @example
- * [Jetstream]  - 6/10/2022, 4:33:42 PM      ERROR [VideoService.createOutput] Failed to create cloudlfare output
- */
-export const createPrettyMessage = ({
-  appName,
-  action,
-  level,
-  timestamp,
-  message,
-  scope,
-  stack,
-  errorKey,
-  // statusCode,
-  context,
-  parentPath,
-  cause,
-  deep = 0,
-}: CreatePrettyMessageOptions): string => {
-  if ('undefined' !== typeof timestamp) {
-    // Only format the timestamp to a locale representation if it's ISO 8601 format. Any format
-    // that is not a valid date string will throw, just ignore it (it will be printed as-is).
-    try {
-      if (timestamp === new Date(timestamp).toISOString()) {
-        timestamp = new Date(timestamp).toLocaleString();
-      }
-    } catch {
-      // Ignore
-    }
-  }
-
-  const color =
-    nestLikeColorScheme[level] || ((text: string): string => text);
-
-  if (errorKey) {
-    message += ` [${errorKey}]`;
-  }
-
-  // [Nest] 9539  - 05/26/2022, 9:00:29 AM     LOG [InstanceLoader] OrganizationsModule dependencies initialized +1ms
-
-  const sAppName = color(`[${appName}]`);
-  const sTimestamp = timestamp ? `${timestamp} ` : '';
-  const sLevel = color(level.toUpperCase());
-
-  let path = '';
-  let sPath = '';
-  if ('undefined' !== typeof scope && 'undefined' !== typeof action) {
-    path = `${scope}.${action}`;
-  } else if ('undefined' !== typeof scope) {
-    path = scope;
-  } else if ('undefined' !== typeof action) {
-    path = action;
-  }
-
-  // SyncWorker.sync --> CloudflareApi.createOutput]
-  if (path && parentPath) {
-    path = `${parentPath} --> ${path}`;
-  } else if (parentPath) {
-    path = parentPath;
-  }
-
-  if (path) {
-    sPath = clc.yellow(` [${path}]`);
-  }
-
-  // const sDeep = color(printDeep(deep));
-  const sMessage = color(` ${message}`);
-  const sStack = 'undefined' !== typeof stack ? color(`\n ${stack}`) : '';
-
-  let sRecursion = '';
-  if (cause) {
-    const {
-      action,
-      scope,
-      ...context
-    } = cause?.context || {
-    };
-
-    /**
-     * Print child errors recursively
-     */
-    sRecursion = cause ? `\n${createPrettyMessage({
-      appName,
-      action,
-      level,
-      timestamp,
-      message: cause.message ?? message,
-      scope,
-      stack: cause.stack,
-      errorKey: cause.errorKey,
-      context,
-      parentPath: path,
-      cause: cause.cause,
-      deep: deep + 1,
-    })}` : '';
-  }
-
-  const sContext = context && Object.keys(context).length > 0 ? color(` -- ${JSON.stringify(context, null, 2)}`) : '';
-
-  //  sAppName          sTimestamp            sLevel            sPath                     sMessage
-  // [Jetstream]  - 6/10/2022, 4:33:42 PM      ERROR [VideoService.createOutput] Failer to create cloudlfare output
-  return `${sAppName}  - ${sTimestamp}     ${sLevel}${sPath}${sMessage}${sStack}${sContext}${sRecursion}`;
-};
-
-/**
- * Create a nest-like console format
- * @param appName - App name (Jetstream, WHATSBIBLE, etc.)
- * @returns Winston format
- */
-export const nestLikeConsoleFormat = (appName = 'Nest'): Format =>
-  format.printf(
-    ({
-      level,
-      timestamp,
-      message,
-      scope,
-      action,
-      // ms,
-      stack,
-      errorKey,
-      statusCode,
-      error: cause,
-      ...context
-    }) => {
-      return createPrettyMessage({
-        appName,
-        action,
-        level: level as LogLevel,
-        timestamp,
-        message,
-        stack,
-        context,
-        scope,
-        errorKey,
-        statusCode,
-        cause,
-        deep: 0,
-      } as CreatePrettyMessageOptions);
-    },
-  );

package/src/middlewares/app.middleware.ts

@@ -1,26 +0,0 @@
-// app.middleware.ts
-import { Injectable, NestMiddleware } from '@nestjs/common';
-import { Response } from 'express';
-
-import { AppConfigType, InjectAppConfig } from '#/configs/app.config';
-import { getRequestLanguage } from '#/tools/get-request-language';
-import { extractRequestId } from '#/tools/request-id';
-import { NestExpressRequest } from '#/types/express-request';
-
-@Injectable()
-export class AppMiddleware implements NestMiddleware {
-  constructor(
-    @InjectAppConfig() private readonly appConfig: AppConfigType,
-  ) {}
-
-  use(req: NestExpressRequest, res: Response, next: () => void) {
-    const fallbackLang = this.appConfig.fallbackLanguage;
-
-    req.appShortname = this.appConfig.shortname;
-    req.requestId = extractRequestId(req);
-    req.query.lang = getRequestLanguage(req, fallbackLang);
-    req.query.fallbackLang = fallbackLang;
-
-    next();
-  }
-}

package/src/middlewares/index.ts

@@ -1 +0,0 @@
-export * from './app.middleware.js';

package/src/modules/hooks/base-hook.ts

@@ -1,64 +0,0 @@
-import { BaseServiceMethodContext } from '#/context';
-import { paramCase } from '@pcg/text-kit';
-
-export type BaseHookContext = BaseServiceMethodContext;
-
-const createHookIdFromClassName = (className: string) => {
-  const paramName = paramCase(className.replace(/Hook$/, ''));
-  const [first, ...rest] = paramName.split('-');
-
-  if (rest.length === 0) {
-    return first;
-  }
-
-  // If the first part of the name is a number, prepend 'hook' to it
-  return `${first}.${rest.join('-')}`;
-};
-
-/**
- * Interface for BaseHook class constructor with static id property
- */
-export interface BaseHookConstructor {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  new (...args: any[]): BaseHook;
-  readonly id: string;
-}
-
-/**
- * Base class for all hooks. Extend this class to create a new hook type.
- */
-export abstract class BaseHook<T = unknown, U extends BaseHookContext = BaseHookContext> {
-  /**
-   * Static id getter for accessing the hook type ID directly from the class
-   */
-  static get id(): string {
-    return createHookIdFromClassName(this.name);
-  }
-
-  /**
-   * Unique identifier for the hook type.
-   * This ID will be used for event emitting and subscribing.
-   * Automatically generated from the class name.
-   */
-  get id() {
-    return createHookIdFromClassName(this.constructor.name);
-  }
-
-  /**
-   * Optional payload that will be passed to all hook subscribers.
-   */
-  payload?: T;
-
-  /**
-   * Context information for the hook
-   */
-  ctx: U;
-
-  constructor(payload?: T, ctx?: U) {
-    if (payload) {
-      this.payload = payload;
-    }
-
-    this.ctx = ctx as U;
-  }
-}

package/src/modules/hooks/decorators/on-hook.decorator.ts

@@ -1,19 +0,0 @@
-import { OnEvent } from '@nestjs/event-emitter';
-
-import { BaseHookConstructor } from '../base-hook.js';
-
-/**
- * Decorator that registers a method as a handler for a specific hook.
- *
- * @param hook Class reference to the hook type (not an instance)
- * @returns Method decorator
- *
- * @example
- * ```typescript
- * @OnHook(ExampleHook)
- * handleExampleHook(hook: ExampleHook) {
- *   // Handle the hook here
- * }
- * ```
- */
-export const OnHook = (hook: BaseHookConstructor): MethodDecorator => OnEvent(hook.id);

package/src/modules/hooks/hooks.module.ts

@@ -1,10 +0,0 @@
-import { Global, Module } from '@nestjs/common';
-
-import { HooksService } from './hooks.service.js';
-
-@Global()
-@Module({
-  providers: [HooksService],
-  exports: [HooksService],
-})
-export class HooksModule {}

package/src/modules/hooks/hooks.service.ts

@@ -1,28 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { EventEmitter2 } from '@nestjs/event-emitter';
-
-import { NestJsService } from '#/abstracts/nestjs-service';
-import { BaseHook } from './base-hook.js';
-
-@Injectable()
-export class HooksService extends NestJsService {
-  constructor(private readonly eventEmitter: EventEmitter2) {
-    super();
-  }
-
-  /**
-   * Run a hook and notify all subscribers.
-   * This method will wait for all subscribers to complete their execution.
-   *
-   * @param hook The hook to run
-   * @returns Promise that resolves when all subscribers have completed
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async runHook<T>(hook: BaseHook<T>): Promise<any> {
-    this.logger.debug(`Running hook with ID: "${hook.id}"`, {
-      payload: hook.payload,
-    });
-
-    return await this.eventEmitter.emitAsync(hook.id, hook);
-  }
-}

package/src/modules/hooks/index.ts

@@ -1,11 +0,0 @@
-// Export the base hook class
-export * from './base-hook.js';
-
-// Export decorators
-export * from './decorators/on-hook.decorator.js';
-
-// Export the hooks module
-export * from './hooks.module.js';
-
-// Export the hooks service
-export * from './hooks.service.js';

package/src/modules/id/id.module.ts

@@ -1,26 +0,0 @@
-import { Global, Module } from '@nestjs/common';
-
-import { IdService } from './id.service.js';
-
-/**
- * An IdModule is a module within your application that provides services to generate unique IDs
- * for entities and other data objects.
- * @example
- * ```ts
- * // app.module.ts
- * import { IdModule } from './id.module';
- *
- * @Module({
- *   imports: [IdModule],
- *   controllers: [AppController],
- *   providers: [AppService],
- * })
- * export class AppModule {}
- * ```
- */
-@Global()
-@Module({
-  providers: [IdService],
-  exports: [IdService],
-})
-export class IdModule {}

package/src/modules/id/id.service.ts

@@ -1,57 +0,0 @@
-import { Inject, Injectable } from '@nestjs/common';
-import { getConfigToken } from '@nestjs/config';
-import { createRandomString } from '@pcg/text-kit';
-
-import { APP_CONFIG_TOKEN, type AppConfigType } from '#/configs/app.config';
-import { AppEnv } from '#/enums';
-import { generateEntityId } from '#/tools/generate-entity-id';
-
-/**
- * An IdService is a service within your application that provides methods to generate unique IDs
- * for entities and other data objects.
- */
-@Injectable()
-export class IdService {
-  constructor(
-    @Inject(getConfigToken(APP_CONFIG_TOKEN)) private readonly appConfig: AppConfigType,
-  ) {}
-
-  /**
-   * Returns a delimiter string based on the current environment.
-   * This delimiter is used in constructing the entity IDs.
-   * The delimiter is ':dev:' for development environments,
-   * :stage:' for staging environments and ':' for other environments.
-   *
-   * This allows for better differentiation and traceability of entities across various environments.
-   */
-  get delimiter() {
-    switch (this.appConfig.env) {
-      case AppEnv.TEST:
-        return ':test:';
-      case AppEnv.DEVELOPMENT:
-        return ':dev:';
-      case AppEnv.STAGE:
-        return ':stage:';
-      default:
-        return ':';
-    }
-  }
-
-  /**
-   * Generates unique id for entity
-   * @param prefix - entity id prefix in database (e.g. 'u' for users)
-   * @param app - app shortname (e.g. 'js')
-   * @returns id in format 'jsu:xxxxxxxxxxx' or 'jsu:stage:xxxxxxxxxxx' for staging environment
-   */
-  generateEntityId(prefix: string, app?: string): string {
-    return generateEntityId(app ?? this.appConfig.shortname, prefix, this.delimiter, 11);
-  }
-
-  /**
-   * Generates unique id with length 11
-   * @returns id in format 'xxxxxxxxxxx'
-   */
-  generateId(size?: number) {
-    return createRandomString(size);
-  }
-}

package/src/modules/id/index.ts

@@ -1,2 +0,0 @@
-export * from './id.module.js';
-export * from './id.service.js';

package/src/modules/postgres-pubsub/index.ts

@@ -1,3 +0,0 @@
-export * from './postgres-pubsub.js';
-export * from './postgres-pubsub.module.js';
-

package/src/modules/postgres-pubsub/postgres-pubsub.module.ts

@@ -1,14 +0,0 @@
-import { Global, Module } from '@nestjs/common';
-
-import { PostgresPubSub } from './postgres-pubsub.js';
-
-@Global()
-@Module({
-  providers: [
-    PostgresPubSub,
-  ],
-  exports: [
-    PostgresPubSub,
-  ],
-})
-export class PostgresPubSubModule {}