@goatlab/fluent 0.7.21 → 0.7.22

package/dist/TypeOrmConnector/queryBuilder/mongodb/getMongoWhere.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMongoWhere = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const clearEmpties_1 = require("../../util/clearEmpties");
+const types_1 = require("../../../types");
+const extractConditions_1 = require("../../util/extractConditions");
+const getMongoWhere = ({ where }) => {
+    if (!where || Object.keys(where).length === 0) {
+        return {};
+    }
+    const Filters = {
+        filter: { $or: [{ $and: [] }] }
+    };
+    const orConditions = (0, extractConditions_1.extractConditions)(where['OR']);
+    const andConditions = (0, extractConditions_1.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 = (0, extractConditions_1.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.filter.$or[0].$and.push({ [element]: { $eq: value } });
+                break;
+            case types_1.LogicOperator.isNot:
+                Filters.filter.$or[0].$and.push({ [element]: { $neq: value } });
+                break;
+            case types_1.LogicOperator.greaterThan:
+                Filters.filter.$or[0].$and.push({ [element]: { $gt: value } });
+                break;
+            case types_1.LogicOperator.greaterOrEqualThan:
+                Filters.filter.$or[0].$and.push({ [element]: { $gte: value } });
+                break;
+            case types_1.LogicOperator.lessThan:
+                Filters.filter.$or[0].$and.push({ [element]: { $lt: value } });
+                break;
+            case types_1.LogicOperator.lessOrEqualThan:
+                Filters.filter.$or[0].$and.push({ [element]: { $lte: value } });
+                break;
+            case types_1.LogicOperator.in:
+                Filters.filter.$or[0].$and.push({ [element]: { $in: value } });
+                break;
+            case types_1.LogicOperator.notIn:
+                Filters.filter.$or[0].$and.push({
+                    [element]: { $not: { $in: value } }
+                });
+                break;
+            case types_1.LogicOperator.exists:
+                Filters.filter.$or[0].$and.push({ [element]: { $exists: true } });
+                break;
+            case types_1.LogicOperator.notExists:
+                Filters.filter.$or[0].$and.push({ [element]: { $exists: false } });
+                break;
+            case types_1.LogicOperator.regexp:
+                Filters.filter.$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.filter.$or[0].$and.push({ [element]: { $eq: value } });
+                break;
+            case types_1.LogicOperator.isNot:
+                Filters.filter.$or[0].$and.push({ [element]: { $neq: value } });
+                break;
+            case types_1.LogicOperator.greaterThan:
+                Filters.filter.$or[0].$and.push({ [element]: { $gt: value } });
+                break;
+            case types_1.LogicOperator.greaterOrEqualThan:
+                Filters.filter.$or[0].$and.push({ [element]: { $gte: value } });
+                break;
+            case types_1.LogicOperator.lessThan:
+                Filters.filter.$or[0].$and.push({ [element]: { $lt: value } });
+                break;
+            case types_1.LogicOperator.lessOrEqualThan:
+                Filters.filter.$or[0].$and.push({ [element]: { $lte: value } });
+                break;
+            case types_1.LogicOperator.in:
+                Filters.filter.$or[0].$and.push({ [element]: { $in: value } });
+                break;
+            case types_1.LogicOperator.notIn:
+                Filters.filter.$or[0].$and.push({
+                    [element]: { $not: { $in: value } }
+                });
+                break;
+            case types_1.LogicOperator.exists:
+                Filters.filter.$or[0].$and.push({ [element]: { $exists: true } });
+                break;
+            case types_1.LogicOperator.notExists:
+                Filters.filter.$or[0].$and.push({ [element]: { $exists: false } });
+                break;
+            case types_1.LogicOperator.regexp:
+                Filters.filter.$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.filter.$or.push({ [element]: { $eq: value } });
+                break;
+            case types_1.LogicOperator.isNot:
+                Filters.filter.$or.push({ [element]: { $neq: value } });
+                break;
+            case types_1.LogicOperator.greaterThan:
+                Filters.filter.$or.push({ [element]: { $gt: value } });
+                break;
+            case types_1.LogicOperator.greaterOrEqualThan:
+                Filters.filter.$or.push({ [element]: { $gte: value } });
+                break;
+            case types_1.LogicOperator.lessThan:
+                Filters.filter.$or.push({ [element]: { $lt: value } });
+                break;
+            case types_1.LogicOperator.lessOrEqualThan:
+                Filters.filter.$or.push({ [element]: { $lte: value } });
+                break;
+            case types_1.LogicOperator.in:
+                Filters.filter.$or.push({ [element]: { $in: value } });
+                break;
+            case types_1.LogicOperator.notIn:
+                Filters.filter.$or.push({
+                    [element]: { $not: { $in: value } }
+                });
+                break;
+            case types_1.LogicOperator.exists:
+                Filters.filter.$or.push({ [element]: { $exists: true } });
+                break;
+            case types_1.LogicOperator.notExists:
+                Filters.filter.$or.push({ [element]: { $exists: false } });
+                break;
+            case types_1.LogicOperator.regexp:
+                Filters.filter.$or.push({ [element]: { $regex: value } });
+                break;
+        }
+    }
+    const filtered = (0, clearEmpties_1.clearEmpties)(Filters.filter);
+    return filtered;
+};
+exports.getMongoWhere = getMongoWhere;

package/dist/TypeOrmConnector/queryBuilder/sql/getQueryBuilderWhere.d.ts

@@ -0,0 +1,8 @@
+import { SelectQueryBuilder } from 'typeorm';
+import { AnyObject, FluentQuery } from '../../../types';
+export interface getQueryBuilderWhereParams {
+    where?: FluentQuery<AnyObject>['where'];
+    queryBuilder: SelectQueryBuilder<any>;
+    queryAlias: string;
+}
+export declare const getQueryBuilderWhere: ({ where, queryAlias, queryBuilder }: getQueryBuilderWhereParams) => SelectQueryBuilder<any>;

package/dist/TypeOrmConnector/queryBuilder/sql/getQueryBuilderWhere.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueryBuilderWhere = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const typeorm_1 = require("typeorm");
+const extractConditions_1 = require("../../util/extractConditions");
+const types_1 = require("../../../types");
+const queryId = js_utils_1.Ids.customId('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
+const getQueryBuilderWhere = ({ where, queryAlias, queryBuilder }) => {
+    if (!where || Object.keys(where).length === 0) {
+        return queryBuilder;
+    }
+    const orConditions = (0, extractConditions_1.extractConditions)(where['OR']);
+    const andConditions = (0, extractConditions_1.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 = (0, extractConditions_1.extractConditions)([copy]);
+    queryBuilder.andWhere(new typeorm_1.Brackets(qbAnd => {
+        for (const condition of andConditions) {
+            const { element, operator, value } = condition;
+            const customId = queryId(4);
+            switch (operator) {
+                case types_1.LogicOperator.equals:
+                    qbAnd.andWhere(`${queryAlias}.${element} = :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.isNot:
+                    qbAnd.andWhere(`${queryAlias}.${element} != :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.greaterThan:
+                    qbAnd.andWhere(`${queryAlias}.${element} > :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.greaterOrEqualThan:
+                    qbAnd.andWhere(`${queryAlias}.${element} >= :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.lessThan:
+                    qbAnd.andWhere(`${queryAlias}.${element} < :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.lessOrEqualThan:
+                    qbAnd.andWhere(`${queryAlias}.${element} <= :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.in:
+                    qbAnd.andWhere(`${queryAlias}.${element} IN :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.notIn:
+                    qbAnd.andWhere(`${queryAlias}.${element} NOT IN :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.exists:
+                    qbAnd.andWhere(`${queryAlias}.${element} IS NOT NULL`);
+                    break;
+                case types_1.LogicOperator.notExists:
+                    qbAnd.andWhere(`${queryAlias}.${element} IS NULL`);
+                    break;
+                case types_1.LogicOperator.regexp:
+                    qbAnd.andWhere(`${queryAlias}.${element} LIKE :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+            }
+        }
+        for (const condition of rootLevelConditions) {
+            const { element, operator, value } = condition;
+            const customId = queryId(4);
+            switch (operator) {
+                case types_1.LogicOperator.equals:
+                    qbAnd.andWhere(`${queryAlias}.${element} = :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.isNot:
+                    qbAnd.andWhere(`${queryAlias}.${element} != :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.greaterThan:
+                    qbAnd.andWhere(`${queryAlias}.${element} > :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.greaterOrEqualThan:
+                    qbAnd.andWhere(`${queryAlias}.${element} >= :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.lessThan:
+                    qbAnd.andWhere(`${queryAlias}.${element} < :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.lessOrEqualThan:
+                    qbAnd.andWhere(`${queryAlias}.${element} <= :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.in:
+                    qbAnd.andWhere(`${queryAlias}.${element} IN :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.notIn:
+                    qbAnd.andWhere(`${queryAlias}.${element} NOT IN :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+                case types_1.LogicOperator.exists:
+                    qbAnd.andWhere(`${queryAlias}.${element} IS NOT NULL`);
+                    break;
+                case types_1.LogicOperator.notExists:
+                    qbAnd.andWhere(`${queryAlias}.${element} IS NULL`);
+                    break;
+                case types_1.LogicOperator.regexp:
+                    qbAnd.andWhere(`${queryAlias}.${element} LIKE :${element}_${customId}`, {
+                        [`${element}_${customId}`]: value
+                    });
+                    break;
+            }
+        }
+        qbAnd.andWhere(new typeorm_1.Brackets(qbOr => {
+            for (const condition of orConditions) {
+                const { element, operator, value } = condition;
+                const customId = queryId(4);
+                switch (operator) {
+                    case types_1.LogicOperator.equals:
+                        qbOr.andWhere(`${queryAlias}.${element} = :${element}_${customId}`, {
+                            [`${element}_${customId}`]: value
+                        });
+                        break;
+                    case types_1.LogicOperator.isNot:
+                        qbOr.andWhere(`${queryAlias}.${element} != :${element}_${customId}`, {
+                            [`${element}_${customId}`]: value
+                        });
+                        break;
+                    case types_1.LogicOperator.greaterThan:
+                        qbOr.andWhere(`${queryAlias}.${element} > :${element}_${customId}`, {
+                            [`${element}_${customId}`]: value
+                        });
+                        break;
+                    case types_1.LogicOperator.greaterOrEqualThan:
+                        qbOr.andWhere(`${queryAlias}.${element} >= :${element}_${customId}`, {
+                            [`${element}_${customId}`]: value
+                        });
+                        break;
+                    case types_1.LogicOperator.lessThan:
+                        qbOr.andWhere(`${queryAlias}.${element} < :${element}_${customId}`, {
+                            [`${element}_${customId}`]: value
+                        });
+                        break;
+                    case types_1.LogicOperator.lessOrEqualThan:
+                        qbOr.andWhere(`${queryAlias}.${element} <= :${element}_${customId}`, {
+                            [`${element}_${customId}`]: value
+                        });
+                        break;
+                    case types_1.LogicOperator.in:
+                        qbOr.andWhere(`${queryAlias}.${element} IN :${element}_${customId}`, {
+                            [`${element}_${customId}`]: value
+                        });
+                        break;
+                    case types_1.LogicOperator.notIn:
+                        qbOr.andWhere(`${queryAlias}.${element} NOT IN :${element}_${customId}`, {
+                            [`${element}_${customId}`]: value
+                        });
+                        break;
+                    case types_1.LogicOperator.exists:
+                        qbOr.andWhere(`${queryAlias}.${element} IS NOT NULL`);
+                        break;
+                    case types_1.LogicOperator.notExists:
+                        qbOr.andWhere(`${queryAlias}.${element} IS NULL`);
+                        break;
+                    case types_1.LogicOperator.regexp:
+                        qbOr.andWhere(`${queryAlias}.${element} LIKE :${element}_${customId}`, {
+                            [`${element}_${customId}`]: value
+                        });
+                        break;
+                }
+            }
+        }));
+    }));
+    return queryBuilder;
+};
+exports.getQueryBuilderWhere = getQueryBuilderWhere;

package/dist/TypeOrmConnector/queryBuilder/sql/getTypeOrmWhere.d.ts

@@ -0,0 +1,6 @@
+import { FindManyOptions } from 'typeorm';
+import { AnyObject, FluentQuery } from '../../../types';
+export interface getTypeOrmWhereParams {
+    where?: FluentQuery<AnyObject>['where'];
+}
+export declare const getTypeOrmWhere: ({ where }: getTypeOrmWhereParams) => FindManyOptions['where'];

package/dist/TypeOrmConnector/queryBuilder/sql/getTypeOrmWhere.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeOrmWhere = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const typeorm_1 = require("typeorm");
+const clearEmpties_1 = require("../..//util/clearEmpties");
+const types_1 = require("../../../types");
+const extractConditions_1 = require("../../util/extractConditions");
+const getTypeOrmWhere = ({ where }) => {
+    if (!where || Object.keys(where).length === 0) {
+        return {};
+    }
+    const Filters = { where: [{}] };
+    const orConditions = (0, extractConditions_1.extractConditions)(where['OR']);
+    const andConditions = (0, extractConditions_1.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 = (0, extractConditions_1.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 = (0, clearEmpties_1.clearEmpties)(Filters.where);
+    return filtered;
+};
+exports.getTypeOrmWhere = getTypeOrmWhere;

package/dist/TypeOrmConnector/test/advanced/advancedTestSuite.d.ts

@@ -0,0 +1 @@
+export declare const advancedTestSuite: (Model: any) => void;