@rebasepro/server-postgresql 0.0.1-canary.7f31c25 → 0.0.1-canary.892f711

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgresql",
   "type": "module",
-  "version": "0.0.1-canary.7f31c25",
+  "version": "0.0.1-canary.892f711",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -64,10 +64,10 @@
     "drizzle-orm": "^0.44.4",
     "execa": "^4.1.0",
     "pg": "^8.11.3",
-    "@rebasepro/common": "0.0.1-canary.7f31c25",
-    "@rebasepro/types": "0.0.1-canary.7f31c25",
-    "@rebasepro/server-core": "0.0.1-canary.7f31c25",
-    "@rebasepro/utils": "0.0.1-canary.7f31c25"
+    "@rebasepro/common": "0.0.1-canary.892f711",
+    "@rebasepro/server-core": "0.0.1-canary.892f711",
+    "@rebasepro/types": "0.0.1-canary.892f711",
+    "@rebasepro/utils": "0.0.1-canary.892f711"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/cli.ts

@@ -43,7 +43,7 @@ export async function runPluginCommand(args: string[]) {
 }
 
 async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
-    const VALID_ACTIONS = ["push", "pull", "generate", "migrate", "studio", "branch"];
+    const VALID_ACTIONS = ["push", "generate", "migrate", "studio", "branch"];
     if (!subcommand || !VALID_ACTIONS.includes(subcommand)) {
         console.error(chalk.red(`Unknown db command. Valid: ${VALID_ACTIONS.join(", ")}`));
         process.exit(1);

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,`;
         }
@@ -379,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);
 
@@ -402,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",
@@ -426,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;
@@ -445,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",
@@ -470,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}";`);
@@ -479,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}
@@ -499,6 +497,10 @@ export function generateCollectionFile(
         }
     }
 
+    const relationsBlock = relationsOutput
+        ? `\n    relations: [${relationsOutput}\n    ],`
+        : "";
+
     const fileContent = `${Array.from(imports).join("\n")}
 
 const ${tableName}Collection: PostgresCollection = {
@@ -509,7 +511,7 @@ const ${tableName}Collection: PostgresCollection = {
     icon: "${icon}",
     group: "App",
     properties: {${propsOutput}
-    },
+    },${relationsBlock}
     propertiesOrder: ${JSON.stringify(propertiesOrder, null, 8).replace(/]$/, "    ]")}
 };
 

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