@rebasepro/server-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/test/relations.test.ts

@@ -212,9 +212,9 @@ describe("Comprehensive Relations Test Suite", () => {
 
     const cleanSchema = (schema: string) => {
         return schema
-            .replace(/\/\/.*$/gm, '')
-            .replace(/\/\*[\s\S]*?\*\//g, '')
-            .replace(/\n{2,}/g, '\n')
+            .replace(/\/\/.*$/gm, "")
+            .replace(/\/\*[\s\S]*?\*\//g, "")
+            .replace(/\n{2,}/g, "\n")
             .replace(/\s+/g, " ")
             .trim();
     };
@@ -227,7 +227,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "Authors",
                 properties: {
                     name: { type: "string" },
-                    books: { type: "relation", relationName: "books" }
+                    books: { type: "relation",
+relationName: "books" }
                 },
                 relations: [
                     {
@@ -257,10 +258,10 @@ describe("Comprehensive Relations Test Suite", () => {
             const cleanResult = cleanSchema(result);
 
             // Should create junction table
-            expect(cleanResult).toContain(`export const authorBooks = pgTable("author_books"`);
-            expect(cleanResult).toContain(`author_id: varchar("author_id").notNull().references(() => authors.id, { onDelete: "cascade" })`);
-            expect(cleanResult).toContain(`book_id: varchar("book_id").notNull().references(() => books.id, { onDelete: "cascade" })`);
-            expect(cleanResult).toContain(`export const authorsRelations = drizzleRelations(authors, ({ one, many }) => ({ books: many(authorBooks, { relationName: "books" }) }));`);
+            expect(cleanResult).toContain("export const authorBooks = pgTable(\"author_books\"");
+            expect(cleanResult).toContain("author_id: varchar(\"author_id\").notNull().references(() => authors.id, { onDelete: \"cascade\" })");
+            expect(cleanResult).toContain("book_id: varchar(\"book_id\").notNull().references(() => books.id, { onDelete: \"cascade\" })");
+            expect(cleanResult).toContain("export const authorsRelations = drizzleRelations(authors, ({ one, many }) => ({ \"books\": many(authorBooks, { relationName: \"books\" }) }));");
         });
 
         it("should handle a 4-table many-to-many chain with joinPath", async () => {
@@ -270,7 +271,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "Users",
                 properties: {
                     name: { type: "string" },
-                    permissions: { type: "relation", relationName: "permissions" }
+                    permissions: { type: "relation",
+relationName: "permissions" }
                 },
                 relations: [
                     {
@@ -278,10 +280,18 @@ describe("Comprehensive Relations Test Suite", () => {
                         target: () => permissionsCollection,
                         cardinality: "many",
                         joinPath: [
-                            { table: "user_roles", on: { from: "id", to: "user_id" } },
-                            { table: "roles", on: { from: "role_id", to: "id" } },
-                            { table: "role_permissions", on: { from: "id", to: "role_id" } },
-                            { table: "permissions", on: { from: "permission_id", to: "id" } }
+                            { table: "user_roles",
+on: { from: "id",
+to: "user_id" } },
+                            { table: "roles",
+on: { from: "role_id",
+to: "id" } },
+                            { table: "role_permissions",
+on: { from: "id",
+to: "role_id" } },
+                            { table: "permissions",
+on: { from: "permission_id",
+to: "id" } }
                         ]
                     }
                 ]
@@ -330,7 +340,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "Authors",
                 properties: {
                     name: { type: "string" },
-                    profile: { type: "relation", relationName: "profile" }
+                    profile: { type: "relation",
+relationName: "profile" }
                 },
                 relations: [
                     {
@@ -349,7 +360,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "Profiles",
                 properties: {
                     bio: { type: "string" },
-                    author: { type: "relation", relationName: "author" }
+                    author: { type: "relation",
+relationName: "author" }
                 },
                 relations: [
                     {
@@ -365,13 +377,13 @@ describe("Comprehensive Relations Test Suite", () => {
             const cleanResult = cleanSchema(result);
 
             // Should create FK on profiles table
-            expect(cleanResult).toContain(`author_id: varchar("author_id").references(() => authors.id, { onDelete: "set null" })`);
+            expect(cleanResult).toContain("author_id: varchar(\"author_id\").references(() => authors.id, { onDelete: \"set null\" })");
 
             // Should create owning relation on profiles
-            expect(cleanResult).toContain(`export const profilesRelations = drizzleRelations(profiles, ({ one, many }) => ({ author: one(authors, { fields: [profiles.author_id], references: [authors.id], relationName: "author" }) }));`);
+            expect(cleanResult).toContain("export const profilesRelations = drizzleRelations(profiles, ({ one, many }) => ({ \"author\": one(authors, { fields: [profiles.author_id], references: [authors.id], relationName: \"profiles_author_id\" }) }));");
 
             // Should create inverse relation on authors (this was previously missing)
-            expect(cleanResult).toContain(`export const authorsRelations = drizzleRelations(authors, ({ one, many }) => ({ profile: one(profiles, { fields: [authors.id], references: [profiles.author_id], relationName: "profile" }) }));`);
+            expect(cleanResult).toContain("export const authorsRelations = drizzleRelations(authors, ({ one, many }) => ({ \"profile\": one(profiles, { fields: [authors.id], references: [profiles.author_id], relationName: \"profiles_author_id\" }) }));");
         });
 
         it("should generate owning one-to-many relations", async () => {
@@ -380,7 +392,7 @@ describe("Comprehensive Relations Test Suite", () => {
                 table: "categories",
                 name: "Categories",
                 properties: {
-                    name: { type: "string" },
+                    name: { type: "string" }
                 }
             };
 
@@ -390,7 +402,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "Posts",
                 properties: {
                     title: { type: "string" },
-                    category: { type: "relation", relationName: "category" }
+                    category: { type: "relation",
+relationName: "category" }
                 },
                 relations: [
                     {
@@ -406,9 +419,9 @@ describe("Comprehensive Relations Test Suite", () => {
             const cleanResult = cleanSchema(result);
 
             // Should create FK on posts table
-            expect(cleanResult).toContain(`category_id: varchar("category_id").references(() => categories.id, { onDelete: "set null" })`);
+            expect(cleanResult).toContain("category_id: varchar(\"category_id\").references(() => categories.id, { onDelete: \"set null\" })");
             // Should create owning relation on posts
-            expect(cleanResult).toContain(`export const postsRelations = drizzleRelations(posts, ({ one, many }) => ({ category: one(categories, { fields: [posts.category_id], references: [categories.id], relationName: "category" }) }));`);
+            expect(cleanResult).toContain("export const postsRelations = drizzleRelations(posts, ({ one, many }) => ({ \"category\": one(categories, { fields: [posts.category_id], references: [categories.id], relationName: \"posts_category_id\" }) }));");
         });
     });
 
@@ -420,7 +433,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "Authors",
                 properties: {
                     name: { type: "string" },
-                    publisher: { type: "relation", relationName: "publisher" },
+                    publisher: { type: "relation",
+relationName: "publisher" }
                 },
                 relations: [
                     {
@@ -447,7 +461,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "Books",
                 properties: {
                     title: { type: "string" },
-                    author: { type: "relation", relationName: "author" }
+                    author: { type: "relation",
+relationName: "author" }
                 },
                 relations: [{
                     relationName: "author",
@@ -461,12 +476,12 @@ describe("Comprehensive Relations Test Suite", () => {
             const cleanResult = cleanSchema(result);
 
             // Check owning relation from author to publisher
-            expect(cleanResult).toContain(`publisher_id: varchar("publisher_id").references(() => publishers.id, { onDelete: "set null" })`);
-            expect(cleanResult).toContain(`publisher: one(publishers, { fields: [authors.publisher_id], references: [publishers.id], relationName: "publisher" })`);
+            expect(cleanResult).toContain("publisher_id: varchar(\"publisher_id\").references(() => publishers.id, { onDelete: \"set null\" })");
+            expect(cleanResult).toContain("\"publisher\": one(publishers, { fields: [authors.publisher_id], references: [publishers.id], relationName: \"authors_publisher_id\" })");
 
             // Check owning relation from book to author
-            expect(cleanResult).toContain(`author_id: varchar("author_id").references(() => authors.id, { onDelete: "set null" })`);
-            expect(cleanResult).toContain(`author: one(authors, { fields: [books.author_id], references: [authors.id], relationName: "author" })`);
+            expect(cleanResult).toContain("author_id: varchar(\"author_id\").references(() => authors.id, { onDelete: \"set null\" })");
+            expect(cleanResult).toContain("\"author\": one(authors, { fields: [books.author_id], references: [authors.id], relationName: \"books_author_id\" })");
         });
     });
 
@@ -478,8 +493,10 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "Orders",
                 properties: {
                     customer_code: { type: "string" },
-                    region_id: { type: "number", validation: { integer: true } },
-                    customer: { type: "relation", relationName: "customer" }
+                    region_id: { type: "number",
+validation: { integer: true } },
+                    customer: { type: "relation",
+relationName: "customer" }
                 },
                 relations: [
                     {
@@ -487,7 +504,9 @@ describe("Comprehensive Relations Test Suite", () => {
                         target: () => customersCollection,
                         cardinality: "many",
                         joinPath: [
-                            { table: "customers", on: { from: ["customer_code", "region_id"], to: ["code", "region_id"] } }
+                            { table: "customers",
+on: { from: ["customer_code", "region_id"],
+to: ["code", "region_id"] } }
                         ]
                     }
                 ]
@@ -499,7 +518,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "Customers",
                 properties: {
                     code: { type: "string" },
-                    region_id: { type: "number", validation: { integer: true } },
+                    region_id: { type: "number",
+validation: { integer: true } },
                     name: { type: "string" }
                 }
             };
@@ -537,7 +557,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "Users",
                 properties: {
                     name: { type: "string" },
-                    friends: { type: "relation", relationName: "friends" }
+                    friends: { type: "relation",
+relationName: "friends" }
                 },
                 relations: [
                     {
@@ -569,9 +590,11 @@ describe("Comprehensive Relations Test Suite", () => {
                 table: "products",
                 name: "Products",
                 properties: {
-                    sku: { type: "string", isId: true },
+                    sku: { type: "string",
+isId: true },
                     name: { type: "string" },
-                    categories: { type: "relation", relationName: "categories" }
+                    categories: { type: "relation",
+relationName: "categories" }
                 },
                 relations: [
                     {
@@ -614,7 +637,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "A Entities",
                 properties: {
                     name: { type: "string" },
-                    b_entities: { type: "relation", relationName: "b_entities" }
+                    b_entities: { type: "relation",
+relationName: "b_entities" }
                 },
                 relations: [
                     {
@@ -633,7 +657,8 @@ describe("Comprehensive Relations Test Suite", () => {
                 name: "B Entities",
                 properties: {
                     name: { type: "string" },
-                    a_entity: { type: "relation", relationName: "a_entity" }
+                    a_entity: { type: "relation",
+relationName: "a_entity" }
                 },
                 relations: [
                     {
@@ -655,8 +680,436 @@ describe("Comprehensive Relations Test Suite", () => {
             expect(cleanResult).toContain("export const bEntities = pgTable(\"b_entities\"");
             expect(cleanResult).toContain("a_entity_id: varchar(\"a_entity_id\").references(() => aEntities.id, { onDelete: \"set null\" })");
             // Check that both drizzle relations are generated
-            expect(cleanResult).toContain("export const aEntitiesRelations = drizzleRelations(aEntities, ({ one, many }) => ({ b_entities: many(bEntities, { relationName: \"b_entities\" }) }));");
-            expect(cleanResult).toContain("export const bEntitiesRelations = drizzleRelations(bEntities, ({ one, many }) => ({ a_entity: one(aEntities, { fields: [bEntities.a_entity_id], references: [aEntities.id], relationName: \"a_entity\" }) }));");
+            expect(cleanResult).toContain("\"b_entities\": many(bEntities, { relationName: \"b_entities_a_entity_id\" })");
+            expect(cleanResult).toContain("\"a_entity\": one(aEntities, { fields: [bEntities.a_entity_id], references: [aEntities.id], relationName: \"b_entities_a_entity_id\" })");
         });
     });
 });
+
+/**
+ * Regression tests for https://github.com/rebasepro/rebase/issues/XXX
+ * Ensures both sides of an owning/inverse relation emit the same `relationName`.
+ */
+describe("Shared relationName regression", () => {
+    const cleanSchema = (schema: string) => {
+        return schema
+            .replace(/\/\/.*$/gm, "")
+            .replace(/\/\*[\s\S]*?\*\//g, "")
+            .replace(/\n{2,}/g, "\n")
+            .replace(/\s+/g, " ")
+            .trim();
+    };
+
+    /**
+     * Helper that extracts all `relationName: "..."` values from generated schema output.
+     */
+    const extractRelationNames = (schema: string): string[] => {
+        const matches = schema.match(/relationName:\s*"([^"]+)"/g) ?? [];
+        return matches.map(m => m.replace(/relationName:\s*"/, "").replace(/"$/, ""));
+    };
+
+    it("should emit identical relationName for one-to-many owning + inverse pair", async () => {
+        const companiesCollection: EntityCollection = {
+            slug: "companies",
+            table: "companies",
+            name: "Companies",
+            properties: {
+                name: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "jobs",
+                    target: () => jobsCollection,
+                    cardinality: "many",
+                    direction: "inverse",
+                    foreignKeyOnTarget: "company_id"
+                }
+            ]
+        };
+
+        const jobsCollection: EntityCollection = {
+            slug: "jobs",
+            table: "jobs",
+            name: "Jobs",
+            properties: {
+                title: { type: "string" },
+                company: { type: "relation",
+relationName: "company" }
+            },
+            relations: [
+                {
+                    relationName: "company",
+                    target: () => companiesCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "company_id"
+                }
+            ]
+        };
+
+        const result = await generateSchema([companiesCollection, jobsCollection]);
+        const cleanResult = cleanSchema(result);
+
+        // Both sides must use the same deterministic name: jobs_company_id
+        const expectedSharedName = "jobs_company_id";
+
+        // Owning side (jobs → companies)
+        expect(cleanResult).toContain(
+            `"company": one(companies, { fields: [jobs.company_id], references: [companies.id], relationName: \"${expectedSharedName}\" })`
+        );
+
+        // Inverse side (companies → jobs)
+        expect(cleanResult).toContain(
+            `"jobs": many(jobs, { relationName: \"${expectedSharedName}\" })`
+        );
+
+        // Verify there are exactly 2 occurrences of the shared name
+        const allNames = extractRelationNames(result);
+        const matchingNames = allNames.filter(n => n === expectedSharedName);
+        expect(matchingNames).toHaveLength(2);
+    });
+
+    it("should emit identical relationName for one-to-one owning + inverse pair", async () => {
+        const usersCollection: EntityCollection = {
+            slug: "users",
+            table: "users",
+            name: "Users",
+            properties: {
+                name: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "profile",
+                    target: () => profilesCollection,
+                    cardinality: "one",
+                    direction: "inverse",
+                    foreignKeyOnTarget: "user_id"
+                }
+            ]
+        };
+
+        const profilesCollection: EntityCollection = {
+            slug: "profiles",
+            table: "profiles",
+            name: "Profiles",
+            properties: {
+                bio: { type: "string" },
+                user: { type: "relation",
+relationName: "user" }
+            },
+            relations: [
+                {
+                    relationName: "user",
+                    target: () => usersCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "user_id"
+                }
+            ]
+        };
+
+        const result = await generateSchema([usersCollection, profilesCollection]);
+        const cleanResult = cleanSchema(result);
+
+        const expectedSharedName = "profiles_user_id";
+
+        // Owning side (profiles → users)
+        expect(cleanResult).toContain(
+            `"user": one(users, { fields: [profiles.user_id], references: [users.id], relationName: \"${expectedSharedName}\" })`
+        );
+
+        // Inverse side (users → profiles)
+        expect(cleanResult).toContain(
+            `"profile": one(profiles, { fields: [users.id], references: [profiles.user_id], relationName: \"${expectedSharedName}\" })`
+        );
+
+        // Both must match
+        const allNames = extractRelationNames(result);
+        const matchingNames = allNames.filter(n => n === expectedSharedName);
+        expect(matchingNames).toHaveLength(2);
+    });
+
+    it("should emit different shared names for multiple relations between same tables", async () => {
+        const companiesCollection: EntityCollection = {
+            slug: "companies",
+            table: "companies",
+            name: "Companies",
+            properties: { name: { type: "string" } },
+            relations: [
+                {
+                    relationName: "employees",
+                    target: () => peopleCollection,
+                    cardinality: "many",
+                    direction: "inverse",
+                    foreignKeyOnTarget: "employer_id"
+                },
+                {
+                    relationName: "founders",
+                    target: () => peopleCollection,
+                    cardinality: "many",
+                    direction: "inverse",
+                    foreignKeyOnTarget: "startup_id"
+                }
+            ]
+        };
+
+        const peopleCollection: EntityCollection = {
+            slug: "people",
+            table: "people",
+            name: "People",
+            properties: {
+                name: { type: "string" },
+                employer: { type: "relation",
+relationName: "employer" },
+                startup: { type: "relation",
+relationName: "startup" }
+            },
+            relations: [
+                {
+                    relationName: "employer",
+                    target: () => companiesCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "employer_id"
+                },
+                {
+                    relationName: "startup",
+                    target: () => companiesCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "startup_id"
+                }
+            ]
+        };
+
+        const result = await generateSchema([companiesCollection, peopleCollection]);
+        const allNames = extractRelationNames(result);
+
+        // Each pair should have a distinct shared name
+        const employerNames = allNames.filter(n => n === "people_employer_id");
+        const startupNames = allNames.filter(n => n === "people_startup_id");
+        expect(employerNames).toHaveLength(2);
+        expect(startupNames).toHaveLength(2);
+    });
+});
+
+/**
+ * Regression tests for duplicate relation emission.
+ *
+ * Bug: resolveCollectionRelations used to add slug/snake_case alias entries
+ * for every relation. When the schema generator iterated the dictionary, it
+ * emitted multiple one() definitions with the same `relationName`, causing
+ * Drizzle ORM to throw:
+ *   "There are multiple relations with name 'jobs_company_id' in table 'jobs'"
+ *
+ * Also, property-based entries (e.g. `company_id: { type: "relation", relationName: "company" }`)
+ * duplicated explicit relation entries because the deduplication only compared
+ * property key vs relation key — not the underlying relationName.
+ *
+ * This suite covers both scenarios.
+ */
+describe("Duplicate relation deduplication regression", () => {
+    const cleanSchema = (schema: string) => {
+        return schema
+            .replace(/\/\/.*$/gm, "")
+            .replace(/\/\*[\s\S]*?\*\//g, "")
+            .replace(/\n{2,}/g, "\n")
+            .replace(/\s+/g, " ")
+            .trim();
+    };
+
+    const extractRelationNames = (schema: string): string[] => {
+        const matches = schema.match(/relationName:\s*"([^"]+)"/g) ?? [];
+        return matches.map(m => m.replace(/relationName:\s*"/, "").replace(/"$/, ""));
+    };
+
+    /**
+     * Count how many one() definitions exist for a specific relation key pattern.
+     * This matches `"<key>": one(` in the generated schema.
+     */
+    const countOneEntries = (schema: string, keyPattern: string): number => {
+        const regex = new RegExp(`"${keyPattern}":\\s*one\\(`, "g");
+        return (schema.match(regex) ?? []).length;
+    };
+
+    it("should emit exactly one one() per FK when explicit relation + property share the same FK", async () => {
+        // This models the exact Sustentalent scenario:
+        //   - Explicit relation: { relationName: "company", localKey: "company_id", ... }
+        //   - Property:          { company_id: { type: "relation", relationName: "company" } }
+        // Both reference the same FK `company_id`, but under different keys.
+        const companiesCollection: EntityCollection = {
+            slug: "companies",
+            table: "companies",
+            name: "Companies",
+            properties: {
+                name: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "jobs",
+                    target: () => jobsCollection,
+                    cardinality: "many",
+                    direction: "inverse",
+                    foreignKeyOnTarget: "company_id"
+                }
+            ]
+        };
+
+        const jobsCollection: EntityCollection = {
+            slug: "jobs",
+            table: "jobs",
+            name: "Jobs",
+            properties: {
+                title: { type: "string" },
+                // Property referencing the same FK as the explicit relation
+                company: {
+                    type: "relation",
+                    relationName: "company"
+                }
+            },
+            relations: [
+                {
+                    relationName: "company",
+                    target: () => companiesCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "company_id"
+                }
+            ]
+        };
+
+        const result = await generateSchema([companiesCollection, jobsCollection]);
+        const cleanResult = cleanSchema(result);
+
+        // The jobs table should have exactly ONE one() entry for company_id
+        const jobsRelationNames = extractRelationNames(result);
+        const companyIdRelNames = jobsRelationNames.filter(n => n === "jobs_company_id");
+
+        // Exactly 2: one on the owning side (jobs), one on the inverse side (companies)
+        expect(companyIdRelNames).toHaveLength(2);
+
+        // There must be no duplicate one() definitions within jobsRelations
+        const jobsRelationsBlock = result.match(/export const jobsRelations[\s\S]*?\}\)\);/)?.[0] ?? "";
+        const oneEntriesInJobs = (jobsRelationsBlock.match(/:\s*one\(/g) ?? []).length;
+        expect(oneEntriesInJobs).toBe(1);
+
+        // The companies table should have exactly ONE many() entry for jobs
+        const companiesRelationsBlock = result.match(/export const companiesRelations[\s\S]*?\}\)\);/)?.[0] ?? "";
+        const manyEntriesInCompanies = (companiesRelationsBlock.match(/:\s*many\(/g) ?? []).length;
+        expect(manyEntriesInCompanies).toBe(1);
+    });
+
+    it("should not create aliases when relation key contains underscores", async () => {
+        // Verify that resolving a collection with a snake_case relation name
+        // does NOT produce slug-variant alias entries in the generated schema
+        const parentCollection: EntityCollection = {
+            slug: "departments",
+            table: "departments",
+            name: "Departments",
+            properties: {
+                name: { type: "string" }
+            },
+            relations: [
+                {
+                    relationName: "team_members",
+                    target: () => memberCollection,
+                    cardinality: "many",
+                    direction: "inverse",
+                    foreignKeyOnTarget: "department_id"
+                }
+            ]
+        };
+
+        const memberCollection: EntityCollection = {
+            slug: "team-members",
+            table: "team_members",
+            name: "Team Members",
+            properties: {
+                name: { type: "string" },
+                department: {
+                    type: "relation",
+                    relationName: "department"
+                }
+            },
+            relations: [
+                {
+                    relationName: "department",
+                    target: () => parentCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "department_id"
+                }
+            ]
+        };
+
+        const result = await generateSchema([parentCollection, memberCollection]);
+
+        // team_members table should have exactly one one() definition
+        const teamMembersRelBlock = result.match(/export const teamMembersRelations[\s\S]*?\}\)\);/)?.[0] ?? "";
+        const oneEntries = (teamMembersRelBlock.match(/:\s*one\(/g) ?? []).length;
+        expect(oneEntries).toBe(1);
+
+        // No duplicate relation names anywhere
+        const allNames = extractRelationNames(result);
+        const nameCountMap = new Map<string, number>();
+        for (const name of allNames) {
+            nameCountMap.set(name, (nameCountMap.get(name) ?? 0) + 1);
+        }
+        // Every relation name should appear exactly twice (once per side)
+        for (const [name, count] of nameCountMap) {
+            expect(count).toBeLessThanOrEqual(2);
+        }
+    });
+
+    it("should handle multiple different relations to the same target without duplicates", async () => {
+        // Two separate FKs from one table to the same target table
+        const usersCollection: EntityCollection = {
+            slug: "users",
+            table: "users",
+            name: "Users",
+            properties: { name: { type: "string" } },
+            relations: []
+        };
+
+        const messagesCollection: EntityCollection = {
+            slug: "messages",
+            table: "messages",
+            name: "Messages",
+            properties: {
+                content: { type: "string" },
+                sender: { type: "relation",
+relationName: "sender" },
+                recipient: { type: "relation",
+relationName: "recipient" }
+            },
+            relations: [
+                {
+                    relationName: "sender",
+                    target: () => usersCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "sender_id"
+                },
+                {
+                    relationName: "recipient",
+                    target: () => usersCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "recipient_id"
+                }
+            ]
+        };
+
+        const result = await generateSchema([usersCollection, messagesCollection]);
+
+        // messages table should have exactly TWO one() entries (one per FK)
+        const messagesRelBlock = result.match(/export const messagesRelations[\s\S]*?\}\)\);/)?.[0] ?? "";
+        const oneEntries = (messagesRelBlock.match(/:\s*one\(/g) ?? []).length;
+        expect(oneEntries).toBe(2);
+
+        // The two must have DIFFERENT relationName values
+        const namesInMessages = extractRelationNames(messagesRelBlock);
+        expect(namesInMessages).toHaveLength(2);
+        expect(namesInMessages[0]).not.toBe(namesInMessages[1]);
+    });
+});