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

package/dist/adapters/prisma.mjs

@@ -1,201 +1,226 @@
 import { getHotUpdaterSchemaVersion, hotUpdaterSchema } from "../db/schema/registry.mjs";
 import { generatePrismaSchema } from "../db/schemaGenerators.mjs";
-import { bundleToPatchRows, bundleToRow, rowToBundle } from "../db/bundleRows.mjs";
-import { calculatePagination, createDatabasePlugin, filterCompatibleAppVersions, resolveUpdateInfoFromBundles } from "@hot-updater/plugin-core";
-import { NIL_UUID } from "@hot-updater/core";
+import { isChannelDeleteReferencedError, translateChannelDeleteError } from "./databaseConstraintErrors.mjs";
+import { hasNullOrderOverrides, sortRowsByOrder } from "./databasePluginUtils.mjs";
+import { createPrismaOrderBy, createPrismaWhere } from "./prismaQuery.mjs";
+import { PrismaAdapterError, getPrismaDelegate, parsePrismaApiKeyRow, parsePrismaBundleEventRow, parsePrismaBundleRow, parsePrismaChannelRow, parsePrismaPatchRow, parsePrismaReleaseCatalogRow, parsePrismaReleaseRow, parsePrismaRows } from "./prismaRows.mjs";
+import { DatabasePluginInputError, createDatabasePlugin } from "@hot-updater/plugin-core";
+import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
 //#region src/adapters/prisma.ts
-const assertSupportedRelationMode = (relationMode) => {
-	if (relationMode && relationMode !== "prisma" && relationMode !== "foreign-keys") throw new Error(`Unsupported Prisma relation mode: ${relationMode}`);
+const hasCallbackTransaction = (client) => "$transaction" in client && typeof client.$transaction === "function";
+const runPrismaTransaction = (client, isolationLevel, callback) => {
+	const execute = () => isolationLevel === "serializable" ? client.$transaction(callback, { isolationLevel: "Serializable" }) : client.$transaction(callback);
+	if (isolationLevel === "default") return execute();
+	return (async () => {
+		for (let attempt = 0;; attempt += 1) try {
+			return await execute();
+		} catch (error) {
+			if (attempt >= 2 || typeof error !== "object" || error === null || !("code" in error) || error.code !== "P2034") throw error;
+		}
+	})();
 };
-const getDelegate = (prisma, model) => {
-	const delegate = prisma[model];
-	if (!delegate || typeof delegate !== "object") throw new Error(`Prisma client is missing model delegate "${model}".`);
-	return delegate;
+const assertPrismaProvider = (provider) => {
+	if (provider === "mongodb") throw new PrismaAdapterError("Prisma adapter does not support MongoDB; use mongodbAdapter instead");
 };
-const prismaWhere = (where) => {
-	const targetAppVersionFilters = [];
-	if (where?.targetAppVersion !== void 0) targetAppVersionFilters.push({ target_app_version: where.targetAppVersion });
-	if (where?.targetAppVersionIn) targetAppVersionFilters.push({ target_app_version: { in: where.targetAppVersionIn } });
-	if (where?.targetAppVersionNotNull) targetAppVersionFilters.push({ target_app_version: { not: null } });
-	return {
-		...where?.channel !== void 0 ? { channel: where.channel } : {},
-		...where?.platform !== void 0 ? { platform: where.platform } : {},
-		...where?.enabled !== void 0 ? { enabled: where.enabled } : {},
-		...where?.fingerprintHash !== void 0 ? { fingerprint_hash: where.fingerprintHash } : {},
-		...where?.id ? { id: {
-			...where.id.eq !== void 0 ? { equals: where.id.eq } : {},
-			...where.id.gt !== void 0 ? { gt: where.id.gt } : {},
-			...where.id.gte !== void 0 ? { gte: where.id.gte } : {},
-			...where.id.lt !== void 0 ? { lt: where.id.lt } : {},
-			...where.id.lte !== void 0 ? { lte: where.id.lte } : {},
-			...where.id.in !== void 0 ? { in: where.id.in } : {}
-		} } : {},
-		...targetAppVersionFilters.length > 0 ? { AND: targetAppVersionFilters } : {}
-	};
+const findMany = async (client, input, provider) => {
+	if (input.distinctOn !== void 0) throw new DatabasePluginInputError("invalid-operation");
+	const rawOrderBy = input.orderBy;
+	const orderBy = createPrismaOrderBy(rawOrderBy);
+	const rows = rawOrderBy !== void 0 && hasNullOrderOverrides(rawOrderBy) ? sortRowsByOrder(await getPrismaDelegate(client, input.model).findMany({ where: createPrismaWhere(input.where, provider) }), rawOrderBy).slice(input.offset, input.offset + input.limit) : await getPrismaDelegate(client, input.model).findMany({
+		where: createPrismaWhere(input.where, provider),
+		...orderBy ? { orderBy } : {},
+		skip: input.offset,
+		take: input.limit
+	});
+	switch (input.model) {
+		case "bundles": return parsePrismaRows(rows, parsePrismaBundleRow);
+		case "bundle_patches": return parsePrismaRows(rows, parsePrismaPatchRow);
+		case "bundle_events": return parsePrismaRows(rows, parsePrismaBundleEventRow);
+		case "channels": return parsePrismaRows(rows, parsePrismaChannelRow);
+		case "api_keys": return parsePrismaRows(rows, parsePrismaApiKeyRow);
+		case "releases": return parsePrismaRows(rows, parsePrismaReleaseRow);
+		case "release_catalogs": return parsePrismaRows(rows, parsePrismaReleaseCatalogRow);
+	}
 };
-const createPrismaPlugin = createDatabasePlugin({
-	name: "prisma",
-	factory: (config) => {
-		const prisma = config.prisma;
-		const runInTransaction = async (operation) => {
-			if (typeof prisma.$transaction !== "function") return operation(prisma);
-			return prisma.$transaction(operation);
-		};
-		const fetchPatchMap = async (bundleIds) => {
-			const patches = getDelegate(prisma, "bundle_patches");
-			const patchMap = /* @__PURE__ */ new Map();
-			if (bundleIds.length === 0) return patchMap;
-			const rows = await patches.findMany({
-				where: { bundle_id: { in: [...bundleIds] } },
-				orderBy: { order_index: "asc" }
-			});
-			for (const row of rows) {
-				const patch = row;
-				const current = patchMap.get(patch.bundle_id) ?? [];
-				current.push(patch);
-				patchMap.set(patch.bundle_id, current);
-			}
-			return patchMap;
+const assertPatchReferences = async (client, bundleId, baseBundleId) => {
+	const ids = Array.from(new Set([bundleId, baseBundleId]));
+	if (await getPrismaDelegate(client, "bundles").count({ where: { id: { in: ids } } }) !== ids.length) throw new PrismaAdapterError("patch references a missing bundle");
+};
+const createCrudImplementation = (client, provider, relationMode) => ({
+	deleteChannel: async ({ id }) => {
+		const channels = getPrismaDelegate(client, "channels");
+		if (await channels.findFirst({ where: { id } }) === null) return {
+			deleted: false,
+			reason: "not_found"
 		};
-		const mapRowsToBundles = async (rows) => {
-			const patchMap = await fetchPatchMap(rows.map((row) => String(row["id"])));
-			return rows.map((row) => rowToBundle(row, patchMap.get(String(row["id"])) ?? []));
+		if (await getPrismaDelegate(client, "releases").count({ where: { channel_id: id } }) > 0) return {
+			deleted: false,
+			reason: "not_empty"
 		};
-		const upsertBundle = async (client, bundle) => {
-			const bundles = getDelegate(client, "bundles");
-			const patches = getDelegate(client, "bundle_patches");
-			const row = bundleToRow(bundle);
-			const { id, ...update } = row;
-			await bundles.upsert({
-				where: { id },
-				create: row,
-				update
-			});
-			await patches.deleteMany({ where: { bundle_id: id } });
-			const patchRows = bundleToPatchRows(bundle);
-			if (patchRows.length > 0) await patches.createMany({ data: patchRows });
+		try {
+			await channels.deleteMany({ where: { id } });
+		} catch (error) {
+			if (isChannelDeleteReferencedError(error)) return {
+				deleted: false,
+				reason: "not_empty"
+			};
+			throw error;
+		}
+		return { deleted: true };
+	},
+	insertChannel: async (input) => {
+		const delegate = getPrismaDelegate(client, "channels");
+		const existing = await delegate.findFirst({ where: { name: input.row.name } });
+		if (existing !== null) return {
+			row: parsePrismaChannelRow(existing),
+			inserted: false
 		};
+		const row = parsePrismaChannelRow(await delegate.upsert({
+			where: { name: input.row.name },
+			create: input.row,
+			update: {}
+		}));
 		return {
-			async getBundleById(bundleId) {
-				const row = await getDelegate(prisma, "bundles").findFirst({ where: { id: bundleId } });
-				if (!row) return null;
-				return rowToBundle(row, (await fetchPatchMap([bundleId])).get(bundleId) ?? []);
-			},
-			async getBundles(options) {
-				const bundles = getDelegate(prisma, "bundles");
-				const offset = options.offset ?? 0;
-				const orderBy = options.orderBy ?? {
-					field: "id",
-					direction: "desc"
-				};
-				const where = prismaWhere(options.where);
-				const [total, rows] = await Promise.all([bundles.count({ where }), bundles.findMany({
-					where,
-					orderBy: { id: orderBy.direction },
-					skip: offset,
-					take: options.limit
-				})]);
-				const patchMap = await fetchPatchMap(rows.map((row) => String(row["id"])));
-				return {
-					data: rows.map((row) => rowToBundle(row, patchMap.get(String(row["id"])) ?? [])),
-					pagination: calculatePagination(total, {
-						limit: options.limit,
-						offset
-					})
-				};
-			},
-			async getUpdateInfo(args, context) {
-				const bundles = getDelegate(prisma, "bundles");
-				if (args._updateStrategy === "appVersion") {
-					const channel = args.channel ?? "production";
-					const minBundleId = args.minBundleId ?? NIL_UUID;
-					const rows = await bundles.findMany({
-						select: { target_app_version: true },
-						where: {
-							enabled: true,
-							platform: args.platform,
-							channel,
-							id: { gte: minBundleId },
-							target_app_version: { not: null }
-						}
-					});
-					const compatibleAppVersions = filterCompatibleAppVersions(Array.from(new Set(rows.map((row) => row["target_app_version"]).filter((value) => typeof value === "string" && value.length > 0))), args.appVersion);
-					const updateBundles = compatibleAppVersions.length > 0 ? await bundles.findMany({
-						where: {
-							enabled: true,
-							platform: args.platform,
-							channel,
-							id: { gte: minBundleId },
-							target_app_version: { in: compatibleAppVersions }
-						},
-						orderBy: { id: "desc" }
-					}).then(mapRowsToBundles) : [];
-					return resolveUpdateInfoFromBundles({
-						args: {
-							...args,
-							channel,
-							minBundleId
-						},
-						bundles: updateBundles,
-						context
-					});
-				}
-				const channel = args.channel ?? "production";
-				const minBundleId = args.minBundleId ?? NIL_UUID;
-				const rows = await bundles.findMany({
-					where: {
-						enabled: true,
-						platform: args.platform,
-						channel,
-						id: { gte: minBundleId },
-						fingerprint_hash: args.fingerprintHash
-					},
-					orderBy: { id: "desc" }
-				});
-				return resolveUpdateInfoFromBundles({
-					args: {
-						...args,
-						channel,
-						minBundleId
-					},
-					bundles: await mapRowsToBundles(rows),
-					context
-				});
-			},
-			async getChannels() {
-				const rows = await getDelegate(prisma, "bundles").findMany({
-					select: { channel: true },
-					orderBy: { channel: "asc" }
-				});
-				return Array.from(new Set(rows.map((row) => String(row["channel"]))));
-			},
-			async commitBundle({ changedSets }) {
-				await runInTransaction(async (client) => {
-					const bundles = getDelegate(client, "bundles");
-					const patches = getDelegate(client, "bundle_patches");
-					for (const change of changedSets) {
-						if (change.operation === "delete") {
-							await patches.deleteMany({ where: { bundle_id: change.data.id } });
-							await patches.deleteMany({ where: { base_bundle_id: change.data.id } });
-							await bundles.deleteMany({ where: { id: change.data.id } });
-							continue;
-						}
-						await upsertBundle(client, change.data);
-					}
-				});
-			}
+			row,
+			inserted: row.id === input.row.id
 		};
-	}
+	},
+	create: async (input) => {
+		if (input.model === "bundle_patches") await assertPatchReferences(client, input.data.bundle_id, input.data.base_bundle_id);
+		const delegate = getPrismaDelegate(client, input.model);
+		let row;
+		if (input.onConflict === "ignore") {
+			const where = input.model === "channels" ? { name: input.data.name } : { hash: input.data.hash };
+			row = await delegate.upsert({
+				where,
+				create: input.data,
+				update: {}
+			});
+		} else row = await delegate.create({ data: input.data });
+		switch (input.model) {
+			case "bundles": return parsePrismaBundleRow(row);
+			case "bundle_patches": return parsePrismaPatchRow(row);
+			case "bundle_events": return parsePrismaBundleEventRow(row);
+			case "channels": return parsePrismaChannelRow(row);
+			case "api_keys": return parsePrismaApiKeyRow(row);
+			case "releases": return parsePrismaReleaseRow(row);
+			case "release_catalogs": return parsePrismaReleaseCatalogRow(row);
+		}
+	},
+	update: async (input) => {
+		const id = input.where[0]?.value;
+		if (typeof id !== "string") throw new PrismaAdapterError(`${input.model} update requires a string id`);
+		if (input.model === "api_keys") {
+			const delegate = getPrismaDelegate(client, "api_keys");
+			if (await delegate.findFirst({ where: { id } }) === null) return null;
+			await delegate.update({
+				where: { id },
+				data: input.update
+			});
+			const stored = await delegate.findFirst({ where: { id } });
+			return stored === null ? null : parsePrismaApiKeyRow(stored);
+		}
+		if (input.model === "releases") {
+			const delegate = getPrismaDelegate(client, "releases");
+			if (await delegate.findFirst({ where: { id } }) === null) return null;
+			await delegate.update({
+				where: { id },
+				data: input.update
+			});
+			const stored = await delegate.findFirst({ where: { id } });
+			return stored === null ? null : parsePrismaReleaseRow(stored);
+		}
+		if (input.model === "release_catalogs") {
+			const delegate = getPrismaDelegate(client, "release_catalogs");
+			if (await delegate.findFirst({ where: { scope_key: id } }) === null) return null;
+			await delegate.update({
+				where: { scope_key: id },
+				data: input.update
+			});
+			const stored = await delegate.findFirst({ where: { scope_key: id } });
+			return stored === null ? null : parsePrismaReleaseCatalogRow(stored);
+		}
+		const delegate = getPrismaDelegate(client, "bundles");
+		if (delegate.updateMany === void 0) throw new PrismaAdapterError("model delegate \"bundles\" requires updateMany");
+		if (await delegate.findFirst({ where: { id } }) === null) return null;
+		await delegate.updateMany({
+			where: { id },
+			data: input.update
+		});
+		const stored = await delegate.findFirst({ where: { id } });
+		if (stored === null) return null;
+		return parsePrismaBundleRow(stored);
+	},
+	delete: async (input) => {
+		if (input.model === "bundles" && relationMode === "prisma") {
+			const ids = parsePrismaRows(await getPrismaDelegate(client, "bundles").findMany({ where: createPrismaWhere(input.where, provider) }), parsePrismaBundleRow).map(({ id }) => id);
+			if (ids.length === 0) return;
+			await getPrismaDelegate(client, "bundle_patches").deleteMany({ where: { OR: [{ bundle_id: { in: ids } }, { base_bundle_id: { in: ids } }] } });
+		}
+		try {
+			await getPrismaDelegate(client, input.model).deleteMany({ where: createPrismaWhere(input.where, provider) });
+		} catch (error) {
+			if (input.model === "channels") translateChannelDeleteError(error);
+			throw error;
+		}
+	},
+	count: async (input) => {
+		if (input.distinct !== void 0) throw new DatabasePluginInputError("invalid-operation");
+		return getPrismaDelegate(client, input.model).count({ where: createPrismaWhere(input.where, provider) });
+	},
+	findOne: async (input) => {
+		const row = await getPrismaDelegate(client, input.model).findFirst({ where: createPrismaWhere(input.where, provider) });
+		if (row === null) return null;
+		switch (input.model) {
+			case "bundles": return parsePrismaBundleRow(row);
+			case "bundle_patches": return parsePrismaPatchRow(row);
+			case "channels": return parsePrismaChannelRow(row);
+			case "api_keys": return parsePrismaApiKeyRow(row);
+			case "releases": return parsePrismaReleaseRow(row);
+			case "release_catalogs": return parsePrismaReleaseCatalogRow(row);
+		}
+	},
+	findMany: (input) => findMany(client, input, provider)
 });
+const createPrismaImplementation = (client, relationMode, provider) => {
+	const crud = createCrudImplementation(client, provider, relationMode);
+	const implementation = {
+		...crud,
+		deleteChannel: (input) => {
+			if (!hasCallbackTransaction(client)) throw new PrismaAdapterError("channel deletion requires callback transactions");
+			return runPrismaTransaction(client, "serializable", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).deleteChannel(input));
+		},
+		delete: (input) => {
+			if (input.model !== "bundles" || relationMode === "foreign-keys") return crud.delete(input);
+			if (!hasCallbackTransaction(client)) throw new PrismaAdapterError("relation mode \"prisma\" requires callback transactions");
+			return runPrismaTransaction(client, "serializable", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).delete(input));
+		}
+	};
+	if (relationMode === "prisma" && !hasCallbackTransaction(client)) throw new PrismaAdapterError("relation mode \"prisma\" requires callback transactions");
+	if (!hasCallbackTransaction(client)) return implementation;
+	if (relationMode === "prisma") implementation.create = (input) => runPrismaTransaction(client, "serializable", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).create(input));
+	implementation.update = (input) => runPrismaTransaction(client, relationMode === "prisma" ? "serializable" : "default", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).update(input));
+	return {
+		...implementation,
+		transaction: (callback) => runPrismaTransaction(client, "serializable", async (transactionClient) => {
+			return callback(createCrudImplementation(transactionClient, provider, relationMode));
+		})
+	};
+};
 const prismaAdapter = (config) => {
-	assertSupportedRelationMode(config.relationMode);
-	return Object.assign(createPrismaPlugin(config), {
+	assertPrismaProvider(config.provider);
+	const adapter = createDatabasePluginAdapter("prisma", createPrismaImplementation(config.prisma, config.relationMode ?? "foreign-keys", config.provider));
+	return Object.assign(createDatabasePlugin({
+		name: "prisma",
+		models: adapter.models,
+		commit: adapter.commit
+	}), {
 		adapterName: "prisma",
 		provider: config.provider,
-		generateSchema: (version) => ({
+		generateSchema: ((version) => ({
 			code: generatePrismaSchema(config.provider, version === "latest" ? hotUpdaterSchema : getHotUpdaterSchemaVersion(version)),
 			path: "./prisma/schema/hot_updater.prisma"
-		})
+		}))
 	});
 };
 //#endregion

package/dist/adapters/prismaQuery.cjs

@@ -0,0 +1,58 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+//#region src/adapters/prismaQuery.ts
+const stringFilter = (operator, value, mode) => {
+	return {
+		[operator === "starts_with" ? "startsWith" : operator === "ends_with" ? "endsWith" : "contains"]: value,
+		...mode ? { mode } : {}
+	};
+};
+const SQL_PATTERN_METACHARACTERS = /[%_\\]/u;
+const MONGODB_PATTERN_METACHARACTERS = /[.*+?^${}()|[\]\\]/u;
+const prismaMode = (mode, provider) => {
+	if (mode === "insensitive" || mode === "sensitive" && provider !== "postgresql") throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
+	return mode === "sensitive" ? "default" : void 0;
+};
+const assertLiteralPattern = (value, provider) => {
+	if ((provider === "mongodb" ? MONGODB_PATTERN_METACHARACTERS : SQL_PATTERN_METACHARACTERS).test(value)) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
+};
+const predicate = (where, provider) => {
+	const mode = prismaMode("mode" in where ? where.mode : void 0, provider);
+	switch (where.operator) {
+		case void 0:
+		case "eq": return { [where.field]: mode ? {
+			equals: where.value,
+			mode
+		} : where.value };
+		case "ne": return { [where.field]: {
+			not: where.value,
+			...mode ? { mode } : {}
+		} };
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte": return { [where.field]: { [where.operator]: where.value } };
+		case "in": return { [where.field]: { in: where.value } };
+		case "not_in": return { [where.field]: { notIn: where.value } };
+		case "contains":
+		case "starts_with":
+		case "ends_with":
+			assertLiteralPattern(where.value, provider);
+			return { [where.field]: stringFilter(where.operator, where.value, mode) };
+	}
+};
+const createPrismaWhere = (where, provider) => {
+	const items = where ?? [];
+	const first = items[0];
+	if (first === void 0) return {};
+	let result = predicate(first, provider);
+	for (const item of items.slice(1)) result = { [item.connector === "OR" ? "OR" : "AND"]: [result, predicate(item, provider)] };
+	return result;
+};
+const createPrismaOrderBy = (orderBy) => {
+	if (orderBy === void 0) return void 0;
+	return (Array.isArray(orderBy) ? orderBy : [orderBy]).map((clause) => ({ [clause.field]: clause.direction }));
+};
+//#endregion
+exports.createPrismaOrderBy = createPrismaOrderBy;
+exports.createPrismaWhere = createPrismaWhere;

package/dist/adapters/prismaQuery.mjs

@@ -0,0 +1,56 @@
+import { DatabasePluginInputError } from "@hot-updater/plugin-core";
+//#region src/adapters/prismaQuery.ts
+const stringFilter = (operator, value, mode) => {
+	return {
+		[operator === "starts_with" ? "startsWith" : operator === "ends_with" ? "endsWith" : "contains"]: value,
+		...mode ? { mode } : {}
+	};
+};
+const SQL_PATTERN_METACHARACTERS = /[%_\\]/u;
+const MONGODB_PATTERN_METACHARACTERS = /[.*+?^${}()|[\]\\]/u;
+const prismaMode = (mode, provider) => {
+	if (mode === "insensitive" || mode === "sensitive" && provider !== "postgresql") throw new DatabasePluginInputError("invalid-operation");
+	return mode === "sensitive" ? "default" : void 0;
+};
+const assertLiteralPattern = (value, provider) => {
+	if ((provider === "mongodb" ? MONGODB_PATTERN_METACHARACTERS : SQL_PATTERN_METACHARACTERS).test(value)) throw new DatabasePluginInputError("invalid-operation");
+};
+const predicate = (where, provider) => {
+	const mode = prismaMode("mode" in where ? where.mode : void 0, provider);
+	switch (where.operator) {
+		case void 0:
+		case "eq": return { [where.field]: mode ? {
+			equals: where.value,
+			mode
+		} : where.value };
+		case "ne": return { [where.field]: {
+			not: where.value,
+			...mode ? { mode } : {}
+		} };
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte": return { [where.field]: { [where.operator]: where.value } };
+		case "in": return { [where.field]: { in: where.value } };
+		case "not_in": return { [where.field]: { notIn: where.value } };
+		case "contains":
+		case "starts_with":
+		case "ends_with":
+			assertLiteralPattern(where.value, provider);
+			return { [where.field]: stringFilter(where.operator, where.value, mode) };
+	}
+};
+const createPrismaWhere = (where, provider) => {
+	const items = where ?? [];
+	const first = items[0];
+	if (first === void 0) return {};
+	let result = predicate(first, provider);
+	for (const item of items.slice(1)) result = { [item.connector === "OR" ? "OR" : "AND"]: [result, predicate(item, provider)] };
+	return result;
+};
+const createPrismaOrderBy = (orderBy) => {
+	if (orderBy === void 0) return void 0;
+	return (Array.isArray(orderBy) ? orderBy : [orderBy]).map((clause) => ({ [clause.field]: clause.direction }));
+};
+//#endregion
+export { createPrismaOrderBy, createPrismaWhere };