@rebasepro/server-postgres 0.10.1-canary.b1e3dbf → 0.10.1-canary.ed78a2c

package/src/schema/generate-drizzle-schema-logic.ts

@@ -1,4 +1,4 @@
-import { CollectionConfig, NumberProperty, Property, Relation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollectionConfig, DateProperty, ArrayProperty, MapProperty, ReferenceProperty, VectorProperty, BinaryProperty } from "@rebasepro/types";
+import { CollectionConfig, NumberProperty, Property, ResolvedRelation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollectionConfig, DateProperty, ArrayProperty, MapProperty, ReferenceProperty, VectorProperty, BinaryProperty, isManyToMany, type ResolvedManyToMany, type ResolvedBelongsTo, type ResolvedForeignKeyOnTarget, hasForeignKeyOnTarget } from "@rebasepro/types";
 import { getPrimaryKeys } from "../services/collection-helpers";
 import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig } from "@rebasepro/common";
 import { toSnakeCase, getPolicyNamesForRule } from "@rebasepro/utils";
@@ -97,12 +97,14 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
                 columnDefinition = `uuid("${colName}")`;
             } else if (stringProp.columnType === "uuid") {
                 columnDefinition = `uuid("${colName}")`;
-            } else if (stringProp.columnType === "text" || stringProp.ui?.markdown || stringProp.ui?.multiline) {
-                columnDefinition = `text("${colName}")`;
             } else if (stringProp.columnType === "char") {
                 columnDefinition = `char("${colName}")`;
-            } else {
+            } else if (stringProp.columnType === "varchar") {
                 columnDefinition = `varchar("${colName}")`;
+            } else {
+                // `text` is the default, and the only length-unbounded choice.
+                // Ask for `varchar` explicitly if you want the length constraint.
+                columnDefinition = `text("${colName}")`;
             }
             if (isIdProperty(propName, prop, collection)) {
                 columnDefinition += ".primaryKey()";
@@ -222,16 +224,11 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
         case "relation": {
             const refProp = prop as RelationProperty;
             const resolvedRelations = resolveCollectionRelations(collection);
-            const relation = findRelation(resolvedRelations, refProp.relationName ?? propName);
+            const relation = findRelation(resolvedRelations, refProp.relation?.relationName ?? propName);
 
-            // Only owning one-to-one/many-to-one relations create a column here.
-            if (!relation || relation.direction !== "owning" || relation.cardinality !== "one") {
-                return null;
-            }
-
-            // The localKey property is the source of truth for the FK column name.
-            if (!relation.localKey) {
-                logger.warn(`Could not generate column for owning relation '${relation.relationName}' on '${collection.name}': 'localKey' is not defined.`);
+            // Only `belongsTo` puts a column on this table; every other kind
+            // is a column on the target, a junction row, or a join chain.
+            if (!relation || relation.kind !== "belongsTo") {
                 return null;
             }
 
@@ -252,7 +249,7 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             const targetTableVar = getTableVarName(getTableName(targetCollection));
             const pkProp = getPrimaryKeyProp(targetCollection);
             const targetIdField = pkProp.name;
-            const baseColumn = pkProp.type === "number" ? `integer("${fkColumnName}")` : (pkProp.isUuid ? `uuid("${fkColumnName}")` : `varchar("${fkColumnName}")`);
+            const baseColumn = pkProp.type === "number" ? `integer("${fkColumnName}")` : (pkProp.isUuid ? `uuid("${fkColumnName}")` : `text("${fkColumnName}")`);
 
             const onUpdate = relation.onUpdate ? `onUpdate: "${relation.onUpdate}"` : "";
             const required = prop.validation?.required;
@@ -274,14 +271,14 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             const refProp = prop as ReferenceProperty;
             const targetCollection = collections.find(c => c.slug === refProp.path || getTableName(c) === refProp.path);
             if (!targetCollection) {
-                columnDefinition = `varchar("${colName}")`;
+                columnDefinition = `text("${colName}")`;
                 break;
             }
 
             const pkProp = getPrimaryKeyProp(targetCollection);
             const targetTableVar = getTableVarName(getTableName(targetCollection));
             const targetIdField = pkProp.name;
-            const baseColumn = pkProp.type === "number" ? `integer("${colName}")` : (pkProp.isUuid ? `uuid("${colName}")` : `varchar("${colName}")`);
+            const baseColumn = pkProp.type === "number" ? `integer("${colName}")` : (pkProp.isUuid ? `uuid("${colName}")` : `text("${colName}")`);
 
             const required = prop.validation?.required;
             const onDelete = required ? "cascade" : "set null";
@@ -400,26 +397,22 @@ const generateSinglePolicyCode = (collection: CollectionConfig, rule: SecurityRu
  * Falls back to the local relation name when the counterpart can't be resolved.
  */
 const computeSharedRelationName = (
-    rel: Relation,
+    rel: ResolvedRelation,
     sourceCollection: CollectionConfig,
     _collections: CollectionConfig[]
 ): string => {
     const fallback = rel.relationName ?? toSnakeCase(rel.target().slug);
 
-    // --- owning one (belongs-to) ---
-    if (rel.direction === "owning" && rel.cardinality === "one" && rel.localKey) {
-        // Normalise the localKey to the actual Drizzle property name so that
-        // the owning side produces the same relation name as the inverse side
-        // (which resolves foreignKeyOnTarget via the same helper).
+    // Both sides of a link must derive the same name, so each resolves the
+    // column to its Drizzle property key and builds the name from the table
+    // that actually owns it.
+    if (rel.kind === "belongsTo") {
         const normalisedKey = resolvePropertyKeyForColumn(sourceCollection, rel.localKey);
         return `${getTableName(sourceCollection)}_${normalisedKey}`;
     }
 
-    // --- inverse many (one-to-many has-many) ---
-    if (rel.direction === "inverse" && rel.cardinality === "many" && rel.foreignKeyOnTarget) {
-        // The owning table is the *target*, the FK column is foreignKeyOnTarget.
-        // Resolve to the Drizzle property key on the target so it matches the
-        // owning side's normalised localKey.
+    if (rel.kind === "hasMany" || rel.kind === "hasOne") {
+        // The owning table is the *target*; the column is foreignKeyOnTarget.
         try {
             const targetCollection = rel.target();
             const normalisedFK = resolvePropertyKeyForColumn(targetCollection, rel.foreignKeyOnTarget);
@@ -429,40 +422,8 @@ const computeSharedRelationName = (
         }
     }
 
-    // --- inverse one (one-to-one inverse) ---
-    if (rel.direction === "inverse" && rel.cardinality === "one") {
-        if (rel.foreignKeyOnTarget) {
-            // FK lives on the target table — resolve to Drizzle property key
-            try {
-                const targetCollection = rel.target();
-                const normalisedFK = resolvePropertyKeyForColumn(targetCollection, rel.foreignKeyOnTarget);
-                return `${getTableName(targetCollection)}_${normalisedFK}`;
-            } catch {
-                return fallback;
-            }
-        }
-        // No explicit foreignKeyOnTarget — try to find the corresponding owning relation
-        try {
-            const targetCollection = rel.target();
-            const targetResolvedRelations = resolveCollectionRelations(targetCollection);
-            const correspondingRelation = Object.values(targetResolvedRelations).find(targetRel =>
-                targetRel.direction === "owning" &&
-                targetRel.cardinality === "one" &&
-                targetRel.localKey &&
-                targetRel.target().slug === sourceCollection.slug
-            );
-            if (correspondingRelation && correspondingRelation.localKey) {
-                return `${getTableName(targetCollection)}_${correspondingRelation.localKey}`;
-            }
-        } catch {
-            // ignore
-        }
-        return fallback;
-    }
-
-    // --- M2M owning (through) — keep local name (already shared via junction wiring) ---
-    // --- M2M inverse — keep local name ---
-    // --- joinPath — not emitted as Drizzle relations ---
+    // manyToMany is named through its junction wiring; `via` is not emitted as
+    // a Drizzle relation at all. Both keep the local name.
     return fallback;
 };
 
@@ -519,7 +480,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
     const allTablesToGenerate = new Map<string, {
         collection: CollectionConfig,
         isJunction?: boolean,
-        relation?: Relation,
+        relation?: ResolvedRelation,
         sourceCollection?: CollectionConfig
     }>();
 
@@ -558,7 +519,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
 
         const resolvedRelations = resolveCollectionRelations(collection);
         for (const relation of Object.values(resolvedRelations)) {
-            if (relation.through) { // Standard M2M junction table
+            if (isManyToMany(relation)) { // Standard M2M junction table
                 const junctionTableName = relation.through.table;
                 if (!allTablesToGenerate.has(junctionTableName)) {
                     allTablesToGenerate.set(junctionTableName, {
@@ -584,7 +545,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
         sourceCollection
     }] of allTablesToGenerate.entries()) {
         const tableVarName = getTableVarName(tableName);
-        if (isJunction && relation && sourceCollection && relation.through) {
+        if (isJunction && relation && sourceCollection && isManyToMany(relation)) {
             const targetCollection = relation.target();
             const schema = (isPostgresCollectionConfig(targetCollection) ? targetCollection.schema : undefined) || (isPostgresCollectionConfig(sourceCollection) ? sourceCollection.schema : undefined);
             const tableCreator = schema ? `${schema}Schema.table` : "pgTable";
@@ -597,8 +558,10 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
             const onDelete = relation.onDelete ?? "cascade";
             const refOptions = `{ onDelete: \"${onDelete}\" }`;
 
-            const sourceColType = isNumericId(sourceCollection) ? "integer" : (getPrimaryKeyProp(sourceCollection).isUuid ? "uuid" : "varchar");
-            const targetColType = isNumericId(targetCollection) ? "integer" : (getPrimaryKeyProp(targetCollection).isUuid ? "uuid" : "varchar");
+            // `text`, matching the string default: a junction column must have the
+            // same type as the primary key it references.
+            const sourceColType = isNumericId(sourceCollection) ? "integer" : (getPrimaryKeyProp(sourceCollection).isUuid ? "uuid" : "text");
+            const targetColType = isNumericId(targetCollection) ? "integer" : (getPrimaryKeyProp(targetCollection).isUuid ? "uuid" : "text");
             const sourceId = getPrimaryKeyName(sourceCollection);
             const targetId = getPrimaryKeyName(targetCollection);
 
@@ -637,7 +600,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
             // We should generate a basic id column if one was completely omitted.
             const hasIdColumn = Array.from(columns).some(col => col.includes(".primaryKey()"));
             if (!hasIdColumn) {
-                columns.add("    id: varchar(\"id\").primaryKey()");
+                columns.add("    id: text(\"id\").primaryKey()");
             }
 
             schemaContent += `${Array.from(columns).join(",\n")}`;
@@ -669,7 +632,7 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
 
         if (isJunction) {
             const relationInfo = Array.from(allTablesToGenerate.values()).find(v => v.isJunction && getTableName(v.collection) === tableName);
-            if (relationInfo && relationInfo.relation && relationInfo.sourceCollection && relationInfo.relation.through) {
+            if (relationInfo && relationInfo.relation && relationInfo.sourceCollection && isManyToMany(relationInfo.relation)) {
                 const {
                     relation,
                     sourceCollection
@@ -693,9 +656,9 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
                 try {
                     const targetRelations = resolveCollectionRelations(targetCollection);
                     for (const [, targetRel] of Object.entries(targetRelations)) {
-                        if (targetRel.direction === "inverse" &&
+                        if (targetRel.kind !== "belongsTo" &&
                             targetRel.cardinality === "many" &&
-                            targetRel.inverseRelationName === owningRelationName) {
+                            targetRel.relationName === owningRelationName) {
                             inverseRelationName = targetRel.relationName ?? null;
                             break;
                         }
@@ -740,54 +703,43 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
                     // Skip if we've already emitted a relation with this drizzleRelationName
                     // for this table — prevents duplicate definitions when
                     // resolveCollectionRelations returns alias entries for the same FK.
-                    const deduplicationKey = `${drizzleRelationName}::${rel.direction}`;
+                    const deduplicationKey = `${drizzleRelationName}::${rel.kind}`;
                     if (emittedRelationNames.has(deduplicationKey)) continue;
                     emittedRelationNames.add(deduplicationKey);
 
-                    if (rel.cardinality === "one") {
-                        if (rel.direction === "owning" && rel.localKey) {
+                    switch (rel.kind) {
+                        case "belongsTo":
                             tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        fields: [${tableVarName}.${rel.localKey}],\n        references: [${targetTableVar}.${getPrimaryKeyName(target)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
-                        } else if (rel.direction === "inverse") {
-                            // Inverse one-to-one: the FK lives on the TARGET table, not here.
-                            // Drizzle pairs inverse relations via `relationName` alone — specifying
-                            // `fields`/`references` on the inverse side is invalid and causes
-                            // `normalizeRelation` to crash with "Cannot read properties of
+                            break;
+
+                        case "hasOne":
+                            // The foreign key lives on the TARGET table. Drizzle pairs
+                            // the two sides by `relationName` alone — giving
+                            // `fields`/`references` here is invalid and crashes
+                            // `normalizeRelation` with "Cannot read properties of
                             // undefined (reading 'referencedTable')".
                             tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        relationName: \"${drizzleRelationName}\"\n    })`);
-                        }
-                    } else if (rel.cardinality === "many") {
-                        if (rel.direction === "inverse" && rel.foreignKeyOnTarget) {
-                            // One-to-many inverse relation
+                            break;
+
+                        case "hasMany":
                             tableRelations.push(`    "${relationKey}": many(${targetTableVar}, { relationName: \"${drizzleRelationName}\" })`);
-                        } else if (rel.through) {
-                            // Many-to-many owning relation with explicit junction table
+                            break;
+
+                        case "manyToMany": {
+                            // Both sides point at the junction. This used to have a
+                            // second arm that searched the *target's* relations for an
+                            // owning many-to-many whose name matched, to borrow its
+                            // junction table — unnecessary now that each side names
+                            // its own.
                             const junctionTableVar = getTableVarName(rel.through.table);
                             tableRelations.push(`    "${relationKey}": many(${junctionTableVar}, { relationName: \"${drizzleRelationName}\" })`);
-                        } else if (rel.direction === "inverse" && rel.inverseRelationName) {
-                            // Many-to-many inverse relation - find the corresponding owning relation's junction table
-                            try {
-                                const targetCollection = rel.target();
-                                const targetResolvedRelations = resolveCollectionRelations(targetCollection);
-
-                                // Find the corresponding owning many-to-many relation on the target
-                                const correspondingRelation = Object.values(targetResolvedRelations).find(targetRel =>
-                                    targetRel.direction === "owning" &&
-                                    targetRel.cardinality === "many" &&
-                                    targetRel.through &&
-                                    targetRel.relationName === rel.inverseRelationName
-                                );
-
-                                if (correspondingRelation && correspondingRelation.through) {
-                                    const junctionTableVar = getTableVarName(correspondingRelation.through.table);
-                                    tableRelations.push(`    "${relationKey}": many(${junctionTableVar}, { relationName: \"${drizzleRelationName}\" })`);
-                                } else {
-                                    logger.warn(`Could not find corresponding owning many-to-many relation for inverse relation '${relationKey}' on '${collection.name}'`);
-                                }
-                            } catch (e) {
-                                logger.warn(`Could not resolve inverse many-to-many relation '${relationKey}'`, { error: e });
-                            }
+                            break;
                         }
-                        // joinPath relations don't generate Drizzle relations - they use existing user tables
+
+                        case "via":
+                            // A join chain is resolved at query time, not modelled
+                            // as a Drizzle relation.
+                            break;
                     }
                 } catch (e) {
                     logger.warn(`Could not generate relation ${relationKey} for ${collection.name}`, { error: e });
@@ -800,12 +752,12 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
 
                 const otherRelations = resolveCollectionRelations(otherCollection);
                 for (const [otherKey, otherRel] of Object.entries(otherRelations)) {
-                    if (otherRel.direction === "inverse" && otherRel.foreignKeyOnTarget) {
+                    if (hasForeignKeyOnTarget(otherRel)) {
                         try {
                             const otherTarget = otherRel.target();
                             if (otherTarget.slug === collection.slug) {
                                 const drizzleRelationName = computeSharedRelationName(otherRel, otherCollection, collections);
-                                const deduplicationKey = `${drizzleRelationName}::owning`;
+                                const deduplicationKey = `${drizzleRelationName}::belongsTo`;
 
                                 if (!emittedRelationNames.has(deduplicationKey)) {
                                     const otherTableVar = getTableVarName(getTableName(otherCollection));

package/src/schema/generate-postgres-ddl-logic.ts

@@ -1,10 +1,10 @@
-import { CollectionConfig, NumberProperty, Property, Relation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollectionConfig, DateProperty, ArrayProperty, MapProperty, ReferenceProperty, VectorProperty, BinaryProperty } from "@rebasepro/types";
+import { CollectionConfig, NumberProperty, Property, ResolvedRelation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollectionConfig, DateProperty, ArrayProperty, MapProperty, ReferenceProperty, VectorProperty, BinaryProperty, isManyToMany, type ResolvedManyToMany, type ResolvedBelongsTo } from "@rebasepro/types";
 import { getEnumVarName, getTableName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, getInjectedSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig } from "@rebasepro/common";
 import { toSnakeCase, getPolicyNamesForRule } from "@rebasepro/utils";
 
 // --- Helper Functions ---
 
-const resolveColumnName = (propName: string, prop?: Property | null): string => {
+export const resolveColumnName = (propName: string, prop?: Property | null): string => {
     if (prop && "columnName" in prop && typeof prop.columnName === "string") {
         return prop.columnName;
     }
@@ -36,7 +36,7 @@ const getPrimaryKeyName = (collection: CollectionConfig): string => {
     return getPrimaryKeyProp(collection).name;
 };
 
-const isIdProperty = (propName: string, prop: Property, collection: CollectionConfig): boolean => {
+export const isIdProperty = (propName: string, prop: Property, collection: CollectionConfig): boolean => {
     if ("isId" in prop && Boolean(prop.isId)) return true;
     const hasExplicitId = Object.values(collection.properties ?? {}).some(p => "isId" in (p as unknown as object) && Boolean((p as unknown as Record<string, unknown>).isId));
     return !hasExplicitId && propName === "id";
@@ -90,7 +90,7 @@ const generateSinglePolicyDdl = (collection: CollectionConfig, rule: SecurityRul
     return `${ddl};\n`;
 };
 
-const getSqlColumnType = (propName: string, prop: Property, collection: CollectionConfig, collections: CollectionConfig[]): string => {
+export const getSqlColumnType = (propName: string, prop: Property, collection: CollectionConfig, collections: CollectionConfig[]): string => {
     switch (prop.type) {
         case "string": {
             const stringProp = prop as StringProperty;
@@ -103,13 +103,18 @@ const getSqlColumnType = (propName: string, prop: Property, collection: Collecti
             if (stringProp.isId === "uuid" || stringProp.columnType === "uuid") {
                 return "UUID";
             }
-            if (stringProp.columnType === "text" || stringProp.ui?.markdown || stringProp.ui?.multiline) {
-                return "TEXT";
-            }
             if (stringProp.columnType === "char") {
                 return "CHAR(255)";
             }
-            return "VARCHAR(255)";
+            if (stringProp.columnType === "varchar") {
+                return "VARCHAR(255)";
+            }
+            // `text` is the default. The two generators disagreed here before:
+            // this one emitted VARCHAR(255) while the drizzle path emitted a bare
+            // `varchar()`, which Postgres treats as unbounded — so the same
+            // property produced a capped column down one path and an uncapped one
+            // down the other.
+            return "TEXT";
         }
         case "number": {
             const numProp = prop as NumberProperty;
@@ -165,28 +170,28 @@ const getSqlColumnType = (propName: string, prop: Property, collection: Collecti
         case "relation": {
             const refProp = prop as RelationProperty;
             const resolvedRelations = resolveCollectionRelations(collection);
-            const relation = findRelation(resolvedRelations, refProp.relationName ?? propName);
-            if (!relation || relation.direction !== "owning" || relation.cardinality !== "one") {
-                throw new Error(`Relation ${propName} is not an owning one-to-one/many-to-one relation`);
+            const relation = findRelation(resolvedRelations, refProp.relation?.relationName ?? propName);
+            if (relation?.kind !== "belongsTo") {
+                throw new Error(`Relation ${propName} does not put a column on this table (only \`belongsTo\` does)`);
             }
             let targetCollection: CollectionConfig;
             try {
                 targetCollection = relation.target();
             } catch {
-                return "VARCHAR(255)";
+                return "TEXT";
             }
             const pkProp = getPrimaryKeyProp(targetCollection);
-            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "VARCHAR(255)");
+            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "TEXT");
         }
         case "reference": {
             const refProp = prop as ReferenceProperty;
             const targetCollection = collections.find(c => c.slug === refProp.path || getTableName(c) === refProp.path);
-            if (!targetCollection) return "VARCHAR(255)";
+            if (!targetCollection) return "TEXT";
             const pkProp = getPrimaryKeyProp(targetCollection);
-            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "VARCHAR(255)");
+            return pkProp.type === "number" ? "INTEGER" : (pkProp.isUuid ? "UUID" : "TEXT");
         }
         default:
-            return "VARCHAR(255)";
+            return "TEXT";
     }
 };
 
@@ -233,7 +238,7 @@ export const generatePostgresDdl = async (
     const allTablesToGenerate = new Map<string, {
         collection: CollectionConfig,
         isJunction?: boolean,
-        relation?: Relation,
+        relation?: ResolvedRelation,
         sourceCollection?: CollectionConfig
     }>();
 
@@ -246,7 +251,7 @@ export const generatePostgresDdl = async (
 
         const resolvedRelations = resolveCollectionRelations(collection);
         for (const relation of Object.values(resolvedRelations)) {
-            if (relation.through) {
+            if (isManyToMany(relation)) {
                 const junctionTableName = relation.through.table;
                 if (!allTablesToGenerate.has(junctionTableName)) {
                     allTablesToGenerate.set(junctionTableName, {
@@ -279,7 +284,7 @@ export const generatePostgresDdl = async (
         const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
         const baseTableName = tableName.includes(".") ? tableName.split(".").pop()! : tableName;
 
-        if (isJunction && relation && sourceCollection && relation.through) {
+        if (isJunction && relation && sourceCollection && isManyToMany(relation)) {
             const targetCollection = relation.target();
             const sourceTable = getTableName(sourceCollection);
             const targetTable = getTableName(targetCollection);
@@ -287,8 +292,10 @@ export const generatePostgresDdl = async (
             const targetSchema = isPostgresCollectionConfig(targetCollection) && targetCollection.schema ? targetCollection.schema : "public";
             const { sourceColumn, targetColumn } = relation.through;
 
-            const sourceColType = isNumericId(sourceCollection) ? "INTEGER" : (getPrimaryKeyProp(sourceCollection).isUuid ? "UUID" : "VARCHAR(255)");
-            const targetColType = isNumericId(targetCollection) ? "INTEGER" : (getPrimaryKeyProp(targetCollection).isUuid ? "UUID" : "VARCHAR(255)");
+            // TEXT, matching the string default: a junction column has to have the
+            // same type as the primary key it references.
+            const sourceColType = isNumericId(sourceCollection) ? "INTEGER" : (getPrimaryKeyProp(sourceCollection).isUuid ? "UUID" : "TEXT");
+            const targetColType = isNumericId(targetCollection) ? "INTEGER" : (getPrimaryKeyProp(targetCollection).isUuid ? "UUID" : "TEXT");
             const sourceId = getPrimaryKeyName(sourceCollection);
             const targetId = getPrimaryKeyName(targetCollection);
 
@@ -329,9 +336,9 @@ export const generatePostgresDdl = async (
                 if (prop.type === "relation") {
                     const refProp = prop as RelationProperty;
                     const resolvedRelations = resolveCollectionRelations(collection);
-                    const relInfo = findRelation(resolvedRelations, refProp.relationName ?? propName);
+                    const relInfo = findRelation(resolvedRelations, refProp.relation?.relationName ?? propName);
 
-                    if (!relInfo || relInfo.direction !== "owning" || relInfo.cardinality !== "one" || !relInfo.localKey) {
+                    if (relInfo?.kind !== "belongsTo") {
                         return;
                     }
 
@@ -424,7 +431,7 @@ export const generatePostgresDdl = async (
             // Backwards compatibility: add default id primary key if missing
             const hasPk = columns.some(c => c.includes("PRIMARY KEY"));
             if (!hasPk) {
-                columns.unshift('  "id" VARCHAR(255) PRIMARY KEY');
+                columns.unshift('  "id" TEXT PRIMARY KEY');
             }
 
             ddl += columns.join(",\n");

package/src/schema/introspect-db-inference.ts

@@ -51,10 +51,11 @@ export function inferPropertyFromData(
             }
         }
 
-        // Currency
-        if (colNameLower.includes("price") || colNameLower.includes("cost") || colNameLower.includes("amount") || colNameLower.includes("fee") || pgDataType === "money") {
-            extraLines.push("            ui: {\n                currency: true\n            }");
-        }
+        // No currency heuristic. `admin.currency` was never a declared option and
+        // nothing reads it, so a column called `price` got a block of config that did
+        // nothing — invisible because this generator emits *source text*, which no
+        // typechecker ever saw. Reinstate it by adding `currency` to
+        // AdminNumberOptions first, and something that renders it.
     }
 
     // ── JSON / JSONB Analysis ────────────────────────────────────────────
@@ -169,11 +170,10 @@ export function inferPropertyFromData(
             if (isPk) extraLines.push("            isId: \"cuid\"");
         }
 
-        // Color Codes
-        const allColors = validValues.every(v => typeof v === "string" && COLOR_HEX_REGEX.test(v));
-        if (allColors) {
-            extraLines.push("            ui: {\n                color: true\n            }");
-        }
+        // No colour heuristic. `admin.color` was never a declared option and nothing
+        // reads it — the same dead branch `currency` was. This generator emits *source
+        // text*, so no typechecker ever saw either. Reinstate by adding the option and
+        // something that renders it first.
 
         // Text Lengths, Multiline & Markdown
         let maxLength = 0;
@@ -212,9 +212,9 @@ export function inferPropertyFromData(
         if (allAbsoluteUrls) {
             const isImage = validValues.some(v => typeof v === "string" && v.match(/\.(jpeg|jpg|gif|png|webp|svg)/i));
             if (isImage || isMedia) {
-                extraLines.push("            ui: {\n                url: \"image\"\n            }");
+                extraLines.push("            url: true,\n            admin: {\n                urlPreview: \"image\"\n            }");
             } else {
-                extraLines.push("            ui: {\n                url: true\n            }");
+                extraLines.push("            url: true");
             }
         } else {
             const hasFileExtension = validValues.some(v => typeof v === "string" && v.match(/\.[a-zA-Z0-9]+$/));
@@ -225,9 +225,9 @@ export function inferPropertyFromData(
                 extraLines.push(`            storage: {\n                storagePath: "${inferredStoragePath}"\n            }`);
             } else if (isUrl) {
                 if (isMedia) {
-                    extraLines.push("            ui: {\n                url: \"image\"\n            }");
+                    extraLines.push("            url: true,\n            admin: {\n                urlPreview: \"image\"\n            }");
                 } else {
-                    extraLines.push("            ui: {\n                url: true\n            }");
+                    extraLines.push("            url: true");
                 }
             }
         }