@rebasepro/server-postgresql 0.0.1-canary.09e5ec5 → 0.0.1-canary.3263433

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

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());
     });

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