@goatlab/fluent 0.6.23 → 0.7.0

package/dist/TypeOrmConnector/test/mongo/roles.mongo.repository.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleRepository = void 0;
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const role_schema_1 = require("../relations/roles/role.schema");
+const roles_user_mongo_repository_1 = require("./roles_user.mongo.repository");
+const roles_entity_1 = require("../relations/roles/roles.entity");
+const mongoDatasource_1 = require("./mongoDatasource");
+const user_mongo_repository_1 = require("./user.mongo.repository");
+class RoleRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: roles_entity_1.RoleEntity,
+            dataSource: mongoDatasource_1.MongoDataSource,
+            inputSchema: role_schema_1.RoleEntitySchema
+        });
+        this.users = () => this.belongsToMany({
+            repository: user_mongo_repository_1.UserRepository,
+            pivot: roles_user_mongo_repository_1.RoleUsersRepository
+        });
+    }
+}
+exports.RoleRepository = RoleRepository;

package/dist/TypeOrmConnector/test/mongo/roles_user.mongo.repository.d.ts

@@ -0,0 +1,6 @@
+import { RolesUser } from '../relations/roles/roles_user.entity';
+import { RolesUserInputSchema } from '../relations/roles/roles_user.schema';
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+export declare class RoleUsersRepository extends TypeOrmConnector<RolesUser, RolesUserInputSchema> {
+    constructor();
+}

package/dist/TypeOrmConnector/test/mongo/roles_user.mongo.repository.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleUsersRepository = void 0;
+const roles_user_entity_1 = require("../relations/roles/roles_user.entity");
+const roles_user_schema_1 = require("../relations/roles/roles_user.schema");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const mongoDatasource_1 = require("./mongoDatasource");
+class RoleUsersRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: roles_user_entity_1.RolesUser,
+            dataSource: mongoDatasource_1.MongoDataSource,
+            inputSchema: roles_user_schema_1.RolesUserSchema
+        });
+    }
+}
+exports.RoleUsersRepository = RoleUsersRepository;

package/dist/TypeOrmConnector/test/mongo/user.mongo.repository.d.ts

@@ -0,0 +1,10 @@
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+import { UsersEntity } from '../relations/user/user.entity';
+import { UsersEntityInputSchema } from '../relations/user/user.schema';
+import { CarsRepository } from './car.mongo.repository';
+import { RoleRepository } from './roles.mongo.repository';
+export declare class UserRepository extends TypeOrmConnector<UsersEntity, UsersEntityInputSchema> {
+    constructor();
+    cars: () => CarsRepository;
+    roles: () => RoleRepository;
+}

package/dist/TypeOrmConnector/test/mongo/user.mongo.repository.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRepository = void 0;
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const car_entity_1 = require("../relations/car/car.entity");
+const user_entity_1 = require("../relations/user/user.entity");
+const user_schema_1 = require("../relations/user/user.schema");
+const car_mongo_repository_1 = require("./car.mongo.repository");
+const mongoDatasource_1 = require("./mongoDatasource");
+const roles_mongo_repository_1 = require("./roles.mongo.repository");
+const roles_user_mongo_repository_1 = require("./roles_user.mongo.repository");
+class UserRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: user_entity_1.UsersEntity,
+            dataSource: mongoDatasource_1.MongoDataSource,
+            inputSchema: user_schema_1.UsersEntitySchema
+        });
+        this.cars = () => {
+            return this.hasMany({
+                repository: car_mongo_repository_1.CarsRepository,
+                model: car_entity_1.CarsEntity
+            });
+        };
+        this.roles = () => this.belongsToMany({
+            repository: roles_mongo_repository_1.RoleRepository,
+            pivot: roles_user_mongo_repository_1.RoleUsersRepository
+        });
+    }
+}
+exports.UserRepository = UserRepository;

package/dist/TypeOrmConnector/test/mysql/car.mysql.repository.d.ts

@@ -0,0 +1,6 @@
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+import { CarsEntity } from '../relations/car/car.entity';
+import { CarsEntityInputSchema } from '../relations/car/car.schema';
+export declare class CarsRepository extends TypeOrmConnector<CarsEntity, CarsEntityInputSchema> {
+    constructor();
+}

package/dist/TypeOrmConnector/test/mysql/car.mysql.repository.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarsRepository = void 0;
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const car_entity_1 = require("../relations/car/car.entity");
+const car_schema_1 = require("../relations/car/car.schema");
+const mysqlDataSource_1 = require("./mysqlDataSource");
+class CarsRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: car_entity_1.CarsEntity,
+            dataSource: mysqlDataSource_1.MYSQLDataSource,
+            inputSchema: car_schema_1.CarsEntitySchema
+        });
+    }
+}
+exports.CarsRepository = CarsRepository;

package/dist/TypeOrmConnector/test/mysql/mysqlDataSource.d.ts

@@ -0,0 +1,2 @@
+import { DataSource } from 'typeorm';
+export declare const MYSQLDataSource: DataSource;

package/dist/TypeOrmConnector/test/mysql/mysqlDataSource.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MYSQLDataSource = void 0;
+const typeorm_1 = require("typeorm");
+const dbEntities_1 = require("../dbEntities");
+exports.MYSQLDataSource = new typeorm_1.DataSource({
+    type: 'mysql',
+    database: 'test-db',
+    username: 'root',
+    password: 'password',
+    host: '127.0.0.1',
+    port: 3307,
+    entities: dbEntities_1.dbEntities,
+    synchronize: true,
+    logging: false
+});

package/dist/TypeOrmConnector/test/mysql/roles.mysql.repository.d.ts

@@ -0,0 +1,8 @@
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+import { RoleEntityInputSchema } from '../relations/roles/role.schema';
+import { RoleEntity } from '../relations/roles/roles.entity';
+import { UserRepository } from './user.mysql.repository';
+export declare class RoleRepository extends TypeOrmConnector<RoleEntity, RoleEntityInputSchema> {
+    constructor();
+    users: () => UserRepository;
+}

package/dist/TypeOrmConnector/test/mysql/roles.mysql.repository.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleRepository = void 0;
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const role_schema_1 = require("../relations/roles/role.schema");
+const roles_entity_1 = require("../relations/roles/roles.entity");
+const mysqlDataSource_1 = require("./mysqlDataSource");
+const user_mysql_repository_1 = require("./user.mysql.repository");
+const roles_user_mysql_repository_1 = require("./roles_user.mysql.repository");
+class RoleRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: roles_entity_1.RoleEntity,
+            dataSource: mysqlDataSource_1.MYSQLDataSource,
+            inputSchema: role_schema_1.RoleEntitySchema
+        });
+        this.users = () => this.belongsToMany({
+            repository: user_mysql_repository_1.UserRepository,
+            pivot: roles_user_mysql_repository_1.RoleUsersRepository
+        });
+    }
+}
+exports.RoleRepository = RoleRepository;

package/dist/TypeOrmConnector/test/mysql/roles_user.mysql.repository.d.ts

@@ -0,0 +1,6 @@
+import { RolesUser } from '../relations/roles/roles_user.entity';
+import { RolesUserInputSchema } from '../relations/roles/roles_user.schema';
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+export declare class RoleUsersRepository extends TypeOrmConnector<RolesUser, RolesUserInputSchema> {
+    constructor();
+}

package/dist/TypeOrmConnector/test/mysql/roles_user.mysql.repository.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleUsersRepository = void 0;
+const roles_user_entity_1 = require("../relations/roles/roles_user.entity");
+const roles_user_schema_1 = require("../relations/roles/roles_user.schema");
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const mysqlDataSource_1 = require("./mysqlDataSource");
+class RoleUsersRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: roles_user_entity_1.RolesUser,
+            dataSource: mysqlDataSource_1.MYSQLDataSource,
+            inputSchema: roles_user_schema_1.RolesUserSchema
+        });
+    }
+}
+exports.RoleUsersRepository = RoleUsersRepository;

package/dist/TypeOrmConnector/test/mysql/user.mysql.repository.d.ts

@@ -0,0 +1,10 @@
+import { TypeOrmConnector } from '../../TypeOrmConnector';
+import { UsersEntity } from '../relations/user/user.entity';
+import { UsersEntityInputSchema } from '../relations/user/user.schema';
+import { CarsRepository } from './car.mysql.repository';
+import { RoleRepository } from './roles.mysql.repository';
+export declare class UserRepository extends TypeOrmConnector<UsersEntity, UsersEntityInputSchema> {
+    constructor();
+    cars: () => CarsRepository;
+    roles: () => RoleRepository;
+}

package/dist/TypeOrmConnector/test/mysql/user.mysql.repository.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRepository = void 0;
+const TypeOrmConnector_1 = require("../../TypeOrmConnector");
+const car_entity_1 = require("../relations/car/car.entity");
+const user_entity_1 = require("../relations/user/user.entity");
+const user_schema_1 = require("../relations/user/user.schema");
+const car_mysql_repository_1 = require("./car.mysql.repository");
+const mysqlDataSource_1 = require("./mysqlDataSource");
+const roles_mysql_repository_1 = require("./roles.mysql.repository");
+const roles_user_mysql_repository_1 = require("./roles_user.mysql.repository");
+class UserRepository extends TypeOrmConnector_1.TypeOrmConnector {
+    constructor() {
+        super({
+            entity: user_entity_1.UsersEntity,
+            dataSource: mysqlDataSource_1.MYSQLDataSource,
+            inputSchema: user_schema_1.UsersEntitySchema
+        });
+        this.cars = () => {
+            return this.hasMany({
+                repository: car_mysql_repository_1.CarsRepository,
+                model: car_entity_1.CarsEntity,
+                relationKey: { user: true }
+            });
+        };
+        this.roles = () => this.belongsToMany({
+            repository: roles_mysql_repository_1.RoleRepository,
+            pivot: roles_user_mysql_repository_1.RoleUsersRepository
+        });
+    }
+}
+exports.UserRepository = UserRepository;

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

@@ -4,4 +4,5 @@ export declare class CarsEntity {
     name: string;
     userId?: string;
     user?: UsersEntity;
+    anotherRelation?: UsersEntity;
 }

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

@@ -7,26 +7,34 @@ const user_entity_1 = require("../user/user.entity");
 let CarsEntity = class CarsEntity {
 };
 tslib_1.__decorate([
-    decorators_1.Decorators.id(),
+    decorators_1.f.id(),
     tslib_1.__metadata("design:type", String)
 ], CarsEntity.prototype, "id", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: true }),
+    decorators_1.f.property({ required: true }),
     tslib_1.__metadata("design:type", String)
 ], CarsEntity.prototype, "name", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: true }),
+    decorators_1.f.property({ required: true }),
     tslib_1.__metadata("design:type", String)
 ], CarsEntity.prototype, "userId", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.belongsTo({
+    decorators_1.f.belongsTo({
         entity: () => user_entity_1.UsersEntity,
         inverse: user => user.cars,
         pivotColumnName: 'userId'
     }),
     tslib_1.__metadata("design:type", user_entity_1.UsersEntity)
 ], CarsEntity.prototype, "user", void 0);
+tslib_1.__decorate([
+    decorators_1.f.belongsTo({
+        entity: () => user_entity_1.UsersEntity,
+        inverse: user => user.cars,
+        pivotColumnName: 'userId'
+    }),
+    tslib_1.__metadata("design:type", user_entity_1.UsersEntity)
+], CarsEntity.prototype, "anotherRelation", void 0);
 CarsEntity = tslib_1.__decorate([
-    decorators_1.Decorators.entity('cars')
+    decorators_1.f.entity('cars')
 ], CarsEntity);
 exports.CarsEntity = CarsEntity;

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

@@ -1,8 +1,8 @@
 import { CarsEntity } from './car.entity';
-import { CarsEntityIn } from './car.dto';
+import { CarsEntityInputSchema } from './car.schema';
 import { TypeOrmConnector } from '../../../TypeOrmConnector';
 import { UserRepository } from '../user/user.repositoryTypeOrm';
-export declare class CarsRepository extends TypeOrmConnector<CarsEntity, CarsEntityIn> {
-    constructor(relationQuery?: any);
+export declare class CarsRepository extends TypeOrmConnector<CarsEntity, CarsEntityInputSchema> {
+    constructor();
     user: () => UserRepository;
 }

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

@@ -2,13 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CarsRepository = void 0;
 const car_entity_1 = require("./car.entity");
+const car_schema_1 = require("./car.schema");
 const TypeOrmConnector_1 = require("../../../TypeOrmConnector");
 const user_repositoryTypeOrm_1 = require("../user/user.repositoryTypeOrm");
-const memoryDataSource_1 = require("../../memoryDataSource");
+const memoryDataSource_1 = require("../../sqlite/memoryDataSource");
 class CarsRepository extends TypeOrmConnector_1.TypeOrmConnector {
-    constructor(relationQuery) {
-        super(car_entity_1.CarsEntity, memoryDataSource_1.MemoryDataSource, relationQuery);
-        this.user = () => this.belongsTo(user_repositoryTypeOrm_1.UserRepository, 'user');
+    constructor() {
+        super({
+            entity: car_entity_1.CarsEntity,
+            dataSource: memoryDataSource_1.MemoryDataSource,
+            inputSchema: car_schema_1.CarsEntitySchema
+        });
+        this.user = () => this.belongsTo({
+            repository: user_repositoryTypeOrm_1.UserRepository
+        });
     }
 }
 exports.CarsRepository = CarsRepository;

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const CarsEntitySchema: 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>;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarsEntitySchema = void 0;
+const zod_1 = require("zod");
+exports.CarsEntitySchema = 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()
+});

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.relationsTestSuite = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
 let Model;
 let BelongsToModel;
 let ManyToManyModel;
@@ -10,56 +11,101 @@ const relationsTestSuite = (ModelF, BelongsToModelF, ManyToManyModelF) => {
         BelongsToModel = new BelongsToModelF();
         ManyToManyModel = new ManyToManyModelF();
     });
-    test('Attach - OneToMany - Should  insert data', async () => {
+    test('requireById - Should return valid Object', async () => {
         const insertedUser = await Model.insert({
             name: 'testUser',
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user = await Model.where(keys => keys.id, '=', insertedUser.id).load();
-        const cars = await user.cars().attach({ name: 'Another new car' });
+        const findById = await Model.requireById(insertedUser.id);
+        expect(findById.id).toBe(insertedUser.id);
+    });
+    test('requireById - Should fail if not found', async () => {
+        const insertedUser = await Model.insert({
+            name: 'testUser',
+            age: 20
+        });
+        const [error, found] = await js_utils_1.Promises.try(Model.requireById('62ed01e4219a6ab760ae5c50'));
+        expect(error?.message).toBe('Object 62ed01e4219a6ab760ae5c50 not found');
+    });
+    test('loadFirst - Should return a cloned class', async () => {
+        const insertedUser = await Model.insert({
+            name: 'testUser',
+            age: 20
+        });
+        expect(typeof insertedUser.id).toBe('string');
+        const user = Model.loadFirst({
+            where: {
+                id: insertedUser.id
+            }
+        });
+        expect(Array.isArray(user)).toBe(false);
+        expect(typeof user).toBe('object');
+        expect(typeof user.associate).toBe('function');
+    });
+    test('Associate - OneToMany - Should  insert data', async () => {
+        const insertedUser = await Model.insert({
+            name: 'testUser',
+            age: 20
+        });
+        expect(typeof insertedUser.id).toBe('string');
+        const user = await Model.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', async () => {
+    test('Query related model - OneToMany (belongsToMany)', async () => {
         const insertedUser = await Model.insert({
             name: 'testUser',
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user1 = await Model.where(keys => keys.id, '=', insertedUser.id).load();
-        const cars = await user1.cars().attach({ name: 'My new car' });
+        const user1 = await Model.loadById(insertedUser.id);
+        const cars = await user1.cars().associate({ name: 'My new car' });
         expect(Array.isArray(cars)).toBe(true);
-        const searchUserWithRelation = await Model.where(keys => keys.id, '=', insertedUser.id)
-            .with({ cars: BelongsToModelF })
-            .get();
-        expect(Array.isArray(searchUserWithRelation[0].cars)).toBe(true);
-        expect(searchUserWithRelation[0].cars.length > 0).toBe(true);
+        const searchUserWithRelation = await Model.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()
-            .where(keys => keys.name, '=', 'My new car')
-            .get();
+            .findMany({ where: { name: 'My new car' } });
         expect(Array.isArray(searchCar)).toBe(true);
         expect(searchCar.length > 0).toBe(true);
         const searchCar2 = await user1
             .cars()
-            .where(keys => keys.name, '=', 'My.......')
-            .get();
+            .findMany({ where: { name: 'My.......' } });
         expect(Array.isArray(searchCar2)).toBe(true);
         expect(searchCar2.length === 0).toBe(true);
     });
-    test('Query related model - BelongTo', async () => {
+    test('Query related model - ManyToOne (BelongsTo)', async () => {
         const insertedUser = await Model.insert({
             name: 'testUser',
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user1 = await Model.where(keys => keys.id, '=', insertedUser.id).load();
-        await user1.cars().attach({ name: 'My new car' });
-        const results = await BelongsToModel.with({ user: ModelF }).get();
+        const user1 = await Model.loadById(insertedUser.id);
+        await user1.cars().associate({ name: 'My new car' });
+        const results = await BelongsToModel.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(typeof results[0].user?.name).toBe('string');
+        expect(results[0].user['id']).toBe(insertedUser.id);
     });
     test('Query related model - ManyToMany', async () => {
         const insertedUser = await Model.insert({
@@ -70,23 +116,30 @@ const relationsTestSuite = (ModelF, BelongsToModelF, ManyToManyModelF) => {
         const adminRole = await ManyToManyModel.insert({
             name: 'Administrator'
         });
-        const user = await Model.where(keys => keys.id, '=', insertedUser.id).load();
-        const associated = await user.roles().associate(adminRole.id);
+        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.where(keys => keys.id, '=', insertedUser.id)
-            .with({
-            roles: ManyToManyModelF
-        })
-            .get();
+        const searchUserWithRelation = await Model.findMany({
+            where: {
+                id: insertedUser.id
+            },
+            include: {
+                roles: 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');
-        const roles = await ManyToManyModel.where(keys => keys.name, '=', 'Administrator')
-            .with({
-            users: ModelF
-        })
-            .get();
+        expect(searchUserWithRelation[0].roles[0].id).toBe(adminRole.id);
+        const roles = await ManyToManyModel.findMany({
+            where: {
+                name: 'Administrator'
+            },
+            include: {
+                users: true
+            }
+        });
         expect(Array.isArray(roles)).toBe(true);
         expect(roles.length > 0).toBe(true);
         expect(typeof roles[0].users[0].name).toBe('string');

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare const RoleEntitySchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    users: z.ZodOptional<z.ZodArray<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;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id?: string | undefined;
+    users?: {
+        id?: string | undefined;
+        age?: number | undefined;
+        name: string;
+    }[] | undefined;
+    name: string;
+}, {
+    id?: string | undefined;
+    users?: {
+        id?: string | undefined;
+        age?: number | undefined;
+        name: string;
+    }[] | undefined;
+    name: string;
+}>;
+export declare type RoleEntityInputSchema = z.infer<typeof RoleEntitySchema>;

package/dist/TypeOrmConnector/test/relations/roles/role.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleEntitySchema = void 0;
+const zod_1 = require("zod");
+exports.RoleEntitySchema = zod_1.z.object({
+    id: zod_1.z.string().optional(),
+    name: zod_1.z.string(),
+    users: zod_1.z
+        .object({
+        id: zod_1.z.string().optional(),
+        name: zod_1.z.string(),
+        age: zod_1.z.number().optional()
+    })
+        .array()
+        .optional()
+});

package/dist/TypeOrmConnector/test/relations/roles/roles.entity.js

@@ -7,15 +7,15 @@ const user_entity_1 = require("../user/user.entity");
 let RoleEntity = class RoleEntity {
 };
 tslib_1.__decorate([
-    decorators_1.Decorators.id(),
+    decorators_1.f.id(),
     tslib_1.__metadata("design:type", String)
 ], RoleEntity.prototype, "id", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.property({ required: true }),
+    decorators_1.f.property({ required: true }),
     tslib_1.__metadata("design:type", String)
 ], RoleEntity.prototype, "name", void 0);
 tslib_1.__decorate([
-    decorators_1.Decorators.belongsToMany({
+    decorators_1.f.belongsToMany({
         entity: () => user_entity_1.UsersEntity,
         joinTableName: 'roles_users',
         foreignKey: 'roleId',
@@ -24,6 +24,6 @@ tslib_1.__decorate([
     tslib_1.__metadata("design:type", Array)
 ], RoleEntity.prototype, "users", void 0);
 RoleEntity = tslib_1.__decorate([
-    decorators_1.Decorators.entity('roles')
+    decorators_1.f.entity('roles')
 ], RoleEntity);
 exports.RoleEntity = RoleEntity;