@goatlab/fluent 0.7.5 → 0.7.10

package/dist/TypeOrmConnector/TypeOrmConnector.js

@@ -1,35 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeOrmConnector = exports.getRelationsFromModelGenerator = void 0;
-const types_1 = require("./../types");
-const typeorm_1 = require("typeorm");
+exports.TypeOrmConnector = void 0;
 const js_utils_1 = require("@goatlab/js-utils");
 const BaseConnector_1 = require("../BaseConnector");
 const outputKeys_1 = require("../outputKeys");
 const generatorDatasource_1 = require("../generatorDatasource");
-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;
+const getMongoWhere_1 = require("./queryBuilder/mongodb/getMongoWhere");
+const getRelationsFromModelGenerator_1 = require("./util/getRelationsFromModelGenerator");
+const getMongoFindAggregatedQuery_1 = require("./queryBuilder/mongodb/getMongoFindAggregatedQuery");
+const extractInclude_1 = require("./util/extractInclude");
+const extractOrderBy_1 = require("./util/extractOrderBy");
+const getTypeOrmWhere_1 = require("./queryBuilder/sql/getTypeOrmWhere");
+const getQueryBuilderWhere_1 = require("./queryBuilder/sql/getQueryBuilderWhere");
+const clearEmpties_1 = require("./util/clearEmpties");
 class TypeOrmConnector extends BaseConnector_1.BaseConnector {
     constructor({ entity, dataSource, inputSchema, outputSchema }) {
         super();
@@ -45,7 +28,7 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
             this.repository = this.dataSource.getMongoRepository(entity);
         }
         const relationShipBuilder = generatorDatasource_1.modelGeneratorDataSource.getRepository(entity);
-        const { relations } = (0, exports.getRelationsFromModelGenerator)(relationShipBuilder);
+        const { relations } = (0, getRelationsFromModelGenerator_1.getRelationsFromModelGenerator)(relationShipBuilder);
         this.modelRelations = relations;
         this.outputKeys = (0, outputKeys_1.getOutputKeys)(relationShipBuilder) || [];
     }
@@ -55,7 +38,7 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
         if (this.isMongoDB) {
             datum['id'] = datum['id'].toString();
         }
-        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(datum)));
+        return this.outputSchema.parse((0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(datum)));
     }
     async insertMany(data) {
         const validatedData = this.inputSchema.array().parse(data);
@@ -66,13 +49,22 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
             if (this.isMongoDB) {
                 d['id'] = d['id'].toString();
             }
-            return this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
+            return (0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(d));
         }));
     }
     async findMany(query) {
-        if (this.isMongoDB && query?.include) {
-            const mongoRelationResult = this.customMongoRelatedSearch(query);
-            return mongoRelationResult;
+        const requiresCustomQuery = query?.include && Object.keys(query.include).length;
+        if (this.isMongoDB && requiresCustomQuery) {
+            const results = await this.customMongoRelatedFind(query);
+            return results;
+        }
+        if (requiresCustomQuery) {
+            const { queryBuilder: customQuery, selectedKeys } = this.customTypeOrmRelatedFind({
+                fluentQuery: query
+            });
+            customQuery.select(selectedKeys);
+            let [result, count] = await customQuery.getManyAndCount();
+            return result;
         }
         const generatedQuery = this.generateTypeOrmQuery(query);
         let [found, count] = await this.repository.findAndCount(generatedQuery);
@@ -80,7 +72,7 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
             if (this.isMongoDB) {
                 d['id'] = d['id'].toString();
             }
-            this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
+            (0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(d));
         });
         if (query?.paginated) {
             const paginationInfo = {
@@ -126,7 +118,7 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
         if (this.isMongoDB) {
             dbResult['id'] = dbResult['id'].toString();
         }
-        return this.outputSchema?.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(dbResult)));
+        return this.outputSchema?.parse((0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(dbResult)));
     }
     async replaceById(id, data) {
         const parsedId = this.isMongoDB
@@ -167,7 +159,7 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
         if (this.isMongoDB) {
             val['id'] = val['id'].toString();
         }
-        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
+        return this.outputSchema.parse((0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(val)));
     }
     async deleteById(id) {
         const parsedId = this.isMongoDB
@@ -214,173 +206,15 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
     clone() {
         return new this.constructor();
     }
-    getOrderBy(orderBy) {
-        if (!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);
-    }
-    getMongoSelect(select) {
-        const selected = js_utils_1.Objects.flatten(select || {});
-        for (const k of Object.keys(selected)) {
-            if (k === 'id') {
-                delete selected[k];
-                selected['_id'] = 1;
-                continue;
-            }
-            const containsId = k.lastIndexOf('.id');
-            if (containsId >= 0 && containsId + 3 === k.length) {
-                selected[`${k.replace('.id', '')}._id`] = 1;
-                delete selected[k];
-                continue;
-            }
-            selected[k] = 1;
-        }
-        return selected;
-    }
-    getMongoLookup(include) {
-        if (!include) {
-            return [];
-        }
-        const lookUps = [];
-        for (const relation of Object.keys(include)) {
-            if (this.modelRelations[relation]) {
-                const dbRelation = this.modelRelations[relation];
-                if (dbRelation.isManyToOne) {
-                    const localField = dbRelation.joinColumns[0].propertyPath;
-                    lookUps.push({
-                        $addFields: {
-                            [`${localField}_object`]: { $toObjectId: `$${localField}` }
-                        }
-                    });
-                    lookUps.push({ $addFields: { id: { $toString: '$_id' } } });
-                    lookUps.push({
-                        $lookup: {
-                            from: dbRelation.tableName,
-                            localField: `${localField}_object`,
-                            foreignField: '_id',
-                            as: dbRelation.propertyName,
-                            pipeline: [
-                                { $addFields: { id: { $toString: '$_id' } } }
-                            ]
-                        }
-                    });
-                    lookUps.push({ $unwind: `$${dbRelation.propertyName}` });
-                }
-                if (dbRelation.isOneToMany) {
-                    lookUps.push({ $addFields: { string_id: { $toString: '$_id' } } });
-                    lookUps.push({ $addFields: { id: { $toString: '$_id' } } });
-                    lookUps.push({
-                        $lookup: {
-                            from: dbRelation.tableName,
-                            localField: 'string_id',
-                            foreignField: dbRelation.inverseSidePropertyPath,
-                            as: dbRelation.propertyName,
-                            pipeline: [
-                                { $addFields: { id: { $toString: '$_id' } } }
-                            ]
-                        }
-                    });
-                }
-                if (dbRelation.isManyToMany) {
-                    const relatedTableName = dbRelation.tableName;
-                    const pivotTableName = dbRelation.joinColumns[0].relationMetadata.joinTableName;
-                    const pivotForeignField = dbRelation.joinColumns[0].propertyPath;
-                    const inverseForeignField = dbRelation.inverseJoinColumns[0].propertyPath;
-                    if (!relatedTableName ||
-                        !pivotTableName ||
-                        !pivotForeignField ||
-                        !inverseForeignField) {
-                        throw new Error(`Your many to many relation is not properly set up. Please check both your models and schema for relation: ${relation}`);
-                    }
-                    lookUps.push({ $addFields: { id: { $toString: '$_id' } } });
-                    lookUps.push({
-                        $addFields: { parent_string_id: { $toString: '$_id' } }
-                    });
-                    lookUps.push({
-                        $lookup: {
-                            from: pivotTableName,
-                            localField: 'parent_string_id',
-                            foreignField: pivotForeignField,
-                            as: dbRelation.propertyName,
-                            pipeline: [
-                                { $addFields: { id: { $toString: '$_id' } } },
-                                {
-                                    $addFields: {
-                                        [`${inverseForeignField}_object`]: {
-                                            $toObjectId: `$${inverseForeignField}`
-                                        }
-                                    }
-                                },
-                                {
-                                    $lookup: {
-                                        from: relatedTableName,
-                                        localField: `${inverseForeignField}_object`,
-                                        foreignField: '_id',
-                                        pipeline: [
-                                            { $addFields: { id: { $toString: '$_id' } } }
-                                        ],
-                                        as: dbRelation.propertyName
-                                    }
-                                },
-                                { $unwind: `$${dbRelation.propertyName}` },
-                                {
-                                    $project: {
-                                        [dbRelation.propertyName]: `$${dbRelation.propertyName}`,
-                                        pivot: '$$ROOT'
-                                    }
-                                },
-                                {
-                                    $replaceRoot: {
-                                        newRoot: {
-                                            $mergeObjects: ['$$ROOT', `$${dbRelation.propertyName}`]
-                                        }
-                                    }
-                                },
-                                { $project: { [dbRelation.propertyName]: 0 } }
-                            ]
-                        }
-                    });
-                }
-            }
-        }
-        return lookUps;
-    }
-    async customMongoRelatedSearch(query) {
-        const where = this.getTypeOrmMongoWhere(query?.where);
-        const selected = this.getMongoSelect(query?.select);
-        const lookups = this.getMongoLookup(query?.include);
-        const aggregate = [
-            {
-                $match: where
-            }
-        ];
-        if (query?.limit) {
-            aggregate.push({ $limit: query.limit });
-        }
-        for (const lookup of lookups) {
-            aggregate.push(lookup);
-        }
-        if (selected && Object.keys(selected).length) {
-            aggregate.push({
-                $project: selected
-            });
-        }
-        let raw = await this.mongoRaw().aggregate(aggregate).toArray();
-        return this.outputSchema?.array().parse(raw);
-    }
     generateTypeOrmQuery(query) {
         let filter = {};
         filter.where = this.isMongoDB
-            ? this.getTypeOrmMongoWhere(query?.where)
-            : this.getTypeOrmWhere(query?.where);
+            ? (0, getMongoWhere_1.getMongoWhere)({
+                where: query?.where
+            })
+            : (0, getTypeOrmWhere_1.getTypeOrmWhere)({
+                where: query?.where
+            });
         filter.take = query?.limit;
         filter.skip = query?.offset;
         if (query?.paginated) {
@@ -389,372 +223,175 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
         }
         if (query?.select) {
             const selectQuery = js_utils_1.Objects.flatten(query?.select || {});
+            filter.select = selectQuery;
             if (this.isMongoDB) {
                 filter.select = Object.keys(selectQuery);
             }
-            else {
-                filter.select = selectQuery;
-            }
         }
-        filter.order = this.getOrderBy(query?.orderBy);
-        filter.relations = query?.include;
-        return filter;
-    }
-    getTypeOrmWhere(where) {
-        if (!where || Object.keys(where).length === 0) {
-            return {};
+        if (query?.orderBy) {
+            filter.order = (0, extractOrderBy_1.extractOrderBy)(query.orderBy);
         }
-        const Filters = { where: [{}] };
-        const orConditions = this.extractConditions(where['OR']);
-        const andConditions = this.extractConditions(where['AND']);
-        const copy = js_utils_1.Objects.clone(where);
-        if (!!copy['AND']) {
-            delete copy['AND'];
+        if (query?.include) {
+            filter.relations = (0, extractInclude_1.extractInclude)(query.include);
         }
-        if (!!copy['OR']) {
-            delete copy['OR'];
+        return filter;
+    }
+    customTypeOrmRelatedFind({ fluentQuery: query, queryBuilder, targetFluentRepository, alias, isLeftJoin }) {
+        const queryAlias = alias || queryBuilder?.alias || `${this.repository.metadata.tableName}`;
+        let customQuery = queryBuilder || this.raw().createQueryBuilder(queryAlias);
+        const self = targetFluentRepository || this;
+        if (!isLeftJoin) {
+            customQuery = (0, getQueryBuilderWhere_1.getQueryBuilderWhere)({
+                queryBuilder: customQuery,
+                queryAlias,
+                where: query?.where
+            });
         }
-        const rootLevelConditions = this.extractConditions([copy]);
-        for (const condition of andConditions) {
-            const { element, operator, value } = condition;
-            switch (operator) {
-                case types_1.LogicOperator.equals:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.Equal)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.isNot:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) }
-                    });
-                    break;
-                case types_1.LogicOperator.greaterThan:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.MoreThan)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.greaterOrEqualThan:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.MoreThanOrEqual)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.lessThan:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.LessThan)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.lessOrEqualThan:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.LessThanOrEqual)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.in:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.In)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.notIn:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) }
-                    });
-                    break;
-                case types_1.LogicOperator.exists:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) }
-                    });
-                    break;
-                case types_1.LogicOperator.notExists:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.IsNull)() }
-                    });
-                    break;
-                case types_1.LogicOperator.regexp:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.Like)(value) }
-                    });
-                    break;
+        const { queryBuilder: qb, selectedKeys } = this.getTypeOrmQueryBuilderSubqueries({
+            queryBuilder: customQuery,
+            selfReference: targetFluentRepository,
+            include: query?.include,
+            leftTableAlias: alias
+        });
+        customQuery = qb;
+        const extraKeys = this.getTypeOrmQueryBuilderSelect(queryAlias, self, query?.select);
+        const keySet = new Set([...selectedKeys, ...extraKeys]);
+        return {
+            queryBuilder: customQuery,
+            selectedKeys: Array.from(keySet)
+        };
+    }
+    getTypeOrmQueryBuilderSelect(queryAlias, self, select) {
+        const selected = js_utils_1.Objects.flatten(select || {});
+        const selectedKeys = [];
+        const iterableKeys = Object.keys(selected).length
+            ? Object.keys(selected)
+            : self.outputKeys || [];
+        const baseNestedKeys = new Set();
+        for (const key of iterableKeys) {
+            const keyArray = key.split('.');
+            if (keyArray.length <= 1) {
+                continue;
             }
-        }
-        for (const condition of rootLevelConditions) {
-            const { element, operator, value } = condition;
-            switch (operator) {
-                case types_1.LogicOperator.equals:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.Equal)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.isNot:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) }
-                    });
-                    break;
-                case types_1.LogicOperator.greaterThan:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.MoreThan)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.greaterOrEqualThan:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.MoreThanOrEqual)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.lessThan:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.LessThan)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.lessOrEqualThan:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.LessThanOrEqual)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.in:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.In)(value) }
-                    });
-                    break;
-                case types_1.LogicOperator.notIn:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) }
-                    });
-                    break;
-                case types_1.LogicOperator.exists:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) }
-                    });
-                    break;
-                case types_1.LogicOperator.notExists:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.IsNull)() }
-                    });
-                    break;
-                case types_1.LogicOperator.regexp:
-                    Filters.where[0] = js_utils_1.Objects.nest({
-                        ...Filters.where[0],
-                        ...{ [element]: (0, typeorm_1.Like)(value) }
-                    });
-                    break;
+            const total = keyArray.length;
+            for (const [index, val] of keyArray.entries()) {
+                if (total === index + 1) {
+                    continue;
+                }
+                let excludedField = '';
+                if (excludedField) {
+                    excludedField = `${excludedField}.${excludedField}${val}`;
+                }
+                excludedField = `${excludedField}${val}`;
+                baseNestedKeys.add(excludedField);
             }
         }
-        for (const condition of orConditions) {
-            const { element, operator, value } = condition;
-            switch (operator) {
-                case types_1.LogicOperator.equals:
-                    Filters.where.push({ [element]: (0, typeorm_1.Equal)(value) });
-                    break;
-                case types_1.LogicOperator.isNot:
-                    Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) });
-                    break;
-                case types_1.LogicOperator.greaterThan:
-                    Filters.where.push({ [element]: (0, typeorm_1.MoreThan)(value) });
-                    break;
-                case types_1.LogicOperator.greaterOrEqualThan:
-                    Filters.where.push({ [element]: (0, typeorm_1.MoreThanOrEqual)(value) });
-                    break;
-                case types_1.LogicOperator.lessThan:
-                    Filters.where.push({ [element]: (0, typeorm_1.LessThan)(value) });
-                    break;
-                case types_1.LogicOperator.lessOrEqualThan:
-                    Filters.where.push({ [element]: (0, typeorm_1.LessThanOrEqual)(value) });
-                    break;
-                case types_1.LogicOperator.in:
-                    Filters.where.push({ [element]: (0, typeorm_1.In)(value) });
-                    break;
-                case types_1.LogicOperator.notIn:
-                    Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) });
-                    break;
-                case types_1.LogicOperator.exists:
-                    Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) });
-                    break;
-                case types_1.LogicOperator.notExists:
-                    Filters.where.push({ [element]: (0, typeorm_1.IsNull)() });
-                    break;
-                case types_1.LogicOperator.regexp:
-                    Filters.where.push({ [element]: (0, typeorm_1.Like)(value) });
+        for (const k of iterableKeys) {
+            const field = k.includes('.') ? js_utils_1.Strings.camel(`${k}`) : k;
+            const search = `${queryAlias}.${field}`;
+            let isNestedRelation = false;
+            for (const item of k.split('.')) {
+                if (!!self[item]) {
+                    isNestedRelation = true;
                     break;
+                }
             }
-        }
-        const filtered = this.clearEmpties(Filters.where);
-        return filtered;
-    }
-    getTypeOrmMongoWhere(where) {
-        if (!where || Object.keys(where).length === 0) {
-            return {};
-        }
-        const Filters = {
-            where: { $or: [{ $and: [] }] }
-        };
-        const orConditions = this.extractConditions(where['OR']);
-        const andConditions = this.extractConditions(where['AND']);
-        const copy = js_utils_1.Objects.clone(where);
-        if (!!copy['AND']) {
-            delete copy['AND'];
-        }
-        if (!!copy['OR']) {
-            delete copy['OR'];
-        }
-        const rootLevelConditions = this.extractConditions([copy]);
-        for (const condition of andConditions) {
-            let { element, operator, value } = condition;
-            if (element === 'id') {
-                element = '_id';
-                value = (Array.isArray(value)
-                    ? value.map(v => js_utils_1.Ids.objectID(v))
-                    : js_utils_1.Ids.objectID(value));
+            if (!!self[field] || !!self[queryAlias] || isNestedRelation) {
+                continue;
             }
-            switch (operator) {
-                case types_1.LogicOperator.equals:
-                    Filters.where.$or[0].$and.push({ [element]: { $eq: value } });
-                    break;
-                case types_1.LogicOperator.isNot:
-                    Filters.where.$or[0].$and.push({ [element]: { $neq: value } });
-                    break;
-                case types_1.LogicOperator.greaterThan:
-                    Filters.where.$or[0].$and.push({ [element]: { $gt: value } });
-                    break;
-                case types_1.LogicOperator.greaterOrEqualThan:
-                    Filters.where.$or[0].$and.push({ [element]: { $gte: value } });
-                    break;
-                case types_1.LogicOperator.lessThan:
-                    Filters.where.$or[0].$and.push({ [element]: { $lt: value } });
-                    break;
-                case types_1.LogicOperator.lessOrEqualThan:
-                    Filters.where.$or[0].$and.push({ [element]: { $lte: value } });
-                    break;
-                case types_1.LogicOperator.in:
-                    Filters.where.$or[0].$and.push({ [element]: { $in: value } });
-                    break;
-                case types_1.LogicOperator.notIn:
-                    Filters.where.$or[0].$and.push({
-                        [element]: { $not: { $in: value } }
-                    });
-                    break;
-                case types_1.LogicOperator.exists:
-                    Filters.where.$or[0].$and.push({ [element]: { $exists: true } });
-                    break;
-                case types_1.LogicOperator.notExists:
-                    Filters.where.$or[0].$and.push({ [element]: { $exists: false } });
-                    break;
-                case types_1.LogicOperator.regexp:
-                    Filters.where.$or[0].$and.push({ [element]: { $regex: value } });
-                    break;
+            if (baseNestedKeys.has(field)) {
+                continue;
             }
+            selectedKeys.push(search);
         }
-        for (const condition of rootLevelConditions) {
-            let { element, operator, value } = condition;
-            if (element === 'id') {
-                element = '_id';
-                value = (Array.isArray(value)
-                    ? value.map(v => js_utils_1.Ids.objectID(v))
-                    : js_utils_1.Ids.objectID(value));
-            }
-            switch (operator) {
-                case types_1.LogicOperator.equals:
-                    Filters.where.$or[0].$and.push({ [element]: { $eq: value } });
-                    break;
-                case types_1.LogicOperator.isNot:
-                    Filters.where.$or[0].$and.push({ [element]: { $neq: value } });
-                    break;
-                case types_1.LogicOperator.greaterThan:
-                    Filters.where.$or[0].$and.push({ [element]: { $gt: value } });
-                    break;
-                case types_1.LogicOperator.greaterOrEqualThan:
-                    Filters.where.$or[0].$and.push({ [element]: { $gte: value } });
-                    break;
-                case types_1.LogicOperator.lessThan:
-                    Filters.where.$or[0].$and.push({ [element]: { $lt: value } });
-                    break;
-                case types_1.LogicOperator.lessOrEqualThan:
-                    Filters.where.$or[0].$and.push({ [element]: { $lte: value } });
-                    break;
-                case types_1.LogicOperator.in:
-                    Filters.where.$or[0].$and.push({ [element]: { $in: value } });
-                    break;
-                case types_1.LogicOperator.notIn:
-                    Filters.where.$or[0].$and.push({
-                        [element]: { $not: { $in: value } }
-                    });
-                    break;
-                case types_1.LogicOperator.exists:
-                    Filters.where.$or[0].$and.push({ [element]: { $exists: true } });
-                    break;
-                case types_1.LogicOperator.notExists:
-                    Filters.where.$or[0].$and.push({ [element]: { $exists: false } });
-                    break;
-                case types_1.LogicOperator.regexp:
-                    Filters.where.$or[0].$and.push({ [element]: { $regex: value } });
-                    break;
-            }
+        return selectedKeys;
+    }
+    getTypeOrmQueryBuilderSubqueries({ queryBuilder, selfReference, include, leftTableAlias }) {
+        const selectedKeys = [];
+        if (!include) {
+            return { queryBuilder, selectedKeys };
         }
-        for (const condition of orConditions) {
-            let { element, operator, value } = condition;
-            if (element === 'id') {
-                element = '_id';
-                value = (Array.isArray(value)
-                    ? value.map(v => js_utils_1.Ids.objectID(v))
-                    : js_utils_1.Ids.objectID(value));
+        for (const relation of Object.keys(include)) {
+            const self = selfReference || this;
+            const dbRelation = self.modelRelations[relation];
+            const newSelf = self[relation]();
+            const fluentRelatedQuery = include[relation] === true ? {} : include[relation];
+            if (!dbRelation) {
+                throw new Error(`The relation ${relation} is not properly defined. Check your entity and repository`);
             }
-            switch (operator) {
-                case types_1.LogicOperator.equals:
-                    Filters.where.$or.push({ [element]: { $eq: value } });
-                    break;
-                case types_1.LogicOperator.isNot:
-                    Filters.where.$or.push({ [element]: { $neq: value } });
-                    break;
-                case types_1.LogicOperator.greaterThan:
-                    Filters.where.$or.push({ [element]: { $gt: value } });
-                    break;
-                case types_1.LogicOperator.greaterOrEqualThan:
-                    Filters.where.$or.push({ [element]: { $gte: value } });
-                    break;
-                case types_1.LogicOperator.lessThan:
-                    Filters.where.$or.push({ [element]: { $lt: value } });
-                    break;
-                case types_1.LogicOperator.lessOrEqualThan:
-                    Filters.where.$or.push({ [element]: { $lte: value } });
-                    break;
-                case types_1.LogicOperator.in:
-                    Filters.where.$or.push({ [element]: { $in: value } });
-                    break;
-                case types_1.LogicOperator.notIn:
-                    Filters.where.$or.push({
-                        [element]: { $not: { $in: value } }
-                    });
-                    break;
-                case types_1.LogicOperator.exists:
-                    Filters.where.$or.push({ [element]: { $exists: true } });
-                    break;
-                case types_1.LogicOperator.notExists:
-                    Filters.where.$or.push({ [element]: { $exists: false } });
-                    break;
-                case types_1.LogicOperator.regexp:
-                    Filters.where.$or.push({ [element]: { $regex: value } });
-                    break;
+            const selectedKeysArray = fluentRelatedQuery.select
+                ? Object.keys(js_utils_1.Objects.flatten(fluentRelatedQuery.select))
+                : [];
+            if (dbRelation.isManyToOne) {
+                const leftSideTableName = leftTableAlias || queryBuilder.alias;
+                const leftSideForeignKey = `${leftSideTableName}.${dbRelation.joinColumns[0].propertyPath}`;
+                const rightSideTableName = `${leftSideTableName}_${relation}`;
+                const rightSidePrimaryKey = `${rightSideTableName}.id`;
+                const keys = new Set(selectedKeysArray.map(k => `${rightSideTableName}.${k}`));
+                selectedKeys.push(...Array.from(keys));
+                const shallowQuery = { ...fluentRelatedQuery };
+                delete shallowQuery['include'];
+                const { queryBuilder: leftJoinBuilder, selectedKeys: deepkeys } = this.customTypeOrmRelatedFind({
+                    queryBuilder: this.raw().createQueryBuilder(rightSideTableName),
+                    fluentQuery: shallowQuery,
+                    targetFluentRepository: newSelf,
+                    alias: rightSideTableName
+                });
+                selectedKeys.push(...deepkeys);
+                const joinQuery = leftJoinBuilder.getQuery().split('WHERE');
+                const customLeftJoin = joinQuery && joinQuery[1] ? joinQuery[1].trim() : '1=1';
+                const leftJoinParams = leftJoinBuilder.getParameters();
+                queryBuilder.leftJoinAndMapOne(`${leftSideTableName}.${relation}`, dbRelation.targetClass, rightSideTableName, `(${leftSideForeignKey} = ${rightSidePrimaryKey} AND  ${customLeftJoin} )`, leftJoinParams);
+                const { queryBuilder: qb, selectedKeys: k } = this.customTypeOrmRelatedFind({
+                    queryBuilder,
+                    fluentQuery: fluentRelatedQuery,
+                    targetFluentRepository: newSelf,
+                    alias: rightSideTableName,
+                    isLeftJoin: true
+                });
+                selectedKeys.push(...k);
+                queryBuilder = qb;
+            }
+            if (dbRelation.isOneToMany) {
+                const leftSideTableName = leftTableAlias || queryBuilder.alias;
+                const leftSidePrimaryKey = `${leftSideTableName}.id`;
+                const rightSideTableName = `${leftSideTableName}_${relation}`;
+                const rightSideForeignKey = `${rightSideTableName}.${dbRelation.inverseSidePropertyPath}`;
+                const keys = new Set(selectedKeysArray.map(k => `${rightSideTableName}.${k}`));
+                selectedKeys.push(...Array.from(keys));
+                const shallowQuery = { ...fluentRelatedQuery };
+                delete shallowQuery['include'];
+                const { queryBuilder: leftJoinBuilder, selectedKeys: deepKeys } = this.customTypeOrmRelatedFind({
+                    queryBuilder: this.raw().createQueryBuilder(rightSideTableName),
+                    fluentQuery: shallowQuery,
+                    targetFluentRepository: newSelf,
+                    alias: rightSideTableName
+                });
+                selectedKeys.push(...deepKeys);
+                const joinQuery = leftJoinBuilder.getQuery().split('WHERE');
+                const customLeftJoin = joinQuery && joinQuery[1] ? joinQuery[1].trim() : '1=1';
+                const leftJoinParams = leftJoinBuilder.getParameters();
+                queryBuilder.leftJoinAndMapMany(`${leftSideTableName}.${relation}`, dbRelation.targetClass, rightSideTableName, `(${leftSidePrimaryKey} = ${rightSideForeignKey} AND ${customLeftJoin} )`, leftJoinParams);
+                const { queryBuilder: q, selectedKeys: k } = this.customTypeOrmRelatedFind({
+                    queryBuilder,
+                    fluentQuery: fluentRelatedQuery,
+                    targetFluentRepository: newSelf,
+                    alias: rightSideTableName,
+                    isLeftJoin: true
+                });
+                selectedKeys.push(...k);
+                queryBuilder = q;
             }
         }
-        const filtered = this.clearEmpties(Filters.where);
-        return filtered;
+        return { queryBuilder, selectedKeys };
+    }
+    async customMongoRelatedFind(query) {
+        const aggregate = (0, getMongoFindAggregatedQuery_1.getMongoFindAggregatedQuery)({
+            query,
+            self: this
+        });
+        const raw = await this.mongoRaw().aggregate(aggregate).toArray();
+        return this.outputSchema?.array().parse(raw);
     }
 }
 exports.TypeOrmConnector = TypeOrmConnector;