typeorm 0.2.28 → 0.2.32

package/browser/query-builder/QueryBuilder.js

@@ -1,11 +1,12 @@
-import { __awaiter, __generator, __read, __spread } from "tslib";
+import { __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
 import { QueryExpressionMap } from "./QueryExpressionMap";
 import { Brackets } from "./Brackets";
 import { EntityMetadata } from "../metadata/EntityMetadata";
 import { SqljsDriver } from "../driver/sqljs/SqljsDriver";
+import { PostgresDriver } from "../driver/postgres/PostgresDriver";
+import { CockroachDriver } from "../driver/cockroachdb/CockroachDriver";
 import { SqlServerDriver } from "../driver/sqlserver/SqlServerDriver";
 import { OracleDriver } from "../driver/oracle/OracleDriver";
-import { MysqlDriver } from "../driver/mysql/MysqlDriver";
 import { EntitySchema } from "../";
 import { FindOperator } from "../find-options/FindOperator";
 import { In } from "../find-options/operator/In";
@@ -54,7 +55,7 @@ var QueryBuilder = /** @class */ (function () {
                 throw new Error("Main alias is not set"); // todo: better exception
             return this.expressionMap.mainAlias.name;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     /**
@@ -291,6 +292,15 @@ var QueryBuilder = /** @class */ (function () {
     QueryBuilder.prototype.clone = function () {
         return new this.constructor(this);
     };
+    /**
+     * 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.
+     */
+    QueryBuilder.prototype.comment = function (comment) {
+        this.expressionMap.comment = comment;
+        return this;
+    };
     /**
      * Disables escaping.
      */
@@ -395,31 +405,142 @@ var QueryBuilder = /** @class */ (function () {
      * Replaces all entity's propertyName to name in the given statement.
      */
     QueryBuilder.prototype.replacePropertyNames = function (statement) {
+        var e_1, _a;
         var _this = this;
-        this.expressionMap.aliases.forEach(function (alias) {
+        // Escape special characters in regular expressions
+        // Per https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
+        var escapeRegExp = function (s) { return s.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"); };
+        var _loop_1 = function (alias) {
+            var e_2, _d, e_3, _e, e_4, _f, e_5, _g, e_6, _h, e_7, _j;
             if (!alias.hasMetadata)
-                return;
-            var replaceAliasNamePrefix = _this.expressionMap.aliasNamePrefixingEnabled ? alias.name + "\\." : "";
-            var replacementAliasNamePrefix = _this.expressionMap.aliasNamePrefixingEnabled ? _this.escape(alias.name) + "." : "";
-            alias.metadata.columns.forEach(function (column) {
-                var expression = "([ =\(]|^.{0})" + replaceAliasNamePrefix + column.propertyPath + "([ =\)\,]|.{0}$)";
-                statement = statement.replace(new RegExp(expression, "gm"), "$1" + replacementAliasNamePrefix + _this.escape(column.databaseName) + "$2");
-                var expression2 = "([ =\(]|^.{0})" + replaceAliasNamePrefix + column.propertyName + "([ =\)\,]|.{0}$)";
-                statement = statement.replace(new RegExp(expression2, "gm"), "$1" + replacementAliasNamePrefix + _this.escape(column.databaseName) + "$2");
-            });
-            alias.metadata.relations.forEach(function (relation) {
-                __spread(relation.joinColumns, relation.inverseJoinColumns).forEach(function (joinColumn) {
-                    var expression = "([ =\(]|^.{0})" + replaceAliasNamePrefix + relation.propertyPath + "\\." + joinColumn.referencedColumn.propertyPath + "([ =\)\,]|.{0}$)";
-                    statement = statement.replace(new RegExp(expression, "gm"), "$1" + replacementAliasNamePrefix + _this.escape(joinColumn.databaseName) + "$2"); // todo: fix relation.joinColumns[0], what if multiple columns
-                });
-                if (relation.joinColumns.length > 0) {
-                    var expression = "([ =\(]|^.{0})" + replaceAliasNamePrefix + relation.propertyPath + "([ =\)\,]|.{0}$)";
-                    statement = statement.replace(new RegExp(expression, "gm"), "$1" + replacementAliasNamePrefix + _this.escape(relation.joinColumns[0].databaseName) + "$2"); // todo: fix relation.joinColumns[0], what if multiple columns
+                return "continue";
+            var replaceAliasNamePrefix = this_1.expressionMap.aliasNamePrefixingEnabled ? alias.name + "." : "";
+            var replacementAliasNamePrefix = this_1.expressionMap.aliasNamePrefixingEnabled ? this_1.escape(alias.name) + "." : "";
+            var replacements = {};
+            try {
+                // Insert & overwrite the replacements from least to most relevant in our replacements object.
+                // To do this we iterate and overwrite in the order of relevance.
+                // Least to Most Relevant:
+                // * Relation Property Path to first join column key
+                // * Relation Property Path + Column Path
+                // * Column Database Name
+                // * Column Propety Name
+                // * Column Property Path
+                for (var _k = (e_2 = void 0, __values(alias.metadata.relations)), _l = _k.next(); !_l.done; _l = _k.next()) {
+                    var relation = _l.value;
+                    if (relation.joinColumns.length > 0)
+                        replacements[relation.propertyPath] = relation.joinColumns[0].databaseName;
                 }
-            });
-        });
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_l && !_l.done && (_d = _k.return)) _d.call(_k);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            try {
+                for (var _m = (e_3 = void 0, __values(alias.metadata.relations)), _o = _m.next(); !_o.done; _o = _m.next()) {
+                    var relation = _o.value;
+                    try {
+                        for (var _p = (e_4 = void 0, __values(__spreadArray(__spreadArray([], __read(relation.joinColumns)), __read(relation.inverseJoinColumns)))), _q = _p.next(); !_q.done; _q = _p.next()) {
+                            var joinColumn = _q.value;
+                            var propertyKey = relation.propertyPath + "." + joinColumn.referencedColumn.propertyPath;
+                            replacements[propertyKey] = joinColumn.databaseName;
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_q && !_q.done && (_f = _p.return)) _f.call(_p);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_o && !_o.done && (_e = _m.return)) _e.call(_m);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            try {
+                for (var _r = (e_5 = void 0, __values(alias.metadata.columns)), _s = _r.next(); !_s.done; _s = _r.next()) {
+                    var column = _s.value;
+                    replacements[column.databaseName] = column.databaseName;
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_s && !_s.done && (_g = _r.return)) _g.call(_r);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            try {
+                for (var _t = (e_6 = void 0, __values(alias.metadata.columns)), _u = _t.next(); !_u.done; _u = _t.next()) {
+                    var column = _u.value;
+                    replacements[column.propertyName] = column.databaseName;
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_u && !_u.done && (_h = _t.return)) _h.call(_t);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            try {
+                for (var _v = (e_7 = void 0, __values(alias.metadata.columns)), _w = _v.next(); !_w.done; _w = _v.next()) {
+                    var column = _w.value;
+                    replacements[column.propertyPath] = column.databaseName;
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_w && !_w.done && (_j = _v.return)) _j.call(_v);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+            var replacementKeys = Object.keys(replacements);
+            if (replacementKeys.length) {
+                statement = statement.replace(new RegExp(
+                // Avoid a lookbehind here since it's not well supported
+                "([ =(]|^.{0})" +
+                    (escapeRegExp(replaceAliasNamePrefix) + "(" + replacementKeys.map(escapeRegExp).join("|") + ")") +
+                    "(?=[ =),]|.{0}$)", "gm"), function (_, pre, p) {
+                    return "" + pre + replacementAliasNamePrefix + _this.escape(replacements[p]);
+                });
+            }
+        };
+        var this_1 = this;
+        try {
+            for (var _b = __values(this.expressionMap.aliases), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var alias = _c.value;
+                _loop_1(alias);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
         return statement;
     };
+    QueryBuilder.prototype.createComment = function () {
+        if (!this.expressionMap.comment) {
+            return "";
+        }
+        // ANSI SQL 2003 support C style comments - comments that start with `/*` and end with `*/`
+        // In some dialects query nesting is available - but not all.  Because of this, we'll need
+        // to scrub "ending" characters from the SQL but otherwise we can leave everything else
+        // as-is and it should be valid.
+        return "/* " + this.expressionMap.comment.replace("*/", "") + " */ ";
+    };
     /**
      * Creates "WHERE" expression.
      */
@@ -450,7 +571,7 @@ var QueryBuilder = /** @class */ (function () {
             conditionsArray.push(condition);
         }
         if (!conditionsArray.length) {
-            return " ";
+            return "";
         }
         else if (conditionsArray.length === 1) {
             return " WHERE " + conditionsArray[0];
@@ -471,9 +592,9 @@ var QueryBuilder = /** @class */ (function () {
         if (typeof this.expressionMap.returning !== "string" &&
             this.expressionMap.extraReturningColumns.length > 0 &&
             driver.isReturningSqlSupported()) {
-            columns.push.apply(columns, __spread(this.expressionMap.extraReturningColumns.filter(function (column) {
+            columns.push.apply(columns, __spreadArray([], __read(this.expressionMap.extraReturningColumns.filter(function (column) {
                 return columns.indexOf(column) === -1;
-            })));
+            }))));
         }
         if (columns.length) {
             var columnsExpression = columns.map(function (column) {
@@ -519,7 +640,7 @@ var QueryBuilder = /** @class */ (function () {
         if (Array.isArray(this.expressionMap.returning)) {
             this.expressionMap.returning.forEach(function (columnName) {
                 if (_this.expressionMap.mainAlias.hasMetadata) {
-                    columns.push.apply(columns, __spread(_this.expressionMap.mainAlias.metadata.findColumnsWithPropertyPath(columnName)));
+                    columns.push.apply(columns, __spreadArray([], __read(_this.expressionMap.mainAlias.metadata.findColumnsWithPropertyPath(columnName))));
                 }
             });
         }
@@ -588,6 +709,9 @@ var QueryBuilder = /** @class */ (function () {
             return where;
         if (where instanceof Brackets) {
             var whereQueryBuilder = this.createQueryBuilder();
+            whereQueryBuilder.expressionMap.mainAlias = this.expressionMap.mainAlias;
+            whereQueryBuilder.expressionMap.aliasNamePrefixingEnabled = this.expressionMap.aliasNamePrefixingEnabled;
+            whereQueryBuilder.expressionMap.nativeParameters = this.expressionMap.nativeParameters;
             where.whereFactory(whereQueryBuilder);
             var whereString = whereQueryBuilder.createWhereExpressionString();
             this.setParameters(whereQueryBuilder.getParameters());
@@ -619,12 +743,17 @@ var QueryBuilder = /** @class */ (function () {
                             else if (parameterValue instanceof FindOperator) {
                                 var parameters_1 = [];
                                 if (parameterValue.useParameter) {
-                                    var realParameterValues = parameterValue.multipleParameters ? parameterValue.value : [parameterValue.value];
-                                    realParameterValues.forEach(function (realParameterValue, realParameterValueIndex) {
-                                        _this.expressionMap.nativeParameters[parameterName + (parameterBaseCount + realParameterValueIndex)] = realParameterValue;
-                                        parameterIndex_1++;
-                                        parameters_1.push(_this.connection.driver.createParameter(parameterName + (parameterBaseCount + realParameterValueIndex), parameterIndex_1 - 1));
-                                    });
+                                    if (parameterValue.objectLiteralParameters) {
+                                        _this.setParameters(parameterValue.objectLiteralParameters);
+                                    }
+                                    else {
+                                        var realParameterValues = parameterValue.multipleParameters ? parameterValue.value : [parameterValue.value];
+                                        realParameterValues.forEach(function (realParameterValue, realParameterValueIndex) {
+                                            _this.expressionMap.nativeParameters[parameterName + (parameterBaseCount + realParameterValueIndex)] = realParameterValue;
+                                            parameterIndex_1++;
+                                            parameters_1.push(_this.connection.driver.createParameter(parameterName + (parameterBaseCount + realParameterValueIndex), parameterIndex_1 - 1));
+                                        });
+                                    }
                                 }
                                 return _this.computeFindOperatorExpression(parameterValue, aliasPath, parameters_1);
                             }
@@ -665,6 +794,7 @@ var QueryBuilder = /** @class */ (function () {
      * Gets SQL needs to be inserted into final query.
      */
     QueryBuilder.prototype.computeFindOperatorExpression = function (operator, aliasPath, parameters) {
+        var driver = this.connection.driver;
         switch (operator.type) {
             case "not":
                 if (operator.child) {
@@ -683,13 +813,18 @@ var QueryBuilder = /** @class */ (function () {
                 return aliasPath + " >= " + parameters[0];
             case "equal":
                 return aliasPath + " = " + parameters[0];
+            case "ilike":
+                if (driver instanceof PostgresDriver || driver instanceof CockroachDriver) {
+                    return aliasPath + " ILIKE " + parameters[0];
+                }
+                return "UPPER(" + aliasPath + ") LIKE UPPER(" + parameters[0] + ")";
             case "like":
                 return aliasPath + " LIKE " + parameters[0];
             case "between":
                 return aliasPath + " BETWEEN " + parameters[0] + " AND " + parameters[1];
             case "in":
-                if ((this.connection.driver instanceof OracleDriver || this.connection.driver instanceof MysqlDriver) && parameters.length === 0) {
-                    return aliasPath + " IN (null)";
+                if (parameters.length === 0) {
+                    return "0=1";
                 }
                 return aliasPath + " IN (" + parameters.join(", ") + ")";
             case "any":
@@ -697,8 +832,8 @@ var QueryBuilder = /** @class */ (function () {
             case "isNull":
                 return aliasPath + " IS NULL";
             case "raw":
-                if (typeof operator.value === "function") {
-                    return operator.value(aliasPath);
+                if (operator.getSql) {
+                    return operator.getSql(aliasPath);
                 }
                 else {
                     return aliasPath + " = " + operator.value;