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

package/dist/adapters/mongodbAdapter.mjs

@@ -0,0 +1,173 @@
+import { DATABASE_VERSION_COLUMN, findPhysicalColumn, findPhysicalIndex, indexOrderColumns, normalizeStoredRow, rowKey } from "@hot-updater/plugin-core/internal";
+import { MongoError } from "mongodb";
+//#region src/adapters/mongodbAdapter.ts
+var MongoTransactionUnsupportedError = class extends Error {
+	name = "MongoTransactionUnsupportedError";
+	constructor(cause) {
+		super("Hot Updater writes in MongoDB transactions, which need a replica set or a sharded cluster.", { cause });
+	}
+};
+/** A single key column is the `_id`; a composite key is a document in key-column order. */
+const idOf = (table, key) => table.key.length === 1 ? key[0] : Object.fromEntries(table.key.map((column, at) => [column, key[at]]));
+/** A filter on `_id` (never an ObjectId), and on the version when given. */
+const byId = (_id, v) => v === void 0 ? { _id } : {
+	_id,
+	[DATABASE_VERSION_COLUMN]: v
+};
+/** Null columns are left out, so unique indexes skip them as SQL's do. */
+const toDocument = (table, row) => ({
+	_id: idOf(table, rowKey(table, row)),
+	...Object.fromEntries(table.columns.flatMap(({ name }) => row[name] === null || row[name] === void 0 ? [] : [[name, row[name]]]))
+});
+/** `columns op bound` over a tuple prefix, expanded into ORs. */
+const compare = (columns, { values, inclusive }, op) => {
+	const terms = values.map((value, position) => ({
+		...Object.fromEntries(columns.slice(0, position).map((column, at) => [column, values[at]])),
+		[columns[position]]: { [position === values.length - 1 && inclusive ? `${op}e` : op]: value }
+	}));
+	return terms.length === 1 ? terms[0] : { $or: terms };
+};
+const indexDescription = (table, index) => {
+	const columns = index.unique ? index.eq : [...index.eq, ...indexOrderColumns(table, index)];
+	const exists = columns.filter((column) => findPhysicalColumn(table, column).nullable).map((column) => [column, { $exists: true }]);
+	return {
+		name: index.name,
+		key: Object.fromEntries(columns.map((column) => [column, 1])),
+		...index.unique && { unique: true },
+		...index.unique && exists.length > 0 && { partialFilterExpression: Object.fromEntries(exists) }
+	};
+};
+const mongoError = (error) => error instanceof MongoError ? error : void 0;
+/**
+* The storage engine's adapter over MongoDB: one collection per table, the
+* key as `_id`, and indexes as declared, with multi-valued fields as multikey
+* indexes. A write runs in one transaction. Guards are conditional updates,
+* and `check` is a conditional `$inc`: a real write, so a concurrent
+* transaction on the document conflicts.
+*/
+const createMongoAdapter = (options) => {
+	const { client, tablePrefix = "", maxOps = 1e3 } = options;
+	const collection = (table) => client.db().collection(tablePrefix + table.name);
+	const normalize = (table, document) => normalizeStoredRow(table, document, { jsonText: false });
+	/** Whether the op applied; a guard that no longer matches changes nothing. */
+	const apply = async (op, session) => {
+		const target = collection(op.table);
+		if (op.type === "insert") {
+			await target.insertOne(toDocument(op.table, op.row), { session });
+			return true;
+		}
+		const _id = idOf(op.table, op.key);
+		const update = async (filter, change) => (await target.updateOne(filter, change, { session })).matchedCount === 1;
+		switch (op.type) {
+			case "patch": {
+				const $set = { [DATABASE_VERSION_COLUMN]: op.guard.v + 1 };
+				const $unset = {};
+				for (const [name, value] of Object.entries(op.set)) if (value === null) $unset[name] = "";
+				else $set[name] = value;
+				return update(byId(_id, op.guard.v), {
+					$set,
+					$unset
+				});
+			}
+			case "delete": return (await target.deleteOne(byId(_id, op.guard.v), { session })).deletedCount === 1;
+			case "check": return update(byId(_id, op.guard.v), { $inc: { _checked: 1 } });
+			case "increment": {
+				if (op.init === void 0 || op.guard !== void 0) return update(byId(_id, op.guard?.v), { $inc: {
+					...op.by,
+					[DATABASE_VERSION_COLUMN]: 1
+				} });
+				const set = {};
+				for (const { name } of op.table.columns) {
+					const start = op.init[name] ?? null;
+					const by = name === DATABASE_VERSION_COLUMN ? 1 : op.by[name];
+					const stored = { $ifNull: [`$${name}`, { $literal: start ?? 0 }] };
+					if (by !== void 0) set[name] = { $add: [stored, by] };
+					else if (start !== null) set[name] = stored;
+				}
+				await target.updateOne(byId(_id), [{ $set: set }], {
+					upsert: true,
+					session
+				});
+				return true;
+			}
+		}
+	};
+	return {
+		id: "mongodb",
+		fits: (ops) => ops.length <= maxOps,
+		async get(table, keys) {
+			if (keys.length === 0) return [];
+			const ids = keys.map((key) => idOf(table, key));
+			const documents = await collection(table).find(byId({ $in: ids })).toArray();
+			const found = new Map(documents.map((document) => [JSON.stringify(document._id), document]));
+			return ids.map((id) => {
+				const document = found.get(JSON.stringify(id));
+				return document === void 0 ? null : normalize(table, document);
+			});
+		},
+		async query(table, request) {
+			const index = findPhysicalIndex(table, request.index);
+			const columns = indexOrderColumns(table, index);
+			const bounds = [...request.lower ? [compare(columns, request.lower, "$gt")] : [], ...request.upper ? [compare(columns, request.upper, "$lt")] : []];
+			const direction = request.order === "asc" ? 1 : -1;
+			return (await collection(table).find({
+				...Object.fromEntries(index.eq.map((column, at) => [column, request.eq[at]])),
+				...bounds.length > 0 && { $and: bounds }
+			}, {
+				sort: Object.fromEntries(columns.map((column) => [column, direction])),
+				limit: request.limit,
+				...options.batchSize && { batchSize: options.batchSize }
+			}).toArray()).map((document) => normalize(table, document));
+		},
+		async write(ops) {
+			const session = client.startSession();
+			let position = 0;
+			try {
+				session.startTransaction({
+					readConcern: { level: "snapshot" },
+					writeConcern: { w: "majority" }
+				});
+				for (; position < ops.length; position += 1) if (!await apply(ops[position], session)) {
+					await session.abortTransaction();
+					return {
+						ok: false,
+						failedOp: position
+					};
+				}
+				await session.commitTransaction().catch(async (error) => {
+					if (!mongoError(error)?.hasErrorLabel("UnknownTransactionCommitResult")) throw error;
+					await session.commitTransaction();
+				});
+				return { ok: true };
+			} catch (error) {
+				if (session.inTransaction()) await session.abortTransaction().catch(() => void 0);
+				const failure = mongoError(error);
+				if (failure?.hasErrorLabel("TransientTransactionError") || failure?.code === 112) return {
+					ok: false,
+					retry: true
+				};
+				if (failure?.code === 11e3 && position < ops.length) return ops[position].type === "increment" ? {
+					ok: false,
+					retry: true
+				} : {
+					ok: false,
+					failedOp: position
+				};
+				throw failure?.code === 20 ? new MongoTransactionUnsupportedError(error) : error;
+			} finally {
+				await session.endSession();
+			}
+		},
+		migrations: { async apply(tables) {
+			for (const table of tables) {
+				await client.db().createCollection(tablePrefix + table.name).catch((error) => {
+					if (mongoError(error)?.code !== 48) throw error;
+				});
+				if (table.indexes.length === 0) continue;
+				await collection(table).createIndexes(table.indexes.map((index) => indexDescription(table, index)));
+			}
+		} }
+	};
+};
+//#endregion
+export { MongoTransactionUnsupportedError, createMongoAdapter };

package/dist/adapters/prisma.cjs

@@ -1,229 +1,47 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../_virtual/_rolldown/runtime.cjs");
-const require_registry = require("../db/schema/registry.cjs");
-const require_schemaGenerators = require("../db/schemaGenerators.cjs");
-const require_databaseConstraintErrors = require("./databaseConstraintErrors.cjs");
-const require_databasePluginUtils = require("./databasePluginUtils.cjs");
-const require_prismaQuery = require("./prismaQuery.cjs");
-const require_prismaRows = require("./prismaRows.cjs");
-let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
-let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
+const require_settingsMigrator = require("../db/settingsMigrator.cjs");
+const require_builtInDatabase = require("../db/builtInDatabase.cjs");
+const require_sqlAdapter = require("../database/sql/sqlAdapter.cjs");
+const require_sqlProviders = require("./sqlProviders.cjs");
+const require_enginePrismaSchema = require("../db/enginePrismaSchema.cjs");
+const require_prismaExecutor = require("./prismaExecutor.cjs");
 //#region src/adapters/prisma.ts
-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 assertPrismaProvider = (provider) => {
-	if (provider === "mongodb") throw new require_prismaRows.PrismaAdapterError("Prisma adapter does not support MongoDB; use mongodbAdapter instead");
-};
-const findMany = async (client, input, provider) => {
-	if (input.distinctOn !== void 0) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
-	const rawOrderBy = input.orderBy;
-	const orderBy = require_prismaQuery.createPrismaOrderBy(rawOrderBy);
-	const rows = rawOrderBy !== void 0 && require_databasePluginUtils.hasNullOrderOverrides(rawOrderBy) ? require_databasePluginUtils.sortRowsByOrder(await require_prismaRows.getPrismaDelegate(client, input.model).findMany({ where: require_prismaQuery.createPrismaWhere(input.where, provider) }), rawOrderBy).slice(input.offset, input.offset + input.limit) : await require_prismaRows.getPrismaDelegate(client, input.model).findMany({
-		where: require_prismaQuery.createPrismaWhere(input.where, provider),
-		...orderBy ? { orderBy } : {},
-		skip: input.offset,
-		take: input.limit
-	});
-	switch (input.model) {
-		case "bundles": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaBundleRow);
-		case "bundle_patches": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaPatchRow);
-		case "bundle_events": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaBundleEventRow);
-		case "channels": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaChannelRow);
-		case "api_keys": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaApiKeyRow);
-		case "releases": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaReleaseRow);
-		case "release_catalogs": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaReleaseCatalogRow);
-	}
-};
-const assertPatchReferences = async (client, bundleId, baseBundleId) => {
-	const ids = Array.from(new Set([bundleId, baseBundleId]));
-	if (await require_prismaRows.getPrismaDelegate(client, "bundles").count({ where: { id: { in: ids } } }) !== ids.length) throw new require_prismaRows.PrismaAdapterError("patch references a missing bundle");
-};
-const createCrudImplementation = (client, provider, relationMode) => ({
-	deleteChannel: async ({ id }) => {
-		const channels = require_prismaRows.getPrismaDelegate(client, "channels");
-		if (await channels.findFirst({ where: { id } }) === null) return {
-			deleted: false,
-			reason: "not_found"
-		};
-		if (await require_prismaRows.getPrismaDelegate(client, "releases").count({ where: { channel_id: id } }) > 0) return {
-			deleted: false,
-			reason: "not_empty"
-		};
-		try {
-			await channels.deleteMany({ where: { id } });
-		} catch (error) {
-			if (require_databaseConstraintErrors.isChannelDeleteReferencedError(error)) return {
-				deleted: false,
-				reason: "not_empty"
+/**
+* Hot Updater's database on a Prisma client: the storage engine through the
+* shared SQL core, fenced by the schema settings. `db generate` writes the
+* models Prisma applies; `db migrate` then sets the collations Prisma cannot
+* declare and writes the settings rows the fence checks.
+*/
+const prismaAdapter = (config) => {
+	const provider = require_sqlProviders.checkSqlProvider("prismaAdapter", config.provider);
+	const executor = require_prismaExecutor.prismaExecutor(config.prisma, provider);
+	return {
+		...require_builtInDatabase.createEngineDatabase({
+			name: "prisma",
+			adapter: require_sqlAdapter.createSqlAdapter({ executor })
+		}),
+		provider,
+		generateSchema: ((version, _name, { schema } = require_builtInDatabase.builtInTarget) => {
+			if (version !== "latest" && version !== require_builtInDatabase.builtInSettings["schema.core"]) throw new Error(`Invalid version ${version}`);
+			return {
+				code: require_enginePrismaSchema.generatePrismaEngineSchema(provider, schema),
+				path: "prisma/schema.prisma"
 			};
-			throw error;
-		}
-		return { deleted: true };
-	},
-	insertChannel: async (input) => {
-		const delegate = require_prismaRows.getPrismaDelegate(client, "channels");
-		const existing = await delegate.findFirst({ where: { name: input.row.name } });
-		if (existing !== null) return {
-			row: require_prismaRows.parsePrismaChannelRow(existing),
-			inserted: false
-		};
-		const row = require_prismaRows.parsePrismaChannelRow(await delegate.upsert({
-			where: { name: input.row.name },
-			create: input.row,
-			update: {}
-		}));
-		return {
-			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 = require_prismaRows.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 require_prismaRows.parsePrismaBundleRow(row);
-			case "bundle_patches": return require_prismaRows.parsePrismaPatchRow(row);
-			case "bundle_events": return require_prismaRows.parsePrismaBundleEventRow(row);
-			case "channels": return require_prismaRows.parsePrismaChannelRow(row);
-			case "api_keys": return require_prismaRows.parsePrismaApiKeyRow(row);
-			case "releases": return require_prismaRows.parsePrismaReleaseRow(row);
-			case "release_catalogs": return require_prismaRows.parsePrismaReleaseCatalogRow(row);
-		}
-	},
-	update: async (input) => {
-		const id = input.where[0]?.value;
-		if (typeof id !== "string") throw new require_prismaRows.PrismaAdapterError(`${input.model} update requires a string id`);
-		if (input.model === "api_keys") {
-			const delegate = require_prismaRows.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 : require_prismaRows.parsePrismaApiKeyRow(stored);
-		}
-		if (input.model === "releases") {
-			const delegate = require_prismaRows.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 : require_prismaRows.parsePrismaReleaseRow(stored);
-		}
-		if (input.model === "release_catalogs") {
-			const delegate = require_prismaRows.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
+		}),
+		createMigrator: ({ schema, settings } = require_builtInDatabase.builtInTarget) => {
+			const collations = require_enginePrismaSchema.prismaCollationStatements(provider, schema);
+			return require_settingsMigrator.createSettingsMigrator({
+				adapterName: "prisma",
+				executor,
+				settings,
+				applyTables: "`prisma db push` (or `prisma migrate`)",
+				...collations.length === 0 ? {} : { fixups: {
+					description: "Set the collations Prisma cannot declare, so strings compare by their bytes",
+					statements: collations
+				} }
 			});
-			const stored = await delegate.findFirst({ where: { scope_key: id } });
-			return stored === null ? null : require_prismaRows.parsePrismaReleaseCatalogRow(stored);
-		}
-		const delegate = require_prismaRows.getPrismaDelegate(client, "bundles");
-		if (delegate.updateMany === void 0) throw new require_prismaRows.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 require_prismaRows.parsePrismaBundleRow(stored);
-	},
-	delete: async (input) => {
-		if (input.model === "bundles" && relationMode === "prisma") {
-			const ids = require_prismaRows.parsePrismaRows(await require_prismaRows.getPrismaDelegate(client, "bundles").findMany({ where: require_prismaQuery.createPrismaWhere(input.where, provider) }), require_prismaRows.parsePrismaBundleRow).map(({ id }) => id);
-			if (ids.length === 0) return;
-			await require_prismaRows.getPrismaDelegate(client, "bundle_patches").deleteMany({ where: { OR: [{ bundle_id: { in: ids } }, { base_bundle_id: { in: ids } }] } });
-		}
-		try {
-			await require_prismaRows.getPrismaDelegate(client, input.model).deleteMany({ where: require_prismaQuery.createPrismaWhere(input.where, provider) });
-		} catch (error) {
-			if (input.model === "channels") require_databaseConstraintErrors.translateChannelDeleteError(error);
-			throw error;
-		}
-	},
-	count: async (input) => {
-		if (input.distinct !== void 0) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
-		return require_prismaRows.getPrismaDelegate(client, input.model).count({ where: require_prismaQuery.createPrismaWhere(input.where, provider) });
-	},
-	findOne: async (input) => {
-		const row = await require_prismaRows.getPrismaDelegate(client, input.model).findFirst({ where: require_prismaQuery.createPrismaWhere(input.where, provider) });
-		if (row === null) return null;
-		switch (input.model) {
-			case "bundles": return require_prismaRows.parsePrismaBundleRow(row);
-			case "bundle_patches": return require_prismaRows.parsePrismaPatchRow(row);
-			case "channels": return require_prismaRows.parsePrismaChannelRow(row);
-			case "api_keys": return require_prismaRows.parsePrismaApiKeyRow(row);
-			case "releases": return require_prismaRows.parsePrismaReleaseRow(row);
-			case "release_catalogs": return require_prismaRows.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 require_prismaRows.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 require_prismaRows.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 require_prismaRows.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) => {
-	assertPrismaProvider(config.provider);
-	const adapter = (0, _hot_updater_plugin_core_internal.createDatabasePluginAdapter)("prisma", createPrismaImplementation(config.prisma, config.relationMode ?? "foreign-keys", config.provider));
-	return Object.assign((0, _hot_updater_plugin_core.createDatabasePlugin)({
-		name: "prisma",
-		models: adapter.models,
-		commit: adapter.commit
-	}), {
-		adapterName: "prisma",
-		provider: config.provider,
-		generateSchema: ((version) => ({
-			code: require_schemaGenerators.generatePrismaSchema(config.provider, version === "latest" ? require_registry.hotUpdaterSchema : require_registry.getHotUpdaterSchemaVersion(version)),
-			path: "./prisma/schema/hot_updater.prisma"
-		}))
-	});
-};
 //#endregion
 exports.prismaAdapter = prismaAdapter;

package/dist/adapters/prisma.d.cts

@@ -1,13 +1,17 @@
-import { DatabaseAdapterWithCapabilities, ORMSQLProvider } from "../db/types.cjs";
-
+import { ToolingDatabase } from "../db/types.cjs";
+import { PrismaProvider } from "../db/enginePrismaSchema.cjs";
 //#region src/adapters/prisma.d.ts
-type PrismaRelationMode = "prisma" | "foreign-keys";
 interface PrismaConfig {
+  /** A Prisma client: raw queries and interactive transactions run on it. */
   readonly prisma: object;
-  readonly provider: ORMSQLProvider;
-  readonly relationMode?: PrismaRelationMode;
-  readonly db?: unknown;
+  readonly provider: PrismaProvider;
 }
-declare const prismaAdapter: (config: PrismaConfig) => DatabaseAdapterWithCapabilities;
+/**
+ * Hot Updater's database on a Prisma client: the storage engine through the
+ * shared SQL core, fenced by the schema settings. `db generate` writes the
+ * models Prisma applies; `db migrate` then sets the collations Prisma cannot
+ * declare and writes the settings rows the fence checks.
+ */
+declare const prismaAdapter: (config: PrismaConfig) => ToolingDatabase;
 //#endregion
-export { PrismaConfig, prismaAdapter };
+export { PrismaConfig, type PrismaProvider, prismaAdapter };

package/dist/adapters/prisma.d.mts

@@ -1,13 +1,17 @@
-import { DatabaseAdapterWithCapabilities, ORMSQLProvider } from "../db/types.mjs";
-
+import { ToolingDatabase } from "../db/types.mjs";
+import { PrismaProvider } from "../db/enginePrismaSchema.mjs";
 //#region src/adapters/prisma.d.ts
-type PrismaRelationMode = "prisma" | "foreign-keys";
 interface PrismaConfig {
+  /** A Prisma client: raw queries and interactive transactions run on it. */
   readonly prisma: object;
-  readonly provider: ORMSQLProvider;
-  readonly relationMode?: PrismaRelationMode;
-  readonly db?: unknown;
+  readonly provider: PrismaProvider;
 }
-declare const prismaAdapter: (config: PrismaConfig) => DatabaseAdapterWithCapabilities;
+/**
+ * Hot Updater's database on a Prisma client: the storage engine through the
+ * shared SQL core, fenced by the schema settings. `db generate` writes the
+ * models Prisma applies; `db migrate` then sets the collations Prisma cannot
+ * declare and writes the settings rows the fence checks.
+ */
+declare const prismaAdapter: (config: PrismaConfig) => ToolingDatabase;
 //#endregion
-export { PrismaConfig, prismaAdapter };
+export { PrismaConfig, type PrismaProvider, prismaAdapter };