@prisma/orm-family-sql 8.0.0-rc.11-dev.36 → 8.0.0-rc.11-dev.38

package/dist/orm-client.mjs

@@ -1,9 +1,9 @@
 import { t as resolveStorageTable } from "./resolve-storage-table-DZsfnzeW.mjs";
 import { i as isUniqueConstraintViolation } from "./dist-x6jvtkKM.mjs";
-import { C as LiteralExpr, D as OrExpr, F as SubqueryExpr, I as TableSource, L as UpdateAst, O as OrderByItem, P as SelectAst, R as WindowFuncExpr, S as ListExpression, T as NullCheckExpr, U as isWhereExpr, V as isAggregateFn, _ as InsertAst, b as JsonArrayAggExpr, c as DeleteAst, f as EqColJoinOn, j as ProjectionItem, k as ParamRef, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, s as DefaultValueExpr, t as AggregateExpr, v as InsertOnConflict, w as NotExpr, x as JsonObjectExpr, y as JoinAst } from "./types-CWwta5EN-BS4OsQAL.mjs";
+import { C as LiteralExpr, D as OrExpr, F as SubqueryExpr, I as TableSource, L as UpdateAst, O as OrderByItem, P as SelectAst, R as WindowFuncExpr, S as ListExpression, T as NullCheckExpr, U as isWhereExpr, V as isAggregateFn, _ as InsertAst, b as JsonArrayAggExpr, c as DeleteAst, f as EqColJoinOn, j as ProjectionItem, k as ParamRef, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, s as DefaultValueExpr, t as AggregateExpr, v as InsertOnConflict, w as NotExpr, x as JsonObjectExpr, y as JoinAst } from "./types-ZNKYVjLr-DzjvSHKB.mjs";
 import { t as collectOrderedParamRefs } from "./util-DQQgv2j1-D6INZaRG.mjs";
-import { n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection } from "./ast-CS0lZ0OC.mjs";
-import { i as isExpression, o as toExpr } from "./expression-CiiHMYqY.mjs";
+import { n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection } from "./ast-C8jX7HNs.mjs";
+import { i as isExpression, o as toExpr } from "./expression-DqrE3myO.mjs";
 import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-ECZ4ohtG.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
@@ -343,6 +343,29 @@ function assertReturningCapability(contract, action) {
 		action
 	} });
 }
+function assertInsertConflictSkipCapability(contract, action, targeted) {
+	requireCapability(contract, action, "insertOnConflictSkip");
+	if (!targeted) requireCapability(contract, action, "insertOnConflictWithoutTarget");
+}
+function requireCapability(contract, action, capability) {
+	if (hasContractCapability(contract, capability)) return;
+	throw ormError("ORM.CAPABILITY_MISSING", `${action} requires contract capability "${capability}". Re-emit the contract against an adapter that reports it.`, { meta: {
+		capability,
+		action
+	} });
+}
+function resolveInsertConflictColumns(contract, namespaceId, modelName, conflictOn, action) {
+	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	return conflictOn.map((fieldName) => {
+		const column = fieldToColumn[fieldName];
+		if (column === void 0) throw ormError("ORM.ARGUMENT_INVALID", `${action} conflictOn field "${fieldName}" is not a scalar field of model "${modelName}"`, { meta: {
+			action,
+			model: modelName,
+			field: fieldName
+		} });
+		return column;
+	});
+}
 function assertDistinctOnCapability(contract, methodName) {
 	if (contract.capabilities["postgres"]?.["distinctOn"] === true) return;
 	throw ormError("ORM.CAPABILITY_MISSING", `${methodName}() requires capability postgres.distinctOn`, { meta: {
@@ -1243,15 +1266,20 @@ function normalizeInsertRows(contract, namespaceId, tableName, rows) {
 		return normalizedRow;
 	}) };
 }
-function compileInsertReturning(contract, namespaceId, tableName, rows, returningColumns) {
+function conflictSkipClause(tableName, conflictSkip) {
+	if (!conflictSkip) return void 0;
+	if (conflictSkip.columns.length === 0) return InsertOnConflict.doNothing();
+	return InsertOnConflict.on(conflictSkip.columns.map((column) => ColumnRef.of(tableName, column))).doNothing();
+}
+function compileInsertReturning(contract, namespaceId, tableName, rows, returningColumns, conflictSkip) {
 	const { rows: normalizedRows } = normalizeInsertRows(contract, namespaceId, tableName, rows);
-	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows).withReturning(buildReturningColumns(contract, namespaceId, tableName, returningColumns));
+	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows).withOnConflict(conflictSkipClause(tableName, conflictSkip)).withReturning(buildReturningColumns(contract, namespaceId, tableName, returningColumns));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileInsertCount(contract, namespaceId, tableName, rows) {
+function compileInsertCount(contract, namespaceId, tableName, rows, conflictSkip) {
 	const { rows: normalizedRows } = normalizeInsertRows(contract, namespaceId, tableName, rows);
-	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows);
+	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows).withOnConflict(conflictSkipClause(tableName, conflictSkip));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
@@ -1302,21 +1330,21 @@ function groupRowsByColumnSignature(rows) {
 	if (currentGroup.length > 0) groups.push(currentGroup);
 	return groups;
 }
-function compileInsertReturningSplit(contract, namespaceId, tableName, rows, returningColumns) {
+function compileInsertReturningSplit(contract, namespaceId, tableName, rows, returningColumns, conflictSkip) {
 	if (rows.length === 0) throw ormError("ORM.MUTATION_DATA_MISSING", "create() requires at least one row", { meta: {
 		method: "create",
 		namespaceId,
 		tableName
 	} });
-	return groupRowsByColumnSignature(rows).map((group) => compileInsertReturning(contract, namespaceId, tableName, group, returningColumns));
+	return groupRowsByColumnSignature(rows).map((group) => compileInsertReturning(contract, namespaceId, tableName, group, returningColumns, conflictSkip));
 }
-function compileInsertCountSplit(contract, namespaceId, tableName, rows) {
+function compileInsertCountSplit(contract, namespaceId, tableName, rows, conflictSkip) {
 	if (rows.length === 0) throw ormError("ORM.MUTATION_DATA_MISSING", "createAndCount() requires at least one row", { meta: {
 		method: "createAndCount",
 		namespaceId,
 		tableName
 	} });
-	return groupRowsByColumnSignature(rows).map((group) => compileInsertCount(contract, namespaceId, tableName, group));
+	return groupRowsByColumnSignature(rows).map((group) => compileInsertCount(contract, namespaceId, tableName, group, conflictSkip));
 }
 function compileUpsertReturning(contract, namespaceId, tableName, createValues, updateValues, conflictColumns, returningColumns) {
 	const createAssignments = toParamAssignments(contract, namespaceId, tableName, createValues);
@@ -3717,6 +3745,16 @@ function isToWhereExprInput(value) {
 function isWhereDirectInput(value) {
 	return isWhereExpr(value) && typeof value === "object" && value !== null && "accept" in value && typeof value.accept === "function" || isToWhereExprInput(value);
 }
+function splitCreateArguments(optionsOrConfigure, configure) {
+	if (typeof optionsOrConfigure === "function") return {
+		options: void 0,
+		configureCallback: optionsOrConfigure
+	};
+	return {
+		options: optionsOrConfigure,
+		configureCallback: configure
+	};
+}
 function isMtiVariantInfo(variant) {
 	return variant?.strategy === "mti";
 }
@@ -4248,16 +4286,26 @@ var CollectionImpl = class CollectionImpl {
 	* for await (const row of db.orm.User.createAll(seedUsers)) {
 	*   console.log('inserted', row.id);
 	* }
+	*
+	* // Let the database skip rows that collide with a unique
+	* // constraint; only the rows it inserted come back:
+	* const inserted = await db.orm.User.createAll(seedUsers, {
+	*   onConflict: 'skip',
+	*   conflictOn: ['email'],
+	* });
 	* ```
 	*
 	* Accepts an optional `configure` callback that receives a
 	* `MetaBuilder<'write'>` for attaching typed annotations to the
-	* compiled insert plan.
+	* compiled insert plan. It may be passed in second position when
+	* there are no options.
 	*/
-	createAll(data, configure) {
-		return this.#createAllWithAnnotations(data, this.#collectAnnotationsFromMeta(configure, "write", "createAll"));
+	createAll(data, optionsOrConfigure, configure) {
+		const { options, configureCallback } = splitCreateArguments(optionsOrConfigure, configure);
+		const conflictSkip = this.#resolveConflictSkip(options, "createAll()");
+		return this.#createAllWithAnnotations(data, this.#collectAnnotationsFromMeta(configureCallback, "write", "createAll"), conflictSkip);
 	}
-	#createAllWithAnnotations(data, annotationsMap) {
+	#createAllWithAnnotations(data, annotationsMap, conflictSkip) {
 		if (data.length === 0) {
 			const generator = async function* () {};
 			return new AsyncIterableResult(generator());
@@ -4270,7 +4318,7 @@ var CollectionImpl = class CollectionImpl {
 		applyCreateDefaults(this.ctx, this.namespaceId, this.tableName, mappedRows);
 		const { selectedForQuery: selectedForInsert, hiddenColumns } = this.#augmentMutationSelection();
 		if (this.contract.capabilities?.["sql"]?.["defaultInInsert"] !== true) {
-			const plans = compileInsertReturningSplit(this.contract, this.namespaceId, this.tableName, mappedRows, selectedForInsert).map((plan) => mergeAnnotations(plan, annotationsMap));
+			const plans = compileInsertReturningSplit(this.contract, this.namespaceId, this.tableName, mappedRows, selectedForInsert, conflictSkip).map((plan) => mergeAnnotations(plan, annotationsMap));
 			return dispatchSplitMutationRows({
 				context: this.ctx.context,
 				runtime: this.ctx.runtime,
@@ -4285,7 +4333,7 @@ var CollectionImpl = class CollectionImpl {
 				mapRow: (mapped) => blindCast(mapped)
 			});
 		}
-		const compiled = mergeAnnotations(compileInsertReturning(this.contract, this.namespaceId, this.tableName, mappedRows, selectedForInsert), annotationsMap);
+		const compiled = mergeAnnotations(compileInsertReturning(this.contract, this.namespaceId, this.tableName, mappedRows, selectedForInsert, conflictSkip), annotationsMap);
 		return dispatchMutationRows({
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
@@ -4300,6 +4348,17 @@ var CollectionImpl = class CollectionImpl {
 			mapRow: (mapped) => blindCast(mapped)
 		});
 	}
+	#resolveConflictSkip(options, method) {
+		if (options === void 0) return void 0;
+		if (options.onConflict !== "skip") throw ormError("ORM.ARGUMENT_INVALID", `${method} onConflict must be "skip"; received ${JSON.stringify(options.onConflict)}`, { meta: {
+			method,
+			model: this.modelName
+		} });
+		this.#assertNotMtiVariant(method);
+		const conflictOn = options.conflictOn ?? [];
+		assertInsertConflictSkipCapability(this.contract, method, conflictOn.length > 0);
+		return { columns: resolveInsertConflictColumns(this.contract, this.namespaceId, this.modelName, conflictOn, method) };
+	}
 	#assertNotMtiVariant(method) {
 		if (this.#resolveMtiCreateContext()) throw ormError("ORM.OPERATION_UNSUPPORTED", `${method} is not supported for MTI variant "${this.state.variantName}" on model "${this.modelName}". Use createAll() instead.`, { meta: {
 			method,
@@ -4412,7 +4471,8 @@ var CollectionImpl = class CollectionImpl {
 	}
 	/**
 	* Write terminal: insert many rows without materializing the
-	* inserted rows, returning the number of inserted records.
+	* inserted rows, returning the number of rows the database reports
+	* inserting.
 	*
 	* Prefer `createAll(...)` when you need the returned rows; prefer
 	* this when you only need to know how many rows were inserted (the
@@ -4424,25 +4484,36 @@ var CollectionImpl = class CollectionImpl {
 	*   { email: 'b@example.com' },
 	* ]);
 	* // inserted === 2
+	*
+	* // Let the database skip rows that collide with a unique
+	* // constraint; the count is how many it actually inserted:
+	* const added = await db.orm.User.createAndCount(seedUsers, {
+	*   onConflict: 'skip',
+	* });
 	* ```
 	*
 	* Not supported on MTI variants — use `createAll(...)` instead.
 	*/
-	async createAndCount(data, configure) {
+	async createAndCount(data, optionsOrConfigure, configure) {
+		const { options, configureCallback } = splitCreateArguments(optionsOrConfigure, configure);
+		const conflictSkip = this.#resolveConflictSkip(options, "createAndCount()");
 		if (data.length === 0) return 0;
 		this.#assertNotMtiVariant("createAndCount()");
-		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "createAndCount");
+		const annotationsMap = this.#collectAnnotationsFromMeta(configureCallback, "write", "createAndCount");
 		const rows = blindCast(data);
 		const mappedRows = this.#mapCreateRows(rows);
 		applyCreateDefaults(this.ctx, this.namespaceId, this.tableName, mappedRows);
 		if (this.contract.capabilities?.["sql"]?.["defaultInInsert"] !== true) {
-			const plans = compileInsertCountSplit(this.contract, this.namespaceId, this.tableName, mappedRows).map((plan) => mergeAnnotations(plan, annotationsMap));
-			for (const plan of plans) await this.ctx.runtime.execute(plan);
-			return data.length;
+			const plans = compileInsertCountSplit(this.contract, this.namespaceId, this.tableName, mappedRows, conflictSkip).map((plan) => mergeAnnotations(plan, annotationsMap));
+			let affectedRows = 0;
+			for (const plan of plans) {
+				const stats = await this.ctx.runtime.execute(plan);
+				affectedRows += stats.affectedRows;
+			}
+			return affectedRows;
 		}
-		const compiled = mergeAnnotations(compileInsertCount(this.contract, this.namespaceId, this.tableName, mappedRows), annotationsMap);
-		await this.ctx.runtime.execute(compiled);
-		return data.length;
+		const compiled = mergeAnnotations(compileInsertCount(this.contract, this.namespaceId, this.tableName, mappedRows, conflictSkip), annotationsMap);
+		return (await this.ctx.runtime.execute(compiled)).affectedRows;
 	}
 	/**
 	* Write terminal: insert a row, or update the existing row on