@nestjs/common 10.4.10 → 11.0.0-next.1

package/services/console-logger.service.d.ts

@@ -1,3 +1,4 @@
+import { InspectOptions } from 'util';
 import { LoggerService, LogLevel } from './logger.service';
 export interface ConsoleLoggerOptions {
     /**
@@ -6,16 +7,98 @@ export interface ConsoleLoggerOptions {
     logLevels?: LogLevel[];
     /**
      * If enabled, will print timestamp (time difference) between current and previous log message.
+     * Note: This option is not used when `json` is enabled.
      */
     timestamp?: boolean;
+    /**
+     * A prefix to be used for each log message.
+     * Note: This option is not used when `json` is enabled.
+     */
+    prefix?: string;
+    /**
+     * If enabled, will print the log message in JSON format.
+     */
+    json?: boolean;
+    /**
+     * If enabled, will print the log message in color.
+     * Default true if json is disabled, false otherwise
+     */
+    colors?: boolean;
+    /**
+     * The context of the logger.
+     */
+    context?: string;
+    /**
+     * If enabled, will print the log message in a single line, even if it is an object with multiple properties.
+     * If set to a number, the most n inner elements are united on a single line as long as all properties fit into breakLength. Short array elements are also grouped together.
+     * Default true when `json` is enabled, false otherwise.
+     */
+    compact?: boolean | number;
+    /**
+     * Specifies the maximum number of Array, TypedArray, Map, Set, WeakMap, and WeakSet elements to include when formatting.
+     * Set to null or Infinity to show all elements. Set to 0 or negative to show no elements.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default 100
+     */
+    maxArrayLength?: number;
+    /**
+     * Specifies the maximum number of characters to include when formatting.
+     * Set to null or Infinity to show all elements. Set to 0 or negative to show no characters.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default 10000.
+     */
+    maxStringLength?: number;
+    /**
+     * If enabled, will sort keys while formatting objects.
+     * Can also be a custom sorting function.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default false
+     */
+    sorted?: boolean | ((a: string, b: string) => number);
+    /**
+     * Specifies the number of times to recurse while formatting object. T
+     * This is useful for inspecting large objects. To recurse up to the maximum call stack size pass Infinity or null.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default 5
+     */
+    depth?: number;
+    /**
+     * If true, object's non-enumerable symbols and properties are included in the formatted result.
+     * WeakMap and WeakSet entries are also included as well as user defined prototype properties
+     * @default false
+     */
+    showHidden?: boolean;
+    /**
+     * The length at which input values are split across multiple lines. Set to Infinity to format the input as a single line (in combination with "compact" set to true).
+     * Default Infinity when "compact" is true, 80 otherwise.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     */
+    breakLength?: number;
 }
 export declare class ConsoleLogger implements LoggerService {
-    protected context?: string;
+    /**
+     * The options of the logger.
+     */
     protected options: ConsoleLoggerOptions;
-    private static lastTimestampAt?;
-    private originalContext?;
+    /**
+     * The context of the logger (can be set manually or automatically inferred).
+     */
+    protected context?: string;
+    /**
+     * The original context of the logger (set in the constructor).
+     */
+    protected originalContext?: string;
+    /**
+     * The options used for the "inspect" method.
+     */
+    protected inspectOptions: InspectOptions;
+    /**
+     * The last timestamp at which the log message was printed.
+     */
+    protected static lastTimestampAt?: number;
     constructor();
     constructor(context: string);
+    constructor(options: ConsoleLoggerOptions);
     constructor(context: string, options: ConsoleLoggerOptions);
     /**
      * Write a 'log' level log, if the configured level allows for it.
@@ -70,7 +153,13 @@ export declare class ConsoleLogger implements LoggerService {
     resetContext(): void;
     isLevelEnabled(level: LogLevel): boolean;
     protected getTimestamp(): string;
-    protected printMessages(messages: unknown[], context?: string, logLevel?: LogLevel, writeStreamType?: 'stdout' | 'stderr'): void;
+    protected printMessages(messages: unknown[], context?: string, logLevel?: LogLevel, writeStreamType?: 'stdout' | 'stderr', errorStack?: unknown): void;
+    protected printAsJson(message: unknown, options: {
+        context: string;
+        logLevel: LogLevel;
+        writeStreamType?: 'stdout' | 'stderr';
+        errorStack?: unknown;
+    }): void;
     protected formatPid(pid: number): string;
     protected formatContext(context: string): string;
     protected formatMessage(logLevel: LogLevel, message: unknown, pidMessage: string, formattedLogLevel: string, contextMessage: string, timestampDiff: string): string;
@@ -79,6 +168,8 @@ export declare class ConsoleLogger implements LoggerService {
     protected printStackTrace(stack: string): void;
     protected updateAndGetTimestampDiff(): string;
     protected formatTimestampDiff(timestampDiff: number): string;
+    protected getInspectOptions(): InspectOptions;
+    protected stringifyReplacer(key: string, value: unknown): unknown;
     private getContextAndMessagesToPrint;
     private getContextAndStackAndMessagesToPrint;
     private isStackFormat;

package/services/console-logger.service.js

@@ -3,10 +3,12 @@ var ConsoleLogger_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleLogger = void 0;
 const tslib_1 = require("tslib");
+const util_1 = require("util");
 const core_1 = require("../decorators/core");
 const cli_colors_util_1 = require("../utils/cli-colors.util");
 const shared_utils_1 = require("../utils/shared.utils");
 const utils_1 = require("./utils");
+const DEFAULT_DEPTH = 5;
 const DEFAULT_LOG_LEVELS = [
     'log',
     'error',
@@ -24,13 +26,21 @@ const dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
     month: '2-digit',
 });
 let ConsoleLogger = ConsoleLogger_1 = class ConsoleLogger {
-    constructor(context, options = {}) {
-        this.context = context;
-        this.options = options;
-        if (!options.logLevels) {
-            options.logLevels = DEFAULT_LOG_LEVELS;
-        }
+    constructor(contextOrOptions, options) {
+        // eslint-disable-next-line prefer-const
+        let [context, opts] = (0, shared_utils_1.isString)(contextOrOptions)
+            ? [contextOrOptions, options]
+            : options
+                ? [undefined, options]
+                : [contextOrOptions?.context, contextOrOptions];
+        opts = opts ?? {};
+        opts.logLevels ??= DEFAULT_LOG_LEVELS;
+        opts.colors ??= opts.colors ?? (opts.json ? false : true);
+        opts.prefix ??= 'Nest';
+        this.options = opts;
+        this.inspectOptions = this.getInspectOptions();
         if (context) {
+            this.context = context;
             this.originalContext = context;
         }
     }
@@ -49,7 +59,7 @@ let ConsoleLogger = ConsoleLogger_1 = class ConsoleLogger {
             return;
         }
         const { messages, context, stack } = this.getContextAndStackAndMessagesToPrint([message, ...optionalParams]);
-        this.printMessages(messages, context, 'error', 'stderr');
+        this.printMessages(messages, context, 'error', 'stderr', stack);
         this.printStackTrace(stack);
     }
     warn(message, ...optionalParams) {
@@ -122,8 +132,17 @@ let ConsoleLogger = ConsoleLogger_1 = class ConsoleLogger {
     getTimestamp() {
         return dateTimeFormatter.format(Date.now());
     }
-    printMessages(messages, context = '', logLevel = 'log', writeStreamType) {
+    printMessages(messages, context = '', logLevel = 'log', writeStreamType, errorStack) {
         messages.forEach(message => {
+            if (this.options.json) {
+                this.printAsJson(message, {
+                    context,
+                    logLevel,
+                    writeStreamType,
+                    errorStack,
+                });
+                return;
+            }
             const pidMessage = this.formatPid(process.pid);
             const contextMessage = this.formatContext(context);
             const timestampDiff = this.updateAndGetTimestampDiff();
@@ -132,11 +151,33 @@ let ConsoleLogger = ConsoleLogger_1 = class ConsoleLogger {
             process[writeStreamType ?? 'stdout'].write(formattedMessage);
         });
     }
+    printAsJson(message, options) {
+        const logObject = {
+            level: options.logLevel,
+            pid: process.pid,
+            timestamp: Date.now(),
+            message,
+        };
+        if (options.context) {
+            logObject.context = options.context;
+        }
+        if (options.errorStack) {
+            logObject.stack = options.errorStack;
+        }
+        const formattedMessage = !this.options.colors && this.inspectOptions.compact === true
+            ? JSON.stringify(logObject, this.stringifyReplacer)
+            : (0, util_1.inspect)(logObject, this.inspectOptions);
+        process[options.writeStreamType ?? 'stdout'].write(`${formattedMessage}\n`);
+    }
     formatPid(pid) {
-        return `[Nest] ${pid}  - `;
+        return `[${this.options.prefix}] ${pid}  - `;
     }
     formatContext(context) {
-        return context ? (0, cli_colors_util_1.yellow)(`[${context}] `) : '';
+        if (!context) {
+            return '';
+        }
+        context = `[${context}] `;
+        return this.options.colors ? (0, cli_colors_util_1.yellow)(context) : context;
     }
     formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff) {
         const output = this.stringifyMessage(message, logLevel);
@@ -155,16 +196,27 @@ let ConsoleLogger = ConsoleLogger_1 = class ConsoleLogger {
             // If the message is a non-class function, call it and re-resolve its value.
             return this.stringifyMessage(message(), logLevel);
         }
-        return (0, shared_utils_1.isPlainObject)(message) || Array.isArray(message)
-            ? `${this.colorize('Object:', logLevel)}\n${JSON.stringify(message, (key, value) => typeof value === 'bigint' ? value.toString() : value, 2)}\n`
-            : this.colorize(message, logLevel);
+        if (typeof message === 'string') {
+            return this.colorize(message, logLevel);
+        }
+        const outputText = (0, util_1.inspect)(message, this.inspectOptions);
+        if ((0, shared_utils_1.isPlainObject)(message)) {
+            return `Object(${Object.keys(message).length}) ${outputText}`;
+        }
+        if (Array.isArray(message)) {
+            return `Array(${message.length}) ${outputText}`;
+        }
+        return outputText;
     }
     colorize(message, logLevel) {
+        if (!this.options.colors || this.options.json) {
+            return message;
+        }
         const color = this.getColorByLogLevel(logLevel);
         return color(message);
     }
     printStackTrace(stack) {
-        if (!stack) {
+        if (!stack || this.options.json) {
             return;
         }
         process.stderr.write(`${stack}\n`);
@@ -178,7 +230,50 @@ let ConsoleLogger = ConsoleLogger_1 = class ConsoleLogger {
         return result;
     }
     formatTimestampDiff(timestampDiff) {
-        return (0, cli_colors_util_1.yellow)(` +${timestampDiff}ms`);
+        const formattedDiff = ` +${timestampDiff}ms`;
+        return this.options.colors ? (0, cli_colors_util_1.yellow)(formattedDiff) : formattedDiff;
+    }
+    getInspectOptions() {
+        let breakLength = this.options.breakLength;
+        if (typeof breakLength === 'undefined') {
+            breakLength = this.options.colors
+                ? this.options.compact
+                    ? Infinity
+                    : undefined
+                : this.options.compact === false
+                    ? undefined
+                    : Infinity; // default breakLength to Infinity if inline is not set and colors is false
+        }
+        const inspectOptions = {
+            depth: this.options.depth ?? DEFAULT_DEPTH,
+            sorted: this.options.sorted,
+            showHidden: this.options.showHidden,
+            compact: this.options.compact ?? (this.options.json ? true : false),
+            colors: this.options.colors,
+            breakLength,
+        };
+        if (this.options.maxArrayLength) {
+            inspectOptions.maxArrayLength = this.options.maxArrayLength;
+        }
+        if (this.options.maxStringLength) {
+            inspectOptions.maxStringLength = this.options.maxStringLength;
+        }
+        return inspectOptions;
+    }
+    stringifyReplacer(key, value) {
+        // Mimic util.inspect behavior for JSON logger with compact on and colors off
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value === 'symbol') {
+            return value.toString();
+        }
+        if (value instanceof Map ||
+            value instanceof Set ||
+            value instanceof Error) {
+            return `${(0, util_1.inspect)(value, this.inspectOptions)}`;
+        }
+        return value;
     }
     getContextAndMessagesToPrint(args) {
         if (args?.length <= 1) {
@@ -251,5 +346,5 @@ exports.ConsoleLogger = ConsoleLogger = ConsoleLogger_1 = tslib_1.__decorate([
     (0, core_1.Injectable)(),
     tslib_1.__param(0, (0, core_1.Optional)()),
     tslib_1.__param(1, (0, core_1.Optional)()),
-    tslib_1.__metadata("design:paramtypes", [String, Object])
+    tslib_1.__metadata("design:paramtypes", [Object, Object])
 ], ConsoleLogger);

package/services/logger.service.d.ts

@@ -50,7 +50,7 @@ interface LogBufferRecord {
  * @publicApi
  */
 export declare class Logger implements LoggerService {
-    protected context?: string;
+    protected context?: string | undefined;
     protected options: {
         timestamp?: boolean;
     };

package/services/logger.service.js

@@ -118,12 +118,12 @@ let Logger = Logger_1 = class Logger {
     static overrideLogger(logger) {
         if (Array.isArray(logger)) {
             Logger_1.logLevels = logger;
-            return this.staticInstanceRef?.setLogLevels(logger);
+            return this.staticInstanceRef?.setLogLevels?.(logger);
         }
         if ((0, shared_utils_1.isObject)(logger)) {
             if (logger instanceof Logger_1 && logger.constructor !== Logger_1) {
                 const errorMessage = `Using the "extends Logger" instruction is not allowed in Nest v9. Please, use "extends ConsoleLogger" instead.`;
-                this.staticInstanceRef.error(errorMessage);
+                this.staticInstanceRef?.error(errorMessage);
                 throw new Error(errorMessage);
             }
             this.staticInstanceRef = logger;

package/utils/merge-with-values.util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MergeWithValues = void 0;
+/* eslint-disable @typescript-eslint/no-empty-object-type */
 const MergeWithValues = (data) => {
     return (Metatype) => {
         const Type = class extends Metatype {

package/utils/shared.utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSymbol = exports.isEmpty = exports.isNil = exports.isConstructor = exports.isNumber = exports.isString = exports.isFunction = exports.stripEndSlash = exports.normalizePath = exports.addLeadingSlash = exports.isPlainObject = exports.isObject = exports.isUndefined = void 0;
-/* eslint-disable @typescript-eslint/no-use-before-define */
 const isUndefined = (obj) => typeof obj === 'undefined';
 exports.isUndefined = isUndefined;
 const isObject = (fn) => !(0, exports.isNil)(fn) && typeof fn === 'object';