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

package/src/db/createBundleDiff.ts

@@ -1,370 +0,0 @@
-import crypto from "node:crypto";
-import path from "node:path";
-import { promisify } from "node:util";
-import { brotliDecompress } from "node:zlib";
-
-import { hdiff } from "@hot-updater/bsdiff";
-import {
-  getAssetBaseStorageUri,
-  getBundlePatch,
-  getBundlePatches,
-  getManifestStorageUri,
-} from "@hot-updater/core";
-import type {
-  Bundle,
-  ConfiguredDatabase,
-  StoragePluginWith,
-} from "@hot-updater/plugin-core";
-import {
-  createBundleStorageKey,
-  getManifestAssetDownloadPath,
-  resolveManifestAssetStorageUri,
-  rowToBundle,
-} from "@hot-updater/plugin-core";
-
-import { createDatabaseCoreApi } from "../core/api";
-
-type BundleManifest = {
-  bundleId: string;
-  assets: Record<
-    string,
-    {
-      downloadByteSize?: unknown;
-      downloadFileHash?: unknown;
-      fileHash: string;
-      signature?: string;
-    }
-  >;
-};
-
-export interface CreateBundleDiffInput {
-  baseBundleId: string;
-  bundleId: string;
-}
-
-export interface CreateBundleDiffDependencies {
-  /** The config's database: a provider's, or `standaloneRepository`. */
-  database: ConfiguredDatabase;
-  storagePlugin: StoragePluginWith<"get" | "put" | "delete"> | null;
-}
-
-export interface CreateBundleDiffOptions {
-  makePrimary?: boolean;
-}
-
-const HBC_ASSET_PATH_RE = /\.bundle$/;
-const decompressBrotli = promisify(brotliDecompress);
-
-const isBundleManifest = (value: unknown): value is BundleManifest => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-
-  const manifest = value as {
-    bundleId?: unknown;
-    assets?: unknown;
-  };
-
-  if (typeof manifest.bundleId !== "string") {
-    return false;
-  }
-
-  if (!manifest.assets || typeof manifest.assets !== "object") {
-    return false;
-  }
-
-  return Object.values(manifest.assets as Record<string, unknown>).every(
-    (asset) => {
-      if (!asset || typeof asset !== "object" || Array.isArray(asset)) {
-        return false;
-      }
-
-      const manifestAsset = asset as {
-        fileHash?: unknown;
-        signature?: unknown;
-      };
-
-      return (
-        typeof manifestAsset.fileHash === "string" &&
-        (manifestAsset.signature === undefined ||
-          typeof manifestAsset.signature === "string")
-      );
-    },
-  );
-};
-
-const getRelativeStorageDir = (relativePath: string) => {
-  const normalized = relativePath.replace(/\\/g, "/");
-  const dirname = path.posix.dirname(normalized);
-  return dirname === "." ? "" : dirname;
-};
-
-async function downloadFromUrl(url: string) {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to download storage object: ${response.status}`);
-  }
-
-  return new Uint8Array(await response.arrayBuffer());
-}
-
-async function downloadStorageBytes(
-  storageUri: string,
-  storagePlugin: StoragePluginWith<"get" | "put" | "delete"> | null,
-) {
-  const protocol = new URL(storageUri).protocol.replace(":", "");
-
-  if (!storagePlugin || storagePlugin.protocol !== protocol) {
-    if (protocol === "http" || protocol === "https") {
-      return downloadFromUrl(storageUri);
-    }
-    if (!storagePlugin) {
-      throw new Error("Storage plugin is not configured");
-    }
-    throw new Error(`No storage plugin for protocol: ${protocol}`);
-  }
-
-  const { response } = await storagePlugin.get({ storageUri });
-  if (response === null) {
-    throw new Error(`Storage object not found: ${storageUri}`);
-  }
-  return new Uint8Array(await response.arrayBuffer());
-}
-
-async function fetchManifest(
-  bundle: Bundle,
-  storagePlugin: StoragePluginWith<"get" | "put" | "delete"> | null,
-): Promise<BundleManifest> {
-  const manifestStorageUri = getManifestStorageUri(bundle);
-  if (!manifestStorageUri) {
-    throw new Error(`Bundle ${bundle.id} does not have manifest metadata`);
-  }
-
-  const manifestBytes = await downloadStorageBytes(
-    manifestStorageUri,
-    storagePlugin,
-  );
-
-  const payload: unknown = JSON.parse(new TextDecoder().decode(manifestBytes));
-  if (!isBundleManifest(payload)) {
-    throw new Error(`Invalid manifest payload for bundle ${bundle.id}`);
-  }
-
-  return payload;
-}
-
-function resolveHbcAssetPath(manifest: BundleManifest) {
-  const candidates = Object.keys(manifest.assets)
-    .sort((left, right) => left.localeCompare(right))
-    .filter((candidate) => HBC_ASSET_PATH_RE.test(candidate));
-
-  if (candidates.length === 0) {
-    throw new Error("No Hermes bundle asset found in manifest");
-  }
-  if (candidates.length > 1) {
-    throw new Error(
-      `Expected exactly one Hermes bundle asset in manifest, found ${candidates.length}: ${candidates.join(", ")}`,
-    );
-  }
-
-  return candidates[0];
-}
-
-async function fetchAssetBytes(
-  bundle: Bundle,
-  assetPath: string,
-  manifest: BundleManifest,
-  storagePlugin: StoragePluginWith<"get" | "put" | "delete"> | null,
-) {
-  const assetBaseStorageUri = getAssetBaseStorageUri(bundle);
-  if (!assetBaseStorageUri) {
-    throw new Error(`Bundle ${bundle.id} does not have asset storage metadata`);
-  }
-  const asset = manifest.assets[assetPath];
-  if (!asset) {
-    throw new Error(`Asset ${assetPath} is missing from manifest`);
-  }
-
-  const downloadPath = getManifestAssetDownloadPath(assetPath);
-  if (downloadPath !== assetPath) {
-    const compressedAssetStorageUri = resolveManifestAssetStorageUri({
-      assetBaseStorageUri,
-      assetPath: downloadPath,
-      downloadFileHash: asset.downloadFileHash,
-      fileHash: asset.fileHash,
-    });
-
-    let compressedBytes: Uint8Array | null = null;
-    try {
-      compressedBytes = await downloadStorageBytes(
-        compressedAssetStorageUri,
-        storagePlugin,
-      );
-    } catch (error) {
-      if (!(error instanceof Error)) throw error;
-      compressedBytes = null;
-    }
-
-    if (compressedBytes) {
-      return new Uint8Array(await decompressBrotli(compressedBytes));
-    }
-  }
-
-  const assetStorageUri = resolveManifestAssetStorageUri({
-    assetBaseStorageUri,
-    assetPath,
-    fileHash: asset.fileHash,
-  });
-  return downloadStorageBytes(assetStorageUri, storagePlugin);
-}
-
-function buildNextPatchState({
-  currentBundle,
-  nextPatch,
-  makePrimary,
-}: {
-  currentBundle: Bundle;
-  nextPatch: NonNullable<ReturnType<typeof getBundlePatch>>;
-  makePrimary: boolean;
-}) {
-  const existingPatches = getBundlePatches(currentBundle).filter(
-    (patch) => patch.baseBundleId !== nextPatch.baseBundleId,
-  );
-  const orderedPatches = makePrimary
-    ? [nextPatch, ...existingPatches]
-    : [...existingPatches, nextPatch];
-
-  return orderedPatches;
-}
-
-export async function createBundleDiff(
-  { baseBundleId, bundleId }: CreateBundleDiffInput,
-  deps: CreateBundleDiffDependencies,
-  options: CreateBundleDiffOptions = {},
-) {
-  const core = createDatabaseCoreApi(deps.database);
-
-  if (!deps.storagePlugin) {
-    throw new Error("Storage plugin is not configured");
-  }
-
-  if (baseBundleId === bundleId) {
-    throw new Error("Base bundle must be different from the target bundle");
-  }
-
-  const [baseBundle, targetBundle] = (
-    await Promise.all([core.getBundle(baseBundleId), core.getBundle(bundleId)])
-  ).map((detail) =>
-    detail === null ? null : rowToBundle(detail.bundle, detail.patches),
-  );
-
-  if (!baseBundle || !targetBundle) {
-    throw new Error("Bundle not found");
-  }
-
-  if (baseBundle.platform !== targetBundle.platform) {
-    throw new Error("Base bundle platform must match the target bundle");
-  }
-
-  if (baseBundle.id.localeCompare(targetBundle.id) >= 0) {
-    throw new Error("Base bundle must be older than the target bundle");
-  }
-
-  const [baseManifest, targetManifest] = await Promise.all([
-    fetchManifest(baseBundle, deps.storagePlugin),
-    fetchManifest(targetBundle, deps.storagePlugin),
-  ]);
-
-  const baseAssetPath = resolveHbcAssetPath(baseManifest);
-  const targetAssetPath = resolveHbcAssetPath(targetManifest);
-
-  if (baseAssetPath !== targetAssetPath) {
-    throw new Error("Base and target Hermes asset paths do not match");
-  }
-
-  const baseAssetHash = baseManifest.assets[baseAssetPath]?.fileHash;
-  const targetAssetHash = targetManifest.assets[targetAssetPath]?.fileHash;
-
-  if (!baseAssetHash || !targetAssetHash) {
-    throw new Error("Hermes asset hash is missing from manifest");
-  }
-
-  if (baseAssetHash === targetAssetHash) {
-    throw new Error("Hermes bundle is unchanged; no diff patch is required");
-  }
-
-  const [baseBytes, targetBytes] = await Promise.all([
-    fetchAssetBytes(
-      baseBundle,
-      baseAssetPath,
-      baseManifest,
-      deps.storagePlugin,
-    ),
-    fetchAssetBytes(
-      targetBundle,
-      targetAssetPath,
-      targetManifest,
-      deps.storagePlugin,
-    ),
-  ]);
-
-  const patchBytes = await hdiff(baseBytes, targetBytes);
-  const patchFileHash = crypto
-    .createHash("sha256")
-    .update(patchBytes)
-    .digest("hex");
-  const patchFilename = `${path.posix.basename(targetAssetPath)}.bsdiff`;
-  const previousPatch = getBundlePatch(targetBundle, baseBundle.id);
-
-  const uploadKey = createBundleStorageKey(
-    targetBundle.id,
-    "patches",
-    baseBundle.id,
-    patchFileHash,
-    getRelativeStorageDir(targetAssetPath),
-    patchFilename,
-  );
-  const patchUpload = await deps.storagePlugin.put({
-    key: uploadKey,
-    body: new ReadableStream<Uint8Array>({
-      start(controller) {
-        controller.enqueue(patchBytes);
-        controller.close();
-      },
-    }),
-    contentLength: patchBytes.byteLength,
-    contentType: "application/octet-stream",
-  });
-
-  const nextPatch = {
-    baseBundleId: baseBundle.id,
-    baseFileHash: baseAssetHash,
-    byteSize: patchBytes.byteLength,
-    patchFileHash,
-    patchStorageUri: patchUpload.storageUri,
-  };
-  const patches = buildNextPatchState({
-    currentBundle: targetBundle,
-    nextPatch,
-    makePrimary: options.makePrimary ?? true,
-  });
-
-  const updatedBundle: Bundle = {
-    ...targetBundle,
-    patches,
-  };
-  await core.updateBundle(targetBundle.id, { patches });
-
-  if (
-    previousPatch?.patchStorageUri &&
-    previousPatch.patchStorageUri !== patchUpload.storageUri
-  ) {
-    await deps.storagePlugin
-      .delete({ storageUri: previousPatch.patchStorageUri })
-      .catch(() => {
-        return;
-      });
-  }
-
-  return updatedBundle;
-}

package/src/db/engineDrizzleSchema.ts

@@ -1,72 +0,0 @@
-import { SETTINGS_TABLE } from "../database/fence";
-import type { ResolvedSchema } from "../database/resolveSchema";
-import {
-  sqlTableShapes,
-  type SqlDialect,
-  type SqlTableShape,
-} from "../database/sql/sqlSchema";
-
-const drizzle = {
-  postgresql: { module: "drizzle-orm/pg-core", table: "pgTable" },
-  mysql: { module: "drizzle-orm/mysql-core", table: "mysqlTable" },
-  sqlite: { module: "drizzle-orm/sqlite-core", table: "sqliteTable" },
-} as const;
-
-const literal = (value: string) => JSON.stringify(value);
-
-/**
- * The Drizzle schema `drizzle-kit` applies for the engine's tables: every
- * column typed exactly as the engine's DDL, keys, indexes, index tables, and
- * the settings table. The engine keeps references itself, so there are no
- * foreign keys. `hot-updater db migrate` then writes only the settings rows.
- */
-export const generateDrizzleEngineSchema = (
-  dialect: SqlDialect,
-  schema: ResolvedSchema,
-): string => {
-  const { module, table: tableFunction } = drizzle[dialect];
-  const tables = [...schema.tables, SETTINGS_TABLE];
-  const blocks: string[] = [];
-  const emit = (shape: SqlTableShape) => {
-    const columns = shape.columns.map(
-      (column) =>
-        `  ${literal(column.name)}: column(${literal(column.type)})(${literal(column.name)})${column.notNull ? ".notNull()" : ""}${column.default === undefined ? "" : `.default(${column.default})`},`,
-    );
-    const at = (name: string) => `table[${literal(name)}]`;
-    const extras = [
-      `primaryKey({ columns: [${shape.key.map(at).join(", ")}] })`,
-      ...shape.indexes.flatMap((index) =>
-        index.kind === "index"
-          ? [
-              `${index.unique ? "uniqueIndex" : "index"}(${literal(index.name)}).on(${index.columns.map(at).join(", ")})`,
-            ]
-          : [],
-      ),
-    ];
-    blocks.push(
-      `export const ${shape.name} = ${tableFunction}(${literal(shape.name)}, {\n${columns.join("\n")}\n}, (table) => [\n${extras.map((extra) => `  ${extra},`).join("\n")}\n]);`,
-    );
-    for (const index of shape.indexes) {
-      if (index.kind === "table") emit(index.table);
-    }
-  };
-  for (const shape of sqlTableShapes(dialect, tables)) emit(shape);
-  const used = ["customType", "index", "primaryKey", "uniqueIndex"]
-    .filter((name) =>
-      name === "customType"
-        ? true
-        : blocks.some((block) => block.includes(`${name}(`)),
-    )
-    .concat(tableFunction)
-    .sort();
-  return [
-    "// Generated by `hot-updater db generate` from Hot Updater's schema. Do not edit.",
-    `import { ${used.join(", ")} } from ${literal(module)};`,
-    "",
-    "/** A column typed exactly as Hot Updater's SQL schema declares it. */",
-    "const column = (type: string) =>",
-    "  customType<{ data: unknown; driverData: unknown }>({ dataType: () => type });",
-    "",
-    ...blocks.flatMap((block) => [block, ""]),
-  ].join("\n");
-};

package/src/db/engineMigrator.ts

@@ -1,105 +0,0 @@
-import type { DatabaseAdapter } from "@hot-updater/plugin-core/internal";
-
-import { HOT_UPDATER_SCHEMA_VERSION } from "../core/schema";
-import type { SchemaSettings } from "../database/fence";
-import type { ResolvedSchema } from "../database/resolveSchema";
-import {
-  assertSupportedMigrationMode,
-  getEmptyMigrationResult,
-} from "./fixedMigratorShared";
-import { migrateSchema } from "./schemaSettings";
-import {
-  refusePreEngineDatabase,
-  storedSchemaVersion,
-} from "./settingsMigrator";
-import type { MigrateOptions, MigrationResult, Migrator } from "./types";
-
-export interface EngineMigratorOptions {
-  readonly adapterName: string;
-  /** An adapter whose `migrations` create its tables and indexes. */
-  readonly adapter: DatabaseAdapter;
-  readonly schema: ResolvedSchema;
-  readonly settings: SchemaSettings;
-  /** Every settings row by key and value, whatever the layout, so an older database is recognized. */
-  readonly readSettings: () => Promise<ReadonlyMap<string, unknown>>;
-}
-
-/**
- * `hot-updater db migrate` for a store whose adapter creates its own tables
- * (MongoDB and the key-value stores): the tables and indexes, then the
- * settings rows, applied when a setting is missing or different, and refused
- * on a database from before the engine.
- */
-export const createEngineMigrator = (
-  options: EngineMigratorOptions,
-): Migrator => {
-  const getVersion = async () =>
-    storedSchemaVersion(await options.readSettings());
-
-  const makeResult = async (
-    migrate: MigrateOptions = {},
-  ): Promise<MigrationResult> => {
-    assertSupportedMigrationMode(migrate);
-    const stored = await options.readSettings();
-    refusePreEngineDatabase(options.adapterName, stored);
-    if (
-      Object.entries(options.settings).every(
-        ([key, value]) => stored.get(key) === value,
-      )
-    ) {
-      return getEmptyMigrationResult();
-    }
-    return {
-      operations: [
-        ...options.schema.tables.map((table) => ({
-          type: "create-table" as const,
-          value: {
-            ormName: table.name,
-            columns: Object.fromEntries(
-              table.columns.map((column) => [
-                column.name,
-                { ormName: column.name, type: column.type },
-              ]),
-            ),
-          },
-        })),
-        ...(migrate.updateSettings === false
-          ? []
-          : [
-              {
-                type: "custom" as const,
-                description: `Write the schema settings: ${Object.keys(options.settings).join(", ")}`,
-              },
-            ]),
-      ],
-      execute: () =>
-        migrateSchema(
-          options.adapter,
-          options.adapterName,
-          options.schema.tables,
-          options.settings,
-        ),
-    };
-  };
-
-  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,
-  };
-};

package/src/db/enginePrismaSchema.ts

@@ -1,147 +0,0 @@
-import { SETTINGS_TABLE } from "../database/fence";
-import type { ResolvedSchema } from "../database/resolveSchema";
-import {
-  quoteSql,
-  sqlTableShapes,
-  type SqlColumnShape,
-  type SqlTableShape,
-} from "../database/sql/sqlSchema";
-
-export type PrismaProvider = "postgresql" | "mysql" | "sqlite";
-
-interface PrismaColumn {
-  readonly scalar: string;
-  /** The native type attribute, such as `@db.VarChar(64)`. */
-  readonly native?: string;
-  /** Whether `db migrate` sets the column's collation, which Prisma cannot declare. */
-  readonly collate?: true;
-}
-
-const SCALARS: Readonly<Record<string, string>> = {
-  TEXT: "String",
-  INTEGER: "BigInt",
-  REAL: "Float",
-  bigint: "BigInt",
-  "double precision": "Float",
-  double: "Float",
-  boolean: "Boolean",
-  jsonb: "Json",
-  json: "Json",
-};
-
-/**
- * A column's Prisma type from the DDL type the shared SQL schema gives it.
- * MySQL's ASCII keys become `VarBinary`: the same bytes and order as
- * `ascii_bin`, within InnoDB's key limit without a character set.
- */
-const prismaColumn = (
-  provider: PrismaProvider,
-  { type }: SqlColumnShape,
-): PrismaColumn => {
-  const length = /^varchar\((\d+)\)/u.exec(type)?.[1];
-  if (provider === "mysql" && type.includes("CHARACTER SET")) {
-    if (type.includes("CHARACTER SET ascii") && length) {
-      return { scalar: "Bytes", native: `@db.VarBinary(${length})` };
-    }
-    return {
-      scalar: "String",
-      native: length ? `@db.VarChar(${length})` : "@db.LongText",
-      collate: true,
-    };
-  }
-  if (provider === "postgresql" && type.includes("COLLATE")) {
-    return {
-      scalar: "String",
-      ...(length ? { native: `@db.VarChar(${length})` } : {}),
-      collate: true,
-    };
-  }
-  return { scalar: SCALARS[type] ?? "String" };
-};
-
-/** Prisma fields start with a letter: `_v` becomes `hu_v`, mapped back to `_v`. */
-const fieldName = (column: string) =>
-  column.startsWith("_") ? `hu${column}` : column;
-
-const list = (columns: readonly string[]) =>
-  `[${columns.map(fieldName).join(", ")}]`;
-
-const flatten = (shapes: readonly SqlTableShape[]): SqlTableShape[] =>
-  shapes.flatMap((shape) => [
-    shape,
-    ...flatten(
-      shape.indexes.flatMap((index) =>
-        index.kind === "table" ? [index.table] : [],
-      ),
-    ),
-  ]);
-
-const shapesOf = (provider: PrismaProvider, schema: ResolvedSchema) =>
-  flatten(sqlTableShapes(provider, [...schema.tables, SETTINGS_TABLE]));
-
-const renderField = (provider: PrismaProvider, column: SqlColumnShape) => {
-  const { scalar, native } = prismaColumn(provider, column);
-  const name = fieldName(column.name);
-  return [
-    `${name} ${scalar}${column.notNull ? "" : "?"}`,
-    ...(native === undefined ? [] : [native]),
-    ...(column.default === undefined ? [] : [`@default(${column.default})`]),
-    ...(name === column.name ? [] : [`@map(${JSON.stringify(column.name)})`]),
-  ].join(" ");
-};
-
-/**
- * Hot Updater's tables as Prisma models, for `prisma db push` or
- * `prisma migrate`: keys, indexes, index tables, and the settings table.
- * The engine keeps references itself, so the models have no relations.
- */
-export const generatePrismaEngineSchema = (
-  provider: PrismaProvider,
-  schema: ResolvedSchema,
-): string =>
-  shapesOf(provider, schema)
-    .map((shape) => {
-      const lines = [
-        ...shape.columns.map((column) => renderField(provider, column)),
-        `@@id(${list(shape.key)})`,
-        ...shape.indexes.flatMap((index) =>
-          index.kind === "index"
-            ? [
-                `@@${index.unique ? "unique" : "index"}(${list(index.columns)}, map: ${JSON.stringify(index.name)})`,
-              ]
-            : [],
-        ),
-      ];
-      return `model ${shape.name} {\n${lines.map((line) => `  ${line}`).join("\n")}\n}`;
-    })
-    .join("\n\n");
-
-/**
- * The collations Prisma cannot declare, which `hot-updater db migrate` sets
- * after Prisma created the tables: `COLLATE "C"` on PostgreSQL and binary
- * UTF-8 on MySQL, so strings compare by their bytes as the engine expects.
- * The settings table is only read by key, and the migrator has already read
- * it: altering it would invalidate PostgreSQL's cached plan for that read.
- */
-export const prismaCollationStatements = (
-  provider: PrismaProvider,
-  schema: ResolvedSchema,
-): string[] => {
-  if (provider !== "postgresql" && provider !== "mysql") return [];
-  const quote = (name: string) => quoteSql(provider, name);
-  const tables = shapesOf(provider, schema).filter(
-    (shape) => shape.name !== SETTINGS_TABLE.name,
-  );
-  return tables.flatMap((shape) => {
-    const changes = shape.columns
-      .filter((column) => prismaColumn(provider, column).collate)
-      .map((column) =>
-        provider === "postgresql"
-          ? `ALTER COLUMN ${quote(column.name)} TYPE ${column.type}`
-          : `MODIFY ${quote(column.name)} ${column.type}${column.notNull ? " NOT NULL" : " NULL"}`,
-      );
-    return changes.length === 0
-      ? []
-      : [`ALTER TABLE ${quote(shape.name)} ${changes.join(", ")}`];
-  });
-};