@goatlab/fluent 0.7.21 → 0.7.22

package/dist/TypeOrmConnector/test/relations/relationsTestsSuite.js

@@ -0,0 +1,548 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relationsTestSuite = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+let User;
+let Car;
+let Role;
+const relationsTestSuite = (UserRepo, BelongsToModelF, ManyToManyModelF) => {
+    beforeAll(() => {
+        User = new UserRepo();
+        Car = new BelongsToModelF();
+        Role = new ManyToManyModelF();
+    });
+    const insertRelatedData = async () => {
+        const insertedUser = await User.insert({
+            name: 'testUser1',
+            age: 20
+        });
+        await User.insert({
+            name: 'anotherUser 2',
+            age: 24
+        });
+        const adminRole = await Role.insert({
+            name: 'Administrator'
+        });
+        const user = await User.loadById(insertedUser.id);
+        const attachedRole = await user.roles().attach(adminRole.id);
+        const associatedCar1 = await user.cars().associate({ name: 'My' });
+        const associatedCar2 = await user.cars().associate({ name: 'My new car 2' });
+        const associatedCar3 = await user.cars().associate({ name: 'My new car 4' });
+        const associatedCar4 = await user.cars().associate({ name: 'My new car 4' });
+        return { insertedUser, adminRole };
+    };
+    test('requireById - Should return valid Object', async () => {
+        const insertedUser = await User.insert({
+            name: 'testUser',
+            age: 20
+        });
+        expect(typeof insertedUser.id).toBe('string');
+        const findById = await User.requireById(insertedUser.id);
+        expect(findById.id).toBe(insertedUser.id);
+    });
+    test('requireById - Should fail if not found', async () => {
+        const insertedUser = await User.insert({
+            name: 'testUser',
+            age: 20
+        });
+        const [error, found] = await js_utils_1.Promises.try(User.requireById('62ed01e4219a6ab760ae5c50'));
+        expect(error?.message).toBe('Object 62ed01e4219a6ab760ae5c50 not found');
+    });
+    test('loadFirst - Should return a cloned class', async () => {
+        const insertedUser = await User.insert({
+            name: 'testUser',
+            age: 20
+        });
+        expect(typeof insertedUser.id).toBe('string');
+        const user = User.loadFirst({
+            where: {
+                id: insertedUser.id
+            }
+        });
+        expect(Array.isArray(user)).toBe(false);
+        expect(typeof user).toBe('object');
+        expect(user).toHaveProperty('associate');
+    });
+    test('Associate - OneToMany - Should  insert data', async () => {
+        const insertedUser = await User.insert({
+            name: 'testUser',
+            age: 20
+        });
+        expect(typeof insertedUser.id).toBe('string');
+        const user = await User.loadById(insertedUser.id);
+        const cars = await user.cars().associate({ name: 'Another new car' });
+        expect(Array.isArray(cars)).toBe(true);
+        expect(cars[0].name).toBe('Another new car');
+        expect(cars[0].userId).toBe(insertedUser.id);
+    });
+    test('Query related model - OneToMany (belongsToMany)', async () => {
+        const insertedUser = await User.insert({
+            name: 'testUser',
+            age: 20
+        });
+        expect(typeof insertedUser.id).toBe('string');
+        const user1 = await User.loadById(insertedUser.id);
+        const cars = await user1.cars().associate({ name: 'My new car' });
+        expect(Array.isArray(cars)).toBe(true);
+        const searchUserWithRelation = await User.findMany({
+            where: { id: insertedUser.id },
+            include: {
+                cars: true
+            }
+        });
+        const firstResult = searchUserWithRelation[0];
+        expect(Array.isArray(searchUserWithRelation)).toBe(true);
+        expect(Array.isArray(firstResult.cars)).toBe(true);
+        expect(firstResult.cars.length > 0).toBe(true);
+        expect(firstResult.cars[0].userId).toBe(insertedUser.id);
+        const searchCar = await user1.cars().findMany({
+            where: { name: 'My new car' },
+            include: { user: true }
+        });
+        expect(Array.isArray(searchCar)).toBe(true);
+        expect(searchCar.length > 0).toBe(true);
+        expect(searchCar[0].user?.id).toBe(insertedUser.id);
+        const searchCar2 = await user1
+            .cars()
+            .findMany({ where: { name: 'My.......' } });
+        expect(Array.isArray(searchCar2)).toBe(true);
+        expect(searchCar2.length === 0).toBe(true);
+    });
+    test('Query related model - ManyToOne (BelongsTo)', async () => {
+        const insertedUser = await User.insert({
+            name: 'testUser',
+            age: 20
+        });
+        expect(typeof insertedUser.id).toBe('string');
+        const user1 = await User.loadById(insertedUser.id);
+        await user1.cars().associate({ name: 'My new car' });
+        const results = await Car.findMany({
+            where: {
+                userId: insertedUser.id
+            },
+            include: {
+                user: true
+            }
+        });
+        expect(Array.isArray(results)).toBe(true);
+        expect(results.length > 0).toBe(true);
+        expect(typeof results[0].user?.name).toBe('string');
+        expect(results[0].user['id']).toBe(insertedUser.id);
+    });
+    test('Include - can load cyclical relations', async () => {
+        const { insertedUser } = await insertRelatedData();
+        const searchUserWithRelations = await User.findMany({
+            where: {
+                id: insertedUser.id
+            },
+            include: {
+                cars: {
+                    include: {
+                        user: {
+                            include: {
+                                cars: {
+                                    include: {
+                                        user: true
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        expect(searchUserWithRelations.length).toBe(1);
+        expect(searchUserWithRelations[0].cars?.length).toBe(4);
+        expect(searchUserWithRelations[0].cars[0].user?.id).toBe(insertedUser.id);
+        expect(searchUserWithRelations[0].cars[0].user?.name).toBe(insertedUser.name);
+        expect(searchUserWithRelations[0].cars[0].user?.id).toBe(searchUserWithRelations[0].id);
+        expect(searchUserWithRelations[0].cars[0].user?.name).toBe(searchUserWithRelations[0].name);
+        expect(searchUserWithRelations[0].cars[0].user?.cars?.length).toBe(4);
+        expect(searchUserWithRelations[0].cars[0].user?.cars[0].user?.id).toBe(searchUserWithRelations[0].id);
+    });
+    test('Include - can filter related models', async () => {
+        const { insertedUser } = await insertRelatedData();
+        const searchUserWithRelations = await User.findMany({
+            where: {
+                id: insertedUser.id
+            },
+            include: {
+                cars: {
+                    select: {
+                        name: true,
+                        id: true
+                    },
+                    where: {
+                        name: 'My new car 4'
+                    },
+                    include: {
+                        user: {
+                            include: {
+                                cars: {
+                                    where: {
+                                        name: 'My new car XXXxX'
+                                    },
+                                    include: {
+                                        user: true
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        expect(searchUserWithRelations[0].cars?.length).toBe(2);
+        expect(searchUserWithRelations[0].cars[0].name).toBe('My new car 4');
+        expect(searchUserWithRelations[0].cars[0].user?.cars?.length).toBe(0);
+    });
+    test('Include - (One to Many) Should display [] if not found', async () => {
+        const { insertedUser } = await insertRelatedData();
+        const searchUserWithRelations = await User.findMany({
+            where: {
+                id: insertedUser.id
+            },
+            include: {
+                cars: {
+                    where: {
+                        name: 'My new car XX'
+                    }
+                }
+            }
+        });
+        expect(Array.isArray(searchUserWithRelations[0].cars)).toBe(true);
+        expect(searchUserWithRelations[0].cars?.length).toBe(0);
+    });
+    test('Include - (Many to One) Should display null if not found', async () => {
+        const { insertedUser } = await insertRelatedData();
+        const insertedCars = await Car.findMany({
+            where: {
+                userId: insertedUser.id
+            },
+            select: {
+                id: true,
+                name: true,
+                userId: true,
+                user: true
+            },
+            include: {
+                user: {
+                    where: {
+                        name: 'JOHN'
+                    }
+                }
+            }
+        });
+        expect(insertedCars[0].user === null || insertedCars[0].user === undefined).toBe(true);
+        expect(insertedCars.length).toBe(4);
+    });
+    test('Include - Should pull info from the main search object if no related data', async () => {
+        const { insertedUser } = await insertRelatedData();
+        const searchUserWithRelations = await User.findMany({
+            select: {
+                id: true,
+                name: true,
+                cars: {
+                    name: true,
+                    user: {
+                        id: true,
+                        name: true,
+                        cars: {
+                            id: true,
+                            user: true,
+                            name: true
+                        }
+                    }
+                }
+            },
+            where: {
+                id: insertedUser.id
+            },
+            include: {
+                cars: {
+                    select: {
+                        name: true,
+                        id: true
+                    },
+                    where: {
+                        name: 'My new car XXX'
+                    },
+                    include: {
+                        user: {
+                            include: {
+                                cars: {
+                                    where: {
+                                        name: 'My new car XXXxX'
+                                    },
+                                    include: {
+                                        user: true
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        expect(searchUserWithRelations[0].id).toBe(insertedUser.id);
+        expect(searchUserWithRelations[0].name).toBe(insertedUser.name);
+        expect(searchUserWithRelations[0].cars?.length).toBe(0);
+    });
+    test('Include - Can filter and select specific keys', async () => {
+        const { insertedUser } = await insertRelatedData();
+        const searchUserWithRelations = await User.findMany({
+            select: {
+                id: true,
+                name: true,
+                age: true,
+                cars: {
+                    name: true,
+                    user: {
+                        id: true,
+                        name: true,
+                        cars: {
+                            id: true,
+                            user: true,
+                            name: true
+                        }
+                    }
+                }
+            },
+            where: {
+                id: insertedUser.id
+            },
+            include: {
+                cars: {
+                    select: {
+                        name: true,
+                        id: true
+                    },
+                    where: {
+                        name: 'My new car 4'
+                    },
+                    include: {
+                        user: {
+                            include: {
+                                cars: {
+                                    where: {
+                                        name: 'My new car XXXxX'
+                                    },
+                                    include: {
+                                        user: true
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        expect(searchUserWithRelations[0]).toHaveProperty('age');
+        expect(searchUserWithRelations[0].age).toBe(insertedUser.age);
+        expect(searchUserWithRelations[0]).not.toHaveProperty('breed');
+    });
+    test('Include - Should filter keys from nested objects', async () => {
+        const { insertedUser } = await insertRelatedData();
+        const searchUserWithRelations = await User.findMany({
+            select: {
+                id: true,
+                name: true,
+                cars: {
+                    name: true,
+                    user: {
+                        id: true,
+                        name: true,
+                        cars: {
+                            id: true,
+                            user: true,
+                            name: true
+                        }
+                    }
+                }
+            },
+            where: {
+                id: insertedUser.id
+            },
+            include: {
+                cars: {
+                    select: {
+                        name: true
+                    },
+                    where: {
+                        name: 'My new car 4'
+                    },
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                name: true
+                            },
+                            include: {
+                                cars: {
+                                    where: {
+                                        name: 'My new car XXXxX'
+                                    },
+                                    include: {
+                                        user: true
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        expect(searchUserWithRelations[0].cars[0]).not.toHaveProperty('id');
+        expect(searchUserWithRelations[0].cars[0]).not.toHaveProperty('userId');
+        expect(searchUserWithRelations[0].cars[0]).toHaveProperty('user');
+        expect(searchUserWithRelations[0].cars[0].name).toBe('My new car 4');
+        expect(searchUserWithRelations[0].cars[0].user).not.toHaveProperty('age');
+        expect(searchUserWithRelations[0].cars[0].user).not.toHaveProperty('breed');
+        expect(searchUserWithRelations[0].cars[0].user?.id).toBe(insertedUser.id);
+    });
+    test('Include - Can select keys using main select or nested selects', async () => {
+        const { insertedUser } = await insertRelatedData();
+        await User.findMany({
+            select: {
+                id: true,
+                name: true,
+                cars: {
+                    name: true,
+                    user: {
+                        id: true,
+                        name: true,
+                        cars: {
+                            id: true,
+                            user: true,
+                            name: true
+                        }
+                    }
+                }
+            },
+            where: {
+                id: insertedUser.id
+            },
+            include: {
+                cars: {
+                    select: {
+                        name: true,
+                        id: true
+                    },
+                    where: {
+                        name: 'My new car 4'
+                    },
+                    include: {
+                        user: {
+                            include: {
+                                cars: {
+                                    where: {
+                                        name: 'My new car XXXxX'
+                                    },
+                                    include: {
+                                        user: true
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    });
+    test('Include - (Many to Many) should display [] if not found', async () => {
+        const { insertedUser } = await insertRelatedData();
+        await User.findMany({
+            select: {
+                id: true,
+                name: true,
+                cars: {
+                    name: true,
+                    user: {
+                        id: true,
+                        name: true,
+                        cars: {
+                            id: true,
+                            user: true,
+                            name: true
+                        }
+                    }
+                }
+            },
+            where: {
+                id: insertedUser.id
+            },
+            include: {
+                cars: {
+                    select: {
+                        name: true,
+                        id: true
+                    },
+                    where: {
+                        name: 'My new car 4'
+                    },
+                    include: {
+                        user: {
+                            include: {
+                                cars: {
+                                    where: {
+                                        name: 'My new car XXXxX'
+                                    },
+                                    include: {
+                                        user: true
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    });
+    test('Query related model - ManyToMany', async () => {
+        const insertedUser = await User.insert({
+            name: 'testUser',
+            age: 20
+        });
+        expect(typeof insertedUser.id).toBe('string');
+        const adminRole = await Role.insert({
+            name: 'Administrator'
+        });
+        const user = await User.loadById(insertedUser.id);
+        const attached = await user.roles().attach(adminRole.id);
+        expect(attached[0].userId).toBe(insertedUser.id);
+        expect(attached[0].roleId).toBe(adminRole.id);
+        const searchUserWithRelation = await User.findMany({
+            where: {
+                id: insertedUser.id
+            },
+            include: {
+                roles: {
+                    withPivot: true
+                }
+            }
+        });
+        expect(Array.isArray(searchUserWithRelation[0].roles)).toBe(true);
+        expect(searchUserWithRelation[0].roles.length > 0).toBe(true);
+        expect(typeof searchUserWithRelation[0].roles[0].name).toBe('string');
+        expect(searchUserWithRelation[0].roles[0].id).toBe(adminRole.id);
+        expect(searchUserWithRelation[0].roles[0].pivot.id).toBe(attached[0].id);
+        const roles = await Role.findMany({
+            where: {
+                name: 'Administrator'
+            },
+            include: {
+                users: { withPivot: true }
+            }
+        });
+        expect(Array.isArray(roles)).toBe(true);
+        expect(roles.length > 0).toBe(true);
+        expect(typeof roles[0].users[0].name).toBe('string');
+        expect(typeof roles[0].users[0].age).toBe('number');
+        expect(roles[0].users[0].pivot).toBeDefined();
+        expect(roles[0].users[0].id).toBe(roles[0].users[0].pivot.userId);
+        expect(roles.some(r => {
+            return r.users.some(u => u.id === insertedUser.id);
+        })).toBe(true);
+    });
+};
+exports.relationsTestSuite = relationsTestSuite;

package/dist/TypeOrmConnector/test/relations/roles/role.output.schema.d.ts

@@ -0,0 +1,152 @@
+import { z } from 'zod';
+export declare const userWithPivot: z.ZodObject<z.extendShape<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    age: z.ZodOptional<z.ZodNumber>;
+    breed: z.ZodOptional<z.ZodObject<{
+        family: z.ZodOptional<z.ZodString>;
+        members: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        family?: string | undefined;
+        members?: number | undefined;
+    }, {
+        family?: string | undefined;
+        members?: number | undefined;
+    }>>;
+}, {
+    pivot: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        roleId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        roleId: string;
+        userId: string;
+    }, {
+        id?: string | undefined;
+        roleId: string;
+        userId: string;
+    }>>;
+}>, "strip", z.ZodTypeAny, {
+    pivot?: {
+        id?: string | undefined;
+        roleId: string;
+        userId: string;
+    } | undefined;
+    id?: string | undefined;
+    age?: number | undefined;
+    breed?: {
+        family?: string | undefined;
+        members?: number | undefined;
+    } | undefined;
+    name: string;
+}, {
+    pivot?: {
+        id?: string | undefined;
+        roleId: string;
+        userId: string;
+    } | undefined;
+    id?: string | undefined;
+    age?: number | undefined;
+    breed?: {
+        family?: string | undefined;
+        members?: number | undefined;
+    } | undefined;
+    name: string;
+}>;
+export declare const RoleOuputSchema: z.ZodObject<z.extendShape<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+}, {
+    id: z.ZodString;
+    users: z.ZodOptional<z.ZodArray<z.ZodObject<z.extendShape<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        age: z.ZodOptional<z.ZodNumber>;
+        breed: z.ZodOptional<z.ZodObject<{
+            family: z.ZodOptional<z.ZodString>;
+            members: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            family?: string | undefined;
+            members?: number | undefined;
+        }, {
+            family?: string | undefined;
+            members?: number | undefined;
+        }>>;
+    }, {
+        pivot: z.ZodOptional<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            roleId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id?: string | undefined;
+            roleId: string;
+            userId: string;
+        }, {
+            id?: string | undefined;
+            roleId: string;
+            userId: string;
+        }>>;
+    }>, "strip", z.ZodTypeAny, {
+        pivot?: {
+            id?: string | undefined;
+            roleId: string;
+            userId: string;
+        } | undefined;
+        id?: string | undefined;
+        age?: number | undefined;
+        breed?: {
+            family?: string | undefined;
+            members?: number | undefined;
+        } | undefined;
+        name: string;
+    }, {
+        pivot?: {
+            id?: string | undefined;
+            roleId: string;
+            userId: string;
+        } | undefined;
+        id?: string | undefined;
+        age?: number | undefined;
+        breed?: {
+            family?: string | undefined;
+            members?: number | undefined;
+        } | undefined;
+        name: string;
+    }>, "many">>;
+}>, "strip", z.ZodTypeAny, {
+    users?: {
+        pivot?: {
+            id?: string | undefined;
+            roleId: string;
+            userId: string;
+        } | undefined;
+        id?: string | undefined;
+        age?: number | undefined;
+        breed?: {
+            family?: string | undefined;
+            members?: number | undefined;
+        } | undefined;
+        name: string;
+    }[] | undefined;
+    id: string;
+    name: string;
+}, {
+    users?: {
+        pivot?: {
+            id?: string | undefined;
+            roleId: string;
+            userId: string;
+        } | undefined;
+        id?: string | undefined;
+        age?: number | undefined;
+        breed?: {
+            family?: string | undefined;
+            members?: number | undefined;
+        } | undefined;
+        name: string;
+    }[] | undefined;
+    id: string;
+    name: string;
+}>;
+export declare type RoleDtoOut = z.infer<typeof RoleOuputSchema>;