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

package/query-builder/QueryBuilder.js

@@ -4,6 +4,7 @@ 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");
@@ -26,8 +27,21 @@ const escapeRegExp_1 = require("../util/escapeRegExp");
  * Allows to build complex sql queries in a fashion way and execute those queries.
  */
 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");
@@ -36,12 +50,12 @@ class QueryBuilder {
          */
         this.parameterIndex = 0;
         if (InstanceChecker_1.InstanceChecker.isDataSource(connectionOrQueryBuilder)) {
-            this.connection = connectionOrQueryBuilder;
+            this.dataSource = connectionOrQueryBuilder;
             this.queryRunner = queryRunner;
-            this.expressionMap = new QueryExpressionMap_1.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();
         }
@@ -63,6 +77,8 @@ class QueryBuilder {
     /**
      * 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";
@@ -91,6 +107,8 @@ class QueryBuilder {
     }
     /**
      * Creates UPDATE query and applies given update values.
+     * @param entityOrTableNameUpdateSet
+     * @param maybeUpdateSet
      */
     update(entityOrTableNameUpdateSet, maybeUpdateSet) {
         const updateSet = maybeUpdateSet
@@ -133,6 +151,8 @@ class QueryBuilder {
     }
     /**
      * 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;
@@ -154,9 +174,11 @@ 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);
@@ -164,6 +186,7 @@ class QueryBuilder {
     }
     /**
      * Check the existence of a parameter for this query builder.
+     * @param key
      */
     hasParameter(key) {
         return (this.parentQueryBuilder?.hasParameter(key) ||
@@ -173,6 +196,8 @@ 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") {
@@ -189,6 +214,7 @@ class QueryBuilder {
     }
     /**
      * Adds all parameters from the given object.
+     * @param parameters
      */
     setParameters(parameters) {
         for (const [key, value] of Object.entries(parameters)) {
@@ -204,21 +230,6 @@ 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.
      */
@@ -239,12 +250,11 @@ 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;
     }
     /**
@@ -258,10 +268,9 @@ 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.
@@ -282,9 +291,10 @@ 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.
@@ -299,6 +309,7 @@ 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;
@@ -313,14 +324,16 @@ 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;
@@ -329,6 +342,7 @@ 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;
@@ -336,6 +350,7 @@ class QueryBuilder {
     }
     /**
      * If set to true the query will be wrapped into a transaction.
+     * @param enabled
      */
     useTransaction(enabled) {
         this.expressionMap.useTransaction = enabled;
@@ -343,6 +358,9 @@ class QueryBuilder {
     }
     /**
      * Adds CTE to query
+     * @param queryBuilder
+     * @param alias
+     * @param options
      */
     addCommonTableExpression(queryBuilder, alias, options) {
         this.expressionMap.commonTableExpressions.push({
@@ -358,6 +376,7 @@ 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
@@ -383,23 +402,24 @@ 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,
@@ -419,15 +439,9 @@ 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 = {};
@@ -539,7 +553,7 @@ 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;
@@ -552,7 +566,7 @@ 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) {
@@ -561,13 +575,12 @@ 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
@@ -585,10 +598,11 @@ 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" &&
@@ -668,16 +682,16 @@ 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
                             ? ")"
                             : ""}`);
             }
@@ -688,6 +702,8 @@ 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")
@@ -703,7 +719,7 @@ 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]}`;
@@ -764,7 +780,7 @@ class QueryBuilder {
         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") {
@@ -772,9 +788,9 @@ class QueryBuilder {
                     throw new error_1.TypeORMError(`Nested CTEs aren't supported (CTE: ${cte.alias})`);
                 }
                 cteBodyExpression = cte.queryBuilder.getQuery();
-                if (!this.connection.driver.cteCapabilities.writable &&
+                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.connection.options.type} (CTE: ${cte.alias})`);
+                    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());
             }
@@ -794,7 +810,7 @@ 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"
@@ -814,6 +830,7 @@ class QueryBuilder {
     }
     /**
      * Creates "WHERE" condition for an in-ids condition.
+     * @param ids
      */
     getWhereInIdsCondition(ids) {
         const metadata = this.expressionMap.mainAlias.metadata;
@@ -827,8 +844,9 @@ class QueryBuilder {
             if (!primaryColumn.transformer &&
                 !primaryColumn.relationMetadata &&
                 !primaryColumn.embeddedMetadata) {
+                const values = normalized.map((id) => primaryColumn.getEntityValue(id, false));
                 return {
-                    [primaryColumn.propertyName]: (0, In_1.In)(normalized.map((id) => primaryColumn.getEntityValue(id, false))),
+                    [primaryColumn.propertyName]: values.length === 1 ? (0, Equal_1.Equal)(values[0]) : (0, In_1.In)(values),
                 };
             }
         }
@@ -901,6 +919,9 @@ class QueryBuilder {
     }
     /**
      * Creates a property paths for a given ObjectLiteral.
+     * @param metadata
+     * @param entity
+     * @param prefix
      */
     createPropertyPath(metadata, entity, prefix = "") {
         const paths = [];
@@ -939,10 +960,6 @@ 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.
@@ -1061,29 +1078,6 @@ 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 error_1.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 error_1.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)],
@@ -1102,8 +1096,8 @@ 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 {
@@ -1138,16 +1132,11 @@ 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;
     }
 }
 exports.QueryBuilder = QueryBuilder;
-/**
- * Contains all registered query builder classes.
- */
-QueryBuilder.queryBuilderRegistry = {};
-
-//# sourceMappingURL=QueryBuilder.js.map
+//# sourceMappingURL=QueryBuilder.js.map