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

package/test/data-transformer-hardening.test.ts

@@ -0,0 +1,417 @@
+import {
+    serializeDataToServer,
+    parsePropertyFromServer,
+    normalizeDbValues,
+    sanitizeAndConvertDates
+} from "../src/data-transformer";
+import type { EntityCollection, Property, Properties, RelationProperty } from "@rebasepro/types";
+
+// ─────────────────────────────────────────────────────────────
+// Fixture helpers
+// ─────────────────────────────────────────────────────────────
+function makeCollection(
+    slug: string,
+    properties: Properties,
+    relations?: EntityCollection["relations"]
+): EntityCollection {
+    return {
+        name: slug,
+        slug,
+        path: slug,
+        collectionType: "postgres",
+        tableName: slug,
+        properties,
+        relations
+    } as unknown as EntityCollection;
+}
+
+// ─────────────────────────────────────────────────────────────
+// serializeDataToServer — typed return (Issue #7 regression)
+// ─────────────────────────────────────────────────────────────
+describe("serializeDataToServer typed return", () => {
+    const properties: Properties = {
+        title: { type: "string", name: "Title" } as Property,
+        count: { type: "number", name: "Count" } as Property
+    };
+
+    it("returns a SerializedEntityData object with scalarData, not raw values", () => {
+        const result = serializeDataToServer(
+            { title: "Hello", count: 5 },
+            properties
+        );
+        expect(result).toHaveProperty("scalarData");
+        expect(result).toHaveProperty("inverseRelationUpdates");
+        expect(result).toHaveProperty("joinPathRelationUpdates");
+    });
+
+    it("does NOT include __inverseRelationUpdates on scalarData (dunder elimination)", () => {
+        const result = serializeDataToServer(
+            { title: "Test" },
+            properties
+        );
+        // The old pattern embedded __dunder properties on the result object
+        expect(result.scalarData).not.toHaveProperty("__inverseRelationUpdates");
+        expect(result.scalarData).not.toHaveProperty("__joinPathRelationUpdates");
+    });
+
+    it("returns empty arrays when no collection/registry is provided", () => {
+        const result = serializeDataToServer(
+            { title: "Test" },
+            properties
+        );
+        expect(result.inverseRelationUpdates).toEqual([]);
+        expect(result.joinPathRelationUpdates).toEqual([]);
+    });
+
+    it("passes scalar values through correctly", () => {
+        const result = serializeDataToServer(
+            { title: "Hello World", count: 42 },
+            properties
+        );
+        expect(result.scalarData.title).toBe("Hello World");
+        expect(result.scalarData.count).toBe(42);
+    });
+
+    it("handles null/undefined entity gracefully", () => {
+        const result = serializeDataToServer(null as any, properties);
+        // Object.entries(null) yields nothing → empty object
+        expect(result.scalarData).toEqual({});
+        expect(result.inverseRelationUpdates).toEqual([]);
+        expect(result.joinPathRelationUpdates).toEqual([]);
+    });
+});
+
+// ─────────────────────────────────────────────────────────────
+// parsePropertyFromServer — relation factory (Issue #1 regression)
+// ─────────────────────────────────────────────────────────────
+describe("parsePropertyFromServer relation factory", () => {
+    const targetCollection = makeCollection("authors", {
+        name: { type: "string", name: "Name" } as Property
+    });
+
+    const collection = makeCollection("posts", {
+        author: {
+            type: "relation",
+            name: "Author",
+            relation: {
+                target: () => targetCollection,
+                cardinality: "one",
+                direction: "owning",
+                localKey: "author_id",
+                relationName: "author"
+            }
+        } as unknown as Property
+    });
+
+    it("produces a relation ref with __type 'relation' from a string FK value", () => {
+        const property = collection.properties.author as Property;
+        const result = parsePropertyFromServer("author-123", property, collection, "author") as Record<string, unknown>;
+        expect(result.__type).toBe("relation");
+        expect(result.id).toBe("author-123");
+        expect(result.path).toBe("authors");
+    });
+
+    it("produces a relation ref with __type 'relation' from a numeric FK value", () => {
+        const property = collection.properties.author as Property;
+        const result = parsePropertyFromServer(42, property, collection, "author") as Record<string, unknown>;
+        expect(result.__type).toBe("relation");
+        expect(result.id).toBe("42");
+        expect(result.path).toBe("authors");
+    });
+});
+
+// ─────────────────────────────────────────────────────────────
+// normalizeDbValues — pipeline deduplication (Issue #5 regression)
+// ─────────────────────────────────────────────────────────────
+describe("normalizeDbValues", () => {
+    const collection = makeCollection("items", {
+        title: { type: "string", name: "Title" } as Property,
+        price: { type: "number", name: "Price" } as Property,
+        created_at: { type: "date", name: "Created" } as Property
+    });
+
+    it("coerces string numbers to actual numbers", () => {
+        const result = normalizeDbValues(
+            { title: "Widget", price: "19.99" } as any,
+            collection
+        );
+        expect(result.price).toBe(19.99);
+    });
+
+    it("converts Date objects to { __type: 'date', value: ISO } format", () => {
+        const date = new Date("2024-01-15T10:30:00Z");
+        const result = normalizeDbValues(
+            { title: "Widget", created_at: date } as any,
+            collection
+        );
+        expect(result.created_at).toEqual({
+            __type: "date",
+            value: "2024-01-15T10:30:00.000Z"
+        });
+    });
+
+    it("strips unknown database columns not in properties", () => {
+        const result = normalizeDbValues(
+            { title: "Widget", internal_counter: 999 } as any,
+            collection
+        );
+        expect(result).not.toHaveProperty("internal_counter");
+        expect(result.title).toBe("Widget");
+    });
+
+    it("returns data as-is when properties is empty", () => {
+        const empty = makeCollection("empty", {});
+        const data = { foo: "bar" };
+        const result = normalizeDbValues(data as any, empty);
+        expect(result).toEqual({});
+    });
+
+    it("handles null data gracefully", () => {
+        const result = normalizeDbValues(null as any, collection);
+        expect(result).toBeNull();
+    });
+
+    it("skips relation properties (they are hydrated by Drizzle)", () => {
+        const collectionWithRelation = makeCollection("orders", {
+            customer: {
+                type: "relation",
+                name: "Customer",
+                relation: {
+                    target: () => collection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "customer_id",
+                    relationName: "customer"
+                }
+            } as unknown as Property,
+            total: { type: "number", name: "Total" } as Property
+        });
+
+        const result = normalizeDbValues(
+            { customer: "some-id", total: 42 } as any,
+            collectionWithRelation
+        );
+        // Relation properties should be skipped
+        expect(result).not.toHaveProperty("customer");
+        expect(result.total).toBe(42);
+    });
+});
+
+// ─────────────────────────────────────────────────────────────
+// sanitizeAndConvertDates — utility regression
+// ─────────────────────────────────────────────────────────────
+describe("sanitizeAndConvertDates", () => {
+    it("converts NaN number to null", () => {
+        expect(sanitizeAndConvertDates(NaN)).toBeNull();
+    });
+
+    it("converts 'NaN' string to null", () => {
+        expect(sanitizeAndConvertDates("NaN")).toBeNull();
+    });
+
+    it("converts Date to ISO string", () => {
+        const date = new Date("2024-01-01T00:00:00Z");
+        expect(sanitizeAndConvertDates(date)).toBe("2024-01-01T00:00:00.000Z");
+    });
+
+    it("converts ISO string to ISO string", () => {
+        const iso = "2024-01-01T00:00:00Z";
+        expect(sanitizeAndConvertDates(iso)).toBe("2024-01-01T00:00:00.000Z");
+    });
+
+    it("passes through non-date strings unchanged", () => {
+        expect(sanitizeAndConvertDates("hello")).toBe("hello");
+    });
+
+    it("recursively sanitizes arrays", () => {
+        const result = sanitizeAndConvertDates([NaN, "hello", null]);
+        expect(result).toEqual([null, "hello", null]);
+    });
+});
+
+// ─────────────────────────────────────────────────────────────
+// getColumnMeta — type guard regression (Issue #6)
+// ─────────────────────────────────────────────────────────────
+import { getColumnMeta } from "../src/services/entity-helpers";
+
+describe("getColumnMeta type guard", () => {
+    it("extracts columnType, dataType, primary from a well-formed column", () => {
+        const fakeCol = {
+            columnType: "PgVarchar",
+            dataType: "string",
+            primary: false
+        };
+        const meta = getColumnMeta(fakeCol as any);
+        expect(meta.columnType).toBe("PgVarchar");
+        expect(meta.dataType).toBe("string");
+        expect(meta.primary).toBe(false);
+    });
+
+    it("returns undefined for missing properties instead of crashing", () => {
+        const emptyCol = {};
+        const meta = getColumnMeta(emptyCol as any);
+        expect(meta.columnType).toBeUndefined();
+        expect(meta.dataType).toBeUndefined();
+        expect(meta.primary).toBeUndefined();
+    });
+
+    it("returns undefined for wrong-typed properties instead of passing them through", () => {
+        const badCol = {
+            columnType: 42,       // should be string
+            dataType: true,       // should be string
+            primary: "yes"        // should be boolean
+        };
+        const meta = getColumnMeta(badCol as any);
+        expect(meta.columnType).toBeUndefined();
+        expect(meta.dataType).toBeUndefined();
+        expect(meta.primary).toBeUndefined();
+    });
+});
+
+// ─────────────────────────────────────────────────────────────
+// FK column preservation (Issue #5) — normalizeScalarValues
+// ─────────────────────────────────────────────────────────────
+describe("normalizeDbValues FK column preservation", () => {
+    it("preserves internal FK columns as primitives when not defined as properties", () => {
+        const targetCollection = makeCollection("categories", {
+            name: { type: "string", name: "Name" } as Property
+        });
+
+        const categoryRelation = {
+            target: () => targetCollection,
+            cardinality: "one" as const,
+            direction: "owning" as const,
+            localKey: "category_id",
+            relationName: "category"
+        };
+
+        const collection = makeCollection("products", {
+            title: { type: "string", name: "Title" } as Property,
+            category: {
+                type: "relation",
+                name: "Category",
+                relationName: "category"
+            } as unknown as Property
+        }, [categoryRelation] as any);
+
+        const result = normalizeDbValues(
+            { title: "Widget", category_id: "cat-123", category: "ignored" } as any,
+            collection
+        );
+
+        // FK column should be preserved as a primitive string
+        expect(result.category_id).toBe("cat-123");
+        // Relation property should be skipped (db.query handles it)
+        expect(result).not.toHaveProperty("category");
+        // Regular property should be present
+        expect(result.title).toBe("Widget");
+    });
+
+    it("preserves numeric FK columns as numbers", () => {
+        const targetCollection = makeCollection("authors", {
+            name: { type: "string", name: "Name" } as Property
+        });
+
+        const authorRelation = {
+            target: () => targetCollection,
+            cardinality: "one" as const,
+            direction: "owning" as const,
+            localKey: "author_id",
+            relationName: "author"
+        };
+
+        const collection = makeCollection("books", {
+            title: { type: "string", name: "Title" } as Property,
+            author: {
+                type: "relation",
+                name: "Author",
+                relationName: "author"
+            } as unknown as Property
+        }, [authorRelation] as any);
+
+        const result = normalizeDbValues(
+            { title: "Book", author_id: 42 } as any,
+            collection
+        );
+        expect(result.author_id).toBe(42);
+    });
+
+    it("converts null FK columns to null", () => {
+        const targetCollection = makeCollection("authors", {
+            name: { type: "string", name: "Name" } as Property
+        });
+
+        const authorRelation = {
+            target: () => targetCollection,
+            cardinality: "one" as const,
+            direction: "owning" as const,
+            localKey: "author_id",
+            relationName: "author"
+        };
+
+        const collection = makeCollection("books", {
+            title: { type: "string", name: "Title" } as Property,
+            author: {
+                type: "relation",
+                name: "Author",
+                relationName: "author"
+            } as unknown as Property
+        }, [authorRelation] as any);
+
+        const result = normalizeDbValues(
+            { title: "Book", author_id: null } as any,
+            collection
+        );
+        expect(result.author_id).toBeNull();
+    });
+});
+
+// ─────────────────────────────────────────────────────────────
+// Structural dunder guard (Issue #7) — prevent re-introduction
+// ─────────────────────────────────────────────────────────────
+describe("structural dunder guard", () => {
+    it("scalarData never contains any __ prefixed keys", () => {
+        const properties: Properties = {
+            title: { type: "string", name: "Title" } as Property,
+            count: { type: "number", name: "Count" } as Property,
+            active: { type: "boolean", name: "Active" } as Property
+        };
+
+        const result = serializeDataToServer(
+            { title: "Test", count: 10, active: true },
+            properties
+        );
+
+        const dunderKeys = Object.keys(result.scalarData).filter(k => k.startsWith("__"));
+        expect(dunderKeys).toEqual([]);
+    });
+
+    it("scalarData never contains any __ prefixed keys even with relation properties", () => {
+        const targetCollection = makeCollection("tags", {
+            label: { type: "string", name: "Label" } as Property
+        });
+
+        const properties: Properties = {
+            title: { type: "string", name: "Title" } as Property,
+            tag: {
+                type: "relation",
+                name: "Tag",
+                relation: {
+                    target: () => targetCollection,
+                    cardinality: "one",
+                    direction: "owning",
+                    localKey: "tag_id",
+                    relationName: "tag"
+                }
+            } as unknown as Property
+        };
+
+        const result = serializeDataToServer(
+            { title: "Test", tag: { id: "t1", path: "tags", __type: "relation" } },
+            properties
+        );
+
+        const dunderKeys = Object.keys(result.scalarData).filter(k => k.startsWith("__"));
+        expect(dunderKeys).toEqual([]);
+    });
+});

package/test/data-transformer.test.ts

@@ -0,0 +1,175 @@
+import { serializePropertyToServer } from "../src/data-transformer";
+import type { Property } from "@rebasepro/types";
+
+describe("serializePropertyToServer", () => {
+    // ── Relation property ──
+    describe("relation property", () => {
+        const relationProp: Property = { type: "relation" } as Property;
+
+        it("should extract id from a relation object", () => {
+            const value = { id: "abc-123",
+path: "authors",
+__type: "relation" };
+            expect(serializePropertyToServer(value, relationProp)).toBe("abc-123");
+        });
+
+        it("should return null for empty string values", () => {
+            expect(serializePropertyToServer("", relationProp)).toBeNull();
+        });
+
+        it("should pass through a plain string ID", () => {
+            expect(serializePropertyToServer("uuid-string", relationProp)).toBe("uuid-string");
+        });
+
+        it("should pass through a numeric ID", () => {
+            expect(serializePropertyToServer(42, relationProp)).toBe(42);
+        });
+
+        it("should return null for null values", () => {
+            expect(serializePropertyToServer(null, relationProp)).toBeNull();
+        });
+
+        it("should return undefined for undefined values", () => {
+            expect(serializePropertyToServer(undefined, relationProp)).toBeUndefined();
+        });
+
+        it("should serialize an array of relation objects to array of IDs", () => {
+            const value = [
+                { id: "id-1",
+path: "authors" },
+                { id: "id-2",
+path: "authors" }
+            ];
+            expect(serializePropertyToServer(value, relationProp)).toEqual(["id-1", "id-2"]);
+        });
+
+        it("should convert empty strings within arrays to null", () => {
+            const value = ["", "some-uuid"];
+            expect(serializePropertyToServer(value, relationProp)).toEqual([null, "some-uuid"]);
+        });
+
+        it("should handle mixed array of objects and strings", () => {
+            const value = [
+                { id: "id-1",
+path: "authors" },
+                "raw-id-2",
+                ""
+            ];
+            expect(serializePropertyToServer(value, relationProp)).toEqual(["id-1", "raw-id-2", null]);
+        });
+    });
+
+    // ── String property ──
+    describe("string property", () => {
+        const stringProp: Property = { type: "string" } as Property;
+
+        it("should pass through a regular string", () => {
+            expect(serializePropertyToServer("hello", stringProp)).toBe("hello");
+        });
+
+        it("should pass through empty string for non-relation types", () => {
+            expect(serializePropertyToServer("", stringProp)).toBe("");
+        });
+
+        it("should pass through null", () => {
+            expect(serializePropertyToServer(null, stringProp)).toBeNull();
+        });
+    });
+
+    // ── Number property ──
+    describe("number property", () => {
+        const numberProp: Property = { type: "number" } as Property;
+
+        it("should pass through numeric values", () => {
+            expect(serializePropertyToServer(42, numberProp)).toBe(42);
+        });
+
+        it("should pass through zero", () => {
+            expect(serializePropertyToServer(0, numberProp)).toBe(0);
+        });
+
+        it("should pass through null", () => {
+            expect(serializePropertyToServer(null, numberProp)).toBeNull();
+        });
+    });
+
+    // ── Map property ──
+    describe("map property", () => {
+        const mapProp: Property = {
+            type: "map",
+            properties: {
+                name: { type: "string" } as Property,
+                age: { type: "number" } as Property,
+                author: { type: "relation" } as Property
+            }
+        } as unknown as Property;
+
+        it("should recursively serialize nested properties", () => {
+            const value = {
+                name: "Alice",
+                age: 30,
+                author: { id: "author-1",
+path: "authors" }
+            };
+            expect(serializePropertyToServer(value, mapProp)).toEqual({
+                name: "Alice",
+                age: 30,
+                author: "author-1"
+            });
+        });
+
+        it("should convert empty string relation in map to null", () => {
+            const value = {
+                name: "Test",
+                age: 25,
+                author: ""
+            };
+            expect(serializePropertyToServer(value, mapProp)).toEqual({
+                name: "Test",
+                age: 25,
+                author: null
+            });
+        });
+
+        it("should handle unknown sub-keys by passing through", () => {
+            const value = {
+                name: "Bob",
+                unknownField: "should pass through"
+            };
+            const result = serializePropertyToServer(value, mapProp) as Record<string, unknown>;
+            expect(result.name).toBe("Bob");
+            expect(result.unknownField).toBe("should pass through");
+        });
+    });
+
+    // ── Array property ──
+    describe("array property", () => {
+        const arrayOfStringsProp: Property = {
+            type: "array",
+            of: { type: "string" } as Property
+        } as unknown as Property;
+
+        it("should serialize array elements through their sub-property type", () => {
+            expect(serializePropertyToServer(["a", "b", "c"], arrayOfStringsProp))
+                .toEqual(["a", "b", "c"]);
+        });
+
+        it("should pass through non-array values", () => {
+            expect(serializePropertyToServer("not-an-array", arrayOfStringsProp))
+                .toBe("not-an-array");
+        });
+    });
+
+    // ── Boolean property ──
+    describe("boolean property", () => {
+        const boolProp: Property = { type: "boolean" } as Property;
+
+        it("should pass through true", () => {
+            expect(serializePropertyToServer(true, boolProp)).toBe(true);
+        });
+
+        it("should pass through false", () => {
+            expect(serializePropertyToServer(false, boolProp)).toBe(false);
+        });
+    });
+});