vona-module-a-logger 5.0.9 → 5.0.11

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

@@ -0,0 +1,85 @@
+import type { BeanScopeUtil } from 'vona';
+import type { IDecoratorBroadcastOptions } from 'vona-module-a-broadcast';
+import type { IAopMethodOptionsLog } from '../bean/aopMethod.log.ts';
+/** bean: end */
+/** bean: begin */
+import type { BeanLogger } from '../bean/bean.logger.ts';
+/** broadcast: end */
+/** broadcast: begin */
+import type { BroadcastSetLevel } from '../bean/broadcast.setLevel.ts';
+/** middlewareSystem: end */
+/** aopMethod: begin */
+import type { IMiddlewareSystemOptionsHttpLog } from '../bean/middlewareSystem.httpLog.ts';
+/** broadcast: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from '../bean/aopMethod.log.ts';
+declare module 'vona-module-a-aspect' {
+    interface IMiddlewareSystemRecord {
+        'a-logger:httpLog': IMiddlewareSystemOptionsHttpLog;
+    }
+}
+declare module 'vona-module-a-logger' {
+    interface MiddlewareSystemHttpLog {
+    }
+}
+/** aopMethod: end */
+/** bean: begin */
+export * from '../bean/bean.logger.ts';
+declare module 'vona-module-a-aspect' {
+    interface IAopMethodRecord {
+        'a-logger:log': IAopMethodOptionsLog;
+    }
+}
+declare module 'vona-module-a-logger' {
+    interface AopMethodLog {
+    }
+}
+/** bean: end */
+/** broadcast: begin */
+export * from '../bean/broadcast.setLevel.ts';
+declare module 'vona' {
+}
+declare module 'vona-module-a-logger' {
+    interface BeanLogger {
+    }
+}
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        logger: BeanLogger;
+    }
+}
+/** middlewareSystem: begin */
+export * from '../bean/middlewareSystem.httpLog.ts';
+declare module 'vona-module-a-broadcast' {
+    interface IBroadcastRecord {
+        'a-logger:setLevel': IDecoratorBroadcastOptions;
+    }
+}
+declare module 'vona-module-a-logger' {
+    interface BroadcastSetLevel {
+    }
+}
+export interface IModuleBroadcast {
+    setLevel: BroadcastSetLevel;
+}
+export declare class ScopeModuleALogger extends BeanScopeBase {
+}
+export interface ScopeModuleALogger {
+    util: BeanScopeUtil;
+    broadcast: IModuleBroadcast;
+}
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-logger': ScopeModuleALogger;
+    }
+    interface IBeanScopeContainer {
+        logger: ScopeModuleALogger;
+    }
+}
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "a-logger";
+export { ScopeModuleALogger as ScopeModule } from './index.ts';

package/dist/bean/aopMethod.log.d.ts

@@ -0,0 +1,21 @@
+import type { ILoggerClientChildRecord, ILoggerClientRecord, LoggerLevel, Next, NextSync } from 'vona';
+import type { IAopMethodExecute, IAopMethodGet, IAopMethodSet, IDecoratorAopMethodOptions } from 'vona-module-a-aspect';
+import type winston from 'winston';
+import { BeanAopMethodBase } from 'vona';
+export interface IAopMethodOptionsLog extends IDecoratorAopMethodOptions {
+    level: LoggerLevel;
+    childName?: keyof ILoggerClientChildRecord;
+    clientName?: keyof ILoggerClientRecord;
+    auto?: boolean;
+    args?: boolean;
+    result?: boolean;
+    context?: Record<string, any>;
+}
+export declare class AopMethodLog extends BeanAopMethodBase implements IAopMethodGet, IAopMethodSet, IAopMethodExecute {
+    get(options: IAopMethodOptionsLog, next: NextSync, receiver: any, prop: string): any;
+    set(options: IAopMethodOptionsLog, value: any, next: NextSync, receiver: any, prop: string): boolean;
+    execute(options: IAopMethodOptionsLog, _args: [], next: Next | NextSync, receiver: any, prop: string): Promise<any> | any;
+    _getContext(options: IAopMethodOptionsLog, receiver: any): unknown;
+    _logResult(profiler: winston.Profiler, context: any, res: any, options: IAopMethodOptionsLog, message: string): void;
+    _logError(profiler: winston.Profiler, context: any, err: Error, _options: IAopMethodOptionsLog, message: string): void;
+}

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

@@ -0,0 +1,6 @@
+import type { ILoggerClientRecord, LoggerLevel } from 'vona';
+import { BeanBase } from 'vona';
+export declare class BeanLogger extends BeanBase {
+    getLevel(clientName?: keyof ILoggerClientRecord): LoggerLevel | undefined;
+    setLevel(level: LoggerLevel | boolean, clientName?: keyof ILoggerClientRecord): void;
+}

package/dist/bean/broadcast.setLevel.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 TypeBroadcastSetLevelJobData {
+    level: LoggerLevel | boolean;
+    clientName?: keyof ILoggerClientRecord;
+}
+export declare class BroadcastSetLevel extends BeanBroadcastBase<TypeBroadcastSetLevelJobData> implements IBroadcastExecute<TypeBroadcastSetLevelJobData> {
+    execute(data: TypeBroadcastSetLevelJobData, isEmitter?: boolean): Promise<void>;
+}

package/dist/bean/middlewareSystem.httpLog.d.ts

@@ -0,0 +1,8 @@
+import type { Next } from 'vona';
+import type { IDecoratorMiddlewareSystemOptions, IMiddlewareSystemExecute } from 'vona-module-a-aspect';
+import { BeanBase } from 'vona';
+export interface IMiddlewareSystemOptionsHttpLog extends IDecoratorMiddlewareSystemOptions {
+}
+export declare class MiddlewareSystemHttpLog extends BeanBase implements IMiddlewareSystemExecute {
+    execute(_options: IMiddlewareSystemOptionsHttpLog, next: Next): Promise<void>;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './.metadata/index.ts';
+export * from './lib/index.ts';
+export * from './types/index.ts';

package/dist/index.js

@@ -0,0 +1,166 @@
+import { BeanInfo, BeanAopMethodBase, SymbolBeanFullName, BeanBase, BeanScopeBase } from 'vona';
+import { Bean, Scope } from 'vona-module-a-bean';
+import { evaluateExpressions } from '@cabloy/utils';
+import { AopMethod, MiddlewareSystem, Aspect } from 'vona-module-a-aspect';
+import { Broadcast, BeanBroadcastBase } from 'vona-module-a-broadcast';
+import StdSerializers from 'pino-std-serializers';
+
+var _dec$4, _dec2$4, _class$4;
+let AopMethodLog = (_dec$4 = AopMethod({
+  level: 'info'
+}), _dec2$4 = BeanInfo({
+  module: "a-logger"
+}), _dec$4(_class$4 = _dec2$4(_class$4 = class AopMethodLog extends BeanAopMethodBase {
+  get(options, next, receiver, prop) {
+    const context = this._getContext(options, receiver);
+    const message = `${receiver[SymbolBeanFullName]}#${prop}(get)`;
+    const logger = this.app.meta.logger.child(options.childName, options.clientName);
+    // begin
+    !options.auto && logger.log(options.level, message, context ? {
+      context
+    } : undefined);
+    const profiler = logger.startTimer();
+    // next
+    try {
+      const res = next();
+      this._logResult(profiler, context, res, options, message);
+      return res;
+    } catch (err) {
+      this._logError(profiler, context, err, options, message);
+      throw err;
+    }
+  }
+  set(options, value, next, receiver, prop) {
+    const context = this._getContext(options, receiver);
+    const message = `${receiver[SymbolBeanFullName]}#${prop}(set)`;
+    const logger = this.app.meta.logger.child(options.childName, options.clientName);
+    // begin
+    logger.log(options.level, `${message} value: ${JSON.stringify(value)}`, context ? {
+      context
+    } : undefined);
+    const profiler = logger.startTimer();
+    // next
+    try {
+      const res = next();
+      !options.auto && this._logResult(profiler, context, undefined, options, message);
+      return res;
+    } catch (err) {
+      this._logError(profiler, context, err, options, message);
+      throw err;
+    }
+  }
+  execute(options, _args, next, receiver, prop) {
+    const context = this._getContext(options, receiver);
+    const message = `${receiver[SymbolBeanFullName]}#${prop}`;
+    const logger = this.app.meta.logger.child(options.childName, options.clientName);
+    // begin
+    options.args !== false && logger.log(options.level, `${message} args: ${JSON.stringify(_args)}`, context ? {
+      context
+    } : undefined);
+    const profiler = logger.startTimer();
+    // next
+    try {
+      const res = next();
+      if (res?.then) {
+        return res.then(res => {
+          options.result !== false && this._logResult(profiler, context, res, options, message);
+          return res;
+        }).catch(err => {
+          this._logError(profiler, context, err, options, message);
+          throw err;
+        });
+      }
+      options.result !== false && this._logResult(profiler, context, res, options, message);
+      return res;
+    } catch (err) {
+      this._logError(profiler, context, err, options, message);
+      throw err;
+    }
+  }
+  _getContext(options, receiver) {
+    return evaluateExpressions(options.context, receiver);
+  }
+  _logResult(profiler, context, res, options, message) {
+    const textResult = res !== undefined ? ` result: ${JSON.stringify(res)}` : '';
+    const info = {
+      level: options.level,
+      message: `${message}${textResult}`
+    };
+    if (context) info.context = context;
+    profiler.done(info);
+  }
+  _logError(profiler, context, err, _options, message) {
+    const textError = ` error: ${err.message}`;
+    const info = {
+      level: 'error',
+      message: `${message}${textError}`
+    };
+    if (context) info.context = context;
+    profiler.done(info);
+  }
+}) || _class$4) || _class$4);
+
+var _dec$3, _dec2$3, _class$3;
+let BeanLogger = (_dec$3 = Bean(), _dec2$3 = BeanInfo({
+  module: "a-logger"
+}), _dec$3(_class$3 = _dec2$3(_class$3 = class BeanLogger extends BeanBase {
+  getLevel(clientName) {
+    return this.app.meta.logger.getLevel(clientName);
+  }
+  setLevel(level, clientName) {
+    this.app.meta.logger.setLevel(level, clientName);
+    this.scope.broadcast.setLevel.emit({
+      level,
+      clientName
+    });
+  }
+}) || _class$3) || _class$3);
+
+var _dec$2, _dec2$2, _class$2;
+let BroadcastSetLevel = (_dec$2 = Broadcast(), _dec2$2 = BeanInfo({
+  module: "a-logger"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = class BroadcastSetLevel extends BeanBroadcastBase {
+  async execute(data, isEmitter) {
+    if (!isEmitter) {
+      this.app.meta.logger.setLevel(data.level, data.clientName);
+    }
+  }
+}) || _class$2) || _class$2);
+
+var _dec$1, _dec2$1, _class$1;
+let MiddlewareSystemHttpLog = (_dec$1 = MiddlewareSystem(), _dec2$1 = BeanInfo({
+  module: "a-logger"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = class MiddlewareSystemHttpLog extends BeanBase {
+  async execute(_options, next) {
+    const ctx = this.ctx;
+    // start
+    const req = StdSerializers.req(ctx.req);
+    this.$loggerChild('req').http(JSON.stringify(req));
+    const profiler = this.$loggerChild('res').startTimer();
+    // next
+    await next();
+    // end
+    const res = {
+      url: ctx.req.url,
+      statusCode: ctx.res.statusCode,
+      headers: ctx.res.getHeaders()
+    };
+    profiler.done({
+      level: 'http',
+      message: JSON.stringify(res)
+    });
+  }
+}) || _class$1) || _class$1);
+
+var _dec, _dec2, _class;
+let ScopeModuleALogger = (_dec = Scope(), _dec2 = BeanInfo({
+  module: "a-logger"
+}), _dec(_class = _dec2(_class = class ScopeModuleALogger extends BeanScopeBase {}) || _class) || _class);
+
+/** scope: end */
+
+function Log(options) {
+  return Aspect.aopMethod('a-logger:log', options);
+}
+
+export { AopMethodLog, BeanLogger, BroadcastSetLevel, Log, MiddlewareSystemHttpLog, ScopeModuleALogger };

package/dist/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './log.ts';

package/dist/lib/log.d.ts

@@ -0,0 +1,2 @@
+import type { IAopMethodOptionsLog } from '../bean/aopMethod.log.js';
+export declare function Log(options?: Partial<IAopMethodOptionsLog>): MethodDecorator;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './logger.ts';

package/dist/types/logger.d.ts

@@ -0,0 +1,7 @@
+declare module 'vona' {
+    interface ILoggerClientChildRecord {
+        req: never;
+        res: never;
+    }
+}
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-logger",
   "type": "module",
-  "version": "5.0.9",
+  "version": "5.0.11",
   "title": "a-logger",
   "vonaModule": {
     "dependencies": {}
@@ -28,8 +28,12 @@
   "dependencies": {
     "pino-std-serializers": "^7.0.0"
   },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.0.1"
+  },
   "scripts": {
-    "clean": "rimraf dist tsconfig.tsbuildinfo",
-    "tsc:publish": "npm run clean && tsc"
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && vona :bin:buildModule && tsc -p tsconfig.build.json"
   }
 }