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

package/src/core/schema.ts

@@ -1,173 +0,0 @@
-import { defineAggregate, defineTable } from "../database/schema";
-
-/** A channel's id is `channel:` and its name's channel key, so ids share channel_key's bound. */
-const CHANNEL_ID = { type: "string", maxLength: 1408, ascii: true } as const;
-
-/** Core's schema version: the `schema.core` settings row. */
-export const HOT_UPDATER_SCHEMA_VERSION = "1.0.0";
-
-const bundles = defineTable(
-  {
-    id: { type: "string", maxLength: 36 },
-    platform: { type: "string", maxLength: 16 },
-    git_commit_hash: { type: "string", maxLength: 255, required: false },
-    metadata: { type: "json" },
-    manifest_storage_uri: { type: "string" },
-    manifest_file_hash: { type: "string" },
-    asset_base_storage_uri: { type: "string" },
-  },
-  {
-    key: ["id"],
-    indexes: {
-      byPlatform: { eq: ["platform"], sort: ["id"] },
-      all: { eq: [], sort: ["id"] },
-    },
-  },
-);
-
-const bundlePatches = defineTable(
-  {
-    id: { type: "string", maxLength: 255 },
-    bundle_id: {
-      type: "string",
-      maxLength: 36,
-      references: { model: "bundles", onDelete: "cascade" },
-    },
-    base_bundle_id: {
-      type: "string",
-      maxLength: 36,
-      references: { model: "bundles", onDelete: "cascade" },
-    },
-    base_file_hash: { type: "string" },
-    patch_file_hash: { type: "string" },
-    patch_storage_uri: { type: "string" },
-    byte_size: { type: "integer" },
-    order_index: { type: "integer" },
-  },
-  {
-    key: ["id"],
-    indexes: {
-      pair: { eq: ["bundle_id", "base_bundle_id"], sort: [], unique: true },
-      byBundle: {
-        eq: ["bundle_id"],
-        sort: ["order_index"],
-        root: { model: "bundles" },
-      },
-      byBase: { eq: ["base_bundle_id"], sort: ["bundle_id"] },
-    },
-  },
-);
-
-const releases = defineTable(
-  {
-    id: { type: "string", maxLength: 36 },
-    revision: { type: "integer" },
-    scope_key: { type: "string", maxLength: 2048, ascii: true },
-    channel_id: {
-      ...CHANNEL_ID,
-      references: { model: "channels", onDelete: "restrict" },
-    },
-    platform: { type: "string", maxLength: 16 },
-    kind: { type: "string", maxLength: 16 },
-    bundle_id: {
-      type: "string",
-      maxLength: 36,
-      required: false,
-      references: { model: "bundles", onDelete: "restrict" },
-    },
-    strategy: { type: "string", maxLength: 16 },
-    target_app_version: { type: "string", required: false },
-    fingerprint_hash: { type: "string", maxLength: 255, required: false },
-    enabled: { type: "boolean" },
-    should_force_update: { type: "boolean" },
-    message: { type: "string", required: false },
-    rollout_cohort_count: { type: "integer" },
-    target_cohorts: { type: "json" },
-    operation: { type: "string", maxLength: 16 },
-    source_release_id: {
-      type: "string",
-      maxLength: 36,
-      required: false,
-      references: { model: "releases", onDelete: "none" },
-    },
-    created_at_ms: { type: "integer" },
-    updated_at_ms: { type: "integer" },
-  },
-  {
-    key: ["id"],
-    indexes: {
-      byScope: {
-        eq: ["scope_key"],
-        sort: ["id"],
-        root: { model: "release_catalogs" },
-      },
-      byScopeEnabled: {
-        eq: ["scope_key", "enabled"],
-        sort: ["id"],
-        root: { model: "release_catalogs" },
-      },
-      byChannelPlatform: { eq: ["channel_id", "platform"], sort: ["id"] },
-      byChannelPlatformEnabled: {
-        eq: ["channel_id", "platform", "enabled"],
-        sort: ["id"],
-      },
-      byBundle: { eq: ["bundle_id"], sort: ["id"] },
-      all: { eq: [], sort: ["id"] },
-    },
-  },
-);
-
-/** One compiled catalog per scope; the update check reads exactly this row. */
-const releaseCatalogs = defineTable(
-  {
-    scope_key: { type: "string", maxLength: 2048, ascii: true },
-    catalog_id: { type: "string", maxLength: 255 },
-    strategy: { type: "string", maxLength: 16 },
-    channel_id: {
-      ...CHANNEL_ID,
-      references: { model: "channels", onDelete: "none" },
-    },
-    channel_key: { type: "string", maxLength: 1400, ascii: true },
-    platform: { type: "string", maxLength: 16 },
-    fingerprint_hash: { type: "string", maxLength: 255, required: false },
-    generation: { type: "integer" },
-    payload: { type: "string" },
-    catalog_hash: { type: "string", maxLength: 71 },
-    byte_size: { type: "integer" },
-    is_tombstone: { type: "boolean" },
-    updated_at_ms: { type: "integer" },
-  },
-  { key: ["scope_key"], indexes: { all: { eq: [], sort: ["scope_key"] } } },
-);
-
-const channels = defineTable(
-  {
-    id: CHANNEL_ID,
-    name: { type: "string", maxLength: 255, unique: true },
-  },
-  { key: ["id"], indexes: { all: { eq: [], sort: ["name"] } } },
-);
-
-/** Bundles per platform and in total (`platform_key` is a platform or `*`). */
-const bundleTotals = defineAggregate(
-  { platform_key: { type: "string", maxLength: 16 } },
-  {
-    key: ["platform_key"],
-    counters: ["bundles"],
-    indexes: { byPlatform: { eq: ["platform_key"], sort: [] } },
-  },
-);
-
-export const coreSchema = {
-  bundles,
-  bundle_patches: bundlePatches,
-  releases,
-  release_catalogs: releaseCatalogs,
-  channels,
-  bundle_totals: bundleTotals,
-} as const;
-
-export type CoreSchema = typeof coreSchema;
-
-/** Core's module: always installed, never a plugin. */
-export const coreModule = { id: "core", schema: coreSchema } as const;

package/src/core/writes.ts

@@ -1,160 +0,0 @@
-import type {
-  BundlePatchRow,
-  BundleRow,
-  BundleRowUpdate,
-  ChannelDeleteResult,
-  ChannelInsertResult,
-  ChannelRow,
-} from "@hot-updater/plugin-core";
-
-import type { HotUpdaterTransaction, TableRow } from "../database/database";
-import { DatabaseConstraintError } from "../database/errors";
-import { toChannelRow, type CoreDatabase } from "./reads";
-import type { CoreSchema } from "./schema";
-
-export type CoreTransaction = HotUpdaterTransaction<CoreSchema>;
-export type StoredBundle = TableRow<CoreSchema["bundles"]>;
-
-const PAGE = 500;
-
-/** Moves one bundle into or out of its platform's total and the overall total. */
-const countBundle = (tx: CoreTransaction, platform: string, delta: number) => {
-  for (const key of [platform, "*"]) {
-    tx.aggregate("bundle_totals", { platform_key: key }, { bundles: delta });
-  }
-};
-
-export const insertBundle = (tx: CoreTransaction, row: BundleRow): void => {
-  tx.create("bundles", row);
-  countBundle(tx, row.platform, 1);
-};
-
-export const updateBundle = (
-  tx: CoreTransaction,
-  current: StoredBundle,
-  set: BundleRowUpdate,
-): void => {
-  tx.update("bundles", current, set);
-  if (set.platform !== undefined && set.platform !== current.platform) {
-    countBundle(tx, current.platform, -1);
-    countBundle(tx, set.platform, 1);
-  }
-};
-
-/** Deletes a bundle and, by cascade, every patch to or from it; a release on it refuses. */
-export const deleteBundle = async (
-  tx: CoreTransaction,
-  current: StoredBundle,
-): Promise<void> => {
-  await tx.delete("bundles", current);
-  countBundle(tx, current.platform, -1);
-};
-
-/** Deletes a bundle's own patches, exactly as many as its counter holds. */
-export const deleteBundlePatches = async (
-  tx: CoreTransaction,
-  bundle: StoredBundle,
-): Promise<void> => {
-  const count = bundle._refs_bundle_patches_bundle_id ?? 0;
-  let cursor: string | undefined;
-  for (let seen = 0; seen < count; ) {
-    const page = await tx.findMany("bundle_patches", {
-      index: "byBundle",
-      where: { bundle_id: bundle.id },
-      limit: Math.min(count - seen, PAGE),
-      ...(cursor === undefined ? {} : { cursor }),
-    });
-    for (const row of page.rows) await tx.delete("bundle_patches", row);
-    seen += page.rows.length;
-    if (page.next === undefined) break;
-    cursor = page.next;
-  }
-};
-
-/**
- * Replaces a bundle's patches with `rows`: kept patches are updated where
- * they changed, others deleted or created, so no key is written twice.
- */
-export const replaceBundlePatches = async (
-  tx: CoreTransaction,
-  bundle: StoredBundle,
-  rows: readonly BundlePatchRow[],
-): Promise<void> => {
-  const wanted = new Map(rows.map((row) => [row.id, row]));
-  const count = bundle._refs_bundle_patches_bundle_id ?? 0;
-  let cursor: string | undefined;
-  for (let seen = 0; seen < count; ) {
-    const page = await tx.findMany("bundle_patches", {
-      index: "byBundle",
-      where: { bundle_id: bundle.id },
-      limit: Math.min(count - seen, PAGE),
-      ...(cursor === undefined ? {} : { cursor }),
-    });
-    for (const stored of page.rows) {
-      const next = wanted.get(stored.id);
-      wanted.delete(stored.id);
-      if (next === undefined) {
-        await tx.delete("bundle_patches", stored);
-        continue;
-      }
-      const set = Object.fromEntries(
-        Object.entries(next).filter(
-          ([field, value]) =>
-            field !== "id" &&
-            (stored as Record<string, unknown>)[field] !== value,
-        ),
-      );
-      if (Object.keys(set).length > 0) {
-        tx.update("bundle_patches", stored, set);
-      }
-    }
-    seen += page.rows.length;
-    if (page.next === undefined) break;
-    cursor = page.next;
-  }
-  for (const row of wanted.values()) tx.create("bundle_patches", row);
-};
-
-/** A channel by name, created when missing; a concurrent creator's row is returned instead. */
-export const insertChannel = async (
-  db: CoreDatabase,
-  row: ChannelRow,
-): Promise<ChannelInsertResult> => {
-  for (let attempt = 1; ; attempt += 1) {
-    try {
-      return await db.transaction(async (tx) => {
-        const existing = await tx.findOne("channels", { name: row.name });
-        if (existing !== null) {
-          return { row: toChannelRow(existing), inserted: false };
-        }
-        tx.create("channels", row);
-        return { row, inserted: true };
-      });
-    } catch (error) {
-      // Another writer took the name, or the id, first: read again.
-      if (
-        attempt < 3 &&
-        error instanceof DatabaseConstraintError &&
-        (error.reason === "unique" || error.reason === "exists")
-      ) {
-        continue;
-      }
-      throw error;
-    }
-  }
-};
-
-/** Deletes a channel no release uses: 1 read + 1 write. */
-export const deleteChannel = (
-  db: CoreDatabase,
-  id: string,
-): Promise<ChannelDeleteResult> =>
-  db.transaction(async (tx) => {
-    const row = await tx.findOne("channels", { id });
-    if (row === null) return { deleted: false, reason: "not_found" };
-    if ((row._refs_releases_channel_id ?? 0) > 0) {
-      return { deleted: false, reason: "not_empty" };
-    }
-    await tx.delete("channels", row);
-    return { deleted: true };
-  });

package/src/createHotUpdaterCore.ts

@@ -1,260 +0,0 @@
-import {
-  assertStorageOperations,
-  type StoragePlugin,
-} from "@hot-updater/plugin-core";
-import type { DatabaseAdapter } from "@hot-updater/plugin-core/internal";
-
-import {
-  assemblePlugins,
-  HotUpdaterConfigError,
-} from "./assembly/assemblePlugins";
-import type { CoreApi } from "./core/api";
-import { toolingTargetOf } from "./db/coreDatabase";
-import type { ToolingDatabase, ToolingTarget } from "./db/types";
-import {
-  type ClientRoutePolicy,
-  createHotUpdaterHandlers,
-  type HotUpdaterHandlers,
-} from "./handler";
-import type { AnyHotUpdaterPlugin, PluginApis } from "./plugins/definePlugin";
-import { createStorageAccess } from "./storageAccess";
-
-export type RuntimeHotUpdaterAPI<
-  TPlugins extends readonly AnyHotUpdaterPlugin[] =
-    readonly AnyHotUpdaterPlugin[],
-> = {
-  readonly handlers: HotUpdaterHandlers;
-  /** Core's reads and typed writes: bundles, Releases, Catalogs, and channels. */
-  readonly core: CoreApi;
-  /** Each plugin's API by plugin id. */
-  readonly api: PluginApis<TPlugins>;
-  /** The database's name, which `hot-updater db` commands read. */
-  readonly adapterName: string;
-  /**
-   * Applies aggregate changes the database batches that are still pending:
-   * this process's buffer, and the log rows no compaction has merged yet.
-   * A long-lived server with `aggregateBatching: { mode: "memory" }` calls
-   * it before it exits.
-   */
-  readonly flush: () => Promise<void>;
-};
-
-export type HotUpdaterAPI = RuntimeHotUpdaterAPI;
-
-const REMOVED_CLIENT_ACCESS =
-  'clientAccess objects were removed in 1.0: set clientAccess: "public", or add a plugin that provides clientAuth';
-
-/**
- * A `clientAccess` object from before 1.0. Its `type` names the fix, so
- * TypeScript reports it where the object is written.
- */
-export interface RemovedClientAccess {
-  readonly type: typeof REMOVED_CLIENT_ACCESS;
-  readonly headerName?: string;
-}
-
-export type ClientAccessPolicy =
-  /** Leaves client routes public; required when no plugin provides clientAuth. */
-  "public" | RemovedClientAccess;
-
-type ProvidesClientAuth<TPlugin> = TPlugin extends {
-  readonly provides?: infer TProvides;
-}
-  ? TProvides extends { readonly clientAuth: true }
-    ? true
-    : false
-  : false;
-
-type ClientAuthIds<
-  TPlugins extends readonly unknown[],
-  TFound extends string[] = [],
-> = TPlugins extends readonly [infer THead, ...infer TTail]
-  ? ClientAuthIds<
-      TTail,
-      ProvidesClientAuth<THead> extends true
-        ? [
-            ...TFound,
-            THead extends { readonly id: infer TId extends string }
-              ? TId
-              : string,
-          ]
-        : TFound
-    >
-  : TFound;
-
-type JoinIds<TIds extends string[]> = TIds extends [
-  infer TFirst extends string,
-  ...infer TRest extends string[],
-]
-  ? TRest extends []
-    ? `"${TFirst}"`
-    : `"${TFirst}", ${JoinIds<TRest>}`
-  : "";
-
-/**
- * Client routes have one policy source: exactly one plugin that provides
- * clientAuth, or an explicit `clientAccess`. Tuples are counted here; an
- * untyped list that may hold a clientAuth plugin is left to startup.
- */
-export type ClientAccessRule<TPlugins extends readonly AnyHotUpdaterPlugin[]> =
-  number extends TPlugins["length"]
-    ? true extends ProvidesClientAuth<TPlugins[number]>
-      ? {
-          readonly clientAccess?: "Remove clientAccess: a plugin in this list may provide clientAuth";
-        }
-      : { readonly clientAccess: ClientAccessPolicy }
-    : ClientAuthIds<TPlugins> extends []
-      ? { readonly clientAccess: ClientAccessPolicy }
-      : ClientAuthIds<TPlugins> extends [infer TId extends string]
-        ? {
-            readonly clientAccess?: `Remove clientAccess: plugin "${TId}" provides clientAuth`;
-          }
-        : {
-            readonly clientAuth: `Keep one clientAuth plugin: ${JoinIds<ClientAuthIds<TPlugins>>} all provide it`;
-          };
-
-export type CreateHotUpdaterOptions<
-  TPlugins extends readonly AnyHotUpdaterPlugin[] = readonly [],
-> = {
-  /** A provider's database on the storage engine, such as `kyselyAdapter(...)` or `postgres(...)`. */
-  readonly database: ToolingDatabase;
-  /** Storage implementations used to read provider-specific storage URIs. */
-  readonly storage?: readonly StoragePlugin[];
-  /** The plugins the server runs; at most one provides clientAuth. Defaults to none. */
-  readonly plugins?: TPlugins;
-} & ClientAccessRule<TPlugins>;
-
-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 configured database, when it runs on the storage engine. */
-const databaseOf = (value: unknown): ToolingDatabase => {
-  if (isRecord(value) && typeof value.name === "string") {
-    if (isAdapter(value.adapter)) return value as unknown as ToolingDatabase;
-    if ("core" in value && "fetchAdmin" in value) {
-      throw new HotUpdaterConfigError(
-        "standaloneRepository reaches a server's admin API from the CLI and console. createHotUpdater needs the server's own database, such as kyselyAdapter(...).",
-      );
-    }
-  }
-  throw new HotUpdaterConfigError(
-    "database must be a Hot Updater 1.0 database, such as kyselyAdapter(...) or postgres(...). Upgrade the provider package that created it.",
-  );
-};
-
-/** `"public"`, or nothing; a `clientAccess` object says what replaced it. */
-const isPublic = (value: unknown): boolean => {
-  if (value === undefined) return false;
-  if (value === "public") return true;
-  throw new HotUpdaterConfigError(
-    isRecord(value)
-      ? 'clientAccess objects were removed in 1.0. Set clientAccess: "public", or add a plugin that provides clientAuth to plugins.'
-      : 'clientAccess must be "public"; to protect client routes, add a plugin that provides clientAuth to plugins.',
-  );
-};
-
-export const hotUpdaterCoreMetadata = Symbol.for(
-  "@hot-updater/server/core-metadata",
-);
-
-export type HotUpdaterCoreMetadata = {
-  /** The configured database, with the tooling `hot-updater db` runs. */
-  readonly database: ToolingDatabase;
-  /** The tables and settings rows that tooling creates for this server's plugins. */
-  readonly target: ToolingTarget;
-  /** The plugins as configured, whose commands the CLI adds. */
-  readonly plugins: readonly AnyHotUpdaterPlugin[];
-};
-
-export function getHotUpdaterCoreMetadata(
-  hotUpdater: RuntimeHotUpdaterAPI,
-): HotUpdaterCoreMetadata | undefined {
-  return (
-    hotUpdater as RuntimeHotUpdaterAPI & {
-      readonly [hotUpdaterCoreMetadata]?: HotUpdaterCoreMetadata;
-    }
-  )[hotUpdaterCoreMetadata];
-}
-
-export function createHotUpdater<
-  const TPlugins extends readonly AnyHotUpdaterPlugin[] = readonly [],
->(
-  options: CreateHotUpdaterOptions<TPlugins>,
-): RuntimeHotUpdaterAPI<NoInfer<TPlugins>> {
-  for (const key of ["authorityId", "catalogId"]) {
-    if (Object.hasOwn(options, key)) {
-      throw new TypeError(
-        `Remove ${key} from createHotUpdater options. Catalog identity is managed internally.`,
-      );
-    }
-  }
-  const database = databaseOf(options.database);
-  const storagePlugins = (options.storage ?? []).map((storage) => {
-    assertStorageOperations(storage, ["get", "getDownloadUrl"]);
-    return storage;
-  });
-  const { downloadStorageObject, readStorageText, resolveFileUrl } =
-    createStorageAccess(storagePlugins);
-  const publicClients = isPublic(
-    (options as { readonly clientAccess?: unknown }).clientAccess,
-  );
-  const plugins = assemblePlugins(options.plugins ?? [], database.adapter, {
-    storage: { readStorageText, resolveFileUrl },
-    ...(database.onCachedRoutesChange === undefined
-      ? {}
-      : { onCachedRoutesChange: () => database.onCachedRoutesChange!() }),
-    ...(database.aggregateBatching === undefined
-      ? {}
-      : { batching: database.aggregateBatching }),
-  });
-  const clientAuth = plugins.clientAuth;
-  if (clientAuth !== undefined && publicClients) {
-    throw new HotUpdaterConfigError(
-      `Plugin "${clientAuth.plugin}" provides clientAuth, so remove clientAccess.`,
-    );
-  }
-  if (clientAuth === undefined && !publicClients) {
-    throw new HotUpdaterConfigError(
-      'Set clientAccess to "public", or add a plugin that provides clientAuth.',
-    );
-  }
-  const clientPolicy: ClientRoutePolicy | undefined =
-    clientAuth === undefined
-      ? undefined
-      : {
-          varyHeaders: clientAuth.varyHeaders.map((header) =>
-            header.toLowerCase(),
-          ),
-          authenticate: (request) => clientAuth.authenticate(request.headers),
-        };
-  const handlers = createHotUpdaterHandlers({
-    api: { core: plugins.core },
-    ...(clientPolicy === undefined ? {} : { clientPolicy }),
-    downloadStorageObject,
-    endpoints: plugins.endpoints,
-    plugins: Object.keys(plugins.api),
-  });
-
-  const api = {
-    adapterName: database.name,
-    handlers,
-    core: plugins.core,
-    api: plugins.api as PluginApis<TPlugins>,
-    flush: plugins.flush,
-  };
-  Object.defineProperty(api, hotUpdaterCoreMetadata, {
-    enumerable: false,
-    value: {
-      database,
-      target: toolingTargetOf(options.plugins ?? []),
-      plugins: options.plugins ?? [],
-    } satisfies HotUpdaterCoreMetadata,
-  });
-  return api;
-}