@rebasepro/server-postgresql 0.5.0 → 0.6.1

package/test/array-null-safety.test.ts

@@ -0,0 +1,335 @@
+import { describe, it, expect } from "@jest/globals";
+import {
+    serializePropertyToServer,
+    parsePropertyFromServer,
+    serializeDataToServer
+} from "../src/data-transformer";
+import type { Property, Properties, EntityCollection } from "@rebasepro/types";
+
+// ─────────────────────────────────────────────────────────────
+// Fixture helpers
+// ─────────────────────────────────────────────────────────────
+function makeCollection(slug: string, properties: Properties): EntityCollection {
+    return {
+        name: slug,
+        slug,
+        path: slug,
+        collectionType: "postgres",
+        tableName: slug,
+        properties
+    } as unknown as EntityCollection;
+}
+
+// ─────────────────────────────────────────────────────────────
+// Property fixtures
+// ─────────────────────────────────────────────────────────────
+const arrayOfStringsProp: Property = {
+    type: "array",
+    name: "Tags",
+    of: { type: "string", name: "Tag" }
+} as Property;
+
+const arrayOfNumbersProp: Property = {
+    type: "array",
+    name: "Scores",
+    of: { type: "number", name: "Score" }
+} as Property;
+
+const arrayOfMapsProp: Property = {
+    type: "array",
+    name: "Addresses",
+    of: {
+        type: "map",
+        name: "Address",
+        properties: {
+            street: { type: "string", name: "Street" },
+            city: { type: "string", name: "City" }
+        }
+    }
+} as Property;
+
+const arrayOneOfProp: Property = {
+    type: "array",
+    name: "Blocks",
+    oneOf: {
+        typeField: "type",
+        valueField: "value",
+        properties: {
+            text: { type: "string", name: "Text" } as Property,
+            number: { type: "number", name: "Number" } as Property
+        }
+    }
+} as Property;
+
+const arrayOfRelationsProp: Property = {
+    type: "array",
+    name: "Authors",
+    of: { type: "relation", name: "Author" }
+} as Property;
+
+// A bare array property without `of` or `oneOf`
+const bareArrayProp: Property = {
+    type: "array",
+    name: "RawArray"
+} as Property;
+
+// ─────────────────────────────────────────────────────────────
+// 1. serializePropertyToServer — array null safety
+// ─────────────────────────────────────────────────────────────
+describe("serializePropertyToServer — array null safety", () => {
+
+    // ── Null / undefined early return ──
+    it("returns null when value is null with array-of-strings property", () => {
+        expect(serializePropertyToServer(null, arrayOfStringsProp)).toBeNull();
+    });
+
+    it("returns undefined when value is undefined with array-of-strings property", () => {
+        expect(serializePropertyToServer(undefined, arrayOfStringsProp)).toBeUndefined();
+    });
+
+    // ── Empty array ──
+    it("returns [] when value is an empty array", () => {
+        expect(serializePropertyToServer([], arrayOfStringsProp)).toEqual([]);
+    });
+
+    // ── Null with different sub-types ──
+    it("returns null when value is null with array-of-numbers property", () => {
+        expect(serializePropertyToServer(null, arrayOfNumbersProp)).toBeNull();
+    });
+
+    it("returns null when value is null with array-of-maps property", () => {
+        expect(serializePropertyToServer(null, arrayOfMapsProp)).toBeNull();
+    });
+
+    it("returns null when value is null with array oneOf property", () => {
+        expect(serializePropertyToServer(null, arrayOneOfProp)).toBeNull();
+    });
+
+    // ── Non-array values (coerced to empty array) ──
+    it("coerces a non-array string to empty array for array property", () => {
+        expect(serializePropertyToServer("not-an-array", arrayOfStringsProp)).toEqual([]);
+    });
+
+    it("coerces a non-array number to empty array for array property", () => {
+        expect(serializePropertyToServer(42, arrayOfStringsProp)).toEqual([]);
+    });
+
+    it("coerces a non-array object to empty array for bare array property", () => {
+        const obj = { a: 1 };
+        expect(serializePropertyToServer(obj, bareArrayProp)).toEqual([]);
+    });
+
+    it("coerces a boolean to empty array for array property", () => {
+        expect(serializePropertyToServer(true, arrayOfStringsProp)).toEqual([]);
+        expect(serializePropertyToServer(false, arrayOfStringsProp)).toEqual([]);
+    });
+
+    // ── Arrays with null / undefined elements ──
+    it("handles array with null elements by passing each through sub-serialization", () => {
+        const result = serializePropertyToServer([null, "a", null], arrayOfStringsProp);
+        expect(result).toEqual([null, "a", null]);
+    });
+
+    it("handles array with undefined elements by passing each through sub-serialization", () => {
+        const result = serializePropertyToServer([undefined, "a"], arrayOfStringsProp);
+        expect(result).toEqual([undefined, "a"]);
+    });
+
+    // ── Array of relation objects with null entries ──
+    it("serializes array of relation objects with null entries correctly", () => {
+        const value = [{ id: "1" }, null, { id: "2" }];
+        const result = serializePropertyToServer(value, arrayOfRelationsProp);
+        // null entries pass through serializePropertyToServer for the sub-property
+        // which returns null for null values
+        expect(result).toEqual(["1", null, "2"]);
+    });
+
+    // ── Array of maps where some entries are null ──
+    it("handles array of maps where some entries are null gracefully", () => {
+        const value = [
+            { street: "123 Main", city: "NYC" },
+            null,
+            { street: "456 Oak", city: "LA" }
+        ];
+        const result = serializePropertyToServer(value, arrayOfMapsProp);
+        expect(result).toEqual([
+            { street: "123 Main", city: "NYC" },
+            null,
+            { street: "456 Oak", city: "LA" }
+        ]);
+    });
+
+    // ── Empty array with oneOf property ──
+    it("returns [] when value is an empty array with oneOf property", () => {
+        expect(serializePropertyToServer([], arrayOneOfProp)).toEqual([]);
+    });
+
+    // ── Nested array of arrays (unusual) ──
+    it("returns nested array of arrays as-is for bare array property", () => {
+        const nested = [["a", "b"], ["c"]];
+        // Without `of` or `oneOf`, the array case falls through to `return value`
+        expect(serializePropertyToServer(nested, bareArrayProp)).toEqual([["a", "b"], ["c"]]);
+    });
+});
+
+// ─────────────────────────────────────────────────────────────
+// 2. parsePropertyFromServer — array null safety
+// ─────────────────────────────────────────────────────────────
+describe("parsePropertyFromServer — array null safety", () => {
+    const dummyCollection = makeCollection("items", {
+        tags: arrayOfStringsProp
+    });
+
+    // ── Null / undefined early return ──
+    it("returns null when value is null with array property", () => {
+        expect(parsePropertyFromServer(null, arrayOfStringsProp, dummyCollection)).toBeNull();
+    });
+
+    it("returns undefined when value is undefined with array property", () => {
+        expect(parsePropertyFromServer(undefined, arrayOfStringsProp, dummyCollection)).toBeUndefined();
+    });
+
+    // ── Empty array ──
+    it("returns [] when value is an empty array with array-of-strings", () => {
+        expect(parsePropertyFromServer([], arrayOfStringsProp, dummyCollection)).toEqual([]);
+    });
+
+    // ── Non-array values (coerced to array) ──
+    it("coerces a non-array string to single-element array for array property", () => {
+        expect(parsePropertyFromServer("not-an-array", arrayOfStringsProp, dummyCollection)).toEqual(["not-an-array"]);
+    });
+
+    it("coerces a non-array number to empty array for array property", () => {
+        expect(parsePropertyFromServer(99, arrayOfStringsProp, dummyCollection)).toEqual([]);
+    });
+
+    // ── Null with oneOf ──
+    it("returns null when value is null with array oneOf property", () => {
+        expect(parsePropertyFromServer(null, arrayOneOfProp, dummyCollection)).toBeNull();
+    });
+
+    // ── Array with null elements ──
+    it("handles array with null elements for parsing gracefully", () => {
+        const result = parsePropertyFromServer([null, "a", null], arrayOfStringsProp, dummyCollection);
+        expect(result).toEqual([null, "a", null]);
+    });
+
+    // ── Falsy non-null values (coerced to array) ──
+    it("coerces falsy number 0 to empty array for array property", () => {
+        expect(parsePropertyFromServer(0, arrayOfStringsProp, dummyCollection)).toEqual([]);
+    });
+
+    it("coerces false to empty array for array property", () => {
+        expect(parsePropertyFromServer(false, arrayOfStringsProp, dummyCollection)).toEqual([]);
+    });
+
+    it("coerces empty string to single-element array for array property", () => {
+        expect(parsePropertyFromServer("", arrayOfStringsProp, dummyCollection)).toEqual([""]);
+    });
+});
+
+// ─────────────────────────────────────────────────────────────
+// 3. serializeDataToServer — entity with null array fields
+// ─────────────────────────────────────────────────────────────
+describe("serializeDataToServer — entity with null array fields", () => {
+    const tagsProperty: Property = {
+        type: "array",
+        name: "Tags",
+        of: { type: "string", name: "Tag" }
+    } as Property;
+
+    const categoriesProperty: Property = {
+        type: "array",
+        name: "Categories",
+        of: { type: "string", name: "Category" }
+    } as Property;
+
+    const metadataProperty: Property = {
+        type: "map",
+        name: "Metadata",
+        properties: {
+            labels: {
+                type: "array",
+                name: "Labels",
+                of: { type: "string", name: "Label" }
+            } as Property
+        }
+    } as Property;
+
+    const properties: Properties = {
+        tags: tagsProperty
+    };
+
+    // ── Null array field ──
+    it("serializes entity with tags: null — scalarData.tags should be null", () => {
+        const result = serializeDataToServer(
+            { tags: null },
+            properties
+        );
+        expect(result.scalarData.tags).toBeNull();
+    });
+
+    // ── Undefined array field ──
+    it("serializes entity with tags: undefined — tags value should be undefined in scalarData", () => {
+        const result = serializeDataToServer(
+            { tags: undefined },
+            properties
+        );
+        // Object.entries iterates keys even when value is undefined,
+        // and serializePropertyToServer returns undefined for undefined input
+        expect(result.scalarData.tags).toBeUndefined();
+    });
+
+    // ── Empty array field ──
+    it("serializes entity with tags: [] — scalarData.tags should be []", () => {
+        const result = serializeDataToServer(
+            { tags: [] },
+            properties
+        );
+        expect(result.scalarData.tags).toEqual([]);
+    });
+
+    // ── Multiple array fields, mixed null / populated ──
+    it("handles entity with multiple array fields, some null, some populated", () => {
+        const multiProperties: Properties = {
+            tags: tagsProperty,
+            categories: categoriesProperty
+        };
+
+        const result = serializeDataToServer(
+            { tags: null, categories: ["cat-a", "cat-b"] },
+            multiProperties
+        );
+        expect(result.scalarData.tags).toBeNull();
+        expect(result.scalarData.categories).toEqual(["cat-a", "cat-b"]);
+    });
+
+    // ── Nested map containing null array ──
+    it("handles entity with nested map containing array field that is null", () => {
+        const nestedProperties: Properties = {
+            metadata: metadataProperty
+        };
+
+        const result = serializeDataToServer(
+            { metadata: { labels: null } },
+            nestedProperties
+        );
+        // The map serializer recurses into sub-properties; the inner array gets null-checked
+        expect(result.scalarData.metadata).toEqual({ labels: null });
+    });
+
+    // ── All array fields null ──
+    it("handles entity with only array fields, all null — scalarData should have all null values", () => {
+        const allArrayProperties: Properties = {
+            tags: tagsProperty,
+            categories: categoriesProperty
+        };
+
+        const result = serializeDataToServer(
+            { tags: null, categories: null },
+            allArrayProperties
+        );
+        expect(result.scalarData.tags).toBeNull();
+        expect(result.scalarData.categories).toBeNull();
+    });
+});

package/test/auth-services.test.ts

@@ -8,7 +8,9 @@ jest.mock("drizzle-orm", () => {
     const actual = jest.requireActual("drizzle-orm");
     return {
         ...actual,
-        eq: jest.fn((field, value) => ({ field, value, type: "eq" })),
+        eq: jest.fn((field, value) => ({ field,
+value,
+type: "eq" })),
         sql: Object.assign(
             jest.fn((strings: TemplateStringsArray, ...values: unknown[]) => ({
                 strings,
@@ -16,8 +18,11 @@ jest.mock("drizzle-orm", () => {
                 type: "sql"
             })),
             {
-                raw: jest.fn((val: string) => ({ val, type: "sql-raw" })),
-                join: jest.fn((parts: unknown[], separator: unknown) => ({ parts, separator, type: "sql-join" }))
+                raw: jest.fn((val: string) => ({ val,
+type: "sql-raw" })),
+                join: jest.fn((parts: unknown[], separator: unknown) => ({ parts,
+separator,
+type: "sql-join" }))
             }
         ),
         relations: jest.fn(() => ({}))
@@ -133,11 +138,11 @@ describe("Auth Services", () => {
                     email: "test@example.com",
                     displayName: "Test User"
                 };
-                const dbReturnedUser = { 
+                const dbReturnedUser = {
                     id: "user-123",
                     ...newUser,
                     createdAt: new Date(),
-                    updatedAt: new Date() 
+                    updatedAt: new Date()
                 };
                 mockInsertReturning.mockResolvedValueOnce([dbReturnedUser]);
 
@@ -154,7 +159,8 @@ describe("Auth Services", () => {
 
         describe("getUserById", () => {
             it("should return user when found", async () => {
-                const mockUser = { id: "user-123", email: "test@example.com" };
+                const mockUser = { id: "user-123",
+email: "test@example.com" };
                 mockSelectWhere.mockResolvedValueOnce([mockUser]);
 
                 const result = await userService.getUserById("user-123");
@@ -174,7 +180,8 @@ describe("Auth Services", () => {
 
         describe("getUserByEmail", () => {
             it("should return user when found by email", async () => {
-                const mockUser = { id: "user-123", email: "test@example.com" };
+                const mockUser = { id: "user-123",
+email: "test@example.com" };
                 mockSelectWhere.mockResolvedValueOnce([mockUser]);
 
                 const result = await userService.getUserByEmail("test@example.com");
@@ -194,13 +201,15 @@ describe("Auth Services", () => {
 
         describe("getUserByIdentity", () => {
             it("should fetch user by identity", async () => {
-                const mockUser = { id: "user-123", email: "test@example.com" };
+                const mockUser = { id: "user-123",
+email: "test@example.com" };
                 mockSelectWhere.mockResolvedValueOnce([{ user: mockUser }]);
 
                 const result = await userService.getUserByIdentity("google", "google-abc");
 
                 expect(db.select).toHaveBeenCalled();
-                expect(result).toEqual(expect.objectContaining({ id: "user-123", email: "test@example.com" }));
+                expect(result).toEqual(expect.objectContaining({ id: "user-123",
+email: "test@example.com" }));
             });
         });
 
@@ -223,10 +232,10 @@ describe("Auth Services", () => {
 
         describe("updateUser", () => {
             it("should update user and return updated record", async () => {
-                const updatedUser = { 
+                const updatedUser = {
                     id: "user-123",
                     email: "test@example.com",
-                    displayName: "Updated Name" 
+                    displayName: "Updated Name"
                 };
                 mockUpdateReturning.mockResolvedValueOnce([updatedUser]);
 
@@ -261,8 +270,10 @@ describe("Auth Services", () => {
         describe("listUsers", () => {
             it("should return all users", async () => {
                 const mockUsers = [
-                    { id: "user-1", email: "user1@example.com" },
-                    { id: "user-2", email: "user2@example.com" }
+                    { id: "user-1",
+email: "user1@example.com" },
+                    { id: "user-2",
+email: "user2@example.com" }
                 ];
                 mockSelectFrom.mockReturnValueOnce(Promise.resolve(mockUsers));
 
@@ -270,8 +281,10 @@ describe("Auth Services", () => {
 
                 expect(db.select).toHaveBeenCalled();
                 expect(result).toEqual([
-                    mockUserData({ id: "user-1", email: "user1@example.com" }),
-                    mockUserData({ id: "user-2", email: "user2@example.com" })
+                    mockUserData({ id: "user-1",
+email: "user1@example.com" }),
+                    mockUserData({ id: "user-2",
+email: "user2@example.com" })
                 ]);
             });
         });
@@ -332,7 +345,8 @@ describe("Auth Services", () => {
 
         describe("getUserByVerificationToken", () => {
             it("should find user by verification token", async () => {
-                const mockUser = { id: "user-123", email: "test@example.com" };
+                const mockUser = { id: "user-123",
+email: "test@example.com" };
                 mockSelectWhere.mockResolvedValueOnce([mockUser]);
 
                 const result = await userService.getUserByVerificationToken("token-abc");
@@ -396,7 +410,8 @@ describe("Auth Services", () => {
 
         describe("getUserWithRoles", () => {
             it("should return user with roles", async () => {
-                const mockUser = { id: "user-123", email: "test@example.com" };
+                const mockUser = { id: "user-123",
+email: "test@example.com" };
                 mockSelectWhere.mockResolvedValueOnce([mockUser]);
                 mockExecute.mockResolvedValueOnce({
                     rows: [{ roles: ["admin"] }]
@@ -427,7 +442,8 @@ describe("Auth Services", () => {
             it("should return paginated and filtered users list", async () => {
                 mockExecute
                     .mockResolvedValueOnce({ rows: [{ total: 1 }] })
-                    .mockResolvedValueOnce({ rows: [{ id: "user-123", email: "test@example.com" }] });
+                    .mockResolvedValueOnce({ rows: [{ id: "user-123",
+email: "test@example.com" }] });
 
                 const result = await userService.listUsersPaginated({
                     limit: 10,
@@ -439,7 +455,8 @@ describe("Auth Services", () => {
 
                 expect(mockExecute).toHaveBeenCalledTimes(2);
                 expect(result).toEqual({
-                    users: [mockUserData({ id: "user-123", email: "test@example.com" })],
+                    users: [mockUserData({ id: "user-123",
+email: "test@example.com" })],
                     total: 1,
                     limit: 10,
                     offset: 0