@prisma/orm-family-sql 0.17.0-dev.7 → 0.17.0-dev.9

package/dist/orm-client.mjs

@@ -2459,7 +2459,91 @@ function isCollectionState(value) {
 function hasThrough$1(relation) {
 	return relation.through !== void 0;
 }
+var SqlTableBinding = class SqlTableBinding {
+	#storage;
+	#reference;
+	constructor(storage, reference) {
+		this.#storage = Object.freeze({ ...storage });
+		this.#reference = reference;
+		Object.freeze(this);
+	}
+	static unaliased(storage) {
+		return new SqlTableBinding(storage, storage.tableName);
+	}
+	static aliased(storage, alias) {
+		return new SqlTableBinding(storage, alias);
+	}
+	column(columnName) {
+		return ColumnRef.of(this.#reference, columnName);
+	}
+	tableSource(contract) {
+		return tableSourceForContract(contract, this.#storage.namespaceId, this.#storage.tableName, this.#reference);
+	}
+	isReferencedAs(candidate) {
+		return this.#reference === candidate;
+	}
+	isStoredAt(namespaceId, tableName) {
+		return this.#storage.namespaceId === namespaceId && this.#storage.tableName === tableName;
+	}
+};
+var ModelAccessorScope = class ModelAccessorScope {
+	current;
+	#visibleBindings;
+	#aliasCounter;
+	constructor(current, visibleBindings, aliasCounter) {
+		this.current = current;
+		this.#visibleBindings = Object.freeze([...visibleBindings]);
+		this.#aliasCounter = aliasCounter;
+		Object.freeze(this);
+	}
+	static root(namespaceId, tableName) {
+		const binding = SqlTableBinding.unaliased({
+			namespaceId,
+			tableName
+		});
+		return new ModelAccessorScope(binding, [binding], { nextId: 1 });
+	}
+	forRelation(namespaceId, tableName) {
+		const binding = this.#allocateBinding(namespaceId, tableName, "rel");
+		return new ModelAccessorScope(binding, [...this.#visibleBindings, binding], this.#aliasCounter);
+	}
+	forManyToManyRelation(childNamespaceId, childTableName, junctionNamespaceId, junctionTableName) {
+		const initialChildScope = this.forRelation(childNamespaceId, childTableName);
+		const junctionBinding = initialChildScope.#allocateBinding(junctionNamespaceId, junctionTableName, "junction");
+		return {
+			childScope: new ModelAccessorScope(initialChildScope.current, [...initialChildScope.#visibleBindings, junctionBinding], this.#aliasCounter),
+			junctionBinding
+		};
+	}
+	forJoinedSource(namespaceId, tableName) {
+		if (this.current.isStoredAt(namespaceId, tableName)) return this;
+		const binding = SqlTableBinding.unaliased({
+			namespaceId,
+			tableName
+		});
+		return new ModelAccessorScope(binding, [...this.#visibleBindings, binding], this.#aliasCounter);
+	}
+	#allocateBinding(namespaceId, tableName, aliasKind) {
+		const storage = {
+			namespaceId,
+			tableName
+		};
+		if (!this.#visibleBindings.some((binding) => binding.isReferencedAs(tableName))) return SqlTableBinding.unaliased(storage);
+		return SqlTableBinding.aliased(storage, this.#allocateAlias(aliasKind));
+	}
+	#allocateAlias(kind) {
+		while (true) {
+			const alias = `__orm_${kind}_${this.#aliasCounter.nextId}`;
+			this.#aliasCounter.nextId += 1;
+			if (!this.#visibleBindings.some((binding) => binding.isReferencedAs(alias))) return alias;
+		}
+	}
+};
 function createModelAccessor(context, namespaceId, modelName, variantName) {
+	const tableName = resolveModelTableName(context.contract, namespaceId, modelName);
+	return createModelAccessorInScope(context, namespaceId, modelName, variantName, ModelAccessorScope.root(namespaceId, tableName));
+}
+function createModelAccessorInScope(context, namespaceId, modelName, variantName, scope) {
 	const contract = context.contract;
 	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
 	const tableName = resolveModelTableName(contract, namespaceId, modelName);
@@ -2493,19 +2577,20 @@ function createModelAccessor(context, namespaceId, modelName, variantName) {
 		if (typeof prop !== "string") return;
 		if (variantCoordinates) {
 			const variantRelation = variantCoordinates.relations[prop];
-			if (variantRelation) return createRelationFilterAccessor(context, namespaceId, variantCoordinates.name, variantCoordinates.tableName, prop, variantRelation);
+			if (variantRelation) return createRelationFilterAccessor(context, namespaceId, variantCoordinates.name, scope.forJoinedSource(namespaceId, variantCoordinates.tableName), variantRelation);
 		}
 		const relation = modelRelations[prop];
-		if (relation) return createRelationFilterAccessor(context, namespaceId, modelName, tableName, prop, relation);
+		if (relation) return createRelationFilterAccessor(context, namespaceId, modelName, scope, relation);
 		const variantField = variantFieldColumns[prop];
 		const resolvedTable = variantField?.table ?? tableName;
+		const fieldBinding = scope.forJoinedSource(namespaceId, resolvedTable).current;
 		const columnName = variantField?.column ?? fieldToColumn[prop] ?? prop;
 		const column = resolveColumn(contract, namespaceId, resolvedTable, columnName);
 		if (!column) return;
 		const traits = context.codecDescriptors.descriptorFor(column.codecId)?.traits ?? [];
 		const operations = opsByCodecId.get(column.codecId) ?? [];
 		const codec = codecRefForStorageColumn(contract.storage, namespaceId, resolvedTable, columnName);
-		return createScalarFieldAccessor(resolvedTable, columnName, column.codecId, column.nullable, codec, traits, operations, context);
+		return createScalarFieldAccessor(fieldBinding, columnName, column.codecId, column.nullable, codec, traits, operations, context);
 	} }));
 }
 function resolveColumn(contract, namespaceId, tableName, columnName) {
@@ -2522,8 +2607,8 @@ function resolveColumn(contract, namespaceId, tableName, columnName) {
 		nullable: column.nullable
 	};
 }
-function createScalarFieldAccessor(tableName, columnName, codecId, nullable, codec, traits, operations, context) {
-	const column = ColumnRef.of(tableName, columnName);
+function createScalarFieldAccessor(tableBinding, columnName, codecId, nullable, codec, traits, operations, context) {
+	const column = tableBinding.column(columnName);
 	const comparisonEntries = [];
 	for (const [name, meta] of Object.entries(COMPARISON_METHODS_META)) {
 		if (meta.traits.some((t) => !traits.includes(t))) continue;
@@ -2558,42 +2643,41 @@ function createExtensionMethodFactory(selfExpr, entry, context) {
 		return methods;
 	};
 }
-function createRelationFilterAccessor(context, parentNamespaceId, parentModelName, parentTableName, relationName, relation) {
+function createRelationFilterAccessor(context, parentNamespaceId, parentModelName, parentScope, relation) {
 	const relatedTableName = resolveModelTableName(context.contract, relation.toNamespace, relation.to);
 	return {
-		some: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, {
+		some: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, {
 			mode: "some",
 			predicate
 		}),
-		every: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, {
+		every: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, {
 			mode: "every",
 			predicate
 		}),
-		none: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, {
+		none: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, {
 			mode: "none",
 			predicate
 		})
 	};
 }
-function buildExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, options) {
-	if (hasThrough$1(relation)) return buildManyToManyExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, options);
-	const filterPlan = planRelationFilterMode(buildJoinWhere(context.contract, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relation), toRelationWhereExpr(context, relation.toNamespace, relation.to, options.predicate), options.mode);
+function buildExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, options) {
+	if (hasThrough$1(relation)) return buildManyToManyExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, options);
+	const childScope = parentScope.forRelation(relation.toNamespace, relatedTableName);
+	const filterPlan = planRelationFilterMode(buildJoinWhere(context.contract, parentNamespaceId, parentModelName, parentScope.current, childScope.current, relation), toRelationWhereExpr(context, relation.toNamespace, relation.to, options.predicate, childScope), options.mode);
 	if (filterPlan.kind === "constantTrue") return AndExpr.true();
 	const selectProjectionColumn = firstTargetColumn(context.contract, relation) ?? "id";
-	const subquery = SelectAst.from(tableSourceForContract(context.contract, relation.toNamespace, relatedTableName)).withProjection([ProjectionItem.of("_exists", ColumnRef.of(relatedTableName, selectProjectionColumn))]).withWhere(filterPlan.where);
+	const subquery = SelectAst.from(childScope.current.tableSource(context.contract)).withProjection([ProjectionItem.of("_exists", childScope.current.column(selectProjectionColumn))]).withWhere(filterPlan.where);
 	return filterPlan.notExists ? ExistsExpr.notExists(subquery) : ExistsExpr.exists(subquery);
 }
-function buildManyToManyExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, options) {
+function buildManyToManyExistsExpr(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation, options) {
 	const { through } = relation;
-	const junctionTable = through.table;
-	const relatedTableAlias = parentNamespaceId === relation.toNamespace && parentTableName === relatedTableName ? `${relationName}__child` : void 0;
-	const relatedTableRef = relatedTableAlias ?? relatedTableName;
-	const junctionJoinOn = buildPairedColumnExprs(junctionTable, through.childColumns, relatedTableRef, through.targetColumns);
+	const { childScope, junctionBinding } = parentScope.forManyToManyRelation(relation.toNamespace, relatedTableName, through.namespaceId, through.table);
+	const junctionJoinOn = buildPairedColumnExprs(junctionBinding, through.childColumns, childScope.current, through.targetColumns);
 	const parentLocalColumns = relation.on.localFields.map((field) => resolveFieldToColumn(context.contract, parentNamespaceId, parentModelName, field));
-	const filterPlan = planRelationFilterMode(buildPairedColumnExprs(junctionTable, through.parentColumns, parentTableName, parentLocalColumns), remapColumnRefs(relatedTableName, relatedTableRef, toRelationWhereExpr(context, relation.toNamespace, relation.to, options.predicate)), options.mode);
+	const filterPlan = planRelationFilterMode(buildPairedColumnExprs(junctionBinding, through.parentColumns, parentScope.current, parentLocalColumns), toRelationWhereExpr(context, relation.toNamespace, relation.to, options.predicate, childScope), options.mode);
 	if (filterPlan.kind === "constantTrue") return AndExpr.true();
 	const firstTargetCol = firstJoinColumn(through.targetColumns, "targetColumns");
-	const subquery = SelectAst.from(tableSourceForContract(context.contract, relation.toNamespace, relatedTableName, relatedTableAlias)).withJoins([JoinAst.inner(TableSource.named(junctionTable, void 0, through.namespaceId), junctionJoinOn)]).withProjection([ProjectionItem.of("_exists", ColumnRef.of(relatedTableRef, firstTargetCol))]).withWhere(filterPlan.where);
+	const subquery = SelectAst.from(childScope.current.tableSource(context.contract)).withJoins([JoinAst.inner(junctionBinding.tableSource(context.contract), junctionJoinOn)]).withProjection([ProjectionItem.of("_exists", childScope.current.column(firstTargetCol))]).withWhere(filterPlan.where);
 	return filterPlan.notExists ? ExistsExpr.notExists(subquery) : ExistsExpr.exists(subquery);
 }
 function planRelationFilterMode(joinWhere, childWhere, mode) {
@@ -2616,10 +2700,6 @@ function planRelationFilterMode(joinWhere, childWhere, mode) {
 		where: childWhere ? and(joinWhere, childWhere) : joinWhere
 	};
 }
-function remapColumnRefs(tableName, tableRef, expr) {
-	if (!expr || tableName === tableRef) return expr;
-	return expr.rewrite({ columnRef: (column) => column.table === tableName ? ColumnRef.of(tableRef, column.column) : column });
-}
 function firstJoinColumn(columns, label) {
 	const first = columns[0];
 	if (!first) throw new InternalError(`Relation metadata is missing ${label}`);
@@ -2633,14 +2713,14 @@ function buildPairedColumnExprs(leftTable, leftColumns, rightTable, rightColumns
 		const left = leftColumns[i];
 		const right = rightColumns[i];
 		if (!left || !right) throw new InternalError(`Relation metadata is missing a join column pair at index ${i}`);
-		exprs.push(BinaryExpr.eq(ColumnRef.of(leftTable, left), ColumnRef.of(rightTable, right)));
+		exprs.push(BinaryExpr.eq(leftTable.column(left), rightTable.column(right)));
 	}
 	if (exprs.length === 1 && exprs[0]) return exprs[0];
 	return and(...exprs);
 }
-function toRelationWhereExpr(context, relatedNamespaceId, relatedModelName, predicate) {
+function toRelationWhereExpr(context, relatedNamespaceId, relatedModelName, predicate, scope) {
 	if (!predicate) return;
-	const accessor = createModelAccessor(context, relatedNamespaceId, relatedModelName);
+	const accessor = createModelAccessorInScope(context, relatedNamespaceId, relatedModelName, void 0, scope);
 	if (typeof predicate === "function") return predicate(accessor);
 	const exprs = [];
 	for (const [fieldName, value] of Object.entries(predicate)) {
@@ -2665,7 +2745,7 @@ function toRelationWhereExpr(context, relatedNamespaceId, relatedModelName, pred
 	if (exprs.length === 0) return;
 	return exprs.length === 1 ? exprs[0] : and(...exprs);
 }
-function buildJoinWhere(contract, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relation) {
+function buildJoinWhere(contract, parentNamespaceId, parentModelName, parentTable, relatedTable, relation) {
 	const localFields = relation.on?.localFields ?? [];
 	const targetFields = relation.on?.targetFields ?? [];
 	const joinExprs = [];
@@ -2676,7 +2756,7 @@ function buildJoinWhere(contract, parentNamespaceId, parentModelName, parentTabl
 		if (!localField || !targetField) continue;
 		const localColumn = resolveFieldToColumn(contract, parentNamespaceId, parentModelName, localField);
 		const targetColumn = resolveFieldToColumn(contract, relation.toNamespace, relation.to, targetField);
-		joinExprs.push(BinaryExpr.eq(ColumnRef.of(relatedTableName, targetColumn), ColumnRef.of(parentTableName, localColumn)));
+		joinExprs.push(BinaryExpr.eq(relatedTable.column(targetColumn), parentTable.column(localColumn)));
 	}
 	if (joinExprs.length === 0) throw new InternalError("Relation metadata is missing join columns");
 	const firstExpr = joinExprs[0];