@rebasepro/server-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/test/doctor.test.ts

@@ -0,0 +1,182 @@
+import { EntityCollection, StringProperty, NumberProperty, DateProperty, ArrayProperty, Property } from "@rebasepro/types";
+import { generateSchema } from "../src/schema/generate-drizzle-schema-logic";
+import { checkCollectionsVsSchema, getExpectedColumnType } from "../src/schema/doctor";
+import * as fs from "fs";
+import * as path from "path";
+import { tmpdir } from "os";
+
+// Re-export for testing — we need to access the internal helper
+// but since it's not exported, we test it indirectly via checkCollectionsVsSchema
+
+describe("Rebase Schema Doctor", () => {
+
+    describe("checkCollectionsVsSchema", () => {
+        const createTempSchemaFile = async (content: string): Promise<string> => {
+            const dir = fs.mkdtempSync(path.join(tmpdir(), "doctor-test-"));
+            const filePath = path.join(dir, "schema.generated.ts");
+            fs.writeFileSync(filePath, content, "utf-8");
+            return filePath;
+        };
+
+        it("should detect missing schema file", async () => {
+            const collections: EntityCollection[] = [{
+                slug: "products",
+                table: "products",
+                name: "Products",
+                properties: { name: { type: "string" } }
+            }];
+
+            const result = await checkCollectionsVsSchema(collections, "/nonexistent/path/schema.generated.ts");
+            expect(result.passed).toBe(false);
+            expect(result.issues).toHaveLength(1);
+            expect(result.issues[0].category).toBe("schema_stale");
+            expect(result.issues[0].severity).toBe("error");
+        });
+
+        it("should pass when schema matches collections", async () => {
+            const collections: EntityCollection[] = [{
+                slug: "products",
+                table: "products",
+                name: "Products",
+                properties: {
+                    name: { type: "string" },
+                    price: { type: "number" }
+                }
+            }];
+
+            // Generate the expected schema and write to temp file
+            const expectedSchema = await generateSchema(collections);
+            const schemaPath = await createTempSchemaFile(expectedSchema);
+
+            try {
+                const result = await checkCollectionsVsSchema(collections, schemaPath);
+                expect(result.passed).toBe(true);
+                expect(result.issues).toHaveLength(0);
+            } finally {
+                fs.rmSync(path.dirname(schemaPath), { recursive: true });
+            }
+        });
+
+        it("should detect stale schema when collections have changed", async () => {
+            const originalCollections: EntityCollection[] = [{
+                slug: "products",
+                table: "products",
+                name: "Products",
+                properties: { name: { type: "string" } }
+            }];
+
+            const updatedCollections: EntityCollection[] = [{
+                slug: "products",
+                table: "products",
+                name: "Products",
+                properties: {
+                    name: { type: "string" },
+                    price: { type: "number" } // New field added
+                }
+            }];
+
+            // Write schema for original, check against updated
+            const originalSchema = await generateSchema(originalCollections);
+            const schemaPath = await createTempSchemaFile(originalSchema);
+
+            try {
+                const result = await checkCollectionsVsSchema(updatedCollections, schemaPath);
+                expect(result.passed).toBe(false);
+                expect(result.issues.some(i => i.category === "schema_stale")).toBe(true);
+            } finally {
+                fs.rmSync(path.dirname(schemaPath), { recursive: true });
+            }
+        });
+
+        it("should return error for nonexistent schema file even with empty collections", async () => {
+            const result = await checkCollectionsVsSchema([], "/nonexistent/path");
+            // Schema file doesn't exist → error regardless of collection count
+            expect(result.passed).toBe(false);
+            expect(result.issues[0].category).toBe("schema_stale");
+        });
+    });
+
+    describe("column type mapping", () => {
+        // We test getExpectedColumnType indirectly through import
+        // These are integration-style tests against the mapping logic
+
+        it("should map string types correctly", () => {
+            expect(getExpectedColumnType({ type: "string" })).toBe("character varying");
+            expect(getExpectedColumnType({ type: "string",
+columnType: "text" } as StringProperty)).toBe("text");
+            expect(getExpectedColumnType({ type: "string",
+columnType: "char" } as StringProperty)).toBe("character");
+        });
+
+        it("should map number types correctly", () => {
+            expect(getExpectedColumnType({ type: "number" })).toBe("numeric");
+            expect(getExpectedColumnType({ type: "number",
+validation: { integer: true } } as NumberProperty)).toBe("integer");
+            expect(getExpectedColumnType({ type: "number",
+columnType: "real" } as NumberProperty)).toBe("real");
+            expect(getExpectedColumnType({ type: "number",
+columnType: "double precision" } as NumberProperty)).toBe("double precision");
+            expect(getExpectedColumnType({ type: "number",
+columnType: "bigint" } as NumberProperty)).toBe("bigint");
+        });
+
+        it("should map boolean type correctly", () => {
+            expect(getExpectedColumnType({ type: "boolean" })).toBe("boolean");
+        });
+
+        it("should map date types correctly", () => {
+            expect(getExpectedColumnType({ type: "date" })).toBe("timestamp with time zone");
+            expect(getExpectedColumnType({ type: "date",
+columnType: "date" } as DateProperty)).toBe("date");
+            expect(getExpectedColumnType({ type: "date",
+columnType: "time" } as DateProperty)).toBe("time without time zone");
+        });
+
+        it("should map json types correctly", () => {
+            expect(getExpectedColumnType({ type: "map" })).toBe("jsonb");
+            expect(getExpectedColumnType({ type: "array" })).toBe("jsonb");
+            expect(getExpectedColumnType({ type: "array",
+columnType: "json" } as ArrayProperty)).toBe("json");
+        });
+
+        it("should map enum string to USER-DEFINED", () => {
+            expect(getExpectedColumnType({
+                type: "string",
+                enum: { active: "Active",
+inactive: "Inactive" }
+            } as StringProperty)).toBe("USER-DEFINED");
+        });
+
+        it("should return null for relation type", () => {
+            expect(getExpectedColumnType({ type: "relation" } as Property)).toBe(null);
+        });
+    });
+
+    describe("report generation", () => {
+        it("should correctly count errors and warnings in summary", () => {
+            const issues = [
+                { severity: "error" as const,
+category: "missing_table" as const,
+table: "t1",
+message: "m",
+fix: "f" },
+                { severity: "warning" as const,
+category: "type_mismatch" as const,
+table: "t2",
+message: "m",
+fix: "f" },
+                { severity: "error" as const,
+category: "missing_column" as const,
+table: "t3",
+message: "m",
+fix: "f" }
+            ];
+
+            const errors = issues.filter(i => i.severity === "error").length;
+            const warnings = issues.filter(i => i.severity === "warning").length;
+
+            expect(errors).toBe(2);
+            expect(warnings).toBe(1);
+        });
+    });
+});

package/test/entityService.errors.test.ts

@@ -9,7 +9,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
     let db: jest.Mocked<NodePgDatabase<any>>;
 
     const mockTable = {
-        id: { name: "id", dataType: "number" },
+        id: { name: "id",
+dataType: "number" },
         name: { name: "name" },
         _def: { tableName: "test_table" }
     };
@@ -52,7 +53,7 @@ describe("EntityService - Error Handling & Edge Cases", () => {
             update: jest.fn().mockReturnThis(),
             set: jest.fn().mockReturnThis(),
             delete: jest.fn().mockReturnThis(),
-            transaction: jest.fn((callback) => callback(db)),
+            transaction: jest.fn((callback) => callback(db))
         } as any;
 
         // Add a then method to make the db object awaitable when the query chain ends
@@ -81,7 +82,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
 
     describe("ID Type Validation", () => {
         it("should handle valid numeric ID strings", async () => {
-            const mockEntity = { id: 123, name: "Test" };
+            const mockEntity = { id: 123,
+name: "Test" };
             db.limit.mockResolvedValue([mockEntity]);
 
             const entity = await entityService.fetchEntity("test", "123");
@@ -95,7 +97,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
         });
 
         it("should handle zero as valid ID", async () => {
-            const mockEntity = { id: 0, name: "Test" };
+            const mockEntity = { id: 0,
+name: "Test" };
             db.limit.mockResolvedValue([mockEntity]);
 
             const entity = await entityService.fetchEntity("test", 0);
@@ -103,7 +106,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
         });
 
         it("should handle negative numbers as valid ID", async () => {
-            const mockEntity = { id: -1, name: "Test" };
+            const mockEntity = { id: -1,
+name: "Test" };
             db.limit.mockResolvedValue([mockEntity]);
 
             const entity = await entityService.fetchEntity("test", -1);
@@ -176,7 +180,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
 
     describe("Concurrent Operations", () => {
         it("should handle multiple simultaneous reads", async () => {
-            const mockEntity = { id: 1, name: "Test" };
+            const mockEntity = { id: 1,
+name: "Test" };
             db.limit.mockResolvedValue([mockEntity]);
 
             const promises = Array(10).fill(0).map(() =>
@@ -193,7 +198,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
 
         it("should handle race conditions in write operations", async () => {
             db.returning.mockResolvedValue([{ id: 1 }]);
-            db.limit.mockResolvedValue([{ id: 1, name: "Updated" }]);
+            db.limit.mockResolvedValue([{ id: 1,
+name: "Updated" }]);
 
             const promises = Array(5).fill(0).map((_, i) =>
                 entityService.saveEntity("test", { name: `Update ${i}` }, 1)
@@ -243,7 +249,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
             const incompleteEntity = {}; // Missing required fields
 
             db.returning.mockResolvedValue([{ id: 1 }]);
-            db.limit.mockResolvedValue([{ id: 1, name: null }]);
+            db.limit.mockResolvedValue([{ id: 1,
+name: null }]);
 
             // The service should handle validation at the collection level
             // This test verifies the service doesn't crash with incomplete data
@@ -252,7 +259,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
         });
 
         it("should handle NULL values in database correctly", async () => {
-            const mockEntity = { id: 1, name: null };
+            const mockEntity = { id: 1,
+name: null };
             db.limit.mockResolvedValue([mockEntity]);
 
             const entity = await entityService.fetchEntity("test", 1);
@@ -263,7 +271,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
             const entityWithUndefined = { name: undefined };
 
             db.returning.mockResolvedValue([{ id: 1 }]);
-            db.limit.mockResolvedValue([{ id: 1, name: null }]);
+            db.limit.mockResolvedValue([{ id: 1,
+name: null }]);
 
             const entity = await entityService.saveEntity("test", entityWithUndefined);
             expect(entity.id).toBe("1");
@@ -276,7 +285,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
 
             // The service should handle this safely through parameterized queries
             // This test should not throw an error because of proper parameterization
-            const mockEntity = { id: 1, name: "Safe" };
+            const mockEntity = { id: 1,
+name: "Safe" };
             db.limit.mockResolvedValue([mockEntity]);
 
             const entity = await entityService.fetchEntity("test", maliciousId);
@@ -288,7 +298,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
             const entityWithLongValue = { name: veryLongString };
 
             db.returning.mockResolvedValue([{ id: 1 }]);
-            db.limit.mockResolvedValue([{ id: 1, name: veryLongString }]);
+            db.limit.mockResolvedValue([{ id: 1,
+name: veryLongString }]);
 
             const entity = await entityService.saveEntity("test", entityWithLongValue);
             expect(entity.values.name).toBe(veryLongString);
@@ -299,7 +310,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
             const entityWithSpecialChars = { name: specialChars };
 
             db.returning.mockResolvedValue([{ id: 1 }]);
-            db.limit.mockResolvedValue([{ id: 1, name: specialChars }]);
+            db.limit.mockResolvedValue([{ id: 1,
+name: specialChars }]);
 
             const entity = await entityService.saveEntity("test", entityWithSpecialChars);
             expect(entity.values.name).toBe(specialChars);
@@ -317,7 +329,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
             };
             jest.spyOn(collectionRegistry, "getCollectionByPath").mockReturnValue(booleanCollection);
 
-            const mockEntity = { id: 1, active: false };
+            const mockEntity = { id: 1,
+active: false };
             db.limit.mockResolvedValue([mockEntity]);
 
             const entity = await entityService.fetchEntity("test", 1);
@@ -334,7 +347,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
             };
             jest.spyOn(collectionRegistry, "getCollectionByPath").mockReturnValue(numericCollection);
 
-            const mockEntity = { id: 1, count: 0 };
+            const mockEntity = { id: 1,
+count: 0 };
             db.limit.mockResolvedValue([mockEntity]);
 
             const entity = await entityService.fetchEntity("test", 1);
@@ -342,7 +356,8 @@ describe("EntityService - Error Handling & Edge Cases", () => {
         });
 
         it("should handle empty string values correctly", async () => {
-            const mockEntity = { id: 1, name: "" };
+            const mockEntity = { id: 1,
+name: "" };
             db.limit.mockResolvedValue([mockEntity]);
 
             const entity = await entityService.fetchEntity("test", 1);