@hot-updater/server 0.33.1 → 0.34.0

package/src/db/bundleRows.ts

@@ -0,0 +1,140 @@
+import type { Bundle, BundlePatchArtifact, Platform } from "@hot-updater/core";
+import {
+  DEFAULT_ROLLOUT_COHORT_COUNT,
+  getAssetBaseStorageUri,
+  getBundlePatches,
+  getManifestFileHash,
+  getManifestStorageUri,
+  stripBundleArtifactMetadata,
+} from "@hot-updater/core";
+
+import { parseBundleMetadata } from "./updateArtifacts";
+
+export type BundleRow = {
+  readonly id: string;
+  readonly platform: string;
+  readonly should_force_update: unknown;
+  readonly enabled: unknown;
+  readonly file_hash: string;
+  readonly git_commit_hash: string | null;
+  readonly message: string | null;
+  readonly channel: string;
+  readonly storage_uri: string;
+  readonly target_app_version: string | null;
+  readonly fingerprint_hash: string | null;
+  readonly metadata?: unknown;
+  readonly manifest_storage_uri?: string | null;
+  readonly manifest_file_hash?: string | null;
+  readonly asset_base_storage_uri?: string | null;
+  readonly rollout_cohort_count?: number | null;
+  readonly target_cohorts?: unknown;
+};
+
+export type BundlePatchRow = {
+  readonly id: string;
+  readonly bundle_id: string;
+  readonly base_bundle_id: string;
+  readonly base_file_hash: string;
+  readonly patch_file_hash: string;
+  readonly patch_storage_uri: string;
+  readonly order_index?: number | null;
+};
+
+const parseTargetCohorts = (value: unknown): string[] | null => {
+  if (!value) return null;
+  if (Array.isArray(value)) {
+    return value.filter((item): item is string => typeof item === "string");
+  }
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return Array.isArray(parsed)
+      ? parsed.filter((item): item is string => typeof item === "string")
+      : null;
+  } catch {
+    return null;
+  }
+};
+
+const buildBundlePatchId = (bundleId: string, baseBundleId: string) =>
+  `${bundleId}:${baseBundleId}`;
+
+export const bundleToRow = (bundle: Bundle): BundleRow => ({
+  id: bundle.id,
+  platform: bundle.platform,
+  should_force_update: bundle.shouldForceUpdate,
+  enabled: bundle.enabled,
+  file_hash: bundle.fileHash,
+  git_commit_hash: bundle.gitCommitHash,
+  message: bundle.message,
+  channel: bundle.channel,
+  storage_uri: bundle.storageUri,
+  target_app_version: bundle.targetAppVersion,
+  fingerprint_hash: bundle.fingerprintHash,
+  metadata: stripBundleArtifactMetadata(bundle.metadata) ?? {},
+  manifest_storage_uri: getManifestStorageUri(bundle),
+  manifest_file_hash: getManifestFileHash(bundle),
+  asset_base_storage_uri: getAssetBaseStorageUri(bundle),
+  rollout_cohort_count:
+    bundle.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+  target_cohorts: bundle.targetCohorts ?? null,
+});
+
+export const bundleToPatchRows = (bundle: Bundle): BundlePatchRow[] =>
+  getBundlePatches(bundle).map((patch, index) => ({
+    id: buildBundlePatchId(bundle.id, patch.baseBundleId),
+    bundle_id: bundle.id,
+    base_bundle_id: patch.baseBundleId,
+    base_file_hash: patch.baseFileHash,
+    patch_file_hash: patch.patchFileHash,
+    patch_storage_uri: patch.patchStorageUri,
+    order_index: index,
+  }));
+
+const mapPatchRowToPatch = (record: BundlePatchRow): BundlePatchArtifact => ({
+  baseBundleId: record.base_bundle_id,
+  baseFileHash: record.base_file_hash,
+  patchFileHash: record.patch_file_hash,
+  patchStorageUri: record.patch_storage_uri,
+});
+
+export const rowToBundle = (
+  record: BundleRow,
+  patchRecords: readonly BundlePatchRow[] = [],
+): Bundle => {
+  const patches = patchRecords
+    .slice()
+    .sort(
+      (left, right) =>
+        (left.order_index ?? 0) - (right.order_index ?? 0) ||
+        left.base_bundle_id.localeCompare(right.base_bundle_id),
+    )
+    .map(mapPatchRowToPatch);
+  const primaryPatch = patches[0] ?? null;
+
+  return {
+    id: record.id,
+    platform: record.platform as Platform,
+    shouldForceUpdate: Boolean(record.should_force_update),
+    enabled: Boolean(record.enabled),
+    fileHash: record.file_hash,
+    gitCommitHash: record.git_commit_hash ?? null,
+    message: record.message ?? null,
+    channel: record.channel,
+    storageUri: record.storage_uri,
+    targetAppVersion: record.target_app_version ?? null,
+    fingerprintHash: record.fingerprint_hash ?? null,
+    metadata: parseBundleMetadata(record.metadata),
+    manifestStorageUri: record.manifest_storage_uri ?? null,
+    manifestFileHash: record.manifest_file_hash ?? null,
+    assetBaseStorageUri: record.asset_base_storage_uri ?? null,
+    patches,
+    patchBaseBundleId: primaryPatch?.baseBundleId ?? null,
+    patchBaseFileHash: primaryPatch?.baseFileHash ?? null,
+    patchFileHash: primaryPatch?.patchFileHash ?? null,
+    patchStorageUri: primaryPatch?.patchStorageUri ?? null,
+    rolloutCohortCount:
+      record.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+    targetCohorts: parseTargetCohorts(record.target_cohorts),
+  };
+};

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";