@rebasepro/server-postgresql 0.0.1-canary.dbf160a → 0.0.1-canary.e17585f

package/test/generate-drizzle-schema.test.ts

@@ -666,6 +666,53 @@ using: "{is_locked} = false" }
             expect(result).toContain('as: "restrictive"');
         });
 
+        it("should enable RLS on every table even without any security rules", async () => {
+            const collections: EntityCollection[] = [{
+                slug: "public_data",
+                table: "public_data",
+                name: "Public Data",
+                properties: { title: { type: "string" } }
+                // No securityRules defined — table should still have .enableRLS()
+            }];
+
+            const result = await generateSchema(collections);
+            expect(result).toContain(".enableRLS()");
+            // No policies should be generated
+            expect(result).not.toContain("pgPolicy(");
+        });
+
+        it("should enable RLS on tables that do have security rules", async () => {
+            const collections: EntityCollection[] = [{
+                slug: "secure_data",
+                table: "secure_data",
+                name: "Secure Data",
+                properties: { title: { type: "string" } },
+                securityRules: [
+                    { operation: "select", access: "public" }
+                ]
+            }];
+
+            const result = await generateSchema(collections);
+            expect(result).toContain(".enableRLS()");
+            expect(result).toContain("pgPolicy(");
+        });
+
+        it("should fall back to deny-all (sql`false`) when no USING clause can be generated", async () => {
+            const collections: EntityCollection[] = [{
+                slug: "deny_test",
+                table: "deny_test",
+                name: "Deny Test",
+                properties: { title: { type: "string" } },
+                securityRules: [
+                    { operation: "select" }
+                    // No access, ownerField, or using — should produce sql`false`
+                ]
+            }];
+
+            const result = await generateSchema(collections);
+            expect(result).toContain("sql`false`");
+        });
+
     });
 });
 // V2 improvements tests
@@ -986,3 +1033,298 @@ isId: true }
         expect(cleanResult).toContain("user_name: varchar(\"user_name\").primaryKey()");
     });
 });
+
+// ── columnName tests ────────────────────────────────────────────────────
+describe("generateDrizzleSchema columnName support", () => {
+    const cleanSchema = (schema: string) => {
+        return schema
+            .replace(/\/\/.*$/gm, "")
+            .replace(/\/\*[\s\S]*?\*\//g, "")
+            .replace(/\n{2,}/g, "\n")
+            .replace(/\s+/g, " ")
+            .trim();
+    };
+
+    it("should use explicit columnName as the SQL column name instead of deriving from the property key", async () => {
+        const collections: EntityCollection[] = [{
+            slug: "billing",
+            table: "company_billing_config",
+            name: "Billing",
+            properties: {
+                employee_number_140a: {
+                    type: "string",
+                    name: "Employee Number 140a",
+                    columnName: "employee_number_140a",
+                },
+                contract_number_140a: {
+                    type: "string",
+                    name: "Contract Number 140a",
+                    columnName: "contract_number_140a",
+                },
+            },
+        }];
+
+        const result = await generateSchema(collections);
+        const cleanResult = cleanSchema(result);
+
+        // Must use the exact columnName, NOT toSnakeCase(propKey) which would produce "employee_number_140_a"
+        expect(cleanResult).toContain('employee_number_140a: varchar("employee_number_140a")');
+        expect(cleanResult).toContain('contract_number_140a: varchar("contract_number_140a")');
+
+        // Must NOT contain the broken snake_case version
+        expect(cleanResult).not.toContain("employee_number_140_a");
+        expect(cleanResult).not.toContain("contract_number_140_a");
+    });
+
+    it("should fall back to toSnakeCase when columnName is not set (manually-authored collections)", async () => {
+        const collections: EntityCollection[] = [{
+            slug: "products",
+            table: "products",
+            name: "Products",
+            properties: {
+                productName: {
+                    type: "string",
+                    name: "Product Name",
+                    // No columnName — should derive from key
+                },
+            },
+        }];
+
+        const result = await generateSchema(collections);
+        const cleanResult = cleanSchema(result);
+
+        // JS key stays camelCase, SQL column name gets snake_cased
+        expect(cleanResult).toContain('productName: varchar("product_name")');
+    });
+
+    it("should handle mixed properties — some with columnName, some without", async () => {
+        const collections: EntityCollection[] = [{
+            slug: "config",
+            table: "app_config",
+            name: "Config",
+            properties: {
+                // Introspected: has explicit columnName
+                fee_number_140a: {
+                    type: "string",
+                    name: "Fee Number",
+                    columnName: "fee_number_140a",
+                },
+                // Manually added: no columnName
+                displayName: {
+                    type: "string",
+                    name: "Display Name",
+                },
+            },
+        }];
+
+        const result = await generateSchema(collections);
+        const cleanResult = cleanSchema(result);
+
+        // Introspected prop uses exact columnName
+        expect(cleanResult).toContain('fee_number_140a: varchar("fee_number_140a")');
+        // Manual prop: JS key stays camelCase, SQL column gets snake_cased
+        expect(cleanResult).toContain('displayName: varchar("display_name")');
+    });
+
+    it("should use columnName for all property types, not just strings", async () => {
+        const collections: EntityCollection[] = [{
+            slug: "metrics",
+            table: "metrics",
+            name: "Metrics",
+            properties: {
+                count_v2: {
+                    type: "number",
+                    name: "Count V2",
+                    columnName: "count_v2",
+                },
+                is_active_v2: {
+                    type: "boolean",
+                    name: "Is Active V2",
+                    columnName: "is_active_v2",
+                },
+                created_at_v2: {
+                    type: "date",
+                    name: "Created At V2",
+                    columnName: "created_at_v2",
+                },
+                metadata_v2: {
+                    type: "map",
+                    name: "Metadata V2",
+                    columnName: "metadata_v2",
+                },
+            },
+        }];
+
+        const result = await generateSchema(collections);
+        const cleanResult = cleanSchema(result);
+
+        expect(cleanResult).toContain('count_v2: numeric("count_v2")');
+        expect(cleanResult).toContain('is_active_v2: boolean("is_active_v2")');
+        expect(cleanResult).toContain('created_at_v2: timestamp("created_at_v2"');
+        expect(cleanResult).toContain('metadata_v2: jsonb("metadata_v2")');
+    });
+
+    it("should reproduce and prevent the medmot bug: digit+letter column names", async () => {
+        // This is the exact scenario from the medmot project that caused the production failure
+        const collections: EntityCollection[] = [{
+            slug: "company_billing_config",
+            table: "company_billing_config",
+            name: "Company Billing Config",
+            properties: {
+                employee_number_140a: { type: "string", name: "Employee Number", columnName: "employee_number_140a" },
+                contract_number_140a: { type: "string", name: "Contract Number", columnName: "contract_number_140a" },
+                amount: { type: "number", name: "Amount" },
+                id: { type: "number", name: "ID", isId: "increment" },
+                service_provider_140a: { type: "string", name: "Service Provider", columnName: "service_provider_140a" },
+                internal_area_code_140a: { type: "string", name: "Internal Area Code", columnName: "internal_area_code_140a" },
+                fee_number_140a: { type: "string", name: "Fee Number", columnName: "fee_number_140a" },
+                receiver_market_participant_140a: { type: "string", name: "Receiver Market Participant", columnName: "receiver_market_participant_140a" },
+                employee_value_number_140a: { type: "string", name: "Employee Value Number", columnName: "employee_value_number_140a" },
+                sender_market_participant_140a: { type: "string", name: "Sender Market Participant", columnName: "sender_market_participant_140a" },
+                processing_indicator_140a: { type: "string", name: "Processing Indicator", columnName: "processing_indicator_140a" },
+                insurance_id_140a: { type: "string", name: "Insurance ID", columnName: "insurance_id_140a" },
+                company_id: { type: "number", name: "Company ID" },
+            },
+        }];
+
+        const result = await generateSchema(collections);
+
+        // Every _140a column must stay _140a, not become _140_a
+        const brokenPattern = /_140_a/;
+        expect(result).not.toMatch(brokenPattern);
+
+        // Spot-check a few exact columns
+        expect(result).toContain('"employee_number_140a"');
+        expect(result).toContain('"contract_number_140a"');
+        expect(result).toContain('"service_provider_140a"');
+        expect(result).toContain('"insurance_id_140a"');
+    });
+
+    describe("generateDrizzleSchema autoValue date properties", () => {
+
+        it("should add .default(sql`now()`) for on_create autoValue", async () => {
+            const collections: EntityCollection[] = [
+                {
+                    slug: "articles",
+                    table: "articles",
+                    name: "Articles",
+                    properties: {
+                        title: { type: "string" },
+                        created_at: {
+                            type: "date",
+                            autoValue: "on_create"
+                        }
+                    }
+                }
+            ];
+
+            const result = await generateSchema(collections, true);
+
+            // on_create should produce .default(sql`now()`)
+            expect(result).toContain(".default(sql`now()`)");
+            // No $onUpdate or triggers — on_update logic lives in the backend driver
+            expect(result).not.toContain(".$onUpdate");
+            expect(result).not.toContain("CREATE OR REPLACE TRIGGER");
+            expect(result).not.toContain("CREATE OR REPLACE FUNCTION");
+        });
+
+        it("should add .default(sql`now()`) for on_update autoValue (INSERT default only)", async () => {
+            const collections: EntityCollection[] = [
+                {
+                    slug: "articles",
+                    table: "articles",
+                    name: "Articles",
+                    properties: {
+                        title: { type: "string" },
+                        updated_at: {
+                            type: "date",
+                            autoValue: "on_update"
+                        }
+                    }
+                }
+            ];
+
+            const result = await generateSchema(collections, true);
+
+            // on_update should produce .default(sql`now()`) for initial INSERT value
+            expect(result).toContain(".default(sql`now()`)");
+            // No $onUpdate or triggers — update logic is handled by the backend driver
+            expect(result).not.toContain(".$onUpdate");
+            expect(result).not.toContain("CREATE OR REPLACE TRIGGER");
+        });
+
+        it("should not modify date columns without autoValue", async () => {
+            const collections: EntityCollection[] = [
+                {
+                    slug: "events",
+                    table: "events",
+                    name: "Events",
+                    properties: {
+                        name: { type: "string" },
+                        event_date: { type: "date" }
+                    }
+                }
+            ];
+
+            const result = await generateSchema(collections, true);
+
+            // A plain date should NOT have any autoValue-related modifiers
+            expect(result).not.toContain(".default(sql`now()`)");
+            expect(result).not.toContain(".$onUpdate");
+        });
+
+        it("should handle both on_create and on_update in the same collection", async () => {
+            const collections: EntityCollection[] = [
+                {
+                    slug: "posts",
+                    table: "posts",
+                    name: "Posts",
+                    properties: {
+                        title: { type: "string" },
+                        created_at: {
+                            type: "date",
+                            autoValue: "on_create"
+                        },
+                        updated_at: {
+                            type: "date",
+                            autoValue: "on_update"
+                        }
+                    }
+                }
+            ];
+
+            const result = await generateSchema(collections, true);
+
+            // Both should get .default(sql`now()`) for INSERT defaults
+            expect(result).toMatch(/created_at:.*\.default\(sql`now\(\)`\)/);
+            expect(result).toMatch(/updated_at:.*\.default\(sql`now\(\)`\)/);
+            // No $onUpdate or triggers
+            expect(result).not.toContain(".$onUpdate");
+            expect(result).not.toContain("CREATE OR REPLACE TRIGGER");
+        });
+
+        it("should handle on_create with date columnType", async () => {
+            const collections: EntityCollection[] = [
+                {
+                    slug: "logs",
+                    table: "logs",
+                    name: "Logs",
+                    properties: {
+                        message: { type: "string" },
+                        log_date: {
+                            type: "date",
+                            columnType: "date",
+                            autoValue: "on_create"
+                        }
+                    }
+                }
+            ];
+
+            const result = await generateSchema(collections, true);
+
+            // Should use date() column with the default
+            expect(result).toContain("date(\"log_date\"");
+            expect(result).toContain(".default(sql`now()`)");
+        });
+    });
+});

package/test/introspect-db-generation.test.ts

@@ -148,27 +148,27 @@ describe("generateCollectionFile", () => {
     });
 
     describe("enum support", () => {
-        it("generates enumValues for USER-DEFINED columns with matching enum", () => {
+        it("generates enum for USER-DEFINED columns with matching enum", () => {
             const enumMap = new Map([["order_status", ["pending", "shipped", "delivered"]]]);
             const meta = makeSimpleTable("orders", [
                 mkCol("orders", "id", { data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
                 mkCol("orders", "status", { data_type: "USER-DEFINED", udt_name: "order_status" }),
             ]);
             const result = generateCollectionFile("orders", meta, [], new Set(), new Map([["orders", meta]]), enumMap);
-            expect(result).toContain('enumValues:');
+            expect(result).toContain('enum:');
             expect(result).toContain('{ id: "pending", label: "Pending" }');
             expect(result).toContain('{ id: "shipped", label: "Shipped" }');
             expect(result).toContain('{ id: "delivered", label: "Delivered" }');
             expect(result).toContain('type: "string"');
         });
 
-        it("does NOT add enumValues for USER-DEFINED without matching enum", () => {
+        it("does NOT add enum for USER-DEFINED without matching enum", () => {
             const meta = makeSimpleTable("things", [
                 mkCol("things", "id", { data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
                 mkCol("things", "geom", { data_type: "USER-DEFINED", udt_name: "geometry" }),
             ]);
             const result = generateCollectionFile("things", meta, [], new Set(), new Map([["things", meta]]), new Map());
-            expect(result).not.toContain("enumValues");
+            expect(result).not.toContain("enum");
         });
 
         it("humanizes enum value labels with underscores", () => {
@@ -264,7 +264,7 @@ describe("generateCollectionFile", () => {
             ]);
             const result = generateCollectionFile("t", meta, [], new Set(), new Map([["t", meta]]), enumMap);
             expect(result).not.toContain("storagePath");
-            expect(result).toContain("enumValues");
+            expect(result).toContain("enum:");
         });
     });
 
@@ -285,22 +285,40 @@ describe("generateCollectionFile", () => {
     });
 
     describe("inverse relation (other table -> this table)", () => {
-        it("generates a one-to-many inverse relation", () => {
+        it("generates a one-to-many inverse relation in the relations array", () => {
             const allFks: ForeignKeyRow[] = [mkFk("comments", "post_id", "posts")];
             const meta = makeSimpleTable("posts", [
                 mkCol("posts", "id", { data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
             ]);
             const result = generateCollectionFile("posts", meta, allFks, new Set(), new Map([["posts", meta]]), new Map());
             expect(result).toContain('import commentsCollection from "./comments"');
+            // Should be in the relations array, not as an inline property
+            expect(result).toContain('relations: [');
+            expect(result).toContain('relationName: "comments"');
             expect(result).toContain('cardinality: "many"');
             expect(result).toContain('direction: "inverse"');
             expect(result).toContain('inverseRelationName: "post"');
             expect(result).toContain('foreignKeyOnTarget: "post_id"');
+            // Should NOT appear as an inline property with type: "relation"
+            const propsSection = result.split('properties:')[1].split('relations:')[0];
+            expect(propsSection).not.toContain('"relation"');
+        });
+
+        it("does NOT include inverse relations in propertiesOrder", () => {
+            const allFks: ForeignKeyRow[] = [mkFk("comments", "post_id", "posts")];
+            const meta = makeSimpleTable("posts", [
+                mkCol("posts", "id", { data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+            ]);
+            const result = generateCollectionFile("posts", meta, allFks, new Set(), new Map([["posts", meta]]), new Map());
+            const orderMatch = result.match(/propertiesOrder:\s*(\[[\s\S]*?\])/);
+            expect(orderMatch).toBeTruthy();
+            const orderBlock = orderMatch![1];
+            expect(orderBlock).not.toContain('"comments"');
         });
     });
 
     describe("many-to-many relations", () => {
-        it("generates owning M2M with through config for alphabetically-first table", () => {
+        it("generates owning M2M with through config in relations array", () => {
             const jtFks: ForeignKeyRow[] = [
                 mkFk("articles_tags", "article_id", "articles"),
                 mkFk("articles_tags", "tag_id", "tags"),
@@ -317,13 +335,15 @@ describe("generateCollectionFile", () => {
             const joinTables = new Set(["articles_tags"]);
 
             const result = generateCollectionFile("articles", articlesMeta, [], joinTables, tablesMap, new Map());
+            expect(result).toContain('relations: [');
+            expect(result).toContain('relationName: "tags"');
             expect(result).toContain('direction: "owning"');
             expect(result).toContain('table: "articles_tags"');
             expect(result).toContain('sourceColumn: "article_id"');
             expect(result).toContain('targetColumn: "tag_id"');
         });
 
-        it("generates inverse M2M for alphabetically-second table", () => {
+        it("generates inverse M2M in relations array", () => {
             const jtFks: ForeignKeyRow[] = [
                 mkFk("articles_tags", "article_id", "articles"),
                 mkFk("articles_tags", "tag_id", "tags"),
@@ -340,12 +360,13 @@ describe("generateCollectionFile", () => {
             const joinTables = new Set(["articles_tags"]);
 
             const result = generateCollectionFile("tags", tagsMeta, [], joinTables, tablesMap, new Map());
+            expect(result).toContain('relations: [');
             expect(result).toContain('direction: "inverse"');
         });
     });
 
     describe("self-referencing M2M", () => {
-        it("generates self-ref M2M with _via_ property name", () => {
+        it("generates self-ref M2M with _via_ relation name in relations array", () => {
             const jtFks: ForeignKeyRow[] = [
                 mkFk("user_friends", "user_id", "users"),
                 mkFk("user_friends", "friend_id", "users"),
@@ -362,7 +383,8 @@ describe("generateCollectionFile", () => {
             const joinTables = new Set(["user_friends"]);
 
             const result = generateCollectionFile("users", usersMeta, [], joinTables, tablesMap, new Map());
-            expect(result).toContain("users_via_friend");
+            expect(result).toContain('relations: [');
+            expect(result).toContain('relationName: "users_via_friend"');
             expect(result).toContain('table: "user_friends"');
             expect(result).toContain('sourceColumn: "user_id"');
             expect(result).toContain('targetColumn: "friend_id"');