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

package/dist/createDatabasePlugin.mjs

@@ -1,307 +1,796 @@
-import { calculatePagination } from "./calculatePagination.mjs";
-import { BundleUnitOfWork } from "./bundleUnitOfWork.mjs";
-import { getRequestBundleUnitOfWork } from "./bundleUnitOfWorkStore.mjs";
-import { mergeWith } from "es-toolkit";
+import { DatabasePluginInputError } from "./databasePluginCrudValidationErrors.mjs";
+import { isChannelText, isRecord } from "./databasePluginCrudValidationFields.mjs";
+import { validateCreateData, validateResult } from "./databasePluginCrudValidationRows.mjs";
+import { validateApiKeyUpdateData, validateBundleUpdateData, validateReleaseUpdateData } from "./databasePluginCrudValidationMutations.mjs";
+import { createDatabasePluginCrud } from "./databasePluginCrud.mjs";
+import { createTransactionDatabasePlugin } from "./databasePluginTransaction.mjs";
 //#region src/createDatabasePlugin.ts
-const REPLACE_ON_UPDATE_KEYS = ["patches", "targetCohorts"];
-const DEFAULT_DESC_ORDER = {
-	field: "id",
-	direction: "desc"
+const PAGE_SIZE = 100;
+const compareChannelRows = (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+var DatabaseAtomicCommitUnsupportedError = class extends Error {
+	name = "DatabaseAtomicCommitUnsupportedError";
+	constructor(pluginName) {
+		super(`Database plugin "${pluginName}" cannot atomically commit changes across models.`);
+		this.pluginName = pluginName;
+	}
 };
-function normalizePage(value) {
-	if (!Number.isInteger(value) || value === void 0 || value < 1) return;
-	return value;
-}
-function mergeBundleUpdate(baseBundle, patch) {
-	return mergeWith({ ...baseBundle }, patch, (_targetValue, sourceValue, key) => {
-		if (REPLACE_ON_UPDATE_KEYS.includes(key)) return sourceValue;
+/**
+* Internal provider signal for a delete rejected by a live reference.
+*
+* Provider implementations throw this after translating their native
+* foreign-key or reference-condition error. The public database contract
+* observes only the indexed `referenced` commit conflict.
+*/
+var DatabaseRowReferencedError = class extends Error {
+	name = "DatabaseRowReferencedError";
+	constructor() {
+		super("The database row is still referenced.");
+	}
+};
+var DatabaseCommitConflictError = class extends Error {
+	name = "DatabaseCommitConflictError";
+	constructor(result) {
+		super("Database commit precondition failed.");
+		this.result = result;
+	}
+};
+const toBundleWhere = (where) => {
+	if (!where) return [];
+	const filters = [];
+	if (where.platform !== void 0) filters.push({
+		field: "platform",
+		value: where.platform
 	});
-}
-function mergeIdFilter(base, patch) {
-	return {
-		...base,
-		...patch
-	};
-}
-function mergeWhereWithIdFilter(where, idFilter) {
-	return {
-		...where,
-		id: mergeIdFilter(where?.id, idFilter)
-	};
-}
-function buildCursorPageQuery(where, cursor, orderBy) {
-	const direction = orderBy.direction;
-	if (cursor.after) return {
-		reverseData: false,
-		where: mergeWhereWithIdFilter(where, { [direction === "desc" ? "lt" : "gt"]: cursor.after }),
-		orderBy
-	};
-	if (cursor.before) return {
-		reverseData: true,
-		where: mergeWhereWithIdFilter(where, { [direction === "desc" ? "gt" : "lt"]: cursor.before }),
-		orderBy: {
-			field: orderBy.field,
-			direction: direction === "desc" ? "asc" : "desc"
+	if (where.id?.eq !== void 0) filters.push({
+		field: "id",
+		value: where.id.eq
+	});
+	if (where.id?.gt !== void 0) filters.push({
+		field: "id",
+		operator: "gt",
+		value: where.id.gt
+	});
+	if (where.id?.gte !== void 0) filters.push({
+		field: "id",
+		operator: "gte",
+		value: where.id.gte
+	});
+	if (where.id?.lt !== void 0) filters.push({
+		field: "id",
+		operator: "lt",
+		value: where.id.lt
+	});
+	if (where.id?.lte !== void 0) filters.push({
+		field: "id",
+		operator: "lte",
+		value: where.id.lte
+	});
+	if (where.id?.in !== void 0) filters.push({
+		field: "id",
+		operator: "in",
+		value: where.id.in
+	});
+	return filters;
+};
+const assertReleaseReferences = async (database, row) => {
+	if (await database.findOne({
+		model: "channels",
+		where: [{
+			field: "id",
+			value: row.channel_id
+		}]
+	}) === null) throw new DatabasePluginInputError("invalid-data");
+	if (row.bundle_id !== null) {
+		const bundle = await database.findOne({
+			model: "bundles",
+			where: [{
+				field: "id",
+				value: row.bundle_id
+			}]
+		});
+		if (bundle === null || bundle.platform !== row.platform) throw new DatabasePluginInputError("invalid-data");
+	}
+};
+const applyChange = async (database, change, changeIndex) => {
+	switch (change.model) {
+		case "bundles": switch (change.operation) {
+			case "insert":
+				await database.create({
+					model: "bundles",
+					data: change.row
+				});
+				return;
+			case "update":
+				if (await database.update({
+					model: "bundles",
+					where: [{
+						field: "id",
+						value: change.where.id
+					}],
+					update: change.update
+				}) === null) throw new DatabaseCommitConflictError({
+					committed: false,
+					conflict: {
+						changeIndex,
+						reason: "not_found"
+					}
+				});
+				return;
+			case "delete":
+				if (await database.count({
+					model: "releases",
+					where: [{
+						field: "bundle_id",
+						value: change.where.id
+					}]
+				}) > 0) throw new DatabaseCommitConflictError({
+					committed: false,
+					conflict: {
+						changeIndex,
+						reason: "referenced"
+					}
+				});
+				await database.delete({
+					model: "bundles",
+					where: [{
+						field: "id",
+						value: change.where.id
+					}]
+				});
+				return;
 		}
-	};
-	return {
-		reverseData: false,
-		where: where ?? {},
-		orderBy
-	};
-}
-function buildCountBeforeWhere(where, firstBundleId, orderBy) {
-	return mergeWhereWithIdFilter(where, { [orderBy.direction === "desc" ? "gt" : "lt"]: firstBundleId });
+		case "releases": switch (change.operation) {
+			case "insert":
+				await assertReleaseReferences(database, change.row);
+				await database.create({
+					model: "releases",
+					data: change.row
+				});
+				return;
+			case "update":
+				if (await database.update({
+					model: "releases",
+					where: [{
+						field: "id",
+						value: change.where.id
+					}],
+					update: change.update
+				}) === null) throw new DatabaseCommitConflictError({
+					committed: false,
+					conflict: {
+						changeIndex,
+						reason: "not_found"
+					}
+				});
+				return;
+			case "delete":
+				await database.delete({
+					model: "releases",
+					where: [{
+						field: "id",
+						value: change.where.id
+					}]
+				});
+				return;
+		}
+		case "releaseCatalogs":
+			if (await database.findOne({
+				model: "release_catalogs",
+				where: [{
+					field: "scope_key",
+					value: change.row.scope_key
+				}]
+			}) === null) await database.create({
+				model: "release_catalogs",
+				data: change.row
+			});
+			else {
+				const { scope_key: _scopeKey, ...update } = change.row;
+				await database.update({
+					model: "release_catalogs",
+					where: [{
+						field: "scope_key",
+						value: change.row.scope_key
+					}],
+					update
+				});
+			}
+			return;
+		case "bundlePatches": switch (change.operation) {
+			case "insert":
+				await database.create({
+					model: "bundle_patches",
+					data: change.row
+				});
+				return;
+			case "delete":
+				await database.delete({
+					model: "bundle_patches",
+					where: [{
+						field: "bundle_id",
+						value: change.where.bundleId
+					}]
+				});
+				return;
+		}
+		case "channels": switch (change.operation) {
+			case "insert":
+				await database.create({
+					model: "channels",
+					data: change.row,
+					onConflict: change.onConflict
+				});
+				return;
+			case "delete":
+				if (await database.count({
+					model: "releases",
+					where: [{
+						field: "channel_id",
+						value: change.where.id
+					}]
+				}) > 0) throw new DatabaseCommitConflictError({
+					committed: false,
+					conflict: {
+						changeIndex,
+						reason: "referenced"
+					}
+				});
+				try {
+					await database.delete({
+						model: "channels",
+						where: [{
+							field: "id",
+							value: change.where.id
+						}]
+					});
+				} catch (error) {
+					if (error instanceof DatabaseRowReferencedError) throw new DatabaseCommitConflictError({
+						committed: false,
+						conflict: {
+							changeIndex,
+							reason: "referenced"
+						}
+					});
+					throw error;
+				}
+				return;
+		}
+		case "analytics":
+			await database.create({
+				model: "bundle_events",
+				data: change.row
+			});
+			return;
+		case "apiKeys": switch (change.operation) {
+			case "insert":
+				await database.create({
+					model: "api_keys",
+					data: change.row,
+					onConflict: change.onConflict
+				});
+				return;
+			case "update":
+				if (await database.update({
+					model: "api_keys",
+					where: [{
+						field: "id",
+						value: change.where.id
+					}],
+					update: { revoked_at_ms: change.update.revokedAtMs }
+				}) === null) throw new DatabaseCommitConflictError({
+					committed: false,
+					conflict: {
+						changeIndex,
+						reason: "not_found"
+					}
+				});
+				return;
+		}
+	}
+};
+const expectationVersion = async (database, expectation) => {
+	if (expectation.model === "releases") return (await database.findOne({
+		model: "releases",
+		where: [{
+			field: "id",
+			value: expectation.id
+		}],
+		select: ["revision"]
+	}))?.revision ?? null;
+	return (await database.findOne({
+		model: "release_catalogs",
+		where: [{
+			field: "scope_key",
+			value: expectation.scopeKey
+		}],
+		select: ["generation"]
+	}))?.generation ?? null;
+};
+const applyExpectations = async (database, expectations) => {
+	for (const expectation of expectations) {
+		const expectedVersion = expectation.model === "releases" ? expectation.revision : expectation.generation;
+		const actualVersion = await expectationVersion(database, expectation);
+		if (actualVersion !== expectedVersion) throw new DatabaseCommitConflictError({
+			committed: false,
+			conflict: {
+				actualVersion,
+				changeIndex: -1,
+				expectedVersion,
+				key: expectation.model === "releases" ? expectation.id : expectation.scopeKey,
+				model: expectation.model,
+				reason: "version_conflict"
+			}
+		});
+	}
+};
+const applyChanges = async (database, input) => {
+	await applyExpectations(database, input.expectations ?? []);
+	for (const [changeIndex, change] of input.changes.entries()) await applyChange(database, change, changeIndex);
+	return { committed: true };
+};
+const hasOnlyKeys = (value, keys) => {
+	return Reflect.ownKeys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+};
+const validateWhere = (where, field, validateValue = (value) => typeof value === "string") => {
+	if (!isRecord(where) || !hasOnlyKeys(where, [field]) || !validateValue(Reflect.get(where, field))) throw new DatabasePluginInputError("invalid-data");
+};
+const validateDatabaseChange = (change) => {
+	if (!isRecord(change)) throw new DatabasePluginInputError("invalid-data");
+	switch (change.model) {
+		case "bundles": switch (change.operation) {
+			case "insert":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"row"
+				])) throw new DatabasePluginInputError("invalid-data");
+				validateCreateData("bundles", change.row);
+				return;
+			case "update":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"where",
+					"update"
+				])) throw new DatabasePluginInputError("invalid-data");
+				validateWhere(change.where, "id");
+				validateBundleUpdateData(change.update);
+				return;
+			case "delete":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"where"
+				])) throw new DatabasePluginInputError("invalid-data");
+				validateWhere(change.where, "id");
+				return;
+			default: throw new DatabasePluginInputError("invalid-operation");
+		}
+		case "bundlePatches": switch (change.operation) {
+			case "insert":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"row"
+				])) throw new DatabasePluginInputError("invalid-data");
+				validateCreateData("bundle_patches", change.row);
+				return;
+			case "delete":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"where"
+				])) throw new DatabasePluginInputError("invalid-data");
+				validateWhere(change.where, "bundleId");
+				return;
+			default: throw new DatabasePluginInputError("invalid-operation");
+		}
+		case "releases": switch (change.operation) {
+			case "insert":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"row"
+				])) throw new DatabasePluginInputError("invalid-data");
+				validateCreateData("releases", change.row);
+				return;
+			case "update":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"where",
+					"update"
+				])) throw new DatabasePluginInputError("invalid-data");
+				validateWhere(change.where, "id");
+				validateReleaseUpdateData(change.update);
+				return;
+			case "delete":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"where"
+				])) throw new DatabasePluginInputError("invalid-data");
+				validateWhere(change.where, "id");
+				return;
+			default: throw new DatabasePluginInputError("invalid-operation");
+		}
+		case "releaseCatalogs":
+			if (change.operation !== "put" || !hasOnlyKeys(change, [
+				"model",
+				"operation",
+				"row"
+			])) throw new DatabasePluginInputError("invalid-operation");
+			validateCreateData("release_catalogs", change.row);
+			return;
+		case "channels": switch (change.operation) {
+			case "insert":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"row",
+					"onConflict"
+				]) || change.onConflict !== "ignore") throw new DatabasePluginInputError("invalid-operation");
+				validateCreateData("channels", change.row);
+				return;
+			case "delete":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"where"
+				])) throw new DatabasePluginInputError("invalid-data");
+				validateWhere(change.where, "id", isChannelText);
+				return;
+			default: throw new DatabasePluginInputError("invalid-operation");
+		}
+		case "analytics":
+			if (change.operation !== "insert" || !hasOnlyKeys(change, [
+				"model",
+				"operation",
+				"row"
+			])) throw new DatabasePluginInputError("invalid-operation");
+			validateCreateData("bundle_events", change.row);
+			return;
+		case "apiKeys": switch (change.operation) {
+			case "insert":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"row",
+					"onConflict"
+				]) || change.onConflict !== "ignore") throw new DatabasePluginInputError("invalid-operation");
+				validateCreateData("api_keys", change.row);
+				return;
+			case "update":
+				if (!hasOnlyKeys(change, [
+					"model",
+					"operation",
+					"where",
+					"update"
+				])) throw new DatabasePluginInputError("invalid-data");
+				validateWhere(change.where, "id");
+				if (!isRecord(change.update)) throw new DatabasePluginInputError("invalid-data");
+				if (!hasOnlyKeys(change.update, ["revokedAtMs"])) throw new DatabasePluginInputError("invalid-data");
+				validateApiKeyUpdateData({ revoked_at_ms: change.update.revokedAtMs });
+				return;
+			default: throw new DatabasePluginInputError("invalid-operation");
+		}
+		default: throw new DatabasePluginInputError("invalid-model");
+	}
+};
+const validateDatabaseCommitExpectation = (expectation) => {
+	if (!isRecord(expectation)) throw new DatabasePluginInputError("invalid-data");
+	if (expectation.model === "releases") {
+		if (!hasOnlyKeys(expectation, [
+			"model",
+			"id",
+			"revision"
+		]) || typeof expectation.id !== "string" || !(expectation.revision === null || typeof expectation.revision === "number" && Number.isSafeInteger(expectation.revision) && expectation.revision >= 1)) throw new DatabasePluginInputError("invalid-data");
+		return;
+	}
+	if (expectation.model === "releaseCatalogs") {
+		if (!hasOnlyKeys(expectation, [
+			"model",
+			"scopeKey",
+			"generation"
+		]) || typeof expectation.scopeKey !== "string" || !(expectation.generation === null || typeof expectation.generation === "number" && Number.isSafeInteger(expectation.generation) && expectation.generation >= 1)) throw new DatabasePluginInputError("invalid-data");
+		return;
+	}
+	throw new DatabasePluginInputError("invalid-model");
+};
+function validateDatabaseCommit(input) {
+	if (!isRecord(input) || !Array.isArray(input.changes) || (Object.hasOwn(input, "expectations") ? !hasOnlyKeys(input, ["changes", "expectations"]) || !Array.isArray(input.expectations) : !hasOnlyKeys(input, ["changes"]))) throw new DatabasePluginInputError("invalid-data");
+	input.changes.forEach(validateDatabaseChange);
+	if (Array.isArray(input.expectations)) input.expectations.forEach(validateDatabaseCommitExpectation);
 }
-function createPaginatedResult(total, limit, startIndex, data) {
-	const pagination = calculatePagination(total, {
-		limit,
-		offset: startIndex
-	});
-	const nextCursor = data.length > 0 && startIndex + data.length < total ? data.at(-1)?.id : void 0;
-	const previousCursor = data.length > 0 && startIndex > 0 ? data[0]?.id : void 0;
-	return {
-		data,
-		pagination: {
-			...pagination,
-			...nextCursor ? { nextCursor } : {},
-			...previousCursor ? { previousCursor } : {}
+const validateChannelInsertResult = (input, result) => {
+	validateResult("channels", result.row, void 0);
+	if (typeof result.inserted !== "boolean" || result.row.name !== input.row.name || result.inserted && result.row.id !== input.row.id) throw new DatabasePluginInputError("invalid-result");
+};
+const validateChannelDeleteResult = (result) => {
+	if (result.deleted) return;
+	if (result.reason !== "not_found" && result.reason !== "not_empty") throw new DatabasePluginInputError("invalid-result");
+};
+const createDatabasePluginAdapter = (name, implementation) => {
+	const crud = createDatabasePluginCrud(implementation);
+	const transaction = implementation.transaction;
+	const executeCommit = implementation.commit ? implementation.commit : async (input) => {
+		if (transaction) try {
+			return await transaction((database) => applyChanges(createTransactionDatabasePlugin(database), input));
+		} catch (error) {
+			if (error instanceof DatabaseCommitConflictError) return error.result;
+			throw error;
+		}
+		if ((input.expectations?.length ?? 0) > 0 || input.changes.length > 1 || input.changes.some((change) => change.model === "channels" && change.operation === "delete")) throw new DatabaseAtomicCommitUnsupportedError(name);
+		try {
+			return await applyChanges(crud, input);
+		} catch (error) {
+			if (error instanceof DatabaseCommitConflictError) return error.result;
+			throw error;
 		}
 	};
-}
-function expandLimitForUnitOfWork(options, unitOfWork) {
-	const extraLimit = unitOfWork.listFetchExtraCount();
-	if (extraLimit === 0) return options;
-	return {
-		...options,
-		limit: options.limit + extraLimit
+	const commit = async (input) => {
+		validateDatabaseCommit(input);
+		return executeCommit(input);
 	};
-}
-function adjustPaginationTotal(pagination, options) {
-	if (options.totalDelta === 0) return pagination;
-	const total = Math.max(0, pagination.total + options.totalDelta);
-	const hasPreviousPage = pagination.currentPage > 1;
-	const hasNextPage = pagination.currentPage * options.limit < total;
+	const findApiKeyByHash = (database, hash) => database.findOne({
+		model: "api_keys",
+		where: [{
+			field: "hash",
+			value: hash
+		}]
+	});
 	return {
-		...pagination,
-		total,
-		hasNextPage,
-		hasPreviousPage,
-		totalPages: total === 0 ? 0 : Math.ceil(total / options.limit)
-	};
-}
-/**
-* Creates a database plugin with lazy initialization and automatic hook execution.
-*
-* This factory function abstracts the double currying pattern used by all database plugins,
-* ensuring consistent lazy initialization behavior across different database providers.
-* Hooks are automatically executed at appropriate times without requiring manual invocation.
-*
-* @param options - Configuration options for the database plugin
-* @returns A double-curried function that lazily initializes the database plugin
-*
-* @example
-* ```typescript
-* export const postgres = createDatabasePlugin<PostgresConfig>({
-*   name: "postgres",
-*   factory: (config) => {
-*     const db = new Kysely(config);
-*     return {
-*       async getBundleById(bundleId) { ... },
-*       async getBundles(options) { ... },
-*       async getChannels() { ... },
-*       async commitBundle({ changedSets }) { ... }
-*     };
-*   }
-* });
-* ```
-*/
-function createDatabasePlugin(options) {
-	return (config, hooks) => {
-		let cachedMethods = null;
-		const getMethods = () => {
-			if (!cachedMethods) cachedMethods = options.factory(config);
-			return cachedMethods;
-		};
-		return () => {
-			const instanceMutationUnitOfWork = new BundleUnitOfWork();
-			const getRequestUnitOfWork = (context) => {
-				return getRequestBundleUnitOfWork(context);
-			};
-			const getMutationUnitOfWork = (context) => {
-				return getRequestUnitOfWork(context) ?? instanceMutationUnitOfWork;
-			};
-			const runGetBundles = async (options, context) => {
-				if (context === void 0) return getMethods().getBundles(options);
-				return getMethods().getBundles(options, context);
-			};
-			const getBundlesWithLegacyCursorFallback = async (options, context) => {
-				const orderBy = options.orderBy ?? DEFAULT_DESC_ORDER;
-				const baseWhere = options.where;
-				const total = (await runGetBundles({
-					where: baseWhere,
-					limit: 1,
-					offset: 0,
-					orderBy
-				}, context)).pagination.total;
-				if (!options.cursor?.after && !options.cursor?.before) {
-					const firstPage = await runGetBundles({
-						where: baseWhere,
-						limit: options.limit,
+		models: {
+			bundles: {
+				findById: (id) => crud.findOne({
+					model: "bundles",
+					where: [{
+						field: "id",
+						value: id
+					}]
+				}),
+				findMany: (query) => crud.findMany({
+					model: "bundles",
+					where: toBundleWhere(query.where),
+					limit: query.limit,
+					offset: query.offset,
+					orderBy: [query.orderBy]
+				}),
+				count: (where) => crud.count({
+					model: "bundles",
+					where: toBundleWhere(where)
+				})
+			},
+			bundlePatches: { async findByBundleIds(bundleIds) {
+				if (bundleIds.length === 0) return [];
+				const rows = [];
+				for (let offset = 0;; offset += PAGE_SIZE) {
+					const page = await crud.findMany({
+						model: "bundle_patches",
+						where: [{
+							field: "bundle_id",
+							operator: "in",
+							value: bundleIds
+						}],
+						limit: PAGE_SIZE,
+						offset,
+						orderBy: [{
+							field: "id",
+							direction: "asc"
+						}]
+					});
+					rows.push(...page);
+					if (page.length < PAGE_SIZE) return rows;
+				}
+			} },
+			releases: {
+				findById: (id) => crud.findOne({
+					model: "releases",
+					where: [{
+						field: "id",
+						value: id
+					}]
+				}),
+				findMany(input) {
+					if (!Number.isSafeInteger(input.limit) || input.limit <= 0 || input.afterReleaseId !== void 0 && input.beforeReleaseId !== void 0) throw new DatabasePluginInputError("invalid-query");
+					const query = crud.findMany({
+						model: "releases",
+						where: [
+							...input.afterReleaseId === void 0 ? [] : [{
+								field: "id",
+								operator: "gt",
+								value: input.afterReleaseId
+							}],
+							...input.beforeReleaseId === void 0 ? [] : [{
+								field: "id",
+								operator: "lt",
+								value: input.beforeReleaseId
+							}],
+							...input.bundleId === void 0 ? [] : [{
+								field: "bundle_id",
+								value: input.bundleId
+							}],
+							...input.channelId === void 0 ? [] : [{
+								field: "channel_id",
+								value: input.channelId
+							}],
+							...input.enabled === void 0 ? [] : [{
+								field: "enabled",
+								value: input.enabled
+							}],
+							...input.platform === void 0 ? [] : [{
+								field: "platform",
+								value: input.platform
+							}],
+							...input.targetAppVersion === void 0 ? [] : [{
+								field: "target_app_version",
+								value: input.targetAppVersion
+							}]
+						],
+						limit: input.limit,
 						offset: 0,
-						orderBy
-					}, context);
-					return createPaginatedResult(total, options.limit, 0, firstPage.data);
+						orderBy: [{
+							field: "id",
+							direction: input.afterReleaseId === void 0 ? "desc" : "asc"
+						}]
+					});
+					return input.afterReleaseId === void 0 ? query : query.then((rows) => [...rows].reverse());
+				},
+				findManyByScope(input) {
+					if (input.consistency !== "strong" || !Number.isSafeInteger(input.limit) || input.limit <= 0) throw new DatabasePluginInputError("invalid-query");
+					return crud.findMany({
+						model: "releases",
+						where: [{
+							field: "scope_key",
+							value: input.scopeKey
+						}, ...input.afterReleaseId === void 0 ? [] : [{
+							field: "id",
+							operator: "gt",
+							value: input.afterReleaseId
+						}]],
+						limit: input.limit,
+						offset: 0,
+						orderBy: [{
+							field: "id",
+							direction: "asc"
+						}]
+					});
 				}
-				const { where, orderBy: queryOrderBy, reverseData } = buildCursorPageQuery(baseWhere, options.cursor, orderBy);
-				const cursorPage = await runGetBundles({
-					where,
-					limit: options.limit,
-					offset: 0,
-					orderBy: queryOrderBy
-				}, context);
-				const data = reverseData ? cursorPage.data.slice().reverse() : cursorPage.data;
-				if (data.length === 0) {
-					const emptyStartIndex = options.cursor.after ? total : 0;
-					return {
-						data,
-						pagination: {
-							...calculatePagination(total, {
-								limit: options.limit,
-								offset: emptyStartIndex
-							}),
-							...options.cursor.after ? { previousCursor: options.cursor.after } : {},
-							...options.cursor.before ? { nextCursor: options.cursor.before } : {}
-						}
-					};
+			},
+			releaseCatalogs: {
+				findByScopeKey: (scopeKey) => crud.findOne({
+					model: "release_catalogs",
+					where: [{
+						field: "scope_key",
+						value: scopeKey
+					}]
+				}),
+				findMany(input) {
+					if (!Number.isSafeInteger(input.limit) || input.limit <= 0) throw new DatabasePluginInputError("invalid-query");
+					return crud.findMany({
+						model: "release_catalogs",
+						where: input.afterScopeKey === void 0 ? [] : [{
+							field: "scope_key",
+							operator: "gt",
+							value: input.afterScopeKey
+						}],
+						limit: input.limit,
+						offset: 0,
+						orderBy: [{
+							field: "scope_key",
+							direction: "asc"
+						}]
+					});
 				}
-				const firstBundleId = data[0].id;
-				const countBeforeResult = await runGetBundles({
-					where: buildCountBeforeWhere(baseWhere, firstBundleId, orderBy),
-					limit: 1,
-					offset: 0,
-					orderBy
-				}, context);
-				return createPaginatedResult(total, options.limit, countBeforeResult.pagination.total, data);
-			};
-			const plugin = {
-				name: options.name,
-				async getBundleById(bundleId, context) {
-					const requestUnitOfWork = getRequestUnitOfWork(context);
-					if (requestUnitOfWork) return requestUnitOfWork.getById(bundleId, () => getMethods().getBundleById(bundleId, context));
-					const pendingMutation = instanceMutationUnitOfWork.peekChanged(bundleId);
-					if (pendingMutation.found) return pendingMutation.value;
-					return getMethods().getBundleById(bundleId);
+			},
+			channels: {
+				async insert(input) {
+					if (input.onConflict !== "returnExisting") throw new DatabasePluginInputError("invalid-operation");
+					validateCreateData("channels", input.row);
+					const result = await implementation.insertChannel(input);
+					validateChannelInsertResult(input, result);
+					return result;
 				},
-				async getBundles(options, context) {
-					if (typeof options === "object" && options !== null && "offset" in options && options.offset !== void 0) throw new Error("Bundle offset pagination has been removed. Use cursor.after or cursor.before instead.");
-					const methods = getMethods();
-					const requestUnitOfWork = getRequestUnitOfWork(context);
-					const unitOfWork = requestUnitOfWork ?? instanceMutationUnitOfWork;
-					const shouldOverlay = requestUnitOfWork !== null || instanceMutationUnitOfWork.hasChanges();
-					const normalizedOptions = {
-						...options,
-						page: normalizePage(options.page),
-						orderBy: options.orderBy ?? DEFAULT_DESC_ORDER
-					};
-					const overlayResult = (result) => ({
-						...result,
-						data: unitOfWork.overlayList(result.data, {
-							limit: normalizedOptions.limit,
-							orderBy: normalizedOptions.orderBy,
-							where: normalizedOptions.where
-						}),
-						pagination: adjustPaginationTotal(result.pagination, {
-							limit: normalizedOptions.limit,
-							totalDelta: unitOfWork.totalDelta(normalizedOptions.where)
-						})
-					});
-					if (normalizedOptions.page !== void 0) {
-						const { page, ...pageOptions } = normalizedOptions;
-						const requestedOffset = (page - 1) * normalizedOptions.limit;
-						const fetchPageOptions = expandLimitForUnitOfWork(pageOptions, unitOfWork);
-						let pageResult = await runGetBundles({
-							...fetchPageOptions,
-							offset: requestedOffset
-						}, context);
-						const total = pageResult.pagination.total;
-						const totalPages = total === 0 ? 0 : Math.ceil(total / normalizedOptions.limit);
-						const maxOffset = totalPages === 0 ? 0 : (Math.max(1, totalPages) - 1) * normalizedOptions.limit;
-						const resolvedOffset = Math.min(requestedOffset, maxOffset);
-						if (resolvedOffset !== requestedOffset) pageResult = await runGetBundles({
-							...fetchPageOptions,
-							offset: resolvedOffset
-						}, context);
-						const result = { ...createPaginatedResult(total, normalizedOptions.limit, resolvedOffset, pageResult.data) };
-						return shouldOverlay ? overlayResult(result) : result;
-					}
-					if (methods.supportsCursorPagination) {
-						const fetchOptions = expandLimitForUnitOfWork(normalizedOptions, unitOfWork);
-						const result = context === void 0 ? await methods.getBundles(fetchOptions) : await methods.getBundles(fetchOptions, context);
-						return shouldOverlay ? overlayResult(result) : result;
+				async list(_input) {
+					const channels = [];
+					for (let offset = 0;; offset += PAGE_SIZE) {
+						const page = await crud.findMany({
+							model: "channels",
+							orderBy: [{
+								field: "name",
+								direction: "asc"
+							}],
+							limit: PAGE_SIZE,
+							offset
+						});
+						channels.push(...page);
+						if (page.length < PAGE_SIZE) {
+							channels.sort(compareChannelRows);
+							return { channels };
+						}
 					}
-					const result = await getBundlesWithLegacyCursorFallback(shouldOverlay ? expandLimitForUnitOfWork(normalizedOptions, unitOfWork) : normalizedOptions, context);
-					return shouldOverlay ? overlayResult(result) : result;
-				},
-				async getChannels(context) {
-					if (context === void 0) return getMethods().getChannels();
-					return getMethods().getChannels(context);
 				},
-				async onUnmount() {
-					const methods = getMethods();
-					if (methods.onUnmount) return methods.onUnmount();
-				},
-				async commitBundle(context) {
-					const methods = getMethods();
-					const unitOfWork = getMutationUnitOfWork(context);
-					const params = { changedSets: unitOfWork.changedSets() };
-					if (context === void 0) await methods.commitBundle(params);
-					else await methods.commitBundle(params, context);
-					unitOfWork.clear();
-					await hooks?.onDatabaseUpdated?.();
-				},
-				async updateBundle(targetBundleId, newBundle, context) {
-					const unitOfWork = getMutationUnitOfWork(context);
-					const currentBundle = await unitOfWork.getById(targetBundleId, () => context === void 0 ? getMethods().getBundleById(targetBundleId) : getMethods().getBundleById(targetBundleId, context));
-					if (!currentBundle) throw new Error("targetBundleId not found");
-					const updatedBundle = mergeBundleUpdate(currentBundle, newBundle);
-					unitOfWork.markUpdate(updatedBundle);
-				},
-				async appendBundle(inputBundle, context) {
-					getMutationUnitOfWork(context).markInsert(inputBundle);
-				},
-				async deleteBundle(deleteBundle, context) {
-					getMutationUnitOfWork(context).markDelete(deleteBundle);
+				async delete(input) {
+					if (!isChannelText(input.id)) throw new DatabasePluginInputError("invalid-data");
+					const result = await implementation.deleteChannel(input);
+					validateChannelDeleteResult(result);
+					return result;
 				}
-			};
-			Object.defineProperty(plugin, "getUpdateInfo", {
-				configurable: true,
-				enumerable: true,
-				get() {
-					const directGetUpdateInfo = getMethods().getUpdateInfo;
-					if (!directGetUpdateInfo) {
-						Object.defineProperty(plugin, "getUpdateInfo", {
-							configurable: true,
-							enumerable: true,
-							value: void 0
+			},
+			analytics: {
+				async append(row) {
+					await crud.create({
+						model: "bundle_events",
+						data: row
+					});
+				},
+				async scan(input) {
+					const rows = [];
+					for (let offset = 0; rows.length < input.limit; offset += PAGE_SIZE) {
+						const page = await crud.findMany({
+							model: "bundle_events",
+							where: [{
+								field: "received_at_ms",
+								operator: "lt",
+								value: input.beforeReceivedAtMs
+							}],
+							orderBy: [{
+								field: "received_at_ms",
+								direction: "asc"
+							}, {
+								field: "id",
+								direction: "asc"
+							}],
+							limit: PAGE_SIZE,
+							offset
 						});
-						return;
+						rows.push(...page.filter((row) => input.after === void 0 || row.received_at_ms > input.after.receivedAtMs || row.received_at_ms === input.after.receivedAtMs && row.id > input.after.id));
+						if (page.length < PAGE_SIZE) break;
 					}
-					const wrappedGetUpdateInfo = async (args, context) => {
-						if (context === void 0) return directGetUpdateInfo(args);
-						return directGetUpdateInfo(args, context);
+					return rows.slice(0, input.limit);
+				}
+			},
+			apiKeys: {
+				async create(row) {
+					const run = async (database) => {
+						if (await findApiKeyByHash(database, row.hash) !== null) return "existing";
+						await database.create({
+							model: "api_keys",
+							data: row
+						});
+						return "created";
 					};
-					Object.defineProperty(plugin, "getUpdateInfo", {
-						configurable: true,
-						enumerable: true,
-						value: wrappedGetUpdateInfo
+					return transaction ? transaction((database) => run(createTransactionDatabasePlugin(database))) : run(crud);
+				},
+				findByHash: (hash) => findApiKeyByHash(crud, hash),
+				list: () => crud.findMany({
+					model: "api_keys",
+					orderBy: [{
+						field: "created_at_ms",
+						direction: "desc"
+					}, {
+						field: "id",
+						direction: "asc"
+					}],
+					limit: Number.MAX_SAFE_INTEGER,
+					offset: 0
+				}),
+				async revoke({ id, revokedAtMs }) {
+					return crud.update({
+						model: "api_keys",
+						where: [{
+							field: "id",
+							value: id
+						}],
+						update: { revoked_at_ms: revokedAtMs }
 					});
-					return wrappedGetUpdateInfo;
 				}
-			});
-			return plugin;
-		};
+			}
+		},
+		commit,
+		...implementation.dispose ? { dispose: implementation.dispose } : {}
 	};
-}
+};
+const createDatabasePlugin = (options) => ({ ...options });
 //#endregion
-export { createDatabasePlugin };
+export { DatabaseAtomicCommitUnsupportedError, DatabaseRowReferencedError, createDatabasePlugin, createDatabasePluginAdapter };