@buenojs/bueno 0.8.4 → 0.8.6

package/src/modules/pipes.ts

@@ -13,10 +13,14 @@
  * - Provide default values
  */
 
-import type { Context } from "../context";
 import type { Token } from "../container";
+import type { Context } from "../context";
 import type { StandardSchema } from "../types";
-import { validate, isStandardSchema, type ValidationResult } from "../validation";
+import {
+	type ValidationResult,
+	isStandardSchema,
+	validate,
+} from "../validation";
 
 // ============= Types =============
 
@@ -74,7 +78,7 @@ export interface PipeTransform<T = unknown, R = unknown> {
  */
 export type PipeFn<T = unknown, R = unknown> = (
 	value: T,
-	context: PipeContext
+	context: PipeContext,
 ) => R | Promise<R>;
 
 /**
@@ -94,7 +98,10 @@ export type Pipe<T = unknown, R = unknown> =
 type Constructor = new (...args: unknown[]) => unknown;
 
 // WeakMap for storing pipes metadata on method prototypes
-const pipesMethodMetadata = new WeakMap<object, Map<string | symbol, ParameterPipeMetadata[]>>();
+const pipesMethodMetadata = new WeakMap<
+	object,
+	Map<string | symbol, ParameterPipeMetadata[]>
+>();
 
 /**
  * Metadata for a parameter with pipes
@@ -103,7 +110,7 @@ export interface ParameterPipeMetadata {
 	/** Parameter index */
 	index: number;
 	/** Parameter decorator type */
-	decorator: 'body' | 'query' | 'param' | 'custom';
+	decorator: "body" | "query" | "param" | "custom";
 	/** Key for query/param decorators */
 	key?: string;
 	/** Schema for validation */
@@ -118,7 +125,7 @@ export interface ParameterPipeMetadata {
 function setMethodPipes(
 	target: object,
 	propertyKey: string | symbol,
-	metadata: ParameterPipeMetadata[]
+	metadata: ParameterPipeMetadata[],
 ): void {
 	if (!pipesMethodMetadata.has(target)) {
 		pipesMethodMetadata.set(target, new Map());
@@ -131,7 +138,7 @@ function setMethodPipes(
  */
 export function getMethodPipes(
 	target: object,
-	propertyKey: string | symbol
+	propertyKey: string | symbol,
 ): ParameterPipeMetadata[] | undefined {
 	return pipesMethodMetadata.get(target)?.get(propertyKey);
 }
@@ -155,7 +162,7 @@ export function UsePipes(...pipes: Pipe[]): ParameterDecorator {
 	return (
 		target: unknown,
 		propertyKey: string | symbol | undefined,
-		parameterIndex: number
+		parameterIndex: number,
 	) => {
 		if (propertyKey === undefined) {
 			throw new Error("UsePipes can only be used on method parameters");
@@ -163,19 +170,19 @@ export function UsePipes(...pipes: Pipe[]): ParameterDecorator {
 
 		const targetObj = target as object;
 		const existing = getMethodPipes(targetObj, propertyKey) ?? [];
-		
+
 		// Find existing metadata for this parameter or create new
-		const existingParam = existing.find(p => p.index === parameterIndex);
+		const existingParam = existing.find((p) => p.index === parameterIndex);
 		if (existingParam) {
 			existingParam.pipes.push(...pipes);
 		} else {
 			existing.push({
 				index: parameterIndex,
-				decorator: 'custom',
-				pipes: [...pipes]
+				decorator: "custom",
+				pipes: [...pipes],
 			});
 		}
-		
+
 		setMethodPipes(targetObj, propertyKey, existing);
 	};
 }
@@ -198,7 +205,7 @@ export function Body(schema?: StandardSchema): ParameterDecorator {
 	return (
 		target: unknown,
 		propertyKey: string | symbol | undefined,
-		parameterIndex: number
+		parameterIndex: number,
 	) => {
 		if (propertyKey === undefined) {
 			throw new Error("Body can only be used on method parameters");
@@ -206,14 +213,14 @@ export function Body(schema?: StandardSchema): ParameterDecorator {
 
 		const targetObj = target as object;
 		const existing = getMethodPipes(targetObj, propertyKey) ?? [];
-		
+
 		existing.push({
 			index: parameterIndex,
-			decorator: 'body',
+			decorator: "body",
 			schema,
-			pipes: schema ? [new ValidationPipe(schema)] : []
+			pipes: schema ? [new ValidationPipe(schema)] : [],
 		});
-		
+
 		setMethodPipes(targetObj, propertyKey, existing);
 	};
 }
@@ -234,11 +241,14 @@ export function Body(schema?: StandardSchema): ParameterDecorator {
  * search(@Query('limit', limitSchema) limit: number) {}
  * ```
  */
-export function Query(key?: string, schema?: StandardSchema): ParameterDecorator {
+export function Query(
+	key?: string,
+	schema?: StandardSchema,
+): ParameterDecorator {
 	return (
 		target: unknown,
 		propertyKey: string | symbol | undefined,
-		parameterIndex: number
+		parameterIndex: number,
 	) => {
 		if (propertyKey === undefined) {
 			throw new Error("Query can only be used on method parameters");
@@ -246,15 +256,15 @@ export function Query(key?: string, schema?: StandardSchema): ParameterDecorator
 
 		const targetObj = target as object;
 		const existing = getMethodPipes(targetObj, propertyKey) ?? [];
-		
+
 		existing.push({
 			index: parameterIndex,
-			decorator: 'query',
+			decorator: "query",
 			key,
 			schema,
-			pipes: schema ? [new ValidationPipe(schema)] : []
+			pipes: schema ? [new ValidationPipe(schema)] : [],
 		});
-		
+
 		setMethodPipes(targetObj, propertyKey, existing);
 	};
 }
@@ -276,7 +286,7 @@ export function Param(key?: string, ...pipes: Pipe[]): ParameterDecorator {
 	return (
 		target: unknown,
 		propertyKey: string | symbol | undefined,
-		parameterIndex: number
+		parameterIndex: number,
 	) => {
 		if (propertyKey === undefined) {
 			throw new Error("Param can only be used on method parameters");
@@ -284,14 +294,14 @@ export function Param(key?: string, ...pipes: Pipe[]): ParameterDecorator {
 
 		const targetObj = target as object;
 		const existing = getMethodPipes(targetObj, propertyKey) ?? [];
-		
+
 		existing.push({
 			index: parameterIndex,
-			decorator: 'param',
+			decorator: "param",
 			key,
-			pipes: [...pipes]
+			pipes: [...pipes],
 		});
-		
+
 		setMethodPipes(targetObj, propertyKey, existing);
 	};
 }
@@ -313,13 +323,16 @@ export class ValidationPipe<T = unknown> implements PipeTransform<unknown, T> {
 
 	async transform(value: unknown, context: PipeContext): Promise<T> {
 		const result: ValidationResult<T> = await validate(this.schema, value);
-		
+
 		if (result.success) {
 			return result.data;
 		}
-		
+
 		// Validation failed
-		const failedResult = result as Extract<ValidationResult<T>, { success: false }>;
+		const failedResult = result as Extract<
+			ValidationResult<T>,
+			{ success: false }
+		>;
 		const error = new Error("Validation failed");
 		(error as Error & { issues: unknown[] }).issues = [...failedResult.issues];
 		throw error;
@@ -336,12 +349,12 @@ export class ValidationPipe<T = unknown> implements PipeTransform<unknown, T> {
  */
 export class ParseIntPipe implements PipeTransform<string, number> {
 	transform(value: string, context: PipeContext): number {
-		const parsed = parseInt(value, 10);
-		
+		const parsed = Number.parseInt(value, 10);
+
 		if (isNaN(parsed)) {
 			throw new Error(`Validation failed: "${value}" is not a valid integer`);
 		}
-		
+
 		return parsed;
 	}
 }
@@ -356,12 +369,12 @@ export class ParseIntPipe implements PipeTransform<string, number> {
  */
 export class ParseFloatPipe implements PipeTransform<string, number> {
 	transform(value: string, context: PipeContext): number {
-		const parsed = parseFloat(value);
-		
+		const parsed = Number.parseFloat(value);
+
 		if (isNaN(parsed)) {
 			throw new Error(`Validation failed: "${value}" is not a valid number`);
 		}
-		
+
 		return parsed;
 	}
 }
@@ -375,20 +388,20 @@ export class ParseFloatPipe implements PipeTransform<string, number> {
  * ```
  */
 export class ParseBoolPipe implements PipeTransform<string, boolean> {
-	private readonly truthyValues = ['true', '1', 'yes', 'on'];
-	private readonly falsyValues = ['false', '0', 'no', 'off'];
+	private readonly truthyValues = ["true", "1", "yes", "on"];
+	private readonly falsyValues = ["false", "0", "no", "off"];
 
 	transform(value: string, context: PipeContext): boolean {
 		const lower = value.toLowerCase();
-		
+
 		if (this.truthyValues.includes(lower)) {
 			return true;
 		}
-		
+
 		if (this.falsyValues.includes(lower)) {
 			return false;
 		}
-		
+
 		throw new Error(`Validation failed: "${value}" is not a valid boolean`);
 	}
 }
@@ -422,8 +435,8 @@ export class DefaultValuePipe<T> implements PipeTransform<unknown, T> {
  */
 export class TrimPipe implements PipeTransform<string, string> {
 	transform(value: string, context: PipeContext): string {
-		if (typeof value !== 'string') {
-			throw new Error('Value must be a string');
+		if (typeof value !== "string") {
+			throw new Error("Value must be a string");
 		}
 		return value.trim();
 	}
@@ -456,13 +469,16 @@ export class ParseJsonPipe<T = unknown> implements PipeTransform<string, T> {
  * ```
  */
 export class ParseArrayPipe implements PipeTransform<string, string[]> {
-	constructor(private separator: string = ',') {}
+	constructor(private separator = ",") {}
 
 	transform(value: string, context: PipeContext): string[] {
-		if (typeof value !== 'string') {
-			throw new Error('Value must be a string');
+		if (typeof value !== "string") {
+			throw new Error("Value must be a string");
 		}
-		return value.split(this.separator).map(s => s.trim()).filter(s => s.length > 0);
+		return value
+			.split(this.separator)
+			.map((s) => s.trim())
+			.filter((s) => s.length > 0);
 	}
 }
 
@@ -492,7 +508,7 @@ export interface PipeExecutorOptions {
 export async function executePipes<T = unknown>(
 	value: unknown,
 	context: PipeContext,
-	options: PipeExecutorOptions
+	options: PipeExecutorOptions,
 ): Promise<T> {
 	const { globalPipes = [], parameterPipes = [], resolvePipe } = options;
 
@@ -509,8 +525,11 @@ export async function executePipes<T = unknown>(
 		if (typeof pipe === "function") {
 			// Check if it's a pipe function or a class constructor
 			const funcPipe = pipe as { prototype?: unknown; transform?: unknown };
-			if (funcPipe.prototype && typeof funcPipe.prototype === "object" &&
-				"transform" in (funcPipe.prototype as object)) {
+			if (
+				funcPipe.prototype &&
+				typeof funcPipe.prototype === "object" &&
+				"transform" in (funcPipe.prototype as object)
+			) {
 				// It's a class constructor - try to resolve from container or create instance
 				pipeInstance = resolvePipe ? resolvePipe(pipe) : null;
 				if (!pipeInstance) {
@@ -559,25 +578,25 @@ export async function executePipes<T = unknown>(
  */
 export async function extractParameterValue(
 	context: Context,
-	metadata: ParameterPipeMetadata
+	metadata: ParameterPipeMetadata,
 ): Promise<unknown> {
 	switch (metadata.decorator) {
-		case 'body':
+		case "body":
 			return await context.body();
-		
-		case 'query':
+
+		case "query":
 			if (metadata.key) {
 				return context.query[metadata.key];
 			}
 			return context.query;
-		
-		case 'param':
+
+		case "param":
 			if (metadata.key) {
 				return context.params[metadata.key];
 			}
 			return context.params;
-		
-		case 'custom':
+
+		case "custom":
 		default:
 			return undefined;
 	}
@@ -590,18 +609,21 @@ export async function extractParameterValue(
  */
 export function createBadRequestResponse(error: Error): Response {
 	const issues = (error as Error & { issues?: unknown[] }).issues;
-	
-	return new Response(JSON.stringify({
-		statusCode: 400,
-		error: "Bad Request",
-		message: error.message,
-		...(issues && { issues })
-	}), {
-		status: 400,
-		headers: {
-			"Content-Type": "application/json",
+
+	return new Response(
+		JSON.stringify({
+			statusCode: 400,
+			error: "Bad Request",
+			message: error.message,
+			...(issues && { issues }),
+		}),
+		{
+			status: 400,
+			headers: {
+				"Content-Type": "application/json",
+			},
 		},
-	});
+	);
 }
 
 // ============= Type Guards =============
@@ -623,4 +645,4 @@ export function isPipeTransform(value: unknown): value is PipeTransform {
  */
 export function isPipeFn(value: unknown): value is PipeFn {
 	return typeof value === "function" && !isPipeTransform(value);
-}
+}

package/src/notification/channels/base.ts

@@ -0,0 +1,68 @@
+/**
+ * Base Channel Service
+ *
+ * Abstract base class for all channel implementations
+ */
+
+import type {
+	ChannelHealth,
+	ChannelService,
+	NotificationMessage,
+} from "../types";
+
+// ============= Abstract Base Channel Service =============
+
+export abstract class BaseChannelService<
+	T extends NotificationMessage = NotificationMessage,
+> implements ChannelService<T>
+{
+	abstract readonly name: string;
+	readonly configSchema?: unknown;
+
+	/**
+	 * Validate message structure
+	 * Should throw if message is invalid
+	 */
+	abstract validate(message: unknown): asserts message is T;
+
+	/**
+	 * Send a notification message
+	 */
+	abstract send(message: T): Promise<string | undefined>;
+
+	/**
+	 * Get health status
+	 */
+	async getHealth(): Promise<ChannelHealth> {
+		return {
+			status: "healthy",
+			message: "Channel is operational",
+			checkedAt: new Date(),
+		};
+	}
+
+	/**
+	 * Validate that value matches expected type
+	 */
+	protected validateField(
+		value: unknown,
+		expectedType: string,
+		fieldName: string,
+	): void {
+		const actualType = typeof value;
+		if (actualType !== expectedType) {
+			throw new Error(
+				`Invalid ${this.name} message: ${fieldName} must be ${expectedType}, got ${actualType}`,
+			);
+		}
+	}
+
+	/**
+	 * Validate that required field exists
+	 */
+	protected validateRequired(value: unknown, fieldName: string): void {
+		if (value === undefined || value === null) {
+			throw new Error(`Invalid ${this.name} message: ${fieldName} is required`);
+		}
+	}
+}

package/src/notification/channels/email.ts

@@ -0,0 +1,105 @@
+/**
+ * Email Channel Service
+ *
+ * Sends notifications via email through various drivers
+ * (SMTP, Sendgrid, Brevo, Resend)
+ */
+
+import type { EmailChannelConfig, EmailMessage } from "../types";
+import { BaseChannelService } from "./base";
+
+// ============= Email Channel Service =============
+
+export class EmailChannelService extends BaseChannelService<EmailMessage> {
+	readonly name = "email";
+	private config: EmailChannelConfig;
+	private sentCount = 0;
+	private failureCount = 0;
+
+	constructor(config: EmailChannelConfig) {
+		super();
+		this.config = config;
+	}
+
+	/**
+	 * Validate email message structure
+	 */
+	validate(message: unknown): asserts message is EmailMessage {
+		if (typeof message !== "object" || message === null) {
+			throw new Error("Invalid email message: must be an object");
+		}
+
+		const msg = message as Record<string, unknown>;
+
+		// Check required fields
+		if (msg.channel !== "email") {
+			throw new Error('Invalid email message: channel must be "email"');
+		}
+
+		if (typeof msg.recipient !== "string" || !msg.recipient.includes("@")) {
+			throw new Error("Invalid email message: recipient must be a valid email");
+		}
+
+		if (typeof msg.subject !== "string" || msg.subject.length === 0) {
+			throw new Error("Invalid email message: subject is required");
+		}
+
+		// Check that at least one of html or text is present
+		if (!msg.html && !msg.text) {
+			throw new Error(
+				"Invalid email message: either html or text must be provided",
+			);
+		}
+	}
+
+	/**
+	 * Send email message
+	 */
+	async send(message: EmailMessage): Promise<string | undefined> {
+		try {
+			if (this.config.dryRun) {
+				console.log(`[EmailChannel] Would send email to: ${message.recipient}`);
+				console.log(`  Subject: ${message.subject}`);
+				this.sentCount++;
+				return this._generateMessageId();
+			}
+
+			// In a real implementation, delegate to appropriate driver
+			// For now, simulate sending
+			const messageId = this._generateMessageId();
+			console.log(
+				`[EmailChannel] Email sent: ${messageId} to ${message.recipient}`,
+			);
+			this.sentCount++;
+
+			return messageId;
+		} catch (error) {
+			this.failureCount++;
+			throw new Error(
+				`Failed to send email: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
+	/**
+	 * Get email channel metrics
+	 */
+	getMetrics() {
+		const total = this.sentCount + this.failureCount;
+		return {
+			sent: this.sentCount,
+			failed: this.failureCount,
+			total,
+			successRate: total > 0 ? this.sentCount / total : 0,
+		};
+	}
+
+	/**
+	 * Generate a message ID
+	 */
+	private _generateMessageId(): string {
+		const timestamp = Date.now();
+		const random = Math.random().toString(36).substring(2, 15);
+		return `${timestamp}.${random}@bueno.local`;
+	}
+}

package/src/notification/channels/push.ts

@@ -0,0 +1,104 @@
+/**
+ * Push Notification Channel Service
+ *
+ * Sends notifications via push through various drivers
+ * (Firebase, APNS, custom)
+ */
+
+import type { PushChannelConfig, PushNotificationMessage } from "../types";
+import { BaseChannelService } from "./base";
+
+// ============= Push Notification Channel Service =============
+
+export class PushNotificationChannelService extends BaseChannelService<PushNotificationMessage> {
+	readonly name = "push";
+	private config: PushChannelConfig;
+	private sentCount = 0;
+	private failureCount = 0;
+
+	constructor(config: PushChannelConfig) {
+		super();
+		this.config = config;
+	}
+
+	/**
+	 * Validate push notification message structure
+	 */
+	validate(message: unknown): asserts message is PushNotificationMessage {
+		if (typeof message !== "object" || message === null) {
+			throw new Error("Invalid push message: must be an object");
+		}
+
+		const msg = message as Record<string, unknown>;
+
+		if (msg.channel !== "push") {
+			throw new Error('Invalid push message: channel must be "push"');
+		}
+
+		if (typeof msg.recipient !== "string" || msg.recipient.length === 0) {
+			throw new Error(
+				"Invalid push message: recipient (device token) is required",
+			);
+		}
+
+		if (typeof msg.title !== "string" || msg.title.length === 0) {
+			throw new Error("Invalid push message: title is required");
+		}
+
+		if (typeof msg.body !== "string" || msg.body.length === 0) {
+			throw new Error("Invalid push message: body is required");
+		}
+	}
+
+	/**
+	 * Send push notification message
+	 */
+	async send(message: PushNotificationMessage): Promise<string | undefined> {
+		try {
+			if (this.config.dryRun) {
+				console.log(`[PushChannel] Would send push to: ${message.recipient}`);
+				console.log(`  Title: ${message.title}`);
+				console.log(`  Body: ${message.body}`);
+				this.sentCount++;
+				return this._generateMessageId();
+			}
+
+			// In a real implementation, delegate to appropriate driver
+			// For now, simulate sending
+			const messageId = this._generateMessageId();
+			console.log(
+				`[PushChannel] Push sent: ${messageId} to ${message.recipient}`,
+			);
+			this.sentCount++;
+
+			return messageId;
+		} catch (error) {
+			this.failureCount++;
+			throw new Error(
+				`Failed to send push: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
+	/**
+	 * Get push channel metrics
+	 */
+	getMetrics() {
+		const total = this.sentCount + this.failureCount;
+		return {
+			sent: this.sentCount,
+			failed: this.failureCount,
+			total,
+			successRate: total > 0 ? this.sentCount / total : 0,
+		};
+	}
+
+	/**
+	 * Generate a message ID
+	 */
+	private _generateMessageId(): string {
+		const timestamp = Date.now();
+		const random = Math.random().toString(36).substring(2, 15);
+		return `push_${timestamp}_${random}`;
+	}
+}