@shware/workflow 6.1.1 → 8.0.0

package/dist/store/postgres.mjs

@@ -1,10 +1,16 @@
 import { ConditionIR, WorkflowIR } from "../ir.mjs";
 import { UserErasedError } from "./erasure.mjs";
+import { visitorIdOf, visitorSubject } from "./identity.mjs";
 import { uuidv7 } from "./sql.mjs";
-import { lockUserTransaction } from "./user-lock.mjs";
+import { beginReadCommitted, lockUser, lockUserTransaction } from "./user-lock.mjs";
 import { PostgresReporting } from "./postgres-reporting.mjs";
 import { DEFAULT_SCHEMA, TABLES, columnName, indexName, uniqueConstraintName } from "./tables.mjs";
 // src/store/postgres.ts
+/** Who a device row belongs to: its user, or before sign-in its visitor. */
+function deviceOwner(row) {
+	if (row.user_id !== null) return row.user_id;
+	return row.visitor_id === null ? void 0 : visitorSubject(row.visitor_id);
+}
 /** information_schema's udt_name per column type. */
 const UDT = {
 	uuid: "uuid",
@@ -154,29 +160,55 @@ var PostgresJourneyStore = class {
 			params
 		};
 	}
-	async countEvents(userId, event, window) {
+	async countEvents(userId, event, window, atLeast) {
 		const { where, params } = this.eventWindow(userId, event, window);
-		const rows = await this.sql.query(`SELECT count(*)::int AS c FROM ${this.t.event} WHERE ${where}`, params);
+		const capped = atLeast !== void 0 && Number.isInteger(atLeast) && atLeast > 0;
+		if (capped) params.push(atLeast);
+		const rows = await this.sql.query(capped ? `SELECT count(*)::int AS c FROM (SELECT 1 FROM ${this.t.event} WHERE ${where} LIMIT $${params.length}) capped` : `SELECT count(*)::int AS c FROM ${this.t.event} WHERE ${where}`, params);
 		return Number(rows.at(0)?.c ?? 0);
 	}
-	async listEventPayloads(userId, event, window) {
+	async pageEventPayloads(userId, event, window, page) {
 		const { where, params } = this.eventWindow(userId, event, window);
-		return (await this.sql.query(`SELECT payload FROM ${this.t.event} WHERE ${where}`, params)).map((row) => asJson(row.payload));
+		let keyset = "";
+		if (page.after !== void 0) {
+			params.push(page.after.ts, page.after.id);
+			keyset = ` AND (ts, id) > ($${params.length - 1}::timestamptz, $${params.length}::uuid)`;
+		}
+		params.push(page.limit);
+		const rows = await this.sql.query(`SELECT payload, ts::text AS ts, id::text AS id FROM ${this.t.event}
+       WHERE ${where}${keyset} ORDER BY ts, id LIMIT $${params.length}`, params);
+		const last = rows.at(-1);
+		return {
+			payloads: rows.map((row) => asJson(row.payload)),
+			...last !== void 0 && rows.length === page.limit ? { next: {
+				ts: last.ts,
+				id: last.id
+			} } : {}
+		};
 	}
 	async getProfile(userId) {
 		const row = (await this.sql.query(`SELECT props FROM ${this.t.profile} WHERE user_id = $1`, [userId])).at(0);
 		return row === void 0 ? void 0 : asJson(row.props);
 	}
-	async mergeProfile(userId, props) {
+	async mergeProfile(userId, props, at = Date.now()) {
 		return this.sql.transaction(async (tx) => {
 			await this.lockUser(tx, userId);
-			const rows = await tx.query(`INSERT INTO ${this.t.profile} (user_id, props)
-         SELECT $1, jsonb_strip_nulls($2::text::jsonb) ${this.notErased("$1")}
-         ON CONFLICT (user_id) DO UPDATE SET props = jsonb_strip_nulls(${this.t.profile}.props || $3::text::jsonb)
+			const times = asJson((await tx.query(`SELECT props_at FROM ${this.t.profile} WHERE user_id = $1`, [userId]))[0]?.props_at ?? null) ?? {};
+			const patch = Object.fromEntries(Object.entries(props).filter(([key]) => (times[key] ?? Number.NEGATIVE_INFINITY) <= at));
+			const stamped = {
+				...times,
+				...Object.fromEntries(Object.keys(patch).map((k) => [k, at]))
+			};
+			const rows = await tx.query(`INSERT INTO ${this.t.profile} (user_id, props, props_at)
+         SELECT $1, jsonb_strip_nulls($2::text::jsonb), $4::text::jsonb ${this.notErased("$1")}
+         ON CONFLICT (user_id) DO UPDATE SET
+           props = jsonb_strip_nulls(${this.t.profile}.props || $3::text::jsonb),
+           props_at = $4::text::jsonb
          RETURNING props`, [
 				userId,
-				JSON.stringify(props),
-				JSON.stringify(props)
+				JSON.stringify(patch),
+				JSON.stringify(patch),
+				JSON.stringify(stamped)
 			]);
 			if (rows.length === 0) throw new UserErasedError(userId);
 			return asJson(rows[0].props);
@@ -184,10 +216,10 @@ var PostgresJourneyStore = class {
 	}
 	async listUserIds(page) {
 		const params = [];
-		let where = "";
+		let where = ` WHERE user_id NOT LIKE '${visitorSubject("")}%'`;
 		if (page?.after !== void 0) {
 			params.push(page.after);
-			where = ` WHERE user_id > $${params.length}`;
+			where += ` AND user_id > $${params.length}`;
 		}
 		let limit = "";
 		if (page?.limit !== void 0) {
@@ -196,23 +228,160 @@ var PostgresJourneyStore = class {
 		}
 		return (await this.sql.query(`SELECT user_id FROM (SELECT user_id FROM ${this.t.profile} UNION SELECT user_id FROM ${this.t.event}) u${where} ORDER BY user_id${limit}`, params)).map((row) => row.user_id);
 	}
-	listDevices(userId) {
-		return this.sql.query(`SELECT token, platform FROM ${this.t.device} WHERE user_id = $1 ORDER BY ts DESC`, [userId]);
+	listDevices(subject) {
+		const visitorId = visitorIdOf(subject);
+		return this.sql.query(visitorId === void 0 ? `SELECT token, platform FROM ${this.t.device} WHERE user_id = $1 ORDER BY updated_at DESC` : `SELECT token, platform FROM ${this.t.device} WHERE visitor_id = $1 AND user_id IS NULL ORDER BY updated_at DESC`, [visitorId ?? subject]);
 	}
 	async upsertDevice(device) {
-		await this.sql.transaction(async (tx) => {
-			await this.lockUser(tx, device.userId);
-			if ((await tx.query(`INSERT INTO ${this.t.device} (token, user_id, platform, ts)
-         SELECT $1, $2, $3, ${TS("$4")} ${this.notErased("$2")}
-         ON CONFLICT (token) DO UPDATE SET user_id = EXCLUDED.user_id, platform = EXCLUDED.platform, ts = EXCLUDED.ts
+		const { deviceId = null, userId, visitorId = null, token, platform, at } = device;
+		const subject = userId ?? visitorSubject(visitorId ?? "");
+		return this.sql.transaction(async (tx) => {
+			await this.lockUser(tx, subject);
+			const previous = await tx.query(`SELECT token, user_id, visitor_id FROM ${this.t.device} WHERE token = $1 OR device_id = $2 FOR UPDATE`, [token, deviceId]);
+			for (const row of previous) {
+				if (row.token === token) continue;
+				const owner = deviceOwner(row);
+				await tx.query(owner === void 0 || owner === subject ? `DELETE FROM ${this.t.device} WHERE token = $1` : `UPDATE ${this.t.device} SET device_id = NULL WHERE token = $1`, [row.token]);
+			}
+			if ((await tx.query(`INSERT INTO ${this.t.device} (device_id, user_id, visitor_id, token, platform, created_at, updated_at)
+         SELECT $1, $2, $3, $4, $5, ${TS("$6")}, ${TS("$6")} ${this.notErased("$7")}
+         ON CONFLICT (token) DO UPDATE SET
+           device_id = COALESCE(EXCLUDED.device_id, ${this.t.device}.device_id),
+           user_id = EXCLUDED.user_id,
+           visitor_id = COALESCE(EXCLUDED.visitor_id, ${this.t.device}.visitor_id),
+           platform = EXCLUDED.platform,
+           updated_at = EXCLUDED.updated_at
          RETURNING token`, [
-				device.token,
-				device.userId,
-				device.platform,
-				device.ts
-			])).length === 0) throw new UserErasedError(device.userId);
+				deviceId,
+				userId,
+				visitorId,
+				token,
+				platform,
+				at,
+				subject
+			])).length === 0) throw new UserErasedError(subject);
+			const owners = previous.flatMap((row) => {
+				const owner = deviceOwner(row);
+				return owner === void 0 || owner === subject ? [] : [owner];
+			});
+			return [...new Set(owners)];
+		});
+	}
+	async linkedUser(visitorId) {
+		return (await this.sql.query(`SELECT user_id FROM ${this.t.visitor} WHERE visitor_id = $1`, [visitorId]))[0]?.user_id ?? void 0;
+	}
+	async touchVisitor(visitorId, at) {
+		return (await this.sql.query(`INSERT INTO ${this.t.visitor} (visitor_id, user_id, created_at, updated_at)
+       VALUES ($1, NULL, ${TS("$2")}, ${TS("$2")})
+       ON CONFLICT (visitor_id) DO UPDATE SET updated_at = EXCLUDED.updated_at
+       RETURNING user_id`, [visitorId, at]))[0]?.user_id ?? visitorSubject(visitorId);
+	}
+	async pruneVisitors(before, limit) {
+		const idle = `user_id IS NULL AND updated_at < ${TS("$1")} AND NOT EXISTS (
+      SELECT 1 FROM ${this.t.entry} e
+      WHERE e.user_id = '${visitorSubject("")}' || visitor_id AND e.status = 'running')`;
+		const candidates = await this.sql.query(`SELECT visitor_id FROM ${this.t.visitor} WHERE ${idle} ORDER BY updated_at LIMIT $2`, [before, limit]);
+		let pruned = 0;
+		for (const { visitor_id: visitorId } of candidates) {
+			const subject = visitorSubject(visitorId);
+			await this.sql.transaction(async (tx) => {
+				await this.lockUser(tx, subject);
+				if ((await tx.query(`DELETE FROM ${this.t.visitor} WHERE visitor_id = $2 AND ${idle} RETURNING visitor_id`, [before, visitorId])).length === 0) return;
+				await this.deleteSubjectRows(tx, subject);
+				pruned += 1;
+			});
+		}
+		return pruned;
+	}
+	async entryOwner(instanceId) {
+		return (await this.sql.query(`SELECT user_id FROM ${this.t.entry} WHERE instance_id = $1`, [instanceId]))[0]?.user_id;
+	}
+	async linkVisitor(visitorId, userId, at) {
+		const subject = visitorSubject(visitorId);
+		if (await this.linkedUser(visitorId) !== void 0) return null;
+		return this.sql.transaction(async (tx) => {
+			await beginReadCommitted(tx);
+			for (const key of [subject, userId].sort()) await lockUser(tx, this.schema, key);
+			if ((await tx.query(`INSERT INTO ${this.t.visitor} (visitor_id, user_id, created_at, updated_at)
+         SELECT $1, $2, ${TS("$3")}, ${TS("$3")} ${this.notErased("$2")}
+         ON CONFLICT (visitor_id) DO UPDATE SET user_id = EXCLUDED.user_id, updated_at = EXCLUDED.updated_at
+           WHERE ${this.t.visitor}.user_id IS NULL
+         RETURNING visitor_id`, [
+				visitorId,
+				userId,
+				at
+			])).length === 0) {
+				if ((await tx.query(`SELECT 1 FROM ${this.t.erasure} WHERE user_id = $1`, [userId])).length > 0) throw new UserErasedError(userId);
+				return null;
+			}
+			const droppedIds = (await tx.query(`DELETE FROM ${this.t.entry} v USING ${this.t.entry} u
+         WHERE v.user_id = $1 AND u.user_id = $2 AND u.workflow = v.workflow
+         RETURNING v.instance_id`, [subject, userId])).map((row) => row.instance_id);
+			await tx.query(`DELETE FROM ${this.t.subscription} WHERE wake_handle = ANY($1::text[])`, [droppedIds]);
+			await tx.query(`DELETE FROM ${this.t.execution} WHERE instance_id = ANY($1::text[])`, [droppedIds]);
+			await tx.query(`DELETE FROM ${this.t.event} v USING ${this.t.event} u
+         WHERE v.user_id = $1 AND u.user_id = $2 AND u.event_id = v.event_id`, [subject, userId]);
+			const events = await tx.query(`SELECT DISTINCT name FROM ${this.t.event} WHERE user_id = $1`, [subject]);
+			await tx.query(`INSERT INTO ${this.t.suppression} (user_id, channel, topic, ts)
+         SELECT $2, channel, topic, ts FROM ${this.t.suppression} WHERE user_id = $1
+         ON CONFLICT (user_id, channel, topic) DO NOTHING`, [subject, userId]);
+			await tx.query(`DELETE FROM ${this.t.suppression} WHERE user_id = $1`, [subject]);
+			const props = await this.mergeProfileInto(tx, subject, userId);
+			for (const table of [
+				this.t.event,
+				this.t.entry,
+				this.t.execution,
+				this.t.subscription,
+				this.t.instance,
+				this.t.message
+			]) await tx.query(`UPDATE ${table} SET user_id = $2 WHERE user_id = $1`, [subject, userId]);
+			await tx.query(`UPDATE ${this.t.device} SET user_id = $2, updated_at = ${TS("$3")}
+         WHERE visitor_id = $1 AND user_id IS NULL`, [
+				visitorId,
+				userId,
+				at
+			]);
+			return {
+				dropped: droppedIds,
+				events: events.map((row) => row.name),
+				props
+			};
 		});
 	}
+	/**
+	* The visitor's properties under the user's, a key the user has a time for going to the later
+	* write, one a row older than the times going to the user if they hold it. The visitor's row
+	* goes. Answers the keys that moved.
+	*/
+	async mergeProfileInto(tx, subject, userId) {
+		const rows = await tx.query(`SELECT user_id, props, props_at FROM ${this.t.profile} WHERE user_id = ANY($1::text[])`, [[subject, userId]]);
+		const from = rows.find((row) => row.user_id === subject);
+		if (from === void 0) return [];
+		const to = rows.find((row) => row.user_id === userId);
+		const fromTimes = asJson(from.props_at ?? null) ?? {};
+		const toTimes = asJson(to?.props_at ?? null) ?? {};
+		const toProps = to === void 0 ? {} : asJson(to.props);
+		const moved = Object.entries(asJson(from.props)).filter(([key]) => {
+			const written = toTimes[key];
+			return written === void 0 ? !Object.hasOwn(toProps, key) : (fromTimes[key] ?? 0) > written;
+		});
+		const props = {
+			...toProps,
+			...Object.fromEntries(moved)
+		};
+		const times = {
+			...toTimes,
+			...Object.fromEntries(moved.map(([key]) => [key, fromTimes[key] ?? 0]))
+		};
+		await tx.query(`INSERT INTO ${this.t.profile} (user_id, props, props_at) VALUES ($1, $2::text::jsonb, $3::text::jsonb)
+       ON CONFLICT (user_id) DO UPDATE SET props = EXCLUDED.props, props_at = EXCLUDED.props_at`, [
+			userId,
+			JSON.stringify(props),
+			JSON.stringify(times)
+		]);
+		await tx.query(`DELETE FROM ${this.t.profile} WHERE user_id = $1`, [subject]);
+		return moved.map(([key]) => key);
+	}
 	async requestErasure(userId, at) {
 		await this.sql.transaction(async (tx) => {
 			await this.lockUser(tx, userId);
@@ -252,27 +421,33 @@ var PostgresJourneyStore = class {
 	async forgetUser(userId, at) {
 		await this.sql.transaction(async (tx) => {
 			await this.lockUser(tx, userId);
-			for (const child of [
-				this.t.messageOpen,
-				this.t.messageClick,
-				this.t.messageLink
-			]) await tx.query(`DELETE FROM ${child} WHERE message_id IN (SELECT id FROM ${this.t.message} WHERE user_id = $1)`, [userId]);
-			for (const table of [
-				this.t.message,
-				this.t.instance,
-				this.t.entry,
-				this.t.execution,
-				this.t.subscription,
-				this.t.segmentStart,
-				this.t.segmentMember,
-				this.t.suppression,
-				this.t.device,
-				this.t.event,
-				this.t.profile
-			]) await tx.query(`DELETE FROM ${table} WHERE user_id = $1`, [userId]);
+			await this.deleteSubjectRows(tx, userId);
 			await tx.query(`UPDATE ${this.t.erasure} SET erased_at = COALESCE(erased_at, ${TS("$2")}) WHERE user_id = $1`, [userId, at]);
 		});
 	}
+	/** Everything kept about a user or visitor, on a transaction holding their lock. */
+	async deleteSubjectRows(tx, subject) {
+		for (const child of [
+			this.t.messageOpen,
+			this.t.messageClick,
+			this.t.messageLink
+		]) await tx.query(`DELETE FROM ${child} WHERE message_id IN (SELECT id FROM ${this.t.message} WHERE user_id = $1)`, [subject]);
+		for (const table of [
+			this.t.message,
+			this.t.instance,
+			this.t.entry,
+			this.t.execution,
+			this.t.subscription,
+			this.t.segmentStart,
+			this.t.segmentMember,
+			this.t.suppression,
+			this.t.device,
+			this.t.event,
+			this.t.profile
+		]) await tx.query(`DELETE FROM ${table} WHERE user_id = $1`, [subject]);
+		const visitorId = visitorIdOf(subject);
+		if (visitorId !== void 0) await tx.query(`DELETE FROM ${this.t.device} WHERE visitor_id = $1 AND user_id IS NULL`, [visitorId]);
+	}
 	async isSuppressed(userId, channel, topic) {
 		return (await this.sql.query(`SELECT 1 AS x FROM ${this.t.suppression}
        WHERE user_id = $1 AND channel = $2 AND (topic IS NULL OR topic = $3::text)`, [
@@ -305,12 +480,14 @@ var PostgresJourneyStore = class {
 		});
 	}
 	async removeDevice(token) {
-		return (await this.sql.query(`DELETE FROM ${this.t.device} WHERE token = $1 RETURNING user_id`, [token]))[0]?.user_id ?? void 0;
+		const rows = await this.sql.query(`DELETE FROM ${this.t.device} WHERE token = $1 RETURNING user_id, visitor_id`, [token]);
+		return rows[0] === void 0 ? void 0 : deviceOwner(rows[0]);
 	}
 	async unbindDevice(token) {
-		return (await this.sql.query(`WITH old AS (SELECT token, user_id FROM ${this.t.device} WHERE token = $1 FOR UPDATE)
-       UPDATE ${this.t.device} d SET user_id = NULL FROM old WHERE d.token = old.token
-       RETURNING old.user_id`, [token]))[0]?.user_id ?? void 0;
+		const rows = await this.sql.query(`WITH old AS (SELECT token, user_id, visitor_id FROM ${this.t.device} WHERE token = $1 FOR UPDATE)
+       UPDATE ${this.t.device} d SET user_id = NULL, visitor_id = NULL, updated_at = ${TS("$2")} FROM old WHERE d.token = old.token
+       RETURNING old.user_id, old.visitor_id`, [token, Date.now()]);
+		return rows[0] === void 0 ? void 0 : deviceOwner(rows[0]);
 	}
 	async listSegments() {
 		return (await this.sql.query(`SELECT id, condition FROM ${this.t.segment} ORDER BY id`)).map((row) => ({
@@ -323,11 +500,12 @@ var PostgresJourneyStore = class {
 		return row === void 0 ? void 0 : ConditionIR.parse(asJson(row.condition));
 	}
 	async findTriggers(event) {
-		return (await this.sql.query(`SELECT workflow, hash, "where" AS where_clause, filter, version FROM ${this.t.trigger} WHERE event = $1`, [event])).map((row) => ({
+		return (await this.sql.query(`SELECT workflow, hash, "where" AS where_clause, filter, visitors, version FROM ${this.t.trigger} WHERE event = $1`, [event])).map((row) => ({
 			workflow: row.workflow,
 			hash: row.hash,
 			where: row.where_clause === null ? null : ConditionIR.parse(asJson(row.where_clause)),
 			filter: row.filter === null ? null : ConditionIR.parse(asJson(row.filter)),
+			visitors: row.visitors === true,
 			version: row.version ?? void 0
 		}));
 	}
@@ -347,8 +525,18 @@ var PostgresJourneyStore = class {
 		const row = (await this.sql.query(`SELECT ir FROM ${this.t.ir} WHERE content_hash = $1`, [contentHash])).at(0);
 		return row === void 0 ? void 0 : WorkflowIR.parse(asJson(row.ir));
 	}
-	replaceRoutes(bundle) {
-		return this.sql.transaction((tx) => this.swapRoutes(tx, bundle));
+	replaceRoutes(bundle, version) {
+		return this.sql.transaction(async (tx) => {
+			if (version !== void 0) await tx.query(`INSERT INTO ${this.t.deployment} (scope, version_id, version_created_at, applied_at)
+           VALUES ('routes', $1, ${TS("$2")}, ${TS("$3")})
+           ON CONFLICT (scope) DO UPDATE SET version_id = EXCLUDED.version_id,
+             version_created_at = EXCLUDED.version_created_at, applied_at = EXCLUDED.applied_at`, [
+				version.id,
+				version.createdAt,
+				Date.now()
+			]);
+			await this.swapRoutes(tx, bundle, version?.id);
+		});
 	}
 	async liveBundleVersion() {
 		const row = (await this.sql.transaction((tx) => tx.query(`SELECT version_id, (extract(epoch FROM version_created_at) * 1000)::double precision AS created_at
@@ -384,12 +572,13 @@ var PostgresJourneyStore = class {
 			JSON.stringify(segment.condition),
 			segment.contentHash
 		]);
-		for (const workflow of bundle.workflows) if (workflow.trigger.type === "event") await tx.query(`INSERT INTO ${this.t.trigger} (workflow, hash, event, "where", filter, version) VALUES ($1, $2, $3, $4::text::jsonb, $5::text::jsonb, $6)`, [
+		for (const workflow of bundle.workflows) if (workflow.trigger.type === "event") await tx.query(`INSERT INTO ${this.t.trigger} (workflow, hash, event, "where", filter, visitors, version) VALUES ($1, $2, $3, $4::text::jsonb, $5::text::jsonb, $6, $7)`, [
 			workflow.id,
 			workflow.contentHash,
 			workflow.trigger.event,
 			workflow.trigger.where === void 0 ? null : JSON.stringify(workflow.trigger.where),
 			workflow.trigger.filter === void 0 ? null : JSON.stringify(workflow.trigger.filter),
+			workflow.trigger.visitors === true,
 			version ?? null
 		]);
 		else if (workflow.trigger.type === "segment") await tx.query(`INSERT INTO ${this.t.segmentTrigger} (workflow, hash, segment, version) VALUES ($1, $2, $3, $4)`, [
@@ -448,17 +637,19 @@ var PostgresJourneyStore = class {
 		});
 	}
 	async claimEntry(sql, entry) {
-		if ((await sql.query(`INSERT INTO ${this.t.entry} (workflow, user_id, instance_id, hash, status, ts)
-       SELECT $1, $2, $3, $4, 'running', ${TS("$5")} ${this.notErased("$2")}
+		const claimedAt = Date.now();
+		if ((await sql.query(`INSERT INTO ${this.t.entry} (workflow, user_id, instance_id, hash, status, ts, claimed_at)
+       SELECT $1, $2, $3, $4, 'running', ${TS("$5")}, ${TS("$6")} ${this.notErased("$2")}
        ON CONFLICT (workflow, user_id) DO NOTHING RETURNING instance_id`, [
 			entry.workflow,
 			entry.userId,
 			entry.instanceId,
 			entry.hash,
-			entry.ts
+			entry.ts,
+			claimedAt
 		])).length > 0) return "entered";
 		if ((await sql.query(`UPDATE ${this.t.entry} SET instance_id = $1, hash = $2, status = 'running', ts = ${TS("$3")},
-         admitted_at = NULL
+         admitted_at = NULL, claimed_at = ${TS("$6")}
        WHERE workflow = $4 AND user_id = $5 AND status = 'failed'
          AND NOT EXISTS (SELECT 1 FROM ${this.t.erasure} WHERE user_id = $5)
        RETURNING instance_id`, [
@@ -466,7 +657,8 @@ var PostgresJourneyStore = class {
 			entry.hash,
 			entry.ts,
 			entry.workflow,
-			entry.userId
+			entry.userId,
+			claimedAt
 		])).length > 0) return "reclaimed";
 		await this.refuseIfErased(sql, entry.userId);
 		return null;
@@ -497,6 +689,30 @@ var PostgresJourneyStore = class {
 	async removeEntry(instanceId) {
 		await this.sql.query(`DELETE FROM ${this.t.entry} WHERE instance_id = $1`, [instanceId]);
 	}
+	async getEntry(workflow, userId) {
+		const row = (await this.sql.transaction((tx) => tx.query(`SELECT instance_id, status, admitted_at IS NOT NULL AS admitted
+         FROM ${this.t.entry} WHERE workflow = $1 AND user_id = $2`, [workflow, userId]))).at(0);
+		return row === void 0 ? void 0 : {
+			instanceId: row.instance_id,
+			status: row.status,
+			admitted: row.admitted
+		};
+	}
+	async unadmittedEntries(claimedBefore, limit) {
+		return (await this.sql.query(`SELECT instance_id, workflow, user_id FROM ${this.t.entry}
+       WHERE admitted_at IS NULL AND status = 'running'
+         AND COALESCE(claimed_at, ts) < ${TS("$1")}
+       ORDER BY COALESCE(claimed_at, ts) LIMIT $2`, [claimedBefore, limit])).map((row) => ({
+			instanceId: row.instance_id,
+			workflow: row.workflow,
+			userId: row.user_id
+		}));
+	}
+	async failUnadmittedEntry(instanceId) {
+		return (await this.sql.query(`UPDATE ${this.t.entry} SET status = 'failed'
+       WHERE instance_id = $1 AND status = 'running' AND admitted_at IS NULL
+       RETURNING instance_id`, [instanceId])).length > 0;
+	}
 	async setEntryStatus(instanceId, status) {
 		await this.sql.query(`UPDATE ${this.t.entry} SET status = $1 WHERE instance_id = $2`, [status, instanceId]);
 	}