@theshelf/logging 0.0.1

package/README.md

@@ -0,0 +1,72 @@
+
+# Logging | The Shelf
+
+The logging package provides a universal interaction layer with an actual logging solution.
+
+## Installation
+
+```bash
+npm install @theshelf/logging
+```
+
+## Implementations
+
+Currently, there are two implementations:
+
+* **Void** - dummy implementation that doesn't log anything (suited for testing).
+* **Console** - implementation based on the Node.js console.
+
+## Configuration
+
+The used implementation needs to be configured in the `.env` file with the debug enabled setting.
+
+```env
+LOGGING_IMPLEMENTATION="console" # (void | console)
+LOGGING_DEBUG_ENABLED=true
+```
+
+## How to use
+
+An instance of the configured logger implementation can be imported for performing logging operations.
+
+```ts
+import logger from '@theshelf/logging';
+
+// Perform operations with the logger instance
+```
+
+### Operations
+
+```ts
+import logger from '@theshelf/logging';
+
+// Log info
+await logger.logInfo(message);
+
+// Log warning
+await logger.logWarn(message);
+
+// Log error
+await logger.logError(message);
+
+// Log debug information
+await logger.logDebug(message);
+
+// Log multiple messages (works for all levels)
+await logger.logInfo(message1, message2, ...);
+
+// Logging multiple types of values (works for all levels)
+await logger.logInfo('string', new Error('Oops...'), 42, [ 'a', 3.14 ], { name: 'John Doe', age: null });
+```
+
+### Value interpretation
+
+Currently, the logger has support for the following types of values:
+
+* All primitive types
+* Null / undefined
+* Errors (its stack if available or else its message)
+* Arrays (all values will be interpreted and concatenated with a space between them)
+* Objects (will be stringyfied)
+
+In case multiple messages are given, they will be concatenated with a space between them.

package/dist/Logger.d.ts

@@ -0,0 +1,9 @@
+import type { LogProcessor } from './definitions/interfaces';
+export default class Logger implements LogProcessor {
+    #private;
+    constructor(processor: LogProcessor, debugEnabled?: boolean);
+    logInfo(...message: unknown[]): Promise<void>;
+    logWarn(...message: unknown[]): Promise<void>;
+    logError(...message: unknown[]): Promise<void>;
+    logDebug(...message: unknown[]): Promise<void>;
+}

package/dist/Logger.js

@@ -0,0 +1,51 @@
+export default class Logger {
+    #processor;
+    #debugEnabled;
+    constructor(processor, debugEnabled = false) {
+        this.#processor = processor;
+        this.#debugEnabled = debugEnabled;
+    }
+    logInfo(...message) {
+        const messageString = this.#createMessage(message);
+        return this.#processor.logInfo(messageString);
+    }
+    logWarn(...message) {
+        const messageString = this.#createMessage(message);
+        return this.#processor.logWarn(messageString);
+    }
+    logError(...message) {
+        const messageString = this.#createMessage(message);
+        return this.#processor.logError(messageString);
+    }
+    logDebug(...message) {
+        if (this.#debugEnabled === false) {
+            return Promise.resolve();
+        }
+        const messageString = this.#createMessage(message);
+        return this.#processor.logDebug(messageString);
+    }
+    #createMessage(message) {
+        return message.map(value => this.#interpretValue(value)).join(' ');
+    }
+    #interpretValue(value) {
+        switch (typeof value) {
+            case 'string': return value;
+            case 'object': return this.#interpretObject(value);
+            case 'undefined': return 'undefined';
+            case 'function': return 'function';
+            default: return String(value);
+        }
+    }
+    #interpretObject(object) {
+        if (object === null) {
+            return 'null';
+        }
+        if (Array.isArray(object)) {
+            return object.map(value => this.#interpretValue(value)).join(' ');
+        }
+        if (object instanceof Error) {
+            return object.stack ?? object.message;
+        }
+        return JSON.stringify(object);
+    }
+}

package/dist/definitions/interfaces.d.ts

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

package/dist/definitions/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/errors/LogError.d.ts

@@ -0,0 +1,2 @@
+export default class LogError extends Error {
+}

package/dist/errors/LogError.js

@@ -0,0 +1,2 @@
+export default class LogError extends Error {
+}

package/dist/errors/UnknownImplementation.d.ts

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

package/dist/errors/UnknownImplementation.js

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

package/dist/implementation.d.ts

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

package/dist/implementation.js

@@ -0,0 +1,14 @@
+import UnknownImplementation from './errors/UnknownImplementation';
+import createConsole from './implementations/console/create';
+import createVoid from './implementations/void/create';
+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/Console.d.ts

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

package/dist/implementations/console/Console.js

@@ -0,0 +1,14 @@
+export default class Console {
+    async logInfo(message) {
+        return console.info(message);
+    }
+    async logWarn(message) {
+        return console.warn(message);
+    }
+    async logError(message) {
+        return console.error(message);
+    }
+    async logDebug(message) {
+        return console.debug(message);
+    }
+}

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

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

package/dist/implementations/console/create.js

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

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

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

package/dist/implementations/void/Void.js

@@ -0,0 +1,18 @@
+export default class Void {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    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) {
+        return Promise.resolve();
+    }
+}

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

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

package/dist/implementations/void/create.js

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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import Logger from './Logger';
+declare const logger: Logger;
+export default logger;

package/dist/index.js

@@ -0,0 +1,5 @@
+import Logger from './Logger';
+import implementation from './implementation';
+const debugEnabled = process.env.LOGGING_DEBUG_ENABLED === 'true';
+const logger = new Logger(implementation, debugEnabled);
+export default logger;

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@theshelf/logging",
+  "private": false,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "lint": "eslint",
+    "review": "npm run build && npm run lint",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "types": "dist/index.d.ts",
+  "exports": "./dist/index.js"
+}