pogi 2.10.2 → 3.0.0-beta2

package/lib/pgDb.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PgDb = exports.TranzactionIsolationLevel = exports.FieldType = void 0;
+exports.PgDb = exports.FieldType = void 0;
 const tslib_1 = require("tslib");
 const queryAble_1 = require("./queryAble");
 const pgTable_1 = require("./pgTable");
@@ -32,13 +32,20 @@ FROM pg_proc p
 WHERE n.nspname NOT IN ('pg_catalog', 'pg_constraint', 'information_schema')
   AND tr.oid is null;`;
 const GET_CURRENT_SCHEMAS = "SELECT current_schemas(false)";
-const LIST_SPECIAL_TYPE_FIELDS = `SELECT c.nspname as schema_name, b.relname as table_name, a.attname as column_name, a.atttypid as typid 
+const LIST_SPECIAL_TYPE_FIELDS = `SELECT c.nspname as schema_name, b.relname as table_name, a.attname as column_name, a.atttypid as typid, t.typcategory
     FROM pg_attribute a 
     JOIN pg_class b ON (a.attrelid = b.oid)
     JOIN pg_type t ON (a.atttypid = t.oid)
     JOIN pg_namespace c ON (b.relnamespace=c.oid) 
     WHERE (a.atttypid in (114, 3802, 1082, 1083, 1114, 1184, 1266, 3614) or t.typcategory='A')
     AND reltype>0 `;
+const TYPE2OID = `SELECT t.oid, typname FROM pg_catalog.pg_type t WHERE typname in (
+    '_bool',
+    'int8','_int2','_int4','_int8','_float4','float8','_float8',
+    '_text','_varchar',
+    'json','jsonb', '_json','_jsonb',
+    'date','time','timestamp','timestamptz','timetz','_date','_time','_timestamp','_timestamptz','_timetz', 
+    'tsvector')`;
 var FieldType;
 (function (FieldType) {
     FieldType[FieldType["JSON"] = 0] = "JSON";
@@ -46,25 +53,29 @@ var FieldType;
     FieldType[FieldType["TIME"] = 2] = "TIME";
     FieldType[FieldType["TSVECTOR"] = 3] = "TSVECTOR";
 })(FieldType = exports.FieldType || (exports.FieldType = {}));
-var TranzactionIsolationLevel;
-(function (TranzactionIsolationLevel) {
-    TranzactionIsolationLevel["serializable"] = "SERIALIZABLE";
-    TranzactionIsolationLevel["repeatableRead"] = "REPEATABLE READ";
-    TranzactionIsolationLevel["readCommitted"] = "READ COMMITTED";
-    TranzactionIsolationLevel["readUncommitted"] = "READ UNCOMMITTED";
-})(TranzactionIsolationLevel = exports.TranzactionIsolationLevel || (exports.TranzactionIsolationLevel = {}));
 class PgDb extends queryAble_1.QueryAble {
-    constructor(pgdb = {}) {
+    constructor(pgdb) {
         super();
+        this.connection = null;
         this.tables = {};
         this.fn = {};
         this.pgdbTypeParsers = {};
+        this.knownOids = {};
         this.listeners = new EventEmitter();
+        this.connectionForListen = null;
+        this._needToRestartConnectionForListen = false;
+        this.restartConnectionForListen = null;
+        this.notificationListener = (notification) => this.listeners.emit(notification.channel, notification);
+        this.errorListener = (e) => {
+            this._needToRestartConnectionForListen = true;
+            this.tryToFixConnectionForListenActively();
+        };
         this.schemas = {};
-        this.config = pgdb.config;
+        this.config = pgdb.config || {};
         this.pool = pgdb.pool;
         this.postProcessResult = pgdb.postProcessResult;
         this.pgdbTypeParsers = pgdb.pgdbTypeParsers || {};
+        this.knownOids = pgdb.knownOids || {};
         this.db = this;
         if (pgdb.getLogger) {
             this.setLogger(pgdb.getLogger());
@@ -80,14 +91,14 @@ class PgDb extends queryAble_1.QueryAble {
                     schema[tableName] = schema.tables[tableName];
             }
         }
-        this.defaultSchemas = pgdb.defaultSchemas;
+        this.defaultSchemas = pgdb.defaultSchemas || [];
         this.setDefaultTablesAndFunctions();
     }
     setPostProcessResult(f) {
         this.postProcessResult = f;
     }
     static getInstance(config) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             if (config.connectionString) {
                 let res = CONNECTION_URL_REGEXP.exec(config.connectionString);
                 if (res) {
@@ -102,7 +113,7 @@ class PgDb extends queryAble_1.QueryAble {
             if (!PgDb.instances) {
                 PgDb.instances = {};
             }
-            if (PgDb.instances[connectionString]) {
+            if (PgDb.instances[connectionString] != null) {
                 return PgDb.instances[connectionString];
             }
             else {
@@ -113,18 +124,18 @@ class PgDb extends queryAble_1.QueryAble {
         });
     }
     close() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             for (let cs in PgDb.instances) {
                 let db = yield PgDb.instances[cs];
                 if (db.pool == this.pool) {
                     delete PgDb.instances[cs];
                 }
             }
-            yield this.pool.end();
+            yield new Promise((resolve) => this.pool.end(resolve));
         });
     }
     static connect(config) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             if (config.connectionString) {
                 let res = CONNECTION_URL_REGEXP.exec(config.connectionString);
                 if (res) {
@@ -141,7 +152,7 @@ class PgDb extends queryAble_1.QueryAble {
         });
     }
     init() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             this.pool = new pg.Pool(_.omit(this.config, ['logger', 'skipUndefined']));
             if (this.config.logger)
                 this.setLogger(this.config.logger);
@@ -154,16 +165,16 @@ class PgDb extends queryAble_1.QueryAble {
         });
     }
     reload() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             yield this.initSchemasAndTables();
             yield this.initFieldTypes();
         });
     }
     initSchemasAndTables() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             let schemasAndTables = yield this.query(LIST_SCHEMAS_TABLES);
             let functions = yield this.query(GET_SCHEMAS_PROCEDURES);
-            this.defaultSchemas = PgConverters.arraySplit(yield this.queryOneField(GET_CURRENT_SCHEMAS));
+            this.defaultSchemas = yield this.queryOneField(GET_CURRENT_SCHEMAS);
             let oldSchemaNames = Object.keys(this.schemas);
             for (let sc of oldSchemaNames) {
                 if (this[sc] === this.schemas[sc])
@@ -203,145 +214,225 @@ class PgDb extends queryAble_1.QueryAble {
         }
     }
     initFieldTypes() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             let schemaNames = "'" + Object.keys(this.schemas).join("', '") + "'";
             if (schemaNames == "''") {
                 this.getLogger(true).error("No readable schema found!");
                 return;
             }
+            let type2oid = {};
+            let res = yield this.query(TYPE2OID);
+            for (let tt of res || []) {
+                type2oid[tt.typname] = +tt.oid;
+            }
             let specialTypeFields = yield this.query(LIST_SPECIAL_TYPE_FIELDS + ' AND c.nspname in (' + schemaNames + ')');
             for (let r of specialTypeFields) {
                 if (this.schemas[r.schema_name][r.table_name]) {
                     this.schemas[r.schema_name][r.table_name].fieldTypes[r.column_name] =
-                        ([3802, 114].indexOf(r.typid) > -1) ? FieldType.JSON :
-                            ([3614].indexOf(r.typid) > -1) ? FieldType.TSVECTOR :
-                                ([1082, 1083, 1114, 1184, 1266].indexOf(r.typid) > -1) ? FieldType.TIME :
+                        ([type2oid['json'], type2oid['jsonb']].indexOf(r.typid) > -1) ? FieldType.JSON :
+                            ([type2oid['tsvector']].indexOf(r.typid) > -1) ? FieldType.TSVECTOR :
+                                ([type2oid['date'], type2oid['time'], type2oid['timestamp'], type2oid['timestamptz'], type2oid['timetz']].indexOf(r.typid) > -1) ? FieldType.TIME :
                                     FieldType.ARRAY;
                 }
             }
+            let builtInArrayTypeParsers = [
+                {
+                    oidList: [
+                        type2oid['_bool']
+                    ],
+                    parser: PgConverters.parseBooleanArray
+                },
+                {
+                    oidList: [
+                        type2oid['_int2'],
+                        type2oid['_int4'],
+                        type2oid['_float4'],
+                    ],
+                    parser: PgConverters.parseNumberArray
+                },
+                {
+                    oidList: [
+                        type2oid['_text'],
+                        type2oid['_varchar']
+                    ],
+                    parser: PgConverters.parseArray
+                },
+                {
+                    oidList: [
+                        type2oid['_json'],
+                        type2oid['_jsonb']
+                    ],
+                    parser: PgConverters.parseJsonArray
+                },
+                {
+                    oidList: [
+                        type2oid['_date'],
+                        type2oid['_time'],
+                        type2oid['_timetz'],
+                        type2oid['_timestamp'],
+                        type2oid['_timestamptz'],
+                    ],
+                    parser: PgConverters.parseDateArray
+                }
+            ];
+            builtInArrayTypeParsers.forEach(parserObj => {
+                parserObj.oidList.forEach(oid => {
+                    pg.types.setTypeParser(oid, parserObj.parser);
+                    delete this.pgdbTypeParsers[oid];
+                    this.knownOids[oid] = true;
+                });
+            });
             for (let r of specialTypeFields) {
+                if (this.knownOids[r.typid] && !this.pgdbTypeParsers[r.typid]) {
+                    continue;
+                }
                 switch (r.typid) {
-                    case 114:
-                    case 3802:
-                    case 1082:
-                    case 1083:
-                    case 1114:
-                    case 1184:
-                    case 1266:
-                    case 3614:
-                        break;
-                    case 1005:
-                    case 1007:
-                    case 1021:
-                        pg.types.setTypeParser(r.typid, PgConverters.arraySplitToNum);
-                        break;
-                    case 1009:
-                    case 1015:
-                        pg.types.setTypeParser(r.typid, PgConverters.arraySplit);
-                        break;
-                    case 3807:
-                        pg.types.setTypeParser(r.typid, PgConverters.arraySplitToJson);
-                        break;
-                    case 1016:
-                    case 1022:
-                        break;
-                    case 1115:
-                    case 1182:
-                    case 1183:
-                    case 1185:
-                    case 1270:
-                        pg.types.setTypeParser(r.typid, PgConverters.arraySplitToDate);
+                    case type2oid['json']:
+                    case type2oid['jsonb']:
+                    case type2oid['date']:
+                    case type2oid['time']:
+                    case type2oid['timetz']:
+                    case type2oid['timestamp']:
+                    case type2oid['timestamptz']:
+                    case type2oid['tsvector']:
+                    case type2oid['_int8']:
+                    case type2oid['_float8']:
                         break;
                     default:
-                        pg.types.setTypeParser(r.typid, PgConverters.arraySplit);
+                        pg.types.setTypeParser(r.typid, PgConverters.parseArray);
+                        delete this.pgdbTypeParsers[r.typid];
                 }
             }
-            yield this.setPgDbTypeParser('int8', PgConverters.numWithValidation);
-            yield this.setPgDbTypeParser('float8', PgConverters.numWithValidation);
-            yield this.setPgDbTypeParser('_int8', PgConverters.stringArrayToNumWithValidation);
-            yield this.setPgDbTypeParser('_float8', PgConverters.stringArrayToNumWithValidation);
+            this.pgdbTypeParsers[type2oid['int8']] = PgConverters.parseNumberWithValidation;
+            this.pgdbTypeParsers[type2oid['float8']] = PgConverters.parseNumberWithValidation;
+            this.pgdbTypeParsers[type2oid['_int8']] = PgConverters.parseNumberArrayWithValidation;
+            this.pgdbTypeParsers[type2oid['_float8']] = PgConverters.parseNumberArrayWithValidation;
+            this.knownOids[type2oid['int8']] = true;
+            this.knownOids[type2oid['float8']] = true;
+            this.knownOids[type2oid['_int8']] = true;
+            this.knownOids[type2oid['_float8']] = true;
+            let allUsedTypeFields = yield this.queryOneColumn(`
+            SELECT distinct a.atttypid as typid
+            FROM pg_attribute a
+                JOIN pg_class b ON (a.attrelid = b.oid)
+                JOIN pg_type t ON (a.atttypid = t.oid)
+                JOIN pg_namespace c ON (b.relnamespace=c.oid)
+            WHERE
+                reltype>0 AND
+                c.nspname in (${schemaNames})`);
+            allUsedTypeFields.forEach(oid => this.knownOids[oid] = true);
         });
     }
     setTypeParser(typeName, parser, schemaName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             try {
                 if (schemaName) {
                     let oid = yield this.queryOneField(GET_OID_FOR_COLUMN_TYPE_FOR_SCHEMA, { typeName, schemaName });
                     pg.types.setTypeParser(oid, parser);
                     delete this.pgdbTypeParsers[oid];
+                    this.knownOids[oid] = true;
                 }
                 else {
                     let list = yield this.queryOneColumn(GET_OID_FOR_COLUMN_TYPE, { typeName });
                     list.forEach(oid => {
                         pg.types.setTypeParser(oid, parser);
                         delete this.pgdbTypeParsers[oid];
+                        this.knownOids[oid] = true;
                     });
                 }
             }
             catch (e) {
-                throw Error('Not existing type: ' + typeName);
+                throw new Error('Not existing type: ' + typeName);
             }
         });
     }
     setPgDbTypeParser(typeName, parser, schemaName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             try {
                 if (schemaName) {
                     let oid = yield this.queryOneField(GET_OID_FOR_COLUMN_TYPE_FOR_SCHEMA, { typeName, schemaName });
                     this.pgdbTypeParsers[oid] = parser;
+                    this.knownOids[oid] = true;
                 }
                 else {
                     let list = yield this.queryOneColumn(GET_OID_FOR_COLUMN_TYPE, { typeName });
-                    list.forEach(oid => this.pgdbTypeParsers[oid] = parser);
+                    list.forEach(oid => {
+                        this.pgdbTypeParsers[oid] = parser;
+                        this.knownOids[oid] = true;
+                    });
                 }
             }
             catch (e) {
-                throw Error('Not existing type: ' + typeName);
+                throw new Error('Not existing type: ' + typeName);
+            }
+        });
+    }
+    resetMissingParsers(connection, oidList) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            let unknownOids = oidList.filter(oid => !this.knownOids[oid]);
+            if (unknownOids.length) {
+                let fieldsData = yield connection.query(`select oid, typcategory from pg_type where oid = ANY($1)`, [unknownOids]);
+                fieldsData.rows.forEach(fieldData => {
+                    if (fieldData.typcategory == 'A') {
+                        this.pgdbTypeParsers[fieldData.oid] = PgConverters.parseArray;
+                    }
+                    this.knownOids[fieldData.oid] = true;
+                });
             }
         });
     }
     dedicatedConnectionBegin() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            if (this.needToFixConnectionForListen()) {
+                yield this.runRestartConnectionForListen();
+            }
             let pgDb = new PgDb(this);
             pgDb.connection = yield this.pool.connect();
+            pgDb.connection.on('error', queryAble_1.QueryAble.connectionErrorListener);
             return pgDb;
         });
     }
     dedicatedConnectionEnd() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             if (this.connection) {
-                yield this.connection.release();
+                this.connection.off('error', queryAble_1.QueryAble.connectionErrorListener);
+                try {
+                    yield this.connection.release();
+                }
+                catch (err) {
+                    this.getLogger().error('Error while dedicated connection end.', err);
+                }
                 this.connection = null;
             }
             return this;
         });
     }
     savePoint(name) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             if (this.isTransactionActive()) {
                 name = (name || '').replace(/"/g, '');
                 yield this.query(`SAVEPOINT "${name}"`);
             }
             else {
-                throw Error('No active transaction');
+                throw new Error('No active transaction');
             }
             return this;
         });
     }
     savePointRelease(name) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             if (this.isTransactionActive()) {
                 name = (name || '').replace(/"/g, '');
                 yield this.query(`RELEASE SAVEPOINT "${name}"`);
             }
             else {
-                throw Error('No active transaction');
+                throw new Error('No active transaction');
             }
             return this;
         });
     }
     transactionBegin(options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             let pgDb = this.connection ? this : yield this.dedicatedConnectionBegin();
             let q = 'BEGIN';
             if (options === null || options === void 0 ? void 0 : options.isolationLevel) {
@@ -358,13 +449,13 @@ class PgDb extends queryAble_1.QueryAble {
         });
     }
     transactionCommit() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             yield this.query('COMMIT');
             return this.dedicatedConnectionEnd();
         });
     }
     transactionRollback(options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             if (options === null || options === void 0 ? void 0 : options.savePoint) {
                 let name = (options.savePoint || '').replace(/"/g, '');
                 yield this.query(`ROLLBACK TO SAVEPOINT "${name}"`);
@@ -380,7 +471,7 @@ class PgDb extends queryAble_1.QueryAble {
         return this.connection != null;
     }
     execute(fileName, statementTransformerFunction) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             let isTransactionInPlace = this.isTransactionActive();
             let pgdb = isTransactionInPlace ? this : yield this.dedicatedConnectionBegin();
             let runStatementList = (statementList) => {
@@ -434,7 +525,7 @@ class PgDb extends queryAble_1.QueryAble {
                                     let s = line.slice(SQL_TOKENIZER_REGEXP.lastIndex - 1);
                                     let token = s.match(SQL_$_ESCAPE_REGEXP);
                                     if (!token) {
-                                        throw Error('Invalid sql in line: ' + line);
+                                        throw new Error('Invalid sql in line: ' + line);
                                     }
                                     inQuotedString = token[0];
                                     SQL_TOKENIZER_REGEXP.lastIndex += inQuotedString.length - 1;
@@ -523,46 +614,148 @@ class PgDb extends queryAble_1.QueryAble {
         });
     }
     listen(channel, callback) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (!this.connectionForListen) {
-                this.connectionForListen = yield this.pool.connect();
-                this.connectionForListen.on('notification', (notification) => this.listeners.emit(notification.channel, notification));
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            let restartConnectionError = null;
+            if (this.needToFixConnectionForListen()) {
+                restartConnectionError = yield this.runRestartConnectionForListen();
             }
-            if (!this.listeners.listenerCount(channel)) {
-                yield this.connectionForListen.query('LISTEN ' + channel);
+            if (this.listeners.listenerCount(channel)) {
+                this.listeners.on(channel, callback);
+            }
+            else {
+                if (restartConnectionError) {
+                    throw restartConnectionError;
+                }
+                try {
+                    if (!this.connectionForListen) {
+                        yield this.initConnectionForListen();
+                    }
+                    yield this.connectionForListen.query(`LISTEN "${channel}"`);
+                }
+                catch (err) {
+                    this._needToRestartConnectionForListen = true;
+                    throw err;
+                }
+                this.listeners.on(channel, callback);
             }
-            this.listeners.on(channel, callback);
         });
     }
     unlisten(channel, callback) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (!this.connectionForListen) {
-                this.listeners.removeAllListeners();
-                return;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            let restartConnectionError = null;
+            if (this.needToFixConnectionForListen()) {
+                restartConnectionError = yield this.runRestartConnectionForListen();
             }
-            if (callback) {
+            if (callback && this.listeners.listenerCount(channel) > 1) {
                 this.listeners.removeListener(channel, callback);
             }
             else {
+                if (restartConnectionError) {
+                    throw restartConnectionError;
+                }
+                try {
+                    yield this.internalQuery({ connection: this.connectionForListen, sql: `UNLISTEN "${channel}"` });
+                    if (this.connectionForListen && this.listeners.eventNames().length == 1) {
+                        this.connectionForListen.removeAllListeners('notification');
+                        this.connectionForListen.release();
+                        this.connectionForListen = null;
+                    }
+                }
+                catch (err) {
+                    this._needToRestartConnectionForListen = true;
+                    throw err;
+                }
                 this.listeners.removeAllListeners(channel);
             }
-            if (!this.listeners.listenerCount(channel)) {
-                yield this.internalQuery({ connection: this.connectionForListen, sql: 'UNLISTEN ' + channel });
-            }
-            let allListeners = this.listeners.eventNames().reduce((sum, ename) => sum + this.listeners.listenerCount(ename), 0);
-            if (!allListeners && this.connectionForListen) {
-                this.connectionForListen.removeAllListeners('notification');
-                this.connectionForListen.release();
-                this.connectionForListen = null;
-            }
         });
     }
     notify(channel, payload) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            if (this.needToFixConnectionForListen()) {
+                let restartConnectionError = yield this.runRestartConnectionForListen();
+                if (restartConnectionError) {
+                    throw restartConnectionError;
+                }
+            }
+            let hasConnectionForListen = !!this.connectionForListen;
             let connection = this.connectionForListen || this.connection;
             let sql = 'SELECT pg_notify(:channel, :payload)';
             let params = { channel, payload };
-            return this.internalQuery({ connection, sql, params });
+            try {
+                return this.internalQuery({ connection, sql, params });
+            }
+            catch (err) {
+                if (hasConnectionForListen) {
+                    this._needToRestartConnectionForListen = true;
+                }
+                throw err;
+            }
+        });
+    }
+    runRestartConnectionForListen() {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            if (!this._needToRestartConnectionForListen) {
+                return null;
+            }
+            let errorResult = null;
+            if (!this.restartConnectionForListen) {
+                this.restartConnectionForListen = (() => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+                    let eventNames = this.listeners.eventNames();
+                    if (this.connectionForListen) {
+                        try {
+                            this.connectionForListen.on('notification', this.notificationListener);
+                            this.connectionForListen.on('error', this.errorListener);
+                        }
+                        catch (e) { }
+                        try {
+                            yield this.connectionForListen.release();
+                        }
+                        catch (e) { }
+                        this.connectionForListen = null;
+                    }
+                    let error = null;
+                    if (eventNames.length) {
+                        try {
+                            yield this.initConnectionForListen();
+                            for (let channel of eventNames) {
+                                yield this.connectionForListen.query(`LISTEN "${channel}"`);
+                            }
+                        }
+                        catch (err) {
+                            error = err;
+                        }
+                    }
+                    return error;
+                }))();
+                errorResult = yield this.restartConnectionForListen;
+                this.restartConnectionForListen = null;
+            }
+            else {
+                errorResult = yield this.restartConnectionForListen;
+            }
+            if (!errorResult) {
+                this._needToRestartConnectionForListen = false;
+            }
+            return errorResult;
+        });
+    }
+    needToFixConnectionForListen() {
+        return this._needToRestartConnectionForListen;
+    }
+    tryToFixConnectionForListenActively() {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            yield new Promise(r => setTimeout(r, 1000));
+            let error = yield this.runRestartConnectionForListen();
+            if (error) {
+                yield this.tryToFixConnectionForListenActively();
+            }
+        });
+    }
+    initConnectionForListen() {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            this.connectionForListen = yield this.pool.connect();
+            this.connectionForListen.on('notification', this.notificationListener);
+            this.connectionForListen.on('error', this.errorListener);
         });
     }
 }