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

package/worker/migrations/0001_hot-updater_1.0.0.sql

@@ -151,6 +151,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,
@@ -183,19 +204,15 @@ 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);
+  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 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);
 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);

package/worker/src/databaseMigration.integration.spec.ts

@@ -10,7 +10,7 @@ declare module "vitest" {
   }
 }
 
-it("ships a single D1 1.0.0 CREATE migration", () => {
+it("ships a single 1.0.0 initialization migration", () => {
   expect(inject("d1Migrations").map(({ name }) => name)).toEqual([
     "0001_hot-updater_1.0.0.sql",
   ]);
@@ -47,6 +47,7 @@ it("creates the current schema with required artifact sizes", async () => {
   expect(tables.results.map(({ name }) => name)).toEqual(
     expect.arrayContaining([
       "bundle_events",
+      "bundle_installations",
       "bundle_patches",
       "bundles",
       "channels",
@@ -96,6 +97,66 @@ it("creates the current schema with required artifact sizes", async () => {
     byte_size: 3_000_000_002,
   });
 
+  await env.DB.prepare(`
+    INSERT INTO bundle_installations (
+      install_id, id, user_id, username, to_bundle_id, type, platform,
+      app_version, channel, cohort, received_at_ms
+    ) VALUES (
+      'install-1', 'event-1', 'user-1', 'Demo User',
+      '00000000-0000-0000-0000-000000000001', 'UPDATE_APPLIED', 'ios',
+      '1.0.0', 'production', 'cohort-1', 100
+    )
+  `).run();
+  await expect(
+    env.DB.prepare(
+      "SELECT install_id, received_at_ms FROM bundle_installations",
+    ).first(),
+  ).resolves.toEqual({ install_id: "install-1", received_at_ms: 100 });
+
+  const installationIndexes = await env.DB.prepare(`
+    SELECT name FROM sqlite_master
+    WHERE type = 'index' AND tbl_name = 'bundle_installations'
+    ORDER BY name
+  `).all<{ name: string }>();
+  expect(installationIndexes.results.map(({ name }) => name)).toEqual(
+    expect.arrayContaining([
+      "bundle_installations_received_at_idx",
+      "bundle_installations_user_id_idx",
+      "bundle_installations_scope_idx",
+      "bundle_installations_bundle_idx",
+    ]),
+  );
+
+  const movementIndex = await env.DB.prepare(
+    "PRAGMA index_info(bundle_events_install_idx)",
+  ).all<{ name: string }>();
+  expect(movementIndex.results.map(({ name }) => name)).toEqual([
+    "install_id",
+    "type",
+    "received_at_ms",
+    "id",
+  ]);
+
+  for (const [direction, type] of [
+    ["from", "RECOVERED"],
+    ["to", "UPDATE_APPLIED"],
+  ]) {
+    const plan = await env.DB.prepare(`
+      EXPLAIN QUERY PLAN SELECT * FROM bundle_events
+      WHERE type = ? AND platform = 'ios' AND channel = 'production'
+        AND ${direction}_bundle_id = ? AND received_at_ms >= 100 AND received_at_ms < 200
+      ORDER BY received_at_ms DESC, id DESC LIMIT 101
+    `)
+      .bind(type, "00000000-0000-0000-0000-000000000001")
+      .all<{ detail: string }>();
+    expect(plan.results.map(({ detail }) => detail).join("\n")).toContain(
+      `bundle_events_${direction}_bundle_idx`,
+    );
+    expect(plan.results.map(({ detail }) => detail).join("\n")).not.toContain(
+      "TEMP B-TREE",
+    );
+  }
+
   for (const size of [-1, Number.MAX_SAFE_INTEGER + 1, null]) {
     await expect(
       env.DB.prepare("UPDATE bundles SET archive_byte_size = ?")

package/worker/src/databasePlugins.integration.spec.ts

@@ -3,6 +3,7 @@ import type {
   ChannelRow,
   ReleaseRow,
 } from "@hot-updater/plugin-core";
+import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
 import { setupDatabasePluginTestSuite } from "@hot-updater/test-utils";
 import { env } from "cloudflare:test";
 import {
@@ -16,6 +17,7 @@ import {
   vi,
 } from "vitest";
 
+import { createBundleEventRowFixture } from "../../../../packages/test-utils/src/databaseTestFixtures";
 import { d1Database } from "../../src/d1Database";
 import { d1Database as d1RuntimeDatabase } from "../../src/worker";
 
@@ -92,7 +94,7 @@ vi.mock("cloudflare", () => ({
 const reset = async (): Promise<void> => {
   await getDb()
     .prepare(
-      "DELETE FROM bundle_events; DELETE FROM api_keys; DELETE FROM bundle_patches; DELETE FROM release_catalogs; DELETE FROM releases; DELETE FROM bundles; DELETE FROM channels;",
+      "DELETE FROM bundle_events; DELETE FROM bundle_installations; DELETE FROM api_keys; DELETE FROM bundle_patches; DELETE FROM release_catalogs; DELETE FROM releases; DELETE FROM bundles; DELETE FROM channels;",
     )
     .run();
 };
@@ -209,6 +211,38 @@ describe.each([
     ).resolves.toEqual({ deleted: false, reason: "not_found" });
   });
 
+  it("rolls back the snapshot when the later event insert fails, then safely retries", async () => {
+    const plugin = createPlugin();
+    const event = createBundleEventRowFixture("9101", 100);
+    const input = { event, installation: toInsightsInstallationRow(event) };
+    await env.DB.prepare(`
+      CREATE TRIGGER fail_insights_event BEFORE INSERT ON bundle_events
+      BEGIN SELECT RAISE(ABORT, 'injected event failure'); END;
+    `).run();
+    try {
+      await expect(plugin.models.insights.record(input)).rejects.toThrow(
+        "injected event failure",
+      );
+      expect(
+        (await env.DB.prepare("SELECT * FROM bundle_events").all()).results,
+      ).toEqual([]);
+      expect(
+        (await env.DB.prepare("SELECT * FROM bundle_installations").all())
+          .results,
+      ).toEqual([]);
+    } finally {
+      await env.DB.prepare("DROP TRIGGER fail_insights_event").run();
+    }
+    await plugin.models.insights.record(input);
+    await plugin.models.insights.record(input);
+    await expect(
+      plugin.models.insights.findInstallations({ installId: event.install_id }),
+    ).resolves.toEqual([input.installation]);
+    expect(
+      (await env.DB.prepare("SELECT id FROM bundle_events").all()).results,
+    ).toEqual([{ id: event.id }]);
+  });
+
   it("rejects direct and committed deletion while a Release references the channel", async () => {
     const plugin = createPlugin();
     const channel = createChannelRow("active");

package/worker/src/insightsMovement.integration.spec.ts

@@ -0,0 +1,73 @@
+import { env } from "cloudflare:test";
+import { expect, inject, it } from "vitest";
+
+import { d1Database } from "../../src/worker";
+
+it("pages sparse movements beyond 50,000 reports through ordered native index ranges", async () => {
+  await env.DB.prepare(inject("prepareSql")).run();
+  await env.DB.prepare(`
+    WITH RECURSIVE reports(n) AS (
+      SELECT 1 UNION ALL SELECT n + 1 FROM reports WHERE n < 60000
+    )
+    INSERT INTO bundle_events (
+      id, type, install_id, from_bundle_id, to_bundle_id, platform,
+      app_version, channel, cohort, update_strategy, received_at_ms
+    )
+    SELECT '00000000-0000-7000-8000-' || printf('%012d', n),
+      CASE n % 800 WHEN 0 THEN 'UPDATE_APPLIED' WHEN 1 THEN 'RECOVERED' ELSE 'UNCHANGED' END,
+      'sparse-movement-install',
+      CASE WHEN n % 800 IN (0, 1) THEN '00000000-0000-7000-8000-000000001001' ELSE NULL END,
+      '00000000-0000-7000-8000-000000001002', 'ios', '1.0.0', 'production', '0',
+      CASE WHEN n % 800 IN (0, 1) THEN 'appVersion' ELSE NULL END,
+      n / 2
+    FROM reports
+  `).run();
+
+  const queries: { sql: string; params: readonly unknown[] }[] = [];
+  const plugin = d1Database({
+    prepare(sql) {
+      return {
+        bind(...params) {
+          queries.push({ sql, params });
+          return env.DB.prepare(sql).bind(...params);
+        },
+      };
+    },
+    batch: () =>
+      Promise.reject(new Error("Unexpected write in movement query")),
+  });
+  const input = {
+    filter: {
+      kind: "installationMovement",
+      installId: "sparse-movement-install",
+    },
+    beforeReceivedAtMs: 30001,
+    limit: 101,
+  } as const;
+  const first = await plugin.models.insights.listEvents(input);
+  expect(first).toHaveLength(101);
+  const last = first[first.length - 1]!;
+  const second = await plugin.models.insights.listEvents({
+    ...input,
+    after: { receivedAtMs: last.received_at_ms, id: last.id },
+  });
+  expect(second).toHaveLength(49);
+  const expected = Array.from({ length: 60000 }, (_, index) => index + 1)
+    .filter((index) => index % 800 === 0 || index % 800 === 1)
+    .reverse()
+    .map(
+      (index) => `00000000-0000-7000-8000-${String(index).padStart(12, "0")}`,
+    );
+  expect([...first, ...second].map(({ id }) => id)).toEqual(expected);
+  expect(queries.length).toBeLessThanOrEqual(6);
+  for (const { sql, params } of queries) {
+    expect(sql).toContain("LIMIT");
+    expect(params[params.length - 1]).toBe("0");
+    const plan = await env.DB.prepare(`EXPLAIN QUERY PLAN ${sql}`)
+      .bind(...params)
+      .all<{ detail: string }>();
+    const details = plan.results.map(({ detail }) => detail).join("\n");
+    expect(details).toContain("bundle_events_install_idx");
+    expect(details).not.toContain("TEMP B-TREE");
+  }
+});