@pesalink/response-utils-package

PesaLink Logger
The PesaLink Logger package provides utilities to enhance logging capabilities for your Node.js applications. It allows you to log method calls dynamically for class prototypes and supports advanced logging strategies such as AOP (Aspect-Oriented Programming). This package includes two main components: AOPLogger and AOPLoggerUtils.

Features
Dynamic Logging: Log all method calls on a class prototype.
Exclusion Support: Exclude specific methods from being logged.
Error-Only Logging: Configure methods to log only errors.
Custom Advice Types: Choose the logging strategy (around, before, after).
Utility-Driven Approach: Use either AOPLogger directly or the AOPLoggerUtils method logMethodsWithAOP.
Installation
Install the package using npm:

bash
Copy code
npm install pesalink-logger
Usage
1. Using AOPLogger Directly
AOPLogger is the core utility to log individual method calls on a class prototype. You can call it directly to configure logging for specific methods.

javascript
Copy code
const AOPLogger = require("pesalink-logger/aopLogger");

AOPLogger.logMethodCall(
classPrototype, // The class prototype
methodName, // Name of the method to log
className, // Name of the class
methodType, // Optional: Type of method (e.g., "getAll" for error logging)
adviceType, // Optional: Type of advice (default: "around")
classType // Optional: Class type for custom logging
);
2. Using AOPLoggerUtils.logMethodsWithAOP
The logMethodsWithAOP method in AOPLoggerUtils simplifies logging for all methods in a class prototype, with options to exclude specific methods or log errors only for some.

javascript
Copy code
const { logMethodsWithAOP } = require("pesalink-logger/aopLoggerUtils");

logMethodsWithAOP(
classPrototype, // Prototype of the class
excludedMethods = [], // Methods to exclude from logging
logErrorsOnly = [], // Methods to log only errors (e.g., "getAll")
className, // Name of the class for logging context
classType, // Optional: Class type for custom strategies
adviceType = "around" // Optional: Advice type (default: "around")
);

Parameters for logMethodsWithAOP

Parameter Description
classPrototype The prototype of the class whose methods you want to log.
excludedMethods Array of method names to exclude from logging.
logErrorsOnly Array of methods for which only errors should be logged (e.g., getAll).
className The name of the class (used for logging context).
classType The type of the class (optional, used in custom logging strategies).
adviceType The type of advice (optional, default is "around" for method execution).
Example: Dynamic Logging
Below is an example demonstrating the use of AOPLoggerUtils to log method calls dynamically on a class:

``
const { logMethodsWithAOP } = require("pesalink-logger/aopLoggerUtils");

class MyService {
constructor() {}

fetchData() {
console.log("Fetching data...");
}

saveData() {
console.log("Saving data...");
}

getAll() {
throw new Error("An error occurred while fetching all data!");
}
}

// Exclude saveData and log only errors for getAll
logMethodsWithAOP(
MyService.prototype,
["saveData"], // Excluded methods
["getAll"], // Log errors only
"MyService" // Class name
);

// Instantiate and test logging
const service = new MyService();
service.fetchData();
try {
service.getAll();
} catch (error) {}
`

`Integration Notes
The AOPLogger class provides the low-level API for method call logging.
The AOPLoggerUtils.logMethodsWithAOP method wraps around AOPLogger to simplify configuration for dynamic logging of class prototypes.
Both utilities are included in the pesalink-logger package and can be used interchangeably based on your project needs.