nestjs-log-decorator 1.3.0 → 1.5.0

package/README.md

@@ -25,14 +25,15 @@ TypeScript decorators that eliminate logging boilerplate from NestJS application
 
 ## Description
 
-`@Log()` decorator replaces the try-catch logging pattern in NestJS service methods by automatically logging method invocation on return or error.
+`@Log()` decorator replaces the try-catch logging pattern in NestJS service methods by automatically logging method success and errors, with optional invocation and result logging.
 
 **Key Features**
 
 - By default uses structured output
 - Prettifies Axios errors
 - Zero configuration
-- Zero dependencies
+- Minimal dependencies
+- Uses default `@nestjs/common` Logger instance
 
 ## Installation
 
@@ -42,19 +43,17 @@ npm install nestjs-log-decorator @nestjs/common
 
 ## Quick Start
 
+Simply apply `@Log()` to your class or method:
+
 ```typescript
-import { Logger } from '@nestjs/common';
 import { Log } from 'nestjs-log-decorator';
 
 class UserService {
-  readonly logger = new Logger(UserService.name);
-
   @Log()
   createUser(name: string, email: string) {
     return { id: 1, name, email };
   }
 }
-
 ```
 
 Once a service method is called, it will log the method invocation with all arguments.
@@ -104,18 +103,43 @@ const result = await resultPromise;
 // [UserService] { method: 'createUser', state: 'success', args: { name: 'John' } }
 ```
 
+### Result Logging
+
+If you want to include method results in success logs, use the `result` option.
+
+```typescript
+class UserService {
+  // Logs result as-is
+  @Log({ result: true })
+  findUser(id: number) {
+    return { id, name: 'John', email: 'john@example.com' };
+  }
+
+  // Logs formatted result
+  @Log({
+    result: (res: { id: number; name: string; email: string }) => ({ id: res.id, name: res.name }),
+  })
+  findPublicUser(id: number) {
+    return { id, name: 'John', email: 'john@example.com' };
+  }
+}
+```
+
+Example success output:
+
+```typescript
+// [UserService] { method: 'findUser', state: 'success', args: { id: 1 }, result: { id: 1, name: 'John', email: 'john@example.com' } }
+// [UserService] { method: 'findPublicUser', state: 'success', args: { id: 1 }, result: { id: 1, name: 'John' } }
+```
+
 ### Complete Example
 
-After installation, no additional configuration is needed, just make sure that your class has a public `logger` property that implements the default NestJS Logger interface.
+After installation, no additional configuration is needed. If the class has `logger` properly, the `@Log()` decorator will use it log method. If the logger is missing, the decorator will inject `@nestjs/common` Logger instance using the class name as the context.
 
 ```typescript
-import { Logger } from '@nestjs/common';
 import { Log } from 'nestjs-log-decorator';
 
-
 class PaymentService {
-  // `logger` property will be used by decorator
-  readonly logger = new Logger(PaymentService.name);
 
   @Log()
   async processPayment(amount: number, currency: string) {
@@ -130,7 +154,25 @@ class PaymentService {
 }
 ```
 
-The `logger` property is public due to TypeScript validation limitations. TS cannot check if a private property is valid, but it should still work even if the property is private.
+#### Explicit Logger (Optional)
+
+If you need a custom logger (e.g., for testing or a different context), you can still define your own:
+
+```typescript
+import { Logger } from '@nestjs/common';
+import { Log } from 'nestjs-log-decorator';
+
+@Log()
+class PaymentService {
+  // Explicit logger takes precedence over auto-injected one
+  readonly logger = new Logger('CustomPaymentContext');
+
+  async processPayment(amount: number, currency: string) {
+    // Logs using the explicit logger with 'CustomPaymentContext' context
+    return await this.gateway.processPayment(amount, currency);
+  }
+}
+```
 
 ## How It Works
 
@@ -141,38 +183,38 @@ The `@Log()` decorator wraps your methods with automatic try-catch logging. It e
 │                            @Log() Decorator Flow                            │
 └─────────────────────────────────────────────────────────────────────────────┘
 
-  Method Call                                                        
-       │                                                             
-       ▼                                                             
-┌──────────────────┐                                                 
-│ Extract Args     │  ──▶  { id: 1, name: 'John' }                   
-│ (auto or custom) │                                                 
-└────────┬─────────┘                                                 
-         │                                                           
-         ▼                                                           
-┌──────────────────┐       ┌─────────────────────────────────────┐   
-│ onInvoke: true?  │──YES─▶│ logger.log({ state: 'invoked' })    │   
-└────────┬─────────┘       └─────────────────────────────────────┘   
-         │ NO                                                        
-         ▼                                                           
-┌──────────────────────┐                                                 
-│ Execute Original     │                                                 
-│ Method (sync/async)  │                                                 
-└────────┬─────────────┘                                                 
-         │                                                           
-    ┌────┴────┐                                                      
-    ▼         ▼                                                      
- SUCCESS    ERROR                                                    
-    │         │                                                      
-    ▼         ▼                                                      
-┌────────┐ ┌──────────────────────────────────────────────────────┐  
-│log()   │ │ logger.error({ state: 'error', error: prettify(e) })│  
-│success │ │ (Axios errors auto-prettified)                      │  
-└────────┘ └──────────────────────────────────────────────────────┘  
-    │         │                                                      
-    ▼         ▼                                                      
- Return    Re-throw                                                  
- Result    Error                                                     
+  Method Call
+       │
+       ▼
+┌──────────────────┐
+│ Extract Args     │  ──▶  { id: 1, name: 'John' }
+│ (auto or custom) │
+└────────┬─────────┘
+         │
+         ▼
+┌──────────────────┐       ┌─────────────────────────────────────┐
+│ onInvoke: true?  │──YES─▶│ logger.log({ state: 'invoked' })    │
+└────────┬─────────┘       └─────────────────────────────────────┘
+         │ NO
+         ▼
+┌──────────────────────┐
+│ Execute Original     │
+│ Method (sync/async)  │
+└────────┬─────────────┘
+         │
+    ┌────┴────┐
+    ▼         ▼
+ SUCCESS    ERROR
+    │         │
+    ▼         ▼
+┌────────┐ ┌──────────────────────────────────────────────────────┐
+│log()   │ │ logger.error({ state: 'error', error: prettify(e) })│
+│success │ │ (Axios errors auto-prettified)                      │
+└────────┘ └──────────────────────────────────────────────────────┘
+    │         │
+    ▼         ▼
+ Return    Re-throw
+ Result    Error
 ```
 
 ## Usage
@@ -182,9 +224,9 @@ The `@Log()` decorator wraps your methods with automatic try-catch logging. It e
 Apply `@Log()` to specific methods for granular control:
 
 ```typescript
-class DataService {
-  readonly logger = new Logger(DataService.name);
+import { Log } from 'nestjs-log-decorator';
 
+class DataService {
   @Log()
   async fetchData(id: number) {
     // This method is logged
@@ -203,14 +245,11 @@ class DataService {
 If you want to log all methods in a class, use the `@Log()` decorator on its definition:
 
 ```typescript
-import { Logger } from '@nestjs/common';
 import { Log } from 'nestjs-log-decorator';
 
 @Log()
 @Injectable()
 class PaymentService {
-  readonly logger = new Logger(PaymentService.name);
-
   processPayment(amount: number, currency: string) {
     // Automatically logged on success or error
     return { status: 'completed', amount, currency };
@@ -232,8 +271,6 @@ import { Log, NoLog } from 'nestjs-log-decorator';
 
 @Log()
 class UserService {
-  readonly logger = new Logger(UserService.name);
-
   createUser(name: string) {
     // Logged
     return { name };
@@ -268,8 +305,6 @@ Class-level with `onInvoke`:
 ```typescript
 @Log({ onInvoke: true })
 class ApiService {
-  readonly logger = new Logger(ApiService.name);
-  
   // All methods will log invocation + completion
 }
 ```
@@ -289,8 +324,6 @@ interface LargePayload {
 }
 
 class SyncService {
-  readonly logger = new Logger(SyncService.name);
-
   // Only log the ID, exclude the large payload
   @Log({ args: (id: number, _payload: LargePayload) => ({ id }) })
   async syncData(id: number, payload: LargePayload) {
@@ -319,6 +352,31 @@ class SyncService {
 [SyncService] { method: 'lookupUser', state: 'success', args: '1:John' }
 ```
 
+### `result` — Success Result Logging
+
+Control how return values are included in success logs:
+
+- `result: true` logs the raw return value
+- `result: (value) => ...` logs a formatted value
+
+```typescript
+class PaymentService {
+  // Log full return value
+  @Log({ result: true })
+  createPayment(id: number) {
+    return { id, status: 'success', cardToken: 'tok_123' };
+  }
+
+  // Log only safe result fields
+  @Log({
+    result: (res: { id: number; status: string; cardToken: string }) => ({ id: res.id, status: res.status }),
+  })
+  createPaymentSafe(id: number) {
+    return { id, status: 'success', cardToken: 'tok_123' };
+  }
+}
+```
+
 ## Log Format
 
 All logs are structured JSON objects:
@@ -329,7 +387,9 @@ All logs are structured JSON objects:
 {
   method: 'methodName',
   state: 'success',
-  args: { param1: value1, param2: value2 }
+  args: { param1: value1, param2: value2 },
+  // Present only when `result` option is configured
+  result: { any: 'value' }
 }
 ```
 
@@ -437,12 +497,13 @@ async fetchData(url: string) {
 
 ### `Log(options?)`
 
-Decorator that can be applied to classes or methods.
+Decorator that can be applied to classes or methods. When applied to a class, by default all methods are logged.
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
 | `onInvoke` | `boolean` | `false` | Log method invocation before execution |
 | `args` | `(...args) => any` | `undefined` | Custom function to format logged arguments |
+| `result` | `true \| (result) => any` | `undefined` | Include and optionally format successful method result |
 
 ### `NoLog()`
 
@@ -459,7 +520,7 @@ import { Log, NoLog, LogOptions, Loggable, isLoggable } from 'nestjs-log-decorat
 | `Log` | Decorator | Main logging decorator |
 | `NoLog` | Decorator | Exclude method from logging |
 | `LogOptions` | Interface | Options for `@Log()` decorator |
-| `Loggable` | Interface | Interface for classes with a `logger` property |
+| `Loggable` | Interface | Interface for classes with a `logger` property (optional) |
 | `isLoggable` | Function | Type guard to check if instance has logger |
 
 ## Advanced Example
@@ -471,6 +532,7 @@ import { Log, NoLog } from 'nestjs-log-decorator';
 @Log()
 @Injectable()
 export class OrderService {
+  // Optional: explicit logger takes precedence over auto-injected one
   readonly logger = new Logger(OrderService.name);
 
   constructor(
@@ -485,9 +547,9 @@ export class OrderService {
   }
 
   // Logged with invocation + custom args (exclude sensitive card data)
-  @Log({ 
-    onInvoke: true, 
-    args: (orderId: number, _cardDetails: CardDetails) => ({ orderId }) 
+  @Log({
+    onInvoke: true,
+    args: (orderId: number, _cardDetails: CardDetails) => ({ orderId })
   })
   async processPayment(orderId: number, cardDetails: CardDetails) {
     const result = await this.paymentGateway.charge(orderId, cardDetails);

package/dist/index.cjs

@@ -1,4 +1,5 @@
-require("@nestjs/common");
+let base_decorators = require("base-decorators");
+let _nestjs_common = require("@nestjs/common");
 
 //#region src/axios/axios.stub.ts
 /**
@@ -67,35 +68,40 @@ var LogWrapper = class {
 		this.method = method;
 		this.args = args;
 	}
-	invoked() {
+	invoked(message) {
 		this.logger.log({
 			method: this.method,
 			state: "invoked",
-			args: this.args
+			args: this.args,
+			...message ? { message } : {}
 		});
 	}
-	success() {
+	success(message, additionalFields = {}) {
 		this.logger.log({
 			method: this.method,
 			state: "success",
-			args: this.args
+			args: this.args,
+			...message ? { message } : {},
+			...additionalFields
 		});
 	}
-	error(error) {
+	error(error, message) {
 		try {
 			const pretifiedError = prettifyAxiosError(error);
 			this.logger.error({
 				method: this.method,
 				state: "error",
 				args: this.args,
-				error: pretifiedError
+				error: pretifiedError,
+				...message ? { message } : {}
 			});
 		} catch {
 			this.logger.error({
 				method: this.method,
 				state: "error",
 				args: this.args,
-				error
+				error,
+				...message ? { message } : {}
 			});
 		}
 	}
@@ -104,95 +110,24 @@ const isLoggable = (instance) => {
 	return typeof instance === "object" && instance !== null && "logger" in instance;
 };
 /**
-* Creates a LogWrapper instance with validated logger and built args object.
-* @internal
-*/
-const createLogWrapper = (instance, className, methodName, argsObject) => {
-	if (!isLoggable(instance)) throw new Error(`Logger not found in ${className}. Please add: readonly logger = new Logger(${className}.name)`);
-	return new LogWrapper(instance.logger, methodName, argsObject);
-};
-/**
-* Builds an object mapping parameter names to their values.
-*
-* Creates a record where keys are parameter names and values are the
-* corresponding argument values passed to the function.
-*
-* @param parameterNames - Array of parameter names
-* @param args - Array of argument values
-* @returns Object mapping parameter names to values
-*
-* @example
-* buildArgsObject(['id', 'name'], [1, 'John'])
-* // Returns: { id: 1, name: 'John' }
-*
-* @internal
-*/
-const buildArgsObject = (parameterNames, args) => {
-	if (args.length === 0 && parameterNames.length === 0) return;
-	const argsObject = {};
-	parameterNames.forEach((paramName, index) => {
-		if (index < args.length) argsObject[paramName] = args[index];
-	});
-	return argsObject;
-};
-
-//#endregion
-//#region src/decorate/applyToMethod.ts
-/**
-* Applies logging to a single method.
-* @internal
-*/
-const applyToMethod = (target, propertyKey, descriptor, { onInvoke: shouldLogInvoke = false, args: formatArgs } = {}) => {
-	const originalMethod = descriptor.value;
-	const parameterNames = getParameterNames(originalMethod);
-	descriptor.value = function(...args) {
-		const argsObject = formatArgs ? formatArgs(...args) : buildArgsObject(parameterNames, args);
-		const logWrapper = createLogWrapper(this, target.constructor.name, propertyKey, argsObject);
-		if (shouldLogInvoke) logWrapper.invoked();
-		try {
-			const result = originalMethod.apply(this, args);
-			if (result instanceof Promise) return handleAsyncExecution(result, logWrapper);
-			logWrapper.success();
-			return result;
-		} catch (error) {
-			logWrapper.error(error);
-			throw error;
-		}
-	};
-	return descriptor;
-};
-/**
-* Extracts parameter names from a function signature.
+* Creates a LogWrapper instance for structured method logging.
 *
-* This function parses the function's string representation to extract
-* parameter names, handling TypeScript type annotations and default values.
+* When the target instance already has a `logger` property (i.e., satisfies
+* the {@link Loggable} interface), that logger is used directly. Otherwise,
+* a new `Logger` from `@nestjs/common` is created with `className` as its
+* context and assigned to `instance.logger`, so subsequent calls reuse it.
 *
-* @param func - The function to extract parameter names from
-* @returns Array of parameter names
-*
-* @example
-* function example(id: number, name: string = 'default') {}
-* getParameterNames(example) // Returns: ['id', 'name']
+* @param instance   - The class instance whose method is being logged
+* @param className  - The name of the class (used as Logger context if auto-injected)
+* @param methodName - The name of the method being logged
+* @param argsObject - Formatted arguments to include in the log entry
+* @returns A configured {@link LogWrapper} ready for invoked/success/error calls
 *
 * @internal
 */
-const getParameterNames = (func) => {
-	const match = func.toString().match(/\(([^)]*)\)/);
-	if (!match?.[1]) return [];
-	return match[1].split(",").map((param) => param.trim().split(/[=:]/)[0].trim()).filter((param) => param.length > 0);
-};
-/**
-* Handles execution of async methods with proper logging.
-* @internal
-*/
-const handleAsyncExecution = (result, logWrapper) => {
-	return result.then((value) => {
-		logWrapper.success();
-		return value;
-	}).catch((error) => {
-		logWrapper.error(error);
-		throw error;
-	});
+const createLogWrapper = (instance, className, methodName, argsObject) => {
+	if (!isLoggable(instance)) instance.logger = new _nestjs_common.Logger(className);
+	return new LogWrapper(instance.logger, methodName, argsObject);
 };
 
 //#endregion
@@ -203,23 +138,6 @@ const handleAsyncExecution = (result, logWrapper) => {
 */
 const NO_LOG_METADATA_KEY = Symbol("noLog");
 
-//#endregion
-//#region src/decorate/applyToClass.ts
-/**
-* Applies logging to all methods in a class.
-* @internal
-*/
-const applyToClass = (target, options) => {
-	Object.getOwnPropertyNames(target.prototype).forEach((propertyName) => {
-		if (propertyName === "constructor") return;
-		const descriptor = Object.getOwnPropertyDescriptor(target.prototype, propertyName);
-		if (!descriptor || typeof descriptor.value !== "function") return;
-		if (descriptor.value[NO_LOG_METADATA_KEY] === true) return;
-		applyToMethod(target.prototype, propertyName, descriptor, options);
-		Object.defineProperty(target.prototype, propertyName, descriptor);
-	});
-};
-
 //#endregion
 //#region src/log.decorator.ts
 /**
@@ -229,6 +147,7 @@ const applyToClass = (target, options) => {
 *
 * **Usage on Classes:**
 * When applied to a class, wraps all methods in the class with logging.
+* A `logger` property is auto-injected if not already defined.
 *
 * **Usage on Methods:**
 * When applied to a method, wraps only that specific method with logging.
@@ -238,13 +157,10 @@ const applyToClass = (target, options) => {
 * - Successful completion with arguments
 * - Errors with arguments and error details (Axios errors are automatically prettified)
 *
-* **Requirements:**
-* The class must have a `logger` property (typically a NestJS Logger instance).
-*
 * **Log Format:**
 * All logs are output as structured objects with the following format:
 * - Invocation: `{ method: string, state: 'invoked', args: Record<string, any> }` (only when `onInvoke: true`)
-* - Success: `{ method: string, state: 'success', args: Record<string, any> }`
+* - Success: `{ method: string, state: 'success', args: Record<string, any>, result?: unknown }`
 * - Error: `{ method: string, state: 'error', args: Record<string, any>, error: Error | PrettifiedAxiosError }`
 *
 * **Custom Argument Formatting:**
@@ -253,6 +169,11 @@ const applyToClass = (target, options) => {
 * - Logging only specific arguments
 * - Transforming sensitive data before logging
 *
+* **Result Logging:**
+* Use the `result` option to include successful return values in success logs.
+* - `result: true` logs the raw returned value
+* - `result: (value) => ...` logs a formatted value
+*
 * **Error Handling:**
 * - Axios errors are automatically prettified using `prettifyAxiosError` to provide structured error information
 * - Regular errors are logged as-is
@@ -265,11 +186,9 @@ const applyToClass = (target, options) => {
 * - Methods with no arguments
 *
 * @example
-* // Class-level usage - logs all methods
+* // Class-level usage - logs all methods, logger auto-injected
 * @Log()
 * class UserService {
-*   readonly logger = new Logger(UserService.name)
-*
 *   createUser(name: string, email: string) {
 *     return { id: 1, name, email }
 *   }
@@ -282,8 +201,6 @@ const applyToClass = (target, options) => {
 * @example
 * // Method-level usage - logs only specific method
 * class DataService {
-*   readonly logger = new Logger(DataService.name)
-*
 *   @Log({ onInvoke: true })
 *   async fetchData(id: number) {
 *     const data = await this.repository.findById(id)
@@ -295,8 +212,7 @@ const applyToClass = (target, options) => {
 *     return 'helper'
 *   }
 * }
-*
-* @example
+* 
 * // Error handling with regular errors
 * class PaymentService {
 *   readonly logger = new Logger(PaymentService.name)
@@ -342,17 +258,15 @@ const applyToClass = (target, options) => {
 * @example
 * // Custom argument formatting - exclude large objects from logs
 * class SyncService {
-*   readonly logger = new Logger(SyncService.name)
-*
 *   @Log({ args: (loanId: number) => ({ loanId }) })
-*   async syncLoan(loanId: number, loanData?: CloudbankinLoan) {
+*   async syncLoan(loanId: number, loanData?: unknown) {
 *     // loanData is excluded from logs due to large size
 *     // Only loanId will be logged
 *     return this.processLoan(loanId, loanData)
 *   }
-*
+* 
 *   @Log({ args: (loanId: number, transactionId: number) => ({ loanId, transactionId }) })
-*   async syncPayment(loanId: number, transactionId: number, loanData?: CloudbankinLoan) {
+*   async syncPayment(loanId: number, transactionId: number, loanData?: unknown) {
 *     // Only loanId and transactionId are logged, loanData is excluded
 *     return this.processPayment(loanId, transactionId, loanData)
 *   }
@@ -361,22 +275,26 @@ const applyToClass = (target, options) => {
 * // Logs output:
 * // [SyncService] { method: 'syncLoan', state: 'success', args: { loanId: 123 } }
 * // [SyncService] { method: 'syncPayment', state: 'success', args: { loanId: 123, transactionId: 456 } }
-*
+* 
 * @param options - Configuration options for the decorator
-* @throws {Error} If the logger property is not found in the class instance
-*
 * @returns Decorator function that can be applied to classes or methods
 */
-const Log = (options = {}) => {
-	return ((target, propertyKey, descriptor) => {
-		if (propertyKey === void 0) {
-			applyToClass(target, options);
-			return target;
+const Log = ({ onInvoke: shouldLogInvoke = false, args: formatArgs, result: formatResult } = {}) => (0, base_decorators.Effect)(({ args, argsObject, target, propertyKey, className }) => {
+	const formattedArgs = formatArgs ? formatArgs(...args) : argsObject;
+	const resultFormatter = typeof formatResult === "function" ? formatResult : (value) => value;
+	const logger = createLogWrapper(target, className, String(propertyKey), formattedArgs);
+	return {
+		onInvoke: shouldLogInvoke ? () => logger.invoked() : void 0,
+		onReturn: ({ result }) => {
+			logger.success(void 0, formatResult ? { result: resultFormatter(result) } : void 0);
+			return result;
+		},
+		onError: ({ error }) => {
+			logger.error(error);
+			throw error;
 		}
-		if (descriptor !== void 0) return applyToMethod(target, propertyKey, descriptor, options);
-		throw new Error("Log decorator can only be applied to classes or methods");
-	});
-};
+	};
+}, NO_LOG_METADATA_KEY);
 /**
 * Method decorator that prevents logging when used with class-level @Log()
 *
@@ -388,8 +306,6 @@ const Log = (options = {}) => {
 * @example
 * @Log()
 * class UserService {
-*   readonly logger = new Logger(UserService.name)
-*
 *   createUser(name: string) {
 *     // This will be logged
 *     return { name }
@@ -425,27 +341,23 @@ const Log = (options = {}) => {
 *     return 'helper'
 *   }
 * }
-*
+* 
 * @returns {MethodDecorator} The method decorator function
 */
-const NoLog = () => {
-	return (_target, _propertyKey, descriptor) => {
-		const value = descriptor.value;
-		value[NO_LOG_METADATA_KEY] = true;
-		return descriptor;
-	};
-};
+const NoLog = () => (0, base_decorators.SetMeta)(NO_LOG_METADATA_KEY, true);
+
+//#endregion
+//#region src/axios/isTimoutError.ts
+function isTimeoutError(error) {
+	return error.code === "ECONNABORTED" || error.code === "ETIMEDOUT";
+}
 
 //#endregion
 exports.Log = Log;
 exports.LogWrapper = LogWrapper;
 exports.NO_LOG_METADATA_KEY = NO_LOG_METADATA_KEY;
 exports.NoLog = NoLog;
-exports.applyToClass = applyToClass;
-exports.applyToMethod = applyToMethod;
-exports.buildArgsObject = buildArgsObject;
 exports.createLogWrapper = createLogWrapper;
-exports.getParameterNames = getParameterNames;
-exports.handleAsyncExecution = handleAsyncExecution;
 exports.isLoggable = isLoggable;
+exports.isTimeoutError = isTimeoutError;
 exports.prettifyAxiosError = prettifyAxiosError;

package/dist/index.d.cts

@@ -2,10 +2,11 @@ import { Logger } from "@nestjs/common";
 
 //#region src/types.d.ts
 type LogArgsFormatter<TArgs extends unknown[]> = (...args: TArgs) => string | number | Record<string, unknown> | undefined;
+type LogResultFormatter<TResult = unknown> = (result: TResult) => unknown;
 /**
  * Configuration options for the Log decorator.
  */
-interface LogOptions<TArgs extends unknown[] = unknown[]> {
+interface LogOptions<TArgs extends unknown[] = unknown[], TResult = unknown> {
   /**
    * When true, logs method invocation with arguments.
    * When false or not set, only logs success and error states.
@@ -28,6 +29,21 @@ interface LogOptions<TArgs extends unknown[] = unknown[]> {
    * @returns Formatted arguments as string, number, object, or undefined
    */
   args?: LogArgsFormatter<TArgs>;
+  /**
+   * Controls how successful method result is logged.
+   *
+   * - `true`: logs the returned result value as-is
+   * - formatter function: receives the method result and returns a formatted value
+   *
+   * @example
+   * // Log raw result
+   * @Log({ result: true })
+   *
+   * @example
+   * // Log only selected result fields
+   * @Log({ result: (res: { id: number; data: unknown }) => ({ id: res.id }) })
+   */
+  result?: true | LogResultFormatter<TResult>;
 }
 /**
  * Symbol used to mark methods that should not be logged
@@ -35,59 +51,23 @@ interface LogOptions<TArgs extends unknown[] = unknown[]> {
  */
 declare const NO_LOG_METADATA_KEY: unique symbol;
 //#endregion
-//#region src/LogWrapper.d.ts
-/**
- * Wrapper class for logging operations with consistent format.
- * @internal
- */
-declare class LogWrapper {
-  private readonly logger;
-  private readonly method;
-  private readonly args;
-  constructor(logger: Logger, method: string, args: string | number | Record<string, unknown> | undefined);
-  invoked(): void;
-  success(): void;
-  error(error: unknown): void;
-}
-/** If you see it, then you probably forgot to add `readonly logger = new Logger(YourClass.name)` to your class */
-interface Loggable {
-  logger: Logger;
-}
-declare const isLoggable: (instance: unknown) => instance is Loggable;
-/**
- * Creates a LogWrapper instance with validated logger and built args object.
- * @internal
- */
-declare const createLogWrapper: (instance: unknown, className: string, methodName: string, argsObject: string | number | Record<string, unknown> | undefined) => LogWrapper;
-/**
- * Builds an object mapping parameter names to their values.
- *
- * Creates a record where keys are parameter names and values are the
- * corresponding argument values passed to the function.
- *
- * @param parameterNames - Array of parameter names
- * @param args - Array of argument values
- * @returns Object mapping parameter names to values
- *
- * @example
- * buildArgsObject(['id', 'name'], [1, 'John'])
- * // Returns: { id: 1, name: 'John' }
- *
- * @internal
- */
-declare const buildArgsObject: (parameterNames: string[], args: unknown[]) => Record<string, unknown> | undefined;
-//#endregion
 //#region src/log.decorator.d.ts
-type LoggableConstructor = new (...args: any[]) => Loggable;
 /**
  * Decorator function that can be applied to classes or methods.
  * Uses overloads to provide type checking for class decorators while
  * keeping method decorators flexible.
  */
 interface LogDecorator {
-  /** Class decorator - enforces that class instances have a `logger` property */
-  <T extends LoggableConstructor>(target: T): T;
-  /** Method decorator - no compile-time constraint on `this` */
+  /**
+   * Class decorator - applies logging to all methods in the class.
+   * The class no longer needs to define a `logger` property; one will
+   * be auto-injected if missing.
+   */
+  <T extends new (...args: any[]) => unknown>(target: T): T;
+  /**
+   * Method decorator - no compile-time constraint on `this`.
+   * Wraps only the specific method with logging.
+   */
   (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor): PropertyDescriptor;
 }
 /**
@@ -97,6 +77,7 @@ interface LogDecorator {
  *
  * **Usage on Classes:**
  * When applied to a class, wraps all methods in the class with logging.
+ * A `logger` property is auto-injected if not already defined.
  *
  * **Usage on Methods:**
  * When applied to a method, wraps only that specific method with logging.
@@ -106,13 +87,10 @@ interface LogDecorator {
  * - Successful completion with arguments
  * - Errors with arguments and error details (Axios errors are automatically prettified)
  *
- * **Requirements:**
- * The class must have a `logger` property (typically a NestJS Logger instance).
- *
  * **Log Format:**
  * All logs are output as structured objects with the following format:
  * - Invocation: `{ method: string, state: 'invoked', args: Record<string, any> }` (only when `onInvoke: true`)
- * - Success: `{ method: string, state: 'success', args: Record<string, any> }`
+ * - Success: `{ method: string, state: 'success', args: Record<string, any>, result?: unknown }`
  * - Error: `{ method: string, state: 'error', args: Record<string, any>, error: Error | PrettifiedAxiosError }`
  *
  * **Custom Argument Formatting:**
@@ -121,6 +99,11 @@ interface LogDecorator {
  * - Logging only specific arguments
  * - Transforming sensitive data before logging
  *
+ * **Result Logging:**
+ * Use the `result` option to include successful return values in success logs.
+ * - `result: true` logs the raw returned value
+ * - `result: (value) => ...` logs a formatted value
+ *
  * **Error Handling:**
  * - Axios errors are automatically prettified using `prettifyAxiosError` to provide structured error information
  * - Regular errors are logged as-is
@@ -133,11 +116,9 @@ interface LogDecorator {
  * - Methods with no arguments
  *
  * @example
- * // Class-level usage - logs all methods
+ * // Class-level usage - logs all methods, logger auto-injected
  * @Log()
  * class UserService {
- *   readonly logger = new Logger(UserService.name)
- *
  *   createUser(name: string, email: string) {
  *     return { id: 1, name, email }
  *   }
@@ -150,8 +131,6 @@ interface LogDecorator {
  * @example
  * // Method-level usage - logs only specific method
  * class DataService {
- *   readonly logger = new Logger(DataService.name)
- *
  *   @Log({ onInvoke: true })
  *   async fetchData(id: number) {
  *     const data = await this.repository.findById(id)
@@ -164,7 +143,6 @@ interface LogDecorator {
  *   }
  * }
  *
- * @example
  * // Error handling with regular errors
  * class PaymentService {
  *   readonly logger = new Logger(PaymentService.name)
@@ -210,17 +188,15 @@ interface LogDecorator {
  * @example
  * // Custom argument formatting - exclude large objects from logs
  * class SyncService {
- *   readonly logger = new Logger(SyncService.name)
- *
  *   @Log({ args: (loanId: number) => ({ loanId }) })
- *   async syncLoan(loanId: number, loanData?: CloudbankinLoan) {
+ *   async syncLoan(loanId: number, loanData?: unknown) {
  *     // loanData is excluded from logs due to large size
  *     // Only loanId will be logged
  *     return this.processLoan(loanId, loanData)
  *   }
  *
  *   @Log({ args: (loanId: number, transactionId: number) => ({ loanId, transactionId }) })
- *   async syncPayment(loanId: number, transactionId: number, loanData?: CloudbankinLoan) {
+ *   async syncPayment(loanId: number, transactionId: number, loanData?: unknown) {
  *     // Only loanId and transactionId are logged, loanData is excluded
  *     return this.processPayment(loanId, transactionId, loanData)
  *   }
@@ -231,11 +207,13 @@ interface LogDecorator {
  * // [SyncService] { method: 'syncPayment', state: 'success', args: { loanId: 123, transactionId: 456 } }
  *
  * @param options - Configuration options for the decorator
- * @throws {Error} If the logger property is not found in the class instance
- *
  * @returns Decorator function that can be applied to classes or methods
  */
-declare const Log: <TArgs extends unknown[]>(options?: LogOptions<TArgs>) => LogDecorator;
+declare const Log: <TArgs extends unknown[], TResult = unknown>({
+  onInvoke: shouldLogInvoke,
+  args: formatArgs,
+  result: formatResult
+}?: LogOptions<TArgs, TResult>) => LogDecorator;
 /**
  * Method decorator that prevents logging when used with class-level @Log()
  *
@@ -247,8 +225,6 @@ declare const Log: <TArgs extends unknown[]>(options?: LogOptions<TArgs>) => Log
  * @example
  * @Log()
  * class UserService {
- *   readonly logger = new Logger(UserService.name)
- *
  *   createUser(name: string) {
  *     // This will be logged
  *     return { name }
@@ -287,51 +263,91 @@ declare const Log: <TArgs extends unknown[]>(options?: LogOptions<TArgs>) => Log
  *
  * @returns {MethodDecorator} The method decorator function
  */
-declare const NoLog: () => (_target: unknown, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+declare const NoLog: () => MethodDecorator;
 //#endregion
-//#region src/axios/axios.logger.d.ts
-declare function prettifyAxiosError(error: unknown): unknown;
-//#endregion
-//#region src/decorate/applyToMethod.d.ts
-type MethodFunction = (...args: unknown[]) => unknown;
+//#region src/LogWrapper.d.ts
 /**
- * Applies logging to a single method.
+ * Wrapper class for logging operations with consistent format.
  * @internal
  */
-declare const applyToMethod: (target: object, propertyKey: string, descriptor: PropertyDescriptor, {
-  onInvoke: shouldLogInvoke,
-  args: formatArgs
-}?: LogOptions) => PropertyDescriptor;
+declare class LogWrapper {
+  private readonly logger;
+  private readonly method;
+  private readonly args;
+  constructor(logger: Logger, method: string, args: string | number | Record<string, unknown> | undefined);
+  invoked(message?: string): void;
+  success(message?: string, additionalFields?: Record<string, unknown>): void;
+  error(error: unknown, message?: string): void;
+}
 /**
- * Extracts parameter names from a function signature.
+ * Interface for classes that expose a NestJS Logger instance.
  *
- * This function parses the function's string representation to extract
- * parameter names, handling TypeScript type annotations and default values.
+ * Implementing this interface is optional when using the `@Log()` decorator.
+ * If a class does not define a `logger` property, the decorator will
+ * automatically inject a `new Logger(ClassName)` instance at runtime.
  *
- * @param func - The function to extract parameter names from
- * @returns Array of parameter names
- *
- * @example
- * function example(id: number, name: string = 'default') {}
- * getParameterNames(example) // Returns: ['id', 'name']
- *
- * @internal
+ * You may still implement this interface explicitly to provide a custom logger
+ * (e.g., a mock for testing, or a logger with a non-default context).
  */
-declare const getParameterNames: (func: MethodFunction) => string[];
+interface Loggable {
+  logger: Logger;
+}
+declare const isLoggable: (instance: unknown) => instance is Loggable;
 /**
- * Handles execution of async methods with proper logging.
+ * Creates a LogWrapper instance for structured method logging.
+ *
+ * When the target instance already has a `logger` property (i.e., satisfies
+ * the {@link Loggable} interface), that logger is used directly. Otherwise,
+ * a new `Logger` from `@nestjs/common` is created with `className` as its
+ * context and assigned to `instance.logger`, so subsequent calls reuse it.
+ *
+ * @param instance   - The class instance whose method is being logged
+ * @param className  - The name of the class (used as Logger context if auto-injected)
+ * @param methodName - The name of the method being logged
+ * @param argsObject - Formatted arguments to include in the log entry
+ * @returns A configured {@link LogWrapper} ready for invoked/success/error calls
+ *
  * @internal
  */
-declare const handleAsyncExecution: (result: Promise<unknown>, logWrapper: LogWrapper) => Promise<unknown>;
+declare const createLogWrapper: (instance: unknown, className: string, methodName: string, argsObject: string | number | Record<string, unknown> | undefined) => LogWrapper;
 //#endregion
-//#region src/decorate/applyToClass.d.ts
-interface Constructor {
-  prototype: Record<string, unknown>;
-}
+//#region src/axios/axios.logger.d.ts
+declare function prettifyAxiosError(error: unknown): unknown;
+//#endregion
+//#region src/axios/axios.stub.d.ts
 /**
- * Applies logging to all methods in a class.
- * @internal
- */
-declare const applyToClass: (target: Constructor, options: LogOptions) => void;
+ * Stub for axios types and utils, to avoid ading axios as a dependency
+ *
+ * Please avoid adding business logic to this file.
+ * */
+interface AxiosError extends Error {
+  name: string;
+  message: string;
+  stack?: string;
+  isAxiosError: true;
+  config: AxiosRequestConfig;
+  response: AxiosResponse;
+  code?: string;
+  request?: any;
+  status?: number;
+}
+interface AxiosRequestConfig {
+  url?: string;
+  method?: string;
+  baseURL?: string;
+  path?: string;
+  headers?: unknown;
+  data?: unknown;
+  params?: unknown;
+}
+interface AxiosResponse {
+  status: number;
+  statusText: string;
+  data: unknown;
+  headers: unknown;
+}
+//#endregion
+//#region src/axios/isTimoutError.d.ts
+declare function isTimeoutError(error: AxiosError): boolean;
 //#endregion
-export { Log, LogArgsFormatter, LogOptions, LogWrapper, Loggable, NO_LOG_METADATA_KEY, NoLog, applyToClass, applyToMethod, buildArgsObject, createLogWrapper, getParameterNames, handleAsyncExecution, isLoggable, prettifyAxiosError };
+export { Log, LogArgsFormatter, LogOptions, LogResultFormatter, LogWrapper, Loggable, NO_LOG_METADATA_KEY, NoLog, createLogWrapper, isLoggable, isTimeoutError, prettifyAxiosError };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "nestjs-log-decorator",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Decorator that removes try catch boilerplate logging from NestJS service methods",
-  "author": "Vlad Goncharov <leovs010@gmail.com>",
+  "author": "Vlad Goncharov <vlad.goncharov@neolab.com>",
   "license": "AGPL-3.0",
   "homepage": "https://github.com/NeoLabHQ/nestjs-log-decorator#readme",
   "repository": {
@@ -24,13 +24,18 @@
   "scripts": {
     "build": "tsdown",
     "build:watch": "tsdown --watch",
-    "dev": "concurrently -c auto --names build,test npm:build:watch npm:test",
-    "test": "vitest",
+    "dev": "concurrently -c auto --names build,test npm:build:watch npm:test:watch",
+    "lint": "npm run typecheck",
+    "test": "vitest --run",
+    "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",
     "commit": "cz help",
     "cz": "git add . && cz"
   },
+  "dependencies": {
+    "base-decorators": "^0.1.1"
+  },
   "devDependencies": {
     "@semantic-release/git": "^10.0.1",
     "@types/node": "^25.0.3",
@@ -49,5 +54,14 @@
     "commitizen": {
       "path": "./node_modules/cz-conventional-changelog"
     }
-  }
+  },
+  "keywords": [
+    "decorator",
+    "decorators",
+    "library",
+    "nestjs",
+    "typescript",
+    "utility",
+    "logger"
+  ]
 }