@hot-updater/server 1.0.0-rc.2 → 1.0.0-rc.21

package/src/db/databasePluginUpdateCheck.bench.ts

@@ -1,110 +0,0 @@
-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 recordInsights() {
-    throw new BenchmarkMutationError();
-  },
-  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,296 +0,0 @@
-import { DatabaseSync, type SqliteValue } from "node:sqlite";
-
-import { PGlite } from "@electric-sql/pglite";
-import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
-import { Kysely, SqliteDialect } from "kysely";
-import { PGliteDialect } from "kysely-pglite-dialect";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { createBundleEventRowFixture } from "../../../test-utils/src/databaseTestFixtures";
-import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
-import { kyselyAdapter } from "../adapters/kysely";
-import { createDatabasePluginCore } from "./databasePluginCore";
-import { createKyselyMigrator } from "./fixedMigrator";
-import { createSchemaReadinessChecker } from "./schemaReadiness";
-
-interface SettingsDatabase {
-  readonly private_hot_updater_settings: {
-    readonly key: string;
-    readonly value: string;
-  };
-}
-
-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 () => {
-    await Promise.all(kyselyInstances.splice(0).map((db) => db.destroy()));
-    await Promise.all(databases.splice(0).map((db) => db.close()));
-  });
-
-  it("creates the final Insights access paths in the initial schema", 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 expect(migrator.next()).resolves.toEqual({ version: "1.0.0" });
-    await expect(migrator.previous()).resolves.toBeUndefined();
-    const migration = await migrator.migrateToLatest();
-    await migration.execute();
-    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
-    const plugin = kyselyAdapter({ db: kysely, provider: "postgresql" });
-    const event = createBundleEventRowFixture("706", 100);
-    const input = { event, installation: toInsightsInstallationRow(event) };
-    await plugin.models.insights.record(input);
-
-    const repeated = await migrator.migrateToLatest();
-    expect(repeated.operations).toEqual([]);
-    expect(repeated.getSQL?.()).toBe("");
-    await repeated.execute();
-    await expect(migrator.next()).resolves.toBeUndefined();
-    await expect(
-      plugin.models.insights.findInstallations({ installId: event.install_id }),
-    ).resolves.toEqual([input.installation]);
-    await expect(
-      plugin.models.insights.countEvents({
-        filter: {
-          platform: "ios",
-          channel: "production",
-          type: "UPDATE_APPLIED",
-          toBundleId: event.to_bundle_id,
-        },
-        sinceMs: 0,
-        beforeReceivedAtMs: 101,
-      }),
-    ).resolves.toBe(1);
-    const indexes = await database.query<{ indexname: string }>(
-      "select indexname from pg_indexes where tablename in ('bundle_events', 'bundle_installations')",
-    );
-    expect(indexes.rows.map(({ indexname }) => indexname)).toEqual(
-      expect.arrayContaining([
-        "bundle_events_from_bundle_idx",
-        "bundle_events_to_bundle_idx",
-        "bundle_installations_scope_idx",
-        "bundle_installations_bundle_idx",
-      ]),
-    );
-    await database.exec("set enable_seqscan = off");
-    const plan = await database.query<{ "QUERY PLAN": string }>(
-      "explain select * from bundle_events where type = 'UPDATE_APPLIED' and platform = 'ios' and channel = 'production' and to_bundle_id = $1 and received_at_ms < 101 order by received_at_ms desc, id desc limit 10",
-      [event.to_bundle_id],
-    );
-    expect(plan.rows.map((row) => row["QUERY PLAN"]).join("\n")).toContain(
-      "bundle_events_to_bundle_idx",
-    );
-  });
-
-  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(database),
-    });
-    kyselyInstances.push(kysely);
-    const migrator = createKyselyMigrator({
-      db: kysely,
-      provider: "postgresql",
-    });
-
-    await expect(migrator.getVersion()).resolves.toBeUndefined();
-    const result = await migrator.migrateToLatest({
-      mode: "from-schema",
-      updateSettings: true,
-    });
-    expect(result.operations.length).toBeGreaterThan(0);
-    await result.execute();
-
-    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("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(database),
-    });
-    kyselyInstances.push(kysely);
-    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
-      );
-    `);
-    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: "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(core.api.getBundles({ limit: 1 })).rejects.toThrow(
-      "Hot Updater v1 cannot migrate schema 0.36.0",
-    );
-    expect(count).not.toHaveBeenCalled();
-    expect(findMany).not.toHaveBeenCalled();
-  });
-});

package/src/db/fixedMigrator.ts

@@ -1,147 +0,0 @@
-import { sql, type QueryExecutorProvider } from "kysely";
-
-import {
-  HOT_UPDATER_CORE_SCHEMA_KEY,
-  HOT_UPDATER_SCHEMA_VERSION,
-  HOT_UPDATER_SETTINGS_TABLE,
-} from "../schema/types";
-import {
-  assertCurrentOrEmptySchemaVersion,
-  assertSupportedMigrationMode,
-  getEmptyMigrationResult,
-  inferLegacyCoreSchemaVersion,
-  isCurrentSchemaVersion,
-} from "./fixedMigratorShared";
-import { createTableSql } from "./schema/sql";
-import {
-  createSqlCreateOperations,
-  getSettingsInsertSql,
-} from "./schema/sqlOperations";
-import { executeMigrationStatements } from "./sqlMigrationExecution";
-import type {
-  MigrateOptions,
-  MigrationResult,
-  Migrator,
-  ORMSQLProvider,
-  RelationMode,
-} from "./types";
-
-const isMissingSettingsTableError = (error: unknown): boolean => {
-  if (!(error instanceof Error)) return false;
-  const message = error.message.toLowerCase();
-  return (
-    message.includes("private_hot_updater_settings") &&
-    (message.includes("does not exist") ||
-      message.includes("no such table") ||
-      message.includes("doesn't exist") ||
-      message.includes("not found"))
-  );
-};
-
-export const createKyselyMigrator = ({
-  db,
-  provider,
-  relationMode = "foreign-keys",
-}: {
-  db: QueryExecutorProvider;
-  provider: ORMSQLProvider;
-  relationMode?: RelationMode;
-}): Migrator => {
-  const getSetting = async (key: string): Promise<string | undefined> => {
-    try {
-      const result = await sql<{ readonly value: unknown }>`select ${sql.ref(
-        "value",
-      )} from ${sql.table(HOT_UPDATER_SETTINGS_TABLE)} where ${sql.ref(
-        "key",
-      )} = ${key} limit 1`.execute(db);
-      const row = result.rows[0];
-      if (!row) return undefined;
-      if (typeof row.value !== "string") {
-        throw new Error(`Invalid Hot Updater schema setting: ${key}`);
-      }
-      return row.value;
-    } catch (error) {
-      if (!isMissingSettingsTableError(error)) throw error;
-      return undefined;
-    }
-  };
-
-  const getCoreVersion = (): Promise<string | undefined> =>
-    getSetting(HOT_UPDATER_CORE_SCHEMA_KEY);
-
-  const getSchemaVersions = async (): Promise<{
-    readonly coreVersion: string | undefined;
-    readonly legacyCoreVersion: string | undefined;
-  }> => {
-    const coreVersion = await getCoreVersion();
-    const legacyCoreVersion = inferLegacyCoreSchemaVersion(
-      await getSetting("version"),
-    );
-    return { coreVersion, legacyCoreVersion };
-  };
-
-  const getVersion = async (): Promise<string | undefined> => {
-    const { coreVersion, legacyCoreVersion } = await getSchemaVersions();
-    return coreVersion ?? legacyCoreVersion;
-  };
-
-  const makeResult = async (
-    options: MigrateOptions = {},
-  ): Promise<MigrationResult> => {
-    assertSupportedMigrationMode(options);
-
-    const { coreVersion, legacyCoreVersion } = await getSchemaVersions();
-    if (isCurrentSchemaVersion(coreVersion)) {
-      return getEmptyMigrationResult();
-    }
-    assertCurrentOrEmptySchemaVersion(coreVersion ?? legacyCoreVersion);
-
-    const settingsStatement = getSettingsInsertSql(provider);
-    const settingsOperation =
-      options.updateSettings === false
-        ? undefined
-        : {
-            type: "custom" as const,
-            sql: settingsStatement,
-          };
-    const statements = [
-      ...createTableSql(provider, relationMode),
-      settingsStatement,
-    ];
-
-    return {
-      operations: createSqlCreateOperations(
-        provider,
-        relationMode,
-        settingsOperation,
-      ),
-      getSQL: () => statements.map((statement) => `${statement};`).join("\n\n"),
-      execute: () => executeMigrationStatements({ db, provider, statements }),
-    };
-  };
-
-  return {
-    getVersion,
-    getNameVariants: async () => undefined,
-    next: async () => {
-      const { coreVersion } = await getSchemaVersions();
-      return isCurrentSchemaVersion(coreVersion)
-        ? undefined
-        : { version: HOT_UPDATER_SCHEMA_VERSION };
-    },
-    previous: async () => undefined,
-    up: makeResult,
-    down: async () => {
-      throw new Error("No previous schema to migrate to.");
-    },
-    migrateTo: async (version, options) => {
-      if (version !== HOT_UPDATER_SCHEMA_VERSION) {
-        throw new Error(`Invalid version ${version}`);
-      }
-      return makeResult(options);
-    },
-    migrateToLatest: makeResult,
-  };
-};
-
-export { createMongoMigrator } from "./fixedMigratorMongo";