@entifix/sql 0.11.0 → 0.12.1

package/dist/adapters/sql-repository-factory.d.ts

@@ -0,0 +1,11 @@
+import { EntityRepositoryFactoryTag } from '@entifix/business';
+import { Layer } from 'effect';
+import { SqlClient } from 'effect/sql';
+/**
+ * The repository factory over the one SQL database the service connects to:
+ * every entity reads and writes its own table on the `SqlClient` the
+ * composition root provides. A route set asks the factory, never the client,
+ * so it names no engine.
+ */
+export declare const SqlRepositoryFactoryLayer: Layer.Layer<EntityRepositoryFactoryTag, never, SqlClient.SqlClient>;
+//# sourceMappingURL=sql-repository-factory.d.ts.map

package/dist/adapters/sql-repository-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-repository-factory.d.ts","sourceRoot":"","sources":["../../src/adapters/sql-repository-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAIvC;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,qEASrC,CAAC"}

package/dist/adapters/sql-repository-factory.js

@@ -0,0 +1,17 @@
+import { EntityRepositoryFactoryTag } from '@entifix/business';
+import { Effect, Layer } from 'effect';
+import { SqlClient } from 'effect/sql';
+import { makeSqlRepository } from './make-sql-repository.js';
+/**
+ * The repository factory over the one SQL database the service connects to:
+ * every entity reads and writes its own table on the `SqlClient` the
+ * composition root provides. A route set asks the factory, never the client,
+ * so it names no engine.
+ */ export const SqlRepositoryFactoryLayer = Layer.effect(EntityRepositoryFactoryTag, Effect.gen(function*() {
+    const sql = yield* SqlClient.SqlClient;
+    return {
+        for: (entityConstructor)=>Effect.succeed(makeSqlRepository(sql, entityConstructor))
+    };
+}));
+
+//# sourceMappingURL=sql-repository-factory.js.map

package/dist/adapters/sql-repository-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/sql-repository-factory.ts"],"sourcesContent":["import { EntityRepositoryFactoryTag } from '@entifix/business';\nimport { Effect, Layer } from 'effect';\nimport { SqlClient } from 'effect/sql';\n\nimport { makeSqlRepository } from './make-sql-repository.js';\n\n/**\n * The repository factory over the one SQL database the service connects to:\n * every entity reads and writes its own table on the `SqlClient` the\n * composition root provides. A route set asks the factory, never the client,\n * so it names no engine.\n */\nexport const SqlRepositoryFactoryLayer = Layer.effect(\n  EntityRepositoryFactoryTag,\n  Effect.gen(function* () {\n    const sql = yield* SqlClient.SqlClient;\n    return {\n      for: entityConstructor =>\n        Effect.succeed(makeSqlRepository(sql, entityConstructor)),\n    };\n  }),\n);\n"],"names":["EntityRepositoryFactoryTag","Effect","Layer","SqlClient","makeSqlRepository","SqlRepositoryFactoryLayer","effect","gen","sql","for","entityConstructor","succeed"],"mappings":"AAAA,SAASA,0BAA0B,QAAQ,oBAAoB;AAC/D,SAASC,MAAM,EAAEC,KAAK,QAAQ,SAAS;AACvC,SAASC,SAAS,QAAQ,aAAa;AAEvC,SAASC,iBAAiB,QAAQ,2BAA2B;AAE7D;;;;;CAKC,GACD,OAAO,MAAMC,4BAA4BH,MAAMI,MAAM,CACnDN,4BACAC,OAAOM,GAAG,CAAC;IACT,MAAMC,MAAM,OAAOL,UAAUA,SAAS;IACtC,OAAO;QACLM,KAAKC,CAAAA,oBACHT,OAAOU,OAAO,CAACP,kBAAkBI,KAAKE;IAC1C;AACF,IACA"}

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export * from './adapters/make-sql-repository.js';
 export * from './adapters/sql-filter-translator.js';
+export * from './adapters/sql-repository-factory.js';
+export * from './errors/translate-sql-error.js';
 export * from './sql-database/sql-health-probe.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,oCAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC"}

package/dist/index.js

@@ -1,5 +1,7 @@
 export * from './adapters/make-sql-repository.js';
 export * from './adapters/sql-filter-translator.js';
+export * from './adapters/sql-repository-factory.js';
+export * from './errors/translate-sql-error.js';
 export * from './sql-database/sql-health-probe.js';
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './adapters/make-sql-repository.js';\nexport * from './adapters/sql-filter-translator.js';\nexport * from './sql-database/sql-health-probe.js';\n"],"names":[],"mappings":"AAAA,cAAc,oCAAoC;AAClD,cAAc,sCAAsC;AACpD,cAAc,qCAAqC"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './adapters/make-sql-repository.js';\nexport * from './adapters/sql-filter-translator.js';\nexport * from './adapters/sql-repository-factory.js';\nexport * from './errors/translate-sql-error.js';\nexport * from './sql-database/sql-health-probe.js';\n"],"names":[],"mappings":"AAAA,cAAc,oCAAoC;AAClD,cAAc,sCAAsC;AACpD,cAAc,uCAAuC;AACrD,cAAc,kCAAkC;AAChD,cAAc,qCAAqC"}

package/dist/transactions/idempotency.d.ts

@@ -0,0 +1,15 @@
+import type { IdempotencyStore } from '@entifix/business';
+import type { SqlClient } from 'effect/sql';
+export interface SqlIdempotencyOptions {
+    /** How long a record lives, in milliseconds. */
+    readonly retentionMs: number;
+    /** The clock, in epoch milliseconds. */
+    readonly now?: () => number;
+}
+/**
+ * The idempotency store over SQL. A claim is one statement: it inserts the key,
+ * or takes over a record that has expired, and only one of two concurrent
+ * callers sees its row come back.
+ */
+export declare const makeSqlIdempotencyStore: (sql: SqlClient.SqlClient, { retentionMs, now }: SqlIdempotencyOptions) => IdempotencyStore;
+//# sourceMappingURL=idempotency.d.ts.map

package/dist/transactions/idempotency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idempotency.d.ts","sourceRoot":"","sources":["../../src/transactions/idempotency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,gBAAgB,EAEjB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AA2B5C,MAAM,WAAW,qBAAqB;IACpC,gDAAgD;IAChD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wCAAwC;IACxC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AAID;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAClC,KAAK,SAAS,CAAC,SAAS,EACxB,sBAAiC,qBAAqB,KACrD,gBA2CD,CAAC"}

package/dist/transactions/idempotency.js

@@ -0,0 +1,56 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { Effect } from 'effect';
+import { translateSqlError } from '../errors/translate-sql-error.js';
+const recordOf = (row)=>_extends({
+        dedupKey: row.dedup_key,
+        fingerprint: row.fingerprint,
+        state: row.state
+    }, row.response == null ? {} : {
+        response: typeof row.response === 'string' ? JSON.parse(row.response) : row.response
+    }, {
+        expiresAt: new Date(row.expires_at).toISOString()
+    });
+const fault = (error)=>translateSqlError(error);
+/**
+ * The idempotency store over SQL. A claim is one statement: it inserts the key,
+ * or takes over a record that has expired, and only one of two concurrent
+ * callers sees its row come back.
+ */ export const makeSqlIdempotencyStore = (sql, { retentionMs, now = Date.now })=>({
+        claim: (dedupKey, fingerprint)=>Effect.gen(function*() {
+                const at = new Date(now());
+                const expiresAt = new Date(now() + retentionMs);
+                const taken = yield* sql`
+        INSERT INTO entifix_idempotency (dedup_key, fingerprint, state, expires_at)
+        VALUES (${dedupKey}, ${fingerprint}, 'inFlight', ${expiresAt})
+        ON CONFLICT (dedup_key) DO UPDATE
+          SET fingerprint = EXCLUDED.fingerprint, state = 'inFlight',
+              response = NULL, expires_at = EXCLUDED.expires_at
+          WHERE entifix_idempotency.expires_at <= ${at}
+        RETURNING dedup_key`;
+                if (taken.length > 0) return {
+                    _tag: 'claimed'
+                };
+                const [existing] = yield* sql`
+        SELECT * FROM entifix_idempotency WHERE dedup_key = ${dedupKey}`;
+                // Released between the two statements: one more claim takes it.
+                if (existing === undefined) {
+                    yield* sql`
+          INSERT INTO entifix_idempotency (dedup_key, fingerprint, state, expires_at)
+          VALUES (${dedupKey}, ${fingerprint}, 'inFlight', ${expiresAt})`;
+                    return {
+                        _tag: 'claimed'
+                    };
+                }
+                return {
+                    _tag: 'existing',
+                    record: recordOf(existing)
+                };
+            }).pipe(Effect.mapError(fault)),
+        complete: (dedupKey, response)=>sql`
+      UPDATE entifix_idempotency
+      SET state = 'completed', response = ${JSON.stringify(response)}::jsonb
+      WHERE dedup_key = ${dedupKey}`.pipe(Effect.asVoid, Effect.mapError(fault)),
+        release: (dedupKey)=>sql`DELETE FROM entifix_idempotency WHERE dedup_key = ${dedupKey}`.pipe(Effect.asVoid, Effect.mapError(fault))
+    });
+
+//# sourceMappingURL=idempotency.js.map

package/dist/transactions/idempotency.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/idempotency.ts"],"sourcesContent":["import type {\n  IdempotencyClaim,\n  IdempotencyRecord,\n  IdempotencyStore,\n  StoredResponse,\n} from '@entifix/business';\nimport { Effect } from 'effect';\nimport type { SqlClient } from 'effect/sql';\n\nimport { translateSqlError } from '../errors/translate-sql-error.js';\n\ninterface IdempotencyRow {\n  readonly dedup_key: string;\n  readonly fingerprint: string;\n  readonly state: 'inFlight' | 'completed';\n  readonly response: StoredResponse | string | null;\n  readonly expires_at: Date | string;\n}\n\nconst recordOf = (row: IdempotencyRow): IdempotencyRecord => ({\n  dedupKey: row.dedup_key,\n  fingerprint: row.fingerprint,\n  state: row.state,\n  ...(row.response == null\n    ? {}\n    : {\n        response:\n          typeof row.response === 'string'\n            ? (JSON.parse(row.response) as StoredResponse)\n            : row.response,\n      }),\n  expiresAt: new Date(row.expires_at).toISOString(),\n});\n\nexport interface SqlIdempotencyOptions {\n  /** How long a record lives, in milliseconds. */\n  readonly retentionMs: number;\n  /** The clock, in epoch milliseconds. */\n  readonly now?: () => number;\n}\n\nconst fault = (error: unknown) => translateSqlError(error);\n\n/**\n * The idempotency store over SQL. A claim is one statement: it inserts the key,\n * or takes over a record that has expired, and only one of two concurrent\n * callers sees its row come back.\n */\nexport const makeSqlIdempotencyStore = (\n  sql: SqlClient.SqlClient,\n  { retentionMs, now = Date.now }: SqlIdempotencyOptions,\n): IdempotencyStore => ({\n  claim: (dedupKey, fingerprint) =>\n    Effect.gen(function* () {\n      const at = new Date(now());\n      const expiresAt = new Date(now() + retentionMs);\n      const taken = yield* sql<{ readonly dedup_key: string }>`\n        INSERT INTO entifix_idempotency (dedup_key, fingerprint, state, expires_at)\n        VALUES (${dedupKey}, ${fingerprint}, 'inFlight', ${expiresAt})\n        ON CONFLICT (dedup_key) DO UPDATE\n          SET fingerprint = EXCLUDED.fingerprint, state = 'inFlight',\n              response = NULL, expires_at = EXCLUDED.expires_at\n          WHERE entifix_idempotency.expires_at <= ${at}\n        RETURNING dedup_key`;\n      if (taken.length > 0) return { _tag: 'claimed' } as IdempotencyClaim;\n      const [existing] = yield* sql<IdempotencyRow>`\n        SELECT * FROM entifix_idempotency WHERE dedup_key = ${dedupKey}`;\n      // Released between the two statements: one more claim takes it.\n      if (existing === undefined) {\n        yield* sql`\n          INSERT INTO entifix_idempotency (dedup_key, fingerprint, state, expires_at)\n          VALUES (${dedupKey}, ${fingerprint}, 'inFlight', ${expiresAt})`;\n        return { _tag: 'claimed' } as IdempotencyClaim;\n      }\n      return {\n        _tag: 'existing',\n        record: recordOf(existing),\n      } as IdempotencyClaim;\n    }).pipe(Effect.mapError(fault)),\n\n  complete: (dedupKey, response) =>\n    sql`\n      UPDATE entifix_idempotency\n      SET state = 'completed', response = ${JSON.stringify(response)}::jsonb\n      WHERE dedup_key = ${dedupKey}`.pipe(\n      Effect.asVoid,\n      Effect.mapError(fault),\n    ),\n\n  release: dedupKey =>\n    sql`DELETE FROM entifix_idempotency WHERE dedup_key = ${dedupKey}`.pipe(\n      Effect.asVoid,\n      Effect.mapError(fault),\n    ),\n});\n"],"names":["Effect","translateSqlError","recordOf","row","dedupKey","dedup_key","fingerprint","state","response","JSON","parse","expiresAt","Date","expires_at","toISOString","fault","error","makeSqlIdempotencyStore","sql","retentionMs","now","claim","gen","at","taken","length","_tag","existing","undefined","record","pipe","mapError","complete","stringify","asVoid","release"],"mappings":";AAMA,SAASA,MAAM,QAAQ,SAAS;AAGhC,SAASC,iBAAiB,QAAQ,mCAAmC;AAUrE,MAAMC,WAAW,CAACC,MAA4C;QAC5DC,UAAUD,IAAIE,SAAS;QACvBC,aAAaH,IAAIG,WAAW;QAC5BC,OAAOJ,IAAII,KAAK;OACZJ,IAAIK,QAAQ,IAAI,OAChB,CAAC,IACD;QACEA,UACE,OAAOL,IAAIK,QAAQ,KAAK,WACnBC,KAAKC,KAAK,CAACP,IAAIK,QAAQ,IACxBL,IAAIK,QAAQ;IACpB;QACJG,WAAW,IAAIC,KAAKT,IAAIU,UAAU,EAAEC,WAAW;;AAUjD,MAAMC,QAAQ,CAACC,QAAmBf,kBAAkBe;AAEpD;;;;CAIC,GACD,OAAO,MAAMC,0BAA0B,CACrCC,KACA,EAAEC,WAAW,EAAEC,MAAMR,KAAKQ,GAAG,EAAyB,GAChC,CAAA;QACtBC,OAAO,CAACjB,UAAUE,cAChBN,OAAOsB,GAAG,CAAC;gBACT,MAAMC,KAAK,IAAIX,KAAKQ;gBACpB,MAAMT,YAAY,IAAIC,KAAKQ,QAAQD;gBACnC,MAAMK,QAAQ,OAAON,GAAmC,CAAC;;gBAE/C,EAAEd,SAAS,EAAE,EAAEE,YAAY,cAAc,EAAEK,UAAU;;;;kDAInB,EAAEY,GAAG;2BAC5B,CAAC;gBACtB,IAAIC,MAAMC,MAAM,GAAG,GAAG,OAAO;oBAAEC,MAAM;gBAAU;gBAC/C,MAAM,CAACC,SAAS,GAAG,OAAOT,GAAmB,CAAC;4DACQ,EAAEd,SAAS,CAAC;gBAClE,gEAAgE;gBAChE,IAAIuB,aAAaC,WAAW;oBAC1B,OAAOV,GAAG,CAAC;;kBAED,EAAEd,SAAS,EAAE,EAAEE,YAAY,cAAc,EAAEK,UAAU,CAAC,CAAC;oBACjE,OAAO;wBAAEe,MAAM;oBAAU;gBAC3B;gBACA,OAAO;oBACLA,MAAM;oBACNG,QAAQ3B,SAASyB;gBACnB;YACF,GAAGG,IAAI,CAAC9B,OAAO+B,QAAQ,CAAChB;QAE1BiB,UAAU,CAAC5B,UAAUI,WACnBU,GAAG,CAAC;;0CAEkC,EAAET,KAAKwB,SAAS,CAACzB,UAAU;wBAC7C,EAAEJ,SAAS,CAAC,CAAC0B,IAAI,CACnC9B,OAAOkC,MAAM,EACblC,OAAO+B,QAAQ,CAAChB;QAGpBoB,SAAS/B,CAAAA,WACPc,GAAG,CAAC,kDAAkD,EAAEd,SAAS,CAAC,CAAC0B,IAAI,CACrE9B,OAAOkC,MAAM,EACblC,OAAO+B,QAAQ,CAAChB;IAEtB,CAAA,EAAG"}

package/dist/transactions/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The half of this package that needs `@entifix/transactions`: the unit of
+ * work, the outbox and its relay, the inboxes and the idempotency store over
+ * SQL. Behind a subpath, with that package an optional peer, so entity CRUD
+ * over SQL does not arrive with the outbox attached.
+ */
+export * from './idempotency.js';
+export * from './outbox.js';
+export * from './relay.js';
+export * from './schema.js';
+export * from './unit-of-work.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/transactions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transactions/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC"}

package/dist/transactions/index.js

@@ -0,0 +1,12 @@
+/**
+ * The half of this package that needs `@entifix/transactions`: the unit of
+ * work, the outbox and its relay, the inboxes and the idempotency store over
+ * SQL. Behind a subpath, with that package an optional peer, so entity CRUD
+ * over SQL does not arrive with the outbox attached.
+ */ export * from './idempotency.js';
+export * from './outbox.js';
+export * from './relay.js';
+export * from './schema.js';
+export * from './unit-of-work.js';
+
+//# sourceMappingURL=index.js.map

package/dist/transactions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/index.ts"],"sourcesContent":["/**\n * The half of this package that needs `@entifix/transactions`: the unit of\n * work, the outbox and its relay, the inboxes and the idempotency store over\n * SQL. Behind a subpath, with that package an optional peer, so entity CRUD\n * over SQL does not arrive with the outbox attached.\n */\nexport * from './idempotency.js';\nexport * from './outbox.js';\nexport * from './relay.js';\nexport * from './schema.js';\nexport * from './unit-of-work.js';\n"],"names":[],"mappings":"AAAA;;;;;CAKC,GACD,cAAc,mBAAmB;AACjC,cAAc,cAAc;AAC5B,cAAc,aAAa;AAC3B,cAAc,cAAc;AAC5B,cAAc,oBAAoB"}

package/dist/transactions/outbox.d.ts

@@ -0,0 +1,47 @@
+import type { Outbox, OutboxEntry, OutboxEvent } from '@entifix/transactions';
+import type { SqlClient } from 'effect/sql';
+/** A row of `entifix_outbox`, as the driver hands it back. */
+export type OutboxRow = {
+    readonly event_id: string;
+    readonly aggregate_type: string;
+    readonly aggregate_id: string;
+    readonly version: number;
+    readonly event: OutboxEvent | string;
+    readonly attempts: number;
+    readonly last_error: string | null;
+    readonly quarantined: boolean;
+    readonly sent: boolean;
+    readonly created_at: Date | string;
+};
+/** A row as the outbox port's entry. `jsonb` may arrive parsed or as text. */
+export declare const entryOf: (row: OutboxRow) => OutboxEntry;
+/** The values one event is inserted with. */
+export declare const outboxRow: (event: OutboxEvent) => {
+    event_id: string;
+    aggregate_type: string;
+    aggregate_id: string;
+    version: number;
+    event: string;
+    created_at: string;
+};
+export interface SqlOutboxOptions {
+    /**
+     * How long a relay holds the entries it took before another may take them —
+     * long enough to publish a batch, short enough that a relay that died does
+     * not hold its aggregates past the next sweep. Thirty seconds by default.
+     */
+    readonly leaseSeconds?: number;
+}
+/**
+ * The outbox over Postgres
+ * ([ADR 0018](../../../../../docs/adr/0018-one-outbox-ordered-per-aggregate.md)).
+ *
+ * `pending` **claims** what it returns: it leases the oldest entries of the
+ * aggregates no other relay holds, with `FOR UPDATE SKIP LOCKED` and an
+ * advisory lock per aggregate taken in the same statement, so several runners
+ * drain one table without publishing an entry twice or two versions of one
+ * aggregate out of order. A failure gives the whole aggregate back at once, so
+ * the next pass retries it rather than waiting out the lease.
+ */
+export declare const makeSqlOutbox: (sql: SqlClient.SqlClient, options?: SqlOutboxOptions) => Outbox;
+//# sourceMappingURL=outbox.d.ts.map

package/dist/transactions/outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.d.ts","sourceRoot":"","sources":["../../src/transactions/outbox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI5C,8DAA8D;AAG9D,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,IAAI,GAAG,MAAM,CAAC;CACpC,CAAC;AAKF,8EAA8E;AAC9E,eAAO,MAAM,OAAO,GAAI,KAAK,SAAS,KAAG,WAavC,CAAC;AAEH,6CAA6C;AAC7C,eAAO,MAAM,SAAS,GAAI,OAAO,WAAW;;;;;;;CAO1C,CAAC;AAEH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAID;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GACxB,KAAK,SAAS,CAAC,SAAS,EACxB,UAAS,gBAAqB,KAC7B,MA4FF,CAAC"}

package/dist/transactions/outbox.js

@@ -0,0 +1,99 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { Effect } from 'effect';
+import { translateSqlError } from '../errors/translate-sql-error.js';
+const iso = (value)=>value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+/** A row as the outbox port's entry. `jsonb` may arrive parsed or as text. */ export const entryOf = (row)=>_extends({
+        eventId: row.event_id,
+        aggregate: {
+            type: row.aggregate_type,
+            id: row.aggregate_id
+        },
+        version: row.version,
+        event: typeof row.event === 'string' ? JSON.parse(row.event) : row.event,
+        sent: row.sent,
+        attempts: row.attempts
+    }, row.last_error === null ? {} : {
+        lastError: row.last_error
+    }, {
+        quarantined: row.quarantined,
+        createdAt: iso(row.created_at)
+    });
+/** The values one event is inserted with. */ export const outboxRow = (event)=>({
+        event_id: event.id,
+        aggregate_type: event.aggregate.type,
+        aggregate_id: event.aggregate.id,
+        version: event.version,
+        event: JSON.stringify(event),
+        created_at: event.at
+    });
+const fault = (error)=>translateSqlError(error);
+/**
+ * The outbox over Postgres
+ * ([ADR 0018](../../../../../docs/adr/0018-one-outbox-ordered-per-aggregate.md)).
+ *
+ * `pending` **claims** what it returns: it leases the oldest entries of the
+ * aggregates no other relay holds, with `FOR UPDATE SKIP LOCKED` and an
+ * advisory lock per aggregate taken in the same statement, so several runners
+ * drain one table without publishing an entry twice or two versions of one
+ * aggregate out of order. A failure gives the whole aggregate back at once, so
+ * the next pass retries it rather than waiting out the lease.
+ */ export const makeSqlOutbox = (sql, options = {})=>{
+    var _options_leaseSeconds;
+    const lease = `${String((_options_leaseSeconds = options.leaseSeconds) != null ? _options_leaseSeconds : 30)} seconds`;
+    return {
+        enqueue: (event)=>sql`
+        INSERT INTO entifix_outbox ${sql.insert(outboxRow(event))}
+        ON CONFLICT (event_id) DO NOTHING
+        RETURNING event_id`.pipe(Effect.map((rows)=>rows.length === 0 ? 'duplicate' : 'enqueued'), Effect.mapError(fault)),
+        pending: (limit)=>sql`
+        WITH picked AS (
+          SELECT o.event_id FROM entifix_outbox o
+          WHERE NOT o.sent AND NOT o.quarantined
+            AND (o.lease_until IS NULL OR o.lease_until < now())
+            AND NOT EXISTS (
+              SELECT 1 FROM entifix_outbox h
+              WHERE h.aggregate_type = o.aggregate_type
+                AND h.aggregate_id = o.aggregate_id
+                AND NOT h.sent AND NOT h.quarantined
+                AND h.lease_until >= now()
+            )
+            AND pg_try_advisory_xact_lock(
+              hashtext(o.aggregate_type || ':' || o.aggregate_id)
+            )
+          ORDER BY o.created_at, o.version
+          LIMIT ${limit}
+          FOR UPDATE SKIP LOCKED
+        )
+        UPDATE entifix_outbox AS t
+        SET lease_until = now() + ${lease}::interval
+        FROM picked WHERE t.event_id = picked.event_id
+        RETURNING t.*`.pipe(Effect.map((rows)=>rows.map(entryOf).sort((a, b)=>a.createdAt.localeCompare(b.createdAt) || a.version - b.version)), Effect.mapError(fault)),
+        markSent: (entry)=>sql`
+        UPDATE entifix_outbox SET sent = true, lease_until = NULL
+        WHERE event_id = ${entry.eventId}`.pipe(Effect.asVoid, Effect.mapError(fault)),
+        recordFailure: (entry, error, quarantine)=>sql`
+        UPDATE entifix_outbox
+        SET attempts = attempts + 1, last_error = ${error},
+            quarantined = ${quarantine}
+        WHERE event_id = ${entry.eventId}`.pipe(Effect.andThen(sql`
+            UPDATE entifix_outbox SET lease_until = NULL
+            WHERE aggregate_type = ${entry.aggregate.type}
+              AND aggregate_id = ${entry.aggregate.id} AND NOT sent`), Effect.asVoid, Effect.mapError(fault)),
+        stats: ()=>sql`
+        SELECT
+          count(*) FILTER (WHERE NOT sent AND NOT quarantined) AS pending,
+          count(*) FILTER (WHERE quarantined) AS quarantined,
+          min(created_at) FILTER (WHERE NOT sent AND NOT quarantined) AS oldest
+        FROM entifix_outbox`.pipe(Effect.map(([row])=>{
+                var _ref, _ref1;
+                return _extends({
+                    pending: Number((_ref = row == null ? void 0 : row.pending) != null ? _ref : 0),
+                    quarantined: Number((_ref1 = row == null ? void 0 : row.quarantined) != null ? _ref1 : 0)
+                }, (row == null ? void 0 : row.oldest) == null ? {} : {
+                    oldestPendingAt: iso(row.oldest)
+                });
+            }), Effect.mapError(fault))
+    };
+};
+
+//# sourceMappingURL=outbox.js.map

package/dist/transactions/outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/outbox.ts"],"sourcesContent":["import type { Outbox, OutboxEntry, OutboxEvent } from '@entifix/transactions';\nimport { Effect } from 'effect';\nimport type { SqlClient } from 'effect/sql';\n\nimport { translateSqlError } from '../errors/translate-sql-error.js';\n\n/** A row of `entifix_outbox`, as the driver hands it back. */\n// A type alias, not an interface: a row must be assignable to the record a\n// driver hands back, and an interface has no index signature.\nexport type OutboxRow = {\n  readonly event_id: string;\n  readonly aggregate_type: string;\n  readonly aggregate_id: string;\n  readonly version: number;\n  readonly event: OutboxEvent | string;\n  readonly attempts: number;\n  readonly last_error: string | null;\n  readonly quarantined: boolean;\n  readonly sent: boolean;\n  readonly created_at: Date | string;\n};\n\nconst iso = (value: Date | string): string =>\n  value instanceof Date ? value.toISOString() : new Date(value).toISOString();\n\n/** A row as the outbox port's entry. `jsonb` may arrive parsed or as text. */\nexport const entryOf = (row: OutboxRow): OutboxEntry => ({\n  eventId: row.event_id,\n  aggregate: { type: row.aggregate_type, id: row.aggregate_id },\n  version: row.version,\n  event:\n    typeof row.event === 'string'\n      ? (JSON.parse(row.event) as OutboxEvent)\n      : row.event,\n  sent: row.sent,\n  attempts: row.attempts,\n  ...(row.last_error === null ? {} : { lastError: row.last_error }),\n  quarantined: row.quarantined,\n  createdAt: iso(row.created_at),\n});\n\n/** The values one event is inserted with. */\nexport const outboxRow = (event: OutboxEvent) => ({\n  event_id: event.id,\n  aggregate_type: event.aggregate.type,\n  aggregate_id: event.aggregate.id,\n  version: event.version,\n  event: JSON.stringify(event),\n  created_at: event.at,\n});\n\nexport interface SqlOutboxOptions {\n  /**\n   * How long a relay holds the entries it took before another may take them —\n   * long enough to publish a batch, short enough that a relay that died does\n   * not hold its aggregates past the next sweep. Thirty seconds by default.\n   */\n  readonly leaseSeconds?: number;\n}\n\nconst fault = (error: unknown) => translateSqlError(error);\n\n/**\n * The outbox over Postgres\n * ([ADR 0018](../../../../../docs/adr/0018-one-outbox-ordered-per-aggregate.md)).\n *\n * `pending` **claims** what it returns: it leases the oldest entries of the\n * aggregates no other relay holds, with `FOR UPDATE SKIP LOCKED` and an\n * advisory lock per aggregate taken in the same statement, so several runners\n * drain one table without publishing an entry twice or two versions of one\n * aggregate out of order. A failure gives the whole aggregate back at once, so\n * the next pass retries it rather than waiting out the lease.\n */\nexport const makeSqlOutbox = (\n  sql: SqlClient.SqlClient,\n  options: SqlOutboxOptions = {},\n): Outbox => {\n  const lease = `${String(options.leaseSeconds ?? 30)} seconds`;\n  return {\n    enqueue: event =>\n      sql<{ readonly event_id: string }>`\n        INSERT INTO entifix_outbox ${sql.insert(outboxRow(event))}\n        ON CONFLICT (event_id) DO NOTHING\n        RETURNING event_id`.pipe(\n        Effect.map(rows =>\n          rows.length === 0 ? ('duplicate' as const) : ('enqueued' as const),\n        ),\n        Effect.mapError(fault),\n      ),\n\n    pending: limit =>\n      sql<OutboxRow>`\n        WITH picked AS (\n          SELECT o.event_id FROM entifix_outbox o\n          WHERE NOT o.sent AND NOT o.quarantined\n            AND (o.lease_until IS NULL OR o.lease_until < now())\n            AND NOT EXISTS (\n              SELECT 1 FROM entifix_outbox h\n              WHERE h.aggregate_type = o.aggregate_type\n                AND h.aggregate_id = o.aggregate_id\n                AND NOT h.sent AND NOT h.quarantined\n                AND h.lease_until >= now()\n            )\n            AND pg_try_advisory_xact_lock(\n              hashtext(o.aggregate_type || ':' || o.aggregate_id)\n            )\n          ORDER BY o.created_at, o.version\n          LIMIT ${limit}\n          FOR UPDATE SKIP LOCKED\n        )\n        UPDATE entifix_outbox AS t\n        SET lease_until = now() + ${lease}::interval\n        FROM picked WHERE t.event_id = picked.event_id\n        RETURNING t.*`.pipe(\n        Effect.map(rows =>\n          rows\n            .map(entryOf)\n            .sort(\n              (a, b) =>\n                a.createdAt.localeCompare(b.createdAt) || a.version - b.version,\n            ),\n        ),\n        Effect.mapError(fault),\n      ),\n\n    markSent: entry =>\n      sql`\n        UPDATE entifix_outbox SET sent = true, lease_until = NULL\n        WHERE event_id = ${entry.eventId}`.pipe(\n        Effect.asVoid,\n        Effect.mapError(fault),\n      ),\n\n    recordFailure: (entry, error, quarantine) =>\n      sql`\n        UPDATE entifix_outbox\n        SET attempts = attempts + 1, last_error = ${error},\n            quarantined = ${quarantine}\n        WHERE event_id = ${entry.eventId}`.pipe(\n        Effect.andThen(\n          sql`\n            UPDATE entifix_outbox SET lease_until = NULL\n            WHERE aggregate_type = ${entry.aggregate.type}\n              AND aggregate_id = ${entry.aggregate.id} AND NOT sent`,\n        ),\n        Effect.asVoid,\n        Effect.mapError(fault),\n      ),\n\n    stats: () =>\n      sql<{\n        readonly pending: string | number;\n        readonly quarantined: string | number;\n        readonly oldest: Date | string | null;\n      }>`\n        SELECT\n          count(*) FILTER (WHERE NOT sent AND NOT quarantined) AS pending,\n          count(*) FILTER (WHERE quarantined) AS quarantined,\n          min(created_at) FILTER (WHERE NOT sent AND NOT quarantined) AS oldest\n        FROM entifix_outbox`.pipe(\n        Effect.map(([row]) => ({\n          pending: Number(row?.pending ?? 0),\n          quarantined: Number(row?.quarantined ?? 0),\n          ...(row?.oldest == null ? {} : { oldestPendingAt: iso(row.oldest) }),\n        })),\n        Effect.mapError(fault),\n      ),\n  };\n};\n"],"names":["Effect","translateSqlError","iso","value","Date","toISOString","entryOf","row","eventId","event_id","aggregate","type","aggregate_type","id","aggregate_id","version","event","JSON","parse","sent","attempts","last_error","lastError","quarantined","createdAt","created_at","outboxRow","stringify","at","fault","error","makeSqlOutbox","sql","options","lease","String","leaseSeconds","enqueue","insert","pipe","map","rows","length","mapError","pending","limit","sort","a","b","localeCompare","markSent","entry","asVoid","recordFailure","quarantine","andThen","stats","Number","oldest","oldestPendingAt"],"mappings":"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"}

package/dist/transactions/relay.d.ts

@@ -0,0 +1,22 @@
+import { EventBusTag, OutboxMaxAttempts } from '@entifix/transactions';
+import { type OutboxStatsSink, type RelayOutcomeSink } from '@entifix/transactions/engine';
+import { Effect } from 'effect';
+import { SqlClient } from 'effect/sql';
+/**
+ * Starts the relay over the service's SQL database: the tables are ensured, a
+ * daemon sweeps the outbox, and its last sweep runs in the `flush` phase of a
+ * shutdown, after consumers have stopped and while the bus is still open.
+ * Several replicas may run it at once — the outbox's claim keeps them apart.
+ */
+export declare const startSqlOutboxRelay: (options: {
+    /** What the outbox's outcomes and gauges are labelled with. */
+    readonly database: string;
+    readonly onStats?: OutboxStatsSink;
+    readonly onOutcome?: RelayOutcomeSink;
+}) => Effect.Effect<void, import("@entifix/core").StoreFailure, import("@entifix/business").ShutdownRegistryTag | SqlClient.SqlClient | OutboxMaxAttempts | EventBusTag>;
+/**
+ * One drain now, for a write that just committed — the event leaves at once
+ * rather than at the next sweep. A failure is reported and left to the sweep.
+ */
+export declare const drainSqlOutboxNow: (database: string, onOutcome?: RelayOutcomeSink) => Effect.Effect<void, never, SqlClient.SqlClient | OutboxMaxAttempts | EventBusTag>;
+//# sourceMappingURL=relay.d.ts.map

package/dist/transactions/relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay.d.ts","sourceRoot":"","sources":["../../src/transactions/relay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,gBAAgB,EAGtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAKvC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS;IAC3C,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC;CACvC,uKAcG,CAAC;AAEL;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAU,MAAM,EAChB,YAAW,gBAAqC,sFAe/C,CAAC"}

package/dist/transactions/relay.js

@@ -0,0 +1,45 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { EventBusTag, OutboxMaxAttempts } from '@entifix/transactions';
+import { drainOutbox, ignoreRelayOutcome, runRelayDaemon, sweepOutbox } from '@entifix/transactions/engine';
+import { Effect } from 'effect';
+import { SqlClient } from 'effect/sql';
+import { makeSqlOutbox } from './outbox.js';
+import { ensureSqlTransactionTables } from './schema.js';
+/**
+ * Starts the relay over the service's SQL database: the tables are ensured, a
+ * daemon sweeps the outbox, and its last sweep runs in the `flush` phase of a
+ * shutdown, after consumers have stopped and while the bus is still open.
+ * Several replicas may run it at once — the outbox's claim keeps them apart.
+ */ export const startSqlOutboxRelay = (options)=>Effect.gen(function*() {
+        const sql = yield* SqlClient.SqlClient;
+        const bus = yield* EventBusTag;
+        const maxAttempts = yield* OutboxMaxAttempts;
+        yield* ensureSqlTransactionTables(sql);
+        yield* runRelayDaemon(sweepOutbox(makeSqlOutbox(sql), bus, _extends({
+            maxAttempts,
+            database: options.database
+        }, options.onStats ? {
+            onStats: options.onStats
+        } : {}, options.onOutcome ? {
+            onOutcome: options.onOutcome
+        } : {})));
+    });
+/**
+ * One drain now, for a write that just committed — the event leaves at once
+ * rather than at the next sweep. A failure is reported and left to the sweep.
+ */ export const drainSqlOutboxNow = (database, onOutcome = ignoreRelayOutcome)=>Effect.gen(function*() {
+        const sql = yield* SqlClient.SqlClient;
+        const bus = yield* EventBusTag;
+        const maxAttempts = yield* OutboxMaxAttempts;
+        yield* drainOutbox(makeSqlOutbox(sql), bus, {
+            maxAttempts,
+            database,
+            onOutcome
+        });
+    }).pipe(Effect.catch((failure)=>onOutcome({
+            _tag: 'drainFailed',
+            database,
+            failure
+        })));
+
+//# sourceMappingURL=relay.js.map

package/dist/transactions/relay.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/relay.ts"],"sourcesContent":["import { EventBusTag, OutboxMaxAttempts } from '@entifix/transactions';\nimport {\n  drainOutbox,\n  ignoreRelayOutcome,\n  type OutboxStatsSink,\n  type RelayOutcomeSink,\n  runRelayDaemon,\n  sweepOutbox,\n} from '@entifix/transactions/engine';\nimport { Effect } from 'effect';\nimport { SqlClient } from 'effect/sql';\n\nimport { makeSqlOutbox } from './outbox.js';\nimport { ensureSqlTransactionTables } from './schema.js';\n\n/**\n * Starts the relay over the service's SQL database: the tables are ensured, a\n * daemon sweeps the outbox, and its last sweep runs in the `flush` phase of a\n * shutdown, after consumers have stopped and while the bus is still open.\n * Several replicas may run it at once — the outbox's claim keeps them apart.\n */\nexport const startSqlOutboxRelay = (options: {\n  /** What the outbox's outcomes and gauges are labelled with. */\n  readonly database: string;\n  readonly onStats?: OutboxStatsSink;\n  readonly onOutcome?: RelayOutcomeSink;\n}) =>\n  Effect.gen(function* () {\n    const sql = yield* SqlClient.SqlClient;\n    const bus = yield* EventBusTag;\n    const maxAttempts = yield* OutboxMaxAttempts;\n    yield* ensureSqlTransactionTables(sql);\n    yield* runRelayDaemon(\n      sweepOutbox(makeSqlOutbox(sql), bus, {\n        maxAttempts,\n        database: options.database,\n        ...(options.onStats ? { onStats: options.onStats } : {}),\n        ...(options.onOutcome ? { onOutcome: options.onOutcome } : {}),\n      }),\n    );\n  });\n\n/**\n * One drain now, for a write that just committed — the event leaves at once\n * rather than at the next sweep. A failure is reported and left to the sweep.\n */\nexport const drainSqlOutboxNow = (\n  database: string,\n  onOutcome: RelayOutcomeSink = ignoreRelayOutcome,\n) =>\n  Effect.gen(function* () {\n    const sql = yield* SqlClient.SqlClient;\n    const bus = yield* EventBusTag;\n    const maxAttempts = yield* OutboxMaxAttempts;\n    yield* drainOutbox(makeSqlOutbox(sql), bus, {\n      maxAttempts,\n      database,\n      onOutcome,\n    });\n  }).pipe(\n    Effect.catch(failure =>\n      onOutcome({ _tag: 'drainFailed', database, failure }),\n    ),\n  );\n"],"names":["EventBusTag","OutboxMaxAttempts","drainOutbox","ignoreRelayOutcome","runRelayDaemon","sweepOutbox","Effect","SqlClient","makeSqlOutbox","ensureSqlTransactionTables","startSqlOutboxRelay","options","gen","sql","bus","maxAttempts","database","onStats","onOutcome","drainSqlOutboxNow","pipe","catch","failure","_tag"],"mappings":";AAAA,SAASA,WAAW,EAAEC,iBAAiB,QAAQ,wBAAwB;AACvE,SACEC,WAAW,EACXC,kBAAkB,EAGlBC,cAAc,EACdC,WAAW,QACN,+BAA+B;AACtC,SAASC,MAAM,QAAQ,SAAS;AAChC,SAASC,SAAS,QAAQ,aAAa;AAEvC,SAASC,aAAa,QAAQ,cAAc;AAC5C,SAASC,0BAA0B,QAAQ,cAAc;AAEzD;;;;;CAKC,GACD,OAAO,MAAMC,sBAAsB,CAACC,UAMlCL,OAAOM,GAAG,CAAC;QACT,MAAMC,MAAM,OAAON,UAAUA,SAAS;QACtC,MAAMO,MAAM,OAAOd;QACnB,MAAMe,cAAc,OAAOd;QAC3B,OAAOQ,2BAA2BI;QAClC,OAAOT,eACLC,YAAYG,cAAcK,MAAMC,KAAK;YACnCC;YACAC,UAAUL,QAAQK,QAAQ;WACtBL,QAAQM,OAAO,GAAG;YAAEA,SAASN,QAAQM,OAAO;QAAC,IAAI,CAAC,GAClDN,QAAQO,SAAS,GAAG;YAAEA,WAAWP,QAAQO,SAAS;QAAC,IAAI,CAAC;IAGlE,GAAG;AAEL;;;CAGC,GACD,OAAO,MAAMC,oBAAoB,CAC/BH,UACAE,YAA8Bf,kBAAkB,GAEhDG,OAAOM,GAAG,CAAC;QACT,MAAMC,MAAM,OAAON,UAAUA,SAAS;QACtC,MAAMO,MAAM,OAAOd;QACnB,MAAMe,cAAc,OAAOd;QAC3B,OAAOC,YAAYM,cAAcK,MAAMC,KAAK;YAC1CC;YACAC;YACAE;QACF;IACF,GAAGE,IAAI,CACLd,OAAOe,KAAK,CAACC,CAAAA,UACXJ,UAAU;YAAEK,MAAM;YAAeP;YAAUM;QAAQ,KAErD"}

package/dist/transactions/schema.d.ts

@@ -0,0 +1,17 @@
+import { Effect } from 'effect';
+import type { SqlClient } from 'effect/sql';
+/** The tables the outbox, the inboxes and the idempotency store live in. */
+export declare const SQL_TRANSACTION_TABLES: {
+    readonly outbox: "entifix_outbox";
+    readonly inbox: "entifix_inbox";
+    readonly commandInbox: "entifix_command_inbox";
+    readonly idempotency: "entifix_idempotency";
+};
+/**
+ * Creates the outbox, the event and command inboxes and the idempotency table
+ * if they are missing. Idempotent, so a service runs it on every boot; Postgres
+ * dialect, because the outbox's claim rides `FOR UPDATE SKIP LOCKED` and an
+ * advisory lock.
+ */
+export declare const ensureSqlTransactionTables: (sql: SqlClient.SqlClient) => Effect.Effect<void, import("@entifix/core").StoreFailure, never>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/transactions/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/transactions/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI5C,4EAA4E;AAC5E,eAAO,MAAM,sBAAsB;;;;;CAKzB,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,GAAI,KAAK,SAAS,CAAC,SAAS,qEAyCN,CAAC"}

package/dist/transactions/schema.js

@@ -0,0 +1,56 @@
+import { Effect } from 'effect';
+import { translateSqlError } from '../errors/translate-sql-error.js';
+/** The tables the outbox, the inboxes and the idempotency store live in. */ export const SQL_TRANSACTION_TABLES = {
+    outbox: 'entifix_outbox',
+    inbox: 'entifix_inbox',
+    commandInbox: 'entifix_command_inbox',
+    idempotency: 'entifix_idempotency'
+};
+/**
+ * Creates the outbox, the event and command inboxes and the idempotency table
+ * if they are missing. Idempotent, so a service runs it on every boot; Postgres
+ * dialect, because the outbox's claim rides `FOR UPDATE SKIP LOCKED` and an
+ * advisory lock.
+ */ export const ensureSqlTransactionTables = (sql)=>Effect.gen(function*() {
+        yield* sql`
+      CREATE TABLE IF NOT EXISTS entifix_outbox (
+        event_id text PRIMARY KEY,
+        aggregate_type text NOT NULL,
+        aggregate_id text NOT NULL,
+        version integer NOT NULL,
+        event jsonb NOT NULL,
+        sent boolean NOT NULL DEFAULT false,
+        attempts integer NOT NULL DEFAULT 0,
+        last_error text,
+        quarantined boolean NOT NULL DEFAULT false,
+        created_at timestamptz NOT NULL,
+        lease_until timestamptz
+      )`;
+        yield* sql`
+      CREATE INDEX IF NOT EXISTS entifix_outbox_pending
+        ON entifix_outbox (created_at, version)
+        WHERE NOT sent AND NOT quarantined`;
+        yield* sql`
+      CREATE TABLE IF NOT EXISTS entifix_inbox (
+        consumer text NOT NULL,
+        event_id text NOT NULL,
+        claimed_at timestamptz NOT NULL DEFAULT now(),
+        PRIMARY KEY (consumer, event_id)
+      )`;
+        yield* sql`
+      CREATE TABLE IF NOT EXISTS entifix_command_inbox (
+        command_id text PRIMARY KEY,
+        claimed_at timestamptz NOT NULL DEFAULT now(),
+        replay jsonb
+      )`;
+        yield* sql`
+      CREATE TABLE IF NOT EXISTS entifix_idempotency (
+        dedup_key text PRIMARY KEY,
+        fingerprint text NOT NULL,
+        state text NOT NULL,
+        response jsonb,
+        expires_at timestamptz NOT NULL
+      )`;
+    }).pipe(Effect.mapError((error)=>translateSqlError(error)));
+
+//# sourceMappingURL=schema.js.map

package/dist/transactions/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/schema.ts"],"sourcesContent":["import { Effect } from 'effect';\nimport type { SqlClient } from 'effect/sql';\n\nimport { translateSqlError } from '../errors/translate-sql-error.js';\n\n/** The tables the outbox, the inboxes and the idempotency store live in. */\nexport const SQL_TRANSACTION_TABLES = {\n  outbox: 'entifix_outbox',\n  inbox: 'entifix_inbox',\n  commandInbox: 'entifix_command_inbox',\n  idempotency: 'entifix_idempotency',\n} as const;\n\n/**\n * Creates the outbox, the event and command inboxes and the idempotency table\n * if they are missing. Idempotent, so a service runs it on every boot; Postgres\n * dialect, because the outbox's claim rides `FOR UPDATE SKIP LOCKED` and an\n * advisory lock.\n */\nexport const ensureSqlTransactionTables = (sql: SqlClient.SqlClient) =>\n  Effect.gen(function* () {\n    yield* sql`\n      CREATE TABLE IF NOT EXISTS entifix_outbox (\n        event_id text PRIMARY KEY,\n        aggregate_type text NOT NULL,\n        aggregate_id text NOT NULL,\n        version integer NOT NULL,\n        event jsonb NOT NULL,\n        sent boolean NOT NULL DEFAULT false,\n        attempts integer NOT NULL DEFAULT 0,\n        last_error text,\n        quarantined boolean NOT NULL DEFAULT false,\n        created_at timestamptz NOT NULL,\n        lease_until timestamptz\n      )`;\n    yield* sql`\n      CREATE INDEX IF NOT EXISTS entifix_outbox_pending\n        ON entifix_outbox (created_at, version)\n        WHERE NOT sent AND NOT quarantined`;\n    yield* sql`\n      CREATE TABLE IF NOT EXISTS entifix_inbox (\n        consumer text NOT NULL,\n        event_id text NOT NULL,\n        claimed_at timestamptz NOT NULL DEFAULT now(),\n        PRIMARY KEY (consumer, event_id)\n      )`;\n    yield* sql`\n      CREATE TABLE IF NOT EXISTS entifix_command_inbox (\n        command_id text PRIMARY KEY,\n        claimed_at timestamptz NOT NULL DEFAULT now(),\n        replay jsonb\n      )`;\n    yield* sql`\n      CREATE TABLE IF NOT EXISTS entifix_idempotency (\n        dedup_key text PRIMARY KEY,\n        fingerprint text NOT NULL,\n        state text NOT NULL,\n        response jsonb,\n        expires_at timestamptz NOT NULL\n      )`;\n  }).pipe(Effect.mapError(error => translateSqlError(error)));\n"],"names":["Effect","translateSqlError","SQL_TRANSACTION_TABLES","outbox","inbox","commandInbox","idempotency","ensureSqlTransactionTables","sql","gen","pipe","mapError","error"],"mappings":"AAAA,SAASA,MAAM,QAAQ,SAAS;AAGhC,SAASC,iBAAiB,QAAQ,mCAAmC;AAErE,0EAA0E,GAC1E,OAAO,MAAMC,yBAAyB;IACpCC,QAAQ;IACRC,OAAO;IACPC,cAAc;IACdC,aAAa;AACf,EAAW;AAEX;;;;;CAKC,GACD,OAAO,MAAMC,6BAA6B,CAACC,MACzCR,OAAOS,GAAG,CAAC;QACT,OAAOD,GAAG,CAAC;;;;;;;;;;;;;OAaR,CAAC;QACJ,OAAOA,GAAG,CAAC;;;0CAG2B,CAAC;QACvC,OAAOA,GAAG,CAAC;;;;;;OAMR,CAAC;QACJ,OAAOA,GAAG,CAAC;;;;;OAKR,CAAC;QACJ,OAAOA,GAAG,CAAC;;;;;;;OAOR,CAAC;IACN,GAAGE,IAAI,CAACV,OAAOW,QAAQ,CAACC,CAAAA,QAASX,kBAAkBW,SAAS"}

package/dist/transactions/unit-of-work.d.ts

@@ -0,0 +1,17 @@
+import type { UnitOfWork } from '@entifix/transactions';
+import { type SqlClient } from 'effect/sql';
+/** What a unit's body writes through: the client, inside the unit's transaction. */
+export interface SqlUnit {
+    readonly sql: SqlClient.SqlClient;
+}
+/**
+ * Units of work over one SQL database
+ * ([ADR 0009](../../../../../docs/adr/0009-a-unit-of-work-the-outbox-inbox-and-command-claim-join.md)):
+ * the body's writes, the events it emitted and its claim are one transaction.
+ * A taken claim, or an event id the outbox already holds, rolls back and
+ * answers `duplicate`; a business failure rolls back and answers `aborted`; a
+ * store failure is an error; a serialization failure runs the whole unit again,
+ * body included, which is why the body must be retry-safe.
+ */
+export declare const makeSqlUnitOfWork: (sql: SqlClient.SqlClient) => UnitOfWork<SqlUnit>;
+//# sourceMappingURL=unit-of-work.d.ts.map

package/dist/transactions/unit-of-work.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-of-work.d.ts","sourceRoot":"","sources":["../../src/transactions/unit-of-work.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,UAAU,EAGX,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,SAAS,EAAY,MAAM,YAAY,CAAC;AAKtD,oFAAoF;AACpF,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,SAAS,CAAC;CACnC;AAwCD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAC5B,KAAK,SAAS,CAAC,SAAS,KACvB,UAAU,CAAC,OAAO,CAuGpB,CAAC"}

package/dist/transactions/unit-of-work.js

@@ -0,0 +1,95 @@
+import { Contention, isStoreFault } from '@entifix/core';
+import { Data, Effect, Option, Schedule } from 'effect';
+import { SqlError } from 'effect/sql';
+import { translateSqlError } from '../errors/translate-sql-error.js';
+import { outboxRow } from './outbox.js';
+/** The claim was taken, or an emitted event was already recorded: roll back. */ let Duplicate = class Duplicate extends Data.TaggedError('SqlUnitDuplicate') {
+};
+/** The body refused with a business failure: roll back, and answer it. */ let Aborted = class Aborted extends Data.TaggedError('SqlUnitAborted') {
+};
+/** A serialization failure or a deadlock: the whole unit runs again. */ const ATTEMPTS = 3;
+const BACK_OFF = Schedule.exponential('20 millis');
+const claimed = (sql, claim)=>claim.kind === 'event' ? sql`
+        INSERT INTO entifix_inbox (consumer, event_id)
+        VALUES (${claim.consumer}, ${claim.eventId})
+        ON CONFLICT DO NOTHING RETURNING event_id` : sql`
+        INSERT INTO entifix_command_inbox (command_id)
+        VALUES (${claim.commandId})
+        ON CONFLICT DO NOTHING RETURNING command_id`;
+const readReplay = (sql, commandId)=>sql`
+    SELECT replay FROM entifix_command_inbox WHERE command_id = ${commandId}`.pipe(Effect.map(([row])=>row === undefined || row.replay == null ? Option.none() : Option.some(typeof row.replay === 'string' ? JSON.parse(row.replay) : row.replay)), Effect.mapError((error)=>translateSqlError(error)));
+/**
+ * Units of work over one SQL database
+ * ([ADR 0009](../../../../../docs/adr/0009-a-unit-of-work-the-outbox-inbox-and-command-claim-join.md)):
+ * the body's writes, the events it emitted and its claim are one transaction.
+ * A taken claim, or an event id the outbox already holds, rolls back and
+ * answers `duplicate`; a business failure rolls back and answers `aborted`; a
+ * store failure is an error; a serialization failure runs the whole unit again,
+ * body included, which is why the body must be retry-safe.
+ */ export const makeSqlUnitOfWork = (sql)=>{
+    const attempt = (body, options)=>sql.withTransaction(Effect.gen(function*() {
+            const claim = options == null ? void 0 : options.claim;
+            if (claim !== undefined) {
+                const rows = yield* claimed(sql, claim);
+                if (rows.length === 0) return yield* Effect.fail(new Duplicate());
+            }
+            const emitted = [];
+            const value = yield* body({
+                handle: {
+                    sql
+                },
+                emit: (event)=>void emitted.push(event)
+            }).pipe(// The body's own driver failure is translated first: an outage
+            // fails the unit, while a unique violation is the refusal it would
+            // be from any adapter, and aborts it.
+            Effect.mapError((failure)=>{
+                const translated = SqlError.isSqlError(failure) ? translateSqlError(failure) : failure;
+                return isStoreFault(translated) ? translated : new Aborted({
+                    reason: translated
+                });
+            }));
+            if (emitted.length > 0) {
+                const written = yield* sql`
+              INSERT INTO entifix_outbox ${sql.insert(emitted.map(outboxRow))}
+              ON CONFLICT (event_id) DO NOTHING RETURNING event_id`;
+                // An event id already recorded is the outbox's own idempotency
+                // claim: what it announces committed before.
+                if (written.length < emitted.length) return yield* Effect.fail(new Duplicate());
+            }
+            if ((claim == null ? void 0 : claim.kind) === 'command' && (options == null ? void 0 : options.replay) !== undefined) yield* sql`
+              UPDATE entifix_command_inbox
+              SET replay = ${JSON.stringify(options.replay(value))}::jsonb
+              WHERE command_id = ${claim.commandId}`;
+            return value;
+        })).pipe(Effect.map((value)=>({
+                _tag: 'committed',
+                value
+            })), Effect.catch((failure)=>{
+            var _options_claim;
+            return failure instanceof Duplicate ? Effect.map((options == null ? void 0 : (_options_claim = options.claim) == null ? void 0 : _options_claim.kind) === 'command' ? readReplay(sql, options.claim.commandId) : Effect.succeed(Option.none()), (replay)=>({
+                    _tag: 'duplicate',
+                    replay
+                })) : failure instanceof Aborted ? Effect.succeed({
+                _tag: 'aborted',
+                reason: failure.reason
+            }) : // connection lost, a serialization conflict at commit. A
+            // unique violation cannot: the claim and the outbox insert
+            // both read a conflict as a duplicate, and the body's own is
+            // aborted above.
+            Effect.fail(translateSqlError(failure));
+        }));
+    return {
+        run: (body, options)=>Effect.gen(function*() {
+                const outcome = yield* attempt(body, options).pipe(Effect.retry({
+                    times: ATTEMPTS - 1,
+                    while: (failure)=>failure instanceof Contention,
+                    schedule: BACK_OFF
+                }));
+                if (outcome._tag === 'committed' && (options == null ? void 0 : options.afterCommit)) yield* options.afterCommit.pipe(Effect.ignore);
+                return outcome;
+            }),
+        replay: (commandId)=>readReplay(sql, commandId)
+    };
+};
+
+//# sourceMappingURL=unit-of-work.js.map

package/dist/transactions/unit-of-work.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/unit-of-work.ts"],"sourcesContent":["import { Contention, isStoreFault, type StoreFault } from '@entifix/core';\nimport type {\n  OutboxEvent,\n  UnitClaim,\n  UnitOfWork,\n  UnitOutcome,\n  UnitRunOptions,\n} from '@entifix/transactions';\nimport { Data, Effect, Option, Schedule } from 'effect';\nimport { type SqlClient, SqlError } from 'effect/sql';\n\nimport { translateSqlError } from '../errors/translate-sql-error.js';\nimport { outboxRow } from './outbox.js';\n\n/** What a unit's body writes through: the client, inside the unit's transaction. */\nexport interface SqlUnit {\n  readonly sql: SqlClient.SqlClient;\n}\n\n/** The claim was taken, or an emitted event was already recorded: roll back. */\nclass Duplicate extends Data.TaggedError('SqlUnitDuplicate') {}\n\n/** The body refused with a business failure: roll back, and answer it. */\nclass Aborted extends Data.TaggedError('SqlUnitAborted')<{\n  readonly reason: unknown;\n}> {}\n\n/** A serialization failure or a deadlock: the whole unit runs again. */\nconst ATTEMPTS = 3;\nconst BACK_OFF = Schedule.exponential('20 millis');\n\nconst claimed = (sql: SqlClient.SqlClient, claim: UnitClaim) =>\n  claim.kind === 'event'\n    ? sql<{ readonly event_id: string }>`\n        INSERT INTO entifix_inbox (consumer, event_id)\n        VALUES (${claim.consumer}, ${claim.eventId})\n        ON CONFLICT DO NOTHING RETURNING event_id`\n    : sql<{ readonly command_id: string }>`\n        INSERT INTO entifix_command_inbox (command_id)\n        VALUES (${claim.commandId})\n        ON CONFLICT DO NOTHING RETURNING command_id`;\n\nconst readReplay = (sql: SqlClient.SqlClient, commandId: string) =>\n  sql<{ readonly replay: unknown }>`\n    SELECT replay FROM entifix_command_inbox WHERE command_id = ${commandId}`.pipe(\n    Effect.map(([row]) =>\n      row === undefined || row.replay == null\n        ? Option.none()\n        : Option.some(\n            typeof row.replay === 'string'\n              ? (JSON.parse(row.replay) as unknown)\n              : row.replay,\n          ),\n    ),\n    Effect.mapError(error => translateSqlError(error) as StoreFault),\n  );\n\n/**\n * Units of work over one SQL database\n * ([ADR 0009](../../../../../docs/adr/0009-a-unit-of-work-the-outbox-inbox-and-command-claim-join.md)):\n * the body's writes, the events it emitted and its claim are one transaction.\n * A taken claim, or an event id the outbox already holds, rolls back and\n * answers `duplicate`; a business failure rolls back and answers `aborted`; a\n * store failure is an error; a serialization failure runs the whole unit again,\n * body included, which is why the body must be retry-safe.\n */\nexport const makeSqlUnitOfWork = (\n  sql: SqlClient.SqlClient,\n): UnitOfWork<SqlUnit> => {\n  const attempt = <A, E, R>(\n    body: (unit: {\n      readonly handle: SqlUnit;\n      emit(event: OutboxEvent): void;\n    }) => Effect.Effect<A, E, R>,\n    options: UnitRunOptions<A, R> | undefined,\n  ) =>\n    sql\n      .withTransaction(\n        Effect.gen(function* () {\n          const claim = options?.claim;\n          if (claim !== undefined) {\n            const rows = yield* claimed(sql, claim);\n            if (rows.length === 0) return yield* Effect.fail(new Duplicate());\n          }\n\n          const emitted: OutboxEvent[] = [];\n          const value = yield* body({\n            handle: { sql },\n            emit: event => void emitted.push(event),\n          }).pipe(\n            // The body's own driver failure is translated first: an outage\n            // fails the unit, while a unique violation is the refusal it would\n            // be from any adapter, and aborts it.\n            Effect.mapError(failure => {\n              const translated = SqlError.isSqlError(failure)\n                ? translateSqlError(failure)\n                : failure;\n              return isStoreFault(translated)\n                ? translated\n                : new Aborted({ reason: translated });\n            }),\n          );\n\n          if (emitted.length > 0) {\n            const written = yield* sql<{ readonly event_id: string }>`\n              INSERT INTO entifix_outbox ${sql.insert(emitted.map(outboxRow))}\n              ON CONFLICT (event_id) DO NOTHING RETURNING event_id`;\n            // An event id already recorded is the outbox's own idempotency\n            // claim: what it announces committed before.\n            if (written.length < emitted.length)\n              return yield* Effect.fail(new Duplicate());\n          }\n\n          if (claim?.kind === 'command' && options?.replay !== undefined)\n            yield* sql`\n              UPDATE entifix_command_inbox\n              SET replay = ${JSON.stringify(options.replay(value))}::jsonb\n              WHERE command_id = ${claim.commandId}`;\n          return value;\n        }),\n      )\n      .pipe(\n        Effect.map(\n          value =>\n            ({ _tag: 'committed', value }) as UnitOutcome<\n              A,\n              Exclude<E, StoreFault>\n            >,\n        ),\n        Effect.catch(failure =>\n          failure instanceof Duplicate\n            ? Effect.map(\n                options?.claim?.kind === 'command'\n                  ? readReplay(sql, options.claim.commandId)\n                  : Effect.succeed(Option.none()),\n                replay =>\n                  ({ _tag: 'duplicate', replay }) as UnitOutcome<\n                    A,\n                    Exclude<E, StoreFault>\n                  >,\n              )\n            : failure instanceof Aborted\n              ? Effect.succeed({\n                  _tag: 'aborted',\n                  reason: failure.reason as Exclude<E, StoreFault>,\n                } as UnitOutcome<A, Exclude<E, StoreFault>>)\n              : // What reaches here is the transaction's own failure — a\n                // connection lost, a serialization conflict at commit. A\n                // unique violation cannot: the claim and the outbox insert\n                // both read a conflict as a duplicate, and the body's own is\n                // aborted above.\n                Effect.fail(translateSqlError(failure) as StoreFault),\n        ),\n      );\n\n  return {\n    run: (body, options) =>\n      Effect.gen(function* () {\n        const outcome = yield* attempt(body, options).pipe(\n          Effect.retry({\n            times: ATTEMPTS - 1,\n            while: failure => failure instanceof Contention,\n            schedule: BACK_OFF,\n          }),\n        );\n        if (outcome._tag === 'committed' && options?.afterCommit)\n          yield* options.afterCommit.pipe(Effect.ignore);\n        return outcome;\n      }),\n    replay: commandId => readReplay(sql, commandId),\n  };\n};\n"],"names":["Contention","isStoreFault","Data","Effect","Option","Schedule","SqlError","translateSqlError","outboxRow","Duplicate","TaggedError","Aborted","ATTEMPTS","BACK_OFF","exponential","claimed","sql","claim","kind","consumer","eventId","commandId","readReplay","pipe","map","row","undefined","replay","none","some","JSON","parse","mapError","error","makeSqlUnitOfWork","attempt","body","options","withTransaction","gen","rows","length","fail","emitted","value","handle","emit","event","push","failure","translated","isSqlError","reason","written","insert","stringify","_tag","catch","succeed","run","outcome","retry","times","while","schedule","afterCommit","ignore"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entifix/sql",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "SQL adapter over @effect/sql: an entity repository with RSQL filter and sort translation, and a health probe.",
   "license": "MIT",
   "repository": {
@@ -21,6 +21,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./transactions": {
+      "types": "./dist/transactions/index.d.ts",
+      "import": "./dist/transactions/index.js",
+      "default": "./dist/transactions/index.js"
     }
   },
   "files": [
@@ -46,19 +51,34 @@
           "skipTypeCheck": true,
           "stripLeadingPaths": true
         }
+      },
+      "test-integration": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "vitest run --config vitest.integration.mts",
+          "cwd": "packages/ts/sql-client"
+        }
       }
     }
   },
   "dependencies": {
     "@swc/helpers": "0.5.23",
-    "@entifix/core": "0.11.0",
-    "@entifix/business": "0.11.0"
+    "@entifix/business": "0.12.1",
+    "@entifix/core": "0.12.1"
   },
   "devDependencies": {
+    "@effect/sql-pg": "4.0.6",
     "effect": "4.0.6",
-    "@entifix/testing-unit": "0.11.0"
+    "@entifix/testing-unit": "0.12.1",
+    "@entifix/transactions": "0.12.1"
   },
   "peerDependencies": {
-    "effect": "^4.0.6"
+    "effect": "^4.0.6",
+    "@entifix/transactions": "0.12.1"
+  },
+  "peerDependenciesMeta": {
+    "@entifix/transactions": {
+      "optional": true
+    }
   }
 }