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

package/src/runtime.spec.ts

@@ -1,207 +0,0 @@
-import {
-  createStoragePlugin,
-  type ConfigInput,
-} from "@hot-updater/plugin-core";
-import { describe, expect, expectTypeOf, it, vi } from "vitest";
-
-import packageJson from "../package.json" with { type: "json" };
-import { coreSettings } from "./db/coreDatabase";
-import { createHotUpdater, HotUpdaterConfigError } from "./index";
-import type {
-  ClientAccessPolicy,
-  CreateHotUpdaterOptions,
-  RuntimeHotUpdaterAPI,
-} from "./index";
-import {
-  createFencedDatabase,
-  createRuntimeDatabase,
-} from "./runtime.testFixtures";
-import { HOT_UPDATER_SERVER_VERSION } from "./version";
-
-describe("runtime createHotUpdater", () => {
-  it.each(["authorityId", "catalogId"])("rejects a user-supplied %s", (key) => {
-    expect(() =>
-      createHotUpdater({
-        clientAccess: "public",
-        database: createRuntimeDatabase(),
-        [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("types the options and the instance without the legacy API", () => {
-    expectTypeOf<ConfigInput>().not.toHaveProperty("authorityId");
-    expectTypeOf<ConfigInput>().not.toHaveProperty("catalogId");
-    expectTypeOf<keyof CreateHotUpdaterOptions>().toEqualTypeOf<
-      "clientAccess" | "database" | "plugins" | "storage"
-    >();
-    expectTypeOf<
-      CreateHotUpdaterOptions["clientAccess"]
-    >().toEqualTypeOf<ClientAccessPolicy>();
-    expectTypeOf<keyof RuntimeHotUpdaterAPI>().toEqualTypeOf<
-      "adapterName" | "api" | "core" | "flush" | "handlers"
-    >();
-  });
-
-  it("runs on an engine database without exposing its tooling", () => {
-    const storage = createStoragePlugin({
-      name: "contextlessTestStorage",
-      protocol: "s3",
-      get: async () => ({ response: null }),
-      getDownloadUrl: async () => ({
-        url: "https://assets.example.com/bundle.zip",
-      }),
-    });
-
-    const hotUpdater = createHotUpdater({
-      clientAccess: "public",
-      database: createRuntimeDatabase("contextlessTestDatabase"),
-      storage: [storage],
-    });
-
-    expect(hotUpdater.adapterName).toBe("contextlessTestDatabase");
-    expect(Object.keys(hotUpdater).sort()).toEqual([
-      "adapterName",
-      "api",
-      "core",
-      "flush",
-      "handlers",
-    ]);
-    expect(hotUpdater).not.toHaveProperty("authorityId");
-    expectTypeOf(hotUpdater).not.toHaveProperty("createMigrator");
-    expectTypeOf(hotUpdater.handlers.client)
-      .parameter(0)
-      .toEqualTypeOf<Request>();
-  });
-
-  it("refuses a database that is not on the storage engine", () => {
-    const legacy = { name: "legacy", models: {}, commit: async () => ({}) };
-    const remote = {
-      name: "standalone",
-      core: {},
-      fetchAdmin: async () => new Response(null),
-    };
-
-    for (const database of [legacy, remote, undefined]) {
-      expect(() =>
-        createHotUpdater({
-          clientAccess: "public",
-          database: database as unknown as CreateHotUpdaterOptions["database"],
-        }),
-      ).toThrow(HotUpdaterConfigError);
-    }
-    expect(() =>
-      createHotUpdater({
-        clientAccess: "public",
-        database: remote as unknown as CreateHotUpdaterOptions["database"],
-      }),
-    ).toThrow("standaloneRepository reaches a server's admin API");
-  });
-
-  it("answers 503 until the schema settings are written", async () => {
-    const error = vi.spyOn(console, "error").mockImplementation(() => {});
-    try {
-      const hotUpdater = createHotUpdater({
-        clientAccess: "public",
-        database: await createFencedDatabase("kysely"),
-      });
-
-      const response = await hotUpdater.handlers.admin(
-        new Request("https://updates.example.com/channels"),
-      );
-
-      expect(response.status).toBe(503);
-      await expect(hotUpdater.core.listChannels()).rejects.toThrow(
-        "Hot Updater schema setting",
-      );
-    } finally {
-      error.mockRestore();
-    }
-  });
-
-  it("serves a fenced database once its settings are written", async () => {
-    const hotUpdater = createHotUpdater({
-      clientAccess: "public",
-      database: await createFencedDatabase("kysely", coreSettings),
-    });
-
-    await expect(hotUpdater.core.listChannels()).resolves.toEqual([]);
-  });
-
-  it.each(["s3", "https"])(
-    "rejects registered %s storage without getDownloadUrl",
-    (protocol) => {
-      const storage = createStoragePlugin({
-        name: "deployOnlyStorage",
-        protocol,
-        get: async () => ({ response: null }),
-      });
-
-      expect(() =>
-        createHotUpdater({
-          clientAccess: "public",
-          database: createRuntimeDatabase(),
-          storage: [storage],
-        }),
-      ).toThrow(
-        'Storage plugin "deployOnlyStorage" does not implement getDownloadUrl.',
-      );
-    },
-  );
-
-  it("keeps the version route mounted on the client handler", async () => {
-    const hotUpdater = createHotUpdater({
-      clientAccess: "public",
-      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({
-      adminProtocol: 2,
-      infrastructureGeneration: 1,
-      version: HOT_UPDATER_SERVER_VERSION,
-    });
-  });
-
-  it("rejects a missing client access policy", () => {
-    expect(() =>
-      createHotUpdater({
-        database: createRuntimeDatabase(),
-      } as unknown as CreateHotUpdaterOptions),
-    ).toThrow(
-      'Set clientAccess to "public", or add a plugin that provides clientAuth.',
-    );
-  });
-
-  it("rejects a clientAccess object, naming what replaced it", () => {
-    const withObject = (clientAccess: unknown) => () =>
-      createHotUpdater({
-        clientAccess: clientAccess as ClientAccessPolicy,
-        database: createRuntimeDatabase(),
-      });
-    const removed =
-      'clientAccess objects were removed in 1.0. Set clientAccess: "public", or add a plugin that provides clientAuth to plugins.';
-
-    expect(withObject({ type: "api-key", headerName: "x-client-key" })).toThrow(
-      removed,
-    );
-    expect(withObject({ type: "public" })).toThrow(removed);
-    expect(withObject("private")).toThrow(
-      'clientAccess must be "public"; to protect client routes, add a plugin that provides clientAuth to plugins.',
-    );
-  });
-});

package/src/runtime.testFixtures.ts

@@ -1,60 +0,0 @@
-import type { Bundle } from "@hot-updater/core";
-import type {
-  EngineDatabase,
-  StoragePlugin,
-  StoragePluginWith,
-} from "@hot-updater/plugin-core";
-import { createStoragePlugin } from "@hot-updater/plugin-core";
-import { createMemoryAdapter } from "@hot-updater/plugin-core/internal";
-
-import type { SchemaSettings } from "./database/fence";
-import { createEngineDatabase, toolingTargetOf } from "./db/coreDatabase";
-import { migrateSchema } from "./db/schemaSettings";
-import { apiKeys } from "./plugins/api-keys";
-import { insights } from "./plugins/insights";
-
-export const runtimeBundle: Bundle = {
-  id: "00000000-0000-0000-0000-000000000001",
-  platform: "ios",
-  gitCommitHash: null,
-  manifestStorageUri: "s3://test-bucket/bundles/bundle/manifest.json",
-  manifestFileHash: "manifest-hash",
-  assetBaseStorageUri: "s3://test-bucket/assets",
-};
-
-export const createRuntimeStorage = (
-  get: NonNullable<StoragePlugin["get"]> = async () => ({ response: null }),
-  getDownloadUrl?: StoragePlugin["getDownloadUrl"],
-): StoragePluginWith<"get"> =>
-  createStoragePlugin({
-    name: "testStorage",
-    protocol: "s3",
-    get,
-    ...(getDownloadUrl ? { getDownloadUrl } : {}),
-  });
-
-/** An in-memory database on the storage engine, without the schema fence. */
-export const createRuntimeDatabase = (
-  name = "testDatabase",
-): EngineDatabase => ({
-  name,
-  adapter: createMemoryAdapter(),
-});
-
-/** Every table the runtime specs use: core's, Insights', and API keys'. */
-const runtimeTables = toolingTargetOf([insights(), apiKeys()]).schema.tables;
-
-/**
- * An in-memory database behind the schema fence, as a provider builds it:
- * its tables and `settings` rows written first, or none at all.
- */
-export const createFencedDatabase = async (
-  name: string,
-  settings?: SchemaSettings,
-): Promise<EngineDatabase> => {
-  const adapter = createMemoryAdapter();
-  if (settings !== undefined) {
-    await migrateSchema(adapter, name, runtimeTables, settings);
-  }
-  return createEngineDatabase({ name, adapter });
-};

package/src/runtimeBundles.integration.spec.ts

@@ -1,112 +0,0 @@
-import { type ChildProcess, spawn, spawnSync } from "node:child_process";
-import net from "node:net";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import { HOT_UPDATER_SERVER_VERSION } from "./version";
-
-/** Runs the built bundle from `tests/runtime`, with `plugins: []` and no Node APIs. */
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-
-for (const [command, ...args] of [
-  ["deno", "--version"],
-  ["pnpm", "exec", "wrangler", "--version"],
-]) {
-  if (spawnSync(command!, args, { cwd: root, stdio: "ignore" }).status !== 0) {
-    throw new Error(
-      `${command === "pnpm" ? "wrangler" : command} is required for the server runtime bundle tests.`,
-    );
-  }
-}
-
-const openPort = () =>
-  new Promise<number>((resolve, reject) => {
-    const server = net.createServer();
-    server.on("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const { port } = server.address() as net.AddressInfo;
-      server.close(() => resolve(port));
-    });
-  });
-
-let running: ChildProcess | undefined;
-
-const serve = async (command: string, args: readonly string[]) => {
-  const port = await openPort();
-  const child = spawn(command, [...args, "--port", String(port)], {
-    cwd: root,
-    detached: true,
-    env: { ...process.env, NO_COLOR: "1" },
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  running = child;
-  const logs: string[] = [];
-  child.stdout.on("data", (chunk: Buffer) => logs.push(chunk.toString()));
-  child.stderr.on("data", (chunk: Buffer) => logs.push(chunk.toString()));
-  const url = `http://127.0.0.1:${port}`;
-  for (
-    let attempt = 0;
-    attempt < 120 && child.exitCode === null;
-    attempt += 1
-  ) {
-    const ready = await fetch(`${url}/version`).then(
-      (response) => response.ok,
-      () => false,
-    );
-    if (ready) return url;
-    await new Promise((resolve) => setTimeout(resolve, 500));
-  }
-  throw new Error(`${command} never served /version:\n${logs.join("")}`);
-};
-
-describe.sequential("server bundle with plugins: []", () => {
-  afterEach(() => {
-    if (running?.pid !== undefined && running.exitCode === null) {
-      process.kill(-running.pid, "SIGTERM");
-    }
-    running = undefined;
-  });
-
-  it.each([
-    [
-      "Deno",
-      "deno",
-      [
-        "run",
-        "--allow-read",
-        "--allow-net",
-        "--allow-env",
-        "tests/runtime/deno-server.mjs",
-      ],
-    ],
-    [
-      "workerd",
-      "pnpm",
-      [
-        "exec",
-        "wrangler",
-        "dev",
-        "--config",
-        "tests/runtime/wrangler.runtime.jsonc",
-        "--local",
-        "--log-level",
-        "error",
-      ],
-    ],
-  ] as const)(
-    "serves client routes on %s",
-    async (_runtime, command, args) => {
-      const url = await serve(command, args);
-      const version = await fetch(`${url}/version`);
-      await expect(version.json()).resolves.toEqual({
-        adminProtocol: 2,
-        infrastructureGeneration: 1,
-        version: HOT_UPDATER_SERVER_VERSION,
-      });
-      expect((await fetch(`${url}/not-a-route`)).status).toBe(404);
-    },
-    120_000,
-  );
-});

package/src/storageAccess.spec.ts

@@ -1,152 +0,0 @@
-import {
-  createStorageDownloadPath,
-  createStoragePlugin,
-} from "@hot-updater/plugin-core";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { createStorageAccess } from "./storageAccess";
-
-describe("createStorageAccess", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it("reads text through a matching storage implementation", async () => {
-    const get = vi.fn(
-      async (_storageUri: string) => new Response("manifest text"),
-    );
-    const storage = createStoragePlugin({
-      name: "r2Storage",
-      protocol: "r2",
-      get: async (input) => ({ response: await get(input.storageUri) }),
-    });
-    const { readStorageText } = createStorageAccess([storage]);
-
-    await expect(readStorageText("r2://assets/manifest.json")).resolves.toBe(
-      "manifest text",
-    );
-    expect(get).toHaveBeenCalledWith("r2://assets/manifest.json");
-  });
-
-  it("reads direct HTTP storage when no plugin owns the protocol", async () => {
-    const fetchMock = vi.fn<typeof fetch>(
-      async () => new Response("manifest text"),
-    );
-    vi.stubGlobal("fetch", fetchMock);
-    const { readStorageText } = createStorageAccess([]);
-
-    await expect(
-      readStorageText("https://assets.example.com/manifest.json"),
-    ).resolves.toBe("manifest text");
-  });
-
-  it("uses an unowned HTTPS URI directly as the download URL", async () => {
-    const { resolveFileUrl } = createStorageAccess([]);
-    const storageUri = "https://assets.example.com/bundle.zip";
-
-    await expect(resolveFileUrl(storageUri)).resolves.toBe(storageUri);
-  });
-
-  it("lets a matching HTTPS storage own reads before direct fetch", async () => {
-    const fetchMock = vi.fn<typeof fetch>();
-    vi.stubGlobal("fetch", fetchMock);
-    const get = vi.fn(
-      async () => ({ response: new Response("owned manifest") }) as const,
-    );
-    const storage = createStoragePlugin({
-      name: "standaloneStorage",
-      protocol: "https",
-      get,
-    });
-    const { readStorageText } = createStorageAccess([storage]);
-    const storageUri = "https://storage.example.com/manifest.json";
-
-    await expect(readStorageText(storageUri)).resolves.toBe("owned manifest");
-    expect(get).toHaveBeenCalledWith({ storageUri });
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("lets a matching HTTPS storage resolve the download URL", async () => {
-    const getDownloadUrl = vi.fn(async () => ({
-      url: "https://cdn.example.com/bundle.zip",
-    }));
-    const storage = createStoragePlugin({
-      name: "standaloneStorage",
-      protocol: "https",
-      get: async () => ({ response: null }),
-      getDownloadUrl,
-    });
-    const { resolveFileUrl } = createStorageAccess([storage]);
-    const storageUri = "https://storage.example.com/bundle.zip";
-
-    await expect(resolveFileUrl(storageUri)).resolves.toBe(
-      "https://cdn.example.com/bundle.zip",
-    );
-    expect(getDownloadUrl).toHaveBeenCalledWith({ storageUri });
-  });
-
-  it("creates and serves a runtime-neutral delivery URL", async () => {
-    const storage = createStoragePlugin({
-      name: "r2Storage",
-      protocol: "r2",
-      get: vi.fn(
-        async () =>
-          ({
-            response: new Response("bundle", {
-              headers: { "content-type": "application/zip" },
-            }),
-          }) as const,
-      ),
-      getDownloadUrl: async ({ storageUri }) => ({
-        url: createStorageDownloadPath(storageUri, "test-signature"),
-      }),
-    });
-    const access = createStorageAccess([storage]);
-
-    const fileUrl = await access.resolveFileUrl("r2://bucket/bundle.zip");
-    expect(fileUrl).toMatch(/^\/storage\//);
-    const segments = fileUrl!.split("/");
-    const token = segments.at(-2)!;
-    const signature = segments.at(-1)!;
-    const response = await access.downloadStorageObject!(token, signature);
-    await expect(response?.text()).resolves.toBe("bundle");
-    await expect(
-      access.downloadStorageObject!(token, `${signature}tampered`),
-    ).resolves.toBeNull();
-  });
-
-  it("lets a CDN resolver bypass built-in server delivery", async () => {
-    const resolveUrl = vi.fn(async () => ({
-      url: "https://cdn.example.com/bundle.zip",
-    }));
-    const storage = createStoragePlugin({
-      name: "s3Storage",
-      protocol: "s3",
-      get: async () => ({ response: null }),
-      getDownloadUrl: resolveUrl,
-    });
-    const access = createStorageAccess([storage]);
-
-    await expect(access.resolveFileUrl("s3://bucket/bundle.zip")).resolves.toBe(
-      "https://cdn.example.com/bundle.zip",
-    );
-    expect(access.downloadStorageObject).toEqual(expect.any(Function));
-  });
-
-  it("rejects ambiguous storage protocol ownership", () => {
-    const first = createStoragePlugin({
-      name: "firstR2Storage",
-      protocol: "r2",
-      get: async () => ({ response: null }),
-    });
-    const second = createStoragePlugin({
-      name: "secondR2Storage",
-      protocol: "r2",
-      get: async () => ({ response: null }),
-    });
-
-    expect(() => createStorageAccess([first, second])).toThrow(
-      "Multiple storage plugins handle protocol: r2",
-    );
-  });
-});

package/src/storageAccess.ts

@@ -1,141 +0,0 @@
-import {
-  parseStorageDownloadPath,
-  type StoragePluginWith,
-} from "@hot-updater/plugin-core";
-
-const assertRemoteUrl = (value: string) => {
-  const protocol = new URL(value).protocol;
-  if (protocol !== "http:" && protocol !== "https:") {
-    throw new Error("Storage getDownloadUrl must resolve to an HTTP(S) URL.");
-  }
-  return value;
-};
-
-const getStorageProtocol = (storageUri: string) =>
-  new URL(storageUri).protocol.replace(":", "");
-
-const isRemoteUrlProtocol = (protocol: string) =>
-  protocol === "http" || protocol === "https";
-
-const resolveDownloadPath = (value: string, storageUri: string) => {
-  const parsed = parseStorageDownloadPath(value);
-  if (!parsed || parsed.storageUri !== storageUri) {
-    throw new Error(
-      "Storage getDownloadUrl must return an HTTP(S) URL or a valid storage download path.",
-    );
-  }
-  return value;
-};
-
-const tokensEqual = (left: string, right: string) => {
-  const leftBytes = new TextEncoder().encode(left);
-  const rightBytes = new TextEncoder().encode(right);
-  let difference = leftBytes.length ^ rightBytes.length;
-  const length = Math.max(leftBytes.length, rightBytes.length);
-  for (let index = 0; index < length; index += 1) {
-    difference |= (leftBytes[index] ?? 0) ^ (rightBytes[index] ?? 0);
-  }
-  return difference === 0;
-};
-
-export const createStorageAccess = (
-  storagePlugins: StoragePluginWith<"get">[],
-) => {
-  const protocols = new Set<string>();
-  for (const storage of storagePlugins) {
-    if (protocols.has(storage.protocol)) {
-      throw new Error(
-        `Multiple storage plugins handle protocol: ${storage.protocol}`,
-      );
-    }
-    protocols.add(storage.protocol);
-  }
-
-  const findStorage = (protocol: string) =>
-    storagePlugins.find((item) => item.protocol === protocol);
-
-  const readStorageResponse = async (
-    storageUri: string,
-  ): Promise<Response | null> => {
-    const protocol = getStorageProtocol(storageUri);
-    const storage = findStorage(protocol);
-    if (storage) return (await storage.get({ storageUri })).response;
-
-    if (isRemoteUrlProtocol(protocol)) {
-      const response = await fetch(storageUri);
-      return response.ok ? response : null;
-    }
-
-    throw new Error(`No storage plugin for protocol: ${protocol}`);
-  };
-
-  const resolveFileUrl = async (
-    storageUri: string | null,
-  ): Promise<string | null> => {
-    if (!storageUri) return null;
-
-    const protocol = getStorageProtocol(storageUri);
-    const storage = findStorage(protocol);
-    if (!storage) {
-      if (isRemoteUrlProtocol(protocol)) return storageUri;
-      throw new Error(`No storage plugin for protocol: ${protocol}`);
-    }
-    if (!storage.getDownloadUrl) {
-      throw new Error(
-        `Storage plugin "${storage.name}" does not implement getDownloadUrl.`,
-      );
-    }
-    const { url: downloadUrl } = await storage.getDownloadUrl({ storageUri });
-    try {
-      return assertRemoteUrl(downloadUrl);
-    } catch (error) {
-      if (/^[a-z][a-z\d+.-]*:/i.test(downloadUrl)) throw error;
-    }
-    return resolveDownloadPath(downloadUrl, storageUri);
-  };
-
-  const readStorageText = async (
-    storageUri: string,
-  ): Promise<string | null> => {
-    const response = await readStorageResponse(storageUri);
-    return response?.text() ?? null;
-  };
-
-  const downloadStorageObject = storagePlugins.some(
-    (storage) => storage.getDownloadUrl !== undefined,
-  )
-    ? async (
-        storageUriToken: string,
-        encodedSignature: string,
-      ): Promise<Response | null> => {
-        const requestedPath = `/storage/${storageUriToken}/${encodedSignature}`;
-        const requested = parseStorageDownloadPath(requestedPath);
-        if (!requested) return null;
-        let storage: StoragePluginWith<"get"> | undefined;
-        try {
-          storage = findStorage(getStorageProtocol(requested.storageUri));
-        } catch {
-          return null;
-        }
-        if (!storage?.getDownloadUrl) return null;
-        const { url: downloadUrl } = await storage.getDownloadUrl({
-          storageUri: requested.storageUri,
-        });
-        try {
-          new URL(downloadUrl);
-          return null;
-        } catch {
-          if (/^[a-z][a-z\d+.-]*:/i.test(downloadUrl)) return null;
-        }
-        if (!tokensEqual(downloadUrl, requestedPath)) return null;
-        return (await storage.get({ storageUri: requested.storageUri }))
-          .response;
-      }
-    : undefined;
-
-  return {
-    downloadStorageObject,
-    readStorageText,
-    resolveFileUrl,
-  };
-};