@hot-updater/server 1.0.0-rc.1 → 1.0.0-rc.16

package/dist/core/reads.d.mts

@@ -0,0 +1,48 @@
+import "../database/engineReads.mjs";
+import { HotUpdaterDatabase } from "../database/database.mjs";
+import { ReleaseCatalogRequest } from "../db/releaseCatalog.mjs";
+import { CoreSchema } from "./schema.mjs";
+import { BundleDetail, BundlePatchRow, ChannelRow, KeysetInput, ReleaseCatalogRow, ReleaseFilter, ReleaseRow } from "@hot-updater/plugin-core";
+import { ArtifactInfo, ReleaseCatalog } from "@hot-updater/core";
+//#region src/core/reads.d.ts
+type CoreDatabase = HotUpdaterDatabase<CoreSchema>;
+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. */
+declare const createCoreReads: (db: CoreDatabase, storage: CoreStorage) => {
+  /** The update check: one point read of its scope's catalog. */
+  getReleaseCatalog(input: ReleaseCatalogRequest): Promise<ReleaseCatalog | null>;
+  /** Artifact resolution: one batch read of both bundles and one unique read of their patch. */
+  getArtifactInfo(targetBundleId: string, currentBundleId: string, artifactProtocolVersion: 1): Promise<ArtifactInfo | null>;
+  /** A bundle, its patches, and how many patches start from it. */
+  getBundle(id: string): Promise<BundleDetail | null>;
+  /** 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. */
+  countBundleChildren(baseBundleIds: readonly string[]): Promise<Record<string, number>>;
+  listPatchesFromBase(baseBundleId: string, input: KeysetInput): Promise<BundlePatchRow[]>;
+  /** One page of bundles with their patches, oldest or newest first, optionally for one platform. */
+  listBundles(input: KeysetInput & {
+    readonly platform?: "ios" | "android";
+  }): Promise<BundleDetail[]>;
+  /** Bundles in total or for one platform: one counter row. */
+  countBundles(platform?: "ios" | "android"): Promise<number>;
+  /** Auto-patch bases for a new bundle: one point read of its scope's catalog. */
+  findBaseBundleIds(candidateKey: string, bundleId: string, limit: number): Promise<string[]>;
+  getRelease(id: string): Promise<ReleaseRow | null>;
+  /** One page of releases through the index its filter names. */
+  listReleases(input: KeysetInput & {
+    readonly filter: ReleaseFilter;
+  }): Promise<ReleaseRow[]>;
+  /** A scope's newest release id: `byScope` descending, limit 1. */
+  latestReleaseId(scopeKey: string): Promise<string | null>;
+  getReleaseCatalogRow(scopeKey: string): Promise<ReleaseCatalogRow | null>;
+  listReleaseCatalogs(input: KeysetInput): Promise<ReleaseCatalogRow[]>;
+  /** Every channel, by name. */
+  listChannels(): Promise<ChannelRow[]>;
+  findChannelByName(name: string): Promise<ChannelRow | null>;
+};
+type CoreReads = ReturnType<typeof createCoreReads>;
+//#endregion
+export { type BundleDetail, CoreDatabase, CoreReads, CoreStorage, type KeysetInput, type ReleaseFilter, createCoreReads };

package/dist/core/reads.mjs

@@ -0,0 +1,267 @@
+import { projectReleaseCatalogRow, releaseCatalogScopeKeyOf } from "../db/releaseCatalog.mjs";
+import { resolveManifestArtifacts } from "../db/updateArtifacts.mjs";
+import { baseBundleIdsOf, parseBaseCandidateKey } from "./baseCandidates.mjs";
+import { rowToBundle } from "@hot-updater/plugin-core";
+import { ARTIFACT_PROTOCOL_VERSION, NIL_UUID } from "@hot-updater/core";
+//#region src/core/reads.ts
+const PAGE = 500;
+const pick = (fields) => (row) => Object.fromEntries(fields.map((field) => [field, row[field]]));
+const toBundleRow = pick([
+	"id",
+	"platform",
+	"git_commit_hash",
+	"metadata",
+	"manifest_storage_uri",
+	"manifest_file_hash",
+	"asset_base_storage_uri"
+]);
+const toPatchRow = pick([
+	"id",
+	"bundle_id",
+	"base_bundle_id",
+	"base_file_hash",
+	"patch_file_hash",
+	"patch_storage_uri",
+	"byte_size",
+	"order_index"
+]);
+const toReleaseRow = pick([
+	"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"
+]);
+const toCatalogRow = pick([
+	"scope_key",
+	"catalog_id",
+	"strategy",
+	"channel_id",
+	"channel_key",
+	"platform",
+	"fingerprint_hash",
+	"generation",
+	"payload",
+	"catalog_hash",
+	"byte_size",
+	"is_tombstone",
+	"updated_at_ms"
+]);
+const toChannelRow = pick(["id", "name"]);
+/** Every page of one read, in order. */
+const drain = async (read) => {
+	const rows = [];
+	let cursor;
+	do {
+		const page = await read(cursor === void 0 ? {} : { cursor });
+		rows.push(...page.rows);
+		cursor = page.next;
+	} while (cursor !== void 0);
+	return rows;
+};
+/** Core's reads, each through one declared index or key. */
+const createCoreReads = (db, storage) => {
+	/** A bundle row's patches, exactly as many as its reference counter holds. */
+	const detail = async (row) => {
+		const count = row._refs_bundle_patches_bundle_id ?? 0;
+		const patches = [];
+		let cursor;
+		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 === void 0 ? {} : { cursor }
+			});
+			patches.push(...page.rows.map(toPatchRow));
+			if (page.next === void 0) break;
+			cursor = page.next;
+		}
+		return {
+			bundle: toBundleRow(row),
+			patches,
+			childCount: row._refs_bundle_patches_base_bundle_id ?? 0
+		};
+	};
+	const after = (input) => input.after === void 0 ? {} : { 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) {
+			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, currentBundleId, artifactProtocolVersion) {
+			const { readStorageText } = storage;
+			if (artifactProtocolVersion !== ARTIFACT_PROTOCOL_VERSION || readStorageText === void 0) 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 === void 0) 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) {
+			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) {
+			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, input) {
+			return (await db.findMany("bundle_patches", {
+				index: "byBase",
+				where: { base_bundle_id: baseBundleId },
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			})).rows.map(toPatchRow);
+		},
+		/** One page of bundles with their patches, oldest or newest first, optionally for one platform. */
+		async listBundles(input) {
+			const page = input.platform === void 0 ? 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) {
+			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, bundleId, limit) {
+			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) {
+			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) {
+			const { filter } = input;
+			const options = {
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			};
+			return (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 === void 0 ? 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 === void 0 ? 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
+			})).rows.map(toReleaseRow);
+		},
+		/** A scope's newest release id: `byScope` descending, limit 1. */
+		async latestReleaseId(scopeKey) {
+			const { rows } = await db.findMany("releases", {
+				index: "byScope",
+				where: { scope_key: scopeKey },
+				order: "desc",
+				limit: 1
+			});
+			return rows[0]?.id ?? null;
+		},
+		async getReleaseCatalogRow(scopeKey) {
+			const row = await db.findOne("release_catalogs", { scope_key: scopeKey });
+			return row === null ? null : toCatalogRow(row);
+		},
+		async listReleaseCatalogs(input) {
+			return (await db.findMany("release_catalogs", {
+				index: "all",
+				where: {},
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			})).rows.map(toCatalogRow);
+		},
+		/** Every channel, by name. */
+		async listChannels() {
+			return (await drain((page) => db.findMany("channels", {
+				index: "all",
+				where: {},
+				limit: PAGE,
+				...page
+			}))).map(toChannelRow);
+		},
+		async findChannelByName(name) {
+			const row = await db.findOne("channels", { name });
+			return row === null ? null : toChannelRow(row);
+		}
+	};
+};
+//#endregion
+export { createCoreReads, drain, toBundleRow, toCatalogRow, toChannelRow, toPatchRow, toReleaseRow };

package/dist/core/releases.cjs

@@ -0,0 +1,193 @@
+const require_reads = require("./reads.cjs");
+const require_writes = require("./writes.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/core/releases.ts
+const PAGE = 500;
+const fail = (code, message) => {
+	throw new _hot_updater_plugin_core.ReleaseCatalogMutationError(code, message);
+};
+const checkScope = (scope) => {
+	const channelKey = (0, _hot_updater_core.encodeChannelKey)(scope.channelName);
+	const expected = scope.strategy === "APP_VERSION" ? (0, _hot_updater_core.createReleaseCatalogScopeKey)({
+		channelKey,
+		platform: scope.platform,
+		strategy: "APP_VERSION"
+	}) : (0, _hot_updater_core.createReleaseCatalogScopeKey)({
+		channelKey,
+		fingerprintHash: scope.fingerprintHash ?? "",
+		platform: scope.platform,
+		strategy: "FINGERPRINT"
+	});
+	if (scope.strategy === "FINGERPRINT" !== (scope.fingerprintHash !== null) || scope.scopeKey !== expected) fail("INVALID_SCOPE", "Release catalog scope metadata is inconsistent");
+};
+/** A scope's enabled releases, all of them, under the catalog's guard. */
+const enabledReleases = async (tx, scopeKey) => {
+	const rows = [];
+	let cursor;
+	do {
+		const page = await tx.findMany("releases", {
+			index: "byScopeEnabled",
+			where: {
+				scope_key: scopeKey,
+				enabled: true
+			},
+			limit: PAGE,
+			...cursor === void 0 ? {} : { cursor }
+		});
+		rows.push(...page.rows.map(require_reads.toReleaseRow));
+		cursor = page.next;
+	} while (cursor !== void 0);
+	return rows;
+};
+/** The scope's newest release id: `byScope` descending, limit 1. */
+const latestReleaseId = async (tx, scopeKey) => {
+	const { rows } = await tx.findMany("releases", {
+		index: "byScope",
+		where: { scope_key: scopeKey },
+		order: "desc",
+		limit: 1
+	});
+	return rows[0]?.id ?? null;
+};
+/** Compiles `enabled` and writes it as the scope's next catalog generation. */
+const writeCatalog = async (tx, scope, stored, enabled, updatedAtMs) => {
+	const compilation = await (0, _hot_updater_plugin_core.compileReleaseCatalog)({
+		strategy: scope.strategy,
+		releases: enabled.map(_hot_updater_plugin_core.releaseRowToRelease)
+	});
+	const generation = (stored.generation ?? 0) + 1;
+	if (!Number.isSafeInteger(generation)) fail("CATALOG_GENERATION_EXHAUSTED", `Catalog "${scope.scopeKey}" exhausted its generation counter`);
+	const catalog = {
+		scope_key: scope.scopeKey,
+		catalog_id: stored.catalog?.catalog_id ?? (0, _hot_updater_plugin_core.createUUIDv7)(),
+		strategy: scope.strategy,
+		channel_id: scope.channelId,
+		channel_key: (0, _hot_updater_core.encodeChannelKey)(scope.channelName),
+		platform: scope.platform,
+		fingerprint_hash: scope.fingerprintHash,
+		generation,
+		payload: compilation.canonicalPayload,
+		catalog_hash: compilation.catalogHash,
+		byte_size: compilation.byteSize,
+		is_tombstone: compilation.payload.releaseDescriptors.length === 0,
+		updated_at_ms: updatedAtMs
+	};
+	const { scope_key: _scopeKey, ...set } = catalog;
+	if (stored.row === null) tx.create("release_catalogs", catalog);
+	else tx.update("release_catalogs", stored.row, set);
+	return {
+		catalog,
+		compilation
+	};
+};
+/** The scope's catalog row, and its compiled catalog and generation if it has one. */
+const readCatalog = async (tx, scopeKey) => {
+	const row = await tx.findOne("release_catalogs", { scope_key: scopeKey });
+	return {
+		row,
+		generation: row?.generation ?? null,
+		catalog: row === null ? null : require_reads.toCatalogRow(row)
+	};
+};
+/** A scope with releases and no compiled catalog lost its history. */
+const assertHistory = (stored, hasReleases) => {
+	if (stored.catalog === null && hasReleases) fail("CATALOG_IDENTITY_MISSING", "Catalog history is missing. Restore its catalog row from backup before rebuilding or deploying.");
+};
+/** One release change and its scope's next catalog, inside `tx`. */
+const changeRelease = async (tx, { scope, change, bundle, updatedAtMs }) => {
+	checkScope(scope);
+	const stored = await readCatalog(tx, scope.scopeKey);
+	const enabled = await enabledReleases(tx, scope.scopeKey);
+	if (bundle !== void 0) {
+		require_writes.insertBundle(tx, bundle.row);
+		for (const patch of bundle.patches) tx.create("bundle_patches", patch);
+	}
+	let before = null;
+	let release;
+	if (change.operation === "insert") {
+		const latest = await latestReleaseId(tx, scope.scopeKey);
+		assertHistory(stored, latest !== null);
+		const floor = [latest, bundle && (0, _hot_updater_plugin_core.isUUIDv7)(bundle.row.id) ? bundle.row.id : null].filter((id) => id !== null).sort().at(-1);
+		const id = change.row.id ?? (0, _hot_updater_plugin_core.createUUIDv7After)(floor ?? null);
+		if (latest !== null && id <= latest) fail("NON_MONOTONIC_RELEASE_ID", `Release "${id}" must sort after "${latest}"`);
+		release = {
+			...change.row,
+			id
+		};
+		if (release.scope_key !== scope.scopeKey || release.channel_id !== scope.channelId || release.platform !== scope.platform || release.strategy !== scope.strategy || release.fingerprint_hash !== scope.fingerprintHash || release.revision !== 1) fail("INVALID_SCOPE", "Inserted Release does not match its catalog scope");
+		tx.create("releases", release);
+	} else {
+		const row = await tx.findOne("releases", { id: change.id });
+		if (row === null || row.scope_key !== scope.scopeKey) return fail("RELEASE_NOT_FOUND", `Release "${change.id}" was not found in scope "${scope.scopeKey}"`);
+		assertHistory(stored, true);
+		before = require_reads.toReleaseRow(row);
+		if (change.operation === "delete") {
+			await tx.delete("releases", row);
+			release = null;
+		} else {
+			const set = {
+				...change.update,
+				revision: before.revision + 1
+			};
+			tx.update("releases", row, set);
+			release = {
+				...before,
+				...set
+			};
+		}
+	}
+	const changedId = before?.id ?? release?.id;
+	const next = [...enabled.filter(({ id }) => id !== changedId), ...release?.enabled ? [release] : []].sort((left, right) => left.id < right.id ? -1 : 1);
+	const { catalog, compilation } = await writeCatalog(tx, scope, stored, next, updatedAtMs);
+	return {
+		catalog,
+		release,
+		diagnostics: compilation.diagnostics
+	};
+};
+/**
+* Release changes rooted at their catalogs: each reads its scope's catalog
+* and enabled releases, applies the change, and writes the next catalog
+* generation, all in one transaction. A concurrent change in a scope bumps
+* its catalog row, so this transaction reruns instead of publishing a stale
+* catalog.
+*/
+const changeReleases = (db, inputs) => {
+	if (new Set(inputs.map(({ scope }) => scope.scopeKey)).size !== inputs.length) fail("INVALID_SCOPE", "A batch cannot change one catalog scope twice");
+	return db.transaction(async (tx) => {
+		const results = [];
+		for (const input of inputs) results.push(await changeRelease(tx, input));
+		return results;
+	});
+};
+/** Recompiles a scope's catalog from its enabled releases inside `tx`; an unchanged catalog is not rewritten. */
+const rebuildScope = async (tx, scope, updatedAtMs) => {
+	checkScope(scope);
+	const stored = await readCatalog(tx, scope.scopeKey);
+	assertHistory(stored, await latestReleaseId(tx, scope.scopeKey) !== null);
+	const enabled = await enabledReleases(tx, scope.scopeKey);
+	const compilation = await (0, _hot_updater_plugin_core.compileReleaseCatalog)({
+		strategy: scope.strategy,
+		releases: enabled.map(_hot_updater_plugin_core.releaseRowToRelease)
+	});
+	const current = stored.catalog;
+	if (current !== null && current.strategy === scope.strategy && current.channel_id === scope.channelId && current.channel_key === (0, _hot_updater_core.encodeChannelKey)(scope.channelName) && current.platform === scope.platform && current.fingerprint_hash === scope.fingerprintHash && current.catalog_hash === compilation.catalogHash) return {
+		catalog: current,
+		current,
+		changed: false,
+		diagnostics: compilation.diagnostics
+	};
+	const written = await writeCatalog(tx, scope, stored, enabled, updatedAtMs);
+	return {
+		catalog: written.catalog,
+		current,
+		changed: true,
+		diagnostics: written.compilation.diagnostics
+	};
+};
+//#endregion
+exports.changeRelease = changeRelease;
+exports.changeReleases = changeReleases;
+exports.readCatalog = readCatalog;
+exports.rebuildScope = rebuildScope;