@adatechnology/logger 0.0.2

package/dist/index.js

@@ -0,0 +1,567 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_LOGGER_CONFIG: () => DEFAULT_LOGGER_CONFIG,
+  LOGGER_PROVIDER: () => LOGGER_PROVIDER,
+  LoggerModule: () => LoggerModule,
+  RequestContextMiddleware: () => RequestContextMiddleware,
+  getContext: () => getContext,
+  runWithContext: () => runWithContext
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/logger.module.ts
+var import_common4 = require("@nestjs/common");
+
+// src/logger.provider.ts
+var import_common = require("@nestjs/common");
+
+// src/implementations/winston/winston.logger.token.ts
+var WINSTON_LOGGER = "WINSTON_LOGGER";
+var WINSTON_RAW = "WINSTON_RAW";
+var WINSTON_OBFUSCATOR = "WINSTON_OBFUSCATOR";
+
+// src/logger.provider.ts
+var LoggerProvider = class {
+  constructor(implementation) {
+    this.implementation = implementation;
+  }
+  debug(...args) {
+    return this.implementation.debug(...args);
+  }
+  info(...args) {
+    return this.implementation.info(...args);
+  }
+  warn(...args) {
+    return this.implementation.warn(...args);
+  }
+  error(...args) {
+    return this.implementation.error(...args);
+  }
+  setContext(context) {
+    if (typeof this.implementation.setContext === "function") {
+      return this.implementation.setContext(context);
+    }
+    return;
+  }
+};
+LoggerProvider = __decorateClass([
+  (0, import_common.Injectable)(),
+  __decorateParam(0, (0, import_common.Inject)(WINSTON_LOGGER))
+], LoggerProvider);
+
+// src/logger.token.ts
+var LOGGER_PROVIDER = "LOGGER_PROVIDER";
+
+// src/implementations/winston/winston.logger.module.ts
+var import_common3 = require("@nestjs/common");
+var import_winston = require("winston");
+var import_util = require("util");
+
+// src/implementations/winston/winston.logger.provider.ts
+var import_common2 = require("@nestjs/common");
+
+// src/context/async-context.service.ts
+var import_async_hooks = require("async_hooks");
+var asyncLocalStorage = new import_async_hooks.AsyncLocalStorage();
+function getContext() {
+  return asyncLocalStorage.getStore();
+}
+function runWithContext(ctx, fn) {
+  return asyncLocalStorage.run(ctx, fn);
+}
+
+// src/logger.constant.ts
+var DEFAULT_SENSITIVE_KEYS = [
+  "password",
+  "pass",
+  "pwd",
+  "token",
+  "accessToken",
+  "refreshToken",
+  "authorization",
+  "auth",
+  "secret",
+  "ssn",
+  "creditCard"
+];
+var EMPTY_STRING = "";
+var MASK = {
+  REPLACEMENT: "****",
+  MIN_LENGTH: 4,
+  EDGE_CHARS: 2
+};
+var MASK_REPLACEMENT = MASK.REPLACEMENT;
+var MASK_MIN_LENGTH = MASK.MIN_LENGTH;
+var MASK_EDGE_CHARS = MASK.EDGE_CHARS;
+var ID_FALLBACK_SEPARATOR = "-";
+
+// src/implementations/winston/winston.logger.provider.ts
+var WinstonLoggerProvider = class {
+  constructor(logger, obfuscator) {
+    this.logger = logger;
+    this.obfuscator = obfuscator;
+  }
+  context;
+  debug(messageOrPayload, meta, context) {
+    this.handleLog("debug" /* DEBUG */, messageOrPayload, meta, context);
+  }
+  info(messageOrPayload, meta, context) {
+    this.handleLog("info" /* INFO */, messageOrPayload, meta, context);
+  }
+  warn(messageOrPayload, meta, context) {
+    this.handleLog("warn" /* WARN */, messageOrPayload, meta, context);
+  }
+  error(messageOrPayload, meta, context) {
+    this.handleLog("error" /* ERROR */, messageOrPayload, meta, context);
+  }
+  setContext(context) {
+    this.context = context;
+  }
+  handleLog(level, messageOrPayload, meta, context) {
+    let payload;
+    if (typeof messageOrPayload === "string") {
+      payload = {
+        message: messageOrPayload,
+        meta,
+        context: context || this.context
+      };
+    } else {
+      payload = {
+        ...messageOrPayload,
+        context: messageOrPayload.context || context || this.context,
+        meta: { ...messageOrPayload.meta, ...meta }
+      };
+    }
+    this.log({ level, payload });
+  }
+  log(params) {
+    const { level, payload } = params;
+    const { message, context, meta, ...rest } = payload;
+    const messageText = message ?? EMPTY_STRING;
+    const messageContext = context ?? this.context;
+    const obfuscatedMeta = this.obfuscator ? this.obfuscator(meta) : meta;
+    const requestContext = getContext();
+    const requestIdFromContext = requestContext?.requestId;
+    const logInfo = {
+      ...rest,
+      context: messageContext,
+      requestId: requestIdFromContext || payload.requestId,
+      meta: obfuscatedMeta
+    };
+    this.logger.log(level, messageText, logInfo);
+  }
+};
+WinstonLoggerProvider = __decorateClass([
+  (0, import_common2.Injectable)(),
+  __decorateParam(0, (0, import_common2.Inject)(WINSTON_RAW)),
+  __decorateParam(1, (0, import_common2.Inject)(WINSTON_OBFUSCATOR))
+], WinstonLoggerProvider);
+
+// src/implementations/winston/winston.logger.constants.ts
+var DEFAULT_LOG_LEVEL = "info";
+
+// src/obfuscator.ts
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function maskString(str) {
+  if (str.length <= MASK.MIN_LENGTH) return MASK.REPLACEMENT;
+  return str.slice(0, MASK.EDGE_CHARS) + MASK.REPLACEMENT + str.slice(-MASK.EDGE_CHARS);
+}
+function normalizeEntries(entries) {
+  const keys = [];
+  const custom = /* @__PURE__ */ new Map();
+  if (!entries || entries.length === 0) return { keys, custom };
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      keys.push(entry);
+    } else if (entry && typeof entry === "object" && "key" in entry && typeof entry.key === "string" && typeof entry.obfuscator === "function") {
+      custom.set(entry.key.toLowerCase(), entry.obfuscator);
+    }
+  }
+  return { keys, custom };
+}
+function defaultObfuscator(params) {
+  const { obj, entries } = params;
+  if (obj == null) return obj;
+  if (Array.isArray(obj)) {
+    return obj.map((item) => defaultObfuscator({ obj: item, entries }));
+  }
+  if (!isObject(obj)) return obj;
+  const { keys: extraKeys, custom } = normalizeEntries(entries);
+  const keys = DEFAULT_SENSITIVE_KEYS.concat(extraKeys || []);
+  function splitIntoWords(k) {
+    const withSpaces = k.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-.]+/g, " ");
+    return withSpaces.split(/\s+/).filter(Boolean);
+  }
+  const out = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    const lowerKey = key.toLowerCase();
+    if (custom.has(lowerKey)) {
+      try {
+        out[key] = custom.get(lowerKey)(value);
+      } catch (error) {
+        out[key] = MASK.REPLACEMENT;
+      }
+    } else if (
+      // match when key exactly equals a sensitive token OR
+      // when any token equals one of the camelCase/sep-separated words
+      keys.some((s) => {
+        const sens = s.toLowerCase();
+        if (lowerKey === sens) return true;
+        const words = splitIntoWords(lowerKey);
+        return words.some((w) => w === sens);
+      })
+    ) {
+      if (typeof value === "string") out[key] = maskString(value);
+      else out[key] = MASK.REPLACEMENT;
+    } else if (isObject(value) || Array.isArray(value)) {
+      out[key] = defaultObfuscator({ obj: value, entries });
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function buildDefaultObfuscator(additional) {
+  return (v) => defaultObfuscator({ obj: v, entries: additional });
+}
+
+// src/implementations/winston/winston.logger.module.ts
+var WinstonImplementationModule = class {
+  static forRoot(config) {
+    const providers = this.createProviders(config);
+    return {
+      module: WinstonImplementationModule,
+      providers,
+      exports: [WINSTON_LOGGER]
+    };
+  }
+  static forRootAsync(options) {
+    return {
+      module: WinstonImplementationModule,
+      imports: options.imports || [],
+      providers: [
+        {
+          provide: "LOGGER_CONFIG",
+          useFactory: options.useFactory,
+          inject: options.inject || []
+        },
+        {
+          provide: WINSTON_RAW,
+          useFactory: (config) => {
+            return this.createWinstonLogger(config);
+          },
+          inject: ["LOGGER_CONFIG"]
+        },
+        {
+          provide: WINSTON_OBFUSCATOR,
+          useFactory: (config) => {
+            return config?.obfuscator ?? buildDefaultObfuscator(config?.obfuscatorKeys);
+          },
+          inject: ["LOGGER_CONFIG"]
+        },
+        {
+          provide: WINSTON_LOGGER,
+          useClass: WinstonLoggerProvider
+        }
+      ],
+      exports: [WINSTON_LOGGER]
+    };
+  }
+  static createProviders(config) {
+    const winstonLogger = this.createWinstonLogger(config);
+    const obfuscator = config?.obfuscator ?? buildDefaultObfuscator(config?.obfuscatorKeys);
+    return [
+      {
+        provide: WINSTON_RAW,
+        useValue: winstonLogger
+      },
+      {
+        provide: WINSTON_OBFUSCATOR,
+        useValue: obfuscator
+      },
+      {
+        provide: WINSTON_LOGGER,
+        useClass: WinstonLoggerProvider
+      }
+    ];
+  }
+  static createWinstonLogger(config) {
+    const isProduction = config?.isProduction ?? process.env.NODE_ENV === "production";
+    const useColors = config?.colorize !== false;
+    const standardFields = (0, import_winston.format)((info) => {
+      const meta = info.meta;
+      if (meta) {
+        if (meta.requestId && !info.requestId) {
+          info.requestId = meta.requestId;
+          delete meta.requestId;
+        }
+        if (meta.context && !info.context) {
+          info.context = meta.context;
+          delete meta.context;
+        }
+        if (meta.source && !info.source) {
+          info.source = meta.source;
+          delete meta.source;
+        }
+        if (meta.lib && !info.lib) {
+          info.lib = meta.lib;
+          delete meta.lib;
+        }
+        if (meta.libVersion && !info.libVersion) {
+          info.libVersion = meta.libVersion;
+          delete meta.libVersion;
+        }
+        if (meta.libMethod && !info.libMethod) {
+          info.libMethod = meta.libMethod;
+          delete meta.libMethod;
+        }
+        if (meta.appName && !info.appName) {
+          info.appName = meta.appName;
+          delete meta.appName;
+        }
+        if (meta.appVersion && !info.appVersion) {
+          info.appVersion = meta.appVersion;
+          delete meta.appVersion;
+        }
+        if (meta.logContext && !info.source) {
+          const lc = meta.logContext;
+          if (lc.className && lc.methodName) {
+            info.source = `${lc.className}.${lc.methodName}`;
+          } else if (lc.className) {
+            info.source = lc.className;
+          } else if (lc.methodName) {
+            info.source = lc.methodName;
+          }
+        }
+      }
+      info.requestId = info.requestId || "no-request-id";
+      info.context = info.context || config?.context || "App";
+      info.appName = info.appName || config?.appName;
+      info.appVersion = info.appVersion || config?.appVersion;
+      info.lib = info.lib || config?.lib;
+      info.libVersion = info.libVersion || config?.libVersion;
+      return info;
+    });
+    const levelColorizer = import_winston.format.colorize();
+    const developmentFormat = import_winston.format.printf(
+      (info) => {
+        const {
+          level,
+          message,
+          timestamp,
+          requestId,
+          context,
+          source,
+          meta,
+          stack,
+          appName,
+          appVersion,
+          lib,
+          libMethod,
+          libVersion
+        } = info;
+        const colors = {
+          reset: "\x1B[0m",
+          gray: "\x1B[90m",
+          cyan: "\x1B[36m",
+          magenta: "\x1B[35m",
+          yellow: "\x1B[33m",
+          red: "\x1B[31m",
+          green: "\x1B[32m",
+          bold: "\x1B[1m"
+        };
+        const colorize = (color, text) => useColors ? `${color}${text}${colors.reset}` : text;
+        const coloredLevel = useColors ? levelColorizer.colorize(level, level.toUpperCase()) : level.toUpperCase();
+        const coloredTime = colorize(colors.gray, timestamp);
+        const coloredRequestId = colorize(colors.cyan, requestId);
+        let appDisplay = "";
+        if (appName) {
+          const appText = appVersion ? `${appName}@${appVersion}` : appName;
+          appDisplay = `[${colorize(colors.green, `App-${appText}`)}]`;
+        }
+        let libDisplay = "";
+        if (lib) {
+          const libText = libVersion ? `${lib}:${libVersion}` : lib;
+          libDisplay = `[${colorize(colors.yellow, libText)}]`;
+        }
+        const mag = colors.magenta;
+        let sourceDisplay = "";
+        let libMethodDisplay = "";
+        if (source) {
+          sourceDisplay = `[${colorize(mag, source)}]`;
+        }
+        if (lib) {
+          const methodPath = libMethod ? `${context}.${libMethod}` : context;
+          libMethodDisplay = `[${colorize(mag, methodPath)}]`;
+          if (source === context || source === methodPath) {
+            sourceDisplay = "";
+          }
+        } else if (!source) {
+          libMethodDisplay = `[${colorize(mag, context)}]`;
+        } else if (source.startsWith(`${context}.`) || source === context) {
+          libMethodDisplay = `[${colorize(mag, source)}]`;
+          sourceDisplay = "";
+        } else {
+          libMethodDisplay = `[${colorize(mag, context)}]`;
+          sourceDisplay = `[${colorize(mag, source)}]`;
+        }
+        let output = `${appDisplay}${libDisplay}[${coloredRequestId}][${coloredTime}]${sourceDisplay}${libMethodDisplay}[${coloredLevel}] - ${message}`;
+        if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
+          const inspectedMeta = (0, import_util.inspect)(meta, {
+            colors: useColors,
+            depth: null,
+            compact: true,
+            sorted: true,
+            breakLength: Infinity
+          });
+          output += ` - ${inspectedMeta}`;
+        }
+        if (stack) {
+          output += `
+${colorize(colors.red, stack)}`;
+        }
+        return output;
+      }
+    );
+    const formats = [
+      import_winston.format.timestamp(),
+      import_winston.format.errors({ stack: true }),
+      import_winston.format.splat(),
+      standardFields()
+    ];
+    if (isProduction) {
+      formats.push(import_winston.format.json());
+    } else {
+      formats.push(developmentFormat);
+    }
+    const defaultFormat = import_winston.format.combine(...formats);
+    const consoleTransport = new import_winston.transports.Console({
+      format: defaultFormat
+    });
+    const defaultOptions = {
+      level: config?.level || process.env.LOG_LEVEL || DEFAULT_LOG_LEVEL,
+      format: defaultFormat,
+      transports: [consoleTransport]
+    };
+    const mergedOptions = Object.assign(
+      {},
+      defaultOptions,
+      config?.loggerOptions || {}
+    );
+    return (0, import_winston.createLogger)(mergedOptions);
+  }
+};
+WinstonImplementationModule = __decorateClass([
+  (0, import_common3.Module)({})
+], WinstonImplementationModule);
+
+// src/logger.module.ts
+var LoggerModule = class {
+  static forRoot(config) {
+    const implModule = WinstonImplementationModule.forRoot(config);
+    const provider = {
+      provide: LOGGER_PROVIDER,
+      useClass: LoggerProvider
+    };
+    if (config && config.requestScoped) {
+      provider.scope = import_common4.Scope.REQUEST;
+    }
+    return {
+      module: LoggerModule,
+      imports: [implModule],
+      providers: [provider],
+      exports: [LOGGER_PROVIDER]
+    };
+  }
+  static forRootAsync(options) {
+    return {
+      module: LoggerModule,
+      imports: [
+        ...options.imports || [],
+        WinstonImplementationModule.forRootAsync(options)
+      ],
+      providers: [
+        {
+          provide: LOGGER_PROVIDER,
+          useClass: LoggerProvider
+        }
+      ],
+      exports: [LOGGER_PROVIDER]
+    };
+  }
+};
+LoggerModule = __decorateClass([
+  (0, import_common4.Global)(),
+  (0, import_common4.Module)({})
+], LoggerModule);
+
+// src/middleware/request-context.middleware.ts
+var import_common5 = require("@nestjs/common");
+var import_crypto = require("crypto");
+
+// src/request-id.constants.ts
+var DEFAULT_HTTP_REQUEST_ID_HEADER = "x-request-id";
+var DEFAULT_HTTP_REQUEST_ID_FALLBACKS = ["x-correlation-id"];
+var HEADERS_PARAMS = {
+  REQUEST_ID: DEFAULT_HTTP_REQUEST_ID_HEADER,
+  FALLBACKS: DEFAULT_HTTP_REQUEST_ID_FALLBACKS
+};
+
+// src/middleware/request-context.middleware.ts
+var RequestContextMiddleware = class {
+  use(req, _res, next) {
+    const existing = req.headers?.[HEADERS_PARAMS.REQUEST_ID] || req.headers?.[HEADERS_PARAMS.FALLBACKS[0]];
+    const id = existing || (typeof import_crypto.randomUUID === "function" ? (0, import_crypto.randomUUID)() : `${Date.now()}${ID_FALLBACK_SEPARATOR}${Math.random()}`);
+    asyncLocalStorage.run({ requestId: id }, () => next());
+  }
+};
+RequestContextMiddleware = __decorateClass([
+  (0, import_common5.Injectable)()
+], RequestContextMiddleware);
+
+// src/logger.config.ts
+var DEFAULT_LOGGER_CONFIG = {
+  requestScoped: false,
+  level: "info",
+  colorize: true
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_LOGGER_CONFIG,
+  LOGGER_PROVIDER,
+  LoggerModule,
+  RequestContextMiddleware,
+  getContext,
+  runWithContext
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@adatechnology/logger",
+  "version": "0.0.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.16",
+    "@nestjs/core": "^11"
+  },
+  "devDependencies": {
+    "@esbuild-plugins/tsconfig-paths": "^0.1.2",
+    "tsup": "^8.5.1"
+  },
+  "dependencies": {
+    "winston": "^3.9.0"
+  },
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build": "tsup src/index.ts --dts --tsconfig tsconfig.tsup.json",
+    "build:watch": "tsup src/index.ts --watch --dts --tsconfig tsconfig.tsup.json",
+    "check": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/src/context/async-context.service.ts

@@ -0,0 +1,17 @@
+import { AsyncLocalStorage } from "async_hooks";
+import { RequestContext } from "./async-context.types";
+
+export const asyncLocalStorage = new AsyncLocalStorage<
+  Record<string, unknown>
+>();
+
+export function getContext(): RequestContext {
+  return asyncLocalStorage.getStore();
+}
+
+export function runWithContext<T>(
+  ctx: Record<string, unknown>,
+  fn: () => T,
+): T {
+  return asyncLocalStorage.run(ctx, fn as any);
+}

package/src/context/async-context.types.ts

@@ -0,0 +1 @@
+export type RequestContext = Record<string, unknown> | undefined;

package/src/implementations/winston/winston.logger.constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_LOG_LEVEL = "info";