@hot-updater/server 0.36.6 → 1.0.0-rc.0

package/src/db/databasePluginUpdateCheck.bench.ts

@@ -0,0 +1,107 @@
+import {
+  createReleaseCatalogScopeKey,
+  encodeChannelKey,
+  RELEASE_CATALOG_FALLBACK_POLICY,
+  RELEASE_CATALOG_SCHEMA_VERSION,
+} from "@hot-updater/core";
+import {
+  createDatabasePlugin,
+  type CompiledReleaseCatalog,
+  type ReleaseCatalogRow,
+} from "@hot-updater/plugin-core";
+import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
+import { bench, describe } from "vitest";
+
+import { createHotUpdater } from "../index";
+
+const CATALOG_ID = "bench";
+const CHANNEL_KEY = encodeChannelKey("production");
+const SCOPE_KEY = createReleaseCatalogScopeKey({
+  channelKey: CHANNEL_KEY,
+  platform: "ios",
+  strategy: "APP_VERSION",
+});
+const PAYLOAD = JSON.stringify({
+  fallbackPolicy: RELEASE_CATALOG_FALLBACK_POLICY,
+  releaseDescriptors: [],
+  schemaVersion: RELEASE_CATALOG_SCHEMA_VERSION,
+  segments: [],
+  strategy: "APP_VERSION",
+} satisfies CompiledReleaseCatalog);
+const CATALOG: ReleaseCatalogRow = {
+  catalog_id: CATALOG_ID,
+  byte_size: Buffer.byteLength(PAYLOAD),
+  catalog_hash: `sha256:${"0".repeat(64)}`,
+  channel_id: "channel-production",
+  channel_key: CHANNEL_KEY,
+  fingerprint_hash: null,
+  generation: 1,
+  is_tombstone: false,
+  payload: PAYLOAD,
+  platform: "ios",
+  scope_key: SCOPE_KEY,
+  strategy: "APP_VERSION",
+  updated_at_ms: 1,
+};
+
+class BenchmarkMutationError extends Error {
+  readonly name = "BenchmarkMutationError";
+
+  constructor() {
+    super("The Release Catalog benchmark plugin is read-only.");
+  }
+}
+
+const name = "release-catalog-benchmark";
+const adapter = createDatabasePluginAdapter(name, {
+  async count() {
+    return 0;
+  },
+  async create() {
+    throw new BenchmarkMutationError();
+  },
+  async delete() {
+    throw new BenchmarkMutationError();
+  },
+  async deleteChannel() {
+    throw new BenchmarkMutationError();
+  },
+  async findMany() {
+    return [];
+  },
+  async findOne(input) {
+    return input.model === "release_catalogs" ? CATALOG : null;
+  },
+  async insertChannel() {
+    throw new BenchmarkMutationError();
+  },
+  async update() {
+    throw new BenchmarkMutationError();
+  },
+});
+const database = createDatabasePlugin({
+  name,
+  commit: adapter.commit,
+  models: adapter.models,
+});
+const hotUpdater = createHotUpdater({
+  database,
+  clientAccess: { type: "public" },
+});
+const url =
+  `https://updates.example.com/release-catalogs/app-version/` +
+  `ios/${CHANNEL_KEY}/1.0.0`;
+
+describe("database plugin update check benchmark", () => {
+  bench(
+    "fixed-model plugin paged update check",
+    async () => {
+      const response = await hotUpdater.handlers.client(new Request(url));
+      if (response.status !== 200) {
+        throw new Error(`Expected 200 response, received ${response.status}.`);
+      }
+      await response.text();
+    },
+    { iterations: 20, warmupIterations: 5 },
+  );
+});

package/src/db/fixedMigrator.spec.ts

@@ -1,9 +1,14 @@
+import { DatabaseSync, type SqliteValue } from "node:sqlite";
+
 import { PGlite } from "@electric-sql/pglite";
-import { Kysely } from "kysely";
+import { Kysely, SqliteDialect } from "kysely";
 import { PGliteDialect } from "kysely-pglite-dialect";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 
+import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
+import { createDatabasePluginCore } from "./databasePluginCore";
 import { createKyselyMigrator } from "./fixedMigrator";
+import { createSchemaReadinessChecker } from "./schemaReadiness";
 
 interface SettingsDatabase {
   readonly private_hot_updater_settings: {
@@ -12,24 +17,48 @@ interface SettingsDatabase {
   };
 }
 
-describe("createKyselyMigrator", () => {
+const createNodeSqliteKysely = (
+  database: DatabaseSync,
+): Kysely<SettingsDatabase> =>
+  new Kysely<SettingsDatabase>({
+    dialect: new SqliteDialect({
+      database: {
+        close: () => database.close(),
+        prepare: (sqlText) => {
+          const statement = database.prepare(sqlText);
+          return {
+            reader: statement.columns().length > 0,
+            all: (parameters) =>
+              statement.all(...(parameters as SqliteValue[])),
+            run: (parameters) => {
+              const result = statement.run(...(parameters as SqliteValue[]));
+              return {
+                changes: result.changes,
+                lastInsertRowid: result.lastInsertRowid,
+              };
+            },
+            iterate: (parameters) =>
+              statement.iterate(...(parameters as SqliteValue[])),
+          };
+        },
+      },
+    }),
+  });
+
+describe("Kysely migrator", () => {
   const databases: PGlite[] = [];
   const kyselyInstances: Kysely<SettingsDatabase>[] = [];
 
   afterEach(async () => {
-    for (const kysely of kyselyInstances.splice(0)) {
-      await kysely.destroy();
-    }
-    for (const db of databases.splice(0)) {
-      await db.close();
-    }
+    await Promise.all(kyselyInstances.splice(0).map((db) => db.destroy()));
+    await Promise.all(databases.splice(0).map((db) => db.close()));
   });
 
-  it("includes the schema version row in fresh standalone SQL", async () => {
-    const db = new PGlite();
-    databases.push(db);
+  it("creates schema 1.0.0 from an empty database", async () => {
+    const database = new PGlite();
+    databases.push(database);
     const kysely = new Kysely<SettingsDatabase>({
-      dialect: new PGliteDialect(db),
+      dialect: new PGliteDialect(database),
     });
     kyselyInstances.push(kysely);
     const migrator = createKyselyMigrator({
@@ -37,53 +66,166 @@ describe("createKyselyMigrator", () => {
       provider: "postgresql",
     });
 
-    const migration = await migrator.migrateToLatest({
+    await expect(migrator.getVersion()).resolves.toBeUndefined();
+    const result = await migrator.migrateToLatest({
       mode: "from-schema",
-      updateSettings: false,
+      updateSettings: true,
     });
+    expect(result.operations.length).toBeGreaterThan(0);
+    await result.execute();
 
-    expect(migration.getSQL?.()).toContain(
-      "insert into private_hot_updater_settings (key, value) values ('version', '0.31.0')",
-    );
-    expect(migration.operations).not.toContainEqual(
-      expect.objectContaining({
-        sql: expect.stringContaining(
-          "insert into private_hot_updater_settings",
-        ),
-      }),
+    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
+    const tables = await database.query<{ tablename: string }>(`
+      select tablename from pg_tables
+      where schemaname = 'public'
+      order by tablename
+    `);
+    expect(tables.rows.map(({ tablename }) => tablename)).toEqual(
+      expect.arrayContaining([
+        "bundles",
+        "bundle_patches",
+        "channels",
+        "releases",
+        "release_catalogs",
+        "bundle_events",
+        "api_keys",
+        "private_hot_updater_settings",
+      ]),
     );
   });
 
-  it("rejects unknown schema versions before writing settings", async () => {
-    const db = new PGlite();
-    databases.push(db);
+  it("is a no-op when schema.core is already 1.0.0", async () => {
+    const database = new PGlite();
+    databases.push(database);
     const kysely = new Kysely<SettingsDatabase>({
-      dialect: new PGliteDialect(db),
+      dialect: new PGliteDialect(database),
     });
     kyselyInstances.push(kysely);
-    await db.exec(`
+    const migrator = createKyselyMigrator({
+      db: kysely,
+      provider: "postgresql",
+    });
+    await (
+      await migrator.migrateToLatest({
+        mode: "from-schema",
+        updateSettings: true,
+      })
+    ).execute();
+
+    const result = await migrator.migrateToLatest({ mode: "from-schema" });
+    expect(result.operations).toEqual([]);
+    expect(result.getSQL?.()).toBe("");
+  });
+
+  it("ignores a leftover version marker when schema.core is 1.0.0", async () => {
+    const database = new PGlite();
+    databases.push(database);
+    const kysely = new Kysely<SettingsDatabase>({
+      dialect: new PGliteDialect(database),
+    });
+    kyselyInstances.push(kysely);
+    const migrator = createKyselyMigrator({
+      db: kysely,
+      provider: "postgresql",
+    });
+    await (
+      await migrator.migrateToLatest({
+        mode: "from-schema",
+        updateSettings: true,
+      })
+    ).execute();
+    await database.exec(`
+      insert into private_hot_updater_settings (key, value)
+      values ('version', '0.36.0')
+      on conflict (key) do update set value = excluded.value
+    `);
+
+    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
+    await expect(
+      migrator.migrateToLatest({ mode: "from-schema" }),
+    ).resolves.toMatchObject({ operations: [] });
+  });
+
+  it.each(["0.21.0", "0.36.0", "0.38.0", "0.39.0"])(
+    "rejects in-place upgrade from schema %s",
+    async (version) => {
+      const database = new PGlite();
+      databases.push(database);
+      const kysely = new Kysely<SettingsDatabase>({
+        dialect: new PGliteDialect(database),
+      });
+      kyselyInstances.push(kysely);
+      await database.exec(`
+        create table private_hot_updater_settings (
+          key text primary key,
+          value text not null
+        );
+        insert into private_hot_updater_settings (key, value)
+        values ('schema.core', '${version}');
+      `);
+      const migrator = createKyselyMigrator({
+        db: kysely,
+        provider: "postgresql",
+      });
+
+      await expect(
+        migrator.migrateToLatest({ mode: "from-schema" }),
+      ).rejects.toThrow(`Hot Updater v1 cannot migrate schema ${version}`);
+    },
+  );
+
+  it("rejects a corrupt schema.core value", async () => {
+    const database = new DatabaseSync(":memory:");
+    database.exec(`
+      create table private_hot_updater_settings (
+        key text primary key,
+        value text not null
+      );
+    `);
+    database
+      .prepare(
+        "insert into private_hot_updater_settings (key, value) values (?, ?)",
+      )
+      .run("schema.core", new Uint8Array([0xff]));
+    const kysely = createNodeSqliteKysely(database);
+    kyselyInstances.push(kysely);
+    const migrator = createKyselyMigrator({ db: kysely, provider: "sqlite" });
+
+    await expect(migrator.getVersion()).rejects.toThrow(
+      "Invalid Hot Updater schema setting: schema.core",
+    );
+  });
+
+  it("blocks v0 schema readiness before reading bundle data", async () => {
+    const database = new DatabaseSync(":memory:");
+    database.exec(`
       create table private_hot_updater_settings (
         key text primary key,
         value text not null
       );
-      insert into private_hot_updater_settings (key, value)
-      values ('version', '0.20.0');
     `);
+    database
+      .prepare(
+        "insert into private_hot_updater_settings (key, value) values (?, ?)",
+      )
+      .run("schema.core", "0.36.0");
+    const kysely = createNodeSqliteKysely(database);
+    kyselyInstances.push(kysely);
     const migrator = createKyselyMigrator({
       db: kysely,
-      provider: "postgresql",
+      provider: "sqlite",
+    });
+    const plugin = createInMemoryDatabasePlugin();
+    const count = vi.spyOn(plugin.models.bundles, "count");
+    const findMany = vi.spyOn(plugin.models.bundles, "findMany");
+    const core = createDatabasePluginCore(plugin, async () => null, {
+      beforeOperation: createSchemaReadinessChecker("v0-sql", () => migrator),
     });
 
-    await expect(
-      migrator.migrateToLatest({
-        mode: "from-schema",
-        updateSettings: true,
-      }),
-    ).rejects.toThrow("Unsupported Hot Updater schema version: 0.20.0");
-
-    const version = await db.query<{ value: string }>(
-      "select value from private_hot_updater_settings where key = 'version'",
+    await expect(core.api.getBundles({ limit: 1 })).rejects.toThrow(
+      "Hot Updater v1 cannot migrate schema 0.36.0",
     );
-    expect(version.rows[0]?.value).toBe("0.20.0");
+    expect(count).not.toHaveBeenCalled();
+    expect(findMany).not.toHaveBeenCalled();
   });
 });