@shware/workflow 7.0.0 → 9.0.0

package/dist/store/postgres.cjs

@@ -1,11 +1,18 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_ir = require("../ir.cjs");
 const require_store_erasure = require("./erasure.cjs");
+const require_store_identity = require("./identity.cjs");
+const require_store_condition_sql = require("./condition-sql.cjs");
 const require_store_sql = require("./sql.cjs");
 const require_store_user_lock = require("./user-lock.cjs");
 const require_store_postgres_reporting = require("./postgres-reporting.cjs");
 const require_store_tables = require("./tables.cjs");
 // 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 : require_store_identity.visitorSubject(row.visitor_id);
+}
 /** information_schema's udt_name per column type. */
 const UDT = {
 	uuid: "uuid",
@@ -185,51 +192,228 @@ var PostgresJourneyStore = class {
 		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 require_store_erasure.UserErasedError(userId);
 			return asJson(rows[0].props);
 		});
 	}
-	async listUserIds(page) {
+	async listSegmentCandidates(page) {
+		if (page.segments.length === 0) return [];
 		const params = [];
-		let where = "";
-		if (page?.after !== void 0) {
-			params.push(page.after);
-			where = ` WHERE user_id > $${params.length}`;
-		}
-		let limit = "";
-		if (page?.limit !== void 0) {
-			params.push(page.limit);
-			limit = ` LIMIT $${params.length}`;
-		}
-		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);
+		const bind = (value) => {
+			params.push(value);
+			return `$${params.length}`;
+		};
+		const definitions = new Map(page.segments.map((segment) => [segment.id, segment.condition]));
+		const branches = page.segments.map(({ id, condition }) => {
+			const segment = bind(id);
+			const matches = require_store_condition_sql.conditionToSql(condition, {
+				tables: this.t,
+				user: "u.user_id",
+				props: "p.props",
+				nowMs: page.now,
+				segments: definitions,
+				bind
+			});
+			const key = `segment = ${segment}::text AND user_id = u.user_id`;
+			return `SELECT ${segment}::text AS segment
+        WHERE (${matches}) IS DISTINCT FROM EXISTS (SELECT 1 FROM ${this.t.segmentMember} WHERE ${key})
+           OR EXISTS (SELECT 1 FROM ${this.t.segmentStart} WHERE ${key})`;
+		});
+		let keyset = "";
+		if (page.after !== void 0) keyset = ` AND user_id > ${bind(page.after)}::text`;
+		return (await this.sql.query(`WITH u AS MATERIALIZED (
+         SELECT user_id FROM (
+           SELECT user_id FROM ${this.t.profile}
+           UNION SELECT user_id FROM ${this.t.event}
+           UNION SELECT user_id FROM ${this.t.segmentMember}
+         ) known
+         -- Segments are about users: a visitor is not one until they sign in
+         WHERE user_id NOT LIKE '${require_store_identity.visitorSubject("")}%'${keyset}
+       )
+       SELECT u.user_id, json_agg(c.segment) AS segments
+       FROM u
+       LEFT JOIN ${this.t.profile} p ON p.user_id = u.user_id
+       CROSS JOIN LATERAL (${branches.join("\n UNION ALL ")}) c
+       GROUP BY u.user_id
+       ORDER BY u.user_id
+       LIMIT ${bind(page.limit)}::int`, params)).map((row) => ({
+			userId: row.user_id,
+			segments: asJson(row.segments)
+		}));
 	}
-	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 = require_store_identity.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 ?? require_store_identity.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 require_store_erasure.UserErasedError(device.userId);
+				deviceId,
+				userId,
+				visitorId,
+				token,
+				platform,
+				at,
+				subject
+			])).length === 0) throw new require_store_erasure.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 ?? require_store_identity.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 = '${require_store_identity.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 = require_store_identity.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 = require_store_identity.visitorSubject(visitorId);
+		if (await this.linkedUser(visitorId) !== void 0) return null;
+		return this.sql.transaction(async (tx) => {
+			await require_store_user_lock.beginReadCommitted(tx);
+			for (const key of [subject, userId].sort()) await require_store_user_lock.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 require_store_erasure.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) => {
@@ -270,27 +454,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 = require_store_identity.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)`, [
@@ -323,12 +513,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) => ({
@@ -341,11 +533,12 @@ var PostgresJourneyStore = class {
 		return row === void 0 ? void 0 : require_ir.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 : require_ir.ConditionIR.parse(asJson(row.where_clause)),
 			filter: row.filter === null ? null : require_ir.ConditionIR.parse(asJson(row.filter)),
+			visitors: row.visitors === true,
 			version: row.version ?? void 0
 		}));
 	}
@@ -412,12 +605,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)`, [