@rebasepro/server-postgresql 0.0.1-canary.6e26b67 → 0.0.1-canary.7f31c25

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,170 @@ 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"');
+    });
+});

package/test/relations.test.ts

@@ -382,8 +382,8 @@ relationName: "author" }
             // 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: \"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: \"profiles_author_id\" }) }));");
+            // Should create inverse relation on authors — inverse side has NO fields/references
+            expect(cleanResult).toContain("export const authorsRelations = drizzleRelations(authors, ({ one, many }) => ({ \"profile\": one(profiles, { relationName: \"profiles_author_id\" }) }));");
         });
 
         it("should generate owning one-to-many relations", async () => {
@@ -818,9 +818,9 @@ relationName: "user" }
             `"user": one(users, { fields: [profiles.user_id], references: [users.id], relationName: \"${expectedSharedName}\" })`
         );
 
-        // Inverse side (users → profiles)
+        // Inverse side (users → profiles) — no fields/references, paired by relationName only
         expect(cleanResult).toContain(
-            `"profile": one(profiles, { fields: [users.id], references: [profiles.user_id], relationName: \"${expectedSharedName}\" })`
+            `"profile": one(profiles, { relationName: \"${expectedSharedName}\" })`
         );
 
         // Both must match