@theshelf/logging 0.1.0 → 0.2.0

package/README.md

@@ -9,32 +9,53 @@ The logging package provides a universal interaction layer with an actual loggin
 npm install @theshelf/logging
 ```
 
-## Implementations
+## Drivers
 
-Currently, there are two implementations:
+Currently, there are three drivers available:
 
-* **Void** - dummy implementation that doesn't log anything (suited for testing).
-* **Console** - implementation based on the Node.js console.
+* **Void** - dummy driver that doesn't log anything (suited for testing).
+* **Memory** - in memory logging (suited for testing).
+* **Console** - driver based on the Node.js console.
 
-## Configuration
+## How to use
+
+The basic set up looks like this.
+
+```ts
+import Logger, { VoidDriver | MemoryDriver | ConsoleDriver as SelectedDriver } from '@theshelf/logging';
 
-The used implementation needs to be configured in the `.env` file with the debug enabled setting.
+const driver = new SelectedDriver(/* configuration */);
+const logger = new Logger(driver);
 
-```env
-LOGGING_IMPLEMENTATION="console" # (void | console)
-LOGGING_DEBUG_ENABLED=true
+// Perform operations with the logger instance
 ```
 
-## How to use
+### Configuration
 
-An instance of the configured logger implementation can be imported for performing logging operations.
+#### Logger
+
+The logger has a configurable log level.
 
 ```ts
-import logger from '@theshelf/logging';
+import { LogLevels } from '@theshelf/logging';
 
-// Perform operations with the logger instance
+logger.logLevel = LogLevels.DEBUG; // default level
 ```
 
+Other levels are: `INFO` | `WARN` | `ERROR` | `FATAL`.
+
+#### Void driver
+
+No configuration options.
+
+#### Memory driver
+
+No configuration options.
+
+#### Console driver
+
+No configuration options.
+
 ### Operations
 
 ```ts

package/dist/Logger.d.ts

@@ -1,9 +1,13 @@
-import type { LogProcessor } from './definitions/interfaces.js';
-export default class Logger implements LogProcessor {
+import type { LogLevel } from './definitions/constants.js';
+import type { Driver } from './definitions/interfaces.js';
+export default class Logger implements Driver {
     #private;
-    constructor(processor: LogProcessor, debugEnabled?: boolean);
+    constructor(driver: Driver);
+    set logLevel(level: LogLevel);
+    get logLevel(): LogLevel;
+    logDebug(...message: unknown[]): Promise<void>;
     logInfo(...message: unknown[]): Promise<void>;
     logWarn(...message: unknown[]): Promise<void>;
     logError(...message: unknown[]): Promise<void>;
-    logDebug(...message: unknown[]): Promise<void>;
+    logFatal(...message: unknown[]): Promise<void>;
 }

package/dist/Logger.js

@@ -1,28 +1,47 @@
+import { LogLevels } from './definitions/constants.js';
 export default class Logger {
-    #processor;
-    #debugEnabled;
-    constructor(processor, debugEnabled = false) {
-        this.#processor = processor;
-        this.#debugEnabled = debugEnabled;
+    #driver;
+    #logLevel = LogLevels.DEBUG;
+    constructor(driver) {
+        this.#driver = driver;
+    }
+    set logLevel(level) {
+        this.#logLevel = level;
+    }
+    get logLevel() {
+        return this.#logLevel;
+    }
+    logDebug(...message) {
+        if (this.#logLevel > LogLevels.DEBUG) {
+            return Promise.resolve();
+        }
+        const messageString = this.#createMessage(message);
+        return this.#driver.logDebug(messageString);
     }
     logInfo(...message) {
+        if (this.#logLevel > LogLevels.INFO) {
+            return Promise.resolve();
+        }
         const messageString = this.#createMessage(message);
-        return this.#processor.logInfo(messageString);
+        return this.#driver.logInfo(messageString);
     }
     logWarn(...message) {
+        if (this.#logLevel > LogLevels.WARN) {
+            return Promise.resolve();
+        }
         const messageString = this.#createMessage(message);
-        return this.#processor.logWarn(messageString);
+        return this.#driver.logWarn(messageString);
     }
     logError(...message) {
-        const messageString = this.#createMessage(message);
-        return this.#processor.logError(messageString);
-    }
-    logDebug(...message) {
-        if (this.#debugEnabled === false) {
+        if (this.#logLevel > LogLevels.ERROR) {
             return Promise.resolve();
         }
         const messageString = this.#createMessage(message);
-        return this.#processor.logDebug(messageString);
+        return this.#driver.logError(messageString);
+    }
+    logFatal(...message) {
+        const messageString = this.#createMessage(message);
+        return this.#driver.logFatal(messageString);
     }
     #createMessage(message) {
         return message.map(value => this.#interpretValue(value)).join(' ');

package/dist/definitions/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const LogLevels: {
+    readonly DEBUG: 0;
+    readonly INFO: 1;
+    readonly WARN: 2;
+    readonly ERROR: 3;
+    readonly FATAL: 4;
+};
+export type LogLevel = typeof LogLevels[keyof typeof LogLevels];

package/dist/definitions/constants.js

@@ -0,0 +1,7 @@
+export const LogLevels = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+    FATAL: 4
+};

package/dist/definitions/interfaces.d.ts

@@ -1,6 +1,7 @@
-export interface LogProcessor {
+export interface Driver {
+    logDebug(message: string): Promise<void>;
     logInfo(message: string): Promise<void>;
     logWarn(message: string): Promise<void>;
     logError(message: string): Promise<void>;
-    logDebug(message: string): Promise<void>;
+    logFatal(message: string): Promise<void>;
 }

package/dist/{implementations/console → drivers}/Console.d.ts

@@ -1,7 +1,8 @@
-import type { LogProcessor } from '../../definitions/interfaces.js';
-export default class Console implements LogProcessor {
+import type { Driver } from '../definitions/interfaces.js';
+export default class Console implements Driver {
+    logDebug(message: string): Promise<void>;
     logInfo(message: string): Promise<void>;
     logWarn(message: string): Promise<void>;
     logError(message: string): Promise<void>;
-    logDebug(message: string): Promise<void>;
+    logFatal(message: string): Promise<void>;
 }

package/dist/{implementations/console → drivers}/Console.js

@@ -1,4 +1,8 @@
+/* eslint no-console: "off" */
 export default class Console {
+    async logDebug(message) {
+        return console.debug(message);
+    }
     async logInfo(message) {
         return console.info(message);
     }
@@ -8,7 +12,7 @@ export default class Console {
     async logError(message) {
         return console.error(message);
     }
-    async logDebug(message) {
-        return console.debug(message);
+    async logFatal(message) {
+        return console.error(message);
     }
 }

package/dist/drivers/Memory.d.ts

@@ -0,0 +1,17 @@
+import type { LogLevel } from '../definitions/constants.js';
+import type { Driver } from '../definitions/interfaces.js';
+type Log = {
+    level: LogLevel;
+    message: string;
+};
+export default class Memory implements Driver {
+    #private;
+    get logs(): Log[];
+    logDebug(message: string): Promise<void>;
+    logInfo(message: string): Promise<void>;
+    logWarn(message: string): Promise<void>;
+    logError(message: string): Promise<void>;
+    logFatal(message: string): Promise<void>;
+    clear(): void;
+}
+export {};

package/dist/drivers/Memory.js

@@ -0,0 +1,23 @@
+import { LogLevels } from '../definitions/constants.js';
+export default class Memory {
+    #logs = [];
+    get logs() { return this.#logs; }
+    async logDebug(message) {
+        this.#logs.push({ level: LogLevels.DEBUG, message });
+    }
+    async logInfo(message) {
+        this.#logs.push({ level: LogLevels.INFO, message });
+    }
+    async logWarn(message) {
+        this.#logs.push({ level: LogLevels.WARN, message });
+    }
+    async logError(message) {
+        this.#logs.push({ level: LogLevels.ERROR, message });
+    }
+    async logFatal(message) {
+        this.#logs.push({ level: LogLevels.FATAL, message });
+    }
+    clear() {
+        this.#logs.splice(0);
+    }
+}

package/dist/{implementations/void → drivers}/Void.d.ts

@@ -1,7 +1,8 @@
-import type { LogProcessor } from '../../definitions/interfaces.js';
-export default class Void implements LogProcessor {
+import type { Driver } from '../definitions/interfaces.js';
+export default class Void implements Driver {
+    logDebug(message: string): Promise<void>;
     logInfo(message: string): Promise<void>;
     logWarn(message: string): Promise<void>;
     logError(message: string): Promise<void>;
-    logDebug(message: string): Promise<void>;
+    logFatal(message: string): Promise<void>;
 }

package/dist/{implementations/void → drivers}/Void.js

@@ -1,18 +1,18 @@
+/* eslint @typescript-eslint/no-unused-vars: "off" */
 export default class Void {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    logDebug(message) {
+        return Promise.resolve();
+    }
     logInfo(message) {
         return Promise.resolve();
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     logWarn(message) {
         return Promise.resolve();
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     logError(message) {
         return Promise.resolve();
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    logDebug(message) {
+    logFatal(message) {
         return Promise.resolve();
     }
 }

package/dist/errors/LogError.d.ts

@@ -1,2 +1,3 @@
 export default class LogError extends Error {
+    constructor(message?: string);
 }

package/dist/errors/LogError.js

@@ -1,2 +1,9 @@
 export default class LogError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
 }

package/dist/index.d.ts

@@ -1,3 +1,8 @@
-import Logger from './Logger.js';
-declare const logger: Logger;
-export default logger;
+export * from './definitions/constants.js';
+export type * from './definitions/constants.js';
+export type * from './definitions/interfaces.js';
+export { default as LogError } from './errors/LogError.js';
+export { default as ConsoleDriver } from './drivers/Console.js';
+export { default as MemoryDriver } from './drivers/Memory.js';
+export { default as VoidDriver } from './drivers/Void.js';
+export { default } from './Logger.js';

package/dist/index.js

@@ -1,5 +1,6 @@
-import Logger from './Logger.js';
-import implementation from './implementation.js';
-const debugEnabled = process.env.LOGGING_DEBUG_ENABLED === 'true';
-const logger = new Logger(implementation, debugEnabled);
-export default logger;
+export * from './definitions/constants.js';
+export { default as LogError } from './errors/LogError.js';
+export { default as ConsoleDriver } from './drivers/Console.js';
+export { default as MemoryDriver } from './drivers/Memory.js';
+export { default as VoidDriver } from './drivers/Void.js';
+export { default } from './Logger.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@theshelf/logging",
   "private": false,
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "repository": {
     "url": "https://github.com/MaskingTechnology/theshelf"
@@ -9,6 +9,8 @@
   "scripts": {
     "build": "tsc",
     "clean": "rimraf dist",
+    "test": "vitest run",
+    "test-coverage": "vitest run --coverage",
     "lint": "eslint",
     "review": "npm run build && npm run lint",
     "prepublishOnly": "npm run clean && npm run build"

package/dist/errors/UnknownImplementation.d.ts

@@ -1,4 +0,0 @@
-import LogError from './LogError.js';
-export default class UnknownImplementation extends LogError {
-    constructor(name: string);
-}

package/dist/errors/UnknownImplementation.js

@@ -1,6 +0,0 @@
-import LogError from './LogError.js';
-export default class UnknownImplementation extends LogError {
-    constructor(name) {
-        super(`Unknown logger implementation: ${name}`);
-    }
-}

package/dist/implementation.d.ts

@@ -1,3 +0,0 @@
-import type { LogProcessor } from './definitions/interfaces.js';
-declare const _default: LogProcessor;
-export default _default;

package/dist/implementation.js

@@ -1,14 +0,0 @@
-import UnknownImplementation from './errors/UnknownImplementation.js';
-import createConsole from './implementations/console/create.js';
-import createVoid from './implementations/void/create.js';
-const implementations = new Map([
-    ['console', createConsole],
-    ['void', createVoid]
-]);
-const DEFAULT_LOGGING_IMPLEMENTATION = 'void';
-const implementationName = process.env.LOGGING_IMPLEMENTATION ?? DEFAULT_LOGGING_IMPLEMENTATION;
-const creator = implementations.get(implementationName.toLowerCase());
-if (creator === undefined) {
-    throw new UnknownImplementation(implementationName);
-}
-export default creator();

package/dist/implementations/console/create.d.ts

@@ -1,2 +0,0 @@
-import Console from './Console.js';
-export default function create(): Console;

package/dist/implementations/console/create.js

@@ -1,4 +0,0 @@
-import Console from './Console.js';
-export default function create() {
-    return new Console();
-}

package/dist/implementations/void/create.d.ts

@@ -1,2 +0,0 @@
-import Void from './Void.js';
-export default function create(): Void;

package/dist/implementations/void/create.js

@@ -1,4 +0,0 @@
-import Void from './Void.js';
-export default function create() {
-    return new Void();
-}