@rebasepro/server-postgres 0.12.1-canary.g181d0fe → 0.12.1-canary.g35be8cb

package/dist/index.es.js

@@ -11364,11 +11364,27 @@ function buildProperties(meta, enumMap) {
 	return properties;
 }
 /**
-* Owning relations, derived from this table's foreign keys. Mirrors the shape
-* `generateCollectionFile` emits, except `target` uses the slug string form
-* rather than a thunk to a module import.
-*/
-function buildRelations(meta, slugByTable) {
+* Owning relations, derived from this table's foreign keys — the same shape
+* `generateCollectionFile` writes into a collection file: a `relation` property
+* whose nested descriptor carries `kind`, a `target` thunk and the `localKey`.
+*
+* The shape is load-bearing, not cosmetic. `resolveCollectionRelations` reads
+* relations from `property.relation` and `resolveRelation` requires `target` to
+* be a thunk; this used to emit `target`/`cardinality`/`localKey` flat on the
+* property with the slug as a bare string, which satisfies neither. Nothing
+* threw — the resolver simply skipped every such property and reported that the
+* collection had no relations. So an introspected BaaS collection had its FK
+* columns removed from `properties` (they "surface as relations") and then no
+* resolvable relation to surface as, which is why writing the FK column
+* directly came back as `has no field 'product_id'`: `assertKnownWriteFields`
+* learns that column from the resolved relation's `localKey`.
+*
+* The thunk closes over the collections being built in this same pass rather
+* than importing a module, which is what a runtime introspection has instead of
+* generated files. It is called lazily, after the map is fully populated, so a
+* table may reference one introspected later.
+*/
+function buildRelations(meta, slugByTable, collectionBySlug) {
 	const relations = {};
 	for (const fk of meta.fks) {
 		const targetSlug = slugByTable.get(fk.foreign_table_name);
@@ -11378,10 +11394,11 @@ function buildRelations(meta, slugByTable) {
 		relations[key] = {
 			name: humanize(key),
 			type: "relation",
-			target: targetSlug,
-			cardinality: "one",
-			direction: "owning",
-			localKey: fk.column_name
+			relation: {
+				kind: "belongsTo",
+				target: () => collectionBySlug.get(targetSlug),
+				localKey: fk.column_name
+			}
 		};
 	}
 	return relations;
@@ -11396,6 +11413,7 @@ function buildCollectionsFromSchema({ tablesMap, enumMap, joinTables }, pgSchema
 	const slugByTable = /* @__PURE__ */ new Map();
 	for (const tableName of tablesMap.keys()) if (!joinTables.has(tableName)) slugByTable.set(tableName, tableName);
 	const collections = [];
+	const collectionBySlug = /* @__PURE__ */ new Map();
 	for (const [tableName, meta] of tablesMap) {
 		if (joinTables.has(tableName)) continue;
 		const collectionName = humanize(tableName);
@@ -11408,10 +11426,11 @@ function buildCollectionsFromSchema({ tablesMap, enumMap, joinTables }, pgSchema
 			icon: getIconForTable(tableName),
 			properties: {
 				...buildProperties(meta, enumMap),
-				...buildRelations(meta, slugByTable)
+				...buildRelations(meta, slugByTable, collectionBySlug)
 			}
 		};
 		collections.push(collection);
+		collectionBySlug.set(tableName, collection);
 	}
 	return collections;
 }
@@ -11912,11 +11931,13 @@ function createPostgresBootstrapper(pgConfig) {
 		*/
 		async ensureCollectionSchema(collections, driverResult, log) {
 			const internals = driverResult.internals;
-			const { ensureCollectionTables } = await import("./ensure-collection-tables-Vu-GRELM.js");
-			return { applied: (await ensureCollectionTables({ async query(text) {
+			const { ensureCollectionTables } = await import("./ensure-collection-tables-DsDsNl6o.js");
+			const plan = await ensureCollectionTables({ async query(text) {
 				const result = await internals.db.execute(sql.raw(text));
 				return { rows: result.rows ?? (Array.isArray(result) ? result : []) };
-			} }, collections, log)).actions.length };
+			} }, collections, log);
+			for (const failure of plan.failures) logger.warn(`🔗 [schema] Could not add foreign key "${failure.target}" — the column exists and the collection still serves, but rows are not policed by this constraint: ${failure.error}`);
+			return { applied: plan.actions.length - plan.failures.length };
 		},
 		/**
 		* Apply the collections' RLS policies — ENABLE ROW LEVEL SECURITY and the
@@ -11935,7 +11956,7 @@ function createPostgresBootstrapper(pgConfig) {
 		*/
 		async ensureCollectionPolicies(collections, driverResult, log) {
 			const internals = driverResult.internals;
-			const { ensureCollectionPolicies } = await import("./ensure-collection-policies-CT-zIUWA.js");
+			const { ensureCollectionPolicies } = await import("./ensure-collection-policies-Vl3Cv1Q9.js");
 			const outcome = await ensureCollectionPolicies({ async query(text) {
 				const result = await internals.db.execute(sql.raw(text));
 				return { rows: result.rows ?? (Array.isArray(result) ? result : []) };