@prisma-next/target-postgres 0.14.0-dev.44 → 0.14.0-dev.46

package/dist/control.mjs

@@ -1,17 +1,17 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-tjatyhtZ.mjs";
-import { a as PostgresDatabaseSchemaNode } from "./postgres-table-schema-node-1nNc8XDT.mjs";
-import { i as contractToPostgresDatabaseSchemaNode, n as diffPostgresDatabaseSchema, r as verifyPostgresDatabaseSchema, t as createPostgresMigrationPlanner } from "./planner-CG2pLHk-.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CuGDsrG4.mjs";
+import { a as PostgresDatabaseSchemaNode } from "./postgres-table-schema-node-Clei_xel.mjs";
+import { i as contractToPostgresDatabaseSchemaNode, n as diffPostgresDatabaseSchema, r as verifyPostgresDatabaseSchema, t as createPostgresMigrationPlanner } from "./planner-CMXuFrQB.mjs";
 import { r as renderDefaultLiteral } from "./planner-ddl-builders-B8Nn6nHN.mjs";
-import { n as PostgresContractSerializer } from "./postgres-contract-view-BegduLr6.mjs";
+import { n as PostgresContractSerializer } from "./postgres-contract-view-V3rGJCoe.mjs";
+import { UNBOUND_NAMESPACE_ID, coordinateKey, elementCoordinates } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
 import { extractCodecControlHooks, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
 import { notOk, ok, okVoid } from "@prisma-next/utils/result";
 import { SqlSchemaVerifierBase } from "@prisma-next/family-sql/ir";
 import { SqlQueryError } from "@prisma-next/sql-errors";
-import { inferRelations, mapDefault, parseRawDefault, toFieldName, toModelName, toNamedTypeName } from "@prisma-next/family-sql/psl-infer";
+import { buildChildRelationField, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, toFieldName, toModelName, toNamedTypeName } from "@prisma-next/family-sql/psl-infer";
 import { UNSPECIFIED_PSL_NAMESPACE_ID, makePslNamespace, makePslNamespaceEntries } from "@prisma-next/framework-components/psl-ast";
 //#region src/core/migrations/runner.ts
 const LOCK_DOMAIN = "prisma_next.contract.marker";
@@ -621,6 +621,108 @@ const PSL_SCALAR_TYPE_NAMES = new Set([
 	"Bytes"
 ]);
 /**
+* Coordinates every element a set of already-assembled contracts declare,
+* mapped to the {@link SqlDescribedContractSpace} that owns it and keyed by
+* the shared {@link coordinateKey} helper. `contract infer` uses this to omit
+* database elements a stack extension pack's contract space already
+* describes — reusing the same coordinate walk the contract-space aggregate
+* and cross-space collision check use (`elementCoordinates`), rather than a
+* bespoke per-entity-kind membership test — and, for a foreign key whose
+* referenced table an entry owns, to resolve the qualified cross-space
+* relation it describes.
+*/
+function describedContractOwners(describedContracts) {
+	const owners = /* @__PURE__ */ new Map();
+	for (const entry of describedContracts) for (const coordinate of elementCoordinates(entry.contract.storage)) owners.set(coordinateKey(coordinate), entry);
+	return owners;
+}
+function resolveCrossSpaceTarget(owner, namespaceId, tableName) {
+	const domainNamespace = owner.contract.domain.namespaces[namespaceId];
+	if (domainNamespace === void 0) return;
+	for (const [modelName, model] of Object.entries(domainNamespace.models)) {
+		const storage = blindCast(model.storage);
+		if (storage.namespaceId !== namespaceId || storage.table !== tableName) continue;
+		const fieldNamesByColumn = /* @__PURE__ */ new Map();
+		for (const [fieldName, fieldStorage] of Object.entries(storage.fields)) fieldNamesByColumn.set(fieldStorage.column, { fieldName });
+		return {
+			spaceId: owner.spaceId,
+			namespaceId,
+			modelName,
+			fieldNamesByColumn
+		};
+	}
+}
+/**
+* Classifies every foreign key on a surviving table into one of three cases.
+* A foreign key that carries a `referencedSchema` is checked against the
+* pack-owned coordinates first, so a pack-owned target wins even when a local
+* table happens to share its bare name; only foreign keys with no owned
+* coordinate fall through to the local/dangling distinction.
+*
+* - **Cross-space**: `referencedSchema` is set and a described contract owns
+*   the coordinate `(referencedSchema, 'table', referencedTable)`. The
+*   referenced table is absent from the tree (omitted because the pack
+*   describes it, or never introspected — `contract infer` walks a single
+*   namespace). Removed from `foreignKeys` (so `inferRelations` never falls
+*   back to a bare, unqualified table name for it) and replaced with a
+*   `RelationField` qualified with the owning pack's space id and namespace
+*   id. `owners` holds only pack-declared coordinates, so an app's own table
+*   (e.g. `public.users`) is never owned and cannot be captured here.
+* - **Local**: not a pack-owned coordinate, and the referenced table survived
+*   introspection — left untouched, `inferRelations` handles it as before.
+* - **Dangling**: not a pack-owned coordinate, and the referenced table is
+*   neither in the tree nor owned by any described contract. Removed from
+*   `foreignKeys`, keeping the scalar column, rather than emitting a relation
+*   to a model that was never defined.
+*
+* A pack that owns the referenced coordinate but declares no domain model
+* mapped to it is malformed; that case throws rather than degrading to a
+* silent drop, which would contradict the dangling definition above.
+*/
+function resolveForeignKeys(tables, owners) {
+	const resultTables = {};
+	const extraRelationsByTable = /* @__PURE__ */ new Map();
+	const crossSpaceFieldNamesByTable = /* @__PURE__ */ new Map();
+	for (const [tableName, table] of Object.entries(tables)) {
+		const keptForeignKeys = [];
+		for (const fk of table.foreignKeys) {
+			if (fk.referencedSchema !== void 0) {
+				const owner = owners.get(coordinateKey({
+					namespaceId: fk.referencedSchema,
+					entityKind: "table",
+					entityName: fk.referencedTable
+				}));
+				if (owner !== void 0) {
+					const target = resolveCrossSpaceTarget(owner, fk.referencedSchema, fk.referencedTable);
+					if (target === void 0) throw new Error(`contract infer: described contract space "${owner.spaceId}" owns storage coordinate "${fk.referencedSchema}.${fk.referencedTable}" but declares no domain model mapped to it. A pack that describes a table must also declare the domain model it maps to; this pack is malformed.`);
+					if (!crossSpaceFieldNamesByTable.has(fk.referencedTable)) crossSpaceFieldNamesByTable.set(fk.referencedTable, target.fieldNamesByColumn);
+					const fieldName = deriveRelationFieldName(fk.columns, fk.referencedTable);
+					const optional = fk.columns.some((columnName) => table.columns[columnName]?.nullable ?? false);
+					const relationField = {
+						...buildChildRelationField(fieldName, target.modelName, fk, optional),
+						typeNamespaceId: target.namespaceId,
+						typeContractSpaceId: target.spaceId
+					};
+					const existingRelations = extraRelationsByTable.get(tableName);
+					if (existingRelations) existingRelations.push(relationField);
+					else extraRelationsByTable.set(tableName, [relationField]);
+					continue;
+				}
+			}
+			if (tables[fk.referencedTable] !== void 0) keptForeignKeys.push(fk);
+		}
+		resultTables[tableName] = keptForeignKeys.length === table.foreignKeys.length ? table : {
+			...table,
+			foreignKeys: keptForeignKeys
+		};
+	}
+	return {
+		tables: resultTables,
+		extraRelationsByTable,
+		crossSpaceFieldNamesByTable
+	};
+}
+/**
 * Infers a PSL AST (for `printPsl`) from an introspected Postgres schema tree.
 *
 * Target-owned inference: it walks the `PostgresDatabaseSchemaNode` tree and
@@ -633,9 +735,20 @@ const PSL_SCALAR_TYPE_NAMES = new Set([
 * introspects a single live namespace) are gathered into the model set and
 * emitted as one `UNSPECIFIED_PSL_NAMESPACE_ID` bucket. Top-level entities
 * (policies/roles → PSL extension blocks) are a later slice.
+*
+* `describedContracts` — the stack's extension packs' already-assembled
+* contracts, each paired with its space id — is consulted while gathering
+* tables: a table whose coordinate `(schemaName, 'table', tableName)` one of
+* those contracts already declares is omitted, before the duplicate-name
+* check below and before relation inference, so it cannot spuriously
+* collide with an app table and never contributes a bare relation field. A
+* surviving table's foreign key into an omitted, pack-owned table is not
+* dropped: {@link resolveForeignKeys} rewrites it into a relation qualified
+* with the pack's space id (`<spaceId>:<namespaceId>.<Model>`) instead.
 */
-function inferPostgresPslContract(tree) {
+function inferPostgresPslContract(tree, describedContracts) {
 	const namespaces = Object.values(tree.namespaces);
+	const owners = describedContractOwners(describedContracts ?? []);
 	const enumTypeNames = [...new Set(namespaces.flatMap((ns) => ns.nativeEnumTypeNames))];
 	if (enumTypeNames.length > 0) {
 		const names = enumTypeNames.join(", ");
@@ -643,25 +756,35 @@ function inferPostgresPslContract(tree) {
 	}
 	const tables = {};
 	for (const namespace of namespaces) for (const [tableName, table] of Object.entries(namespace.tables)) {
+		if (owners.has(coordinateKey({
+			namespaceId: namespace.schemaName,
+			entityKind: "table",
+			entityName: tableName
+		}))) continue;
 		if (tables[tableName] !== void 0) throw new Error(`contract infer: duplicate table name "${tableName}" across schemas is not yet supported (single-namespace PSL inference emits one flat bucket; multi-namespace \`namespace { … }\` output is a later slice).`);
 		tables[tableName] = table;
 	}
-	return buildPslDocumentAst({ tables }, {
+	const { tables: resolvedTables, extraRelationsByTable, crossSpaceFieldNamesByTable } = resolveForeignKeys(tables, owners);
+	return buildPslDocumentAst({ tables: resolvedTables }, {
 		typeMap: createPostgresTypeMap(/* @__PURE__ */ new Set()),
 		defaultMapping: createPostgresDefaultMapping(),
 		parseRawDefault
+	}, {
+		extraRelationsByTable,
+		crossSpaceFieldNamesByTable
 	});
 }
-function buildPslDocumentAst(schemaIR, options) {
+function buildPslDocumentAst(schemaIR, options, foreignKeyExtras) {
 	const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
+	const { extraRelationsByTable, crossSpaceFieldNamesByTable } = foreignKeyExtras;
 	const modelNames = buildTopLevelNameMap(Object.keys(schemaIR.tables), toModelName, "model", "table");
 	const modelNameMap = new Map([...modelNames].map(([tableName, result]) => [tableName, result.name]));
 	const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames);
-	const fieldNamesByTable = buildFieldNamesByTable(schemaIR.tables);
+	const fieldNamesByTable = new Map([...crossSpaceFieldNamesByTable, ...buildFieldNamesByTable(schemaIR.tables)]);
 	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
 	const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, /* @__PURE__ */ new Map(), reservedNamedTypeNames);
 	const models = [];
-	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, /* @__PURE__ */ new Map(), fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationsByTable.get(table.name) ?? []));
+	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, /* @__PURE__ */ new Map(), fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, [...relationsByTable.get(table.name) ?? [], ...extraRelationsByTable.get(table.name) ?? []]));
 	const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
 	const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) => a.name.localeCompare(b.name));
 	const types = namedTypeEntries.length > 0 ? {
@@ -786,6 +909,8 @@ function buildRelationField(rel, hostTableName, fieldNamesByTable, usedFieldName
 		kind: "field",
 		name: fieldName,
 		typeName: rel.typeName,
+		...ifDefined("typeNamespaceId", rel.typeNamespaceId),
+		...ifDefined("typeContractSpaceId", rel.typeContractSpaceId),
 		optional: rel.optional,
 		list: rel.list,
 		attributes: attrs,
@@ -1023,9 +1148,9 @@ const postgresTargetDescriptor = {
 	...postgresTargetDescriptorMeta,
 	contractSerializer: new PostgresContractSerializer(),
 	schemaVerifier: new PostgresSchemaVerifier(),
-	inferPslContract(schema) {
+	inferPslContract(schema, describedContracts) {
 		PostgresDatabaseSchemaNode.assert(schema);
-		return inferPostgresPslContract(schema);
+		return inferPostgresPslContract(schema, describedContracts);
 	},
 	diffDatabaseSchema(input) {
 		return diffPostgresDatabaseSchema({