@goatlab/fluent 0.6.24 → 0.7.1

package/dist/TypeOrmConnector/TypeOrmConnector.js

@@ -1,22 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeOrmConnector = exports.getRelations = void 0;
+exports.TypeOrmConnector = exports.getRelationsFromModelGenerator = void 0;
+const types_1 = require("./../types");
 const typeorm_1 = require("typeorm");
-const mongodb_1 = require("mongodb");
 const js_utils_1 = require("@goatlab/js-utils");
-const loadRelations_1 = require("../loadRelations");
 const BaseConnector_1 = require("../BaseConnector");
 const outputKeys_1 = require("../outputKeys");
 const generatorDatasource_1 = require("../generatorDatasource");
-const getRelations = typeOrmRepo => {
+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,
-            inverseSidePropertyPath: relation.inverseSidePropertyPath,
-            propertyPath: relation.propertyName,
+            inverseSidePropertyRelationPath: relation.inverseSidePropertyPath,
+            inverseSidePropertyPath: pPath?.propertyPath,
+            propertyName: relation.propertyName,
             entityName: relation.inverseEntityMetadata.name,
             tableName: relation.inverseEntityMetadata.tableName,
             targetClass: relation.inverseEntityMetadata.target,
@@ -28,489 +29,744 @@ const getRelations = typeOrmRepo => {
         relations
     };
 };
-exports.getRelations = getRelations;
+exports.getRelationsFromModelGenerator = getRelationsFromModelGenerator;
 class TypeOrmConnector extends BaseConnector_1.BaseConnector {
-    constructor(entity, dataSource, relationQuery) {
+    constructor({ entity, dataSource, inputSchema, outputSchema }) {
         super();
         this.dataSource = dataSource;
-        this.relationQuery = relationQuery;
+        this.inputSchema = inputSchema;
+        this.outputSchema =
+            outputSchema || inputSchema;
+        this.entity = entity;
         this.repository = this.dataSource.getRepository(entity);
-        const relationShipBuilder = generatorDatasource_1.modelGeneratorDataSource.getRepository(entity);
-        const { relations } = (0, exports.getRelations)(relationShipBuilder);
-        this.modelRelations = relations;
-        this.outputKeys = (0, outputKeys_1.getOutputKeys)(relationShipBuilder) || [];
         this.isMongoDB =
             this.repository.metadata.connection.driver.options.type === 'mongodb';
-    }
-    async get() {
-        const query = this.getGeneratedQuery();
-        const result = await this.repository.find(query);
-        let data = this.jsApplySelect(result);
-        data = await (0, loadRelations_1.loadRelations)({
-            data,
-            relations: this.relations,
-            modelRelations: this.modelRelations,
-            dataSource: this.dataSource,
-            provider: 'typeorm',
-            self: this
-        });
-        this.reset();
-        return data;
-    }
-    async getPaginated() {
-        const response = await this.get();
-        const results = {
-            current_page: response[0].meta.currentPage,
-            data: response[0].data,
-            first_page_url: response[0].meta.firstPageUrl,
-            next_page_url: response[0].meta.nextPageUrl,
-            path: response[0].meta.path,
-            per_page: response[0].meta.itemsPerPage,
-            prev_page_url: response[0].meta.previousPageUrl,
-            total: response[0].meta.totalItemCount
-        };
-        if (results && results.data && this.selectArray.length > 0) {
-            results.data = this.jsApplySelect(results.data);
-            return results;
-        }
-        return results;
-    }
-    async all() {
-        return this.get();
-    }
-    async find(filter = {}) {
-        const stringFilter = filter;
-        let parsedFilter = {};
-        try {
-            parsedFilter = JSON.parse(stringFilter);
-        }
-        catch (error) {
-            parsedFilter = {};
-        }
-        this.selectArray = (parsedFilter && parsedFilter.fields) || [];
-        this.whereArray =
-            (parsedFilter && parsedFilter.where && parsedFilter.where.and) || [];
-        this.orWhereArray =
-            (parsedFilter && parsedFilter.where && parsedFilter.where.or) || [];
-        this.limit((parsedFilter && (parsedFilter.limit || parsedFilter.take)) || 100);
-        this.offset((parsedFilter && (parsedFilter.offset || parsedFilter.skip)) || 0);
-        if (parsedFilter && parsedFilter.order) {
-            const orderB = [
-                parsedFilter.order.field,
-                parsedFilter.order.asc ? 'asc' : 'desc',
-                parsedFilter.order.type || 'string'
-            ];
-            this.chainReference.push({ method: 'orderBy', orderB });
-            this.orderByArray = orderB;
-        }
-        return this.get();
-    }
-    async paginate(paginator) {
-        if (!paginator) {
-            throw new Error('Paginator cannot be empty');
+        if (this.isMongoDB) {
+            this.repository = this.dataSource.getMongoRepository(entity);
         }
-        this.paginator = paginator;
-        const response = await this.getPaginated();
-        return response;
-    }
-    raw() {
-        return this.repository;
+        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 datum = await this.repository.save(data);
-        const result = this.jsApplySelect([datum]);
-        this.reset();
-        return result[0];
+        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 inserted = await this.repository.save(data, {
+        const validatedData = this.inputSchema.array().parse(data);
+        const inserted = await this.repository.save(validatedData, {
             chunk: data.length / 300
         });
-        this.reset();
-        const result = this.jsApplySelect(inserted);
-        return result;
-    }
-    async updateById(id, data) {
-        const parsedId = this.isMongoDB
-            ? new mongodb_1.ObjectId(id)
-            : id;
-        const dataToInsert = this.outputKeys.includes('updated')
-            ? {
-                ...data,
-                ...{ updated: new Date() }
+        return this.outputSchema.array().parse(inserted.map(d => {
+            if (this.isMongoDB) {
+                d['id'] = d['id'].toString();
             }
-            : data;
-        await this.repository.update(id, dataToInsert);
-        const dbResult = await this.repository.findBy({
-            id: (0, typeorm_1.In)([parsedId])
-        });
-        const result = this.jsApplySelect(dbResult);
-        this.reset();
-        return result[0];
+            return this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
+        }));
     }
-    async replaceById(id, data) {
-        const parsedId = this.isMongoDB
-            ? new mongodb_1.ObjectId(id)
-            : id;
-        const value = await this.repository.findOneOrFail({
-            where: { id: 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;
-        await this.repository.update(id, dataToInsert);
-        const val = await this.repository.findOneOrFail({
-            where: {
-                id: parsedId
-            }
-        });
-        const returnValue = this.jsApplySelect([val]);
-        this.reset();
-        return returnValue[0];
-    }
-    async clear({ sure }) {
-        if (!sure || sure !== true) {
-            throw new Error('Clear() method will delete everything!, you must set the "sure" parameter "clear({sure:true})" to continue');
-        }
-        await this.repository.clear();
-        this.reset();
-        return true;
-    }
-    async deleteById(id) {
-        const parsedId = this.isMongoDB
-            ? new mongodb_1.ObjectId(id)
-            : id;
-        await this.repository.delete(parsedId);
-        this.reset();
-        return id;
+    raw() {
+        return this.repository;
     }
-    async findById(id) {
-        const parsedId = this.isMongoDB
-            ? new mongodb_1.ObjectId(id)
-            : id;
-        const data = await this.repository.findBy({
-            id: (0, typeorm_1.In)([parsedId])
-        });
-        const result = this.jsApplySelect(data);
-        this.reset();
-        return result[0];
+    mongoRaw() {
+        return this.repository;
     }
-    async findByIds(ids) {
-        const parsedIds = [...ids];
-        if (this.isMongoDB) {
-            parsedIds.map(id => new mongodb_1.ObjectId(id));
+    async findMany(query) {
+        if (this.isMongoDB && query?.include) {
+            const mongoRelationResult = this.customMongoRelatedSearch(query);
+            return mongoRelationResult;
         }
-        const data = await this.repository.findBy({
-            id: (0, typeorm_1.In)(parsedIds)
+        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));
         });
-        const result = this.jsApplySelect(data);
-        return result;
-    }
-    getPage() {
-        const page = 'page=';
-        if (this.paginator && this.paginator.page) {
-            return `${page + this.paginator.page}&`;
+        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;
         }
-        return '';
-    }
-    getPaginatorLimit(filter) {
-        if (this.paginator && this.paginator.perPage) {
-            return { ...filter, limit: this.paginator.perPage };
+        if (query?.select) {
+            return found;
         }
-        return filter;
+        return this.outputSchema?.array().parse(found);
     }
-    getPopulate() {
-        const populate = [];
-        this.populateArray.forEach(relation => {
-            if (typeof relation === 'string') {
-                populate.push({ relation });
+    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;
             }
-            else if (Array.isArray(relation)) {
-                relation.forEach(nestedRelation => {
-                    if (typeof nestedRelation === 'string') {
-                        populate.push({ relation: nestedRelation });
-                    }
-                    else if (typeof nestedRelation === 'object') {
-                        populate.push(nestedRelation);
+            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 } }
+                            ]
+                        }
+                    });
+                }
             }
-            else if (typeof relation === 'object') {
-                populate.push(relation);
+        }
+        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
             }
-        });
-        return populate;
+        ];
+        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);
     }
-    getGeneratedQuery() {
+    generateTypeOrmQuery(query) {
         let filter = {};
-        filter = this.isMongoDB
-            ? this.getMongoFilters(filter)
-            : this.getFilters(filter);
-        filter = this.getLimit(filter);
-        filter = this.getSkip(filter);
-        filter = this.getSelect(filter);
-        filter = this.getOrderBy(filter);
-        filter = this.getPaginatorLimit(filter);
-        const page = this.getPage();
-        const populate = this.getPopulate();
-        if (this.rawQuery) {
-            filter.relations = populate || this.rawQuery.populate;
-            filter.take = filter.take || this.rawQuery.limit;
-            filter.skip = filter.skip || this.rawQuery.skip;
-            filter.order = filter.order || this.rawQuery.order;
-            filter.select = { ...filter.select, ...this.rawQuery.fields };
-            filter.where = { ...this.rawQuery.where };
+        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;
         }
+        filter.select = js_utils_1.Objects.flatten(query?.select || {});
+        filter.order = this.getOrderBy(query?.orderBy);
+        filter.relations = query?.include;
         return filter;
     }
-    getFilters(filters) {
-        const andFilters = this.whereArray;
-        const orFilters = this.orWhereArray;
-        if (this.relationQuery && this.relationQuery.data) {
-            const ids = this.relationQuery.data.map(d => d.id);
-            andFilters.push([
-                this.relationQuery.relation.inverseSidePropertyPath,
-                'in',
-                ids
-            ]);
-        }
-        if (!andFilters || andFilters.length === 0) {
-            return filters;
+    getTypeOrmWhere(where) {
+        if (!where || Object.keys(where).length === 0) {
+            return {};
         }
         const Filters = { where: [{}] };
-        andFilters.forEach(condition => {
-            const element = condition[0];
-            const operator = condition[1];
-            const value = condition[2];
+        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 '=':
+                case types_1.LogicOperator.equals:
                     Filters.where[0] = js_utils_1.Objects.nest({
                         ...Filters.where[0],
                         ...{ [element]: (0, typeorm_1.Equal)(value) }
                     });
                     break;
-                case '!=':
+                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 '>':
+                case types_1.LogicOperator.greaterThan:
                     Filters.where[0] = js_utils_1.Objects.nest({
                         ...Filters.where[0],
                         ...{ [element]: (0, typeorm_1.MoreThan)(value) }
                     });
                     break;
-                case '>=':
+                case types_1.LogicOperator.greaterOrEqualThan:
                     Filters.where[0] = js_utils_1.Objects.nest({
                         ...Filters.where[0],
                         ...{ [element]: (0, typeorm_1.MoreThanOrEqual)(value) }
                     });
                     break;
-                case '<':
+                case types_1.LogicOperator.lessThan:
                     Filters.where[0] = js_utils_1.Objects.nest({
                         ...Filters.where[0],
                         ...{ [element]: (0, typeorm_1.LessThan)(value) }
                     });
                     break;
-                case '<=':
+                case types_1.LogicOperator.lessOrEqualThan:
                     Filters.where[0] = js_utils_1.Objects.nest({
                         ...Filters.where[0],
                         ...{ [element]: (0, typeorm_1.LessThanOrEqual)(value) }
                     });
                     break;
-                case 'in':
+                case types_1.LogicOperator.in:
                     Filters.where[0] = js_utils_1.Objects.nest({
                         ...Filters.where[0],
                         ...{ [element]: (0, typeorm_1.In)(value) }
                     });
                     break;
-                case 'nin':
+                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 'exists':
+                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 '!exists':
+                case types_1.LogicOperator.notExists:
                     Filters.where[0] = js_utils_1.Objects.nest({
                         ...Filters.where[0],
                         ...{ [element]: (0, typeorm_1.IsNull)() }
                     });
                     break;
-                case 'regexp':
+                case types_1.LogicOperator.regexp:
                     Filters.where[0] = js_utils_1.Objects.nest({
                         ...Filters.where[0],
                         ...{ [element]: (0, typeorm_1.Like)(value) }
                     });
                     break;
             }
-        });
-        orFilters.forEach(condition => {
-            const element = condition[0];
-            const operator = condition[1];
-            const value = condition[2];
+        }
+        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 '=':
+                case types_1.LogicOperator.equals:
                     Filters.where.push({ [element]: (0, typeorm_1.Equal)(value) });
                     break;
-                case '!=':
+                case types_1.LogicOperator.isNot:
                     Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.Equal)(value)) });
                     break;
-                case '>':
+                case types_1.LogicOperator.greaterThan:
                     Filters.where.push({ [element]: (0, typeorm_1.MoreThan)(value) });
                     break;
-                case '>=':
-                    Filters.where.push(js_utils_1.Objects.nest({ [element]: (0, typeorm_1.MoreThanOrEqual)(value) }));
+                case types_1.LogicOperator.greaterOrEqualThan:
+                    Filters.where.push({ [element]: (0, typeorm_1.MoreThanOrEqual)(value) });
                     break;
-                case '<':
+                case types_1.LogicOperator.lessThan:
                     Filters.where.push({ [element]: (0, typeorm_1.LessThan)(value) });
                     break;
-                case '<=':
+                case types_1.LogicOperator.lessOrEqualThan:
                     Filters.where.push({ [element]: (0, typeorm_1.LessThanOrEqual)(value) });
                     break;
-                case 'in':
+                case types_1.LogicOperator.in:
                     Filters.where.push({ [element]: (0, typeorm_1.In)(value) });
                     break;
-                case 'nin':
+                case types_1.LogicOperator.notIn:
                     Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.In)(value)) });
                     break;
-                case 'exists':
+                case types_1.LogicOperator.exists:
                     Filters.where.push({ [element]: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) });
                     break;
-                case '!exists':
+                case types_1.LogicOperator.notExists:
                     Filters.where.push({ [element]: (0, typeorm_1.IsNull)() });
                     break;
-                case 'regexp':
+                case types_1.LogicOperator.regexp:
                     Filters.where.push({ [element]: (0, typeorm_1.Like)(value) });
                     break;
             }
-        });
-        return Filters;
+        }
+        const filtered = this.clearEmpties(Filters.where);
+        return filtered;
     }
-    getMongoFilters(filters) {
-        const andFilters = this.whereArray;
-        const orFilters = this.orWhereArray;
-        if (this.relationQuery && this.relationQuery.data) {
-            const ids = this.relationQuery.data.map(d => js_utils_1.Ids.objectID(d.id));
-            andFilters.push([
-                this.relationQuery.relation.inverseSidePropertyPath,
-                'in',
-                ids
-            ]);
+    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 (!andFilters || andFilters.length === 0) {
-            return filters;
+        if (!!copy['OR']) {
+            delete copy['OR'];
         }
-        const Filters = { where: { $and: [] } };
-        andFilters.forEach(condition => {
-            let element = condition[0];
-            const operator = condition[1];
-            let value = condition[2];
+        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 = (Array.isArray(value)
                     ? value.map(v => js_utils_1.Ids.objectID(v))
-                    : js_utils_1.Ids.objectID(value);
+                    : js_utils_1.Ids.objectID(value));
             }
             switch (operator) {
-                case '=':
-                    Filters.where.$and.push({ [element]: { $eq: value } });
+                case types_1.LogicOperator.equals:
+                    Filters.where.$or[0].$and.push({ [element]: { $eq: value } });
                     break;
-                case '!=':
-                    Filters.where.$and.push({ [element]: { $neq: value } });
+                case types_1.LogicOperator.isNot:
+                    Filters.where.$or[0].$and.push({ [element]: { $neq: value } });
                     break;
-                case '>':
-                    Filters.where.$and.push({ [element]: { $gt: value } });
+                case types_1.LogicOperator.greaterThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $gt: value } });
                     break;
-                case '>=':
-                    Filters.where.$and.push({ [element]: { $gte: value } });
+                case types_1.LogicOperator.greaterOrEqualThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $gte: value } });
                     break;
-                case '<':
-                    Filters.where.$and.push({ [element]: { $lt: value } });
+                case types_1.LogicOperator.lessThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $lt: value } });
                     break;
-                case '<=':
-                    Filters.where.$and.push({ [element]: { $lte: value } });
+                case types_1.LogicOperator.lessOrEqualThan:
+                    Filters.where.$or[0].$and.push({ [element]: { $lte: value } });
                     break;
-                case 'in':
-                    Filters.where.$and.push({ [element]: { $in: value } });
+                case types_1.LogicOperator.in:
+                    Filters.where.$or[0].$and.push({ [element]: { $in: value } });
                     break;
-                case 'nin':
-                    Filters.where.$and.push({
+                case types_1.LogicOperator.notIn:
+                    Filters.where.$or[0].$and.push({
                         [element]: { $not: { $in: value } }
                     });
                     break;
-                case 'exists':
-                    Filters.where.$and.push({ [element]: { $exists: true } });
+                case types_1.LogicOperator.exists:
+                    Filters.where.$or[0].$and.push({ [element]: { $exists: true } });
                     break;
-                case '!exists':
-                    Filters.where.$and.push({ [element]: { $exists: false } });
+                case types_1.LogicOperator.notExists:
+                    Filters.where.$or[0].$and.push({ [element]: { $exists: false } });
                     break;
-                case 'regex':
-                    Filters.where.$and.push({ [element]: { $regex: value } });
+                case types_1.LogicOperator.regexp:
+                    Filters.where.$or[0].$and.push({ [element]: { $regex: value } });
                     break;
             }
-        });
-        return Filters;
-    }
-    getOrderBy(filter) {
-        if (!this.orderByArray || this.orderByArray.length === 0) {
-            return filter;
         }
-        return {
-            ...filter,
-            order: {
-                [this.orderByArray[0]]: this.orderByArray[1].toUpperCase()
+        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;
     }
-    getLimit(filter) {
-        if (!this.limitNumber || this.limitNumber === 0) {
-            this.limitNumber = (this.rawQuery && this.rawQuery.limit) || 50;
+    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');
         }
-        return { ...filter, take: this.limitNumber };
+        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)));
     }
-    getSkip(filter) {
-        if (!this.offsetNumber) {
-            this.offsetNumber = (this.rawQuery && this.rawQuery.skip) || 0;
+    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 { ...filter, skip: this.offsetNumber };
+        return this.outputSchema.parse(this.clearEmpties(js_utils_1.Objects.deleteNulls(val)));
     }
-    getSelect(filter) {
-        let select = this.selectArray;
-        if (Object.keys(select).length === 0 && select.constructor === Object) {
-            select = [''];
+    async clear() {
+        await this.repository.clear();
+        return true;
+    }
+    loadFirst(query) {
+        const detachedClass = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+        detachedClass.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query
+        });
+        return detachedClass;
+    }
+    loadById(id) {
+        const newInstance = this.clone();
+        newInstance.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query: {
+                where: {
+                    id
+                }
+            }
+        });
+        return newInstance;
+    }
+    async requireById(id, q) {
+        const found = await this.findByIds([id], {
+            select: q?.select,
+            include: q?.include,
+            limit: 1
+        });
+        found.map(d => {
+            if (this.isMongoDB) {
+                d['id'] = d['id'].toString();
+            }
+            this.clearEmpties(js_utils_1.Objects.deleteNulls(d));
+        });
+        if (!found[0]) {
+            throw new Error(`Object ${id} not found`);
         }
-        select = select.map(s => {
-            s = s.split(' as ')[0];
-            s = s.includes('id') ? 'id' : s;
-            return s;
+        return this.outputSchema?.parse(found[0]);
+    }
+    clone() {
+        return new this.constructor();
+    }
+    async findByIds(ids, q) {
+        let data = await this.findMany({
+            where: {
+                id: {
+                    in: ids
+                }
+            },
+            limit: q?.limit,
+            select: q?.select,
+            include: q?.include
         });
-        if (select.find(e => e.startsWith('data.'))) {
-            select.unshift('data');
+        return this.outputSchema?.array().parse(data);
+    }
+    getOrderBy(orderBy) {
+        if (!orderBy || orderBy.length === 0) {
+            return {};
         }
-        if (!select) {
-            return filter;
+        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 { ...filter, fields: select };
+        return js_utils_1.Objects.nest(order);
     }
 }
 exports.TypeOrmConnector = TypeOrmConnector;