typeorm 0.3.29-dev.cc07c90 → 1.0.0-beta.1

package/browser/query-builder/QueryBuilder.js

@@ -1,11 +1,15 @@
-import { QueryExpressionMap } from "./QueryExpressionMap";
-import { Brackets } from "./Brackets";
-import { FindOperator } from "../find-options/FindOperator";
-import { In } from "../find-options/operator/In";
-import { TypeORMError } from "../error";
-import { EntityPropertyNotFoundError } from "../error/EntityPropertyNotFoundError";
-import { InstanceChecker } from "../util/InstanceChecker";
-import { escapeRegExp } from "../util/escapeRegExp";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = void 0;
+const QueryExpressionMap_1 = require("./QueryExpressionMap");
+const Brackets_1 = require("./Brackets");
+const FindOperator_1 = require("../find-options/FindOperator");
+const Equal_1 = require("../find-options/operator/Equal");
+const In_1 = require("../find-options/operator/In");
+const error_1 = require("../error");
+const EntityPropertyNotFoundError_1 = require("../error/EntityPropertyNotFoundError");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+const escapeRegExp_1 = require("../util/escapeRegExp");
 // todo: completely cover query builder with tests
 // todo: entityOrProperty can be target name. implement proper behaviour if it is.
 // todo: check in persistment if id exist on object and throw exception (can be in partial selection?)
@@ -22,9 +26,22 @@ import { escapeRegExp } from "../util/escapeRegExp";
 /**
  * Allows to build complex sql queries in a fashion way and execute those queries.
  */
-export class QueryBuilder {
+class QueryBuilder {
+    /**
+     * DataSource on which QueryBuilder was created.
+     * @deprecated since 1.0.0. Use {@link dataSource} instance instead.
+     */
+    get connection() {
+        return this.dataSource;
+    }
+    /**
+     * Contains all registered query builder classes.
+     */
+    static { this.queryBuilderRegistry = {}; }
     /**
      * QueryBuilder can be initialized from given Connection and QueryRunner objects or from given other QueryBuilder.
+     * @param connectionOrQueryBuilder
+     * @param queryRunner
      */
     constructor(connectionOrQueryBuilder, queryRunner) {
         this["@instanceof"] = Symbol.for("QueryBuilder");
@@ -32,13 +49,13 @@ export class QueryBuilder {
          * Memo to help keep place of current parameter index for `createParameter`
          */
         this.parameterIndex = 0;
-        if (InstanceChecker.isDataSource(connectionOrQueryBuilder)) {
-            this.connection = connectionOrQueryBuilder;
+        if (InstanceChecker_1.InstanceChecker.isDataSource(connectionOrQueryBuilder)) {
+            this.dataSource = connectionOrQueryBuilder;
             this.queryRunner = queryRunner;
-            this.expressionMap = new QueryExpressionMap(this.connection);
+            this.expressionMap = new QueryExpressionMap_1.QueryExpressionMap(this.dataSource);
         }
         else {
-            this.connection = connectionOrQueryBuilder.connection;
+            this.dataSource = connectionOrQueryBuilder.dataSource;
             this.queryRunner = connectionOrQueryBuilder.queryRunner;
             this.expressionMap = connectionOrQueryBuilder.expressionMap.clone();
         }
@@ -54,12 +71,14 @@ export class QueryBuilder {
      */
     get alias() {
         if (!this.expressionMap.mainAlias)
-            throw new TypeORMError(`Main alias is not set`); // todo: better exception
+            throw new error_1.TypeORMError(`Main alias is not set`); // todo: better exception
         return this.expressionMap.mainAlias.name;
     }
     /**
      * Creates SELECT query and selects given data.
      * Replaces all previous selections if they exist.
+     * @param selection
+     * @param selectionAliasName
      */
     select(selection, selectionAliasName) {
         this.expressionMap.queryType = "select";
@@ -73,7 +92,7 @@ export class QueryBuilder {
                 { selection: selection, aliasName: selectionAliasName },
             ];
         }
-        if (InstanceChecker.isSelectQueryBuilder(this))
+        if (InstanceChecker_1.InstanceChecker.isSelectQueryBuilder(this))
             return this;
         return QueryBuilder.queryBuilderRegistry["SelectQueryBuilder"](this);
     }
@@ -82,18 +101,20 @@ export class QueryBuilder {
      */
     insert() {
         this.expressionMap.queryType = "insert";
-        if (InstanceChecker.isInsertQueryBuilder(this))
+        if (InstanceChecker_1.InstanceChecker.isInsertQueryBuilder(this))
             return this;
         return QueryBuilder.queryBuilderRegistry["InsertQueryBuilder"](this);
     }
     /**
      * Creates UPDATE query and applies given update values.
+     * @param entityOrTableNameUpdateSet
+     * @param maybeUpdateSet
      */
     update(entityOrTableNameUpdateSet, maybeUpdateSet) {
         const updateSet = maybeUpdateSet
             ? maybeUpdateSet
             : entityOrTableNameUpdateSet;
-        entityOrTableNameUpdateSet = InstanceChecker.isEntitySchema(entityOrTableNameUpdateSet)
+        entityOrTableNameUpdateSet = InstanceChecker_1.InstanceChecker.isEntitySchema(entityOrTableNameUpdateSet)
             ? entityOrTableNameUpdateSet.options.name
             : entityOrTableNameUpdateSet;
         if (typeof entityOrTableNameUpdateSet === "function" ||
@@ -103,7 +124,7 @@ export class QueryBuilder {
         }
         this.expressionMap.queryType = "update";
         this.expressionMap.valuesSet = updateSet;
-        if (InstanceChecker.isUpdateQueryBuilder(this))
+        if (InstanceChecker_1.InstanceChecker.isUpdateQueryBuilder(this))
             return this;
         return QueryBuilder.queryBuilderRegistry["UpdateQueryBuilder"](this);
     }
@@ -112,24 +133,26 @@ export class QueryBuilder {
      */
     delete() {
         this.expressionMap.queryType = "delete";
-        if (InstanceChecker.isDeleteQueryBuilder(this))
+        if (InstanceChecker_1.InstanceChecker.isDeleteQueryBuilder(this))
             return this;
         return QueryBuilder.queryBuilderRegistry["DeleteQueryBuilder"](this);
     }
     softDelete() {
         this.expressionMap.queryType = "soft-delete";
-        if (InstanceChecker.isSoftDeleteQueryBuilder(this))
+        if (InstanceChecker_1.InstanceChecker.isSoftDeleteQueryBuilder(this))
             return this;
         return QueryBuilder.queryBuilderRegistry["SoftDeleteQueryBuilder"](this);
     }
     restore() {
         this.expressionMap.queryType = "restore";
-        if (InstanceChecker.isSoftDeleteQueryBuilder(this))
+        if (InstanceChecker_1.InstanceChecker.isSoftDeleteQueryBuilder(this))
             return this;
         return QueryBuilder.queryBuilderRegistry["SoftDeleteQueryBuilder"](this);
     }
     /**
      * Sets entity's relation with which this query builder gonna work.
+     * @param entityTargetOrPropertyPath
+     * @param maybePropertyPath
      */
     relation(entityTargetOrPropertyPath, maybePropertyPath) {
         const entityTarget = arguments.length === 2 ? entityTargetOrPropertyPath : undefined;
@@ -142,7 +165,7 @@ export class QueryBuilder {
             const mainAlias = this.createFromAlias(entityTarget);
             this.expressionMap.setMainAlias(mainAlias);
         }
-        if (InstanceChecker.isRelationQueryBuilder(this))
+        if (InstanceChecker_1.InstanceChecker.isRelationQueryBuilder(this))
             return this;
         return QueryBuilder.queryBuilderRegistry["RelationQueryBuilder"](this);
     }
@@ -151,9 +174,11 @@ export class QueryBuilder {
      * Returns true if relation exists, false otherwise.
      *
      * todo: move this method to manager? or create a shortcut?
+     * @param target
+     * @param relation
      */
     hasRelation(target, relation) {
-        const entityMetadata = this.connection.getMetadata(target);
+        const entityMetadata = this.dataSource.getMetadata(target);
         const relations = Array.isArray(relation) ? relation : [relation];
         return relations.every((relation) => {
             return !!entityMetadata.findRelationWithPropertyPath(relation);
@@ -161,6 +186,7 @@ export class QueryBuilder {
     }
     /**
      * Check the existence of a parameter for this query builder.
+     * @param key
      */
     hasParameter(key) {
         return (this.parentQueryBuilder?.hasParameter(key) ||
@@ -170,13 +196,15 @@ export class QueryBuilder {
      * Sets parameter name and its value.
      *
      * The key for this parameter may contain numbers, letters, underscores, or periods.
+     * @param key
+     * @param value
      */
     setParameter(key, value) {
         if (typeof value === "function") {
-            throw new TypeORMError(`Function parameter isn't supported in the parameters. Please check "${key}" parameter.`);
+            throw new error_1.TypeORMError(`Function parameter isn't supported in the parameters. Please check "${key}" parameter.`);
         }
         if (!key.match(/^([A-Za-z0-9_.]+)$/)) {
-            throw new TypeORMError("QueryBuilder parameter keys may only contain numbers, letters, underscores, or periods.");
+            throw new error_1.TypeORMError("QueryBuilder parameter keys may only contain numbers, letters, underscores, or periods.");
         }
         if (this.parentQueryBuilder) {
             this.parentQueryBuilder.setParameter(key, value);
@@ -186,6 +214,7 @@ export class QueryBuilder {
     }
     /**
      * Adds all parameters from the given object.
+     * @param parameters
      */
     setParameters(parameters) {
         for (const [key, value] of Object.entries(parameters)) {
@@ -201,21 +230,6 @@ export class QueryBuilder {
         this.setParameter(parameterName, value);
         return `:${parameterName}`;
     }
-    /**
-     * Adds native parameters from the given object.
-     *
-     * @deprecated Use `setParameters` instead
-     */
-    setNativeParameters(parameters) {
-        // set parent query builder parameters as well in sub-query mode
-        if (this.parentQueryBuilder) {
-            this.parentQueryBuilder.setNativeParameters(parameters);
-        }
-        Object.keys(parameters).forEach((key) => {
-            this.expressionMap.nativeParameters[key] = parameters[key];
-        });
-        return this;
-    }
     /**
      * Gets all parameters.
      */
@@ -236,12 +250,11 @@ export class QueryBuilder {
         return parameters;
     }
     /**
-     * Prints sql to stdout using console.log.
+     * Logs the generated sql query using the configured logger.
      */
-    printSql() {
-        // TODO rename to logSql()
+    logQuery() {
         const [query, parameters] = this.getQueryAndParameters();
-        this.connection.logger.logQuery(query, parameters);
+        this.dataSource.logger.logQuery(query, parameters);
         return this;
     }
     /**
@@ -255,10 +268,9 @@ export class QueryBuilder {
      * Gets query to be executed with all parameters used in it.
      */
     getQueryAndParameters() {
-        // this execution order is important because getQuery method generates this.expressionMap.nativeParameters values
         const query = this.getQuery();
         const parameters = this.getParameters();
-        return this.connection.driver.escapeQueryWithParameters(query, parameters, this.expressionMap.nativeParameters);
+        return this.dataSource.driver.escapeQueryWithParameters(query, parameters);
     }
     /**
      * Executes sql generated by query builder and returns raw database results.
@@ -279,9 +291,10 @@ export class QueryBuilder {
     /**
      * Creates a completely new query builder.
      * Uses same query runner as current QueryBuilder.
+     * @param queryRunner
      */
     createQueryBuilder(queryRunner) {
-        return new this.constructor(this.connection, queryRunner ?? this.queryRunner);
+        return new this.constructor(this.dataSource, queryRunner ?? this.queryRunner);
     }
     /**
      * Clones query builder as it is.
@@ -296,6 +309,7 @@ export class QueryBuilder {
      * Includes a Query comment in the query builder.  This is helpful for debugging purposes,
      * such as finding a specific query in the database server's logs, or for categorization using
      * an APM product.
+     * @param comment
      */
     comment(comment) {
         this.expressionMap.comment = comment;
@@ -310,14 +324,16 @@ export class QueryBuilder {
     }
     /**
      * Escapes table name, column name or alias name using current database's escaping character.
+     * @param name
      */
     escape(name) {
         if (!this.expressionMap.disableEscaping)
             return name;
-        return this.connection.driver.escape(name);
+        return this.dataSource.driver.escape(name);
     }
     /**
      * Sets or overrides query builder's QueryRunner.
+     * @param queryRunner
      */
     setQueryRunner(queryRunner) {
         this.queryRunner = queryRunner;
@@ -326,6 +342,7 @@ export class QueryBuilder {
     /**
      * Indicates if listeners and subscribers must be called before and after query execution.
      * Enabled by default.
+     * @param enabled
      */
     callListeners(enabled) {
         this.expressionMap.callListeners = enabled;
@@ -333,6 +350,7 @@ export class QueryBuilder {
     }
     /**
      * If set to true the query will be wrapped into a transaction.
+     * @param enabled
      */
     useTransaction(enabled) {
         this.expressionMap.useTransaction = enabled;
@@ -340,6 +358,9 @@ export class QueryBuilder {
     }
     /**
      * Adds CTE to query
+     * @param queryBuilder
+     * @param alias
+     * @param options
      */
     addCommonTableExpression(queryBuilder, alias, options) {
         this.expressionMap.commonTableExpressions.push({
@@ -355,6 +376,7 @@ export class QueryBuilder {
     /**
      * Gets escaped table name with schema name if SqlServer driver used with custom
      * schema name, otherwise returns escaped table name.
+     * @param tablePath
      */
     getTableName(tablePath) {
         return tablePath
@@ -372,7 +394,7 @@ export class QueryBuilder {
      */
     getMainTableName() {
         if (!this.expressionMap.mainAlias)
-            throw new TypeORMError(`Entity where values should be inserted is not specified. Call "qb.into(entity)" method to specify it.`);
+            throw new error_1.TypeORMError(`Entity where values should be inserted is not specified. Call "qb.into(entity)" method to specify it.`);
         if (this.expressionMap.mainAlias.hasMetadata)
             return this.expressionMap.mainAlias.metadata.tablePath;
         return this.expressionMap.mainAlias.tablePath;
@@ -380,23 +402,24 @@ export class QueryBuilder {
     /**
      * Specifies FROM which entity's table select/update/delete will be executed.
      * Also sets a main string alias of the selection data.
+     * @param entityTarget
+     * @param aliasName
      */
     createFromAlias(entityTarget, aliasName) {
         // if table has a metadata then find it to properly escape its properties
-        // const metadata = this.connection.entityMetadatas.find(metadata => metadata.tableName === tableName);
-        if (this.connection.hasMetadata(entityTarget)) {
-            const metadata = this.connection.getMetadata(entityTarget);
+        // const metadata = this.dataSource.entityMetadatas.find(metadata => metadata.tableName === tableName);
+        if (this.dataSource.hasMetadata(entityTarget)) {
+            const metadata = this.dataSource.getMetadata(entityTarget);
             return this.expressionMap.createAlias({
                 type: "from",
                 name: aliasName,
-                metadata: this.connection.getMetadata(entityTarget),
+                metadata: this.dataSource.getMetadata(entityTarget),
                 tablePath: metadata.tablePath,
             });
         }
         else {
             if (typeof entityTarget === "string") {
-                const isSubquery = entityTarget.substr(0, 1) === "(" &&
-                    entityTarget.substr(-1) === ")";
+                const isSubquery = entityTarget.startsWith("(") && entityTarget.endsWith(")");
                 return this.expressionMap.createAlias({
                     type: "from",
                     name: aliasName,
@@ -416,15 +439,9 @@ export class QueryBuilder {
             });
         }
     }
-    /**
-     * @deprecated this way of replace property names is too slow.
-     *  Instead, we'll replace property names at the end - once query is build.
-     */
-    replacePropertyNames(statement) {
-        return statement;
-    }
     /**
      * Replaces all entity's propertyName to name in the given SQL string.
+     * @param statement
      */
     replacePropertyNamesForTheWholeQuery(statement) {
         const replacements = {};
@@ -475,7 +492,7 @@ export class QueryBuilder {
         }
         const replacementKeys = Object.keys(replacements);
         const replaceAliasNamePrefixes = replacementKeys
-            .map((key) => escapeRegExp(key))
+            .map((key) => (0, escapeRegExp_1.escapeRegExp)(key))
             .join("|");
         if (replacementKeys.length > 0) {
             statement = statement.replace(new RegExp(
@@ -536,7 +553,7 @@ export class QueryBuilder {
         const conditionsArray = [];
         const whereExpression = this.createWhereClausesExpression(this.expressionMap.wheres);
         if (whereExpression.length > 0 && whereExpression !== "1=1") {
-            conditionsArray.push(this.replacePropertyNames(whereExpression));
+            conditionsArray.push(whereExpression);
         }
         if (this.expressionMap.mainAlias.hasMetadata) {
             const metadata = this.expressionMap.mainAlias.metadata;
@@ -549,7 +566,7 @@ export class QueryBuilder {
                         "." +
                         metadata.deleteDateColumn.propertyName
                     : metadata.deleteDateColumn.propertyName;
-                const condition = `${this.replacePropertyNames(column)} IS NULL`;
+                const condition = `${column} IS NULL`;
                 conditionsArray.push(condition);
             }
             if (metadata.discriminatorColumn && metadata.parentEntityMetadata) {
@@ -558,13 +575,12 @@ export class QueryBuilder {
                         "." +
                         metadata.discriminatorColumn.databaseName
                     : metadata.discriminatorColumn.databaseName;
-                const condition = `${this.replacePropertyNames(column)} IN (:...discriminatorColumnValues)`;
+                const condition = `${column} IN (:...discriminatorColumnValues)`;
                 conditionsArray.push(condition);
             }
         }
         if (this.expressionMap.extraAppendedAndWhereCondition) {
-            const condition = this.replacePropertyNames(this.expressionMap.extraAppendedAndWhereCondition);
-            conditionsArray.push(condition);
+            conditionsArray.push(this.expressionMap.extraAppendedAndWhereCondition);
         }
         let condition = "";
         // time travel
@@ -582,10 +598,11 @@ export class QueryBuilder {
     }
     /**
      * Creates "RETURNING" / "OUTPUT" expression.
+     * @param returningType
      */
     createReturningExpression(returningType) {
         const columns = this.getReturningColumns();
-        const driver = this.connection.driver;
+        const driver = this.dataSource.driver;
         // also add columns we must auto-return to perform entity updation
         // if user gave his own returning
         if (typeof this.expressionMap.returning !== "string" &&
@@ -665,16 +682,16 @@ export class QueryBuilder {
             switch (clause.type) {
                 case "and":
                     return ((index > 0 ? "AND " : "") +
-                        `${this.connection.options.isolateWhereStatements
+                        `${this.dataSource.options.isolateWhereStatements
                             ? "("
-                            : ""}${expression}${this.connection.options.isolateWhereStatements
+                            : ""}${expression}${this.dataSource.options.isolateWhereStatements
                             ? ")"
                             : ""}`);
                 case "or":
                     return ((index > 0 ? "OR " : "") +
-                        `${this.connection.options.isolateWhereStatements
+                        `${this.dataSource.options.isolateWhereStatements
                             ? "("
-                            : ""}${expression}${this.connection.options.isolateWhereStatements
+                            : ""}${expression}${this.dataSource.options.isolateWhereStatements
                             ? ")"
                             : ""}`);
             }
@@ -685,6 +702,8 @@ export class QueryBuilder {
     }
     /**
      * Computes given where argument - transforms to a where string all forms it can take.
+     * @param condition
+     * @param alwaysWrap
      */
     createWhereConditionExpression(condition, alwaysWrap = false) {
         if (typeof condition === "string")
@@ -700,7 +719,7 @@ export class QueryBuilder {
             }
             return "(" + this.createWhereClausesExpression(condition) + ")";
         }
-        const { driver } = this.connection;
+        const { driver } = this.dataSource;
         switch (condition.operator) {
             case "lessThan":
                 return `${condition.parameters[0]} < ${condition.parameters[1]}`;
@@ -755,34 +774,34 @@ export class QueryBuilder {
             case "or":
                 return "(" + condition.parameters.join(" OR ") + ")";
         }
-        throw new TypeError(`Unsupported FindOperator ${FindOperator.constructor.name}`);
+        throw new TypeError(`Unsupported FindOperator ${FindOperator_1.FindOperator.constructor.name}`);
     }
     createCteExpression() {
         if (!this.hasCommonTableExpressions()) {
             return "";
         }
-        const databaseRequireRecusiveHint = this.connection.driver.cteCapabilities.requiresRecursiveHint;
+        const databaseRequireRecusiveHint = this.dataSource.driver.cteCapabilities.requiresRecursiveHint;
         const cteStrings = this.expressionMap.commonTableExpressions.map((cte) => {
             let cteBodyExpression = typeof cte.queryBuilder === "string" ? cte.queryBuilder : "";
             if (typeof cte.queryBuilder !== "string") {
                 if (cte.queryBuilder.hasCommonTableExpressions()) {
-                    throw new TypeORMError(`Nested CTEs aren't supported (CTE: ${cte.alias})`);
+                    throw new error_1.TypeORMError(`Nested CTEs aren't supported (CTE: ${cte.alias})`);
                 }
                 cteBodyExpression = cte.queryBuilder.getQuery();
-                if (!this.connection.driver.cteCapabilities.writable &&
-                    !InstanceChecker.isSelectQueryBuilder(cte.queryBuilder)) {
-                    throw new TypeORMError(`Only select queries are supported in CTEs in ${this.connection.options.type} (CTE: ${cte.alias})`);
+                if (!this.dataSource.driver.cteCapabilities.writable &&
+                    !InstanceChecker_1.InstanceChecker.isSelectQueryBuilder(cte.queryBuilder)) {
+                    throw new error_1.TypeORMError(`Only select queries are supported in CTEs in ${this.dataSource.options.type} (CTE: ${cte.alias})`);
                 }
                 this.setParameters(cte.queryBuilder.getParameters());
             }
             let cteHeader = this.escape(cte.alias);
             if (cte.options.columnNames) {
                 const escapedColumnNames = cte.options.columnNames.map((column) => this.escape(column));
-                if (InstanceChecker.isSelectQueryBuilder(cte.queryBuilder)) {
+                if (InstanceChecker_1.InstanceChecker.isSelectQueryBuilder(cte.queryBuilder)) {
                     if (cte.queryBuilder.expressionMap.selects.length &&
                         cte.options.columnNames.length !==
                             cte.queryBuilder.expressionMap.selects.length) {
-                        throw new TypeORMError(`cte.options.columnNames length (${cte.options.columnNames.length}) doesn't match subquery select list length ${cte.queryBuilder.expressionMap.selects.length} (CTE: ${cte.alias})`);
+                        throw new error_1.TypeORMError(`cte.options.columnNames length (${cte.options.columnNames.length}) doesn't match subquery select list length ${cte.queryBuilder.expressionMap.selects.length} (CTE: ${cte.alias})`);
                     }
                 }
                 cteHeader += `(${escapedColumnNames.join(", ")})`;
@@ -791,7 +810,7 @@ export class QueryBuilder {
                 ? "RECURSIVE"
                 : "";
             let materializeClause = "";
-            if (this.connection.driver.cteCapabilities.materializedHint &&
+            if (this.dataSource.driver.cteCapabilities.materializedHint &&
                 cte.options.materialized !== undefined) {
                 materializeClause = cte.options.materialized
                     ? "MATERIALIZED"
@@ -811,6 +830,7 @@ export class QueryBuilder {
     }
     /**
      * Creates "WHERE" condition for an in-ids condition.
+     * @param ids
      */
     getWhereInIdsCondition(ids) {
         const metadata = this.expressionMap.mainAlias.metadata;
@@ -824,14 +844,15 @@ export class QueryBuilder {
             if (!primaryColumn.transformer &&
                 !primaryColumn.relationMetadata &&
                 !primaryColumn.embeddedMetadata) {
+                const values = normalized.map((id) => primaryColumn.getEntityValue(id, false));
                 return {
-                    [primaryColumn.propertyName]: In(normalized.map((id) => primaryColumn.getEntityValue(id, false))),
+                    [primaryColumn.propertyName]: values.length === 1 ? (0, Equal_1.Equal)(values[0]) : (0, In_1.In)(values),
                 };
             }
         }
-        return new Brackets((qb) => {
+        return new Brackets_1.Brackets((qb) => {
             for (const data of normalized) {
-                qb.orWhere(new Brackets((qb) => qb.where(data)));
+                qb.orWhere(new Brackets_1.Brackets((qb) => qb.where(data)));
             }
         });
     }
@@ -892,12 +913,15 @@ export class QueryBuilder {
         const aliasPropertyPath = propertyPathParts.join(".");
         const columns = alias.metadata.findColumnsWithPropertyPath(aliasPropertyPath);
         if (!columns.length) {
-            throw new EntityPropertyNotFoundError(propertyPath, alias.metadata);
+            throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, alias.metadata);
         }
         return [alias, root, columns];
     }
     /**
      * Creates a property paths for a given ObjectLiteral.
+     * @param metadata
+     * @param entity
+     * @param prefix
      */
     createPropertyPath(metadata, entity, prefix = "") {
         const paths = [];
@@ -907,7 +931,7 @@ export class QueryBuilder {
             // If the value is a `FindOperator`, or null, or not an object, then we don't, for example.
             if (entity[key] === null ||
                 typeof entity[key] !== "object" ||
-                InstanceChecker.isFindOperator(entity[key])) {
+                InstanceChecker_1.InstanceChecker.isFindOperator(entity[key])) {
                 paths.push(path);
                 continue;
             }
@@ -936,10 +960,6 @@ export class QueryBuilder {
                         continue;
                     }
                 }
-                if (relation.relationType === "one-to-many" ||
-                    relation.relationType === "many-to-many") {
-                    throw new Error(`Cannot query across ${relation.relationType} for property ${path}`);
-                }
                 // For any other case, if the `entity[key]` contains all of the primary keys we can do a
                 // lookup via these.  We don't need to look up via any other values 'cause these are
                 // the unique primary keys.
@@ -997,7 +1017,7 @@ export class QueryBuilder {
         }
     }
     getWherePredicateCondition(aliasPath, parameterValue) {
-        if (InstanceChecker.isFindOperator(parameterValue)) {
+        if (InstanceChecker_1.InstanceChecker.isFindOperator(parameterValue)) {
             const parameters = [];
             if (parameterValue.useParameter) {
                 if (parameterValue.objectLiteralParameters) {
@@ -1058,29 +1078,6 @@ export class QueryBuilder {
                 };
             }
         }
-        else if (parameterValue === null) {
-            const nullBehavior = this.connection.options.invalidWhereValuesBehavior?.null ||
-                "ignore";
-            if (nullBehavior === "sql-null") {
-                return {
-                    operator: "isNull",
-                    parameters: [aliasPath],
-                };
-            }
-            else if (nullBehavior === "throw") {
-                throw new TypeORMError(`Null value encountered in property '${aliasPath}' of a where condition. ` +
-                    `To match with SQL NULL, the IsNull() operator must be used. ` +
-                    `Set 'invalidWhereValuesBehavior.null' to 'ignore' or 'sql-null' in connection options to skip or handle null values.`);
-            }
-        }
-        else if (parameterValue === undefined) {
-            const undefinedBehavior = this.connection.options.invalidWhereValuesBehavior?.undefined ||
-                "ignore";
-            if (undefinedBehavior === "throw") {
-                throw new TypeORMError(`Undefined value encountered in property '${aliasPath}' of a where condition. ` +
-                    `Set 'invalidWhereValuesBehavior.undefined' to 'ignore' in connection options to skip properties with undefined values.`);
-            }
-        }
         return {
             operator: "equal",
             parameters: [aliasPath, this.createParameter(parameterValue)],
@@ -1090,7 +1087,7 @@ export class QueryBuilder {
         if (typeof where === "string") {
             return where;
         }
-        if (InstanceChecker.isBrackets(where)) {
+        if (InstanceChecker_1.InstanceChecker.isBrackets(where)) {
             const whereQueryBuilder = this.createQueryBuilder();
             whereQueryBuilder.parentQueryBuilder = this;
             whereQueryBuilder.expressionMap.mainAlias =
@@ -1099,12 +1096,12 @@ export class QueryBuilder {
                 this.expressionMap.aliasNamePrefixingEnabled;
             whereQueryBuilder.expressionMap.parameters =
                 this.expressionMap.parameters;
-            whereQueryBuilder.expressionMap.nativeParameters =
-                this.expressionMap.nativeParameters;
+            whereQueryBuilder.expressionMap.joinAttributes =
+                this.expressionMap.joinAttributes;
             whereQueryBuilder.expressionMap.wheres = [];
             where.whereFactory(whereQueryBuilder);
             return {
-                operator: InstanceChecker.isNotBrackets(where)
+                operator: InstanceChecker_1.InstanceChecker.isNotBrackets(where)
                     ? "not"
                     : "brackets",
                 condition: whereQueryBuilder.expressionMap.wheres,
@@ -1135,15 +1132,11 @@ export class QueryBuilder {
      * Creates a query builder used to execute sql queries inside this query builder.
      */
     obtainQueryRunner() {
-        return this.queryRunner || this.connection.createQueryRunner();
+        return this.queryRunner || this.dataSource.createQueryRunner();
     }
     hasCommonTableExpressions() {
         return this.expressionMap.commonTableExpressions.length > 0;
     }
 }
-/**
- * Contains all registered query builder classes.
- */
-QueryBuilder.queryBuilderRegistry = {};
-
-//# sourceMappingURL=QueryBuilder.js.map
+exports.QueryBuilder = QueryBuilder;
+//# sourceMappingURL=QueryBuilder.js.map