@buenojs/bueno 0.8.4 → 0.8.6

package/src/modules/interceptors.ts

@@ -16,8 +16,8 @@
  * - Add headers or modify request/response
  */
 
-import type { Context } from "../context";
 import type { Token } from "../container";
+import type { Context } from "../context";
 
 // ============= Types =============
 
@@ -72,7 +72,7 @@ export interface NestInterceptor<T = unknown, R = unknown> {
  */
 export type InterceptorFn = (
 	context: Context,
-	next: () => Promise<unknown>
+	next: () => Promise<unknown>,
 ) => Promise<unknown> | unknown;
 
 /**
@@ -81,7 +81,10 @@ export type InterceptorFn = (
  * - An interceptor class instance
  * - An interceptor function
  */
-export type Interceptor = Token<NestInterceptor> | NestInterceptor | InterceptorFn;
+export type Interceptor =
+	| Token<NestInterceptor>
+	| NestInterceptor
+	| InterceptorFn;
 
 // ============= Metadata Storage =============
 
@@ -92,19 +95,27 @@ type Constructor = new (...args: unknown[]) => unknown;
 const interceptorsClassMetadata = new WeakMap<Constructor, Interceptor[]>();
 
 // WeakMap for storing interceptors metadata on method prototypes
-const interceptorsMethodMetadata = new WeakMap<object, Map<string | symbol, Interceptor[]>>();
+const interceptorsMethodMetadata = new WeakMap<
+	object,
+	Map<string | symbol, Interceptor[]>
+>();
 
 /**
  * Set interceptors on a class constructor
  */
-function setClassInterceptors(target: Constructor, interceptors: Interceptor[]): void {
+function setClassInterceptors(
+	target: Constructor,
+	interceptors: Interceptor[],
+): void {
 	interceptorsClassMetadata.set(target, interceptors);
 }
 
 /**
  * Get interceptors from a class constructor
  */
-export function getClassInterceptors(target: Constructor): Interceptor[] | undefined {
+export function getClassInterceptors(
+	target: Constructor,
+): Interceptor[] | undefined {
 	return interceptorsClassMetadata.get(target);
 }
 
@@ -153,7 +164,9 @@ export function getMethodInterceptors(
  * }
  * ```
  */
-export function UseInterceptors(...interceptors: Interceptor[]): MethodDecorator & ClassDecorator {
+export function UseInterceptors(
+	...interceptors: Interceptor[]
+): MethodDecorator & ClassDecorator {
 	const decorator = (
 		target: unknown,
 		propertyKey?: string | symbol,
@@ -162,14 +175,21 @@ export function UseInterceptors(...interceptors: Interceptor[]): MethodDecorator
 		if (propertyKey !== undefined && descriptor !== undefined) {
 			// Method decorator
 			const targetObj = target as object;
-			const existingInterceptors = getMethodInterceptors(targetObj, propertyKey) ?? [];
-			setMethodInterceptors(targetObj, propertyKey, [...existingInterceptors, ...interceptors]);
+			const existingInterceptors =
+				getMethodInterceptors(targetObj, propertyKey) ?? [];
+			setMethodInterceptors(targetObj, propertyKey, [
+				...existingInterceptors,
+				...interceptors,
+			]);
 			return descriptor;
 		} else {
 			// Class decorator
 			const targetClass = target as Constructor;
 			const existingInterceptors = getClassInterceptors(targetClass) ?? [];
-			setClassInterceptors(targetClass, [...existingInterceptors, ...interceptors]);
+			setClassInterceptors(targetClass, [
+				...existingInterceptors,
+				...interceptors,
+			]);
 		}
 	};
 	return decorator as MethodDecorator & ClassDecorator;
@@ -235,8 +255,13 @@ export interface TransformResponse<T> {
  * // Response: { data: [{ id: 1, name: 'John' }], timestamp: '2024-01-15T10:30:00.000Z' }
  * ```
  */
-export class TransformInterceptor<T = unknown> implements NestInterceptor<T, TransformResponse<T>> {
-	async intercept(context: Context, next: CallHandler<T>): Promise<TransformResponse<T>> {
+export class TransformInterceptor<T = unknown>
+	implements NestInterceptor<T, TransformResponse<T>>
+{
+	async intercept(
+		context: Context,
+		next: CallHandler<T>,
+	): Promise<TransformResponse<T>> {
 		const result = await next.handle();
 		return {
 			data: result,
@@ -298,7 +323,7 @@ export class CacheInterceptor implements NestInterceptor {
 	private static cache = new Map<string, CacheEntry>();
 	private static cleanupInterval: Timer | null = null;
 
-	constructor(private ttlMs: number = 60000) {
+	constructor(private ttlMs = 60000) {
 		// Setup periodic cleanup of expired entries
 		CacheInterceptor.setupCleanup();
 	}
@@ -410,7 +435,9 @@ export interface InterceptorExecutorOptions {
 	/** Interceptors from method */
 	methodInterceptors?: Interceptor[];
 	/** Container for resolving interceptor instances */
-	resolveInterceptor?: (interceptor: Interceptor) => NestInterceptor | InterceptorFn | null;
+	resolveInterceptor?: (
+		interceptor: Interceptor,
+	) => NestInterceptor | InterceptorFn | null;
 }
 
 /**
@@ -420,7 +447,9 @@ function createCallHandler(
 	interceptors: Array<NestInterceptor | InterceptorFn>,
 	context: Context,
 	finalHandler: () => Promise<unknown>,
-	resolveInterceptor?: (interceptor: Interceptor) => NestInterceptor | InterceptorFn | null,
+	resolveInterceptor?: (
+		interceptor: Interceptor,
+	) => NestInterceptor | InterceptorFn | null,
 ): CallHandler {
 	let index = 0;
 
@@ -430,10 +459,15 @@ function createCallHandler(
 		}
 
 		const interceptor = interceptors[index++];
-		let interceptorInstance: NestInterceptor | InterceptorFn | null = interceptor;
+		let interceptorInstance: NestInterceptor | InterceptorFn | null =
+			interceptor;
 
 		// Resolve if needed
-		if (resolveInterceptor && !isNestInterceptor(interceptor) && !isInterceptorFn(interceptor)) {
+		if (
+			resolveInterceptor &&
+			!isNestInterceptor(interceptor) &&
+			!isInterceptorFn(interceptor)
+		) {
 			interceptorInstance = resolveInterceptor(interceptor);
 		}
 
@@ -502,7 +536,10 @@ export async function executeInterceptors(
 		// Resolve the interceptor
 		if (typeof interceptor === "function") {
 			// Check if it's an interceptor function or a class constructor
-			const funcInterceptor = interceptor as { prototype?: unknown; intercept?: unknown };
+			const funcInterceptor = interceptor as {
+				prototype?: unknown;
+				intercept?: unknown;
+			};
 			if (
 				funcInterceptor.prototype &&
 				typeof funcInterceptor.prototype === "object" &&
@@ -512,7 +549,8 @@ export async function executeInterceptors(
 				instance = resolveInterceptor ? resolveInterceptor(interceptor) : null;
 				if (!instance) {
 					// Create a new instance if not in container
-					const InterceptorClass = interceptor as unknown as new () => NestInterceptor;
+					const InterceptorClass =
+						interceptor as unknown as new () => NestInterceptor;
 					instance = new InterceptorClass();
 				}
 			} else {
@@ -571,4 +609,4 @@ export function isNestInterceptor(value: unknown): value is NestInterceptor {
  */
 export function isInterceptorFn(value: unknown): value is InterceptorFn {
 	return typeof value === "function" && !isNestInterceptor(value);
-}
+}

package/src/modules/lazy.ts

@@ -5,9 +5,9 @@
  * and reduced memory usage for large applications.
  */
 
-import type { Container, Token, Provider } from "../container";
-import { Injectable } from "./metadata";
+import type { Container, Provider, Token } from "../container";
 import { Inject } from "./index";
+import { Injectable } from "./metadata";
 
 // ============= Types =============
 
@@ -166,7 +166,9 @@ export function LazyModule(loader: ModuleLoaderFn): ClassDecorator {
 /**
  * Token for the ModuleLoader service
  */
-export const MODULE_LOADER_TOKEN = Symbol.for("ModuleLoader") as Token<ModuleLoader>;
+export const MODULE_LOADER_TOKEN = Symbol.for(
+	"ModuleLoader",
+) as Token<ModuleLoader>;
 
 /**
  * Options for loading lazy modules
@@ -200,9 +202,7 @@ export class ModuleLoader {
 	private container: Container;
 	private loadedModules = new Set<Constructor>();
 	private moduleLoaders = new Map<Constructor, LazyModuleLoaderImpl>();
-	private onModuleLoadCallback?: (
-		moduleClass: Constructor,
-	) => Promise<void>;
+	private onModuleLoadCallback?: (moduleClass: Constructor) => Promise<void>;
 
 	constructor(container: Container) {
 		this.container = container;
@@ -230,9 +230,7 @@ export class ModuleLoader {
 	): Promise<void> {
 		// Normalize to Constructor if it's a token
 		const moduleClass =
-			typeof moduleToken === "function"
-				? (moduleToken as Constructor)
-				: null;
+			typeof moduleToken === "function" ? (moduleToken as Constructor) : null;
 
 		if (!moduleClass) {
 			throw new Error("Module token must be a class constructor");
@@ -385,9 +383,7 @@ export function createLazyLoader(
 		const module = await importFn();
 		const moduleClass = module[exportName] as Constructor;
 		if (!moduleClass) {
-			throw new Error(
-				`Export "${exportName}" not found in lazy loaded module`,
-			);
+			throw new Error(`Export "${exportName}" not found in lazy loaded module`);
 		}
 		return moduleClass;
 	};
@@ -396,9 +392,7 @@ export function createLazyLoader(
 /**
  * Check if all lazy modules in a list are loaded
  */
-export function areAllLazyModulesLoaded(
-	modules: Constructor[],
-): boolean {
+export function areAllLazyModulesLoaded(modules: Constructor[]): boolean {
 	return modules.every((module) => {
 		const metadata = getLazyMetadata(module);
 		return !metadata || metadata.loaded;
@@ -408,11 +402,9 @@ export function areAllLazyModulesLoaded(
 /**
  * Get list of unloaded lazy modules
  */
-export function getUnloadedLazyModules(
-	modules: Constructor[],
-): Constructor[] {
+export function getUnloadedLazyModules(modules: Constructor[]): Constructor[] {
 	return modules.filter((module) => {
 		const metadata = getLazyMetadata(module);
 		return metadata && !metadata.loaded;
 	});
-}
+}

package/src/modules/lifecycle.ts

@@ -104,7 +104,9 @@ export function isOnApplicationBootstrap(
 /**
  * Check if an instance implements OnModuleDestroy
  */
-export function isOnModuleDestroy(instance: unknown): instance is OnModuleDestroy {
+export function isOnModuleDestroy(
+	instance: unknown,
+): instance is OnModuleDestroy {
 	return (
 		typeof instance === "object" &&
 		instance !== null &&
@@ -123,8 +125,8 @@ export function isBeforeApplicationShutdown(
 		typeof instance === "object" &&
 		instance !== null &&
 		"beforeApplicationShutdown" in instance &&
-		typeof (instance as BeforeApplicationShutdown)
-			.beforeApplicationShutdown === "function"
+		typeof (instance as BeforeApplicationShutdown).beforeApplicationShutdown ===
+			"function"
 	);
 }
 
@@ -146,7 +148,9 @@ export function isOnApplicationShutdown(
 /**
  * Check if an instance implements OnBeforeRequest
  */
-export function isOnBeforeRequest(instance: unknown): instance is OnBeforeRequest {
+export function isOnBeforeRequest(
+	instance: unknown,
+): instance is OnBeforeRequest {
 	return (
 		typeof instance === "object" &&
 		instance !== null &&
@@ -158,7 +162,9 @@ export function isOnBeforeRequest(instance: unknown): instance is OnBeforeReques
 /**
  * Check if an instance implements OnAfterRequest
  */
-export function isOnAfterRequest(instance: unknown): instance is OnAfterRequest {
+export function isOnAfterRequest(
+	instance: unknown,
+): instance is OnAfterRequest {
 	return (
 		typeof instance === "object" &&
 		instance !== null &&
@@ -170,7 +176,9 @@ export function isOnAfterRequest(instance: unknown): instance is OnAfterRequest
 /**
  * Check if an instance implements OnRequestError
  */
-export function isOnRequestError(instance: unknown): instance is OnRequestError {
+export function isOnRequestError(
+	instance: unknown,
+): instance is OnRequestError {
 	return (
 		typeof instance === "object" &&
 		instance !== null &&
@@ -475,4 +483,4 @@ export interface RequestLifecycle
 /**
  * Combined interface for all lifecycle hooks.
  */
-export interface FullLifecycle extends ApplicationLifecycle, RequestLifecycle {}
+export interface FullLifecycle extends ApplicationLifecycle, RequestLifecycle {}

package/src/modules/metadata.ts

@@ -5,7 +5,7 @@
  * This module has no dependencies on other module files.
  */
 
-import type { Token, Provider } from "../container";
+import type { Provider, Token } from "../container";
 
 // Type alias for class constructors
 type Constructor = new (...args: unknown[]) => unknown;
@@ -24,14 +24,21 @@ export interface ModuleMetadata {
 // Simple metadata storage without Reflect.metadata
 const metadataStore = new WeakMap<Constructor, Map<string, unknown>>();
 
-export function setMetadata(target: Constructor, key: string, value: unknown): void {
+export function setMetadata(
+	target: Constructor,
+	key: string,
+	value: unknown,
+): void {
 	if (!metadataStore.has(target)) {
 		metadataStore.set(target, new Map());
 	}
 	metadataStore.get(target)?.set(key, value);
 }
 
-export function getMetadata<T>(target: Constructor, key: string): T | undefined {
+export function getMetadata<T>(
+	target: Constructor,
+	key: string,
+): T | undefined {
 	return metadataStore.get(target)?.get(key) as T | undefined;
 }
 
@@ -49,7 +56,10 @@ export function setPrototypeMetadata(
 	prototypeMetadataStore.get(target)?.set(key, value);
 }
 
-export function getPrototypeMetadata<T>(target: object, key: string): T | undefined {
+export function getPrototypeMetadata<T>(
+	target: object,
+	key: string,
+): T | undefined {
 	return prototypeMetadataStore.get(target)?.get(key) as T | undefined;
 }
 
@@ -87,4 +97,4 @@ export function Module(metadata: ModuleMetadata): ClassDecorator {
 }
 
 // Export the Constructor type for use in other modules
-export type { Constructor };
+export type { Constructor };