@nest-yalc-2/logger 1.0.0

package/src/logger-nest.service.ts

@@ -0,0 +1,151 @@
+import { ConsoleLogger, ConsoleLoggerOptions } from '@nestjs/common';
+import {
+  IImprovedLoggerOptions,
+  ILoggerPluginMethods,
+  ImprovedLoggerService,
+  LogMethodOptions,
+  beforeLogging,
+} from './logger-abstract.service.js';
+import { maskDataInObject } from './logger.helper.js';
+import { WithPluginSystem } from '@nest-yalc-2/utils/plugin.helper.js';
+
+export class ImprovedNestLogger
+  extends WithPluginSystem<ILoggerPluginMethods>(ConsoleLogger)
+  implements ImprovedLoggerService
+{
+  public readonly isImprovedLoggerService = true;
+
+  constructor(
+    context: string,
+    options: ConsoleLoggerOptions,
+    protected _options: IImprovedLoggerOptions = {},
+  ) {
+    super(context, options);
+  }
+
+  private getOptions(options: LogMethodOptions | any): LogMethodOptions {
+    return typeof options === 'string' ? { message: options } : options;
+  }
+
+  private composeMessage(message: any, options: LogMethodOptions) {
+    const data = {
+      ...maskDataInObject(options.data, options.masks, options.stack),
+      config: options.config,
+    };
+
+    return (
+      (typeof message === 'string'
+        ? message
+        : JSON.stringify(message, null, 2)) +
+      (data ? `\n${JSON.stringify(data, null, 2)}` : '')
+    );
+  }
+
+  log(message: any): void;
+  log(message: any, options: LogMethodOptions): void;
+  log(message: any, ...optionalParams: any[]): void;
+  log(
+    message: unknown,
+    options: LogMethodOptions = {},
+    ...rest: unknown[]
+  ): void {
+    const _options = this.getOptions(options);
+
+    this.beforeLogging(message, _options);
+
+    super.log(
+      this.composeMessage(message, _options),
+      _options.context ?? this.context,
+      ...rest,
+    );
+  }
+
+  error(message: any, stack?: string | undefined): void;
+  error(
+    message: any,
+    stack: string | undefined,
+    options: LogMethodOptions,
+  ): void;
+  error(message: any, ...optionalParams: any[]): void;
+  error(
+    message: unknown,
+    stack?: unknown,
+    options: LogMethodOptions = {},
+    ...rest: unknown[]
+  ): void {
+    const _options = this.getOptions(options);
+    this.beforeLogging(message, _options);
+
+    super.error(
+      this.composeMessage(message, _options),
+      stack,
+      _options.context ?? this.context,
+      ...rest,
+    );
+  }
+
+  debug(message: any): void;
+  debug(message: any, options: LogMethodOptions): void;
+  debug(message: any, ...optionalParams: any[]): void;
+  debug(
+    message: unknown,
+    options: LogMethodOptions = {},
+    ...rest: unknown[]
+  ): void {
+    const _options = this.getOptions(options);
+    this.beforeLogging(message, _options);
+
+    super.debug(
+      this.composeMessage(message, _options),
+      _options.context ?? this.context,
+      ...rest,
+    );
+  }
+
+  verbose(message: any): void;
+  verbose(message: any, options: LogMethodOptions): void;
+  verbose(message: any, ...optionalParams: any[]): void;
+  verbose(
+    message: unknown,
+    options: LogMethodOptions = {},
+    ...rest: unknown[]
+  ): void {
+    const _options = this.getOptions(options);
+    this.beforeLogging(message, _options);
+
+    super.verbose(
+      this.composeMessage(message, _options),
+      _options.context ?? this.context,
+      ...rest,
+    );
+  }
+
+  warn(message: any): void;
+  warn(message: any, options: LogMethodOptions): void;
+  warn(message: any, ...optionalParams: any[]): void;
+  warn(
+    message: unknown,
+    options: LogMethodOptions = {},
+    ...rest: unknown[]
+  ): void {
+    const _options = this.getOptions(options);
+    this.beforeLogging(message, _options);
+
+    super.warn(
+      this.composeMessage(message, _options),
+      _options.context ?? this.context,
+      ...rest,
+    );
+  }
+
+  beforeLogging(message: any, options: LogMethodOptions) {
+    this.options.event = this.options.event ?? {};
+    this.invokePlugins(
+      'onBeforeLogging',
+      message,
+      options,
+      this._options.clsService,
+    );
+    void beforeLogging(message, options);
+  }
+}

package/src/logger-pino.service.d.ts

@@ -0,0 +1,10 @@
+import { LogLevel, OnApplicationShutdown } from '@nestjs/common';
+import { type Logger } from 'pino';
+import { type IImprovedLoggerOptions, LoggerAbstractService } from './logger-abstract.service.js';
+export declare const FLUSH_INTERVAL = 10000;
+export declare class PinoLogger extends LoggerAbstractService implements OnApplicationShutdown {
+    getLogger(): Logger;
+    constructor(context: string, logLevels: LogLevel[], options?: IImprovedLoggerOptions);
+    onApplicationShutdown(): Promise<void>;
+}
+export declare function flush(): Promise<unknown>;

package/src/logger-pino.service.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinoLogger = exports.FLUSH_INTERVAL = void 0;
+exports.flush = flush;
+const pino_1 = __importDefault(require("pino"));
+const logger_abstract_service_js_1 = require("./logger-abstract.service.js");
+const logger_helper_js_1 = require("./logger.helper.js");
+const promise_helper_js_1 = require("@nest-yalc-2/utils/promise.helper.js");
+let logger;
+let destination;
+exports.FLUSH_INTERVAL = 10000;
+class PinoLogger extends logger_abstract_service_js_1.LoggerAbstractService {
+    getLogger() {
+        return logger;
+    }
+    constructor(context, logLevels, options = {}) {
+        super(context, logLevels, {
+            log: (message, options) => logger.info({
+                context: options?.context ?? context,
+                ...(0, logger_helper_js_1.maskDataInObject)(options?.data, options?.masks),
+                config: options?.config,
+                trace: options?.stack,
+            }, message),
+            error: (message, trace, options) => {
+                logger.error({
+                    context: options?.context ?? context,
+                    ...(0, logger_helper_js_1.maskDataInObject)(options?.data, options?.masks),
+                    config: options?.config,
+                    trace,
+                }, message);
+            },
+            debug: (message, options) => logger.debug({
+                context: options?.context ?? context,
+                ...(0, logger_helper_js_1.maskDataInObject)(options?.data, options?.masks),
+                config: options?.config,
+                trace: options?.stack,
+            }, message),
+            warn: (message, options) => logger.warn({
+                context: options?.context ?? context,
+                ...(0, logger_helper_js_1.maskDataInObject)(options?.data, options?.masks),
+                config: options?.config,
+                trace: options?.stack,
+            }, message),
+            verbose: (message, options) => logger.trace({
+                context: options?.context ?? context,
+                ...(0, logger_helper_js_1.maskDataInObject)(options?.data, options?.masks),
+                config: options?.config,
+                trace: options?.stack,
+            }, message),
+        }, options);
+        if (!logger) {
+            destination = pino_1.default.destination({ sync: false });
+            logger = (0, pino_1.default)({
+                formatters: {
+                    level: (label) => {
+                        return { level: label };
+                    },
+                },
+                timestamp: () => `,"timestamp":"${new Date().toISOString()}"`,
+            }, destination);
+        }
+        logger.level = 'trace';
+        setInterval(function () {
+            logger.flush();
+        }, exports.FLUSH_INTERVAL).unref();
+        promise_helper_js_1.globalPromiseTracker.addDeferred(flush);
+    }
+    async onApplicationShutdown() {
+        await flush();
+    }
+}
+exports.PinoLogger = PinoLogger;
+function flush() {
+    destination?.flushSync();
+    return new Promise((resolve, reject) => {
+        logger.flush((err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve('Logger flushed successfully');
+            }
+        });
+    });
+}
+//# sourceMappingURL=logger-pino.service.js.map

package/src/logger-pino.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-pino.service.js","sourceRoot":"","sources":["logger-pino.service.ts"],"names":[],"mappings":";;;;;;AAqJA,sBAWC;AA/JD,gDAAyC;AACzC,6EAGsC;AACtC,yDAAsD;AACtD,4EAA4E;AAG5E,IAAI,MAAc,CAAC;AACnB,IAAI,WAAsB,CAAC;AAEd,QAAA,cAAc,GAAG,KAAK,CAAC;AAEpC,MAAa,UACX,SAAQ,kDAAqB;IAG7B,SAAS;QACP,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,YACE,OAAe,EACf,SAAqB,EACrB,UAAkC,EAAE;QAEpC,KAAK,CACH,OAAO,EACP,SAAS,EACT;YACE,GAAG,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CACxB,MAAM,CAAC,IAAI,CACT;gBACE,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,OAAO;gBACpC,GAAG,IAAA,mCAAgB,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC;gBAClD,MAAM,EAAE,OAAO,EAAE,MAAM;gBACvB,KAAK,EAAE,OAAO,EAAE,KAAK;aACtB,EACD,OAAO,CACR;YACH,KAAK,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;gBACjC,MAAM,CAAC,KAAK,CACV;oBACE,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,OAAO;oBACpC,GAAG,IAAA,mCAAgB,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC;oBAClD,MAAM,EAAE,OAAO,EAAE,MAAM;oBACvB,KAAK;iBACN,EACD,OAAO,CACR,CAAC;YACJ,CAAC;YACD,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CAC1B,MAAM,CAAC,KAAK,CACV;gBACE,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,OAAO;gBACpC,GAAG,IAAA,mCAAgB,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC;gBAClD,MAAM,EAAE,OAAO,EAAE,MAAM;gBACvB,KAAK,EAAE,OAAO,EAAE,KAAK;aACtB,EACD,OAAO,CACR;YACH,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CACzB,MAAM,CAAC,IAAI,CACT;gBACE,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,OAAO;gBACpC,GAAG,IAAA,mCAAgB,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC;gBAClD,MAAM,EAAE,OAAO,EAAE,MAAM;gBACvB,KAAK,EAAE,OAAO,EAAE,KAAK;aACtB,EACD,OAAO,CACR;YACH,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CAC5B,MAAM,CAAC,KAAK,CACV;gBACE,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,OAAO;gBACpC,GAAG,IAAA,mCAAgB,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC;gBAClD,MAAM,EAAE,OAAO,EAAE,MAAM;gBACvB,KAAK,EAAE,OAAO,EAAE,KAAK;aACtB,EACD,OAAO,CACR;SACJ,EACD,OAAO,CACR,CAAC;QAEF,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,WAAW,GAAG,cAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;YAChD,MAAM,GAAG,IAAA,cAAI,EACX;gBASE,UAAU,EAAE;oBACV,KAAK,EAAE,CAAC,KAAa,EAAE,EAAE;wBACvB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;oBAC1B,CAAC;iBACF;gBACD,SAAS,EAAE,GAAG,EAAE,CAAC,iBAAiB,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,GAAG;aAC9D,EACD,WAAW,CACZ,CAAC;QACJ,CAAC;QAED,MAAM,CAAC,KAAK,GAAG,OAAO,CAAC;QAIvB,WAAW,CAAC;YACV,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC,EAAE,sBAAc,CAAC,CAAC,KAAK,EAAE,CAAC;QAqB3B,wCAAoB,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,KAAK,CAAC,qBAAqB;QACzB,MAAM,KAAK,EAAE,CAAC;IAChB,CAAC;CACF;AAhID,gCAgIC;AAMD,SAAgB,KAAK;IACnB,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YACnB,IAAI,GAAG,EAAE,CAAC;gBACR,MAAM,CAAC,GAAG,CAAC,CAAC;YACd,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,6BAA6B,CAAC,CAAC;YACzC,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}

package/src/logger-pino.service.ts

@@ -0,0 +1,161 @@
+import { LogLevel, OnApplicationShutdown } from '@nestjs/common';
+import pino, { type Logger } from 'pino';
+import {
+  type IImprovedLoggerOptions,
+  LoggerAbstractService,
+} from './logger-abstract.service.js';
+import { maskDataInObject } from './logger.helper.js';
+import { globalPromiseTracker } from '@nest-yalc-2/utils/promise.helper.js';
+import { SonicBoom } from 'sonic-boom';
+
+let logger: Logger;
+let destination: SonicBoom;
+
+export const FLUSH_INTERVAL = 10000;
+
+export class PinoLogger
+  extends LoggerAbstractService
+  implements OnApplicationShutdown
+{
+  getLogger(): Logger {
+    return logger;
+  }
+
+  constructor(
+    context: string,
+    logLevels: LogLevel[],
+    options: IImprovedLoggerOptions = {},
+  ) {
+    super(
+      context,
+      logLevels,
+      {
+        log: (message, options) =>
+          logger.info(
+            {
+              context: options?.context ?? context,
+              ...maskDataInObject(options?.data, options?.masks),
+              config: options?.config,
+              trace: options?.stack,
+            },
+            message,
+          ),
+        error: (message, trace, options) => {
+          logger.error(
+            {
+              context: options?.context ?? context,
+              ...maskDataInObject(options?.data, options?.masks),
+              config: options?.config,
+              trace,
+            },
+            message,
+          );
+        },
+        debug: (message, options) =>
+          logger.debug(
+            {
+              context: options?.context ?? context,
+              ...maskDataInObject(options?.data, options?.masks),
+              config: options?.config,
+              trace: options?.stack,
+            },
+            message,
+          ),
+        warn: (message, options) =>
+          logger.warn(
+            {
+              context: options?.context ?? context,
+              ...maskDataInObject(options?.data, options?.masks),
+              config: options?.config,
+              trace: options?.stack,
+            },
+            message,
+          ),
+        verbose: (message, options) =>
+          logger.trace(
+            {
+              context: options?.context ?? context,
+              ...maskDataInObject(options?.data, options?.masks),
+              config: options?.config,
+              trace: options?.stack,
+            },
+            message,
+          ),
+      },
+      options,
+    );
+
+    if (!logger) {
+      destination = pino.destination({ sync: false });
+      logger = pino(
+        {
+          // base: {
+          //   memorySize: process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE,
+          //   region: process.env.AWS_REGION,
+          //   runtime: process.env.AWS_EXECUTION_ENV,
+          //   version: process.env.AWS_LAMBDA_FUNCTION_VERSION,
+          // },
+          // name: process.env.AWS_LAMBDA_FUNCTION_NAME,
+          // level: process.env.LOG_LEVEL || 'info',
+          formatters: {
+            level: (label: string) => {
+              return { level: label };
+            },
+          },
+          timestamp: () => `,"timestamp":"${new Date().toISOString()}"`,
+        },
+        destination,
+      );
+    }
+
+    logger.level = 'trace'; // enable all. Levels are handled by the Service.
+
+    // asynchronously flush every 10 seconds to keep the buffer empty
+    // in periods of low activity
+    setInterval(function () {
+      logger.flush();
+    }, FLUSH_INTERVAL).unref();
+
+    // TODO: remove it if it's not needed anymore (https://github.com/pinojs/pino/pull/1240/files)
+    // use pino.final to create a special logger that
+    // guarantees final tick writes
+    // const handler = pino.destination(
+    //   logger,
+    //   (err: String, finalLogger: Logger, evt: String) => {
+    //     finalLogger.info(`${evt} caught`);
+    //     if (err) finalLogger.error(err, 'error caused exit');
+    //     process.exit(err ? 1 : 0);
+    //   },
+    // );
+    // // catch all the ways node might exit
+    // process.on('beforeExit', () => handler(null, 'beforeExit'));
+    // process.on('exit', () => handler(null, 'exit'));
+    // process.on('uncaughtException', (err) => handler(err, 'uncaughtException'));
+    // process.on('SIGINT', () => handler(null, 'SIGINT'));
+    // process.on('SIGQUIT', () => handler(null, 'SIGQUIT'));
+    // process.on('SIGTERM', () => handler(null, 'SIGTERM'));
+
+    globalPromiseTracker.addDeferred(flush);
+  }
+
+  async onApplicationShutdown() {
+    await flush();
+  }
+}
+
+/**
+ * We keep this function outside of the class such that we do not rely
+ * on the class instance that might be destroyed before the flush is called.
+ */
+export function flush() {
+  destination?.flushSync();
+  return new Promise((resolve, reject) => {
+    logger.flush((err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve('Logger flushed successfully');
+      }
+    });
+  });
+}

package/src/logger.enum.d.ts

@@ -0,0 +1,17 @@
+export declare enum LogLevelEnum {
+    LOG = "log",
+    ERROR = "error",
+    WARN = "warn",
+    DEBUG = "debug",
+    VERBOSE = "verbose"
+}
+export declare const LOG_LEVEL_DEFAULT: LogLevelEnum[];
+export declare const LOG_LEVEL_ALL: LogLevelEnum[];
+export declare enum LoggerTypeEnum {
+    CONSOLE = "console",
+    PINO = "pino",
+    NEST = "nest-logger"
+}
+export declare enum LoggerDefContext {
+    NEST_SYSTEM = "system"
+}

package/src/logger.enum.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerDefContext = exports.LoggerTypeEnum = exports.LOG_LEVEL_ALL = exports.LOG_LEVEL_DEFAULT = exports.LogLevelEnum = void 0;
+var LogLevelEnum;
+(function (LogLevelEnum) {
+    LogLevelEnum["LOG"] = "log";
+    LogLevelEnum["ERROR"] = "error";
+    LogLevelEnum["WARN"] = "warn";
+    LogLevelEnum["DEBUG"] = "debug";
+    LogLevelEnum["VERBOSE"] = "verbose";
+})(LogLevelEnum || (exports.LogLevelEnum = LogLevelEnum = {}));
+exports.LOG_LEVEL_DEFAULT = [
+    LogLevelEnum.DEBUG,
+    LogLevelEnum.ERROR,
+    LogLevelEnum.LOG,
+    LogLevelEnum.WARN,
+];
+exports.LOG_LEVEL_ALL = [
+    LogLevelEnum.DEBUG,
+    LogLevelEnum.ERROR,
+    LogLevelEnum.LOG,
+    LogLevelEnum.VERBOSE,
+    LogLevelEnum.WARN,
+];
+var LoggerTypeEnum;
+(function (LoggerTypeEnum) {
+    LoggerTypeEnum["CONSOLE"] = "console";
+    LoggerTypeEnum["PINO"] = "pino";
+    LoggerTypeEnum["NEST"] = "nest-logger";
+})(LoggerTypeEnum || (exports.LoggerTypeEnum = LoggerTypeEnum = {}));
+var LoggerDefContext;
+(function (LoggerDefContext) {
+    LoggerDefContext["NEST_SYSTEM"] = "system";
+})(LoggerDefContext || (exports.LoggerDefContext = LoggerDefContext = {}));
+//# sourceMappingURL=logger.enum.js.map

package/src/logger.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.enum.js","sourceRoot":"","sources":["logger.enum.ts"],"names":[],"mappings":";;;AAAA,IAAY,YAMX;AAND,WAAY,YAAY;IACtB,2BAAW,CAAA;IACX,+BAAe,CAAA;IACf,6BAAa,CAAA;IACb,+BAAe,CAAA;IACf,mCAAmB,CAAA;AACrB,CAAC,EANW,YAAY,4BAAZ,YAAY,QAMvB;AAEY,QAAA,iBAAiB,GAAG;IAC/B,YAAY,CAAC,KAAK;IAClB,YAAY,CAAC,KAAK;IAClB,YAAY,CAAC,GAAG;IAChB,YAAY,CAAC,IAAI;CAClB,CAAC;AAEW,QAAA,aAAa,GAAG;IAC3B,YAAY,CAAC,KAAK;IAClB,YAAY,CAAC,KAAK;IAClB,YAAY,CAAC,GAAG;IAChB,YAAY,CAAC,OAAO;IACpB,YAAY,CAAC,IAAI;CAClB,CAAC;AAEF,IAAY,cAIX;AAJD,WAAY,cAAc;IACxB,qCAAmB,CAAA;IACnB,+BAAa,CAAA;IACb,sCAAoB,CAAA;AACtB,CAAC,EAJW,cAAc,8BAAd,cAAc,QAIzB;AAED,IAAY,gBAEX;AAFD,WAAY,gBAAgB;IAC1B,0CAAsB,CAAA;AACxB,CAAC,EAFW,gBAAgB,gCAAhB,gBAAgB,QAE3B"}

package/src/logger.enum.ts

@@ -0,0 +1,32 @@
+export enum LogLevelEnum {
+  LOG = 'log',
+  ERROR = 'error',
+  WARN = 'warn',
+  DEBUG = 'debug',
+  VERBOSE = 'verbose',
+}
+
+export const LOG_LEVEL_DEFAULT = [
+  LogLevelEnum.DEBUG,
+  LogLevelEnum.ERROR,
+  LogLevelEnum.LOG,
+  LogLevelEnum.WARN,
+];
+
+export const LOG_LEVEL_ALL = [
+  LogLevelEnum.DEBUG,
+  LogLevelEnum.ERROR,
+  LogLevelEnum.LOG,
+  LogLevelEnum.VERBOSE,
+  LogLevelEnum.WARN,
+];
+
+export enum LoggerTypeEnum {
+  CONSOLE = 'console',
+  PINO = 'pino',
+  NEST = 'nest-logger',
+}
+
+export enum LoggerDefContext {
+  NEST_SYSTEM = 'system',
+}

package/src/logger.event.d.ts

@@ -0,0 +1,11 @@
+export declare enum LoggerEvent {
+    QUERY_ERROR = "logger.query_error",
+    QUERY_LOG = "logger.query_log",
+    QUERY_SLOW = "logger.query_slow",
+    ERROR = "logger.error",
+    SCHEMA_BUILD = "logger.schema_build",
+    WARN = "logger.warn",
+    INFO = "logger.info",
+    DEBUG = "logger.debug",
+    LOG = "logger.log"
+}

package/src/logger.event.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerEvent = void 0;
+var LoggerEvent;
+(function (LoggerEvent) {
+    LoggerEvent["QUERY_ERROR"] = "logger.query_error";
+    LoggerEvent["QUERY_LOG"] = "logger.query_log";
+    LoggerEvent["QUERY_SLOW"] = "logger.query_slow";
+    LoggerEvent["ERROR"] = "logger.error";
+    LoggerEvent["SCHEMA_BUILD"] = "logger.schema_build";
+    LoggerEvent["WARN"] = "logger.warn";
+    LoggerEvent["INFO"] = "logger.info";
+    LoggerEvent["DEBUG"] = "logger.debug";
+    LoggerEvent["LOG"] = "logger.log";
+})(LoggerEvent || (exports.LoggerEvent = LoggerEvent = {}));
+//# sourceMappingURL=logger.event.js.map

package/src/logger.event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.event.js","sourceRoot":"","sources":["logger.event.ts"],"names":[],"mappings":";;;AAAA,IAAY,WAUX;AAVD,WAAY,WAAW;IACrB,iDAAkC,CAAA;IAClC,6CAA8B,CAAA;IAC9B,+CAAgC,CAAA;IAChC,qCAAsB,CAAA;IACtB,mDAAoC,CAAA;IACpC,mCAAoB,CAAA;IACpB,mCAAoB,CAAA;IACpB,qCAAsB,CAAA;IACtB,iCAAkB,CAAA;AACpB,CAAC,EAVW,WAAW,2BAAX,WAAW,QAUtB"}

package/src/logger.event.ts

@@ -0,0 +1,11 @@
+export enum LoggerEvent {
+  QUERY_ERROR = 'logger.query_error',
+  QUERY_LOG = 'logger.query_log',
+  QUERY_SLOW = 'logger.query_slow',
+  ERROR = 'logger.error',
+  SCHEMA_BUILD = 'logger.schema_build',
+  WARN = 'logger.warn',
+  INFO = 'logger.info',
+  DEBUG = 'logger.debug',
+  LOG = 'logger.log',
+}

package/src/logger.factory.d.ts

@@ -0,0 +1,3 @@
+import { LogLevel } from '@nestjs/common';
+import type { IImprovedLoggerOptions, ImprovedLoggerService } from './logger-abstract.service.js';
+export declare const AppLoggerFactory: (context: string, loggerLevels?: LogLevel[], loggerType?: string, options?: IImprovedLoggerOptions) => ImprovedLoggerService;

package/src/logger.factory.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppLoggerFactory = void 0;
+const logger_console_service_js_1 = require("./logger-console.service.js");
+const logger_pino_service_js_1 = require("./logger-pino.service.js");
+const common_1 = require("@nestjs/common");
+const logger_enum_js_1 = require("./logger.enum.js");
+const logger_nest_service_js_1 = require("./logger-nest.service.js");
+const _ = __importStar(require("lodash-es"));
+const logger_helper_js_1 = require("./logger.helper.js");
+exports.AppLoggerFactory = _.memoize((context, loggerLevels = logger_enum_js_1.LOG_LEVEL_DEFAULT, loggerType, options) => {
+    let logger;
+    switch (loggerType) {
+        case logger_enum_js_1.LoggerTypeEnum.CONSOLE:
+            logger = new logger_console_service_js_1.ConsoleLogger(context, loggerLevels, options);
+            break;
+        case logger_enum_js_1.LoggerTypeEnum.PINO:
+            logger = new logger_pino_service_js_1.PinoLogger(context, loggerLevels, options);
+            break;
+        case logger_enum_js_1.LoggerTypeEnum.NEST:
+        default:
+            logger = new logger_nest_service_js_1.ImprovedNestLogger(context, {
+                timestamp: true,
+            }, options);
+            logger.setLogLevels?.(loggerLevels);
+            break;
+    }
+    common_1.Logger.overrideLogger((0, logger_helper_js_1.getEnvLoggerLevels)());
+    common_1.Logger.debug?.(`Use Logger: ${loggerType ??
+        `not specified, fallback to default (${logger_enum_js_1.LoggerTypeEnum.NEST})`}`);
+    return logger;
+}, (context, loggerLevels, loggerType, options) => `${context}-${loggerLevels?.join('-')}-${loggerType}-${options}`);
+//# sourceMappingURL=logger.factory.js.map

package/src/logger.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.factory.js","sourceRoot":"","sources":["logger.factory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2EAA4D;AAC5D,qEAAsD;AACtD,2CAAkD;AAClD,qDAAqE;AACrE,qEAA8D;AAK9D,6CAA+B;AAC/B,yDAAwD;AAE3C,QAAA,gBAAgB,GAKA,CAAC,CAAC,OAAO,CACpC,CACE,OAAe,EACf,eAA2B,kCAAiB,EAC5C,UAAmB,EACnB,OAAgC,EACT,EAAE;IACzB,IAAI,MAA6B,CAAC;IAClC,QAAQ,UAAU,EAAE,CAAC;QACnB,KAAK,+BAAc,CAAC,OAAO;YACzB,MAAM,GAAG,IAAI,yCAAa,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;YAC3D,MAAM;QACR,KAAK,+BAAc,CAAC,IAAI;YACtB,MAAM,GAAG,IAAI,mCAAU,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;YACxD,MAAM;QACR,KAAK,+BAAc,CAAC,IAAI,CAAC;QACzB;YACE,MAAM,GAAG,IAAI,2CAAkB,CAC7B,OAAO,EACP;gBACE,SAAS,EAAE,IAAI;aAChB,EACD,OAAO,CACR,CAAC;YAGF,MAAM,CAAC,YAAY,EAAE,CAAC,YAAY,CAAC,CAAC;YACpC,MAAM;IACV,CAAC;IAKD,eAAM,CAAC,cAAc,CAAC,IAAA,qCAAkB,GAAE,CAAC,CAAC;IAI5C,eAAM,CAAC,KAAK,EAAE,CACZ,eACE,UAAU;QACV,uCAAuC,+BAAc,CAAC,IAAI,GAC5D,EAAE,CACH,CAAC;IAEF,OAAO,MAAM,CAAC;AAChB,CAAC,EACD,CACE,OAAe,EACf,YAAoC,EACpC,UAA8B,EAC9B,OAA2C,EACnC,EAAE,CAAC,GAAG,OAAO,IAAI,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,UAAU,IAAI,OAAO,EAAE,CAC9E,CAAC"}