@seidor-cloud-produtos/orbit-backend-lib 2.0.47 → 2.0.48

package/dist/clean-arch/application/logger/index.d.ts

@@ -16,17 +16,25 @@ export interface LogProperties {
 }
 export interface LogPropertiesInput {
     level: LOG_LEVEL;
-    actor?: string;
-    type?: string;
+}
+export interface LogParams {
+    actor: string;
+    type: string;
 }
 export interface LogOptions {
 }
 export default abstract class LoggerGateway {
     protected cache: Cache;
-    constructor(cache: Cache);
+    protected params: LogParams;
+    protected options?: LogOptions | undefined;
+    constructor(cache: Cache, params: LogParams, options?: LogOptions | undefined);
     private static cacheKey;
-    log(props: LogPropertiesInput, options: LogOptions, ...dataToLog: any[]): Promise<void>;
-    abstract register(props: LogProperties, options: LogOptions, ...dataToLog: any[]): Promise<void> | void;
+    info(...input: any[]): Promise<void>;
+    warn(...input: any[]): Promise<void>;
+    error(...input: any[]): Promise<void>;
+    debug(...input: any[]): Promise<void>;
+    log(props: LogPropertiesInput, ...dataToLog: any[]): Promise<void>;
+    protected abstract register(props: LogProperties, ...dataToLog: any[]): Promise<void> | void;
     private static buildAcceptLogLevelValues;
     protected isToLog(props: LogProperties, ...dataToLog: any[]): Promise<boolean | undefined>;
     protected buildProps(props?: LogPropertiesInput): LogProperties;

package/dist/clean-arch/application/logger/index.js

@@ -14,22 +14,38 @@ var CategoryEnum;
 })(CategoryEnum || (exports.CategoryEnum = CategoryEnum = {}));
 class LoggerGateway {
     cache;
-    constructor(cache) {
+    params;
+    options;
+    constructor(cache, params, options) {
         this.cache = cache;
+        this.params = params;
+        this.options = options;
     }
     static cacheKey = 'LOG_LEVEL';
-    async log(props, options, ...dataToLog) {
+    async info(...input) {
+        return await this.log({ level: types_1.LOG_LEVEL.info }, input);
+    }
+    async warn(...input) {
+        return await this.log({ level: types_1.LOG_LEVEL.warn }, input);
+    }
+    async error(...input) {
+        return await this.log({ level: types_1.LOG_LEVEL.error }, input);
+    }
+    async debug(...input) {
+        return await this.log({ level: types_1.LOG_LEVEL.error }, input);
+    }
+    async log(props, ...dataToLog) {
         try {
             const buildedProperties = this.buildProps(props);
             const isToLog = await this.isToLog(buildedProperties, dataToLog);
             if (!isToLog) {
                 return;
             }
-            return await this.register(buildedProperties, options, dataToLog);
+            return await this.register(buildedProperties, dataToLog);
         }
         catch (e) {
             console.error('Error in log', e);
-            console.log('Input', props, options, dataToLog);
+            console.log('Input', props, dataToLog);
         }
     }
     static buildAcceptLogLevelValues(level) {
@@ -78,14 +94,14 @@ class LoggerGateway {
                 ...props,
             };
         }
-        return this.buildDefaultProps();
+        return defaultProps;
     }
     buildDefaultProps() {
         return {
             level: types_1.LOG_LEVEL.info,
             dateTime: new Date(),
-            actor: 'default',
-            type: 'default',
+            actor: this.params.actor,
+            type: this.params.type,
         };
     }
     async setLevel(level, filter, ttl) {

package/dist/clean-arch/infra/logger/logger-in-memory.d.ts

@@ -1,13 +1,11 @@
-import LoggerGateway, { LogOptions, LogPropertiesInput } from '../../application/logger';
+import LoggerGateway, { LogOptions, LogParams, LogPropertiesInput } from '../../application/logger';
 import { Cache } from '../../../clean-arch/application/cache/cache';
 export interface LoggerInMemoryOptions extends LogOptions {
     showProps?: boolean;
 }
 export declare class LoggerInMemory extends LoggerGateway {
-    constructor(cache: Cache);
-    log(props: LogPropertiesInput, options: LoggerInMemoryOptions, ...dataToLog: any[]): Promise<void>;
-    register(props: LogPropertiesInput, options: LoggerInMemoryOptions, ...dataToLog: any[]): void;
-    private info;
-    private error;
-    private warning;
+    protected options: LoggerInMemoryOptions;
+    constructor(cache: Cache, params: LogParams, options?: LoggerInMemoryOptions);
+    log(props: LogPropertiesInput, ...dataToLog: any[]): Promise<void>;
+    protected register(props: LogPropertiesInput, ...dataToLog: any[]): void;
 }

package/dist/clean-arch/infra/logger/logger-in-memory.js

@@ -5,42 +5,27 @@ const tslib_1 = require("tslib");
 const logger_1 = tslib_1.__importDefault(require("../../application/logger"));
 const types_1 = require("../environment/types");
 class LoggerInMemory extends logger_1.default {
-    constructor(cache) {
-        super(cache);
+    constructor(cache, params, options) {
+        super(cache, params, options);
     }
-    async log(props, options, ...dataToLog) {
-        return await super.log(props, options, dataToLog);
+    async log(props, ...dataToLog) {
+        return await super.log(props, dataToLog);
     }
-    register(props, options, ...dataToLog) {
+    register(props, ...dataToLog) {
+        const params = [...dataToLog];
+        if (this.options?.showProps) {
+            params.push(props);
+        }
         switch (props?.level) {
             case types_1.LOG_LEVEL.error:
-                return this.error(props, options, dataToLog);
+                return console.error(...params);
             case types_1.LOG_LEVEL.warn:
-                return this.warning(props, options, dataToLog);
+                return console.warn(...params);
+            case types_1.LOG_LEVEL.debug:
+                return console.debug(...params);
             default:
-                return this.info(props, options, dataToLog);
-        }
-    }
-    info(props, options, ...dataToLog) {
-        const params = [...dataToLog];
-        if (options?.showProps) {
-            params.push(props);
-        }
-        console.info(...params);
-    }
-    error(props, options, ...dataToLog) {
-        const params = [...dataToLog];
-        if (options?.showProps) {
-            params.push(props);
-        }
-        console.error(...params);
-    }
-    warning(props, options, ...dataToLog) {
-        const params = [...dataToLog];
-        if (options?.showProps) {
-            params.push(props);
+                return console.info(...params);
         }
-        console.warn(...params);
     }
 }
 exports.LoggerInMemory = LoggerInMemory;

package/dist/clean-arch/infra/logger/logger-orbit.d.ts

@@ -1,5 +1,5 @@
 import Queue from '../../application/queue/queue';
-import LoggerGateway, { ActorEnum, CategoryEnum, LogOptions, LogProperties, LogPropertiesInput } from '../../application/logger';
+import LoggerGateway, { ActorEnum, CategoryEnum, LogOptions, LogParams, LogProperties, LogPropertiesInput } from '../../application/logger';
 import DomainEvent from '../../domain/events/domain-event';
 import { Cache } from '../../../clean-arch/application/cache/cache';
 export interface LoggerOrbitOptions extends LogOptions {
@@ -8,8 +8,6 @@ export interface LoggerOrbitOptions extends LogOptions {
 }
 export interface LogOrbitPropertiesInput extends LogPropertiesInput {
     id?: string;
-    actorType?: ActorEnum;
-    category?: CategoryEnum;
     tenantId?: string;
     dateTime?: Date;
     expirationHours?: number;
@@ -20,15 +18,20 @@ export interface LogOrbitPropertiesInput extends LogPropertiesInput {
 }
 export interface LogOrbitProperties extends LogProperties {
     id?: string;
+    tenantId?: string;
     actorType: ActorEnum;
     category: CategoryEnum;
-    tenantId?: string;
     expirationHours: number;
     trace?: {
         mainId?: string;
         ids: string[];
     };
 }
+export interface LogOrbitParams extends LogParams {
+    actorType: ActorEnum;
+    category: CategoryEnum;
+    expirationHours: number;
+}
 export type LogPayload = Omit<LogProperties, 'expirationHours'> & {
     expirationDate: Date;
     details: any;
@@ -41,11 +44,12 @@ export default class LogEvent implements DomainEvent {
 }
 export declare class LoggerOrbit extends LoggerGateway {
     private queue;
-    constructor(queue: Queue, cache: Cache);
-    log(props: LogOrbitPropertiesInput, options: LoggerOrbitOptions, ...dataToLog: any[]): Promise<void>;
+    protected options: LoggerOrbitOptions;
+    protected params: LogOrbitParams;
+    constructor(queue: Queue, cache: Cache, params: LogOrbitParams, options?: LoggerOrbitOptions);
+    log(props: LogOrbitPropertiesInput, ...dataToLog: any[]): Promise<void>;
     protected isToLog(props: LogOrbitProperties, ...dataToLog: any[]): Promise<boolean | undefined>;
-    register(data: any, props: LogOrbitPropertiesInput, options: LoggerOrbitOptions): Promise<void>;
+    register(data: any, props: LogOrbitPropertiesInput): Promise<void>;
     private buildPayload;
     protected buildDefaultProps(): LogOrbitProperties;
-    protected buildProps(props: LogOrbitPropertiesInput): LogOrbitProperties;
 }

package/dist/clean-arch/infra/logger/logger-orbit.js

@@ -15,27 +15,27 @@ class LogEvent {
 exports.default = LogEvent;
 class LoggerOrbit extends logger_1.default {
     queue;
-    constructor(queue, cache) {
-        super(cache);
+    constructor(queue, cache, params, options) {
+        super(cache, params, options);
         this.queue = queue;
     }
-    async log(props, options, ...dataToLog) {
-        return await super.log(props, options, dataToLog);
+    async log(props, ...dataToLog) {
+        return await super.log(props, dataToLog);
     }
     async isToLog(props, ...dataToLog) {
         return ((await super.isToLog(props, dataToLog)) ||
             props.category === logger_1.CategoryEnum.BUSINESS);
     }
-    async register(data, props, options) {
+    async register(data, props) {
         try {
             const payload = this.buildPayload(data, props);
             await this.queue.publish('logservice.common.direct', new LogEvent(payload));
         }
         catch (error) {
-            if (options?.retryStrategy) {
-                await options.retryStrategy(data, props, options);
+            if (this.options?.retryStrategy) {
+                await this.options.retryStrategy(data, props);
             }
-            if (options?.throwOnError) {
+            if (this.options?.throwOnError) {
                 throw new log_error_1.default();
             }
         }
@@ -58,20 +58,10 @@ class LoggerOrbit extends logger_1.default {
         const sevenDaysInHours = 168;
         return {
             ...super.buildDefaultProps(),
-            category: logger_1.CategoryEnum.TECHNICAL,
+            category: this.params.category,
             actorType: logger_1.ActorEnum.SYSTEM,
             expirationHours: sevenDaysInHours * 4,
         };
     }
-    buildProps(props) {
-        let buildedProps = this.buildDefaultProps();
-        if (props) {
-            buildedProps = {
-                ...buildedProps,
-                ...props,
-            };
-        }
-        return buildedProps;
-    }
 }
 exports.LoggerOrbit = LoggerOrbit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "2.0.47",
+  "version": "2.0.48",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/clean-arch/infra/logger/lib-logger.d.ts

@@ -1,7 +0,0 @@
-import { LogProperties } from '../../application/logger';
-import { LoggerInMemory } from './logger-in-memory';
-declare class LibLogger extends LoggerInMemory {
-    protected buildDefaultProps(): LogProperties;
-}
-declare const libLogger: LibLogger;
-export default libLogger;

package/dist/clean-arch/infra/logger/lib-logger.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const cache_in_memory_1 = tslib_1.__importDefault(require("../cache/cache-in-memory"));
-const logger_in_memory_1 = require("./logger-in-memory");
-class LibLogger extends logger_in_memory_1.LoggerInMemory {
-    buildDefaultProps() {
-        return {
-            ...super.buildDefaultProps(),
-            actor: 'lib-seidor-common',
-        };
-    }
-}
-const libLogger = new LibLogger(cache_in_memory_1.default);
-exports.default = libLogger;