@goatlab/fluent 0.7.4 → 0.7.9

package/dist/TypeOrmConnector/TypeOrmConnector.js

@@ -1,760 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeOrmConnector = exports.getRelationsFromModelGenerator = void 0;
-const types_1 = require("./../types");
-const typeorm_1 = require("typeorm");
-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;
-class TypeOrmConnector extends BaseConnector_1.BaseConnector {
-    constructor({ entity, dataSource, inputSchema, outputSchema }) {
-        super();
-        this.dataSource = dataSource;
-        this.inputSchema = inputSchema;
-        this.outputSchema =
-            outputSchema || inputSchema;
-        this.entity = entity;
-        this.repository = this.dataSource.getRepository(entity);
-        this.isMongoDB =
-            this.repository.metadata.connection.driver.options.type === 'mongodb';
-        if (this.isMongoDB) {
-            this.repository = this.dataSource.getMongoRepository(entity);
-        }
-        const relationShipBuilder = generatorDatasource_1.modelGeneratorDataSource.getRepository(entity);
-        const { relations } = (0, exports.getRelationsFromModelGenerator)(relationShipBuilder);
-        this.modelRelations = relations;
-        this.outputKeys = (0, outputKeys_1.getOutputKeys)(relationShipBuilder) || [];
-    }
-    async insert(data) {
-        const validatedData = this.inputSchema.parse(data);
-        let datum = await this.repository.save(validatedData);
-        if (this.isMongoDB) {
-            datum['id'] = datum['id'].toString();
-        }
-        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(datum)));
-    }
-    async insertMany(data) {
-        const validatedData = this.inputSchema.array().parse(data);
-        const inserted = await this.repository.save(validatedData, {
-            chunk: data.length / 300
-        });
-        return this.outputSchema.array().parse(inserted.map(d => {
-            if (this.isMongoDB) {
-                d['id'] = d['id'].toString();
-            }
-            return this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
-        }));
-    }
-    async findMany(query) {
-        if (this.isMongoDB && query?.include) {
-            const mongoRelationResult = this.customMongoRelatedSearch(query);
-            return mongoRelationResult;
-        }
-        const generatedQuery = this.generateTypeOrmQuery(query);
-        let [found, count] = await this.repository.findAndCount(generatedQuery);
-        found.map(d => {
-            if (this.isMongoDB) {
-                d['id'] = d['id'].toString();
-            }
-            this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
-        });
-        if (query?.paginated) {
-            const paginationInfo = {
-                total: count,
-                perPage: query.paginated.perPage,
-                currentPage: query.paginated.page,
-                nextPage: query.paginated.page + 1,
-                firstPage: 1,
-                lastPage: Math.ceil(count / query.paginated.perPage),
-                prevPage: query.paginated.page === 1 ? null : query.paginated.page - 1,
-                from: (query.paginated.page - 1) * query.paginated.perPage + 1,
-                to: query.paginated.perPage * query.paginated.page,
-                data: found
-            };
-            return paginationInfo;
-        }
-        if (query?.select) {
-            return found;
-        }
-        return this.outputSchema?.array().parse(found);
-    }
-    async updateById(id, data) {
-        const parsedId = this.isMongoDB
-            ? js_utils_1.Ids.objectID(id)
-            : id;
-        const idFieldName = this.isMongoDB ? '_id' : 'id';
-        const dataToInsert = this.outputKeys.includes('updated')
-            ? {
-                ...data,
-                ...{ updated: new Date() }
-            }
-            : data;
-        const validatedData = this.inputSchema.parse(dataToInsert);
-        const updateResults = await this.repository.update(id, validatedData);
-        if (updateResults.affected === 0) {
-            throw new Error('No rows where affected');
-        }
-        const dbResult = await this.repository.findOneOrFail({
-            where: {
-                [idFieldName]: parsedId
-            }
-        });
-        if (this.isMongoDB) {
-            dbResult['id'] = dbResult['id'].toString();
-        }
-        return this.outputSchema?.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(dbResult)));
-    }
-    async replaceById(id, data) {
-        const parsedId = this.isMongoDB
-            ? js_utils_1.Ids.objectID(id)
-            : id;
-        const idFieldName = this.isMongoDB ? '_id' : 'id';
-        const value = await this.repository.findOneOrFail({
-            where: {
-                [idFieldName]: parsedId
-            }
-        });
-        const flatValue = js_utils_1.Objects.flatten(JSON.parse(JSON.stringify(value)));
-        Object.keys(flatValue).forEach(key => {
-            flatValue[key] = null;
-        });
-        const nullObject = js_utils_1.Objects.nest(flatValue);
-        const newValue = { ...nullObject, ...data };
-        delete newValue._id;
-        delete newValue.id;
-        delete newValue.created;
-        delete newValue.updated;
-        const dataToInsert = this.outputKeys.includes('updated')
-            ? {
-                ...data,
-                ...{ updated: new Date() }
-            }
-            : data;
-        const validatedData = this.inputSchema.parse(dataToInsert);
-        const updateResults = await this.repository.update(id, validatedData);
-        if (updateResults.affected === 0) {
-            throw new Error('No rows where affected');
-        }
-        const val = await this.repository.findOneOrFail({
-            where: {
-                [idFieldName]: parsedId
-            }
-        });
-        if (this.isMongoDB) {
-            val['id'] = val['id'].toString();
-        }
-        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
-    }
-    async deleteById(id) {
-        const parsedId = this.isMongoDB
-            ? js_utils_1.Ids.objectID(id)
-            : id;
-        await this.repository.delete(parsedId);
-        return id;
-    }
-    async clear() {
-        await this.repository.clear();
-        return true;
-    }
-    loadFirst(query) {
-        const newInstance = this.clone();
-        newInstance.setRelatedQuery({
-            entity: this.entity,
-            repository: this,
-            query: {
-                ...query,
-                limit: 1
-            }
-        });
-        return newInstance;
-    }
-    loadById(id) {
-        const newInstance = this.clone();
-        newInstance.setRelatedQuery({
-            entity: this.entity,
-            repository: this,
-            query: {
-                where: {
-                    id
-                }
-            }
-        });
-        return newInstance;
-    }
-    raw() {
-        return this.repository;
-    }
-    mongoRaw() {
-        return this.repository;
-    }
-    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);
-        filter.take = query?.limit;
-        filter.skip = query?.offset;
-        if (query?.paginated) {
-            filter.take = query.paginated.perPage;
-            filter.skip = (query.paginated?.page - 1) * query?.paginated.perPage;
-        }
-        if (query?.select) {
-            const selectQuery = js_utils_1.Objects.flatten(query?.select || {});
-            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 {};
-        }
-        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 (!!copy['OR']) {
-            delete copy['OR'];
-        }
-        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;
-            }
-        }
-        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;
-            }
-        }
-        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) });
-                    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));
-            }
-            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;
-            }
-        }
-        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;
-            }
-        }
-        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));
-            }
-            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 filtered = this.clearEmpties(Filters.where);
-        return filtered;
-    }
-}
-exports.TypeOrmConnector = TypeOrmConnector;