reggolxc 2.0.4 → 2.0.6

package/dist/console.js

@@ -1,11 +1,23 @@
 // 1. Crear wrappers de metodos log nativos
-// 2. Establecer sistema que determine si el livel del log aplica para ser impreso
+// 2. Establecer sistema que determine si el nivel del log aplica para ser impreso
 // 3. Crear Objetos transports
 // 4. Objetos transports deben recibir un callback
-// 5. Logs en consola deben estar stilizados para navegadores y terminales. 
+// 5. Logs en consola deben estar estilizados para navegadores y terminales. 
 // 6. Desarrollar con TDD
-export const LEVELS_ENUM = { DEBUG: 'debug', INFO: 'info', WARN: 'warn', ERROR: 'error', FATAL: 'fatal' };
-const LEVELS = { [LEVELS_ENUM.DEBUG]: 1, [LEVELS_ENUM.INFO]: 2, [LEVELS_ENUM.WARN]: 3, [LEVELS_ENUM.ERROR]: 4, [LEVELS_ENUM.FATAL]: 5 };
+export const LEVELS_ENUM = {
+    DEBUG: 'debug',
+    INFO: 'info',
+    WARN: 'warn',
+    ERROR: 'error',
+    FATAL: 'fatal'
+};
+const LEVELS = {
+    [LEVELS_ENUM.DEBUG]: 1,
+    [LEVELS_ENUM.INFO]: 2,
+    [LEVELS_ENUM.WARN]: 3,
+    [LEVELS_ENUM.ERROR]: 4,
+    [LEVELS_ENUM.FATAL]: 5
+};
 const BROWSER_STYLES = {
     debug: 'color: #808080; font-weight: bold;',
     info: 'color: #0088ff; font-weight: bold;',
@@ -14,15 +26,15 @@ const BROWSER_STYLES = {
     fatal: 'color: #ffffff; background-color: #ff0000; font-weight: bold; padding: 2px 4px; border-radius: 3px;'
 };
 const TIME_STYLE = 'color: #a9a9a9; font-weight: normal; font-style: italic;';
-class Transport {
+export class Transport {
     constructor(minLevelValue = 0) {
         this.minLevelValue = minLevelValue;
     }
     handle(levelName, levelValue, payload) { }
 }
 export class ConsoleTransport extends Transport {
-    super(minLevel = LEVELS_ENUM.DEBUG) {
-        this.minLevelValue = LEVELS[minLevel];
+    constructor(minLevel = LEVELS_ENUM.DEBUG) {
+        super(LEVELS[minLevel]);
     }
     handle(levelName, levelValue, payload) {
         if (levelValue < this.minLevelValue)
@@ -32,9 +44,8 @@ export class ConsoleTransport extends Transport {
     }
 }
 export class TelemetryTransport extends Transport {
-    constructor(fetchFun, minLevelValue = LEVELS_ENUM.ERROR) {
-        const minLevel = LEVELS[minLevelValue];
-        super(minLevel);
+    constructor(fetchFun, minLevel = LEVELS_ENUM.ERROR) {
+        super(LEVELS[minLevel]);
         this.fetchFun = fetchFun;
     }
     handle(levelName, levelValue, payload) {
@@ -46,12 +57,11 @@ export class TelemetryTransport extends Transport {
     }
 }
 /**
-* @description  Custom logger
-* @param minLevel
-*/
+ * @description Custom logger
+ */
 export class Roggel {
     constructor(transports = []) {
-        this.transports = transports;
+        this.transports = Array.isArray(transports) ? transports : [transports];
     }
     addTransport(transport) {
         const transportArr = Array.isArray(transport) ? transport : [transport];
@@ -73,13 +83,8 @@ export class Roggel {
         });
     }
     debug(message, ...args) { this.processLog('debug', message, args); }
-    ;
     info(message, ...args) { this.processLog('info', message, args); }
-    ;
     warn(message, ...args) { this.processLog('warn', message, args); }
-    ;
     error(message, ...args) { this.processLog('error', message, args); }
-    ;
     fatal(message, ...args) { this.processLog('fatal', message, args); }
-    ;
 }

package/dist/console.test.js

@@ -1,30 +1,25 @@
 import { Roggel, TelemetryTransport, ConsoleTransport, LEVELS_ENUM } from "./console";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 describe('Logger', () => {
     const logger = new Roggel();
     it('should have functions [debug, info, warn, error, fatal]', () => {
-        expect(Object.values(LEVELS_ENUM).every((l) => typeof logger[l])).toBe(true);
+        expect(Object.values(LEVELS_ENUM).every((l) => typeof logger[l] === 'function')).toBe(true);
     });
-    it('Addtransport be a fun', () => {
+    it('addTransport should be a function', () => {
         expect(typeof logger.addTransport).toBe('function');
     });
-    it('shoould add new transport', () => {
+    it('should add new transport', () => {
         const transport = new ConsoleTransport();
         logger.addTransport(transport);
         expect(logger.getTransports().length).toBe(1);
     });
     it('should process log', () => {
-        const logger = new Roggel();
-        const sendLogService = async (payload) => {
-            return new Promise((resolve, reject) => {
-                setTimeout(() => {
-                    resolve(payload);
-                }, 2000);
-            });
-        };
+        const localLogger = new Roggel();
+        const sendLogService = vi.fn().mockResolvedValue('ok');
         const telemetry = new TelemetryTransport(sendLogService);
-        const console = new ConsoleTransport();
-        logger.addTransport([telemetry, console]);
-        expect(() => logger.error('print test')).not.toThrow();
+        const consoleTransport = new ConsoleTransport();
+        localLogger.addTransport([telemetry, consoleTransport]);
+        expect(() => localLogger.error('print test')).not.toThrow();
+        expect(sendLogService).toHaveBeenCalled();
     });
 });

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "reggolxc",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "",
-  "main": "dist/console.js",
+  "type": "module",
+  "main": "./dist/console.js",
+  "module": "./dist/console.js",
+  "types": "./dist/console.d.ts",
   "scripts": {
     "test": "vitest"
   },
@@ -11,6 +14,5 @@
   "devDependencies": {
     "typescript": "^7.0.2",
     "vitest": "^4.1.11"
-  },
-  "module": "module"
-}
+  }
+}

package/src/console.test.ts

@@ -1,39 +1,33 @@
-import { Roggel, TelemetryTransport, ConsoleTransport, LEVELS_ENUM, type levelsT, payloadI } from "./console";
-import { describe, expect, it } from "vitest";
-
+import { Roggel, TelemetryTransport, ConsoleTransport, LEVELS_ENUM, type LogLevel, type LogPayload } from "./console";
+import { describe, expect, it, vi } from "vitest";
 
 describe('Logger', () => {
     const logger = new Roggel();
 
     it('should have functions [debug, info, warn, error, fatal]', () => {
-        expect(Object.values(LEVELS_ENUM).every((l: levelsT) => typeof logger[l])).toBe(true);
-    })
+        expect(
+            Object.values(LEVELS_ENUM).every((l: LogLevel) => typeof logger[l as keyof Roggel] === 'function')
+        ).toBe(true);
+    });
 
-    it('Addtransport be a fun', () => {
+    it('addTransport should be a function', () => {
         expect(typeof logger.addTransport).toBe('function');
-    })
-    it('shoould add new transport', () => {
+    });
+
+    it('should add new transport', () => {
         const transport = new ConsoleTransport();
         logger.addTransport(transport);
         expect(logger.getTransports().length).toBe(1);
-    })
-    it('should process log', () => {
-        const logger = new Roggel();
-        const sendLogService = async <T,>(payload: payloadI) => {
-            return new Promise<T>(
-                (resolve, reject) => {
-                    setTimeout(() => {
-                        resolve(payload as unknown as T);
-                    }, 2000)
-                }, 
-            )
-        }
+    });
 
-        const telemetry = new TelemetryTransport(sendLogService)
-        const console = new ConsoleTransport();
-
-        logger.addTransport([telemetry, console]);
-        expect(() => logger.error('print test')).not.toThrow();
-    })
+    it('should process log', () => {
+        const localLogger = new Roggel();        
+        const sendLogService = vi.fn().mockResolvedValue('ok');
+        const telemetry = new TelemetryTransport(sendLogService);
+        const consoleTransport = new ConsoleTransport(); 
+        localLogger.addTransport([telemetry, consoleTransport]);        
+        expect(() => localLogger.error('print test')).not.toThrow();        
+        expect(sendLogService).toHaveBeenCalled();
+    });
 
-})
+});

package/src/console.ts

@@ -1,12 +1,28 @@
 // 1. Crear wrappers de metodos log nativos
-// 2. Establecer sistema que determine si el livel del log aplica para ser impreso
+// 2. Establecer sistema que determine si el nivel del log aplica para ser impreso
 // 3. Crear Objetos transports
 // 4. Objetos transports deben recibir un callback
-// 5. Logs en consola deben estar stilizados para navegadores y terminales. 
+// 5. Logs en consola deben estar estilizados para navegadores y terminales. 
 // 6. Desarrollar con TDD
 
-export const LEVELS_ENUM = { DEBUG: 'debug', INFO: 'info', WARN: 'warn', ERROR: 'error', FATAL: 'fatal' } as const
-const LEVELS = { [LEVELS_ENUM.DEBUG]: 1, [LEVELS_ENUM.INFO]: 2, [LEVELS_ENUM.WARN]: 3, [LEVELS_ENUM.ERROR]: 4, [LEVELS_ENUM.FATAL]: 5 } as const;
+
+export const LEVELS_ENUM = { 
+    DEBUG: 'debug', 
+    INFO: 'info', 
+    WARN: 'warn', 
+    ERROR: 'error', 
+    FATAL: 'fatal' 
+} as const;
+
+export type LogLevel = typeof LEVELS_ENUM[keyof typeof LEVELS_ENUM];
+
+const LEVELS: Record<LogLevel, number> = { 
+    [LEVELS_ENUM.DEBUG]: 1, 
+    [LEVELS_ENUM.INFO]: 2, 
+    [LEVELS_ENUM.WARN]: 3, 
+    [LEVELS_ENUM.ERROR]: 4, 
+    [LEVELS_ENUM.FATAL]: 5 
+};
 
 const BROWSER_STYLES: Record<string, string> = {
     debug: 'color: #808080; font-weight: bold;',
@@ -18,47 +34,55 @@ const BROWSER_STYLES: Record<string, string> = {
 
 const TIME_STYLE = 'color: #a9a9a9; font-weight: normal; font-style: italic;';
 
-export type levelsT = typeof LEVELS_ENUM[keyof typeof LEVELS_ENUM];
-type consoleKeysT = Exclude<levelsT, 'fatal'>
-
-export interface payloadI {
-    level: levelsT,
-    timestamp: string,
-    message: string,
-    args: unknown[]
+export interface LogPayload {
+    level: LogLevel;
+    timestamp: string;
+    message: string;
+    args: any[];
 }
 
-abstract class Transport {
-    constructor(protected minLevelValue: number = 0) { }
-    handle(levelName: string, levelValue: number, payload: payloadI) { }
+export type FetchTransportFn = (payload: LogPayload) => Promise<unknown>;
+
+
+export class Transport {
+    public minLevelValue: number;
+
+    constructor(minLevelValue: number = 0) {
+        this.minLevelValue = minLevelValue;
+    }
+
+    handle(levelName: LogLevel, levelValue: number, payload: LogPayload): void {}
 }
 
 export class ConsoleTransport extends Transport {
-    super(minLevel: levelsT = LEVELS_ENUM.DEBUG) {
-        this.minLevelValue = LEVELS[minLevel];
+    constructor(minLevel: LogLevel = LEVELS_ENUM.DEBUG) {
+        super(LEVELS[minLevel]);
     }
 
-    handle(levelName: string, levelValue: number, payload: payloadI) {
+    handle(levelName: LogLevel, levelValue: number, payload: LogPayload): void {
         if (levelValue < this.minLevelValue) return;
-        const consoleMethod = (levelName === 'fatal' ? 'error' : levelName) as consoleKeysT;
 
-        console[consoleMethod](
+        const consoleMethod = (levelName === 'fatal' ? 'error' : levelName) as keyof Console;
+        
+        (console[consoleMethod] as Function)(
             `%c[${payload.timestamp}] %c[${levelName.toUpperCase()}]`, 
             TIME_STYLE, 
-            BROWSER_STYLES[levelName] || '',
-            payload.message,
+            BROWSER_STYLES[levelName] || '', 
+            payload.message, 
             ...payload.args
         );
     }
 }
 
 export class TelemetryTransport extends Transport {
-    constructor(private fetchFun: <T>(payload: payloadI) => Promise<T>, minLevelValue = LEVELS_ENUM.ERROR) {
-        const minLevel = LEVELS[minLevelValue];
-        super(minLevel);
+    private fetchFun: FetchTransportFn;
+
+    constructor(fetchFun: FetchTransportFn, minLevel: LogLevel = LEVELS_ENUM.ERROR) {
+        super(LEVELS[minLevel]);
+        this.fetchFun = fetchFun;
     }
 
-    handle(levelName: string, levelValue: number, payload: payloadI) {
+    handle(levelName: LogLevel, levelValue: number, payload: LogPayload): void {
         if (levelValue < this.minLevelValue) return;
 
         this.fetchFun(payload).catch(err => {
@@ -67,44 +91,43 @@ export class TelemetryTransport extends Transport {
     }
 }
 
-interface IRoggel {
 
-}
+/**
+ * @description Custom logger
+ */
+export class Roggel {
+    private transports: Transport[];
 
-/**  
-* @description  Custom logger 
-* @param minLevel
-*/
-export class Roggel implements IRoggel {
-    constructor(private transports: (ConsoleTransport | TelemetryTransport)[] = []) { }
+    constructor(transports: Transport | Transport[] = []) {
+        this.transports = Array.isArray(transports) ? transports : [transports];
+    }
 
-    public addTransport(transport: (ConsoleTransport | TelemetryTransport)[] | (ConsoleTransport | TelemetryTransport)) {
+    addTransport(transport: Transport | Transport[]): void {
         const transportArr = Array.isArray(transport) ? transport : [transport];
         this.transports.push(...transportArr);
     }
 
-    public getTransports() {
+    getTransports(): Transport[] {
         return this.transports;
     }
 
-    protected processLog(levelName: levelsT, message: string, args: unknown[]) {
+    private processLog(levelName: LogLevel, message: string, args: any[]): void {
         const levelValue = LEVELS[levelName];
-        const payload:payloadI = {
+        const payload: LogPayload = {
             level: levelName,
-            timestamp: new Date().toISOString() as string,
+            timestamp: new Date().toISOString(),
             message,
             args
-        }
+        };
+
         this.transports.forEach(transport => {
             transport.handle(levelName, levelValue, payload);
         });
     }
 
-    public debug(message: string, ...args: unknown[]) { this.processLog('debug', message, args) };
-    public info(message: string, ...args: unknown[]) { this.processLog('info', message, args) };
-    public warn(message: string, ...args: unknown[]) { this.processLog('warn', message, args) };
-    public error(message: string, ...args: unknown[]) { this.processLog('error', message, args) };
-    public fatal(message: string, ...args: unknown[]) { this.processLog('fatal', message, args) };
-
-}
-
+    debug(message: string, ...args: any[]): void { this.processLog('debug', message, args); }
+    info(message: string, ...args: any[]): void { this.processLog('info', message, args); }
+    warn(message: string, ...args: any[]): void { this.processLog('warn', message, args); }
+    error(message: string, ...args: any[]): void { this.processLog('error', message, args); }
+    fatal(message: string, ...args: any[]): void { this.processLog('fatal', message, args); }
+}