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

package/dist/adapters/prisma.mjs

@@ -1,227 +1,46 @@
-import { getHotUpdaterSchemaVersion, hotUpdaterSchema } from "../db/schema/registry.mjs";
-import { generatePrismaSchema } from "../db/schemaGenerators.mjs";
-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";
+import { createSettingsMigrator } from "../db/settingsMigrator.mjs";
+import { builtInSettings, builtInTarget, createEngineDatabase } from "../db/builtInDatabase.mjs";
+import { createSqlAdapter } from "../database/sql/sqlAdapter.mjs";
+import { checkSqlProvider } from "./sqlProviders.mjs";
+import { generatePrismaEngineSchema, prismaCollationStatements } from "../db/enginePrismaSchema.mjs";
+import { prismaExecutor } from "./prismaExecutor.mjs";
 //#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 PrismaAdapterError("Prisma adapter does not support MongoDB; use mongodbAdapter instead");
-};
-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 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"
-		};
-		if (await getPrismaDelegate(client, "releases").count({ where: { channel_id: id } }) > 0) return {
-			deleted: false,
-			reason: "not_empty"
-		};
-		try {
-			await channels.deleteMany({ where: { id } });
-		} catch (error) {
-			if (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 = checkSqlProvider("prismaAdapter", config.provider);
+	const executor = prismaExecutor(config.prisma, provider);
+	return {
+		...createEngineDatabase({
+			name: "prisma",
+			adapter: createSqlAdapter({ executor })
+		}),
+		provider,
+		generateSchema: ((version, _name, { schema } = builtInTarget) => {
+			if (version !== "latest" && version !== builtInSettings["schema.core"]) throw new Error(`Invalid version ${version}`);
+			return {
+				code: generatePrismaEngineSchema(provider, schema),
+				path: "prisma/schema.prisma"
 			};
-			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 {
-			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
+		}),
+		createMigrator: ({ schema, settings } = builtInTarget) => {
+			const collations = prismaCollationStatements(provider, schema);
+			return 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 : 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) => {
-	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) => ({
-			code: generatePrismaSchema(config.provider, version === "latest" ? hotUpdaterSchema : getHotUpdaterSchemaVersion(version)),
-			path: "./prisma/schema/hot_updater.prisma"
-		}))
-	});
-};
 //#endregion
 export { prismaAdapter };

package/dist/adapters/prismaExecutor.cjs

@@ -0,0 +1,64 @@
+const require_fence = require("../database/fence.cjs");
+const require_sqlSchema = require("../database/sql/sqlSchema.cjs");
+//#region src/adapters/prismaExecutor.ts
+/**
+* Prisma reports a raw query's database error as P2010 with the database's
+* code in `meta.code`, and a failed transaction as P2034. The error thrown on
+* carries that code, as the SQL core classifies it, with Prisma's as `cause`.
+*/
+const withDatabaseCode = (dialect, error) => {
+	const { code, meta } = error ?? {};
+	const database = code === "P2034" ? "40001" : meta?.code === void 0 ? void 0 : String(meta.code);
+	if (database === void 0) return error;
+	return Object.assign(new Error(String(meta?.message ?? error.message), { cause: error }), { code: dialect === "sqlite" ? `SQLITE:${database}` : database });
+};
+/** MySQL's ASCII keys are `VarBinary` in Prisma's schema, and read back as bytes. */
+const decoder = new TextDecoder();
+const decodeRow = (row) => {
+	for (const [column, value] of Object.entries(row)) if (value instanceof Uint8Array) row[column] = decoder.decode(value);
+	return row;
+};
+const over = (dialect, client) => ({ async execute({ sql, params }) {
+	try {
+		if (/^\s*SELECT\b/iu.test(sql)) return {
+			rows: (await client.$queryRawUnsafe(sql, ...params)).map(decodeRow),
+			changes: 0
+		};
+		return {
+			rows: [],
+			changes: Number(await client.$executeRawUnsafe(sql, ...params))
+		};
+	} catch (error) {
+		throw withDatabaseCode(dialect, error);
+	}
+} });
+/** Taking the write lock first makes a SQLite transaction behave as BEGIN IMMEDIATE. */
+const writeLock = (dialect) => `UPDATE ${require_sqlSchema.quoteSql(dialect, require_fence.SETTINGS_TABLE.name)} SET ${require_sqlSchema.quoteSql(dialect, "_v")} = ${require_sqlSchema.quoteSql(dialect, "_v")} WHERE 0 = 1`;
+/**
+* The SQL core's executor over a Prisma client, through raw queries and
+* interactive transactions. A SQLite transaction takes the write lock with
+* its first statement, as BEGIN IMMEDIATE would.
+*/
+const prismaExecutor = (client, dialect) => ({
+	dialect,
+	...over(dialect, client),
+	async transaction(fn) {
+		try {
+			return await client.$transaction(async (tx) => {
+				const connection = over(dialect, tx);
+				if (dialect === "sqlite") await connection.execute({
+					sql: writeLock(dialect),
+					params: []
+				});
+				return fn(connection);
+			}, {
+				maxWait: 1e4,
+				timeout: 3e4
+			});
+		} catch (error) {
+			throw withDatabaseCode(dialect, error);
+		}
+	}
+});
+//#endregion
+exports.prismaExecutor = prismaExecutor;

package/dist/adapters/prismaExecutor.mjs

@@ -0,0 +1,64 @@
+import { SETTINGS_TABLE } from "../database/fence.mjs";
+import { quoteSql } from "../database/sql/sqlSchema.mjs";
+//#region src/adapters/prismaExecutor.ts
+/**
+* Prisma reports a raw query's database error as P2010 with the database's
+* code in `meta.code`, and a failed transaction as P2034. The error thrown on
+* carries that code, as the SQL core classifies it, with Prisma's as `cause`.
+*/
+const withDatabaseCode = (dialect, error) => {
+	const { code, meta } = error ?? {};
+	const database = code === "P2034" ? "40001" : meta?.code === void 0 ? void 0 : String(meta.code);
+	if (database === void 0) return error;
+	return Object.assign(new Error(String(meta?.message ?? error.message), { cause: error }), { code: dialect === "sqlite" ? `SQLITE:${database}` : database });
+};
+/** MySQL's ASCII keys are `VarBinary` in Prisma's schema, and read back as bytes. */
+const decoder = new TextDecoder();
+const decodeRow = (row) => {
+	for (const [column, value] of Object.entries(row)) if (value instanceof Uint8Array) row[column] = decoder.decode(value);
+	return row;
+};
+const over = (dialect, client) => ({ async execute({ sql, params }) {
+	try {
+		if (/^\s*SELECT\b/iu.test(sql)) return {
+			rows: (await client.$queryRawUnsafe(sql, ...params)).map(decodeRow),
+			changes: 0
+		};
+		return {
+			rows: [],
+			changes: Number(await client.$executeRawUnsafe(sql, ...params))
+		};
+	} catch (error) {
+		throw withDatabaseCode(dialect, error);
+	}
+} });
+/** Taking the write lock first makes a SQLite transaction behave as BEGIN IMMEDIATE. */
+const writeLock = (dialect) => `UPDATE ${quoteSql(dialect, SETTINGS_TABLE.name)} SET ${quoteSql(dialect, "_v")} = ${quoteSql(dialect, "_v")} WHERE 0 = 1`;
+/**
+* The SQL core's executor over a Prisma client, through raw queries and
+* interactive transactions. A SQLite transaction takes the write lock with
+* its first statement, as BEGIN IMMEDIATE would.
+*/
+const prismaExecutor = (client, dialect) => ({
+	dialect,
+	...over(dialect, client),
+	async transaction(fn) {
+		try {
+			return await client.$transaction(async (tx) => {
+				const connection = over(dialect, tx);
+				if (dialect === "sqlite") await connection.execute({
+					sql: writeLock(dialect),
+					params: []
+				});
+				return fn(connection);
+			}, {
+				maxWait: 1e4,
+				timeout: 3e4
+			});
+		} catch (error) {
+			throw withDatabaseCode(dialect, error);
+		}
+	}
+});
+//#endregion
+export { prismaExecutor };

package/dist/adapters/sqlProviders.cjs

@@ -0,0 +1,9 @@
+const require_types = require("../db/types.cjs");
+//#region src/adapters/sqlProviders.ts
+/** The provider an adapter was given, when Hot Updater's SQL core runs on it. */
+const checkSqlProvider = (adapter, provider) => {
+	if (!require_types.sqlProviders.includes(provider)) throw new Error(`${adapter}: provider "${String(provider)}" is not supported. Use ${require_types.sqlProviders.map((name) => `"${name}"`).join(", ")}; CockroachDB and SQL Server were dropped in 1.0.`);
+	return provider;
+};
+//#endregion
+exports.checkSqlProvider = checkSqlProvider;

package/dist/adapters/sqlProviders.mjs

@@ -0,0 +1,9 @@
+import { sqlProviders } from "../db/types.mjs";
+//#region src/adapters/sqlProviders.ts
+/** The provider an adapter was given, when Hot Updater's SQL core runs on it. */
+const checkSqlProvider = (adapter, provider) => {
+	if (!sqlProviders.includes(provider)) throw new Error(`${adapter}: provider "${String(provider)}" is not supported. Use ${sqlProviders.map((name) => `"${name}"`).join(", ")}; CockroachDB and SQL Server were dropped in 1.0.`);
+	return provider;
+};
+//#endregion
+export { checkSqlProvider };

package/dist/apiKeys.cjs

@@ -18,13 +18,13 @@ const isApiKey = (value) => {
 	}
 };
 const normalizeApiKeyHeaderName = (value = API_KEY_HEADER_NAME) => {
-	if (typeof value !== "string" || value.length === 0) throw new TypeError("clientAccess.headerName must be a valid header name.");
+	if (typeof value !== "string" || value.length === 0) throw new TypeError("apiKeys({ headerName }) must name a valid header.");
 	try {
 		const headers = new Headers();
 		headers.set(value, "");
 		return headers.keys().next().value;
 	} catch {
-		throw new TypeError("clientAccess.headerName must be a valid header name.");
+		throw new TypeError("apiKeys({ headerName }) must name a valid header.");
 	}
 };
 const hashApiKey = async (apiKey) => {
@@ -33,7 +33,7 @@ const hashApiKey = async (apiKey) => {
 	return bytesToBase64Url(new Uint8Array(digest));
 };
 const apiKeyId = () => {
-	const bytes = new Uint8Array(16);
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
 	crypto.getRandomValues(bytes);
 	return `api-${bytesToBase64Url(bytes)}`;
 };
@@ -70,7 +70,7 @@ const registerApiKey = async (input) => {
 	});
 };
 const createApiKey = (input) => {
-	const bytes = new Uint8Array(32);
+	const bytes = /* @__PURE__ */ new Uint8Array(32);
 	crypto.getRandomValues(bytes);
 	return registerApiKey({
 		apiKey: bytesToBase64Url(bytes),
@@ -100,13 +100,11 @@ const authenticateApiKey = async (input) => {
 	const apiKey = input.request.headers.get(normalizeApiKeyHeaderName(input.headerName));
 	if (apiKey === null || !isApiKey(apiKey)) return false;
 	const hash = await hashApiKey(apiKey);
-	await input.beforeLookup?.();
 	const record = await input.apiKeys.findByHash(hash);
 	return record !== null && record.hash === hash && record.role === "client" && record.revoked_at_ms === null;
 };
 const createApiKeyManagement = (input) => Object.freeze({
 	async create({ name }) {
-		await input.beforeOperation();
 		const created = await createApiKey({
 			apiKeys: input.apiKeys,
 			name
@@ -117,11 +115,9 @@ const createApiKeyManagement = (input) => Object.freeze({
 		});
 	},
 	async list() {
-		await input.beforeOperation();
 		return Object.freeze((await input.apiKeys.list()).map(toApiKeyMetadata));
 	},
 	async revoke({ id }) {
-		await input.beforeOperation();
 		const record = await input.apiKeys.revoke({
 			id,
 			revokedAtMs: Date.now()
@@ -131,9 +127,13 @@ const createApiKeyManagement = (input) => Object.freeze({
 });
 //#endregion
 exports.API_KEY_HEADER_NAME = API_KEY_HEADER_NAME;
+exports.apiKeyId = apiKeyId;
 exports.authenticateApiKey = authenticateApiKey;
 exports.createApiKey = createApiKey;
 exports.createApiKeyManagement = createApiKeyManagement;
+exports.hashApiKey = hashApiKey;
+exports.isApiKey = isApiKey;
 exports.normalizeApiKeyHeaderName = normalizeApiKeyHeaderName;
+exports.normalizeApiKeyName = normalizeApiKeyName;
 exports.provisionApiKey = provisionApiKey;
 exports.registerApiKey = registerApiKey;

package/dist/apiKeys.d.cts

@@ -1,5 +1,4 @@
 import { ApiKeyModel, ApiKeyRow } from "@hot-updater/plugin-core";
-
 //#region src/apiKeys.d.ts
 declare const API_KEY_HEADER_NAME = "x-api-key";
 type ApiKeyMetadata = Omit<ApiKeyRow, "hash">;
@@ -24,27 +23,5 @@ interface ApiKeyManagementAPI {
     readonly id: string;
   }): Promise<ApiKeyMetadata | null>;
 }
-declare const registerApiKey: (input: {
-  readonly apiKey: string;
-  readonly apiKeys: ApiKeyModel;
-  readonly createdAtMs?: number;
-  readonly name: string;
-}) => Promise<CreatedApiKey>;
-declare const createApiKey: (input: {
-  readonly apiKeys: ApiKeyModel;
-  readonly name: string;
-}) => Promise<CreatedApiKey>;
-/**
- * Provisions the client API key used by managed init.
- *
- * A saved plaintext key is registered idempotently; otherwise a new key is
- * created. Callers must persist or display the returned plaintext because the
- * database stores only its hash.
- */
-declare const provisionApiKey: (input: {
-  readonly apiKeys: ApiKeyModel;
-  readonly existingApiKey?: string;
-  readonly name: string;
-}) => Promise<CreatedApiKey>;
 //#endregion
-export { API_KEY_HEADER_NAME, ApiKeyManagementAPI, ApiKeyMetadata, CreatedApiKey, createApiKey, provisionApiKey, registerApiKey };
+export { API_KEY_HEADER_NAME, ApiKeyManagementAPI, ApiKeyMetadata, CreatedApiKey };

package/dist/apiKeys.d.mts

@@ -1,5 +1,4 @@
 import { ApiKeyModel, ApiKeyRow } from "@hot-updater/plugin-core";
-
 //#region src/apiKeys.d.ts
 declare const API_KEY_HEADER_NAME = "x-api-key";
 type ApiKeyMetadata = Omit<ApiKeyRow, "hash">;
@@ -24,27 +23,5 @@ interface ApiKeyManagementAPI {
     readonly id: string;
   }): Promise<ApiKeyMetadata | null>;
 }
-declare const registerApiKey: (input: {
-  readonly apiKey: string;
-  readonly apiKeys: ApiKeyModel;
-  readonly createdAtMs?: number;
-  readonly name: string;
-}) => Promise<CreatedApiKey>;
-declare const createApiKey: (input: {
-  readonly apiKeys: ApiKeyModel;
-  readonly name: string;
-}) => Promise<CreatedApiKey>;
-/**
- * Provisions the client API key used by managed init.
- *
- * A saved plaintext key is registered idempotently; otherwise a new key is
- * created. Callers must persist or display the returned plaintext because the
- * database stores only its hash.
- */
-declare const provisionApiKey: (input: {
-  readonly apiKeys: ApiKeyModel;
-  readonly existingApiKey?: string;
-  readonly name: string;
-}) => Promise<CreatedApiKey>;
 //#endregion
-export { API_KEY_HEADER_NAME, ApiKeyManagementAPI, ApiKeyMetadata, CreatedApiKey, createApiKey, provisionApiKey, registerApiKey };
+export { API_KEY_HEADER_NAME, ApiKeyManagementAPI, ApiKeyMetadata, CreatedApiKey };

package/dist/apiKeys.mjs

@@ -18,13 +18,13 @@ const isApiKey = (value) => {
 	}
 };
 const normalizeApiKeyHeaderName = (value = API_KEY_HEADER_NAME) => {
-	if (typeof value !== "string" || value.length === 0) throw new TypeError("clientAccess.headerName must be a valid header name.");
+	if (typeof value !== "string" || value.length === 0) throw new TypeError("apiKeys({ headerName }) must name a valid header.");
 	try {
 		const headers = new Headers();
 		headers.set(value, "");
 		return headers.keys().next().value;
 	} catch {
-		throw new TypeError("clientAccess.headerName must be a valid header name.");
+		throw new TypeError("apiKeys({ headerName }) must name a valid header.");
 	}
 };
 const hashApiKey = async (apiKey) => {
@@ -33,7 +33,7 @@ const hashApiKey = async (apiKey) => {
 	return bytesToBase64Url(new Uint8Array(digest));
 };
 const apiKeyId = () => {
-	const bytes = new Uint8Array(16);
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
 	crypto.getRandomValues(bytes);
 	return `api-${bytesToBase64Url(bytes)}`;
 };
@@ -70,7 +70,7 @@ const registerApiKey = async (input) => {
 	});
 };
 const createApiKey = (input) => {
-	const bytes = new Uint8Array(32);
+	const bytes = /* @__PURE__ */ new Uint8Array(32);
 	crypto.getRandomValues(bytes);
 	return registerApiKey({
 		apiKey: bytesToBase64Url(bytes),
@@ -100,13 +100,11 @@ const authenticateApiKey = async (input) => {
 	const apiKey = input.request.headers.get(normalizeApiKeyHeaderName(input.headerName));
 	if (apiKey === null || !isApiKey(apiKey)) return false;
 	const hash = await hashApiKey(apiKey);
-	await input.beforeLookup?.();
 	const record = await input.apiKeys.findByHash(hash);
 	return record !== null && record.hash === hash && record.role === "client" && record.revoked_at_ms === null;
 };
 const createApiKeyManagement = (input) => Object.freeze({
 	async create({ name }) {
-		await input.beforeOperation();
 		const created = await createApiKey({
 			apiKeys: input.apiKeys,
 			name
@@ -117,11 +115,9 @@ const createApiKeyManagement = (input) => Object.freeze({
 		});
 	},
 	async list() {
-		await input.beforeOperation();
 		return Object.freeze((await input.apiKeys.list()).map(toApiKeyMetadata));
 	},
 	async revoke({ id }) {
-		await input.beforeOperation();
 		const record = await input.apiKeys.revoke({
 			id,
 			revokedAtMs: Date.now()
@@ -130,4 +126,4 @@ const createApiKeyManagement = (input) => Object.freeze({
 	}
 });
 //#endregion
-export { API_KEY_HEADER_NAME, authenticateApiKey, createApiKey, createApiKeyManagement, normalizeApiKeyHeaderName, provisionApiKey, registerApiKey };
+export { API_KEY_HEADER_NAME, apiKeyId, authenticateApiKey, createApiKey, createApiKeyManagement, hashApiKey, isApiKey, normalizeApiKeyHeaderName, normalizeApiKeyName, provisionApiKey, registerApiKey };