@prisma/orm-family-sql 8.0.0-rc.16-dev.1 → 8.0.0-rc.16-dev.3

package/dist/orm-client.mjs

@@ -1,8 +1,8 @@
 import { t as resolveStorageTable } from "./resolve-storage-table-DZsfnzeW.mjs";
 import { i as isUniqueConstraintViolation } from "./dist-x6jvtkKM.mjs";
-import { A as ParamRef, C as LiteralExpr, E as NullCheckExpr, F as SelectAst, G as isOrderByNulls, I as SubqueryExpr, L as TableSource, M as ProjectionItem, O as OrExpr, R as UpdateAst, S as ListExpression, T as NotExpr, U as isAggregateFn, V as checkLimitOffset, W as isOrderByDirection, _ as InsertAst, b as JsonArrayAggExpr, c as DeleteAst, f as EqColJoinOn, k as OrderByItem, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, q as isWhereExpr, r as BinaryExpr, s as DefaultValueExpr, t as AggregateExpr, v as InsertOnConflict, x as JsonObjectExpr, y as JoinAst, z as WindowFuncExpr } from "./types-NTQsD2MS-DAP2yVDn.mjs";
+import { A as ParamRef, C as LiteralExpr, E as NullCheckExpr, F as SelectAst, G as isOrderByNulls, I as SubqueryExpr, L as TableSource, M as ProjectionItem, O as OrExpr, R as UpdateAst, S as ListExpression, T as NotExpr, U as isAggregateFn, V as checkLimitOffset, W as isOrderByDirection, _ as InsertAst, b as JsonArrayAggExpr, c as DeleteAst, f as EqColJoinOn, k as OrderByItem, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, q as isWhereExpr, r as BinaryExpr, s as DefaultValueExpr, t as AggregateExpr, v as InsertOnConflict, w as LockingClause, x as JsonObjectExpr, y as JoinAst, z as WindowFuncExpr } from "./types-NTQsD2MS-DAP2yVDn.mjs";
 import { t as collectOrderedParamRefs } from "./util-BBgcP3gI-XJBkxo1K.mjs";
-import { n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection } from "./ast-DFvrXEbF.mjs";
+import { C as lockStrengthCapabilities, S as lockOptionCapabilities, T as missingCapability, n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection, w as lockWaitPolicyOf, x as lockIncompatible } from "./ast-B_UPqRyb.mjs";
 import { i as isExpression, o as toExpr } from "./expression-JOe6lo4g.mjs";
 import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-DoGFktu5.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
@@ -371,6 +371,14 @@ function assertDistinctOnCapability(contract, methodName) {
 		method: methodName
 	} });
 }
+function assertLockCapability(contract, requirement, methodName) {
+	const capability = missingCapability(contract.capabilities, requirement);
+	if (capability === void 0) return;
+	throw ormError("ORM.CAPABILITY_MISSING", `${methodName}() requires capability ${capability}`, { meta: {
+		capability,
+		method: methodName
+	} });
+}
 function hasContractCapability(contract, capability) {
 	const capabilities = contract.capabilities;
 	const value = capabilities[capability];
@@ -1039,6 +1047,7 @@ function emptyState() {
 		limit: void 0,
 		offset: void 0,
 		variantName: void 0,
+		locking: void 0,
 		annotations: /* @__PURE__ */ new Map()
 	};
 }
@@ -1464,6 +1473,29 @@ function compileDeleteCount(contract, namespaceId, tableName, filters, variantNa
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
+function includeCarriesLock(include) {
+	return [
+		include.nested,
+		...include.scalar === void 0 ? [] : [include.scalar.state],
+		...Object.values(include.combine ?? {}).map((branch) => branch.kind === "rows" ? branch.state : branch.selector.state)
+	].some(stateCarriesLock);
+}
+function stateCarriesLock(state) {
+	return state.locking !== void 0 || state.includes.some(includeCarriesLock);
+}
+function conflictOf(state, call) {
+	if (state.includes.some(includeCarriesLock)) return "includeRefinement";
+	if (state.locking === void 0) return void 0;
+	if (call !== void 0) return call;
+	if (state.includes.length > 0) return "include";
+	if (state.distinct !== void 0 && state.distinct.length > 0) return "distinct";
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) return "distinctOn";
+}
+/** Refuses a row lock the ORM cannot render: inside an include, with include, distinct or distinctOn in the state, or before a call that drops it. */
+function assertLockCompatible(state, call) {
+	const conflict = conflictOf(state, call);
+	if (conflict !== void 0) throw lockIncompatible(conflict, `A locking clause cannot be combined with ${conflict}`);
+}
 function augmentSelectionForJoinColumns(selectedFields, requiredColumns) {
 	if (!selectedFields) return {
 		selectedForQuery: selectedFields,
@@ -2047,9 +2079,11 @@ function buildSelectAst(contract, tableName, state, options) {
 	if (state.limit !== void 0) ast = ast.withLimit(state.limit);
 	if (state.offset !== void 0) ast = ast.withOffset(state.offset);
 	if (options.joins && options.joins.length > 0) ast = ast.withJoins(options.joins);
+	if (state.locking !== void 0) ast = ast.withLocking(state.locking);
 	return ast;
 }
 function compileSelect(contract, namespaceId, tableName, state, modelName) {
+	assertLockCompatible(state);
 	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
 	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
 	const selection = polyInfo && modelName ? resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state) : void 0;
@@ -2071,6 +2105,7 @@ function compileSelect(contract, namespaceId, tableName, state, modelName) {
 	return buildOrmQueryPlan(contract, ast, params, state.annotations);
 }
 function compileSelectWithIncludes(contract, aggregates, namespaceId, tableName, state, modelName) {
+	assertLockCompatible(state);
 	const includeJoins = [];
 	const includeProjection = [];
 	const topLevelWhere = buildStateWhere(contract, tableName, state, { namespaceId });
@@ -3914,7 +3949,7 @@ function isModelCollection(value) {
 function assertScopeReceiver(value) {
 	if (!isModelCollection(value)) throw ormError("ORM.ARGUMENT_INVALID", "Cannot apply the scope: it was not given a collection", {
 		why: `A scope is applied to a collection, such as db.orm.public.Post; received ${describeReceived(value)}.`,
-		fix: "Run the scope with apply on a collection: collection.apply(scope).",
+		fix: "Pass the scope to with on a collection: collection.with(scope).",
 		meta: { argument: "collection" }
 	});
 }
@@ -4183,7 +4218,7 @@ function listed(items, conjunction) {
 	const last = items.at(-1) ?? "";
 	return items.length > 1 ? `${items.slice(0, -1).join(", ")} ${conjunction} ${last}` : last;
 }
-const HIDDEN_BY_A_SCOPE = "A scope applied with apply can add one without showing it at the call site.";
+const HIDDEN_BY_A_SCOPE = "A scope passed to with can add one without showing it at the call site.";
 /** Throws `ORM.ARGUMENT_INVALID` when the collection has a limit, an offset, a cursor or a distinct selection, which `method`, a write of every matching row, would ignore. */
 function assertBulkWriteIgnoresNothing(state, modelName, method) {
 	const { nouns, calls } = presentParts(state, [
@@ -4354,7 +4389,7 @@ var CollectionBase = class CollectionBase {
 		if (!filter) return blindCast(this);
 		return this.#cloneSelf({ filters: [...this.state.filters, filter] });
 	}
-	apply(fn) {
+	with(fn) {
 		return fn(this);
 	}
 	/**
@@ -4362,7 +4397,7 @@ var CollectionBase = class CollectionBase {
 	*
 	* ```ts
 	* const summary = db.Post.scope((posts) => posts.select('id', 'title').include('user'));
-	* db.User.include('posts', (posts) => posts.apply(summary));
+	* db.User.include('posts', (posts) => posts.with(summary));
 	* ```
 	*/
 	scope(body) {
@@ -4475,6 +4510,7 @@ var CollectionBase = class CollectionBase {
 	* ```
 	*/
 	groupBy(...fields) {
+		assertLockCompatible(this.state, "groupBy");
 		const groupByColumns = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
 		return new GroupedCollection(this.ctx, this.modelName, {
 			tableName: this.tableName,
@@ -4551,6 +4587,42 @@ var CollectionBase = class CollectionBase {
 			distinctOn: distinctOnFields
 		});
 	}
+	/**
+	* Lock the selected rows of this model with `FOR UPDATE` until the transaction ends.
+	*
+	* Requires the `sql.forUpdate` and `sql.lockOf` capabilities, because the lock always names the model's table with `OF`.
+	*
+	* ```typescript
+	* const job = await tx.orm.Job.where({ state: 'queued' }).limit(1).forUpdate({ skipLocked: true }).first();
+	* ```
+	*/
+	forUpdate(...options) {
+		return this.#lock("forUpdate", options[0]);
+	}
+	/**
+	* Lock the selected rows of this model with `FOR NO KEY UPDATE` until the transaction ends. Unlike `forUpdate`, it does not block foreign-key checks from rows that reference them.
+	*
+	* Requires the `postgres.forNoKeyUpdate` and `sql.lockOf` capabilities, because the lock always names the model's table with `OF`.
+	*/
+	forNoKeyUpdate(...options) {
+		return this.#lock("forNoKeyUpdate", options[0]);
+	}
+	/**
+	* Lock the selected rows of this model with `FOR SHARE` until the transaction ends; other transactions may share-lock them but not write them.
+	*
+	* Requires the `sql.forShare` and `sql.lockOf` capabilities, because the lock always names the model's table with `OF`.
+	*/
+	forShare(...options) {
+		return this.#lock("forShare", options[0]);
+	}
+	/**
+	* Lock the selected rows of this model with `FOR KEY SHARE` until the transaction ends; only deletes and key changes are blocked.
+	*
+	* Requires the `postgres.forKeyShare` and `sql.lockOf` capabilities, because the lock always names the model's table with `OF`.
+	*/
+	forKeyShare(...options) {
+		return this.#lock("forKeyShare", options[0]);
+	}
 	limit(n) {
 		return this.#cloneSelf({ limit: typeof n === "number" ? n : toExpr(n) });
 	}
@@ -4612,6 +4684,7 @@ var CollectionBase = class CollectionBase {
 		return description.consume(queryPlanRows(this.ctx.runtime, description.plan));
 	}
 	#describeAggregate(fn, configure) {
+		assertLockCompatible(this.state, "aggregate");
 		const aggregateSpec = fn(createAggregateBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName));
 		const entries = Object.entries(aggregateSpec);
 		if (entries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "aggregate() requires at least one aggregation selector", { meta: {
@@ -4651,6 +4724,7 @@ var CollectionBase = class CollectionBase {
 		};
 	}
 	async create(data, configure) {
+		assertLockCompatible(this.state, "mutation");
 		assertReturningCapability(this.contract, "create()");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "create");
 		if (hasNestedMutationCallbacks(this.contract, this.namespaceId, this.modelName, blindCast(data))) {
@@ -4677,6 +4751,7 @@ var CollectionBase = class CollectionBase {
 		} });
 	}
 	createAll(data, optionsOrConfigure, configure) {
+		assertLockCompatible(this.state, "mutation");
 		const { options, configureCallback } = splitCreateArguments(optionsOrConfigure, configure);
 		const conflictSkip = this.#resolveConflictSkip(options, "createAll()");
 		return this.#createAllWithAnnotations(data, this.#collectAnnotationsFromMeta(configureCallback, "write", "createAll"), conflictSkip);
@@ -4878,6 +4953,7 @@ var CollectionBase = class CollectionBase {
 	* Not supported on MTI variants — use `createAll(...)` instead.
 	*/
 	async createAndCount(data, optionsOrConfigure, configure) {
+		assertLockCompatible(this.state, "mutation");
 		const { options, configureCallback } = splitCreateArguments(optionsOrConfigure, configure);
 		const conflictSkip = this.#resolveConflictSkip(options, "createAndCount()");
 		if (data.length === 0) return 0;
@@ -4899,6 +4975,7 @@ var CollectionBase = class CollectionBase {
 		return (await this.ctx.runtime.execute(compiled)).affectedRows;
 	}
 	async upsert(input, configure) {
+		assertLockCompatible(this.state, "mutation");
 		assertReturningCapability(this.contract, "upsert()");
 		this.#assertNotMtiVariant("upsert()");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "upsert");
@@ -4941,6 +5018,7 @@ var CollectionBase = class CollectionBase {
 		} });
 	}
 	async update(data, configure) {
+		assertLockCompatible(this.state, "mutation");
 		assertReturningCapability(this.contract, "update()");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "update");
 		if (hasNestedMutationCallbacks(this.contract, this.namespaceId, this.modelName, blindCast(data))) {
@@ -4966,6 +5044,7 @@ var CollectionBase = class CollectionBase {
 	}
 	updateAll(data, configure) {
 		assertBulkWriteIgnoresNothing(this.state, this.modelName, "updateAll");
+		assertLockCompatible(this.state, "mutation");
 		return this.#updateAllWithAnnotations(data, this.#collectAnnotationsFromMeta(configure, "write", "updateAll"));
 	}
 	#updateAllWithAnnotations(data, annotationsMap) {
@@ -4994,6 +5073,7 @@ var CollectionBase = class CollectionBase {
 	}
 	async updateAndCount(data, configure) {
 		assertBulkWriteIgnoresNothing(this.state, this.modelName, "updateAndCount");
+		assertLockCompatible(this.state, "mutation");
 		const mappedData = mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, data);
 		if (Object.keys(mappedData).length === 0) return 0;
 		applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, mappedData);
@@ -5002,6 +5082,7 @@ var CollectionBase = class CollectionBase {
 		return (await this.ctx.runtime.execute(compiled)).affectedRows;
 	}
 	async delete(configure) {
+		assertLockCompatible(this.state, "mutation");
 		assertReturningCapability(this.contract, "delete()");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "delete");
 		return withMutationScope(this.ctx.runtime, async (scope) => {
@@ -5017,6 +5098,7 @@ var CollectionBase = class CollectionBase {
 	}
 	deleteAll(configure) {
 		assertBulkWriteIgnoresNothing(this.state, this.modelName, "deleteAll");
+		assertLockCompatible(this.state, "mutation");
 		return this.#deleteAllWithAnnotations(this.#collectAnnotationsFromMeta(configure, "write", "deleteAll"));
 	}
 	#deleteAllWithAnnotations(annotationsMap) {
@@ -5076,6 +5158,7 @@ var CollectionBase = class CollectionBase {
 	}
 	async deleteAndCount(configure) {
 		assertBulkWriteIgnoresNothing(this.state, this.modelName, "deleteAndCount");
+		assertLockCompatible(this.state, "mutation");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "deleteAndCount");
 		const compiled = mergeAnnotations(compileDeleteCount(this.contract, this.namespaceId, this.tableName, this.state.filters, this.state.variantName, this.modelName), annotationsMap);
 		return (await this.ctx.runtime.execute(compiled)).affectedRows;
@@ -5170,6 +5253,18 @@ var CollectionBase = class CollectionBase {
 		if (this.includeRefinementMode) return;
 		throw ormError("ORM.INCLUDE_INVALID", `${action} is only available inside include() refinement callbacks`, { meta: { action } });
 	}
+	#lock(strength, options) {
+		if (this.includeRefinementMode) throw lockIncompatible("includeRefinement", `${strength}() cannot be called inside an include() refinement callback`);
+		assertLockCapability(this.contract, lockStrengthCapabilities[strength], strength);
+		assertLockCapability(this.contract, lockOptionCapabilities.of, strength);
+		const waitPolicy = lockWaitPolicyOf(strength, options);
+		if (waitPolicy !== void 0) assertLockCapability(this.contract, lockOptionCapabilities[waitPolicy], strength);
+		const clause = LockingClause.of(strength, {
+			of: [this.tableName],
+			...ifDefined("waitPolicy", waitPolicy)
+		});
+		return this.#clone({ locking: [...this.state.locking ?? [], clause] });
+	}
 	#clone(overrides) {
 		return this.#createSelf({
 			...this.state,