Merge pull request #12 from yao206cc/main

feat(logger): support function messages based on context

Author: tianyingchun

packages/logger/src/core/create-logger.ts

@@ -1,11 +1,11 @@
-import type { DeepPartial, LoggerMessage } from '../types/index.js';
+import type { DeepPartial, RawLoggerMessage } from '../types/index.js';
 import type { LoggerContext } from '../types/type-logger.js';
 import type { Logger as BaseLogger } from '../types/type-logger.js';
 import { Logger } from './logger.js';
 
 export const createLogger = <
   Context extends object = object,
-  Message extends LoggerMessage = LoggerMessage,
+  Message extends RawLoggerMessage<Context> = RawLoggerMessage<Context>,
 >(
   options?: LoggerContext<Context> & {
     setup?: () =>
@@ -15,4 +15,4 @@ export const createLogger = <
   }
 ): BaseLogger<LoggerContext<Context>, Message> => {
   return new Logger<Context, Message>(options);
-};
+};

packages/logger/src/core/logger.ts

@@ -15,7 +15,7 @@ import type {
   LoggerContext,
 } from '../types/type-logger.js';
 import type { LoggerPlugin } from '../types/type-logger-plugin.js';
-import type { LoggerMessage } from '../types/type-message.js';
+import type { LoggerMessage, RawLoggerMessage } from '../types/type-message.js';
 import type { DeepPartial } from '../types/type-partial-deep.js';
 
 /**
@@ -26,18 +26,18 @@ import type { DeepPartial } from '../types/type-partial-deep.js';
  * is created with the build() method.
  *
  * @template Context The logger context type, including log level, name, etc.
- * @template Message The log message type
+ * @template RawMessage The log message type
  */
 export class Logger<
   Context extends object = object,
-  Message extends LoggerMessage = LoggerMessage,
-> implements BaseLogger<LoggerContext<Context>, Message>
-{
+  Message extends RawLoggerMessage<Context> = RawLoggerMessage<Context>,
+> implements BaseLogger<LoggerContext<Context>, Message> {
   private ctx: LoggerContext<Context>;
   private errorHandling: ((error: Error) => void) | undefined;
   private pipeline: Pipeline<{
     ctx: LoggerContext<Context>;
-    message: Message;
+    rawMessage: Message;
+    message?: LoggerMessage;
     level: LogLevel;
   }> = new Pipeline();
 
@@ -59,6 +59,7 @@ export class Logger<
     });
     this.errorHandling = errorHandling;
     this.useSetupCtx(setup);
+    this.useMessageParser();
   }
 
   private useSetupCtx = async (
@@ -73,17 +74,32 @@ export class Logger<
     });
   };
 
+  /**
+   * Registers message parser pipeline
+   */
+  private useMessageParser() {
+    this.pipeline.use(async (ctx, next) => {
+      const rawMessage = ctx.rawMessage as Message;
+      ctx.message = this.parseMessage(rawMessage, ctx.ctx);
+      await next();
+    });
+  }
+
   /**
    * Registers a Logger plugin into the logging pipeline.
    * @param plugins LoggerPlugin instances to be used in the pipeline
    * @returns this, for chaining
    */
   public use(
-    ...plugins: LoggerPlugin<LoggerContext<Context>, Message>[]
+    ...plugins: LoggerPlugin<LoggerContext<Context>, LoggerMessage>[]
   ): Pick<BaseLogger<LoggerContext<Context>, Message>, 'use' | 'build'> {
     for (const plugin of plugins) {
       this.pipeline.use(async (ctx, next) => {
         const { level, message, ctx: pluginCtx } = ctx;
+        if (!message) {
+          await next();
+          return;
+        }
         const options = {
           ctx: { ...simpleDeepClone(pluginCtx), pluginName: plugin.pluginName },
           level: level,
@@ -126,7 +142,7 @@ export class Logger<
   public debug(message: Message) {
     this.pipeline.execute({
       ctx: this.ctx,
-      message: message,
+      rawMessage: message,
       level: LogLevel.Debug,
     });
   }
@@ -138,7 +154,7 @@ export class Logger<
   public info(message: Message) {
     this.pipeline.execute({
       ctx: this.ctx,
-      message: message,
+      rawMessage: message,
       level: LogLevel.Info,
     });
   }
@@ -150,7 +166,7 @@ export class Logger<
   public warn(message: Message) {
     this.pipeline.execute({
       ctx: this.ctx,
-      message: message,
+      rawMessage: message,
       level: LogLevel.Warn,
     });
   }
@@ -162,7 +178,7 @@ export class Logger<
   public error(message: Message) {
     this.pipeline.execute({
       ctx: this.ctx,
-      message: message,
+      rawMessage: message,
       level: LogLevel.Error,
     });
   }
@@ -174,8 +190,31 @@ export class Logger<
   public verbose(message: Message) {
     this.pipeline.execute({
       ctx: this.ctx,
-      message: message,
+      rawMessage: message,
       level: LogLevel.Verbose,
     });
   }
+
+  /**
+   * The log message, which can be a function or a static message.
+   * If it's a function, it will be executed with the current context.
+   * @param message The log message to be parsed.
+   * @returns message The parsed log message.
+   */
+  private parseMessage(
+    message: Message,
+    ctx: LoggerContext<Context>
+  ): LoggerMessage {
+    try {
+      if (typeof message === 'function') {
+        return message(ctx);
+      }
+      return message;
+    } catch (err: any) {
+      return {
+        message: 'Failed to execute message function',
+        stack: err?.stack,
+      };
+    }
+  }
 }

packages/logger/src/types/type-logger.ts

@@ -1,6 +1,6 @@
 import type { LogLevel } from '../constant/log-level.js';
 import type { LoggerPlugin } from './type-logger-plugin.js';
-import type { LoggerMessage } from './type-message.js';
+import type { LoggerMessage, RawLoggerMessage } from './type-message.js';
 
 export type LoggerContext<Context extends object = object> = Context & {
   name: string;
@@ -14,10 +14,10 @@ export type LoggerPluginList<
 
 export interface Logger<
   Context extends LoggerContext = LoggerContext,
-  Message extends LoggerMessage = LoggerMessage,
+  Message extends RawLoggerMessage<Context> = RawLoggerMessage<Context>,
 > {
   use: (
-    ...plugins: LoggerPlugin<Context, Message>[]
+    ...plugins: LoggerPlugin<Context, LoggerMessage>[]
   ) => Pick<Logger<Context, Message>, 'use' | 'build'>;
   build: () => Pick<
     Logger<Context, Message>,
@@ -28,4 +28,4 @@ export interface Logger<
   warn: (message: Message) => void;
   error: (message: Message) => void;
   verbose: (message: Message) => void;
-}
+}

packages/logger/src/types/type-message.ts

@@ -1,8 +1,12 @@
+import type { LoggerContext } from "./type-logger.js";
+
 export type LoggerMessageObject = {
   message: string | object;
   prefix?: string;
   name?: string;
   stack?: string | undefined | null;
 };
 
-export type LoggerMessage = string | LoggerMessageObject;
+export type LoggerMessage = string | LoggerMessageObject
+
+export type RawLoggerMessage<Context extends object = object> = LoggerMessage | ((ctx: LoggerContext<Context>) => LoggerMessage)

packages/logger/tests/logger.spec.ts

@@ -12,11 +12,11 @@ describe('Logger Basic Functionality', () => {
   let mockConsoleInfo: ReturnType<typeof vi.spyOn>;
 
   beforeEach(() => {
-    mockConsoleLog = vi.spyOn(console, 'log').mockImplementation(() => {});
-    mockConsoleWarn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    mockConsoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
-    mockConsoleDebug = vi.spyOn(console, 'debug').mockImplementation(() => {});
-    mockConsoleInfo = vi.spyOn(console, 'info').mockImplementation(() => {});
+    mockConsoleLog = vi.spyOn(console, 'log').mockImplementation(() => { });
+    mockConsoleWarn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+    mockConsoleError = vi.spyOn(console, 'error').mockImplementation(() => { });
+    mockConsoleDebug = vi.spyOn(console, 'debug').mockImplementation(() => { });
+    mockConsoleInfo = vi.spyOn(console, 'info').mockImplementation(() => { });
   });
 
   afterEach(() => {
@@ -136,6 +136,11 @@ describe('Logger Basic Functionality', () => {
       thresholdLevel: LogLevel.Verbose,
       name: 'sampleLogger',
       env: 'node',
+      setup() {
+        return {
+          env: 'browser',
+        };
+      },
     })
       .use(consolePlugin)
       .build();
@@ -170,19 +175,152 @@ describe('Logger Basic Functionality', () => {
 
     expect(executeMock).toHaveBeenCalledTimes(5);
     expect(executeMock.mock.calls[0][0]).toEqual(
-      '[error] ctx: sampleLogger node 0 error error message'
+      '[error] ctx: sampleLogger browser 0 error error message'
     );
     expect(executeMock.mock.calls[1][0]).toEqual(
-      '[warn] ctx: sampleLogger node 1 warn warn message'
+      '[warn] ctx: sampleLogger browser 1 warn warn message'
     );
     expect(executeMock.mock.calls[2][0]).toEqual(
-      '[info] ctx: sampleLogger node 2 info info message'
+      '[info] ctx: sampleLogger browser 2 info info message'
     );
     expect(executeMock.mock.calls[3][0]).toEqual(
-      '[debug] ctx: sampleLogger node 3 debug debug message'
+      '[debug] ctx: sampleLogger browser 3 debug debug message'
     );
     expect(executeMock.mock.calls[4][0]).toEqual(
-      '[verbose] ctx: sampleLogger node 4 verbose verbose message'
+      '[verbose] ctx: sampleLogger browser 4 verbose verbose message'
+    );
+  });
+
+  // Test case for function messages
+  it('should handle function messages correctly', async () => {
+    const executeMock = vi.fn();
+
+    const consolePlugin = definePlugin({
+      pluginName: 'consolePlugin',
+      execute({ message }) {
+        if (typeof message === 'string') {
+          executeMock(message);
+        } else if (typeof message === 'object') {
+          executeMock(`${message.prefix} ${message.message}`);
+        }
+      },
+    });
+
+    type AppContext = {
+      userId: string;
+      environment: string;
+    };
+
+    const logger = createLogger<AppContext>({
+      thresholdLevel: LogLevel.Verbose,
+      name: 'functionLogger',
+      environment: 'production',
+      userId: '',
+      setup: async () => Promise.resolve({ userId: 'user-123' }),
+    })
+      .use(consolePlugin)
+      .build();
+    // 1. Test string-returning function message
+    logger.info(
+      (ctx) => `User ${ctx.userId} logged in from ${ctx.environment}`
+    );
+
+    // 2. Test object-returning function message
+    logger.warn((ctx) => ({
+      message: `Warning for ${ctx.userId}`,
+      prefix: '[WARNING]',
+    }));
+
+    // 3. Test dynamic context modification
+    logger.debug((ctx) => {
+      // Test that context is immutable - create a new object instead
+      const localCtx = { ...ctx, userId: 'user-456' };
+      return `Updated user: ${localCtx.userId}`;
+    });
+
+    // 4. Test using modified context
+    logger.info((ctx) => `Now user is ${ctx.userId}`);
+
+    // 5. Test error handling
+    logger.error(() => {
+      throw new Error('Test error in message function');
+    });
+
+    await sleep(100);
+
+    // Verify results
+    expect(executeMock).toHaveBeenCalledTimes(5);
+    expect(executeMock.mock.calls[0][0]).toBe(
+      'User user-123 logged in from production'
+    );
+    expect(executeMock.mock.calls[1][0]).toBe('[WARNING] Warning for user-123');
+    expect(executeMock.mock.calls[2][0]).toBe('Updated user: user-456');
+    expect(executeMock.mock.calls[3][0]).toBe('Now user is user-123');
+
+    // Verify error message handling
+    expect(executeMock.mock.calls[4][0]).toContain(
+      'Message function execution failed'
+    );
+  });
+
+  // New test case: Handling function messages in pipeline plugins
+  it('should handle function messages in pipeline plugins', async () => {
+    type AppContext = {
+      env: string;
+      version: string;
+    };
+
+    const executeMock = vi.fn();
+
+    const consolePlugin = definePlugin<AppContext>({
+      pluginName: 'consolePlugin',
+      execute({ ctx, level, message, pipe }) {
+        pipe(
+          (ctx: AppContext) => ctx,
+          // Resolve function message
+          () => message,
+          (msg) => {
+            if (typeof msg === 'string') {
+              executeMock(`[${LogLevel[level]}] ${msg}`);
+            } else {
+              executeMock(`[${LogLevel[level]}] ${msg.message}`);
+            }
+          }
+        )(ctx);
+      },
+    });
+
+    const logger = createLogger<AppContext>({
+      thresholdLevel: LogLevel.Verbose,
+      name: 'pipelineLogger',
+      env: 'production',
+      version: '1.0.0',
+    })
+      .use(consolePlugin)
+      .build();
+
+    // Function message - string
+    logger.info((ctx) => `App v${ctx.version} running in ${ctx.env}`);
+
+    // Function message - object
+    logger.warn((ctx) => ({
+      message: `Deprecated feature in ${ctx.env} v${ctx.version}`,
+    }));
+
+    // Regular string message
+    logger.error('Critical error occurred');
+
+    await sleep(100);
+
+    expect(executeMock).toHaveBeenCalledTimes(3);
+    expect(executeMock.mock.calls[0][0]).toBe(
+      '[Info] App v1.0.0 running in production'
+    );
+    expect(executeMock.mock.calls[1][0]).toBe(
+      '[Warn] Deprecated feature in production v1.0.0'
+    );
+    expect(executeMock.mock.calls[2][0]).toBe(
+      '[Error] Critical error occurred'
     );
   });
-});
+});