@rebasepro/server-postgresql 0.0.1-canary.629af03 → 0.0.1-canary.94dff14

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgresql",
   "type": "module",
-  "version": "0.0.1-canary.629af03",
+  "version": "0.0.1-canary.94dff14",
   "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/server-core": "0.0.1-canary.629af03",
-    "@rebasepro/types": "0.0.1-canary.629af03",
-    "@rebasepro/utils": "0.0.1-canary.629af03",
-    "@rebasepro/common": "0.0.1-canary.629af03"
+    "@rebasepro/common": "0.0.1-canary.94dff14",
+    "@rebasepro/utils": "0.0.1-canary.94dff14",
+    "@rebasepro/server-core": "0.0.1-canary.94dff14",
+    "@rebasepro/types": "0.0.1-canary.94dff14"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

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

@@ -159,7 +159,7 @@ export function mapPgType(dataType: string): string {
     if (dt === "interval") return "string";
 
     // Array types MUST be checked before numeric ("_int4" contains "int")
-    if (dt === "array" || dt.startsWith("_")) return "json";
+    if (dt === "array" || dt.startsWith("_")) return "array";
 
     // Numeric types
     if (
@@ -183,7 +183,7 @@ export function mapPgType(dataType: string): string {
     if (dt.includes("time") || dt.includes("date")) return "date";
 
     // JSON
-    if (dt === "json" || dt === "jsonb") return "json";
+    if (dt === "json" || dt === "jsonb") return "map";
 
     // Binary
     if (dt === "bytea") return "string";
@@ -321,6 +321,20 @@ export function generateCollectionFile(
             }
         }
 
+        // Array/Map heuristics
+        if (propType === "array") {
+            let innerType = "string";
+            if (col.udt_name.startsWith("_")) {
+                const baseType = col.udt_name.substring(1);
+                // Simple recursive check or hardcoded for inner type:
+                // We'll just call mapPgType on the baseType
+                innerType = mapPgType(baseType);
+            }
+            extra = `\n            of: { type: "${innerType}" },`;
+        } else if (propType === "map") {
+            extra = `\n            keyValue: true,`;
+        }
+
         // String sub-type heuristics (skip if already handled as enum)
         if (propType === "string" && !isEnumColumn) {
             if (colNameLower.includes("image") || colNameLower.includes("avatar") || colNameLower.includes("photo") || colNameLower.includes("logo") || colNameLower.includes("cover")) {
@@ -509,11 +523,14 @@ export default ${tableName}Collection;
  */
 export function generateIndexContent(fileNames: string[]): string {
     const sorted = [...fileNames].sort();
-    let content = "";
+    let imports = "";
+    let arrayElements = "";
     for (const f of sorted) {
-        content += `export { default as ${f} } from "./${f}";\n`;
+        const varName = toCollectionVarName(f);
+        imports += `import ${varName} from "./${f}";\n`;
+        arrayElements += `    ${varName},\n`;
     }
-    return content;
+    return `${imports}\nexport const collections = [\n${arrayElements}];\n`;
 }
 
 /**
@@ -521,17 +538,50 @@ export function generateIndexContent(fileNames: string[]): string {
  * Returns the merged content string.
  */
 export function mergeIndexContent(existingContent: string, newFileNames: string[]): string {
-    const existingExports = new Set(
-        [...existingContent.matchAll(/export\s+\{[^}]+\}\s+from\s+"\.\/([^"]+)"/g)].map((m) => m[1])
+    const existingImports = new Set(
+        [...existingContent.matchAll(/import\s+([a-zA-Z0-9_]+)\s+from\s+"\.\/([^"]+)"/g)].map((m) => m[2])
     );
     const sorted = [...newFileNames].sort();
-    let merged = existingContent.trimEnd() + "\n";
+    
+    let newImports = "";
+    let newElements = "";
+    
     for (const f of sorted) {
-        if (!existingExports.has(f)) {
-            merged += `export { default as ${f} } from "./${f}";\n`;
+        if (!existingImports.has(f)) {
+            const varName = toCollectionVarName(f);
+            newImports += `import ${varName} from "./${f}";\n`;
+            newElements += `    ${varName},\n`;
         }
     }
-    return merged;
+    
+    if (!newImports) return existingContent;
+    
+    // Simple injection logic:
+    // Add new imports below the last import or at the top
+    const importRegex = /import\s+.*?;/g;
+    let lastImportMatch;
+    let match;
+    while ((match = importRegex.exec(existingContent)) !== null) {
+        lastImportMatch = match;
+    }
+    
+    let contentWithImports = existingContent;
+    if (lastImportMatch) {
+        const pos = lastImportMatch.index + lastImportMatch[0].length;
+        contentWithImports = existingContent.slice(0, pos) + "\n" + newImports.trimEnd() + existingContent.slice(pos);
+    } else {
+        contentWithImports = newImports + "\n" + existingContent;
+    }
+    
+    // Inject into the `collections = [...]` array
+    const arrayRegex = /export\s+const\s+collections\s*=\s*\[([\s\S]*?)\];/;
+    return contentWithImports.replace(arrayRegex, (fullMatch, arrayContent) => {
+        let mergedArray = arrayContent.trimEnd();
+        if (mergedArray && !mergedArray.endsWith(",")) mergedArray += ",";
+        if (mergedArray) mergedArray += "\n";
+        mergedArray += newElements.trimEnd();
+        return `export const collections = [\n    ${mergedArray.trim()}\n];`;
+    });
 }
 
 /**

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

@@ -49,7 +49,7 @@ describe("generateCollectionFile", () => {
             expect(result).toContain('type: "number"');
             expect(result).toContain('type: "boolean"');
             expect(result).toContain('type: "date"');
-            expect(result).toContain('type: "json"');
+            expect(result).toContain('type: "map"');
         });
 
         it("skips FK columns from properties (they become relations)", () => {

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

@@ -190,14 +190,14 @@ describe("mapPgType", () => {
             expect(mapPgType(t)).toBe("date");
         }
     });
-    it("maps JSON types to json", () => {
-        expect(mapPgType("json")).toBe("json");
-        expect(mapPgType("jsonb")).toBe("json");
+    it("maps JSON types to map", () => {
+        expect(mapPgType("json")).toBe("map");
+        expect(mapPgType("jsonb")).toBe("map");
     });
-    it("maps ARRAY and underscore-prefixed types to json", () => {
-        expect(mapPgType("ARRAY")).toBe("json");
-        expect(mapPgType("_int4")).toBe("json");
-        expect(mapPgType("_text")).toBe("json");
+    it("maps ARRAY and underscore-prefixed types to array", () => {
+        expect(mapPgType("ARRAY")).toBe("array");
+        expect(mapPgType("_int4")).toBe("array");
+        expect(mapPgType("_text")).toBe("array");
     });
     it("maps string-like types to string", () => {
         for (const t of ["text", "varchar", "character varying", "char", "character", "uuid", "bytea", "inet", "cidr", "macaddr", "macaddr8", "interval"]) {
@@ -350,9 +350,12 @@ describe("generateIndexContent", () => {
         expect(lines[2]).toContain("zebra");
     });
 
-    it("each line is a default re-export", () => {
+    it("generates import statements and collections array", () => {
         const result = generateIndexContent(["users"]);
-        expect(result).toBe('export { default as users } from "./users";\n');
+        expect(result).toContain('import usersCollection from "./users";');
+        expect(result).toContain('export const collections = [');
+        expect(result).toContain('    usersCollection,');
+        expect(result).toContain('];');
     });
 });
 
@@ -361,16 +364,16 @@ describe("generateIndexContent", () => {
 // ═══════════════════════════════════════════════════════════════════════
 describe("mergeIndexContent", () => {
     it("adds new exports without duplicating existing ones", () => {
-        const existing = 'export { default as users } from "./users";\n';
+        const existing = 'import usersCollection from "./users";\n\nexport const collections = [\n    usersCollection,\n];\n';
         const result = mergeIndexContent(existing, ["users", "posts"]);
-        expect(result.match(/users/g)!.length).toBe(2); // one in existing, one mention in "users" still just 1 export line
-        expect(result).toContain('export { default as posts } from "./posts";');
-        // users should appear exactly once as an export statement
-        expect(result.match(/export.*users.*from/g)!.length).toBe(1);
+        expect(result.match(/import usersCollection from ".\/users";/g)!.length).toBe(1);
+        expect(result).toContain('import postsCollection from "./posts";');
+        expect(result).toContain('usersCollection,');
+        expect(result).toContain('postsCollection,');
     });
 
     it("returns existing content trimmed + newline when no new files", () => {
-        const existing = 'export { default as a } from "./a";\n';
+        const existing = 'import aCollection from "./a";\n\nexport const collections = [\n    aCollection,\n];\n';
         const result = mergeIndexContent(existing, ["a"]);
         expect(result.trim()).toBe(existing.trim());
     });