@goatlab/fluent 0.6.24 → 0.7.1

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;