@goatlab/fluent 0.7.21 → 0.7.22

package/dist/TypeOrmConnector/TypeOrmConnector.js

@@ -0,0 +1,370 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmConnector = void 0;
+const js_utils_1 = require("@goatlab/js-utils");
+const BaseConnector_1 = require("../BaseConnector");
+const outputKeys_1 = require("../outputKeys");
+const generatorDatasource_1 = require("../generatorDatasource");
+const getMongoWhere_1 = require("./queryBuilder/mongodb/getMongoWhere");
+const getRelationsFromModelGenerator_1 = require("./util/getRelationsFromModelGenerator");
+const getMongoFindAggregatedQuery_1 = require("./queryBuilder/mongodb/getMongoFindAggregatedQuery");
+const extractInclude_1 = require("./util/extractInclude");
+const extractOrderBy_1 = require("./util/extractOrderBy");
+const getTypeOrmWhere_1 = require("./queryBuilder/sql/getTypeOrmWhere");
+const getQueryBuilderWhere_1 = require("./queryBuilder/sql/getQueryBuilderWhere");
+const clearEmpties_1 = require("./util/clearEmpties");
+class TypeOrmConnector extends BaseConnector_1.BaseConnector {
+    constructor({ entity, dataSource, inputSchema, outputSchema }) {
+        super();
+        this.dataSource = dataSource;
+        this.inputSchema = inputSchema;
+        this.outputSchema =
+            outputSchema || inputSchema;
+        this.entity = entity;
+        this.repository = this.dataSource.getRepository(entity);
+        this.isMongoDB =
+            this.repository.metadata.connection.driver.options.type === 'mongodb';
+        if (this.isMongoDB) {
+            this.repository = this.dataSource.getMongoRepository(entity);
+        }
+        const relationShipBuilder = generatorDatasource_1.modelGeneratorDataSource.getRepository(entity);
+        const { relations } = (0, getRelationsFromModelGenerator_1.getRelationsFromModelGenerator)(relationShipBuilder);
+        this.modelRelations = relations;
+        this.outputKeys = (0, outputKeys_1.getOutputKeys)(relationShipBuilder) || [];
+    }
+    async insert(data) {
+        const validatedData = this.inputSchema.parse(data);
+        if (this.isMongoDB && validatedData['id']) {
+            validatedData['_id'] = js_utils_1.Ids.objectID(validatedData['id']);
+            delete validatedData['id'];
+        }
+        let datum = await this.repository.save(validatedData);
+        if (this.isMongoDB) {
+            datum['id'] = datum['id'].toString();
+        }
+        return this.outputSchema.parse((0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(datum)));
+    }
+    async insertMany(data) {
+        const validatedData = this.inputSchema.array().parse(data);
+        const inserted = await this.repository.save(validatedData, {
+            chunk: data.length / 300
+        });
+        return this.outputSchema.array().parse(inserted.map(d => {
+            if (this.isMongoDB) {
+                d['id'] = d['id'].toString();
+            }
+            return (0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(d));
+        }));
+    }
+    async findMany(query) {
+        const requiresCustomQuery = query?.include && Object.keys(query.include).length;
+        if (this.isMongoDB) {
+            const results = await this.customMongoRelatedFind(query);
+            return results;
+        }
+        if (requiresCustomQuery) {
+            const { queryBuilder: customQuery, selectedKeys } = this.customTypeOrmRelatedFind({
+                fluentQuery: query
+            });
+            customQuery.select(selectedKeys);
+            let [result, count] = await customQuery.getManyAndCount();
+            return result;
+        }
+        const generatedQuery = this.generateTypeOrmQuery(query);
+        let [found, count] = await this.repository.findAndCount(generatedQuery);
+        found.map(d => {
+            if (this.isMongoDB) {
+                d['id'] = d['_id'].toString();
+            }
+            (0, clearEmpties_1.clearEmpties)(js_utils_1.Objects.deleteNulls(d));
+        });
+        if (query?.paginated) {
+            const paginationInfo = {
+                total: count,
+                perPage: query.paginated.perPage,
+                currentPage: query.paginated.page,
+                nextPage: query.paginated.page + 1,
+                firstPage: 1,
+                lastPage: Math.ceil(count / query.paginated.perPage),
+                prevPage: query.paginated.page === 1 ? null : query.paginated.page - 1,
+                from: (query.paginated.page - 1) * query.paginated.perPage + 1,
+                to: query.paginated.perPage * query.paginated.page,
+                data: found
+            };
+            return paginationInfo;
+        }
+        if (query?.select) {
+            return found;
+        }
+        return this.outputSchema?.array().parse(found);
+    }
+    async updateById(id, data) {
+        const dataToInsert = this.outputKeys.includes('updated')
+            ? {
+                ...data,
+                ...{ updated: new Date() }
+            }
+            : data;
+        const validatedData = this.inputSchema.parse(dataToInsert);
+        await this.repository.update(id, validatedData);
+        return (await this.requireById(id));
+    }
+    async replaceById(id, data) {
+        const idFieldName = this.isMongoDB ? '_id' : 'id';
+        const value = this.requireById(id);
+        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);
+        await this.repository.update(id, validatedData);
+        return (await this.requireById(id));
+    }
+    async deleteById(id) {
+        const parsedId = this.isMongoDB
+            ? js_utils_1.Ids.objectID(id)
+            : id;
+        await this.repository.delete(parsedId);
+        return id;
+    }
+    async clear() {
+        await this.repository.clear();
+        return true;
+    }
+    loadFirst(query) {
+        const newInstance = this.clone();
+        newInstance.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query: {
+                ...query,
+                limit: 1
+            }
+        });
+        return newInstance;
+    }
+    loadById(id) {
+        const newInstance = this.clone();
+        newInstance.setRelatedQuery({
+            entity: this.entity,
+            repository: this,
+            query: {
+                where: {
+                    id
+                }
+            }
+        });
+        return newInstance;
+    }
+    raw() {
+        return this.repository;
+    }
+    mongoRaw() {
+        return this.repository;
+    }
+    clone() {
+        return new this.constructor();
+    }
+    generateTypeOrmQuery(query) {
+        let filter = {};
+        filter.where = this.isMongoDB
+            ? (0, getMongoWhere_1.getMongoWhere)({
+                where: query?.where
+            })
+            : (0, getTypeOrmWhere_1.getTypeOrmWhere)({
+                where: query?.where
+            });
+        filter.take = query?.limit;
+        filter.skip = query?.offset;
+        if (query?.paginated) {
+            filter.take = query.paginated.perPage;
+            filter.skip = (query.paginated?.page - 1) * query?.paginated.perPage;
+        }
+        if (query?.select) {
+            const selectQuery = js_utils_1.Objects.flatten(query?.select || {});
+            filter.select = selectQuery;
+        }
+        if (query?.orderBy) {
+            filter.order = (0, extractOrderBy_1.extractOrderBy)(query.orderBy);
+        }
+        if (query?.include) {
+            filter.relations = (0, extractInclude_1.extractInclude)(query.include);
+        }
+        return filter;
+    }
+    customTypeOrmRelatedFind({ fluentQuery: query, queryBuilder, targetFluentRepository, alias, isLeftJoin }) {
+        const queryAlias = alias || queryBuilder?.alias || `${this.repository.metadata.tableName}`;
+        let customQuery = queryBuilder || this.raw().createQueryBuilder(queryAlias);
+        const self = targetFluentRepository || this;
+        if (!isLeftJoin) {
+            customQuery = (0, getQueryBuilderWhere_1.getQueryBuilderWhere)({
+                queryBuilder: customQuery,
+                queryAlias,
+                where: query?.where
+            });
+        }
+        const { queryBuilder: qb, selectedKeys } = this.getTypeOrmQueryBuilderSubqueries({
+            queryBuilder: customQuery,
+            selfReference: targetFluentRepository,
+            include: query?.include,
+            leftTableAlias: alias
+        });
+        customQuery = qb;
+        const extraKeys = this.getTypeOrmQueryBuilderSelect(queryAlias, self, query?.select);
+        const keySet = new Set([...selectedKeys, ...extraKeys]);
+        return {
+            queryBuilder: customQuery,
+            selectedKeys: Array.from(keySet)
+        };
+    }
+    getTypeOrmQueryBuilderSelect(queryAlias, self, select) {
+        const selected = js_utils_1.Objects.flatten(select || {});
+        const selectedKeys = [];
+        const iterableKeys = Object.keys(selected).length
+            ? Object.keys(selected)
+            : self.outputKeys || [];
+        const baseNestedKeys = new Set();
+        for (const key of iterableKeys) {
+            const keyArray = key.split('.');
+            if (keyArray.length <= 1) {
+                continue;
+            }
+            const total = keyArray.length;
+            for (const [index, val] of keyArray.entries()) {
+                if (total === index + 1) {
+                    continue;
+                }
+                let excludedField = '';
+                if (excludedField) {
+                    excludedField = `${excludedField}.${excludedField}${val}`;
+                }
+                excludedField = `${excludedField}${val}`;
+                baseNestedKeys.add(excludedField);
+            }
+        }
+        for (const k of iterableKeys) {
+            const field = k.includes('.') ? js_utils_1.Strings.camel(`${k}`) : k;
+            const search = `${queryAlias}.${field}`;
+            let isNestedRelation = false;
+            for (const item of k.split('.')) {
+                if (!!self[item]) {
+                    isNestedRelation = true;
+                    break;
+                }
+            }
+            if (!!self[field] || !!self[queryAlias] || isNestedRelation) {
+                continue;
+            }
+            if (baseNestedKeys.has(field)) {
+                continue;
+            }
+            selectedKeys.push(search);
+        }
+        return selectedKeys;
+    }
+    getTypeOrmQueryBuilderSubqueries({ queryBuilder, selfReference, include, leftTableAlias }) {
+        const selectedKeys = [];
+        if (!include) {
+            return { queryBuilder, selectedKeys };
+        }
+        for (const relation of Object.keys(include)) {
+            const self = selfReference || this;
+            const dbRelation = self.modelRelations[relation];
+            const newSelf = self[relation]();
+            const fluentRelatedQuery = include[relation] === true ? {} : include[relation];
+            if (!dbRelation) {
+                throw new Error(`The relation ${relation} is not properly defined. Check your entity and repository`);
+            }
+            const selectedKeysArray = fluentRelatedQuery.select
+                ? Object.keys(js_utils_1.Objects.flatten(fluentRelatedQuery.select))
+                : [];
+            if (dbRelation.isManyToOne) {
+                const leftSideTableName = leftTableAlias || queryBuilder.alias;
+                const leftSideForeignKey = `${leftSideTableName}.${dbRelation.joinColumns[0].propertyPath}`;
+                const rightSideTableName = `${leftSideTableName}_${relation}`;
+                const rightSidePrimaryKey = `${rightSideTableName}.id`;
+                const keys = new Set(selectedKeysArray.map(k => `${rightSideTableName}.${k}`));
+                selectedKeys.push(...Array.from(keys));
+                const shallowQuery = { ...fluentRelatedQuery };
+                delete shallowQuery['include'];
+                const { queryBuilder: leftJoinBuilder, selectedKeys: deepkeys } = this.customTypeOrmRelatedFind({
+                    queryBuilder: this.raw().createQueryBuilder(rightSideTableName),
+                    fluentQuery: shallowQuery,
+                    targetFluentRepository: newSelf,
+                    alias: rightSideTableName
+                });
+                selectedKeys.push(...deepkeys);
+                const joinQuery = leftJoinBuilder.getQuery().split('WHERE');
+                const customLeftJoin = joinQuery && joinQuery[1] ? joinQuery[1].trim() : '1=1';
+                const leftJoinParams = leftJoinBuilder.getParameters();
+                queryBuilder.leftJoinAndMapOne(`${leftSideTableName}.${relation}`, dbRelation.targetClass, rightSideTableName, `(${leftSideForeignKey} = ${rightSidePrimaryKey} AND  ${customLeftJoin} )`, leftJoinParams);
+                const { queryBuilder: qb, selectedKeys: k } = this.customTypeOrmRelatedFind({
+                    queryBuilder,
+                    fluentQuery: fluentRelatedQuery,
+                    targetFluentRepository: newSelf,
+                    alias: rightSideTableName,
+                    isLeftJoin: true
+                });
+                selectedKeys.push(...k);
+                queryBuilder = qb;
+            }
+            if (dbRelation.isOneToMany) {
+                const leftSideTableName = leftTableAlias || queryBuilder.alias;
+                const leftSidePrimaryKey = `${leftSideTableName}.id`;
+                const rightSideTableName = `${leftSideTableName}_${relation}`;
+                const rightSideForeignKey = `${rightSideTableName}.${dbRelation.inverseSidePropertyPath}`;
+                const keys = new Set(selectedKeysArray.map(k => `${rightSideTableName}.${k}`));
+                selectedKeys.push(...Array.from(keys));
+                const shallowQuery = { ...fluentRelatedQuery };
+                delete shallowQuery['include'];
+                const { queryBuilder: leftJoinBuilder, selectedKeys: deepKeys } = this.customTypeOrmRelatedFind({
+                    queryBuilder: this.raw().createQueryBuilder(rightSideTableName),
+                    fluentQuery: shallowQuery,
+                    targetFluentRepository: newSelf,
+                    alias: rightSideTableName
+                });
+                selectedKeys.push(...deepKeys);
+                const joinQuery = leftJoinBuilder.getQuery().split('WHERE');
+                const customLeftJoin = joinQuery && joinQuery[1] ? joinQuery[1].trim() : '1=1';
+                const leftJoinParams = leftJoinBuilder.getParameters();
+                queryBuilder.leftJoinAndMapMany(`${leftSideTableName}.${relation}`, dbRelation.targetClass, rightSideTableName, `(${leftSidePrimaryKey} = ${rightSideForeignKey} AND ${customLeftJoin} )`, leftJoinParams);
+                const { queryBuilder: q, selectedKeys: k } = this.customTypeOrmRelatedFind({
+                    queryBuilder,
+                    fluentQuery: fluentRelatedQuery,
+                    targetFluentRepository: newSelf,
+                    alias: rightSideTableName,
+                    isLeftJoin: true
+                });
+                selectedKeys.push(...k);
+                queryBuilder = q;
+            }
+        }
+        return { queryBuilder, selectedKeys };
+    }
+    async customMongoRelatedFind(query) {
+        const aggregate = (0, getMongoFindAggregatedQuery_1.getMongoFindAggregatedQuery)({
+            query,
+            self: this
+        });
+        const raw = await this.mongoRaw().aggregate(aggregate).toArray();
+        if (query?.select) {
+            return this.outputSchema['deepPartial']()
+                .array()
+                .parse(raw);
+        }
+        return this.outputSchema?.array().parse(raw);
+    }
+}
+exports.TypeOrmConnector = TypeOrmConnector;

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,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMongoFindAggregatedQuery = void 0;
+const getMongoBaseAggregations_1 = require("./getMongoBaseAggregations");
+const getMongoOrderBy_1 = require("./getMongoOrderBy");
+const getMongoSelect_1 = require("./getMongoSelect");
+const getMongoWhere_1 = require("./getMongoWhere");
+const getMongoFindAggregatedQuery = ({ query, self }) => {
+    const selected = (0, getMongoSelect_1.getMongoSelect)(query?.select);
+    const orderBy = (0, getMongoOrderBy_1.getMongoOrderBy)(query?.orderBy);
+    const where = (0, getMongoWhere_1.getMongoWhere)({
+        where: query?.where
+    });
+    const baseAggregations = (0, getMongoBaseAggregations_1.getMongoBaseAggregation)({
+        include: query?.include,
+        self
+    });
+    const aggregate = [
+        {
+            $match: where
+        }
+    ];
+    if (orderBy) {
+        aggregate.push(orderBy);
+    }
+    if (!query?.include) {
+        aggregate.push({ $addFields: { id: { $toString: '$_id' } } });
+    }
+    if (query?.offset) {
+        aggregate.push({ $skip: query?.offset });
+    }
+    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/getMongoOrderBy.d.ts

@@ -0,0 +1,4 @@
+import { FluentQuery } from '../../../types';
+export declare const getMongoOrderBy: (orderBy?: FluentQuery<any>['orderBy']) => {
+    $sort: {};
+} | undefined;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMongoOrderBy = void 0;
+const extractOrderBy_1 = require("../../util/extractOrderBy");
+const getMongoOrderBy = (orderBy) => {
+    if (!orderBy) {
+        return undefined;
+    }
+    const order = (0, extractOrderBy_1.extractOrderBy)(orderBy);
+    const sort = {
+        $sort: {}
+    };
+    for (const key of Object.keys(order)) {
+        const val = order[key];
+        sort.$sort[key] = val === 'asc' ? 1 : -1;
+    }
+    return sort;
+};
+exports.getMongoOrderBy = getMongoOrderBy;

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'];