@buenojs/bueno 0.8.4 → 0.8.5

package/src/config/validation.ts

@@ -3,7 +3,7 @@
  * Supports Standard Schema validators (Zod, Valibot, ArkType)
  */
 
-import type { StandardSchema, StandardIssue } from "../types";
+import type { StandardIssue, StandardSchema } from "../types";
 import type { BuenoConfig, DeepPartial } from "./types";
 
 /**
@@ -142,10 +142,16 @@ const DEFAULT_RULES: ValidationRule[] = [
 		validate: (value) => {
 			if (value === undefined) return { valid: true };
 			if (typeof value !== "number") {
-				return { valid: false, message: "Slow query threshold must be a number" };
+				return {
+					valid: false,
+					message: "Slow query threshold must be a number",
+				};
 			}
 			if (value < 0) {
-				return { valid: false, message: "Slow query threshold must be non-negative" };
+				return {
+					valid: false,
+					message: "Slow query threshold must be non-negative",
+				};
 			}
 			return { valid: true };
 		},
@@ -215,7 +221,203 @@ const DEFAULT_RULES: ValidationRule[] = [
 				return { valid: false, message: "Collect interval must be a number" };
 			}
 			if (value < 0) {
-				return { valid: false, message: "Collect interval must be non-negative" };
+				return {
+					valid: false,
+					message: "Collect interval must be non-negative",
+				};
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "jobs.driver",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			if (value !== "redis" && value !== "memory") {
+				return {
+					valid: false,
+					message: 'Jobs driver must be "redis" or "memory"',
+					expected: '"redis" | "memory"',
+					received: value,
+				};
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "jobs.concurrency",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			if (typeof value !== "number") {
+				return { valid: false, message: "Concurrency must be a number" };
+			}
+			if (value < 1) {
+				return { valid: false, message: "Concurrency must be at least 1" };
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "jobs.maxRetries",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			if (typeof value !== "number") {
+				return { valid: false, message: "Max retries must be a number" };
+			}
+			if (value < 0) {
+				return { valid: false, message: "Max retries must be non-negative" };
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "jobs.retryDelay",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			if (typeof value !== "number") {
+				return { valid: false, message: "Retry delay must be a number" };
+			}
+			if (value < 0) {
+				return { valid: false, message: "Retry delay must be non-negative" };
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "jobs.batchSize",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			if (typeof value !== "number") {
+				return { valid: false, message: "Batch size must be a number" };
+			}
+			if (value < 1) {
+				return { valid: false, message: "Batch size must be at least 1" };
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "jobs.pollInterval",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			if (typeof value !== "number") {
+				return { valid: false, message: "Poll interval must be a number" };
+			}
+			if (value < 100) {
+				return {
+					valid: false,
+					message: "Poll interval must be at least 100ms",
+				};
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "jobs.jobTimeout",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			if (typeof value !== "number") {
+				return { valid: false, message: "Job timeout must be a number" };
+			}
+			if (value < 1000) {
+				return { valid: false, message: "Job timeout must be at least 1000ms" };
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "notification.email.driver",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			const validDrivers = ["smtp", "sendgrid", "brevo", "resend"];
+			if (!validDrivers.includes(value as string)) {
+				return {
+					valid: false,
+					message: `Email driver must be one of: ${validDrivers.join(", ")}`,
+					expected: validDrivers.join(" | "),
+					received: value,
+				};
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "notification.email.from",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			if (typeof value !== "string") {
+				return { valid: false, message: "From email must be a string" };
+			}
+			if (!value.includes("@")) {
+				return {
+					valid: false,
+					message: "From email must be a valid email address",
+					received: value,
+				};
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "notification.email.smtp.port",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			if (typeof value !== "number") {
+				return { valid: false, message: "SMTP port must be a number" };
+			}
+			if (value < 1 || value > 65535) {
+				return {
+					valid: false,
+					message: "SMTP port must be between 1 and 65535",
+				};
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "notification.sms.driver",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			const validDrivers = ["twilio", "aws-sns", "custom"];
+			if (!validDrivers.includes(value as string)) {
+				return {
+					valid: false,
+					message: `SMS driver must be one of: ${validDrivers.join(", ")}`,
+					expected: validDrivers.join(" | "),
+					received: value,
+				};
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "notification.whatsapp.driver",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			const validDrivers = ["twilio", "custom"];
+			if (!validDrivers.includes(value as string)) {
+				return {
+					valid: false,
+					message: `WhatsApp driver must be one of: ${validDrivers.join(", ")}`,
+					expected: validDrivers.join(" | "),
+					received: value,
+				};
+			}
+			return { valid: true };
+		},
+	},
+	{
+		path: "notification.push.driver",
+		validate: (value) => {
+			if (value === undefined) return { valid: true };
+			const validDrivers = ["firebase", "apns", "custom"];
+			if (!validDrivers.includes(value as string)) {
+				return {
+					valid: false,
+					message: `Push driver must be one of: ${validDrivers.join(", ")}`,
+					expected: validDrivers.join(" | "),
+					received: value,
+				};
 			}
 			return { valid: true };
 		},
@@ -296,7 +498,11 @@ export function validateConfigDefaults(
 		});
 	}
 
-	if (config.cache?.driver === "redis" && !config.cache.url && !process.env.REDIS_URL) {
+	if (
+		config.cache?.driver === "redis" &&
+		!config.cache.url &&
+		!process.env.REDIS_URL
+	) {
 		warnings.push({
 			message: "Redis cache driver selected but no Redis URL configured",
 			path: "cache.url",
@@ -404,7 +610,9 @@ export async function assertValidConfig<T extends BuenoConfig = BuenoConfig>(
 	// Log warnings
 	if (result.warnings.length > 0) {
 		for (const warning of result.warnings) {
-			console.warn(`Config warning: ${warning.message}${warning.path ? ` (at ${warning.path})` : ""}`);
+			console.warn(
+				`Config warning: ${warning.message}${warning.path ? ` (at ${warning.path})` : ""}`,
+			);
 		}
 	}
 }
@@ -438,4 +646,4 @@ export function createCustomValidator(
 			warnings: [],
 		};
 	};
-}
+}

package/src/container/forward-ref.ts

@@ -8,14 +8,14 @@
 
 /**
  * Forward reference container for lazy resolution of circular dependencies.
- * 
+ *
  * @template T - The type of the referenced value
- * 
+ *
  * @example
  * ```typescript
  * // Creating a forward reference
  * const ref = forwardRef(() => ServiceB);
- * 
+ *
  * // Using with @Inject decorator
  * @Injectable()
  * class ServiceA {
@@ -31,7 +31,7 @@ export interface ForwardRef<T> {
 	 * The unique symbol identifying this as a ForwardRef
 	 */
 	readonly __forwardRef: unique symbol;
-	
+
 	/**
 	 * Factory function that returns the actual value when called.
 	 * This is invoked lazily when the dependency is first accessed.
@@ -42,19 +42,19 @@ export interface ForwardRef<T> {
 /**
  * Symbol used to identify ForwardRef objects
  */
-const FORWARD_REF_SYMBOL = Symbol.for('buno.forwardRef');
+const FORWARD_REF_SYMBOL = Symbol.for("buno.forwardRef");
 
 /**
  * Create a forward reference for circular dependency resolution.
- * 
+ *
  * The provided factory function is called lazily when the dependency
  * is actually resolved, allowing the referenced class to be defined
  * later in the module loading process.
- * 
+ *
  * @template T - The type of the referenced value
  * @param fn - Factory function that returns the actual token or value
  * @returns A ForwardRef object that can be used with @Inject()
- * 
+ *
  * @example
  * ```typescript
  * // service-a.ts
@@ -64,12 +64,12 @@ const FORWARD_REF_SYMBOL = Symbol.for('buno.forwardRef');
  *     @Inject(forwardRef(() => ServiceB))
  *     private serviceB: ServiceB
  *   ) {}
- *   
+ *
  *   doSomething() {
  *     return this.serviceB.help();
  *   }
  * }
- * 
+ *
  * // service-b.ts
  * @Injectable()
  * export class ServiceB {
@@ -77,7 +77,7 @@ const FORWARD_REF_SYMBOL = Symbol.for('buno.forwardRef');
  *     @Inject(forwardRef(() => ServiceA))
  *     private serviceA: ServiceA
  *   ) {}
- *   
+ *
  *   help() {
  *     return 'helping';
  *   }
@@ -93,10 +93,10 @@ export function forwardRef<T>(fn: () => T): ForwardRef<T> {
 
 /**
  * Type guard to check if a value is a ForwardRef.
- * 
+ *
  * @param value - The value to check
  * @returns True if the value is a ForwardRef, false otherwise
- * 
+ *
  * @example
  * ```typescript
  * const ref = forwardRef(() => MyService);
@@ -107,30 +107,30 @@ export function forwardRef<T>(fn: () => T): ForwardRef<T> {
  */
 export function isForwardRef(value: unknown): value is ForwardRef<unknown> {
 	return (
-		typeof value === 'object' &&
+		typeof value === "object" &&
 		value !== null &&
-		'__forwardRef' in value &&
-		'forwardRef' in value &&
-		typeof (value as ForwardRef<unknown>).forwardRef === 'function'
+		"__forwardRef" in value &&
+		"forwardRef" in value &&
+		typeof (value as ForwardRef<unknown>).forwardRef === "function"
 	);
 }
 
 /**
  * Resolve a forward reference to its actual value.
- * 
+ *
  * If the provided value is a ForwardRef, this function calls its
  * factory function to get the actual value. If it's not a ForwardRef,
  * the value is returned as-is.
- * 
+ *
  * @template T - The expected type of the resolved value
  * @param ref - Either a ForwardRef or a direct value
  * @returns The resolved value
- * 
+ *
  * @example
  * ```typescript
  * const token = Token<ServiceB>('ServiceB');
  * const ref = forwardRef(() => token);
- * 
+ *
  * // Resolves to the token
  * const actualToken = resolveForwardRef(ref);
  * ```
@@ -140,4 +140,4 @@ export function resolveForwardRef<T>(ref: ForwardRef<T> | T): T {
 		return ref.forwardRef();
 	}
 	return ref;
-}
+}

package/src/container/index.ts

@@ -51,7 +51,10 @@ class ResolutionStack {
 	 * Track tokens that are being lazily resolved for circular dependencies.
 	 * These tokens have a proxy placeholder that will be resolved later.
 	 */
-	private lazyResolutions = new Map<Token, { resolved: boolean; instance?: unknown }>();
+	private lazyResolutions = new Map<
+		Token,
+		{ resolved: boolean; instance?: unknown }
+	>();
 
 	push(token: Token): void {
 		if (this.stack.has(token)) {
@@ -73,7 +76,10 @@ class ResolutionStack {
 	/**
 	 * Mark a token as being lazily resolved (for circular dependency support)
 	 */
-	markLazy(token: Token, placeholder: { resolved: boolean; instance?: unknown }): void {
+	markLazy(
+		token: Token,
+		placeholder: { resolved: boolean; instance?: unknown },
+	): void {
 		this.lazyResolutions.set(token, placeholder);
 	}
 
@@ -201,8 +207,12 @@ export class Container {
 			get: (target: T, prop: string | symbol): unknown => {
 				// If already resolved, return the cached value
 				if (placeholder.resolved && placeholder.instance) {
-					const value = (placeholder.instance as Record<string | symbol, unknown>)[prop];
-					return typeof value === 'function' ? value.bind(placeholder.instance) : value;
+					const value = (
+						placeholder.instance as Record<string | symbol, unknown>
+					)[prop];
+					return typeof value === "function"
+						? value.bind(placeholder.instance)
+						: value;
 				}
 
 				// Resolve the actual instance
@@ -215,7 +225,7 @@ export class Container {
 					// If not yet cached, we need to wait for the resolution to complete
 					// This happens when the proxy is accessed during construction
 					// Return a function that will resolve later
-					if (prop === 'then') {
+					if (prop === "then") {
 						// Make the proxy thenable for async contexts
 						return undefined;
 					}
@@ -223,22 +233,27 @@ export class Container {
 
 				// Try to get the value from the resolved instance
 				if (placeholder.instance) {
-					const value = (placeholder.instance as Record<string | symbol, unknown>)[prop];
-					return typeof value === 'function' ? value.bind(placeholder.instance) : value;
+					const value = (
+						placeholder.instance as Record<string | symbol, unknown>
+					)[prop];
+					return typeof value === "function"
+						? value.bind(placeholder.instance)
+						: value;
 				}
 
 				// Return a no-op function for method calls during construction
 				return () => undefined;
 			},
-			
+
 			set: (target: T, prop: string | symbol, value: unknown): boolean => {
 				if (placeholder.instance) {
-					(placeholder.instance as Record<string | symbol, unknown>)[prop] = value;
+					(placeholder.instance as Record<string | symbol, unknown>)[prop] =
+						value;
 					return true;
 				}
 				return false;
 			},
-			
+
 			has: (target: T, prop: string | symbol): boolean => {
 				if (placeholder.instance) {
 					return prop in (placeholder.instance as object);
@@ -376,11 +391,18 @@ export function Inject(token: Token | ForwardRef<Token>): ParameterDecorator {
 	) => {
 		const targetObj = target as object;
 		const existingTokens: Array<Token | ForwardRef<Token>> =
-			getContainerMetadata<Array<Token | ForwardRef<Token>>>(targetObj, "inject:tokens") ?? [];
+			getContainerMetadata<Array<Token | ForwardRef<Token>>>(
+				targetObj,
+				"inject:tokens",
+			) ?? [];
 		existingTokens[parameterIndex] = token;
 		setContainerMetadata(targetObj, "inject:tokens", existingTokens);
 	};
 }
 
 // Export getter and setter for use by modules
-export { getContainerMetadata as getInjectTokens, setContainerMetadata, getContainerMetadata };
+export {
+	getContainerMetadata as getInjectTokens,
+	setContainerMetadata,
+	getContainerMetadata,
+};

package/src/context/index.ts

@@ -287,7 +287,17 @@ export class Context<V extends ContextVariables = ContextVariables> {
 	/**
 	 * Create a new Response with current state
 	 */
-	newResponse(body: Blob | ArrayBuffer | FormData | URLSearchParams | ReadableStream<unknown> | string | null, options?: ResponseInit): Response {
+	newResponse(
+		body:
+			| Blob
+			| ArrayBuffer
+			| FormData
+			| URLSearchParams
+			| ReadableStream<unknown>
+			| string
+			| null,
+		options?: ResponseInit,
+	): Response {
 		return new Response(body, {
 			status: this._response.status,
 			headers: this._response.headers,