@rebasepro/server-postgresql 0.0.1-canary.6e26b67 → 0.0.1-canary.892f711

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

@@ -281,6 +281,7 @@ export function generateCollectionFile(
     const imports = new Set<string>(['import { PostgresCollection } from "@rebasepro/types";']);
 
     let propsOutput = ``;
+    let relationsOutput = ``;
     const propertiesOrder: string[] = [];
 
     // Detect composite primary keys
@@ -289,7 +290,8 @@ export function generateCollectionFile(
     // Map columns
     for (const col of meta.columns) {
         // Skip foreign keys since we handle them as relations
-        if (meta.fks.some((fk) => fk.column_name === col.column_name)) continue;
+        // Exception: Do not skip if it's part of the primary key!
+        if (meta.fks.some((fk) => fk.column_name === col.column_name) && !meta.pks.includes(col.column_name)) continue;
 
         propertiesOrder.push(col.column_name);
 
@@ -302,22 +304,22 @@ export function generateCollectionFile(
 
         const colNameLower = col.column_name.toLowerCase();
 
-        // Enum values — generate real enumValues from the PG enum
+        // Enum values — generate real enum from the PG enum
         if (isEnumColumn && colEnumValues) {
             const enumEntries = colEnumValues
                 .map((v) => `{ id: "${v}", label: "${humanize(v)}" }`)
                 .join(", ");
-            extra = `\n            enumValues: [${enumEntries}],`;
+            extra = `\n            enum: [${enumEntries}],`;
         }
 
         // Date auto-value heuristics
         if (propType === "date") {
             if (colNameLower === "created_at" || colNameLower === "createdat") {
-                extra = `\n            autoValue: "on_create",\n            readOnly: true,\n            hideFromCollection: true,`;
+                extra = `\n            autoValue: "on_create",\n            ui: {\n                readOnly: true,\n                hideFromCollection: true\n            },`;
             } else if (colNameLower === "updated_at" || colNameLower === "updatedat") {
-                extra = `\n            autoValue: "on_update",\n            readOnly: true,\n            hideFromCollection: true,`;
+                extra = `\n            autoValue: "on_update",\n            ui: {\n                readOnly: true,\n                hideFromCollection: true\n            },`;
             } else if (col.column_default && (col.column_default.includes("now()") || col.column_default.includes("CURRENT_TIMESTAMP"))) {
-                extra = `\n            autoValue: "on_create",\n            readOnly: true,`;
+                extra = `\n            autoValue: "on_create",\n            ui: {\n                readOnly: true\n            },`;
             }
         }
 
@@ -330,7 +332,7 @@ export function generateCollectionFile(
                 // We'll just call mapPgType on the baseType
                 innerType = mapPgType(baseType);
             }
-            extra = `\n            of: { type: "${innerType}" },`;
+            extra = `\n            of: { name: "${humanize(col.column_name)} Item", type: "${innerType}" },`;
         } else if (propType === "map") {
             extra = `\n            keyValue: true,`;
         }
@@ -370,6 +372,7 @@ export function generateCollectionFile(
         propsOutput += `
         ${col.column_name}: {
             name: "${humanName}",
+            columnName: "${col.column_name}",
             type: "${propType}",${extra}
         },`;
     }
@@ -378,7 +381,12 @@ export function generateCollectionFile(
     for (const fk of meta.fks) {
         const targetTableName = fk.foreign_table_name;
         if (!joinTables.has(targetTableName)) {
-            const relName = fk.column_name.replace(/_id$/, "");
+            let relName = fk.column_name.replace(/_id$/, "");
+            if (meta.pks.includes(fk.column_name) && relName === fk.column_name) {
+                // If the FK is also the PK and its name doesn't imply a relation (like "id"),
+                // use the target table name to avoid conflicting with the PK property.
+                relName = targetTableName;
+            }
             // Push the relation property key, not the FK column name
             propertiesOrder.push(relName);
 
@@ -401,21 +409,19 @@ export function generateCollectionFile(
     }
 
     // Map Inverse Relations (1-to-many where OTHER table points to THIS table)
+    // These go into the `relations` array so they render as subcollection tabs.
     const inverseFks = allFks.filter((fk) => fk.foreign_table_name === tableName && !joinTables.has(fk.table_name));
     for (const fk of inverseFks) {
         const sourceTableName = fk.table_name;
-        propertiesOrder.push(sourceTableName);
 
         const targetCollectionCamel = toCollectionVarName(sourceTableName);
         imports.add(`import ${targetCollectionCamel} from "./${sourceTableName}";`);
 
         const inverseRelName = fk.column_name.replace(/_id$/, "");
-        const relHumanName = humanize(sourceTableName);
 
-        propsOutput += `
-        ${sourceTableName}: {
-            name: "${relHumanName}",
-            type: "relation",
+        relationsOutput += `
+        {
+            relationName: "${sourceTableName}",
             target: () => ${targetCollectionCamel},
             cardinality: "many",
             direction: "inverse",
@@ -425,6 +431,7 @@ export function generateCollectionFile(
     }
 
     // Map Many-to-Many Relations (Join Tables)
+    // These also go into the `relations` array so they render as subcollection tabs.
     const relatedJoinTables = Array.from(joinTables).filter((jt) => {
         const jtMeta = tablesMap.get(jt);
         return jtMeta ? jtMeta.fks.some((fk) => fk.foreign_table_name === tableName) : false;
@@ -444,15 +451,10 @@ export function generateCollectionFile(
             const otherFk = selfRefFks[1];
 
             const relPropName = `${tableName}_via_${otherFk.column_name.replace(/_id$/, "")}`;
-            propertiesOrder.push(relPropName);
-
-            // Self-ref: import is the same collection (use a lazy reference)
-            const relHumanName = humanize(otherFk.column_name.replace(/_id$/, ""));
 
-            propsOutput += `
-        ${relPropName}: {
-            name: "${relHumanName}",
-            type: "relation",
+            relationsOutput += `
+        {
+            relationName: "${relPropName}",
             target: () => ${tableName}Collection,
             cardinality: "many",
             direction: "owning",
@@ -469,7 +471,6 @@ export function generateCollectionFile(
 
         if (otherFk) {
             const targetTableName = otherFk.foreign_table_name;
-            propertiesOrder.push(targetTableName);
 
             const targetCollectionCamel = toCollectionVarName(targetTableName);
             imports.add(`import ${targetCollectionCamel} from "./${targetTableName}";`);
@@ -478,19 +479,17 @@ export function generateCollectionFile(
             const direction = tableName < targetTableName ? "owning" : "inverse";
 
             const thisFk = joinFks.find((fk) => fk.foreign_table_name === tableName);
-            const relHumanName = humanize(targetTableName);
 
             let throughCode = "";
             if (direction === "owning" && thisFk) {
-                throughCode = `\n            through: {\n                table: "${jt}",\n                sourceColumn: "${thisFk.column_name}",\n                targetColumn: "${otherFk.column_name}"\n            }`;
+                throughCode = `\n            through: {\n                table: "${jt}",\n                sourceColumn: "${thisFk.column_name}",\n                targetColumn: "${otherFk.column_name}"\n            },`;
             } else if (direction === "inverse") {
                 throughCode = `\n            // Make sure the target collection configures the 'through' property.`;
             }
 
-            propsOutput += `
-        ${targetTableName}: {
-            name: "${relHumanName}",
-            type: "relation",
+            relationsOutput += `
+        {
+            relationName: "${targetTableName}",
             target: () => ${targetCollectionCamel},
             cardinality: "many",
             direction: "${direction}",${throughCode}
@@ -498,6 +497,10 @@ export function generateCollectionFile(
         }
     }
 
+    const relationsBlock = relationsOutput
+        ? `\n    relations: [${relationsOutput}\n    ],`
+        : "";
+
     const fileContent = `${Array.from(imports).join("\n")}
 
 const ${tableName}Collection: PostgresCollection = {
@@ -508,7 +511,7 @@ const ${tableName}Collection: PostgresCollection = {
     icon: "${icon}",
     group: "App",
     properties: {${propsOutput}
-    },
+    },${relationsBlock}
     propertiesOrder: ${JSON.stringify(propertiesOrder, null, 8).replace(/]$/, "    ]")}
 };
 

package/src/services/EntityPersistService.ts

@@ -111,7 +111,7 @@ export class EntityPersistService {
                             targetColumnName = relation.localKey;
                         } else if (relation.foreignKeyOnTarget) {
                             targetColumnName = relation.foreignKeyOnTarget;
-                        } else if (relation.joinPath && relation.joinPath.length > 0) {
+                        } else if (relation.joinPath && relation.joinPath.length === 1) {
                             const targetTableName = getTableName(targetCollection);
                             const relevantJoinStep = relation.joinPath.find(joinStep => joinStep.table === targetTableName);
 
@@ -123,6 +123,12 @@ export class EntityPersistService {
                                 const targetColumnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(relation.joinPath[0].on.to);
                                 targetColumnName = targetColumnNames[0];
                             }
+                        } else if (relation.joinPath && relation.joinPath.length > 1) {
+                            // For multi-hop relations (like many-to-many through a junction table),
+                            // there is no direct foreign key on the target table pointing to the parent.
+                            // The relationship is managed via the junction table.
+                            // We shouldn't inject the parent ID directly into the target entity payload.
+                            break;
                         } else {
                             throw new Error(`Relation '${relationKey}' lacks configuration for path-based saving.`);
                         }

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/introspect-db-generation.test.ts

@@ -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"');

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