@hot-updater/cloudflare 0.36.7 → 1.0.0-rc.1

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

@@ -0,0 +1,205 @@
+-- HotUpdater schema 1.0.0
+
+CREATE TABLE channels (
+  id TEXT PRIMARY KEY NOT NULL,
+  name TEXT NOT NULL,
+  CONSTRAINT channels_id_length_check CHECK (length(id) BETWEEN 1 AND 255),
+  CONSTRAINT channels_name_length_check CHECK (length(name) BETWEEN 1 AND 255)
+);
+
+CREATE TABLE bundles (
+  id TEXT PRIMARY KEY NOT NULL,
+  platform TEXT NOT NULL,
+  file_hash TEXT NOT NULL,
+  git_commit_hash TEXT,
+  storage_uri TEXT NOT NULL,
+  archive_byte_size REAL NOT NULL,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  manifest_storage_uri TEXT,
+  manifest_file_hash TEXT,
+  asset_base_storage_uri TEXT,
+  CONSTRAINT bundles_archive_byte_size_check CHECK (
+    archive_byte_size BETWEEN 0 AND 9007199254740991
+  )
+);
+
+CREATE TABLE bundle_patches (
+  id TEXT PRIMARY KEY NOT NULL,
+  bundle_id TEXT NOT NULL,
+  base_bundle_id TEXT NOT NULL,
+  base_file_hash TEXT NOT NULL,
+  patch_file_hash TEXT NOT NULL,
+  patch_storage_uri TEXT NOT NULL,
+  byte_size REAL NOT NULL,
+  order_index INTEGER NOT NULL DEFAULT 0,
+  CONSTRAINT bundle_patches_byte_size_check CHECK (
+    byte_size BETWEEN 0 AND 9007199254740991
+  ),
+  CONSTRAINT bundle_patches_bundle_id_fk FOREIGN KEY (bundle_id)
+    REFERENCES bundles(id) ON UPDATE RESTRICT ON DELETE CASCADE,
+  CONSTRAINT bundle_patches_base_bundle_id_fk FOREIGN KEY (base_bundle_id)
+    REFERENCES bundles(id) ON UPDATE RESTRICT ON DELETE CASCADE
+);
+
+CREATE TABLE releases (
+  id TEXT PRIMARY KEY NOT NULL,
+  revision INTEGER NOT NULL,
+  scope_key TEXT COLLATE BINARY NOT NULL,
+  channel_id TEXT COLLATE BINARY NOT NULL,
+  platform TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  bundle_id TEXT,
+  strategy TEXT NOT NULL,
+  target_app_version TEXT,
+  fingerprint_hash TEXT,
+  enabled INTEGER NOT NULL,
+  should_force_update INTEGER NOT NULL,
+  message TEXT,
+  rollout_cohort_count INTEGER NOT NULL DEFAULT 1000,
+  target_cohorts TEXT NOT NULL DEFAULT '[]',
+  operation TEXT NOT NULL,
+  source_release_id TEXT,
+  created_at_ms REAL NOT NULL,
+  updated_at_ms REAL NOT NULL,
+  CONSTRAINT releases_revision_check CHECK (revision >= 1),
+  CONSTRAINT releases_kind_bundle_check CHECK (
+    (kind = 'BUNDLE' AND bundle_id IS NOT NULL)
+    OR (kind = 'EMBEDDED' AND bundle_id IS NULL)
+  ),
+  CONSTRAINT releases_strategy_target_check CHECK (
+    (strategy = 'APP_VERSION' AND target_app_version IS NOT NULL AND fingerprint_hash IS NULL)
+    OR (strategy = 'FINGERPRINT' AND target_app_version IS NULL AND fingerprint_hash IS NOT NULL)
+  ),
+  CONSTRAINT releases_rollout_cohort_count_check CHECK (
+    rollout_cohort_count BETWEEN 0 AND 1000
+  ),
+  CONSTRAINT releases_operation_check CHECK (
+    operation IN ('DEPLOY', 'PROMOTE', 'ROLLBACK')
+  ),
+  CONSTRAINT releases_channel_id_fk FOREIGN KEY (channel_id)
+    REFERENCES channels(id) ON UPDATE RESTRICT ON DELETE RESTRICT,
+  CONSTRAINT releases_bundle_id_fk FOREIGN KEY (bundle_id)
+    REFERENCES bundles(id) ON UPDATE RESTRICT ON DELETE RESTRICT,
+  CONSTRAINT releases_source_release_id_fk FOREIGN KEY (source_release_id)
+    REFERENCES releases(id) ON UPDATE RESTRICT ON DELETE SET NULL
+);
+
+CREATE TABLE release_catalogs (
+  scope_key TEXT COLLATE BINARY PRIMARY KEY NOT NULL,
+  catalog_id TEXT NOT NULL,
+  strategy TEXT NOT NULL,
+  channel_id TEXT COLLATE BINARY NOT NULL,
+  channel_key TEXT COLLATE BINARY NOT NULL,
+  platform TEXT NOT NULL,
+  fingerprint_hash TEXT,
+  generation REAL NOT NULL,
+  payload TEXT NOT NULL,
+  catalog_hash TEXT NOT NULL,
+  byte_size INTEGER NOT NULL,
+  is_tombstone INTEGER NOT NULL,
+  updated_at_ms REAL NOT NULL,
+  CONSTRAINT release_catalogs_strategy_target_check CHECK (
+    (strategy = 'APP_VERSION' AND fingerprint_hash IS NULL)
+    OR (strategy = 'FINGERPRINT' AND fingerprint_hash IS NOT NULL)
+  ),
+  CONSTRAINT release_catalogs_generation_check CHECK (
+    generation BETWEEN 1 AND 9007199254740991
+  ),
+  CONSTRAINT release_catalogs_byte_size_check CHECK (
+    byte_size BETWEEN 0 AND 262144
+  ),
+  CONSTRAINT release_catalogs_channel_id_fk FOREIGN KEY (channel_id)
+    REFERENCES channels(id) ON UPDATE RESTRICT ON DELETE RESTRICT
+);
+
+CREATE TABLE bundle_events (
+  id TEXT PRIMARY KEY NOT NULL,
+  type TEXT NOT NULL,
+  install_id TEXT NOT NULL,
+  user_id TEXT,
+  username TEXT,
+  from_release_id TEXT,
+  from_bundle_id TEXT,
+  to_release_id TEXT,
+  to_bundle_id TEXT NOT NULL,
+  platform TEXT NOT NULL,
+  app_version TEXT NOT NULL,
+  channel TEXT NOT NULL,
+  cohort TEXT NOT NULL,
+  update_strategy TEXT,
+  fingerprint_hash TEXT,
+  sdk_version TEXT,
+  received_at_ms REAL NOT NULL,
+  CONSTRAINT bundle_events_type_check CHECK (
+    type IN ('UPDATE_APPLIED', 'RECOVERED', 'RELEASE_ADOPTED', 'UNCHANGED')
+  ),
+  CONSTRAINT bundle_events_platform_check CHECK (
+    platform IN ('ios', 'android')
+  ),
+  CONSTRAINT bundle_events_shape_check CHECK (
+    (
+      type IN ('UPDATE_APPLIED', 'RECOVERED', 'RELEASE_ADOPTED')
+      AND from_bundle_id IS NOT NULL
+      AND update_strategy IS NOT NULL
+      AND update_strategy IN ('fingerprint', 'appVersion')
+    ) OR (
+      type = 'UNCHANGED'
+      AND from_bundle_id IS NULL
+      AND update_strategy IS NULL
+    )
+  ),
+  CONSTRAINT bundle_events_received_at_check CHECK (received_at_ms >= 0)
+);
+
+CREATE TABLE api_keys (
+  id TEXT PRIMARY KEY NOT NULL,
+  hash TEXT NOT NULL,
+  name TEXT NOT NULL,
+  prefix TEXT NOT NULL,
+  role TEXT NOT NULL,
+  created_at_ms REAL NOT NULL,
+  revoked_at_ms REAL,
+  CONSTRAINT api_keys_role_check CHECK (role = 'client'),
+  CONSTRAINT api_keys_created_at_check CHECK (created_at_ms >= 0),
+  CONSTRAINT api_keys_revoked_at_check
+    CHECK (revoked_at_ms IS NULL OR revoked_at_ms >= 0)
+);
+
+CREATE TABLE private_hot_updater_settings (
+  key TEXT PRIMARY KEY NOT NULL,
+  value TEXT NOT NULL DEFAULT '1.0.0'
+);
+
+CREATE UNIQUE INDEX channels_name_key ON channels(name);
+CREATE INDEX bundle_patches_bundle_id_idx ON bundle_patches(bundle_id);
+CREATE INDEX bundle_patches_base_bundle_id_idx ON bundle_patches(base_bundle_id);
+CREATE INDEX releases_scope_order_idx ON releases(scope_key, id);
+CREATE INDEX releases_channel_platform_order_idx
+  ON releases(channel_id, platform, id);
+CREATE INDEX releases_bundle_id_idx ON releases(bundle_id);
+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 UNIQUE INDEX api_keys_hash_key ON api_keys(hash);
+CREATE INDEX api_keys_created_at_idx
+  ON api_keys(created_at_ms, id);
+
+INSERT INTO private_hot_updater_settings (key, value)
+VALUES ('schema.core', '1.0.0')
+ON CONFLICT(key) DO UPDATE SET value = excluded.value;

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

@@ -0,0 +1,130 @@
+import { env } from "cloudflare:test";
+import { expect, inject, it } from "vitest";
+
+declare module "vitest" {
+  export interface ProvidedContext {
+    d1Migrations: readonly {
+      readonly name: string;
+      readonly sql: string;
+    }[];
+  }
+}
+
+it("ships a single D1 1.0.0 CREATE migration", () => {
+  expect(inject("d1Migrations").map(({ name }) => name)).toEqual([
+    "0001_hot-updater_1.0.0.sql",
+  ]);
+});
+
+it("creates the current schema with required artifact sizes", async () => {
+  const [createMigration] = inject("d1Migrations");
+  await env.DB.prepare(createMigration!.sql).run();
+  await env.DB.prepare(`
+    INSERT INTO bundles (
+      id, platform, file_hash, storage_uri, archive_byte_size, metadata
+    ) VALUES (
+      '00000000-0000-0000-0000-000000000001', 'ios', 'hash',
+      'storage://bundle', 3000000001, '{}'
+    )
+  `).run();
+  await env.DB.prepare(`
+    INSERT INTO bundle_patches (
+      id, bundle_id, base_bundle_id, base_file_hash, patch_file_hash,
+      patch_storage_uri, byte_size
+    ) VALUES (
+      'patch-1', '00000000-0000-0000-0000-000000000001',
+      '00000000-0000-0000-0000-000000000001', 'base-hash', 'patch-hash',
+      'storage://patch', 3000000002
+    )
+  `).run();
+
+  const tables = await env.DB.prepare(`
+    SELECT name FROM sqlite_master
+    WHERE type = 'table'
+    ORDER BY name
+  `).all<{ name: string }>();
+
+  expect(tables.results.map(({ name }) => name)).toEqual(
+    expect.arrayContaining([
+      "bundle_events",
+      "bundle_patches",
+      "bundles",
+      "channels",
+      "api_keys",
+      "private_hot_updater_settings",
+      "release_catalogs",
+      "releases",
+    ]),
+  );
+
+  const version = await env.DB.prepare(
+    "SELECT value FROM private_hot_updater_settings WHERE key = 'schema.core'",
+  ).first<string>("value");
+  expect(version).toBe("1.0.0");
+
+  await env.DB.prepare(
+    "INSERT INTO channels (id, name) VALUES ('channel-1', 'production')",
+  ).run();
+  await env.DB.prepare(`
+    INSERT INTO releases (
+      id, revision, scope_key, channel_id, platform, kind, bundle_id,
+      strategy, target_app_version, fingerprint_hash, enabled,
+      should_force_update, message, rollout_cohort_count, target_cohorts,
+      operation, source_release_id, created_at_ms, updated_at_ms
+    ) VALUES (
+      '00000000-0000-0000-0000-000000000001', 1, 'scope', 'channel-1',
+      'ios', 'BUNDLE', '00000000-0000-0000-0000-000000000001',
+      'APP_VERSION', '1.0.0', NULL, 1, 0, NULL, 1000, '[]',
+      'DEPLOY', NULL, 0, 0
+    )
+  `).run();
+
+  const release = await env.DB.prepare(
+    "SELECT channel_id, bundle_id FROM releases",
+  ).first();
+  expect(release).toEqual({
+    channel_id: "channel-1",
+    bundle_id: "00000000-0000-0000-0000-000000000001",
+  });
+  const sizes = await env.DB.prepare(`
+    SELECT bundle.archive_byte_size, patch.byte_size
+    FROM bundles AS bundle
+    JOIN bundle_patches AS patch ON patch.bundle_id = bundle.id
+  `).first();
+  expect(sizes).toEqual({
+    archive_byte_size: 3_000_000_001,
+    byte_size: 3_000_000_002,
+  });
+
+  for (const size of [-1, Number.MAX_SAFE_INTEGER + 1, null]) {
+    await expect(
+      env.DB.prepare("UPDATE bundles SET archive_byte_size = ?")
+        .bind(size)
+        .run(),
+    ).rejects.toThrow(/constraint failed/);
+    await expect(
+      env.DB.prepare("UPDATE bundle_patches SET byte_size = ?")
+        .bind(size)
+        .run(),
+    ).rejects.toThrow(/constraint failed/);
+  }
+
+  await expect(
+    env.DB.prepare(`
+      INSERT INTO bundles (id, platform, file_hash, storage_uri)
+      VALUES ('missing-size', 'ios', 'hash', 'storage://bundle')
+    `).run(),
+  ).rejects.toThrow(/NOT NULL constraint failed/);
+  await expect(
+    env.DB.prepare(`
+      INSERT INTO bundle_patches (
+        id, bundle_id, base_bundle_id, base_file_hash, patch_file_hash,
+        patch_storage_uri
+      ) VALUES (
+        'missing-size', '00000000-0000-0000-0000-000000000001',
+        '00000000-0000-0000-0000-000000000001', 'base-hash', 'patch-hash',
+        'storage://patch'
+      )
+    `).run(),
+  ).rejects.toThrow(/NOT NULL constraint failed/);
+});

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

@@ -0,0 +1,292 @@
+import type {
+  BundleRow,
+  ChannelRow,
+  ReleaseRow,
+} from "@hot-updater/plugin-core";
+import { setupDatabasePluginTestSuite } from "@hot-updater/test-utils";
+import { env } from "cloudflare:test";
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  inject,
+  it,
+  vi,
+} from "vitest";
+
+import { d1Database } from "../../src/d1Database";
+import { d1Database as d1RuntimeDatabase } from "../../src/worker";
+
+const state = vi.hoisted<{ db: D1Database | undefined }>(() => ({
+  db: undefined,
+}));
+
+class D1TestStateError extends Error {
+  readonly name = "D1TestStateError";
+}
+
+const getDb = (): D1Database => {
+  if (state.db === undefined) {
+    throw new D1TestStateError();
+  }
+  return state.db;
+};
+
+vi.mock("cloudflare", () => ({
+  default: class MockCloudflare {
+    readonly d1 = {
+      database: {
+        query: async (
+          _databaseId: string,
+          input:
+            | { readonly sql: string; readonly params?: readonly string[] }
+            | {
+                readonly batch: readonly {
+                  readonly sql: string;
+                  readonly params?: readonly string[];
+                }[];
+              },
+        ) => {
+          const statements =
+            "batch" in input
+              ? input.batch.map(({ sql, params }) =>
+                  getDb()
+                    .prepare(sql)
+                    .bind(...(params ?? [])),
+                )
+              : (() => {
+                  const params = input.params ?? [];
+                  let paramOffset = 0;
+                  return input.sql
+                    .split(";")
+                    .map((sql) => sql.trim())
+                    .filter(Boolean)
+                    .map((sql) => {
+                      const paramCount = sql.match(/\?/g)?.length ?? 0;
+                      const statement = getDb()
+                        .prepare(sql)
+                        .bind(
+                          ...params.slice(
+                            paramOffset,
+                            paramOffset + paramCount,
+                          ),
+                        );
+                      paramOffset += paramCount;
+                      return statement;
+                    });
+                })();
+          const results = await getDb().batch(statements);
+          return {
+            async *iterPages() {
+              yield { result: results };
+            },
+          };
+        },
+      },
+    };
+  },
+}));
+
+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;",
+    )
+    .run();
+};
+
+const createChannelRow = (name: string): ChannelRow => ({
+  id: `channel-${name}`,
+  name,
+});
+
+const createBundleRow = (): BundleRow => ({
+  id: "00000000-0000-0000-0000-000000000902",
+  platform: "ios",
+  file_hash: "hash",
+  git_commit_hash: null,
+  storage_uri: "storage://bundle",
+  archive_byte_size: 3_000_000_001,
+  metadata: {},
+  manifest_storage_uri: null,
+  manifest_file_hash: null,
+  asset_base_storage_uri: null,
+});
+
+const createReleaseRow = (
+  channel: ChannelRow,
+  bundle: BundleRow,
+): ReleaseRow => ({
+  id: "00000000-0000-7000-8000-000000000903",
+  revision: 1,
+  scope_key: `v1:test:${channel.name}:ios:app-version`,
+  channel_id: channel.id,
+  platform: bundle.platform,
+  kind: "BUNDLE",
+  bundle_id: bundle.id,
+  strategy: "APP_VERSION",
+  target_app_version: "1.0.0",
+  fingerprint_hash: null,
+  enabled: true,
+  should_force_update: false,
+  message: null,
+  rollout_cohort_count: 1000,
+  target_cohorts: [],
+  operation: "DEPLOY",
+  source_release_id: null,
+  created_at_ms: 100,
+  updated_at_ms: 100,
+});
+
+setupDatabasePluginTestSuite({
+  name: "cloudflare d1 http fixed-model database plugin",
+  migrate: async () => {
+    state.db = env.DB;
+    await getDb().prepare(inject("prepareSql")).run();
+  },
+  createPlugin: () =>
+    d1Database({
+      accountId: "account-id",
+      cloudflareApiToken: "api-token",
+      databaseId: "database-id",
+    }),
+  reset,
+  dispose: () => undefined,
+});
+
+setupDatabasePluginTestSuite({
+  name: "cloudflare worker d1 fixed-model database plugin",
+  migrate: () => undefined,
+  createPlugin: () => d1RuntimeDatabase(env.DB),
+  reset,
+  dispose: () => {
+    state.db = undefined;
+  },
+});
+
+describe.each([
+  {
+    name: "cloudflare d1 http",
+    createPlugin: () =>
+      d1Database({
+        accountId: "account-id",
+        cloudflareApiToken: "api-token",
+        databaseId: "database-id",
+      }),
+  },
+  {
+    name: "cloudflare worker d1",
+    createPlugin: () => d1RuntimeDatabase(env.DB),
+  },
+])("$name Channel deletion", ({ createPlugin }) => {
+  beforeAll(() => {
+    state.db = env.DB;
+  });
+
+  beforeEach(async () => {
+    await reset();
+  });
+
+  afterAll(() => {
+    state.db = undefined;
+  });
+
+  it("deletes only empty channels", async () => {
+    const plugin = createPlugin();
+    const channel = createChannelRow("empty");
+    await plugin.models.channels.insert({
+      row: channel,
+      onConflict: "returnExisting",
+    });
+
+    await expect(
+      plugin.models.channels.delete({ id: channel.id }),
+    ).resolves.toEqual({ deleted: true });
+    await expect(
+      plugin.models.channels.delete({ id: channel.id }),
+    ).resolves.toEqual({ deleted: false, reason: "not_found" });
+  });
+
+  it("rejects direct and committed deletion while a Release references the channel", async () => {
+    const plugin = createPlugin();
+    const channel = createChannelRow("active");
+    const bundle = createBundleRow();
+    const release = createReleaseRow(channel, bundle);
+    await plugin.models.channels.insert({
+      row: channel,
+      onConflict: "returnExisting",
+    });
+    await plugin.commit({
+      changes: [
+        { model: "bundles", operation: "insert", row: bundle },
+        { model: "releases", operation: "insert", row: release },
+      ],
+    });
+
+    await expect(
+      plugin.models.channels.delete({ id: channel.id }),
+    ).resolves.toEqual({ deleted: false, reason: "not_empty" });
+    await expect(
+      plugin.commit({
+        changes: [
+          {
+            model: "channels",
+            operation: "delete",
+            where: { id: channel.id },
+          },
+        ],
+      }),
+    ).resolves.toEqual({
+      committed: false,
+      conflict: { changeIndex: 0, reason: "referenced" },
+    });
+    await expect(plugin.models.bundles.findById(bundle.id)).resolves.toEqual(
+      bundle,
+    );
+  });
+
+  it("atomically deletes a Release before deleting its newly empty channel", async () => {
+    const plugin = createPlugin();
+    const channel = createChannelRow("retired");
+    const bundle = createBundleRow();
+    const release = createReleaseRow(channel, bundle);
+    await plugin.models.channels.insert({
+      row: channel,
+      onConflict: "returnExisting",
+    });
+    await plugin.commit({
+      changes: [
+        { model: "bundles", operation: "insert", row: bundle },
+        { model: "releases", operation: "insert", row: release },
+      ],
+    });
+
+    await expect(
+      plugin.commit({
+        changes: [
+          {
+            model: "releases",
+            operation: "delete",
+            where: { id: release.id },
+          },
+          {
+            model: "channels",
+            operation: "delete",
+            where: { id: channel.id },
+          },
+        ],
+      }),
+    ).resolves.toEqual({ committed: true });
+    await expect(
+      plugin.models.releases.findById(release.id),
+    ).resolves.toBeNull();
+    await expect(plugin.models.bundles.findById(bundle.id)).resolves.toEqual(
+      bundle,
+    );
+    await expect(plugin.models.channels.list({})).resolves.toEqual({
+      channels: [],
+    });
+  });
+});