nelog 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mem U Sins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# NoLog
+
+nelog — adapter based logger util
+
+## Installation
+
+```shell
+$ npm install nelog
+```
+
+## Adapters
+
+| Adapter                                                 | destination         |
+|---------------------------------------------------------|---------------------|
+| [Console](https://github.com/memUsins/nelogconsole)     | Console adapter     |
+| [File](https://github.com/memUsins/nelogfile)           | File (json) adapter |
+| [Loki](https://github.com/memUsins/nelogloki)           | Loki adapter        |
+| [Context Manager](https://github.com/memUsins/nelogctx) | Context manager     |
+
+## Usage
+
+### Additional Methods for Logging
+- **withFields**, **withField**, **withError**, **withName** for detailed context:
+  ```ts
+  logger.withFields({ "foo": "bar" }).info("Some log info")
+  logger.withField("foo", "bar").info("Some log info")
+  logger.withError(new Error("my error")).info("Some log info")
+  logger.withName("TestLogger").info("Some log info")
+  ```

package/lib/entry.d.ts

@@ -0,0 +1,18 @@
+import { IEntry, F, Log, ILogger } from './thridparty';
+export declare class Entry implements IEntry {
+    private logger;
+    private readonly data;
+    constructor(logger: ILogger);
+    log(log: Log): void;
+    withField(key: string, value: any): IEntry;
+    withFields(fields: F): IEntry;
+    withError(err: Error): IEntry;
+    withName(name: string): IEntry;
+    print(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    debugJson(data: any): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    fatal(...args: any[]): void;
+}

package/lib/entry.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entry = void 0;
+const thridparty_1 = require("./thridparty");
+// entry implements Entry
+class Entry {
+    logger;
+    data;
+    constructor(logger) {
+        this.logger = logger;
+        this.data = {
+            fields: {},
+            error: null,
+            name: '',
+            withName: false,
+        };
+    }
+    // Log core method to logging
+    log(log) {
+        log.data = { ...this.data };
+        this.logger.log(log);
+        this.data.error = null;
+        this.data.fields = {};
+    }
+    // WithField add field to entry data
+    withField(key, value) {
+        this.data.fields = { [key]: value };
+        return this;
+    }
+    // WithFields add fields to entry data
+    withFields(fields) {
+        this.data.fields = { ...fields };
+        return this;
+    }
+    // WithError add error to entry data
+    withError(err) {
+        this.data.error = err;
+        return this;
+    }
+    // WithName add name to entry data
+    withName(name) {
+        this.data.name = name;
+        return this;
+    }
+    // Print default log
+    print(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.UnselectedLevel, ...args));
+    }
+    // Info default log
+    info(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.InfoLevel, ...args));
+    }
+    // Debug default log
+    debug(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.DebugLevel, ...args));
+    }
+    // DebugJson log formating json struct
+    debugJson(data) {
+        try {
+            const jsonData = JSON.stringify(data, null, 2);
+            this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.DebugLevel, jsonData));
+        }
+        catch (err) {
+            this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.DebugLevel, 'failed to unmarshal json'));
+        }
+    }
+    // Warn default log
+    warn(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.WarnLevel, ...args));
+    }
+    // Error default log
+    error(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.ErrorLevel, ...args));
+    }
+    // Fatal default log
+    fatal(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.FatalLevel, ...args));
+    }
+}
+exports.Entry = Entry;

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './thridparty';
+export * from './logger';
+export * from './entry';

package/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./thridparty"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./entry"), exports);

package/lib/logger.d.ts

@@ -0,0 +1,21 @@
+import { IAdapter, IEntry, F, Log, ILogger } from './thridparty';
+export declare class Logger implements ILogger {
+    private readonly adapters;
+    constructor(adapters?: IAdapter[]);
+    log(log: Log): void;
+    withField(key: string, value: any): IEntry;
+    withFields(fields: F): IEntry;
+    withName(name: string): IEntry;
+    withError(err: Error): IEntry;
+    print(...args: any[]): void;
+    info(...args: any[]): void;
+    infon(name: string, ...args: any[]): void;
+    debug(...args: any[]): void;
+    debugn(name: string, ...args: any[]): void;
+    warn(...args: any[]): void;
+    warnn(name: string, ...args: any[]): void;
+    error(...args: any[]): void;
+    errorn(name: string, ...args: any[]): void;
+    fatal(...args: any[]): void;
+    fataln(name: string, ...args: any[]): void;
+}

package/lib/logger.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const thridparty_1 = require("./thridparty");
+const entry_1 = require("./entry");
+// Logger implements ILogger
+class Logger {
+    adapters;
+    constructor(adapters = []) {
+        this.adapters = adapters;
+    }
+    // Log core method to logging
+    log(log) {
+        for (const adapter of this.adapters) {
+            const copy = (0, thridparty_1.newLogCopy)(log);
+            adapter.log(copy);
+        }
+    }
+    // WithField returns Entry with field
+    withField(key, value) {
+        const e = new entry_1.Entry(this);
+        e.withField(key, value);
+        return e;
+    }
+    // WithFields returns Entry with fields
+    withFields(fields) {
+        const e = new entry_1.Entry(this);
+        e.withFields(fields);
+        return e;
+    }
+    // WithName returns Entry with name
+    withName(name) {
+        const e = new entry_1.Entry(this);
+        e.withName(name);
+        return e;
+    }
+    // WithError returns Entry with error
+    withError(err) {
+        const e = new entry_1.Entry(this);
+        e.withError(err);
+        return e;
+    }
+    // Print default log
+    print(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.UnselectedLevel, ...args));
+    }
+    // Info default log
+    info(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.InfoLevel, ...args));
+    }
+    // Infon log with name
+    infon(name, ...args) {
+        this.log((0, thridparty_1.newDefaultLogn)(thridparty_1.Level.InfoLevel, name, ...args));
+    }
+    // Debug default log
+    debug(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.DebugLevel, ...args));
+    }
+    // Debugn log with name
+    debugn(name, ...args) {
+        this.log((0, thridparty_1.newDefaultLogn)(thridparty_1.Level.DebugLevel, name, ...args));
+    }
+    // Warn default log
+    warn(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.WarnLevel, ...args));
+    }
+    // Warnn log with name
+    warnn(name, ...args) {
+        this.log((0, thridparty_1.newDefaultLogn)(thridparty_1.Level.WarnLevel, name, ...args));
+    }
+    // Error default log
+    error(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.ErrorLevel, ...args));
+    }
+    // Errorn log with name
+    errorn(name, ...args) {
+        this.log((0, thridparty_1.newDefaultLogn)(thridparty_1.Level.ErrorLevel, name, ...args));
+    }
+    // Fatal default log
+    fatal(...args) {
+        this.log((0, thridparty_1.newDefaultLog)(thridparty_1.Level.FatalLevel, ...args));
+    }
+    // Fataln log with name
+    fataln(name, ...args) {
+        this.log((0, thridparty_1.newDefaultLogn)(thridparty_1.Level.FatalLevel, name, ...args));
+    }
+}
+exports.Logger = Logger;

package/lib/thridparty/index.d.ts

@@ -0,0 +1,3 @@
+export { ILogger, IEntry, IAdapter } from './types';
+export { Level, isLevelEnabled, levelToString } from './level';
+export { F, Log, LogData, newLogCopy, newDefaultLog, newDefaultLogn } from './log';

package/lib/thridparty/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newDefaultLogn = exports.newDefaultLog = exports.newLogCopy = exports.levelToString = exports.isLevelEnabled = exports.Level = void 0;
+var level_1 = require("./level");
+Object.defineProperty(exports, "Level", { enumerable: true, get: function () { return level_1.Level; } });
+Object.defineProperty(exports, "isLevelEnabled", { enumerable: true, get: function () { return level_1.isLevelEnabled; } });
+Object.defineProperty(exports, "levelToString", { enumerable: true, get: function () { return level_1.levelToString; } });
+var log_1 = require("./log");
+Object.defineProperty(exports, "newLogCopy", { enumerable: true, get: function () { return log_1.newLogCopy; } });
+Object.defineProperty(exports, "newDefaultLog", { enumerable: true, get: function () { return log_1.newDefaultLog; } });
+Object.defineProperty(exports, "newDefaultLogn", { enumerable: true, get: function () { return log_1.newDefaultLogn; } });

package/lib/thridparty/level.d.ts

@@ -0,0 +1,10 @@
+export declare enum Level {
+    DebugLevel = -2,
+    InfoLevel = -1,
+    WarnLevel = 0,
+    ErrorLevel = 1,
+    FatalLevel = 2,
+    UnselectedLevel = 3
+}
+export declare const isLevelEnabled: (current: Level, level: Level) => boolean;
+export declare const levelToString: (level: Level) => string;

package/lib/thridparty/level.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.levelToString = exports.isLevelEnabled = exports.Level = void 0;
+// Level core level declaration
+var Level;
+(function (Level) {
+    Level[Level["DebugLevel"] = -2] = "DebugLevel";
+    Level[Level["InfoLevel"] = -1] = "InfoLevel";
+    Level[Level["WarnLevel"] = 0] = "WarnLevel";
+    Level[Level["ErrorLevel"] = 1] = "ErrorLevel";
+    Level[Level["FatalLevel"] = 2] = "FatalLevel";
+    Level[Level["UnselectedLevel"] = 3] = "UnselectedLevel";
+})(Level || (exports.Level = Level = {}));
+// IsEnabled check is level enabled
+const isLevelEnabled = (current, level) => {
+    return level >= current;
+};
+exports.isLevelEnabled = isLevelEnabled;
+// String returns the string representation of the level
+const levelToString = (level) => {
+    switch (level) {
+        case Level.DebugLevel:
+            return 'debug';
+        case Level.InfoLevel:
+            return 'info';
+        case Level.WarnLevel:
+            return 'warn';
+        case Level.ErrorLevel:
+            return 'error';
+        case Level.FatalLevel:
+            return 'fatal';
+        case Level.UnselectedLevel:
+            return 'unselected';
+        default:
+            return '';
+    }
+};
+exports.levelToString = levelToString;

package/lib/thridparty/log.d.ts

@@ -0,0 +1,17 @@
+import { Level } from './level';
+export type F = Record<string, any>;
+export interface LogData {
+    fields: F;
+    error: Error | null;
+    name: string;
+    withName: boolean;
+}
+export interface Log {
+    level: Level;
+    data: LogData;
+    message: string;
+    timestamp: Date;
+}
+export declare const newLogCopy: (log: Log) => Log;
+export declare const newDefaultLog: (level: Level, ...args: any[]) => Log;
+export declare const newDefaultLogn: (level: Level, name: string, ...args: any[]) => Log;

package/lib/thridparty/log.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newDefaultLogn = exports.newDefaultLog = exports.newLogCopy = void 0;
+// NewLogCopy returns copied Log
+const newLogCopy = (log) => {
+    const fields = {};
+    for (const [k, v] of Object.entries(log.data.fields)) {
+        fields[k] = v;
+    }
+    return {
+        level: log.level,
+        message: log.message,
+        data: {
+            fields,
+            error: log.data.error,
+            name: log.data.name,
+            withName: log.data.withName,
+        },
+        timestamp: log.timestamp,
+    };
+};
+exports.newLogCopy = newLogCopy;
+// NewDefaultLog returns new Log
+const newDefaultLog = (level, ...args) => {
+    return {
+        level,
+        message: args.map(String).join(' '),
+        data: {
+            fields: {},
+            error: null,
+            name: '',
+            withName: false,
+        },
+        timestamp: new Date(),
+    };
+};
+exports.newDefaultLog = newDefaultLog;
+// NewDefaultLogn returns new Log with name args
+const newDefaultLogn = (level, name, ...args) => {
+    return {
+        level,
+        message: args.map(String).join(' '),
+        data: {
+            fields: {},
+            error: null,
+            name,
+            withName: false,
+        },
+        timestamp: new Date(),
+    };
+};
+exports.newDefaultLogn = newDefaultLogn;

package/lib/thridparty/types.d.ts

@@ -0,0 +1,36 @@
+import { F, Log } from './log';
+export interface ILogger {
+    log(log: Log): void;
+    withField(key: string, value: any): IEntry;
+    withFields(fields: F): IEntry;
+    withError(err: Error): IEntry;
+    withName(name: string): IEntry;
+    print(...args: any[]): void;
+    info(...args: any[]): void;
+    infon(name: string, ...args: any[]): void;
+    debug(...args: any[]): void;
+    debugn(name: string, ...args: any[]): void;
+    warn(...args: any[]): void;
+    warnn(name: string, ...args: any[]): void;
+    error(...args: any[]): void;
+    errorn(name: string, ...args: any[]): void;
+    fatal(...args: any[]): void;
+    fataln(name: string, ...args: any[]): void;
+}
+export interface IEntry {
+    log(log: Log): void;
+    withField(key: string, value: any): IEntry;
+    withFields(fields: F): IEntry;
+    withError(err: Error): IEntry;
+    withName(name: string): IEntry;
+    print(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    fatal(...args: any[]): void;
+}
+export interface IAdapter {
+    log(log: Log): void;
+    format(log: Log): unknown;
+}

package/lib/thridparty/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "nelog",
+  "version": "0.0.1",
+  "description": "Logger",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/**/*"
+  ],
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "format": "prettier -w ./src",
+    "lint": "eslint . --ext .ts"
+  },
+  "keywords": [
+    "Logger"
+  ],
+  "type": "commonjs",
+  "author": "memUsins",
+  "devDependencies": {
+    "eslint": "^9.39.1",
+    "prettier": "^3.7.3"
+  }
+}