feat: introduce logger

bin/commands/interactive.mjs

@@ -13,6 +13,7 @@ import {
 } from '@clack/prompts';
 
 import commands from './index.mjs';
+import { Logger } from '../../src/logger/index.mjs';
 
 /**
  * Validates that a string is not empty.
@@ -165,7 +166,7 @@ export default async function interactive() {
 
   const finalCommand = cmdParts.join(' ');
 
-  console.log(`\nGenerated command:\n${finalCommand}\n`);
+  Logger.getInstance().info(`\nGenerated command:\n${finalCommand}\n`);
 
   // Step 5: Confirm and execute the generated command
   if (await confirm({ message: 'Run now?', initialValue: true })) {

bin/utils.mjs

@@ -1,4 +1,5 @@
 import createMarkdownLoader from '../src/loaders/markdown.mjs';
+import { Logger } from '../src/logger/index.mjs';
 import createMarkdownParser from '../src/parsers/markdown.mjs';
 
 /**
@@ -42,7 +43,7 @@ export const errorWrap =
     try {
       return await fn(...args);
     } catch (err) {
-      console.error(err);
+      Logger.getInstance().error(err);
       process.exit(1);
     }
   };

src/logger/__tests__/logger.test.mjs

@@ -0,0 +1,221 @@
+import { deepStrictEqual, strictEqual } from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { LogLevel } from '../constants.mjs';
+import { createLogger } from '../logger.mjs';
+
+/**
+ * @type {import('../types').Metadata}
+ */
+const metadata = {
+  file: {
+    path: 'test.md',
+    position: {
+      start: { line: 1 },
+      end: { line: 1 },
+    },
+  },
+};
+
+describe('createLogger', () => {
+  describe('DEBUG', () => {
+    it('should log DEBUG messages when logger level is set to DEBUG', t => {
+      t.mock.timers.enable({ apis: ['Date'] });
+
+      const transport = t.mock.fn();
+
+      const logger = createLogger(transport, LogLevel.debug);
+
+      logger.debug('Hello, World!', metadata);
+
+      strictEqual(transport.mock.callCount(), 1);
+
+      const call = transport.mock.calls[0];
+      deepStrictEqual(call.arguments, [
+        {
+          level: LogLevel.debug,
+          message: 'Hello, World!',
+          metadata,
+          module: undefined,
+          timestamp: 0,
+        },
+      ]);
+    });
+
+    it('should filter DEBUG messages when logger level is set to INFO or higher', t => {
+      [LogLevel.info, LogLevel.warn, LogLevel.error, LogLevel.fatal].forEach(
+        loggerLevel => {
+          const transport = t.mock.fn();
+
+          const logger = createLogger(transport, loggerLevel);
+
+          logger.debug('Hello, World!');
+
+          strictEqual(transport.mock.callCount(), 0);
+        }
+      );
+    });
+  });
+
+  describe('INFO', () => {
+    it('should log INFO messages when logger level is set to INFO or lower', t => {
+      t.mock.timers.enable({ apis: ['Date'] });
+      [LogLevel.info, LogLevel.debug].forEach(loggerLevel => {
+        const transport = t.mock.fn();
+
+        const logger = createLogger(transport, loggerLevel);
+
+        logger.info('Hello, World!', metadata);
+
+        strictEqual(transport.mock.callCount(), 1);
+
+        const call = transport.mock.calls[0];
+        deepStrictEqual(call.arguments, [
+          {
+            level: LogLevel.info,
+            message: 'Hello, World!',
+            metadata,
+            module: undefined,
+            timestamp: 0,
+          },
+        ]);
+      });
+    });
+
+    it('should filter INFO messages when logger level is set to WARN or higher', t => {
+      [LogLevel.warn, LogLevel.error, LogLevel.fatal].forEach(loggerLevel => {
+        const transport = t.mock.fn();
+
+        const logger = createLogger(transport, loggerLevel);
+
+        logger.info('Hello, World!');
+
+        strictEqual(transport.mock.callCount(), 0);
+      });
+    });
+  });
+
+  describe('WARN', () => {
+    it('should log WARN messages when logger level is set to WARN or lower', t => {
+      t.mock.timers.enable({ apis: ['Date'] });
+
+      [LogLevel.warn, LogLevel.info, LogLevel.debug].forEach(loggerLevel => {
+        const transport = t.mock.fn();
+
+        const logger = createLogger(transport, loggerLevel);
+
+        logger.warn('Hello, World!', metadata);
+
+        strictEqual(transport.mock.callCount(), 1);
+
+        const call = transport.mock.calls[0];
+        deepStrictEqual(call.arguments, [
+          {
+            level: LogLevel.warn,
+            message: 'Hello, World!',
+            metadata,
+            module: undefined,
+            timestamp: 0,
+          },
+        ]);
+      });
+    });
+
+    it('should filter WARN messages when logger level is set to ERROR or higher', t => {
+      [LogLevel.error, LogLevel.fatal].forEach(loggerLevel => {
+        const transport = t.mock.fn();
+
+        const logger = createLogger(transport, loggerLevel);
+
+        logger.warn('Hello, World!');
+
+        strictEqual(transport.mock.callCount(), 0);
+      });
+    });
+  });
+
+  describe('ERROR', () => {
+    it('should log ERROR messages when logger level is set to ERROR or lower', t => {
+      t.mock.timers.enable({ apis: ['Date'] });
+
+      [LogLevel.error, LogLevel.warn, LogLevel.info, LogLevel.debug].forEach(
+        loggerLevel => {
+          const transport = t.mock.fn();
+
+          const logger = createLogger(transport, loggerLevel);
+
+          logger.error('Hello, World!', metadata);
+
+          strictEqual(transport.mock.callCount(), 1);
+
+          const call = transport.mock.calls[0];
+          deepStrictEqual(call.arguments, [
+            {
+              level: LogLevel.error,
+              message: 'Hello, World!',
+              metadata,
+              module: undefined,
+              timestamp: 0,
+            },
+          ]);
+        }
+      );
+    });
+
+    it('should filter ERROR messages when logger level is set to FATAL', t => {
+      const transport = t.mock.fn();
+
+      const logger = createLogger(transport, LogLevel.fatal);
+
+      logger.warn('Hello, World!');
+
+      strictEqual(transport.mock.callCount(), 0);
+    });
+  });
+
+  it('should filter all messages when minimum level is set above FATAL', t => {
+    const transport = t.mock.fn();
+
+    // silent logs
+    const logger = createLogger(transport, 100);
+
+    Object.keys(LogLevel).forEach(level => {
+      logger[level]('Hello, World!');
+    });
+
+    strictEqual(transport.mock.callCount(), 0);
+  });
+
+  it('should log all messages if message is a string array', t => {
+    const transport = t.mock.fn();
+
+    const logger = createLogger(transport, LogLevel.info);
+
+    logger.info(['Hello, 1!', 'Hello, 2!', 'Hello, 3!']);
+
+    strictEqual(transport.mock.callCount(), 3);
+  });
+
+  it('should log error message', t => {
+    t.mock.timers.enable({ apis: ['Date'] });
+
+    const transport = t.mock.fn();
+
+    const logger = createLogger(transport, LogLevel.error);
+
+    logger.error(new Error('Hello, World!'));
+
+    strictEqual(transport.mock.callCount(), 1);
+
+    const call = transport.mock.calls[0];
+    deepStrictEqual(call.arguments, [
+      {
+        level: LogLevel.error,
+        message: 'Hello, World!',
+        metadata: {},
+        module: undefined,
+        timestamp: 0,
+      },
+    ]);
+  });
+});