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

package/src/db/createBundleDiff.ts

@@ -1,364 +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,
-  BundleRepository,
-  StoragePluginWith,
-} from "@hot-updater/plugin-core";
-import {
-  createBundleStorageKey,
-  createDatabaseClient,
-  getManifestAssetDownloadPath,
-  resolveManifestAssetStorageUri,
-} from "@hot-updater/plugin-core";
-
-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 {
-  databasePlugin: BundleRepository;
-  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 database = createDatabaseClient(deps.databasePlugin);
-
-  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 = await database.getBundleById(baseBundleId);
-  const targetBundle = await database.getBundleById(bundleId);
-
-  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 database.updateBundleById(targetBundle.id, updatedBundle);
-
-  if (
-    previousPatch?.patchStorageUri &&
-    previousPatch.patchStorageUri !== patchUpload.storageUri
-  ) {
-    await deps.storagePlugin
-      .delete({ storageUri: previousPatch.patchStorageUri })
-      .catch(() => {
-        return;
-      });
-  }
-
-  return updatedBundle;
-}

package/src/db/databasePluginCore.spec.ts

@@ -1,62 +0,0 @@
-import { type DatabasePlugin } from "@hot-updater/plugin-core";
-import { describe, expect, it, vi } from "vitest";
-
-import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
-import { createDatabasePluginCore } from "./databasePluginCore";
-import {
-  currentBundle,
-  resolveFileUrl,
-} from "./databasePluginCore.testFixtures";
-
-describe("createDatabasePluginCore", () => {
-  it("runs the schema readiness guard before a low plugin operation", async () => {
-    const plugin: DatabasePlugin = createInMemoryDatabasePlugin();
-    const beforeOperation = vi.fn(async () => {});
-    const core = createDatabasePluginCore(plugin, resolveFileUrl, {
-      beforeOperation,
-    });
-
-    await core.api.getChannels();
-
-    expect(beforeOperation).toHaveBeenCalledOnce();
-  });
-
-  it("inserts an artifact without synthesizing a Release", async () => {
-    const plugin: DatabasePlugin = createInMemoryDatabasePlugin();
-    const core = createDatabasePluginCore(plugin, resolveFileUrl);
-
-    await core.api.insertBundle(currentBundle);
-
-    await expect(
-      core.api.getBundleById(currentBundle.id),
-    ).resolves.toMatchObject(currentBundle);
-    await expect(
-      plugin.models.releases.findMany({
-        bundleId: currentBundle.id,
-        limit: 10,
-      }),
-    ).resolves.toEqual([]);
-  });
-
-  it("updates an artifact without requiring or mutating a Release", async () => {
-    const plugin: DatabasePlugin = createInMemoryDatabasePlugin();
-    const core = createDatabasePluginCore(plugin, resolveFileUrl);
-    await core.api.insertBundle(currentBundle);
-    await core.api.updateBundleById(currentBundle.id, {
-      storageUri: `r2://bucket/bundles/${currentBundle.id}/updated.zip`,
-    });
-
-    await expect(
-      core.api.getBundleById(currentBundle.id),
-    ).resolves.toMatchObject({
-      id: currentBundle.id,
-      storageUri: `r2://bucket/bundles/${currentBundle.id}/updated.zip`,
-    });
-    await expect(
-      plugin.models.releases.findMany({
-        bundleId: currentBundle.id,
-        limit: 10,
-      }),
-    ).resolves.toEqual([]);
-  });
-});

package/src/db/databasePluginCore.testFixtures.ts

@@ -1,76 +0,0 @@
-import type { Bundle } from "@hot-updater/core";
-import {
-  createDatabaseClient,
-  type DatabasePlugin,
-} from "@hot-updater/plugin-core";
-
-export const currentBundle: Bundle = {
-  id: "00000000-0000-0000-0000-000000000001",
-  fileHash: "current-archive-hash",
-  gitCommitHash: null,
-  platform: "ios",
-  storageUri:
-    "r2://bucket/bundles/00000000-0000-0000-0000-000000000001/archive.zip",
-  archiveByteSize: 3_000_000_001,
-  manifestStorageUri:
-    "r2://bucket/bundles/00000000-0000-0000-0000-000000000001/manifest.json",
-  manifestFileHash: "sig:current-manifest",
-  assetBaseStorageUri: "r2://bucket/assets",
-};
-
-export const targetBundle: Bundle = {
-  ...currentBundle,
-  id: "00000000-0000-0000-0000-000000000002",
-  fileHash: "target-archive-hash",
-  storageUri:
-    "r2://bucket/bundles/00000000-0000-0000-0000-000000000002/archive.zip",
-  manifestStorageUri:
-    "r2://bucket/bundles/00000000-0000-0000-0000-000000000002/manifest.json",
-  manifestFileHash: "sig:target-manifest",
-  assetBaseStorageUri: "r2://bucket/assets",
-  patches: [
-    {
-      baseBundleId: currentBundle.id,
-      baseFileHash: "current-bundle-hash",
-      patchFileHash: "patch-hash",
-      patchStorageUri:
-        "r2://bucket/bundles/00000000-0000-0000-0000-000000000002/patches/00000000-0000-0000-0000-000000000001/index.ios.bundle.bsdiff",
-      byteSize: 3_000_000_002,
-    },
-  ],
-};
-
-export const resolveFileUrl = async (storageUri: string | null) => {
-  if (!storageUri) return null;
-  const url = new URL(storageUri);
-  return `https://assets.example.com/${url.host}${url.pathname}`;
-};
-
-export const seedBundles = async (plugin: DatabasePlugin): Promise<void> => {
-  const client = createDatabaseClient(plugin);
-  await client.insertBundle(currentBundle);
-  await client.insertBundle(targetBundle);
-};
-
-export const manifests = new Map<string, string>([
-  [
-    currentBundle.manifestStorageUri ?? "",
-    JSON.stringify({
-      bundleId: currentBundle.id,
-      assets: {
-        "index.ios.bundle": { fileHash: "current-bundle-hash" },
-        "shared.png": { fileHash: "shared-hash" },
-      },
-    }),
-  ],
-  [
-    targetBundle.manifestStorageUri ?? "",
-    JSON.stringify({
-      bundleId: targetBundle.id,
-      assets: {
-        "index.ios.bundle": { fileHash: "target-bundle-hash" },
-        "shared.png": { fileHash: "shared-hash" },
-      },
-    }),
-  ],
-]);

package/src/db/databasePluginCore.ts

@@ -1,185 +0,0 @@
-import type { Bundle } from "@hot-updater/core";
-import { decodeChannelKey } from "@hot-updater/core";
-import {
-  type ChannelRow,
-  createDatabaseClient,
-  deleteRelease as deleteReleasePolicy,
-  preflightReleasePolicy as preflightReleasePolicyMutation,
-  rebuildReleaseCatalog as rebuildReleaseCatalogProjection,
-  updateReleasePolicy as updateReleasePolicyMutation,
-} from "@hot-updater/plugin-core";
-
-import {
-  createArtifactResolver,
-  createReleaseCatalogReader,
-} from "./releaseCatalog";
-import type { DatabaseAPI, DatabasePlugin } from "./types";
-
-export function createDatabasePluginCore(
-  database: DatabasePlugin,
-  resolveFileUrl: (storageUri: string | null) => Promise<string | null>,
-  options?: {
-    beforeOperation?: () => Promise<void>;
-    readStorageText?: (storageUri: string) => Promise<string | null>;
-  },
-): {
-  api: DatabaseAPI;
-  adapterName: string;
-  createMigrator: () => never;
-  generateSchema: () => never;
-} {
-  const client = createDatabaseClient(database);
-  const beforeOperation = options?.beforeOperation;
-  const getReleaseCatalog = createReleaseCatalogReader(database);
-  const getArtifact = createArtifactResolver({
-    database,
-    readStorageText: options?.readStorageText,
-    resolveFileUrl,
-  });
-  const api: DatabaseAPI = {
-    async getBundleById(id: string): Promise<Bundle | null> {
-      await beforeOperation?.();
-      return client.getBundleById(id);
-    },
-
-    async getReleaseCatalog(input) {
-      await beforeOperation?.();
-      return getReleaseCatalog(input);
-    },
-
-    async getArtifactInfo(targetBundleId, currentBundleId) {
-      await beforeOperation?.();
-      return getArtifact(targetBundleId, currentBundleId);
-    },
-
-    async getReleaseById(id) {
-      await beforeOperation?.();
-      return database.models.releases.findById(id);
-    },
-
-    async getReleasesByScope(input) {
-      await beforeOperation?.();
-      return database.models.releases.findManyByScope({
-        ...input,
-        consistency: "strong",
-      });
-    },
-
-    async getReleases(input) {
-      await beforeOperation?.();
-      return database.models.releases.findMany(input);
-    },
-
-    async getReleaseCatalogByScopeKey(scopeKey) {
-      await beforeOperation?.();
-      return database.models.releaseCatalogs.findByScopeKey(scopeKey);
-    },
-
-    async getReleaseCatalogs(input) {
-      await beforeOperation?.();
-      return database.models.releaseCatalogs.findMany(input);
-    },
-
-    async updateReleasePolicy(input) {
-      await beforeOperation?.();
-      return updateReleasePolicyMutation({ database, ...input });
-    },
-
-    async preflightReleasePolicy(input) {
-      await beforeOperation?.();
-      return preflightReleasePolicyMutation({ database, ...input });
-    },
-
-    async deleteRelease(input) {
-      await beforeOperation?.();
-      return deleteReleasePolicy({ database, ...input });
-    },
-
-    async rebuildReleaseCatalog(scopeKey) {
-      await beforeOperation?.();
-      const catalog =
-        await database.models.releaseCatalogs.findByScopeKey(scopeKey);
-      if (catalog === null) {
-        throw new Error(`Release catalog "${scopeKey}" was not found.`);
-      }
-      return rebuildReleaseCatalogProjection({
-        database,
-        scope: {
-          channelId: catalog.channel_id,
-          channelName: decodeChannelKey(catalog.channel_key),
-          fingerprintHash: catalog.fingerprint_hash,
-          platform: catalog.platform,
-          scopeKey: catalog.scope_key,
-          strategy: catalog.strategy,
-        },
-      });
-    },
-
-    async commitDatabase(input) {
-      await beforeOperation?.();
-      return database.commit(input);
-    },
-
-    async getChannels(): Promise<readonly ChannelRow[]> {
-      await beforeOperation?.();
-      return client.getChannels();
-    },
-
-    async insertChannel(input) {
-      await beforeOperation?.();
-      return database.models.channels.insert(input);
-    },
-
-    async deleteChannel(input) {
-      await beforeOperation?.();
-      return database.models.channels.delete(input);
-    },
-
-    async getBundles(options) {
-      await beforeOperation?.();
-      return client.getBundles(options);
-    },
-
-    async insertBundle(bundle: Bundle): Promise<void> {
-      await beforeOperation?.();
-      await client.insertBundle(bundle);
-    },
-
-    async insertBundles(bundles: readonly Bundle[]): Promise<void> {
-      await beforeOperation?.();
-      await client.mutate(async (transaction) => {
-        for (const bundle of bundles) {
-          await transaction.insertBundle(bundle);
-        }
-      });
-    },
-
-    async updateBundleById(
-      bundleId: string,
-      update: Partial<Bundle>,
-    ): Promise<void> {
-      await beforeOperation?.();
-      await client.updateBundleById(bundleId, update);
-    },
-
-    async deleteBundleById(bundleId: string): Promise<void> {
-      await beforeOperation?.();
-      await client.deleteBundleById(bundleId);
-    },
-  };
-
-  return {
-    api,
-    adapterName: database.name,
-    createMigrator: () => {
-      throw new Error(
-        "createMigrator is only available for Kysely/MongoDB database plugins.",
-      );
-    },
-    generateSchema: () => {
-      throw new Error(
-        "generateSchema is only available for Drizzle/Prisma database plugins.",
-      );
-    },
-  };
-}