@theshelf/logging 0.3.2 → 0.4.0

package/README.md

@@ -1,7 +1,7 @@
 
-# Logging | The Shelf
+# Logging core | The Shelf
 
-The logging package provides a universal interaction layer with an actual logging solution.
+This package contains the definition of the logging operations. It uses a interchangeable driver system for performing the actual operations. A console, in-memory and void driver is included.
 
 ## Installation
 
@@ -9,31 +9,20 @@ The logging package provides a universal interaction layer with an actual loggin
 npm install @theshelf/logging
 ```
 
-## Drivers
-
-Currently, there are three drivers available:
-
-* **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.
-* **Database** - driver that logs messages into a database.
-
 ## How to use
 
 The basic set up looks like this.
 
 ```ts
-import Logger, { VoidDriver | MemoryDriver | ConsoleDriver as SelectedDriver } from '@theshelf/logging';
+import Logger, { MemoryDriver } from '@theshelf/logging';
 
-const driver = new SelectedDriver(/* configuration */);
+const driver = new MemoryDriver();
 const logger = new Logger(driver);
 
 // Perform operations with the logger instance
 ```
 
-### Configuration
-
-#### Logger
+## Configuration
 
 The logger has a configurable log level.
 
@@ -43,59 +32,32 @@ import { LogLevels } from '@theshelf/logging';
 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.
-
-#### Database driver
-
-The database driver requires a [database](https://github.com/MaskingTechnology/theshelf/tree/main/packages/database) from @theshelf and a table name (record type) to log messages into.
-
-```ts
-import { database } from './your-database-instance';
-
-const recordType = 'logs';
-const driver = new DatabaseDriver(database, recordType);
-
-const logger = new Logger(driver);
-```
-
-### Operations
+## Operations
 
 ```ts
 // Log debug
-await logger.logDebug(message);
+await logger.debug(message);
 
 // Log info
-await logger.logInfo(message);
+await logger.info(message);
 
 // Log warning
-await logger.logWarn(message);
+await logger.warn(message);
 
 // Log error
-await logger.logError(message);
+await logger.error(message);
 
 // Log fatal
-await logger.logFatal(message);
+await logger.fatal(message);
 
 // Log multiple messages (works for all levels)
-await logger.logInfo(message1, message2, ...);
+await logger.info(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 });
+await logger.info('string', new Error('Oops...'), 42, [ 'a', 3.14 ], { name: 'John Doe', age: null });
 ```
 
-### Value interpretation
+## Value interpretation
 
 Currently, the logger has support for the following types of values:
 
@@ -103,6 +65,27 @@ Currently, the logger has support for the following types of values:
 * 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)
+* Objects (will be stringified)
 
 In case multiple messages are given, they will be concatenated with a space between them.
+
+## Drivers
+
+There are three drivers included in this package. Other drivers are available in separate packages.
+
+### Void
+
+Dummy driver that doesn't log anything (suited for testing). It doesn't have any configuration options or additional operations.
+
+### Memory
+
+In memory logging (suited for testing). It doesn't have any configuration options, but has an additional operation.
+
+```ts
+// Clear the memory
+driver.clear();
+```
+
+### Console
+
+Driver based on the Node.js console. It doesn't have any configuration options or additional operations.

package/dist/Logger.d.ts

@@ -1,13 +1,16 @@
 import type { LogLevel } from './definitions/constants.js';
 import type { Driver } from './definitions/interfaces.js';
-export default class Logger implements Driver {
+import type { Log } from './definitions/types.js';
+export default class Logger {
     #private;
-    constructor(driver: Driver);
+    constructor(driver: Driver, source?: string);
     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>;
-    logFatal(...message: unknown[]): Promise<void>;
+    for(source: string): Logger;
+    log(log: Log): Promise<void>;
+    debug(...message: unknown[]): Promise<void>;
+    info(...message: unknown[]): Promise<void>;
+    warn(...message: unknown[]): Promise<void>;
+    error(...message: unknown[]): Promise<void>;
+    fatal(...message: unknown[]): Promise<void>;
 }

package/dist/Logger.js

@@ -1,9 +1,11 @@
 import { LogLevels } from './definitions/constants.js';
 export default class Logger {
     #driver;
+    #source;
     #logLevel = LogLevels.DEBUG;
-    constructor(driver) {
+    constructor(driver, source = 'Unknown') {
         this.#driver = driver;
+        this.#source = source;
     }
     set logLevel(level) {
         this.#logLevel = level;
@@ -11,40 +13,55 @@ export default class Logger {
     get logLevel() {
         return this.#logLevel;
     }
-    logDebug(...message) {
+    for(source) {
+        const tracedSource = `${this.#source}.${source}`;
+        const logger = new Logger(this.#driver, tracedSource);
+        logger.logLevel = this.#logLevel;
+        return logger;
+    }
+    log(log) {
+        return this.#driver.log(log);
+    }
+    debug(...message) {
         if (this.#logLevel > LogLevels.DEBUG) {
             return Promise.resolve();
         }
-        const messageString = this.#createMessage(message);
-        return this.#driver.logDebug(messageString);
+        const log = this.#createLog(LogLevels.DEBUG, message);
+        return this.log(log);
     }
-    logInfo(...message) {
+    info(...message) {
         if (this.#logLevel > LogLevels.INFO) {
             return Promise.resolve();
         }
-        const messageString = this.#createMessage(message);
-        return this.#driver.logInfo(messageString);
+        const log = this.#createLog(LogLevels.INFO, message);
+        return this.log(log);
     }
-    logWarn(...message) {
+    warn(...message) {
         if (this.#logLevel > LogLevels.WARN) {
             return Promise.resolve();
         }
-        const messageString = this.#createMessage(message);
-        return this.#driver.logWarn(messageString);
+        const log = this.#createLog(LogLevels.WARN, message);
+        return this.log(log);
     }
-    logError(...message) {
+    error(...message) {
         if (this.#logLevel > LogLevels.ERROR) {
             return Promise.resolve();
         }
-        const messageString = this.#createMessage(message);
-        return this.#driver.logError(messageString);
+        const log = this.#createLog(LogLevels.ERROR, message);
+        return this.log(log);
+    }
+    fatal(...message) {
+        const log = this.#createLog(LogLevels.FATAL, message);
+        return this.log(log);
     }
-    logFatal(...message) {
-        const messageString = this.#createMessage(message);
-        return this.#driver.logFatal(messageString);
+    #createLog(level, messages) {
+        const timestamp = new Date().toISOString();
+        const source = this.#source;
+        const message = this.#createMessage(messages);
+        return { timestamp, level, source, message };
     }
-    #createMessage(message) {
-        return message.map(value => this.#interpretValue(value)).join(' ');
+    #createMessage(messages) {
+        return messages.map(message => this.#interpretValue(message)).join(' ');
     }
     #interpretValue(value) {
         switch (typeof value) {

package/dist/definitions/interfaces.d.ts

@@ -1,7 +1,4 @@
+import type { Log } from './types.js';
 export interface Driver {
-    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>;
+    log(log: Log): Promise<void>;
 }

package/dist/definitions/types.d.ts

@@ -0,0 +1,7 @@
+import type { LogLevel } from './constants.js';
+export type Log = {
+    timestamp: string;
+    level: LogLevel;
+    source: string;
+    message: string;
+};

package/dist/definitions/types.js

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

package/dist/drivers/Console.d.ts

@@ -1,8 +1,6 @@
 import type { Driver } from '../definitions/interfaces.js';
+import type { Log } from '../definitions/types.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>;
-    logFatal(message: string): Promise<void>;
+    #private;
+    log(log: Log): Promise<void>;
 }

package/dist/drivers/Console.js

@@ -1,18 +1,21 @@
 /* eslint no-console: "off" */
+import { LogLevels } from '../definitions/constants.js';
+import levelToString from '../utils/levelToString.js';
 export default class Console {
-    async logDebug(message) {
-        return console.debug(`[DEBUG] ${message}`);
+    async log(log) {
+        const message = this.#createLogMessage(log);
+        switch (log.level) {
+            case LogLevels.DEBUG: return console.debug(message);
+            case LogLevels.INFO: return console.info(message);
+            case LogLevels.WARN: return console.warn(message);
+            default: return console.error(message);
+        }
     }
-    async logInfo(message) {
-        return console.info(`[INFO] ${message}`);
-    }
-    async logWarn(message) {
-        return console.warn(`[WARN] ${message}`);
-    }
-    async logError(message) {
-        return console.error(`[ERROR] ${message}`);
-    }
-    async logFatal(message) {
-        return console.error(`[FATAL] ${message}`);
+    #createLogMessage(log) {
+        const time = log.timestamp;
+        const level = levelToString(log.level);
+        const source = log.source;
+        const message = log.message;
+        return `[${time}][${level}][${source}] ${message}`;
     }
 }

package/dist/drivers/Memory.d.ts

@@ -1,17 +1,8 @@
-import type { LogLevel } from '../definitions/constants.js';
 import type { Driver } from '../definitions/interfaces.js';
-type Log = {
-    level: LogLevel;
-    message: string;
-};
+import type { Log } from '../definitions/types.js';
 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>;
+    log(log: Log): Promise<void>;
     clear(): void;
 }
-export {};

package/dist/drivers/Memory.js

@@ -1,21 +1,8 @@
-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 });
+    async log(log) {
+        this.#logs.push(log);
     }
     clear() {
         this.#logs.splice(0);

package/dist/drivers/Void.d.ts

@@ -1,8 +1,5 @@
 import type { Driver } from '../definitions/interfaces.js';
+import type { Log } from '../definitions/types.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>;
-    logFatal(message: string): Promise<void>;
+    log(log: Log): Promise<void>;
 }

package/dist/drivers/Void.js

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

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export * from './definitions/constants.js';
-export type * from './definitions/constants.js';
-export type * from './definitions/interfaces.js';
+export { LogLevels } from './definitions/constants.js';
+export type { LogLevel } from './definitions/constants.js';
+export type { Driver } from './definitions/interfaces.js';
+export type { Log } from './definitions/types.js';
 export { default as LogError } from './errors/LogError.js';
 export { default as ConsoleDriver } from './drivers/Console.js';
-export { default as DatabaseDriver } from './drivers/Database.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,7 +1,6 @@
-export * from './definitions/constants.js';
+export { LogLevels } from './definitions/constants.js';
 export { default as LogError } from './errors/LogError.js';
 export { default as ConsoleDriver } from './drivers/Console.js';
-export { default as DatabaseDriver } from './drivers/Database.js';
 export { default as MemoryDriver } from './drivers/Memory.js';
 export { default as VoidDriver } from './drivers/Void.js';
 export { default } from './Logger.js';

package/dist/utils/levelToString.d.ts

@@ -0,0 +1,2 @@
+import type { LogLevel } from '../definitions/constants.js';
+export default function levelToString(level: LogLevel): string;

package/dist/utils/levelToString.js

@@ -0,0 +1,5 @@
+import { LogLevels } from '../definitions/constants.js';
+const logLevels = new Map(Object.entries(LogLevels).map(([key, value]) => [value, key]));
+export default function levelToString(level) {
+    return logLevels.get(level) ?? 'UNKNOWN';
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@theshelf/logging",
   "private": false,
-  "version": "0.3.2",
+  "version": "0.4.0",
   "type": "module",
   "repository": {
     "url": "git+https://github.com/MaskingTechnology/theshelf.git"
   },
+  "license": "MIT",
   "scripts": {
     "build": "tsc",
     "clean": "rimraf dist",
@@ -19,14 +20,6 @@
     "README.md",
     "dist"
   ],
-  "types": "dist/index.d.ts",
-  "exports": "./dist/index.js",
-  "peerDependencies": {
-    "@theshelf/database": "^0.3.0"
-  },
-  "peerDependenciesMeta": {
-    "@theshelf/database": {
-      "optional": true
-    }
-  }
+  "types": "./dist/index.d.ts",
+  "exports": "./dist/index.js"
 }

package/dist/drivers/Database.d.ts

@@ -1,12 +0,0 @@
-import type Database from '@theshelf/database';
-import type { RecordType } from '@theshelf/database';
-import type { Driver } from '../definitions/interfaces.js';
-export default class DatabaseDriver implements Driver {
-    #private;
-    constructor(database: Database, recordType: RecordType);
-    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>;
-}

package/dist/drivers/Database.js

@@ -1,31 +0,0 @@
-export default class DatabaseDriver {
-    #database;
-    #recordType;
-    constructor(database, recordType) {
-        this.#recordType = recordType;
-        this.#database = database;
-    }
-    logDebug(message) {
-        return this.#logRecord('DEBUG', message);
-    }
-    logInfo(message) {
-        return this.#logRecord('INFO', message);
-    }
-    logWarn(message) {
-        return this.#logRecord('WARN', message);
-    }
-    logError(message) {
-        return this.#logRecord('ERROR', message);
-    }
-    logFatal(message) {
-        return this.#logRecord('FATAL', message);
-    }
-    async #logRecord(level, message) {
-        const data = {
-            timestamp: new Date().toISOString(),
-            level,
-            message
-        };
-        await this.#database.createRecord(this.#recordType, data);
-    }
-}