@hot-updater/server 0.33.2 → 0.35.0

package/src/db/fixedMigrator.spec.ts

@@ -0,0 +1,89 @@
+import { PGlite } from "@electric-sql/pglite";
+import { Kysely } from "kysely";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { createKyselyMigrator } from "./fixedMigrator";
+
+interface SettingsDatabase {
+  readonly private_hot_updater_settings: {
+    readonly key: string;
+    readonly value: string;
+  };
+}
+
+describe("createKyselyMigrator", () => {
+  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();
+    }
+  });
+
+  it("includes the schema version row in fresh standalone SQL", async () => {
+    const db = new PGlite();
+    databases.push(db);
+    const kysely = new Kysely<SettingsDatabase>({
+      dialect: new PGliteDialect(db),
+    });
+    kyselyInstances.push(kysely);
+    const migrator = createKyselyMigrator({
+      db: kysely,
+      provider: "postgresql",
+    });
+
+    const migration = await migrator.migrateToLatest({
+      mode: "from-schema",
+      updateSettings: false,
+    });
+
+    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",
+        ),
+      }),
+    );
+  });
+
+  it("rejects unknown schema versions before writing settings", async () => {
+    const db = new PGlite();
+    databases.push(db);
+    const kysely = new Kysely<SettingsDatabase>({
+      dialect: new PGliteDialect(db),
+    });
+    kyselyInstances.push(kysely);
+    await db.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');
+    `);
+    const migrator = createKyselyMigrator({
+      db: kysely,
+      provider: "postgresql",
+    });
+
+    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'",
+    );
+    expect(version.rows[0]?.value).toBe("0.20.0");
+  });
+});

package/src/db/fixedMigrator.ts

@@ -0,0 +1,288 @@
+import type { Kysely } from "kysely";
+import type { MongoClient } from "mongodb";
+
+import {
+  HOT_UPDATER_SCHEMA_VERSION,
+  HOT_UPDATER_SETTINGS_TABLE,
+} from "../schema/types";
+import { createMongoMigrationOperations } from "./schema/mongodb";
+import {
+  hotUpdaterSchema,
+  schemaIndexAppliesToProvider,
+} from "./schema/registry";
+import { createTableSql } from "./schema/sql";
+import { createV029AlterSql, createV031AlterSql } from "./schema/sqlMigrations";
+import {
+  createSqlCreateOperations,
+  getSettingsInsertSql,
+} from "./schema/sqlOperations";
+import type {
+  MigrateOptions,
+  MigrationOperation,
+  MigrationResult,
+  Migrator,
+  ORMSQLProvider,
+  RelationMode,
+} from "./types";
+
+interface SettingsDatabase {
+  readonly private_hot_updater_settings: {
+    readonly key: string;
+    readonly value: string;
+  };
+}
+
+const getEmptyResult = (): MigrationResult => ({
+  operations: [],
+  execute: async () => {},
+  getSQL: () => "",
+});
+
+const assertSupportedMigrationMode = (options: MigrateOptions): void => {
+  if (options.mode === "from-database") {
+    throw new Error("Hot Updater migrations support only mode: 'from-schema'.");
+  }
+};
+
+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"))
+  );
+};
+
+const isMongoNamespaceExistsError = (error: unknown): boolean => {
+  if (!(error instanceof Error)) return false;
+  const mongoError = error as { code?: unknown; codeName?: unknown };
+  return mongoError.code === 48 || mongoError.codeName === "NamespaceExists";
+};
+
+const ignoreExistingCollection = (error: unknown): undefined => {
+  if (isMongoNamespaceExistsError(error)) {
+    return undefined;
+  }
+  throw error;
+};
+
+const toCustomOperations = (
+  statements: readonly string[],
+  settingsOperation?: MigrationOperation,
+): MigrationOperation[] => [
+  ...statements.map(
+    (statement): MigrationOperation => ({
+      type: "custom",
+      sql: statement,
+    }),
+  ),
+  ...(settingsOperation ? [settingsOperation] : []),
+];
+
+const assertSupportedSchemaVersion = (
+  currentVersion: string | undefined,
+): void => {
+  if (
+    currentVersion !== undefined &&
+    currentVersion !== "0.21.0" &&
+    currentVersion !== "0.29.0"
+  ) {
+    throw new Error(
+      `Unsupported Hot Updater schema version: ${currentVersion}`,
+    );
+  }
+};
+
+export const createKyselyMigrator = ({
+  db,
+  provider,
+  relationMode = "foreign-keys",
+}: {
+  db: Kysely<SettingsDatabase>;
+  provider: ORMSQLProvider;
+  relationMode?: RelationMode;
+}): Migrator => {
+  const getVersion = async (): Promise<string | undefined> => {
+    try {
+      const row = await db
+        .selectFrom(HOT_UPDATER_SETTINGS_TABLE)
+        .select("value")
+        .where("key", "=", "version")
+        .executeTakeFirst();
+      return typeof row?.value === "string" ? row.value : undefined;
+    } catch (error) {
+      if (!isMissingSettingsTableError(error)) throw error;
+      return undefined;
+    }
+  };
+
+  const makeResult = async (
+    options: MigrateOptions = {},
+  ): Promise<MigrationResult> => {
+    assertSupportedMigrationMode(options);
+
+    const currentVersion = await getVersion();
+    if (currentVersion === HOT_UPDATER_SCHEMA_VERSION) {
+      return getEmptyResult();
+    }
+    assertSupportedSchemaVersion(currentVersion);
+
+    const settingsStatement = getSettingsInsertSql(provider);
+    const settingsOperation =
+      options.updateSettings === false
+        ? undefined
+        : ({
+            type: "custom",
+            sql: settingsStatement,
+          } satisfies MigrationOperation);
+    const executableSettingsStatements =
+      options.updateSettings === false ? [] : [settingsStatement];
+    const statements =
+      currentVersion === undefined
+        ? [...createTableSql(provider, relationMode), settingsStatement]
+        : [
+            ...(currentVersion === "0.21.0"
+              ? createV029AlterSql(provider)
+              : []),
+            ...(currentVersion === "0.21.0" || currentVersion === "0.29.0"
+              ? createV031AlterSql(provider, relationMode)
+              : []),
+            ...executableSettingsStatements,
+          ];
+    const operations =
+      currentVersion === undefined
+        ? createSqlCreateOperations(provider, relationMode, settingsOperation)
+        : toCustomOperations(
+            [
+              ...(currentVersion === "0.21.0"
+                ? createV029AlterSql(provider)
+                : []),
+              ...(currentVersion === "0.21.0" || currentVersion === "0.29.0"
+                ? createV031AlterSql(provider, relationMode)
+                : []),
+            ],
+            settingsOperation,
+          );
+
+    return {
+      operations,
+      getSQL: () => statements.map((statement) => `${statement};`).join("\n\n"),
+      execute: async () => {
+        const { sql } = await import("kysely");
+        for (const statement of statements) {
+          await sql.raw(statement).execute(db);
+        }
+      },
+    };
+  };
+
+  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, options) => {
+      if (version !== HOT_UPDATER_SCHEMA_VERSION) {
+        throw new Error(`Invalid version ${version}`);
+      }
+      return makeResult(options);
+    },
+    migrateToLatest: makeResult,
+  };
+};
+
+export const createMongoMigrator = (client: MongoClient): Migrator => {
+  const settings = client
+    .db()
+    .collection<{ key: string; value: unknown }>(HOT_UPDATER_SETTINGS_TABLE);
+  const getVersion = async (): Promise<string | undefined> => {
+    const row = await settings.findOne({ key: "version" });
+    return typeof row?.value === "string" ? row.value : undefined;
+  };
+  const makeResult = async (
+    options: MigrateOptions = {},
+  ): Promise<MigrationResult> => {
+    assertSupportedMigrationMode(options);
+
+    if ((await getVersion()) === HOT_UPDATER_SCHEMA_VERSION) {
+      return getEmptyResult();
+    }
+    const settingsOperation =
+      options.updateSettings === false
+        ? undefined
+        : ({
+            type: "custom",
+            key: "version",
+            value: HOT_UPDATER_SCHEMA_VERSION,
+          } satisfies MigrationOperation);
+    return {
+      operations: createMongoMigrationOperations(settingsOperation),
+      execute: async () => {
+        const db = client.db();
+        for (const table of hotUpdaterSchema.tables) {
+          if (table.internal) continue;
+          await db
+            .createCollection(table.ormName)
+            .catch(ignoreExistingCollection);
+        }
+        await db.collection("bundles").createIndex(
+          { id: 1 },
+          {
+            name: "bundles_id_idx",
+          },
+        );
+        for (const table of hotUpdaterSchema.tables) {
+          if (table.internal) continue;
+          for (const index of (table.indexes ?? []).filter((item) =>
+            schemaIndexAppliesToProvider(item, "mongodb"),
+          )) {
+            await db
+              .collection(table.ormName)
+              .createIndex(
+                Object.fromEntries(index.columns.map((column) => [column, 1])),
+                { name: index.name },
+              );
+          }
+        }
+        if (options.updateSettings !== false) {
+          await settings.updateOne(
+            { key: "version" },
+            { $set: { value: HOT_UPDATER_SCHEMA_VERSION } },
+            { upsert: true },
+          );
+        }
+      },
+    };
+  };
+
+  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, options) => {
+      if (version !== HOT_UPDATER_SCHEMA_VERSION) {
+        throw new Error(`Invalid version ${version}`);
+      }
+      return makeResult(options);
+    },
+    migrateToLatest: makeResult,
+  };
+};

package/src/db/hotUpdaterSchema.ts

@@ -0,0 +1,6 @@
+export * from "../schema";
+export * from "./schema/mongodb";
+export * from "./schema/registry";
+export * from "./schema/sql";
+export * from "./schema/sqlMigrations";
+export * from "./schema/sqlOperations";