@prisma/orm-family-sql 8.0.0-rc.14-dev.30 → 8.0.0-rc.14-dev.32

package/dist/orm-client.mjs

@@ -3896,7 +3896,7 @@ function splitCreateArguments(optionsOrConfigure, configure) {
 function isMtiVariantInfo(variant) {
 	return variant?.strategy === "mti";
 }
-var CollectionImpl = class CollectionImpl {
+var CollectionBase = class CollectionBase {
 	/** @internal */
 	ctx;
 	/** @internal */
@@ -3932,7 +3932,7 @@ var CollectionImpl = class CollectionImpl {
 	* because their names are the registry's, not the class declaration's.
 	*
 	* A name the collection already carries is skipped, and which member holds
-	* it decides what the skip means. A `CollectionImpl` member is rejected at
+	* it decides what the skip means. A `CollectionBase` member is rejected at
 	* ORM composition with `ORM.AGGREGATE_OPERATION_RESERVED`, since
 	* {@link reservedCollectionMemberNames} scans this class. A member declared
 	* by a custom collection class registered through `orm({ collections })`
@@ -3972,27 +3972,14 @@ var CollectionImpl = class CollectionImpl {
 			namespaceId: this.namespaceId
 		});
 		if (!filter) return blindCast(this);
-		return this.#clone({ filters: [...this.state.filters, filter] });
+		return this.#cloneSelf({ filters: [...this.state.filters, filter] });
 	}
 	/**
-	* Narrow a polymorphic model to a specific variant. The returned
-	* collection has the variant's row shape and a discriminator filter
-	* is automatically applied. Chaining `.variant(...)` again replaces
-	* the previous variant filter.
-	*
-	* ```typescript
-	* // Read only admin users (STI):
-	* const admins = await db.orm.User.variant('Admin').all();
-	*
-	* // Iterate the rows:
-	* for await (const admin of db.orm.User.variant('Admin').all()) {
-	*   console.log(admin.role);
-	* }
-	*
-	* // Insert under a variant — discriminator is injected automatically:
-	* await db.orm.User.variant('Admin').create({ name: 'Ada', role: 'super' });
-	* ```
+	* Call `fn` with this collection and return its result.
 	*/
+	apply(fn) {
+		return fn(this);
+	}
 	variant(variantName) {
 		const model = modelOf(this.contract, this.namespaceId, this.modelName);
 		const discriminator = model?.discriminator;
@@ -4052,46 +4039,15 @@ var CollectionImpl = class CollectionImpl {
 		};
 		return this.#cloneWithRow({ includes: [...this.state.includes, includeExpr] });
 	}
-	/**
-	* Project the row down to a subset of scalar fields. Previously
-	* included relations are preserved on the resulting row shape; only
-	* scalar columns are narrowed.
-	*
-	* ```typescript
-	* const summaries = await db.orm.User.select('id', 'email').all();
-	* // typeof summaries[number] === { id: ...; email: ... }
-	*
-	* for await (const row of db.orm.User.select('id', 'email').all()) {
-	*   console.log(row.id, row.email);
-	* }
-	* ```
-	*/
 	select(...fields) {
 		const selectedFields = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
 		return this.#cloneWithRow({ selectedFields });
 	}
-	/**
-	* Append an `ORDER BY` clause. Pass a single selector callback or an
-	* array of callbacks; each receives a typed model accessor whose
-	* columns expose `.asc()` and `.desc()`. Multiple calls append to the
-	* existing list (left-to-right ordering preserved).
-	*
-	* Calling `orderBy(...)` unlocks `cursor(...)` and `distinctOn(...)`,
-	* which both require a defined sort order.
-	*
-	* ```typescript
-	* const newest = await db.orm.User.orderBy((u) => u.createdAt.desc()).all();
-	*
-	* const byName = await db.orm.User
-	*   .orderBy([(u) => u.lastName.asc(), (u) => u.firstName.asc()])
-	*   .all();
-	* ```
-	*/
 	orderBy(selection) {
 		const accessor = createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, this.state.variantName);
 		const nextOrders = (Array.isArray(selection) ? selection : [selection]).map((selector) => selector(accessor));
 		const existing = this.state.orderBy ?? [];
-		return this.#clone({ orderBy: [...existing, ...nextOrders] });
+		return this.#cloneSelf({ orderBy: [...existing, ...nextOrders] });
 	}
 	/**
 	* Switch to grouped-aggregate mode. Returns a `GroupedCollection`
@@ -4161,136 +4117,39 @@ var CollectionImpl = class CollectionImpl {
 		}
 		return createIncludeCombine(branches);
 	}
-	/**
-	* Resume pagination from a known cursor position. Requires a prior
-	* `orderBy(...)` so the cursor has a stable basis; provide a value
-	* for every column referenced by the active `orderBy(...)` so each
-	* ordered axis has a defined boundary.
-	*
-	* ```typescript
-	* const page1 = await db.orm.Post
-	*   .orderBy((p) => p.createdAt.desc())
-	*   .limit(20)
-	*   .all();
-	*
-	* const last = page1[page1.length - 1]!;
-	* const page2 = await db.orm.Post
-	*   .orderBy((p) => p.createdAt.desc())
-	*   .cursor({ createdAt: last.createdAt })
-	*   .limit(20)
-	*   .all();
-	* ```
-	*/
 	cursor(cursorValues) {
 		assertCursorCompatibleOrder(this.state.orderBy);
 		const mappedCursor = mapCursorValuesToColumns(this.contract, this.namespaceId, this.modelName, cursorValues);
-		if (Object.keys(mappedCursor).length === 0) return blindCast(this);
-		return this.#clone({ cursor: mappedCursor });
+		if (Object.keys(mappedCursor).length === 0) return this;
+		return this.#cloneSelf({ cursor: mappedCursor });
 	}
-	/**
-	* Emit `SELECT DISTINCT` keyed on the given fields. Replaces any
-	* previous `distinct(...)` / `distinctOn(...)` selection.
-	*
-	* ```typescript
-	* const groups = await db.orm.User.distinct('country', 'role').all();
-	* ```
-	*/
 	distinct(...fields) {
 		const distinctFields = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
-		return this.#clone({
+		return this.#cloneSelf({
 			distinct: distinctFields,
 			distinctOn: void 0
 		});
 	}
-	/**
-	* Emit `SELECT DISTINCT ON (fields)` — keep the first row per
-	* distinct key according to the current `orderBy(...)`. Requires a
-	* prior `orderBy(...)`; replaces any previous `distinct(...)` /
-	* `distinctOn(...)` selection.
-	*
-	* Requires the `postgres.distinctOn` capability.
-	*
-	* ```typescript
-	* // Latest post per user:
-	* const latestPerUser = await db.orm.Post
-	*   .orderBy([(p) => p.userId.asc(), (p) => p.createdAt.desc()])
-	*   .distinctOn('userId')
-	*   .all();
-	* ```
-	*/
 	distinctOn(...fields) {
 		assertDistinctOnCapability(this.contract, "distinctOn");
 		assertDistinctOnCompatibleOrder(this.state.orderBy, fields.length);
 		const distinctOnFields = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
-		return this.#clone({
+		return this.#cloneSelf({
 			distinct: void 0,
 			distinctOn: distinctOnFields
 		});
 	}
-	/**
-	* Apply `LIMIT n`. Replaces any previous limit set on this collection.
-	*
-	* ```typescript
-	* const firstTen = await db.orm.User.orderBy((u) => u.id.asc()).limit(10).all();
-	* ```
-	*/
 	limit(n) {
-		return this.#clone({ limit: typeof n === "number" ? n : toExpr(n) });
+		return this.#cloneSelf({ limit: typeof n === "number" ? n : toExpr(n) });
 	}
-	/**
-	* Apply `OFFSET n`. Replaces any previous offset set on this collection.
-	*
-	* ```typescript
-	* const page2 = await db.orm.User
-	*   .orderBy((u) => u.id.asc())
-	*   .offset(10)
-	*   .limit(10)
-	*   .all();
-	* ```
-	*/
 	offset(n) {
-		return this.#clone({ offset: typeof n === "number" ? n : toExpr(n) });
+		return this.#cloneSelf({ offset: typeof n === "number" ? n : toExpr(n) });
 	}
-	/**
-	* Read terminal: execute the query and stream every matching row.
-	*
-	* The returned `AsyncIterableResult<Row>` is BOTH a thenable that
-	* resolves to `Row[]` (so `await` collects all rows into an array)
-	* AND an async iterable (so `for await` streams rows as they
-	* arrive, without buffering the whole result set in memory). Pick
-	* whichever fits the caller. A single result can only be consumed
-	* once.
-	*
-	* Queries without `include(...)` stream rows as the driver yields them (drivers that cannot
-	* expose a cursor buffer internally first). Queries with `include(...)` read the whole parent
-	* result set into memory before yielding the first row.
-	*
-	* ```typescript
-	* // Thenable — collect to an array:
-	* const users = await db.orm.User.all();
-	* for (const user of users) console.log(user.id);
-	*
-	* // Async iterable — stream rows as they arrive:
-	* for await (const user of db.orm.User.all()) {
-	*   console.log(user.id);
-	* }
-	* ```
-	*
-	* Accepts an optional `configure` callback that receives a
-	* `MetaBuilder<'read'>` so the caller can attach typed user
-	* annotations to the executed plan. `meta.annotate(...)` enforces
-	* applicability at the type level and at runtime; annotations are
-	* merged into `plan.meta.annotations` at compile time.
-	*
-	* ```typescript
-	* await db.orm.User.all((meta) => meta.annotate(cacheAnnotation({ key: 'users' })));
-	* ```
-	*/
 	all(configure) {
 		return this.#withAnnotationsFromMeta(configure, "all").#dispatch();
 	}
 	get prepared() {
-		return {
+		return blindCast({
 			aggregate: (fn, configure) => this.#describeAggregate(fn, configure),
 			all: (configure) => {
 				return describeCollectionRows(this.#withAnnotationsFromMeta(configure, "all").#descriptionOptions());
@@ -4298,7 +4157,7 @@ var CollectionImpl = class CollectionImpl {
 			first: (filter, configure) => {
 				return describeCollectionFirst(this.#forFirst(filter, configure).#descriptionOptions());
 			}
-		};
+		});
 	}
 	#descriptionOptions() {
 		return {
@@ -4405,41 +4264,6 @@ var CollectionImpl = class CollectionImpl {
 			model: this.modelName
 		} });
 	}
-	/**
-	* Write terminal: insert many rows and stream the inserted rows.
-	*
-	* The returned `AsyncIterableResult<Row>` is BOTH a thenable that
-	* resolves to `Row[]` AND an async iterable that streams inserted
-	* rows as they arrive. Use whichever shape fits the caller — but
-	* only consume it once. Streaming is the default; some
-	* driver/plan combinations may still buffer internally before
-	* yielding.
-	*
-	* ```typescript
-	* // Thenable — collect all inserted rows into an array:
-	* const created = await db.orm.User.createAll([
-	*   { email: 'a@example.com' },
-	*   { email: 'b@example.com' },
-	* ]);
-	*
-	* // Async iterable — stream inserted rows as they arrive:
-	* 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. It may be passed in second position when
-	* there are no options.
-	*/
 	createAll(data, optionsOrConfigure, configure) {
 		const { options, configureCallback } = splitCreateArguments(optionsOrConfigure, configure);
 		const conflictSkip = this.#resolveConflictSkip(options, "createAll()");
@@ -4662,38 +4486,6 @@ var CollectionImpl = class CollectionImpl {
 		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
-	* conflict. Returns the resulting row (the inserted one or the
-	* updated/existing one).
-	*
-	* `conflictOn` selects which unique constraint drives the conflict
-	* resolution — omit to use the model's primary key.
-	*
-	* ```typescript
-	* // Insert-or-update on email uniqueness:
-	* await db.orm.User.upsert({
-	*   create: { email: 'alice@example.com', name: 'Alice' },
-	*   update: { name: 'Alice (updated)' },
-	*   conflictOn: { email: 'alice@example.com' },
-	* });
-	*
-	* // Conditional create — `update: {}` keeps the existing row
-	* // unchanged. `conflictOn` must reference the constraint that
-	* // makes the row "already exist"; omit only when the conflict is
-	* // on the primary key. On conflict,
-	* // `ON CONFLICT DO NOTHING RETURNING ...` may return zero rows,
-	* // so a follow-up reload is issued to fetch and return the
-	* // existing row.
-	* await db.orm.User.upsert({
-	*   create: { email: 'alice@example.com', name: 'Alice' },
-	*   update: {},
-	*   conflictOn: { email: 'alice@example.com' },
-	* });
-	* ```
-	*
-	* Not supported on MTI variants.
-	*/
 	async upsert(input, configure) {
 		assertReturningCapability(this.contract, "upsert()");
 		this.#assertNotMtiVariant("upsert()");
@@ -4736,44 +4528,6 @@ var CollectionImpl = class CollectionImpl {
 			model: this.modelName
 		} });
 	}
-	/**
-	* Write terminal: update a single matching row — the first one the
-	* filter matches — and return it (or `null` when no row matched).
-	* Requires a prior `.where(...)` — calling `update(...)` on an
-	* unfiltered collection is a type error.
-	*
-	* Related rows can be created, linked, or unlinked through relation callbacks on any relation:
-	* to-one (1:1, N:1), to-many (1:N), and many-to-many (N:M, written through the junction table).
-	* The callback receives a mutator exposing `create(...)`, `connect(...)`, and `disconnect(...)`.
-	* A to-one `disconnect()` clears the foreign key; a to-many `disconnect()` with no criteria
-	* unlinks every related row; an N:M `disconnect()` requires criteria. N:M `create`/`connect` are
-	* unavailable when the junction has required columns the relation API cannot populate. Nested
-	* updates against existing related rows are not supported through this API.
-	*
-	* ```typescript
-	* // Update one row by id:
-	* const updated = await db.orm.User
-	*   .where({ id: 1 })
-	*   .update({ name: 'Alice Renamed' });
-	*
-	* // Update + relink — runs as a graph of internal mutations:
-	* await db.orm.User
-	*   .where({ id: 1 })
-	*   .update({
-	*     name: 'Alice',
-	*     posts: (posts) => posts.connect([{ id: 5 }]),
-	*   });
-	* ```
-	*
-	* Accepts an optional `configure` callback that receives a
-	* `MetaBuilder<'write'>` for attaching typed annotations.
-	*
-	* Note: when the input contains nested-mutation callbacks, the
-	* operation is executed as a graph of internal queries via
-	* `withMutationScope`. In that path the `configure` callback still runs, so `meta.annotate`
-	* validation applies, but the recorded annotations are discarded: neither the nested
-	* statements nor the read-back query carry them.
-	*/
 	async update(data, configure) {
 		assertReturningCapability(this.contract, "update()");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "update");
@@ -4797,31 +4551,6 @@ var CollectionImpl = class CollectionImpl {
 			return (await scoped.#clone({ filters: [identityWhere] }).#updateAllWithAnnotations(blindCast(data), annotationsMap))[0] ?? null;
 		});
 	}
-	/**
-	* Write terminal: update every matching row and stream the updated
-	* rows. Requires a prior `.where(...)` filter.
-	*
-	* The returned `AsyncIterableResult<Row>` is BOTH a thenable that
-	* resolves to `Row[]` AND an async iterable that streams updated
-	* rows as they arrive. Use whichever fits; a result can only be
-	* consumed once. Streaming is the default; some driver/plan
-	* combinations may still buffer internally before yielding.
-	*
-	* ```typescript
-	* // Thenable — collect updated rows into an array:
-	* const updated = await db.orm.Post
-	*   .where({ published: false })
-	*   .updateAll({ published: true });
-	*
-	* // Async iterable — stream updated rows as they arrive:
-	* for await (const row of db.orm.Post.where({ draft: true }).updateAll({ draft: false })) {
-	*   console.log('published', row.id);
-	* }
-	* ```
-	*
-	* Accepts an optional `configure` callback that receives a
-	* `MetaBuilder<'write'>` for attaching typed annotations.
-	*/
 	updateAll(data, configure) {
 		return this.#updateAllWithAnnotations(data, this.#collectAnnotationsFromMeta(configure, "write", "updateAll"));
 	}
@@ -4849,20 +4578,6 @@ var CollectionImpl = class CollectionImpl {
 			mapRow: (mapped) => blindCast(mapped)
 		});
 	}
-	/**
-	* Write terminal: update every matching row without returning them,
-	* resolving to the count of rows that were updated. Requires a prior
-	* `.where(...)` filter.
-	*
-	* Prefer `updateAll(...)` when you need the updated rows; prefer
-	* this when you only need the affected-row count.
-	*
-	* ```typescript
-	* const count = await db.orm.Post
-	*   .where({ published: false })
-	*   .updateAndCount({ published: true });
-	* ```
-	*/
 	async updateAndCount(data, configure) {
 		const mappedData = mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, data);
 		if (Object.keys(mappedData).length === 0) return 0;
@@ -4871,20 +4586,6 @@ var CollectionImpl = class CollectionImpl {
 		const compiled = mergeAnnotations(compileUpdateCount(this.contract, this.namespaceId, this.tableName, mappedData, this.state.filters, this.state.variantName, this.modelName), annotationsMap);
 		return (await this.ctx.runtime.execute(compiled)).affectedRows;
 	}
-	/**
-	* Write terminal: delete a single matching row — the first one the
-	* filter matches — and return it (or `null` when no row matched).
-	* Requires a prior `.where(...)` — calling `delete()` on an
-	* unfiltered collection is a type error.
-	*
-	* ```typescript
-	* const deleted = await db.orm.User.where({ id: 1 }).delete();
-	* if (deleted) console.log('deleted', deleted.email);
-	* ```
-	*
-	* Accepts an optional `configure` callback that receives a
-	* `MetaBuilder<'write'>` for attaching typed annotations.
-	*/
 	async delete(configure) {
 		assertReturningCapability(this.contract, "delete()");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "delete");
@@ -4895,31 +4596,8 @@ var CollectionImpl = class CollectionImpl {
 			return (await scoped.#clone({ filters: [identityWhere] }).#executeDeleteReturning(annotationsMap).toArray())[0] ?? null;
 		});
 	}
-	/**
-	* Write terminal: delete every matching row and stream the deleted
-	* rows. Requires a prior `.where(...)` filter.
-	*
-	* The returned `AsyncIterableResult<Row>` is BOTH a thenable that
-	* resolves to `Row[]` AND an async iterable that streams deleted
-	* rows as they arrive. Use whichever fits; a result can only be
-	* consumed once. Streaming is the default; some driver/plan
-	* combinations may still buffer internally before yielding.
-	*
-	* ```typescript
-	* // Thenable — collect the deleted rows into an array:
-	* const deleted = await db.orm.Post.where({ archived: true }).deleteAll();
-	*
-	* // Async iterable — stream deleted rows as they arrive:
-	* for await (const row of db.orm.Post.where({ archived: true }).deleteAll()) {
-	*   console.log('removed', row.id);
-	* }
-	* ```
-	*
-	* Accepts an optional `configure` callback that receives a
-	* `MetaBuilder<'write'>` for attaching typed annotations.
-	*/
 	deleteAll(configure) {
-		return blindCast(this).#deleteAllWithAnnotations(this.#collectAnnotationsFromMeta(configure, "write", "deleteAll"));
+		return this.#deleteAllWithAnnotations(this.#collectAnnotationsFromMeta(configure, "write", "deleteAll"));
 	}
 	#deleteAllWithAnnotations(annotationsMap) {
 		assertReturningCapability(this.contract, "deleteAll()");
@@ -4976,18 +4654,6 @@ var CollectionImpl = class CollectionImpl {
 		};
 		return new AsyncIterableResult(generator());
 	}
-	/**
-	* Write terminal: delete every matching row without returning them,
-	* resolving to the count of rows that were deleted. Requires a prior
-	* `.where(...)` filter.
-	*
-	* Prefer `deleteAll(...)` when you need the deleted rows; prefer
-	* this when you only need the affected-row count.
-	*
-	* ```typescript
-	* const removed = await db.orm.Post.where({ archived: true }).deleteAndCount();
-	* ```
-	*/
 	async deleteAndCount(configure) {
 		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);
@@ -5087,6 +4753,12 @@ var CollectionImpl = class CollectionImpl {
 			...overrides
 		});
 	}
+	#cloneSelf(overrides) {
+		return blindCast(this.#createSelf({
+			...this.state,
+			...overrides
+		}));
+	}
 	#withRuntime(runtime) {
 		return blindCast(new (blindCast(this.constructor))({
 			...this.ctx,
@@ -5115,7 +4787,7 @@ var CollectionImpl = class CollectionImpl {
 		}));
 	}
 	#createCollection(modelName, options) {
-		return blindCast(new ((this.registry.get(modelName)) ?? (blindCast(CollectionImpl)))(this.ctx, modelName, {
+		return blindCast(new ((this.registry.get(modelName)) ?? (blindCast(CollectionBase)))(this.ctx, modelName, {
 			tableName: options.tableName,
 			namespaceId: options.namespaceId,
 			state: options.state,
@@ -5190,17 +4862,9 @@ const collectionInstanceMemberNames = [
 * so ORM composition rejects any operation this set contains.
 */
 function reservedCollectionMemberNames() {
-	return /* @__PURE__ */ new Set([...Object.getOwnPropertyNames(CollectionImpl.prototype), ...collectionInstanceMemberNames]);
+	return /* @__PURE__ */ new Set([...Object.getOwnPropertyNames(CollectionBase.prototype), ...collectionInstanceMemberNames]);
 }
-const Collection = blindCast(CollectionImpl);
-/**
-* The class behind {@link Collection}, for package-internal prototype-chain
-* checks (`instanceof`) and default construction. The public constructor
-* surface carries a single construct signature returning the intersection,
-* which heritage clauses require; the raw class keeps the `Function` shape
-* those checks need.
-*/
-const CollectionBase = CollectionImpl;
+const Collection = blindCast(CollectionBase);
 /**
 * Reject a contributed aggregate operation whose name a collection member
 * already owns. Aggregate operations surface as reducer methods on the