vona-module-a-logger 5.0.8 → 5.0.10

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/index.js

@@ -0,0 +1,31 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/** broadcast: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from "../bean/aopMethod.log.js";
+/** aopMethod: end */
+/** bean: begin */
+export * from "../bean/bean.logger.js";
+/** bean: end */
+/** broadcast: begin */
+export * from "../bean/broadcast.setLevel.js";
+/** middlewareSystem: begin */
+export * from "../bean/middlewareSystem.httpLog.js";
+let ScopeModuleALogger = class ScopeModuleALogger extends BeanScopeBase {
+};
+ScopeModuleALogger = __decorate([
+    Scope()
+], ScopeModuleALogger);
+export { 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/.metadata/this.js

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

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/aopMethod.log.js

@@ -0,0 +1,97 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { evaluateExpressions } from '@cabloy/utils';
+import { BeanAopMethodBase, SymbolBeanFullName } from 'vona';
+import { AopMethod } from 'vona-module-a-aspect';
+let AopMethodLog = 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);
+    }
+};
+AopMethodLog = __decorate([
+    AopMethod({
+        level: 'info',
+    })
+], AopMethodLog);
+export { AopMethodLog };

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/bean.logger.js

@@ -0,0 +1,21 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BeanBase } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+let BeanLogger = 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 });
+    }
+};
+BeanLogger = __decorate([
+    Bean()
+], BeanLogger);
+export { BeanLogger };

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/broadcast.setLevel.js

@@ -0,0 +1,18 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BeanBroadcastBase, Broadcast } from 'vona-module-a-broadcast';
+let BroadcastSetLevel = class BroadcastSetLevel extends BeanBroadcastBase {
+    async execute(data, isEmitter) {
+        if (!isEmitter) {
+            this.app.meta.logger.setLevel(data.level, data.clientName);
+        }
+    }
+};
+BroadcastSetLevel = __decorate([
+    Broadcast()
+], BroadcastSetLevel);
+export { BroadcastSetLevel };

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/bean/middlewareSystem.httpLog.js

@@ -0,0 +1,31 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import StdSerializers from 'pino-std-serializers';
+import { BeanBase } from 'vona';
+import { MiddlewareSystem } from 'vona-module-a-aspect';
+let MiddlewareSystemHttpLog = 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) });
+    }
+};
+MiddlewareSystemHttpLog = __decorate([
+    MiddlewareSystem()
+], MiddlewareSystemHttpLog);
+export { MiddlewareSystemHttpLog };

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,3 @@
+export * from "./.metadata/index.js";
+export * from "./lib/index.js";
+export * from "./types/index.js";

package/dist/lib/index.d.ts

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

package/dist/lib/index.js

@@ -0,0 +1 @@
+export * from "./log.js";

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/lib/log.js

@@ -0,0 +1,4 @@
+import { Aspect } from 'vona-module-a-aspect';
+export function Log(options) {
+    return Aspect.aopMethod('a-logger:log', options);
+}

package/dist/types/index.d.ts

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

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from "./logger.js";

package/dist/types/logger.d.ts

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

package/dist/types/logger.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-logger",
   "type": "module",
-  "version": "5.0.8",
+  "version": "5.0.10",
   "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 && tsc -p tsconfig.build.json"
   }
 }