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

package/src/db/pluginTables.spec.ts

@@ -1,248 +0,0 @@
-import { PGlite } from "@electric-sql/pglite";
-import { createMemoryAdapter } from "@hot-updater/plugin-core/internal";
-import { Kysely } from "kysely";
-import { PGliteDialect } from "kysely-pglite-dialect";
-import { describe, expect, it, vi } from "vitest";
-
-import { drizzleAdapter } from "../adapters/drizzle";
-import { kyselyAdapter } from "../adapters/kysely";
-import { prismaAdapter } from "../adapters/prisma";
-import { createHotUpdater } from "../createHotUpdaterCore";
-import { HotUpdaterSchemaMigrationRequiredError } from "../database/fence";
-import { defineTable } from "../database/schema";
-import { createTableStatements } from "../database/sql/sqlAdapter";
-import { apiKeys } from "../plugins/api-keys";
-import {
-  type AnyHotUpdaterPlugin,
-  definePlugin,
-} from "../plugins/definePlugin";
-import { insights } from "../plugins/insights";
-import {
-  coreTarget,
-  createEngineDatabase,
-  toolingTargetOf,
-} from "./coreDatabase";
-import { createMigrator, generateSchema } from "./index";
-
-const notes = definePlugin({
-  id: "notes",
-  schemaVersion: "2",
-  schema: {
-    notes: defineTable(
-      {
-        id: { type: "string" },
-        author: { type: "string" },
-        text: { type: "string" },
-      },
-      { key: ["id"], indexes: { byAuthor: { eq: ["author"], sort: ["id"] } } },
-    ),
-  },
-  init: ({ db }) => ({
-    api: {
-      add: (id: string, author: string, text: string) =>
-        db.transaction(async (tx) => {
-          tx.create("notes", { id, author, text });
-        }),
-      read: (id: string) => db.findOne("notes", { id }),
-    },
-  }),
-});
-
-/** `hot-updater db migrate`: the migrator for the server's tables, run. */
-const migrate = async (hotUpdater: { readonly adapterName: string }) => {
-  const result = await createMigrator(hotUpdater).migrateToLatest({
-    mode: "from-schema",
-    updateSettings: true,
-  });
-  await result.execute();
-  return result;
-};
-
-const memoryDatabase = () =>
-  createEngineDatabase({ name: "memory", adapter: createMemoryAdapter() });
-
-describe("plugin tables in db tooling", () => {
-  it("adds each plugin's tables and settings row to core's, prefixed by its id unless it keeps its names", () => {
-    expect(toolingTargetOf([])).toBe(coreTarget);
-    const target = toolingTargetOf([insights(), notes]);
-    const names = target.schema.tables.map(({ name }) => name);
-    expect(names.slice(0, coreTarget.schema.tables.length)).toEqual(
-      coreTarget.schema.tables.map(({ name }) => name),
-    );
-    expect(names).toContain("bundle_events");
-    expect(names.at(-1)).toBe("notes_notes");
-    expect(target.settings).toEqual({
-      ...coreTarget.settings,
-      "schema.insights": insights().schemaVersion,
-      "schema.notes": "2",
-    });
-  });
-
-  it("fits Hot Updater's own plugins' tables within MySQL's key limit", () => {
-    expect(() =>
-      createTableStatements(
-        "mysql",
-        toolingTargetOf([insights(), apiKeys()]).schema.tables,
-      ),
-    ).not.toThrow();
-  });
-
-  it("migrates an engine database's core and plugin tables with its adapter", async () => {
-    const hotUpdater = createHotUpdater({
-      database: memoryDatabase(),
-      plugins: [notes],
-      clientAccess: "public",
-    });
-    await expect(hotUpdater.api.notes.read("n1")).rejects.toBeInstanceOf(
-      HotUpdaterSchemaMigrationRequiredError,
-    );
-
-    const result = await migrate(hotUpdater);
-    expect(result.operations).toContainEqual(
-      expect.objectContaining({
-        type: "create-table",
-        value: expect.objectContaining({ ormName: "notes_notes" }),
-      }),
-    );
-    await hotUpdater.api.notes.add("n1", "ada", "hello");
-    await expect(hotUpdater.api.notes.read("n1")).resolves.toEqual({
-      id: "n1",
-      author: "ada",
-      text: "hello",
-    });
-    await expect(hotUpdater.core.listChannels()).resolves.toEqual([]);
-  });
-
-  it("answers 503 until the plugin's settings row exists, then serves it", async () => {
-    const database = memoryDatabase();
-    await migrate(createHotUpdater({ database, clientAccess: "public" }));
-    const hotUpdater = createHotUpdater({
-      database,
-      plugins: [notes],
-      clientAccess: "public",
-    });
-    await expect(hotUpdater.api.notes.read("n1")).rejects.toThrow(
-      'Hot Updater schema setting "schema.notes" for memory is missing; expected "2". Run `hot-updater db migrate`.',
-    );
-    await expect(hotUpdater.core.listChannels()).rejects.toBeInstanceOf(
-      HotUpdaterSchemaMigrationRequiredError,
-    );
-    const channels = () =>
-      hotUpdater.handlers.admin(new Request("http://localhost/channels"));
-    const error = vi.spyOn(console, "error").mockImplementation(() => {});
-    expect((await channels()).status).toBe(503);
-    error.mockRestore();
-
-    await migrate(hotUpdater);
-    expect((await channels()).status).toBe(200);
-    await expect(hotUpdater.api.notes.read("n1")).resolves.toBeNull();
-    // The server without the plugin was already served.
-    await expect(
-      createHotUpdater({
-        database,
-        clientAccess: "public",
-      }).core.listChannels(),
-    ).resolves.toEqual([]);
-  });
-
-  it("writes a Kysely migration of the plugin's tables and settings row", async () => {
-    const db = new PGlite();
-    const kysely = new Kysely<object>({ dialect: new PGliteDialect(db) });
-    try {
-      const hotUpdater = createHotUpdater({
-        database: kyselyAdapter({ db: kysely, provider: "postgresql" }),
-        plugins: [notes],
-        clientAccess: "public",
-      });
-      const result = await createMigrator(hotUpdater).migrateToLatest({
-        mode: "from-schema",
-        updateSettings: true,
-      });
-      const sql = result.getSQL?.() ?? "";
-      expect(sql).toContain('CREATE TABLE IF NOT EXISTS "notes_notes"');
-      expect(sql).toContain(
-        'CREATE INDEX IF NOT EXISTS "notes_notes_byAuthor" ON "notes_notes" ("author", "id")',
-      );
-      expect(sql).toContain("VALUES ('schema.notes', '2', 0)");
-
-      await result.execute();
-      await hotUpdater.api.notes.add("n1", "ada", "hello");
-      await expect(hotUpdater.api.notes.read("n1")).resolves.toMatchObject({
-        text: "hello",
-      });
-    } finally {
-      await kysely.destroy();
-      await db.close();
-    }
-  });
-
-  it("generates Drizzle and Prisma schemas with the plugin's tables", () => {
-    const generated = (
-      database: Parameters<typeof createHotUpdater>[0]["database"],
-    ) =>
-      generateSchema(
-        createHotUpdater({
-          database,
-          plugins: [notes],
-          clientAccess: "public",
-        }),
-        "latest",
-      ).code;
-
-    expect(
-      generated(drizzleAdapter({ db: {}, provider: "postgresql" })),
-    ).toContain('pgTable("notes_notes"');
-    expect(
-      generated(prismaAdapter({ prisma: {}, provider: "postgresql" })),
-    ).toContain("model notes_notes {");
-  });
-
-  it("checks a plugin's id and tables against core and the other plugins the server runs", () => {
-    const named = definePlugin({
-      id: "insights",
-      schemaVersion: "1",
-      schema: {
-        notes: defineTable({ id: { type: "string" } }, { key: ["id"] }),
-      },
-      init: () => ({ api: {} }),
-    });
-    const tabled = definePlugin({
-      id: "api",
-      schemaVersion: "1",
-      schema: {
-        keys: defineTable({ id: { type: "string" } }, { key: ["id"] }),
-      },
-      init: () => ({ api: {} }),
-    });
-    const unprefixed = definePlugin({
-      id: "shadowCore",
-      namespace: false,
-      schemaVersion: "1",
-      schema: {
-        channels: defineTable({ id: { type: "string" } }, { key: ["id"] }),
-      },
-      init: () => ({ api: {} }),
-    });
-    const start = (plugins: readonly AnyHotUpdaterPlugin[]) => () =>
-      createHotUpdater({
-        database: memoryDatabase(),
-        plugins,
-        ...(plugins.some(({ provides }) => provides?.clientAuth)
-          ? {}
-          : { clientAccess: "public" }),
-      } as Parameters<typeof createHotUpdater>[0]);
-
-    // Only the plugins a server runs get tables, so these fit on their own.
-    expect(start([named])).not.toThrow();
-    expect(start([tabled])).not.toThrow();
-    expect(start([named, insights()])).toThrow(
-      'Plugin "insights" is registered twice.',
-    );
-    expect(start([tabled, apiKeys()])).toThrow(
-      'apiKeys.api_keys: table "api_keys" is also declared by api.keys',
-    );
-    expect(start([unprefixed])).toThrow(
-      'shadowCore.channels: table "channels" is also declared by core.channels',
-    );
-  });
-});

package/src/db/releaseCatalog.ts

@@ -1,106 +0,0 @@
-import {
-  createReleaseCatalogScopeKey,
-  RELEASE_CATALOG_FALLBACK_POLICY,
-  RELEASE_CATALOG_SCHEMA_VERSION,
-  type ReleaseCatalog,
-} from "@hot-updater/core";
-import {
-  projectCompiledCatalog,
-  projectCompiledRollbackCatalog,
-  type CompiledReleaseCatalog,
-  type ReleaseCatalogRow,
-} from "@hot-updater/plugin-core";
-
-export type ReleaseCatalogRequest =
-  | {
-      readonly strategy: "APP_VERSION";
-      readonly platform: "ios" | "android";
-      readonly channelKey: string;
-      readonly appVersion: string;
-    }
-  | {
-      readonly strategy: "FINGERPRINT";
-      readonly platform: "ios" | "android";
-      readonly channelKey: string;
-      readonly fingerprintHash: string;
-    };
-
-/** A stored catalog payload, checked against its strategy's shape. */
-export const parseCompiledCatalog = (
-  payload: string,
-  strategy: ReleaseCatalogRequest["strategy"],
-): CompiledReleaseCatalog => {
-  const parsed: unknown = JSON.parse(payload);
-  if (
-    typeof parsed !== "object" ||
-    parsed === null ||
-    Reflect.get(parsed, "schemaVersion") !== RELEASE_CATALOG_SCHEMA_VERSION ||
-    Reflect.get(parsed, "strategy") !== strategy ||
-    Reflect.get(parsed, "fallbackPolicy") !== RELEASE_CATALOG_FALLBACK_POLICY ||
-    !Array.isArray(Reflect.get(parsed, "releaseDescriptors"))
-  ) {
-    throw new Error("Stored Release catalog payload is invalid");
-  }
-  if (
-    strategy === "APP_VERSION" &&
-    !Array.isArray(Reflect.get(parsed, "segments"))
-  ) {
-    throw new Error("Stored app-version Release catalog is invalid");
-  }
-  if (
-    strategy === "FINGERPRINT" &&
-    !Array.isArray(Reflect.get(parsed, "releaseIndexes"))
-  ) {
-    throw new Error("Stored fingerprint Release catalog is invalid");
-  }
-  return parsed as CompiledReleaseCatalog;
-};
-
-/** The scope key an update check reads. */
-export const releaseCatalogScopeKeyOf = (
-  input: ReleaseCatalogRequest,
-): string =>
-  input.strategy === "APP_VERSION"
-    ? createReleaseCatalogScopeKey({
-        channelKey: input.channelKey,
-        platform: input.platform,
-        strategy: "APP_VERSION",
-      })
-    : createReleaseCatalogScopeKey({
-        channelKey: input.channelKey,
-        fingerprintHash: input.fingerprintHash,
-        platform: input.platform,
-        strategy: "FINGERPRINT",
-      });
-
-/** Projects a stored catalog row for one update check; null when the row is not this scope's. */
-export const projectReleaseCatalogRow = (
-  row: ReleaseCatalogRow | null,
-  input: ReleaseCatalogRequest,
-  scopeKey = releaseCatalogScopeKeyOf(input),
-): ReleaseCatalog | null => {
-  if (
-    row === null ||
-    row.platform !== input.platform ||
-    row.strategy !== input.strategy ||
-    row.channel_key !== input.channelKey ||
-    row.scope_key !== scopeKey ||
-    row.fingerprint_hash !==
-      (input.strategy === "FINGERPRINT" ? input.fingerprintHash : null)
-  ) {
-    return null;
-  }
-  const compiled = parseCompiledCatalog(row.payload, input.strategy);
-  const appVersion =
-    input.strategy === "APP_VERSION" ? input.appVersion : undefined;
-  return {
-    catalogId: row.catalog_id,
-    catalogHash: row.catalog_hash,
-    fallbackPolicy: RELEASE_CATALOG_FALLBACK_POLICY,
-    generation: row.generation,
-    releases: projectCompiledCatalog(compiled, appVersion),
-    rollbackReleases: projectCompiledRollbackCatalog(compiled, appVersion),
-    schemaVersion: RELEASE_CATALOG_SCHEMA_VERSION,
-    scopeKey,
-  };
-};

package/src/db/schemaSettings.ts

@@ -1,104 +0,0 @@
-import type {
-  DatabaseAdapter,
-  PhysicalTable,
-  StoredRow,
-  WriteOp,
-} from "@hot-updater/plugin-core/internal";
-
-import {
-  ENGINE_SCHEMA_KEY,
-  ENGINE_SCHEMA_VERSION,
-  HotUpdaterSchemaMigrationRequiredError,
-  isMissingSchemaError,
-  readSettings,
-  SETTINGS_TABLE,
-  type SchemaSettings,
-} from "../database/fence";
-
-/** Refuses a database with `schema.core` but no `schema.engine`: it predates the engine. */
-const assertEngineDatabase = (
-  adapterName: string,
-  stored: ReadonlyMap<string, StoredRow | null>,
-) => {
-  if (stored.get("schema.core") && !stored.get(ENGINE_SCHEMA_KEY)) {
-    throw new HotUpdaterSchemaMigrationRequiredError(
-      adapterName,
-      String(stored.get("schema.core")!.value),
-      { key: ENGINE_SCHEMA_KEY, expected: ENGINE_SCHEMA_VERSION, found: null },
-    );
-  }
-};
-
-const storedSettings = async (
-  adapter: DatabaseAdapter,
-  keys: readonly string[],
-) => {
-  const rows = await readSettings(adapter, keys);
-  return new Map(keys.map((key, position) => [key, rows[position] ?? null]));
-};
-
-/** Writes the settings rows after every table exists, refusing a pre-engine database. */
-export const writeSchemaSettings = async (
-  adapter: DatabaseAdapter,
-  adapterName: string,
-  settings: SchemaSettings,
-): Promise<void> => {
-  const stored = await storedSettings(adapter, [
-    ...new Set(["schema.core", ENGINE_SCHEMA_KEY, ...Object.keys(settings)]),
-  ]);
-  assertEngineDatabase(adapterName, stored);
-  const ops = Object.entries(settings).flatMap(([key, value]): WriteOp[] => {
-    const row = stored.get(key);
-    if (row === null || row === undefined) {
-      return [
-        { type: "insert", table: SETTINGS_TABLE, row: { key, value, _v: 0 } },
-      ];
-    }
-    if (row.value === value) return [];
-    return [
-      {
-        type: "patch",
-        table: SETTINGS_TABLE,
-        key: [key],
-        set: { value },
-        guard: { v: Number(row._v) },
-        previous: row,
-      },
-    ];
-  });
-  if (ops.length === 0) return;
-  const result = await adapter.write(ops);
-  if (!result.ok) {
-    throw new Error(
-      "The schema settings changed during the migration; run it again.",
-    );
-  }
-};
-
-/**
- * Creates or updates every table, then writes the settings rows last. A
- * pre-engine database is refused before any table changes.
- */
-export const migrateSchema = async (
-  adapter: DatabaseAdapter,
-  adapterName: string,
-  tables: readonly PhysicalTable[],
-  settings: SchemaSettings,
-): Promise<void> => {
-  if (adapter.migrations === undefined) {
-    throw new Error(
-      `${adapterName} creates its tables with its own tooling; write only the settings rows.`,
-    );
-  }
-  // A database without the settings table is empty, so nothing is refused.
-  const stored = await storedSettings(adapter, [
-    "schema.core",
-    ENGINE_SCHEMA_KEY,
-  ]).catch((error: unknown) => {
-    if (!isMissingSchemaError(error)) throw error;
-    return new Map<string, StoredRow | null>();
-  });
-  assertEngineDatabase(adapterName, stored);
-  await adapter.migrations.apply([...tables, SETTINGS_TABLE]);
-  await writeSchemaSettings(adapter, adapterName, settings);
-};

package/src/db/settingsMigrator.spec.ts

@@ -1,65 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-
-import { describe, expect, it } from "vitest";
-
-import { checkSchemaFence, SETTINGS_TABLE } from "../database/fence";
-import { createSqlAdapter } from "../database/sql/sqlAdapter";
-import { createTableStatements } from "../database/sql/sqlSchema";
-import { sqliteExecutor } from "../database/sql/sqlTestExecutors";
-import { createSettingsMigrator } from "./settingsMigrator";
-
-const settings = { "schema.engine": "1", "schema.core": "1.0.0" };
-
-const migratorOver = (database: DatabaseSync) =>
-  createSettingsMigrator({
-    adapterName: "orm",
-    executor: sqliteExecutor(database),
-    settings,
-    applyTables: "the ORM's push",
-  });
-
-describe("the settings-only migrator", () => {
-  it("writes only the settings rows once the ORM applied the tables, then has nothing left", async () => {
-    const database = new DatabaseSync(":memory:");
-    database.exec(createTableStatements("sqlite", [SETTINGS_TABLE]).join(";"));
-    const migrator = migratorOver(database);
-
-    const pending = await migrator.migrateToLatest();
-    expect(pending.operations).toEqual([
-      expect.objectContaining({ type: "custom" }),
-    ]);
-    expect(pending.getSQL?.()).toContain("ON CONFLICT");
-    await pending.execute();
-    await expect(migrator.migrateToLatest()).resolves.toMatchObject({
-      operations: [],
-    });
-    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
-    await expect(
-      checkSchemaFence(
-        createSqlAdapter({ executor: sqliteExecutor(database) }),
-        "orm",
-        settings,
-      ),
-    ).resolves.toBeUndefined();
-  });
-
-  it("asks for the ORM's tables first, refuses a database from before the engine, and rethrows other failures", async () => {
-    await expect(
-      migratorOver(new DatabaseSync(":memory:")).migrateToLatest(),
-    ).rejects.toThrow("the ORM's push");
-
-    const legacy = new DatabaseSync(":memory:");
-    legacy.exec(
-      "CREATE TABLE private_hot_updater_settings (key TEXT PRIMARY KEY, value TEXT NOT NULL); INSERT INTO private_hot_updater_settings VALUES ('schema.core', '1.0.0');",
-    );
-    await expect(migratorOver(legacy).migrateToLatest()).rejects.toMatchObject({
-      setting: { key: "schema.engine", expected: "1", found: null },
-    });
-
-    const closed = new DatabaseSync(":memory:");
-    closed.close();
-    await expect(migratorOver(closed).migrateToLatest()).rejects.toThrow(
-      "database is not open",
-    );
-  });
-});

package/src/db/settingsMigrator.ts

@@ -1,152 +0,0 @@
-import { HOT_UPDATER_SCHEMA_VERSION } from "../core/schema";
-import {
-  ENGINE_SCHEMA_KEY,
-  ENGINE_SCHEMA_VERSION,
-  isMissingSchemaError,
-  SETTINGS_TABLE,
-  type SchemaSettings,
-} from "../database/fence";
-import { HotUpdaterSchemaMigrationRequiredError } from "../database/fence";
-import type { SqlExecutor } from "../database/sql/sqlAdapter";
-import { quoteSql } from "../database/sql/sqlSchema";
-import { settingsStatements } from "./engineSql";
-import {
-  assertSupportedMigrationMode,
-  getEmptyMigrationResult,
-} from "./fixedMigratorShared";
-import type { MigrateOptions, MigrationResult, Migrator } from "./types";
-
-/**
- * Every settings row by key and value alone, so a v0 layout reads too; null
- * when the settings table is missing.
- */
-export const readStoredSettings = async (
-  executor: SqlExecutor,
-  tablePrefix = "",
-): Promise<ReadonlyMap<string, unknown> | null> => {
-  const quote = (name: string) => quoteSql(executor.dialect, name);
-  try {
-    const { rows } = await executor.execute({
-      sql: `SELECT ${quote("key")}, ${quote("value")} FROM ${quote(tablePrefix + SETTINGS_TABLE.name)}`,
-      params: [],
-    });
-    return new Map(rows.map((row) => [String(row.key), row.value]));
-  } catch (error) {
-    if (!isMissingSchemaError(error)) throw error;
-    return null;
-  }
-};
-
-/** `schema.core`, or a v0 database's `version`. */
-export const storedSchemaVersion = (
-  stored: ReadonlyMap<string, unknown> | null,
-): string | undefined => {
-  const version = stored?.get("schema.core") ?? stored?.get("version");
-  return typeof version === "string" ? version : undefined;
-};
-
-/** A v0 or pre-engine database is recreated, never converted. */
-export const refusePreEngineDatabase = (
-  adapterName: string,
-  stored: ReadonlyMap<string, unknown>,
-): void => {
-  const version = storedSchemaVersion(stored);
-  if (version === undefined || stored.has(ENGINE_SCHEMA_KEY)) return;
-  throw new HotUpdaterSchemaMigrationRequiredError(
-    adapterName,
-    version,
-    stored.has("schema.core")
-      ? { key: ENGINE_SCHEMA_KEY, expected: ENGINE_SCHEMA_VERSION, found: null }
-      : undefined,
-  );
-};
-
-/**
- * `hot-updater db migrate` for an ORM that applies the DDL itself (Drizzle,
- * Prisma): it sets what the ORM cannot declare, writes the settings rows, and
- * refuses a v0 or pre-engine database.
- */
-export const createSettingsMigrator = (options: {
-  readonly adapterName: string;
-  readonly executor: SqlExecutor;
-  readonly settings: SchemaSettings;
-  /** How the ORM applies the tables, for the error when they are missing. */
-  readonly applyTables: string;
-  /** What the ORM cannot declare, set before the settings rows. */
-  readonly fixups?: {
-    readonly description: string;
-    readonly statements: readonly string[];
-  };
-}): Migrator => {
-  const read = () => readStoredSettings(options.executor);
-  const getVersion = async () => storedSchemaVersion(await read());
-
-  const makeResult = async (
-    migrate: MigrateOptions = {},
-  ): Promise<MigrationResult> => {
-    assertSupportedMigrationMode(migrate);
-    const stored = await read();
-    if (stored === null) {
-      throw new Error(
-        `${options.adapterName}: the Hot Updater tables are missing. Run \`hot-updater db generate\`, apply the schema with ${options.applyTables}, then migrate again.`,
-      );
-    }
-    refusePreEngineDatabase(options.adapterName, stored);
-    if (
-      migrate.updateSettings === false ||
-      Object.entries(options.settings).every(
-        ([key, value]) => stored.get(key) === value,
-      )
-    ) {
-      return getEmptyMigrationResult();
-    }
-    const fixups = options.fixups?.statements ?? [];
-    const statements = [
-      ...fixups,
-      ...settingsStatements(options.executor.dialect, options.settings),
-    ];
-    return {
-      operations: [
-        ...(fixups.length === 0
-          ? []
-          : [
-              {
-                type: "custom" as const,
-                description: options.fixups!.description,
-              },
-            ]),
-        {
-          type: "custom",
-          description: `Write the schema settings: ${Object.keys(options.settings).join(", ")}`,
-        },
-      ],
-      getSQL: () => statements.map((statement) => `${statement};`).join("\n\n"),
-      execute: async () => {
-        for (const sql of statements) {
-          await options.executor.execute({ sql, params: [] });
-        }
-      },
-    };
-  };
-
-  return {
-    getVersion,
-    getNameVariants: async () => undefined,
-    next: async () =>
-      (await getVersion()) === HOT_UPDATER_SCHEMA_VERSION
-        ? 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, migrate) => {
-      if (version !== HOT_UPDATER_SCHEMA_VERSION) {
-        throw new Error(`Invalid version ${version}`);
-      }
-      return makeResult(migrate);
-    },
-    migrateToLatest: makeResult,
-  };
-};