@prisma/orm-extension-supabase 8.0.0-rc.2-dev.3 → 8.0.0-rc.20

package/dist/runtime.mjs

@@ -1,22 +1,22 @@
-import { n as version, t as contract_default } from "./contract-DFQ5w0dT-ewVq9BvG.mjs";
-import { a as isSupabaseRole, n as SupabaseRole, t as SUPABASE_JWT_ROLE_CLAIM } from "./roles-D5vC3rNp-tYQlvifU.mjs";
+import { n as version, t as contract_default } from "./contract-BT1LXEGv-BCF6iBts.mjs";
+import { a as isSupabaseRole, n as SupabaseRole, t as SUPABASE_JWT_ROLE_CLAIM } from "./roles-9Ql17Kbb-p1cF6Jlt.mjs";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import postgresAdapter from "@prisma/orm-target-postgres/adapter/runtime";
-import postgresDriver from "@prisma/orm-target-postgres/driver/runtime";
-import { instantiateExecutionStack } from "@prisma/orm-framework/components/execution";
-import { PostgresRuntimeImpl, buildNamespacedNativeEnums, isPgPool } from "@prisma/orm-postgres/runtime";
-import { sql } from "@prisma/orm-family-sql/builder/runtime";
-import { orm } from "@prisma/orm-family-sql/orm-client";
-import { createRawSql } from "@prisma/orm-family-sql/relational-core/expression";
-import { createExecutionContext, createSqlExecutionStack, withTransaction } from "@prisma/orm-family-sql/runtime";
+import postgresDriver, { suppressIdleConnectionErrors } from "@prisma/orm-target-postgres/driver/runtime";
+import { buildPostgresStaticContext } from "@prisma/orm-postgres/internal/static-context";
+import { buildPostgresQueryMembers } from "@prisma/orm-postgres/internal/transaction-members";
+import { validatePostgresContract } from "@prisma/orm-postgres/internal/validate-contract";
+import { PostgresRuntimeImpl, isPgPool } from "@prisma/orm-postgres/runtime";
+import { checkCollectionClasses, orm, prepareQuery } from "@prisma/orm-family-sql/orm-client";
+import { activitySource, createExecutionContext, createSqlExecutionStack, withTransaction, withTransactionMembers } from "@prisma/orm-family-sql/runtime";
+import { createTransactionStart, preparedStatementExecute, preparedStatementQuery, transactionStart } from "@prisma/orm-family-sql/runtime/internal/prepared-query";
 import postgresTarget, { PostgresContractSerializer } from "@prisma/orm-target-postgres/target/runtime";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { createRemoteJWKSet, decodeProtectedHeader, jwtVerify } from "jose";
 import { Pool } from "pg";
-import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { AsyncIterableResult } from "@prisma/orm-framework/components/runtime";
-import { preparedStatementExecute, preparedStatementQuery } from "@prisma/orm-family-sql/runtime/internal/prepared-query";
 //#region ../../../3-extensions/supabase/dist/runtime.mjs
 /**
 * Tells the runtime that the Supabase pack's runtime component is available.
@@ -44,14 +44,22 @@ const supabaseRuntimeDescriptor = {
 function supabaseError(code, message, options) {
 	return structuredError(code, message, options);
 }
+let buildRoleScope;
+/**
+* The operations under `binding` of the runtime `runtime()` returns. Each operation calls `runtime()` when it runs, so a client can build its role scope before its runtime exists; when `runtime()` throws, the operation rejects. For the facade only; the package entry does not export it.
+*/
+function roleScope(runtime, binding) {
+	return buildRoleScope(runtime, binding);
+}
 var SupabaseRuntimeImpl = class extends PostgresRuntimeImpl {
 	/**
-	* Opens a raw connection and applies role + JWT claims via session-scoped set_config.
-	* On bind failure, destroys the connection before rethrowing — no leaked connections.
-	* Not on the `SupabaseRuntime` interface; consumed by the facade, not by app code.
+	* Opens a raw connection and applies role + JWT claims via session-scoped set_config. On bind failure, destroys the connection before rethrowing — no leaked connections. Every operation of `forRole(binding)` runs on a session opened here.
 	*/
 	async openRoleSession(binding) {
-		const conn = await this.acquireRawConnection();
+		return (await this.openRoleConnection(binding)).session;
+	}
+	async openRoleConnection(binding, options) {
+		const conn = await this.acquireRawConnection(options);
 		try {
 			await conn.execute({
 				sql: "SELECT set_config($1, $2, false)",
@@ -66,7 +74,9 @@ var SupabaseRuntimeImpl = class extends PostgresRuntimeImpl {
 			throw err;
 		}
 		const self = this;
-		return {
+		const session = {
+			[transactionStart]: createTransactionStart(),
+			[activitySource]: self.connectionActivitySource(conn, () => session),
 			query(plan, options) {
 				return self.queryAgainstQueryable(plan, conn, {
 					...options,
@@ -80,39 +90,13 @@ var SupabaseRuntimeImpl = class extends PostgresRuntimeImpl {
 				});
 			},
 			[preparedStatementQuery](prepared, params, options) {
-				return self.runPreparedQueryAgainstRoleQueryable(prepared, params, conn, options, "connection");
+				return self.runPreparedQueryAgainstRoleQueryable(prepared, params, conn, options);
 			},
 			[preparedStatementExecute](prepared, params, options) {
-				return self.runPreparedExecuteAgainstRoleQueryable(prepared, params, conn, options, "connection");
+				return self.runPreparedExecuteAgainstRoleQueryable(prepared, params, conn, options);
 			},
 			async transaction() {
-				const tx = await conn.beginTransaction();
-				return {
-					async commit() {
-						await tx.commit();
-					},
-					async rollback() {
-						await tx.rollback();
-					},
-					query(plan, options) {
-						return self.queryAgainstQueryable(plan, tx, {
-							...options,
-							scope: "transaction"
-						});
-					},
-					execute(plan, options) {
-						return self.executeStatisticsAgainstQueryable(plan, tx, {
-							...options,
-							scope: "transaction"
-						});
-					},
-					[preparedStatementQuery](prepared, params, options) {
-						return self.runPreparedQueryAgainstRoleQueryable(prepared, params, tx, options, "transaction");
-					},
-					[preparedStatementExecute](prepared, params, options) {
-						return self.runPreparedExecuteAgainstRoleQueryable(prepared, params, tx, options, "transaction");
-					}
-				};
+				return self.beginTransactionOn(conn, session, void 0);
 			},
 			/**
 			* Resets all session-local config then releases the connection back to the pool.
@@ -130,59 +114,100 @@ var SupabaseRuntimeImpl = class extends PostgresRuntimeImpl {
 				await conn.destroy(reason);
 			}
 		};
+		return {
+			conn,
+			session
+		};
 	}
-	/**
-	* Opens a role session, queries the plan, then releases after the stream drains.
-	* On mid-stream error, destroys the session instead of releasing.
-	*/
-	queryWithRole(plan, binding, options) {
-		const self = this;
-		const generator = async function* () {
-			const session = await self.openRoleSession(binding);
-			let errored = false;
-			try {
-				for await (const row of session.query(plan, options)) yield row;
-			} catch (err) {
-				errored = true;
-				await session.destroy(err).catch(() => void 0);
-				throw err;
-			} finally {
-				if (!errored) await session.release();
-			}
+	forRole(binding) {
+		return buildRoleScope(() => this, binding);
+	}
+	static {
+		buildRoleScope = (runtime, binding) => {
+			const open = (options) => async () => (await runtime().openRoleConnection(binding, options)).session;
+			const scope = {
+				query(plan, options) {
+					return streamOnSession(open(options), (session) => session.query(plan, options));
+				},
+				execute(plan, options) {
+					return executeOnSession(open(options), (session) => session.execute(plan, options));
+				},
+				[preparedStatementQuery](statement, params, options) {
+					return streamOnSession(open(options), (session) => session[preparedStatementQuery](statement, params, options));
+				},
+				[preparedStatementExecute](statement, params, options) {
+					return executeOnSession(open(options), (session) => session[preparedStatementExecute](statement, params, options));
+				},
+				connection: open(void 0),
+				[activitySource]: {
+					startActivity: async (activity) => runtime().startActivityOnRoute(route, activity, void 0),
+					planContentHash: async (plan) => runtime().planContentHashFor(plan, "connection", void 0)
+				}
+			};
+			const route = {
+				scope: "connection",
+				parent: () => void 0,
+				runtimeWork: true,
+				query: (plan, options) => scope.query(plan, options),
+				execute: (plan, options) => scope.execute(plan, options),
+				preparedQuery: (statement, params, options) => scope[preparedStatementQuery](statement, params, options),
+				preparedExecute: (statement, params, options) => scope[preparedStatementExecute](statement, params, options),
+				transaction: (parent) => runtime().beginRoleTransaction(binding, parent)
+			};
+			return scope;
 		};
-		return new AsyncIterableResult(generator());
 	}
-	async executeWithRole(plan, binding, options) {
-		const session = await this.openRoleSession(binding);
-		try {
-			const stats = await session.execute(plan, options);
-			await session.release();
-			return stats;
-		} catch (err) {
-			await session.destroy(err).catch(() => void 0);
-			throw err;
-		}
+	async beginRoleTransaction(binding, parent) {
+		const { conn, session } = await this.openRoleConnection(binding, { activityParent: parent });
+		return this.ownTransaction(session, () => this.beginTransactionOn(conn, session, parent));
 	}
-	runPreparedExecuteAgainstRoleQueryable(prepared, params, queryable, options, scope) {
+	runPreparedExecuteAgainstRoleQueryable(prepared, params, queryable, options) {
 		return this.runPreparedExecuteAgainstQueryable(blindCast(prepared), blindCast(params), queryable, {
 			...options,
-			scope
+			scope: "connection"
 		});
 	}
-	runPreparedQueryAgainstRoleQueryable(prepared, params, queryable, options, scope) {
+	runPreparedQueryAgainstRoleQueryable(prepared, params, queryable, options) {
 		return this.runPreparedQueryAgainstQueryable(blindCast(prepared), blindCast(params), queryable, {
 			...options,
-			scope
+			scope: "connection"
 		});
 	}
 };
-function hasContractJson(options) {
-	return "contractJson" in options;
+function streamOnSession(open, rows) {
+	const generator = async function* () {
+		const session = await open();
+		let errored = false;
+		try {
+			for await (const row of rows(session)) yield row;
+		} catch (err) {
+			errored = true;
+			await session.destroy(err).catch(() => void 0);
+			throw err;
+		} finally {
+			if (!errored) await session.release();
+		}
+	};
+	return new AsyncIterableResult(generator());
+}
+async function executeOnSession(open, run) {
+	const session = await open();
+	try {
+		const stats = await run(session);
+		await session.release();
+		return stats;
+	} catch (err) {
+		await session.destroy(err).catch(() => void 0);
+		throw err;
+	}
 }
 const contractSerializer = new PostgresContractSerializer();
-function resolveContract(options) {
-	const contractJson = hasContractJson(options) ? options.contractJson : contractSerializer.serializeContract(options.contract);
-	return blindCast(contractSerializer.deserializeContract(contractJson));
+function closedClientError() {
+	return structuredError("DRIVER.NOT_CONNECTED", "Runtime is closed", {
+		why: "close() was called on this client.",
+		fix: "Create a new supabase(...) client.",
+		meta: { extension: "supabase" }
+	});
 }
 function resolveKeyMaterial(options) {
 	const jwtSecret = "jwtSecret" in options ? options.jwtSecret : void 0;
@@ -220,17 +245,25 @@ function algKeyMismatchReason(jwt, kind) {
 	if (kind === "secret" && asymmetric) return `token is signed with ${alg} but this client is configured with jwtSecret (HS256). Current Supabase projects sign with asymmetric keys by default — configure jwksUrl (https://<project>/auth/v1/.well-known/jwks.json) instead of jwtSecret.`;
 	if (kind === "jwks" && alg.startsWith("HS")) return `token is signed with ${alg} (a symmetric algorithm) but this client is configured with jwksUrl. A legacy HS256 Supabase project needs jwtSecret (the JWT_SECRET from \`supabase status\`) instead of jwksUrl.`;
 }
+function checkPgOption(pg) {
+	if (pg === void 0 || typeof pg === "object" && pg !== null && isPgPool(pg)) return;
+	throw supabaseError("SUPABASE.CONFIG_INVALID", "The pg option takes a pg.Pool", {
+		why: "Each role-bound query needs a connection of its own, which a single pg.Client cannot give.",
+		fix: "Pass a pg.Pool as pg, or pass url.",
+		meta: { reason: "pg is not a pg.Pool" }
+	});
+}
 function toPool(options) {
 	if (options.pg !== void 0 && isPgPool(options.pg)) return {
 		pool: options.pg,
 		owned: false
 	};
 	if (typeof options.url === "string") return {
-		pool: new Pool({
+		pool: suppressIdleConnectionErrors(new Pool({
 			connectionString: options.url,
 			connectionTimeoutMillis: options.poolOptions?.connectionTimeoutMillis ?? 2e4,
 			idleTimeoutMillis: options.poolOptions?.idleTimeoutMillis ?? 3e4
-		}),
+		})),
 		owned: true
 	};
 }
@@ -241,16 +274,34 @@ function withSupabaseDescriptor(extensions) {
 /**
 * Deserializes the Supabase extension's own emitted contract into a runtime
 * contract: namespaces hydrate into `PostgresSchema` instances (with
-* `qualifyTable`), and `typeRef` columns (`Timestamptz`, `Uuid`) resolve
-* through the codec registry. Exposed only via `service_role`'s `.supabase`
+* `qualifyTable`), and each column resolves its codec through the codec
+* registry. Exposed only via `service_role`'s `.supabase`
 * secondary root — never merged into the app contract.
 */
 function buildExtensionContract() {
 	return blindCast(contractSerializer.deserializeContract(contract_default));
 }
+/**
+* Creates a Supabase client whose queries run as the role a JWT names. The client infers its
+* contract type from `contract`: a value from `contractFromJson` of `@prisma/orm-postgres/static`
+* for an emitted contract, or a TypeScript-authored contract. A contract is validated once, however
+* many clients are built from it. The pool is created on the first query.
+*
+* @example
+* ```ts
+* import { contractFromJson } from '@prisma/orm-postgres/static';
+* import { supabase } from '@prisma/orm-extension-supabase/runtime';
+* import type { Contract } from './contract.d';
+* import contractJson from './contract.json' with { type: 'json' };
+*
+* export const contract = contractFromJson<Contract>(contractJson);
+* export const db = await supabase({ contract, url, jwtSecret });
+* ```
+*/
 async function supabase(options) {
 	const keyMaterial = resolveKeyMaterial(options);
-	const contract = resolveContract(options);
+	checkPgOption(options.pg);
+	const contract = validatePostgresContract(options.contract);
 	const stack = createSqlExecutionStack({
 		target: postgresTarget,
 		adapter: postgresAdapter,
@@ -261,25 +312,63 @@ async function supabase(options) {
 		contract,
 		stack
 	});
-	const rawCodecInferer = stack.adapter.rawCodecInferer;
-	const rawSqlTag = createRawSql(rawCodecInferer);
-	const poolEntry = toPool(options);
-	let closed = false;
-	const stackInstance = instantiateExecutionStack(stack);
-	const driverDescriptor = stack.driver;
-	if (!driverDescriptor) throw new InternalError("Driver descriptor missing from execution stack");
-	const driver = driverDescriptor.create({ cursor: { disabled: true } });
-	if (poolEntry) await driver.connect({
-		kind: "pgPool",
-		pool: poolEntry.pool
-	});
-	const runtime = new SupabaseRuntimeImpl({
-		context,
-		adapter: stackInstance.adapter,
-		driver,
-		...ifDefined("verifyMarker", options.verifyMarker),
-		...ifDefined("middleware", options.middleware)
+	checkCollectionClasses(contract, options.collections);
+	const { sql: appSql, raw, toSql, enums, nativeEnums } = buildPostgresStaticContext(contract, context, stack);
+	const extContract = buildExtensionContract();
+	const extContext = createExecutionContext({
+		contract: extContract,
+		stack
 	});
+	const extStatic = buildPostgresStaticContext(extContract, extContext, stack);
+	let runtimes;
+	let connectError;
+	let closed = false;
+	function getRuntimes() {
+		if (connectError !== void 0) throw connectError.error;
+		if (runtimes !== void 0) return runtimes;
+		if (closed) throw closedClientError();
+		const driverDescriptor = stack.driver;
+		if (!driverDescriptor) throw new InternalError("Driver descriptor missing from execution stack");
+		const adapter = stack.adapter.create(stack);
+		const driver = driverDescriptor.create({ cursor: { disabled: true } });
+		const sharedOptions = {
+			adapter,
+			driver,
+			...ifDefined("middleware", options.middleware),
+			...ifDefined("log", options.log),
+			...ifDefined("mode", options.mode),
+			closeRefusal: "at-once",
+			ownsDriver: false
+		};
+		const runtime = new SupabaseRuntimeImpl({
+			context,
+			...sharedOptions,
+			...ifDefined("verifyMarker", options.verifyMarker)
+		});
+		const extRuntime = new SupabaseRuntimeImpl({
+			context: extContext,
+			...sharedOptions,
+			verifyMarker: false
+		});
+		const poolEntry = toPool(options);
+		const ownedPool = poolEntry?.owned ? poolEntry.pool : void 0;
+		if (poolEntry) driver.connect({
+			kind: "pgPool",
+			pool: poolEntry.pool
+		}).catch(async (err) => {
+			connectError = { error: err };
+			await ownedPool?.end().catch(() => void 0);
+		});
+		runtimes = {
+			runtime,
+			extRuntime,
+			driver,
+			ownedPool
+		};
+		return runtimes;
+	}
+	const runtime = () => getRuntimes().runtime;
+	const extRuntime = () => getRuntimes().extRuntime;
 	async function verifyJwt(jwt) {
 		const mismatch = algKeyMismatchReason(jwt, keyMaterial.kind);
 		if (mismatch !== void 0) throw supabaseError("SUPABASE.JWT_INVALID", `Invalid JWT: ${mismatch}`, { meta: { reason: mismatch } });
@@ -294,86 +383,71 @@ async function supabase(options) {
 			});
 		}
 	}
-	function buildRoleBoundDbWithContext(binding, roleContext, roleRuntime) {
-		return {
-			sql: sql({
-				context: roleContext,
-				rawCodecInferer
-			}),
-			orm: orm({
-				runtime: {
-					query(plan) {
-						return roleRuntime.queryWithRole(plan, binding);
-					},
-					execute(plan) {
-						return roleRuntime.executeWithRole(plan, binding);
-					},
-					connection: () => roleRuntime.openRoleSession(binding)
-				},
-				context: roleContext
-			}),
-			raw: rawSqlTag,
-			query(plan, execOptions) {
-				return roleRuntime.queryWithRole(plan, binding, execOptions);
-			},
-			execute(plan, execOptions) {
-				return roleRuntime.executeWithRole(plan, binding, execOptions);
+	function buildRoleBoundDb(binding) {
+		const role = roleScope(runtime, binding);
+		const roleOrm = orm({
+			runtime: role,
+			context,
+			...ifDefined("collections", options.collections)
+		});
+		const roleBound = {
+			sql: appSql,
+			orm: roleOrm,
+			raw,
+			toSql,
+			enums,
+			nativeEnums,
+			prepare(declaration, callback) {
+				return prepareQuery(runtime(), declaration, callback);
 			},
+			query: role.query,
+			execute: role.execute,
+			[preparedStatementQuery]: role[preparedStatementQuery],
+			[preparedStatementExecute]: role[preparedStatementExecute],
 			transaction(fn) {
-				return withTransaction({ connection: () => roleRuntime.openRoleSession(binding) }, fn);
+				return withTransaction(role, (txCtx) => fn(withTransactionMembers(txCtx, {
+					...buildPostgresQueryMembers({
+						context,
+						collections: options.collections,
+						sql: appSql,
+						raw,
+						toSql,
+						prepareRuntime: runtime
+					}, txCtx),
+					enums,
+					nativeEnums
+				})));
 			}
 		};
-	}
-	function buildRoleBoundDb(binding) {
-		return buildRoleBoundDbWithContext(binding, context, runtime);
+		return Object.assign(roleBound, { [activitySource]: role[activitySource] });
 	}
 	const serviceRoleBinding = {
 		role: SupabaseRole.members.ServiceRole,
 		claims: {}
 	};
-	const extContract = buildExtensionContract();
-	const extContext = createExecutionContext({
-		contract: extContract,
-		stack
-	});
-	const extRuntime = new SupabaseRuntimeImpl({
-		context: extContext,
-		adapter: stackInstance.adapter,
-		driver,
-		verifyMarker: false,
-		...ifDefined("middleware", options.middleware)
-	});
-	const extNativeEnums = blindCast(Object.freeze(buildNamespacedNativeEnums(extContract.storage)));
+	const serviceRole = roleScope(extRuntime, serviceRoleBinding);
 	const supabaseInternal = {
-		sql: sql({
-			context: extContext,
-			rawCodecInferer
-		}),
+		sql: extStatic.sql,
+		toSql: extStatic.toSql,
 		orm: orm({
-			runtime: {
-				query(plan) {
-					return extRuntime.queryWithRole(plan, serviceRoleBinding);
-				},
-				execute(plan) {
-					return extRuntime.executeWithRole(plan, serviceRoleBinding);
-				},
-				connection: () => extRuntime.openRoleSession(serviceRoleBinding)
-			},
+			runtime: serviceRole,
 			context: extContext
 		}),
-		nativeEnums: extNativeEnums,
-		query(plan, execOptions) {
-			return extRuntime.queryWithRole(plan, serviceRoleBinding, execOptions);
-		},
-		execute(plan, execOptions) {
-			return extRuntime.executeWithRole(plan, serviceRoleBinding, execOptions);
-		}
+		nativeEnums: extStatic.nativeEnums,
+		query: serviceRole.query,
+		execute: serviceRole.execute
 	};
-	async function closeDb() {
-		if (closed) return;
+	let closePromise;
+	async function closeRuntimes() {
+		if (runtimes === void 0) return;
+		const { runtime, extRuntime, driver, ownedPool } = runtimes;
+		await Promise.all([runtime.close(), extRuntime.close()]);
+		if (ownedPool !== void 0) await driver.close();
+	}
+	function closeDb() {
 		closed = true;
-		await runtime.close();
-		if (poolEntry?.owned) await poolEntry.pool.end().catch(() => void 0);
+		closePromise ??= closeRuntimes();
+		return closePromise;
 	}
 	return {
 		context,
@@ -395,7 +469,7 @@ async function supabase(options) {
 		},
 		asServiceRole() {
 			return {
-				...buildRoleBoundDbWithContext(serviceRoleBinding, context, runtime),
+				...buildRoleBoundDb(serviceRoleBinding),
 				supabase: supabaseInternal
 			};
 		},