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

package/src/db/types.ts

@@ -1,21 +1,23 @@
+import type { ArtifactInfo, Bundle } from "@hot-updater/core";
 import type {
-  AppUpdateAvailableInfo,
-  Bundle,
-  GetBundlesArgs,
-  UpdateInfo,
-} from "@hot-updater/core";
-import type {
-  DatabaseBundleQueryOptions,
-  DatabasePlugin,
-  HotUpdaterContext,
-  RuntimeStoragePlugin,
+  ChannelDeleteInput,
+  ChannelDeleteResult,
+  ChannelInsertInput,
+  ChannelInsertResult,
+  ChannelRow,
+  DatabaseCommit,
+  DatabaseCommitResult,
+  DatabasePlugin as DatabasePluginContract,
+  ReleaseCatalogMutationPreflight,
+  ReleaseCatalogMutationResult,
+  ReleaseCatalogRebuildResult,
+  ReleaseCatalogRow,
+  ReleasePolicyPatch,
+  ReleaseRow,
 } from "@hot-updater/plugin-core";
 
 import type { PaginatedResult } from "../types";
 
-export type DatabasePluginFactory<TContext = unknown> =
-  (() => DatabasePlugin<TContext>) & Partial<DatabaseAdapterCapabilities>;
-
 export const sqlProviders = [
   "sqlite",
   "cockroachdb",
@@ -45,6 +47,7 @@ export type MigrationOperation =
         columns: Record<string, { ormName: string; type: string }>;
       };
     }
+  | { type: "custom"; description: string }
   | { type: "custom"; sql: string }
   | { type: "custom"; key: string; value: unknown };
 
@@ -83,29 +86,66 @@ export interface DatabaseAdapterCapabilities {
   generateSchema?: SchemaGenerator;
 }
 
-export type DatabaseAdapterWithCapabilities<TContext = unknown> =
-  DatabasePlugin<TContext> & DatabaseAdapterCapabilities;
+export type DatabaseAdapterWithCapabilities = DatabasePluginContract &
+  DatabaseAdapterCapabilities;
 
-export type DatabaseAdapter<TContext = unknown> =
-  | DatabaseAdapterWithCapabilities<TContext>
-  | DatabasePlugin<TContext>
-  | DatabasePluginFactory<TContext>;
+export type DatabasePlugin = DatabaseAdapterWithCapabilities;
 
-export function isDatabasePluginFactory<TContext = unknown>(
-  adapter: DatabaseAdapter<TContext>,
-): adapter is DatabasePluginFactory<TContext> {
-  return typeof adapter === "function";
-}
-
-export function isDatabasePlugin<TContext = unknown>(
-  adapter: DatabaseAdapter<TContext>,
-): adapter is DatabasePlugin<TContext> {
+export function isDatabasePlugin(plugin: unknown): plugin is DatabasePlugin {
   return (
-    typeof adapter === "object" &&
-    adapter !== null &&
-    "getBundleById" in adapter &&
-    "getBundles" in adapter &&
-    "getChannels" in adapter
+    typeof plugin === "object" &&
+    plugin !== null &&
+    "name" in plugin &&
+    typeof plugin.name === "string" &&
+    "models" in plugin &&
+    typeof plugin.models === "object" &&
+    plugin.models !== null &&
+    "bundles" in plugin.models &&
+    typeof plugin.models.bundles === "object" &&
+    plugin.models.bundles !== null &&
+    "findById" in plugin.models.bundles &&
+    typeof plugin.models.bundles.findById === "function" &&
+    "findMany" in plugin.models.bundles &&
+    typeof plugin.models.bundles.findMany === "function" &&
+    "count" in plugin.models.bundles &&
+    typeof plugin.models.bundles.count === "function" &&
+    "bundlePatches" in plugin.models &&
+    typeof plugin.models.bundlePatches === "object" &&
+    plugin.models.bundlePatches !== null &&
+    "findByBundleIds" in plugin.models.bundlePatches &&
+    typeof plugin.models.bundlePatches.findByBundleIds === "function" &&
+    "channels" in plugin.models &&
+    typeof plugin.models.channels === "object" &&
+    plugin.models.channels !== null &&
+    "insert" in plugin.models.channels &&
+    typeof plugin.models.channels.insert === "function" &&
+    "list" in plugin.models.channels &&
+    typeof plugin.models.channels.list === "function" &&
+    "delete" in plugin.models.channels &&
+    typeof plugin.models.channels.delete === "function" &&
+    "analytics" in plugin.models &&
+    typeof plugin.models.analytics === "object" &&
+    plugin.models.analytics !== null &&
+    "append" in plugin.models.analytics &&
+    typeof plugin.models.analytics.append === "function" &&
+    "scan" in plugin.models.analytics &&
+    typeof plugin.models.analytics.scan === "function" &&
+    "apiKeys" in plugin.models &&
+    typeof plugin.models.apiKeys === "object" &&
+    plugin.models.apiKeys !== null &&
+    "create" in plugin.models.apiKeys &&
+    typeof plugin.models.apiKeys.create === "function" &&
+    "findByHash" in plugin.models.apiKeys &&
+    typeof plugin.models.apiKeys.findByHash === "function" &&
+    "list" in plugin.models.apiKeys &&
+    typeof plugin.models.apiKeys.list === "function" &&
+    "revoke" in plugin.models.apiKeys &&
+    typeof plugin.models.apiKeys.revoke === "function" &&
+    "commit" in plugin &&
+    typeof plugin.commit === "function" &&
+    (!("dispose" in plugin) ||
+      plugin.dispose === undefined ||
+      typeof plugin.dispose === "function")
   );
 }
 
@@ -121,38 +161,62 @@ export function getSQLProvider(
     : undefined;
 }
 
-export interface DatabaseAPI<TContext = unknown> {
-  getBundleById(
-    id: string,
-    context?: HotUpdaterContext<TContext>,
-  ): Promise<Bundle | null>;
-  getUpdateInfo(
-    args: GetBundlesArgs,
-    context?: HotUpdaterContext<TContext>,
-  ): Promise<UpdateInfo | null>;
-  getAppUpdateInfo(
-    args: GetBundlesArgs,
-    context?: HotUpdaterContext<TContext>,
-  ): Promise<AppUpdateAvailableInfo | null>;
-  getChannels(context?: HotUpdaterContext<TContext>): Promise<string[]>;
+export interface DatabaseAPI {
+  getBundleById(id: string): Promise<Bundle | null>;
+  getReleaseCatalog(
+    input: import("./releaseCatalog").ReleaseCatalogRequest,
+  ): Promise<import("@hot-updater/core").ReleaseCatalog | null>;
+  getArtifactInfo(
+    targetBundleId: string,
+    currentBundleId: string,
+  ): Promise<ArtifactInfo | null>;
+  getReleaseById(id: string): Promise<ReleaseRow | null>;
+  getReleasesByScope(input: {
+    readonly scopeKey: string;
+    readonly afterReleaseId?: string;
+    readonly limit: number;
+  }): Promise<readonly ReleaseRow[]>;
+  getReleases(input: {
+    readonly afterReleaseId?: string;
+    readonly beforeReleaseId?: string;
+    readonly bundleId?: string;
+    readonly channelId?: string;
+    readonly enabled?: boolean;
+    readonly platform?: "ios" | "android";
+    readonly targetAppVersion?: string;
+    readonly limit: number;
+  }): Promise<readonly ReleaseRow[]>;
+  getReleaseCatalogByScopeKey(
+    scopeKey: string,
+  ): Promise<ReleaseCatalogRow | null>;
+  getReleaseCatalogs(input: {
+    readonly afterScopeKey?: string;
+    readonly limit: number;
+  }): Promise<readonly ReleaseCatalogRow[]>;
+  updateReleasePolicy(input: {
+    readonly expectedRevision?: number;
+    readonly patch: ReleasePolicyPatch;
+    readonly releaseId: string;
+  }): Promise<ReleaseCatalogMutationResult>;
+  preflightReleasePolicy(input: {
+    readonly expectedRevision?: number;
+    readonly patch: ReleasePolicyPatch;
+    readonly releaseId: string;
+  }): Promise<ReleaseCatalogMutationPreflight>;
+  deleteRelease(input: {
+    readonly expectedRevision?: number;
+    readonly releaseId: string;
+  }): Promise<ReleaseCatalogMutationResult>;
+  rebuildReleaseCatalog(scopeKey: string): Promise<ReleaseCatalogRebuildResult>;
+  commitDatabase(input: DatabaseCommit): Promise<DatabaseCommitResult>;
+  getChannels(): Promise<readonly ChannelRow[]>;
+  insertChannel(input: ChannelInsertInput): Promise<ChannelInsertResult>;
+  deleteChannel(input: ChannelDeleteInput): Promise<ChannelDeleteResult>;
   getBundles(
-    options: DatabaseBundleQueryOptions,
-    context?: HotUpdaterContext<TContext>,
+    options: import("@hot-updater/plugin-core").DatabaseBundleQueryOptions,
   ): Promise<PaginatedResult>;
-  insertBundle(
-    bundle: Bundle,
-    context?: HotUpdaterContext<TContext>,
-  ): Promise<void>;
-  updateBundleById(
-    bundleId: string,
-    newBundle: Partial<Bundle>,
-    context?: HotUpdaterContext<TContext>,
-  ): Promise<void>;
-  deleteBundleById(
-    bundleId: string,
-    context?: HotUpdaterContext<TContext>,
-  ): Promise<void>;
+  insertBundle(bundle: Bundle): Promise<void>;
+  insertBundles(bundles: readonly Bundle[]): Promise<void>;
+  updateBundleById(bundleId: string, newBundle: Partial<Bundle>): Promise<void>;
+  deleteBundleById(bundleId: string): Promise<void>;
 }
-
-export type StoragePluginFactory<TContext = unknown> =
-  () => RuntimeStoragePlugin<TContext>;

package/src/db/updateArtifacts.spec.ts

@@ -0,0 +1,359 @@
+import { NIL_UUID, type Bundle } from "@hot-updater/core";
+import { createDatabaseClient } from "@hot-updater/plugin-core";
+import { describe, expect, it, vi } from "vitest";
+
+import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
+import { createArtifactResolver } from "./releaseCatalog";
+import { resolveManifestArtifacts } from "./updateArtifacts";
+
+type TestManifestAsset = {
+  downloadByteSize?: unknown;
+  downloadFileHash?: unknown;
+  fileHash: string;
+};
+
+const CURRENT_BUNDLE_ID = "00000000-0000-0000-0000-000000000101";
+const TARGET_BUNDLE_ID = "00000000-0000-0000-0000-000000000102";
+const CURRENT_MANIFEST_URI = `s3://test-bucket/bundles/${CURRENT_BUNDLE_ID}/manifest.json`;
+const TARGET_MANIFEST_URI = `s3://test-bucket/bundles/${TARGET_BUNDLE_ID}/manifest.json`;
+const PATCH_STORAGE_URI = `s3://test-bucket/bundles/${TARGET_BUNDLE_ID}/patches/${CURRENT_BUNDLE_ID}/patch.bsdiff`;
+const VALID_DOWNLOAD_FILE_HASH = "a".repeat(64);
+
+const getUtf8ByteSize = (value: string) =>
+  new TextEncoder().encode(value).byteLength;
+
+const createBundle = (
+  id: string,
+  archiveByteSize: number,
+  overrides: Partial<Bundle> = {},
+): Bundle => ({
+  archiveByteSize,
+  assetBaseStorageUri: "s3://test-bucket/assets",
+  fileHash: `${id}-archive-hash`,
+  gitCommitHash: null,
+  id,
+  manifestFileHash: `${id}-manifest-hash`,
+  manifestStorageUri:
+    id === CURRENT_BUNDLE_ID ? CURRENT_MANIFEST_URI : TARGET_MANIFEST_URI,
+  platform: "ios",
+  storageUri: `s3://test-bucket/bundles/${id}/bundle.zip`,
+  ...overrides,
+});
+
+async function runScenario({
+  archiveByteSize,
+  archiveUrlUsable = true,
+  assetPath = "index.ios.bundle",
+  patchByteSize,
+  resolveUrl,
+  targetAsset,
+  targetManifestSuffix = "",
+}: {
+  archiveByteSize: number | ((manifestByteSize: number) => number);
+  archiveUrlUsable?: boolean;
+  assetPath?: string;
+  patchByteSize?: unknown;
+  resolveUrl?: (storageUri: string) => Promise<string | null>;
+  targetAsset: TestManifestAsset;
+  targetManifestSuffix?: string;
+}) {
+  const currentManifestText = JSON.stringify({
+    assets: {
+      [assetPath]: {
+        fileHash: "current-file-hash",
+      },
+    },
+    bundleId: CURRENT_BUNDLE_ID,
+  });
+  const targetManifestText = `${JSON.stringify({
+    assets: {
+      [assetPath]: targetAsset,
+    },
+    bundleId: TARGET_BUNDLE_ID,
+  })}${targetManifestSuffix}`;
+  const manifestByteSize = getUtf8ByteSize(targetManifestText);
+  const resolvedArchiveByteSize =
+    typeof archiveByteSize === "function"
+      ? archiveByteSize(manifestByteSize)
+      : archiveByteSize;
+  const hasPatch = patchByteSize !== undefined;
+  const currentBundle = createBundle(CURRENT_BUNDLE_ID, 1_024);
+  const targetBundle = createBundle(
+    TARGET_BUNDLE_ID,
+    resolvedArchiveByteSize,
+    hasPatch
+      ? {
+          patches: [
+            {
+              baseBundleId: CURRENT_BUNDLE_ID,
+              baseFileHash: "current-file-hash",
+              byteSize: patchByteSize as number,
+              patchFileHash: "patch-file-hash",
+              patchStorageUri: PATCH_STORAGE_URI,
+            },
+          ],
+        }
+      : {},
+  );
+  const storageTexts = new Map([
+    [CURRENT_MANIFEST_URI, currentManifestText],
+    [TARGET_MANIFEST_URI, targetManifestText],
+  ]);
+  const resolveFileUrl = vi.fn(async (storageUri: string | null) => {
+    if (!storageUri) return null;
+    if (resolveUrl) return resolveUrl(storageUri);
+    return `https://download.example.com/${encodeURIComponent(storageUri)}`;
+  });
+
+  const result = await resolveManifestArtifacts({
+    archiveUrlUsable,
+    currentBundle,
+    readStorageText: async (storageUri) => storageTexts.get(storageUri) ?? null,
+    resolveFileUrl,
+    targetBundle,
+  });
+
+  return {
+    manifestByteSize,
+    resolveFileUrl,
+    result,
+  };
+}
+
+describe("resolveManifestArtifacts", () => {
+  it("uses raw UTF-8 manifest bytes and selects archive at equal size", async () => {
+    const { resolveFileUrl, result } = await runScenario({
+      archiveByteSize: (manifestByteSize) => manifestByteSize + 7,
+      assetPath: "assets/한글.png",
+      targetAsset: {
+        downloadByteSize: 7,
+        fileHash: "target-file-hash",
+      },
+      targetManifestSuffix: "\n",
+    });
+
+    expect(result).toBeNull();
+    expect(resolveFileUrl).not.toHaveBeenCalled();
+  });
+
+  it("accepts a valid download hash and size pair on a raw asset", async () => {
+    const { resolveFileUrl, result } = await runScenario({
+      archiveByteSize: (manifestByteSize) => manifestByteSize + 7,
+      assetPath: "assets/logo.png",
+      targetAsset: {
+        downloadByteSize: 7,
+        downloadFileHash: VALID_DOWNLOAD_FILE_HASH,
+        fileHash: "target-file-hash",
+      },
+    });
+
+    expect(result).toBeNull();
+    expect(resolveFileUrl).not.toHaveBeenCalled();
+  });
+
+  it("treats an invalid present hash on a raw asset as unknown cost", async () => {
+    const { resolveFileUrl, result } = await runScenario({
+      archiveByteSize: 1,
+      assetPath: "assets/logo.png",
+      targetAsset: {
+        downloadByteSize: 100,
+        downloadFileHash: "INVALID",
+        fileHash: "target-file-hash",
+      },
+    });
+
+    expect(result).not.toBeNull();
+    expect(resolveFileUrl).toHaveBeenCalledWith(
+      "s3://test-bucket/assets/sha256/ta/target-file-hash.png",
+    );
+  });
+
+  it.each([
+    ["missing", undefined],
+    ["invalid", "INVALID"],
+  ])(
+    "treats a Brotli asset as unknown cost when its download hash is %s",
+    async (_label, downloadFileHash) => {
+      const { resolveFileUrl, result } = await runScenario({
+        archiveByteSize: 1,
+        targetAsset: {
+          downloadByteSize: 100,
+          downloadFileHash,
+          fileHash: "target-file-hash",
+        },
+      });
+
+      expect(result).not.toBeNull();
+      expect(resolveFileUrl).toHaveBeenCalledWith(
+        "s3://test-bucket/assets/sha256/ta/target-file-hash.br",
+      );
+    },
+  );
+
+  it.each([
+    ["keeps", 9, true],
+    ["omits", 10, false],
+  ])(
+    "%s a %i-byte patch when the file is 10 bytes",
+    async (_action, patchByteSize, expectsPatch) => {
+      const { resolveFileUrl, result } = await runScenario({
+        archiveByteSize: (manifestByteSize) => manifestByteSize + 1_000,
+        patchByteSize,
+        targetAsset: {
+          downloadByteSize: 10,
+          downloadFileHash: VALID_DOWNLOAD_FILE_HASH,
+          fileHash: "target-file-hash",
+        },
+      });
+
+      expect(result?.changedAssets?.["index.ios.bundle"]?.patch).toEqual(
+        expectsPatch
+          ? expect.objectContaining({ patchUrl: expect.any(String) })
+          : undefined,
+      );
+      expect(resolveFileUrl).toHaveBeenCalledWith(
+        `s3://test-bucket/assets/sha256/aa/${VALID_DOWNLOAD_FILE_HASH}.br`,
+      );
+      expect(resolveFileUrl).toHaveBeenCalledWith(PATCH_STORAGE_URI);
+    },
+  );
+
+  it("keeps a larger patch when the file and archive URLs are unavailable", async () => {
+    const fileStorageUri = `s3://test-bucket/assets/sha256/aa/${VALID_DOWNLOAD_FILE_HASH}.br`;
+    const { result } = await runScenario({
+      archiveByteSize: 1,
+      archiveUrlUsable: false,
+      patchByteSize: 100,
+      resolveUrl: async (storageUri) =>
+        storageUri === fileStorageUri
+          ? null
+          : `https://download.example.com/${encodeURIComponent(storageUri)}`,
+      targetAsset: {
+        downloadByteSize: 50,
+        downloadFileHash: VALID_DOWNLOAD_FILE_HASH,
+        fileHash: "target-file-hash",
+      },
+    });
+
+    expect(result?.changedAssets?.["index.ios.bundle"]).toEqual({
+      fileHash: "target-file-hash",
+      patch: expect.objectContaining({
+        patchUrl: expect.any(String),
+      }),
+    });
+  });
+
+  it("recalculates from the file when an unknown-size patch URL is unavailable", async () => {
+    const { resolveFileUrl, result } = await runScenario({
+      archiveByteSize: (manifestByteSize) => manifestByteSize + 50,
+      patchByteSize: Number.NaN,
+      resolveUrl: async (storageUri) =>
+        storageUri === PATCH_STORAGE_URI
+          ? null
+          : `https://download.example.com/${encodeURIComponent(storageUri)}`,
+      targetAsset: {
+        downloadByteSize: 100,
+        downloadFileHash: VALID_DOWNLOAD_FILE_HASH,
+        fileHash: "target-file-hash",
+      },
+    });
+
+    expect(result).toBeNull();
+    expect(resolveFileUrl).toHaveBeenCalledWith(PATCH_STORAGE_URI);
+    expect(resolveFileUrl).toHaveBeenCalledWith(
+      `s3://test-bucket/assets/sha256/aa/${VALID_DOWNLOAD_FILE_HASH}.br`,
+    );
+  });
+
+  it("recalculates from a known patch when the file fallback cost is unknown", async () => {
+    const { result } = await runScenario({
+      archiveByteSize: (manifestByteSize) => manifestByteSize + 50,
+      patchByteSize: 100,
+      targetAsset: {
+        downloadByteSize: 100,
+        fileHash: "target-file-hash",
+      },
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it("keeps the manifest path when safe addition overflows", async () => {
+    const { result } = await runScenario({
+      archiveByteSize: 1,
+      assetPath: "assets/logo.png",
+      targetAsset: {
+        downloadByteSize: Number.MAX_SAFE_INTEGER,
+        fileHash: "target-file-hash",
+      },
+    });
+
+    expect(result).not.toBeNull();
+  });
+
+  it("keeps the manifest path when a byte size is invalid", async () => {
+    const { result } = await runScenario({
+      archiveByteSize: 1,
+      assetPath: "assets/logo.png",
+      targetAsset: {
+        downloadByteSize: -1,
+        fileHash: "target-file-hash",
+      },
+    });
+
+    expect(result).not.toBeNull();
+  });
+
+  it("does not select archive when its URL is unavailable", async () => {
+    const { result } = await runScenario({
+      archiveByteSize: 1,
+      archiveUrlUsable: false,
+      assetPath: "assets/logo.png",
+      targetAsset: {
+        downloadByteSize: 100,
+        fileHash: "target-file-hash",
+      },
+    });
+
+    expect(result).not.toBeNull();
+  });
+});
+
+describe("createArtifactResolver", () => {
+  it("returns usable manifest artifacts when the archive URL is null", async () => {
+    const databasePlugin = createInMemoryDatabasePlugin();
+    const database = createDatabaseClient(databasePlugin);
+    const targetManifestText = JSON.stringify({
+      assets: {
+        "assets/logo.png": {
+          downloadByteSize: 100,
+          fileHash: "target-file-hash",
+        },
+      },
+      bundleId: TARGET_BUNDLE_ID,
+    });
+    const targetBundle = createBundle(TARGET_BUNDLE_ID, 1);
+    await database.insertBundle(targetBundle);
+
+    const resolver = createArtifactResolver({
+      database: databasePlugin,
+      readStorageText: async (storageUri) =>
+        storageUri === TARGET_MANIFEST_URI ? targetManifestText : null,
+      resolveFileUrl: async (storageUri) =>
+        storageUri === targetBundle.storageUri
+          ? null
+          : `https://download.example.com/${encodeURIComponent(storageUri ?? "")}`,
+    });
+
+    await expect(resolver(TARGET_BUNDLE_ID, NIL_UUID)).resolves.toMatchObject({
+      changedAssets: {
+        "assets/logo.png": {
+          file: { url: expect.any(String) },
+          fileHash: "target-file-hash",
+        },
+      },
+      fileUrl: null,
+      manifestUrl: expect.any(String),
+    });
+  });
+});