@buenojs/bueno 0.8.4 → 0.8.5

package/src/events/registry.ts

@@ -0,0 +1,182 @@
+import {
+	type Event,
+	type EventCategory,
+	EventContext,
+	EventError,
+	type EventRegistry,
+	type EventRegistryOptions,
+	type EventRegistryState,
+	type EventStats,
+} from "./types";
+
+export class EventRegistryImpl implements EventRegistry {
+	private state: EventRegistryState;
+
+	constructor(options: EventRegistryOptions = {}) {
+		this.state = {
+			events: new Map(),
+			categories: new Map(),
+			config: {
+				maxEvents: options.maxEvents || 1000,
+				retentionPeriod: options.retentionPeriod || 24 * 60 * 60 * 1000, // 24 hours
+				cleanupInterval: options.cleanupInterval || 60 * 60 * 1000, // 1 hour
+			},
+		};
+
+		this.setupCleanup();
+	}
+
+	registerEvent(event: Event): void {
+		if (this.state.events.size >= this.state.config.maxEvents) {
+			this.cleanupOldEvents();
+		}
+
+		this.state.events.set(event.id, event);
+	}
+
+	getEvent(id: string): Event | undefined {
+		return this.state.events.get(id);
+	}
+
+	getEventsByCategory(category: string): Event[] {
+		return Array.from(this.state.events.values()).filter(
+			(event) => event.context?.category === category,
+		);
+	}
+
+	getAllEvents(): Event[] {
+		return Array.from(this.state.events.values());
+	}
+
+	getEventCategories(): EventCategory[] {
+		return Array.from(this.state.categories.values());
+	}
+
+	registerEventCategory(category: EventCategory): void {
+		this.state.categories.set(category.name, category);
+	}
+
+	getEventStats(): EventStats {
+		return {
+			totalEvents: this.state.events.size,
+			eventsPerSecond: this.calculateEventsPerSecond(),
+			listenersCount: 0, // Not tracked in registry
+			errorsCount: 0, // Not tracked in registry
+			averageProcessingTime: 0, // Not tracked in registry
+		};
+	}
+
+	clearEvents(): void {
+		this.state.events.clear();
+	}
+
+	private setupCleanup(): void {
+		setInterval(() => {
+			this.cleanupOldEvents();
+		}, this.state.config.cleanupInterval);
+	}
+
+	private cleanupOldEvents(): void {
+		const now = Date.now();
+		const retentionTime = now - this.state.config.retentionPeriod;
+
+		for (const [id, event] of this.state.events.entries()) {
+			if (event.timestamp.getTime() < retentionTime) {
+				this.state.events.delete(id);
+			}
+		}
+	}
+
+	private calculateEventsPerSecond(): number {
+		const now = Date.now();
+		const oneSecondAgo = now - 1000;
+		let count = 0;
+
+		for (const event of this.state.events.values()) {
+			if (event.timestamp.getTime() > oneSecondAgo) {
+				count++;
+			}
+		}
+
+		return count;
+	}
+
+	getEventHistory(options: {
+		category?: string;
+		startTime?: Date;
+		endTime?: Date;
+		limit?: number;
+	}): Event[] {
+		let events = Array.from(this.state.events.values());
+
+		if (options.category) {
+			events = events.filter(
+				(event) => event.context?.category === options.category,
+			);
+		}
+
+		if (options.startTime) {
+			events = events.filter((event) => event.timestamp >= options.startTime);
+		}
+
+		if (options.endTime) {
+			events = events.filter((event) => event.timestamp <= options.endTime);
+		}
+
+		// Sort first before applying limit
+		events = events.sort(
+			(a, b) => b.timestamp.getTime() - a.timestamp.getTime(),
+		);
+
+		if (options.limit) {
+			events = events.slice(0, options.limit);
+		}
+
+		return events;
+	}
+
+	searchEvents(query: string): Event[] {
+		const lowerQuery = query.toLowerCase();
+		return Array.from(this.state.events.values()).filter(
+			(event) =>
+				event.name.toLowerCase().includes(lowerQuery) ||
+				(event.data &&
+					JSON.stringify(event.data).toLowerCase().includes(lowerQuery)),
+		);
+	}
+
+	exportEvents(): Event[] {
+		return Array.from(this.state.events.values());
+	}
+
+	importEvents(events: Event[]): void {
+		events.forEach((event) => this.registerEvent(event));
+	}
+
+	getEventTimeline(): { timestamp: Date; eventCount: number }[] {
+		const timeline: { timestamp: Date; eventCount: number }[] = [];
+		const eventsByTime = new Map();
+
+		for (const event of this.state.events.values()) {
+			const timeKey = new Date(
+				event.timestamp.getTime() - (event.timestamp.getTime() % (60 * 1000)),
+			);
+			const count = eventsByTime.get(timeKey) || 0;
+			eventsByTime.set(timeKey, count + 1);
+		}
+
+		for (const [time, count] of eventsByTime.entries()) {
+			timeline.push({ timestamp: time, eventCount: count });
+		}
+
+		return timeline.sort(
+			(a, b) => a.timestamp.getTime() - b.timestamp.getTime(),
+		);
+	}
+}
+
+export function createEventRegistry(
+	options?: EventRegistryOptions,
+): EventRegistry {
+	return new EventRegistryImpl(options);
+}

package/src/events/types.ts

@@ -0,0 +1,124 @@
+export interface Event {
+	id: string;
+	name: string;
+	timestamp: Date;
+	data: Record<string, any>;
+	context?: EventContext;
+}
+
+export interface EventContext {
+	userId?: string;
+	sessionId?: string;
+	requestId?: string;
+	ipAddress?: string;
+	userAgent?: string;
+}
+
+export interface EventListener {
+	id: string;
+	name: string;
+	handler: EventHandler;
+	filter?: EventFilter;
+	priority?: number;
+	once?: boolean;
+}
+
+export type EventHandler = (event: Event) => Promise<void> | void;
+
+export type EventFilter = (event: Event) => boolean;
+
+export interface EventCategory {
+	name: string;
+	description: string;
+	events: string[];
+}
+
+export interface EventManagerConfig {
+	maxListeners?: number;
+	eventCategories?: EventCategory[];
+	middleware?: EventMiddleware[];
+}
+
+export type EventMiddleware = (
+	event: Event,
+	next: () => Promise<void>,
+) => Promise<void>;
+
+export interface EventRegistry {
+	registerEvent(event: Event): void;
+	getEvent(id: string): Event | undefined;
+	getEventsByCategory(category: string): Event[];
+	getAllEvents(): Event[];
+}
+
+export interface EventManager {
+	emit(event: Event): Promise<void>;
+	emitSync(event: Event): void;
+	on(event: string, listener: EventHandler): () => void;
+	once(event: string, listener: EventHandler): () => void;
+	off(event: string, listener: EventHandler): void;
+	addListener(listener: EventListener): void;
+	removeListener(listener: EventListener): void;
+	addFilter(filter: EventFilter): void;
+	removeFilter(filter: EventFilter): void;
+	addMiddleware(middleware: EventMiddleware): void;
+	removeMiddleware(middleware: EventMiddleware): void;
+	getListeners(event: string): EventListener[];
+	hasListeners(event: string): boolean;
+	clearListeners(event?: string): void;
+	getEventCategories(): EventCategory[];
+	registerEventCategory(category: EventCategory): void;
+}
+
+export interface EventError extends Error {
+	event: Event;
+	originalError?: Error;
+}
+
+export interface EventStats {
+	totalEvents: number;
+	eventsPerSecond: number;
+	listenersCount: number;
+	errorsCount: number;
+	averageProcessingTime: number;
+}
+
+export interface EventOptions {
+	context?: EventContext;
+	timestamp?: Date;
+	id?: string;
+}
+
+export interface EventListenerOptions {
+	priority?: number;
+	once?: boolean;
+	filter?: EventFilter;
+}
+
+export interface EventManagerOptions {
+	maxListeners?: number;
+	eventCategories?: EventCategory[];
+	middleware?: EventMiddleware[];
+	errorHandling?: "throw" | "log" | "ignore";
+}
+
+export interface EventRegistryOptions {
+	maxEvents?: number;
+	retentionPeriod?: number;
+	cleanupInterval?: number;
+}
+
+export interface EventManagerState {
+	listeners: Map<string, EventListener[]>;
+	filters: EventFilter[];
+	middleware: EventMiddleware[];
+	categories: EventCategory[];
+	stats: EventStats;
+	config: EventManagerConfig;
+}
+
+export interface EventRegistryState {
+	events: Map<string, Event>;
+	categories: Map<string, EventCategory>;
+	config: EventRegistryOptions;
+}

package/src/frontend/api-routes.ts

@@ -9,24 +9,32 @@
  * - Type-safe response helpers
  */
 
-import { createLogger, type Logger } from "../logger/index.js";
+import { type Logger, createLogger } from "../logger/index.js";
 import type {
+	APIContext,
+	APIMiddleware,
+	APIResponse,
 	APIRouteConfig,
-	PartialAPIRouteConfig,
 	APIRouteDefinition,
 	APIRouteHandler,
-	APIContext,
-	APIResponse,
-	APIMiddleware,
 	APIRouteModule,
 	HTTPMethod,
+	PartialAPIRouteConfig,
 } from "./types.js";
 
 // ============= Constants =============
 
 const DEFAULT_API_DIR = "pages/api";
 const SUPPORTED_EXTENSIONS = [".ts", ".js"];
-const SUPPORTED_METHODS: HTTPMethod[] = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+const SUPPORTED_METHODS: HTTPMethod[] = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"HEAD",
+	"OPTIONS",
+];
 
 // ============= API Route Manager Class =============
 
@@ -102,7 +110,10 @@ export class APIRouteManager {
 	/**
 	 * Process a single API file
 	 */
-	private async processAPIFile(filePath: string, basePath: string): Promise<void> {
+	private async processAPIFile(
+		filePath: string,
+		basePath: string,
+	): Promise<void> {
 		const fullPath = `${basePath}/${filePath}`;
 		const routePath = this.filePathToRoute(filePath);
 
@@ -136,14 +147,18 @@ export class APIRouteManager {
 		};
 
 		this.routes.set(routePath, route);
-		this.logger.debug(`Processed API route: ${routePath} [${methods.join(", ")}]`);
+		this.logger.debug(
+			`Processed API route: ${routePath} [${methods.join(", ")}]`,
+		);
 	}
 
 	/**
 	 * Load middlewares from _middleware.ts files
 	 */
 	private async loadMiddlewares(basePath: string): Promise<void> {
-		const glob = new Bun.Glob(`**/_middleware{${this.config.extensions.join(",")}}`);
+		const glob = new Bun.Glob(
+			`**/_middleware{${this.config.extensions.join(",")}}`,
+		);
 
 		try {
 			for await (const file of glob.scan(basePath)) {
@@ -261,7 +276,10 @@ export class APIRouteManager {
 	/**
 	 * Match a request to an API route
 	 */
-	match(method: string, pathname: string): { route: APIRouteDefinition; params: Record<string, string> } | null {
+	match(
+		method: string,
+		pathname: string,
+	): { route: APIRouteDefinition; params: Record<string, string> } | null {
 		for (const route of this.routes.values()) {
 			const match = pathname.match(route.regex);
 			if (match) {
@@ -316,8 +334,11 @@ export class APIRouteManager {
 		} catch (error) {
 			this.logger.error(`API error: ${pathname}`, error);
 			return this.jsonResponse(
-				{ error: "Internal Server Error", message: error instanceof Error ? error.message : "Unknown error" },
-				500
+				{
+					error: "Internal Server Error",
+					message: error instanceof Error ? error.message : "Unknown error",
+				},
+				500,
 			);
 		}
 	}
@@ -339,7 +360,7 @@ export class APIRouteManager {
 	 */
 	private async createContext(
 		request: Request,
-		params: Record<string, string>
+		params: Record<string, string>,
 	): Promise<APIContext> {
 		const url = new URL(request.url);
 
@@ -361,7 +382,10 @@ export class APIRouteManager {
 					body = await request.text();
 				}
 			} catch (error) {
-				this.logger.warn("Failed to parse request body", error as Record<string, unknown>);
+				this.logger.warn(
+					"Failed to parse request body",
+					error as Record<string, unknown>,
+				);
 			}
 		}
 
@@ -419,7 +443,7 @@ export class APIRouteManager {
 		context: APIContext,
 		middlewares: APIMiddleware[],
 		route: APIRouteDefinition,
-		method: HTTPMethod
+		method: HTTPMethod,
 	): Promise<Response> {
 		let index = 0;
 
@@ -509,7 +533,9 @@ export class APIRouteManager {
 /**
  * Create an API route manager
  */
-export function createAPIRouteManager(config: PartialAPIRouteConfig = {}): APIRouteManager {
+export function createAPIRouteManager(
+	config: PartialAPIRouteConfig = {},
+): APIRouteManager {
 	return new APIRouteManager(config);
 }
 
@@ -518,7 +544,11 @@ export function createAPIRouteManager(config: PartialAPIRouteConfig = {}): APIRo
 /**
  * Create a JSON response
  */
-export function json(data: unknown, status = 200, headers?: Record<string, string>): Response {
+export function json(
+	data: unknown,
+	status = 200,
+	headers?: Record<string, string>,
+): Response {
 	return new Response(JSON.stringify(data), {
 		status,
 		headers: {
@@ -531,7 +561,11 @@ export function json(data: unknown, status = 200, headers?: Record<string, strin
 /**
  * Create a text response
  */
-export function text(data: string, status = 200, headers?: Record<string, string>): Response {
+export function text(
+	data: string,
+	status = 200,
+	headers?: Record<string, string>,
+): Response {
 	return new Response(data, {
 		status,
 		headers: {
@@ -544,7 +578,11 @@ export function text(data: string, status = 200, headers?: Record<string, string
 /**
  * Create an HTML response
  */
-export function html(data: string, status = 200, headers?: Record<string, string>): Response {
+export function html(
+	data: string,
+	status = 200,
+	headers?: Record<string, string>,
+): Response {
 	return new Response(data, {
 		status,
 		headers: {
@@ -621,8 +659,10 @@ export function noContent(): Response {
  * Check if a file is an API route file
  */
 export function isAPIRouteFile(filename: string): boolean {
-	return SUPPORTED_EXTENSIONS.some(ext => filename.endsWith(ext)) && 
-		!filename.includes("_middleware");
+	return (
+		SUPPORTED_EXTENSIONS.some((ext) => filename.endsWith(ext)) &&
+		!filename.includes("_middleware")
+	);
 }
 
 /**
@@ -636,5 +676,7 @@ export function isMiddlewareFile(filename: string): boolean {
  * Get HTTP methods from module
  */
 export function getModuleMethods(module: APIRouteModule): HTTPMethod[] {
-	return SUPPORTED_METHODS.filter(method => typeof module[method] === "function");
-}
+	return SUPPORTED_METHODS.filter(
+		(method) => typeof module[method] === "function",
+	);
+}