arkos 1.0.3-alpha → 1.0.4-alpha

package/dist/cjs/modules/base/utils/helpers/__tests__/base.helpers.test.js

@@ -1,754 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const base_helpers_1 = require("../base.helpers");
-jest.mock("../../../../../utils/helpers/models.helpers", () => ({
-    getPrismaModelRelations: jest.fn((type) => {
-        if (type === "Post") {
-            return {
-                singular: [{ name: "category", type: "Category" }],
-                list: [
-                    { name: "tags", type: "Tag" },
-                    { name: "comments", type: "Comment" },
-                ],
-            };
-        }
-        if (type === "User") {
-            return {
-                singular: [{ name: "profile", type: "Profile" }],
-                list: [{ name: "posts", type: "Post" }],
-            };
-        }
-        if (type === "Comment") {
-            return {
-                singular: [{ name: "author", type: "User" }],
-            };
-        }
-        return null;
-    }),
-    getModelUniqueFields: jest.fn((modelName) => {
-        if (modelName === "Category") {
-            return [{ name: "name" }];
-        }
-        if (modelName === "Tag") {
-            return [{ name: "name" }];
-        }
-        if (modelName === "User") {
-            return [{ name: "email" }, { name: "username" }];
-        }
-        return [];
-    }),
-    RelationField: {},
-    RelationFields: {},
-}));
-describe("handleRelationFieldsInBody", () => {
-    describe("Singular Relations", () => {
-        it("should handle create operation for singular relation without id", () => {
-            const body = {
-                name: "John Doe",
-                profile: {
-                    bio: "Software Engineer",
-                    avatarUrl: "https://example.com/avatar.jpg",
-                },
-            };
-            const relationFields = {
-                singular: [{ name: "profile", type: "Profile" }],
-                list: [],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                profile: {
-                    create: {
-                        bio: "Software Engineer",
-                        avatarUrl: "https://example.com/avatar.jpg",
-                    },
-                },
-            });
-        });
-        it("should handle connect operation for singular relation with only id", () => {
-            const body = {
-                name: "John Doe",
-                profile: {
-                    id: "123",
-                },
-            };
-            const relationFields = {
-                singular: [{ name: "profile", type: "Profile" }],
-                list: [],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                profile: {
-                    connect: {
-                        id: "123",
-                    },
-                },
-            });
-        });
-        it("should handle connect operation for singular relation with unique field", () => {
-            const body = {
-                name: "John Doe",
-                category: {
-                    name: "Technology",
-                },
-            };
-            const relationFields = {
-                singular: [
-                    {
-                        name: "category",
-                        type: "Category",
-                    },
-                ],
-                list: [],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                category: {
-                    connect: {
-                        name: "Technology",
-                    },
-                },
-            });
-        });
-        it("should handle update operation for singular relation with id and other fields", () => {
-            const body = {
-                name: "John Doe",
-                profile: {
-                    id: "123",
-                    bio: "Updated Bio",
-                    avatarUrl: "https://example.com/new-avatar.jpg",
-                },
-            };
-            const relationFields = {
-                singular: [{ name: "profile", type: "Profile" }],
-                list: [],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                profile: {
-                    update: {
-                        data: {
-                            bio: "Updated Bio",
-                            avatarUrl: "https://example.com/new-avatar.jpg",
-                        },
-                    },
-                },
-            });
-        });
-        it("should handle explicit connect operation with apiAction", () => {
-            const body = {
-                name: "John Doe",
-                profile: {
-                    id: "123",
-                    apiAction: "connect",
-                },
-            };
-            const relationFields = {
-                singular: [{ name: "profile", type: "Profile" }],
-                list: [],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                profile: {
-                    connect: {
-                        id: "123",
-                    },
-                },
-            });
-        });
-    });
-    describe("List Relations", () => {
-        it("should handle create operation for list relation items without ids", () => {
-            const body = {
-                title: "My Post",
-                tags: [
-                    { name: "JavaScript", apiAction: "create" },
-                    { name: "TypeScript", apiAction: "create" },
-                ],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    create: [{ name: "JavaScript" }, { name: "TypeScript" }],
-                },
-            });
-        });
-        it("should handle connect operation for list relation items with only ids", () => {
-            const body = {
-                title: "My Post",
-                tags: [{ id: "1" }, { id: "2" }],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    connect: [{ id: "1" }, { id: "2" }],
-                },
-            });
-        });
-        it("should handle connect operation for list relation items with unique fields", () => {
-            const body = {
-                title: "My Post",
-                tags: [{ name: "JavaScript" }, { name: "TypeScript" }],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    connect: [{ name: "JavaScript" }, { name: "TypeScript" }],
-                },
-            });
-        });
-        it("should handle update operation for list relation items with ids and other fields", () => {
-            const body = {
-                title: "My Post",
-                tags: [
-                    { id: "1", name: "Updated JavaScript" },
-                    { id: "2", name: "Updated TypeScript" },
-                ],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    update: [
-                        { where: { id: "1" }, data: { name: "Updated JavaScript" } },
-                        { where: { id: "2" }, data: { name: "Updated TypeScript" } },
-                    ],
-                },
-            });
-        });
-        it('should handle deleteMany operation for list relation items with apiAction: "delete"', () => {
-            const body = {
-                title: "My Post",
-                tags: [
-                    { id: "1", apiAction: "delete" },
-                    { id: "2", apiAction: "delete" },
-                ],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    deleteMany: {
-                        id: { in: ["1", "2"] },
-                    },
-                },
-            });
-        });
-        it('should handle disconnect operation for list relation items with apiAction: "disconnect"', () => {
-            const body = {
-                title: "My Post",
-                tags: [
-                    { id: "1", apiAction: "disconnect" },
-                    { id: "2", apiAction: "disconnect" },
-                ],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    disconnect: [{ id: "1" }, { id: "2" }],
-                },
-            });
-        });
-        it("should handle mixed operations for list relation items", () => {
-            const body = {
-                title: "My Post",
-                tags: [
-                    { name: "New Tag", apiAction: "create" },
-                    { id: "1" },
-                    { id: "2", name: "Updated Tag" },
-                    { id: "3", apiAction: "delete" },
-                    { id: "4", apiAction: "disconnect" },
-                ],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    create: [{ name: "New Tag" }],
-                    connect: [{ id: "1" }],
-                    update: [{ where: { id: "2" }, data: { name: "Updated Tag" } }],
-                    disconnect: [{ id: "4" }],
-                    deleteMany: { id: { in: ["3"] } },
-                },
-            });
-        });
-    });
-    describe("Nested Relations", () => {
-        it("should handle nested relations recursively", () => {
-            const body = {
-                name: "John Doe",
-                posts: [
-                    {
-                        title: "My First Post",
-                        category: { name: "Technology" },
-                        tags: [{ name: "JavaScript" }],
-                    },
-                ],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "posts", type: "Post" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                posts: {
-                    create: [
-                        {
-                            title: "My First Post",
-                            category: {
-                                connect: { name: "Technology" },
-                            },
-                            tags: {
-                                connect: [{ name: "JavaScript" }],
-                            },
-                        },
-                    ],
-                },
-            });
-        });
-        it("should handle deep nested relations", () => {
-            const body = {
-                name: "John Doe",
-                posts: [
-                    {
-                        title: "My First Post",
-                        comments: [
-                            {
-                                content: "Great post!",
-                                author: { email: "user@example.com", apiAction: "create" },
-                            },
-                        ],
-                    },
-                ],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "posts", type: "Post" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                posts: {
-                    create: [
-                        {
-                            title: "My First Post",
-                            comments: {
-                                create: [
-                                    {
-                                        content: "Great post!",
-                                        author: { create: { email: "user@example.com" } },
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                },
-            });
-        });
-    });
-    describe("Edge Cases", () => {
-        it("should handle empty arrays for list relation fields", () => {
-            const body = {
-                name: "John Doe",
-                posts: [],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "posts", type: "Post" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                posts: {},
-            });
-        });
-        it("should handle null values for relation fields", () => {
-            const body = {
-                name: "John Doe",
-                profile: null,
-                posts: null,
-            };
-            const relationFields = {
-                singular: [{ name: "profile", type: "Profile" }],
-                list: [{ name: "posts", type: "Post" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                profile: null,
-                posts: null,
-            });
-        });
-    });
-});
-describe("canBeUsedToConnect", () => {
-    it("should return true for objects with only an id", () => {
-        const modelName = "User";
-        const bodyField = { id: "123" };
-        expect((0, base_helpers_1.canBeUsedToConnect)(modelName, bodyField)).toBe(true);
-    });
-    it("should return true for objects with a single unique field", () => {
-        const modelName = "User";
-        const bodyField = { email: "test@example.com" };
-        expect((0, base_helpers_1.canBeUsedToConnect)(modelName, bodyField)).toBe(true);
-    });
-    it("should return true for objects with a single field from uniqueFields list", () => {
-        const modelName = "User";
-        const bodyField = { username: "testuser" };
-        expect((0, base_helpers_1.canBeUsedToConnect)(modelName, bodyField)).toBe(true);
-    });
-    it("should return true for objects with apiAction set to connect", () => {
-        const modelName = "User";
-        const bodyField = { id: "123", apiAction: "connect" };
-        expect((0, base_helpers_1.canBeUsedToConnect)(modelName, bodyField)).toBe(true);
-    });
-    it("should return false for objects with multiple fields", () => {
-        const modelName = "User";
-        const bodyField = { id: "123", name: "John" };
-        expect((0, base_helpers_1.canBeUsedToConnect)(modelName, bodyField)).toBe(false);
-    });
-    it("should return false for objects with a single field that is not unique", () => {
-        const modelName = "User";
-        const bodyField = { name: "John" };
-        expect((0, base_helpers_1.canBeUsedToConnect)(modelName, bodyField)).toBe(false);
-    });
-    it("should return false for objects with apiAction set to something other than connect", () => {
-        const modelName = "User";
-        const bodyField = { id: "123", apiAction: "delete" };
-        expect((0, base_helpers_1.canBeUsedToConnect)(modelName, bodyField)).toBe(false);
-    });
-    it("should return false for null or undefined values", () => {
-        const modelName = "User";
-        expect((0, base_helpers_1.canBeUsedToConnect)(modelName, null)).toBe(false);
-        expect((0, base_helpers_1.canBeUsedToConnect)(modelName, undefined)).toBe(false);
-    });
-});
-describe("isListFieldAnArray", () => {
-    it("should return true for arrays", () => {
-        expect((0, base_helpers_1.isListFieldAnArray)([])).toBe(true);
-        expect((0, base_helpers_1.isListFieldAnArray)([1, 2, 3])).toBe(true);
-        expect((0, base_helpers_1.isListFieldAnArray)(new Array())).toBe(true);
-    });
-    it("should return false for non-arrays", () => {
-        expect((0, base_helpers_1.isListFieldAnArray)({})).toBe(false);
-        expect((0, base_helpers_1.isListFieldAnArray)("array")).toBe(false);
-        expect((0, base_helpers_1.isListFieldAnArray)(123)).toBe(false);
-        expect((0, base_helpers_1.isListFieldAnArray)(null)).toBe(false);
-        expect((0, base_helpers_1.isListFieldAnArray)(undefined)).toBe(false);
-    });
-});
-describe("isPrismaRelationFormat", () => {
-    it("should return true for objects with Prisma operations", () => {
-        expect((0, base_helpers_1.isPrismaRelationFormat)({ create: { name: "Test" } })).toBe(true);
-        expect((0, base_helpers_1.isPrismaRelationFormat)({ connect: { id: 1 } })).toBe(true);
-        expect((0, base_helpers_1.isPrismaRelationFormat)({
-            update: { where: { id: 1 }, data: { name: "Test" } },
-        })).toBe(true);
-        expect((0, base_helpers_1.isPrismaRelationFormat)({ delete: { id: 1 } })).toBe(true);
-        expect((0, base_helpers_1.isPrismaRelationFormat)({ disconnect: { id: 1 } })).toBe(true);
-        expect((0, base_helpers_1.isPrismaRelationFormat)({ deleteMany: { id: { in: [1, 2, 3] } } })).toBe(true);
-        expect((0, base_helpers_1.isPrismaRelationFormat)({
-            connectOrCreate: {
-                where: { email: "test@example.com" },
-                create: { email: "test@example.com", name: "Test" },
-            },
-        })).toBe(true);
-        expect((0, base_helpers_1.isPrismaRelationFormat)({
-            upsert: {
-                where: { id: 1 },
-                update: { name: "Updated" },
-                create: { name: "New" },
-            },
-        })).toBe(true);
-        expect((0, base_helpers_1.isPrismaRelationFormat)({ set: [{ id: 1 }, { id: 2 }] })).toBe(true);
-    });
-    it("should return false for objects without Prisma operations", () => {
-        expect((0, base_helpers_1.isPrismaRelationFormat)({ name: "Test" })).toBe(false);
-        expect((0, base_helpers_1.isPrismaRelationFormat)({ id: 1, title: "Test" })).toBe(false);
-        expect((0, base_helpers_1.isPrismaRelationFormat)([])).toBe(false);
-        expect((0, base_helpers_1.isPrismaRelationFormat)({ apiAction: "create" })).toBe(false);
-    });
-});
-describe("handleRelationFieldsInBody with pre-formatted relations", () => {
-    describe("Pre-formatted Singular Relations", () => {
-        it("should preserve pre-formatted create operation", () => {
-            const body = {
-                name: "John Doe",
-                profile: {
-                    create: {
-                        bio: "Software Engineer",
-                        avatarUrl: "https://example.com/avatar.jpg",
-                    },
-                },
-            };
-            const relationFields = {
-                singular: [{ name: "profile", type: "Profile" }],
-                list: [],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                profile: {
-                    create: {
-                        bio: "Software Engineer",
-                        avatarUrl: "https://example.com/avatar.jpg",
-                    },
-                },
-            });
-        });
-        it("should preserve pre-formatted connect operation", () => {
-            const body = {
-                name: "John Doe",
-                profile: {
-                    connect: {
-                        id: "123",
-                    },
-                },
-            };
-            const relationFields = {
-                singular: [{ name: "profile", type: "Profile" }],
-                list: [],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                profile: {
-                    connect: {
-                        id: "123",
-                    },
-                },
-            });
-        });
-        it("should preserve pre-formatted upsert operation", () => {
-            const body = {
-                title: "My Post",
-                author: {
-                    upsert: {
-                        where: { email: "author@example.com" },
-                        update: { name: "Updated Author" },
-                        create: { email: "author@example.com", name: "New Author" },
-                    },
-                },
-            };
-            const relationFields = {
-                singular: [{ name: "author", type: "User" }],
-                list: [],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                author: {
-                    upsert: {
-                        where: { email: "author@example.com" },
-                        update: { name: "Updated Author" },
-                        create: { email: "author@example.com", name: "New Author" },
-                    },
-                },
-            });
-        });
-    });
-    describe("Pre-formatted List Relations", () => {
-        it("should preserve pre-formatted connect operations in list", () => {
-            const body = {
-                title: "My Post",
-                tags: {
-                    connect: [{ id: "1" }, { id: "2" }],
-                },
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    connect: [{ id: "1" }, { id: "2" }],
-                },
-            });
-        });
-        it("should preserve pre-formatted create operations in list", () => {
-            const body = {
-                title: "My Post",
-                tags: {
-                    create: [{ name: "JavaScript" }, { name: "TypeScript" }],
-                },
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    create: [{ name: "JavaScript" }, { name: "TypeScript" }],
-                },
-            });
-        });
-        it("should preserve pre-formatted set operation", () => {
-            const body = {
-                title: "My Post",
-                tags: {
-                    set: [{ id: "1" }, { id: "2" }],
-                },
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    set: [{ id: "1" }, { id: "2" }],
-                },
-            });
-        });
-        it("should preserve complex pre-formatted operations", () => {
-            const body = {
-                title: "My Post",
-                tags: {
-                    create: [{ name: "New Tag" }],
-                    connect: [{ id: "1" }],
-                    set: [{ id: "5" }, { id: "6" }],
-                },
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "tags", type: "Tag" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                tags: {
-                    create: [{ name: "New Tag" }],
-                    connect: [{ id: "1" }],
-                    set: [{ id: "5" }, { id: "6" }],
-                },
-            });
-        });
-    });
-    describe("Mixed Auto and Pre-formatted Relations", () => {
-        it("should handle mix of auto and pre-formatted relations", () => {
-            const body = {
-                title: "My Post",
-                category: {
-                    name: "Technology",
-                },
-                tags: {
-                    connect: [{ id: "1" }],
-                    create: [{ name: "New Tag" }],
-                },
-                comments: [
-                    { content: "Great post!", author: { email: "user@example.com" } },
-                ],
-            };
-            const relationFields = {
-                singular: [{ name: "category", type: "Category" }],
-                list: [
-                    { name: "tags", type: "Tag" },
-                    { name: "comments", type: "Comment" },
-                ],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                title: "My Post",
-                category: {
-                    connect: {
-                        name: "Technology",
-                    },
-                },
-                tags: {
-                    connect: [{ id: "1" }],
-                    create: [{ name: "New Tag" }],
-                },
-                comments: {
-                    create: [
-                        {
-                            content: "Great post!",
-                            author: {
-                                connect: {
-                                    email: "user@example.com",
-                                },
-                            },
-                        },
-                    ],
-                },
-            });
-        });
-        it("should process nested relations but preserve pre-formatted ones", () => {
-            const body = {
-                name: "John Doe",
-                posts: [
-                    {
-                        title: "My First Post",
-                        category: {
-                            connect: { name: "Preformatted Category" },
-                        },
-                        comments: [{ content: "Great post!" }],
-                    },
-                ],
-            };
-            const relationFields = {
-                singular: [],
-                list: [{ name: "posts", type: "Post" }],
-            };
-            const result = (0, base_helpers_1.handleRelationFieldsInBody)(body, relationFields);
-            expect(result).toEqual({
-                name: "John Doe",
-                posts: {
-                    create: [
-                        {
-                            title: "My First Post",
-                            category: {
-                                connect: { name: "Preformatted Category" },
-                            },
-                            comments: {
-                                create: [{ content: "Great post!" }],
-                            },
-                        },
-                    ],
-                },
-            });
-        });
-    });
-});
-//# sourceMappingURL=base.helpers.test.js.map