experimental-a2 0.2.0 → 0.4.0

package/dist/{log-postgres.js → store-postgres.js}

@@ -1,13 +1,14 @@
-import { t as A2Error } from "./errors-BJRMd-h6.js";
+import { t as A2Error } from "./errors-BQuJpe82.js";
+import { n as pollingStream } from "./store-polling-DgrrAE3d.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
-import { t as idempotentReplay } from "./idempotent-replay-BMyHrP0L.js";
-import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./log-yJbXUf72.js";
-import { t as pollingStream } from "./log-polling-6COoN60V.js";
-//#region src/log-postgres.ts
+import { t as idempotentReplay } from "./idempotent-replay-DuqEkYA7.js";
+import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./store-N8PXxDAS.js";
+import { t as decodeReturnedEventIds } from "./store-codec-DTG0Ftek.js";
+//#region src/store-postgres.ts
 /**
-* experimental-a2/log-postgres — postgres log backend (the production path).
+* experimental-a2/store-postgres — postgres store backend (the production path).
 *
-* Implements the A2Log interface over any client that speaks the tiny
+* Implements the A2Store interface over any client that speaks the tiny
 * `PostgresClient` shape below — a `pg` Pool matches it structurally
 * (and is what `connectionString` creates, lazily; `pg` is an optional
 * peer dependency). The conformance suite in test/conformance is the
@@ -69,6 +70,17 @@ create table if not exists a2_snapshots (
   updated_at   bigint not null,
   primary key (session_id, reducer_name)
 );
+
+create table if not exists a2_presence (
+  ns          text   not null,
+  participant text   not null,
+  field       text   not null,
+  value       jsonb  not null,
+  seen        bigint not null,
+  at          bigint not null,
+  expires_at  bigint not null,
+  primary key (ns, participant, field)
+);
 `;
 const asNumber = (value) => Number(value);
 const toDate = (ms) => ms === null || ms === void 0 ? null : new Date(asNumber(ms));
@@ -94,7 +106,7 @@ const toStored = (row) => ({
 	lane: row["lane"] ?? null,
 	processedAt: toDate(row["processed_at"]),
 	processedByAttempt: row["processed_by_attempt"] === null || row["processed_by_attempt"] === void 0 ? null : asNumber(row["processed_by_attempt"]),
-	returnedEventIds: row["returned_event_ids"] === null || row["returned_event_ids"] === void 0 ? null : typeof row["returned_event_ids"] === "string" ? JSON.parse(row["returned_event_ids"]) : row["returned_event_ids"],
+	returnedEventIds: row["returned_event_ids"] === null || row["returned_event_ids"] === void 0 ? null : decodeReturnedEventIds(row["returned_event_ids"]),
 	firstClaimedAt: toDate(row["first_claimed_at"]),
 	lastClaimedAt: toDate(row["last_claimed_at"]),
 	attemptCount: asNumber(row["attempt_count"]),
@@ -119,7 +131,7 @@ const wrap = async (fn) => {
 		return await fn();
 	} catch (err) {
 		if (err instanceof A2Error || err instanceof TypeError) throw err;
-		throw new A2Error("LOG_UNAVAILABLE", "postgres log operation failed", { cause: err });
+		throw new A2Error("STORE_UNAVAILABLE", "postgres store operation failed", { cause: err });
 	}
 };
 const jsonb = (value) => JSON.stringify(value) ?? "null";
@@ -151,7 +163,7 @@ function postgres(options = {}) {
 			let c = options.client;
 			if (!c) {
 				c = new (await (import("pg").catch(() => {
-					throw new A2Error("LOG_NOT_CONFIGURED", "experimental-a2/log-postgres with a connectionString needs the 'pg' package (optional peer dependency) — install it, or inject a client");
+					throw new A2Error("STORE_NOT_CONFIGURED", "experimental-a2/store-postgres with a connectionString needs the 'pg' package (optional peer dependency) — install it, or inject a client");
 				}))).default.Pool({ connectionString: options.connectionString });
 				owned = c;
 			}
@@ -230,6 +242,19 @@ function postgres(options = {}) {
 						throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`);
 					}
 				}
+				const causeIndexes = [...new Set(events.filter((e) => e.cause !== void 0).map((e) => e.cause.index))];
+				if (causeIndexes.length > 0) {
+					const { rows: parents } = await query(`select idx, attempt_count, failed_at from a2_events
+                where session_id = $1 and idx = any($2::bigint[])
+                for update`, [sessionId, causeIndexes]);
+					const byIndex = new Map(parents.map((row) => [asNumber(row["idx"]), row]));
+					for (const e of events) {
+						if (!e.cause) continue;
+						const parent = byIndex.get(e.cause.index);
+						if (!parent) throw new TypeError(`no event at index ${e.cause.index} in session '${sessionId}'`);
+						if (asNumber(parent["attempt_count"]) !== e.cause.attempt || parent["failed_at"] !== null) throw new A2Error("SUPERSEDED_ATTEMPT", `attempt ${e.cause.attempt} no longer owns event ${e.cause.index} in session '${sessionId}'`);
+					}
+				}
 				const { rows: maxRows } = await query(`select coalesce(max(idx), 0) as max,
                     exists(
                       select 1 from a2_events pending
@@ -305,6 +330,10 @@ function postgres(options = {}) {
 					params.push(opts.afterIndex);
 					conditions.push(`idx > $${params.length}`);
 				}
+				if (opts?.throughIndex !== void 0) {
+					params.push(opts.throughIndex);
+					conditions.push(`idx <= $${params.length}`);
+				}
 				const { rows } = await c.query(`select * from a2_events where ${conditions.join(" and ")} order by idx`, params);
 				return rows.map(toStored);
 			});
@@ -356,27 +385,56 @@ function postgres(options = {}) {
 				};
 			}));
 		},
-		async renewClaims({ sessionId, holder, indexes, ttlMs, expiresAtMs }) {
-			if (indexes.length === 0) return [];
+		async renewClaims({ sessionId, holder, claims, ttlMs, expiresAtMs }) {
+			if (claims.length === 0) return {
+				renewed: [],
+				superseded: []
+			};
 			return wrap(async () => {
 				const c = await client();
 				const now = clock.now().getTime();
 				const expiresAt = expiresAtMs ?? now + ttlMs;
-				const { rows } = await c.query(`update a2_events set claim_expires_at = $1
-            where session_id = $2
-              and idx = any($3::bigint[])
-              and processed_at is null
-              and failed_at is null
-              and claim_holder = $4
-              and claim_expires_at > $5
-            returning idx`, [
+				const indexes = claims.map((claim) => claim.index);
+				const attempts = new Map(claims.map((claim) => [claim.index, claim.attempt]));
+				const { rows } = await c.query(`with listed as (
+             select idx, attempt
+               from unnest($3::bigint[], $6::int[]) as listed(idx, attempt)
+           ),
+           renewed as (
+             update a2_events event set claim_expires_at = $1
+               from listed
+              where event.session_id = $2
+                and event.idx = listed.idx
+                and event.attempt_count = listed.attempt
+                and event.processed_at is null
+                and event.failed_at is null
+                and event.claim_holder = $4
+                and event.claim_expires_at > $5
+              returning event.idx
+           )
+           select event.idx, event.attempt_count,
+                  exists(select 1 from renewed where renewed.idx = event.idx)
+                    as renewed
+             from a2_events event
+            where event.session_id = $2 and event.idx = any($3::bigint[])`, [
 					expiresAt,
 					sessionId,
 					indexes,
 					holder,
-					now
+					now,
+					claims.map((claim) => claim.attempt)
 				]);
-				return rows.map((row) => asNumber(row["idx"])).toSorted((a, b) => a - b);
+				const renewed = [];
+				const superseded = [];
+				for (const row of rows) {
+					const index = asNumber(row["idx"]);
+					if (row["renewed"] === true) renewed.push(index);
+					else if (asNumber(row["attempt_count"]) > (attempts.get(index) ?? 0)) superseded.push(index);
+				}
+				return {
+					renewed: renewed.toSorted((a, b) => a - b),
+					superseded: superseded.toSorted((a, b) => a - b)
+				};
 			});
 		},
 		async completeAttempt({ sessionId, index, attempt, events }) {
@@ -390,7 +448,7 @@ function postgres(options = {}) {
 				if (new Set(ids).size !== ids.length) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains the same event id more than once");
 				if (parent["processed_at"] !== null) {
 					if (asNumber(parent["processed_by_attempt"]) !== attempt) return { outcome: "superseded" };
-					const returnedIds = parent["returned_event_ids"] === null || parent["returned_event_ids"] === void 0 ? null : typeof parent["returned_event_ids"] === "string" ? JSON.parse(parent["returned_event_ids"]) : parent["returned_event_ids"];
+					const returnedIds = parent["returned_event_ids"] === null || parent["returned_event_ids"] === void 0 ? null : decodeReturnedEventIds(parent["returned_event_ids"]);
 					if (returnedIds === null || returnedIds.length !== ids.length || returnedIds.some((id, offset) => id !== ids[offset])) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "completed attempt does not match the returned event batch");
 					if (events.length === 0) return {
 						outcome: "completed",
@@ -592,6 +650,63 @@ function postgres(options = {}) {
 				]);
 			});
 		},
+		presence: {
+			async set(ns, participant, values, meta) {
+				const entries = Object.entries(values);
+				if (entries.length === 0) return;
+				await wrap(async () => {
+					const c = await client();
+					const atMs = meta.at.getTime();
+					const expiresAtMs = clock.now().getTime() + meta.ttlMs;
+					for (const [field, value] of entries) await (value === null ? c.query(`delete from a2_presence
+                    where ns = $1 and participant = $2 and field = $3
+                      and at <= $4`, [
+						ns,
+						participant,
+						field,
+						atMs
+					]) : c.query(`insert into a2_presence
+                     (ns, participant, field, value, seen, at, expires_at)
+                   values ($1, $2, $3, $4::jsonb, $5, $6, $7)
+                   on conflict (ns, participant, field) do update set
+                     value = excluded.value,
+                     seen = excluded.seen,
+                     at = excluded.at,
+                     expires_at = excluded.expires_at
+                   where a2_presence.at <= excluded.at`, [
+						ns,
+						participant,
+						field,
+						jsonb(value),
+						meta.seen,
+						atMs,
+						expiresAtMs
+					]));
+				});
+			},
+			async read(ns) {
+				return wrap(async () => {
+					const c = await client();
+					const now = clock.now().getTime();
+					const { rows } = await c.query(`with swept as (
+               delete from a2_presence
+                where ns = $1 and expires_at <= $2
+             )
+             select participant, field, value, seen, at, expires_at
+               from a2_presence
+              where ns = $1 and expires_at > $2
+              order by participant, field`, [ns, now]);
+					return rows.map((row) => ({
+						participant: row["participant"],
+						field: row["field"],
+						value: row["value"],
+						seen: asNumber(row["seen"]),
+						at: new Date(asNumber(row["at"])),
+						expiresAt: new Date(asNumber(row["expires_at"]))
+					}));
+				});
+			}
+		},
 		inspect: {
 			async listSessions(inspectionOptions) {
 				return wrap(async () => {
@@ -641,6 +756,25 @@ function postgres(options = {}) {
 					};
 				});
 			},
+			async readEvents(sessionId, pageOptions) {
+				return wrap(async () => {
+					const c = await client();
+					const currentFrontier = asNumber((await c.query("select coalesce(max(idx), 0) as frontier from a2_events where session_id = $1", [sessionId])).rows[0]?.["frontier"] ?? 0);
+					const throughIndex = Math.min(pageOptions.throughIndex ?? currentFrontier, currentFrontier);
+					const { rows } = await c.query(`select * from a2_events
+              where session_id = $1 and idx > $2 and idx <= $3
+              order by idx limit $4`, [
+						sessionId,
+						pageOptions.afterIndex,
+						throughIndex,
+						pageOptions.limit
+					]);
+					return {
+						events: rows.map(toStored),
+						throughIndex
+					};
+				});
+			},
 			async listSnapshots(sessionId) {
 				return wrap(async () => {
 					const { rows } = await (await client()).query(`select reducer_name, up_to_index, updated_at
@@ -658,7 +792,7 @@ function postgres(options = {}) {
 				const { rows } = await (await client()).query("select * from a2_events where session_id = $1 and idx > $2 order by idx", [sessionId, afterIndex]);
 				return rows.map(toStored);
 			});
-			return pollingStream(readAfter, opts?.startAt !== void 0 ? { startAt: opts.startAt } : {});
+			return pollingStream(readAfter, opts?.startAfter !== void 0 ? { startAfter: opts.startAfter } : {});
 		},
 		async close() {
 			const current = connection.peek();