@kuckit/infrastructure 1.0.2 → 2.0.0

package/dist/index.js

@@ -1,971 +1,29 @@
-import { drizzle } from "drizzle-orm/node-postgres";
-import { Pool } from "pg";
-import { eq } from "drizzle-orm";
-import { user } from "@kuckit/db/schema/auth";
-import { asClass, asFunction, asValue } from "awilix";
-import { createWriteStream, existsSync, mkdirSync } from "fs";
-import path from "path";
-import { randomUUID } from "crypto";
-import { AppError, ErrorCode } from "@kuckit/domain";
-import { SystemClock } from "@kuckit/domain/ports/clock";
-import { google } from "@ai-sdk/google";
-import { auth } from "@kuckit/auth";
+import { n as createDbPool, t as createDb } from "./db-C4IcCT04.js";
+import { t as makeDrizzleUserRepository } from "./user.drizzle-CgKIqqb3.js";
+import "./repositories-nTfSJyvW.js";
+import { t as runInTransaction } from "./transaction-r4Sy3eC-.js";
+import { n as makeStructuredLogger, t as StructuredLogger } from "./structured-logger-BsxDI9zX.js";
+import { t as makeRequestLogger } from "./request-logger-Cw1XQWTV.js";
+import "./logging-4mLSrMc6.js";
+import "./errors-BB_jeye8.js";
+import { n as makeErrorHandler, t as ErrorHandler } from "./error-handler-D4s_TTI1.js";
+import "./errors-DfkerzdO.js";
+import { t as InMemoryEventBus } from "./in-memory-event-bus-BCyPrNAE.js";
+import { t as makeEventPublisherAdapter } from "./event-publisher-adapter-B02oKEmP.js";
+import { t as makeInMemoryEventPublisher } from "./in-memory-event-publisher-BdOlxfkx.js";
+import "./events-Dqynhuj2.js";
+import { t as InMemoryCacheStore } from "./in-memory-cache-store-oClww-8m.js";
+import "./cache-BjdZ-Ye4.js";
+import { t as InMemoryRateLimiterStore } from "./in-memory-rate-limiter-BDSHZXxf.js";
+import "./rate-limiter-BnvPGJOK.js";
+import { a as withRequestTracing, i as withPerformanceMonitoring, n as makeDecoratedUseCase, r as withErrorHandling, t as decorateUseCase } from "./use-case-decorator-GmDeYViz.js";
+import { t as applyDecorators } from "./apply-decorators-CaHIAL5X.js";
+import { t as withCaching } from "./with-caching-NmBxu7vJ.js";
+import { t as withRetry } from "./with-retry-coyYPiX1.js";
+import { n as withRateLimit, t as RateLimitError } from "./with-rate-limit-Cp2V1RHn.js";
+import "./decorators-CqyPE9AQ.js";
+import { t as registerCoreModule } from "./core.module-DMtIkTcz.js";
+import { t as registerUserModule } from "./user.module-BEpCbKsU.js";
+import "./modules-C_2SF3he.js";
 
-//#region src/db/drizzle/db.ts
-/**
-* Create database connection pool
-*/
-const createDbPool = (connectionString) => {
-	return new Pool({
-		connectionString,
-		max: 20,
-		idleTimeoutMillis: 3e4,
-		connectionTimeoutMillis: 2e3
-	});
-};
-/**
-* Create Drizzle instance from pool
-*/
-const createDb = (pool) => {
-	return drizzle(pool);
-};
-
-//#endregion
-//#region src/db/drizzle/repositories/user.drizzle.ts
-/**
-* Map Drizzle row to domain entity
-*/
-const toDomainUser = (row) => ({
-	id: row.id,
-	name: row.name,
-	email: row.email,
-	emailVerified: row.emailVerified,
-	permissions: row.permissions,
-	createdAt: row.createdAt,
-	updatedAt: row.updatedAt
-});
-/**
-* Map domain entity to Drizzle insert type
-*/
-const toDbUser = (user$1) => ({
-	id: user$1.id,
-	name: user$1.name,
-	email: user$1.email,
-	emailVerified: user$1.emailVerified,
-	permissions: [...user$1.permissions],
-	createdAt: user$1.createdAt,
-	updatedAt: user$1.updatedAt
-});
-/**
-* Drizzle implementation of UserRepository
-*/
-const makeDrizzleUserRepository = (db) => ({
-	async findById(id) {
-		const rows = await db.select().from(user).where(eq(user.id, id)).limit(1);
-		return rows[0] ? toDomainUser(rows[0]) : null;
-	},
-	async findByEmail(email) {
-		const rows = await db.select().from(user).where(eq(user.email, email)).limit(1);
-		return rows[0] ? toDomainUser(rows[0]) : null;
-	},
-	async save(user$1) {
-		await db.insert(user).values(toDbUser(user$1)).onConflictDoUpdate({
-			target: user.id,
-			set: {
-				name: user$1.name,
-				email: user$1.email,
-				emailVerified: user$1.emailVerified,
-				permissions: [...user$1.permissions],
-				updatedAt: user$1.updatedAt
-			}
-		});
-	}
-});
-
-//#endregion
-//#region src/db/transaction.ts
-/**
-* Run a function within a database transaction
-* Creates a child scope with transaction-bound repositories
-*
-* Usage:
-* ```typescript
-* const result = await runInTransaction(container, async (txScope) => {
-*   const { userRepository } = txScope.cradle
-*   await userRepository.save(user)
-*   return user
-* })
-* ```
-*/
-const runInTransaction = async (container, fn) => {
-	return container.resolve("db").transaction(async (tx) => {
-		const txScope = container.createScope();
-		txScope.register({
-			db: asValue(tx),
-			userRepository: asFunction(({ db }) => makeDrizzleUserRepository(db)).scoped()
-		});
-		try {
-			return await fn(txScope);
-		} finally {
-			txScope.dispose();
-		}
-	});
-};
-
-//#endregion
-//#region src/logging/structured-logger.ts
-/**
-* Structured logger implementation
-* - JSON logs compatible with Loki
-* - File + stdout support
-* - Prometheus metrics collection
-*/
-var StructuredLogger = class {
-	fileStream = null;
-	metrics;
-	constructor(options = {}) {
-		this.options = options;
-		this.metrics = new MetricsCollector();
-		if (options.enableFile && options.logDir) this.initFileStream(options.logDir);
-	}
-	initFileStream(logDir) {
-		if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
-		this.fileStream = createWriteStream(path.join(logDir, `app-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`), { flags: "a" });
-	}
-	debug(message, meta) {
-		this.log("DEBUG", message, meta);
-	}
-	info(message, meta) {
-		this.log("INFO", message, meta);
-	}
-	warn(message, meta) {
-		this.log("WARN", message, meta);
-	}
-	error(message, meta) {
-		const context = meta instanceof Error ? {
-			error: meta.message,
-			stack: meta.stack
-		} : meta;
-		this.log("ERROR", message, context);
-	}
-	log(level, message, meta) {
-		if (this.shouldSkip(level)) return;
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		const logEntry = this.formatLog(level, message, meta, timestamp);
-		console.log(logEntry);
-		if (this.fileStream) this.fileStream.write(logEntry + "\n");
-		this.metrics.recordLog(level, meta?.feature);
-	}
-	shouldSkip(level) {
-		const levels = [
-			"DEBUG",
-			"INFO",
-			"WARN",
-			"ERROR"
-		];
-		const minLevel = this.options.minLevel || "DEBUG";
-		return levels.indexOf(level) < levels.indexOf(minLevel);
-	}
-	formatLog(level, message, meta, timestamp) {
-		const logObject = {
-			timestamp,
-			level,
-			message,
-			...meta
-		};
-		if (meta?.requestId) logObject.requestId = meta.requestId;
-		if (meta?.userId) logObject.userId = meta.userId;
-		if (meta?.feature) logObject.feature = meta.feature;
-		return JSON.stringify(logObject);
-	}
-	/**
-	* Get metrics in Prometheus text format
-	*/
-	getMetrics() {
-		return this.metrics.toPrometheusFormat();
-	}
-	/**
-	* Cleanup resources
-	*/
-	async dispose() {
-		return new Promise((resolve) => {
-			if (this.fileStream) this.fileStream.end(() => resolve());
-			else resolve();
-		});
-	}
-};
-/**
-* Prometheus metrics collector
-*/
-var MetricsCollector = class {
-	logCount = new Map([
-		["DEBUG", 0],
-		["INFO", 0],
-		["WARN", 0],
-		["ERROR", 0]
-	]);
-	featureCount = /* @__PURE__ */ new Map();
-	recordLog(level, feature) {
-		this.logCount.set(level, (this.logCount.get(level) || 0) + 1);
-		if (feature) this.featureCount.set(feature, (this.featureCount.get(feature) || 0) + 1);
-	}
-	toPrometheusFormat() {
-		const lines = ["# HELP app_logs_total Total number of logs by level", "# TYPE app_logs_total counter"];
-		for (const [level, count] of this.logCount) lines.push(`app_logs_total{level="${level}"} ${count}`);
-		lines.push("");
-		lines.push("# HELP app_feature_logs_total Total logs by feature");
-		lines.push("# TYPE app_feature_logs_total counter");
-		for (const [feature, count] of this.featureCount) lines.push(`app_feature_logs_total{feature="${feature}"} ${count}`);
-		return lines.join("\n");
-	}
-};
-/**
-* Create logger instance
-*/
-const makeStructuredLogger = (options) => {
-	return new StructuredLogger(options);
-};
-
-//#endregion
-//#region src/logging/request-logger.ts
-/**
-* Create a request-scoped logger that automatically includes
-* requestId and userId in all log entries.
-*
-* This wraps the base singleton logger and enriches all log
-* calls with request context for Loki-compatible structured logging.
-*/
-const makeRequestLogger = (options) => {
-	const context = {
-		requestId: options.requestId,
-		...options.userId && { userId: options.userId }
-	};
-	return {
-		debug: (message, meta) => {
-			options.baseLogger.debug(message, {
-				...context,
-				...meta
-			});
-		},
-		info: (message, meta) => {
-			options.baseLogger.info(message, {
-				...context,
-				...meta
-			});
-		},
-		warn: (message, meta) => {
-			options.baseLogger.warn(message, {
-				...context,
-				...meta
-			});
-		},
-		error: (message, meta) => {
-			if (meta instanceof Error) options.baseLogger.error(message, {
-				...context,
-				error: meta.message,
-				stack: meta.stack
-			});
-			else options.baseLogger.error(message, {
-				...context,
-				...meta
-			});
-		}
-	};
-};
-
-//#endregion
-//#region ../domain/src/errors/index.ts
-/**
-* Severity levels for error classification
-*/
-let ErrorSeverity = /* @__PURE__ */ function(ErrorSeverity$1) {
-	ErrorSeverity$1["LOW"] = "LOW";
-	ErrorSeverity$1["MEDIUM"] = "MEDIUM";
-	ErrorSeverity$1["HIGH"] = "HIGH";
-	ErrorSeverity$1["CRITICAL"] = "CRITICAL";
-	return ErrorSeverity$1;
-}({});
-/**
-* Application error base class
-*/
-var AppError$1 = class AppError$1 extends Error {
-	code;
-	severity;
-	statusCode;
-	meta;
-	constructor(code, message, options = {}) {
-		super(message);
-		this.name = "AppError";
-		this.code = code;
-		this.severity = options.severity || ErrorSeverity.MEDIUM;
-		this.statusCode = options.statusCode || 500;
-		this.meta = options.meta || {};
-		Object.setPrototypeOf(this, AppError$1.prototype);
-	}
-	toJSON() {
-		return {
-			name: this.name,
-			code: this.code,
-			message: this.message,
-			severity: this.severity,
-			statusCode: this.statusCode,
-			meta: this.meta
-		};
-	}
-};
-
-//#endregion
-//#region src/errors/error-handler.ts
-/**
-* Error handler for structured error logging and serialization
-*/
-var ErrorHandler = class ErrorHandler {
-	constructor(logger) {
-		this.logger = logger;
-	}
-	/**
-	* Handle error and serialize for API response
-	*/
-	handle(error, context) {
-		const appError = this.normalize(error);
-		this.log(appError, context);
-		return this.serialize(appError);
-	}
-	/**
-	* Normalize any error to AppError
-	*/
-	normalize(error) {
-		if (error instanceof AppError$1) return error;
-		if (error instanceof Error) return new AppError$1("INTERNAL_SERVER_ERROR", error.message, {
-			statusCode: 500,
-			meta: { originalError: error.name }
-		});
-		return new AppError$1("INTERNAL_SERVER_ERROR", "Unknown error occurred", { statusCode: 500 });
-	}
-	/**
-	* Log error with appropriate level
-	*/
-	log(error, context) {
-		const logContext = {
-			code: error.code,
-			severity: error.severity,
-			stack: error.stack,
-			...context
-		};
-		switch (error.severity) {
-			case "LOW":
-				this.logger.debug(error.message, logContext);
-				break;
-			case "MEDIUM":
-				this.logger.warn(error.message, logContext);
-				break;
-			case "HIGH":
-			case "CRITICAL":
-				this.logger.error(error.message, logContext);
-				break;
-		}
-	}
-	/**
-	* Serialize error for API response
-	*/
-	serialize(error) {
-		return {
-			code: error.code,
-			message: error.message,
-			statusCode: error.statusCode,
-			...Object.keys(error.meta).length > 0 && { meta: error.meta }
-		};
-	}
-	/**
-	* Create error handler factory
-	*/
-	static create(logger) {
-		return new ErrorHandler(logger);
-	}
-};
-/**
-* Factory for error handler
-*/
-const makeErrorHandler = (logger) => {
-	return ErrorHandler.create(logger);
-};
-
-//#endregion
-//#region src/events/in-memory-event-bus.ts
-/**
-* In-memory event bus
-* Stores handlers in Sets, executes synchronously or asynchronously
-*/
-var InMemoryEventBus = class {
-	handlers = /* @__PURE__ */ new Map();
-	allHandlers = /* @__PURE__ */ new Set();
-	constructor(logger) {
-		this.logger = logger;
-	}
-	async publish(event) {
-		const eventName = String(event.name);
-		const handlers = this.handlers.get(eventName) ?? /* @__PURE__ */ new Set();
-		const allHandlers = Array.from(this.allHandlers);
-		const eventHandlers = [...handlers, ...allHandlers];
-		const failed = (await Promise.allSettled(eventHandlers.map((handler) => Promise.resolve(handler(event)).catch((error) => {
-			this.logger.error("Error in event handler", {
-				eventName,
-				eventId: event.meta.eventId,
-				error
-			});
-		})))).filter((r) => r.status === "rejected").length;
-		if (failed > 0) this.logger.warn(`Event published with ${failed} handler errors`, {
-			eventName,
-			eventId: event.meta.eventId
-		});
-	}
-	publishAsync(event) {
-		queueMicrotask(() => {
-			this.publish(event).catch((error) => {
-				this.logger.error("Unhandled error in async event publishing", {
-					eventName: event.name,
-					eventId: event.meta.eventId,
-					error
-				});
-			});
-		});
-	}
-	subscribe(eventName, handler) {
-		const eventNameStr = String(eventName);
-		if (!this.handlers.has(eventNameStr)) this.handlers.set(eventNameStr, /* @__PURE__ */ new Set());
-		const handlerSet = this.handlers.get(eventNameStr);
-		handlerSet.add(handler);
-		return () => {
-			handlerSet.delete(handler);
-			if (handlerSet.size === 0) this.handlers.delete(eventNameStr);
-		};
-	}
-	subscribeAll(handler) {
-		this.allHandlers.add(handler);
-		return () => {
-			this.allHandlers.delete(handler);
-		};
-	}
-};
-
-//#endregion
-//#region src/events/event-publisher-adapter.ts
-/**
-* Adapter that implements EventPublisher port using EventBus
-* Converts the simplified EventPublisher interface to full EventBus types
-*/
-const makeEventPublisherAdapter = (eventBus, logger) => {
-	return {
-		async publish(eventName, payload, aggregateId) {
-			const event = {
-				name: eventName,
-				payload,
-				meta: {
-					eventId: randomUUID(),
-					occurredAt: /* @__PURE__ */ new Date(),
-					version: 1,
-					aggregateId,
-					correlationId: randomUUID()
-				}
-			};
-			logger.debug("Publishing event", {
-				eventName,
-				eventId: event.meta.eventId,
-				aggregateId
-			});
-			await eventBus.publish(event);
-		},
-		subscribe(eventName, handler) {
-			return eventBus.subscribe(eventName, async (event) => {
-				try {
-					await handler(event.payload);
-				} catch (error) {
-					logger.error("Error in event handler", {
-						eventName,
-						error: error instanceof Error ? error.message : "Unknown error"
-					});
-				}
-			});
-		}
-	};
-};
-
-//#endregion
-//#region src/events/in-memory-event-publisher.ts
-/**
-* In-memory event publisher implementation
-* Suitable for development and testing
-*/
-const makeInMemoryEventPublisher = () => {
-	const subscribers = /* @__PURE__ */ new Map();
-	return {
-		async publish(eventName, payload, _aggregateId) {
-			const handlers = subscribers.get(eventName);
-			if (!handlers) return;
-			await Promise.all(Array.from(handlers).map((handler) => Promise.resolve(handler(payload))));
-		},
-		subscribe(eventName, handler) {
-			if (!subscribers.has(eventName)) subscribers.set(eventName, /* @__PURE__ */ new Set());
-			const handlers = subscribers.get(eventName);
-			handlers.add(handler);
-			return () => {
-				handlers.delete(handler);
-				if (handlers.size === 0) subscribers.delete(eventName);
-			};
-		}
-	};
-};
-
-//#endregion
-//#region src/cache/in-memory-cache-store.ts
-/**
-* In-memory cache store implementation
-* Suitable for single-process applications or development
-* For distributed systems, use Redis adapter
-*/
-var InMemoryCacheStore = class {
-	cache = /* @__PURE__ */ new Map();
-	cleanupTimer = null;
-	constructor(cleanupIntervalMs = 6e4) {
-		this.cleanupIntervalMs = cleanupIntervalMs;
-		this.startCleanup();
-	}
-	async get(key) {
-		const entry = this.cache.get(key);
-		if (!entry) return;
-		if (entry.expiresAt && entry.expiresAt < Date.now()) {
-			this.cache.delete(key);
-			return;
-		}
-		return entry.value;
-	}
-	async set(key, value, ttlMs) {
-		const entry = {
-			value,
-			expiresAt: ttlMs ? Date.now() + ttlMs : void 0
-		};
-		this.cache.set(key, entry);
-	}
-	async del(key) {
-		this.cache.delete(key);
-	}
-	async clear() {
-		this.cache.clear();
-	}
-	async has(key) {
-		const entry = this.cache.get(key);
-		if (!entry) return false;
-		if (entry.expiresAt && entry.expiresAt < Date.now()) {
-			this.cache.delete(key);
-			return false;
-		}
-		return true;
-	}
-	/**
-	* Start background cleanup of expired entries
-	*/
-	startCleanup() {
-		this.cleanupTimer = setInterval(() => {
-			const now = Date.now();
-			let expired = 0;
-			for (const [key, entry] of this.cache.entries()) if (entry.expiresAt && entry.expiresAt < now) {
-				this.cache.delete(key);
-				expired++;
-			}
-			if (expired > 0) {}
-		}, this.cleanupIntervalMs);
-	}
-	/**
-	* Stop cleanup timer
-	*/
-	destroy() {
-		if (this.cleanupTimer) {
-			clearInterval(this.cleanupTimer);
-			this.cleanupTimer = null;
-		}
-	}
-};
-
-//#endregion
-//#region src/rate-limiter/in-memory-rate-limiter.ts
-/**
-* In-memory rate limiter using token bucket algorithm
-* Suitable for single-process applications or development
-* For distributed systems, use Redis adapter
-*/
-var InMemoryRateLimiterStore = class {
-	buckets = /* @__PURE__ */ new Map();
-	cleanupTimer = null;
-	constructor(cleanupIntervalMs = 6e4) {
-		this.cleanupIntervalMs = cleanupIntervalMs;
-		this.startCleanup();
-	}
-	async checkLimit(key, capacity, refillPerSecond) {
-		const now = Date.now();
-		let bucket = this.buckets.get(key);
-		if (!bucket) {
-			bucket = {
-				tokens: capacity,
-				lastRefillAt: now
-			};
-			this.buckets.set(key, bucket);
-		}
-		const tokensToAdd = (now - bucket.lastRefillAt) / 1e3 * refillPerSecond;
-		bucket.tokens = Math.min(capacity, bucket.tokens + tokensToAdd);
-		bucket.lastRefillAt = now;
-		const allowed = bucket.tokens >= 1;
-		if (allowed) bucket.tokens -= 1;
-		const secondsToReset = Math.max(0, 1 - bucket.tokens) / refillPerSecond;
-		const resetAt = new Date(now + secondsToReset * 1e3);
-		return {
-			allowed,
-			tokensRemaining: Math.floor(bucket.tokens),
-			resetAt
-		};
-	}
-	async reset(key) {
-		this.buckets.delete(key);
-	}
-	async clear() {
-		this.buckets.clear();
-	}
-	/**
-	* Start background cleanup of old buckets
-	* Removes buckets that haven't been used in a long time
-	*/
-	startCleanup() {
-		this.cleanupTimer = setInterval(() => {
-			const now = Date.now();
-			const maxAgeMs = 36e5;
-			let removed = 0;
-			for (const [key, bucket] of this.buckets.entries()) if (now - bucket.lastRefillAt > maxAgeMs) {
-				this.buckets.delete(key);
-				removed++;
-			}
-			if (removed > 0) {}
-		}, this.cleanupIntervalMs);
-	}
-	/**
-	* Stop cleanup timer
-	*/
-	destroy() {
-		if (this.cleanupTimer) {
-			clearInterval(this.cleanupTimer);
-			this.cleanupTimer = null;
-		}
-	}
-};
-
-//#endregion
-//#region src/decorators/use-case-decorator.ts
-/**
-* Base decorator that adds performance monitoring
-*/
-const withPerformanceMonitoring = (useCase, context, featureName) => {
-	return (async (...args) => {
-		const startTime = Date.now();
-		try {
-			const result = await useCase(...args);
-			const durationMs = Date.now() - startTime;
-			context.logger.debug(`${featureName}_completed`, {
-				requestId: context.requestId,
-				feature: featureName,
-				durationMs
-			});
-			return result;
-		} catch (error) {
-			const durationMs = Date.now() - startTime;
-			if (error instanceof AppError$1) context.logger.debug(`${featureName}_error`, {
-				requestId: context.requestId,
-				feature: featureName,
-				durationMs,
-				code: error.code,
-				severity: error.severity
-			});
-			throw error;
-		}
-	});
-};
-/**
-* Base decorator that adds error handling and conversion
-*/
-const withErrorHandling = (useCase, context, featureName) => {
-	return (async (...args) => {
-		try {
-			return await useCase(...args);
-		} catch (error) {
-			if (error instanceof AppError$1) throw error;
-			if (error instanceof Error) {
-				context.logger.error(`${featureName}_unexpected_error`, {
-					requestId: context.requestId,
-					feature: featureName,
-					errorName: error.name,
-					errorMessage: error.message,
-					stack: error.stack
-				});
-				throw new AppError$1("INTERNAL_SERVER_ERROR", `Unexpected error in ${featureName}`, {
-					statusCode: 500,
-					meta: {
-						originalError: error.message,
-						feature: featureName
-					}
-				});
-			}
-			context.logger.error(`${featureName}_unknown_error`, {
-				requestId: context.requestId,
-				feature: featureName
-			});
-			throw new AppError$1("INTERNAL_SERVER_ERROR", `Unknown error in ${featureName}`, {
-				statusCode: 500,
-				meta: { feature: featureName }
-			});
-		}
-	});
-};
-/**
-* Request tracing decorator - adds context to logs
-*/
-const withRequestTracing = (useCase, context, featureName) => {
-	return (async (...args) => {
-		context.logger.info(`${featureName}_started`, {
-			requestId: context.requestId,
-			userId: context.userId,
-			feature: featureName
-		});
-		try {
-			const result = await useCase(...args);
-			context.logger.info(`${featureName}_success`, {
-				requestId: context.requestId,
-				userId: context.userId,
-				feature: featureName
-			});
-			return result;
-		} catch (error) {
-			context.logger.error(`${featureName}_failed`, {
-				requestId: context.requestId,
-				userId: context.userId,
-				feature: featureName,
-				error: error instanceof Error ? error.message : "Unknown error"
-			});
-			throw error;
-		}
-	});
-};
-/**
-* Compose multiple decorators together
-* Order: Tracing → Performance → Error Handling
-* (outermost → innermost)
-*/
-const decorateUseCase = (useCase, context, featureName) => {
-	let decorated = withErrorHandling(useCase, context, featureName);
-	decorated = withPerformanceMonitoring(decorated, context, featureName);
-	decorated = withRequestTracing(decorated, context, featureName);
-	return decorated;
-};
-/**
-* Factory for creating decorated use cases
-* Used in dependency injection to wrap use cases automatically
-*/
-const makeDecoratedUseCase = (useCase, context, featureName) => {
-	return decorateUseCase(useCase, context, featureName);
-};
-
-//#endregion
-//#region src/decorators/apply-decorators.ts
-/**
-* Helper to apply decorators to use cases in module registration
-* Reduces boilerplate in feature modules
-*
-* Usage:
-* ```
-* getUserProfile: asFunction(({ userRepository, ...deps }) =>
-*   applyDecorators(
-*     makeGetUserProfile({ userRepository }),
-*     deps,
-*     'getUserProfile'
-*   )
-* ).scoped(),
-* ```
-*/
-const applyDecorators = (useCase, deps, featureName) => {
-	return decorateUseCase(useCase, {
-		logger: deps.logger,
-		requestId: deps.requestId,
-		feature: featureName
-	}, featureName);
-};
-
-//#endregion
-//#region src/decorators/with-caching.ts
-/**
-* Wraps a use case with caching
-* - Only works with idempotent read operations
-* - Key function determines cache key from input
-* - TTL controls cache expiration
-* - SWR allows returning stale value while revalidating
-*
-* @example
-* ```ts
-* const cachedGetUser = withCaching(
-*   getUserProfile,
-*   cacheStore,
-*   {
-*     keyFn: (input) => `user:${input.userId}`,
-*     ttlMs: 60000, // 1 minute
-*     staleWhileRevalidateMs: 120000, // 2 minutes
-*   }
-* )
-* ```
-*/
-const withCaching = (fn, cacheStore, options) => {
-	const cached = async (input) => {
-		const cacheKey = options.keyFn(input);
-		const cached$1 = await cacheStore.get(cacheKey);
-		if (cached$1 !== void 0) return cached$1;
-		const result = await fn(input);
-		await cacheStore.set(cacheKey, result, options.ttlMs);
-		return result;
-	};
-	Object.defineProperty(cached, "name", { value: `withCaching(${fn.name || "anonymous"})` });
-	return cached;
-};
-
-//#endregion
-//#region src/decorators/with-retry.ts
-/**
-* Wraps a use case with retry logic
-* - Uses exponential backoff
-* - Only retries on specific errors via retryOn predicate
-* - Backoff is capped at maxBackoffMs
-*
-* @example
-* ```ts
-* const retriedGetUser = withRetry(
-*   getUserProfile,
-*   {
-*     maxAttempts: 3,
-*     initialBackoffMs: 100,
-*     maxBackoffMs: 30000,
-*     backoffMultiplier: 2,
-*     retryOn: (error) => error.message.includes('TIMEOUT'),
-*   }
-* )
-* ```
-*/
-const withRetry = (fn, options = {}) => {
-	const maxAttempts = options.maxAttempts ?? 3;
-	const initialBackoffMs = options.initialBackoffMs ?? 100;
-	const maxBackoffMs = options.maxBackoffMs ?? 3e4;
-	const backoffMultiplier = options.backoffMultiplier ?? 2;
-	const retryOn = options.retryOn ?? ((error) => error instanceof Error);
-	const retried = async (...args) => {
-		let lastError = null;
-		let backoffMs = initialBackoffMs;
-		for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
-			return await fn(...args);
-		} catch (error) {
-			lastError = error instanceof Error ? error : new Error(String(error));
-			if (!retryOn(lastError)) throw error;
-			if (attempt < maxAttempts) {
-				await new Promise((resolve) => setTimeout(resolve, backoffMs));
-				backoffMs = Math.min(backoffMs * backoffMultiplier, maxBackoffMs);
-			}
-		}
-		throw lastError ?? /* @__PURE__ */ new Error("Retry failed without error");
-	};
-	Object.defineProperty(retried, "name", { value: `withRetry(${fn.name || "anonymous"})` });
-	return retried;
-};
-
-//#endregion
-//#region src/decorators/with-rate-limit.ts
-/**
-* Rate limit error
-*/
-var RateLimitError = class extends AppError {
-	constructor(resetAt) {
-		super(ErrorCode.RATE_LIMITED, `Rate limit exceeded. Reset at ${resetAt.toISOString()}`, {
-			statusCode: 429,
-			meta: { resetAt }
-		});
-		this.resetAt = resetAt;
-	}
-};
-/**
-* Wraps a use case with rate limiting
-* - Uses token bucket algorithm
-* - Per-input rate limit tracking via keyFn
-* - Throws RateLimitError when limit exceeded
-*
-* @example
-* ```ts
-* const limitedCreatePost = withRateLimit(
-*   createPost,
-*   rateLimiterStore,
-*   {
-*     keyFn: (input) => `user:${input.userId}`,
-*     capacity: 10,
-*     refillPerSecond: 1, // 1 request per second
-*   }
-* )
-* ```
-*/
-const withRateLimit = (fn, rateLimiterStore, options) => {
-	const limited = async (input) => {
-		const limitKey = options.keyFn(input);
-		const result = await rateLimiterStore.checkLimit(limitKey, options.capacity, options.refillPerSecond);
-		if (!result.allowed) throw new RateLimitError(result.resetAt);
-		return await fn(input);
-	};
-	Object.defineProperty(limited, "name", { value: `withRateLimit(${fn.name || "anonymous"})` });
-	return limited;
-};
-
-//#endregion
-//#region src/modules/core.module.ts
-/**
-* Core module: singleton registrations for infrastructure
-* - Database pool and connection
-* - Clock
-* - Logger (structured, Loki/Prometheus compatible)
-* - AI provider
-* - Auth
-*/
-const registerCoreModule = (container) => {
-	container.register({
-		dbPool: asFunction(({ config }) => createDbPool(config.databaseUrl)).singleton(),
-		db: asFunction(({ dbPool }) => createDb(dbPool)).singleton(),
-		clock: asValue(new SystemClock()),
-		logger: asFunction(({ config }) => makeStructuredLogger({
-			enableFile: config.enableFileLogging,
-			logDir: config.logDir,
-			minLevel: config.logLevel
-		})).singleton(),
-		errorHandler: asFunction(({ logger }) => makeErrorHandler(logger)).singleton(),
-		auth: asValue(auth),
-		aiProvider: asFunction(() => google("gemini-2.5-flash")).singleton(),
-		eventBus: asFunction(({ logger }) => new InMemoryEventBus(logger)).singleton(),
-		cacheStore: asClass(InMemoryCacheStore).singleton(),
-		rateLimiterStore: asClass(InMemoryRateLimiterStore).singleton(),
-		requestLogger: asFunction(({ logger, requestId, session }) => makeRequestLogger({
-			requestId,
-			userId: session?.user?.id,
-			baseLogger: logger
-		})).scoped()
-	});
-};
-
-//#endregion
-//#region src/modules/user.module.ts
-/**
-* User repository module: registers user-related repositories
-*
-* Note: Use case registrations are in apps/server/src/modules/user.module.ts
-* to maintain Clean Architecture layering (Infrastructure should not import Application)
-*/
-const registerUserModule = (container) => {
-	container.register({ userRepository: asFunction(({ db }) => makeDrizzleUserRepository(db)).scoped() });
-};
-
-//#endregion
 export { ErrorHandler, InMemoryCacheStore, InMemoryEventBus, InMemoryRateLimiterStore, RateLimitError, StructuredLogger, applyDecorators, createDb, createDbPool, decorateUseCase, makeDecoratedUseCase, makeDrizzleUserRepository, makeErrorHandler, makeEventPublisherAdapter, makeInMemoryEventPublisher, makeRequestLogger, makeStructuredLogger, registerCoreModule, registerUserModule, runInTransaction, withCaching, withErrorHandling, withPerformanceMonitoring, withRateLimit, withRequestTracing, withRetry };