@hot-updater/plugin-core 0.36.7 → 1.0.0-rc.0

package/dist/databasePluginCrudValidationQueries.mjs

@@ -0,0 +1,97 @@
+import { DatabasePluginInputError } from "./databasePluginCrudValidationErrors.mjs";
+import { isBooleanField, isNumberField, isRecord, isStringField, modelValidators, sortableFields, validateField, validateFields } from "./databasePluginCrudValidationFields.mjs";
+//#region src/databasePluginCrudValidationQueries.ts
+const validateSelect = (model, select) => {
+	if (select === void 0) return;
+	if (!Array.isArray(select) || select.length === 0) throw new DatabasePluginInputError("empty-select");
+	if (!select.every((field) => typeof field === "string")) throw new DatabasePluginInputError("invalid-query");
+	validateFields(model, select);
+};
+const validateWhereValue = (model, condition) => {
+	const field = condition.field;
+	if (typeof field !== "string") throw new DatabasePluginInputError("invalid-query");
+	validateField(model, field);
+	const operator = condition.operator ?? "eq";
+	const value = condition.value;
+	const mode = condition.mode;
+	if (mode !== void 0 && mode !== "sensitive" && mode !== "insensitive") throw new DatabasePluginInputError("invalid-query");
+	switch (operator) {
+		case "eq":
+		case "ne":
+			if (!(isStringField(field) || isNumberField(field) || isBooleanField(field)) || !modelValidators[model][field]?.(value) || mode !== void 0 && (!isStringField(field) || typeof value !== "string")) throw new DatabasePluginInputError("invalid-query");
+			return;
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte":
+			if (mode !== void 0 || !(isStringField(field) || isNumberField(field)) || value === null || !modelValidators[model][field]?.(value)) throw new DatabasePluginInputError("invalid-query");
+			return;
+		case "in":
+		case "not_in":
+			if (!Array.isArray(value) || mode !== void 0) throw new DatabasePluginInputError("invalid-query");
+			if (!(isStringField(field) || isNumberField(field) || isBooleanField(field))) throw new DatabasePluginInputError("invalid-query");
+			if (!value.every((item) => modelValidators[model][field]?.(item))) throw new DatabasePluginInputError("invalid-query");
+			return;
+		case "contains":
+		case "starts_with":
+		case "ends_with":
+			if (!isStringField(field) || typeof value !== "string" || !modelValidators[model][field]?.(value)) throw new DatabasePluginInputError("invalid-query");
+			return;
+		default: throw new DatabasePluginInputError("invalid-query");
+	}
+};
+const validateWhere = (model, where) => {
+	if (where === void 0) return;
+	if (!Array.isArray(where)) throw new DatabasePluginInputError("invalid-query");
+	for (const item of where) {
+		if (!isRecord(item)) throw new DatabasePluginInputError("invalid-query");
+		if (item.connector !== void 0 && item.connector !== "AND" && item.connector !== "OR") throw new DatabasePluginInputError("invalid-query");
+		validateWhereValue(model, item);
+	}
+};
+const validateDistinctFields = (model, fields) => {
+	if (fields === void 0) return void 0;
+	if (!Array.isArray(fields) || fields.length === 0) throw new DatabasePluginInputError("invalid-distinct");
+	if (!fields.every((field) => typeof field === "string")) throw new DatabasePluginInputError("invalid-distinct");
+	validateFields(model, fields);
+	return fields;
+};
+const validateOrderBy = (model, orderBy) => {
+	if (orderBy === void 0) return void 0;
+	if (!Array.isArray(orderBy) || orderBy.length === 0) throw new DatabasePluginInputError("invalid-query");
+	const fields = /* @__PURE__ */ new Set();
+	return orderBy.map((clause) => {
+		if (!isRecord(clause) || typeof clause.field !== "string") throw new DatabasePluginInputError("invalid-query");
+		validateField(model, clause.field);
+		if (!sortableFields[model].has(clause.field)) throw new DatabasePluginInputError("invalid-query");
+		if (clause.direction !== "asc" && clause.direction !== "desc") throw new DatabasePluginInputError("invalid-query");
+		if (clause.nulls !== void 0 && clause.nulls !== "first" && clause.nulls !== "last") throw new DatabasePluginInputError("invalid-query");
+		if (fields.has(clause.field)) throw new DatabasePluginInputError("invalid-operation");
+		fields.add(clause.field);
+		return clause;
+	});
+};
+const validateDistinctOn = (model, distinctOn, orderBy) => {
+	if (distinctOn === void 0) return;
+	if (!isRecord(distinctOn)) throw new DatabasePluginInputError("invalid-distinct");
+	const fields = validateDistinctFields(model, distinctOn.fields);
+	if (fields === void 0 || orderBy === void 0) throw new DatabasePluginInputError("invalid-distinct");
+	for (const [index, field] of fields.entries()) if (orderBy[index]?.field !== field) throw new DatabasePluginInputError("invalid-distinct");
+};
+const validatePagination = (limit, offset) => {
+	const effectiveLimit = limit ?? 100;
+	const effectiveOffset = offset ?? 0;
+	if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 0) || offset !== void 0 && (!Number.isSafeInteger(offset) || offset < 0) || !Number.isSafeInteger(effectiveOffset + effectiveLimit)) throw new DatabasePluginInputError("invalid-pagination");
+};
+const validateBundlePagination = (options) => {
+	if (!Number.isSafeInteger(options.limit) || options.limit <= 0 || options.page !== void 0 && (!Number.isSafeInteger(options.page) || options.page <= 0) || options.page !== void 0 && options.cursor !== void 0) throw new DatabasePluginInputError("invalid-pagination");
+	const cursor = options.cursor;
+	if (cursor === void 0) return;
+	if (!isRecord(cursor)) throw new DatabasePluginInputError("invalid-pagination");
+	const hasAfter = Object.hasOwn(cursor, "after");
+	if (hasAfter === Object.hasOwn(cursor, "before")) throw new DatabasePluginInputError("invalid-pagination");
+	const value = hasAfter ? cursor.after : cursor.before;
+	if (typeof value !== "string" || value.length === 0) throw new DatabasePluginInputError("invalid-pagination");
+};
+//#endregion
+export { validateBundlePagination, validateDistinctFields, validateDistinctOn, validateOrderBy, validatePagination, validateSelect, validateWhere };

package/dist/databasePluginCrudValidationRows.cjs

@@ -0,0 +1,55 @@
+const require_databasePluginCrudValidationErrors = require("./databasePluginCrudValidationErrors.cjs");
+const require_databaseFields = require("./types/databaseFields.cjs");
+const require_databasePluginCrudValidationFields = require("./databasePluginCrudValidationFields.cjs");
+//#region src/databasePluginCrudValidationRows.ts
+const hasValidReleaseInvariants = (data) => {
+	const kind = data.kind;
+	const bundleId = data.bundle_id;
+	const strategy = data.strategy;
+	const targetAppVersion = data.target_app_version;
+	const fingerprintHash = data.fingerprint_hash;
+	return (kind === "BUNDLE" && typeof bundleId === "string" || kind === "EMBEDDED" && bundleId === null) && (strategy === "APP_VERSION" && typeof targetAppVersion === "string" && fingerprintHash === null || strategy === "FINGERPRINT" && targetAppVersion === null && typeof fingerprintHash === "string");
+};
+const hasValidBundleEventInvariants = (data) => (data.type === "UPDATE_APPLIED" || data.type === "RECOVERED" || data.type === "RELEASE_ADOPTED") && typeof data.from_bundle_id === "string" && (data.update_strategy === "fingerprint" || data.update_strategy === "appVersion") || data.type === "UNCHANGED" && data.from_bundle_id === null && data.update_strategy === null;
+const validateCreateData = (model, data) => {
+	if (!require_databasePluginCrudValidationFields.isRecord(data)) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-data");
+	require_databasePluginCrudValidationFields.validateFields(model, Object.keys(data));
+	for (const field of require_databaseFields.databaseFields[model]) {
+		const validator = require_databasePluginCrudValidationFields.modelValidators[model][field];
+		if (!Object.hasOwn(data, field) || !validator || !validator(Reflect.get(data, field))) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-data");
+	}
+	if (model === "bundles" && data.target_app_version === null && data.fingerprint_hash === null) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-data");
+	if (model === "releases" && !hasValidReleaseInvariants(data)) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-data");
+	if (model === "release_catalogs" && (data.strategy === "APP_VERSION" && data.fingerprint_hash !== null || data.strategy === "FINGERPRINT" && typeof data.fingerprint_hash !== "string")) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-data");
+	if (model === "bundle_events" && !hasValidBundleEventInvariants(data)) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-data");
+};
+const selectRow = (row, input) => {
+	const { select } = input;
+	if (!select) return row;
+	return Object.fromEntries(select.map((field) => [field, Reflect.get(row, field)]));
+};
+const validateResult = (model, row, select) => {
+	if (!require_databasePluginCrudValidationFields.isRecord(row)) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-result");
+	const fields = select ?? require_databaseFields.databaseFields[model];
+	for (const field of fields) {
+		const validator = require_databasePluginCrudValidationFields.modelValidators[model][field];
+		if (!Object.hasOwn(row, field) || !validator || !validator(Reflect.get(row, field))) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-result");
+	}
+	if (model === "bundles" && Object.hasOwn(row, "target_app_version") && Object.hasOwn(row, "fingerprint_hash") && Reflect.get(row, "target_app_version") === null && Reflect.get(row, "fingerprint_hash") === null) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-result");
+	if (model === "releases" && [
+		"kind",
+		"bundle_id",
+		"strategy",
+		"target_app_version",
+		"fingerprint_hash"
+	].every((field) => Object.hasOwn(row, field)) && !hasValidReleaseInvariants(row)) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-result");
+	if (model === "bundle_events" && [
+		"type",
+		"from_bundle_id",
+		"update_strategy"
+	].every((field) => Object.hasOwn(row, field)) && !hasValidBundleEventInvariants(row)) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-result");
+};
+//#endregion
+exports.selectRow = selectRow;
+exports.validateCreateData = validateCreateData;
+exports.validateResult = validateResult;

package/dist/databasePluginCrudValidationRows.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/databasePluginCrudValidationRows.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/databasePluginCrudValidationRows.mjs

@@ -0,0 +1,53 @@
+import { DatabasePluginInputError } from "./databasePluginCrudValidationErrors.mjs";
+import { databaseFields } from "./types/databaseFields.mjs";
+import { isRecord, modelValidators, validateFields } from "./databasePluginCrudValidationFields.mjs";
+//#region src/databasePluginCrudValidationRows.ts
+const hasValidReleaseInvariants = (data) => {
+	const kind = data.kind;
+	const bundleId = data.bundle_id;
+	const strategy = data.strategy;
+	const targetAppVersion = data.target_app_version;
+	const fingerprintHash = data.fingerprint_hash;
+	return (kind === "BUNDLE" && typeof bundleId === "string" || kind === "EMBEDDED" && bundleId === null) && (strategy === "APP_VERSION" && typeof targetAppVersion === "string" && fingerprintHash === null || strategy === "FINGERPRINT" && targetAppVersion === null && typeof fingerprintHash === "string");
+};
+const hasValidBundleEventInvariants = (data) => (data.type === "UPDATE_APPLIED" || data.type === "RECOVERED" || data.type === "RELEASE_ADOPTED") && typeof data.from_bundle_id === "string" && (data.update_strategy === "fingerprint" || data.update_strategy === "appVersion") || data.type === "UNCHANGED" && data.from_bundle_id === null && data.update_strategy === null;
+const validateCreateData = (model, data) => {
+	if (!isRecord(data)) throw new DatabasePluginInputError("invalid-data");
+	validateFields(model, Object.keys(data));
+	for (const field of databaseFields[model]) {
+		const validator = modelValidators[model][field];
+		if (!Object.hasOwn(data, field) || !validator || !validator(Reflect.get(data, field))) throw new DatabasePluginInputError("invalid-data");
+	}
+	if (model === "bundles" && data.target_app_version === null && data.fingerprint_hash === null) throw new DatabasePluginInputError("invalid-data");
+	if (model === "releases" && !hasValidReleaseInvariants(data)) throw new DatabasePluginInputError("invalid-data");
+	if (model === "release_catalogs" && (data.strategy === "APP_VERSION" && data.fingerprint_hash !== null || data.strategy === "FINGERPRINT" && typeof data.fingerprint_hash !== "string")) throw new DatabasePluginInputError("invalid-data");
+	if (model === "bundle_events" && !hasValidBundleEventInvariants(data)) throw new DatabasePluginInputError("invalid-data");
+};
+const selectRow = (row, input) => {
+	const { select } = input;
+	if (!select) return row;
+	return Object.fromEntries(select.map((field) => [field, Reflect.get(row, field)]));
+};
+const validateResult = (model, row, select) => {
+	if (!isRecord(row)) throw new DatabasePluginInputError("invalid-result");
+	const fields = select ?? databaseFields[model];
+	for (const field of fields) {
+		const validator = modelValidators[model][field];
+		if (!Object.hasOwn(row, field) || !validator || !validator(Reflect.get(row, field))) throw new DatabasePluginInputError("invalid-result");
+	}
+	if (model === "bundles" && Object.hasOwn(row, "target_app_version") && Object.hasOwn(row, "fingerprint_hash") && Reflect.get(row, "target_app_version") === null && Reflect.get(row, "fingerprint_hash") === null) throw new DatabasePluginInputError("invalid-result");
+	if (model === "releases" && [
+		"kind",
+		"bundle_id",
+		"strategy",
+		"target_app_version",
+		"fingerprint_hash"
+	].every((field) => Object.hasOwn(row, field)) && !hasValidReleaseInvariants(row)) throw new DatabasePluginInputError("invalid-result");
+	if (model === "bundle_events" && [
+		"type",
+		"from_bundle_id",
+		"update_strategy"
+	].every((field) => Object.hasOwn(row, field)) && !hasValidBundleEventInvariants(row)) throw new DatabasePluginInputError("invalid-result");
+};
+//#endregion
+export { selectRow, validateCreateData, validateResult };

package/dist/databasePluginTransaction.cjs

@@ -0,0 +1,7 @@
+const require_databasePluginCrud = require("./databasePluginCrud.cjs");
+//#region src/databasePluginTransaction.ts
+const createTransactionDatabasePlugin = (implementation) => {
+	return require_databasePluginCrud.createDatabasePluginCrud(implementation);
+};
+//#endregion
+exports.createTransactionDatabasePlugin = createTransactionDatabasePlugin;

package/dist/databasePluginTransaction.mjs

@@ -0,0 +1,7 @@
+import { createDatabasePluginCrud } from "./databasePluginCrud.mjs";
+//#region src/databasePluginTransaction.ts
+const createTransactionDatabasePlugin = (implementation) => {
+	return createDatabasePluginCrud(implementation);
+};
+//#endregion
+export { createTransactionDatabasePlugin };

package/dist/databaseRows.cjs

@@ -0,0 +1,149 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_databaseMetadata = require("./databaseMetadata.cjs");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/databaseRows.ts
+const releaseToRow = (release, scopeKey) => ({
+	id: release.id,
+	revision: release.revision,
+	scope_key: scopeKey,
+	channel_id: release.channelId,
+	platform: release.platform,
+	kind: release.kind,
+	bundle_id: release.bundleId,
+	strategy: release.strategy,
+	target_app_version: release.targetAppVersion,
+	fingerprint_hash: release.fingerprintHash,
+	enabled: release.enabled,
+	should_force_update: release.shouldForceUpdate,
+	message: release.message,
+	rollout_cohort_count: release.rolloutCohortCount,
+	target_cohorts: release.targetCohorts,
+	operation: release.operation,
+	source_release_id: release.sourceReleaseId,
+	created_at_ms: release.createdAtMs,
+	updated_at_ms: release.updatedAtMs
+});
+const releaseRowToRelease = (row) => ({
+	id: row.id,
+	revision: row.revision,
+	channelId: row.channel_id,
+	platform: row.platform,
+	kind: row.kind,
+	bundleId: row.bundle_id,
+	strategy: row.strategy,
+	targetAppVersion: row.target_app_version,
+	fingerprintHash: row.fingerprint_hash,
+	enabled: row.enabled,
+	shouldForceUpdate: row.should_force_update,
+	message: row.message,
+	rolloutCohortCount: row.rollout_cohort_count,
+	targetCohorts: row.target_cohorts,
+	operation: row.operation,
+	sourceReleaseId: row.source_release_id,
+	createdAtMs: row.created_at_ms,
+	updatedAtMs: row.updated_at_ms
+});
+const BundleRowHydrationErrorReason = {
+	duplicatePatchId: "duplicate_patch_id",
+	orphanPatchOwner: "orphan_patch_owner",
+	orphanPatchBase: "orphan_patch_base"
+};
+var BundleRowHydrationError = class extends Error {
+	name = "BundleRowHydrationError";
+	reason;
+	patchId;
+	bundleId;
+	constructor({ reason, patchId, bundleId }) {
+		super(`Cannot hydrate bundle rows: ${reason} for patch "${patchId}" and bundle "${bundleId}".`);
+		this.reason = reason;
+		this.patchId = patchId;
+		this.bundleId = bundleId;
+	}
+};
+const bundleToRow = (bundle) => {
+	const metadata = require_databaseMetadata.bundleMetadataToRow(bundle.metadata);
+	return {
+		id: bundle.id,
+		platform: bundle.platform,
+		file_hash: bundle.fileHash,
+		git_commit_hash: bundle.gitCommitHash,
+		storage_uri: bundle.storageUri,
+		archive_byte_size: bundle.archiveByteSize,
+		metadata,
+		manifest_storage_uri: (0, _hot_updater_core.getManifestStorageUri)(bundle),
+		manifest_file_hash: (0, _hot_updater_core.getManifestFileHash)(bundle),
+		asset_base_storage_uri: (0, _hot_updater_core.getAssetBaseStorageUri)(bundle)
+	};
+};
+const bundleToPatchRows = (bundle) => (0, _hot_updater_core.getBundlePatches)(bundle).map((patch, orderIndex) => ({
+	id: `${bundle.id}:${patch.baseBundleId}`,
+	bundle_id: bundle.id,
+	base_bundle_id: patch.baseBundleId,
+	base_file_hash: patch.baseFileHash,
+	patch_file_hash: patch.patchFileHash,
+	patch_storage_uri: patch.patchStorageUri,
+	byte_size: patch.byteSize,
+	order_index: orderIndex
+}));
+const comparePatchRows = (left, right) => left.order_index - right.order_index || left.id.localeCompare(right.id);
+const patchRowToArtifact = (row) => ({
+	baseBundleId: row.base_bundle_id,
+	baseFileHash: row.base_file_hash,
+	byteSize: row.byte_size,
+	patchFileHash: row.patch_file_hash,
+	patchStorageUri: row.patch_storage_uri
+});
+const rowToBundle = (row, patchRows = []) => {
+	const patches = patchRows.slice().sort(comparePatchRows).map(patchRowToArtifact);
+	return {
+		id: row.id,
+		platform: row.platform,
+		fileHash: row.file_hash,
+		gitCommitHash: row.git_commit_hash,
+		storageUri: row.storage_uri,
+		archiveByteSize: row.archive_byte_size,
+		metadata: (0, _hot_updater_core.stripBundleArtifactMetadata)(row.metadata),
+		manifestStorageUri: row.manifest_storage_uri,
+		manifestFileHash: row.manifest_file_hash,
+		assetBaseStorageUri: row.asset_base_storage_uri,
+		patches
+	};
+};
+const rowsToBundles = (bundleRows, patchRows, referencedBundleRows) => {
+	const ownerIds = new Set(bundleRows.map(({ id }) => id));
+	const baseIds = new Set(ownerIds);
+	for (const row of referencedBundleRows) baseIds.add(row.id);
+	const patchIds = /* @__PURE__ */ new Set();
+	const patchesByOwner = /* @__PURE__ */ new Map();
+	for (const patch of patchRows) {
+		if (patchIds.has(patch.id)) throw new BundleRowHydrationError({
+			reason: BundleRowHydrationErrorReason.duplicatePatchId,
+			patchId: patch.id,
+			bundleId: patch.bundle_id
+		});
+		patchIds.add(patch.id);
+		if (!ownerIds.has(patch.bundle_id)) throw new BundleRowHydrationError({
+			reason: BundleRowHydrationErrorReason.orphanPatchOwner,
+			patchId: patch.id,
+			bundleId: patch.bundle_id
+		});
+		if (!baseIds.has(patch.base_bundle_id)) throw new BundleRowHydrationError({
+			reason: BundleRowHydrationErrorReason.orphanPatchBase,
+			patchId: patch.id,
+			bundleId: patch.base_bundle_id
+		});
+		const ownerPatches = patchesByOwner.get(patch.bundle_id) ?? [];
+		ownerPatches.push(patch);
+		patchesByOwner.set(patch.bundle_id, ownerPatches);
+	}
+	return bundleRows.map((row) => rowToBundle(row, patchesByOwner.get(row.id) ?? []));
+};
+//#endregion
+exports.BundleRowHydrationError = BundleRowHydrationError;
+exports.BundleRowHydrationErrorReason = BundleRowHydrationErrorReason;
+exports.bundleToPatchRows = bundleToPatchRows;
+exports.bundleToRow = bundleToRow;
+exports.releaseRowToRelease = releaseRowToRelease;
+exports.releaseToRow = releaseToRow;
+exports.rowToBundle = rowToBundle;
+exports.rowsToBundles = rowsToBundles;

package/dist/databaseRows.d.cts

@@ -0,0 +1,34 @@
+import { BundlePatchRow, BundleRow, ReleaseRow } from "./types/databaseRows.cjs";
+import { Bundle, Release } from "@hot-updater/core";
+
+//#region src/databaseRows.d.ts
+declare const releaseToRow: (release: Release, scopeKey: string) => ReleaseRow;
+declare const releaseRowToRelease: (row: ReleaseRow) => Release;
+declare const BundleRowHydrationErrorReason: {
+  readonly duplicatePatchId: "duplicate_patch_id";
+  readonly orphanPatchOwner: "orphan_patch_owner";
+  readonly orphanPatchBase: "orphan_patch_base";
+};
+type BundleRowHydrationErrorReason = (typeof BundleRowHydrationErrorReason)[keyof typeof BundleRowHydrationErrorReason];
+type BundleRowHydrationErrorInput = {
+  readonly reason: BundleRowHydrationErrorReason;
+  readonly patchId: string;
+  readonly bundleId: string;
+};
+declare class BundleRowHydrationError extends Error {
+  readonly name = "BundleRowHydrationError";
+  readonly reason: BundleRowHydrationErrorReason;
+  readonly patchId: string;
+  readonly bundleId: string;
+  constructor({
+    reason,
+    patchId,
+    bundleId
+  }: BundleRowHydrationErrorInput);
+}
+declare const bundleToRow: (bundle: Bundle) => BundleRow;
+declare const bundleToPatchRows: (bundle: Bundle) => BundlePatchRow[];
+declare const rowToBundle: (row: BundleRow, patchRows?: readonly BundlePatchRow[]) => Bundle;
+declare const rowsToBundles: (bundleRows: readonly BundleRow[], patchRows: readonly BundlePatchRow[], referencedBundleRows: readonly BundleRow[]) => Bundle[];
+//#endregion
+export { BundleRowHydrationError, BundleRowHydrationErrorReason, bundleToPatchRows, bundleToRow, releaseRowToRelease, releaseToRow, rowToBundle, rowsToBundles };

package/dist/databaseRows.d.mts

@@ -0,0 +1,34 @@
+import { BundlePatchRow, BundleRow, ReleaseRow } from "./types/databaseRows.mjs";
+import { Bundle, Release } from "@hot-updater/core";
+
+//#region src/databaseRows.d.ts
+declare const releaseToRow: (release: Release, scopeKey: string) => ReleaseRow;
+declare const releaseRowToRelease: (row: ReleaseRow) => Release;
+declare const BundleRowHydrationErrorReason: {
+  readonly duplicatePatchId: "duplicate_patch_id";
+  readonly orphanPatchOwner: "orphan_patch_owner";
+  readonly orphanPatchBase: "orphan_patch_base";
+};
+type BundleRowHydrationErrorReason = (typeof BundleRowHydrationErrorReason)[keyof typeof BundleRowHydrationErrorReason];
+type BundleRowHydrationErrorInput = {
+  readonly reason: BundleRowHydrationErrorReason;
+  readonly patchId: string;
+  readonly bundleId: string;
+};
+declare class BundleRowHydrationError extends Error {
+  readonly name = "BundleRowHydrationError";
+  readonly reason: BundleRowHydrationErrorReason;
+  readonly patchId: string;
+  readonly bundleId: string;
+  constructor({
+    reason,
+    patchId,
+    bundleId
+  }: BundleRowHydrationErrorInput);
+}
+declare const bundleToRow: (bundle: Bundle) => BundleRow;
+declare const bundleToPatchRows: (bundle: Bundle) => BundlePatchRow[];
+declare const rowToBundle: (row: BundleRow, patchRows?: readonly BundlePatchRow[]) => Bundle;
+declare const rowsToBundles: (bundleRows: readonly BundleRow[], patchRows: readonly BundlePatchRow[], referencedBundleRows: readonly BundleRow[]) => Bundle[];
+//#endregion
+export { BundleRowHydrationError, BundleRowHydrationErrorReason, bundleToPatchRows, bundleToRow, releaseRowToRelease, releaseToRow, rowToBundle, rowsToBundles };

package/dist/databaseRows.mjs

@@ -0,0 +1,141 @@
+import { bundleMetadataToRow } from "./databaseMetadata.mjs";
+import { getAssetBaseStorageUri, getBundlePatches, getManifestFileHash, getManifestStorageUri, stripBundleArtifactMetadata } from "@hot-updater/core";
+//#region src/databaseRows.ts
+const releaseToRow = (release, scopeKey) => ({
+	id: release.id,
+	revision: release.revision,
+	scope_key: scopeKey,
+	channel_id: release.channelId,
+	platform: release.platform,
+	kind: release.kind,
+	bundle_id: release.bundleId,
+	strategy: release.strategy,
+	target_app_version: release.targetAppVersion,
+	fingerprint_hash: release.fingerprintHash,
+	enabled: release.enabled,
+	should_force_update: release.shouldForceUpdate,
+	message: release.message,
+	rollout_cohort_count: release.rolloutCohortCount,
+	target_cohorts: release.targetCohorts,
+	operation: release.operation,
+	source_release_id: release.sourceReleaseId,
+	created_at_ms: release.createdAtMs,
+	updated_at_ms: release.updatedAtMs
+});
+const releaseRowToRelease = (row) => ({
+	id: row.id,
+	revision: row.revision,
+	channelId: row.channel_id,
+	platform: row.platform,
+	kind: row.kind,
+	bundleId: row.bundle_id,
+	strategy: row.strategy,
+	targetAppVersion: row.target_app_version,
+	fingerprintHash: row.fingerprint_hash,
+	enabled: row.enabled,
+	shouldForceUpdate: row.should_force_update,
+	message: row.message,
+	rolloutCohortCount: row.rollout_cohort_count,
+	targetCohorts: row.target_cohorts,
+	operation: row.operation,
+	sourceReleaseId: row.source_release_id,
+	createdAtMs: row.created_at_ms,
+	updatedAtMs: row.updated_at_ms
+});
+const BundleRowHydrationErrorReason = {
+	duplicatePatchId: "duplicate_patch_id",
+	orphanPatchOwner: "orphan_patch_owner",
+	orphanPatchBase: "orphan_patch_base"
+};
+var BundleRowHydrationError = class extends Error {
+	name = "BundleRowHydrationError";
+	reason;
+	patchId;
+	bundleId;
+	constructor({ reason, patchId, bundleId }) {
+		super(`Cannot hydrate bundle rows: ${reason} for patch "${patchId}" and bundle "${bundleId}".`);
+		this.reason = reason;
+		this.patchId = patchId;
+		this.bundleId = bundleId;
+	}
+};
+const bundleToRow = (bundle) => {
+	const metadata = bundleMetadataToRow(bundle.metadata);
+	return {
+		id: bundle.id,
+		platform: bundle.platform,
+		file_hash: bundle.fileHash,
+		git_commit_hash: bundle.gitCommitHash,
+		storage_uri: bundle.storageUri,
+		archive_byte_size: bundle.archiveByteSize,
+		metadata,
+		manifest_storage_uri: getManifestStorageUri(bundle),
+		manifest_file_hash: getManifestFileHash(bundle),
+		asset_base_storage_uri: getAssetBaseStorageUri(bundle)
+	};
+};
+const bundleToPatchRows = (bundle) => getBundlePatches(bundle).map((patch, orderIndex) => ({
+	id: `${bundle.id}:${patch.baseBundleId}`,
+	bundle_id: bundle.id,
+	base_bundle_id: patch.baseBundleId,
+	base_file_hash: patch.baseFileHash,
+	patch_file_hash: patch.patchFileHash,
+	patch_storage_uri: patch.patchStorageUri,
+	byte_size: patch.byteSize,
+	order_index: orderIndex
+}));
+const comparePatchRows = (left, right) => left.order_index - right.order_index || left.id.localeCompare(right.id);
+const patchRowToArtifact = (row) => ({
+	baseBundleId: row.base_bundle_id,
+	baseFileHash: row.base_file_hash,
+	byteSize: row.byte_size,
+	patchFileHash: row.patch_file_hash,
+	patchStorageUri: row.patch_storage_uri
+});
+const rowToBundle = (row, patchRows = []) => {
+	const patches = patchRows.slice().sort(comparePatchRows).map(patchRowToArtifact);
+	return {
+		id: row.id,
+		platform: row.platform,
+		fileHash: row.file_hash,
+		gitCommitHash: row.git_commit_hash,
+		storageUri: row.storage_uri,
+		archiveByteSize: row.archive_byte_size,
+		metadata: stripBundleArtifactMetadata(row.metadata),
+		manifestStorageUri: row.manifest_storage_uri,
+		manifestFileHash: row.manifest_file_hash,
+		assetBaseStorageUri: row.asset_base_storage_uri,
+		patches
+	};
+};
+const rowsToBundles = (bundleRows, patchRows, referencedBundleRows) => {
+	const ownerIds = new Set(bundleRows.map(({ id }) => id));
+	const baseIds = new Set(ownerIds);
+	for (const row of referencedBundleRows) baseIds.add(row.id);
+	const patchIds = /* @__PURE__ */ new Set();
+	const patchesByOwner = /* @__PURE__ */ new Map();
+	for (const patch of patchRows) {
+		if (patchIds.has(patch.id)) throw new BundleRowHydrationError({
+			reason: BundleRowHydrationErrorReason.duplicatePatchId,
+			patchId: patch.id,
+			bundleId: patch.bundle_id
+		});
+		patchIds.add(patch.id);
+		if (!ownerIds.has(patch.bundle_id)) throw new BundleRowHydrationError({
+			reason: BundleRowHydrationErrorReason.orphanPatchOwner,
+			patchId: patch.id,
+			bundleId: patch.bundle_id
+		});
+		if (!baseIds.has(patch.base_bundle_id)) throw new BundleRowHydrationError({
+			reason: BundleRowHydrationErrorReason.orphanPatchBase,
+			patchId: patch.id,
+			bundleId: patch.base_bundle_id
+		});
+		const ownerPatches = patchesByOwner.get(patch.bundle_id) ?? [];
+		ownerPatches.push(patch);
+		patchesByOwner.set(patch.bundle_id, ownerPatches);
+	}
+	return bundleRows.map((row) => rowToBundle(row, patchesByOwner.get(row.id) ?? []));
+};
+//#endregion
+export { BundleRowHydrationError, BundleRowHydrationErrorReason, bundleToPatchRows, bundleToRow, releaseRowToRelease, releaseToRow, rowToBundle, rowsToBundles };