typeorm 0.2.38 → 0.2.39-dev.1649882

package/browser/driver/cockroachdb/CockroachQueryRunner.js

@@ -16,7 +16,6 @@ import { BaseQueryRunner } from "../../query-runner/BaseQueryRunner";
 import { OrmUtils } from "../../util/OrmUtils";
 import { TableCheck } from "../../schema-builder/table/TableCheck";
 import { TableExclusion } from "../../schema-builder/table/TableExclusion";
-import { BroadcasterResult } from "../../subscriber/BroadcasterResult";
 import { TypeORMError } from "../../error";
 /**
  * Runs queries on a single postgres database connection.
@@ -93,42 +92,32 @@ var CockroachQueryRunner = /** @class */ (function (_super) {
      */
     CockroachQueryRunner.prototype.startTransaction = function (isolationLevel) {
         return __awaiter(this, void 0, void 0, function () {
-            var beforeBroadcastResult, afterBroadcastResult;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (this.isTransactionActive)
                             throw new TransactionAlreadyStartedError();
-                        beforeBroadcastResult = new BroadcasterResult();
-                        this.broadcaster.broadcastBeforeTransactionStartEvent(beforeBroadcastResult);
-                        if (!(beforeBroadcastResult.promises.length > 0)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, Promise.all(beforeBroadcastResult.promises)];
+                        return [4 /*yield*/, this.broadcaster.broadcast('BeforeTransactionStart')];
                     case 1:
                         _a.sent();
-                        _a.label = 2;
-                    case 2:
                         this.isTransactionActive = true;
                         return [4 /*yield*/, this.query("START TRANSACTION")];
-                    case 3:
+                    case 2:
                         _a.sent();
                         return [4 /*yield*/, this.query("SAVEPOINT cockroach_restart")];
-                    case 4:
+                    case 3:
                         _a.sent();
-                        if (!isolationLevel) return [3 /*break*/, 6];
+                        if (!isolationLevel) return [3 /*break*/, 5];
                         return [4 /*yield*/, this.query("SET TRANSACTION ISOLATION LEVEL " + isolationLevel)];
-                    case 5:
+                    case 4:
                         _a.sent();
-                        _a.label = 6;
-                    case 6:
+                        _a.label = 5;
+                    case 5:
                         this.storeQueries = true;
-                        afterBroadcastResult = new BroadcasterResult();
-                        this.broadcaster.broadcastAfterTransactionStartEvent(afterBroadcastResult);
-                        if (!(afterBroadcastResult.promises.length > 0)) return [3 /*break*/, 8];
-                        return [4 /*yield*/, Promise.all(afterBroadcastResult.promises)];
-                    case 7:
+                        return [4 /*yield*/, this.broadcaster.broadcast('AfterTransactionStart')];
+                    case 6:
                         _a.sent();
-                        _a.label = 8;
-                    case 8: return [2 /*return*/];
+                        return [2 /*return*/];
                 }
             });
         });
@@ -139,80 +128,70 @@ var CockroachQueryRunner = /** @class */ (function (_super) {
      */
     CockroachQueryRunner.prototype.commitTransaction = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var beforeBroadcastResult, e_1, _a, _b, q, e_2_1, afterBroadcastResult;
+            var e_1, _a, _b, q, e_2_1;
             var e_2, _c;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
                         if (!this.isTransactionActive)
                             throw new TransactionNotStartedError();
-                        beforeBroadcastResult = new BroadcasterResult();
-                        this.broadcaster.broadcastBeforeTransactionCommitEvent(beforeBroadcastResult);
-                        if (!(beforeBroadcastResult.promises.length > 0)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, Promise.all(beforeBroadcastResult.promises)];
+                        return [4 /*yield*/, this.broadcaster.broadcast('BeforeTransactionCommit')];
                     case 1:
                         _d.sent();
+                        this.storeQueries = false;
                         _d.label = 2;
                     case 2:
-                        this.storeQueries = false;
-                        _d.label = 3;
-                    case 3:
-                        _d.trys.push([3, 6, , 18]);
+                        _d.trys.push([2, 5, , 17]);
                         return [4 /*yield*/, this.query("RELEASE SAVEPOINT cockroach_restart")];
-                    case 4:
+                    case 3:
                         _d.sent();
                         return [4 /*yield*/, this.query("COMMIT")];
-                    case 5:
+                    case 4:
                         _d.sent();
                         this.queries = [];
                         this.isTransactionActive = false;
-                        return [3 /*break*/, 18];
-                    case 6:
+                        return [3 /*break*/, 17];
+                    case 5:
                         e_1 = _d.sent();
-                        if (!(e_1.code === "40001")) return [3 /*break*/, 17];
+                        if (!(e_1.code === "40001")) return [3 /*break*/, 16];
                         return [4 /*yield*/, this.query("ROLLBACK TO SAVEPOINT cockroach_restart")];
-                    case 7:
+                    case 6:
                         _d.sent();
+                        _d.label = 7;
+                    case 7:
+                        _d.trys.push([7, 12, 13, 14]);
+                        _a = __values(this.queries), _b = _a.next();
                         _d.label = 8;
                     case 8:
-                        _d.trys.push([8, 13, 14, 15]);
-                        _a = __values(this.queries), _b = _a.next();
-                        _d.label = 9;
-                    case 9:
-                        if (!!_b.done) return [3 /*break*/, 12];
+                        if (!!_b.done) return [3 /*break*/, 11];
                         q = _b.value;
                         return [4 /*yield*/, this.query(q.query, q.parameters)];
-                    case 10:
+                    case 9:
                         _d.sent();
-                        _d.label = 11;
-                    case 11:
+                        _d.label = 10;
+                    case 10:
                         _b = _a.next();
-                        return [3 /*break*/, 9];
-                    case 12: return [3 /*break*/, 15];
-                    case 13:
+                        return [3 /*break*/, 8];
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
                         e_2_1 = _d.sent();
                         e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 15];
-                    case 14:
+                        return [3 /*break*/, 14];
+                    case 13:
                         try {
                             if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
                         finally { if (e_2) throw e_2.error; }
                         return [7 /*endfinally*/];
-                    case 15: return [4 /*yield*/, this.commitTransaction()];
-                    case 16:
+                    case 14: return [4 /*yield*/, this.commitTransaction()];
+                    case 15:
                         _d.sent();
-                        _d.label = 17;
-                    case 17: return [3 /*break*/, 18];
+                        _d.label = 16;
+                    case 16: return [3 /*break*/, 17];
+                    case 17: return [4 /*yield*/, this.broadcaster.broadcast('AfterTransactionCommit')];
                     case 18:
-                        afterBroadcastResult = new BroadcasterResult();
-                        this.broadcaster.broadcastAfterTransactionCommitEvent(afterBroadcastResult);
-                        if (!(afterBroadcastResult.promises.length > 0)) return [3 /*break*/, 20];
-                        return [4 /*yield*/, Promise.all(afterBroadcastResult.promises)];
-                    case 19:
                         _d.sent();
-                        _d.label = 20;
-                    case 20: return [2 /*return*/];
+                        return [2 /*return*/];
                 }
             });
         });
@@ -223,34 +202,24 @@ var CockroachQueryRunner = /** @class */ (function (_super) {
      */
     CockroachQueryRunner.prototype.rollbackTransaction = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var beforeBroadcastResult, afterBroadcastResult;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (!this.isTransactionActive)
                             throw new TransactionNotStartedError();
-                        beforeBroadcastResult = new BroadcasterResult();
-                        this.broadcaster.broadcastBeforeTransactionRollbackEvent(beforeBroadcastResult);
-                        if (!(beforeBroadcastResult.promises.length > 0)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, Promise.all(beforeBroadcastResult.promises)];
+                        return [4 /*yield*/, this.broadcaster.broadcast('BeforeTransactionRollback')];
                     case 1:
                         _a.sent();
-                        _a.label = 2;
-                    case 2:
                         this.storeQueries = false;
                         return [4 /*yield*/, this.query("ROLLBACK")];
-                    case 3:
+                    case 2:
                         _a.sent();
                         this.queries = [];
                         this.isTransactionActive = false;
-                        afterBroadcastResult = new BroadcasterResult();
-                        this.broadcaster.broadcastAfterTransactionRollbackEvent(afterBroadcastResult);
-                        if (!(afterBroadcastResult.promises.length > 0)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, Promise.all(afterBroadcastResult.promises)];
-                    case 4:
+                        return [4 /*yield*/, this.broadcaster.broadcast('AfterTransactionRollback')];
+                    case 3:
                         _a.sent();
-                        _a.label = 5;
-                    case 5: return [2 /*return*/];
+                        return [2 /*return*/];
                 }
             });
         });
@@ -259,103 +228,97 @@ var CockroachQueryRunner = /** @class */ (function (_super) {
      * Executes a given SQL query.
      */
     CockroachQueryRunner.prototype.query = function (query, parameters, useStructuredResult) {
-        var _this = this;
         if (useStructuredResult === void 0) { useStructuredResult = false; }
-        if (this.isReleased)
-            throw new QueryRunnerAlreadyReleasedError();
-        return new Promise(function (ok, fail) { return __awaiter(_this, void 0, void 0, function () {
-            var databaseConnection, queryStartTime_1, err_1;
-            var _this = this;
+        return __awaiter(this, void 0, void 0, function () {
+            var databaseConnection, queryStartTime, raw, maxQueryExecutionTime, queryEndTime, queryExecutionTime, result, err_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 2, , 3]);
+                        if (this.isReleased)
+                            throw new QueryRunnerAlreadyReleasedError();
                         return [4 /*yield*/, this.connect()];
                     case 1:
                         databaseConnection = _a.sent();
                         this.driver.connection.logger.logQuery(query, parameters, this);
-                        queryStartTime_1 = +new Date();
-                        databaseConnection.query(query, parameters, function (err, raw) {
-                            if (_this.isTransactionActive && _this.storeQueries)
-                                _this.queries.push({ query: query, parameters: parameters });
-                            // log slow queries if maxQueryExecution time is set
-                            var maxQueryExecutionTime = _this.driver.options.maxQueryExecutionTime;
-                            var queryEndTime = +new Date();
-                            var queryExecutionTime = queryEndTime - queryStartTime_1;
-                            if (maxQueryExecutionTime && queryExecutionTime > maxQueryExecutionTime)
-                                _this.driver.connection.logger.logQuerySlow(queryExecutionTime, query, parameters, _this);
-                            if (err) {
-                                if (err.code !== "40001")
-                                    _this.driver.connection.logger.logQueryError(err, query, parameters, _this);
-                                fail(new QueryFailedError(query, parameters, err));
-                            }
-                            else {
-                                var result = new QueryResult();
-                                if (raw.hasOwnProperty('rowCount')) {
-                                    result.affected = raw.rowCount;
-                                }
-                                if (raw.hasOwnProperty('rows')) {
-                                    result.records = raw.rows;
-                                }
-                                switch (raw.command) {
-                                    case "DELETE":
-                                        // for DELETE query additionally return number of affected rows
-                                        result.raw = [raw.rows, raw.rowCount];
-                                        break;
-                                    default:
-                                        result.raw = raw.rows;
-                                }
-                                if (useStructuredResult) {
-                                    ok(result);
-                                }
-                                else {
-                                    ok(result.raw);
-                                }
-                            }
-                        });
-                        return [3 /*break*/, 3];
+                        queryStartTime = +new Date();
+                        if (this.isTransactionActive && this.storeQueries) {
+                            this.queries.push({ query: query, parameters: parameters });
+                        }
+                        _a.label = 2;
                     case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, new Promise(function (ok, fail) {
+                                databaseConnection.query(query, parameters, function (err, raw) { return err ? fail(err) : ok(raw); });
+                            })];
+                    case 3:
+                        raw = _a.sent();
+                        maxQueryExecutionTime = this.driver.options.maxQueryExecutionTime;
+                        queryEndTime = +new Date();
+                        queryExecutionTime = queryEndTime - queryStartTime;
+                        if (maxQueryExecutionTime && queryExecutionTime > maxQueryExecutionTime) {
+                            this.driver.connection.logger.logQuerySlow(queryExecutionTime, query, parameters, this);
+                        }
+                        result = new QueryResult();
+                        if (raw.hasOwnProperty('rowCount')) {
+                            result.affected = raw.rowCount;
+                        }
+                        if (raw.hasOwnProperty('rows')) {
+                            result.records = raw.rows;
+                        }
+                        switch (raw.command) {
+                            case "DELETE":
+                                // for DELETE query additionally return number of affected rows
+                                result.raw = [raw.rows, raw.rowCount];
+                                break;
+                            default:
+                                result.raw = raw.rows;
+                        }
+                        if (useStructuredResult) {
+                            return [2 /*return*/, result];
+                        }
+                        else {
+                            return [2 /*return*/, result.raw];
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
                         err_1 = _a.sent();
-                        fail(err_1);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+                        if (err_1.code !== "40001") {
+                            this.driver.connection.logger.logQueryError(err_1, query, parameters, this);
+                        }
+                        throw new QueryFailedError(query, parameters, err_1);
+                    case 5: return [2 /*return*/];
                 }
             });
-        }); });
+        });
     };
     /**
      * Returns raw data stream.
      */
     CockroachQueryRunner.prototype.stream = function (query, parameters, onEnd, onError) {
-        var _this = this;
-        var QueryStream = this.driver.loadStreamDependency();
-        if (this.isReleased)
-            throw new QueryRunnerAlreadyReleasedError();
-        return new Promise(function (ok, fail) { return __awaiter(_this, void 0, void 0, function () {
-            var databaseConnection, stream, err_2;
+        return __awaiter(this, void 0, void 0, function () {
+            var QueryStream, databaseConnection, stream;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 2, , 3]);
+                        QueryStream = this.driver.loadStreamDependency();
+                        if (this.isReleased) {
+                            throw new QueryRunnerAlreadyReleasedError();
+                        }
                         return [4 /*yield*/, this.connect()];
                     case 1:
                         databaseConnection = _a.sent();
                         this.driver.connection.logger.logQuery(query, parameters, this);
                         stream = databaseConnection.query(new QueryStream(query, parameters));
-                        if (onEnd)
+                        if (onEnd) {
                             stream.on("end", onEnd);
-                        if (onError)
+                        }
+                        if (onError) {
                             stream.on("error", onError);
-                        ok(stream);
-                        return [3 /*break*/, 3];
-                    case 2:
-                        err_2 = _a.sent();
-                        fail(err_2);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+                        }
+                        return [2 /*return*/, stream];
                 }
             });
-        }); });
+        });
     };
     /**
      * Returns all available database names including system databases.
@@ -2193,7 +2156,7 @@ var CockroachQueryRunner = /** @class */ (function (_super) {
                         _d = [[]];
                         return [4 /*yield*/, this.query(tablesSql)];
                     case 3:
-                        _b.apply(_a, _c.concat([__spreadArray.apply(void 0, _d.concat([__read.apply(void 0, [_k.sent()])]))]));
+                        _b.apply(_a, _c.concat([__spreadArray.apply(void 0, _d.concat([__read.apply(void 0, [_k.sent()]), false]))]));
                         return [3 /*break*/, 6];
                     case 4:
                         tablesCondition = tableNames
@@ -2208,7 +2171,7 @@ var CockroachQueryRunner = /** @class */ (function (_super) {
                         _h = [[]];
                         return [4 /*yield*/, this.query(tablesSql)];
                     case 5:
-                        _f.apply(_e, _g.concat([__spreadArray.apply(void 0, _h.concat([__read.apply(void 0, [_k.sent()])]))]));
+                        _f.apply(_e, _g.concat([__spreadArray.apply(void 0, _h.concat([__read.apply(void 0, [_k.sent()]), false]))]));
                         _k.label = 6;
                     case 6:
                         if (dbTables.length === 0) {
@@ -2354,7 +2317,7 @@ var CockroachQueryRunner = /** @class */ (function (_super) {
                                                                 tableColumn.generationStrategy = "uuid";
                                                             }
                                                             else {
-                                                                tableColumn.default = dbColumn["column_default"].replace(/:::.*/, "");
+                                                                tableColumn.default = dbColumn["column_default"].replace(/:::[\w\s\[\]\"]+/g, "");
                                                                 tableColumn.default = tableColumn.default.replace(/^(-?[\d\.]+)$/, "($1)");
                                                             }
                                                         }