@goatlab/fluent 0.7.6 → 0.7.11

package/dist/TypeOrmConnector/util/clearEmpties.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearEmpties = void 0;
+const bson_1 = require("bson");
+const clearEmpties = object => {
+    Object.entries(object).forEach(([k, v]) => {
+        if (v && typeof v === 'object')
+            (0, exports.clearEmpties)(v);
+        if ((v && typeof v === 'object' && !Object.keys(v).length) ||
+            v === null ||
+            v === undefined ||
+            v.length === 0) {
+            if (Array.isArray(object)) {
+                if (!(object[k] instanceof bson_1.ObjectId)) {
+                    object.splice(k, 1);
+                }
+            }
+            else if (!(v instanceof Date) && !(v instanceof bson_1.ObjectId)) {
+                delete object[k];
+            }
+        }
+    });
+    return object;
+};
+exports.clearEmpties = clearEmpties;

package/dist/TypeOrmConnector/util/extractConditions.d.ts

@@ -0,0 +1,6 @@
+import { FluentQuery, LogicOperator, Primitives, PrimitivesArray } from '../../types';
+export declare const extractConditions: (conditions: FluentQuery<any>['where'][]) => {
+    operator: LogicOperator;
+    element: string;
+    value: Primitives | PrimitivesArray;
+}[];

package/dist/TypeOrmConnector/util/extractConditions.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractConditions = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const types_1 = require("../../types");
+const isAnyObject_1 = require("./isAnyObject");
+const extractConditions = (conditions) => {
+    const accumulatedClauses = [];
+    if (!conditions) {
+        return accumulatedClauses;
+    }
+    for (const clause of conditions) {
+        if (!clause) {
+            continue;
+        }
+        for (const el of Object.keys(clause)) {
+            const value = clause[el];
+            if ((0, isAnyObject_1.isAnyObject)(value)) {
+                const initialKey = el;
+                const flatten = js_utils_1.Objects.flatten(value);
+                for (const key of Object.keys(flatten)) {
+                    const transformedKey = key.replace(new RegExp('.[0-9]', 'g'), '');
+                    if (types_1.LogicOperator[transformedKey]) {
+                        if (types_1.LogicOperator[transformedKey] === types_1.LogicOperator.in ||
+                            types_1.LogicOperator[transformedKey] === types_1.LogicOperator.notIn) {
+                            accumulatedClauses.push({
+                                operator: types_1.LogicOperator[transformedKey],
+                                element: `${initialKey}`,
+                                value: value[transformedKey]
+                            });
+                        }
+                        else {
+                            accumulatedClauses.push({
+                                operator: types_1.LogicOperator[transformedKey],
+                                element: `${initialKey}`,
+                                value: flatten[key]
+                            });
+                        }
+                    }
+                    else if (transformedKey.includes('.')) {
+                        const op = key.split('.').slice(-1).pop();
+                        if (!op) {
+                            continue;
+                        }
+                        if (types_1.LogicOperator[op]) {
+                            accumulatedClauses.push({
+                                operator: types_1.LogicOperator[op],
+                                element: `${initialKey}.${key.replace(`.${op}`, '')}`,
+                                value: flatten[key]
+                            });
+                        }
+                        else {
+                            accumulatedClauses.push({
+                                operator: types_1.LogicOperator.equals,
+                                element: `${initialKey}.${key}`,
+                                value: flatten[key]
+                            });
+                        }
+                    }
+                    else {
+                        accumulatedClauses.push({
+                            operator: types_1.LogicOperator.equals,
+                            element: `${initialKey}.${transformedKey}`,
+                            value: flatten[key]
+                        });
+                    }
+                }
+            }
+            else {
+                accumulatedClauses.push({
+                    operator: types_1.LogicOperator.equals,
+                    element: el,
+                    value
+                });
+            }
+        }
+    }
+    return accumulatedClauses.filter((v, i, a) => a.findIndex(v2 => JSON.stringify(v2) === JSON.stringify(v)) === i);
+};
+exports.extractConditions = extractConditions;

package/dist/TypeOrmConnector/util/extractInclude.d.ts

@@ -0,0 +1,2 @@
+import { AnyObject, FluentQuery } from '../../types';
+export declare const extractInclude: <T>(include?: import("../../types").QueryIncludeRelation<T> | undefined) => AnyObject | undefined;

package/dist/TypeOrmConnector/util/extractInclude.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractInclude = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const extractInclude = (include) => {
+    if (!include) {
+        return undefined;
+    }
+    const flatten = js_utils_1.Objects.flatten(include);
+    const extractedInclude = {};
+    for (const key of Object.keys(flatten)) {
+        if (key.includes('include')) {
+            const parsedKey = key.split('.include');
+            let acc = '';
+            for (const entity of parsedKey) {
+                extractedInclude[`${acc}${entity}`] = true;
+                acc = acc + entity;
+            }
+            continue;
+        }
+        extractedInclude[key] = true;
+    }
+    return extractedInclude;
+};
+exports.extractInclude = extractInclude;

package/dist/TypeOrmConnector/util/extractMetadataFromKeys.d.ts

@@ -0,0 +1,12 @@
+export interface KeysMetadata {
+    keyName: string;
+    nestableKey: string;
+    relation?: string;
+    parentRelation?: string;
+    level?: number;
+    cardinality?: string;
+}
+export interface KeysMetadataResponse {
+    [key: string]: KeysMetadata;
+}
+export declare const extractMetadataFromKeys: (keys: string[]) => KeysMetadataResponse;

package/dist/TypeOrmConnector/util/extractMetadataFromKeys.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMetadataFromKeys = void 0;
+const extractMetadataFromKeys = (keys) => {
+    const keyToNestedKeyMap = {};
+    for (const key of keys) {
+        const preAttributeIndex = key.lastIndexOf('_');
+        const fullTableAlias = key.slice(0, preAttributeIndex).replace('_', '');
+        const keyName = key.slice(preAttributeIndex + 1, key.length);
+        const flattened = fullTableAlias
+            .replace(/___XXManyToOneXX/g, '')
+            .replace(/___XXOneToManyXX/g, '')
+            .replace(/___/g, '.')
+            .replace('__', '.')
+            .replace('.XXOneToManyXX', '');
+        const possibleCurrentTableKey = key.lastIndexOf('___');
+        const relation = possibleCurrentTableKey <= 0
+            ? undefined
+            : key.slice(possibleCurrentTableKey + 3, preAttributeIndex);
+        const possibleParentTableKeyInit = key.lastIndexOf('___XX');
+        const possibleParentTableKeyEnd = key.lastIndexOf('XX__');
+        const cardinality = key.slice(possibleParentTableKeyInit, possibleParentTableKeyEnd) ||
+            undefined;
+        const parentRelationKey = key
+            .substring(0, possibleParentTableKeyInit)
+            .lastIndexOf('___');
+        const parentRelation = key
+            .substring(parentRelationKey, possibleParentTableKeyInit)
+            .replace(/___/g, '') || undefined;
+        var level = (key.match(/XX___/g) || []).length;
+        keyToNestedKeyMap[key] = {
+            keyName,
+            nestableKey: `${flattened}.${keyName}`,
+            relation,
+            parentRelation,
+            level,
+            cardinality: cardinality && cardinality.replace(/XX/g, '').replace(/___/g, '')
+        };
+    }
+    return keyToNestedKeyMap;
+};
+exports.extractMetadataFromKeys = extractMetadataFromKeys;

package/dist/TypeOrmConnector/util/extractOrderBy.d.ts

@@ -0,0 +1,4 @@
+import { FluentQuery } from 'types';
+export declare const extractOrderBy: <T>(orderBy?: Partial<{ [K in keyof import("types").Concrete<T>]: import("types").Concrete<T>[K] extends object ? Partial<Partial<{ [K_1 in keyof import("types").Concrete<import("types").Concrete<T>[K]>]: import("types").Concrete<import("types").Concrete<T>[K]>[K_1] extends object ? Partial<Partial<{ [K_2 in keyof import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>]: import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2] extends object ? Partial<Partial<{ [K_3 in keyof import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>]: import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3] extends object ? Partial<Partial<{ [K_4 in keyof import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>]: import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4] extends object ? Partial<Partial<{ [K_5 in keyof import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>]: import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5] extends object ? Partial<Partial<{ [K_6 in keyof import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>]: import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6] extends object ? Partial<Partial<{ [K_7 in keyof import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>]: import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7] extends object ? Partial<Partial<{ [K_8 in keyof import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>]: import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8] extends object ? Partial<Partial<{ [K_9 in keyof import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>]: import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<import("types").Concrete<T>[K]>[K_1]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9] extends object ? any : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>> : "asc" | "desc" | undefined; }>[] | undefined) => {
+    [key: string]: any;
+};

package/dist/TypeOrmConnector/util/extractOrderBy.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractOrderBy = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const extractOrderBy = (orderBy) => {
+    if (!orderBy || !Array.isArray(orderBy) || orderBy.length === 0) {
+        return {};
+    }
+    const order = {};
+    for (const orderElement of orderBy) {
+        const flattenOrder = js_utils_1.Objects.flatten(orderElement);
+        for (const k of Object.keys(flattenOrder)) {
+            order[k] = flattenOrder[k];
+        }
+    }
+    return js_utils_1.Objects.nest(order);
+};
+exports.extractOrderBy = extractOrderBy;

package/dist/TypeOrmConnector/util/getRelationsFromModelGenerator.d.ts

@@ -0,0 +1,19 @@
+import { Repository } from 'typeorm';
+export interface GeneratedModelRelations {
+    relations: {
+        [key: string]: {
+            isOneToMany: boolean;
+            isManyToOne: boolean;
+            isManyToMany: boolean;
+            inverseSidePropertyRelationPath?: string;
+            inverseSidePropertyPath?: string;
+            propertyName: string;
+            entityName: string;
+            tableName: string;
+            targetClass: string;
+            joinColumns: any[];
+            inverseJoinColumns: any[];
+        };
+    };
+}
+export declare const getRelationsFromModelGenerator: (typeOrmRepo: Repository<any>) => GeneratedModelRelations;

package/dist/TypeOrmConnector/util/getRelationsFromModelGenerator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelationsFromModelGenerator = void 0;
+const getRelationsFromModelGenerator = (typeOrmRepo) => {
+    const relations = {};
+    for (const relation of typeOrmRepo.metadata.relations) {
+        const pPath = relation.inverseRelation?.joinColumns[0];
+        relations[relation.propertyName] = {
+            isOneToMany: relation.isOneToMany,
+            isManyToOne: relation.isManyToOne,
+            isManyToMany: relation.isManyToMany,
+            inverseSidePropertyRelationPath: relation.inverseSidePropertyPath,
+            inverseSidePropertyPath: pPath?.propertyPath,
+            propertyName: relation.propertyName,
+            entityName: relation.inverseEntityMetadata.name,
+            tableName: relation.inverseEntityMetadata.tableName,
+            targetClass: relation.inverseEntityMetadata.target,
+            joinColumns: relation.joinColumns,
+            inverseJoinColumns: relation.inverseJoinColumns
+        };
+    }
+    return {
+        relations
+    };
+};
+exports.getRelationsFromModelGenerator = getRelationsFromModelGenerator;

package/dist/TypeOrmConnector/util/getSelectedKeysFromRawSql.d.ts

@@ -0,0 +1 @@
+export declare const getSelectedKeysFromRawSql: (sql: string) => string[];

package/dist/TypeOrmConnector/util/getSelectedKeysFromRawSql.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSelectedKeysFromRawSql = void 0;
+const getSelectedKeysFromRawSql = (sql) => {
+    const possibleKeys = sql.split('AS');
+    const keys = new Set([]);
+    for (const stringKey of possibleKeys) {
+        if (stringKey.includes('SELECT')) {
+            const key = stringKey.split('"')[1];
+            if (key.includes('___') || !key.includes('_')) {
+                continue;
+            }
+            keys.add(key.replace('_id', 'id').replace('_', '.'));
+            continue;
+        }
+        keys.add(stringKey.split('"')[1].replace('_id', 'id').replace('_', '.'));
+    }
+    return Array.from(keys);
+};
+exports.getSelectedKeysFromRawSql = getSelectedKeysFromRawSql;

package/dist/TypeOrmConnector/util/isAnyObject.d.ts

@@ -0,0 +1 @@
+export declare const isAnyObject: (val: any) => boolean;

package/dist/TypeOrmConnector/util/isAnyObject.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnyObject = void 0;
+const isAnyObject = (val) => {
+    return typeof val === 'object' && !Array.isArray(val) && val !== null;
+};
+exports.isAnyObject = isAnyObject;

package/dist/TypeOrmConnector/util/nestQueryResults.d.ts

@@ -0,0 +1,2 @@
+import { AnyObject } from '../../types';
+export declare const nestQueryResults: (results: AnyObject[], keyToNestedKeyMap: AnyObject) => AnyObject[];

package/dist/TypeOrmConnector/util/nestQueryResults.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nestQueryResults = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const nestQueryResults = (results, keyToNestedKeyMap) => {
+    let nestableObject = {};
+    let currentLevel = 0;
+    for (const key of Object.keys(keyToNestedKeyMap)) {
+        if (!key.endsWith('_id')) {
+            continue;
+        }
+        const currentLevelMetadata = keyToNestedKeyMap[key];
+        currentLevel = currentLevelMetadata.level;
+        const grouped = js_utils_1.Arrays.groupBy(results, r => r[key]);
+        const resultCount = Object.keys(grouped)?.length || 0;
+        for (const [index, k] of Object.keys(grouped).entries()) {
+            const prefixindex = currentLevelMetadata.nestableKey.lastIndexOf('.');
+            const prefix = currentLevelMetadata.nestableKey.substring(0, prefixindex);
+            const currentIndex = `${prefix}.${index}.${currentLevelMetadata.keyName}`;
+            const results = grouped[k];
+            console.log(currentLevelMetadata);
+            if (currentLevelMetadata.level === currentLevel) {
+                nestableObject[`${currentIndex}`] = k;
+            }
+            for (const result of results) {
+            }
+        }
+    }
+    return results;
+};
+exports.nestQueryResults = nestQueryResults;

package/dist/index.d.ts

@@ -1,22 +1,29 @@
 import { ApiHideProperty, ApiProperty, Column, HideField, InputType, ObjectType, OmitType, PartialType, getModelSchemaRef } from './core/types';
-import type { AnyObject, Deleted, PaginatedData, Paginator, Primitives, PrimitivesArray, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter, SingleQueryOutput } from './types';
+import type { AnyObject, Deleted, PaginatedData, Paginator, Primitives, PrimitivesArray, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter } from './types';
 import { LogicOperator } from './types';
 import { BaseConnector } from './BaseConnector';
 import { Collection } from '@goatlab/js-utils';
 import { f } from './decorators';
 import { Fluent } from './Fluent';
-import type { FluentConnectorInterface } from './BaseConnector';
+import type { FluentConnectorInterface } from './FluentConnectorInterface';
 import type { SchemaObject } from './core/types';
-import { getRelationsFromModelGenerator, TypeOrmConnector } from './TypeOrmConnector/TypeOrmConnector';
+import { 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';
+import { extractConditions } from './TypeOrmConnector/util/extractConditions';
+import { extractInclude } from './TypeOrmConnector/util/extractInclude';
+import { extractMetadataFromKeys } from './TypeOrmConnector/util/extractMetadataFromKeys';
+import { extractOrderBy } from './TypeOrmConnector/util/extractOrderBy';
+import { getRelationsFromModelGenerator } from './TypeOrmConnector/util/getRelationsFromModelGenerator';
+import { getSelectedKeysFromRawSql } from './TypeOrmConnector/util/getSelectedKeysFromRawSql';
+import { nestQueryResults } from './TypeOrmConnector/util/nestQueryResults';
 export { DataSource } from 'typeorm';
-export { ApiHideProperty, ApiProperty, BaseConnector, Collection, Column, f, Fluent, getModelSchemaRef, getOutputKeys, HideField, InputType, loadRelations, modelGeneratorDataSource, ObjectType, OmitType, PartialType, TypeOrmConnector, Cache, getRelationsFromModelGenerator, LogicOperator };
+export { ApiHideProperty, ApiProperty, BaseConnector, Collection, Column, f, Fluent, getModelSchemaRef, getOutputKeys, HideField, InputType, loadRelations, modelGeneratorDataSource, ObjectType, OmitType, PartialType, TypeOrmConnector, Cache, getRelationsFromModelGenerator, LogicOperator, extractConditions, extractInclude, extractMetadataFromKeys, extractOrderBy, getSelectedKeysFromRawSql, nestQueryResults };
 interface ValidatedInput<T> {
     errors: ValidationError[] | null;
     result: Awaited<T>;
 }
-export type { AnyObject, Deleted, FluentConnectorInterface, PaginatedData, Paginator, Primitives, PrimitivesArray, SchemaObject, ValidatedInput, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter, SingleQueryOutput };
+export type { AnyObject, Deleted, FluentConnectorInterface, PaginatedData, Paginator, Primitives, PrimitivesArray, SchemaObject, ValidatedInput, FluentQuery, QueryOutput, LoadedResult, FindByIdFilter };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.nestQueryResults = exports.getSelectedKeysFromRawSql = exports.extractOrderBy = exports.extractMetadataFromKeys = exports.extractInclude = exports.extractConditions = 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; } });
@@ -22,7 +22,6 @@ Object.defineProperty(exports, "f", { enumerable: true, get: function () { retur
 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; } });
@@ -32,5 +31,19 @@ const generatorDatasource_1 = require("./generatorDatasource");
 Object.defineProperty(exports, "modelGeneratorDataSource", { enumerable: true, get: function () { return generatorDatasource_1.modelGeneratorDataSource; } });
 const cache_1 = require("./cache");
 Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return cache_1.Cache; } });
+const extractConditions_1 = require("./TypeOrmConnector/util/extractConditions");
+Object.defineProperty(exports, "extractConditions", { enumerable: true, get: function () { return extractConditions_1.extractConditions; } });
+const extractInclude_1 = require("./TypeOrmConnector/util/extractInclude");
+Object.defineProperty(exports, "extractInclude", { enumerable: true, get: function () { return extractInclude_1.extractInclude; } });
+const extractMetadataFromKeys_1 = require("./TypeOrmConnector/util/extractMetadataFromKeys");
+Object.defineProperty(exports, "extractMetadataFromKeys", { enumerable: true, get: function () { return extractMetadataFromKeys_1.extractMetadataFromKeys; } });
+const extractOrderBy_1 = require("./TypeOrmConnector/util/extractOrderBy");
+Object.defineProperty(exports, "extractOrderBy", { enumerable: true, get: function () { return extractOrderBy_1.extractOrderBy; } });
+const getRelationsFromModelGenerator_1 = require("./TypeOrmConnector/util/getRelationsFromModelGenerator");
+Object.defineProperty(exports, "getRelationsFromModelGenerator", { enumerable: true, get: function () { return getRelationsFromModelGenerator_1.getRelationsFromModelGenerator; } });
+const getSelectedKeysFromRawSql_1 = require("./TypeOrmConnector/util/getSelectedKeysFromRawSql");
+Object.defineProperty(exports, "getSelectedKeysFromRawSql", { enumerable: true, get: function () { return getSelectedKeysFromRawSql_1.getSelectedKeysFromRawSql; } });
+const nestQueryResults_1 = require("./TypeOrmConnector/util/nestQueryResults");
+Object.defineProperty(exports, "nestQueryResults", { enumerable: true, get: function () { return nestQueryResults_1.nestQueryResults; } });
 var typeorm_1 = require("typeorm");
 Object.defineProperty(exports, "DataSource", { enumerable: true, get: function () { return typeorm_1.DataSource; } });

package/dist/loadRelations.js

@@ -21,14 +21,13 @@ const loadRelations = async ({ data, relations, modelRelations, provider, self,
             const chunks = js_utils_1.Arrays.chunk(Array.from(ids), chunkSize);
             const promises = [];
             for (const relatedIds of chunks) {
-                const results = await Repository.findMany({
+                promises.push(Repository.findMany({
                     where: {
                         [relationModel.inverseSidePropertyPath]: {
                             in: relatedIds
                         }
                     }
-                });
-                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]);
@@ -45,14 +44,13 @@ const loadRelations = async ({ data, relations, modelRelations, provider, self,
             const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
             const promises = [];
             for (const relatedIds of chunks) {
-                const results = await Repository.findMany({
+                promises.push(Repository.findMany({
                     where: {
                         id: {
                             in: relatedIds
                         }
                     }
-                });
-                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);
@@ -121,10 +119,10 @@ const loadRelations = async ({ data, relations, modelRelations, provider, self,
                     if (!d[calleeKey]) {
                         d[calleeKey] = [];
                     }
-                    d[calleeKey] = [
-                        ...d[calleeKey],
-                        ...groupedRelated[gp[relationModel.inverseJoinColumns[0].propertyName]]
-                    ];
+                    const mapped = groupedRelated[gp[relationModel.inverseJoinColumns[0].propertyName]];
+                    if (mapped) {
+                        d[calleeKey] = [...d[calleeKey], ...mapped];
+                    }
                 });
             });
             return data;