stratal 0.0.13 → 0.0.14

package/dist/index.d.mts

@@ -0,0 +1,144 @@
+import { $t as Container, Ht as StratalEnv, It as VersioningOptions, Tt as RouterContext, U as HonoApp, ct as ModuleClass, it as DynamicModule } from "./index-C9bIk5tt.mjs";
+import { t as Constructor } from "./types-JUIHSW_a.mjs";
+import { l as LogLevel } from "./index-3TtGtYlJ.mjs";
+//#region src/execution-context.d.ts
+interface StratalExecutionContext {
+  waitUntil(promise: Promise<unknown>): void;
+}
+//#endregion
+//#region src/application.d.ts
+interface ApplicationConfig {
+  /** Root application module */
+  module: ModuleClass | DynamicModule;
+  /** Logging configuration. Defaults: level=INFO, formatter='json' */
+  logging?: {
+    level?: LogLevel;
+    formatter?: 'json' | 'pretty';
+  };
+  /**
+   * API versioning configuration.
+   * When provided, enables URI-based versioning for controllers.
+   */
+  versioning?: VersioningOptions;
+}
+interface ApplicationOptions extends ApplicationConfig {
+  env: StratalEnv;
+  ctx: StratalExecutionContext;
+}
+/**
+ * Application
+ *
+ * Main application class managing the two-tier container hierarchy:
+ * - Global Container: All services (singletons via tsyringe native)
+ * - Request Container: Child of global, context-enriched instances per request
+ *
+ * @example
+ * ```typescript
+ * const app = new Application({ module: AppModule, env, ctx })
+ * await app.initialize()
+ *
+ * // Access container via getter
+ * const service = app.container.resolve(MY_TOKEN)
+ *
+ * // Handle HTTP request (via HonoApp)
+ * // Handle queue batch
+ * await app.handleQueue(batch, 'my-queue')
+ * ```
+ */
+declare class Application {
+  /**
+   * Unified Container - manages all DI operations
+   */
+  private _container;
+  private honoApp;
+  private moduleRegistry;
+  private consumerRegistry;
+  private cronManager;
+  private initialized;
+  readonly env: StratalEnv;
+  private readonly appConfig;
+  constructor({
+    env,
+    ctx,
+    ...config
+  }: ApplicationOptions);
+  /**
+   * Get the Container instance
+   */
+  get container(): Container;
+  /**
+   * Get the HonoApp instance
+   */
+  get hono(): HonoApp;
+  initialize(): Promise<void>;
+  /**
+   * Resolve a service from the container
+   */
+  resolve<T>(token: symbol): T;
+  /**
+   * Handle queue batch processing
+   */
+  handleQueue(batch: MessageBatch, queueName: string): Promise<void>;
+  /**
+   * Handle scheduled cron trigger
+   */
+  handleScheduled(controller: ScheduledController): Promise<void>;
+  /**
+   * Create mock RouterContext for queue/cron/seeder processing
+   */
+  createMockRouterContext(locale?: string): RouterContext;
+  shutdown(): Promise<void>;
+  private registerQueueConsumers;
+  private registerCronJobs;
+  /**
+   * Auto-wire `@Listener()` classes with the EventRegistry.
+   */
+  private registerEventListeners;
+  /**
+   * Register LoggerService and dependencies
+   */
+  private registerLoggerService;
+  /**
+   * Register core services with explicit scope
+   */
+  private registerCoreServices;
+}
+//#endregion
+//#region src/stratal.d.ts
+/**
+ * Stratal — Hono-style entry point for Cloudflare Workers.
+ *
+ * Eagerly bootstraps the Application at construction time, dynamically
+ * importing `cloudflare:workers` for env and waitUntil.
+ *
+ * @example
+ * ```typescript
+ * import { Stratal } from 'stratal'
+ * import { AppModule } from './app.module'
+ *
+ * export default new Stratal({ module: AppModule })
+ * ```
+ */
+declare class Stratal<Env extends StratalEnv = StratalEnv> {
+  private app;
+  private initPromise;
+  private static _application;
+  constructor(config: ApplicationConfig);
+  fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
+  queue(batch: MessageBatch): Promise<void>;
+  scheduled(controller: ScheduledController): Promise<void>;
+  get hono(): Promise<HonoApp>;
+  shutdown(): Promise<void>;
+  /**
+   * @internal
+   * Resolves the Application instance from the static singleton.
+   * Used by worker base classes (DurableObject, Workflow, WorkerEntrypoint)
+   * to access the DI container without going through Cloudflare RPC.
+   */
+  static resolveApplication(): Promise<Application>;
+  private ensureReady;
+  private prepareApp;
+}
+//#endregion
+export { Application, ApplicationConfig, ApplicationOptions, Constructor, Stratal, StratalEnv, StratalExecutionContext };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/execution-context.ts","../src/application.ts","../src/stratal.ts"],"mappings":";;;;UAAiB,uBAAA;EACf,SAAA,CAAU,OAAA,EAAS,OAAA;AAAA;;;UCwBJ,iBAAA;;EAEf,MAAA,EAAQ,WAAA,GAAc,aAAA;ED1BtB;EC4BA,OAAA;IACE,KAAA,GAAQ,QAAA;IACR,SAAA;EAAA;;;;AANJ;EAYE,UAAA,GAAa,iBAAA;AAAA;AAAA,UAGE,kBAAA,SAA2B,iBAAA;EAC1C,GAAA,EAAK,UAAA;EACL,GAAA,EAAK,uBAAA;AAAA;;;;;;;;;;;;;;AAFP;;;;;;;cAyBa,WAAA;EAzB+B;;;EAAA,QA6BlC,UAAA;EAAA,QAEA,OAAA;EAAA,QACA,cAAA;EAAA,QACA,gBAAA;EAAA,QACA,WAAA;EAAA,QACA,WAAA;EAAA,SAEC,GAAA,EAAK,UAAA;EAAA,iBACG,SAAA;;IAEH,GAAA;IAAK,GAAA;IAAA,GAAQ;EAAA,GAAU,kBAAA;EAAlB;;;EAAA,IA+Bf,SAAA,CAAA,GAAa,SAAA;EAWG;;;EAAA,IAJhB,IAAA,CAAA,GAAQ,OAAA;EAIN,UAAA,CAAA,GAAc,OAAA;EA0EoC;;;EAjCxD,OAAA,GAAA,CAAW,KAAA,WAAgB,CAAA;EA0DF;;;EA7CnB,WAAA,CAAY,KAAA,EAAO,YAAA,EAAc,SAAA,WAAoB,OAAA;EAvGnD;;;EA2HF,eAAA,CAAgB,UAAA,EAAY,mBAAA,GAAsB,OAAA;EAvH1C;;;EAwId,uBAAA,CAAwB,MAAA,YAAgB,aAAA;EAQlC,QAAA,CAAA,GAAY,OAAA;EAAA,QAYV,sBAAA;EAAA,QAOA,gBAAA;EAhKmB;;;EAAA,QA0KnB,sBAAA;EApIJ;;;EAAA,QAyJI,qBAAA;EA5GR;;;EAAA,QAgIQ,oBAAA;AAAA;;;;;;ADnSV;;;;;;;;;;;cEqBa,OAAA,aAAoB,UAAA,GAAa,UAAA;EAAA,QACpC,GAAA;EAAA,QACA,WAAA;EAAA,eAEO,YAAA;cAEH,MAAA,EAAQ,iBAAA;EASd,KAAA,CAAM,OAAA,EAAS,OAAA,EAAS,GAAA,EAAK,GAAA,EAAK,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,QAAA;EAKlE,KAAA,CAAM,KAAA,EAAO,YAAA,GAAe,OAAA;EAK5B,SAAA,CAAU,UAAA,EAAY,mBAAA,GAAsB,OAAA;EAAA,IAK9C,IAAA,CAAA,GAAQ,OAAA,CAAQ,OAAA;EAId,QAAA,CAAA,GAAY,OAAA;ED5BlB;;;;;;EAAA,OC0CO,kBAAA,CAAA,GAAsB,OAAA,CAAQ,WAAA;EAAA,QAOvB,WAAA;EAAA,QAKA,UAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,14 @@
+import "./errors-BRJgVd5-.mjs";
+import "./logger-Bg-CuidS.mjs";
+import "./module-Dvzm4dhS.mjs";
+import "./events-CQyvSyrQ.mjs";
+import "./middleware-B3tx1u1K.mjs";
+import "./router-context-DlTxpJUG.mjs";
+import "./cron-manager-CpS_hrDD.mjs";
+import "./validation-DA5nptIp.mjs";
+import "./i18n.module-C9wQr_2k.mjs";
+import "./guards-B5o618bL.mjs";
+import "./gateway-context-D7TFPLi5.mjs";
+import "./queue.module-ZqaZ2iY0.mjs";
+import { n as Application, t as Stratal } from "./stratal-D4MS_7pI.mjs";
+export { Application, Stratal };

package/dist/logger/index.d.mts

@@ -0,0 +1,2 @@
+import { a as LogEntry, c as LOG_LEVEL_PRIORITY, i as LoggerService, l as LogLevel, n as PrettyFormatter, o as InternalLogContext, r as JsonFormatter, s as LogContext, t as ConsoleTransport, u as LOGGER_TOKENS } from "../index-3TtGtYlJ.mjs";
+export { ConsoleTransport, InternalLogContext, JsonFormatter, LOGGER_TOKENS, LOG_LEVEL_PRIORITY, LogContext, LogEntry, LogLevel, LoggerService, PrettyFormatter };

package/dist/logger/index.mjs

@@ -0,0 +1,2 @@
+import { c as LOG_LEVEL_PRIORITY, i as LoggerService, l as LogLevel, n as PrettyFormatter, r as JsonFormatter, t as ConsoleTransport, u as LOGGER_TOKENS } from "../logger-Bg-CuidS.mjs";
+export { ConsoleTransport, JsonFormatter, LOGGER_TOKENS, LOG_LEVEL_PRIORITY, LogLevel, LoggerService, PrettyFormatter };

package/dist/logger-Bg-CuidS.mjs

@@ -0,0 +1,417 @@
+import { inject, injectable } from "tsyringe";
+//#region src/di/tokens.ts
+/**
+* Token for the Container instance
+* Used for injecting the Container into services that need dynamic resolution
+*/
+const CONTAINER_TOKEN = Symbol.for("stratal:di:container");
+const DI_TOKENS = {
+	CloudflareEnv: Symbol.for("stratal:cloudflare:env"),
+	ExecutionContext: Symbol.for("stratal:execution:context"),
+	Container: CONTAINER_TOKEN,
+	Application: Symbol.for("stratal:application"),
+	ModuleRegistry: Symbol.for("stratal:module:registry"),
+	ErrorHandler: Symbol.for("stratal:error:handler"),
+	Database: Symbol.for("stratal:database:service"),
+	Queue: Symbol.for("stratal:queue:manager"),
+	ConsumerRegistry: Symbol.for("stratal:consumer:registry"),
+	Cron: Symbol.for("stratal:cron:manager"),
+	EventRegistry: Symbol.for("stratal:event:registry"),
+	AuthContext: Symbol.for("stratal:auth:context"),
+	DurableObjectState: Symbol.for("stratal:durable:object:state"),
+	DurableObjectId: Symbol.for("stratal:durable:object:id")
+};
+//#endregion
+//#region src/di/decorators/inject-param.decorator.ts
+/**
+* Metadata key for storing parameter injection information
+*/
+const INJECT_PARAM_METADATA_KEY = Symbol.for("stratal:inject:param");
+/**
+* Mark a method parameter for DI injection
+*
+* The parameter will be resolved from the request-scoped container
+* when the controller method is invoked.
+*
+* @param token - DI token to resolve (class or symbol)
+*
+* @example With class token
+* ```typescript
+* async show(
+*   ctx: RouterContext,
+*   @InjectParam(UserService) userService: UserService
+* ) { }
+* ```
+*
+* @example With symbol token
+* ```typescript
+* async show(
+*   ctx: RouterContext,
+*   @InjectParam(DI_TOKENS.Cache) cache: ICacheService
+* ) { }
+* ```
+*/
+function InjectParam(token) {
+	return (target, propertyKey, parameterIndex) => {
+		if (propertyKey === void 0) throw new Error("@InjectParam can only be used on method parameters, not constructor parameters");
+		const existingInjections = Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) ?? [];
+		existingInjections.push({
+			index: parameterIndex,
+			token
+		});
+		Reflect.defineMetadata(INJECT_PARAM_METADATA_KEY, existingInjections, target, propertyKey);
+	};
+}
+/**
+* Get method parameter injections
+*
+* @param target - Controller prototype
+* @param propertyKey - Method name
+* @returns Array of parameter injections sorted by index
+*/
+function getMethodInjections(target, propertyKey) {
+	return (Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) ?? []).sort((a, b) => a.index - b.index);
+}
+//#endregion
+//#region src/di/decorators.ts
+/**
+* DI Decorators
+*
+* Provides decorators for dependency injection:
+* - @Transient: Mark classes as injectable (lifecycle controlled at registration)
+* - @InjectParam: Inject dependencies into method parameters
+*
+* Lifecycle (Singleton, Request, Transient) is controlled at registration time
+* via the `scope` property in module providers or Container.register().
+*/
+/**
+* Mark a class as injectable
+*
+* This decorator wraps tsyringe's `@injectable` decorator and optionally
+* associates a token with the class. The actual lifecycle (Singleton, Request,
+* Transient) is determined at registration time, not decoration time.
+*
+* **Lifecycle Control:**
+* - Use `scope: Scope.Singleton` in module providers for singleton
+* - Use `scope: Scope.Request` in module providers for request-scoped
+* - Default is Transient (new instance per resolution)
+*
+* @param token - Optional DI token for service resolution
+*
+* @example Basic usage (no token)
+* ```typescript
+* @Transient()
+* export class UserService {
+*   constructor(@inject(DI_TOKENS.Database) private db: DatabaseService) {}
+* }
+*
+* // In module:
+* @Module({
+*   providers: [UserService]  // Transient by default
+* })
+* ```
+*
+* @example With token
+* ```typescript
+* @Transient(DI_TOKENS.ConnectionManager)
+* export class ConnectionManager implements Disposable {
+*   // ...
+* }
+*
+* // In Application.ts:
+* container.register(DI_TOKENS.ConnectionManager, ConnectionManager, Scope.Request)
+* ```
+*
+* @example Singleton via provider scope
+* ```typescript
+* @Transient()
+* export class ConsumerRegistry {
+*   // ...
+* }
+*
+* // In module:
+* @Module({
+*   providers: [
+*     { provide: DI_TOKENS.ConsumerRegistry, useClass: ConsumerRegistry, scope: Scope.Singleton }
+*   ]
+* })
+* ```
+*/
+function Transient(token) {
+	return function(target) {
+		const targetConstructor = target;
+		injectable({ token })(targetConstructor);
+		return target;
+	};
+}
+//#endregion
+//#region src/logger/logger.tokens.ts
+/**
+* Dependency Injection Tokens for Logger Module
+*
+* Symbol-based tokens ensure type-safe dependency injection
+* and prevent naming collisions.
+*/
+const LOGGER_TOKENS = {
+	LoggerService: Symbol.for("stratal:logger:service"),
+	Formatter: Symbol.for("stratal:logger:formatter"),
+	Transports: Symbol.for("stratal:logger:transports"),
+	ConsoleTransport: Symbol.for("stratal:logger:console:transport"),
+	LogLevelOptions: Symbol.for("stratal:logger:log:level:options")
+};
+//#endregion
+//#region src/logger/contracts/log-level.ts
+/**
+* Log severity levels
+* Ordered from least to most severe
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel["DEBUG"] = "debug";
+	LogLevel["INFO"] = "info";
+	LogLevel["WARN"] = "warn";
+	LogLevel["ERROR"] = "error";
+	return LogLevel;
+}({});
+/**
+* Map log levels to numeric priorities (for filtering)
+* Higher numbers = more severe = higher priority
+*/
+const LOG_LEVEL_PRIORITY = {
+	[LogLevel.DEBUG]: 0,
+	[LogLevel.INFO]: 1,
+	[LogLevel.WARN]: 2,
+	[LogLevel.ERROR]: 3
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/logger/services/logger.service.ts
+var _ref, _ref2;
+let LoggerService = class LoggerService {
+	constructor(logLevel, executionContext, formatter, transports) {
+		this.logLevel = logLevel;
+		this.executionContext = executionContext;
+		this.formatter = formatter;
+		this.transports = transports;
+	}
+	/**
+	* Log debug message (development only)
+	*/
+	debug(message, context) {
+		this.log(LogLevel.DEBUG, message, context);
+	}
+	/**
+	* Log info message
+	*/
+	info(message, context) {
+		this.log(LogLevel.INFO, message, context);
+	}
+	/**
+	* Log warning message
+	*/
+	warn(message, context) {
+		this.log(LogLevel.WARN, message, context);
+	}
+	/**
+	* Log error message
+	* Accepts Error object or custom context
+	*/
+	error(message, contextOrError) {
+		let context;
+		let error;
+		if (contextOrError instanceof Error) error = contextOrError;
+		else context = contextOrError;
+		this.log(LogLevel.ERROR, message, context, error);
+	}
+	/**
+	* Core logging implementation
+	* Enriches context, formats message, dispatches to transports
+	* Uses ctx.waitUntil() for async non-blocking processing
+	*/
+	log(level, message, userContext, error) {
+		if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.logLevel]) return;
+		const entry = {
+			level,
+			message,
+			context: this.enrichContext(userContext ?? {}),
+			error: error ? this.serializeError(error) : void 0
+		};
+		const formatted = this.formatter.format(entry);
+		const writePromises = this.transports.map((transport) => transport.write(entry, formatted).catch((err) => {
+			console.error(`Transport ${transport.name} failed:`, err);
+		}));
+		const allWrites = Promise.all(writePromises);
+		try {
+			this.executionContext.waitUntil(allWrites);
+		} catch (error) {
+			if (!(error instanceof Error) || !error.message.includes("global scope")) throw error;
+		}
+	}
+	/**
+	* Enrich log context with request info and timestamp
+	* Context enrichment can be extended by application modules
+	*/
+	enrichContext(userContext) {
+		return {
+			...userContext,
+			timestamp: Date.now()
+		};
+	}
+	/**
+	* Serialize Error object for transport
+	*/
+	serializeError(error) {
+		return {
+			message: error.message,
+			stack: error.stack,
+			name: error.name
+		};
+	}
+};
+LoggerService = __decorate([
+	Transient(),
+	__decorateParam(0, inject(LOGGER_TOKENS.LogLevelOptions)),
+	__decorateParam(1, inject(DI_TOKENS.ExecutionContext)),
+	__decorateParam(2, inject(LOGGER_TOKENS.Formatter)),
+	__decorateParam(3, inject(LOGGER_TOKENS.Transports)),
+	__decorateMetadata("design:paramtypes", [
+		typeof (_ref = typeof LogLevel !== "undefined" && LogLevel) === "function" ? _ref : Object,
+		typeof (_ref2 = typeof globalThis !== "undefined" && globalThis.ExecutionContext) === "function" ? _ref2 : Object,
+		Object,
+		Array
+	])
+], LoggerService);
+//#endregion
+//#region src/logger/formatters/json-formatter.ts
+/**
+* JSON Formatter
+*
+* Produces structured JSON logs for production environments.
+* Optimized for log aggregation systems (Cloudflare Analytics, Datadog, etc.)
+*
+* Output format:
+* {
+*   "level": "info",
+*   "message": "User logged in",
+*   "timestamp": 1234567890,
+*   "userId": "user_456",
+*   "error": { "message": "...", "stack": "..." }
+* }
+*/
+var JsonFormatter = class {
+	format(entry) {
+		const output = {
+			level: entry.level,
+			message: entry.message,
+			...entry.context,
+			...entry.error && { error: entry.error }
+		};
+		return JSON.stringify(output);
+	}
+};
+//#endregion
+//#region src/logger/formatters/pretty-formatter.ts
+/**
+* Pretty Formatter
+*
+* Human-readable colored output for development environments.
+* Uses ANSI color codes for terminal output.
+*
+* Output format:
+* [2024-01-15 10:30:45] INFO: User logged in
+*   userId: user_456
+*/
+var PrettyFormatter = class {
+	colors = {
+		[LogLevel.DEBUG]: "\x1B[36m",
+		[LogLevel.INFO]: "\x1B[32m",
+		[LogLevel.WARN]: "\x1B[33m",
+		[LogLevel.ERROR]: "\x1B[31m"
+	};
+	reset = "\x1B[0m";
+	format(entry) {
+		let output = `${this.colors[entry.level]}[${new Date(entry.context.timestamp).toISOString()}] ${entry.level.toUpperCase().padEnd(5)}${this.reset}: ${entry.message}`;
+		const { timestamp: _, ...contextWithoutTimestamp } = entry.context;
+		const contextEntries = Object.entries(contextWithoutTimestamp);
+		if (contextEntries.length > 0) {
+			output += "\n";
+			contextEntries.forEach(([key, value]) => {
+				output += `  ${key}: ${JSON.stringify(value)}\n`;
+			});
+		}
+		if (entry.error?.stack) output += `\n${entry.error.stack}\n`;
+		return output.trimEnd();
+	}
+};
+//#endregion
+//#region src/logger/transports/base-transport.ts
+/**
+* Base Transport
+*
+* Abstract base class providing shared transport logic.
+* Reduces code duplication across transport implementations.
+*/
+var BaseTransport = class {
+	/**
+	* Handle transport errors gracefully
+	* Logs to console.error as fallback to prevent log loss
+	*
+	* @param error - Error that occurred during write
+	* @param entry - Log entry that failed
+	*/
+	handleError(error, entry) {
+		console.error(`[${this.name}] Failed to write log:`, {
+			error: error instanceof Error ? error.message : String(error),
+			logMessage: entry.message,
+			level: entry.level
+		});
+	}
+};
+//#endregion
+//#region src/logger/transports/console-transport.ts
+let ConsoleTransport = class ConsoleTransport extends BaseTransport {
+	name = "console";
+	write(entry, formatted) {
+		try {
+			this.getConsoleMethod(entry.level)(formatted);
+		} catch (error) {
+			this.handleError(error, entry);
+		}
+		return Promise.resolve();
+	}
+	/**
+	* Map log level to console method
+	*/
+	getConsoleMethod(level) {
+		switch (level) {
+			case LogLevel.DEBUG: return console.debug;
+			case LogLevel.INFO: return console.info;
+			case LogLevel.WARN: return console.warn;
+			case LogLevel.ERROR: return console.error;
+			default: return console.log;
+		}
+	}
+};
+ConsoleTransport = __decorate([Transient(LOGGER_TOKENS.ConsoleTransport)], ConsoleTransport);
+//#endregion
+export { __decorate as a, LOG_LEVEL_PRIORITY as c, Transient as d, INJECT_PARAM_METADATA_KEY as f, DI_TOKENS as g, CONTAINER_TOKEN as h, LoggerService as i, LogLevel as l, getMethodInjections as m, PrettyFormatter as n, __decorateParam as o, InjectParam as p, JsonFormatter as r, __decorateMetadata as s, ConsoleTransport as t, LOGGER_TOKENS as u };
+
+//# sourceMappingURL=logger-Bg-CuidS.mjs.map

package/dist/logger-Bg-CuidS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-Bg-CuidS.mjs","names":[],"sources":["../src/di/tokens.ts","../src/di/decorators/inject-param.decorator.ts","../src/di/decorators.ts","../src/logger/logger.tokens.ts","../src/logger/contracts/log-level.ts","../src/logger/services/logger.service.ts","../src/logger/formatters/json-formatter.ts","../src/logger/formatters/pretty-formatter.ts","../src/logger/transports/base-transport.ts","../src/logger/transports/console-transport.ts"],"sourcesContent":["/**\n * Token for the Container instance\n * Used for injecting the Container into services that need dynamic resolution\n */\nexport const CONTAINER_TOKEN = Symbol.for('stratal:di:container')\n\nexport const DI_TOKENS = {\n  // Cloudflare\n  CloudflareEnv: Symbol.for('stratal:cloudflare:env'),\n  ExecutionContext: Symbol.for('stratal:execution:context'),\n\n  // Infrastructure\n  Container: CONTAINER_TOKEN,\n  Application: Symbol.for('stratal:application'),\n  ModuleRegistry: Symbol.for('stratal:module:registry'),\n  ErrorHandler: Symbol.for('stratal:error:handler'),\n  Database: Symbol.for('stratal:database:service'),\n  Queue: Symbol.for('stratal:queue:manager'),\n  ConsumerRegistry: Symbol.for('stratal:consumer:registry'),\n  Cron: Symbol.for('stratal:cron:manager'),\n  EventRegistry: Symbol.for('stratal:event:registry'),\n\n  // Context\n  /**\n   * AuthContext: Use for services that need user authentication (userId).\n   */\n  AuthContext: Symbol.for('stratal:auth:context'),\n\n  // Workers\n  DurableObjectState: Symbol.for('stratal:durable:object:state'),\n  DurableObjectId: Symbol.for('stratal:durable:object:id'),\n} as const\n\nexport type DIToken = typeof DI_TOKENS[keyof typeof DI_TOKENS]\n","/**\n * Method Parameter Injection Decorator\n *\n * Enables DI for controller method parameters. Parameters marked with\n * @InjectParam(token) are resolved from the request-scoped container\n * at method invocation time.\n *\n * @example\n * ```typescript\n * @Route({ response: userSchema })\n * async show(\n *   ctx: RouterContext,\n *   @InjectParam(UserService) userService: UserService,\n *   @InjectParam(CacheService) cache: CacheService\n * ): Promise<Response> {\n *   // userService and cache auto-resolved from request container\n * }\n * ```\n */\nimport type InjectionToken from 'tsyringe/dist/typings/providers/injection-token'\n\n/**\n * Metadata key for storing parameter injection information\n */\nexport const INJECT_PARAM_METADATA_KEY = Symbol.for('stratal:inject:param')\n\n/**\n * Describes a parameter injection\n */\nexport interface ParamInjection {\n  /** Parameter index in the method signature (0-based) */\n  index: number\n  /** DI token to resolve */\n  token: InjectionToken\n}\n\n/**\n * Mark a method parameter for DI injection\n *\n * The parameter will be resolved from the request-scoped container\n * when the controller method is invoked.\n *\n * @param token - DI token to resolve (class or symbol)\n *\n * @example With class token\n * ```typescript\n * async show(\n *   ctx: RouterContext,\n *   @InjectParam(UserService) userService: UserService\n * ) { }\n * ```\n *\n * @example With symbol token\n * ```typescript\n * async show(\n *   ctx: RouterContext,\n *   @InjectParam(DI_TOKENS.Cache) cache: ICacheService\n * ) { }\n * ```\n */\nexport function InjectParam<T>(token: InjectionToken<T>): ParameterDecorator {\n  return (target: object, propertyKey: string | symbol | undefined, parameterIndex: number) => {\n    if (propertyKey === undefined) {\n      throw new Error('@InjectParam can only be used on method parameters, not constructor parameters')\n    }\n\n    const existingInjections: ParamInjection[] =\n      (Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) as ParamInjection[] | undefined) ?? []\n\n    existingInjections.push({\n      index: parameterIndex,\n      token,\n    })\n\n    Reflect.defineMetadata(INJECT_PARAM_METADATA_KEY, existingInjections, target, propertyKey)\n  }\n}\n\n/**\n * Get method parameter injections\n *\n * @param target - Controller prototype\n * @param propertyKey - Method name\n * @returns Array of parameter injections sorted by index\n */\nexport function getMethodInjections(target: object, propertyKey: string | symbol): ParamInjection[] {\n  const injections: ParamInjection[] =\n    (Reflect.getMetadata(INJECT_PARAM_METADATA_KEY, target, propertyKey) as ParamInjection[] | undefined) ?? []\n\n  return injections.sort((a, b) => a.index - b.index)\n}\n","/**\n * DI Decorators\n *\n * Provides decorators for dependency injection:\n * - @Transient: Mark classes as injectable (lifecycle controlled at registration)\n * - @InjectParam: Inject dependencies into method parameters\n *\n * Lifecycle (Singleton, Request, Transient) is controlled at registration time\n * via the `scope` property in module providers or Container.register().\n */\nimport { injectable } from 'tsyringe'\nimport type InjectionToken from 'tsyringe/dist/typings/providers/injection-token'\n\n// Re-export method parameter injection\nexport {\n  InjectParam,\n  getMethodInjections,\n  type ParamInjection,\n  INJECT_PARAM_METADATA_KEY,\n} from './decorators/inject-param.decorator'\n\n/**\n * Mark a class as injectable\n *\n * This decorator wraps tsyringe's `@injectable` decorator and optionally\n * associates a token with the class. The actual lifecycle (Singleton, Request,\n * Transient) is determined at registration time, not decoration time.\n *\n * **Lifecycle Control:**\n * - Use `scope: Scope.Singleton` in module providers for singleton\n * - Use `scope: Scope.Request` in module providers for request-scoped\n * - Default is Transient (new instance per resolution)\n *\n * @param token - Optional DI token for service resolution\n *\n * @example Basic usage (no token)\n * ```typescript\n * @Transient()\n * export class UserService {\n *   constructor(@inject(DI_TOKENS.Database) private db: DatabaseService) {}\n * }\n *\n * // In module:\n * @Module({\n *   providers: [UserService]  // Transient by default\n * })\n * ```\n *\n * @example With token\n * ```typescript\n * @Transient(DI_TOKENS.ConnectionManager)\n * export class ConnectionManager implements Disposable {\n *   // ...\n * }\n *\n * // In Application.ts:\n * container.register(DI_TOKENS.ConnectionManager, ConnectionManager, Scope.Request)\n * ```\n *\n * @example Singleton via provider scope\n * ```typescript\n * @Transient()\n * export class ConsumerRegistry {\n *   // ...\n * }\n *\n * // In module:\n * @Module({\n *   providers: [\n *     { provide: DI_TOKENS.ConsumerRegistry, useClass: ConsumerRegistry, scope: Scope.Singleton }\n *   ]\n * })\n * ```\n */\nexport function Transient<T>(token?: InjectionToken<T>) {\n  return function <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction): TFunction {\n    const targetConstructor = target as unknown as new (...args: unknown[]) => T\n    injectable<T>({ token })(targetConstructor)\n    return target\n  }\n}\n","/**\n * Dependency Injection Tokens for Logger Module\n *\n * Symbol-based tokens ensure type-safe dependency injection\n * and prevent naming collisions.\n */\nexport const LOGGER_TOKENS = {\n  /**\n   * Main logger service facade\n   */\n  LoggerService: Symbol.for('stratal:logger:service'),\n\n  /**\n   * Log formatter (JSON or Pretty)\n   */\n  Formatter: Symbol.for('stratal:logger:formatter'),\n\n  /**\n   * Array of active transports\n   */\n  Transports: Symbol.for('stratal:logger:transports'),\n\n  /**\n   * Individual transport tokens (for factory registration)\n   */\n  ConsoleTransport: Symbol.for('stratal:logger:console:transport'),\n\n  /**\n   * Configured log level for filtering\n   */\n  LogLevelOptions: Symbol.for('stratal:logger:log:level:options'),\n} as const\n","/**\n * Log severity levels\n * Ordered from least to most severe\n */\nexport enum LogLevel {\n  DEBUG = 'debug',\n  INFO = 'info',\n  WARN = 'warn',\n  ERROR = 'error',\n}\n\n/**\n * Map log levels to numeric priorities (for filtering)\n * Higher numbers = more severe = higher priority\n */\nexport const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {\n  [LogLevel.DEBUG]: 0,\n  [LogLevel.INFO]: 1,\n  [LogLevel.WARN]: 2,\n  [LogLevel.ERROR]: 3,\n}\n","import { inject } from 'tsyringe'\nimport { Transient } from '../../di/decorators'\nimport { DI_TOKENS } from '../../di/tokens'\nimport type { InternalLogContext, LogContext, LogEntry } from '../contracts'\nimport { LOG_LEVEL_PRIORITY, LogLevel } from '../contracts/log-level'\nimport type { ILogFormatter } from '../formatters/formatter.interface'\nimport { LOGGER_TOKENS } from '../logger.tokens'\nimport type { ILogTransport } from '../transports/transport.interface'\n\n/**\n * Logger Service\n *\n * Main logging facade.\n *\n * **Features:**\n * - Async logging via ctx.waitUntil() for non-blocking performance\n * - Multi-transport support (console, future Sentry/Cloudflare Analytics)\n * - Configurable formatters (JSON production, Pretty development)\n * - Log level filtering based on environment\n *\n * **Architecture:**\n * - Transports and formatters injected via DI\n *\n * @example Basic usage\n * ```typescript\n * @Transient()\n * export class UserService {\n *   constructor(\n *     @inject(LOGGER_TOKENS.LoggerService)\n *     private readonly logger: LoggerService\n *   ) {}\n *\n *   async createUser(input: CreateUserInput) {\n *     this.logger.info('Creating user', { email: input.email })\n *   }\n * }\n * ```\n */\n@Transient()\nexport class LoggerService {\n  constructor(\n    @inject(LOGGER_TOKENS.LogLevelOptions)\n    private readonly logLevel: LogLevel,\n\n    @inject(DI_TOKENS.ExecutionContext)\n    private readonly executionContext: globalThis.ExecutionContext,\n\n    @inject(LOGGER_TOKENS.Formatter)\n    private readonly formatter: ILogFormatter,\n\n    @inject(LOGGER_TOKENS.Transports)\n    private readonly transports: ILogTransport[],\n  ) { }\n\n  /**\n   * Log debug message (development only)\n   */\n  debug(message: string, context?: LogContext): void {\n    this.log(LogLevel.DEBUG, message, context)\n  }\n\n  /**\n   * Log info message\n   */\n  info(message: string, context?: LogContext): void {\n    this.log(LogLevel.INFO, message, context)\n  }\n\n  /**\n   * Log warning message\n   */\n  warn(message: string, context?: LogContext): void {\n    this.log(LogLevel.WARN, message, context)\n  }\n\n  /**\n   * Log error message\n   * Accepts Error object or custom context\n   */\n  error(message: string, contextOrError?: LogContext | Error): void {\n    let context: LogContext | undefined\n    let error: Error | undefined\n\n    if (contextOrError instanceof Error) {\n      error = contextOrError\n    } else {\n      context = contextOrError\n    }\n\n    this.log(LogLevel.ERROR, message, context, error)\n  }\n\n  /**\n   * Core logging implementation\n   * Enriches context, formats message, dispatches to transports\n   * Uses ctx.waitUntil() for async non-blocking processing\n   */\n  private log(\n    level: LogLevel,\n    message: string,\n    userContext?: LogContext,\n    error?: Error\n  ): void {\n    // Filter by configured log level\n    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.logLevel]) {\n      return\n    }\n\n    // Build complete log entry with enriched context\n    const entry: LogEntry = {\n      level,\n      message,\n      context: this.enrichContext(userContext ?? {}),\n      error: error ? this.serializeError(error) : undefined,\n    }\n\n    // Format once for all transports\n    const formatted = this.formatter.format(entry)\n\n    // Dispatch to all transports asynchronously\n    const writePromises = this.transports.map(transport =>\n      transport.write(entry, formatted).catch((err: unknown) => {\n        // Swallow transport errors to prevent log failure from crashing app\n        console.error(`Transport ${transport.name} failed:`, err)\n      })\n    )\n\n    // Use waitUntil to ensure logs complete even after response sent\n    const allWrites = Promise.all(writePromises)\n    try {\n      this.executionContext.waitUntil(allWrites)\n    } catch (error) {\n      if (!(error instanceof Error) || !error.message.includes('global scope')) {\n        throw error\n      }\n    }\n  }\n\n  /**\n   * Enrich log context with request info and timestamp\n   * Context enrichment can be extended by application modules\n   */\n  private enrichContext(userContext: LogContext): InternalLogContext {\n    return {\n      ...userContext,\n      timestamp: Date.now(),\n    }\n  }\n\n  /**\n   * Serialize Error object for transport\n   */\n  private serializeError(error: Error): { message: string; stack?: string; name?: string } {\n    return {\n      message: error.message,\n      stack: error.stack,\n      name: error.name,\n    }\n  }\n}\n","import type { LogEntry } from '../contracts'\nimport type { ILogFormatter } from './formatter.interface'\n\n/**\n * JSON Formatter\n *\n * Produces structured JSON logs for production environments.\n * Optimized for log aggregation systems (Cloudflare Analytics, Datadog, etc.)\n *\n * Output format:\n * {\n *   \"level\": \"info\",\n *   \"message\": \"User logged in\",\n *   \"timestamp\": 1234567890,\n *   \"userId\": \"user_456\",\n *   \"error\": { \"message\": \"...\", \"stack\": \"...\" }\n * }\n */\nexport class JsonFormatter implements ILogFormatter {\n  format(entry: LogEntry): string {\n    const output = {\n      level: entry.level,\n      message: entry.message,\n      ...entry.context,\n      ...(entry.error && { error: entry.error }),\n    }\n\n    return JSON.stringify(output)\n  }\n}\n","import type { LogEntry } from '../contracts'\nimport { LogLevel } from '../contracts'\nimport type { ILogFormatter } from './formatter.interface'\n\n/**\n * Pretty Formatter\n *\n * Human-readable colored output for development environments.\n * Uses ANSI color codes for terminal output.\n *\n * Output format:\n * [2024-01-15 10:30:45] INFO: User logged in\n *   userId: user_456\n */\nexport class PrettyFormatter implements ILogFormatter {\n  private readonly colors: Record<LogLevel, string> = {\n    [LogLevel.DEBUG]: '\\x1b[36m', // Cyan\n    [LogLevel.INFO]: '\\x1b[32m', // Green\n    [LogLevel.WARN]: '\\x1b[33m', // Yellow\n    [LogLevel.ERROR]: '\\x1b[31m', // Red\n  }\n\n  private readonly reset = '\\x1b[0m'\n\n  format(entry: LogEntry): string {\n    const color = this.colors[entry.level]\n    const timestamp = new Date(entry.context.timestamp).toISOString()\n    const levelStr = entry.level.toUpperCase().padEnd(5)\n\n    let output = `${color}[${timestamp}] ${levelStr}${this.reset}: ${entry.message}`\n\n    // Add context (exclude timestamp)\n    const { timestamp: _, ...contextWithoutTimestamp } = entry.context\n    const contextEntries = Object.entries(contextWithoutTimestamp)\n\n    if (contextEntries.length > 0) {\n      output += '\\n'\n      contextEntries.forEach(([key, value]) => {\n        output += `  ${key}: ${JSON.stringify(value)}\\n`\n      })\n    }\n\n    // Add error stack if present\n    if (entry.error?.stack) {\n      output += `\\n${entry.error.stack}\\n`\n    }\n\n    return output.trimEnd()\n  }\n}\n","import type { ILogTransport } from './transport.interface'\nimport type { LogEntry } from '../contracts'\n\n/**\n * Base Transport\n *\n * Abstract base class providing shared transport logic.\n * Reduces code duplication across transport implementations.\n */\nexport abstract class BaseTransport implements ILogTransport {\n  abstract readonly name: string\n\n  /**\n   * Write log entry - must be implemented by concrete transports\n   */\n  abstract write(entry: LogEntry, formatted: string): Promise<void>\n\n  /**\n   * Handle transport errors gracefully\n   * Logs to console.error as fallback to prevent log loss\n   *\n   * @param error - Error that occurred during write\n   * @param entry - Log entry that failed\n   */\n  protected handleError(error: unknown, entry: LogEntry): void {\n    console.error(`[${this.name}] Failed to write log:`, {\n      error: error instanceof Error ? error.message : String(error),\n      logMessage: entry.message,\n      level: entry.level,\n    })\n  }\n}\n","import { Transient } from '../../di/decorators'\nimport { LOGGER_TOKENS } from '../logger.tokens'\nimport { BaseTransport } from './base-transport'\nimport type { LogEntry } from '../contracts'\nimport { LogLevel } from '../contracts'\n\n/**\n * Console Transport\n *\n * Writes logs to console using appropriate console methods.\n * Maps log levels to console.debug, console.info, console.warn, console.error.\n *\n * Thread-safe for Cloudflare Workers environment.\n */\n@Transient(LOGGER_TOKENS.ConsoleTransport)\nexport class ConsoleTransport extends BaseTransport {\n  readonly name = 'console'\n\n  write(entry: LogEntry, formatted: string): Promise<void> {\n    try {\n      const consoleMethod = this.getConsoleMethod(entry.level)\n      consoleMethod(formatted)\n    } catch (error) {\n      this.handleError(error, entry)\n    }\n\n    return Promise.resolve()\n  }\n\n  /**\n   * Map log level to console method\n   */\n  private getConsoleMethod(level: LogLevel): typeof console.log {\n    switch (level) {\n      case LogLevel.DEBUG:\n        return console.debug\n      case LogLevel.INFO:\n        return console.info\n      case LogLevel.WARN:\n        return console.warn\n      case LogLevel.ERROR:\n        return console.error\n      default:\n        return console.log\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/middleware/index.d.mts

@@ -0,0 +1,2 @@
+import { G as MiddlewareConsumerImpl, K as createMiddlewareConsumer, W as MiddlewareConfigurationService, _t as MiddlewareConfigEntry, bt as MiddlewareRouteTarget, gt as MiddlewareBuilder, vt as MiddlewareConfigurable, xt as RouteInfo, yt as MiddlewareConsumer } from "../index-C9bIk5tt.mjs";
+export { MiddlewareBuilder, MiddlewareConfigEntry, MiddlewareConfigurable, MiddlewareConfigurationService, MiddlewareConsumer, MiddlewareConsumerImpl, MiddlewareRouteTarget, RouteInfo, createMiddlewareConsumer };

package/dist/middleware/index.mjs

@@ -0,0 +1,5 @@
+import "../errors-BRJgVd5-.mjs";
+import "../logger-Bg-CuidS.mjs";
+import { o as MiddlewareConsumerImpl, s as createMiddlewareConsumer, t as MiddlewareConfigurationService } from "../middleware-B3tx1u1K.mjs";
+import "../router-context-DlTxpJUG.mjs";
+export { MiddlewareConfigurationService, MiddlewareConsumerImpl, createMiddlewareConsumer };