@goatlab/fluent 0.7.6 → 0.7.11

package/dist/TypeOrmConnector/test/relations/car/car.repositoryTypeOrm.js

@@ -6,16 +6,21 @@ const car_schema_1 = require("./car.schema");
 const TypeOrmConnector_1 = require("../../../TypeOrmConnector");
 const user_repositoryTypeOrm_1 = require("../user/user.repositoryTypeOrm");
 const memoryDataSource_1 = require("../../sqlite/memoryDataSource");
+const car_output_schema_1 = require("./car.output.schema");
 class CarsRepository extends TypeOrmConnector_1.TypeOrmConnector {
     constructor() {
         super({
             entity: car_entity_1.CarsEntity,
             dataSource: memoryDataSource_1.MemoryDataSource,
-            inputSchema: car_schema_1.CarsEntitySchema
+            inputSchema: car_schema_1.carInputSchema,
+            outputSchema: car_output_schema_1.carOutputSchema
         });
         this.user = () => this.belongsTo({
             repository: user_repositoryTypeOrm_1.UserRepository
         });
+        this.anotherRelation = () => this.belongsTo({
+            repository: user_repositoryTypeOrm_1.UserRepository
+        });
     }
 }
 exports.CarsRepository = CarsRepository;

package/dist/TypeOrmConnector/test/relations/car/car.schema.d.ts

@@ -1,38 +1,15 @@
 import { z } from 'zod';
-export declare const CarsEntitySchema: z.ZodObject<{
+export declare const carInputSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     userId: z.ZodOptional<z.ZodString>;
-    user: z.ZodOptional<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        name: z.ZodString;
-        age: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        id?: string | undefined;
-        age?: number | undefined;
-        name: string;
-    }, {
-        id?: string | undefined;
-        age?: number | undefined;
-        name: string;
-    }>>;
 }, "strip", z.ZodTypeAny, {
     id?: string | undefined;
     userId?: string | undefined;
-    user?: {
-        id?: string | undefined;
-        age?: number | undefined;
-        name: string;
-    } | undefined;
     name: string;
 }, {
     id?: string | undefined;
     userId?: string | undefined;
-    user?: {
-        id?: string | undefined;
-        age?: number | undefined;
-        name: string;
-    } | undefined;
     name: string;
 }>;
-export declare type CarsEntityInputSchema = z.infer<typeof CarsEntitySchema>;
+export declare type CarDtoInput = z.infer<typeof carInputSchema>;

package/dist/TypeOrmConnector/test/relations/car/car.schema.js

@@ -1,14 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CarsEntitySchema = void 0;
+exports.carInputSchema = void 0;
 const zod_1 = require("zod");
-exports.CarsEntitySchema = zod_1.z.object({
+exports.carInputSchema = zod_1.z.object({
     id: zod_1.z.string().optional(),
     name: zod_1.z.string(),
-    userId: zod_1.z.string().optional(),
-    user: zod_1.z.object({
-        id: zod_1.z.string().optional(),
-        name: zod_1.z.string(),
-        age: zod_1.z.number().optional(),
-    }).optional()
+    userId: zod_1.z.string().optional()
 });

package/dist/TypeOrmConnector/test/relations/relationsTestsSuite.d.ts

@@ -1 +1 @@
-export declare const relationsTestSuite: (ModelF: any, BelongsToModelF: any, ManyToManyModelF: any) => void;
+export declare const relationsTestSuite: (UserRepo: any, BelongsToModelF: any, ManyToManyModelF: any) => void;

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

@@ -2,69 +2,89 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.relationsTestSuite = void 0;
 const js_utils_1 = require("@goatlab/js-utils");
-let Model;
-let BelongsToModel;
-let ManyToManyModel;
-const relationsTestSuite = (ModelF, BelongsToModelF, ManyToManyModelF) => {
+let User;
+let Car;
+let Role;
+const relationsTestSuite = (UserRepo, BelongsToModelF, ManyToManyModelF) => {
     beforeAll(() => {
-        Model = new ModelF();
-        BelongsToModel = new BelongsToModelF();
-        ManyToManyModel = new ManyToManyModelF();
+        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 Model.insert({
+        const insertedUser = await User.insert({
             name: 'testUser',
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const findById = await Model.requireById(insertedUser.id);
+        const findById = await User.requireById(insertedUser.id);
         expect(findById.id).toBe(insertedUser.id);
     });
     test('requireById - Should fail if not found', async () => {
-        const insertedUser = await Model.insert({
+        const insertedUser = await User.insert({
             name: 'testUser',
             age: 20
         });
-        const [error, found] = await js_utils_1.Promises.try(Model.requireById('62ed01e4219a6ab760ae5c50'));
+        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 Model.insert({
+        const insertedUser = await User.insert({
             name: 'testUser',
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user = Model.loadFirst({
+        const user = User.loadFirst({
             where: {
                 id: insertedUser.id
             }
         });
         expect(Array.isArray(user)).toBe(false);
         expect(typeof user).toBe('object');
-        expect(typeof user.associate).toBe('function');
+        expect(user).toHaveProperty('associate');
     });
     test('Associate - OneToMany - Should  insert data', async () => {
-        const insertedUser = await Model.insert({
+        const insertedUser = await User.insert({
             name: 'testUser',
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user = await Model.loadById(insertedUser.id);
+        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 Model.insert({
+        const insertedUser = await User.insert({
             name: 'testUser',
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user1 = await Model.loadById(insertedUser.id);
+        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 Model.findMany({
+        const searchUserWithRelation = await User.findMany({
             where: { id: insertedUser.id },
             include: {
                 cars: true
@@ -75,11 +95,13 @@ const relationsTestSuite = (ModelF, BelongsToModelF, ManyToManyModelF) => {
         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' } });
+        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.......' } });
@@ -87,14 +109,14 @@ const relationsTestSuite = (ModelF, BelongsToModelF, ManyToManyModelF) => {
         expect(searchCar2.length === 0).toBe(true);
     });
     test('Query related model - ManyToOne (BelongsTo)', async () => {
-        const insertedUser = await Model.insert({
+        const insertedUser = await User.insert({
             name: 'testUser',
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user1 = await Model.loadById(insertedUser.id);
+        const user1 = await User.loadById(insertedUser.id);
         await user1.cars().associate({ name: 'My new car' });
-        const results = await BelongsToModel.findMany({
+        const results = await Car.findMany({
             where: {
                 userId: insertedUser.id
             },
@@ -107,43 +129,421 @@ const relationsTestSuite = (ModelF, BelongsToModelF, ManyToManyModelF) => {
         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 Model.insert({
+        const insertedUser = await User.insert({
             name: 'testUser',
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const adminRole = await ManyToManyModel.insert({
+        const adminRole = await Role.insert({
             name: 'Administrator'
         });
-        const user = await Model.loadById(insertedUser.id);
-        const associated = await user.roles().attach(adminRole.id);
-        expect(associated[0].userId).toBe(insertedUser.id);
-        expect(associated[0].roleId).toBe(adminRole.id);
-        const searchUserWithRelation = await Model.findMany({
+        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: true
+                roles: {
+                    withPivot: true
+                }
             }
         });
+        console.log(searchUserWithRelation[0]);
         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);
-        const roles = await ManyToManyModel.findMany({
+        expect(searchUserWithRelation[0].roles[0].pivot.id).toBe(attached[0].id);
+        const roles = await Role.findMany({
             where: {
                 name: 'Administrator'
             },
             include: {
-                users: true
+                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;