@rebasepro/server-postgres 0.10.1-canary.ed8caed → 0.10.1-canary.g4db1bb1

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";
@@ -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";
@@ -224,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;
             }
 
@@ -402,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);
@@ -431,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;
 };
 
@@ -521,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
     }>();
 
@@ -560,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, {
@@ -586,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";
@@ -673,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
@@ -697,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;
                         }
@@ -744,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 });
@@ -804,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,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 } from "@rebasepro/types";
 import { getEnumVarName, getTableName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, getInjectedSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig } from "@rebasepro/common";
 import { toSnakeCase, getPolicyNamesForRule } from "@rebasepro/utils";
 
@@ -170,9 +170,9 @@ export const getSqlColumnType = (propName: string, prop: Property, collection: C
         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 {
@@ -238,7 +238,7 @@ export const generatePostgresDdl = async (
     const allTablesToGenerate = new Map<string, {
         collection: CollectionConfig,
         isJunction?: boolean,
-        relation?: Relation,
+        relation?: ResolvedRelation,
         sourceCollection?: CollectionConfig
     }>();
 
@@ -251,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, {
@@ -284,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);
@@ -336,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;
                     }
 

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

@@ -700,11 +700,12 @@ export function generateCollectionFile(
         ${relName}: {
             name: "${relHumanName}",
             type: "relation",
-            target: () => ${targetCollectionCamel},
-            cardinality: "one",
-            direction: "owning",
-            localKey: "${fk.column_name}",
             // mapped from foreign key: ${fk.column_name} -> ${targetTableName}(${fk.foreign_column_name})
+            relation: {
+                kind: "belongsTo",
+                target: () => ${targetCollectionCamel},
+                localKey: "${fk.column_name}"
+            }
         },`);
         }
     }
@@ -718,15 +719,12 @@ export function generateCollectionFile(
         const targetCollectionCamel = toCollectionVarName(sourceTableName);
         imports.add(`import ${targetCollectionCamel} from "./${sourceTableName}";`);
 
-        const inverseRelName = fk.column_name.replace(/_id$/, "");
-
         relationsOutput += `
         {
+            kind: "hasMany",
             relationName: "${sourceTableName}",
             target: () => ${targetCollectionCamel},
-            cardinality: "many",
-            direction: "inverse",
-            inverseRelationName: "${inverseRelName}",
+            // the ${sourceTableName}.${fk.column_name} FK points back here
             foreignKeyOnTarget: "${fk.column_name}"
         },`;
     }
@@ -755,10 +753,9 @@ export function generateCollectionFile(
 
             relationsOutput += `
         {
+            kind: "manyToMany",
             relationName: "${relPropName}",
             target: () => ${tableName}Collection,
-            cardinality: "many",
-            direction: "owning",
             through: {
                 table: "${jt}",
                 sourceColumn: "${thisFk.column_name}",
@@ -776,24 +773,23 @@ export function generateCollectionFile(
             const targetCollectionCamel = toCollectionVarName(targetTableName);
             imports.add(`import ${targetCollectionCamel} from "./${targetTableName}";`);
 
-            // Determine direction (alphabetically first table is owning)
-            const direction = tableName < targetTableName ? "owning" : "inverse";
-
+            // Both sides of a many-to-many are `manyToMany`. There is no owning
+            // and inverse side to pick between any more, so this no longer
+            // guesses one from table-name ordering and no longer emits a
+            // half-configured relation on the losing side with a comment asking
+            // the reader to finish it by hand. Introspection already knows both
+            // junction columns; each side just names them from its own end.
             const thisFk = joinFks.find((fk) => fk.foreign_table_name === tableName);
 
-            let throughCode = "";
-            if (direction === "owning" && thisFk) {
-                throughCode = `\n            through: {\n                table: "${jt}",\n                sourceColumn: "${thisFk.column_name}",\n                targetColumn: "${otherFk.column_name}"\n            },`;
-            } else if (direction === "inverse") {
-                throughCode = "\n            // Make sure the target collection configures the 'through' property.";
-            }
+            const throughCode = thisFk
+                ? `\n            through: {\n                table: "${jt}",\n                sourceColumn: "${thisFk.column_name}",\n                targetColumn: "${otherFk.column_name}"\n            }`
+                : "";
 
             relationsOutput += `
         {
+            kind: "manyToMany",
             relationName: "${targetTableName}",
-            target: () => ${targetCollectionCamel},
-            cardinality: "many",
-            direction: "${direction}",${throughCode}
+            target: () => ${targetCollectionCamel},${throughCode}
         },`;
         }
     }