@goatlab/fluent 0.6.22 → 0.6.30

package/dist/decorators.d.ts

@@ -1,43 +1,47 @@
+import { ColumnType } from 'typeorm';
 import { Primitives } from './types';
 interface PropertyInterface {
     required?: boolean;
     unique?: boolean;
     hidden?: boolean;
+    type?: ColumnType;
 }
 interface EnumProperty {
     enum: any[];
     default?: Primitives;
 }
-export declare type ObjectTypeI<T> = new () => T;
+export declare type DbEntity<T> = new () => T;
 interface ManyToManyInterface<T> {
-    entity: (type?: any) => ObjectTypeI<T>;
+    entity: (type?: any) => DbEntity<T>;
     joinTableName: string;
     foreignKey: string;
     inverseForeignKey: string;
 }
 interface BelongsToInterface<T> {
-    entity: (type?: any) => ObjectTypeI<T>;
+    entity: (type?: any) => DbEntity<T>;
     inverse: string | ((object: T) => any);
-    pivotColumnName: string;
+    pivotColumnName?: string;
 }
 interface hasManyInterface<T> {
-    entity: (type?: any) => ObjectTypeI<T>;
+    entity: (type?: any) => DbEntity<T>;
     inverse: string | ((object: T) => any);
 }
-export declare const Decorators: Readonly<{
-    id: (isMongo?: boolean) => PropertyDecorator;
-    entity: (name: string) => ClassDecorator;
-    property: (params?: PropertyInterface) => PropertyDecorator;
-    embed: (e: any) => PropertyDecorator;
-    embedArray: (e: any, params?: PropertyInterface) => PropertyDecorator;
-    array: (e: any, params?: PropertyInterface) => PropertyDecorator;
-    Enum: (e: EnumProperty, params?: PropertyInterface) => PropertyDecorator;
-    created: (e?: any) => PropertyDecorator;
-    updated: (e?: any) => PropertyDecorator;
-    version: (e?: any) => PropertyDecorator;
-    deleted: (e?: any) => PropertyDecorator;
-    belongsToMany: <T>({ entity, joinTableName, foreignKey, inverseForeignKey }: ManyToManyInterface<T>) => PropertyDecorator;
-    hasMany: <T_1>({ entity, inverse }: hasManyInterface<T_1>) => PropertyDecorator;
-    belongsTo: <T_2>({ entity, inverse, pivotColumnName }: BelongsToInterface<T_2>) => PropertyDecorator;
-}>;
+export declare class DecoratorsClass {
+    id(): PropertyDecorator;
+    mongoId(): PropertyDecorator;
+    entity(name: string): ClassDecorator;
+    property(params?: PropertyInterface): PropertyDecorator;
+    embed(e: any): PropertyDecorator;
+    embedArray(e: any, params?: PropertyInterface): PropertyDecorator;
+    stringArray(e: any, params?: PropertyInterface): PropertyDecorator;
+    Enum(e: EnumProperty, params?: PropertyInterface): PropertyDecorator;
+    created(e?: any): PropertyDecorator;
+    updated(e?: any): PropertyDecorator;
+    deleted(e?: any): PropertyDecorator;
+    version(e?: any): PropertyDecorator;
+    belongsToMany<T>({ entity, joinTableName, foreignKey, inverseForeignKey }: ManyToManyInterface<T>): PropertyDecorator;
+    belongsTo<T>({ entity, inverse, pivotColumnName }: BelongsToInterface<T>): PropertyDecorator;
+    hasMany<T>({ entity, inverse }: hasManyInterface<T>): PropertyDecorator;
+}
+export declare const f: DecoratorsClass;
 export {};

package/dist/decorators.js

@@ -1,98 +1,104 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decorators = void 0;
+exports.f = exports.DecoratorsClass = void 0;
 const typeorm_1 = require("typeorm");
-const fireorm_1 = require("fireorm");
 const graphql_1 = require("graphql");
 const types_1 = require("./core/types");
 const applyDecorators_1 = require("./core/Nestjs/applyDecorators");
 const field_decorator_1 = require("./core/Nestjs/types/decorators/field.decorator");
-exports.Decorators = (() => {
-    const id = (isMongo) => {
-        isMongo = false;
-        if (process.env.MAIN_DATABASE_TYPE === 'mongodb' || isMongo) {
-            return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ObjectIdColumn)(), (0, typeorm_1.PrimaryGeneratedColumn)('uuid'), (0, types_1.ApiProperty)(), (0, field_decorator_1.Field)(() => graphql_1.GraphQLID), (0, typeorm_1.Column)());
-        }
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.PrimaryGeneratedColumn)('uuid'), (0, types_1.ApiProperty)(), (0, field_decorator_1.Field)(() => graphql_1.GraphQLID), (0, typeorm_1.Column)());
-    };
-    const entity = (name) => {
+const js_utils_1 = require("@goatlab/js-utils");
+class DecoratorsClass {
+    id() {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ObjectIdColumn)({ type: 'uuid' }), (0, typeorm_1.PrimaryGeneratedColumn)('uuid'), (0, types_1.ApiProperty)(), (0, field_decorator_1.Field)(() => graphql_1.GraphQLID));
+    }
+    mongoId() {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ObjectIdColumn)(), (0, types_1.ApiProperty)(), (0, field_decorator_1.Field)(() => graphql_1.GraphQLID));
+    }
+    entity(name) {
         const PascalCase = name;
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Entity)({ name: PascalCase }), (0, types_1.ObjectType)(), (0, fireorm_1.Collection)(PascalCase));
-    };
-    const property = (params) => {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Entity)({ name: PascalCase }), (0, types_1.ObjectType)());
+    }
+    property(params) {
         if (params && params.hidden) {
             return (0, applyDecorators_1.applyDecorators)((0, types_1.HideField)(), (0, typeorm_1.Column)({
                 select: false,
-                nullable: !params.required
+                nullable: !params.required,
+                type: params.type
             }), (0, types_1.ApiProperty)({
                 nullable: !params.required,
                 required: !!params.required
             }), (0, types_1.ApiHideProperty)());
         }
         return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
-            nullable: !params.required
+            nullable: !params?.required
         }), (0, types_1.ApiProperty)({
-            nullable: !params.required,
-            required: !!params.required
+            nullable: !params?.required,
+            required: !!params?.required
         }), (0, field_decorator_1.Field)());
-    };
-    const embed = (e) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)(type => e), (0, types_1.ApiProperty)({ type: e }));
-    const embedArray = (e, params) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)(type => e), (0, types_1.ApiProperty)({
-        isArray: true,
-        type: e,
-        nullable: !params.required,
-        required: !!params.required
-    }));
-    const array = (e, params) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
-        type: 'simple-array',
-        nullable: !params?.required
-    }), (0, types_1.ApiProperty)({
-        type: [e],
-        nullable: !params?.required,
-        required: !!params?.required
-    }));
-    const Enum = (e, params) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
-        type: 'enum',
-        enum: e.enum,
-        default: e.default,
-        nullable: !params.required
-    }), (0, types_1.ApiProperty)({
-        enum: e.enum,
-        default: e.default,
-        nullable: !params.required,
-        required: !!params.required
-    }));
-    const created = (e) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.CreateDateColumn)(), (0, types_1.ApiProperty)());
-    const updated = (e) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.UpdateDateColumn)(), (0, types_1.ApiProperty)());
-    const deleted = (e) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.DeleteDateColumn)(), (0, types_1.ApiProperty)());
-    const version = (e) => (0, applyDecorators_1.applyDecorators)((0, typeorm_1.VersionColumn)(), (0, types_1.ApiProperty)());
-    function belongsToMany({ entity, joinTableName, foreignKey, inverseForeignKey }) {
+    }
+    embed(e) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)(type => e), (0, types_1.ApiProperty)({ type: e }));
+    }
+    embedArray(e, params) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)(type => e), (0, types_1.ApiProperty)({
+            isArray: true,
+            type: e,
+            nullable: !params?.required,
+            required: !!params?.required
+        }));
+    }
+    stringArray(e, params) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
+            type: 'simple-array',
+            nullable: !params?.required
+        }), (0, types_1.ApiProperty)({
+            type: [e],
+            nullable: !params?.required,
+            required: !!params?.required
+        }));
+    }
+    Enum(e, params) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.Column)({
+            type: 'enum',
+            enum: e.enum,
+            default: e.default,
+            nullable: !params?.required
+        }), (0, types_1.ApiProperty)({
+            enum: e.enum,
+            default: e.default,
+            nullable: !params?.required,
+            required: !!params?.required
+        }));
+    }
+    created(e) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.CreateDateColumn)(), (0, types_1.ApiProperty)());
+    }
+    updated(e) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.UpdateDateColumn)(), (0, types_1.ApiProperty)());
+    }
+    deleted(e) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.DeleteDateColumn)(), (0, types_1.ApiProperty)());
+    }
+    version(e) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.VersionColumn)(), (0, types_1.ApiProperty)());
+    }
+    belongsToMany({ entity, joinTableName, foreignKey, inverseForeignKey }) {
         return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ManyToMany)(entity), (0, typeorm_1.JoinTable)({
             name: joinTableName,
             joinColumns: [{ name: foreignKey }],
             inverseJoinColumns: [{ name: inverseForeignKey }]
         }));
     }
-    function belongsTo({ entity, inverse, pivotColumnName }) {
-        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ManyToOne)(entity, inverse), (0, typeorm_1.JoinColumn)({ name: pivotColumnName }));
+    belongsTo({ entity, inverse, pivotColumnName }) {
+        return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.ManyToOne)(entity, inverse), (0, typeorm_1.JoinColumn)({
+            name: pivotColumnName,
+            referencedColumnName: 'id',
+            foreignKeyConstraintName: `${pivotColumnName}_id_${js_utils_1.Ids.nanoId()}`
+        }));
     }
-    function hasMany({ entity, inverse }) {
+    hasMany({ entity, inverse }) {
         return (0, applyDecorators_1.applyDecorators)((0, typeorm_1.OneToMany)(entity, inverse));
     }
-    return Object.freeze({
-        id,
-        entity,
-        property,
-        embed,
-        embedArray,
-        array,
-        Enum,
-        created,
-        updated,
-        version,
-        deleted,
-        belongsToMany,
-        hasMany,
-        belongsTo
-    });
-})();
+}
+exports.DecoratorsClass = DecoratorsClass;
+exports.f = new DecoratorsClass();

package/dist/index.d.ts

@@ -1,23 +1,22 @@
 import { ApiHideProperty, ApiProperty, Column, HideField, InputType, ObjectType, OmitType, PartialType, getModelSchemaRef } from './core/types';
-import type { BaseDataElement, DaoOutput, Deleted, Filter, LogicOperator, PaginatedData, Paginator, Paths, Primitives, PrimitivesArray, Sure, WhereClause } from './types';
-import { PaginationLinks, PaginationMeta } from './core/dtos/pagination.dto';
-import { Access } from './core/dtos/access.dto';
+import type { AnyObject, Deleted, PaginatedData, Paginator, Primitives, PrimitivesArray, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter, SingleQueryOutput } from './types';
+import { LogicOperator } from './types';
 import { BaseConnector } from './BaseConnector';
 import { Collection } from '@goatlab/js-utils';
-import { Decorators } from './decorators';
+import { f } from './decorators';
 import { Fluent } from './Fluent';
 import type { FluentConnectorInterface } from './BaseConnector';
 import type { SchemaObject } from './core/types';
-import { TypeOrmConnector } from './TypeOrmConnector/TypeOrmConnector';
+import { getRelationsFromModelGenerator, TypeOrmConnector } from './TypeOrmConnector/TypeOrmConnector';
 import { getOutputKeys } from './outputKeys';
 import { loadRelations } from './loadRelations';
 import { modelGeneratorDataSource } from './generatorDatasource';
 import { Cache } from './cache';
 import { ValidationError } from 'class-validator';
 export { DataSource } from 'typeorm';
-export { Access, ApiHideProperty, ApiProperty, BaseConnector, Collection, Column, Decorators, Fluent, getModelSchemaRef, getOutputKeys, HideField, InputType, loadRelations, modelGeneratorDataSource, ObjectType, OmitType, PaginationLinks, PaginationMeta, PartialType, TypeOrmConnector, Cache };
+export { ApiHideProperty, ApiProperty, BaseConnector, Collection, Column, f, Fluent, getModelSchemaRef, getOutputKeys, HideField, InputType, loadRelations, modelGeneratorDataSource, ObjectType, OmitType, PartialType, TypeOrmConnector, Cache, getRelationsFromModelGenerator, LogicOperator };
 interface ValidatedInput<T> {
     errors: ValidationError[] | null;
     result: Awaited<T>;
 }
-export type { BaseDataElement, DaoOutput, Deleted, Filter, FluentConnectorInterface, LogicOperator, PaginatedData, Paginator, Paths, Primitives, PrimitivesArray, Sure, WhereClause, SchemaObject, ValidatedInput };
+export type { AnyObject, Deleted, FluentConnectorInterface, PaginatedData, Paginator, Primitives, PrimitivesArray, SchemaObject, ValidatedInput, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter, SingleQueryOutput };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cache = exports.TypeOrmConnector = exports.PartialType = exports.PaginationMeta = exports.PaginationLinks = exports.OmitType = exports.ObjectType = exports.modelGeneratorDataSource = exports.loadRelations = exports.InputType = exports.HideField = exports.getOutputKeys = exports.getModelSchemaRef = exports.Fluent = exports.Decorators = exports.Column = exports.Collection = exports.BaseConnector = exports.ApiProperty = exports.ApiHideProperty = exports.Access = exports.DataSource = void 0;
+exports.LogicOperator = exports.getRelationsFromModelGenerator = exports.Cache = exports.TypeOrmConnector = exports.PartialType = exports.OmitType = exports.ObjectType = exports.modelGeneratorDataSource = exports.loadRelations = exports.InputType = exports.HideField = exports.getOutputKeys = exports.getModelSchemaRef = exports.Fluent = exports.f = exports.Column = exports.Collection = exports.BaseConnector = exports.ApiProperty = exports.ApiHideProperty = exports.DataSource = void 0;
 const types_1 = require("./core/types");
 Object.defineProperty(exports, "ApiHideProperty", { enumerable: true, get: function () { return types_1.ApiHideProperty; } });
 Object.defineProperty(exports, "ApiProperty", { enumerable: true, get: function () { return types_1.ApiProperty; } });
@@ -11,20 +11,18 @@ Object.defineProperty(exports, "ObjectType", { enumerable: true, get: function (
 Object.defineProperty(exports, "OmitType", { enumerable: true, get: function () { return types_1.OmitType; } });
 Object.defineProperty(exports, "PartialType", { enumerable: true, get: function () { return types_1.PartialType; } });
 Object.defineProperty(exports, "getModelSchemaRef", { enumerable: true, get: function () { return types_1.getModelSchemaRef; } });
-const pagination_dto_1 = require("./core/dtos/pagination.dto");
-Object.defineProperty(exports, "PaginationLinks", { enumerable: true, get: function () { return pagination_dto_1.PaginationLinks; } });
-Object.defineProperty(exports, "PaginationMeta", { enumerable: true, get: function () { return pagination_dto_1.PaginationMeta; } });
-const access_dto_1 = require("./core/dtos/access.dto");
-Object.defineProperty(exports, "Access", { enumerable: true, get: function () { return access_dto_1.Access; } });
+const types_2 = require("./types");
+Object.defineProperty(exports, "LogicOperator", { enumerable: true, get: function () { return types_2.LogicOperator; } });
 const BaseConnector_1 = require("./BaseConnector");
 Object.defineProperty(exports, "BaseConnector", { enumerable: true, get: function () { return BaseConnector_1.BaseConnector; } });
 const js_utils_1 = require("@goatlab/js-utils");
 Object.defineProperty(exports, "Collection", { enumerable: true, get: function () { return js_utils_1.Collection; } });
 const decorators_1 = require("./decorators");
-Object.defineProperty(exports, "Decorators", { enumerable: true, get: function () { return decorators_1.Decorators; } });
+Object.defineProperty(exports, "f", { enumerable: true, get: function () { return decorators_1.f; } });
 const Fluent_1 = require("./Fluent");
 Object.defineProperty(exports, "Fluent", { enumerable: true, get: function () { return Fluent_1.Fluent; } });
 const TypeOrmConnector_1 = require("./TypeOrmConnector/TypeOrmConnector");
+Object.defineProperty(exports, "getRelationsFromModelGenerator", { enumerable: true, get: function () { return TypeOrmConnector_1.getRelationsFromModelGenerator; } });
 Object.defineProperty(exports, "TypeOrmConnector", { enumerable: true, get: function () { return TypeOrmConnector_1.TypeOrmConnector; } });
 const outputKeys_1 = require("./outputKeys");
 Object.defineProperty(exports, "getOutputKeys", { enumerable: true, get: function () { return outputKeys_1.getOutputKeys; } });

package/dist/loadRelations.js

@@ -8,86 +8,126 @@ const loadRelations = async ({ data, relations, modelRelations, provider, self,
     }
     const chunkSize = provider === 'typeorm' ? 100 : 10;
     for (const relation of Object.keys(relations)) {
-        if (modelRelations[relation]) {
-            const relationModel = modelRelations[relation];
-            const Model = new relations[relation]();
-            if (relationModel.isOneToMany) {
-                const ids = new Set(data.map(d => Model.isMongoDB ? js_utils_1.Ids.objectID(d.id) : d.id));
-                const chunks = js_utils_1.Arrays.chunk(Array.from(ids), chunkSize);
-                const promises = [];
-                for (const relatedIds of chunks) {
-                    const results = await Model.andWhere(keys => keys[relationModel.inverseSidePropertyPath], 'in', relatedIds).get();
-                    promises.push(results);
-                }
-                const relatedResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
-                const grouped = js_utils_1.Arrays.groupBy(relatedResults, r => r[relationModel.inverseSidePropertyPath]);
-                data.forEach(d => {
-                    if (grouped[d.id]) {
-                        d[relationModel.propertyPath] = grouped[d.id];
+        if (!modelRelations[relation]) {
+            throw new Error(`Relationship does not exist: ${relation}. Did you create it in your DB entity?`);
+        }
+        if (!self[relation]) {
+            throw new Error(`Relationship does not exist: ${relation}. Did you create it in your Repository?`);
+        }
+        const relationModel = modelRelations[relation];
+        const Repository = self[relation]();
+        if (relationModel.isOneToMany) {
+            const ids = new Set(data.map(d => d.id));
+            const chunks = js_utils_1.Arrays.chunk(Array.from(ids), chunkSize);
+            const promises = [];
+            for (const relatedIds of chunks) {
+                const results = await Repository.findMany({
+                    where: {
+                        [relationModel.inverseSidePropertyPath]: {
+                            in: relatedIds
+                        }
                     }
                 });
+                promises.push(results);
             }
-            else if (relationModel.isManyToOne) {
-                const ids = js_utils_1.Arrays.deDuplicate(data.map(d => d[relationModel.joinColumns[0].propertyPath]));
-                const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
-                const promises = [];
-                for (const relatedIds of chunks) {
-                    const results = await Model.andWhere(keys => keys.id, 'in', relatedIds).get();
-                    promises.push(results);
+            const relatedResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
+            const grouped = js_utils_1.Arrays.groupBy(relatedResults, r => r[relationModel.inverseSidePropertyPath]);
+            data.map(d => {
+                if (grouped[d.id]) {
+                    d[relationModel.propertyName] = grouped[d.id];
                 }
-                const relatedResults = js_utils_1.Arrays.collapse(promises);
-                const grouped = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
-                data.forEach(d => {
-                    if (grouped[d[relationModel.joinColumns[0].propertyPath]]) {
-                        d[relationModel.propertyPath] =
-                            grouped[d[relationModel.joinColumns[0].propertyPath]][0];
+                return d;
+            });
+            return data;
+        }
+        if (relationModel.isManyToOne) {
+            const ids = js_utils_1.Arrays.deDuplicate(data.map(d => d[relationModel.joinColumns[0].propertyPath]));
+            const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
+            const promises = [];
+            for (const relatedIds of chunks) {
+                const results = await Repository.findMany({
+                    where: {
+                        id: {
+                            in: relatedIds
+                        }
                     }
                 });
+                promises.push(results);
             }
-            else if (relationModel.isManyToMany) {
-                const ids = js_utils_1.Arrays.deDuplicate(data.map(d => Model.isMongoDB ? js_utils_1.Ids.objectID(d.id) : d.id));
-                const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
-                if (relationModel.joinColumns.length === 0) {
-                    return data;
-                }
-                const pivotRepository = self[relationModel.propertyPath]().relationQuery.pivot;
-                const promises = [];
-                for (const pivotIds of chunks) {
-                    const results = await pivotRepository
-                        .where(k => k[relationModel.joinColumns[0].propertyName], 'in', pivotIds)
-                        .get();
-                    promises.push(results);
+            const relatedResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
+            const grouped = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
+            data.map(d => {
+                if (grouped[d[relationModel.joinColumns[0].propertyPath]]) {
+                    d[relationModel.propertyName] =
+                        grouped[d[relationModel.joinColumns[0].propertyPath]][0];
                 }
-                const pivotResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
-                const uniquePivotIds = pivotResults.map(p => p[relationModel.inverseJoinColumns[0].propertyName]);
-                const relationChunks = js_utils_1.Arrays.chunk(uniquePivotIds, chunkSize);
-                const relationPromises = [];
-                for (const relatedIds of relationChunks) {
-                    const results = await Model.andWhere(keys => keys.id, 'in', relatedIds).get();
-                    relationPromises.push(results);
-                }
-                let relatedResults = js_utils_1.Arrays.collapse(await Promise.all(relationPromises));
-                const pivotInverseKey = relationModel.inverseJoinColumns[0].propertyName;
-                relatedResults = relatedResults.map(r => {
-                    return {
-                        ...r,
-                        pivot: pivotResults.find(p => p[pivotInverseKey] === r.id)
-                    };
+            });
+            return data;
+        }
+        if (relationModel.isManyToMany) {
+            const ids = js_utils_1.Arrays.deDuplicate(data.map(d => d.id));
+            const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
+            if (relationModel.joinColumns.length === 0) {
+                return data;
+            }
+            const pivotForeignField = self.modelRelations[relationModel.propertyName].joinColumns[0]
+                .propertyPath;
+            const inverseForeignField = self.modelRelations[relationModel.propertyName].inverseJoinColumns[0]
+                .propertyPath;
+            const pivotRepository = Repository?.relatedQuery.pivot;
+            const calleeKey = Repository?.relatedQuery.key;
+            if (!pivotForeignField ||
+                !inverseForeignField ||
+                !pivotRepository ||
+                !calleeKey) {
+                throw new Error('The Many-to-Many relationship is not properly defined.Please check both your Model and Repository');
+            }
+            const promises = [];
+            for (const pivotIds of chunks) {
+                const results = await pivotRepository.findMany({
+                    where: {
+                        [pivotForeignField]: {
+                            in: pivotIds
+                        }
+                    }
                 });
-                const groupedPivot = js_utils_1.Arrays.groupBy(pivotResults, r => r[relationModel.joinColumns[0].propertyName]);
-                const groupedRelated = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
-                data.forEach(d => {
-                    groupedPivot[d.id]?.forEach(gp => {
-                        if (!d[relationModel.propertyPath]) {
-                            d[relationModel.propertyPath] = [];
+                promises.push(results);
+            }
+            const pivotResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
+            const uniquePivotIds = pivotResults.map(p => p[inverseForeignField]);
+            const relationChunks = js_utils_1.Arrays.chunk(uniquePivotIds, chunkSize);
+            const relationPromises = [];
+            for (const relatedIds of relationChunks) {
+                const results = await Repository.findMany({
+                    where: {
+                        id: {
+                            in: relatedIds
                         }
-                        d[relationModel.propertyPath] = [
-                            ...d[relationModel.propertyPath],
-                            ...groupedRelated[gp[relationModel.inverseJoinColumns[0].propertyName]]
-                        ];
-                    });
+                    }
                 });
+                relationPromises.push(results);
             }
+            let relatedResults = js_utils_1.Arrays.collapse(await Promise.all(relationPromises));
+            relatedResults = relatedResults.map(r => {
+                return {
+                    ...r,
+                    pivot: pivotResults.find(p => p[inverseForeignField] === r.id)
+                };
+            });
+            const groupedPivot = js_utils_1.Arrays.groupBy(pivotResults, r => r[relationModel.joinColumns[0].propertyName]);
+            const groupedRelated = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
+            data.map(d => {
+                groupedPivot[d.id]?.forEach(gp => {
+                    if (!d[calleeKey]) {
+                        d[calleeKey] = [];
+                    }
+                    d[calleeKey] = [
+                        ...d[calleeKey],
+                        ...groupedRelated[gp[relationModel.inverseJoinColumns[0].propertyName]]
+                    ];
+                });
+            });
+            return data;
         }
     }
     return data;