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

package/src/releaseCatalogRoutes.integration.spec.ts

@@ -1,238 +0,0 @@
-import { encodeChannelKey } from "@hot-updater/core";
-import { commitReleaseCatalogMutation } from "@hot-updater/plugin-core";
-import { describe, expect, it, vi } from "vitest";
-
-import { createInMemoryDatabasePlugin } from "../../test-utils/test/inMemoryDatabasePlugin";
-import { registerApiKey } from "./apiKeys";
-import { createHotUpdater } from "./index";
-
-const API_KEY = "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE";
-
-const channelKey = encodeChannelKey("production");
-const scopeKey = `v1:app-version:ios:${channelKey}`;
-
-const createCatalogDatabase = async () => {
-  const database = createInMemoryDatabasePlugin();
-  const channel = { id: "channel-production", name: "production" };
-  await database.models.channels.insert({
-    onConflict: "returnExisting",
-    row: channel,
-  });
-  const bundleId = "00000000-0000-7001-8000-000000000001";
-  await database.commit({
-    changes: [
-      {
-        model: "bundles",
-        operation: "insert",
-        row: {
-          asset_base_storage_uri: null,
-          archive_byte_size: 3_000_000_001,
-          file_hash: "bundle-hash",
-          git_commit_hash: null,
-          id: bundleId,
-          manifest_file_hash: null,
-          manifest_storage_uri: null,
-          metadata: {},
-          platform: "ios",
-          storage_uri: "storage://bundle.zip",
-        },
-      },
-    ],
-  });
-  await commitReleaseCatalogMutation({
-    database,
-    mutation: {
-      operation: "insert",
-      row: {
-        bundle_id: bundleId,
-        channel_id: channel.id,
-        created_at_ms: 1,
-        enabled: true,
-        fingerprint_hash: null,
-        id: "00000000-0000-7000-8000-000000000001",
-        kind: "BUNDLE",
-        message: "Stable Release",
-        operation: "DEPLOY",
-        platform: "ios",
-        revision: 1,
-        rollout_cohort_count: 1000,
-        scope_key: scopeKey,
-        should_force_update: false,
-        source_release_id: null,
-        strategy: "APP_VERSION",
-        target_app_version: ">=1.0.0 <2.0.0",
-        target_cohorts: [],
-        updated_at_ms: 1,
-      },
-    },
-    scope: {
-      channelId: channel.id,
-      channelName: channel.name,
-      fingerprintHash: null,
-      platform: "ios",
-      scopeKey,
-      strategy: "APP_VERSION",
-    },
-    updatedAtMs: 1,
-  });
-  return database;
-};
-
-describe("Release catalog routes", () => {
-  it("serves persisted Catalog identity without configuration and keeps it across server restarts", async () => {
-    const database = await createCatalogDatabase();
-    const storedCatalog =
-      await database.models.releaseCatalogs.findByScopeKey(scopeKey);
-    const hotUpdater = createHotUpdater({
-      database,
-      clientAccess: { type: "public" },
-    });
-    const catalogRead = vi.spyOn(
-      database.models.releaseCatalogs,
-      "findByScopeKey",
-    );
-    const url =
-      `https://updates.example.com/release-catalogs/app-version/` +
-      `ios/${channelKey}/1.5.0`;
-
-    const response = await hotUpdater.handlers.client(new Request(url));
-    expect(response.status).toBe(200);
-    expect(response.headers.get("cache-control")).toBe(
-      "public, max-age=0, s-maxage=5",
-    );
-    expect(response.headers.get("content-type")).toBe(
-      "application/vnd.hot-updater.release-catalog+json; version=1",
-    );
-    const body = await response.json();
-    expect(body).toMatchObject({
-      catalogId: storedCatalog!.catalog_id,
-      fallbackPolicy: "BUILTIN_IF_ACTIVE_INELIGIBLE",
-      generation: 1,
-      releases: [
-        {
-          bundleId: "00000000-0000-7001-8000-000000000001",
-          kind: "BUNDLE",
-          message: "Stable Release",
-          shouldForceUpdate: false,
-        },
-      ],
-      rollbackReleases: [
-        {
-          bundleId: "00000000-0000-7001-8000-000000000001",
-          kind: "BUNDLE",
-        },
-      ],
-      scopeKey,
-    });
-
-    const etag = response.headers.get("etag");
-    expect(etag).toMatch(/^"sha256:[0-9a-f]{64}"$/);
-    const revalidated = await hotUpdater.handlers.client(
-      new Request(url, { headers: { "if-none-match": etag! } }),
-    );
-    expect(revalidated.status).toBe(304);
-    expect(await revalidated.text()).toBe("");
-    expect(catalogRead).toHaveBeenCalledOnce();
-
-    const nonCanonicalVersion = await hotUpdater.handlers.client(
-      new Request(url.replace("/1.5.0", "/v1.5")),
-    );
-    expect(nonCanonicalVersion.status).toBe(400);
-    expect(nonCanonicalVersion.headers.get("cache-control")).toBe(
-      "private, no-store",
-    );
-    expect(catalogRead).toHaveBeenCalledOnce();
-
-    const invalidPlatform = await hotUpdater.handlers.client(
-      new Request(url.replace("/ios/", "/windows/")),
-    );
-    expect(invalidPlatform.status).toBe(400);
-    expect(catalogRead).toHaveBeenCalledOnce();
-
-    const otherChannel = await hotUpdater.handlers.client(
-      new Request(
-        url.replace(`/${channelKey}/`, `/${encodeChannelKey("beta")}/`),
-      ),
-    );
-    expect(otherChannel.status).toBe(404);
-    expect(catalogRead).toHaveBeenCalledTimes(2);
-
-    const legacyAuthorityPath = await hotUpdater.handlers.client(
-      new Request(
-        `https://updates.example.com/release-catalogs/app-version/` +
-          `old-authority/ios/${channelKey}/1.5.0`,
-      ),
-    );
-    expect(legacyAuthorityPath.status).toBe(404);
-    expect(legacyAuthorityPath.headers.get("cache-control")).toBe(
-      "private, no-store",
-    );
-    expect(catalogRead).toHaveBeenCalledTimes(2);
-    const commit = vi.spyOn(database, "commit");
-    const restarted = createHotUpdater({
-      database,
-      clientAccess: { type: "public" },
-    });
-    const relocated = await restarted.handlers.client(
-      new Request(url.replace("updates.example.com", "new.example.com")),
-    );
-    expect(await relocated.json()).toEqual(body);
-    expect(commit).not.toHaveBeenCalled();
-  });
-
-  it("singleflights concurrent cold requests into one exact catalog read", async () => {
-    const database = await createCatalogDatabase();
-    const catalogRead = vi.spyOn(
-      database.models.releaseCatalogs,
-      "findByScopeKey",
-    );
-    const hotUpdater = createHotUpdater({
-      database,
-      clientAccess: { type: "public" },
-    });
-    const url =
-      `https://updates.example.com/release-catalogs/app-version/` +
-      `ios/${channelKey}/1.5.0`;
-
-    const responses = await Promise.all(
-      Array.from({ length: 100 }, () =>
-        hotUpdater.handlers.client(new Request(url)),
-      ),
-    );
-
-    expect(responses.every(({ status }) => status === 200)).toBe(true);
-    expect(catalogRead).toHaveBeenCalledOnce();
-  });
-
-  it("varies authenticated catalog responses by the configured header", async () => {
-    const database = await createCatalogDatabase();
-    await registerApiKey({
-      apiKeys: database.models.apiKeys,
-      apiKey: API_KEY,
-      name: "App",
-    });
-    const hotUpdater = createHotUpdater({
-      clientAccess: {
-        headerName: "X-Hot-Updater-Key",
-        type: "api-key",
-      },
-      database,
-    });
-    const url =
-      `https://updates.example.com/release-catalogs/app-version/` +
-      `ios/${channelKey}/1.5.0`;
-
-    const unauthorized = await hotUpdater.handlers.client(
-      new Request(url, { headers: { "x-api-key": API_KEY } }),
-    );
-    expect(unauthorized.status).toBe(401);
-
-    const response = await hotUpdater.handlers.client(
-      new Request(url, { headers: { "x-hot-updater-key": API_KEY } }),
-    );
-    expect(response.status).toBe(200);
-    expect(response.headers.get("vary")).toBe(
-      "Accept-Encoding, x-hot-updater-key",
-    );
-  });
-});

package/src/runtime.spec.ts

@@ -1,194 +0,0 @@
-import {
-  createStoragePlugin,
-  type DatabasePlugin,
-  type ConfigInput,
-} from "@hot-updater/plugin-core";
-import { describe, expect, expectTypeOf, it, vi } from "vitest";
-
-import { createInMemoryDatabasePlugin } from "../../test-utils/test/inMemoryDatabasePlugin";
-import packageJson from "../package.json" with { type: "json" };
-import { createHotUpdater } from "./index";
-import type {
-  ClientAccessPolicy,
-  CreateHotUpdaterOptions,
-  HandlerAPI,
-} from "./index";
-import {
-  createRuntimeDatabase,
-  createSchemaManagedDatabase,
-} from "./runtime.testFixtures";
-import { HOT_UPDATER_SCHEMA_VERSION } from "./schema/types";
-import { HOT_UPDATER_SERVER_VERSION } from "./version";
-
-const publicClientAccess = {
-  type: "public",
-} satisfies ClientAccessPolicy;
-
-describe("runtime createHotUpdater", () => {
-  it.each(["authorityId", "catalogId"])("rejects a user-supplied %s", (key) => {
-    expect(() =>
-      createHotUpdater({
-        clientAccess: publicClientAccess,
-        database: createInMemoryDatabasePlugin(),
-        [key]: "user-controlled",
-      }),
-    ).toThrow(`Remove ${key}`);
-  });
-
-  it("publishes only the supported runtime and database subpaths", () => {
-    const packageExports = packageJson.exports;
-
-    const databaseEntry = packageExports["./db"];
-    const hasRuntimeEntry = Object.hasOwn(packageExports, "./runtime");
-
-    expect(databaseEntry).toBeDefined();
-    expect(hasRuntimeEntry).toBe(false);
-  });
-
-  it("exports runtime-safe handler types from the root entry", () => {
-    expectTypeOf<ConfigInput>().not.toHaveProperty("authorityId");
-    expectTypeOf<ConfigInput>().not.toHaveProperty("catalogId");
-    expectTypeOf<HandlerAPI>().toHaveProperty("getBundles");
-    expectTypeOf<keyof CreateHotUpdaterOptions>().toEqualTypeOf<
-      "clientAccess" | "database" | "storage"
-    >();
-    expectTypeOf<CreateHotUpdaterOptions>().toHaveProperty("clientAccess");
-    expectTypeOf<
-      CreateHotUpdaterOptions["clientAccess"]
-    >().toEqualTypeOf<ClientAccessPolicy>();
-  });
-
-  it("accepts a direct v2 plugin object without exposing maintenance methods", () => {
-    const database: DatabasePlugin = {
-      ...createInMemoryDatabasePlugin(),
-      name: "contextlessTestDatabase",
-    };
-    const storage = createStoragePlugin({
-      name: "contextlessTestStorage",
-      protocol: "s3",
-      get: async () => ({ response: null }),
-      getDownloadUrl: async () => ({
-        url: "https://assets.example.com/bundle.zip",
-      }),
-    });
-
-    const hotUpdater = createHotUpdater({
-      clientAccess: publicClientAccess,
-      database,
-      storage: [storage],
-    });
-
-    expect(hotUpdater.adapterName).toBe("contextlessTestDatabase");
-    expect(hotUpdater.handlers.client).toEqual(expect.any(Function));
-    expect(hotUpdater.handlers.admin).toEqual(expect.any(Function));
-    expect("createMigrator" in hotUpdater).toBe(false);
-    expect("generateSchema" in hotUpdater).toBe(false);
-    expect(hotUpdater).not.toHaveProperty("authorityId");
-    expect(hotUpdater).not.toHaveProperty("catalogId");
-    expectTypeOf(hotUpdater).not.toHaveProperty("createMigrator");
-    expectTypeOf(hotUpdater).not.toHaveProperty("generateSchema");
-    expectTypeOf(hotUpdater.handlers.client)
-      .parameter(0)
-      .toEqualTypeOf<Request>();
-  });
-
-  it("rejects access when a managed schema is not initialized", async () => {
-    const hotUpdater = createHotUpdater({
-      clientAccess: publicClientAccess,
-      database: createSchemaManagedDatabase("kysely", undefined),
-    });
-
-    const result = hotUpdater.getBundles({ limit: 10 });
-
-    await expect(result).rejects.toThrow(
-      "Hot Updater database schema is not initialized for kysely.",
-    );
-  });
-
-  it.each(["s3", "https"])(
-    "rejects registered %s storage without getDownloadUrl",
-    (protocol) => {
-      const storage = createStoragePlugin({
-        name: "deployOnlyStorage",
-        protocol,
-        get: async () => ({ response: null }),
-      });
-
-      expect(() =>
-        createHotUpdater({
-          clientAccess: publicClientAccess,
-          database: createRuntimeDatabase(),
-          storage: [storage],
-        }),
-      ).toThrow(
-        'Storage plugin "deployOnlyStorage" does not implement getDownloadUrl.',
-      );
-    },
-  );
-
-  it("rejects access when a managed schema is stale", async () => {
-    const hotUpdater = createHotUpdater({
-      clientAccess: publicClientAccess,
-      database: createSchemaManagedDatabase("mongodb", "0.21.0"),
-    });
-
-    const result = hotUpdater.getChannels();
-
-    await expect(result).rejects.toThrow(
-      "Hot Updater v1 cannot migrate schema 0.21.0 in place.",
-    );
-  });
-
-  it("checks a ready managed schema only once", async () => {
-    const database = createSchemaManagedDatabase(
-      "kysely",
-      HOT_UPDATER_SCHEMA_VERSION,
-    );
-    const createMigrator = vi.spyOn(database, "createMigrator");
-    const hotUpdater = createHotUpdater({
-      clientAccess: publicClientAccess,
-      database,
-    });
-
-    await hotUpdater.getChannels();
-    await hotUpdater.getChannels();
-
-    expect(createMigrator).toHaveBeenCalledOnce();
-  });
-
-  it("keeps the version route mounted on the client handler", async () => {
-    const hotUpdater = createHotUpdater({
-      clientAccess: publicClientAccess,
-      database: createRuntimeDatabase(),
-    });
-
-    const response = await hotUpdater.handlers.client(
-      new Request("https://updates.example.com/version"),
-    );
-
-    expect(response.status).toBe(200);
-    await expect(response.json()).resolves.toEqual({
-      infrastructureGeneration: 1,
-      version: HOT_UPDATER_SERVER_VERSION,
-    });
-  });
-
-  it("rejects a missing client access policy", () => {
-    expect(() =>
-      createHotUpdater({
-        database: createRuntimeDatabase(),
-      } as unknown as CreateHotUpdaterOptions),
-    ).toThrow("clientAccess must be an object.");
-  });
-
-  it("rejects an unsupported client access policy", () => {
-    expect(() =>
-      createHotUpdater({
-        clientAccess: {
-          type: "private" as unknown as "public",
-        },
-        database: createRuntimeDatabase(),
-      }),
-    ).toThrow('clientAccess.type must be either "public" or "api-key".');
-  });
-});

package/src/runtime.testFixtures.ts

@@ -1,71 +0,0 @@
-import type { Bundle } from "@hot-updater/core";
-import type {
-  DatabasePlugin,
-  StoragePlugin,
-  StoragePluginWith,
-} from "@hot-updater/plugin-core";
-import { createStoragePlugin } from "@hot-updater/plugin-core";
-
-import { createInMemoryDatabasePlugin } from "../../test-utils/test/inMemoryDatabasePlugin";
-import type { DatabaseAdapterCapabilities, Migrator } from "./db/types";
-
-export const runtimeBundle: Bundle = {
-  id: "00000000-0000-0000-0000-000000000001",
-  platform: "ios",
-  fileHash: "hash123",
-  gitCommitHash: null,
-  storageUri: "s3://test-bucket/bundles/bundle.zip",
-  archiveByteSize: 3_000_000_001,
-};
-
-export const createRuntimeStorage = (
-  get: NonNullable<StoragePlugin["get"]> = async () => ({ response: null }),
-  getDownloadUrl?: StoragePlugin["getDownloadUrl"],
-): StoragePluginWith<"get"> =>
-  createStoragePlugin({
-    name: "testStorage",
-    protocol: "s3",
-    get,
-    ...(getDownloadUrl ? { getDownloadUrl } : {}),
-  });
-
-const createMigrator = (version: string | undefined): Migrator => ({
-  async getVersion() {
-    return version;
-  },
-  async getNameVariants() {
-    return {};
-  },
-  async next() {
-    return undefined;
-  },
-  async previous() {
-    return undefined;
-  },
-  async up() {
-    throw new Error("not implemented");
-  },
-  async down() {
-    throw new Error("not implemented");
-  },
-  async migrateTo() {
-    throw new Error("not implemented");
-  },
-  async migrateToLatest() {
-    throw new Error("not implemented");
-  },
-});
-
-export const createRuntimeDatabase = (): DatabasePlugin => ({
-  ...createInMemoryDatabasePlugin(),
-  name: "testDatabase",
-});
-
-export const createSchemaManagedDatabase = (
-  adapterName: string,
-  version: string | undefined,
-): DatabasePlugin & DatabaseAdapterCapabilities => ({
-  ...createRuntimeDatabase(),
-  adapterName,
-  createMigrator: () => createMigrator(version),
-});

package/src/schema/dsl-all-versions.spec.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { hotUpdaterSchemaVersions } from "./index";
-import { createSettingsTable } from "./settings";
-import {
-  bundlePatchesV100,
-  bundleInstallationsV100,
-  bundlesV100,
-  channelsV100,
-  releaseCatalogsV100,
-  releasesV100,
-  v1_0_0,
-} from "./v1_0_0";
-
-describe("versioned schema DSL", () => {
-  it("uses the local functional DSL for the current schema", () => {
-    expect(v1_0_0.dsl).toBe("schema");
-    expect(channelsV100.dsl).toBe("table");
-    expect(bundlesV100.dsl).toBe("table");
-    expect(bundlePatchesV100.dsl).toBe("table");
-    expect(bundleInstallationsV100.dsl).toBe("table");
-    expect(releasesV100.dsl).toBe("table");
-    expect(releaseCatalogsV100.dsl).toBe("table");
-    expect(createSettingsTable("1.0.0").dsl).toBe("table");
-
-    expect(Object.keys(v1_0_0)).not.toContain("dsl");
-    for (const table of v1_0_0.tables) {
-      expect(Object.keys(table)).not.toContain("dsl");
-    }
-  });
-
-  it("registers only the initial schema 1.0.0", () => {
-    expect(hotUpdaterSchemaVersions.map((item) => item.version)).toEqual([
-      "1.0.0",
-    ]);
-  });
-});