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

package/src/db/types.spec.ts

@@ -1,63 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
-import { isDatabasePlugin } from "./types";
-
-describe("isDatabasePlugin", () => {
-  it("accepts a direct fixed-model plugin object", () => {
-    const plugin = createInMemoryDatabasePlugin();
-
-    const result = isDatabasePlugin(plugin);
-
-    expect(result).toBe(true);
-  });
-
-  it("rejects a v1 factory and malformed required domains", () => {
-    const plugin = createInMemoryDatabasePlugin();
-    const factory = () => plugin;
-    const malformedBundles = {
-      ...plugin,
-      models: {
-        ...plugin.models,
-        bundles: { ...plugin.models.bundles, findMany: null },
-      },
-    };
-    const missingInsights = {
-      ...plugin,
-      models: { ...plugin.models, insights: undefined },
-    };
-    const malformedInsights = {
-      ...plugin,
-      models: {
-        ...plugin.models,
-        insights: { ...plugin.models.insights, listEvents: null },
-      },
-    };
-    const malformedChannels = {
-      ...plugin,
-      models: {
-        ...plugin.models,
-        channels: { ...plugin.models.channels, delete: null },
-      },
-    };
-    const malformedApiKeys = {
-      ...plugin,
-      models: {
-        ...plugin.models,
-        apiKeys: {
-          ...plugin.models.apiKeys,
-          revoke: null,
-        },
-      },
-    };
-    const malformedDispose = { ...plugin, dispose: null };
-
-    expect(isDatabasePlugin(factory)).toBe(false);
-    expect(isDatabasePlugin(malformedBundles)).toBe(false);
-    expect(isDatabasePlugin(missingInsights)).toBe(false);
-    expect(isDatabasePlugin(malformedInsights)).toBe(false);
-    expect(isDatabasePlugin(malformedChannels)).toBe(false);
-    expect(isDatabasePlugin(malformedApiKeys)).toBe(false);
-    expect(isDatabasePlugin(malformedDispose)).toBe(false);
-  });
-});

package/src/db/types.ts

@@ -1,228 +0,0 @@
-import type { ArtifactInfo, Bundle } from "@hot-updater/core";
-import type {
-  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 const sqlProviders = [
-  "sqlite",
-  "cockroachdb",
-  "mysql",
-  "postgresql",
-  "mssql",
-] as const;
-
-export const noSqlProviders = ["mongodb"] as const;
-export const providers = [...sqlProviders, ...noSqlProviders] as const;
-
-export type ORMProvider = (typeof providers)[number];
-export type ORMSQLProvider = (typeof sqlProviders)[number];
-export type RelationMode = "foreign-keys" | "fumadb";
-
-export interface MigrateOptions {
-  mode?: "from-schema" | "from-database";
-  updateSettings?: boolean;
-  unsafe?: boolean;
-}
-
-export type MigrationOperation =
-  | {
-      type: "create-table";
-      value: {
-        ormName: string;
-        columns: Record<string, { ormName: string; type: string }>;
-      };
-    }
-  | { type: "custom"; description: string }
-  | { type: "custom"; sql: string }
-  | { type: "custom"; key: string; value: unknown };
-
-export interface MigrationResult {
-  operations: MigrationOperation[];
-  execute: () => Promise<void>;
-  getSQL?: () => string;
-}
-
-export interface Migrator {
-  getVersion: () => Promise<string | undefined>;
-  getNameVariants: () => Promise<unknown>;
-  next: () => Promise<{ version: string } | undefined>;
-  previous: () => Promise<{ version: string } | undefined>;
-  up: (options?: MigrateOptions) => Promise<MigrationResult>;
-  down: (options?: MigrateOptions) => Promise<MigrationResult>;
-  migrateTo: (
-    version: string,
-    options?: MigrateOptions,
-  ) => Promise<MigrationResult>;
-  migrateToLatest: (options?: MigrateOptions) => Promise<MigrationResult>;
-}
-
-export type SchemaGenerator = (
-  version: string | "latest",
-  name?: string,
-) => {
-  code: string;
-  path: string;
-};
-
-export interface DatabaseAdapterCapabilities {
-  adapterName?: string;
-  provider?: ORMProvider;
-  createMigrator?: () => Migrator;
-  generateSchema?: SchemaGenerator;
-}
-
-export type DatabaseAdapterWithCapabilities = DatabasePluginContract &
-  DatabaseAdapterCapabilities;
-
-export type DatabasePlugin = DatabaseAdapterWithCapabilities;
-
-export function isDatabasePlugin(plugin: unknown): plugin is DatabasePlugin {
-  return (
-    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" &&
-    "insights" in plugin.models &&
-    typeof plugin.models.insights === "object" &&
-    plugin.models.insights !== null &&
-    "record" in plugin.models.insights &&
-    typeof plugin.models.insights.record === "function" &&
-    "listEvents" in plugin.models.insights &&
-    typeof plugin.models.insights.listEvents === "function" &&
-    "findInstallations" in plugin.models.insights &&
-    typeof plugin.models.insights.findInstallations === "function" &&
-    "countEvents" in plugin.models.insights &&
-    typeof plugin.models.insights.countEvents === "function" &&
-    "countInstallations" in plugin.models.insights &&
-    typeof plugin.models.insights.countInstallations === "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")
-  );
-}
-
-export function getSQLProvider(
-  provider: ORMProvider | undefined,
-): ORMSQLProvider | undefined {
-  if (!provider) {
-    return undefined;
-  }
-
-  return (sqlProviders as readonly string[]).includes(provider)
-    ? (provider as ORMSQLProvider)
-    : undefined;
-}
-
-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: import("@hot-updater/plugin-core").DatabaseBundleQueryOptions,
-  ): Promise<PaginatedResult>;
-  insertBundle(bundle: Bundle): Promise<void>;
-  insertBundles(bundles: readonly Bundle[]): Promise<void>;
-  updateBundleById(bundleId: string, newBundle: Partial<Bundle>): Promise<void>;
-  deleteBundleById(bundleId: string): Promise<void>;
-}

package/src/db/updateArtifacts.spec.ts

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