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

package/src/core/api.ts

@@ -1,139 +0,0 @@
-import type {
-  EngineDatabase,
-  HotUpdaterCoreApi,
-} from "@hot-updater/plugin-core";
-import type { DatabaseAdapter } from "@hot-updater/plugin-core/internal";
-
-import { createDatabaseEngine } from "../database/database";
-import { resolveSchema } from "../database/resolveSchema";
-import { createCoreOperations } from "./operations";
-import { createCoreReads, type CoreDatabase, type CoreStorage } from "./reads";
-import { coreModule } from "./schema";
-
-export interface CoreApiOptions {
-  readonly now?: () => number;
-  /** The database's CDN purge, called after a write that changes a Release Catalog. */
-  readonly onCachedRoutesChange?: () => Promise<void>;
-}
-
-/**
- * The update check answers from one Release Catalog row, so a transaction
- * changes what the cacheable client routes answer only when it writes one.
- * The purge runs once, after the attempt that commits.
- */
-const purgingCachedRoutes = (
-  db: CoreDatabase,
-  onCachedRoutesChange: (() => Promise<void>) | undefined,
-): CoreDatabase => {
-  if (onCachedRoutesChange === undefined) return db;
-  return {
-    ...db,
-    async transaction(fn) {
-      let changed = false;
-      const result = await db.transaction((tx) => {
-        changed = false;
-        return fn({
-          ...tx,
-          create: (model, row) => {
-            changed ||= model === "release_catalogs";
-            tx.create(model, row);
-          },
-          update: (model, row, set) => {
-            changed ||= model === "release_catalogs";
-            tx.update(model, row, set);
-          },
-          delete: (model, row) => {
-            changed ||= model === "release_catalogs";
-            return tx.delete(model, row);
-          },
-        });
-      });
-      if (changed) await onCachedRoutesChange();
-      return result;
-    },
-  };
-};
-
-/** Core's reads and typed writes over one database handle. */
-export const createCoreApi = (
-  db: CoreDatabase,
-  storage: CoreStorage,
-  options: CoreApiOptions = {},
-) => {
-  const reads = createCoreReads(db, storage);
-  return {
-    ...reads,
-    ...createCoreOperations(
-      purgingCachedRoutes(db, options.onCachedRoutesChange),
-      options,
-    ),
-    /** One read, which checks the schema settings first. */
-    ready: async (): Promise<void> => {
-      await reads.listReleaseCatalogs({ limit: 1 });
-    },
-  };
-};
-
-export type CoreApi = ReturnType<typeof createCoreApi>;
-
-/**
- * Core's API in process, on a database's storage adapter: how the CLI reads
- * and writes a database that runs on the storage engine.
- */
-export const createInProcessCoreApi = (
-  adapter: DatabaseAdapter,
-  options: CoreApiOptions = {},
-): CoreApi =>
-  createCoreApi(
-    createDatabaseEngine({
-      adapter,
-      schema: resolveSchema([coreModule]),
-    }).database(coreModule),
-    { resolveFileUrl: async () => null },
-    options,
-  );
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null;
-
-const isAdapter = (value: unknown): value is DatabaseAdapter =>
-  isRecord(value) &&
-  ["fits", "get", "query", "write"].every(
-    (method) => typeof value[method] === "function",
-  );
-
-/** The storage adapter a configured database runs on, if it is on the engine. */
-export const engineAdapterOf = (
-  database: unknown,
-): DatabaseAdapter | undefined =>
-  isRecord(database) && isAdapter(database.adapter)
-    ? database.adapter
-    : isAdapter(database)
-      ? database
-      : undefined;
-
-export const OFF_ENGINE_DATABASE =
-  "This database does not run on Hot Updater's storage engine. Upgrade its provider package to 1.0.";
-
-/**
- * Core's API for a configured database, as the CLI uses it: a self-hosted
- * server's admin API when the database is `standaloneRepository`, or the
- * database's own storage adapter, in process.
- */
-export const createDatabaseCoreApi = (
-  database: unknown,
-  options: { readonly now?: () => number } = {},
-): HotUpdaterCoreApi => {
-  if (isRecord(database) && isRecord(database.core)) {
-    return database.core as unknown as HotUpdaterCoreApi;
-  }
-  const adapter = engineAdapterOf(database);
-  if (adapter === undefined) throw new Error(OFF_ENGINE_DATABASE);
-  const engineDatabase = database as Partial<EngineDatabase>;
-  return createInProcessCoreApi(adapter, {
-    ...options,
-    ...(typeof engineDatabase.onCachedRoutesChange === "function"
-      ? { onCachedRoutesChange: () => engineDatabase.onCachedRoutesChange!() }
-      : {}),
-  });
-};

package/src/core/baseCandidates.spec.ts

@@ -1,378 +0,0 @@
-import type { Bundle } from "@hot-updater/core";
-import type { HotUpdaterCoreApi } from "@hot-updater/plugin-core";
-import { createMemoryAdapter } from "@hot-updater/plugin-core/internal";
-import { normalizeRange, rangesIntersect } from "verkit";
-import { describe, expect, it } from "vitest";
-
-import { createBundleFixture } from "../../../test-utils/src/databaseTestFixtures";
-import { createInProcessCoreApi } from "./api";
-import {
-  parseBaseCandidateKey,
-  targetBaseCandidateKey,
-  type BaseCandidateTarget,
-} from "./baseCandidates";
-
-type Target = Pick<BaseCandidateTarget, "appVersion" | "fingerprintHash">;
-
-/**
- * The rule `deploy.ts` used before base candidates came from the catalog
- * (`getPatchBaseBundles` on `next`): page the channel and platform's enabled
- * releases newest first, keep bundle releases older than the new bundle with
- * the same fingerprint or an intersecting range, each bundle once.
- */
-const referenceBaseBundleIds = async (
-  core: HotUpdaterCoreApi,
-  channel: string,
-  target: Target,
-  bundleId: string,
-  maxBaseBundles: number,
-): Promise<string[]> => {
-  const channelRow = await core.findChannelByName(channel);
-  if (channelRow === null) return [];
-  const pageSize = Math.max(maxBaseBundles * 3, 10);
-  const found: string[] = [];
-  let after: string | undefined;
-  while (found.length < maxBaseBundles) {
-    const releases = await core.listReleases({
-      filter: {
-        kind: "channelPlatform",
-        channelId: channelRow.id,
-        platform: "ios",
-        enabled: true,
-      },
-      order: "desc",
-      limit: pageSize,
-      ...(after === undefined ? {} : { after }),
-    });
-    for (const release of releases) {
-      const left = target.appVersion && normalizeRange(target.appVersion);
-      const right =
-        release.target_app_version &&
-        normalizeRange(release.target_app_version);
-      const compatible = target.fingerprintHash
-        ? release.strategy === "FINGERPRINT" &&
-          release.fingerprint_hash === target.fingerprintHash
-        : release.strategy === "APP_VERSION" &&
-          !!left &&
-          !!right &&
-          rangesIntersect(left, right);
-      const id = release.bundle_id;
-      if (
-        compatible &&
-        release.kind === "BUNDLE" &&
-        id !== null &&
-        id < bundleId &&
-        !found.includes(id) &&
-        found.length < maxBaseBundles
-      ) {
-        found.push(id);
-      }
-    }
-    if (releases.length < pageSize) break;
-    after = releases.at(-1)!.id;
-  }
-  return found;
-};
-
-const baseBundleIds = (
-  core: HotUpdaterCoreApi,
-  channel: string,
-  target: Target,
-  bundleId: string,
-  maxBaseBundles: number,
-): Promise<string[]> => {
-  const key = targetBaseCandidateKey({ channel, platform: "ios", ...target });
-  return key === null
-    ? Promise.resolve([])
-    : core.findBaseBundleIds(key, bundleId, maxBaseBundles);
-};
-
-const bundleOf = (n: number): Bundle => ({
-  ...createBundleFixture(String(n)),
-  patches: [],
-});
-const idOf = (n: number) => createBundleFixture(String(n)).id;
-const NEWEST = idOf(999);
-
-const policy = (overrides: {
-  readonly channel?: string;
-  readonly targetAppVersion?: string | null;
-  readonly fingerprintHash?: string | null;
-}) => ({
-  channel: "production",
-  enabled: true,
-  fingerprintHash: null,
-  message: null,
-  shouldForceUpdate: false,
-  targetAppVersion: null,
-  ...overrides,
-});
-
-const RELEASE_RANGES = [
-  "1.0.0",
-  "1.2.3",
-  "1.2.9",
-  "1.3.0",
-  "2.0.0",
-  "0.2.5",
-  "1.2.3-beta.1",
-  "1.2",
-  "1.2.x",
-  "2.x",
-  "~1.2.3",
-  "~1.2.5",
-  "^0.2.3",
-  ">=1.0.0 <1.4.0",
-  ">=1.2.0 <=1.2.5",
-  "1.2.3 - 1.4.0",
-  ">=1.0.0 <1.16.0",
-  "1.2.x || 1.5.x",
-  "1.0.0 || 2.0.0",
-  "1.x",
-  "^1.2.3",
-  ">=1.2.0",
-  "<2.0.0",
-  "*",
-  "1.20.0",
-  "1.20.x",
-  ">=1.5.0 <2.1.0",
-  "3.0.0",
-];
-
-const TARGET_RANGES = [
-  "1.0.0",
-  "1.2.0",
-  "1.2.3",
-  "1.2.4",
-  "1.2.9",
-  "1.3.0",
-  "1.5.2",
-  "1.15.2",
-  "1.16.0",
-  "1.20.0",
-  "2.0.0",
-  "3.0.0",
-  "0.2.5",
-  "1.2",
-  "1.2.x",
-  "~1.2.3",
-  "^1.2.3",
-  "1.x",
-  "2.x",
-  "0.x",
-  ">=1.2.0 <2",
-  ">=1.0.0",
-  "1.2.3 || 2.0.0",
-  "*",
-];
-
-describe("base candidate keys", () => {
-  it("names the target's catalog scope and normalized range", () => {
-    const key = targetBaseCandidateKey({
-      channel: "채널-🚀",
-      platform: "ios",
-      fingerprintHash: null,
-      appVersion: "1.2.x",
-    })!;
-    expect(key).toMatch(/^[\x20-\x7e]+$/u);
-    expect(parseBaseCandidateKey(key)).toEqual({
-      scopeKey: expect.stringMatching(/^v1:app-version:ios:/),
-      range: ">=1.2.0 <1.3.0-0",
-    });
-    expect(
-      parseBaseCandidateKey(
-        targetBaseCandidateKey({
-          channel: "production",
-          platform: "android",
-          fingerprintHash: "fp",
-          appVersion: "1.x",
-        })!,
-      ),
-    ).toEqual({
-      scopeKey: expect.stringMatching(/^v1:fingerprint:android:.*:fp$/),
-      range: null,
-    });
-  });
-
-  it("names nothing for an invalid range or key", () => {
-    expect(
-      targetBaseCandidateKey({
-        channel: "production",
-        platform: "ios",
-        fingerprintHash: null,
-        appVersion: "not a range",
-      }),
-    ).toBeNull();
-    for (const key of [
-      "",
-      "[]",
-      '["v1:app-version:ios"]',
-      '["x", "*"]',
-      '["v1:app-version:ios:cHJvZHVjdGlvbg", "not a range"]',
-    ]) {
-      expect(parseBaseCandidateKey(key)).toBeNull();
-    }
-  });
-});
-
-describe("auto-patch bases against the rule deploy used before", () => {
-  it("finds exactly the bases the reference finds, for every range pair", async () => {
-    const core = createInProcessCoreApi(createMemoryAdapter());
-    for (const [n, range] of RELEASE_RANGES.entries()) {
-      await core.deploy([
-        {
-          bundle: bundleOf(100 + n),
-          release: policy({ targetAppVersion: range }),
-        },
-      ]);
-    }
-    const differences: string[] = [];
-    const withoutBases: string[] = [];
-    let matches = 0;
-    for (const range of TARGET_RANGES) {
-      const target = { appVersion: range, fingerprintHash: null };
-      const reference = await referenceBaseBundleIds(
-        core,
-        "production",
-        target,
-        NEWEST,
-        100,
-      );
-      matches += reference.length;
-      if (reference.length === 0) withoutBases.push(range);
-      const found = await baseBundleIds(
-        core,
-        "production",
-        target,
-        NEWEST,
-        100,
-      );
-      if (JSON.stringify(found) !== JSON.stringify(reference)) {
-        differences.push(range);
-      }
-      // `maxBaseBundles` keeps the newest releases first, as before
-      await expect(
-        baseBundleIds(core, "production", target, NEWEST, 3),
-      ).resolves.toEqual(reference.slice(0, 3));
-    }
-    expect(differences).toEqual([]);
-    // 299 of the 672 pairs meet, and every target, `*` and `1.x` included,
-    // finds bases
-    expect(matches).toBe(299);
-    expect(withoutBases).toEqual([]);
-  });
-
-  it("pairs no target in the gap of a lone release's range", async () => {
-    const core = createInProcessCoreApi(createMemoryAdapter());
-    await core.deploy([
-      {
-        bundle: bundleOf(100),
-        release: policy({ targetAppVersion: "1.2.x || 1.5.x" }),
-      },
-    ]);
-    for (const [appVersion, bases] of [
-      ["1.4.0", []],
-      ["1.2.4", [idOf(100)]],
-      ["1.5.2", [idOf(100)]],
-    ] as const) {
-      const target = { appVersion, fingerprintHash: null };
-      await expect(
-        referenceBaseBundleIds(core, "production", target, NEWEST, 3),
-      ).resolves.toEqual(bases);
-      await expect(
-        baseBundleIds(core, "production", target, NEWEST, 3),
-      ).resolves.toEqual(bases);
-    }
-  });
-
-  it("differs only for an exact prerelease target that a release names", async () => {
-    // Both rules pair `1.2.3-beta.1` only with ranges that allow its
-    // prerelease; the catalog keeps no range text, so once a release names
-    // that prerelease, the other ranges around it pair with it too. No
-    // device runs a prerelease app version: the update check coerces it.
-    const core = createInProcessCoreApi(createMemoryAdapter());
-    for (const [n, range] of ["1.2.x", "1.2.3-beta.1"].entries()) {
-      await core.deploy([
-        {
-          bundle: bundleOf(100 + n),
-          release: policy({ targetAppVersion: range }),
-        },
-      ]);
-    }
-    const target = { appVersion: "1.2.3-beta.1", fingerprintHash: null };
-    await expect(
-      referenceBaseBundleIds(core, "production", target, NEWEST, 3),
-    ).resolves.toEqual([idOf(101)]);
-    await expect(
-      baseBundleIds(core, "production", target, NEWEST, 3),
-    ).resolves.toEqual([idOf(101), idOf(100)]);
-    const ranged = { appVersion: "1.2.x", fingerprintHash: null };
-    await expect(
-      baseBundleIds(core, "production", ranged, NEWEST, 3),
-    ).resolves.toEqual(
-      await referenceBaseBundleIds(core, "production", ranged, NEWEST, 3),
-    );
-  });
-
-  it("orders by release like the reference: promotions, republishes, disabled releases, fingerprints", async () => {
-    const core = createInProcessCoreApi(createMemoryAdapter());
-    const both = async (target: Target) => {
-      const reference = await referenceBaseBundleIds(
-        core,
-        "production",
-        target,
-        NEWEST,
-        3,
-      );
-      await expect(
-        baseBundleIds(core, "production", target, NEWEST, 3),
-      ).resolves.toEqual(reference);
-      return reference;
-    };
-    const v1 = { appVersion: "1.0.0", fingerprintHash: null };
-    const [staged] = await core.deploy([
-      {
-        bundle: bundleOf(10),
-        release: policy({ channel: "staging", targetAppVersion: "1.0.0" }),
-      },
-    ]);
-    const releaseIds: string[] = [];
-    for (let n = 11; n <= 15; n += 1) {
-      const [deployed] = await core.deploy([
-        { bundle: bundleOf(n), release: policy({ targetAppVersion: "1.0.0" }) },
-      ]);
-      releaseIds.push(deployed!.release!.id);
-    }
-    expect(await both(v1)).toEqual([15, 14, 13].map(idOf));
-    // a promotion is the newest release of an older bundle
-    await core.promoteRelease({
-      releaseId: staged!.release!.id,
-      targetChannel: "production",
-    });
-    expect(await both(v1)).toEqual([10, 15, 14].map(idOf));
-    await core.deploy([
-      { bundleId: idOf(11), release: policy({ targetAppVersion: "1.0.0" }) },
-    ]);
-    expect(await both(v1)).toEqual([11, 10, 15].map(idOf));
-    await core.updateReleasePolicy({
-      releaseId: releaseIds[4]!,
-      patch: { enabled: false },
-    });
-    expect(await both(v1)).toEqual([11, 10, 14].map(idOf));
-    for (let n = 20; n <= 23; n += 1) {
-      await core.deploy([
-        {
-          bundle: bundleOf(n),
-          release: policy({ fingerprintHash: n === 22 ? "fp-b" : "fp-a" }),
-        },
-      ]);
-    }
-    expect(await both({ appVersion: null, fingerprintHash: "fp-a" })).toEqual(
-      [23, 21, 20].map(idOf),
-    );
-    // the new bundle is never its own base, nor is a newer one
-    await expect(
-      baseBundleIds(core, "production", v1, idOf(14), 3),
-    ).resolves.toEqual([11, 10, 13].map(idOf));
-  });
-});

package/src/core/baseCandidates.ts

@@ -1,136 +0,0 @@
-import {
-  createReleaseCatalogScopeKey,
-  encodeChannelKey,
-  parseReleaseCatalogScopeKey,
-} from "@hot-updater/core";
-import type {
-  CompiledCatalogSegment,
-  ReleaseCatalogRow,
-} from "@hot-updater/plugin-core";
-import { normalizeRange, rangesIntersect } from "verkit";
-
-import { parseCompiledCatalog } from "../db/releaseCatalog";
-
-/** A new bundle's auto-patch target: where it is released, and to whom. */
-export interface BaseCandidateTarget {
-  readonly channel: string;
-  readonly platform: "ios" | "android";
-  readonly fingerprintHash: string | null;
-  readonly appVersion: string | null;
-}
-
-/** What a base-candidate key names: a catalog scope, and an app-version scope's target range. */
-export interface BaseCandidateQuery {
-  readonly scopeKey: string;
-  readonly range: string | null;
-}
-
-/**
- * A new bundle's base-candidate key: the Release Catalog scope its devices
- * update from, and for an app version its normalized range; null for a
- * target without a valid range.
- */
-export const targetBaseCandidateKey = (
-  target: BaseCandidateTarget,
-): string | null => {
-  const channelKey = encodeChannelKey(target.channel);
-  if (target.fingerprintHash) {
-    return JSON.stringify([
-      createReleaseCatalogScopeKey({
-        channelKey,
-        fingerprintHash: target.fingerprintHash,
-        platform: target.platform,
-        strategy: "FINGERPRINT",
-      }),
-    ]);
-  }
-  const range =
-    target.appVersion === null ? null : normalizeRange(target.appVersion);
-  return range === null
-    ? null
-    : JSON.stringify([
-        createReleaseCatalogScopeKey({
-          channelKey,
-          platform: target.platform,
-          strategy: "APP_VERSION",
-        }),
-        range,
-      ]);
-};
-
-/** The scope and range a base-candidate key names; null for any other string. */
-export const parseBaseCandidateKey = (
-  key: string,
-): BaseCandidateQuery | null => {
-  try {
-    const parsed: unknown = JSON.parse(key);
-    if (!Array.isArray(parsed) || typeof parsed[0] !== "string") return null;
-    const [scopeKey, text] = parsed as [string, unknown];
-    const { strategy } = parseReleaseCatalogScopeKey(scopeKey);
-    if (strategy === "FINGERPRINT") {
-      return parsed.length === 1 ? { scopeKey, range: null } : null;
-    }
-    const range =
-      parsed.length === 2 && typeof text === "string"
-        ? normalizeRange(text)
-        : null;
-    return range === null ? null : { scopeKey, range };
-  } catch {
-    return null;
-  }
-};
-
-/** A compiled segment as a range: its version when it holds exactly one. */
-const segmentRange = ({ lower, upper }: CompiledCatalogSegment): string =>
-  lower?.inclusive && upper?.inclusive && lower.version === upper.version
-    ? lower.version
-    : [
-        lower === null ? "" : `${lower.inclusive ? ">=" : ">"}${lower.version}`,
-        upper === null ? "" : `${upper.inclusive ? "<=" : "<"}${upper.version}`,
-      ]
-        .join(" ")
-        .trim() || "*";
-
-/**
- * Auto-patch bases from a scope's compiled Release Catalog, which holds
- * every enabled bundle release of the scope: those whose range intersects
- * `range` (all of them in a fingerprint scope), newest release first, each
- * bundle once and older than `bundleId`, at most `limit`.
- */
-export const baseBundleIdsOf = (
-  row: ReleaseCatalogRow,
-  range: string | null,
-  bundleId: string,
-  limit: number,
-): string[] => {
-  const catalog = parseCompiledCatalog(row.payload, row.strategy);
-  const serving = new Set(
-    catalog.strategy === "FINGERPRINT"
-      ? catalog.rollbackReleaseIndexes
-      : catalog.segments.flatMap((segment) =>
-          range !== null && rangesIntersect(range, segmentRange(segment))
-            ? segment.rollbackReleaseIndexes
-            : [],
-        ),
-  );
-  const newestFirst = catalog.releaseDescriptors
-    .map((descriptor, index) => ({ descriptor, index }))
-    .sort((left, right) =>
-      left.descriptor.releaseId < right.descriptor.releaseId ? 1 : -1,
-    );
-  const ids: string[] = [];
-  for (const { descriptor, index } of newestFirst) {
-    if (ids.length >= limit) break;
-    const id = descriptor.bundleId;
-    if (
-      serving.has(index) &&
-      descriptor.kind === "BUNDLE" &&
-      id !== null &&
-      id < bundleId &&
-      !ids.includes(id)
-    ) {
-      ids.push(id);
-    }
-  }
-  return ids;
-};

package/src/core/index.ts

@@ -1,44 +0,0 @@
-export {
-  targetBaseCandidateKey,
-  type BaseCandidateTarget,
-} from "./baseCandidates";
-export {
-  createCoreApi,
-  createDatabaseCoreApi,
-  createInProcessCoreApi,
-  type CoreApi,
-} from "./api";
-export { createCoreOperations } from "./operations";
-export {
-  changeReleases,
-  rebuildCatalog,
-  type ReleaseChange,
-  type ReleaseChangeInput,
-  type ReleaseChangeResult,
-} from "./releases";
-export {
-  createCoreReads,
-  toBundleRow,
-  toCatalogRow,
-  toChannelRow,
-  toPatchRow,
-  toReleaseRow,
-  type BundleDetail,
-  type CoreDatabase,
-  type CoreReads,
-  type CoreStorage,
-  type KeysetInput,
-  type ReleaseFilter,
-} from "./reads";
-export {
-  coreModule,
-  coreSchema,
-  HOT_UPDATER_SCHEMA_VERSION,
-  type CoreSchema,
-} from "./schema";
-export {
-  deleteChannel,
-  insertBundle,
-  insertChannel,
-  type CoreTransaction,
-} from "./writes";