@goatlab/fluent 0.7.6 → 0.7.11

package/dist/TypeOrmConnector/queryBuilder/mongodb/getMongoBaseAggregations.d.ts

@@ -0,0 +1,7 @@
+import { AnyObject, FluentQuery } from '../../../types';
+export interface getMongoBaseAggregationParams {
+    include: FluentQuery<AnyObject>['include'];
+    self: any;
+    alias?: string;
+}
+export declare const getMongoBaseAggregation: ({ include, self }: getMongoBaseAggregationParams) => any[];

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

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMongoBaseAggregation = void 0;
+const getMongoWhere_1 = require("./getMongoWhere");
+const getMongoBaseAggregation = ({ include, self }) => {
+    if (!include) {
+        return [];
+    }
+    const modelRelations = self.modelRelations;
+    const aggregations = [];
+    for (const relation of Object.keys(include)) {
+        if (!modelRelations[relation]) {
+            continue;
+        }
+        const innerLookups = [];
+        const dbRelation = modelRelations[relation];
+        if (include[relation]['include']) {
+            const newSelf = self[relation] && self[relation]();
+            const innerRelations = (0, exports.getMongoBaseAggregation)({
+                include: include[relation]['include'],
+                self: newSelf
+            });
+            innerLookups.push(...innerRelations);
+        }
+        const where = (0, getMongoWhere_1.getMongoWhere)({
+            where: include[relation]['where']
+        });
+        if (dbRelation.isManyToOne) {
+            const localField = dbRelation.joinColumns[0].propertyPath;
+            aggregations.push({
+                $addFields: {
+                    [`${localField}_object`]: { $toObjectId: `$${localField}` }
+                }
+            });
+            aggregations.push({ $addFields: { id: { $toString: '$_id' } } });
+            aggregations.push({
+                $lookup: {
+                    from: dbRelation.tableName,
+                    localField: `${localField}_object`,
+                    foreignField: '_id',
+                    as: dbRelation.propertyName,
+                    pipeline: [
+                        {
+                            $match: where
+                        },
+                        { $addFields: { id: { $toString: '$_id' } } },
+                        ...innerLookups
+                    ]
+                }
+            });
+            aggregations.push({
+                $unwind: {
+                    path: `$${dbRelation.propertyName}`,
+                    preserveNullAndEmptyArrays: true
+                }
+            });
+        }
+        if (dbRelation.isOneToMany) {
+            aggregations.push({ $addFields: { string_id: { $toString: '$_id' } } });
+            aggregations.push({ $addFields: { id: { $toString: '$_id' } } });
+            aggregations.push({
+                $lookup: {
+                    from: dbRelation.tableName,
+                    localField: 'string_id',
+                    foreignField: dbRelation.inverseSidePropertyPath,
+                    as: dbRelation.propertyName,
+                    pipeline: [
+                        {
+                            $match: where
+                        },
+                        { $addFields: { id: { $toString: '$_id' } } },
+                        ...innerLookups
+                    ]
+                }
+            });
+        }
+        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}`);
+            }
+            aggregations.push({ $addFields: { id: { $toString: '$_id' } } });
+            aggregations.push({
+                $addFields: { parent_string_id: { $toString: '$_id' } }
+            });
+            aggregations.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: [
+                                    {
+                                        $match: where
+                                    },
+                                    { $addFields: { id: { $toString: '$_id' } } }
+                                ],
+                                as: dbRelation.propertyName
+                            }
+                        },
+                        {
+                            $unwind: {
+                                path: `$${dbRelation.propertyName}`,
+                                preserveNullAndEmptyArrays: true
+                            }
+                        },
+                        {
+                            $project: {
+                                [dbRelation.propertyName]: `$${dbRelation.propertyName}`,
+                                pivot: '$$ROOT'
+                            }
+                        },
+                        {
+                            $replaceRoot: {
+                                newRoot: {
+                                    $mergeObjects: ['$$ROOT', `$${dbRelation.propertyName}`]
+                                }
+                            }
+                        },
+                        { $project: { [dbRelation.propertyName]: 0 } }
+                    ]
+                }
+            });
+        }
+    }
+    return aggregations;
+};
+exports.getMongoBaseAggregation = getMongoBaseAggregation;

package/dist/TypeOrmConnector/queryBuilder/mongodb/getMongoFindAggregatedQuery.d.ts

@@ -0,0 +1,6 @@
+import { FluentQuery } from '../../../types';
+export declare type getFindAggregateQueryParams<T extends FluentQuery<any>> = {
+    query?: T;
+    self?: any;
+};
+export declare const getMongoFindAggregatedQuery: ({ query, self }: getFindAggregateQueryParams<any>) => any[];

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMongoFindAggregatedQuery = void 0;
+const getMongoBaseAggregations_1 = require("./getMongoBaseAggregations");
+const getMongoSelect_1 = require("./getMongoSelect");
+const getMongoWhere_1 = require("./getMongoWhere");
+const getMongoFindAggregatedQuery = ({ query, self }) => {
+    const selected = (0, getMongoSelect_1.getMongoSelect)(query?.select);
+    const where = (0, getMongoWhere_1.getMongoWhere)({
+        where: query?.where
+    });
+    const baseAggregations = (0, getMongoBaseAggregations_1.getMongoBaseAggregation)({
+        include: query?.include,
+        self
+    });
+    const aggregate = [
+        {
+            $match: where
+        }
+    ];
+    if (query?.limit) {
+        aggregate.push({ $limit: query.limit });
+    }
+    for (const lookup of baseAggregations) {
+        aggregate.push(lookup);
+    }
+    if (selected && Object.keys(selected).length) {
+        aggregate.push({
+            $project: selected
+        });
+    }
+    return aggregate;
+};
+exports.getMongoFindAggregatedQuery = getMongoFindAggregatedQuery;

package/dist/TypeOrmConnector/queryBuilder/mongodb/getMongoSelect.d.ts

@@ -0,0 +1,4 @@
+import { FluentQuery } from '../../../types';
+export declare const getMongoSelect: (select: FluentQuery<any>['select']) => {
+    [key: string]: any;
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMongoSelect = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const getMongoSelect = (select) => {
+    const selected = js_utils_1.Objects.flatten(select || {});
+    for (const k of Object.keys(selected)) {
+        selected[k] = 1;
+    }
+    return selected;
+};
+exports.getMongoSelect = getMongoSelect;

package/dist/TypeOrmConnector/queryBuilder/mongodb/getMongoWhere.d.ts

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

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 = {
+        where: { $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.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 = (0, clearEmpties_1.clearEmpties)(Filters.where);
+    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'];