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

package/src/core/reads.ts

@@ -1,417 +0,0 @@
-import {
-  ARTIFACT_PROTOCOL_VERSION,
-  NIL_UUID,
-  type ArtifactInfo,
-  type ReleaseCatalog,
-} from "@hot-updater/core";
-import {
-  rowToBundle,
-  type BundleDetail,
-  type BundlePatchRow,
-  type BundleRow,
-  type ChannelRow,
-  type KeysetInput,
-  type ReleaseCatalogRow,
-  type ReleaseFilter,
-  type ReleaseRow,
-} from "@hot-updater/plugin-core";
-
-import type { HotUpdaterDatabase, ReadRow } from "../database/database";
-import type { Page } from "../database/engineReads";
-import {
-  projectReleaseCatalogRow,
-  releaseCatalogScopeKeyOf,
-  type ReleaseCatalogRequest,
-} from "../db/releaseCatalog";
-import { resolveManifestArtifacts } from "../db/updateArtifacts";
-import { baseBundleIdsOf, parseBaseCandidateKey } from "./baseCandidates";
-import type { CoreSchema } from "./schema";
-
-export type CoreDatabase = HotUpdaterDatabase<CoreSchema>;
-export type { BundleDetail, KeysetInput, ReleaseFilter };
-
-const PAGE = 500;
-
-const pick =
-  <T>(fields: readonly (keyof T & string)[]) =>
-  (row: Readonly<Record<string, unknown>>): T =>
-    Object.fromEntries(fields.map((field) => [field, row[field]])) as T;
-
-export const toBundleRow = pick<BundleRow>([
-  "id",
-  "platform",
-  "git_commit_hash",
-  "metadata",
-  "manifest_storage_uri",
-  "manifest_file_hash",
-  "asset_base_storage_uri",
-]);
-
-export const toPatchRow = pick<BundlePatchRow>([
-  "id",
-  "bundle_id",
-  "base_bundle_id",
-  "base_file_hash",
-  "patch_file_hash",
-  "patch_storage_uri",
-  "byte_size",
-  "order_index",
-]);
-
-export const toReleaseRow = pick<ReleaseRow>([
-  "id",
-  "revision",
-  "scope_key",
-  "channel_id",
-  "platform",
-  "kind",
-  "bundle_id",
-  "strategy",
-  "target_app_version",
-  "fingerprint_hash",
-  "enabled",
-  "should_force_update",
-  "message",
-  "rollout_cohort_count",
-  "target_cohorts",
-  "operation",
-  "source_release_id",
-  "created_at_ms",
-  "updated_at_ms",
-]);
-
-export const toCatalogRow = pick<ReleaseCatalogRow>([
-  "scope_key",
-  "catalog_id",
-  "strategy",
-  "channel_id",
-  "channel_key",
-  "platform",
-  "fingerprint_hash",
-  "generation",
-  "payload",
-  "catalog_hash",
-  "byte_size",
-  "is_tombstone",
-  "updated_at_ms",
-]);
-
-export const toChannelRow = pick<ChannelRow>(["id", "name"]);
-
-/** Every page of one read, in order. */
-export const drain = async <T>(
-  read: (page: { readonly cursor?: string }) => Promise<Page<T>>,
-): Promise<T[]> => {
-  const rows: T[] = [];
-  let cursor: string | undefined;
-  do {
-    const page = await read(cursor === undefined ? {} : { cursor });
-    rows.push(...page.rows);
-    cursor = page.next;
-  } while (cursor !== undefined);
-  return rows;
-};
-
-export interface CoreStorage {
-  readonly readStorageText?: (storageUri: string) => Promise<string | null>;
-  readonly resolveFileUrl: (
-    storageUri: string | null,
-  ) => Promise<string | null>;
-}
-
-/** Core's reads, each through one declared index or key. */
-export const createCoreReads = (db: CoreDatabase, storage: CoreStorage) => {
-  /** A bundle row's patches, exactly as many as its reference counter holds. */
-  const detail = async (
-    row: ReadRow<CoreSchema["bundles"]>,
-  ): Promise<BundleDetail> => {
-    const count = row._refs_bundle_patches_bundle_id ?? 0;
-    const patches: BundlePatchRow[] = [];
-    let cursor: string | undefined;
-    while (patches.length < count) {
-      const page = await db.findMany("bundle_patches", {
-        index: "byBundle",
-        where: { bundle_id: row.id },
-        limit: Math.min(count - patches.length, PAGE),
-        ...(cursor === undefined ? {} : { cursor }),
-      });
-      patches.push(...page.rows.map(toPatchRow));
-      if (page.next === undefined) break;
-      cursor = page.next;
-    }
-    return {
-      bundle: toBundleRow(row),
-      patches,
-      // a reference counter, so cascades cannot make it drift
-      childCount: row._refs_bundle_patches_base_bundle_id ?? 0,
-    };
-  };
-
-  const after = (input: KeysetInput) =>
-    input.after === undefined
-      ? {}
-      : {
-          range:
-            (input.order ?? "asc") === "asc"
-              ? { gt: input.after }
-              : { lt: input.after },
-        };
-
-  return {
-    /** The update check: one point read of its scope's catalog. */
-    async getReleaseCatalog(
-      input: ReleaseCatalogRequest,
-    ): Promise<ReleaseCatalog | null> {
-      const scopeKey = releaseCatalogScopeKeyOf(input);
-      const row = await db.findOne("release_catalogs", { scope_key: scopeKey });
-      return projectReleaseCatalogRow(
-        row === null ? null : toCatalogRow(row),
-        input,
-        scopeKey,
-      );
-    },
-
-    /** Artifact resolution: one batch read of both bundles and one unique read of their patch. */
-    async getArtifactInfo(
-      targetBundleId: string,
-      currentBundleId: string,
-      artifactProtocolVersion: 1,
-    ): Promise<ArtifactInfo | null> {
-      const { readStorageText } = storage;
-      if (
-        artifactProtocolVersion !== ARTIFACT_PROTOCOL_VERSION ||
-        readStorageText === undefined
-      ) {
-        return null;
-      }
-      const withCurrent = currentBundleId !== NIL_UUID;
-      const [[target, current], patch] = await Promise.all([
-        db.findByKeys(
-          "bundles",
-          withCurrent
-            ? [{ id: targetBundleId }, { id: currentBundleId }]
-            : [{ id: targetBundleId }],
-        ),
-        withCurrent
-          ? db.findOne("bundle_patches", {
-              bundle_id: targetBundleId,
-              base_bundle_id: currentBundleId,
-            })
-          : null,
-      ]);
-      if (target === null || target === undefined) return null;
-      return resolveManifestArtifacts({
-        currentBundle: current ? rowToBundle(toBundleRow(current)) : null,
-        readStorageText,
-        resolveFileUrl: storage.resolveFileUrl,
-        targetBundle: rowToBundle(
-          toBundleRow(target),
-          patch === null ? [] : [toPatchRow(patch)],
-        ),
-      });
-    },
-
-    /** A bundle, its patches, and how many patches start from it. */
-    async getBundle(id: string): Promise<BundleDetail | null> {
-      const row = await db.findOne("bundles", { id });
-      return row === null ? null : detail(row);
-    },
-
-    /** One page of the patches that start from a bundle, by target bundle id. */
-    /** Each base bundle's reference counter: one batch read of the bundle rows, and no patches. */
-    async countBundleChildren(
-      baseBundleIds: readonly string[],
-    ): Promise<Record<string, number>> {
-      const ids = [...new Set(baseBundleIds)];
-      if (ids.length === 0) return {};
-      const rows = await db.findByKeys(
-        "bundles",
-        ids.map((id) => ({ id })),
-      );
-      return Object.fromEntries(
-        ids.map((id, position) => [
-          id,
-          rows[position]?._refs_bundle_patches_base_bundle_id ?? 0,
-        ]),
-      );
-    },
-
-    async listPatchesFromBase(
-      baseBundleId: string,
-      input: KeysetInput,
-    ): Promise<BundlePatchRow[]> {
-      const page = await db.findMany("bundle_patches", {
-        index: "byBase",
-        where: { base_bundle_id: baseBundleId },
-        order: input.order ?? "asc",
-        limit: input.limit,
-        ...after(input),
-      });
-      return page.rows.map(toPatchRow);
-    },
-
-    /** One page of bundles with their patches, oldest or newest first, optionally for one platform. */
-    async listBundles(
-      input: KeysetInput & { readonly platform?: "ios" | "android" },
-    ): Promise<BundleDetail[]> {
-      const page =
-        input.platform === undefined
-          ? await db.findMany("bundles", {
-              index: "all",
-              where: {},
-              order: input.order ?? "asc",
-              limit: input.limit,
-              ...after(input),
-            })
-          : await db.findMany("bundles", {
-              index: "byPlatform",
-              where: { platform: input.platform },
-              order: input.order ?? "asc",
-              limit: input.limit,
-              ...after(input),
-            });
-      return Promise.all(page.rows.map(detail));
-    },
-
-    /** Bundles in total or for one platform: one counter row. */
-    async countBundles(platform?: "ios" | "android"): Promise<number> {
-      const { rows } = await db.findAggregates("bundle_totals", {
-        index: "byPlatform",
-        where: { platform_key: platform ?? "*" },
-        limit: 1,
-      });
-      return rows[0]?.bundles ?? 0;
-    },
-
-    /** Auto-patch bases for a new bundle: one point read of its scope's catalog. */
-    async findBaseBundleIds(
-      candidateKey: string,
-      bundleId: string,
-      limit: number,
-    ): Promise<string[]> {
-      const query = parseBaseCandidateKey(candidateKey);
-      if (query === null) return [];
-      const row = await db.findOne("release_catalogs", {
-        scope_key: query.scopeKey,
-      });
-      return row === null
-        ? []
-        : baseBundleIdsOf(toCatalogRow(row), query.range, bundleId, limit);
-    },
-
-    async getRelease(id: string): Promise<ReleaseRow | null> {
-      const row = await db.findOne("releases", { id });
-      return row === null ? null : toReleaseRow(row);
-    },
-
-    /** One page of releases through the index its filter names. */
-    async listReleases(
-      input: KeysetInput & { readonly filter: ReleaseFilter },
-    ): Promise<ReleaseRow[]> {
-      const { filter } = input;
-      const options = {
-        order: input.order ?? "asc",
-        limit: input.limit,
-        ...after(input),
-      } as const;
-      const page =
-        filter.kind === "all"
-          ? await db.findMany("releases", {
-              index: "all",
-              where: {},
-              ...options,
-            })
-          : filter.kind === "bundle"
-            ? await db.findMany("releases", {
-                index: "byBundle",
-                where: { bundle_id: filter.bundleId },
-                ...options,
-              })
-            : filter.kind === "scope"
-              ? filter.enabled === undefined
-                ? await db.findMany("releases", {
-                    index: "byScope",
-                    where: { scope_key: filter.scopeKey },
-                    ...options,
-                  })
-                : await db.findMany("releases", {
-                    index: "byScopeEnabled",
-                    where: {
-                      scope_key: filter.scopeKey,
-                      enabled: filter.enabled,
-                    },
-                    ...options,
-                  })
-              : filter.enabled === undefined
-                ? await db.findMany("releases", {
-                    index: "byChannelPlatform",
-                    where: {
-                      channel_id: filter.channelId,
-                      platform: filter.platform,
-                    },
-                    ...options,
-                  })
-                : await db.findMany("releases", {
-                    index: "byChannelPlatformEnabled",
-                    where: {
-                      channel_id: filter.channelId,
-                      platform: filter.platform,
-                      enabled: filter.enabled,
-                    },
-                    ...options,
-                  });
-      return page.rows.map(toReleaseRow);
-    },
-
-    /** A scope's newest release id: `byScope` descending, limit 1. */
-    async latestReleaseId(scopeKey: string): Promise<string | null> {
-      const { rows } = await db.findMany("releases", {
-        index: "byScope",
-        where: { scope_key: scopeKey },
-        order: "desc",
-        limit: 1,
-      });
-      return rows[0]?.id ?? null;
-    },
-
-    async getReleaseCatalogRow(
-      scopeKey: string,
-    ): Promise<ReleaseCatalogRow | null> {
-      const row = await db.findOne("release_catalogs", { scope_key: scopeKey });
-      return row === null ? null : toCatalogRow(row);
-    },
-
-    async listReleaseCatalogs(
-      input: KeysetInput,
-    ): Promise<ReleaseCatalogRow[]> {
-      const page = await db.findMany("release_catalogs", {
-        index: "all",
-        where: {},
-        order: input.order ?? "asc",
-        limit: input.limit,
-        ...after(input),
-      });
-      return page.rows.map(toCatalogRow);
-    },
-
-    /** Every channel, by name. */
-    async listChannels(): Promise<ChannelRow[]> {
-      const rows = await drain((page) =>
-        db.findMany("channels", {
-          index: "all",
-          where: {},
-          limit: PAGE,
-          ...page,
-        }),
-      );
-      return rows.map(toChannelRow);
-    },
-
-    async findChannelByName(name: string): Promise<ChannelRow | null> {
-      const row = await db.findOne("channels", { name });
-      return row === null ? null : toChannelRow(row);
-    },
-  };
-};
-
-export type CoreReads = ReturnType<typeof createCoreReads>;