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

package/src/data-transformer.ts

@@ -1,7 +1,7 @@
 import { eq, SQL } from "drizzle-orm";
 import { AnyPgColumn } from "drizzle-orm/pg-core";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { CollectionConfig, Properties, Property, Relation, RelationProperty, Vector, BinaryProperty } from "@rebasepro/types";
+import { CollectionConfig, Properties, Property, ResolvedRelation, RelationProperty, Vector, BinaryProperty, hasForeignKeyOnTarget, type ResolvedBelongsTo, type ResolvedForeignKeyOnTarget, type ResolvedVia } from "@rebasepro/types";
 import { getTableName, resolveCollectionRelations, findRelation, createRelationRef, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "@rebasepro/common";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { DrizzleConditionBuilder } from "./utils/drizzle-conditions";
@@ -31,13 +31,13 @@ export interface SerializedEntityData {
      */
     inverseRelationUpdates: Array<{
         relationKey: string;
-        relation: Relation;
+        relation: ResolvedRelation;
         newValue: unknown;
     }>;
     /** JoinPath relation updates that require multi-hop writes. */
     joinPathRelationUpdates: Array<{
         relationKey: string;
-        relation: Relation;
+        relation: ResolvedVia;
         newTargetId: string | number | null;
     }>;
 }
@@ -110,19 +110,19 @@ joinPathRelationUpdates: [] };
     // Track inverse relations that need to be handled separately
     const inverseRelationUpdates: Array<{
         relationKey: string;
-        relation: Relation;
+        relation: ResolvedRelation;
         newValue: unknown;
     }> = [];
     const joinPathRelationUpdates: Array<{
         relationKey: string;
-        relation: Relation;
+        relation: ResolvedVia;
         newTargetId: string | number | null;
     }> = [];
 
     // Pre-calculate all local keys used as foreign keys
     const foreignKeys = new Set<string>();
     Object.values(resolvedRelations).forEach(relation => {
-        if (relation.localKey) foreignKeys.add(relation.localKey);
+        if (relation.kind === "belongsTo") foreignKeys.add(relation.localKey);
     });
 
     for (const [key, value] of Object.entries(row)) {
@@ -141,7 +141,7 @@ joinPathRelationUpdates: [] };
         if (property.type === "relation" && collection) {
             const relation = findRelation(resolvedRelations, key);
             if (relation) {
-                if (relation.direction === "owning" && relation.localKey) {
+                if (relation.kind === "belongsTo") {
                     // Owning relation: Map relation object to FK column on current table
                     const serializedValue = serializePropertyToServer(effectiveValue, property);
                     if (serializedValue !== undefined) {
@@ -149,7 +149,7 @@ joinPathRelationUpdates: [] };
                     }
                     // Don't add the original relation property to the result
                     continue;
-                } else if (relation.direction === "inverse" && relation.foreignKeyOnTarget) {
+                } else if (hasForeignKeyOnTarget(relation)) {
                     // Inverse relation: Need to update the target table's FK
                     const serializedValue = serializePropertyToServer(effectiveValue, property);
                     inverseRelationUpdates.push({
@@ -159,38 +159,29 @@ joinPathRelationUpdates: [] };
                     });
                     // Don't add the original relation property to the result
                     continue;
-                } else if (relation.direction === "inverse" && relation.joinPath && relation.joinPath.length > 0) {
+                } else if (relation.kind === "via") {
+                    // A join chain is written through its own machinery, one
+                    // row at a time for a to-one and as a set for a to-many.
+                    // There used to be two arms here — "owning" and "inverse"
+                    // joinPath — but a join chain has no owning side, so they
+                    // only ever differed by which list they pushed to.
                     const serializedValue = serializePropertyToServer(effectiveValue, property);
                     if (relation.cardinality === "one") {
-                        // One-to-one inverse joinPath: route through joinPathRelationUpdates.
-                        // The write ordering in PersistService ensures these are processed
-                        // BEFORE the main UPDATE, so parentSourceCol reads the pre-update FK value.
-                        // This prevents stale values from corrupting related rows when an
-                        // intermediate FK (e.g. author_id) changes in the same save.
+                        // Ordering matters: PersistService applies these BEFORE
+                        // the main UPDATE, so the mapping reads the pre-update
+                        // foreign key rather than a value the same save changed.
                         joinPathRelationUpdates.push({
                             relationKey: key,
                             relation,
                             newTargetId: serializedValue as string | number | null
                         });
                     } else {
-                        // Many inverse joinPath: capture as inverse relation update
                         inverseRelationUpdates.push({
                             relationKey: key,
                             relation,
                             newValue: serializedValue
                         });
                     }
-                    // Don't add the original relation property to the result
-                    continue;
-                } else if (relation.cardinality === "one" && relation.direction === "owning" && relation.joinPath && relation.joinPath.length > 0) {
-                    // Owning one-to-one via joinPath: capture as a write intent
-                    const serializedValue = serializePropertyToServer(effectiveValue, property);
-                    joinPathRelationUpdates.push({
-                        relationKey: key,
-                        relation,
-                        newTargetId: serializedValue as string | number | null
-                    });
-                    // Don't include this property directly in payload
                     continue;
                 }
             }
@@ -320,7 +311,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
             // Find the normalized relation for this property
             const relation = findRelation(resolvedRelations, propKey);
             if (relation) {
-                if (relation.direction === "owning" && relation.localKey && relation.localKey in data) {
+                if (relation.kind === "belongsTo" && relation.localKey in data) {
                     // Owning relation: FK is in current table
                     const fkValue = data[relation.localKey as keyof M];
                     if (fkValue !== null && fkValue !== undefined) {
@@ -331,7 +322,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             logger.warn(`Could not resolve target collection for relation property: ${propKey}`, { error: e });
                         }
                     }
-                } else if (relation.direction === "inverse" && relation.foreignKeyOnTarget && db && registry) {
+                } else if (hasForeignKeyOnTarget(relation) && db && registry) {
                     // Inverse relation: FK is in target table, need to query for it
                     try {
                         const targetCollection = relation.target();
@@ -368,7 +359,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                     } catch (e) {
                         logger.warn(`Could not resolve inverse relation property: ${propKey}`, { error: e });
                     }
-                } else if (relation.direction === "inverse" && relation.joinPath && db && registry) {
+                } else if (relation.kind === "via" && db && registry) {
                     // Join path relation: Multi-hop relation using joins
                     try {
                         const targetCollection = relation.target();
@@ -547,17 +538,16 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
         case "relation":
             // Transform ID back to relation object with type information
             if (typeof value === "string" || typeof value === "number") {
-                let relationDef: Relation | undefined = (property as RelationProperty).relation;
+                // Normalization stamps the resolved relation onto the property;
+                // fall back to the collection's map for a property that never
+                // went through the registry.
+                let relationDef: ResolvedRelation | undefined = (property as RelationProperty).resolvedRelation;
                 if (!relationDef && propertyKey) {
-                    const resolvedRelations = resolveCollectionRelations(collection);
-                    relationDef = findRelation(resolvedRelations, propertyKey);
-                }
-                if (!relationDef) {
-                    relationDef = collection.relations?.find((rel: Relation) => rel.relationName === (property as RelationProperty).relationName);
+                    relationDef = findRelation(resolveCollectionRelations(collection), propertyKey);
                 }
 
                 if (!relationDef) {
-                    logger.warn(`Relation not defined in property for key: ${propertyKey || "unknown"}`);
+                    logger.warn(`ResolvedRelation not defined in property for key: ${propertyKey || "unknown"}`);
                     return value;
                 }
 
@@ -683,7 +673,7 @@ function normalizeScalarValues<M extends Record<string, unknown>>(
     data: M,
     properties: Properties,
     collection: CollectionConfig,
-    resolvedRelations: Record<string, Relation>,
+    resolvedRelations: Record<string, ResolvedRelation>,
     options: { skipRelations: boolean }
 ): Record<string, unknown> {
     const result: Record<string, unknown> = {};
@@ -691,7 +681,7 @@ function normalizeScalarValues<M extends Record<string, unknown>>(
     // Identify FK columns used only for relations and not exposed as properties
     const internalFKColumns = new Set<string>();
     Object.values(resolvedRelations).forEach(relation => {
-        if (relation.localKey && !properties[relation.localKey]) {
+        if (relation.kind === "belongsTo" && !properties[relation.localKey]) {
             internalFKColumns.add(relation.localKey);
         }
     });

package/src/schema/doctor.ts

@@ -12,7 +12,7 @@ import * as fs from "fs";
 import path from "path";
 import { pathToFileURL } from "url";
 import chalk from "chalk";
-import { CollectionConfig, isPostgresCollectionConfig, Property, NumberProperty, StringProperty, DateProperty, ArrayProperty, MapProperty, RelationProperty } from "@rebasepro/types";
+import { CollectionConfig, isPostgresCollectionConfig, Property, NumberProperty, StringProperty, DateProperty, ArrayProperty, MapProperty, RelationProperty, type ResolvedManyToMany, type ResolvedBelongsTo, isManyToMany } from "@rebasepro/types";
 import { generateSchema } from "./generate-drizzle-schema-logic";
 import { generateTypedefs } from "@rebasepro/codegen";
 import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
@@ -62,12 +62,10 @@ export function getExpectedColumnType(prop: Property): string | null {
             if (sp.enum) return "USER-DEFINED"; // pgEnum → USER-DEFINED in information_schema
             if ("isId" in sp && sp.isId === "uuid") return "uuid";
             if (sp.columnType === "uuid") return "uuid";
-            // A markdown/multiline string compiles to `text`, not varchar — the
-            // generator treats those UI hints as column-type signals, so the
-            // expectation here must too or every such column reads as drift.
-            if (sp.columnType === "text" || sp.ui?.markdown || sp.ui?.multiline) return "text";
             if (sp.columnType === "char") return "character";
-            return "character varying";
+            if (sp.columnType === "varchar") return "character varying";
+            // `text` is the default — see generate-postgres-ddl-logic.
+            return "text";
         }
         case "number": {
             const np = prop as NumberProperty;
@@ -122,7 +120,9 @@ export function getExpectedColumnType(prop: Property): string | null {
         case "relation":
             return null; // FK columns are derived from the relation, not from the property
         case "reference":
-            return "character varying"; // References default to varchar FK
+            // A reference FK follows the key it points at, and a string key is
+            // `text` — see generate-postgres-ddl-logic.
+            return "text";
         case "vector":
             return "USER-DEFINED";
         case "binary":
@@ -387,7 +387,7 @@ export async function checkCollectionsVsDatabase(
 
         for (const collection of postgresCollections) {
             const tableName = getTableName(collection);
-            const schemaName = collection.schema || "public";
+            const schemaName = (collection as { schema?: string }).schema || "public";
             const fullTableName = schemaName === "public" ? tableName : `${schemaName}.${tableName}`;
 
             // Check table existence
@@ -411,10 +411,10 @@ export async function checkCollectionsVsDatabase(
             // Check properties → columns
             for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
                 if (prop.type === "relation") {
-                    // Relation columns are derived from localKey
+                    // ResolvedRelation columns are derived from localKey
                     const resolvedRelations = resolveCollectionRelations(collection);
-                    const relation = findRelation(resolvedRelations, (prop as RelationProperty).relationName ?? propName);
-                    if (relation?.direction === "owning" && relation.cardinality === "one" && relation.localKey) {
+                    const relation = findRelation(resolvedRelations, (prop as RelationProperty).relation?.relationName ?? propName);
+                    if (relation?.kind === "belongsTo") {
                         const fkColName = relation.localKey;
                         if (!dbColumnMap.has(fkColName)) {
                             issues.push({
@@ -434,7 +434,7 @@ export async function checkCollectionsVsDatabase(
                         try {
                             const targetColl = relation.target();
                             targetTableName = getTableName(targetColl);
-                            targetSchemaName = targetColl.schema || "public";
+                            targetSchemaName = (targetColl as { schema?: string }).schema || "public";
                         } catch { /* ignore */ }
 
                         const hasFk = tableFks.some((fk) =>
@@ -568,9 +568,9 @@ export async function checkCollectionsVsDatabase(
             // Also check junction tables for many-to-many relations
             const resolvedRelations = resolveCollectionRelations(collection);
             for (const relation of Object.values(resolvedRelations)) {
-                if (relation.cardinality === "many" && relation.direction === "owning" && relation.through) {
+                if (isManyToMany(relation)) {
                     const junctionTable = relation.through.table;
-                    const junctionSchema = collection.schema || "public";
+                    const junctionSchema = (collection as { schema?: string }).schema || "public";
                     const fullJunctionTable = junctionSchema === "public" ? junctionTable : `${junctionSchema}.${junctionTable}`;
                     if (!existingTables.has(fullJunctionTable)) {
                         issues.push({

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));