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

package/src/db/createBundleDiff.ts

@@ -1,6 +1,4 @@
-import crypto, { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
-import os from "node:os";
+import crypto from "node:crypto";
 import path from "node:path";
 import { promisify } from "node:util";
 import { brotliDecompress } from "node:zlib";
@@ -14,18 +12,27 @@ import {
 } from "@hot-updater/core";
 import type {
   Bundle,
-  DatabasePlugin,
-  NodeStoragePlugin,
+  BundleRepository,
+  StoragePluginWith,
 } from "@hot-updater/plugin-core";
 import {
   createBundleStorageKey,
+  createDatabaseClient,
   getManifestAssetDownloadPath,
   resolveManifestAssetStorageUri,
 } from "@hot-updater/plugin-core";
 
 type BundleManifest = {
   bundleId: string;
-  assets: Record<string, { fileHash: string; signature?: string }>;
+  assets: Record<
+    string,
+    {
+      downloadByteSize?: unknown;
+      downloadFileHash?: unknown;
+      fileHash: string;
+      signature?: string;
+    }
+  >;
 };
 
 export interface CreateBundleDiffInput {
@@ -34,8 +41,8 @@ export interface CreateBundleDiffInput {
 }
 
 export interface CreateBundleDiffDependencies {
-  databasePlugin: DatabasePlugin;
-  storagePlugin: NodeStoragePlugin | null;
+  databasePlugin: BundleRepository;
+  storagePlugin: StoragePluginWith<"get" | "put" | "delete"> | null;
 }
 
 export interface CreateBundleDiffOptions {
@@ -43,7 +50,6 @@ export interface CreateBundleDiffOptions {
 }
 
 const HBC_ASSET_PATH_RE = /\.bundle$/;
-const HOT_UPDATER_DOWNLOAD_DIR_PREFIX = "downloads-";
 const decompressBrotli = promisify(brotliDecompress);
 
 const isBundleManifest = (value: unknown): value is BundleManifest => {
@@ -101,41 +107,30 @@ async function downloadFromUrl(url: string) {
 
 async function downloadStorageBytes(
   storageUri: string,
-  storagePlugin: NodeStoragePlugin | null,
+  storagePlugin: StoragePluginWith<"get" | "put" | "delete"> | null,
 ) {
   const protocol = new URL(storageUri).protocol.replace(":", "");
 
-  if (protocol === "http" || protocol === "https") {
-    return downloadFromUrl(storageUri);
-  }
-
-  if (!storagePlugin) {
-    throw new Error("Storage plugin is not configured");
-  }
-
-  if (storagePlugin.supportedProtocol !== protocol) {
+  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 downloadRoot = path.join(process.cwd(), ".hot-updater");
-  await fs.mkdir(downloadRoot, { recursive: true });
-  const workDir = await fs.mkdtemp(
-    path.join(downloadRoot, HOT_UPDATER_DOWNLOAD_DIR_PREFIX),
-  );
-  const filename = path.basename(new URL(storageUri).pathname) || randomUUID();
-  const filePath = path.join(workDir, filename);
-
-  try {
-    await storagePlugin.profiles.node.downloadFile(storageUri, filePath);
-    return new Uint8Array(await fs.readFile(filePath));
-  } finally {
-    await fs.rm(workDir, { force: true, recursive: true });
+  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: NodeStoragePlugin | null,
+  storagePlugin: StoragePluginWith<"get" | "put" | "delete"> | null,
 ): Promise<BundleManifest> {
   const manifestStorageUri = getManifestStorageUri(bundle);
   if (!manifestStorageUri) {
@@ -147,9 +142,7 @@ async function fetchManifest(
     storagePlugin,
   );
 
-  const payload = JSON.parse(
-    new TextDecoder().decode(manifestBytes),
-  ) as unknown;
+  const payload: unknown = JSON.parse(new TextDecoder().decode(manifestBytes));
   if (!isBundleManifest(payload)) {
     throw new Error(`Invalid manifest payload for bundle ${bundle.id}`);
   }
@@ -178,7 +171,7 @@ async function fetchAssetBytes(
   bundle: Bundle,
   assetPath: string,
   manifest: BundleManifest,
-  storagePlugin: NodeStoragePlugin | null,
+  storagePlugin: StoragePluginWith<"get" | "put" | "delete"> | null,
 ) {
   const assetBaseStorageUri = getAssetBaseStorageUri(bundle);
   if (!assetBaseStorageUri) {
@@ -194,6 +187,7 @@ async function fetchAssetBytes(
     const compressedAssetStorageUri = resolveManifestAssetStorageUri({
       assetBaseStorageUri,
       assetPath: downloadPath,
+      downloadFileHash: asset.downloadFileHash,
       fileHash: asset.fileHash,
     });
 
@@ -203,8 +197,9 @@ async function fetchAssetBytes(
         compressedAssetStorageUri,
         storagePlugin,
       );
-    } catch {
-      // Older deployments stored manifest assets uncompressed.
+    } catch (error) {
+      if (!(error instanceof Error)) throw error;
+      compressedBytes = null;
     }
 
     if (compressedBytes) {
@@ -220,11 +215,6 @@ async function fetchAssetBytes(
   return downloadStorageBytes(assetStorageUri, storagePlugin);
 }
 
-async function getFileHash(filePath: string) {
-  const file = await fs.readFile(filePath);
-  return crypto.createHash("sha256").update(file).digest("hex");
-}
-
 function buildNextPatchState({
   currentBundle,
   nextPatch,
@@ -240,12 +230,8 @@ function buildNextPatchState({
   const orderedPatches = makePrimary
     ? [nextPatch, ...existingPatches]
     : [...existingPatches, nextPatch];
-  const primaryPatch = orderedPatches[0] ?? nextPatch;
 
-  return {
-    patches: orderedPatches,
-    primaryPatch,
-  };
+  return orderedPatches;
 }
 
 export async function createBundleDiff(
@@ -253,6 +239,8 @@ export async function createBundleDiff(
   deps: CreateBundleDiffDependencies,
   options: CreateBundleDiffOptions = {},
 ) {
+  const database = createDatabaseClient(deps.databasePlugin);
+
   if (!deps.storagePlugin) {
     throw new Error("Storage plugin is not configured");
   }
@@ -261,8 +249,8 @@ export async function createBundleDiff(
     throw new Error("Base bundle must be different from the target bundle");
   }
 
-  const baseBundle = await deps.databasePlugin.getBundleById(baseBundleId);
-  const targetBundle = await deps.databasePlugin.getBundleById(bundleId);
+  const baseBundle = await database.getBundleById(baseBundleId);
+  const targetBundle = await database.getBundleById(bundleId);
 
   if (!baseBundle || !targetBundle) {
     throw new Error("Bundle not found");
@@ -315,69 +303,62 @@ export async function createBundleDiff(
   ]);
 
   const patchBytes = await hdiff(baseBytes, targetBytes);
-  const workDir = await fs.mkdtemp(
-    path.join(os.tmpdir(), "hot-updater-console-bsdiff-"),
-  );
+  const patchFileHash = crypto
+    .createHash("sha256")
+    .update(patchBytes)
+    .digest("hex");
   const patchFilename = `${path.posix.basename(targetAssetPath)}.bsdiff`;
-  const patchPath = path.join(workDir, patchFilename);
   const previousPatch = getBundlePatch(targetBundle, baseBundle.id);
 
-  try {
-    await fs.writeFile(patchPath, patchBytes);
-
-    const uploadKey = createBundleStorageKey(
-      targetBundle.id,
-      "patches",
-      baseBundle.id,
-      getRelativeStorageDir(targetAssetPath),
-    );
-    const patchUpload = await deps.storagePlugin.profiles.node.upload(
-      uploadKey,
-      patchPath,
-    );
-    const patchFileHash = await getFileHash(patchPath);
-
-    const nextPatch = {
-      baseBundleId: baseBundle.id,
-      baseFileHash: baseAssetHash,
-      patchFileHash,
-      patchStorageUri: patchUpload.storageUri,
-    };
-    const nextState = buildNextPatchState({
-      currentBundle: targetBundle,
-      nextPatch,
-      makePrimary: options.makePrimary ?? true,
-    });
-
-    await deps.databasePlugin.updateBundle(targetBundle.id, {
-      patches: nextState.patches,
-      patchBaseBundleId: nextState.primaryPatch.baseBundleId,
-      patchBaseFileHash: nextState.primaryPatch.baseFileHash,
-      patchFileHash: nextState.primaryPatch.patchFileHash,
-      patchStorageUri: nextState.primaryPatch.patchStorageUri,
-    });
-    await deps.databasePlugin.commitBundle();
-
-    if (
-      previousPatch?.patchStorageUri &&
-      previousPatch.patchStorageUri !== patchUpload.storageUri
-    ) {
-      await deps.storagePlugin.profiles.node
-        .delete(previousPatch.patchStorageUri)
-        .catch(() => {
-          return;
-        });
-    }
+  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 updatedBundle = await deps.databasePlugin.getBundleById(
-      targetBundle.id,
-    );
-    if (!updatedBundle) {
-      throw new Error("Updated bundle not found");
-    }
+  const nextPatch = {
+    baseBundleId: baseBundle.id,
+    baseFileHash: baseAssetHash,
+    byteSize: patchBytes.byteLength,
+    patchFileHash,
+    patchStorageUri: patchUpload.storageUri,
+  };
+  const patches = buildNextPatchState({
+    currentBundle: targetBundle,
+    nextPatch,
+    makePrimary: options.makePrimary ?? true,
+  });
 
-    return updatedBundle;
-  } finally {
-    await fs.rm(workDir, { force: true, recursive: 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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,185 @@
+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.",
+      );
+    },
+  };
+}