better-ship 0.3.2 → 0.4.0

package/dist/application-BpSwCKJ5.js

@@ -0,0 +1,131 @@
+import { a as createLogger, f as unreachable, m as AppError, p as DatabaseError } from "./core-D3G-2gIx.js";
+import { panic } from "better-result";
+
+//#region src/application/message-already-processed.error.ts
+/** The message's effects already committed. A caller can skip duplicate delivery without repeating those effects. */
+var MessageAlreadyProcessedError = class MessageAlreadyProcessedError extends AppError {
+	messageId;
+	_tag = "MessageAlreadyProcessedError";
+	classification = "terminal";
+	constructor(messageId, options) {
+		super(`message ${messageId} already processed`, options);
+		this.messageId = messageId;
+	}
+	/** Recognize only the processed-message primary key; preserve other failures unchanged at the call site. */
+	static from(cause, messageId) {
+		if (cause instanceof MessageAlreadyProcessedError) return cause;
+		if (!(cause instanceof DatabaseError)) return void 0;
+		const details = cause.details;
+		if (!(details.database === "d1" ? details.kind === "unique" && details.table === "processed_messages" && details.column === "message_id" : details.code === "23505" && details.table_name === "processed_messages" && details.constraint_name === "processed_messages_pkey")) return void 0;
+		return new MessageAlreadyProcessedError(messageId, { cause });
+	}
+};
+
+//#endregion
+//#region src/application/message-bus.ts
+const logger = createLogger("message-bus");
+/**
+* Routes one message to its slot. The bus opens no transaction and keeps no outbox:
+* a handler that writes opens the unit of work itself.
+*/
+var MessageBus = class {
+	deps;
+	registry;
+	constructor(deps, registry) {
+		this.deps = deps;
+		this.registry = registry;
+	}
+	/** Resolves to the handler's own value for a command or query, and to void for an event. */
+	async handle(message) {
+		return await this.dispatch(message);
+	}
+	dispatch(message) {
+		if (message.type === "command") return this.handleCommand(message);
+		if (message.type === "query") return this.handleQuery(message);
+		if (message.type === "event") return this.handleEvent(message);
+		return unreachable(message);
+	}
+	handleCommand(command) {
+		const handler = this.registry.commands[command.name];
+		if (handler === void 0) return panic(`No handler for command ${command.name}`);
+		logger.debug("handling_command", {
+			name: command.name,
+			id: command.id
+		});
+		return handler(command, this.deps);
+	}
+	handleQuery(query) {
+		const handler = this.registry.queries[query.name];
+		if (handler === void 0) return panic(`No handler for query ${query.name}`);
+		return handler(query, this.deps);
+	}
+	/**
+	* Every subscriber runs to completion. One failure is rethrown as is. Several are thrown as
+	* one `AggregateError`. A `MessageAlreadyProcessedError` means that subscriber already committed on
+	* an earlier delivery, so it counts as delivered.
+	*/
+	async handleEvent(event) {
+		const subscriptions = this.registry.events[event.name] ?? [];
+		const outcomes = await Promise.allSettled(subscriptions.map((subscription) => subscription(event, this.deps)));
+		const failures = [];
+		for (const [subscriber, outcome] of outcomes.entries()) {
+			if (outcome.status === "fulfilled") continue;
+			if (outcome.reason instanceof MessageAlreadyProcessedError) {
+				logger.info("duplicate_subscriber_ignored", {
+					event: event.name,
+					id: event.id,
+					subscriber
+				});
+				continue;
+			}
+			failures.push(outcome.reason);
+		}
+		if (failures.length === 1) throw failures[0];
+		if (failures.length > 1) throw new AggregateError(failures, `${event.name}: ${failures.length} subscribers failed`);
+	}
+};
+
+//#endregion
+//#region src/application/unit-of-work.ts
+/** The unit of work: the boundary, the repositories, the events. Every database call is a port. */
+var UnitOfWork = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async run(messageId, work) {
+		const { transaction, messageStore, createRepositories, eventCollector, relay } = this.deps;
+		let written = 0;
+		let value;
+		try {
+			value = await transaction.transaction(async (tx) => {
+				const store = messageStore(tx);
+				await store.claim(messageId);
+				const result = await work(createRepositories(tx));
+				const pending = eventCollector.collect();
+				await store.persistEvents(pending);
+				written = pending.length;
+				return result;
+			});
+		} catch (error) {
+			throw MessageAlreadyProcessedError.from(error, messageId) ?? error;
+		}
+		if (written > 0) relay.wake();
+		return value;
+	}
+};
+
+//#endregion
+//#region src/application/unit-of-work.errors.ts
+/** A boundary was opened inside another. One message, one atomic scope. */
+var UnitOfWorkAlreadyActiveError = class extends AppError {
+	_tag = "UnitOfWorkAlreadyActiveError";
+	classification = "terminal";
+	constructor() {
+		super("a unit of work is already active");
+	}
+};
+
+//#endregion
+export { MessageAlreadyProcessedError as i, UnitOfWork as n, MessageBus as r, UnitOfWorkAlreadyActiveError as t };
+//# sourceMappingURL=application-BpSwCKJ5.js.map

package/dist/application-BpSwCKJ5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-BpSwCKJ5.js","names":[],"sources":["../src/application/message-already-processed.error.ts","../src/application/message-bus.ts","../src/application/unit-of-work.ts","../src/application/unit-of-work.errors.ts"],"sourcesContent":["import { AppError, DatabaseError } from '@/core'\n\nimport type { MessageId } from './messages.ts'\n\n/** The message's effects already committed. A caller can skip duplicate delivery without repeating those effects. */\nexport class MessageAlreadyProcessedError extends AppError {\n  readonly _tag = 'MessageAlreadyProcessedError'\n  readonly classification = 'terminal'\n\n  constructor(\n    readonly messageId: MessageId,\n    options?: { readonly cause: unknown },\n  ) {\n    super(`message ${messageId} already processed`, options)\n  }\n\n  /** Recognize only the processed-message primary key; preserve other failures unchanged at the call site. */\n  static from(cause: unknown, messageId: MessageId): MessageAlreadyProcessedError | undefined {\n    if (cause instanceof MessageAlreadyProcessedError) return cause\n    if (!(cause instanceof DatabaseError)) return undefined\n    const details = cause.details\n    const duplicate =\n      details.database === 'd1'\n        ? details.kind === 'unique' &&\n          details.table === 'processed_messages' &&\n          details.column === 'message_id'\n        : details.code === '23505' &&\n          details.table_name === 'processed_messages' &&\n          details.constraint_name === 'processed_messages_pkey'\n    if (!duplicate) return undefined\n    return new MessageAlreadyProcessedError(messageId, { cause })\n  }\n}\n","import { panic } from 'better-result'\n\nimport { createLogger, unreachable } from '@/core'\n\nimport { MessageAlreadyProcessedError } from './message-already-processed.error.ts'\nimport type { Command, Event, Message, Query } from './messages.ts'\nimport type { Handlers, MessageResult, RegistryMessage } from './registry.ts'\n\nconst logger = createLogger('message-bus')\n\n/** The port an entrypoint dispatches through. `AppDeps` names this as `IMessageBus<typeof registry>`. */\nexport interface IMessageBus<TRegistry extends Handlers<never>> {\n  handle<TMessage extends Message & RegistryMessage<TRegistry>>(\n    message: TMessage,\n  ): Promise<MessageResult<TMessage, TRegistry>>\n}\n\n/**\n * Routes one message to its slot. The bus opens no transaction and keeps no outbox:\n * a handler that writes opens the unit of work itself.\n */\nexport class MessageBus<Deps, TRegistry extends Handlers<Deps>> implements IMessageBus<TRegistry> {\n  constructor(\n    private readonly deps: Deps,\n    private readonly registry: TRegistry,\n  ) {}\n\n  /** Resolves to the handler's own value for a command or query, and to void for an event. */\n  async handle<TMessage extends Message & RegistryMessage<TRegistry>>(\n    message: TMessage,\n  ): Promise<MessageResult<TMessage, TRegistry>> {\n    // SAFETY: the slot for this name is what `MessageResult` names, and dispatch returns its value.\n    return (await this.dispatch(message)) as MessageResult<TMessage, TRegistry>\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-returns -- one table holds every slot's value; `handle` names it.\n  private dispatch(message: Message): Promise<unknown> {\n    if (message.type === 'command') return this.handleCommand(message)\n    if (message.type === 'query') return this.handleQuery(message)\n    if (message.type === 'event') return this.handleEvent(message)\n    // A message parsed at a boundary cannot reach here; one that does must not resolve silently.\n    return unreachable(message)\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-returns -- see dispatch.\n  private handleCommand(command: Command): Promise<unknown> {\n    // `satisfies` proved the registry complete, so a missing slot is a broken registry object.\n    const handler = this.registry.commands[command.name]\n    if (handler === undefined) return panic(`No handler for command ${command.name}`)\n    logger.debug('handling_command', { name: command.name, id: command.id })\n    return handler(command, this.deps)\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-returns -- see dispatch.\n  private handleQuery(query: Query): Promise<unknown> {\n    const handler = this.registry.queries[query.name]\n    if (handler === undefined) return panic(`No handler for query ${query.name}`)\n    return handler(query, this.deps)\n  }\n\n  /**\n   * Every subscriber runs to completion. One failure is rethrown as is. Several are thrown as\n   * one `AggregateError`. A `MessageAlreadyProcessedError` means that subscriber already committed on\n   * an earlier delivery, so it counts as delivered.\n   */\n  private async handleEvent(event: Event): Promise<void> {\n    const subscriptions = this.registry.events[event.name] ?? []\n    const outcomes = await Promise.allSettled(\n      subscriptions.map((subscription) => subscription(event, this.deps)),\n    )\n    const failures: unknown[] = []\n    for (const [subscriber, outcome] of outcomes.entries()) {\n      if (outcome.status === 'fulfilled') continue\n      if (outcome.reason instanceof MessageAlreadyProcessedError) {\n        // The bus swallows this error, so this line is the only record that the skip happened.\n        logger.info('duplicate_subscriber_ignored', { event: event.name, id: event.id, subscriber })\n        continue\n      }\n      failures.push(outcome.reason)\n    }\n    if (failures.length === 1) throw failures[0]\n    if (failures.length > 1) {\n      throw new AggregateError(failures, `${event.name}: ${failures.length} subscribers failed`)\n    }\n  }\n}\n","import type { IEventCollector } from './event-collector.ts'\nimport { MessageAlreadyProcessedError } from './message-already-processed.error.ts'\nimport type { IMessageStore } from './message-store.ts'\nimport type { MessageId } from './messages.ts'\nimport type { IOutboxRelay } from './outbox-relay.ts'\nimport type { ITransaction } from './transaction.ts'\n\n/**\n * Commits the processed-message record, repository writes, and emitted events together before resolving.\n * An existing record rejects with `MessageAlreadyProcessedError`; external effects must run through the outbox after commit.\n * Nested calls reject with `UnitOfWorkAlreadyActiveError`; independent concurrent calls are allowed.\n */\nexport interface IUnitOfWork<Repos> {\n  run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T>\n}\n\nexport type UnitOfWorkDeps<Tx, Repos> = {\n  readonly transaction: ITransaction<Tx>\n  /** The processed-messages and outbox repository for this transaction. */\n  readonly messageStore: (tx: Tx) => IMessageStore\n  /** Repositories participate in the current transaction. */\n  readonly createRepositories: (tx: Tx) => Repos\n  readonly eventCollector: IEventCollector\n  readonly relay: IOutboxRelay\n}\n\n/** The unit of work: the boundary, the repositories, the events. Every database call is a port. */\nexport class UnitOfWork<Tx, Repos> implements IUnitOfWork<Repos> {\n  constructor(private readonly deps: UnitOfWorkDeps<Tx, Repos>) {}\n\n  async run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T> {\n    const { transaction, messageStore, createRepositories, eventCollector, relay } = this.deps\n    let written = 0\n\n    let value: T\n    try {\n      value = await transaction.transaction(async (tx) => {\n        const store = messageStore(tx)\n        await store.claim(messageId)\n        const repos = createRepositories(tx)\n        const result = await work(repos)\n        const pending = eventCollector.collect()\n        await store.persistEvents(pending)\n        written = pending.length\n        return result\n      })\n    } catch (error) {\n      throw MessageAlreadyProcessedError.from(error, messageId) ?? error\n    }\n\n    if (written > 0) relay.wake()\n    return value\n  }\n}\n","import { AppError } from '@/core'\n\n/** A boundary was opened inside another. One message, one atomic scope. */\nexport class UnitOfWorkAlreadyActiveError extends AppError {\n  readonly _tag = 'UnitOfWorkAlreadyActiveError'\n  readonly classification = 'terminal'\n\n  constructor() {\n    super('a unit of work is already active')\n  }\n}\n"],"mappings":"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"}

package/dist/application.d.ts

@@ -1,127 +1,2 @@
-import { w as AppError } from "./index-eL4vb02m.js";
-//#region src/application/messages.d.ts
-/**
- * The identity of a command or event. Receipts and the outbox are keyed by it.
- *
- * Internal messages use UUID v7, so receipts sort by creation. External messages use the
- * provider's own key, `stripe:event:evt_123`, so a redelivered webhook is a duplicate by
- * construction. The app parses and generates ids; this package only carries them.
- */
-type MessageId = string;
-/** An action to perform. One handler, returns a value. The product adds its payload. */
-type Command<Name extends string = string> = {
-  readonly type: 'command';
-  readonly name: Name;
-  readonly id: MessageId;
-};
-/** A request for data. One handler, returns a value. No id: nothing claims a read. */
-type Query<Name extends string = string> = {
-  readonly type: 'query';
-  readonly name: Name;
-};
-/** A fact that happened. Zero or more subscribers, returns nothing. The product adds its payload. */
-type Event<Name extends string = string> = {
-  readonly type: 'event';
-  readonly name: Name;
-  readonly id: MessageId;
-};
-/** The routing fields the bus reads. `type` selects the table, `name` selects the slot. */
-type Message = Command | Event | Query;
-//#endregion
-//#region src/application/message-bus.errors.d.ts
-/**
- * The unit of work throws this when a message's effects already committed.
- * The bus counts an event subscriber that throws it as delivered. From a command it reaches the caller.
- */
-export declare class DuplicateMessageError extends AppError {
-  readonly messageId: MessageId;
-  readonly _tag = "DuplicateMessageError";
-  readonly classification = "terminal";
-  constructor(messageId: MessageId);
-}
-//#endregion
-//#region src/application/handlers.d.ts
-/**
- * Handles one command with the dependency container and returns the caller's value.
- * A handler that writes inside a transaction opens the unit of work itself. Failures throw.
- */
-type CommandHandler<TCommand extends Command, Deps, Value> = (command: TCommand, deps: Deps) => Promise<Value>;
-/**
- * Handles one query with the read-only view of the container.
- * The view is a type over the same object, so a query cannot name a write capability.
- */
-type QueryHandler<TQuery extends Query, QueryDeps, Value> = (query: TQuery, deps: QueryDeps) => Promise<Value>;
-/** Completes one subscriber's work for an event. Failures throw. */
-type EventHandler<TEvent extends Event, Deps> = (event: TEvent, deps: Deps) => Promise<void>;
-//#endregion
-//#region src/application/registry.d.ts
-/** One slot per command. `unknown` keeps the slot covariant; `MessageResult` recovers the value. */
-type CommandRegistry<TCommand extends Command, Deps> = { readonly [M in TCommand as M['name']]: CommandHandler<M, Deps, unknown>; };
-/** One slot per query, typed with the read-only view of the container. */
-type QueryRegistry<TQuery extends Query, QueryDeps> = { readonly [M in TQuery as M['name']]: QueryHandler<M, QueryDeps, unknown>; };
-/**
- * Zero or more subscribers per event. Annotate the object with this type rather than
- * `satisfies`, so an event with no subscribers is still a message the bus accepts.
- */
-type EventRegistry<TEvent extends Event, Deps> = { readonly [M in TEvent as M['name']]?: ReadonlyArray<EventHandler<M, Deps>>; };
-/**
- * The app's three tables. `satisfies MessageRegistry<AppMessage, AppDeps, AppQueryDeps>`
- * makes a missing handler a compile error. `Deps extends QueryDeps` is checked here, the one
- * place both types meet: the read view must be a subset of the container.
- */
-type MessageRegistry<TMessage extends Message, Deps extends QueryDeps, QueryDeps> = {
-  readonly commands: CommandRegistry<Extract<TMessage, Command>, Deps>;
-  readonly queries: QueryRegistry<Extract<TMessage, Query>, QueryDeps>;
-  readonly events: EventRegistry<Extract<TMessage, Event>, Deps>;
-};
-type Slot<Deps> = {
-  handle(message: Message, deps: Deps): Promise<unknown>;
-}['handle'];
-type Subscription<Deps> = {
-  handle(event: Event, deps: Deps): Promise<void>;
-}['handle'];
-/**
- * The registry as the bus routes it: each table keyed by name. The app's names are unknown
- * inside the package, so this is what a runtime string can index.
- */
-type Handlers<Deps> = {
-  readonly commands: Readonly<Record<string, Slot<Deps>>>;
-  readonly queries: Readonly<Record<string, Slot<Deps>>>;
-  readonly events: Readonly<Partial<Record<string, ReadonlyArray<Subscription<Deps>>>>>;
-};
-type SlotMessage<TSlots> = Parameters<Extract<TSlots[keyof TSlots], Slot<never>>>[0];
-type SubscriptionMessage<TSlots> = NonNullable<TSlots[keyof TSlots]> extends ReadonlyArray<infer TSubscription> ? Parameters<Extract<TSubscription, Subscription<never>>>[0] : never;
-/** The messages a registry has a slot for, read off each slot's first parameter. */
-type RegistryMessage<TRegistry extends Handlers<never>> = SlotMessage<TRegistry['commands']> | SlotMessage<TRegistry['queries']> | SubscriptionMessage<TRegistry['events']>;
-type SlotValue<TSlots, TName extends string> = TName extends keyof TSlots ? Awaited<ReturnType<Extract<TSlots[TName], Slot<never>>>> : never;
-/** The value `bus.handle(message)` resolves to: the slot's own return type, or void for an event. */
-type MessageResult<TMessage extends Message, TRegistry extends Handlers<never>> = TMessage extends Command ? SlotValue<TRegistry['commands'], TMessage['name']> : TMessage extends Query ? SlotValue<TRegistry['queries'], TMessage['name']> : void;
-//#endregion
-//#region src/application/message-bus.d.ts
-/** The port an entrypoint dispatches through. `AppDeps` names this as `IMessageBus<typeof registry>`. */
-interface IMessageBus<TRegistry extends Handlers<never>> {
-  handle<TMessage extends Message & RegistryMessage<TRegistry>>(message: TMessage): Promise<MessageResult<TMessage, TRegistry>>;
-}
-/**
- * Routes one message to its slot. The bus opens no transaction and keeps no outbox:
- * a handler that writes opens the unit of work itself.
- */
-export declare class MessageBus<Deps, TRegistry extends Handlers<Deps>> implements IMessageBus<TRegistry> {
-  private readonly deps;
-  private readonly registry;
-  constructor(deps: Deps, registry: TRegistry);
-  /** Resolves to the handler's own value for a command or query, and to void for an event. */
-  handle<TMessage extends Message & RegistryMessage<TRegistry>>(message: TMessage): Promise<MessageResult<TMessage, TRegistry>>;
-  private dispatch;
-  private handleCommand;
-  private handleQuery;
-  /**
-   * Every subscriber runs to completion. One failure is rethrown as is. Several are thrown as
-   * one `AggregateError`. A `DuplicateMessageError` means that subscriber already committed on
-   * an earlier delivery, so it counts as delivered.
-   */
-  private handleEvent;
-}
-//#endregion
-export type { Command, CommandHandler, CommandRegistry, Event, EventHandler, EventRegistry, Handlers, IMessageBus, Message, MessageId, MessageRegistry, MessageResult, Query, QueryHandler, QueryRegistry, RegistryMessage };
-//# sourceMappingURL=application.d.ts.map
+import { C as Event, E as Query, S as Command, T as MessageId, _ as RegistryMessage, a as UnitOfWorkDeps, b as EventHandler, c as IOutboxRelay, d as CommandRegistry, f as EventRegistry, g as QueryRegistry, h as MessageResult, i as UnitOfWork, l as IMessageBus, m as MessageRegistry, n as MessageAlreadyProcessedError, o as IEventCollector, p as Handlers, r as IUnitOfWork, s as ITransaction, t as UnitOfWorkAlreadyActiveError, u as MessageBus, v as IMessageStore, w as Message, x as QueryHandler, y as CommandHandler } from "./index-CkaFqbbV.js";
+export { type Command, type CommandHandler, type CommandRegistry, type Event, type EventHandler, type EventRegistry, type Handlers, type IEventCollector, type IMessageBus, type IMessageStore, type IOutboxRelay, type ITransaction, type IUnitOfWork, type Message, MessageAlreadyProcessedError, MessageBus, type MessageId, type MessageRegistry, type MessageResult, type Query, type QueryHandler, type QueryRegistry, type RegistryMessage, UnitOfWork, UnitOfWorkAlreadyActiveError, type UnitOfWorkDeps };

package/dist/application.js

@@ -1,85 +1,3 @@
-import { a as createLogger, f as unreachable, p as AppError } from "./core-D0asUCvq.js";
-import { panic } from "better-result";
+import { i as MessageAlreadyProcessedError, n as UnitOfWork, r as MessageBus, t as UnitOfWorkAlreadyActiveError } from "./application-BpSwCKJ5.js";
 
-//#region src/application/message-bus.errors.ts
-/**
-* The unit of work throws this when a message's effects already committed.
-* The bus counts an event subscriber that throws it as delivered. From a command it reaches the caller.
-*/
-var DuplicateMessageError = class extends AppError {
-	messageId;
-	_tag = "DuplicateMessageError";
-	classification = "terminal";
-	constructor(messageId) {
-		super(`message ${messageId} already committed`);
-		this.messageId = messageId;
-	}
-};
-
-//#endregion
-//#region src/application/message-bus.ts
-const logger = createLogger("message-bus");
-/**
-* Routes one message to its slot. The bus opens no transaction and keeps no outbox:
-* a handler that writes opens the unit of work itself.
-*/
-var MessageBus = class {
-	deps;
-	registry;
-	constructor(deps, registry) {
-		this.deps = deps;
-		this.registry = registry;
-	}
-	/** Resolves to the handler's own value for a command or query, and to void for an event. */
-	async handle(message) {
-		return await this.dispatch(message);
-	}
-	dispatch(message) {
-		if (message.type === "command") return this.handleCommand(message);
-		if (message.type === "query") return this.handleQuery(message);
-		if (message.type === "event") return this.handleEvent(message);
-		return unreachable(message);
-	}
-	handleCommand(command) {
-		const handler = this.registry.commands[command.name];
-		if (handler === void 0) return panic(`No handler for command ${command.name}`);
-		logger.debug("handling_command", {
-			name: command.name,
-			id: command.id
-		});
-		return handler(command, this.deps);
-	}
-	handleQuery(query) {
-		const handler = this.registry.queries[query.name];
-		if (handler === void 0) return panic(`No handler for query ${query.name}`);
-		return handler(query, this.deps);
-	}
-	/**
-	* Every subscriber runs to completion. One failure is rethrown as is. Several are thrown as
-	* one `AggregateError`. A `DuplicateMessageError` means that subscriber already committed on
-	* an earlier delivery, so it counts as delivered.
-	*/
-	async handleEvent(event) {
-		const subscriptions = this.registry.events[event.name] ?? [];
-		const outcomes = await Promise.allSettled(subscriptions.map((subscription) => subscription(event, this.deps)));
-		const failures = [];
-		for (const [subscriber, outcome] of outcomes.entries()) {
-			if (outcome.status === "fulfilled") continue;
-			if (outcome.reason instanceof DuplicateMessageError) {
-				logger.info("duplicate_subscriber_ignored", {
-					event: event.name,
-					id: event.id,
-					subscriber
-				});
-				continue;
-			}
-			failures.push(outcome.reason);
-		}
-		if (failures.length === 1) throw failures[0];
-		if (failures.length > 1) throw new AggregateError(failures, `${event.name}: ${failures.length} subscribers failed`);
-	}
-};
-
-//#endregion
-export { DuplicateMessageError, MessageBus };
-//# sourceMappingURL=application.js.map
+export { MessageAlreadyProcessedError, MessageBus, UnitOfWork, UnitOfWorkAlreadyActiveError };

package/dist/cloudflare.d.ts

@@ -1 +1,301 @@
-export {}
+import { C as Event, T as MessageId, s as ITransaction, v as IMessageStore } from "./index-CkaFqbbV.js";
+import { E as DatabaseFailure, T as DatabaseError, w as D1ConstraintKind } from "./index-CT1yZd4D.js";
+import { n as DrizzleSchema, t as eventCollector } from "./unit-of-work-context-DOkIB7HK.js";
+import { BatchItem } from "drizzle-orm/batch";
+import { AnyD1Database, DrizzleD1Database } from "drizzle-orm/d1";
+//#region src/infrastructure/cloudflare/d1-database-types.d.ts
+/** A D1 binding or local D1 client accepted by Drizzle. */
+type D1Connection = AnyD1Database;
+/** The application's Drizzle D1 database, preserving its schema and relational query types. */
+type D1Db<Schema extends DrizzleSchema> = DrizzleD1Database<Schema>;
+/** Exposes Drizzle query methods without insert, update, delete, batch, or raw execution methods. */
+type D1ReadDb<Schema extends DrizzleSchema> = Pick<D1Db<Schema>, 'select' | 'selectDistinct' | 'query'>;
+/** D1 reads use this database; repository writes join the active batch through the unit-of-work context. */
+type D1Tx<Schema extends DrizzleSchema> = {
+  readonly db: D1Db<Schema>;
+};
+//#endregion
+//#region src/infrastructure/cloudflare/base-d1-repository.d.ts
+/** A domain aggregate that accumulates events for the unit of work to drain. */
+interface AggregateEvents {
+  collectEvents(): ReadonlyArray<Event>;
+  clearEvents(): void;
+}
+/**
+ * Shared plumbing for a repository that writes inside a D1 unit of work.
+ * Writes are staged, never run; the boundary commits them as one batch. Reads run on `db` now.
+ */
+export declare abstract class BaseD1Repository<Schema extends DrizzleSchema> {
+  protected readonly db: D1Db<Schema>;
+  constructor(db: D1Db<Schema>);
+  /** Add a statement to the current D1 batch without executing it. */
+  protected stage(statement: BatchItem<'sqlite'>): void;
+  /** Execute one read with database error conversion and no automatic retries. */
+  protected read<T>(operation: string, query: () => PromiseLike<T>): Promise<T>;
+  /** Drain an aggregate's pending events into the active boundary. */
+  protected dispatchEvents(aggregate: AggregateEvents): void;
+}
+//#endregion
+//#region src/infrastructure/cloudflare/classify-d1-error.d.ts
+/**
+ * Recognize D1 failures and preserve the original cause. Unrecognized callback exceptions remain unchanged.
+ * D1 exposes error codes and constraint locations in text, so parsing stays at this boundary.
+ */
+export declare function classifyD1Error(cause: unknown, operation?: string): DatabaseError | undefined;
+//#endregion
+//#region src/infrastructure/cloudflare/d1-message-store.d.ts
+/** Processed messages and outbox events share one D1 batch; the primary key prevents concurrent duplicate commits. */
+export declare class D1MessageStore<Schema extends DrizzleSchema> extends BaseD1Repository<Schema> implements IMessageStore {
+  claim(messageId: MessageId): Promise<void>;
+  persistEvents(events: ReadonlyArray<Event>): Promise<void>;
+}
+//#endregion
+//#region src/infrastructure/cloudflare/d1-schema.d.ts
+/** One row per committed message. The primary key is the idempotency claim. */
+export declare const processedMessages: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+  name: "processed_messages";
+  schema: undefined;
+  columns: {
+    messageId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "message_id";
+      tableName: "processed_messages";
+      dataType: "string";
+      columnType: "SQLiteText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: number | undefined;
+    }>;
+    processedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "processed_at";
+      tableName: "processed_messages";
+      dataType: "date";
+      columnType: "SQLiteTimestamp";
+      data: Date;
+      driverParam: number;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: true;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: 'sqlite';
+}>;
+/** Events committed with their state change, waiting for the relay to deliver them. */
+export declare const messageOutbox: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+  name: "message_outbox";
+  schema: undefined;
+  columns: {
+    id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "id";
+      tableName: "message_outbox";
+      dataType: "string";
+      columnType: "SQLiteText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: number | undefined;
+    }>;
+    payload: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "payload";
+      tableName: "message_outbox";
+      dataType: "json";
+      columnType: "SQLiteTextJson";
+      data: Event;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      $type: Event;
+    }>;
+    createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "created_at";
+      tableName: "message_outbox";
+      dataType: "date";
+      columnType: "SQLiteTimestamp";
+      data: Date;
+      driverParam: number;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: true;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    availableAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "available_at";
+      tableName: "message_outbox";
+      dataType: "date";
+      columnType: "SQLiteTimestamp";
+      data: Date;
+      driverParam: number;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: true;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    attempts: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "attempts";
+      tableName: "message_outbox";
+      dataType: "number";
+      columnType: "SQLiteInteger";
+      data: number;
+      driverParam: number;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    claimToken: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "claim_token";
+      tableName: "message_outbox";
+      dataType: "string";
+      columnType: "SQLiteText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: number | undefined;
+    }>;
+    claimExpiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "claim_expires_at";
+      tableName: "message_outbox";
+      dataType: "date";
+      columnType: "SQLiteTimestamp";
+      data: Date;
+      driverParam: number;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    publishedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "published_at";
+      tableName: "message_outbox";
+      dataType: "date";
+      columnType: "SQLiteTimestamp";
+      data: Date;
+      driverParam: number;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    failedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "failed_at";
+      tableName: "message_outbox";
+      dataType: "date";
+      columnType: "SQLiteTimestamp";
+      data: Date;
+      driverParam: number;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    lastError: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+      name: "last_error";
+      tableName: "message_outbox";
+      dataType: "string";
+      columnType: "SQLiteText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: number | undefined;
+    }>;
+  };
+  dialect: 'sqlite';
+}>;
+//#endregion
+//#region src/infrastructure/cloudflare/d1-batch-transaction.d.ts
+/**
+ * The D1 transaction boundary: every write is staged during `work` and committed as one
+ * `db.batch()`. A throw inside `work` means the batch never runs.
+ */
+export declare class D1BatchTransaction<Schema extends DrizzleSchema> implements ITransaction<D1Tx<Schema>> {
+  private readonly db;
+  constructor(db: D1Db<Schema>);
+  transaction<T>(work: (tx: D1Tx<Schema>) => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/infrastructure/cloudflare/d1-database-execution.d.ts
+/** Execute once without retries; convert recognized D1 failures and preserve other exceptions unchanged. */
+export declare function executeDatabase<T>(operation: string, work: () => PromiseLike<T>): Promise<T>;
+//#endregion
+export { type AggregateEvents, type D1Connection, type D1ConstraintKind, type D1Db, type D1ReadDb, type D1Tx, DatabaseError, type DatabaseFailure, eventCollector };
+//# sourceMappingURL=cloudflare.d.ts.map