@prisma/orm-family-sql 8.0.0-rc.18-dev.4 → 8.0.0-rc.18-dev.5

package/dist/orm-client.mjs

@@ -6,7 +6,7 @@ import { C as lockStrengthCapabilities, S as lockOptionCapabilities, T as missin
 import { a as isExpression, s as toExpr, t as ExpressionImpl } from "./expression-impl-B-XNINxr-vYwKVFeP.mjs";
 import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-CYK0Wzja.mjs";
 import { t as createFunctions } from "./functions-0YWByawj.mjs";
-import { t as createIndexReferences } from "./index-reference-D693Lu-E.mjs";
+import { t as createIndexReferences } from "./index-reference-DR62gjQS.mjs";
 import { o as settlementOf } from "./transaction-state-BfXhs7D7-3k10jZ8I.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
@@ -2885,6 +2885,113 @@ function parseIncludePayload(value) {
 		return [];
 	}
 }
+const tablesByContext = /* @__PURE__ */ new WeakMap();
+const NO_METHODS = Object.freeze({});
+function modelKey(namespaceId, modelName) {
+	return JSON.stringify([namespaceId, modelName]);
+}
+function assertUniqueIds(contributions) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const { id } of contributions) {
+		if (seen.has(id)) throw ormError("ORM.ARGUMENT_INVALID", `Two collection method contributions have the id "${id}".`, {
+			why: "A contribution is registered under its id in CollectionMethodRegistry, so an id names one contribution.",
+			fix: "List each extension once, or give one of the two contributions another id.",
+			meta: { id }
+		});
+		seen.add(id);
+	}
+}
+function modelViews(context) {
+	const { contract } = context;
+	const views = [];
+	for (const [namespaceId, namespace] of Object.entries(contract.domain.namespaces)) for (const [name, model] of Object.entries(namespace.models)) {
+		const tableName = model.storage["table"];
+		const resolved = typeof tableName === "string" ? resolveTableForContract(contract, namespaceId, tableName) : void 0;
+		if (resolved === void 0) throw new InternalError(`Model "${name}" in namespace "${namespaceId}" has no storage table the contract declares.`);
+		views.push([modelKey(namespaceId, name), {
+			target: contract.target,
+			name,
+			fields: model.fields,
+			relations: model.relations,
+			table: resolved.table
+		}]);
+	}
+	return views;
+}
+function methodsOf(contribution, view) {
+	let methods;
+	try {
+		methods = contribution.methodsFor(view);
+	} catch (cause) {
+		throw ormError("ORM.ARGUMENT_INVALID", `Collection method contribution "${contribution.id}" failed for model "${view.name}".`, {
+			why: "The ORM client asks every contribution for every model's methods when it is created.",
+			fix: `Fix or remove the extension that contributes "${contribution.id}"; the cause is the contribution's own error.`,
+			meta: {
+				model: view.name,
+				contribution: contribution.id
+			},
+			cause
+		});
+	}
+	if (typeof methods !== "object" || methods === null) throw ormError("ORM.ARGUMENT_INVALID", `Collection method contribution "${contribution.id}" returned no object of methods for model "${view.name}".`, {
+		why: "A contribution returns an object holding a model's methods by name, empty when it gives the model none.",
+		fix: `Fix or remove the extension that contributes "${contribution.id}".`,
+		meta: {
+			model: view.name,
+			contribution: contribution.id
+		}
+	});
+	for (const [name, body] of Object.entries(methods)) if (typeof body !== "function") throw ormError("ORM.ARGUMENT_INVALID", `Collection method "${name}" that contribution "${contribution.id}" gives model "${view.name}" is not a function.`, {
+		why: "A contribution returns each of a model's methods as a function of the collection and the caller's arguments.",
+		fix: `Fix or remove the extension that contributes "${contribution.id}".`,
+		meta: {
+			model: view.name,
+			method: name,
+			contribution: contribution.id
+		}
+	});
+	return blindCast(methods);
+}
+function mergedTable(view, contributions) {
+	const methods = Object.create(null);
+	const owners = /* @__PURE__ */ new Map();
+	for (const contribution of contributions) for (const [name, body] of Object.entries(methodsOf(contribution, view))) {
+		const owner = owners.get(name);
+		if (owner !== void 0) throw ormError("ORM.ARGUMENT_INVALID", `Collection method "${name}" of model "${view.name}" is contributed by both "${owner}" and "${contribution.id}".`, {
+			why: "A collection offers one method under each name in `using`.",
+			fix: "Remove one of the extensions that contribute these methods.",
+			meta: {
+				model: view.name,
+				method: name,
+				contributions: [owner, contribution.id]
+			}
+		});
+		owners.set(name, contribution.id);
+		methods[name] = body;
+	}
+	return Object.freeze(methods);
+}
+/**
+* Asks each contribution for each model's methods, once per execution context. Throws `ORM.ARGUMENT_INVALID` when two contributions share an id, give one model two methods with the same name, fail, or return a method that is not a function.
+*/
+function collectionMethodTables(context) {
+	const cached = tablesByContext.get(context);
+	if (cached !== void 0) return cached;
+	const contributions = context.collectionMethods ?? [];
+	assertUniqueIds(contributions);
+	const tables = /* @__PURE__ */ new Map();
+	for (const [key, view] of modelViews(context)) tables.set(key, mergedTable(view, contributions));
+	tablesByContext.set(context, tables);
+	return tables;
+}
+/** The contributed methods of a model, by name. */
+function collectionMethodTable(context, namespaceId, modelName) {
+	return collectionMethodTables(context).get(modelKey(namespaceId, modelName)) ?? NO_METHODS;
+}
+/** The run-time value of `collection.using`. */
+function createCollectionMethods(receiver, table) {
+	return Object.freeze(Object.fromEntries(Object.entries(table).map(([name, body]) => [name, (...args) => body(receiver, ...args)])));
+}
 /** The filter expression of a condition: a condition from `fns` becomes its AST. */
 function conditionExpr(condition) {
 	return isFunctionCondition(condition) ? condition.buildAst() : condition;
@@ -3152,6 +3259,7 @@ function defineDeclaredFieldsFragment(declarations, body) {
 	});
 }
 const NO_INDEXES = Object.freeze({});
+const NO_COLLECTION_METHODS = Object.freeze({});
 const collectionsBehindViews = /* @__PURE__ */ new WeakMap();
 const BODY_CHAIN_METHODS = {
 	where: true,
@@ -3160,10 +3268,11 @@ const BODY_CHAIN_METHODS = {
 	offset: true
 };
 /**
-* The collection as the body of a fragment for any model sees it: a `where` or `orderBy` callback receives `fns` and an `indexes` with no members, as the body does not know its model.
+* The collection as the body of a fragment for any model sees it: a `where` or `orderBy` callback receives `fns` and an `indexes` with no members, and `using` has no members, as the body does not know its model.
 */
 function withoutIndexes(collection) {
 	const view = new Proxy(collection, { get(target, prop) {
+		if (prop === "using") return NO_COLLECTION_METHODS;
 		const member = Reflect.get(target, prop, target);
 		if (typeof member !== "function") return member;
 		if (!Object.hasOwn(BODY_CHAIN_METHODS, prop)) return member.bind(target);
@@ -5124,6 +5233,7 @@ var CollectionBase = class CollectionBase {
 	registry;
 	/** @internal */
 	includeRefinementMode;
+	#using;
 	constructor(ctx, modelName, options) {
 		this.ctx = ctx;
 		this.contract = ctx.context.contract;
@@ -5189,6 +5299,13 @@ var CollectionBase = class CollectionBase {
 			filters: [...this.state.filters, filter]
 		});
 	}
+	/**
+	* The collection methods packages contribute for this model. Each contribution reads the model and names its methods. Each method returns this collection with the method's filter and order added.
+	*/
+	get using() {
+		this.#using ??= createCollectionMethods(blindCast(this), collectionMethodTable(this.ctx.context, this.namespaceId, this.modelName));
+		return blindCast(this.#using);
+	}
 	whereUnique(criterion) {
 		if (this.includeRefinementMode) throw ormError("ORM.INCLUDE_INVALID", "whereUnique() is not available inside include() refinement callbacks", { meta: { action: "whereUnique()" } });
 		if (!hasCompleteUniqueKey(this.contract, this.namespaceId, this.modelName, criterion)) throw ormError("ORM.ARGUMENT_INVALID", `whereUnique() for model "${this.modelName}" needs a value for every field of the primary key or of one unique constraint`, { meta: {
@@ -5938,6 +6055,7 @@ function assertAggregateOperationsNotReserved(registry) {
 function orm(options) {
 	const { runtime, collections, context } = options;
 	assertAggregateOperationsNotReserved(context.aggregateDescriptors);
+	collectionMethodTables(context);
 	const contract = context.contract;
 	const ctx = {
 		runtime,