better-ship 0.3.2 → 0.4.1

package/dist/postgres.d.ts

@@ -1 +1,289 @@
-export {}
+import { C as Event, T as MessageId, s as ITransaction, v as IMessageStore } from "./index-BN_tjxME.js";
+import { E as DatabaseFailure, T as DatabaseError } from "./index-ToddX0m3.js";
+import { n as DrizzleSchema, t as eventCollector } from "./unit-of-work-context-CbUJGHlL.js";
+import { ExtractTablesWithRelations } from "drizzle-orm";
+import { PostgresJsDatabase, PostgresJsTransaction, drizzle } from "drizzle-orm/postgres-js";
+//#region src/infrastructure/postgres/postgres-database-types.d.ts
+/** The postgres.js client passed to Drizzle, including clients configured through Hyperdrive. */
+type PostgresConnection = ReturnType<typeof drizzle>['$client'];
+/** The application's Drizzle Postgres database, preserving its schema and relational query types. */
+type PostgresDb<Schema extends DrizzleSchema> = PostgresJsDatabase<Schema>;
+/** Exposes Drizzle query methods without insert, update, delete, transaction, or raw execution methods. */
+type PostgresReadDb<Schema extends DrizzleSchema> = Pick<PostgresDb<Schema>, 'select' | 'selectDistinct' | 'selectDistinctOn' | 'query'>;
+/** The native Drizzle transaction with the application's full schema and derived relation types. */
+type PostgresDbTransaction<Schema extends DrizzleSchema> = PostgresJsTransaction<Schema, ExtractTablesWithRelations<Schema>>;
+/** The database transaction supplied to participating repositories by the Postgres adapter. */
+type PostgresTx<Schema extends DrizzleSchema> = {
+  readonly db: PostgresDbTransaction<Schema>;
+};
+//#endregion
+//#region src/infrastructure/postgres/base-postgres-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 Postgres unit of work. */
+export declare abstract class BasePostgresRepository<Schema extends DrizzleSchema> {
+  protected readonly db: PostgresDbTransaction<Schema>;
+  constructor(db: PostgresDbTransaction<Schema>);
+  /** 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/postgres/postgres-message-store.d.ts
+/** Processed messages and outbox events share the active Postgres transaction; the insert result establishes the claim. */
+export declare class PostgresMessageStore<Schema extends DrizzleSchema> implements IMessageStore {
+  private readonly db;
+  constructor(db: PostgresDbTransaction<Schema>);
+  claim(messageId: MessageId): Promise<void>;
+  persistEvents(events: ReadonlyArray<Event>): Promise<void>;
+}
+//#endregion
+//#region src/infrastructure/postgres/postgres-schema.d.ts
+/** One row per committed message. The primary key is the idempotency claim. */
+export declare const processedMessages: import("drizzle-orm/pg-core").PgTableWithColumns<{
+  name: "processed_messages";
+  schema: undefined;
+  columns: {
+    messageId: import("drizzle-orm/pg-core").PgColumn<{
+      name: "message_id";
+      tableName: "processed_messages";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    processedAt: import("drizzle-orm/pg-core").PgColumn<{
+      name: "processed_at";
+      tableName: "processed_messages";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: 'pg';
+}>;
+/** Events committed with their state change, waiting for the relay to deliver them. */
+export declare const messageOutbox: import("drizzle-orm/pg-core").PgTableWithColumns<{
+  name: "message_outbox";
+  schema: undefined;
+  columns: {
+    id: import("drizzle-orm/pg-core").PgColumn<{
+      name: "id";
+      tableName: "message_outbox";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    payload: import("drizzle-orm/pg-core").PgColumn<{
+      name: "payload";
+      tableName: "message_outbox";
+      dataType: "json";
+      columnType: "PgJsonb";
+      data: Event;
+      driverParam: unknown;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      $type: Event;
+    }>;
+    createdAt: import("drizzle-orm/pg-core").PgColumn<{
+      name: "created_at";
+      tableName: "message_outbox";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    availableAt: import("drizzle-orm/pg-core").PgColumn<{
+      name: "available_at";
+      tableName: "message_outbox";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    attempts: import("drizzle-orm/pg-core").PgColumn<{
+      name: "attempts";
+      tableName: "message_outbox";
+      dataType: "number";
+      columnType: "PgInteger";
+      data: number;
+      driverParam: string | number;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    claimToken: import("drizzle-orm/pg-core").PgColumn<{
+      name: "claim_token";
+      tableName: "message_outbox";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    claimExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
+      name: "claim_expires_at";
+      tableName: "message_outbox";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    publishedAt: import("drizzle-orm/pg-core").PgColumn<{
+      name: "published_at";
+      tableName: "message_outbox";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    failedAt: import("drizzle-orm/pg-core").PgColumn<{
+      name: "failed_at";
+      tableName: "message_outbox";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    lastError: import("drizzle-orm/pg-core").PgColumn<{
+      name: "last_error";
+      tableName: "message_outbox";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: 'pg';
+}>;
+//#endregion
+//#region src/infrastructure/postgres/postgres-transaction.d.ts
+/**
+ * The Postgres transaction boundary uses native Drizzle transactions through postgres.js.
+ * Drizzle commits when `work` returns and rolls back when it throws.
+ */
+export declare class PostgresTransaction<Schema extends DrizzleSchema> implements ITransaction<PostgresTx<Schema>> {
+  private readonly db;
+  constructor(db: PostgresDb<Schema>);
+  transaction<T>(work: (tx: PostgresTx<Schema>) => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/infrastructure/postgres/postgres-database-execution.d.ts
+/** Execute once without retries; convert recognized Postgres failures and preserve other exceptions unchanged. */
+export declare function executeDatabase<T>(operation: string, work: () => PromiseLike<T>): Promise<T>;
+//#endregion
+//#region src/infrastructure/postgres/classify-postgres-error.d.ts
+/** Read SQLSTATE or driver codes; unknown callback exceptions remain unchanged. */
+export declare function classifyPostgresError(cause: unknown, operation: string): DatabaseError | undefined;
+//#endregion
+export { type AggregateEvents, DatabaseError, type DatabaseFailure, type PostgresConnection, type PostgresDb, type PostgresDbTransaction, type PostgresReadDb, type PostgresTx, eventCollector };
+//# sourceMappingURL=postgres.d.ts.map

package/dist/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","names":[],"sources":["../src/infrastructure/postgres/postgres-database-types.ts","../src/infrastructure/postgres/base-postgres-repository.ts","../src/infrastructure/postgres/postgres-message-store.ts","../src/infrastructure/postgres/postgres-schema.ts","../src/infrastructure/postgres/postgres-transaction.ts","../src/infrastructure/postgres/postgres-database-execution.ts","../src/infrastructure/postgres/classify-postgres-error.ts"],"mappings":";;;;;;;KAMY,qBAAqB,kBAAkB;;KAGvC,WAAW,eAAe,iBAAiB,mBAAmB;;KAG9D,eAAe,eAAe,iBAAiB,KACzD,WAAW;;KAKD,sBAAsB,eAAe,iBAAiB,sBAChE,QACA,2BAA2B;;KAIjB,WAAW,eAAe;WAC3B,IAAI,sBAAsB;;;;;UCjBpB;EACf,iBAAiB,cAAc;EAC/B;;;8BAIoB,uBAAuB,eAAe;qBAC3B,IAAI,sBAAsB;EAAzD,YAA+B,IAAI,sBAAsB;;YAG/C,KAAK,GAAG,mBAAmB,aAAa,YAAY,KAAK,QAAQ;;YAKjE,eAAe,WAAW;;;;;qBCXzB,qBAAqB,eAAe,0BAA0B;mBAC5C;EAA7B,YAA6B,IAAI,sBAAsB;EAEjD,MAAM,WAAW,YAAY;EAU7B,cAAc,QAAQ,cAAc,SAAS;;;;;qBCnBxC,iDAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;YAAjB;;;;;;;;;;;;;;;;qBAMA,6CAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBCDb,oBAAoB,eAAe,0BAA0B,aACxE,WAAW;mBAEkB;EAA7B,YAA6B,IAAI,WAAW;EAE5C,YAAY,GAAG,OAAO,IAAI,WAAW,YAAY,QAAQ,KAAK,QAAQ;;;;;wBCblD,gBAAgB,GACpC,mBACA,YAAY,YAAY,KACvB,QAAQ;;;;wBC2BK,sBACd,gBACA,oBACC"}

package/dist/postgres.js

@@ -0,0 +1,169 @@
+import { m as AppError, p as DatabaseError } from "./core-MjwyZJ4i.js";
+import { i as MessageAlreadyProcessedError } from "./application-rpZoTfzU.js";
+import { n as eventCollector, r as runWithUnitOfWorkContext } from "./unit-of-work-context-BLNj72v0.js";
+import { DrizzleQueryError } from "drizzle-orm/errors";
+import { isNull } from "drizzle-orm";
+import { index, integer, jsonb, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+
+//#region src/infrastructure/postgres/classify-postgres-error.ts
+const TRANSIENT_CODES = /* @__PURE__ */ new Set([
+	"40001",
+	"40P01",
+	"08000",
+	"08001",
+	"08003",
+	"08006",
+	"57P01",
+	"57P02",
+	"57P03",
+	"CONNECT_TIMEOUT",
+	"CONNECTION_CLOSED",
+	"ECONNRESET",
+	"ECONNREFUSED",
+	"EPIPE",
+	"ETIMEDOUT",
+	"EAI_AGAIN"
+]);
+const TERMINAL_CODES = /* @__PURE__ */ new Set([
+	"57014",
+	"CONNECTION_ENDED",
+	"CONNECTION_DESTROYED",
+	"ECANCELED"
+]);
+const DRIVER_CODES = /* @__PURE__ */ new Set([
+	"CONNECT_TIMEOUT",
+	"CONNECTION_CLOSED",
+	"CONNECTION_ENDED",
+	"CONNECTION_DESTROYED"
+]);
+const TERMINAL_CLASSES = /* @__PURE__ */ new Set([
+	"0A",
+	"22",
+	"23",
+	"25",
+	"28",
+	"3D",
+	"3F",
+	"42",
+	"54"
+]);
+/** Read SQLSTATE or driver codes; unknown callback exceptions remain unchanged. */
+function classifyPostgresError(cause, operation) {
+	let error = cause;
+	const seen = /* @__PURE__ */ new Set();
+	while (error instanceof DrizzleQueryError && !seen.has(error)) {
+		seen.add(error);
+		error = error.cause;
+	}
+	if (error instanceof AppError || error instanceof Error && error.name === "AbortError") return void 0;
+	const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+	const serverError = error instanceof Error && error.name === "PostgresError" && code !== void 0 && /^[0-9A-Z]{5}$/.test(code);
+	const driverError = code !== void 0 && DRIVER_CODES.has(code);
+	if (!(cause instanceof DrizzleQueryError) && !serverError && !driverError) return void 0;
+	return new DatabaseError(operation, classificationOf(code), {
+		database: "postgres",
+		code,
+		table_name: error instanceof Error && "table_name" in error && typeof error.table_name === "string" ? error.table_name : void 0,
+		column_name: error instanceof Error && "column_name" in error && typeof error.column_name === "string" ? error.column_name : void 0,
+		constraint_name: error instanceof Error && "constraint_name" in error && typeof error.constraint_name === "string" ? error.constraint_name : void 0
+	}, { cause });
+}
+function classificationOf(code) {
+	if (code === void 0) return "unknown";
+	if (TRANSIENT_CODES.has(code)) return "transient";
+	if (TERMINAL_CODES.has(code) || TERMINAL_CLASSES.has(code.slice(0, 2))) return "terminal";
+	return "unknown";
+}
+
+//#endregion
+//#region src/infrastructure/postgres/postgres-database-execution.ts
+/** Execute once without retries; convert recognized Postgres failures and preserve other exceptions unchanged. */
+async function executeDatabase(operation, work) {
+	try {
+		return await work();
+	} catch (cause) {
+		throw classifyPostgresError(cause, operation) ?? cause;
+	}
+}
+
+//#endregion
+//#region src/infrastructure/postgres/base-postgres-repository.ts
+/** Shared plumbing for a repository that writes inside a Postgres unit of work. */
+var BasePostgresRepository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	/** Execute one read with database error conversion and no automatic retries. */
+	read(operation, query) {
+		return executeDatabase(operation, query);
+	}
+	/** Drain an aggregate's pending events into the active boundary. */
+	dispatchEvents(aggregate) {
+		const events = aggregate.collectEvents();
+		if (events.length === 0) return;
+		for (const event of events) eventCollector.emit(event);
+		aggregate.clearEvents();
+	}
+};
+
+//#endregion
+//#region src/infrastructure/postgres/postgres-schema.ts
+/** One row per committed message. The primary key is the idempotency claim. */
+const processedMessages = pgTable("processed_messages", {
+	messageId: text("message_id").primaryKey(),
+	processedAt: timestamp("processed_at", { withTimezone: true }).notNull().defaultNow()
+});
+/** Events committed with their state change, waiting for the relay to deliver them. */
+const messageOutbox = pgTable("message_outbox", {
+	id: text("id").primaryKey(),
+	payload: jsonb("payload").$type().notNull(),
+	createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+	availableAt: timestamp("available_at", { withTimezone: true }).notNull().defaultNow(),
+	attempts: integer("attempts").notNull().default(0),
+	claimToken: text("claim_token"),
+	claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
+	publishedAt: timestamp("published_at", { withTimezone: true }),
+	failedAt: timestamp("failed_at", { withTimezone: true }),
+	lastError: text("last_error")
+}, (table) => [index("idx_message_outbox_due").on(table.availableAt, table.createdAt).where(isNull(table.publishedAt)), index("idx_message_outbox_claim_token").on(table.claimToken)]);
+
+//#endregion
+//#region src/infrastructure/postgres/postgres-message-store.ts
+/** Processed messages and outbox events share the active Postgres transaction; the insert result establishes the claim. */
+var PostgresMessageStore = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async claim(messageId) {
+		if ((await this.db.insert(processedMessages).values({ messageId }).onConflictDoNothing().returning({ messageId: processedMessages.messageId })).length === 0) throw new MessageAlreadyProcessedError(messageId);
+	}
+	async persistEvents(events) {
+		if (events.length === 0) return;
+		await this.db.insert(messageOutbox).values(events.map((event) => ({
+			id: event.id,
+			payload: event
+		})));
+	}
+};
+
+//#endregion
+//#region src/infrastructure/postgres/postgres-transaction.ts
+/**
+* The Postgres transaction boundary uses native Drizzle transactions through postgres.js.
+* Drizzle commits when `work` returns and rolls back when it throws.
+*/
+var PostgresTransaction = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	transaction(work) {
+		return runWithUnitOfWorkContext("postgres", () => executeDatabase("unit of work transaction", () => this.db.transaction((db) => work({ db }))));
+	}
+};
+
+//#endregion
+export { BasePostgresRepository, DatabaseError, PostgresMessageStore, PostgresTransaction, classifyPostgresError, eventCollector, executeDatabase, messageOutbox, processedMessages };
+//# sourceMappingURL=postgres.js.map

package/dist/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.js","names":[],"sources":["../src/infrastructure/postgres/classify-postgres-error.ts","../src/infrastructure/postgres/postgres-database-execution.ts","../src/infrastructure/postgres/base-postgres-repository.ts","../src/infrastructure/postgres/postgres-schema.ts","../src/infrastructure/postgres/postgres-message-store.ts","../src/infrastructure/postgres/postgres-transaction.ts"],"sourcesContent":["import { DrizzleQueryError } from 'drizzle-orm/errors'\n\nimport { AppError, DatabaseError, type FailureClassification } from '@/core'\n\nconst TRANSIENT_CODES = new Set([\n  '40001',\n  '40P01',\n  '08000',\n  '08001',\n  '08003',\n  '08006',\n  '57P01',\n  '57P02',\n  '57P03',\n  'CONNECT_TIMEOUT',\n  'CONNECTION_CLOSED',\n  'ECONNRESET',\n  'ECONNREFUSED',\n  'EPIPE',\n  'ETIMEDOUT',\n  'EAI_AGAIN',\n])\nconst TERMINAL_CODES = new Set(['57014', 'CONNECTION_ENDED', 'CONNECTION_DESTROYED', 'ECANCELED'])\nconst DRIVER_CODES = new Set([\n  'CONNECT_TIMEOUT',\n  'CONNECTION_CLOSED',\n  'CONNECTION_ENDED',\n  'CONNECTION_DESTROYED',\n])\nconst TERMINAL_CLASSES = new Set(['0A', '22', '23', '25', '28', '3D', '3F', '42', '54'])\n\n/* oxlint-disable anti-slop/no-runtime-typeof -- Raw driver exceptions have no shared schema; this boundary validates the fields it exposes. */\n/** Read SQLSTATE or driver codes; unknown callback exceptions remain unchanged. */\nexport function classifyPostgresError(\n  cause: unknown,\n  operation: string,\n): DatabaseError | undefined {\n  let error = cause\n  const seen = new Set<unknown>()\n  while (error instanceof DrizzleQueryError && !seen.has(error)) {\n    seen.add(error)\n    error = error.cause\n  }\n  if (error instanceof AppError || (error instanceof Error && error.name === 'AbortError'))\n    return undefined\n  const code =\n    error instanceof Error && 'code' in error && typeof error.code === 'string'\n      ? error.code\n      : undefined\n  const serverError =\n    error instanceof Error &&\n    error.name === 'PostgresError' &&\n    code !== undefined &&\n    /^[0-9A-Z]{5}$/.test(code)\n  const driverError = code !== undefined && DRIVER_CODES.has(code)\n  if (!(cause instanceof DrizzleQueryError) && !serverError && !driverError) return undefined\n\n  return new DatabaseError(\n    operation,\n    classificationOf(code),\n    {\n      database: 'postgres',\n      code,\n      table_name:\n        error instanceof Error && 'table_name' in error && typeof error.table_name === 'string'\n          ? error.table_name\n          : undefined,\n      column_name:\n        error instanceof Error && 'column_name' in error && typeof error.column_name === 'string'\n          ? error.column_name\n          : undefined,\n      constraint_name:\n        error instanceof Error &&\n        'constraint_name' in error &&\n        typeof error.constraint_name === 'string'\n          ? error.constraint_name\n          : undefined,\n    },\n    { cause },\n  )\n}\n\n/* oxlint-enable anti-slop/no-runtime-typeof */\n\nfunction classificationOf(code: string | undefined): FailureClassification {\n  if (code === undefined) return 'unknown'\n  if (TRANSIENT_CODES.has(code)) return 'transient'\n  if (TERMINAL_CODES.has(code) || TERMINAL_CLASSES.has(code.slice(0, 2))) return 'terminal'\n  return 'unknown'\n}\n","import { classifyPostgresError } from './classify-postgres-error.ts'\n\n/** Execute once without retries; convert recognized Postgres failures and preserve other exceptions unchanged. */\nexport async function executeDatabase<T>(\n  operation: string,\n  work: () => PromiseLike<T>,\n): Promise<T> {\n  try {\n    return await work()\n  } catch (cause) {\n    throw classifyPostgresError(cause, operation) ?? cause\n  }\n}\n","import type { Event } from '@/application'\n\nimport type { DrizzleSchema } from '../drizzle-schema.ts'\nimport { eventCollector } from '../unit-of-work-context.ts'\nimport { executeDatabase } from './postgres-database-execution.ts'\nimport type { PostgresDbTransaction } from './postgres-database-types.ts'\n\n/** A domain aggregate that accumulates events for the unit of work to drain. */\nexport interface AggregateEvents {\n  collectEvents(): ReadonlyArray<Event>\n  clearEvents(): void\n}\n\n/** Shared plumbing for a repository that writes inside a Postgres unit of work. */\nexport abstract class BasePostgresRepository<Schema extends DrizzleSchema> {\n  constructor(protected readonly db: PostgresDbTransaction<Schema>) {}\n\n  /** Execute one read with database error conversion and no automatic retries. */\n  protected read<T>(operation: string, query: () => PromiseLike<T>): Promise<T> {\n    return executeDatabase(operation, query)\n  }\n\n  /** Drain an aggregate's pending events into the active boundary. */\n  protected dispatchEvents(aggregate: AggregateEvents): void {\n    const events = aggregate.collectEvents()\n    if (events.length === 0) return\n    for (const event of events) eventCollector.emit(event)\n    aggregate.clearEvents()\n  }\n}\n","import { isNull } from 'drizzle-orm'\nimport { index, integer, jsonb, pgTable, text, timestamp } from 'drizzle-orm/pg-core'\n\nimport type { Event } from '@/application'\n\n/** One row per committed message. The primary key is the idempotency claim. */\nexport const processedMessages = pgTable('processed_messages', {\n  messageId: text('message_id').primaryKey(),\n  processedAt: timestamp('processed_at', { withTimezone: true }).notNull().defaultNow(),\n})\n\n/** Events committed with their state change, waiting for the relay to deliver them. */\nexport const messageOutbox = pgTable(\n  'message_outbox',\n  {\n    id: text('id').primaryKey(),\n    payload: jsonb('payload').$type<Event>().notNull(),\n    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),\n    availableAt: timestamp('available_at', { withTimezone: true }).notNull().defaultNow(),\n    attempts: integer('attempts').notNull().default(0),\n    claimToken: text('claim_token'),\n    claimExpiresAt: timestamp('claim_expires_at', { withTimezone: true }),\n    publishedAt: timestamp('published_at', { withTimezone: true }),\n    failedAt: timestamp('failed_at', { withTimezone: true }),\n    lastError: text('last_error'),\n  },\n  (table) => [\n    index('idx_message_outbox_due')\n      .on(table.availableAt, table.createdAt)\n      .where(isNull(table.publishedAt)),\n    index('idx_message_outbox_claim_token').on(table.claimToken),\n  ],\n)\n","import {\n  MessageAlreadyProcessedError,\n  type Event,\n  type IMessageStore,\n  type MessageId,\n} from '@/application'\n\nimport type { DrizzleSchema } from '../drizzle-schema.ts'\nimport type { PostgresDbTransaction } from './postgres-database-types.ts'\nimport { messageOutbox, processedMessages } from './postgres-schema.ts'\n\n/** Processed messages and outbox events share the active Postgres transaction; the insert result establishes the claim. */\nexport class PostgresMessageStore<Schema extends DrizzleSchema> implements IMessageStore {\n  constructor(private readonly db: PostgresDbTransaction<Schema>) {}\n\n  async claim(messageId: MessageId): Promise<void> {\n    const claimed = await this.db\n      .insert(processedMessages)\n      .values({ messageId })\n      .onConflictDoNothing()\n      .returning({ messageId: processedMessages.messageId })\n    // Thrown inside the transaction, so drizzle rolls back everything written before the claim.\n    if (claimed.length === 0) throw new MessageAlreadyProcessedError(messageId)\n  }\n\n  async persistEvents(events: ReadonlyArray<Event>): Promise<void> {\n    if (events.length === 0) return\n    await this.db\n      .insert(messageOutbox)\n      .values(events.map((event) => ({ id: event.id, payload: event })))\n  }\n}\n","import type { ITransaction } from '@/application'\n\nimport type { DrizzleSchema } from '../drizzle-schema.ts'\nimport { runWithUnitOfWorkContext } from '../unit-of-work-context.ts'\nimport { executeDatabase } from './postgres-database-execution.ts'\nimport type { PostgresDb, PostgresTx } from './postgres-database-types.ts'\n\n/**\n * The Postgres transaction boundary uses native Drizzle transactions through postgres.js.\n * Drizzle commits when `work` returns and rolls back when it throws.\n */\nexport class PostgresTransaction<Schema extends DrizzleSchema> implements ITransaction<\n  PostgresTx<Schema>\n> {\n  constructor(private readonly db: PostgresDb<Schema>) {}\n\n  transaction<T>(work: (tx: PostgresTx<Schema>) => Promise<T>): Promise<T> {\n    return runWithUnitOfWorkContext('postgres', () =>\n      executeDatabase('unit of work transaction', () => this.db.transaction((db) => work({ db }))),\n    )\n  }\n}\n"],"mappings":"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"}

package/dist/unit-of-work-context-BLNj72v0.js

@@ -0,0 +1,48 @@
+import { t as UnitOfWorkAlreadyActiveError } from "./application-rpZoTfzU.js";
+import { panic } from "better-result";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/infrastructure/unit-of-work-context.ts
+const storage = new AsyncLocalStorage();
+/** Reject nested transactions before database work starts; preserve independent concurrent execution. */
+async function runWithUnitOfWorkContext(database, work) {
+	if (storage.getStore() !== void 0) throw new UnitOfWorkAlreadyActiveError();
+	const context = database === "d1" ? {
+		database,
+		events: [],
+		statements: []
+	} : {
+		database,
+		events: []
+	};
+	return storage.run(context, work);
+}
+/** Inject this shared scope into the unit of work and expose its emitter to application handlers. */
+const eventCollector = {
+	emit(event) {
+		currentContext().events.push(event);
+	},
+	collect() {
+		return [...currentContext().events];
+	}
+};
+/** Queue one native D1 statement for the active batch; other contexts cannot accept D1 writes. */
+function stageD1Statement(statement) {
+	d1Context().statements.push(statement);
+}
+/** Read the active D1 batch in staging order for commit. */
+function collectD1Statements() {
+	return [...d1Context().statements];
+}
+function d1Context() {
+	const context = currentContext();
+	if (context.database !== "d1") return panic("D1 statements require a D1 unit of work");
+	return context;
+}
+function currentContext() {
+	return storage.getStore() ?? panic("operation requires an active unit of work");
+}
+
+//#endregion
+export { stageD1Statement as i, eventCollector as n, runWithUnitOfWorkContext as r, collectD1Statements as t };
+//# sourceMappingURL=unit-of-work-context-BLNj72v0.js.map

package/dist/unit-of-work-context-BLNj72v0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-of-work-context-BLNj72v0.js","names":[],"sources":["../src/infrastructure/unit-of-work-context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\n\nimport { panic } from 'better-result'\nimport type { BatchItem } from 'drizzle-orm/batch'\n\nimport { UnitOfWorkAlreadyActiveError, type Event, type IEventCollector } from '@/application'\n\ntype UnitOfWorkContext = { readonly events: Event[] } & (\n  | { readonly database: 'd1'; readonly statements: BatchItem<'sqlite'>[] }\n  | { readonly database: 'postgres' }\n)\n\n// One async scope isolates events and D1 statements and rejects nesting across both adapters.\nconst storage = new AsyncLocalStorage<UnitOfWorkContext>()\n\n/** Reject nested transactions before database work starts; preserve independent concurrent execution. */\nexport async function runWithUnitOfWorkContext<T>(\n  database: UnitOfWorkContext['database'],\n  work: () => Promise<T>,\n): Promise<T> {\n  if (storage.getStore() !== undefined) throw new UnitOfWorkAlreadyActiveError()\n  const context: UnitOfWorkContext =\n    database === 'd1' ? { database, events: [], statements: [] } : { database, events: [] }\n  return storage.run(context, work)\n}\n\n/** Inject this shared scope into the unit of work and expose its emitter to application handlers. */\nexport const eventCollector: IEventCollector = {\n  emit(event) {\n    currentContext().events.push(event)\n  },\n  collect() {\n    return [...currentContext().events]\n  },\n}\n\n/** Queue one native D1 statement for the active batch; other contexts cannot accept D1 writes. */\nexport function stageD1Statement(statement: BatchItem<'sqlite'>): void {\n  d1Context().statements.push(statement)\n}\n\n/** Read the active D1 batch in staging order for commit. */\nexport function collectD1Statements(): ReadonlyArray<BatchItem<'sqlite'>> {\n  return [...d1Context().statements]\n}\n\nfunction d1Context(): Extract<UnitOfWorkContext, { database: 'd1' }> {\n  const context = currentContext()\n  if (context.database !== 'd1') return panic('D1 statements require a D1 unit of work')\n  return context\n}\n\nfunction currentContext(): UnitOfWorkContext {\n  return storage.getStore() ?? panic('operation requires an active unit of work')\n}\n"],"mappings":";;;;;AAaA,MAAM,UAAU,IAAI,kBAAqC;;AAGzD,eAAsB,yBACpB,UACA,MACY;CACZ,IAAI,QAAQ,SAAS,MAAM,QAAW,MAAM,IAAI,6BAA6B;CAC7E,MAAM,UACJ,aAAa,OAAO;EAAE;EAAU,QAAQ,CAAC;EAAG,YAAY,CAAC;CAAE,IAAI;EAAE;EAAU,QAAQ,CAAC;CAAE;CACxF,OAAO,QAAQ,IAAI,SAAS,IAAI;AAClC;;AAGA,MAAa,iBAAkC;CAC7C,KAAK,OAAO;EACV,eAAe,CAAC,CAAC,OAAO,KAAK,KAAK;CACpC;CACA,UAAU;EACR,OAAO,CAAC,GAAG,eAAe,CAAC,CAAC,MAAM;CACpC;AACF;;AAGA,SAAgB,iBAAiB,WAAsC;CACrE,UAAU,CAAC,CAAC,WAAW,KAAK,SAAS;AACvC;;AAGA,SAAgB,sBAA0D;CACxE,OAAO,CAAC,GAAG,UAAU,CAAC,CAAC,UAAU;AACnC;AAEA,SAAS,YAA4D;CACnE,MAAM,UAAU,eAAe;CAC/B,IAAI,QAAQ,aAAa,MAAM,OAAO,MAAM,yCAAyC;CACrF,OAAO;AACT;AAEA,SAAS,iBAAoC;CAC3C,OAAO,QAAQ,SAAS,KAAK,MAAM,2CAA2C;AAChF"}

package/dist/unit-of-work-context-CbUJGHlL.d.ts

@@ -0,0 +1,15 @@
+import { o as IEventCollector } from "./index-BN_tjxME.js";
+import { BatchItem } from "drizzle-orm/batch";
+//#region src/infrastructure/drizzle-schema.d.ts
+/**
+ * The app's drizzle schema: the tables it declared, keyed by name. This is drizzle's own
+ * constraint on every database and transaction type, restated once so the adapters name it.
+ */
+type DrizzleSchema = Record<string, unknown>;
+//#endregion
+//#region src/infrastructure/unit-of-work-context.d.ts
+/** Inject this shared scope into the unit of work and expose its emitter to application handlers. */
+declare const eventCollector: IEventCollector;
+//#endregion
+export { DrizzleSchema as n, eventCollector as t };
+//# sourceMappingURL=unit-of-work-context-CbUJGHlL.d.ts.map

package/dist/unit-of-work-context-CbUJGHlL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-of-work-context-CbUJGHlL.d.ts","names":[],"sources":["../src/infrastructure/drizzle-schema.ts","../src/infrastructure/unit-of-work-context.ts"],"mappings":";;;;;;;KAKY,gBAAgB;;;;cCsBf,gBAAgB"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "better-ship",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "description": "Foundation for applications on Cloudflare Workers: logger, errors, message bus, infrastructure adapters, and UI primitives",
   "license": "Apache-2.0",
   "repository": {
@@ -30,11 +30,24 @@
     "better-result": "3.0.1"
   },
   "devDependencies": {
+    "@cloudflare/vitest-plugin": "1.1.4",
     "@cloudflare/workers-types": "5.20260905.1",
+    "@types/node": "26.4.1",
+    "drizzle-kit": "0.31.10",
+    "drizzle-orm": "0.45.2",
+    "postgres": "3.4.9",
     "tsdown": "0.23.0",
     "typescript": "7.0.2",
     "vitest": "4.1.11"
   },
+  "peerDependencies": {
+    "drizzle-orm": "0.45.2"
+  },
+  "peerDependenciesMeta": {
+    "drizzle-orm": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=22"
   },
@@ -44,6 +57,8 @@
     "typecheck": "tsc --noEmit && tsc -p tests/tsconfig.json",
     "lint": "oxlint . --quiet",
     "lint:fix": "oxlint . --fix --quiet",
-    "test": "vitest run --passWithNoTests"
+    "test": "vitest run",
+    "db:generate:d1": "drizzle-kit generate --config drizzle.d1.config.ts",
+    "db:generate:postgres": "drizzle-kit generate --config drizzle.postgres.config.ts"
   }
 }

package/src/application/event-collector.ts

@@ -0,0 +1,7 @@
+import type { Event } from './messages.ts'
+
+/** Records events in the current unit of work; the unit of work collects a snapshot for outbox persistence. */
+export interface IEventCollector {
+  emit(event: Event): void
+  collect(): ReadonlyArray<Event>
+}

package/src/application/index.ts

@@ -1,7 +1,8 @@
-export { DuplicateMessageError } from './message-bus.errors.ts'
 export type { CommandHandler, EventHandler, QueryHandler } from './handlers.ts'
+export type { IMessageStore } from './message-store.ts'
 export type { Command, Event, Message, MessageId, Query } from './messages.ts'
 export { MessageBus, type IMessageBus } from './message-bus.ts'
+export type { IOutboxRelay } from './outbox-relay.ts'
 export type {
   CommandRegistry,
   EventRegistry,
@@ -11,3 +12,8 @@ export type {
   QueryRegistry,
   RegistryMessage,
 } from './registry.ts'
+export type { ITransaction } from './transaction.ts'
+export { UnitOfWork, type IUnitOfWork, type UnitOfWorkDeps } from './unit-of-work.ts'
+export type { IEventCollector } from './event-collector.ts'
+export { MessageAlreadyProcessedError } from './message-already-processed.error.ts'
+export { UnitOfWorkAlreadyActiveError } from './unit-of-work.errors.ts'