vona-module-a-logger 5.0.33 → 5.0.34

package/dist/.metadata/index.d.ts

@@ -56,27 +56,38 @@ declare module 'vona' {
 }
 /** bean: end */
 /** broadcast: begin */
-export * from '../bean/broadcast.setLevel.ts';
+export * from '../bean/broadcast.setFilterChild.ts';
+export * from '../bean/broadcast.setFilterLevel.ts';
 import { type IDecoratorBroadcastOptions } from 'vona-module-a-broadcast';
 declare module 'vona-module-a-broadcast' {
     interface IBroadcastRecord {
-        'a-logger:setLevel': IDecoratorBroadcastOptions;
+        'a-logger:setFilterChild': IDecoratorBroadcastOptions;
+        'a-logger:setFilterLevel': IDecoratorBroadcastOptions;
     }
 }
 declare module 'vona-module-a-logger' {
-    interface BroadcastSetLevel {
+    interface BroadcastSetFilterChild {
     }
-    interface BroadcastSetLevel {
-        get $beanFullName(): 'a-logger.broadcast.setLevel';
-        get $onionName(): 'a-logger:setLevel';
+    interface BroadcastSetFilterChild {
+        get $beanFullName(): 'a-logger.broadcast.setFilterChild';
+        get $onionName(): 'a-logger:setFilterChild';
+        get $onionOptions(): IDecoratorBroadcastOptions;
+    }
+    interface BroadcastSetFilterLevel {
+    }
+    interface BroadcastSetFilterLevel {
+        get $beanFullName(): 'a-logger.broadcast.setFilterLevel';
+        get $onionName(): 'a-logger:setFilterLevel';
         get $onionOptions(): IDecoratorBroadcastOptions;
     }
 }
 /** broadcast: end */
 /** broadcast: begin */
-import type { BroadcastSetLevel } from '../bean/broadcast.setLevel.ts';
+import type { BroadcastSetFilterChild } from '../bean/broadcast.setFilterChild.ts';
+import type { BroadcastSetFilterLevel } from '../bean/broadcast.setFilterLevel.ts';
 export interface IModuleBroadcast {
-    'setLevel': BroadcastSetLevel;
+    'setFilterChild': BroadcastSetFilterChild;
+    'setFilterLevel': BroadcastSetFilterLevel;
 }
 /** broadcast: end */
 /** main: begin */

package/dist/bean/bean.logger.d.ts

@@ -3,11 +3,13 @@ import type * as Transport from 'winston-transport';
 import { BeanBase } from 'vona';
 import * as Winston from 'winston';
 export declare class BeanLogger extends BeanBase {
-    getLevel(clientName?: keyof ILoggerClientRecord): LoggerLevel | false;
-    setLevel(level: LoggerLevel | boolean, clientName?: keyof ILoggerClientRecord): void;
+    getFilterLevel(clientName?: keyof ILoggerClientRecord): LoggerLevel | false;
+    setFilterLevel(level: LoggerLevel | boolean, clientName?: keyof ILoggerClientRecord): void;
+    getFilterChild(clientName?: keyof ILoggerClientRecord): string[] | undefined;
+    setFilterChild(child: string | string[], clientName?: keyof ILoggerClientRecord): void;
     get default(): Winston.Logger;
     get(clientName?: keyof ILoggerClientRecord): Winston.Logger;
     getChild(childName: keyof ILoggerChildRecord, clientName?: keyof ILoggerClientRecord): Winston.Logger;
-    makeTransportFile(clientInfo: ILoggerOptionsClientInfo, fileName: string, levelStrict?: LoggerLevel): Transport;
+    makeTransportFile(clientInfo: ILoggerOptionsClientInfo, fileName: string, levelStrict?: LoggerLevel, childStrict?: string | string[]): Transport;
     makeTransportConsole(clientInfo: ILoggerOptionsClientInfo): Transport;
 }

package/dist/bean/broadcast.setFilterChild.d.ts

@@ -0,0 +1,10 @@
+import type { ILoggerClientRecord } from 'vona';
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+import { BeanBroadcastBase } from 'vona-module-a-broadcast';
+export interface TypeBroadcastSetFilterChildJobData {
+    child: string | string[];
+    clientName?: keyof ILoggerClientRecord;
+}
+export declare class BroadcastSetFilterChild extends BeanBroadcastBase<TypeBroadcastSetFilterChildJobData> implements IBroadcastExecute<TypeBroadcastSetFilterChildJobData> {
+    execute(data: TypeBroadcastSetFilterChildJobData, isEmitter?: boolean): Promise<void>;
+}

package/dist/bean/broadcast.setFilterLevel.d.ts

@@ -0,0 +1,10 @@
+import type { ILoggerClientRecord, LoggerLevel } from 'vona';
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+import { BeanBroadcastBase } from 'vona-module-a-broadcast';
+export interface TypeBroadcastSetFilterLevelJobData {
+    level: LoggerLevel | boolean;
+    clientName?: keyof ILoggerClientRecord;
+}
+export declare class BroadcastSetFilterLevel extends BeanBroadcastBase<TypeBroadcastSetFilterLevelJobData> implements IBroadcastExecute<TypeBroadcastSetFilterLevelJobData> {
+    execute(data: TypeBroadcastSetFilterLevelJobData, isEmitter?: boolean): Promise<void>;
+}

package/dist/index.js

@@ -1,4 +1,5 @@
 import { BeanInfo, BeanBase, BeanAopMethodBase, SymbolBeanFullName, formatLoggerFilter, formatLoggerDummy, formatLoggerConsole, BeanSimple, combineConfigDefault, deepExtend, BeanScopeBase } from 'vona';
+import { __decorate } from 'tslib';
 import StdSerializers from 'pino-std-serializers';
 import { MiddlewareSystem, AopMethod } from 'vona-module-a-aspect';
 import { evaluateExpressions } from '@cabloy/utils';
@@ -6,10 +7,7 @@ import { Bean, Scope } from 'vona-module-a-bean';
 import * as Winston from 'winston';
 import { Broadcast, BeanBroadcastBase } from 'vona-module-a-broadcast';
 
-var _dec$4, _dec2$4, _class$4;
-let MiddlewareSystemHttpLog = (_dec$4 = MiddlewareSystem(), _dec2$4 = BeanInfo({
-  module: "a-logger"
-}), _dec$4(_class$4 = _dec2$4(_class$4 = class MiddlewareSystemHttpLog extends BeanBase {
+let MiddlewareSystemHttpLog = class MiddlewareSystemHttpLog extends BeanBase {
   async execute(_options, next) {
     const ctx = this.ctx;
     // start
@@ -29,14 +27,12 @@ let MiddlewareSystemHttpLog = (_dec$4 = MiddlewareSystem(), _dec2$4 = BeanInfo({
       message: JSON.stringify(res)
     });
   }
-}) || _class$4) || _class$4);
-
-var _dec$3, _dec2$3, _class$3;
-let AopMethodLog = (_dec$3 = AopMethod({
-  level: 'info'
-}), _dec2$3 = BeanInfo({
+};
+MiddlewareSystemHttpLog = __decorate([MiddlewareSystem(), BeanInfo({
   module: "a-logger"
-}), _dec$3(_class$3 = _dec2$3(_class$3 = class AopMethodLog extends BeanAopMethodBase {
+})], MiddlewareSystemHttpLog);
+
+let AopMethodLog = class AopMethodLog extends BeanAopMethodBase {
   get(options, next, receiver, prop) {
     const context = this._getContext(options, receiver);
     const message = `${receiver[SymbolBeanFullName]}#${prop}(get)`;
@@ -137,22 +133,34 @@ let AopMethodLog = (_dec$3 = AopMethod({
     if (context) info.context = context;
     profiler.done(info);
   }
-}) || _class$3) || _class$3);
-
-var _dec$2, _dec2$2, _class$2;
-let BeanLogger = (_dec$2 = Bean(), _dec2$2 = BeanInfo({
+};
+AopMethodLog = __decorate([AopMethod({
+  level: 'info'
+}), BeanInfo({
   module: "a-logger"
-}), _dec$2(_class$2 = _dec2$2(_class$2 = class BeanLogger extends BeanBase {
-  getLevel(clientName) {
-    return this.app.meta.logger.getLevel(clientName);
+})], AopMethodLog);
+
+let BeanLogger = class BeanLogger extends BeanBase {
+  getFilterLevel(clientName) {
+    return this.app.meta.logger.getFilterLevel(clientName);
   }
-  setLevel(level, clientName) {
-    this.app.meta.logger.setLevel(level, clientName);
-    this.scope.broadcast.setLevel.emit({
+  setFilterLevel(level, clientName) {
+    this.app.meta.logger.setFilterLevel(level, clientName);
+    this.scope.broadcast.setFilterLevel.emit({
       level,
       clientName
     });
   }
+  getFilterChild(clientName) {
+    return this.app.meta.logger.getFilterChild(clientName);
+  }
+  setFilterChild(child, clientName) {
+    this.app.meta.logger.setFilterChild(child, clientName);
+    this.scope.broadcast.setFilterChild.emit({
+      child,
+      clientName
+    });
+  }
   get default() {
     return this.app.meta.logger.get();
   }
@@ -164,10 +172,11 @@ let BeanLogger = (_dec$2 = Bean(), _dec2$2 = BeanInfo({
       name: childName
     });
   }
-  makeTransportFile(clientInfo, fileName, levelStrict) {
+  makeTransportFile(clientInfo, fileName, levelStrict, childStrict) {
     return this.app.meta.logger.createTransportFile(fileName, clientInfo, {
       level: levelStrict ?? 'silly',
       format: Winston.format.combine(formatLoggerFilter({
+        child: childStrict ?? clientInfo.child,
         level: levelStrict ?? clientInfo.level,
         strict: !!levelStrict
       }), Winston.format.json())
@@ -177,26 +186,41 @@ let BeanLogger = (_dec$2 = Bean(), _dec2$2 = BeanInfo({
     return new Winston.transports.Console({
       level: 'silly',
       format: Winston.format.combine(formatLoggerDummy(), formatLoggerFilter({
+        child: clientInfo.child,
         level: clientInfo.level,
         silly: true
       }), Winston.format.colorize(), formatLoggerConsole(clientInfo)),
       forceConsole: true
     });
   }
-}) || _class$2) || _class$2);
+};
+BeanLogger = __decorate([Bean(), BeanInfo({
+  module: "a-logger"
+})], BeanLogger);
 
-var _dec$1, _dec2$1, _class$1;
-let BroadcastSetLevel = (_dec$1 = Broadcast({
-  instance: false
-}), _dec2$1 = BeanInfo({
+let BroadcastSetFilterChild = class BroadcastSetFilterChild extends BeanBroadcastBase {
+  async execute(data, isEmitter) {
+    if (!isEmitter) {
+      this.app.meta.logger.setFilterChild(data.child, data.clientName);
+    }
+  }
+};
+BroadcastSetFilterChild = __decorate([Broadcast(), BeanInfo({
   module: "a-logger"
-}), _dec$1(_class$1 = _dec2$1(_class$1 = class BroadcastSetLevel extends BeanBroadcastBase {
+})], BroadcastSetFilterChild);
+
+let BroadcastSetFilterLevel = class BroadcastSetFilterLevel extends BeanBroadcastBase {
   async execute(data, isEmitter) {
     if (!isEmitter) {
-      this.app.meta.logger.setLevel(data.level, data.clientName);
+      this.app.meta.logger.setFilterLevel(data.level, data.clientName);
     }
   }
-}) || _class$1) || _class$1);
+};
+BroadcastSetFilterLevel = __decorate([Broadcast({
+  instance: false
+}), BeanInfo({
+  module: "a-logger"
+})], BroadcastSetFilterLevel);
 
 class Main extends BeanSimple {
   async moduleLoading() {
@@ -211,11 +235,10 @@ async function configDefault(_app) {
   return {};
 }
 
-var _dec, _dec2, _class;
-let ScopeModuleALogger = (_dec = Scope(), _dec2 = BeanInfo({
+let ScopeModuleALogger = class ScopeModuleALogger extends BeanScopeBase {};
+ScopeModuleALogger = __decorate([Scope(), BeanInfo({
   module: "a-logger"
-}), _dec(_class = _dec2(_class = class ScopeModuleALogger extends BeanScopeBase {}) || _class) || _class);
-
+})], ScopeModuleALogger);
 /** scope: end */
 
-export { AopMethodLog, BeanLogger, BroadcastSetLevel, Main, MiddlewareSystemHttpLog, ScopeModuleALogger, configDefault };
+export { AopMethodLog, BeanLogger, BroadcastSetFilterChild, BroadcastSetFilterLevel, Main, MiddlewareSystemHttpLog, ScopeModuleALogger, configDefault };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-logger",
   "type": "module",
-  "version": "5.0.33",
+  "version": "5.0.34",
   "title": "a-logger",
   "vonaModule": {
     "dependencies": {},

package/dist/bean/broadcast.setLevel.d.ts

@@ -1,10 +0,0 @@
-import type { ILoggerClientRecord, LoggerLevel } from 'vona';
-import type { IBroadcastExecute } from 'vona-module-a-broadcast';
-import { BeanBroadcastBase } from 'vona-module-a-broadcast';
-export interface TypeBroadcastSetLevelJobData {
-    level: LoggerLevel | boolean;
-    clientName?: keyof ILoggerClientRecord;
-}
-export declare class BroadcastSetLevel extends BeanBroadcastBase<TypeBroadcastSetLevelJobData> implements IBroadcastExecute<TypeBroadcastSetLevelJobData> {
-    execute(data: TypeBroadcastSetLevelJobData, isEmitter?: boolean): Promise<void>;
-}