@goatlab/fluent 0.7.31 → 0.7.32

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

@@ -1,575 +0,0 @@
-"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('Attach - Many to Many - Should relate Data', async () => {
-        const insertedUser = await User.insert({
-            name: 'testUser1',
-            age: 20
-        });
-        const adminRole = await Role.insert({
-            name: 'Administrator'
-        });
-        const user = await User.loadById(insertedUser.id);
-        const attachedRoles = await user.roles().attach(adminRole.id);
-        expect(attachedRoles[0].userId).toBe(insertedUser.id);
-        expect(attachedRoles[0].roleId).toBe(adminRole.id);
-    });
-    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('Associate - OneToMany - Should relate existing model', async () => {
-        const insertedUser = await User.insert({
-            name: 'testUser',
-            age: 20
-        });
-        expect(typeof insertedUser.id).toBe('string');
-        const user = await User.loadById(insertedUser.id);
-        const createdCar = await Car.insert({ name: 'Another new car' });
-        const cars = await user.cars().associate(createdCar);
-        expect(Array.isArray(cars)).toBe(true);
-        expect(cars[0].name).toBe('Another new car');
-        expect(cars[0].userId).toBe(insertedUser.id);
-        expect(createdCar.id).toBe(cars[0].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;