stratal 0.0.13 → 0.0.15

package/dist/router-context-BLn4PrRG.mjs

@@ -0,0 +1,264 @@
+import { n as RequestContainerNotInitializedError } from "./errors-CtCi1wn6.mjs";
+import { stream, streamSSE, streamText } from "hono/streaming";
+//#region src/router/constants.ts
+/**
+* Type-safe context keys for Hono router variables
+* Using symbols to avoid string collisions
+*/
+const ROUTER_CONTEXT_KEYS = {
+	REQUEST_CONTAINER: "requestContainer",
+	LOCALE: "locale"
+};
+/**
+* Metadata keys for storing route and controller configuration
+* Using symbols to avoid collisions with other decorators
+*/
+const ROUTE_METADATA_KEYS = {
+	CONTROLLER_ROUTE: Symbol.for("stratal:controller:route"),
+	CONTROLLER_OPTIONS: Symbol.for("stratal:controller:options"),
+	CONTROLLER_MIDDLEWARES: Symbol.for("stratal:controller:middlewares"),
+	ROUTE_CONFIG: Symbol.for("stratal:route:config"),
+	DECORATED_METHODS: Symbol.for("stratal:decorated:methods"),
+	HTTP_ROUTE_CONFIG: Symbol.for("stratal:http-route:config"),
+	HTTP_DECORATED_METHODS: Symbol.for("stratal:http-decorated:methods"),
+	AUTH_GUARD: Symbol.for("stratal:auth:guard"),
+	GATEWAY_MARKER: Symbol.for("stratal:gateway:marker"),
+	WS_ON_MESSAGE: Symbol.for("stratal:ws:on-message"),
+	WS_ON_CLOSE: Symbol.for("stratal:ws:on-close"),
+	WS_ON_ERROR: Symbol.for("stratal:ws:on-error")
+};
+/**
+* Security scheme identifiers for OpenAPI
+* These reference the security scheme definitions in security.schemas.ts
+*/
+const SECURITY_SCHEMES = {
+	BEARER_AUTH: "bearerAuth",
+	API_KEY: "apiKey",
+	SESSION_COOKIE: "sessionCookie"
+};
+/**
+* HTTP method mapping for RESTful controller methods
+* Maps controller method names to HTTP verbs and path patterns
+*/
+const HTTP_METHODS = {
+	index: {
+		method: "get",
+		path: ""
+	},
+	show: {
+		method: "get",
+		path: "/:id"
+	},
+	create: {
+		method: "post",
+		path: ""
+	},
+	update: {
+		method: "put",
+		path: "/:id"
+	},
+	patch: {
+		method: "patch",
+		path: "/:id"
+	},
+	destroy: {
+		method: "delete",
+		path: "/:id"
+	}
+};
+/**
+* Default success status codes for RESTful controller methods
+* Used by @Route() decorator to auto-derive response status
+*/
+const METHOD_STATUS_CODES = {
+	index: 200,
+	show: 200,
+	create: 201,
+	update: 200,
+	patch: 200,
+	destroy: 200
+};
+/**
+* Sentinel symbol to opt a controller out of versioning.
+* When used as the version, no prefix is applied even when defaultVersion is set.
+*/
+const VERSION_NEUTRAL = Symbol.for("stratal:version:neutral");
+/**
+* Default content type for request bodies and responses
+*/
+const DEFAULT_CONTENT_TYPE = "application/json";
+//#endregion
+//#region src/router/router-context.ts
+/**
+* Router context wrapper with helper methods
+*
+* Provides convenient access to Hono's context and common request/response operations.
+* The native Hono context is available via the `c` property for advanced use cases.
+*
+* @example
+* ```typescript
+* async index(ctx: RouterContext): Promise<Response> {
+*   // Use helper methods
+*   const users = await this.service.findAll()
+*   return ctx.json(users)
+* }
+*
+* async show(ctx: RouterContext): Promise<Response> {
+*   // Access route params
+*   const id = ctx.param('id')
+*   const user = await this.service.findById(id)
+*   return ctx.json(user)
+* }
+*
+* async create(ctx: RouterContext): Promise<Response> {
+*   // Parse request body
+*   const body = await ctx.body<CreateUserInput>()
+*   const user = await this.service.create(body)
+*   return ctx.json(user, 201)
+* }
+* ```
+*/
+var RouterContext = class {
+	/**
+	* Native Hono context
+	* Access for advanced use cases not covered by helper methods
+	*/
+	constructor(c) {
+		this.c = c;
+	}
+	/**
+	* Get request-scoped DI container
+	* Contains request-specific services and context (AuthContext)
+	*
+	* @throws Error if container not initialized
+	*/
+	getContainer() {
+		const container = this.c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER);
+		if (!container) throw new RequestContainerNotInitializedError();
+		return container;
+	}
+	/**
+	* Set locale for the current request
+	* Locale is determined by X-Locale header or defaults to config
+	*
+	* @param locale - Locale code (e.g., 'en', 'fr')
+	*/
+	setLocale(locale) {
+		this.c.set(ROUTER_CONTEXT_KEYS.LOCALE, locale);
+	}
+	/**
+	* Get locale for the current request
+	*
+	* @returns Current locale code
+	*/
+	getLocale() {
+		return this.c.get(ROUTER_CONTEXT_KEYS.LOCALE) || "en";
+	}
+	/**
+	* Return JSON response
+	*
+	* @param data - Data to serialize as JSON
+	* @param status - HTTP status code (default: 200)
+	*/
+	json(data, status) {
+		return this.c.json(data, status);
+	}
+	/**
+	* Get route parameter value
+	*
+	* @param key - Parameter name (e.g., 'id' for /users/:id)
+	*/
+	param(key) {
+		return this.c.req.valid("param")[key];
+	}
+	/**
+	* Get query parameter value
+	*
+	* @param key - Query parameter name
+	*/
+	query(key) {
+		const validated = this.c.req.valid("query");
+		return key ? validated[key] : validated;
+	}
+	/**
+	* Get request header value
+	*
+	* @param name - Header name (case-insensitive)
+	*/
+	header(name) {
+		return this.c.req.header(name);
+	}
+	/**
+	* Get validated request body from OpenAPI route
+	* Returns pre-validated data that has passed schema validation
+	*
+	* @returns Validated JSON body
+	*/
+	body() {
+		return this.c.req.valid("json");
+	}
+	/**
+	* Return text response
+	*
+	* @param text - Text content
+	* @param status - HTTP status code (default: 200)
+	*/
+	text(text, status) {
+		return this.c.text(text, status);
+	}
+	/**
+	* Return HTML response
+	*
+	* @param html - HTML content
+	* @param status - HTTP status code (default: 200)
+	*/
+	html(html, status) {
+		return this.c.html(html, status);
+	}
+	/**
+	* Redirect to another URL
+	*
+	* @param url - Target URL
+	* @param status - HTTP status code (default: 302)
+	*/
+	redirect(url, status) {
+		return this.c.redirect(url, status);
+	}
+	/**
+	* Return a streaming response (binary/generic)
+	*
+	* @param callback - Async function that writes to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	stream(callback, onError) {
+		return stream(this.c, callback, onError);
+	}
+	/**
+	* Return a streaming text response
+	*
+	* Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+	*
+	* @param callback - Async function that writes text to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	streamText(callback, onError) {
+		this.c.header("Content-Encoding", "Identity");
+		return streamText(this.c, callback, onError);
+	}
+	/**
+	* Return a Server-Sent Events (SSE) streaming response
+	*
+	* Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+	*
+	* @param callback - Async function that writes SSE events to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	streamSSE(callback, onError) {
+		this.c.header("Content-Encoding", "Identity");
+		return streamSSE(this.c, callback, onError);
+	}
+};
+//#endregion
+export { ROUTER_CONTEXT_KEYS as a, VERSION_NEUTRAL as c, METHOD_STATUS_CODES as i, DEFAULT_CONTENT_TYPE as n, ROUTE_METADATA_KEYS as o, HTTP_METHODS as r, SECURITY_SCHEMES as s, RouterContext as t };
+
+//# sourceMappingURL=router-context-BLn4PrRG.mjs.map

package/dist/router-context-BLn4PrRG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"router-context-BLn4PrRG.mjs","names":["honoStream","honoStreamText","honoStreamSSE"],"sources":["../src/router/constants.ts","../src/router/router-context.ts"],"sourcesContent":["/**\n * Type-safe context keys for Hono router variables\n * Using symbols to avoid string collisions\n */\nexport const ROUTER_CONTEXT_KEYS = {\n  REQUEST_CONTAINER: 'requestContainer',\n  LOCALE: 'locale'\n} as const satisfies Record<string, string>\n\n/**\n * Metadata keys for storing route and controller configuration\n * Using symbols to avoid collisions with other decorators\n */\nexport const ROUTE_METADATA_KEYS = {\n  CONTROLLER_ROUTE: Symbol.for('stratal:controller:route'),\n  CONTROLLER_OPTIONS: Symbol.for('stratal:controller:options'),\n  CONTROLLER_MIDDLEWARES: Symbol.for('stratal:controller:middlewares'),\n  ROUTE_CONFIG: Symbol.for('stratal:route:config'),\n  DECORATED_METHODS: Symbol.for('stratal:decorated:methods'),\n  HTTP_ROUTE_CONFIG: Symbol.for('stratal:http-route:config'),\n  HTTP_DECORATED_METHODS: Symbol.for('stratal:http-decorated:methods'),\n  AUTH_GUARD: Symbol.for('stratal:auth:guard'),\n  GATEWAY_MARKER: Symbol.for('stratal:gateway:marker'),\n  WS_ON_MESSAGE: Symbol.for('stratal:ws:on-message'),\n  WS_ON_CLOSE: Symbol.for('stratal:ws:on-close'),\n  WS_ON_ERROR: Symbol.for('stratal:ws:on-error'),\n} as const\n\n/**\n * Security scheme identifiers for OpenAPI\n * These reference the security scheme definitions in security.schemas.ts\n */\nexport const SECURITY_SCHEMES = {\n  BEARER_AUTH: 'bearerAuth',\n  API_KEY: 'apiKey',\n  SESSION_COOKIE: 'sessionCookie'\n} as const\n\n/**\n * HTTP method mapping for RESTful controller methods\n * Maps controller method names to HTTP verbs and path patterns\n */\nexport const HTTP_METHODS = {\n  index: { method: 'get', path: '' } as const,\n  show: { method: 'get', path: '/:id' } as const,\n  create: { method: 'post', path: '' } as const,\n  update: { method: 'put', path: '/:id' } as const,\n  patch: { method: 'patch', path: '/:id' } as const,\n  destroy: { method: 'delete', path: '/:id' } as const\n} as const\n\n/**\n * Default success status codes for RESTful controller methods\n * Used by @Route() decorator to auto-derive response status\n */\nexport const METHOD_STATUS_CODES = {\n  index: 200,\n  show: 200,\n  create: 201,\n  update: 200,\n  patch: 200,\n  destroy: 200\n} as const\n\n/**\n * Sentinel symbol to opt a controller out of versioning.\n * When used as the version, no prefix is applied even when defaultVersion is set.\n */\nexport const VERSION_NEUTRAL = Symbol.for('stratal:version:neutral')\n\n/**\n * Default content type for request bodies and responses\n */\nexport const DEFAULT_CONTENT_TYPE = 'application/json'\n","import type { Context } from 'hono'\nimport type { SSEStreamingApi } from 'hono/streaming'\nimport { stream as honoStream, streamSSE as honoStreamSSE, streamText as honoStreamText } from 'hono/streaming'\nimport type { ContentfulStatusCode, RedirectStatusCode } from 'hono/utils/http-status'\nimport type { StreamingApi } from 'hono/utils/stream'\nimport type { Container } from '../di/container'\nimport { RequestContainerNotInitializedError } from '../errors'\nimport { ROUTER_CONTEXT_KEYS } from './constants'\nimport type { RouterEnv } from './types'\n\nexport type ContextQueryResult<R extends Record<string, unknown> | undefined, K extends string | undefined> = K extends string ? string : R extends undefined ? Record<string, unknown> : R\n\n/**\n * Router context wrapper with helper methods\n *\n * Provides convenient access to Hono's context and common request/response operations.\n * The native Hono context is available via the `c` property for advanced use cases.\n *\n * @example\n * ```typescript\n * async index(ctx: RouterContext): Promise<Response> {\n *   // Use helper methods\n *   const users = await this.service.findAll()\n *   return ctx.json(users)\n * }\n *\n * async show(ctx: RouterContext): Promise<Response> {\n *   // Access route params\n *   const id = ctx.param('id')\n *   const user = await this.service.findById(id)\n *   return ctx.json(user)\n * }\n *\n * async create(ctx: RouterContext): Promise<Response> {\n *   // Parse request body\n *   const body = await ctx.body<CreateUserInput>()\n *   const user = await this.service.create(body)\n *   return ctx.json(user, 201)\n * }\n * ```\n */\nexport class RouterContext<T extends RouterEnv = RouterEnv> {\n  /**\n   * Native Hono context\n   * Access for advanced use cases not covered by helper methods\n   */\n  constructor(\n    public readonly c: Context<T>\n  ) { }\n\n  /**\n   * Get request-scoped DI container\n   * Contains request-specific services and context (AuthContext)\n   *\n   * @throws Error if container not initialized\n   */\n  getContainer(): Container {\n    const container = this.c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER)\n    if (!container) {\n      throw new RequestContainerNotInitializedError()\n    }\n    return container as Container\n  }\n\n  /**\n   * Set locale for the current request\n   * Locale is determined by X-Locale header or defaults to config\n   *\n   * @param locale - Locale code (e.g., 'en', 'fr')\n   */\n  setLocale(locale: string): void {\n    this.c.set(ROUTER_CONTEXT_KEYS.LOCALE, locale)\n  }\n\n  /**\n   * Get locale for the current request\n   *\n   * @returns Current locale code\n   */\n  getLocale(): string {\n    const locale = this.c.get(ROUTER_CONTEXT_KEYS.LOCALE)\n    return (locale as string) || 'en'\n  }\n\n  /**\n   * Return JSON response\n   *\n   * @param data - Data to serialize as JSON\n   * @param status - HTTP status code (default: 200)\n   */\n  json(data: object, status?: ContentfulStatusCode): Response {\n    return this.c.json(data, status)\n  }\n\n  /**\n   * Get route parameter value\n   *\n   * @param key - Parameter name (e.g., 'id' for /users/:id)\n   */\n  param(key: string): string {\n    return (this.c.req as unknown as { valid(target: 'param'): Record<string, string> }).valid('param')[key]\n  }\n\n  /**\n   * Get query parameter value\n   *\n   * @param key - Query parameter name\n   */\n  query<R extends Record<string, unknown> | undefined = undefined, K extends string | undefined = undefined>(key?: K): ContextQueryResult<R, K> {\n    const validated = (this.c.req as unknown as { valid(target: 'query'): Record<string, unknown> }).valid('query')\n    return key ? validated[key] as ContextQueryResult<R, K> : validated as ContextQueryResult<R, K>\n  }\n\n  /**\n   * Get request header value\n   *\n   * @param name - Header name (case-insensitive)\n   */\n  header(name: string): string | undefined {\n    return this.c.req.header(name)\n  }\n\n  /**\n   * Get validated request body from OpenAPI route\n   * Returns pre-validated data that has passed schema validation\n   *\n   * @returns Validated JSON body\n   */\n  body<T>(): Promise<T> {\n    // Type assertion needed because req.valid() is type-safe per route\n    // but this is a generic helper method that works across all routes\n    return (this.c.req as unknown as { valid(target: 'json'): Promise<T> }).valid('json')\n  }\n\n  /**\n   * Return text response\n   *\n   * @param text - Text content\n   * @param status - HTTP status code (default: 200)\n   */\n  text(text: string, status?: ContentfulStatusCode): Response {\n    return this.c.text(text, status)\n  }\n\n  /**\n   * Return HTML response\n   *\n   * @param html - HTML content\n   * @param status - HTTP status code (default: 200)\n   */\n  html(html: string, status?: ContentfulStatusCode): Response {\n    return this.c.html(html, status)\n  }\n\n  /**\n   * Redirect to another URL\n   *\n   * @param url - Target URL\n   * @param status - HTTP status code (default: 302)\n   */\n  redirect(url: string, status?: RedirectStatusCode): Response {\n    return this.c.redirect(url, status)\n  }\n\n  /**\n   * Return a streaming response (binary/generic)\n   *\n   * @param callback - Async function that writes to the stream\n   * @param onError - Optional error handler called if an error occurs during streaming\n   */\n  stream(callback: (stream: StreamingApi) => Promise<void>, onError?: (err: Error, stream: StreamingApi) => Promise<void>): Response {\n    return honoStream(this.c, callback, onError)\n  }\n\n  /**\n   * Return a streaming text response\n   *\n   * Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.\n   *\n   * @param callback - Async function that writes text to the stream\n   * @param onError - Optional error handler called if an error occurs during streaming\n   */\n  streamText(callback: (stream: StreamingApi) => Promise<void>, onError?: (err: Error, stream: StreamingApi) => Promise<void>): Response {\n    this.c.header('Content-Encoding', 'Identity')\n    return honoStreamText(this.c, callback, onError)\n  }\n\n  /**\n   * Return a Server-Sent Events (SSE) streaming response\n   *\n   * Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.\n   *\n   * @param callback - Async function that writes SSE events to the stream\n   * @param onError - Optional error handler called if an error occurs during streaming\n   */\n  streamSSE(callback: (stream: SSEStreamingApi) => Promise<void>, onError?: (err: Error, stream: SSEStreamingApi) => Promise<void>): Response {\n    this.c.header('Content-Encoding', 'Identity')\n    return honoStreamSSE(this.c, callback, onError)\n  }\n}\n"],"mappings":"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"}

package/dist/seeder/index.d.mts

@@ -0,0 +1,77 @@
+import { $t as Container, s as ApplicationError } from "../index-D69rxo8H.mjs";
+import { t as Constructor } from "../types-Cu4jkeiH.mjs";
+import { t as Application } from "../application-Du0d8O_e.mjs";
+import { t as Command } from "../command-DcebcSrL.mjs";
+
+//#region src/seeder/seeder.d.ts
+declare const SEEDER_INTERNALS: unique symbol;
+interface SeederContext {
+  run(SeederClass: Constructor<Seeder>): Promise<void>;
+  container: Container | null;
+}
+declare abstract class Seeder {
+  [SEEDER_INTERNALS]: SeederContext;
+  abstract run(): Promise<void>;
+  /** Call another seeder (like Laravel's $this->call()) */
+  protected call(SeederClass: Constructor<Seeder>): Promise<void>;
+}
+//#endregion
+//#region src/seeder/seeder-registry.d.ts
+declare const SEEDER_TOKENS: {
+  readonly SeederRegistry: symbol;
+};
+declare class SeederRegistry {
+  private app;
+  private seeders;
+  private nameIndex;
+  constructor(app: Application);
+  register(SeederClass: Constructor<Seeder>): void;
+  run(SeederClass: Constructor<Seeder>, options?: {
+    container?: Container;
+  }): Promise<void>;
+  runAll(options?: {
+    container?: Container;
+  }): Promise<void>;
+  find(name: string): Constructor<Seeder> | undefined;
+  has(SeederClass: Constructor<Seeder>): boolean;
+  list(): {
+    className: string;
+  }[];
+}
+//#endregion
+//#region src/seeder/commands/db-seed-list.command.d.ts
+declare class DbSeedListCommand extends Command {
+  private seeders;
+  static command: string;
+  static description: string;
+  constructor(seeders: SeederRegistry);
+  handle(): undefined | number;
+}
+//#endregion
+//#region src/seeder/commands/db-seed.command.d.ts
+declare class DbSeedCommand extends Command {
+  private seeders;
+  static command: string;
+  static description: string;
+  constructor(seeders: SeederRegistry);
+  handle(): Promise<number | undefined>;
+}
+//#endregion
+//#region src/seeder/errors.d.ts
+declare class SeederNotRegisteredError extends ApplicationError {
+  constructor(name: string);
+}
+declare class SeederNameCollisionError extends ApplicationError {
+  constructor(name: string);
+}
+//#endregion
+//#region src/seeder/is-seeder.d.ts
+/**
+ * Check if a class is a Seeder (extends Seeder base class).
+ *
+ * Used by ModuleRegistry for auto-discovery from providers.
+ */
+declare function isSeeder(target: Constructor): boolean;
+//#endregion
+export { DbSeedCommand, DbSeedListCommand, SEEDER_INTERNALS, SEEDER_TOKENS, Seeder, type SeederContext, SeederNameCollisionError, SeederNotRegisteredError, SeederRegistry, isSeeder };
+//# sourceMappingURL=index.d.mts.map

package/dist/seeder/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/seeder/seeder.ts","../../src/seeder/seeder-registry.ts","../../src/seeder/commands/db-seed-list.command.ts","../../src/seeder/commands/db-seed.command.ts","../../src/seeder/errors.ts","../../src/seeder/is-seeder.ts"],"mappings":";;;;;;cAGa,gBAAA;AAAA,UAEI,aAAA;EACf,GAAA,CAAI,WAAA,EAAa,WAAA,CAAY,MAAA,IAAU,OAAA;EACvC,SAAA,EAAW,SAAA;AAAA;AAAA,uBAGS,MAAA;EAAA,CACnB,gBAAA,GAAmB,aAAA;EAAA,SAKX,GAAA,CAAA,GAAO,OAAA;EAbwC;EAAA,UAgBxC,IAAA,CAAK,WAAA,EAAa,WAAA,CAAY,MAAA,IAAU,OAAA;AAAA;;;cCb7C,aAAA;EAAA,SAEH,cAAA;AAAA;AAAA,cAEG,cAAA;EAAA,QAIS,GAAA;EAAA,QAHZ,OAAA;EAAA,QACA,SAAA;cAEY,GAAA,EAAK,WAAA;EAEzB,QAAA,CAAS,WAAA,EAAa,WAAA,CAAY,MAAA;EAS5B,GAAA,CAAI,WAAA,EAAa,WAAA,CAAY,MAAA,GAAS,OAAA;IAAY,SAAA,GAAY,SAAA;EAAA,IAAc,OAAA;EAsB5E,MAAA,CAAO,OAAA;IAAY,SAAA,GAAY,SAAA;EAAA,IAAc,OAAA;EAMnD,IAAA,CAAK,IAAA,WAAe,WAAA,CAAY,MAAA;EAIhC,GAAA,CAAI,WAAA,EAAa,WAAA,CAAY,MAAA;EAI7B,IAAA,CAAA;IAAU,SAAA;EAAA;AAAA;;;cCzDC,iBAAA,SAA0B,OAAA;EAAA,QAIqB,OAAA;EAAA,OAHnD,OAAA;EAAA,OACA,WAAA;cAEmD,OAAA,EAAS,cAAA;EAInE,MAAA,CAAA;AAAA;;;cCRW,aAAA,SAAsB,OAAA;EAAA,QAIyB,OAAA;EAAA,OAHnD,OAAA;EAAA,OACA,WAAA;cAEmD,OAAA,EAAS,cAAA;EAI7D,MAAA,CAAA,GAAU,OAAA;AAAA;;;cCVL,wBAAA,SAAiC,gBAAA;cAChC,IAAA;AAAA;AAAA,cASD,wBAAA,SAAiC,gBAAA;cAChC,IAAA;AAAA;;;;;;;;iBCLE,QAAA,CAAS,MAAA,EAAQ,WAAA"}

package/dist/seeder/index.mjs

@@ -0,0 +1,7 @@
+import "../errors-CtCi1wn6.mjs";
+import "../decorate-D5j-d9_z.mjs";
+import "../logger-BR1-s1Um.mjs";
+import "../command-DG_u5ob2.mjs";
+import { n as SEEDER_INTERNALS, r as Seeder, t as isSeeder } from "../is-seeder-BN9Ej1r7.mjs";
+import { a as SeederNameCollisionError, i as SeederRegistry, n as DbSeedListCommand, o as SeederNotRegisteredError, r as SEEDER_TOKENS, t as DbSeedCommand } from "../seeder-DatfjJvU.mjs";
+export { DbSeedCommand, DbSeedListCommand, SEEDER_INTERNALS, SEEDER_TOKENS, Seeder, SeederNameCollisionError, SeederNotRegisteredError, SeederRegistry, isSeeder };

package/dist/seeder-DatfjJvU.mjs

@@ -0,0 +1,132 @@
+import { S as ApplicationError, b as ERROR_CODES } from "./errors-CtCi1wn6.mjs";
+import { n as __decorateParam, r as __decorateMetadata, t as __decorate } from "./decorate-D5j-d9_z.mjs";
+import { t as Command } from "./command-DG_u5ob2.mjs";
+import { n as SEEDER_INTERNALS } from "./is-seeder-BN9Ej1r7.mjs";
+import { inject } from "tsyringe";
+//#region src/seeder/errors.ts
+var SeederNotRegisteredError = class extends ApplicationError {
+	constructor(name) {
+		super("errors.seederNotRegistered", ERROR_CODES.SYSTEM.SEEDER_NOT_REGISTERED, { name });
+	}
+};
+var SeederNameCollisionError = class extends ApplicationError {
+	constructor(name) {
+		super("errors.seederNameCollision", ERROR_CODES.SYSTEM.SEEDER_NAME_COLLISION, { name });
+	}
+};
+//#endregion
+//#region src/seeder/seeder-registry.ts
+const SEEDER_TOKENS = { SeederRegistry: Symbol.for("stratal:seeders:registry") };
+var SeederRegistry = class {
+	seeders = /* @__PURE__ */ new Set();
+	nameIndex = /* @__PURE__ */ new Map();
+	constructor(app) {
+		this.app = app;
+	}
+	register(SeederClass) {
+		const existing = this.nameIndex.get(SeederClass.name);
+		if (existing && existing !== SeederClass) throw new SeederNameCollisionError(SeederClass.name);
+		this.seeders.add(SeederClass);
+		this.nameIndex.set(SeederClass.name, SeederClass);
+	}
+	async run(SeederClass, options) {
+		if (!this.seeders.has(SeederClass)) throw new SeederNotRegisteredError(SeederClass.name);
+		const execute = async (container) => {
+			const seeder = container.resolve(SeederClass);
+			seeder[SEEDER_INTERNALS] = {
+				run: (cls) => this.run(cls, { container }),
+				container
+			};
+			await seeder.run();
+		};
+		if (options?.container) await execute(options.container);
+		else {
+			const mockContext = this.app.createMockRouterContext("en");
+			await this.app.container.runInRequestScope(mockContext, execute);
+		}
+	}
+	async runAll(options) {
+		for (const SeederClass of this.seeders) await this.run(SeederClass, options);
+	}
+	find(name) {
+		return this.nameIndex.get(name);
+	}
+	has(SeederClass) {
+		return this.seeders.has(SeederClass);
+	}
+	list() {
+		return [...this.seeders].map((cls) => ({ className: cls.name }));
+	}
+};
+//#endregion
+//#region src/seeder/commands/db-seed-list.command.ts
+let DbSeedListCommand = class DbSeedListCommand extends Command {
+	static command = "db:seed:list";
+	static description = "List available database seeders";
+	constructor(seeders) {
+		super();
+		this.seeders = seeders;
+	}
+	handle() {
+		const list = this.seeders.list();
+		if (list.length === 0) {
+			this.info("No seeders found");
+			return 0;
+		}
+		this.table(["Class"], list.map((s) => [s.className]));
+	}
+};
+DbSeedListCommand = __decorate([__decorateParam(0, inject(SEEDER_TOKENS.SeederRegistry)), __decorateMetadata("design:paramtypes", [Object])], DbSeedListCommand);
+//#endregion
+//#region src/seeder/commands/db-seed.command.ts
+let DbSeedCommand = class DbSeedCommand extends Command {
+	static command = "db:seed {name? : Seeder class name} {--a|all : Run all seeders} {--dry-run : Preview without executing}";
+	static description = "Run database seeders";
+	constructor(seeders) {
+		super();
+		this.seeders = seeders;
+	}
+	async handle() {
+		const name = this.string("name");
+		const all = this.boolean("all");
+		const dryRun = this.boolean("dry-run");
+		if (name && all) this.warn(`Ignoring "${name}" because --all takes precedence`);
+		if (!name && !all) {
+			this.fail("Specify a seeder class name or use --all");
+			return 1;
+		}
+		if (dryRun) {
+			const list = this.seeders.list();
+			if (all) {
+				this.info("Dry run — would execute:");
+				for (const s of list) this.info(`  ${s.className}`);
+			} else {
+				const SeederClass = this.seeders.find(name);
+				if (!SeederClass) {
+					this.fail(`Seeder "${name}" not found`);
+					return 1;
+				}
+				this.info(`Dry run — would execute: ${SeederClass.name}`);
+			}
+			return 0;
+		}
+		if (all) {
+			await this.seeders.runAll();
+			this.success("All seeders completed");
+		} else {
+			const SeederClass = this.seeders.find(name);
+			if (!SeederClass) {
+				this.fail(`Seeder "${name}" not found`);
+				return 1;
+			}
+			await this.seeders.run(SeederClass);
+			this.success(`Seeder "${name}" completed`);
+		}
+		return 0;
+	}
+};
+DbSeedCommand = __decorate([__decorateParam(0, inject(SEEDER_TOKENS.SeederRegistry)), __decorateMetadata("design:paramtypes", [Object])], DbSeedCommand);
+//#endregion
+export { SeederNameCollisionError as a, SeederRegistry as i, DbSeedListCommand as n, SeederNotRegisteredError as o, SEEDER_TOKENS as r, DbSeedCommand as t };
+
+//# sourceMappingURL=seeder-DatfjJvU.mjs.map

package/dist/seeder-DatfjJvU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeder-DatfjJvU.mjs","names":[],"sources":["../src/seeder/errors.ts","../src/seeder/seeder-registry.ts","../src/seeder/commands/db-seed-list.command.ts","../src/seeder/commands/db-seed.command.ts"],"sourcesContent":["import { ApplicationError, ERROR_CODES } from '../errors'\n\nexport class SeederNotRegisteredError extends ApplicationError {\n  constructor(name: string) {\n    super(\n      'errors.seederNotRegistered',\n      ERROR_CODES.SYSTEM.SEEDER_NOT_REGISTERED,\n      { name },\n    )\n  }\n}\n\nexport class SeederNameCollisionError extends ApplicationError {\n  constructor(name: string) {\n    super(\n      'errors.seederNameCollision',\n      ERROR_CODES.SYSTEM.SEEDER_NAME_COLLISION,\n      { name },\n    )\n  }\n}\n","import type { Application } from '../application'\nimport type { Container } from '../di/container'\nimport type { Constructor } from '../types'\nimport { SeederNameCollisionError, SeederNotRegisteredError } from './errors'\nimport { type Seeder, SEEDER_INTERNALS } from './seeder'\n\nexport const SEEDER_TOKENS = {\n  SeederRegistry: Symbol.for('stratal:seeders:registry'),\n} as const\n\nexport class SeederRegistry {\n  private seeders = new Set<Constructor<Seeder>>()\n  private nameIndex = new Map<string, Constructor<Seeder>>()\n\n  constructor(private app: Application) { }\n\n  register(SeederClass: Constructor<Seeder>): void {\n    const existing = this.nameIndex.get(SeederClass.name)\n    if (existing && existing !== SeederClass) {\n      throw new SeederNameCollisionError(SeederClass.name)\n    }\n    this.seeders.add(SeederClass)\n    this.nameIndex.set(SeederClass.name, SeederClass)\n  }\n\n  async run(SeederClass: Constructor<Seeder>, options?: { container?: Container }): Promise<void> {\n    if (!this.seeders.has(SeederClass)) {\n      throw new SeederNotRegisteredError(SeederClass.name)\n    }\n\n    const execute = async (container: Container) => {\n      const seeder = container.resolve<Seeder>(SeederClass)\n      seeder[SEEDER_INTERNALS] = {\n        run: (cls) => this.run(cls, { container }),\n        container,\n      }\n      await seeder.run()\n    }\n\n    if (options?.container) {\n      await execute(options.container)\n    } else {\n      const mockContext = this.app.createMockRouterContext('en')\n      await this.app.container.runInRequestScope(mockContext, execute)\n    }\n  }\n\n  async runAll(options?: { container?: Container }): Promise<void> {\n    for (const SeederClass of this.seeders) {\n      await this.run(SeederClass, options)\n    }\n  }\n\n  find(name: string): Constructor<Seeder> | undefined {\n    return this.nameIndex.get(name)\n  }\n\n  has(SeederClass: Constructor<Seeder>): boolean {\n    return this.seeders.has(SeederClass)\n  }\n\n  list(): { className: string }[] {\n    return [...this.seeders].map(cls => ({ className: cls.name }))\n  }\n}\n","import { inject } from 'tsyringe'\nimport { Command } from '../../quarry/command'\nimport { type SeederRegistry, SEEDER_TOKENS } from '../seeder-registry'\n\nexport class DbSeedListCommand extends Command {\n  static command = 'db:seed:list'\n  static description = 'List available database seeders'\n\n  constructor(@inject(SEEDER_TOKENS.SeederRegistry) private seeders: SeederRegistry) {\n    super()\n  }\n\n  handle(): undefined | number {\n    const list = this.seeders.list()\n    if (list.length === 0) {\n      this.info('No seeders found')\n      return 0\n    }\n    this.table(['Class'], list.map(s => [s.className]))\n\n    return undefined\n  }\n}\n","import { inject } from 'tsyringe'\nimport { Command } from '../../quarry/command'\nimport { type SeederRegistry, SEEDER_TOKENS } from '../seeder-registry'\n\nexport class DbSeedCommand extends Command {\n  static command = 'db:seed {name? : Seeder class name} {--a|all : Run all seeders} {--dry-run : Preview without executing}'\n  static description = 'Run database seeders'\n\n  constructor(@inject(SEEDER_TOKENS.SeederRegistry) private seeders: SeederRegistry) {\n    super()\n  }\n\n  async handle(): Promise<number | undefined> {\n    const name = this.string('name')\n    const all = this.boolean('all')\n    const dryRun = this.boolean('dry-run')\n\n    if (name && all) {\n      this.warn(`Ignoring \"${name}\" because --all takes precedence`)\n    }\n\n    if (!name && !all) {\n      this.fail('Specify a seeder class name or use --all')\n      return 1\n    }\n\n    if (dryRun) {\n      const list = this.seeders.list()\n      if (all) {\n        this.info('Dry run — would execute:')\n        for (const s of list) {\n          this.info(`  ${s.className}`)\n        }\n      } else {\n        const SeederClass = this.seeders.find(name)\n        if (!SeederClass) {\n          this.fail(`Seeder \"${name}\" not found`)\n          return 1\n        }\n        this.info(`Dry run — would execute: ${SeederClass.name}`)\n      }\n      return 0\n    }\n\n    if (all) {\n      await this.seeders.runAll()\n      this.success('All seeders completed')\n    } else {\n      const SeederClass = this.seeders.find(name)\n      if (!SeederClass) {\n        this.fail(`Seeder \"${name}\" not found`)\n        return 1\n      }\n      await this.seeders.run(SeederClass)\n      this.success(`Seeder \"${name}\" completed`)\n    }\n\n    return 0\n  }\n}\n"],"mappings":"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"}

package/dist/smtp.provider-Cj7BUFbJ.mjs

@@ -0,0 +1,78 @@
+import "./errors-CtCi1wn6.mjs";
+import "./decorate-D5j-d9_z.mjs";
+import "./logger-BR1-s1Um.mjs";
+import { EmailSmtpConnectionFailedError, SmtpConfigurationMissingError, SmtpHostMissingError } from "./email/index.mjs";
+import { t as BaseEmailProvider } from "./base-email.provider-CNwsPbwm.mjs";
+import * as nodemailer from "nodemailer";
+import { Readable } from "stream";
+//#region src/email/providers/smtp.provider.ts
+/**
+* SMTP Email Provider
+*
+* Implementation of IEmailProvider using SMTP/nodemailer
+* Supports any SMTP server configured via SMTP_URL
+*/
+var SmtpProvider = class extends BaseEmailProvider {
+	transporter;
+	defaultFrom;
+	constructor(options) {
+		super();
+		this.options = options;
+		if (!this.options.smtp) throw new SmtpConfigurationMissingError();
+		if (!this.options.smtp.host) throw new SmtpHostMissingError();
+		this.transporter = nodemailer.createTransport({
+			host: this.options.smtp.host,
+			port: this.options.smtp.port,
+			secure: this.options.smtp.secure,
+			auth: this.options.smtp.username && this.options.smtp.password ? {
+				user: this.options.smtp.username,
+				pass: this.options.smtp.password
+			} : void 0
+		});
+		this.defaultFrom = this.options.from;
+	}
+	async send(message) {
+		try {
+			const from = message.from ? `${message.from.name} <${message.from.email}>` : `${this.defaultFrom.name} <${this.defaultFrom.email}>`;
+			const info = await this.transporter.sendMail({
+				from,
+				to: Array.isArray(message.to) ? message.to.join(", ") : message.to,
+				subject: message.subject,
+				html: message.html,
+				text: message.text,
+				replyTo: message.replyTo,
+				cc: message.cc?.join(", "),
+				bcc: message.bcc?.join(", "),
+				attachments: message.attachments?.map((attachment) => ({
+					filename: attachment.filename,
+					content: this.toNodeStream(attachment.content),
+					contentType: attachment.contentType
+				}))
+			});
+			return {
+				messageId: info.messageId,
+				accepted: true,
+				metadata: {
+					provider: "smtp",
+					response: info.response
+				}
+			};
+		} catch {
+			throw new EmailSmtpConnectionFailedError(this.options.smtp?.host ?? "", this.options.smtp?.port ?? 587);
+		}
+	}
+	/**
+	* Convert attachment content to Node.js stream format
+	*
+	* Nodemailer expects Node.js Readable streams, not web ReadableStream.
+	* Buffer is passed through as-is since nodemailer supports it directly.
+	*/
+	toNodeStream(content) {
+		if (Buffer.isBuffer(content)) return content;
+		return Readable.fromWeb(content);
+	}
+};
+//#endregion
+export { SmtpProvider };
+
+//# sourceMappingURL=smtp.provider-Cj7BUFbJ.mjs.map

package/dist/smtp.provider-Cj7BUFbJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"smtp.provider-Cj7BUFbJ.mjs","names":[],"sources":["../src/email/providers/smtp.provider.ts"],"sourcesContent":["import type { Transporter } from 'nodemailer'\nimport * as nodemailer from 'nodemailer'\nimport type SMTPTransport from 'nodemailer/lib/smtp-transport'\nimport { Readable } from 'stream'\nimport type { ResolvedEmailAttachment, ResolvedEmailMessage } from '../contracts'\nimport type { EmailModuleOptions } from '../email.module'\nimport { EmailSmtpConnectionFailedError, SmtpConfigurationMissingError, SmtpHostMissingError } from '../errors'\nimport { BaseEmailProvider } from './base-email.provider'\nimport type { EmailSendResult } from './email-provider.interface'\n\n/**\n * SMTP Email Provider\n *\n * Implementation of IEmailProvider using SMTP/nodemailer\n * Supports any SMTP server configured via SMTP_URL\n */\nexport class SmtpProvider extends BaseEmailProvider {\n  private readonly transporter: Transporter<SMTPTransport.SentMessageInfo>\n  private readonly defaultFrom: { name: string; email: string }\n\n  constructor(\n    private readonly options: EmailModuleOptions\n  ) {\n    super()\n\n    // Validate SMTP configuration\n    if (!this.options.smtp) {\n      throw new SmtpConfigurationMissingError()\n    }\n\n    if (!this.options.smtp.host) {\n      throw new SmtpHostMissingError()\n    }\n\n    // Create nodemailer transporter\n    this.transporter = nodemailer.createTransport({\n      host: this.options.smtp.host,\n      port: this.options.smtp.port,\n      secure: this.options.smtp.secure,\n      auth: this.options.smtp.username && this.options.smtp.password\n        ? {\n          user: this.options.smtp.username,\n          pass: this.options.smtp.password,\n        }\n        : undefined,\n    })\n\n    this.defaultFrom = this.options.from\n  }\n\n  async send(message: ResolvedEmailMessage): Promise<EmailSendResult> {\n    try {\n      const from = message.from\n        ? `${message.from.name} <${message.from.email}>`\n        : `${this.defaultFrom.name} <${this.defaultFrom.email}>`\n\n      const info = await this.transporter.sendMail({\n        from,\n        to: Array.isArray(message.to) ? message.to.join(', ') : message.to,\n        subject: message.subject,\n        html: message.html,\n        text: message.text,\n        replyTo: message.replyTo,\n        cc: message.cc?.join(', '),\n        bcc: message.bcc?.join(', '),\n        attachments: message.attachments?.map(attachment => ({\n          filename: attachment.filename,\n          content: this.toNodeStream(attachment.content),\n          contentType: attachment.contentType,\n        })),\n      })\n\n      return {\n        messageId: info.messageId,\n        accepted: true,\n        metadata: {\n          provider: 'smtp',\n          response: info.response,\n        },\n      }\n    } catch {\n      throw new EmailSmtpConnectionFailedError(\n        this.options.smtp?.host ?? '',\n        this.options.smtp?.port ?? 587\n      )\n    }\n  }\n\n  /**\n   * Convert attachment content to Node.js stream format\n   *\n   * Nodemailer expects Node.js Readable streams, not web ReadableStream.\n   * Buffer is passed through as-is since nodemailer supports it directly.\n   */\n  private toNodeStream(content: ResolvedEmailAttachment['content']): Buffer | Readable {\n    if (Buffer.isBuffer(content)) {\n      return content\n    }\n    // Convert web ReadableStream to Node.js Readable\n    return Readable.fromWeb(content as Parameters<typeof Readable.fromWeb>[0])\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,IAAa,eAAb,cAAkC,kBAAkB;CAClD;CACA;CAEA,YACE,SACA;AACA,SAAO;AAFU,OAAA,UAAA;AAKjB,MAAI,CAAC,KAAK,QAAQ,KAChB,OAAM,IAAI,+BAA+B;AAG3C,MAAI,CAAC,KAAK,QAAQ,KAAK,KACrB,OAAM,IAAI,sBAAsB;AAIlC,OAAK,cAAc,WAAW,gBAAgB;GAC5C,MAAM,KAAK,QAAQ,KAAK;GACxB,MAAM,KAAK,QAAQ,KAAK;GACxB,QAAQ,KAAK,QAAQ,KAAK;GAC1B,MAAM,KAAK,QAAQ,KAAK,YAAY,KAAK,QAAQ,KAAK,WAClD;IACA,MAAM,KAAK,QAAQ,KAAK;IACxB,MAAM,KAAK,QAAQ,KAAK;IACzB,GACC,KAAA;GACL,CAAC;AAEF,OAAK,cAAc,KAAK,QAAQ;;CAGlC,MAAM,KAAK,SAAyD;AAClE,MAAI;GACF,MAAM,OAAO,QAAQ,OACjB,GAAG,QAAQ,KAAK,KAAK,IAAI,QAAQ,KAAK,MAAM,KAC5C,GAAG,KAAK,YAAY,KAAK,IAAI,KAAK,YAAY,MAAM;GAExD,MAAM,OAAO,MAAM,KAAK,YAAY,SAAS;IAC3C;IACA,IAAI,MAAM,QAAQ,QAAQ,GAAG,GAAG,QAAQ,GAAG,KAAK,KAAK,GAAG,QAAQ;IAChE,SAAS,QAAQ;IACjB,MAAM,QAAQ;IACd,MAAM,QAAQ;IACd,SAAS,QAAQ;IACjB,IAAI,QAAQ,IAAI,KAAK,KAAK;IAC1B,KAAK,QAAQ,KAAK,KAAK,KAAK;IAC5B,aAAa,QAAQ,aAAa,KAAI,gBAAe;KACnD,UAAU,WAAW;KACrB,SAAS,KAAK,aAAa,WAAW,QAAQ;KAC9C,aAAa,WAAW;KACzB,EAAE;IACJ,CAAC;AAEF,UAAO;IACL,WAAW,KAAK;IAChB,UAAU;IACV,UAAU;KACR,UAAU;KACV,UAAU,KAAK;KAChB;IACF;UACK;AACN,SAAM,IAAI,+BACR,KAAK,QAAQ,MAAM,QAAQ,IAC3B,KAAK,QAAQ,MAAM,QAAQ,IAC5B;;;;;;;;;CAUL,aAAqB,SAAgE;AACnF,MAAI,OAAO,SAAS,QAAQ,CAC1B,QAAO;AAGT,SAAO,SAAS,QAAQ,QAAkD"}