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

package/test/relations.test.ts

@@ -0,0 +1,662 @@
+import { EntityCollection, Relation } from "@rebasepro/types";
+import { generateSchema } from "../src/schema/generate-drizzle-schema-logic";
+import { sanitizeRelation } from "@rebasepro/common";
+
+const mockAuthorCollection: EntityCollection = {
+    name: "Author",
+    slug: "author",
+    table: "authors",
+    properties: {
+        id: {
+            type: "number"
+        },
+        name: {
+            type: "string"
+        }
+    },
+    idField: "id"
+};
+
+const mockPostCollection: EntityCollection = {
+    name: "Post",
+    slug: "posts",
+    table: "posts",
+    properties: {
+        id: {
+            type: "number"
+        },
+        title: {
+            type: "string"
+        },
+        author_id: {
+            type: "number"
+        }
+    },
+    idField: "id"
+};
+
+const mockTagCollection: EntityCollection = {
+    name: "Tag",
+    slug: "tags",
+    table: "tags",
+    properties: {
+        id: {
+            type: "string"
+        },
+        name: {
+            type: "string"
+        }
+    },
+    idField: "id"
+};
+
+describe("sanitizeRelation", () => {
+
+    it("should generate a default relationName if not provided", () => {
+        const relation: Partial<Relation> = {
+            target: () => mockPostCollection,
+            cardinality: "one"
+        };
+        const normalized = sanitizeRelation(relation, mockAuthorCollection);
+        expect(normalized.relationName).toBe("posts");
+    });
+
+    // --- Belongs-To (cardinality: 'one', direction: 'owning') ---
+    describe("Belongs-To (one-to-one/many-to-one)", () => {
+        it("should generate default localKey for a simple belongs-to relation", () => {
+            const relation: Partial<Relation> = {
+                relationName: "post",
+                target: () => mockPostCollection,
+                cardinality: "one"
+            };
+            const normalized = sanitizeRelation(relation, mockAuthorCollection);
+            expect(normalized.localKey).toEqual("post_id");
+            expect(normalized.direction).toEqual("owning");
+        });
+
+        it("should use provided `localKey` for a belongs-to relation", () => {
+            const relation: Partial<Relation> = {
+                relationName: "post",
+                target: () => mockPostCollection,
+                cardinality: "one",
+                localKey: "custom_post_fk"
+            };
+            const normalized = sanitizeRelation(relation, mockAuthorCollection);
+            expect(normalized.localKey).toEqual("custom_post_fk");
+            expect(normalized.direction).toEqual("owning");
+        });
+    });
+
+    // --- Inverse One-to-One (cardinality: 'one', direction: 'inverse') ---
+    describe("Inverse One-to-One", () => {
+        it("should generate default foreignKeyOnTarget for an inverse one-to-one relation", () => {
+            const relation: Partial<Relation> = {
+                relationName: "profile",
+                target: () => mockPostCollection,
+                cardinality: "one",
+                direction: "inverse"
+            };
+            const normalized = sanitizeRelation(relation, mockAuthorCollection);
+            expect(normalized.foreignKeyOnTarget).toEqual("author_id");
+            expect(normalized.direction).toEqual("inverse");
+        });
+
+        it("should use provided `foreignKeyOnTarget` for an inverse one-to-one relation", () => {
+            const relation: Partial<Relation> = {
+                relationName: "profile",
+                target: () => mockPostCollection,
+                cardinality: "one",
+                direction: "inverse",
+                foreignKeyOnTarget: "custom_author_fk"
+            };
+            const normalized = sanitizeRelation(relation, mockAuthorCollection);
+            expect(normalized.foreignKeyOnTarget).toEqual("custom_author_fk");
+            expect(normalized.direction).toEqual("inverse");
+        });
+
+        it("should work with inverseRelationName property", () => {
+            const relation: Partial<Relation> = {
+                relationName: "profile",
+                target: () => mockPostCollection,
+                cardinality: "one",
+                direction: "inverse",
+                inverseRelationName: "author"
+            };
+            const normalized = sanitizeRelation(relation, mockAuthorCollection);
+            expect(normalized.foreignKeyOnTarget).toEqual("author_id");
+            expect(normalized.inverseRelationName).toEqual("author");
+            expect(normalized.direction).toEqual("inverse");
+        });
+    });
+
+    // --- Has-Many (cardinality: 'many', direction: 'inverse') ---
+    describe("Has-Many (one-to-many)", () => {
+        it("should generate default foreignKeyOnTarget for a simple has-many relation", () => {
+            const relation: Partial<Relation> = {
+                relationName: "posts",
+                target: () => mockPostCollection,
+                cardinality: "many",
+                direction: "inverse"
+            };
+            const normalized = sanitizeRelation(relation, mockAuthorCollection);
+            expect(normalized.foreignKeyOnTarget).toEqual("author_id");
+        });
+
+        it("should use provided `foreignKeyOnTarget` for a has-many relation", () => {
+            const relation: Partial<Relation> = {
+                relationName: "posts",
+                target: () => mockPostCollection,
+                cardinality: "many",
+                direction: "inverse",
+                foreignKeyOnTarget: "writer_id"
+            };
+            const normalized = sanitizeRelation(relation, mockAuthorCollection);
+            expect(normalized.foreignKeyOnTarget).toEqual("writer_id");
+        });
+    });
+
+    // --- Many-To-Many (cardinality: 'many', through) ---
+    describe("Many-To-Many", () => {
+        it("should use provided `through` for a many-to-many relation", () => {
+            const relation: Partial<Relation> = {
+                relationName: "tags",
+                target: () => mockTagCollection,
+                cardinality: "many",
+                through: {
+                    table: "posts_tags",
+                    sourceColumn: "post_id",
+                    targetColumn: "tag_id"
+                }
+            };
+            const normalized = sanitizeRelation(relation, mockPostCollection);
+            expect(normalized.through).toEqual({
+                table: "posts_tags",
+                sourceColumn: "post_id",
+                targetColumn: "tag_id"
+            });
+            expect(normalized.direction).toEqual("owning");
+        });
+    });
+
+    // --- Fallback/Default Behavior ---
+    describe("Fallback Behavior", () => {
+        it("should fallback to has-many for ambiguous 'many' without direction or through", () => {
+            const relation: Partial<Relation> = {
+                relationName: "posts",
+                target: () => mockPostCollection,
+                cardinality: "many"
+            };
+            const normalized = sanitizeRelation(relation, mockAuthorCollection);
+            // Should default to has-many (inverse) behavior
+            expect(normalized.direction).toEqual("inverse");
+            expect(normalized.foreignKeyOnTarget).toEqual("author_id");
+        });
+
+        it("should handle 'one' with 'owning' direction", () => {
+            const relation: Partial<Relation> = {
+                relationName: "author",
+                target: () => mockAuthorCollection,
+                cardinality: "one",
+                direction: "owning" // Changed from "inverse"
+            };
+            const normalized = sanitizeRelation(relation, mockPostCollection);
+            expect(normalized.localKey).toEqual("author_id");
+        });
+    });
+});
+/**
+ * Comprehensive test suite for complex relation scenarios
+ * This tests all the production use cases developers might implement
+ */
+describe("Comprehensive Relations Test Suite", () => {
+
+    const cleanSchema = (schema: string) => {
+        return schema
+            .replace(/\/\/.*$/gm, '')
+            .replace(/\/\*[\s\S]*?\*\//g, '')
+            .replace(/\n{2,}/g, '\n')
+            .replace(/\s+/g, " ")
+            .trim();
+    };
+
+    describe("Many-to-Many Relations", () => {
+        it("should handle many-to-many with a through table", async () => {
+            const authorsCollection: EntityCollection = {
+                slug: "authors",
+                table: "authors",
+                name: "Authors",
+                properties: {
+                    name: { type: "string" },
+                    books: { type: "relation", relationName: "books" }
+                },
+                relations: [
+                    {
+                        relationName: "books",
+                        target: () => booksCollection,
+                        cardinality: "many",
+                        direction: "owning",
+                        through: {
+                            table: "author_books",
+                            sourceColumn: "author_id",
+                            targetColumn: "book_id"
+                        }
+                    }
+                ]
+            };
+
+            const booksCollection: EntityCollection = {
+                slug: "books",
+                table: "books",
+                name: "Books",
+                properties: {
+                    title: { type: "string" }
+                }
+            };
+
+            const result = await generateSchema([authorsCollection, booksCollection]);
+            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" }) }));`);
+        });
+
+        it("should handle a 4-table many-to-many chain with joinPath", async () => {
+            const usersCollection: EntityCollection = {
+                slug: "users",
+                table: "users",
+                name: "Users",
+                properties: {
+                    name: { type: "string" },
+                    permissions: { type: "relation", relationName: "permissions" }
+                },
+                relations: [
+                    {
+                        relationName: "permissions",
+                        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" } }
+                        ]
+                    }
+                ]
+            };
+
+            const rolesCollection: EntityCollection = {
+                slug: "roles",
+                table: "roles",
+                name: "Roles",
+                properties: { name: { type: "string" } }
+            };
+
+            const permissionsCollection: EntityCollection = {
+                slug: "permissions",
+                table: "permissions",
+                name: "Permissions",
+                properties: { name: { type: "string" } }
+            };
+
+            const result = await generateSchema([usersCollection, rolesCollection, permissionsCollection]);
+            const cleanResult = cleanSchema(result);
+
+            // joinPath relations use existing user-controlled tables - no views or Drizzle relations generated
+            expect(cleanResult).not.toContain("view_users_to_permissions");
+            expect(cleanResult).not.toContain("viewUsersToPermissions");
+
+            // Should generate basic table definitions for users, roles, and permissions
+            expect(cleanResult).toContain("export const users = pgTable(\"users\"");
+            expect(cleanResult).toContain("export const roles = pgTable(\"roles\"");
+            expect(cleanResult).toContain("export const permissions = pgTable(\"permissions\"");
+
+            // No Drizzle relations generated for joinPath relations
+            expect(cleanResult).not.toContain("usersRelations");
+
+            // No SQL view generation comments
+            expect(result).not.toContain("CREATE OR REPLACE VIEW");
+            expect(result).not.toContain("SQL VIEWS FOR COMPLEX RELATIONS");
+        });
+    });
+
+    describe("Owning Relations", () => {
+        it("should generate owning one-to-one relations", async () => {
+            const authorsCollection: EntityCollection = {
+                slug: "authors",
+                table: "authors",
+                name: "Authors",
+                properties: {
+                    name: { type: "string" },
+                    profile: { type: "relation", relationName: "profile" }
+                },
+                relations: [
+                    {
+                        relationName: "profile",
+                        target: () => profilesCollection,
+                        cardinality: "one",
+                        direction: "inverse",
+                        inverseRelationName: "author"
+                    }
+                ]
+            };
+
+            const profilesCollection: EntityCollection = {
+                slug: "profiles",
+                table: "profiles",
+                name: "Profiles",
+                properties: {
+                    bio: { type: "string" },
+                    author: { type: "relation", relationName: "author" }
+                },
+                relations: [
+                    {
+                        relationName: "author",
+                        target: () => authorsCollection,
+                        cardinality: "one",
+                        localKey: "author_id"
+                    }
+                ]
+            };
+
+            const result = await generateSchema([authorsCollection, profilesCollection]);
+            const cleanResult = cleanSchema(result);
+
+            // Should create FK on profiles table
+            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" }) }));`);
+
+            // 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" }) }));`);
+        });
+
+        it("should generate owning one-to-many relations", async () => {
+            const categoriesCollection: EntityCollection = {
+                slug: "categories",
+                table: "categories",
+                name: "Categories",
+                properties: {
+                    name: { type: "string" },
+                }
+            };
+
+            const postsCollection: EntityCollection = {
+                slug: "posts",
+                table: "posts",
+                name: "Posts",
+                properties: {
+                    title: { type: "string" },
+                    category: { type: "relation", relationName: "category" }
+                },
+                relations: [
+                    {
+                        relationName: "category",
+                        target: () => categoriesCollection,
+                        cardinality: "one",
+                        localKey: "category_id"
+                    }
+                ]
+            };
+
+            const result = await generateSchema([categoriesCollection, postsCollection]);
+            const cleanResult = cleanSchema(result);
+
+            // Should create FK on posts table
+            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" }) }));`);
+        });
+    });
+
+    describe("Mixed Relation Types", () => {
+        it("should handle collections with multiple relations", async () => {
+            const authorsCollection: EntityCollection = {
+                slug: "authors",
+                table: "authors",
+                name: "Authors",
+                properties: {
+                    name: { type: "string" },
+                    publisher: { type: "relation", relationName: "publisher" },
+                },
+                relations: [
+                    {
+                        relationName: "publisher",
+                        target: () => publishersCollection,
+                        cardinality: "one",
+                        localKey: "publisher_id"
+                    }
+                ]
+            };
+
+            const publishersCollection: EntityCollection = {
+                slug: "publishers",
+                table: "publishers",
+                name: "Publishers",
+                properties: {
+                    name: { type: "string" }
+                }
+            };
+
+            const booksCollection: EntityCollection = {
+                slug: "books",
+                table: "books",
+                name: "Books",
+                properties: {
+                    title: { type: "string" },
+                    author: { type: "relation", relationName: "author" }
+                },
+                relations: [{
+                    relationName: "author",
+                    target: () => authorsCollection,
+                    cardinality: "one",
+                    localKey: "author_id"
+                }]
+            };
+
+            const result = await generateSchema([authorsCollection, publishersCollection, booksCollection]);
+            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" })`);
+
+            // 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" })`);
+        });
+    });
+
+    describe("Complex Multi-Column Relations", () => {
+        it("should handle multi-column foreign keys", async () => {
+            const ordersCollection: EntityCollection = {
+                slug: "orders",
+                table: "orders",
+                name: "Orders",
+                properties: {
+                    customer_code: { type: "string" },
+                    region_id: { type: "number", validation: { integer: true } },
+                    customer: { type: "relation", relationName: "customer" }
+                },
+                relations: [
+                    {
+                        relationName: "customer",
+                        target: () => customersCollection,
+                        cardinality: "many",
+                        joinPath: [
+                            { table: "customers", on: { from: ["customer_code", "region_id"], to: ["code", "region_id"] } }
+                        ]
+                    }
+                ]
+            };
+
+            const customersCollection: EntityCollection = {
+                slug: "customers",
+                table: "customers",
+                name: "Customers",
+                properties: {
+                    code: { type: "string" },
+                    region_id: { type: "number", validation: { integer: true } },
+                    name: { type: "string" }
+                }
+            };
+
+            const result = await generateSchema([ordersCollection, customersCollection]);
+            const cleanResult = cleanSchema(result);
+
+            // joinPath relations use existing user-controlled tables - no views generated
+            expect(cleanResult).not.toContain("view_orders_to_customers");
+            expect(cleanResult).not.toContain("viewOrdersToCustomers");
+
+            // Should generate basic table definitions
+            expect(cleanResult).toContain("export const orders = pgTable(\"orders\"");
+            expect(cleanResult).toContain("export const customers = pgTable(\"customers\"");
+
+            // Should include the multi-column properties in the tables
+            expect(cleanResult).toContain("customer_code: varchar(\"customer_code\")");
+            expect(cleanResult).toContain("region_id: integer(\"region_id\")");
+            expect(cleanResult).toContain("code: varchar(\"code\")");
+
+            // No Drizzle relations generated for joinPath relations
+            expect(cleanResult).not.toContain("ordersRelations");
+
+            // No SQL view generation
+            expect(result).not.toContain("CREATE OR REPLACE VIEW");
+            expect(result).not.toContain("SQL VIEWS FOR COMPLEX RELATIONS");
+        });
+    });
+
+    describe("Edge Cases and Production Scenarios", () => {
+        it("should handle self-referencing many-to-many", async () => {
+            const usersCollection: EntityCollection = {
+                slug: "users",
+                table: "users",
+                name: "Users",
+                properties: {
+                    name: { type: "string" },
+                    friends: { type: "relation", relationName: "friends" }
+                },
+                relations: [
+                    {
+                        relationName: "friends",
+                        target: () => usersCollection,
+                        cardinality: "many",
+                        direction: "owning",
+                        through: {
+                            table: "user_friends",
+                            sourceColumn: "user_id",
+                            targetColumn: "friend_id"
+                        }
+                    }
+                ]
+            };
+
+            const result = await generateSchema([usersCollection]);
+            const cleanResult = cleanSchema(result);
+
+            // Should handle self-referencing relations
+            expect(cleanResult).toContain("export const userFriends = pgTable(\"user_friends\"");
+            expect(cleanResult).toContain("user_id: varchar(\"user_id\").notNull().references(() => users.id, { onDelete: \"cascade\" })");
+            expect(cleanResult).toContain("friend_id: varchar(\"friend_id\").notNull().references(() => users.id, { onDelete: \"cascade\" })");
+        });
+
+        it("should handle mixed ID types in relations", async () => {
+            const productsCollection: EntityCollection = {
+                slug: "products",
+                table: "products",
+                name: "Products",
+                properties: {
+                    sku: { type: "string", isId: true },
+                    name: { type: "string" },
+                    categories: { type: "relation", relationName: "categories" }
+                },
+                relations: [
+                    {
+                        relationName: "categories",
+                        target: () => categoriesCollection,
+                        cardinality: "many",
+                        direction: "owning",
+                        through: {
+                            table: "product_categories",
+                            sourceColumn: "product_sku",
+                            targetColumn: "category_id"
+                        }
+                    }
+                ]
+            };
+
+            const categoriesCollection: EntityCollection = {
+                slug: "categories",
+                table: "categories",
+                name: "Categories",
+                properties: {
+                    name: { type: "string" }
+                }
+            };
+
+            const result = await generateSchema([productsCollection, categoriesCollection]);
+            const cleanResult = cleanSchema(result);
+
+            // The primary key should be sku
+            expect(cleanResult).toContain("sku: varchar(\"sku\").primaryKey()");
+            expect(cleanResult).not.toContain("id: serial(\"id\").primaryKey()");
+            expect(cleanResult).toContain("product_sku: varchar(\"product_sku\").notNull().references(() => products.sku, { onDelete: \"cascade\" })");
+            expect(cleanResult).toContain("category_id: varchar(\"category_id\").notNull().references(() => categories.id, { onDelete: \"cascade\" })");
+        });
+
+        it("should handle circular references", async () => {
+            const aCollection: EntityCollection = {
+                slug: "a_entities",
+                table: "a_entities",
+                name: "A Entities",
+                properties: {
+                    name: { type: "string" },
+                    b_entities: { type: "relation", relationName: "b_entities" }
+                },
+                relations: [
+                    {
+                        relationName: "b_entities",
+                        target: () => bCollection,
+                        cardinality: "many",
+                        direction: "inverse",
+                        foreignKeyOnTarget: "a_entity_id"
+                    }
+                ]
+            };
+
+            const bCollection: EntityCollection = {
+                slug: "b_entities",
+                table: "b_entities",
+                name: "B Entities",
+                properties: {
+                    name: { type: "string" },
+                    a_entity: { type: "relation", relationName: "a_entity" }
+                },
+                relations: [
+                    {
+                        relationName: "a_entity",
+                        target: () => aCollection,
+                        cardinality: "one",
+                        direction: "owning",
+                        localKey: "a_entity_id"
+                    }
+                ]
+            };
+
+            const result = await generateSchema([aCollection, bCollection]);
+            const cleanResult = cleanSchema(result);
+
+            // Should handle circular references without infinite loops
+            // The 'owning' relation on bCollection should correctly generate the FK
+            expect(cleanResult).toContain("export const aEntities = pgTable(\"a_entities\"");
+            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\" }) }));");
+        });
+    });
+});

package/test_drizzle_mock.js

@@ -0,0 +1,3 @@
+const { sql } = require('drizzle-orm');
+const q = sql`ARRAY[${sql.join(['a', 'b'].map(f => sql`${f}`), sql`, `)}]::text[]`;
+console.log(JSON.stringify(q, null, 2));