@rebasepro/server-postgresql 0.6.1 → 0.8.0

package/test/unmapped-tables-safety.test.ts

@@ -1,353 +1,66 @@
-/**
- * Tests to verify that Rebase schema generation and drizzle-kit configuration
- * never attempt to drop/modify tables, enums, or other database objects
- * that are NOT defined in the managed schema.
- *
- * How the safety mechanism works:
- *
- *   1. `tablesFilter` in drizzle.config.ts tells drizzle-kit which tables to
- *      introspect from the live database. Tables not in the filter are INVISIBLE
- *      to drizzle-kit — they never enter the diff snapshot, so they can't appear
- *      in DROP TABLE statements.
- *
- *   2. `schemaFilter` restricts to the "public" PostgreSQL schema, so tables in
- *      other schemas (extensions, internal, etc.) are also invisible.
- *
- *   3. `entities.roles: false` prevents drizzle-kit from managing database roles.
- *
- *   4. `extensionsFilters: ["postgis"]` ignores extension-managed tables.
- *
- *   5. The CLI always passes `--strict --verbose` to `db push`, so destructive
- *      operations require explicit confirmation even if something slips through.
- *
- * These tests verify:
- *   - The schema generator outputs correct table/enum lists for tablesFilter
- *   - The tablesFilter scoping correctly excludes unmapped tables
- *   - The drizzle-kit diff engine produces no destructive SQL when the previous
- *     snapshot only contains managed tables (simulating what tablesFilter provides)
- *   - Unmapped tables in the raw snapshot DO produce DROP statements (proving
- *     the tablesFilter is the critical safety boundary, not the diff engine)
- */
-import { generateDrizzleJson, generateMigration } from "drizzle-kit/api";
-import { pgTable, varchar, text, integer, boolean, pgEnum } from "drizzle-orm/pg-core";
-import { getTableName, Table } from "drizzle-orm";
-import { EntityCollection } from "@rebasepro/types";
-import { generateSchema } from "../src/schema/generate-drizzle-schema-logic";
-
-// ── Helpers ─────────────────────────────────────────────────────────────
-
-function buildPrevSnapshot(tables: Record<string, any>, enums: Record<string, any> = {}) {
-    return {
-        id: "prev-snapshot",
-        prevId: "prev-prev-snapshot",
-        version: "7",
-        dialect: "postgresql",
-        tables,
-        enums,
-        schemas: {},
-        sequences: {},
-        roles: {},
-        policies: {},
-        views: {},
-        _meta: { schemas: {},
-tables: {},
-columns: {} }
-    };
-}
-
-function snapshotTable(name: string, columns: Record<string, any>) {
-    return {
-        name,
-        schema: "",
-        columns,
-        indexes: {},
-        foreignKeys: {},
-        compositePrimaryKeys: {},
-        uniqueConstraints: {},
-        policies: {},
-        checkConstraints: {},
-        isRLSEnabled: false
-    };
-}
-
-function snapshotColumn(name: string, type: string, opts: {
-    primaryKey?: boolean;
-    notNull?: boolean;
-} = {}) {
-    return {
-        name,
-        type,
-        primaryKey: opts.primaryKey ?? false,
-        notNull: opts.notNull ?? (opts.primaryKey ?? false),
-        default: undefined
-    };
-}
-
-function snapshotEnum(name: string, schema: string, values: string[]) {
-    return { name,
-schema,
-values };
-}
-
-// ── Drizzle schema objects (the "managed" schema) ───────────────────────
-
-const managedUsers = pgTable("users", {
-    id: varchar("id").primaryKey(),
-    name: varchar("name"),
-    email: varchar("email")
-});
-
-const managedPosts = pgTable("posts", {
-    id: varchar("id").primaryKey(),
-    title: varchar("title").notNull(),
-    user_id: varchar("user_id")
-});
-
-// ── Tests ───────────────────────────────────────────────────────────────
-
-describe("Unmapped tables safety", () => {
-
-    describe("tablesFilter scoping", () => {
-
-        it("should extract only managed table names from the tables export", () => {
-            const tables = { managedUsers,
-managedPosts };
-            const tableNames = Object.values(tables).map(t => getTableName(t as Table));
-
-            expect(tableNames).toEqual(["users", "posts"]);
-            expect(tableNames).not.toContain("legacy_orders");
-            expect(tableNames).not.toContain("external_analytics");
-        });
-
-        it("should produce a tablesFilter that excludes unmapped tables", () => {
-            const tables = { managedUsers,
-managedPosts };
-            const tablesFilter = Object.values(tables).map(t => getTableName(t as Table));
-
-            const unmappedTables = [
-                "legacy_orders",
-                "external_analytics",
-                "stripe_webhooks",
-                "audit_log"
-            ];
-
-            for (const unmapped of unmappedTables) {
-                expect(tablesFilter).not.toContain(unmapped);
-            }
-        });
-
-        it("should produce stable, deterministic table names regardless of export key names", () => {
-            // The table name comes from pgTable("table_name", ...), not the JS variable name
-            const weirdVarName = pgTable("actual_table_name", {
-                id: varchar("id").primaryKey()
-            });
-            expect(getTableName(weirdVarName as Table)).toBe("actual_table_name");
-        });
-    });
-
-    describe("tablesFilter as the safety boundary — proof by contradiction", () => {
-
-        it("without tablesFilter: drizzle-kit WOULD drop unmapped tables (proving tablesFilter is essential)", async () => {
-            // If unmapped tables leak into the prev snapshot (i.e. tablesFilter is NOT applied),
-            // drizzle-kit's diff engine WILL generate DROP TABLE statements.
-            // This test proves that tablesFilter is the critical safety layer.
-            const prevWithUnmapped = buildPrevSnapshot({
-                "public.users": snapshotTable("users", {
-                    id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                    name: snapshotColumn("name", "varchar"),
-                    email: snapshotColumn("email", "varchar")
-                }),
-                // An unmapped table that leaked into the snapshot
-                "public.legacy_orders": snapshotTable("legacy_orders", {
-                    id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                    amount: snapshotColumn("amount", "integer")
-                })
-            });
-
-            const curJson = generateDrizzleJson({ managedUsers });
-            const statements = await generateMigration(prevWithUnmapped as any, curJson as any);
-            const sql = statements.join("\n");
-
-            // WITHOUT tablesFilter, drizzle-kit WOULD drop the unmapped table.
-            // This is expected behavior — it proves tablesFilter is essential.
-            expect(sql).toContain("DROP TABLE");
-            expect(sql).toContain("legacy_orders");
-        });
-
-        it("without tablesFilter: drizzle-kit WOULD drop unmapped enums (proving tablesFilter scope is essential)", async () => {
-            const prevWithUnmappedEnum = buildPrevSnapshot(
-                {
-                    "public.users": snapshotTable("users", {
-                        id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                        name: snapshotColumn("name", "varchar"),
-                        email: snapshotColumn("email", "varchar")
-                    })
-                },
-                {
-                    "public.order_priority": snapshotEnum("order_priority", "public", ["low", "medium", "high"])
-                }
-            );
-
-            const curJson = generateDrizzleJson({ managedUsers });
-            const statements = await generateMigration(prevWithUnmappedEnum as any, curJson as any);
-            const sql = statements.join("\n");
-
-            // Without filtering, drizzle-kit drops the unmapped enum
-            expect(sql).toContain("DROP TYPE");
-            expect(sql).toContain("order_priority");
-        });
-    });
-
-    describe("with tablesFilter applied: only managed tables enter the diff", () => {
-
-        it("should produce zero migration statements when managed schema is unchanged", async () => {
-            // Simulate: tablesFilter ensures only managed tables appear in the snapshot
-            const prevOnlyManaged = buildPrevSnapshot({
-                "public.users": snapshotTable("users", {
-                    id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                    name: snapshotColumn("name", "varchar"),
-                    email: snapshotColumn("email", "varchar")
-                }),
-                "public.posts": snapshotTable("posts", {
-                    id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                    title: snapshotColumn("title", "varchar", { notNull: true }),
-                    user_id: snapshotColumn("user_id", "varchar")
-                })
-            });
-
-            const curJson = generateDrizzleJson({ managedUsers,
-managedPosts });
-            const statements = await generateMigration(prevOnlyManaged as any, curJson as any);
-
-            // No changes needed — managed schema is identical
-            expect(statements.length).toBe(0);
-        });
-
-        it("should correctly detect changes to managed tables without touching anything else", async () => {
-            // Prev: users has id + name (missing email)
-            const prevOnlyManaged = buildPrevSnapshot({
-                "public.users": snapshotTable("users", {
-                    id: snapshotColumn("id", "varchar", { primaryKey: true }),
-                    name: snapshotColumn("name", "varchar")
-                })
-            });
-
-            const curJson = generateDrizzleJson({ managedUsers });
-            const statements = await generateMigration(prevOnlyManaged as any, curJson as any);
-            const sql = statements.join("\n");
-
-            // Should add the email column
-            expect(sql.toLowerCase()).toContain("alter table");
-            expect(sql).toContain("email");
-
-            // Should NOT contain any DROP TABLE
-            expect(sql).not.toContain("DROP TABLE");
-        });
-    });
-
-    describe("schema generation exports correct metadata for tablesFilter", () => {
-
-        it("should export a tables object containing all and only defined collection tables", async () => {
-            const collections: EntityCollection[] = [
-                {
-                    slug: "products",
-                    table: "products",
-                    name: "Products",
-                    properties: {
-                        name: { type: "string" },
-                        price: { type: "number" }
-                    }
-                },
-                {
-                    slug: "categories",
-                    table: "categories",
-                    name: "Categories",
-                    properties: {
-                        title: { type: "string" }
-                    }
-                }
-            ];
-
-            const result = await generateSchema(collections);
-
-            expect(result).toContain("export const tables = {");
-            expect(result).toContain("products");
-            expect(result).toContain("categories");
-            expect(result).not.toContain("legacy_orders");
-        });
-
-        it("should include junction tables in the tables export for M2M relations", async () => {
-            const postsCollection: EntityCollection = {
+import { getTableIncludesFromCollections } from "../src/cli-helpers";
+
+describe("Unmapped tables safety with Atlas", () => {
+    it("should produce include filters only for managed tables and M2M junction tables", async () => {
+        const mockCollections = [
+            {
+                slug: "users",
+                table: "users",
+                properties: { name: { type: "string" } }
+            },
+            {
                 slug: "posts",
                 table: "posts",
-                name: "Posts",
                 properties: {
-                    title: { type: "string" },
-                    tags: { type: "relation",
-relationName: "tags" }
+                    title: { type: "string" }
                 },
-                relations: [{
-                    relationName: "tags",
-                    target: () => tagsCollection,
-                    cardinality: "many",
-                    direction: "owning",
-                    through: {
-                        table: "posts_to_tags",
-                        sourceColumn: "post_id",
-                        targetColumn: "tag_id"
+                relations: [
+                    {
+                        relationName: "tags",
+                        target: () => ({ table: "tags", slug: "tags" }),
+                        cardinality: "many",
+                        direction: "owning",
+                        through: {
+                            table: "posts_to_tags",
+                            sourceColumn: "post_id",
+                            targetColumn: "tag_id"
+                        }
                     }
-                }]
-            };
-            const tagsCollection: EntityCollection = {
-                slug: "tags",
-                table: "tags",
-                name: "Tags",
-                properties: { name: { type: "string" } }
-            };
-
-            const result = await generateSchema([postsCollection, tagsCollection]);
-
-            // Junction table must appear in the tables export
-            expect(result).toContain("export const tables = {");
-            expect(result).toContain("postsToTags");
-        });
+                ]
+            }
+        ];
+
+        const includes = await getTableIncludesFromCollections(mockCollections);
+
+        // Verify only managed tables and their junctions are included
+        expect(includes).toContain("public.users");
+        expect(includes).toContain("public.posts");
+        expect(includes).toContain("public.posts_to_tags");
+
+        // Verify unmapped tables are NOT included, ensuring they are ignored by Atlas --include filters
+        const unmappedTables = [
+            "public.legacy_orders",
+            "public.external_analytics",
+            "public.stripe_webhooks",
+            "public.audit_log"
+        ];
+        for (const unmapped of unmappedTables) {
+            expect(includes).not.toContain(unmapped);
+        }
+    });
 
-        it("should export enums for schema-defined enum types", async () => {
-            const collections: EntityCollection[] = [{
+    it("should support custom schemas in table include paths", async () => {
+        const mockCollections = [
+            {
                 slug: "orders",
                 table: "orders",
-                name: "Orders",
-                properties: {
-                    status: {
-                        type: "string",
-                        enumValues: ["pending", "shipped", "delivered"]
-                    }
-                }
-            }];
-
-            const result = await generateSchema(collections);
-
-            expect(result).toContain("export const enums = {");
-        });
-    });
-
-    describe("drizzle.config.ts safety properties", () => {
-
-        it("schemaFilter should restrict to public schema only", () => {
-            const schemaFilter = ["public"];
-            expect(schemaFilter).toEqual(["public"]);
-            expect(schemaFilter).not.toContain("information_schema");
-            expect(schemaFilter).not.toContain("pg_catalog");
-        });
-
-        it("entities.roles should be false to prevent managing DB roles", () => {
-            const entities = { roles: false };
-            expect(entities.roles).toBe(false);
-        });
+                schema: "sales",
+                properties: { id: { type: "string" } }
+            }
+        ];
 
-        it("extensionsFilters should include postgis", () => {
-            const extensionsFilters = ["postgis"];
-            expect(extensionsFilters).toContain("postgis");
-        });
+        const includes = await getTableIncludesFromCollections(mockCollections);
+        expect(includes).toContain("sales.orders");
+        expect(includes).not.toContain("public.orders");
     });
 });

package/vitest.e2e.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: "node",
+        include: ["test/e2e/**/*.test.ts"],
+        testTimeout: 180_000 // 3 min — container startup + migrations
+    }
+});