@hot-updater/cloudflare 1.0.0-rc.2 → 1.0.0-rc.3

package/dist/worker/index.d.mts

@@ -1,9 +1,8 @@
-import * as _$_hot_updater_plugin_core0 from "@hot-updater/plugin-core";
 import { StoragePluginWith } from "@hot-updater/plugin-core";
-
 //#region src/worker/d1Database.d.ts
 type D1Result = {
   readonly results?: readonly unknown[];
+  readonly success?: boolean;
 };
 type D1BoundStatement = {
   all: () => Promise<D1Result>;
@@ -15,7 +14,7 @@ type D1Like = {
   prepare(sql: string): D1PreparedStatement;
   batch(statements: D1BoundStatement[]): Promise<readonly D1Result[]>;
 };
-declare const d1Database: (database: D1Like) => _$_hot_updater_plugin_core0.DatabasePlugin;
+declare const d1Database: (database: D1Like) => import("@hot-updater/plugin-core").DatabasePlugin;
 //#endregion
 //#region src/r2WorkerStorage.d.ts
 interface CloudflareWorkerStorageConfig {

package/dist/worker/index.mjs

@@ -107,6 +107,29 @@ const eventRow = (row) => {
 		received_at_ms: numberValue(row, "received_at_ms", "bundle_events")
 	};
 };
+const installationRow = (row) => {
+	const type = stringValue(row, "type", "bundle_installations");
+	const platform = stringValue(row, "platform", "bundle_installations");
+	if (![
+		"UPDATE_APPLIED",
+		"RECOVERED",
+		"RELEASE_ADOPTED",
+		"UNCHANGED"
+	].includes(type) || platform !== "ios" && platform !== "android") throw new InvalidD1RowError("bundle_installations");
+	return {
+		id: stringValue(row, "id", "bundle_installations"),
+		install_id: stringValue(row, "install_id", "bundle_installations"),
+		user_id: nullableString(row, "user_id", "bundle_installations"),
+		username: nullableString(row, "username", "bundle_installations"),
+		to_bundle_id: stringValue(row, "to_bundle_id", "bundle_installations"),
+		type,
+		platform,
+		app_version: stringValue(row, "app_version", "bundle_installations"),
+		channel: stringValue(row, "channel", "bundle_installations"),
+		cohort: stringValue(row, "cohort", "bundle_installations"),
+		received_at_ms: numberValue(row, "received_at_ms", "bundle_installations")
+	};
+};
 const apiKeyRow = (row) => {
 	const role = stringValue(row, "role", "api_keys");
 	if (role !== "client") throw new InvalidD1RowError("api_keys");
@@ -181,6 +204,7 @@ function parseD1Row(model, value) {
 		case "bundle_patches": return patchRow(value);
 		case "channels": return channelRow(value);
 		case "bundle_events": return eventRow(value);
+		case "bundle_installations": return installationRow(value);
 		case "api_keys": return apiKeyRow(value);
 		case "releases": return releaseRow(value);
 		case "release_catalogs": return releaseCatalogRow(value);
@@ -217,7 +241,8 @@ const stringPredicate = (condition, operator) => {
 		};
 	}
 	const literal = escapeLikePattern(condition.value);
-	const parameter = bind(operator === "contains" ? `%${literal}%` : operator === "starts_with" ? `${literal}%` : `%${literal}`);
+	const pattern = operator === "contains" ? `%${literal}%` : operator === "starts_with" ? `${literal}%` : `%${literal}`;
+	const parameter = bind(pattern);
 	return {
 		sql: `lower(${condition.field}) LIKE lower(${parameter.sql}) ESCAPE '\\'`,
 		params: parameter.params
@@ -302,11 +327,13 @@ const d1TableNames = {
 	bundle_patches: "bundle_patches",
 	channels: "channels",
 	bundle_events: "bundle_events",
+	bundle_installations: "bundle_installations",
 	api_keys: "api_keys",
 	release_catalogs: "release_catalogs",
 	releases: "releases"
 };
 var D1QueryResultError = class extends Error {
+	result;
 	name = "D1QueryResultError";
 	operation = "count";
 	constructor(result) {
@@ -337,6 +364,7 @@ const findManyD1Rows = async (executor, input) => {
 		case "bundle_patches": return rows.map((row) => parseD1Row("bundle_patches", row));
 		case "channels": return rows.map((row) => parseD1Row("channels", row));
 		case "bundle_events": return rows.map((row) => parseD1Row("bundle_events", row));
+		case "bundle_installations": return rows.map((row) => parseD1Row("bundle_installations", row));
 		case "api_keys": return rows.map((row) => parseD1Row("api_keys", row));
 		case "releases": return rows.map((row) => parseD1Row("releases", row));
 		case "release_catalogs": return rows.map((row) => parseD1Row("release_catalogs", row));
@@ -344,6 +372,12 @@ const findManyD1Rows = async (executor, input) => {
 };
 //#endregion
 //#region src/d1Implementation.ts
+var D1ExecutionError = class extends Error {
+	name = "D1ExecutionError";
+	constructor() {
+		super("D1 did not successfully execute every requested statement");
+	}
+};
 const EXPECTATION_CONFLICT_MARKER = "HOT_UPDATER_COMMIT_EXPECTATION_CONFLICT";
 const expectationGuard = (expectations) => {
 	const clauses = [];
@@ -381,7 +415,8 @@ const expectationConflict = async (executor, expectations) => {
 		const versionField = isRelease ? "revision" : "generation";
 		const key = isRelease ? expectation.id : expectation.scopeKey;
 		const expectedVersion = isRelease ? expectation.revision : expectation.generation;
-		const actualVersion = readVersion((await executor.query(`SELECT ${versionField} FROM ${table} WHERE ${keyField} = json_extract(?, '$') LIMIT 1`, encodeD1Values([key])))[0], versionField);
+		const rows = await executor.query(`SELECT ${versionField} FROM ${table} WHERE ${keyField} = json_extract(?, '$') LIMIT 1`, encodeD1Values([key]));
+		const actualVersion = readVersion(rows[0], versionField);
 		if (actualVersion !== expectedVersion) return {
 			committed: false,
 			conflict: {
@@ -460,14 +495,14 @@ const insertQuery = (input, guard, conflictMode = "returnExisting") => {
 			values = channelValues(input.data);
 			break;
 		case "bundle_events":
+		case "bundle_installations":
 		case "api_keys":
 		case "release_catalogs":
 		case "releases":
 			columns = Object.keys(input.data);
 			values = Object.values(input.data);
-			break;
 	}
-	const conflict = input.onConflict !== "ignore" ? "" : input.model === "channels" ? conflictMode === "ignore" ? " ON CONFLICT(name) DO NOTHING" : " ON CONFLICT(name) DO UPDATE SET name = excluded.name" : input.model === "api_keys" ? conflictMode === "ignore" ? " ON CONFLICT(hash) DO NOTHING" : " ON CONFLICT(hash) DO UPDATE SET hash = excluded.hash" : "";
+	const conflict = input.onConflict !== "ignore" ? "" : input.model === "channels" ? conflictMode === "ignore" ? " ON CONFLICT(name) DO NOTHING" : " ON CONFLICT(name) DO UPDATE SET name = excluded.name" : input.model === "api_keys" ? conflictMode === "ignore" ? " ON CONFLICT(hash) DO NOTHING" : " ON CONFLICT(hash) DO UPDATE SET hash = excluded.hash" : " ON CONFLICT(install_id) DO UPDATE SET install_id = excluded.install_id";
 	return {
 		sql: `INSERT INTO ${d1TableNames[input.model]} (${columns.join(", ")}) ${guard === void 0 ? `VALUES (${d1Placeholders(values.length)})` : `SELECT ${d1Placeholders(values.length)} WHERE ${guard.sql}`}${conflict} RETURNING *`,
 		params: [...encodeD1Values(values), ...guard?.params ?? []]
@@ -531,9 +566,7 @@ const channelDeletePrecondition = (changes, changeIndex, channelId) => {
 				releaseEffects.set(change.row.id, change.row.channel_id);
 				break;
 			case "update": break;
-			case "delete":
-				releaseEffects.set(change.where.id, null);
-				break;
+			case "delete": releaseEffects.set(change.where.id, null);
 		}
 	}
 	return {
@@ -608,10 +641,6 @@ const changeQuery = (change, guard) => {
 			sql: `DELETE FROM channels WHERE id = json_extract(?, '$') AND NOT EXISTS (SELECT 1 FROM releases WHERE channel_id = json_extract(?, '$')) AND ${guard.sql}`,
 			params: [...encodeD1Values([change.where.id, change.where.id]), ...guard.params]
 		};
-		case "insights": return insertQuery({
-			model: "bundle_events",
-			data: change.row
-		}, guard);
 		case "apiKeys": return change.operation === "insert" ? insertQuery({
 			model: "api_keys",
 			data: change.row,
@@ -780,6 +809,25 @@ const deleteChannel = async (executor, input) => {
 	};
 };
 const createD1Implementation = (executor) => ({
+	async recordInsights({ event, installation }) {
+		const columns = Object.keys(installation);
+		const eventInsert = insertQuery({
+			model: "bundle_events",
+			data: event
+		});
+		await executor.batch([{
+			sql: `INSERT INTO bundle_installations (${columns.join(", ")})
+          SELECT ${d1Placeholders(columns.length)}
+          WHERE NOT EXISTS (SELECT 1 FROM bundle_events WHERE id = json_extract(?, '$'))
+          ON CONFLICT(install_id) DO UPDATE SET ${columns.filter((column) => column !== "install_id").map((column) => `${column} = excluded.${column}`).join(", ")}
+          WHERE (excluded.received_at_ms, excluded.id) >
+            (bundle_installations.received_at_ms, bundle_installations.id)`,
+			params: encodeD1Values([...Object.values(installation), event.id])
+		}, {
+			...eventInsert,
+			sql: eventInsert.sql.replace(" RETURNING *", " ON CONFLICT(id) DO NOTHING")
+		}]);
+	},
 	async create(input) {
 		const query = insertQuery(input);
 		const rows = await executor.query(query.sql, query.params);
@@ -788,6 +836,7 @@ const createD1Implementation = (executor) => ({
 			case "bundle_patches": return parseD1Row("bundle_patches", rows[0]);
 			case "channels": return parseD1Row("channels", rows[0]);
 			case "bundle_events": return parseD1Row("bundle_events", rows[0]);
+			case "bundle_installations": return parseD1Row("bundle_installations", rows[0]);
 			case "api_keys": return parseD1Row("api_keys", rows[0]);
 			case "releases": return parseD1Row("releases", rows[0]);
 			case "release_catalogs": return parseD1Row("release_catalogs", rows[0]);
@@ -802,6 +851,7 @@ const createD1Implementation = (executor) => ({
 			case "api_keys": return parseD1Row("api_keys", rows[0]);
 			case "releases": return parseD1Row("releases", rows[0]);
 			case "release_catalogs": return parseD1Row("release_catalogs", rows[0]);
+			case "bundle_installations": return parseD1Row("bundle_installations", rows[0]);
 		}
 	},
 	async delete(input) {
@@ -820,6 +870,7 @@ const createD1Implementation = (executor) => ({
 			case "api_keys": return parseD1Row("api_keys", rows[0]);
 			case "releases": return parseD1Row("releases", rows[0]);
 			case "release_catalogs": return parseD1Row("release_catalogs", rows[0]);
+			case "bundle_installations": return parseD1Row("bundle_installations", rows[0]);
 		}
 	},
 	findMany: (input) => findManyD1Rows(executor, input),
@@ -852,14 +903,19 @@ const createD1Implementation = (executor) => ({
 //#endregion
 //#region src/worker/d1Database.ts
 const d1Database = (database) => {
-	const adapter = createDatabasePluginAdapter("d1Database", createD1Implementation({
+	const implementation = createD1Implementation({
 		async query(sql, params) {
-			return (await database.prepare(sql).bind(...params).all()).results ?? [];
+			const result = await database.prepare(sql).bind(...params).all();
+			if (result.success === false) throw new D1ExecutionError();
+			return result.results ?? [];
 		},
 		async batch(statements) {
-			return (await database.batch(statements.map(({ sql, params }) => database.prepare(sql).bind(...params)))).map(({ results }) => results ?? []);
+			const results = await database.batch(statements.map(({ sql, params }) => database.prepare(sql).bind(...params)));
+			if (results.length !== statements.length || results.some(({ success }) => success === false)) throw new D1ExecutionError();
+			return results.map(({ results }) => results ?? []);
 		}
-	}));
+	});
+	const adapter = createDatabasePluginAdapter("d1Database", implementation);
 	return createDatabasePlugin({
 		name: "d1Database",
 		models: adapter.models,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hot-updater/cloudflare",
   "type": "module",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.0-rc.3",
   "description": "React Native OTA solution for self-hosted",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -60,10 +60,10 @@
     "cloudflare": "4.2.0",
     "hono": "4.12.34",
     "uuidv7": "^1.0.2",
-    "@hot-updater/cli-tools": "1.0.0-rc.1",
-    "@hot-updater/plugin-core": "1.0.0-rc.1",
     "@hot-updater/core": "1.0.0-rc.0",
-    "@hot-updater/server": "1.0.0-rc.1"
+    "@hot-updater/plugin-core": "1.0.0-rc.2",
+    "@hot-updater/server": "1.0.0-rc.2",
+    "@hot-updater/cli-tools": "1.0.0-rc.2"
   },
   "devDependencies": {
     "@cloudflare/vitest-pool-workers": "0.13.0",
@@ -75,11 +75,11 @@
     "toml": "^3.0.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "verkit": "0.3.2",
+    "verkit": "0.4.0",
     "vitest": "4.1.4",
     "wrangler": "^4.69.0",
     "xdg-app-paths": "^8.3.0",
-    "@hot-updater/test-utils": "1.0.0-rc.1"
+    "@hot-updater/test-utils": "1.0.0-rc.2"
   },
   "scripts": {
     "build": "tsdown && pnpm build:worker",

package/sql/bundles.sql

@@ -149,6 +149,27 @@ CREATE TABLE bundle_events (
   CONSTRAINT bundle_events_received_at_check CHECK (received_at_ms >= 0)
 );
 
+CREATE TABLE bundle_installations (
+  install_id TEXT PRIMARY KEY NOT NULL,
+  id TEXT NOT NULL,
+  user_id TEXT,
+  username TEXT,
+  to_bundle_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  platform TEXT NOT NULL,
+  app_version TEXT NOT NULL,
+  channel TEXT NOT NULL,
+  cohort TEXT NOT NULL,
+  received_at_ms REAL NOT NULL,
+  CONSTRAINT bundle_installations_type_check CHECK (
+    type IN ('UPDATE_APPLIED', 'RECOVERED', 'RELEASE_ADOPTED', 'UNCHANGED')
+  ),
+  CONSTRAINT bundle_installations_platform_check CHECK (
+    platform IN ('ios', 'android')
+  ),
+  CONSTRAINT bundle_installations_received_at_check CHECK (received_at_ms >= 0)
+);
+
 CREATE TABLE api_keys (
   id TEXT PRIMARY KEY NOT NULL,
   hash TEXT NOT NULL,
@@ -179,12 +200,13 @@ CREATE INDEX releases_fingerprint_hash_idx ON releases(fingerprint_hash);
 CREATE INDEX releases_enabled_idx ON releases(enabled);
 CREATE INDEX release_catalogs_channel_idx ON release_catalogs(channel_id);
 CREATE INDEX bundle_events_received_at_idx ON bundle_events(received_at_ms, id);
-CREATE INDEX bundle_events_install_idx ON bundle_events(install_id, received_at_ms, id);
-CREATE INDEX bundle_events_user_id_idx ON bundle_events(user_id, received_at_ms, id);
-CREATE INDEX bundle_events_username_idx ON bundle_events(username, received_at_ms, id);
-CREATE INDEX bundle_events_to_bundle_idx ON bundle_events(type, to_bundle_id, received_at_ms, id);
-CREATE INDEX bundle_events_from_bundle_idx ON bundle_events(type, from_bundle_id, received_at_ms, id);
-CREATE INDEX bundle_events_to_release_idx ON bundle_events(type, to_release_id, received_at_ms, id);
-CREATE INDEX bundle_events_from_release_idx ON bundle_events(type, from_release_id, received_at_ms, id);
+CREATE INDEX bundle_events_install_idx ON bundle_events(install_id, type, received_at_ms, id);
+CREATE INDEX bundle_installations_user_id_idx ON bundle_installations(user_id, install_id);
+CREATE INDEX bundle_installations_received_at_idx ON bundle_installations(received_at_ms);
 CREATE UNIQUE INDEX api_keys_hash_key ON api_keys(hash);
 CREATE INDEX api_keys_created_at_idx ON api_keys(created_at_ms, id);
+
+CREATE INDEX bundle_events_from_bundle_idx ON bundle_events(type, platform, channel, from_bundle_id, received_at_ms, id);
+CREATE INDEX bundle_events_to_bundle_idx ON bundle_events(type, platform, channel, to_bundle_id, received_at_ms, id);
+CREATE INDEX bundle_installations_scope_idx ON bundle_installations(platform, channel, received_at_ms);
+CREATE INDEX bundle_installations_bundle_idx ON bundle_installations(platform, channel, to_bundle_id, received_at_ms);

package/src/d1Database.spec.ts

@@ -1,3 +1,4 @@
+import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
 import { beforeEach, expect, it, vi } from "vitest";
 
 import { d1Database } from "./d1Database";
@@ -26,6 +27,26 @@ const bundleD1Row = {
   asset_base_storage_uri: null,
 } as const;
 
+const eventD1Row = {
+  id: "00000000-0000-7000-8000-000000000001",
+  type: "UPDATE_APPLIED",
+  install_id: "install-1",
+  user_id: "user-1",
+  username: "Demo User",
+  from_release_id: null,
+  from_bundle_id: "bundle-previous",
+  to_release_id: null,
+  to_bundle_id: "bundle-current",
+  platform: "ios",
+  app_version: "1.0.0",
+  channel: "production",
+  cohort: "cohort-1",
+  update_strategy: "appVersion",
+  fingerprint_hash: null,
+  sdk_version: "1.0.0",
+  received_at_ms: 100,
+} as const;
+
 vi.mock("cloudflare", () => ({
   default: class MockCloudflare {
     readonly d1 = {
@@ -176,3 +197,81 @@ it("sends parameterized commits through the D1 batch body", async () => {
   expect(state.batches[0]?.[0]?.params.length).toBeGreaterThan(0);
   expect(state.batches[0]?.[1]?.params.length).toBeGreaterThan(0);
 });
+
+it("stores the event and current installation in one parameterized atomic batch", async () => {
+  const plugin = d1Database({
+    accountId: "account",
+    cloudflareApiToken: "token",
+    databaseId: "database",
+  });
+  await expect(
+    plugin.models.insights.record({
+      event: eventD1Row,
+      installation: toInsightsInstallationRow(eventD1Row),
+    }),
+  ).resolves.toBeUndefined();
+  expect(state.queries).toHaveLength(0);
+  expect(state.batches).toHaveLength(1);
+  expect(state.batches[0]).toHaveLength(2);
+  expect(state.batches[0]?.[0]?.sql).toContain(
+    "WHERE NOT EXISTS (SELECT 1 FROM bundle_events",
+  );
+  expect(state.batches[0]?.[1]?.sql).toContain("ON CONFLICT(id) DO NOTHING");
+});
+
+it("queries each movement type through a bounded descending range", async () => {
+  const plugin = d1Database({
+    accountId: "account",
+    cloudflareApiToken: "token",
+    databaseId: "database",
+  });
+
+  await expect(
+    plugin.models.insights.listEvents({
+      filter: {
+        kind: "installationMovement",
+        installId: eventD1Row.install_id,
+      },
+      beforeReceivedAtMs: 200,
+      limit: 101,
+    }),
+  ).resolves.toEqual([]);
+
+  expect(state.queries).toHaveLength(2);
+  for (const query of state.queries) {
+    expect(query.sql).toContain("SELECT * FROM bundle_events");
+    expect(query.sql).toContain("type = json_extract(?, '$')");
+    expect(query.sql).toContain("ORDER BY received_at_ms DESC, id DESC");
+    expect(query.params).toContain("101");
+  }
+  expect(state.queries.flatMap(({ params }) => params)).toEqual(
+    expect.arrayContaining([
+      JSON.stringify("UPDATE_APPLIED"),
+      JSON.stringify("RECOVERED"),
+    ]),
+  );
+});
+
+it("counts active installations without reading event history", async () => {
+  state.results.push({ count: 2 });
+  const plugin = d1Database({
+    accountId: "account",
+    cloudflareApiToken: "token",
+    databaseId: "database",
+  });
+
+  await expect(
+    plugin.models.insights.countInstallations({
+      platform: "ios",
+      channel: "production",
+      sinceMs: 100,
+    }),
+  ).resolves.toBe(2);
+
+  expect(state.queries).toHaveLength(1);
+  expect(state.queries[0]?.sql).toContain(
+    "SELECT COUNT(*) AS count FROM bundle_installations",
+  );
+  expect(state.queries[0]?.sql).toContain("received_at_ms >=");
+  expect(state.queries[0]?.sql).not.toContain("bundle_events");
+});

package/src/d1Database.ts

@@ -2,7 +2,11 @@ import { createDatabasePlugin } from "@hot-updater/plugin-core";
 import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
 import Cloudflare from "cloudflare";
 
-import { createD1Implementation, type D1Statement } from "./d1Implementation";
+import {
+  createD1Implementation,
+  D1ExecutionError,
+  type D1Statement,
+} from "./d1Implementation";
 
 export interface D1DatabaseConfig {
   readonly databaseId: string;
@@ -41,9 +45,11 @@ export const d1Database = (config: D1DatabaseConfig) => {
     const results: unknown[][] = [];
     for await (const resultPage of page.iterPages()) {
       for (const result of resultPage.result) {
+        if (result.success === false) throw new D1ExecutionError();
         results.push(result.results ?? []);
       }
     }
+    if (results.length !== statements.length) throw new D1ExecutionError();
     return results;
   };
 

package/src/d1Implementation.spec.ts

@@ -2,6 +2,20 @@ import { expect, it } from "vitest";
 
 import { createD1Implementation, type D1Statement } from "./d1Implementation";
 
+const installationRow = {
+  id: "event-1",
+  install_id: "install-1",
+  user_id: "user-1",
+  username: "Demo User",
+  to_bundle_id: "bundle-1",
+  type: "UPDATE_APPLIED" as const,
+  platform: "ios" as const,
+  app_version: "1.0.0",
+  channel: "production",
+  cohort: "cohort-1",
+  received_at_ms: 100,
+};
+
 it("guards every write and reports the missing change index", async () => {
   let recorded: readonly D1Statement[] = [];
   const implementation = createD1Implementation({
@@ -250,3 +264,79 @@ it("guards a generic Channel delete and reports a referenced conflict", async ()
   expect(recorded[1]?.sql).toContain("DELETE FROM channels");
   expect(recorded[1]?.sql).toContain("NOT EXISTS");
 });
+
+it("returns the canonical current installation on an idempotent create", async () => {
+  const queries: D1Statement[] = [];
+  const implementation = createD1Implementation({
+    async query(sql, params) {
+      queries.push({ sql, params });
+      return [installationRow];
+    },
+    batch: () => Promise.reject(new Error("unexpected batch")),
+  });
+
+  await expect(
+    implementation.create({
+      model: "bundle_installations",
+      data: installationRow,
+      onConflict: "ignore",
+    }),
+  ).resolves.toEqual(installationRow);
+
+  expect(queries[0]?.sql).toContain("INSERT INTO bundle_installations");
+  expect(queries[0]?.sql).toContain(
+    "ON CONFLICT(install_id) DO UPDATE SET install_id = excluded.install_id",
+  );
+  expect(queries[0]?.sql).toContain("RETURNING *");
+});
+
+it("updates a current installation only through the supplied latest-row condition", async () => {
+  const queries: D1Statement[] = [];
+  const implementation = createD1Implementation({
+    async query(sql, params) {
+      queries.push({ sql, params });
+      return [installationRow];
+    },
+    batch: () => Promise.reject(new Error("unexpected batch")),
+  });
+  const { install_id: _installId, ...update } = installationRow;
+
+  await expect(
+    implementation.update({
+      model: "bundle_installations",
+      where: [
+        { field: "install_id", value: installationRow.install_id },
+        {
+          field: "received_at_ms",
+          operator: "lt",
+          value: installationRow.received_at_ms,
+        },
+      ],
+      update,
+    }),
+  ).resolves.toEqual(installationRow);
+
+  await expect(
+    implementation.update({
+      model: "bundle_installations",
+      where: [
+        { field: "install_id", value: installationRow.install_id },
+        {
+          field: "received_at_ms",
+          value: installationRow.received_at_ms,
+        },
+        { field: "id", operator: "lt", value: installationRow.id },
+      ],
+      update,
+    }),
+  ).resolves.toEqual(installationRow);
+
+  expect(queries[0]?.sql).toContain("UPDATE bundle_installations SET");
+  expect(queries[0]?.sql).toContain(
+    "WHERE (install_id = json_extract(?, '$') AND received_at_ms < json_extract(?, '$'))",
+  );
+  expect(queries[0]?.sql).toContain("RETURNING *");
+  expect(queries[1]?.sql).toContain(
+    "WHERE ((install_id = json_extract(?, '$') AND received_at_ms = json_extract(?, '$')) AND id < json_extract(?, '$'))",
+  );
+});

package/src/d1Implementation.ts

@@ -35,6 +35,13 @@ export interface D1Statement {
   readonly params: readonly string[];
 }
 
+export class D1ExecutionError extends Error {
+  readonly name = "D1ExecutionError";
+  constructor() {
+    super("D1 did not successfully execute every requested statement");
+  }
+}
+
 type D1Guard = {
   readonly sql: string;
   readonly params: readonly string[];
@@ -191,6 +198,7 @@ const insertQuery = (
       values = channelValues(input.data);
       break;
     case "bundle_events":
+    case "bundle_installations":
     case "api_keys":
     case "release_catalogs":
     case "releases":
@@ -210,7 +218,7 @@ const insertQuery = (
           ? conflictMode === "ignore"
             ? " ON CONFLICT(hash) DO NOTHING"
             : " ON CONFLICT(hash) DO UPDATE SET hash = excluded.hash"
-          : "";
+          : " ON CONFLICT(install_id) DO UPDATE SET install_id = excluded.install_id";
 
   return {
     sql: `INSERT INTO ${d1TableNames[input.model]} (${columns.join(", ")}) ${
@@ -439,8 +447,6 @@ const changeQuery = (change: DatabaseChange, guard: D1Guard): D1Statement => {
               ...guard.params,
             ],
           };
-    case "insights":
-      return insertQuery({ model: "bundle_events", data: change.row }, guard);
     case "apiKeys":
       return change.operation === "insert"
         ? insertQuery(
@@ -638,6 +644,33 @@ const deleteChannel = async (
 export const createD1Implementation = (
   executor: D1Executor,
 ): DatabasePluginImplementation => ({
+  async recordInsights({ event, installation }) {
+    const columns = Object.keys(installation);
+    const eventInsert = insertQuery({ model: "bundle_events", data: event });
+    // D1 executes the whole batch as one serial transaction. The snapshot
+    // guard runs before the event insert so a duplicate cannot mutate it.
+    await executor.batch([
+      {
+        sql: `INSERT INTO bundle_installations (${columns.join(", ")})
+          SELECT ${d1Placeholders(columns.length)}
+          WHERE NOT EXISTS (SELECT 1 FROM bundle_events WHERE id = json_extract(?, '$'))
+          ON CONFLICT(install_id) DO UPDATE SET ${columns
+            .filter((column) => column !== "install_id")
+            .map((column) => `${column} = excluded.${column}`)
+            .join(", ")}
+          WHERE (excluded.received_at_ms, excluded.id) >
+            (bundle_installations.received_at_ms, bundle_installations.id)`,
+        params: encodeD1Values([...Object.values(installation), event.id]),
+      },
+      {
+        ...eventInsert,
+        sql: eventInsert.sql.replace(
+          " RETURNING *",
+          " ON CONFLICT(id) DO NOTHING",
+        ),
+      },
+    ]);
+  },
   async create(input) {
     const query = insertQuery(input);
     const rows = await executor.query(query.sql, query.params);
@@ -650,6 +683,8 @@ export const createD1Implementation = (
         return parseD1Row("channels", rows[0]);
       case "bundle_events":
         return parseD1Row("bundle_events", rows[0]);
+      case "bundle_installations":
+        return parseD1Row("bundle_installations", rows[0]);
       case "api_keys":
         return parseD1Row("api_keys", rows[0]);
       case "releases":
@@ -671,6 +706,8 @@ export const createD1Implementation = (
         return parseD1Row("releases", rows[0]);
       case "release_catalogs":
         return parseD1Row("release_catalogs", rows[0]);
+      case "bundle_installations":
+        return parseD1Row("bundle_installations", rows[0]);
     }
   },
   async delete(input) {
@@ -698,6 +735,8 @@ export const createD1Implementation = (
         return parseD1Row("releases", rows[0]);
       case "release_catalogs":
         return parseD1Row("release_catalogs", rows[0]);
+      case "bundle_installations":
+        return parseD1Row("bundle_installations", rows[0]);
     }
   },
   findMany: (input) => findManyD1Rows(executor, input),

package/src/d1Query.ts

@@ -14,6 +14,7 @@ export const d1TableNames = {
   bundle_patches: "bundle_patches",
   channels: "channels",
   bundle_events: "bundle_events",
+  bundle_installations: "bundle_installations",
   api_keys: "api_keys",
   release_catalogs: "release_catalogs",
   releases: "releases",
@@ -79,6 +80,8 @@ export const findManyD1Rows = async (
       return rows.map((row) => parseD1Row("channels", row));
     case "bundle_events":
       return rows.map((row) => parseD1Row("bundle_events", row));
+    case "bundle_installations":
+      return rows.map((row) => parseD1Row("bundle_installations", row));
     case "api_keys":
       return rows.map((row) => parseD1Row("api_keys", row));
     case "releases":