typeorm 0.3.0-rc.9 → 0.3.0

package/browser/find-options/FindOptionsUtils.js

@@ -1,110 +1,315 @@
-import * as tslib_1 from "tslib";
-import { Any, Between, Equal, ILike, In, LessThan, Like, MoreThan, Not, Raw } from "..";
-import { FindOperator } from "./FindOperator";
+import { FindRelationsNotFoundError } from "../error/FindRelationsNotFoundError";
+import { DriverUtils } from "../driver/DriverUtils";
 /**
  * Utilities to work with FindOptions.
  */
-var FindOptionsUtils = /** @class */ (function () {
-    function FindOptionsUtils() {
-    }
+export class FindOptionsUtils {
+    // -------------------------------------------------------------------------
+    // Public Static Methods
+    // -------------------------------------------------------------------------
     /**
      * Checks if given object is really instance of FindOneOptions interface.
      */
-    FindOptionsUtils.isFindOptions = function (obj) {
-        var possibleOptions = obj;
-        return possibleOptions && (possibleOptions.select instanceof Object ||
-            possibleOptions.where instanceof Object ||
-            possibleOptions.relations instanceof Object ||
-            possibleOptions.order instanceof Object ||
-            possibleOptions.options instanceof Object ||
-            possibleOptions.cache instanceof Object ||
-            possibleOptions.lock instanceof Object ||
-            typeof possibleOptions.cache === "boolean" ||
-            typeof possibleOptions.cache === "number" ||
-            typeof possibleOptions.skip === "number" ||
-            typeof possibleOptions.take === "number" ||
-            typeof possibleOptions.skip === "string" ||
-            typeof possibleOptions.take === "string");
-    };
-    return FindOptionsUtils;
-}());
-export { FindOptionsUtils };
-/**
- * Normalizes find options.
- */
-export function normalizeFindOptions(options) {
-    var where = options.where;
-    if (!where)
-        return tslib_1.__assign({}, options);
-    if (!(where instanceof Object))
-        return tslib_1.__assign({}, options);
-    if (where instanceof FindOperator)
-        return tslib_1.__assign({}, options);
-    var recursively$FindOption = function (obj) {
-        var valueKeys = Object.keys(obj);
-        if (valueKeys.length === 1) {
-            var value = obj[valueKeys[0]];
-            if (value instanceof Object && !(value instanceof Array) && !(value instanceof Function))
-                value = recursively$FindOption(value);
-            if (valueKeys[0] === "$any") {
-                return Any(value);
-            }
-            else if (valueKeys[0] === "$between") {
-                return Between(value[0], value[1]);
-            }
-            else if (valueKeys[0] === "$equal") {
-                return Equal(value);
-            }
-            else if (valueKeys[0] === "$iLike") {
-                return ILike(value);
-            }
-            else if (valueKeys[0] === "$in") {
-                return In(value);
-            }
-            else if (valueKeys[0] === "$lessThan") {
-                return LessThan(value);
+    static isFindOneOptions(obj) {
+        const possibleOptions = obj;
+        return (possibleOptions &&
+            (Array.isArray(possibleOptions.select) ||
+                Array.isArray(possibleOptions.relations) ||
+                typeof possibleOptions.select === "object" ||
+                typeof possibleOptions.relations === "object" ||
+                typeof possibleOptions.where === "object" ||
+                // typeof possibleOptions.where === "string" ||
+                typeof possibleOptions.join === "object" ||
+                typeof possibleOptions.order === "object" ||
+                typeof possibleOptions.cache === "object" ||
+                typeof possibleOptions.cache === "boolean" ||
+                typeof possibleOptions.cache === "number" ||
+                typeof possibleOptions.comment === "string" ||
+                typeof possibleOptions.lock === "object" ||
+                typeof possibleOptions.loadRelationIds === "object" ||
+                typeof possibleOptions.loadRelationIds === "boolean" ||
+                typeof possibleOptions.loadEagerRelations === "boolean" ||
+                typeof possibleOptions.withDeleted === "boolean" ||
+                typeof possibleOptions.relationLoadStrategy === "string" ||
+                typeof possibleOptions.transaction === "boolean"));
+    }
+    /**
+     * Checks if given object is really instance of FindManyOptions interface.
+     */
+    static isFindManyOptions(obj) {
+        const possibleOptions = obj;
+        return (possibleOptions &&
+            (this.isFindOneOptions(possibleOptions) ||
+                typeof possibleOptions.skip ===
+                    "number" ||
+                typeof possibleOptions.take ===
+                    "number" ||
+                typeof possibleOptions.skip ===
+                    "string" ||
+                typeof possibleOptions.take ===
+                    "string"));
+    }
+    /**
+     * Checks if given object is really instance of FindOptions interface.
+     */
+    static extractFindManyOptionsAlias(object) {
+        if (this.isFindManyOptions(object) && object.join)
+            return object.join.alias;
+        return undefined;
+    }
+    /**
+     * Applies give find many options to the given query builder.
+
+    static applyFindManyOptionsOrConditionsToQueryBuilder<T>(qb: SelectQueryBuilder<T>, options: FindManyOptions<T>|Partial<T>|undefined): SelectQueryBuilder<T> {
+        if (this.isFindManyOptions(options))
+            return this.applyOptionsToQueryBuilder(qb, options);
+
+        if (options)
+            return qb.where(options);
+
+        return qb;
+    }*/
+    /**
+     * Applies give find options to the given query builder.
+
+    static applyOptionsToQueryBuilder<T>(qb: SelectQueryBuilder<T>, options: FindOneOptions<T>|FindManyOptions<T>|undefined): SelectQueryBuilder<T> {
+
+        // if options are not set then simply return query builder. This is made for simplicity of usage.
+        if (!options || (!this.isFindOneOptions(options) && !this.isFindManyOptions(options)))
+            return qb;
+
+        if (options.transaction === true) {
+            qb.expressionMap.useTransaction = true;
+        }
+
+        if (!qb.expressionMap.mainAlias || !qb.expressionMap.mainAlias.hasMetadata)
+            return qb;
+
+        const metadata = qb.expressionMap.mainAlias!.metadata;
+
+        // apply all options from FindOptions
+        if (options.comment) {
+            qb.comment(options.comment);
+        }
+
+        if (options.withDeleted) {
+            qb.withDeleted();
+        }
+
+        if (options.select) {
+            qb.select([]);
+            options.select.forEach(select => {
+                if (!metadata.hasColumnWithPropertyPath(`${select}`))
+                    throw new TypeORMError(`${select} column was not found in the ${metadata.name} entity.`);
+
+                const columns = metadata.findColumnsWithPropertyPath(`${select}`);
+
+                for (const column of columns) {
+                    qb.addSelect(qb.alias + "." + column.propertyPath);
+                }
+            });
+        }
+
+        if (options.relations) {
+            // Copy because `applyRelationsRecursively` modifies it
+            const allRelations = [...options.relations];
+            this.applyRelationsRecursively(qb, allRelations, qb.expressionMap.mainAlias!.name, qb.expressionMap.mainAlias!.metadata, "");
+            // recursive removes found relations from allRelations array
+            // if there are relations left in this array it means those relations were not found in the entity structure
+            // so, we give an exception about not found relations
+            if (allRelations.length > 0)
+                throw new FindRelationsNotFoundError(allRelations);
+        }
+
+        if (options.join) {
+            if (options.join.leftJoin)
+                Object.keys(options.join.leftJoin).forEach(key => {
+                    qb.leftJoin(options.join!.leftJoin![key], key);
+                });
+
+            if (options.join.innerJoin)
+                Object.keys(options.join.innerJoin).forEach(key => {
+                    qb.innerJoin(options.join!.innerJoin![key], key);
+                });
+
+            if (options.join.leftJoinAndSelect)
+                Object.keys(options.join.leftJoinAndSelect).forEach(key => {
+                    qb.leftJoinAndSelect(options.join!.leftJoinAndSelect![key], key);
+                });
+
+            if (options.join.innerJoinAndSelect)
+                Object.keys(options.join.innerJoinAndSelect).forEach(key => {
+                    qb.innerJoinAndSelect(options.join!.innerJoinAndSelect![key], key);
+                });
+        }
+
+        if (options.cache) {
+            if (options.cache instanceof Object) {
+                const cache = options.cache as { id: any, milliseconds: number };
+                qb.cache(cache.id, cache.milliseconds);
+            } else {
+                qb.cache(options.cache);
             }
-            else if (valueKeys[0] === "$like") {
-                return Like(value);
+        }
+
+        if (options.lock) {
+            if (options.lock.mode === "optimistic") {
+                qb.setLock(options.lock.mode, options.lock.version);
+            } else if (
+                options.lock.mode === "pessimistic_read" ||
+                options.lock.mode === "pessimistic_write" ||
+                options.lock.mode === "dirty_read" ||
+                options.lock.mode === "pessimistic_partial_write" ||
+                options.lock.mode === "pessimistic_write_or_fail" ||
+                options.lock.mode === "for_no_key_update"
+            ) {
+                const tableNames = options.lock.tables ? options.lock.tables.map((table) => {
+                    const tableAlias = qb.expressionMap.aliases.find((alias) => {
+                        return alias.metadata.tableNameWithoutPrefix === table;
+                    });
+                    if (!tableAlias) {
+                        throw new TypeORMError(`"${table}" is not part of this query`);
+                    }
+                    return qb.escape(tableAlias.name);
+                }) : undefined;
+                qb.setLock(options.lock.mode, undefined, tableNames);
             }
-            else if (valueKeys[0] === "$moreThan") {
-                return MoreThan(value);
+        }
+
+        if (options.loadRelationIds === true) {
+            qb.loadAllRelationIds();
+
+        } else if (options.loadRelationIds instanceof Object) {
+            qb.loadAllRelationIds(options.loadRelationIds as any);
+        }
+
+        if (options.where)
+            qb.where(options.where);
+
+        if ((options as FindManyOptions<T>).skip)
+            qb.skip((options as FindManyOptions<T>).skip!);
+
+        if ((options as FindManyOptions<T>).take)
+            qb.take((options as FindManyOptions<T>).take!);
+
+        if (options.order)
+            Object.keys(options.order).forEach(key => {
+                const order = ((options as FindOneOptions<T>).order as any)[key as any];
+
+                if (!metadata.findColumnWithPropertyPath(key))
+                    throw new Error(`${key} column was not found in the ${metadata.name} entity.`);
+
+                switch (order) {
+                    case 1:
+                        qb.addOrderBy(qb.alias + "." + key, "ASC");
+                        break;
+                    case -1:
+                        qb.addOrderBy(qb.alias + "." + key, "DESC");
+                        break;
+                    case "ASC":
+                        qb.addOrderBy(qb.alias + "." + key, "ASC");
+                        break;
+                    case "DESC":
+                        qb.addOrderBy(qb.alias + "." + key, "DESC");
+                        break;
+                }
+            });
+
+        return qb;
+    }*/
+    static applyOptionsToTreeQueryBuilder(qb, options) {
+        if (options === null || options === void 0 ? void 0 : options.relations) {
+            // Copy because `applyRelationsRecursively` modifies it
+            const allRelations = [...options.relations];
+            FindOptionsUtils.applyRelationsRecursively(qb, allRelations, qb.expressionMap.mainAlias.name, qb.expressionMap.mainAlias.metadata, "");
+            // recursive removes found relations from allRelations array
+            // if there are relations left in this array it means those relations were not found in the entity structure
+            // so, we give an exception about not found relations
+            if (allRelations.length > 0)
+                throw new FindRelationsNotFoundError(allRelations);
+        }
+        return qb;
+    }
+    // -------------------------------------------------------------------------
+    // Protected Static Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Adds joins for all relations and sub-relations of the given relations provided in the find options.
+     */
+    static applyRelationsRecursively(qb, allRelations, alias, metadata, prefix) {
+        // find all relations that match given prefix
+        let matchedBaseRelations = [];
+        if (prefix) {
+            const regexp = new RegExp("^" + prefix.replace(".", "\\.") + "\\.");
+            matchedBaseRelations = allRelations
+                .filter((relation) => relation.match(regexp))
+                .map((relation) => relation.replace(regexp, ""))
+                .filter((relation) => metadata.findRelationWithPropertyPath(relation));
+        }
+        else {
+            matchedBaseRelations = allRelations.filter((relation) => metadata.findRelationWithPropertyPath(relation));
+        }
+        // go through all matched relations and add join for them
+        matchedBaseRelations.forEach((relation) => {
+            // generate a relation alias
+            let relationAlias = DriverUtils.buildAlias(qb.connection.driver, { joiner: "__" }, alias, relation);
+            // add a join for the found relation
+            const selection = alias + "." + relation;
+            qb.leftJoinAndSelect(selection, relationAlias);
+            // remove added relations from the allRelations array, this is needed to find all not found relations at the end
+            allRelations.splice(allRelations.indexOf(prefix ? prefix + "." + relation : relation), 1);
+            // try to find sub-relations
+            const join = qb.expressionMap.joinAttributes.find((join) => join.entityOrProperty === selection);
+            this.applyRelationsRecursively(qb, allRelations, join.alias.name, join.metadata, prefix ? prefix + "." + relation : relation);
+            // join the eager relations of the found relation
+            const relMetadata = metadata.relations.find((metadata) => metadata.propertyName === relation);
+            if (relMetadata) {
+                this.joinEagerRelations(qb, relationAlias, relMetadata.inverseEntityMetadata);
             }
-            else if (valueKeys[0] === "$not") {
-                return Not(value);
+        });
+    }
+    static joinEagerRelations(qb, alias, metadata) {
+        metadata.eagerRelations.forEach((relation) => {
+            // generate a relation alias
+            let relationAlias = DriverUtils.buildAlias(qb.connection.driver, qb.connection.namingStrategy.eagerJoinRelationAlias(alias, relation.propertyPath));
+            // add a join for the relation
+            // Checking whether the relation wasn't joined yet.
+            let addJoin = true;
+            for (const join of qb.expressionMap.joinAttributes) {
+                if (join.condition !== undefined ||
+                    join.mapToProperty !== undefined ||
+                    join.isMappingMany !== undefined ||
+                    join.direction !== "LEFT" ||
+                    join.entityOrProperty !==
+                        `${alias}.${relation.propertyPath}`) {
+                    continue;
+                }
+                addJoin = false;
+                relationAlias = join.alias.name;
+                break;
             }
-            else if (valueKeys[0] === "$raw") {
-                return Raw(value);
+            if (addJoin) {
+                qb.leftJoin(alias + "." + relation.propertyPath, relationAlias);
             }
-        }
-        return false;
-    };
-    var recursivelyWhere = function (where) {
-        if (where instanceof Array)
-            return where.map(function (where) { return recursivelyWhere(where); });
-        return Object.keys(where).reduce(function (newWhere, key) {
-            if (where[key] instanceof Object && !(where[key] instanceof FindOperator)) {
-                newWhere[key] = recursively$FindOption(where[key]);
-                // in the case if $find operator was not found we'll have a false as a value
-                // we need to recursive where because it can be another where options
-                if (newWhere[key] === false)
-                    newWhere[key] = recursivelyWhere(where[key]);
+            // Checking whether the relation wasn't selected yet.
+            // This check shall be after the join check to detect relationAlias.
+            let addSelect = true;
+            for (const select of qb.expressionMap.selects) {
+                if (select.aliasName !== undefined ||
+                    select.virtual !== undefined ||
+                    select.selection !== relationAlias) {
+                    continue;
+                }
+                addSelect = false;
+                break;
             }
-            else {
-                newWhere[key] = where[key];
+            if (addSelect) {
+                qb.addSelect(relationAlias);
             }
-            return newWhere;
-        }, {});
-    };
-    // todo: broken after merge
-    // if (options.lock) {
-    //     if (options.lock.mode === "optimistic") {
-    //         qb.setLock(options.lock.mode, options.lock.version as any);
-    //     } else if (options.lock.mode === "pessimistic_read" || options.lock.mode === "pessimistic_write") {
-    //         qb.setLock(options.lock.mode);
-    //     }
-    // }
-    return tslib_1.__assign({}, options, { where: recursivelyWhere(options.where) });
+            // (recursive) join the eager relations
+            this.joinEagerRelations(qb, relationAlias, relation.inverseEntityMetadata);
+        });
+    }
 }
 
 //# sourceMappingURL=FindOptionsUtils.js.map

package/browser/find-options/FindOptionsUtils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../browser/src/find-options/FindOptionsUtils.ts"],"names":[],"mappings":"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","file":"FindOptionsUtils.js","sourcesContent":["import {Any, Between, Equal, ILike, In, LessThan, Like, MoreThan, Not, Raw} from \"..\";\nimport {FindOperator} from \"./FindOperator\";\nimport {FindOptions} from \"./FindOptions\";\n\n/**\n * Utilities to work with FindOptions.\n */\nexport class FindOptionsUtils {\n\n    /**\n     * Checks if given object is really instance of FindOneOptions interface.\n     */\n    static isFindOptions(obj: any): obj is FindOptions<any> {\n        const possibleOptions: FindOptions<any> = obj;\n        return possibleOptions && (\n            possibleOptions.select instanceof Object ||\n            possibleOptions.where instanceof Object ||\n            possibleOptions.relations instanceof Object ||\n            possibleOptions.order instanceof Object ||\n            possibleOptions.options instanceof Object ||\n            possibleOptions.cache instanceof Object ||\n            possibleOptions.lock instanceof Object ||\n            typeof possibleOptions.cache === \"boolean\" ||\n            typeof possibleOptions.cache === \"number\" ||\n            typeof possibleOptions.skip === \"number\" ||\n            typeof possibleOptions.take === \"number\" ||\n            typeof possibleOptions.skip === \"string\" ||\n            typeof possibleOptions.take === \"string\"\n        );\n    }\n\n}\n\n/**\n * Normalizes find options.\n */\nexport function normalizeFindOptions<T>(options: FindOptions<T>): FindOptions<T> {\n\n    const where = options.where;\n    if (!where)\n        return { ...options };\n    if (!(where instanceof Object))\n        return { ...options };\n    if (where instanceof FindOperator)\n        return { ...options };\n\n    const recursively$FindOption = (obj: any) => {\n        const valueKeys = Object.keys(obj);\n        if (valueKeys.length === 1) {\n            let value = obj[valueKeys[0]];\n            if (value instanceof Object && !(value instanceof Array) && !(value instanceof Function))\n                value = recursively$FindOption(value);\n\n            if (valueKeys[0] === \"$any\") {\n                return Any(value);\n\n            } else if (valueKeys[0] === \"$between\") {\n                return Between(value[0], value[1]);\n\n            } else if (valueKeys[0] === \"$equal\") {\n                return Equal(value);\n\n            } else if (valueKeys[0] === \"$iLike\") {\n                return ILike(value);\n\n            } else if (valueKeys[0] === \"$in\") {\n                return In(value);\n\n            } else if (valueKeys[0] === \"$lessThan\") {\n                return LessThan(value);\n\n            } else if (valueKeys[0] === \"$like\") {\n                return Like(value);\n\n            } else if (valueKeys[0] === \"$moreThan\") {\n                return MoreThan(value);\n\n            } else if (valueKeys[0] === \"$not\") {\n                return Not(value);\n\n            } else if (valueKeys[0] === \"$raw\") {\n                return Raw(value);\n            }\n        }\n\n        return false;\n    };\n\n    const recursivelyWhere = <T extends any>(where: T): T => {\n\n        if (where instanceof Array)\n            return where.map((where: any) => recursivelyWhere(where));\n\n        return Object.keys(where).reduce((newWhere, key) => {\n            if (where[key] instanceof Object && !(where[key] instanceof FindOperator)) {\n                newWhere[key] = recursively$FindOption(where[key]);\n\n                // in the case if $find operator was not found we'll have a false as a value\n                // we need to recursive where because it can be another where options\n                if (newWhere[key] === false)\n                    newWhere[key] = recursivelyWhere(where[key]);\n\n            } else {\n                newWhere[key] = where[key];\n            }\n            return newWhere;\n        }, {} as T);\n    };\n\n    // todo: broken after merge\n    // if (options.lock) {\n    //     if (options.lock.mode === \"optimistic\") {\n    //         qb.setLock(options.lock.mode, options.lock.version as any);\n    //     } else if (options.lock.mode === \"pessimistic_read\" || options.lock.mode === \"pessimistic_write\") {\n    //         qb.setLock(options.lock.mode);\n    //     }\n    // }\n\n    return { ...options, where: recursivelyWhere(options.where!) };\n}\n"],"sourceRoot":".."}
+{"version":3,"sources":["../browser/src/find-options/FindOptionsUtils.ts"],"names":[],"mappings":"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","file":"FindOptionsUtils.js","sourcesContent":["import { FindManyOptions } from \"./FindManyOptions\"\nimport { FindOneOptions } from \"./FindOneOptions\"\nimport { SelectQueryBuilder } from \"../query-builder/SelectQueryBuilder\"\nimport { FindRelationsNotFoundError } from \"../error/FindRelationsNotFoundError\"\nimport { EntityMetadata } from \"../metadata/EntityMetadata\"\nimport { DriverUtils } from \"../driver/DriverUtils\"\nimport { FindTreeOptions } from \"./FindTreeOptions\"\n\n/**\n * Utilities to work with FindOptions.\n */\nexport class FindOptionsUtils {\n    // -------------------------------------------------------------------------\n    // Public Static Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Checks if given object is really instance of FindOneOptions interface.\n     */\n    static isFindOneOptions<Entity = any>(\n        obj: any,\n    ): obj is FindOneOptions<Entity> {\n        const possibleOptions: FindOneOptions<Entity> = obj\n        return (\n            possibleOptions &&\n            (Array.isArray(possibleOptions.select) ||\n                Array.isArray(possibleOptions.relations) ||\n                typeof possibleOptions.select === \"object\" ||\n                typeof possibleOptions.relations === \"object\" ||\n                typeof possibleOptions.where === \"object\" ||\n                // typeof possibleOptions.where === \"string\" ||\n                typeof possibleOptions.join === \"object\" ||\n                typeof possibleOptions.order === \"object\" ||\n                typeof possibleOptions.cache === \"object\" ||\n                typeof possibleOptions.cache === \"boolean\" ||\n                typeof possibleOptions.cache === \"number\" ||\n                typeof possibleOptions.comment === \"string\" ||\n                typeof possibleOptions.lock === \"object\" ||\n                typeof possibleOptions.loadRelationIds === \"object\" ||\n                typeof possibleOptions.loadRelationIds === \"boolean\" ||\n                typeof possibleOptions.loadEagerRelations === \"boolean\" ||\n                typeof possibleOptions.withDeleted === \"boolean\" ||\n                typeof possibleOptions.relationLoadStrategy === \"string\" ||\n                typeof possibleOptions.transaction === \"boolean\")\n        )\n    }\n\n    /**\n     * Checks if given object is really instance of FindManyOptions interface.\n     */\n    static isFindManyOptions<Entity = any>(\n        obj: any,\n    ): obj is FindManyOptions<Entity> {\n        const possibleOptions: FindManyOptions<Entity> = obj\n        return (\n            possibleOptions &&\n            (this.isFindOneOptions(possibleOptions) ||\n                typeof (possibleOptions as FindManyOptions<any>).skip ===\n                    \"number\" ||\n                typeof (possibleOptions as FindManyOptions<any>).take ===\n                    \"number\" ||\n                typeof (possibleOptions as FindManyOptions<any>).skip ===\n                    \"string\" ||\n                typeof (possibleOptions as FindManyOptions<any>).take ===\n                    \"string\")\n        )\n    }\n\n    /**\n     * Checks if given object is really instance of FindOptions interface.\n     */\n    static extractFindManyOptionsAlias(object: any): string | undefined {\n        if (this.isFindManyOptions(object) && object.join)\n            return object.join.alias\n\n        return undefined\n    }\n\n    /**\n     * Applies give find many options to the given query builder.\n\n    static applyFindManyOptionsOrConditionsToQueryBuilder<T>(qb: SelectQueryBuilder<T>, options: FindManyOptions<T>|Partial<T>|undefined): SelectQueryBuilder<T> {\n        if (this.isFindManyOptions(options))\n            return this.applyOptionsToQueryBuilder(qb, options);\n\n        if (options)\n            return qb.where(options);\n\n        return qb;\n    }*/\n\n    /**\n     * Applies give find options to the given query builder.\n\n    static applyOptionsToQueryBuilder<T>(qb: SelectQueryBuilder<T>, options: FindOneOptions<T>|FindManyOptions<T>|undefined): SelectQueryBuilder<T> {\n\n        // if options are not set then simply return query builder. This is made for simplicity of usage.\n        if (!options || (!this.isFindOneOptions(options) && !this.isFindManyOptions(options)))\n            return qb;\n\n        if (options.transaction === true) {\n            qb.expressionMap.useTransaction = true;\n        }\n\n        if (!qb.expressionMap.mainAlias || !qb.expressionMap.mainAlias.hasMetadata)\n            return qb;\n\n        const metadata = qb.expressionMap.mainAlias!.metadata;\n\n        // apply all options from FindOptions\n        if (options.comment) {\n            qb.comment(options.comment);\n        }\n\n        if (options.withDeleted) {\n            qb.withDeleted();\n        }\n\n        if (options.select) {\n            qb.select([]);\n            options.select.forEach(select => {\n                if (!metadata.hasColumnWithPropertyPath(`${select}`))\n                    throw new TypeORMError(`${select} column was not found in the ${metadata.name} entity.`);\n\n                const columns = metadata.findColumnsWithPropertyPath(`${select}`);\n\n                for (const column of columns) {\n                    qb.addSelect(qb.alias + \".\" + column.propertyPath);\n                }\n            });\n        }\n\n        if (options.relations) {\n            // Copy because `applyRelationsRecursively` modifies it\n            const allRelations = [...options.relations];\n            this.applyRelationsRecursively(qb, allRelations, qb.expressionMap.mainAlias!.name, qb.expressionMap.mainAlias!.metadata, \"\");\n            // recursive removes found relations from allRelations array\n            // if there are relations left in this array it means those relations were not found in the entity structure\n            // so, we give an exception about not found relations\n            if (allRelations.length > 0)\n                throw new FindRelationsNotFoundError(allRelations);\n        }\n\n        if (options.join) {\n            if (options.join.leftJoin)\n                Object.keys(options.join.leftJoin).forEach(key => {\n                    qb.leftJoin(options.join!.leftJoin![key], key);\n                });\n\n            if (options.join.innerJoin)\n                Object.keys(options.join.innerJoin).forEach(key => {\n                    qb.innerJoin(options.join!.innerJoin![key], key);\n                });\n\n            if (options.join.leftJoinAndSelect)\n                Object.keys(options.join.leftJoinAndSelect).forEach(key => {\n                    qb.leftJoinAndSelect(options.join!.leftJoinAndSelect![key], key);\n                });\n\n            if (options.join.innerJoinAndSelect)\n                Object.keys(options.join.innerJoinAndSelect).forEach(key => {\n                    qb.innerJoinAndSelect(options.join!.innerJoinAndSelect![key], key);\n                });\n        }\n\n        if (options.cache) {\n            if (options.cache instanceof Object) {\n                const cache = options.cache as { id: any, milliseconds: number };\n                qb.cache(cache.id, cache.milliseconds);\n            } else {\n                qb.cache(options.cache);\n            }\n        }\n\n        if (options.lock) {\n            if (options.lock.mode === \"optimistic\") {\n                qb.setLock(options.lock.mode, options.lock.version);\n            } else if (\n                options.lock.mode === \"pessimistic_read\" ||\n                options.lock.mode === \"pessimistic_write\" ||\n                options.lock.mode === \"dirty_read\" ||\n                options.lock.mode === \"pessimistic_partial_write\" ||\n                options.lock.mode === \"pessimistic_write_or_fail\" ||\n                options.lock.mode === \"for_no_key_update\"\n            ) {\n                const tableNames = options.lock.tables ? options.lock.tables.map((table) => {\n                    const tableAlias = qb.expressionMap.aliases.find((alias) => {\n                        return alias.metadata.tableNameWithoutPrefix === table;\n                    });\n                    if (!tableAlias) {\n                        throw new TypeORMError(`\"${table}\" is not part of this query`);\n                    }\n                    return qb.escape(tableAlias.name);\n                }) : undefined;\n                qb.setLock(options.lock.mode, undefined, tableNames);\n            }\n        }\n\n        if (options.loadRelationIds === true) {\n            qb.loadAllRelationIds();\n\n        } else if (options.loadRelationIds instanceof Object) {\n            qb.loadAllRelationIds(options.loadRelationIds as any);\n        }\n\n        if (options.where)\n            qb.where(options.where);\n\n        if ((options as FindManyOptions<T>).skip)\n            qb.skip((options as FindManyOptions<T>).skip!);\n\n        if ((options as FindManyOptions<T>).take)\n            qb.take((options as FindManyOptions<T>).take!);\n\n        if (options.order)\n            Object.keys(options.order).forEach(key => {\n                const order = ((options as FindOneOptions<T>).order as any)[key as any];\n\n                if (!metadata.findColumnWithPropertyPath(key))\n                    throw new Error(`${key} column was not found in the ${metadata.name} entity.`);\n\n                switch (order) {\n                    case 1:\n                        qb.addOrderBy(qb.alias + \".\" + key, \"ASC\");\n                        break;\n                    case -1:\n                        qb.addOrderBy(qb.alias + \".\" + key, \"DESC\");\n                        break;\n                    case \"ASC\":\n                        qb.addOrderBy(qb.alias + \".\" + key, \"ASC\");\n                        break;\n                    case \"DESC\":\n                        qb.addOrderBy(qb.alias + \".\" + key, \"DESC\");\n                        break;\n                }\n            });\n\n        return qb;\n    }*/\n\n    static applyOptionsToTreeQueryBuilder<T>(\n        qb: SelectQueryBuilder<T>,\n        options?: FindTreeOptions,\n    ): SelectQueryBuilder<T> {\n        if (options?.relations) {\n            // Copy because `applyRelationsRecursively` modifies it\n            const allRelations = [...options.relations]\n\n            FindOptionsUtils.applyRelationsRecursively(\n                qb,\n                allRelations,\n                qb.expressionMap.mainAlias!.name,\n                qb.expressionMap.mainAlias!.metadata,\n                \"\",\n            )\n\n            // recursive removes found relations from allRelations array\n            // if there are relations left in this array it means those relations were not found in the entity structure\n            // so, we give an exception about not found relations\n            if (allRelations.length > 0)\n                throw new FindRelationsNotFoundError(allRelations)\n        }\n\n        return qb\n    }\n\n    // -------------------------------------------------------------------------\n    // Protected Static Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Adds joins for all relations and sub-relations of the given relations provided in the find options.\n     */\n    public static applyRelationsRecursively(\n        qb: SelectQueryBuilder<any>,\n        allRelations: string[],\n        alias: string,\n        metadata: EntityMetadata,\n        prefix: string,\n    ): void {\n        // find all relations that match given prefix\n        let matchedBaseRelations: string[] = []\n        if (prefix) {\n            const regexp = new RegExp(\"^\" + prefix.replace(\".\", \"\\\\.\") + \"\\\\.\")\n            matchedBaseRelations = allRelations\n                .filter((relation) => relation.match(regexp))\n                .map((relation) => relation.replace(regexp, \"\"))\n                .filter((relation) =>\n                    metadata.findRelationWithPropertyPath(relation),\n                )\n        } else {\n            matchedBaseRelations = allRelations.filter((relation) =>\n                metadata.findRelationWithPropertyPath(relation),\n            )\n        }\n\n        // go through all matched relations and add join for them\n        matchedBaseRelations.forEach((relation) => {\n            // generate a relation alias\n            let relationAlias: string = DriverUtils.buildAlias(\n                qb.connection.driver,\n                { joiner: \"__\" },\n                alias,\n                relation,\n            )\n\n            // add a join for the found relation\n            const selection = alias + \".\" + relation\n            qb.leftJoinAndSelect(selection, relationAlias)\n\n            // remove added relations from the allRelations array, this is needed to find all not found relations at the end\n            allRelations.splice(\n                allRelations.indexOf(\n                    prefix ? prefix + \".\" + relation : relation,\n                ),\n                1,\n            )\n\n            // try to find sub-relations\n            const join = qb.expressionMap.joinAttributes.find(\n                (join) => join.entityOrProperty === selection,\n            )\n            this.applyRelationsRecursively(\n                qb,\n                allRelations,\n                join!.alias.name,\n                join!.metadata!,\n                prefix ? prefix + \".\" + relation : relation,\n            )\n\n            // join the eager relations of the found relation\n            const relMetadata = metadata.relations.find(\n                (metadata) => metadata.propertyName === relation,\n            )\n            if (relMetadata) {\n                this.joinEagerRelations(\n                    qb,\n                    relationAlias,\n                    relMetadata.inverseEntityMetadata,\n                )\n            }\n        })\n    }\n\n    public static joinEagerRelations(\n        qb: SelectQueryBuilder<any>,\n        alias: string,\n        metadata: EntityMetadata,\n    ) {\n        metadata.eagerRelations.forEach((relation) => {\n            // generate a relation alias\n            let relationAlias = DriverUtils.buildAlias(\n                qb.connection.driver,\n                qb.connection.namingStrategy.eagerJoinRelationAlias(\n                    alias,\n                    relation.propertyPath,\n                ),\n            )\n\n            // add a join for the relation\n            // Checking whether the relation wasn't joined yet.\n            let addJoin = true\n            for (const join of qb.expressionMap.joinAttributes) {\n                if (\n                    join.condition !== undefined ||\n                    join.mapToProperty !== undefined ||\n                    join.isMappingMany !== undefined ||\n                    join.direction !== \"LEFT\" ||\n                    join.entityOrProperty !==\n                        `${alias}.${relation.propertyPath}`\n                ) {\n                    continue\n                }\n                addJoin = false\n                relationAlias = join.alias.name\n                break\n            }\n\n            if (addJoin) {\n                qb.leftJoin(alias + \".\" + relation.propertyPath, relationAlias)\n            }\n\n            // Checking whether the relation wasn't selected yet.\n            // This check shall be after the join check to detect relationAlias.\n            let addSelect = true\n            for (const select of qb.expressionMap.selects) {\n                if (\n                    select.aliasName !== undefined ||\n                    select.virtual !== undefined ||\n                    select.selection !== relationAlias\n                ) {\n                    continue\n                }\n                addSelect = false\n                break\n            }\n\n            if (addSelect) {\n                qb.addSelect(relationAlias)\n            }\n\n            // (recursive) join the eager relations\n            this.joinEagerRelations(\n                qb,\n                relationAlias,\n                relation.inverseEntityMetadata,\n            )\n        })\n    }\n}\n"],"sourceRoot":".."}

package/browser/find-options/FindOptionsWhere.d.ts

@@ -0,0 +1,14 @@
+
+import { FindOperator } from "./FindOperator";
+import { ObjectID } from "../driver/mongodb/typings";
+import { EqualOperator } from "./EqualOperator";
+/**
+ * A single property handler for FindOptionsWere.
+ */
+export declare type FindOptionsWhereProperty<Property> = Property extends Promise<infer I> ? FindOptionsWhereProperty<NonNullable<I>> : Property extends Array<infer I> ? FindOptionsWhereProperty<NonNullable<I>> : Property extends Function ? never : Property extends Buffer ? Property | FindOperator<Property> : Property extends Date ? Property | FindOperator<Property> : Property extends ObjectID ? Property | FindOperator<Property> : Property extends object ? FindOptionsWhere<Property> | FindOptionsWhere<Property>[] | EqualOperator<Property> | FindOperator<any> | boolean : Property | FindOperator<Property>;
+/** :
+ * Used for find operations.
+ */
+export declare type FindOptionsWhere<Entity> = {
+    [P in keyof Entity]?: FindOptionsWhereProperty<NonNullable<Entity[P]>>;
+};

package/browser/find-options/FindOptionsWhere.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=FindOptionsWhere.js.map

package/browser/find-options/FindOptionsWhere.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/find-options/FindOptionsWhere.ts"],"names":[],"mappings":"","file":"FindOptionsWhere.js","sourcesContent":["import { FindOperator } from \"./FindOperator\"\nimport { ObjectID } from \"../driver/mongodb/typings\"\nimport { EqualOperator } from \"./EqualOperator\"\n\n/**\n * A single property handler for FindOptionsWere.\n */\nexport type FindOptionsWhereProperty<Property> = Property extends Promise<\n    infer I\n>\n    ? FindOptionsWhereProperty<NonNullable<I>>\n    : Property extends Array<infer I>\n    ? FindOptionsWhereProperty<NonNullable<I>>\n    : Property extends Function\n    ? never\n    : Property extends Buffer\n    ? Property | FindOperator<Property>\n    : Property extends Date\n    ? Property | FindOperator<Property>\n    : Property extends ObjectID\n    ? Property | FindOperator<Property>\n    : Property extends object\n    ?\n          | FindOptionsWhere<Property>\n          | FindOptionsWhere<Property>[]\n          | EqualOperator<Property>\n          | FindOperator<any>\n          | boolean\n    : Property | FindOperator<Property>\n\n/** :\n * Used for find operations.\n */\nexport type FindOptionsWhere<Entity> = {\n    [P in keyof Entity]?: FindOptionsWhereProperty<NonNullable<Entity[P]>>\n}\n"],"sourceRoot":".."}

package/browser/find-options/FindTreeOptions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Defines a special criteria to find specific entities.
+ */
+export interface FindTreeOptions {
+    /**
+     * Indicates what relations of entity should be loaded (simplified left join form).
+     */
+    relations?: string[];
+    /**
+     * When loading a tree from a TreeRepository, limits the depth of the descendents loaded
+     */
+    depth?: number;
+}

package/browser/find-options/FindTreeOptions.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=FindTreeOptions.js.map

package/browser/find-options/FindTreeOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/find-options/FindTreeOptions.ts"],"names":[],"mappings":"","file":"FindTreeOptions.js","sourcesContent":["/**\n * Defines a special criteria to find specific entities.\n */\nexport interface FindTreeOptions {\n    /**\n     * Indicates what relations of entity should be loaded (simplified left join form).\n     */\n    relations?: string[]\n\n    /**\n     * When loading a tree from a TreeRepository, limits the depth of the descendents loaded\n     */\n    depth?: number\n}\n"],"sourceRoot":".."}

package/browser/find-options/JoinOptions.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Used to specify what entity relations should be loaded.
+ *
+ * Example:
+ *  const options: JoinOptions = {
+ *     alias: "photo",
+ *     leftJoin: {
+ *         author: "photo.author",
+ *         categories: "categories",
+ *         user: "categories.user",
+ *         profile: "user.profile"
+ *     },
+ *     innerJoin: {
+ *         author: "photo.author",
+ *         categories: "categories",
+ *         user: "categories.user",
+ *         profile: "user.profile"
+ *     },
+ *     leftJoinAndSelect: {
+ *         author: "photo.author",
+ *         categories: "categories",
+ *         user: "categories.user",
+ *         profile: "user.profile"
+ *     },
+ *     innerJoinAndSelect: {
+ *         author: "photo.author",
+ *         categories: "categories",
+ *         user: "categories.user",
+ *         profile: "user.profile"
+ *     }
+ * };
+ *
+ * @deprecated
+ */
+export interface JoinOptions {
+    /**
+     * Alias of the main entity.
+     */
+    alias: string;
+    /**
+     * Object where each key represents the LEFT JOIN alias,
+     * and the corresponding value represents the relation path.
+     *
+     * The columns of the joined table are included in the selection.
+     */
+    leftJoinAndSelect?: {
+        [key: string]: string;
+    };
+    /**
+     * Object where each key represents the INNER JOIN alias,
+     * and the corresponding value represents the relation path.
+     *
+     * The columns of the joined table are included in the selection.
+     */
+    innerJoinAndSelect?: {
+        [key: string]: string;
+    };
+    /**
+     * Object where each key represents the LEFT JOIN alias,
+     * and the corresponding value represents the relation path.
+     *
+     * This method does not select the columns of the joined table.
+     */
+    leftJoin?: {
+        [key: string]: string;
+    };
+    /**
+     * Object where each key represents the INNER JOIN alias,
+     * and the corresponding value represents the relation path.
+     *
+     * This method does not select the columns of the joined table.
+     */
+    innerJoin?: {
+        [key: string]: string;
+    };
+}

package/browser/find-options/JoinOptions.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=JoinOptions.js.map

package/browser/find-options/JoinOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../browser/src/find-options/JoinOptions.ts"],"names":[],"mappings":"","file":"JoinOptions.js","sourcesContent":["/**\n * Used to specify what entity relations should be loaded.\n *\n * Example:\n *  const options: JoinOptions = {\n *     alias: \"photo\",\n *     leftJoin: {\n *         author: \"photo.author\",\n *         categories: \"categories\",\n *         user: \"categories.user\",\n *         profile: \"user.profile\"\n *     },\n *     innerJoin: {\n *         author: \"photo.author\",\n *         categories: \"categories\",\n *         user: \"categories.user\",\n *         profile: \"user.profile\"\n *     },\n *     leftJoinAndSelect: {\n *         author: \"photo.author\",\n *         categories: \"categories\",\n *         user: \"categories.user\",\n *         profile: \"user.profile\"\n *     },\n *     innerJoinAndSelect: {\n *         author: \"photo.author\",\n *         categories: \"categories\",\n *         user: \"categories.user\",\n *         profile: \"user.profile\"\n *     }\n * };\n *\n * @deprecated\n */\nexport interface JoinOptions {\n    /**\n     * Alias of the main entity.\n     */\n    alias: string\n\n    /**\n     * Object where each key represents the LEFT JOIN alias,\n     * and the corresponding value represents the relation path.\n     *\n     * The columns of the joined table are included in the selection.\n     */\n    leftJoinAndSelect?: { [key: string]: string }\n\n    /**\n     * Object where each key represents the INNER JOIN alias,\n     * and the corresponding value represents the relation path.\n     *\n     * The columns of the joined table are included in the selection.\n     */\n    innerJoinAndSelect?: { [key: string]: string }\n\n    /**\n     * Object where each key represents the LEFT JOIN alias,\n     * and the corresponding value represents the relation path.\n     *\n     * This method does not select the columns of the joined table.\n     */\n    leftJoin?: { [key: string]: string }\n\n    /**\n     * Object where each key represents the INNER JOIN alias,\n     * and the corresponding value represents the relation path.\n     *\n     * This method does not select the columns of the joined table.\n     */\n    innerJoin?: { [key: string]: string }\n}\n"],"sourceRoot":".."}

package/browser/find-options/OrderByCondition.js

@@ -1,3 +1,3 @@
-
+export {};
 
 //# sourceMappingURL=OrderByCondition.js.map

package/browser/find-options/OrderByCondition.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../browser/src/find-options/OrderByCondition.ts"],"names":[],"mappings":"","file":"OrderByCondition.js","sourcesContent":["/**\n * Special object that defines order condition for ORDER BY in sql.\n *\n * Example:\n * {\n *  \"name\": \"ASC\",\n *  \"id\": \"DESC\"\n * }\n *\n * @deprecated\n */\nexport type OrderByCondition = {\n    [columnName: string]: (\"ASC\"|\"DESC\")|{\n        order: \"ASC\"|\"DESC\";\n        nulls?: \"NULLS FIRST\"|\"NULLS LAST\";\n    }\n};\n"],"sourceRoot":".."}
+{"version":3,"sources":["../browser/src/find-options/OrderByCondition.ts"],"names":[],"mappings":"","file":"OrderByCondition.js","sourcesContent":["/**\n * Special object that defines order condition for ORDER BY in sql.\n *\n * Example:\n * {\n *  \"name\": \"ASC\",\n *  \"id\": \"DESC\"\n * }\n *\n * @deprecated\n */\nexport type OrderByCondition = {\n    [columnName: string]:\n        | (\"ASC\" | \"DESC\")\n        | {\n              order: \"ASC\" | \"DESC\"\n              nulls?: \"NULLS FIRST\" | \"NULLS LAST\"\n          }\n}\n"],"sourceRoot":".."}