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

package/dist/databaseClient.mjs

@@ -0,0 +1,110 @@
+import { DatabaseAtomicCommitUnsupportedError, DatabaseRowReferencedError } from "./createDatabasePlugin.mjs";
+import { bundleToPatchRows, bundleToRow } from "./databaseRows.mjs";
+import { hydrateRows, responsePage } from "./databaseClientReads.mjs";
+import { DatabasePatchUpdateUnsupportedError, bundleUpdateToPatchRows, bundleUpdateToRow } from "./databaseClientUpdates.mjs";
+//#region src/databaseClient.ts
+var DatabaseBundleNotFoundError = class extends Error {
+	name = "DatabaseBundleNotFoundError";
+	constructor(bundleId) {
+		super(`Bundle "${bundleId}" was not found.`);
+		this.bundleId = bundleId;
+	}
+};
+var DatabasePatchInsertUnsupportedError = class extends Error {
+	name = "DatabasePatchInsertUnsupportedError";
+	constructor(bundleId, pluginName) {
+		super(`Database plugin "${pluginName}" cannot atomically insert patches for bundle "${bundleId}".`);
+		this.bundleId = bundleId;
+		this.pluginName = pluginName;
+	}
+};
+const insertChanges = (bundle) => [{
+	model: "bundles",
+	operation: "insert",
+	row: bundleToRow(bundle)
+}, ...bundleToPatchRows(bundle).map((row) => ({
+	model: "bundlePatches",
+	operation: "insert",
+	row
+}))];
+const updateChanges = (bundleId, update) => {
+	const rowUpdate = bundleUpdateToRow(update);
+	return [{
+		model: "bundles",
+		operation: "update",
+		where: { id: bundleId },
+		update: rowUpdate
+	}, ...Object.hasOwn(update, "patches") ? [{
+		model: "bundlePatches",
+		operation: "delete",
+		where: { bundleId }
+	}, ...bundleUpdateToPatchRows(bundleId, update).map((row) => ({
+		model: "bundlePatches",
+		operation: "insert",
+		row
+	}))] : []];
+};
+const deleteChanges = (bundleId) => [{
+	model: "bundles",
+	operation: "delete",
+	where: { id: bundleId }
+}];
+const createDatabaseClient = (plugin) => {
+	const getBundleById = async (id) => {
+		const row = await plugin.models.bundles.findById(id);
+		if (!row) return null;
+		return (await hydrateRows(plugin, [row]))[0] ?? null;
+	};
+	const insertChannel = (input) => plugin.models.channels.insert(input);
+	const createMutationClient = (commit) => ({
+		getBundleById,
+		getBundles: (options) => responsePage(plugin, options),
+		async getChannels() {
+			return (await plugin.models.channels.list({})).channels;
+		},
+		insertChannel,
+		async insertBundle(bundle) {
+			try {
+				await commit(insertChanges(bundle));
+			} catch (error) {
+				if (error instanceof DatabaseAtomicCommitUnsupportedError && bundleToPatchRows(bundle).length > 0) throw new DatabasePatchInsertUnsupportedError(bundle.id, plugin.name);
+				throw error;
+			}
+		},
+		async updateBundleById(bundleId, update) {
+			try {
+				if (!(await commit(updateChanges(bundleId, update))).committed) throw new DatabaseBundleNotFoundError(bundleId);
+			} catch (error) {
+				if (error instanceof DatabaseAtomicCommitUnsupportedError && Object.hasOwn(update, "patches")) throw new DatabasePatchUpdateUnsupportedError(bundleId, plugin.name);
+				throw error;
+			}
+		},
+		async deleteBundleById(bundleId) {
+			const result = await commit(deleteChanges(bundleId));
+			if (!result.committed && result.conflict.reason === "referenced") throw new DatabaseRowReferencedError();
+		}
+	});
+	const runMutation = async (operation) => {
+		const changes = [];
+		const result = await operation(createMutationClient(async (input) => {
+			changes.push(...input);
+			return { committed: true };
+		}));
+		if (changes.length === 0) return result;
+		const commitResult = await plugin.commit({ changes });
+		if (!commitResult.committed) {
+			const change = changes[commitResult.conflict.changeIndex];
+			if (commitResult.conflict.reason === "referenced" && change?.model === "bundles" && change.operation === "delete") throw new DatabaseRowReferencedError();
+			if (change?.model === "bundles" && change.operation === "update") throw new DatabaseBundleNotFoundError(change.where.id);
+			throw new Error(`Database plugin "${plugin.name}" rejected a commit.`);
+		}
+		return result;
+	};
+	return {
+		...createMutationClient((changes) => plugin.commit({ changes })),
+		deleteChannel: (input) => plugin.models.channels.delete(input),
+		mutate: runMutation
+	};
+};
+//#endregion
+export { DatabaseBundleNotFoundError, DatabasePatchInsertUnsupportedError, createDatabaseClient };

package/dist/databaseClientReads.cjs

@@ -0,0 +1,113 @@
+const require_calculatePagination = require("./calculatePagination.cjs");
+const require_databasePluginCrudValidationErrors = require("./databasePluginCrudValidationErrors.cjs");
+const require_databasePluginCrudValidationQueries = require("./databasePluginCrudValidationQueries.cjs");
+const require_databaseRows = require("./databaseRows.cjs");
+//#region src/databaseClientReads.ts
+const PAGE_SIZE = 100;
+const mergeIdFilter = (where, id) => ({
+	...where,
+	id: {
+		...where?.id,
+		...id
+	}
+});
+const loadBundleRows = async (database, where) => {
+	const finiteIds = where?.id?.in;
+	if (finiteIds) {
+		if (finiteIds.length === 0) return [];
+		return [...await database.models.bundles.findMany({
+			where,
+			limit: finiteIds.length,
+			offset: 0,
+			orderBy: {
+				field: "id",
+				direction: "asc"
+			}
+		})];
+	}
+	const [cutoff] = await database.models.bundles.findMany({
+		where,
+		limit: 1,
+		offset: 0,
+		orderBy: {
+			field: "id",
+			direction: "desc"
+		}
+	});
+	if (!cutoff) return [];
+	const rows = [];
+	let after;
+	for (;;) {
+		const page = await database.models.bundles.findMany({
+			where: mergeIdFilter(where, {
+				lte: cutoff.id,
+				...after ? { gt: after } : {}
+			}),
+			limit: PAGE_SIZE,
+			offset: 0,
+			orderBy: {
+				field: "id",
+				direction: "asc"
+			}
+		});
+		rows.push(...page);
+		if (page.length < PAGE_SIZE) return rows;
+		after = page.at(-1)?.id;
+	}
+};
+const hydrateRows = async (database, ownerRows) => {
+	const patchRows = await database.models.bundlePatches.findByBundleIds(ownerRows.map(({ id }) => id));
+	const ownerIds = new Set(ownerRows.map(({ id }) => id));
+	const referencedIds = [...new Set(patchRows.map(({ base_bundle_id }) => base_bundle_id).filter((id) => !ownerIds.has(id)))];
+	return require_databaseRows.rowsToBundles(ownerRows, patchRows, referencedIds.length === 0 ? [] : await loadBundleRows(database, { id: { in: referencedIds } }));
+};
+const cursorIdFilter = (cursor, direction) => {
+	if (cursor?.after) return { [direction === "desc" ? "lt" : "gt"]: cursor.after };
+	if (cursor?.before) return { [direction === "desc" ? "gt" : "lt"]: cursor.before };
+};
+const responsePage = async (database, options) => {
+	require_databasePluginCrudValidationQueries.validateBundlePagination(options);
+	const direction = options.orderBy?.direction ?? "desc";
+	const offset = options.page ? Math.max(0, options.page - 1) * options.limit : 0;
+	const cursor = options.page ? void 0 : options.cursor;
+	const queryLimit = cursor ? options.limit + 1 : options.limit;
+	if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(queryLimit) || !Number.isSafeInteger(offset + queryLimit)) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-pagination");
+	const cursorFilter = cursorIdFilter(cursor, direction);
+	const where = cursorFilter ? mergeIdFilter(options.where, cursorFilter) : options.where;
+	const queryDirection = cursor?.before ? direction === "desc" ? "asc" : "desc" : direction;
+	const [queriedRows, total] = await Promise.all([database.models.bundles.findMany({
+		where,
+		limit: queryLimit,
+		offset,
+		orderBy: {
+			field: "id",
+			direction: queryDirection
+		}
+	}), database.models.bundles.count(options.where)]);
+	const hasMore = cursor ? queriedRows.length > options.limit : false;
+	const pageRows = cursor ? queriedRows.slice(0, options.limit) : queriedRows;
+	const ownerRows = cursor?.before ? pageRows.toReversed() : pageRows;
+	const pagination = require_calculatePagination.calculatePagination(total, {
+		limit: options.limit,
+		offset
+	});
+	const hasPreviousPage = cursor ? Boolean(cursor.after) || hasMore : pagination.hasPreviousPage;
+	const hasNextPage = cursor ? Boolean(cursor.before) || hasMore : pagination.hasNextPage;
+	const firstId = ownerRows[0]?.id;
+	const lastId = ownerRows.at(-1)?.id;
+	return {
+		data: await hydrateRows(database, ownerRows),
+		pagination: {
+			...pagination,
+			hasNextPage,
+			hasPreviousPage,
+			...hasNextPage && lastId ? { nextCursor: lastId } : {},
+			...hasPreviousPage && firstId ? { previousCursor: firstId } : {},
+			...!firstId && cursor?.after ? { previousCursor: cursor.after } : {},
+			...!lastId && cursor?.before ? { nextCursor: cursor.before } : {}
+		}
+	};
+};
+//#endregion
+exports.hydrateRows = hydrateRows;
+exports.responsePage = responsePage;

package/dist/databaseClientReads.mjs

@@ -0,0 +1,112 @@
+import { calculatePagination } from "./calculatePagination.mjs";
+import { DatabasePluginInputError } from "./databasePluginCrudValidationErrors.mjs";
+import { validateBundlePagination } from "./databasePluginCrudValidationQueries.mjs";
+import { rowsToBundles } from "./databaseRows.mjs";
+//#region src/databaseClientReads.ts
+const PAGE_SIZE = 100;
+const mergeIdFilter = (where, id) => ({
+	...where,
+	id: {
+		...where?.id,
+		...id
+	}
+});
+const loadBundleRows = async (database, where) => {
+	const finiteIds = where?.id?.in;
+	if (finiteIds) {
+		if (finiteIds.length === 0) return [];
+		return [...await database.models.bundles.findMany({
+			where,
+			limit: finiteIds.length,
+			offset: 0,
+			orderBy: {
+				field: "id",
+				direction: "asc"
+			}
+		})];
+	}
+	const [cutoff] = await database.models.bundles.findMany({
+		where,
+		limit: 1,
+		offset: 0,
+		orderBy: {
+			field: "id",
+			direction: "desc"
+		}
+	});
+	if (!cutoff) return [];
+	const rows = [];
+	let after;
+	for (;;) {
+		const page = await database.models.bundles.findMany({
+			where: mergeIdFilter(where, {
+				lte: cutoff.id,
+				...after ? { gt: after } : {}
+			}),
+			limit: PAGE_SIZE,
+			offset: 0,
+			orderBy: {
+				field: "id",
+				direction: "asc"
+			}
+		});
+		rows.push(...page);
+		if (page.length < PAGE_SIZE) return rows;
+		after = page.at(-1)?.id;
+	}
+};
+const hydrateRows = async (database, ownerRows) => {
+	const patchRows = await database.models.bundlePatches.findByBundleIds(ownerRows.map(({ id }) => id));
+	const ownerIds = new Set(ownerRows.map(({ id }) => id));
+	const referencedIds = [...new Set(patchRows.map(({ base_bundle_id }) => base_bundle_id).filter((id) => !ownerIds.has(id)))];
+	return rowsToBundles(ownerRows, patchRows, referencedIds.length === 0 ? [] : await loadBundleRows(database, { id: { in: referencedIds } }));
+};
+const cursorIdFilter = (cursor, direction) => {
+	if (cursor?.after) return { [direction === "desc" ? "lt" : "gt"]: cursor.after };
+	if (cursor?.before) return { [direction === "desc" ? "gt" : "lt"]: cursor.before };
+};
+const responsePage = async (database, options) => {
+	validateBundlePagination(options);
+	const direction = options.orderBy?.direction ?? "desc";
+	const offset = options.page ? Math.max(0, options.page - 1) * options.limit : 0;
+	const cursor = options.page ? void 0 : options.cursor;
+	const queryLimit = cursor ? options.limit + 1 : options.limit;
+	if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(queryLimit) || !Number.isSafeInteger(offset + queryLimit)) throw new DatabasePluginInputError("invalid-pagination");
+	const cursorFilter = cursorIdFilter(cursor, direction);
+	const where = cursorFilter ? mergeIdFilter(options.where, cursorFilter) : options.where;
+	const queryDirection = cursor?.before ? direction === "desc" ? "asc" : "desc" : direction;
+	const [queriedRows, total] = await Promise.all([database.models.bundles.findMany({
+		where,
+		limit: queryLimit,
+		offset,
+		orderBy: {
+			field: "id",
+			direction: queryDirection
+		}
+	}), database.models.bundles.count(options.where)]);
+	const hasMore = cursor ? queriedRows.length > options.limit : false;
+	const pageRows = cursor ? queriedRows.slice(0, options.limit) : queriedRows;
+	const ownerRows = cursor?.before ? pageRows.toReversed() : pageRows;
+	const pagination = calculatePagination(total, {
+		limit: options.limit,
+		offset
+	});
+	const hasPreviousPage = cursor ? Boolean(cursor.after) || hasMore : pagination.hasPreviousPage;
+	const hasNextPage = cursor ? Boolean(cursor.before) || hasMore : pagination.hasNextPage;
+	const firstId = ownerRows[0]?.id;
+	const lastId = ownerRows.at(-1)?.id;
+	return {
+		data: await hydrateRows(database, ownerRows),
+		pagination: {
+			...pagination,
+			hasNextPage,
+			hasPreviousPage,
+			...hasNextPage && lastId ? { nextCursor: lastId } : {},
+			...hasPreviousPage && firstId ? { previousCursor: firstId } : {},
+			...!firstId && cursor?.after ? { previousCursor: cursor.after } : {},
+			...!lastId && cursor?.before ? { nextCursor: cursor.before } : {}
+		}
+	};
+};
+//#endregion
+export { hydrateRows, responsePage };

package/dist/databaseClientUpdates.cjs

@@ -0,0 +1,39 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_databaseMetadata = require("./databaseMetadata.cjs");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/databaseClientUpdates.ts
+var DatabasePatchUpdateUnsupportedError = class extends Error {
+	name = "DatabasePatchUpdateUnsupportedError";
+	constructor(bundleId, pluginName) {
+		super(`Database plugin "${pluginName}" cannot atomically replace patches for bundle "${bundleId}".`);
+		this.bundleId = bundleId;
+		this.pluginName = pluginName;
+	}
+};
+const bundleUpdateToRow = (update, _channelId) => {
+	return {
+		...update.platform !== void 0 ? { platform: update.platform } : {},
+		...update.fileHash !== void 0 ? { file_hash: update.fileHash } : {},
+		...update.gitCommitHash !== void 0 ? { git_commit_hash: update.gitCommitHash } : {},
+		...update.storageUri !== void 0 ? { storage_uri: update.storageUri } : {},
+		...update.archiveByteSize !== void 0 ? { archive_byte_size: update.archiveByteSize } : {},
+		...update.metadata !== void 0 ? { metadata: require_databaseMetadata.bundleMetadataToRow(update.metadata) } : {},
+		...update.manifestStorageUri !== void 0 ? { manifest_storage_uri: update.manifestStorageUri } : {},
+		...update.manifestFileHash !== void 0 ? { manifest_file_hash: update.manifestFileHash } : {},
+		...update.assetBaseStorageUri !== void 0 ? { asset_base_storage_uri: update.assetBaseStorageUri } : {}
+	};
+};
+const bundleUpdateToPatchRows = (bundleId, update) => (0, _hot_updater_core.getBundlePatches)({ patches: update.patches }).map((patch, orderIndex) => ({
+	id: `${bundleId}:${patch.baseBundleId}`,
+	bundle_id: bundleId,
+	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
+}));
+//#endregion
+exports.DatabasePatchUpdateUnsupportedError = DatabasePatchUpdateUnsupportedError;
+exports.bundleUpdateToPatchRows = bundleUpdateToPatchRows;
+exports.bundleUpdateToRow = bundleUpdateToRow;

package/dist/databaseClientUpdates.d.cts

@@ -0,0 +1,11 @@
+import { Bundle } from "@hot-updater/core";
+
+//#region src/databaseClientUpdates.d.ts
+declare class DatabasePatchUpdateUnsupportedError extends Error {
+  readonly bundleId: string;
+  readonly pluginName: string;
+  readonly name = "DatabasePatchUpdateUnsupportedError";
+  constructor(bundleId: string, pluginName: string);
+}
+//#endregion
+export { DatabasePatchUpdateUnsupportedError };

package/dist/databaseClientUpdates.d.mts

@@ -0,0 +1,11 @@
+import { Bundle } from "@hot-updater/core";
+
+//#region src/databaseClientUpdates.d.ts
+declare class DatabasePatchUpdateUnsupportedError extends Error {
+  readonly bundleId: string;
+  readonly pluginName: string;
+  readonly name = "DatabasePatchUpdateUnsupportedError";
+  constructor(bundleId: string, pluginName: string);
+}
+//#endregion
+export { DatabasePatchUpdateUnsupportedError };

package/dist/databaseClientUpdates.mjs

@@ -0,0 +1,36 @@
+import { bundleMetadataToRow } from "./databaseMetadata.mjs";
+import { getBundlePatches } from "@hot-updater/core";
+//#region src/databaseClientUpdates.ts
+var DatabasePatchUpdateUnsupportedError = class extends Error {
+	name = "DatabasePatchUpdateUnsupportedError";
+	constructor(bundleId, pluginName) {
+		super(`Database plugin "${pluginName}" cannot atomically replace patches for bundle "${bundleId}".`);
+		this.bundleId = bundleId;
+		this.pluginName = pluginName;
+	}
+};
+const bundleUpdateToRow = (update, _channelId) => {
+	return {
+		...update.platform !== void 0 ? { platform: update.platform } : {},
+		...update.fileHash !== void 0 ? { file_hash: update.fileHash } : {},
+		...update.gitCommitHash !== void 0 ? { git_commit_hash: update.gitCommitHash } : {},
+		...update.storageUri !== void 0 ? { storage_uri: update.storageUri } : {},
+		...update.archiveByteSize !== void 0 ? { archive_byte_size: update.archiveByteSize } : {},
+		...update.metadata !== void 0 ? { metadata: bundleMetadataToRow(update.metadata) } : {},
+		...update.manifestStorageUri !== void 0 ? { manifest_storage_uri: update.manifestStorageUri } : {},
+		...update.manifestFileHash !== void 0 ? { manifest_file_hash: update.manifestFileHash } : {},
+		...update.assetBaseStorageUri !== void 0 ? { asset_base_storage_uri: update.assetBaseStorageUri } : {}
+	};
+};
+const bundleUpdateToPatchRows = (bundleId, update) => getBundlePatches({ patches: update.patches }).map((patch, orderIndex) => ({
+	id: `${bundleId}:${patch.baseBundleId}`,
+	bundle_id: bundleId,
+	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
+}));
+//#endregion
+export { DatabasePatchUpdateUnsupportedError, bundleUpdateToPatchRows, bundleUpdateToRow };

package/dist/databaseJsonValue.cjs

@@ -0,0 +1,37 @@
+//#region src/databaseJsonValue.ts
+const isDatabaseJsonValue = (value) => {
+	const ancestors = /* @__PURE__ */ new WeakSet();
+	const validate = (input) => {
+		if (input === null || typeof input === "string" || typeof input === "boolean") return true;
+		if (typeof input === "number") return Number.isFinite(input);
+		if (typeof input !== "object") return false;
+		if (ancestors.has(input)) return false;
+		ancestors.add(input);
+		try {
+			if (Array.isArray(input)) {
+				if (Object.getPrototypeOf(input) !== Array.prototype) return false;
+				if (Reflect.ownKeys(input).length !== input.length + 1) return false;
+				for (let index = 0; index < input.length; index += 1) {
+					const descriptor = Object.getOwnPropertyDescriptor(input, String(index));
+					if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor) || !validate(descriptor.value)) return false;
+				}
+				return true;
+			}
+			const prototype = Object.getPrototypeOf(input);
+			if (prototype !== Object.prototype && prototype !== null) return false;
+			for (const key of Reflect.ownKeys(input)) {
+				if (typeof key !== "string" || key === "__proto__") return false;
+				const descriptor = Object.getOwnPropertyDescriptor(input, key);
+				if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor) || !validate(descriptor.value)) return false;
+			}
+			return true;
+		} finally {
+			ancestors.delete(input);
+		}
+	};
+	return validate(value);
+};
+const isDatabaseJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && isDatabaseJsonValue(value);
+const isDatabaseMetadataObject = (value) => isDatabaseJsonObject(value) && (!Object.hasOwn(value, "app_version") || typeof value["app_version"] === "string");
+//#endregion
+exports.isDatabaseMetadataObject = isDatabaseMetadataObject;

package/dist/databaseJsonValue.d.cts

@@ -0,0 +1,5 @@
+import { DatabaseBundleMetadata } from "./types/databaseRows.cjs";
+//#region src/databaseJsonValue.d.ts
+declare const isDatabaseMetadataObject: (value: unknown) => value is DatabaseBundleMetadata;
+//#endregion
+export { isDatabaseMetadataObject };

package/dist/databaseJsonValue.d.mts

@@ -0,0 +1,5 @@
+import { DatabaseBundleMetadata } from "./types/databaseRows.mjs";
+//#region src/databaseJsonValue.d.ts
+declare const isDatabaseMetadataObject: (value: unknown) => value is DatabaseBundleMetadata;
+//#endregion
+export { isDatabaseMetadataObject };

package/dist/databaseJsonValue.mjs

@@ -0,0 +1,37 @@
+//#region src/databaseJsonValue.ts
+const isDatabaseJsonValue = (value) => {
+	const ancestors = /* @__PURE__ */ new WeakSet();
+	const validate = (input) => {
+		if (input === null || typeof input === "string" || typeof input === "boolean") return true;
+		if (typeof input === "number") return Number.isFinite(input);
+		if (typeof input !== "object") return false;
+		if (ancestors.has(input)) return false;
+		ancestors.add(input);
+		try {
+			if (Array.isArray(input)) {
+				if (Object.getPrototypeOf(input) !== Array.prototype) return false;
+				if (Reflect.ownKeys(input).length !== input.length + 1) return false;
+				for (let index = 0; index < input.length; index += 1) {
+					const descriptor = Object.getOwnPropertyDescriptor(input, String(index));
+					if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor) || !validate(descriptor.value)) return false;
+				}
+				return true;
+			}
+			const prototype = Object.getPrototypeOf(input);
+			if (prototype !== Object.prototype && prototype !== null) return false;
+			for (const key of Reflect.ownKeys(input)) {
+				if (typeof key !== "string" || key === "__proto__") return false;
+				const descriptor = Object.getOwnPropertyDescriptor(input, key);
+				if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor) || !validate(descriptor.value)) return false;
+			}
+			return true;
+		} finally {
+			ancestors.delete(input);
+		}
+	};
+	return validate(value);
+};
+const isDatabaseJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && isDatabaseJsonValue(value);
+const isDatabaseMetadataObject = (value) => isDatabaseJsonObject(value) && (!Object.hasOwn(value, "app_version") || typeof value["app_version"] === "string");
+//#endregion
+export { isDatabaseMetadataObject };

package/dist/databaseMetadata.cjs

@@ -0,0 +1,13 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_databasePluginCrudValidationErrors = require("./databasePluginCrudValidationErrors.cjs");
+const require_databaseJsonValue = require("./databaseJsonValue.cjs");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/databaseMetadata.ts
+const bundleMetadataToRow = (metadata) => {
+	const value = (0, _hot_updater_core.stripBundleArtifactMetadata)(metadata);
+	if (value === void 0) return {};
+	if (!require_databaseJsonValue.isDatabaseMetadataObject(value)) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-data");
+	return value;
+};
+//#endregion
+exports.bundleMetadataToRow = bundleMetadataToRow;

package/dist/databaseMetadata.mjs

@@ -0,0 +1,12 @@
+import { DatabasePluginInputError } from "./databasePluginCrudValidationErrors.mjs";
+import { isDatabaseMetadataObject } from "./databaseJsonValue.mjs";
+import { stripBundleArtifactMetadata } from "@hot-updater/core";
+//#region src/databaseMetadata.ts
+const bundleMetadataToRow = (metadata) => {
+	const value = stripBundleArtifactMetadata(metadata);
+	if (value === void 0) return {};
+	if (!isDatabaseMetadataObject(value)) throw new DatabasePluginInputError("invalid-data");
+	return value;
+};
+//#endregion
+export { bundleMetadataToRow };

package/dist/databasePluginCrud.cjs

@@ -0,0 +1,86 @@
+const require_databasePluginCrudValidationErrors = require("./databasePluginCrudValidationErrors.cjs");
+const require_databasePluginCrudValidationFields = require("./databasePluginCrudValidationFields.cjs");
+const require_databasePluginCrudValidationRows = require("./databasePluginCrudValidationRows.cjs");
+const require_databasePluginCrudValidationMutations = require("./databasePluginCrudValidationMutations.cjs");
+const require_databasePluginCrudValidationQueries = require("./databasePluginCrudValidationQueries.cjs");
+//#region src/databasePluginCrud.ts
+const createDatabasePluginCrud = (implementation) => {
+	async function create(input) {
+		require_databasePluginCrudValidationFields.validateModel(input.model);
+		require_databasePluginCrudValidationRows.validateCreateData(input.model, input.data);
+		if (input.onConflict !== void 0 && !(input.onConflict === "ignore" && (input.model === "channels" || input.model === "api_keys"))) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-operation");
+		require_databasePluginCrudValidationQueries.validateSelect(input.model, input.select);
+		const row = await implementation.create(input);
+		require_databasePluginCrudValidationRows.validateResult(input.model, row, input.select);
+		return require_databasePluginCrudValidationRows.selectRow(row, input);
+	}
+	async function update(input) {
+		require_databasePluginCrudValidationFields.validateModel(input.model);
+		require_databasePluginCrudValidationQueries.validateWhere(input.model, input.where);
+		require_databasePluginCrudValidationMutations.validateMutationWhere(input.where);
+		require_databasePluginCrudValidationMutations.validateUpdateWhere(input.model, input.where);
+		if (input.model === "bundles") require_databasePluginCrudValidationMutations.validateBundleUpdateData(input.update);
+		else if (input.model === "releases") require_databasePluginCrudValidationMutations.validateReleaseUpdateData(input.update);
+		else if (input.model === "release_catalogs") require_databasePluginCrudValidationMutations.validateReleaseCatalogUpdateData(input.update);
+		else if (input.model === "api_keys") require_databasePluginCrudValidationMutations.validateApiKeyUpdateData(input.update);
+		else throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-operation");
+		require_databasePluginCrudValidationQueries.validateSelect(input.model, input.select);
+		if (input.model === "bundles") {} else if (input.model === "releases") await require_databasePluginCrudValidationMutations.validateReleaseTargetUpdate(implementation, input);
+		const row = await implementation.update(input);
+		if (row === null) return null;
+		require_databasePluginCrudValidationRows.validateResult(input.model, row, input.select);
+		return require_databasePluginCrudValidationRows.selectRow(row, input);
+	}
+	async function deleteRows(input) {
+		require_databasePluginCrudValidationFields.validateModel(input.model);
+		if (input.model !== "bundles" && input.model !== "bundle_patches" && input.model !== "releases" && input.model !== "channels") throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-operation");
+		require_databasePluginCrudValidationQueries.validateWhere(input.model, input.where);
+		require_databasePluginCrudValidationMutations.validateMutationWhere(input.where);
+		await implementation.delete(input);
+	}
+	async function count(input) {
+		require_databasePluginCrudValidationFields.validateModel(input.model);
+		require_databasePluginCrudValidationQueries.validateWhere(input.model, input.where);
+		require_databasePluginCrudValidationQueries.validateDistinctFields(input.model, input.distinct);
+		const value = await implementation.count(input);
+		if (!Number.isSafeInteger(value) || value < 0) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-result");
+		return value;
+	}
+	async function findOne(input) {
+		require_databasePluginCrudValidationFields.validateModel(input.model);
+		require_databasePluginCrudValidationQueries.validateWhere(input.model, input.where);
+		require_databasePluginCrudValidationQueries.validateSelect(input.model, input.select);
+		const row = await implementation.findOne(input);
+		if (row === null) return null;
+		require_databasePluginCrudValidationRows.validateResult(input.model, row, input.select);
+		return require_databasePluginCrudValidationRows.selectRow(row, input);
+	}
+	async function findMany(input) {
+		require_databasePluginCrudValidationFields.validateModel(input.model);
+		require_databasePluginCrudValidationQueries.validateWhere(input.model, input.where);
+		require_databasePluginCrudValidationQueries.validatePagination(input.limit, input.offset);
+		require_databasePluginCrudValidationQueries.validateSelect(input.model, input.select);
+		const validatedOrderBy = require_databasePluginCrudValidationQueries.validateOrderBy(input.model, input.orderBy);
+		require_databasePluginCrudValidationQueries.validateDistinctOn(input.model, input.distinctOn, validatedOrderBy);
+		const normalizedInput = {
+			...input,
+			orderBy: input.orderBy,
+			limit: input.limit ?? 100,
+			offset: input.offset ?? 0
+		};
+		const rows = await implementation.findMany(normalizedInput);
+		if (!Array.isArray(rows)) throw new require_databasePluginCrudValidationErrors.DatabasePluginInputError("invalid-result");
+		rows.forEach((row) => require_databasePluginCrudValidationRows.validateResult(input.model, row, input.select));
+		return rows.map((row) => require_databasePluginCrudValidationRows.selectRow(row, input));
+	}
+	return {
+		create,
+		update,
+		delete: deleteRows,
+		count,
+		findOne,
+		findMany
+	};
+};
+//#endregion
+exports.createDatabasePluginCrud = createDatabasePluginCrud;

package/dist/databasePluginCrud.d.cts

@@ -0,0 +1 @@
+import { DatabasePluginInputError, DatabasePluginInputErrorCode } from "./databasePluginCrudValidationErrors.cjs";

package/dist/databasePluginCrud.d.mts

@@ -0,0 +1 @@
+import { DatabasePluginInputError, DatabasePluginInputErrorCode } from "./databasePluginCrudValidationErrors.mjs";