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

package/src/plugins/insights/testing/setupInsightsHttpTestSuite.ts

@@ -1,152 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { expectInsightsIndex } from "./expectInsightsIndex";
-import type { HttpTestClient } from "./types";
-
-const jsonRequest = (method: string, body: unknown) => ({
-  method,
-  headers: { "content-type": "application/json" },
-  body: JSON.stringify(body),
-});
-
-type InstallationPage = {
-  readonly data: readonly {
-    readonly installId: string;
-    readonly lastKnownBundleId: string;
-    readonly latestStatus: string;
-  }[];
-};
-
-/**
- * The Insights plugin's routes on a database: a client reports an event, and
- * the admin routes read it back. The server must run `insights()`.
- */
-export const setupInsightsHttpTestSuite = (options: {
-  readonly getClient: () => HttpTestClient;
-}): void => {
-  describe("Insights HTTP routes", () => {
-    it("records a reported event and reads it back", async () => {
-      const client = options.getClient();
-      const installId = `install-${crypto.randomUUID()}`;
-      const userId = `user-${crypto.randomUUID()}`;
-      const channel = `insights-${crypto.randomUUID()}`;
-      const event = {
-        appVersion: "1.0.0",
-        channel,
-        cohort: "default",
-        fingerprintHash: null,
-        fromBundleId: null,
-        fromReleaseId: null,
-        installId,
-        platform: "ios",
-        toBundleId: "00000000-0000-7000-8000-000000000001",
-        toReleaseId: null,
-        type: "UNCHANGED",
-        updateStrategy: null,
-        userId,
-        sdkVersion: "2.0.0",
-      };
-
-      const reported = await client.client(
-        "/events",
-        jsonRequest("POST", event),
-      );
-      expect(reported.status).toBe(204);
-      await reported.text();
-
-      const installation = await client.admin(
-        `/installations/${encodeURIComponent(installId)}`,
-      );
-      expect(installation.status).toBe(200);
-      expect(await installation.json()).toMatchObject({
-        installId,
-        latestStatus: "UNCHANGED",
-        lastKnownBundleId: event.toBundleId,
-        channel,
-      });
-      await expectInsightsIndex(async () => {
-        const page = await client.admin(
-          `/installations?userId=${encodeURIComponent(userId)}`,
-        );
-        return ((await page.json()) as InstallationPage).data.map(
-          ({ installId: id }) => id,
-        );
-      }, [installId]);
-      await expectInsightsIndex(async () => {
-        const overview = await client.admin(
-          `/overview?platform=ios&channel=${encodeURIComponent(channel)}&window=24h`,
-        );
-        return (
-          (await overview.json()) as {
-            readonly reportingInstallations: { readonly count: number };
-          }
-        ).reportingInstallations.count;
-      }, 1);
-    });
-
-    it("records an update failure in installation history and the failures read", async () => {
-      const client = options.getClient();
-      const installId = `install-${crypto.randomUUID()}`;
-      const channel = `insights-${crypto.randomUUID()}`;
-      const releaseId = "00000000-0000-7000-8000-0000000000b2";
-      const reported = await client.client(
-        "/events",
-        jsonRequest("POST", {
-          appVersion: "1.0.0",
-          channel,
-          cohort: "default",
-          fingerprintHash: null,
-          fromBundleId: "00000000-0000-7000-8000-000000000001",
-          fromReleaseId: null,
-          installId,
-          platform: "ios",
-          toBundleId: "00000000-0000-7000-8000-000000000002",
-          toReleaseId: releaseId,
-          type: "UPDATE_FAILED",
-          updateStrategy: "appVersion",
-          metadata: {
-            failure: { stage: "download", reason: "http", httpStatus: 403 },
-          },
-        }),
-      );
-      expect(reported.status).toBe(204);
-      await reported.text();
-
-      await expectInsightsIndex(async () => {
-        const page = await client.admin(
-          `/installations/${encodeURIComponent(installId)}/events?limit=10`,
-        );
-        return (
-          (await page.json()) as {
-            readonly data: readonly { type: string; failure?: unknown }[];
-          }
-        ).data.map(({ type, failure }) => ({ type, failure }));
-      }, [
-        {
-          type: "UPDATE_FAILED",
-          failure: { stage: "download", reason: "http", httpStatus: 403 },
-        },
-      ]);
-      const now = Date.now();
-      await expectInsightsIndex(async () => {
-        const failures = await client.admin(
-          `/failures?platform=ios&channel=${encodeURIComponent(channel)}&releaseId=${releaseId}&start=${now - 86_400_000}&end=${now + 3_600_000}`,
-        );
-        const body = (await failures.json()) as {
-          readonly failedUpdates: number;
-          readonly failedInstallations: number;
-        };
-        return [body.failedUpdates, body.failedInstallations];
-      }, [1, 1]);
-    });
-
-    it("refuses a malformed event", async () => {
-      const response = await options
-        .getClient()
-        .client("/events", jsonRequest("POST", { type: "UNCHANGED" }));
-
-      expect(response.status).toBe(400);
-      await response.text();
-    });
-  });
-};

package/src/plugins/insights/testing/setupInsightsModelTestSuite.ts

@@ -1,36 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe } from "vitest";
-
-import type { InsightsModel } from "../modelTypes";
-import { registerInsightsModelTests } from "./insightsModelTests";
-import type { DatabaseTestLifecycle } from "./types";
-
-/**
- * The Insights report contract on one database: pass the Insights plugin's
- * model over it, `createInsightsModel(createDatabasePluginApis(database,
- * [insights()]).insights)`, as `createDatabase`.
- */
-export const setupInsightsModelTestSuite = (
-  lifecycle: DatabaseTestLifecycle<InsightsModel>,
-): void => {
-  describe(lifecycle.name, () => {
-    let model: InsightsModel | undefined;
-    const getDatabase = (): InsightsModel => {
-      if (model === undefined) {
-        throw new Error("The model is unavailable outside the test lifecycle");
-      }
-      return model;
-    };
-    beforeAll(async () => {
-      await lifecycle.migrate();
-      model = await lifecycle.createDatabase();
-    });
-    beforeEach(async () => {
-      await lifecycle.reset(getDatabase());
-    });
-    afterAll(async () => {
-      await lifecycle.dispose(getDatabase());
-      model = undefined;
-    });
-    registerInsightsModelTests({ getDatabase });
-  });
-};

package/src/plugins/insights/testing/types.ts

@@ -1,30 +0,0 @@
-/**
- * The shapes `@hot-updater/test-utils` passes a plugin's suite, restated
- * here so the plugin's tests need no dependency on that package.
- */
-export type HttpTestRequest = (
-  path: string,
-  init?: NonNullable<ConstructorParameters<typeof Request>[1]>,
-) => Promise<Response>;
-
-/** A running server's client and admin mounts. */
-export interface HttpTestClient {
-  readonly client: HttpTestRequest;
-  readonly admin: HttpTestRequest;
-}
-
-export type DatabaseTestState<TDatabase> = {
-  readonly getDatabase: () => TDatabase;
-};
-
-type Awaitable<T> = Promise<T> | T;
-
-/** How a suite gets a database, and gives it back. */
-export type DatabaseTestLifecycle<TDatabase> = {
-  readonly name: string;
-  readonly migrate: () => Awaitable<void>;
-  readonly createDatabase: () => Awaitable<TDatabase>;
-  /** Empties every table between tests. */
-  readonly reset: (database: TDatabase) => Awaitable<void>;
-  readonly dispose: (database: TDatabase) => Awaitable<void>;
-};

package/src/plugins/insights/types.ts

@@ -1,55 +0,0 @@
-import type {
-  ReportingOverview,
-  InsightsBundleSelection,
-  ActiveInstallationWindow,
-  CreateBundleEventRequest,
-  CursorPage,
-  EventCursorPage,
-  EventHistoryRow,
-  InstallationHistoryRow,
-  InstallationRow,
-} from "./domain";
-import type { InsightsScope } from "./modelTypes";
-
-export type InsightsEventPageInput = {
-  readonly beforeReceivedAtMs?: number;
-  readonly sinceMs?: number;
-  readonly bundle?: InsightsBundleSelection;
-  readonly cursor?: string;
-  readonly limit?: number;
-};
-
-export type InsightsInstallationEventPageInput = Omit<
-  InsightsEventPageInput,
-  "bundle"
-> & {
-  readonly installId: string;
-};
-
-export type InsightsUserInstallationPageInput = {
-  readonly userId: string;
-  readonly cursor?: string;
-  readonly limit?: number;
-};
-
-export type InsightsProvider = {
-  appendBundleEvent(input: CreateBundleEventRequest): Promise<void>;
-  listEvents(
-    input: InsightsEventPageInput,
-  ): Promise<EventCursorPage<EventHistoryRow>>;
-  listInstallationEvents(
-    input: InsightsInstallationEventPageInput,
-  ): Promise<EventCursorPage<InstallationHistoryRow>>;
-  getInstallation(input: {
-    readonly installId: string;
-  }): Promise<InstallationRow | null>;
-  pageInstallationsByCurrentUserId(
-    input: InsightsUserInstallationPageInput,
-  ): Promise<CursorPage<InstallationRow>>;
-  getReportingOverview(
-    input: InsightsScope & {
-      readonly window: ActiveInstallationWindow;
-      readonly bundleId?: string;
-    },
-  ): Promise<ReportingOverview>;
-};

package/src/plugins/pluginTestHarness.spec.ts

@@ -1,56 +0,0 @@
-import { createPluginTestHarness } from "@hot-updater/test-utils";
-import { describe, expect, it } from "vitest";
-
-import * as engine from "../database";
-import { defineTable } from "../database/schema";
-import { definePlugin } from "./definePlugin";
-
-const notes = definePlugin({
-  id: "notes",
-  schemaVersion: "1",
-  schema: {
-    notes: defineTable(
-      {
-        id: { type: "string" },
-        text: { type: "string" },
-        at: { type: "integer" },
-      },
-      { key: ["id"], indexes: { byTime: { eq: [], sort: ["at"] } } },
-    ),
-  },
-  init: ({ db, now }) => ({
-    api: {
-      add: (id: string, text: string) =>
-        db.transaction(async (tx) => {
-          tx.create("notes", { id, text, at: now() });
-        }),
-      latest: () =>
-        db.findMany("notes", {
-          index: "byTime",
-          where: {},
-          order: "desc",
-          limit: 2,
-        }),
-    },
-  }),
-});
-
-describe("plugin test harness", () => {
-  it("runs a plugin on a namespaced memory database and measures its reads", async () => {
-    const harness = await createPluginTestHarness(notes, {
-      engine,
-      now: () => 1,
-    });
-    await harness.api.add("a", "first");
-    harness.setNow(() => 2);
-    await harness.api.add("b", "second");
-    harness.setNow(() => 3);
-    await harness.api.add("c", "third");
-
-    expect(harness.tables.map(({ name }) => name)).toEqual(["notes_notes"]);
-    const measured = await harness.measureReads(() => harness.api.latest());
-    expect(measured.result.rows.map(({ id }) => id)).toEqual(["c", "b"]);
-    expect(measured.adapter.rows).toBe(measured.engine.rows);
-    expect(measured.engine).toEqual({ calls: 1, rows: 2 });
-  });
-});

package/src/readBudgets.testFixtures.ts

@@ -1,15 +0,0 @@
-import type { ReadBudgetServer } from "@hot-updater/test-utils";
-
-import { createMeasuredDatabase } from "./assembly/databasePlugins";
-import { targetBaseCandidateKey } from "./core/baseCandidates";
-import { toolingTargetOf } from "./db/coreDatabase";
-import { apiKeys } from "./plugins/api-keys";
-import { insights } from "./plugins/insights";
-
-/** The server parts `setupReadBudgetTestSuite` takes, for the server's own backends. */
-export const readBudgetServer = {
-  createMeasuredDatabase,
-  toolingTargetOf,
-  plugins: [insights(), apiKeys()],
-  targetBaseCandidateKey,
-} satisfies ReadBudgetServer;

package/src/releaseCatalogRoutes.integration.spec.ts

@@ -1,200 +0,0 @@
-import { encodeChannelKey } from "@hot-updater/core";
-import type { EngineDatabase } from "@hot-updater/plugin-core";
-import { describe, expect, it, vi } from "vitest";
-
-import { createDatabaseCoreApi } from "./core/api";
-import { createHotUpdater } from "./index";
-import { apiKeys } from "./plugins/api-keys";
-import { createRuntimeDatabase } from "./runtime.testFixtures";
-
-const API_KEY = "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE";
-
-const channelKey = encodeChannelKey("production");
-const scopeKey = `v1:app-version:ios:${channelKey}`;
-
-/** A database with one deployed release in production's app-version scope. */
-const createCatalogDatabase = async () => {
-  const database = createRuntimeDatabase();
-  await createDatabaseCoreApi(database).deploy([
-    {
-      bundle: {
-        assetBaseStorageUri: "storage://assets",
-        gitCommitHash: null,
-        id: "00000000-0000-7001-8000-000000000001",
-        manifestFileHash: "manifest-hash",
-        manifestStorageUri: "storage://bundle/manifest.json",
-        metadata: {},
-        platform: "ios",
-      },
-      release: {
-        channel: "production",
-        enabled: true,
-        fingerprintHash: null,
-        message: "Stable Release",
-        shouldForceUpdate: false,
-        targetAppVersion: ">=1.0.0 <2.0.0",
-      },
-    },
-  ]);
-  return database;
-};
-
-/** Counts point reads of catalog rows, the update check's one read. */
-const countCatalogReads = (database: EngineDatabase) => {
-  const get = vi.spyOn(database.adapter, "get");
-  return () =>
-    get.mock.calls.filter(([table]) => table.name === "release_catalogs")
-      .length;
-};
-
-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 createDatabaseCoreApi(database).getReleaseCatalogRow(scopeKey);
-    const catalogReads = countCatalogReads(database);
-    const hotUpdater = createHotUpdater({
-      database,
-      clientAccess: "public",
-    });
-    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(catalogReads()).toBe(1);
-
-    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(catalogReads()).toBe(1);
-
-    const invalidPlatform = await hotUpdater.handlers.client(
-      new Request(url.replace("/ios/", "/windows/")),
-    );
-    expect(invalidPlatform.status).toBe(400);
-    expect(catalogReads()).toBe(1);
-
-    const otherChannel = await hotUpdater.handlers.client(
-      new Request(
-        url.replace(`/${channelKey}/`, `/${encodeChannelKey("beta")}/`),
-      ),
-    );
-    expect(otherChannel.status).toBe(404);
-    expect(otherChannel.headers.get("cache-control")).toBe(
-      "public, max-age=0, s-maxage=5",
-    );
-    expect(otherChannel.headers.get("x-hot-updater-catalog")).toBe("none");
-    expect(catalogReads()).toBe(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(legacyAuthorityPath.headers.has("x-hot-updater-catalog")).toBe(
-      false,
-    );
-    expect(catalogReads()).toBe(2);
-    const write = vi.spyOn(database.adapter, "write");
-    const restarted = createHotUpdater({
-      database,
-      clientAccess: "public",
-    });
-    const relocated = await restarted.handlers.client(
-      new Request(url.replace("updates.example.com", "new.example.com")),
-    );
-    expect(await relocated.json()).toEqual(body);
-    expect(write).not.toHaveBeenCalled();
-  });
-
-  it("singleflights concurrent cold requests into one exact catalog read", async () => {
-    const database = await createCatalogDatabase();
-    const catalogReads = countCatalogReads(database);
-    const hotUpdater = createHotUpdater({
-      database,
-      clientAccess: "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(catalogReads()).toBe(1);
-  });
-
-  it("varies authenticated catalog responses by the configured header", async () => {
-    const hotUpdater = createHotUpdater({
-      database: await createCatalogDatabase(),
-      plugins: [apiKeys({ headerName: "X-Hot-Updater-Key" })],
-    });
-    await hotUpdater.api.apiKeys.register({ apiKey: API_KEY, name: "App" });
-    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/retention.spec.ts

@@ -1,73 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { createHotUpdater } from "./index";
-import { definePlugin, defineTable } from "./plugins";
-import { createRuntimeDatabase } from "./runtime.testFixtures";
-
-const DAY = 86_400_000;
-const HOUR = 3_600_000;
-
-/** A plugin whose notes expire a day after their `at`. */
-const notes = definePlugin({
-  id: "notes",
-  schemaVersion: "1",
-  schema: {
-    notes: defineTable(
-      {
-        id: { type: "string", maxLength: 36 },
-        at: { type: "integer" },
-      },
-      { key: ["id"], retention: { field: "at", days: 1 } },
-    ),
-  },
-  init: ({ db }) => ({
-    api: {
-      write: (id: string, at: number) =>
-        db.transaction(async (tx) => {
-          tx.create("notes", { id, at });
-        }),
-      read: (id: string) => db.findOne("notes", { id }),
-    },
-  }),
-});
-
-const createServer = (database = createRuntimeDatabase()) =>
-  createHotUpdater({ clientAccess: "public", database, plugins: [notes] });
-
-describe("server retention", () => {
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("prunes before the write that takes the lease, which keeps what it writes", async () => {
-    vi.useFakeTimers({ toFake: ["Date"] });
-    const hotUpdater = createServer();
-    // A fresh database: the first write takes the lease with nothing to prune.
-    await hotUpdater.api.notes.write("old", Date.now() - 2 * DAY);
-    await expect(hotUpdater.api.notes.read("old")).resolves.not.toBeNull();
-
-    vi.setSystemTime(Date.now() + HOUR + 1);
-    await hotUpdater.api.notes.write("new", Date.now());
-    await expect(hotUpdater.api.notes.read("old")).resolves.toBeNull();
-    await expect(hotUpdater.api.notes.read("new")).resolves.not.toBeNull();
-  });
-
-  it("prunes during a write once the lease is due, on one server an hour", async () => {
-    vi.useFakeTimers({ toFake: ["Date"] });
-    const database = createRuntimeDatabase();
-    const [one, two] = [createServer(database), createServer(database)];
-
-    // The first write takes the lease, due in an hour; nothing has expired.
-    await one.api.notes.write("fresh", Date.now());
-    // Within the hour no write prunes: the other server reads the lease.
-    await two.api.notes.write("stale", Date.now() - 2 * DAY);
-    await one.api.notes.write("second", Date.now());
-    await expect(one.api.notes.read("stale")).resolves.not.toBeNull();
-
-    // Once it is due, the next write, on either server, takes it and prunes.
-    vi.setSystemTime(Date.now() + HOUR + 1);
-    await two.api.notes.write("third", Date.now());
-    await expect(one.api.notes.read("stale")).resolves.toBeNull();
-    await expect(one.api.notes.read("fresh")).resolves.not.toBeNull();
-  });
-});