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

package/src/db/fixedMigrator.ts

@@ -1,49 +1,31 @@
-import type { Kysely } from "kysely";
-import type { MongoClient } from "mongodb";
+import { sql, type QueryExecutorProvider } from "kysely";
 
 import {
+  HOT_UPDATER_CORE_SCHEMA_KEY,
   HOT_UPDATER_SCHEMA_VERSION,
   HOT_UPDATER_SETTINGS_TABLE,
 } from "../schema/types";
-import { createMongoMigrationOperations } from "./schema/mongodb";
 import {
-  hotUpdaterSchema,
-  schemaIndexAppliesToProvider,
-} from "./schema/registry";
+  assertCurrentOrEmptySchemaVersion,
+  assertSupportedMigrationMode,
+  getEmptyMigrationResult,
+  inferLegacyCoreSchemaVersion,
+  isCurrentSchemaVersion,
+} from "./fixedMigratorShared";
 import { createTableSql } from "./schema/sql";
-import { createV029AlterSql, createV031AlterSql } from "./schema/sqlMigrations";
 import {
   createSqlCreateOperations,
   getSettingsInsertSql,
 } from "./schema/sqlOperations";
+import { executeMigrationStatements } from "./sqlMigrationExecution";
 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();
@@ -56,222 +38,97 @@ const isMissingSettingsTableError = (error: unknown): boolean => {
   );
 };
 
-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>;
+  db: QueryExecutorProvider;
   provider: ORMSQLProvider;
   relationMode?: RelationMode;
 }): Migrator => {
-  const getVersion = async (): Promise<string | undefined> => {
+  const getSetting = async (key: string): 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;
+      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 currentVersion = await getVersion();
-    if (currentVersion === HOT_UPDATER_SCHEMA_VERSION) {
-      return getEmptyResult();
+    const { coreVersion, legacyCoreVersion } = await getSchemaVersions();
+    if (isCurrentSchemaVersion(coreVersion)) {
+      return getEmptyMigrationResult();
     }
-    assertSupportedSchemaVersion(currentVersion);
+    assertCurrentOrEmptySchemaVersion(coreVersion ?? legacyCoreVersion);
 
     const settingsStatement = getSettingsInsertSql(provider);
     const settingsOperation =
       options.updateSettings === false
         ? undefined
-        : ({
-            type: "custom",
+        : {
+            type: "custom" as const,
             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,
-          );
+          };
+    const statements = [
+      ...createTableSql(provider, relationMode),
+      settingsStatement,
+    ];
 
     return {
-      operations,
+      operations: createSqlCreateOperations(
+        provider,
+        relationMode,
+        settingsOperation,
+      ),
       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);
-        }
-      },
+      execute: () => executeMigrationStatements({ db, provider, statements }),
     };
   };
 
   return {
     getVersion,
     getNameVariants: async () => undefined,
-    next: async () =>
-      (await getVersion()) === HOT_UPDATER_SCHEMA_VERSION
+    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.");
+        : { version: HOT_UPDATER_SCHEMA_VERSION };
     },
-    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 () => {
@@ -286,3 +143,5 @@ export const createMongoMigrator = (client: MongoClient): Migrator => {
     migrateToLatest: makeResult,
   };
 };
+
+export { createMongoMigrator } from "./fixedMigratorMongo";

package/src/db/fixedMigratorMongo.spec.ts

@@ -0,0 +1,192 @@
+import { MongoClient } from "mongodb";
+import { describe, expect, it, vi } from "vitest";
+
+import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
+import { createDatabasePluginCore } from "./databasePluginCore";
+import { createMongoMigrator } from "./fixedMigrator";
+import { createSchemaReadinessChecker } from "./schemaReadiness";
+
+function createSettingsMongoClient(
+  values: Readonly<Record<string, unknown>>,
+): MongoClient {
+  return {
+    db: () => ({
+      collection: () => ({
+        find: ({ key }: { readonly key: string }) => ({
+          limit: () => ({
+            toArray: async () => {
+              const value = values[key];
+              return value === undefined ? [] : [{ key, value }];
+            },
+          }),
+        }),
+        listIndexes: () => ({
+          toArray: async () => [{ key: { key: 1 }, unique: true }],
+        }),
+      }),
+    }),
+  } as unknown as MongoClient;
+}
+
+describe("MongoDB migration", () => {
+  it("creates schema 1.0.0 from an empty database", async () => {
+    const settings = new Map<string, unknown>();
+    const settingsCollection = {
+      find: ({ key }: { readonly key: string }) => ({
+        limit: () => ({
+          toArray: async () => {
+            const value = settings.get(key);
+            return value === undefined ? [] : [{ key, value }];
+          },
+        }),
+      }),
+      createIndex: vi.fn(async (): Promise<string> => "key_1"),
+      listIndexes: () => ({ toArray: async () => [] }),
+      updateOne: async (
+        { key }: { readonly key: string },
+        update: { readonly $set: { readonly value: unknown } },
+      ) => void settings.set(key, update.$set.value),
+    };
+    const modelCollection = {
+      find: () => ({ toArray: async () => [] }),
+      listIndexes: () => ({ toArray: async () => [] }),
+      createIndex: async () => "created",
+    };
+    const command = vi.fn(
+      async (_input: Record<string, unknown>): Promise<void> => undefined,
+    );
+    const database = {
+      command,
+      createCollection: async () => undefined,
+      collection: (name: string) =>
+        name === "private_hot_updater_settings"
+          ? settingsCollection
+          : modelCollection,
+    };
+    const client = { db: () => database } as unknown as MongoClient;
+
+    await (
+      await createMongoMigrator(client).migrateToLatest({
+        mode: "from-schema",
+        updateSettings: true,
+      })
+    ).execute();
+
+    expect(settingsCollection.createIndex).toHaveBeenCalledWith(
+      { key: 1 },
+      { unique: true },
+    );
+    expect(settings.get("schema.core")).toBe("1.0.0");
+    const commands = command.mock.calls.map(([input]) => input);
+    expect(commands.find(({ collMod }) => collMod === "bundles")).toMatchObject(
+      {
+        validationAction: "error",
+        validationLevel: "strict",
+        validator: {
+          $and: [
+            {
+              $jsonSchema: {
+                properties: {
+                  archive_byte_size: {
+                    bsonType: ["double", "int", "long"],
+                    maximum: Number.MAX_SAFE_INTEGER,
+                    minimum: 0,
+                  },
+                },
+                required: expect.arrayContaining(["archive_byte_size"]),
+              },
+            },
+            {
+              $expr: {
+                $eq: [{ $trunc: "$archive_byte_size" }, "$archive_byte_size"],
+              },
+            },
+          ],
+        },
+      },
+    );
+    expect(
+      commands.find(({ collMod }) => collMod === "bundle_patches"),
+    ).toMatchObject({
+      validationAction: "error",
+      validationLevel: "strict",
+      validator: {
+        $and: [
+          {
+            $jsonSchema: {
+              properties: {
+                byte_size: {
+                  bsonType: ["double", "int", "long"],
+                  maximum: Number.MAX_SAFE_INTEGER,
+                  minimum: 0,
+                },
+              },
+              required: expect.arrayContaining(["byte_size"]),
+            },
+          },
+          {
+            $expr: {
+              $and: expect.arrayContaining([
+                {
+                  $eq: [{ $trunc: "$byte_size" }, "$byte_size"],
+                },
+              ]),
+            },
+          },
+        ],
+      },
+    });
+  });
+
+  it("is a no-op when schema.core is already 1.0.0", async () => {
+    const client = createSettingsMongoClient({ "schema.core": "1.0.0" });
+    const migrator = createMongoMigrator(client);
+
+    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
+    await expect(
+      migrator.migrateToLatest({ mode: "from-schema" }),
+    ).resolves.toMatchObject({ operations: [] });
+  });
+
+  it("ignores a leftover version marker when schema.core is 1.0.0", async () => {
+    const client = createSettingsMongoClient({
+      "schema.core": "1.0.0",
+      version: "0.36.0",
+    });
+    const migrator = createMongoMigrator(client);
+
+    await expect(migrator.getVersion()).resolves.toBe("1.0.0");
+    await expect(
+      migrator.migrateToLatest({ mode: "from-schema" }),
+    ).resolves.toMatchObject({ operations: [] });
+  });
+
+  it("rejects in-place upgrade from a v0 schema marker", async () => {
+    const client = createSettingsMongoClient({ "schema.core": "0.38.0" });
+    const migrator = createMongoMigrator(client);
+
+    await expect(
+      migrator.migrateToLatest({ mode: "from-schema" }),
+    ).rejects.toThrow("Hot Updater v1 cannot migrate schema 0.38.0");
+  });
+
+  it("blocks v0 schema readiness before reading bundle data", async () => {
+    const client = createSettingsMongoClient({ version: "0.36.0" });
+    const migrator = createMongoMigrator(client);
+    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-mongodb",
+        () => 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();
+  });
+});