pogi 2.10.2 → 3.0.0-beta2

package/src/pgDb.ts

@@ -1,14 +1,17 @@
-import { QueryAble, ResultFieldType } from "./queryAble";
+import { QueryAble } from "./queryAble";
+import { IPgDb, ResultFieldType, PostProcessResultFunc, Notification, TranzactionIsolationLevel } from "./pgDbInterface";
+import { IPgTable } from "./pgTableInterface";
 import { PgTable } from "./pgTable";
 import { PgSchema } from "./pgSchema";
+import { IPgSchema } from "./pgSchemaInterface";
 import * as PgConverters from "./pgConverters";
 import { pgUtils } from "./pgUtils";
 import * as _ from 'lodash';
 import * as pg from 'pg';
 import * as readline from 'readline';
 import * as fs from 'fs';
-import {PgDbLogger} from './pgDbLogger';
-import {ConnectionOptions} from './connectionOptions';
+import { PgDbLogger } from './pgDbLogger';
+import { ConnectionOptions } from './connectionOptions';
 import * as EventEmitter from 'events';
 
 const CONNECTION_URL_REGEXP = /^postgres:\/\/(?:([^:]+)(?::([^@]*))?@)?([^\/:]+)?(?::([^\/]+))?\/(.*)$/;
@@ -57,7 +60,7 @@ const GET_CURRENT_SCHEMAS = "SELECT current_schemas(false)";
 /** We get back fields as well that we don't have access to, thus we need to filter those schemas that we have permission for
  * ... TODO check it for tables */
 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 
+    `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)
@@ -65,54 +68,59 @@ const LIST_SPECIAL_TYPE_FIELDS =
     WHERE (a.atttypid in (114, 3802, 1082, 1083, 1114, 1184, 1266, 3614) or t.typcategory='A')
     AND reltype>0 `;
 //AND c.nspname not in ('pg_catalog', 'pg_constraint', 'information_schema')
+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')`
 
 export enum FieldType { JSON, ARRAY, TIME, TSVECTOR }
 
-export enum TranzactionIsolationLevel {
-    serializable = 'SERIALIZABLE',
-    repeatableRead = 'REPEATABLE READ',
-    readCommitted = 'READ COMMITTED',
-    readUncommitted = 'READ UNCOMMITTED'
-}
-
-export type PostProcessResultFunc = (res: any[], fields: ResultFieldType[], logger: PgDbLogger) => void;
 
-/** LISTEN callback parameter */
-export interface Notification {
-    processId: number,
-    channel: string,
-    payload?: string
-}
 
-export class PgDb extends QueryAble {
+export class PgDb extends QueryAble implements IPgDb {
     protected static instances: { [index: string]: Promise<PgDb> };
     /*protected*/
-    pool;
-    connection;
+    pool: pg.Pool;
+    connection: pg.PoolClient | null = null;
 
-    protected connectionForListen;
     /*protected*/
     config: ConnectionOptions;
     /*protected*/
-    defaultSchemas; // for this.tables and this.fn
+    defaultSchemas: string[]; // for this.tables and this.fn
 
-    db;
+    db: IPgDb;
     schemas: { [name: string]: PgSchema };
     tables: { [name: string]: PgTable<any> } = {};
-    fn: { [name: string]: (...any) => any } = {};
+    fn: { [name: string]: (...args: any[]) => any } = {};
     [name: string]: any | PgSchema;
     /* protected */
-    pgdbTypeParsers = {};
+    pgdbTypeParsers: Record<string, (s: any) => any> = {};
     /* protected */
-    postProcessResult: PostProcessResultFunc;
-
-    private constructor(pgdb: { defaultSchemas?, config?, schemas?, pool?, pgdbTypeParsers?, getLogger?: () => any, postProcessResult?: PostProcessResultFunc } = {}) {
+    knownOids: Record<number, boolean> = {};
+    /* protected */
+    postProcessResult: PostProcessResultFunc | undefined | null;
+
+    private constructor(pgdb: {
+        defaultSchemas?: string[],
+        config?: ConnectionOptions,
+        schemas?: Record<string, PgSchema>,
+        pool?: pg.Pool,
+        pgdbTypeParsers?: Record<string, (s: any) => any>,
+        knownOids?: Record<number, boolean>,
+        getLogger?: () => any,
+        postProcessResult?: PostProcessResultFunc | null
+    }) {
         super();
         this.schemas = {};
-        this.config = pgdb.config;
-        this.pool = pgdb.pool;
+        this.config = pgdb.config || {};
+        // pool is initialized in init, because it is asynchronous, but it is needed to call after constructor
+        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());
@@ -130,11 +138,11 @@ export class PgDb extends QueryAble {
             }
         }
 
-        this.defaultSchemas = pgdb.defaultSchemas;
+        this.defaultSchemas = pgdb.defaultSchemas || [];
         this.setDefaultTablesAndFunctions();
     }
 
-    setPostProcessResult(f: (res: any[], fields: ResultFieldType[], logger: PgDbLogger) => void) {
+    setPostProcessResult(f: null | ((res: any[], fields: ResultFieldType[], logger: PgDbLogger) => void)) {
         this.postProcessResult = f;
     }
 
@@ -154,7 +162,7 @@ export class PgDb extends QueryAble {
         if (!PgDb.instances) {
             PgDb.instances = {};
         }
-        if (PgDb.instances[connectionString]) {
+        if (PgDb.instances[connectionString] != null) {
             return PgDb.instances[connectionString];
         } else {
             let pgdb = new PgDb({ config: config });
@@ -170,7 +178,7 @@ export class PgDb extends QueryAble {
                 delete PgDb.instances[cs];
             }
         }
-        await this.pool.end();
+        await new Promise<void>((resolve) => this.pool.end(resolve));
     }
 
     static async connect(config: ConnectionOptions): Promise<PgDb> {
@@ -213,7 +221,7 @@ export class PgDb extends QueryAble {
         let schemasAndTables = await this.query(LIST_SCHEMAS_TABLES);
         let functions = await this.query(GET_SCHEMAS_PROCEDURES);
 
-        this.defaultSchemas = PgConverters.arraySplit(await this.queryOneField(GET_CURRENT_SCHEMAS));
+        this.defaultSchemas = await this.queryOneField(GET_CURRENT_SCHEMAS);
 
         let oldSchemaNames = Object.keys(this.schemas);
         for (let sc of oldSchemaNames) {
@@ -260,121 +268,208 @@ export class PgDb extends QueryAble {
 
     private async initFieldTypes() {
         //--- init field types -------------------------------------------
-        let schemaNames =  "'" + Object.keys(this.schemas).join("', '") + "'";
-        if (schemaNames=="''") {
+        let schemaNames = "'" + Object.keys(this.schemas).join("', '") + "'";
+        if (schemaNames == "''") {
             this.getLogger(true).error("No readable schema found!");
             return;
         }
-        let specialTypeFields: { schema_name: string, table_name: string, column_name: string, typid: number }[]
+        let type2oid = {};
+        let res = await this.query(TYPE2OID);
+        for (let tt of res || []) {
+            type2oid[tt.typname] = +tt.oid;
+        }
+
+        let specialTypeFields: { schema_name: string, table_name: string, column_name: string, typid: number, typcategory: string }[]
             = await 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;
             }
         }
 
+        // https://web.archive.org/web/20160613215445/https://doxygen.postgresql.org/include_2catalog_2pg__type_8h_source.html
+        // https://github.com/lib/pq/blob/master/oid/types.go
+
+        let builtInArrayTypeParsers: { oidList: number[], parser: (s: string) => any }[] = [
+            {
+                oidList: [
+                    type2oid['_bool'] // bool[]
+                ],
+                parser: PgConverters.parseBooleanArray
+            },
+            {
+                oidList: [
+                    type2oid['_int2'], // smallInt[] int2[] 
+                    type2oid['_int4'], // integer[]  int4[]
+                    type2oid['_float4'],  // real[] float4[]
+                ],
+                parser: PgConverters.parseNumberArray
+            },
+            {
+                oidList: [
+                    type2oid['_text'], // text[]
+                    type2oid['_varchar']  // varchar[]
+                ],
+                parser: PgConverters.parseArray
+            },
+            {
+                oidList: [
+                    type2oid['_json'], // json[]
+                    type2oid['_jsonb'] // jsonb[]
+                ],
+                parser: PgConverters.parseJsonArray
+            },
+            {
+                oidList: [
+                    type2oid['_date'], // date[]
+                    type2oid['_time'],
+                    type2oid['_timetz'],
+                    type2oid['_timestamp'], //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) {
-            // https://doxygen.postgresql.org/include_2catalog_2pg__type_8h_source.html
+            if (this.knownOids[r.typid] && !this.pgdbTypeParsers[r.typid]) {
+                continue;
+            }
             switch (r.typid) {
-                case 114:  // json
-                case 3802: // jsonb
-                case 1082: // date
-                case 1083: // time
-                case 1114: // timestamp
-                case 1184: // timestamptz
-                case 1266: // timetz
-                case 3614: // tsvector
-                    break;
-                case 1005: // smallInt[] int2[]
-                case 1007: // integer[]  int4[]
-                case 1021: // real[] float4[]
-                    pg.types.setTypeParser(r.typid, PgConverters.arraySplitToNum);
-                    break;
-                case 1009: // text[]
-                case 1015: // varchar[]
-                    pg.types.setTypeParser(r.typid, PgConverters.arraySplit);
-                    break;
-                case 3807:
-                    pg.types.setTypeParser(r.typid, PgConverters.arraySplitToJson);
-                    break;
-                case 1016: // bigInt[] int8[]
-                case 1022: // double[] float8[]
-                    //pg.types.setTypeParser(r.typid, arraySplitToNumWithValidation);
-                    break;
-                case 1115: // timestamp[]
-                case 1182: // date[]
-                case 1183: // time[]
-                case 1185: // timestamptz[]
-                case 1270: // timetz[]
-                    pg.types.setTypeParser(r.typid, PgConverters.arraySplitToDate);
+                case type2oid['json']:
+                case type2oid['jsonb']:
+                case type2oid['date']: // date
+                case type2oid['time']: // time
+                case type2oid['timetz']: // timetz
+                case type2oid['timestamp']: // timestamp
+                case type2oid['timestamptz']: // timestamptz
+                case type2oid['tsvector']: // tsvector
+                case type2oid['_int8']: // bigInt[] int8[]
+                case type2oid['_float8']: // double[] float8[]
                     break;
                 default:
                     //best guess otherwise user need to specify
-                    pg.types.setTypeParser(r.typid, PgConverters.arraySplit);
+                    pg.types.setTypeParser(r.typid, PgConverters.parseArray);
+                    delete this.pgdbTypeParsers[r.typid];
             }
         }
-
-        //has to set outside of pgjs as it doesnt support exceptions (stop everything immediately)
-        await this.setPgDbTypeParser('int8', PgConverters.numWithValidation); //int8 - 20
-        await this.setPgDbTypeParser('float8', PgConverters.numWithValidation); //float8 - 701
-        await this.setPgDbTypeParser('_int8', PgConverters.stringArrayToNumWithValidation);
-        await 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 = await 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);
     }
 
     /**
      * if schemaName is null, it will be applied for all schemas
      */
-    async setTypeParser(typeName: string, parser: (string) => any, schemaName?: string): Promise<void> {
+    async setTypeParser(typeName: string, parser: (s: string) => any, schemaName?: string): Promise<void> {
         try {
             if (schemaName) {
                 let oid = await 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 = await 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);
         }
     }
 
-    async setPgDbTypeParser(typeName: string, parser: (string) => any, schemaName?: string): Promise<void> {
+    async setPgDbTypeParser(typeName: string, parser: (s: string) => any, schemaName?: string): Promise<void> {
         try {
             if (schemaName) {
                 let oid = await this.queryOneField(GET_OID_FOR_COLUMN_TYPE_FOR_SCHEMA, { typeName, schemaName });
                 this.pgdbTypeParsers[oid] = parser;
+                this.knownOids[oid] = true;
             } else {
                 let list = await 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);
+        }
+    }
+
+    async resetMissingParsers(connection: pg.PoolClient, oidList: number[]): Promise<void> {
+        let unknownOids = oidList.filter(oid => !this.knownOids[oid]);
+        if (unknownOids.length) {
+            let fieldsData = await 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;
+            });
         }
     }
 
     async dedicatedConnectionBegin(): Promise<PgDb> {
+        if (this.needToFixConnectionForListen()) {
+            await this.runRestartConnectionForListen();
+        }
         let pgDb = new PgDb(this);
         pgDb.connection = await this.pool.connect();
+        pgDb.connection.on('error', QueryAble.connectionErrorListener); //When there is an error, then the actual called query will throw exception
         return pgDb;
     }
 
     async dedicatedConnectionEnd(): Promise<PgDb> {
         if (this.connection) {
-            await this.connection.release();
+            this.connection.off('error', QueryAble.connectionErrorListener);
+            try {
+                await this.connection.release();
+            } catch (err) {
+                this.getLogger().error('Error while dedicated connection end.', err);
+            }
             this.connection = null;
         }
         return this;
     }
-    
+
     /** 
      * transaction save point
      * https://www.postgresql.org/docs/current/sql-savepoint.html 
@@ -384,7 +479,7 @@ export class PgDb extends QueryAble {
             name = (name || '').replace(/"/g, '');
             await this.query(`SAVEPOINT "${name}"`);
         } else {
-            throw Error('No active transaction');
+            throw new Error('No active transaction');
         }
         return this;
     }
@@ -398,12 +493,12 @@ export class PgDb extends QueryAble {
             name = (name || '').replace(/"/g, '');
             await this.query(`RELEASE SAVEPOINT "${name}"`);
         } else {
-            throw Error('No active transaction');
+            throw new Error('No active transaction');
         }
         return this;
     }
 
-    async transactionBegin(options?: { isolationLevel?: TranzactionIsolationLevel, deferrable?:boolean, readOnly?: boolean}): Promise<PgDb> {
+    async transactionBegin(options?: { isolationLevel?: TranzactionIsolationLevel, deferrable?: boolean, readOnly?: boolean }): Promise<PgDb> {
         let pgDb = this.connection ? this : await this.dedicatedConnectionBegin();
         let q = 'BEGIN'
         if (options?.isolationLevel) {
@@ -440,13 +535,13 @@ export class PgDb extends QueryAble {
         return this.connection != null;
     }
 
-    async execute(fileName: string, statementTransformerFunction?: (string) => string): Promise<void> {
+    async execute(fileName: string, statementTransformerFunction?: (s: string) => string): Promise<void> {
         let isTransactionInPlace = this.isTransactionActive();
         // statements must be run in a dedicated connection
         let pgdb = isTransactionInPlace ? this : await this.dedicatedConnectionBegin();
 
         /** run statements one after the other */
-        let runStatementList = (statementList) => {
+        let runStatementList = (statementList: string[]) => {
             //this.getLogger(true).log('consumer start', commands.length);
             return new Promise((resolve, reject) => {
                 let currentStatement = 0;
@@ -474,10 +569,10 @@ export class PgDb extends QueryAble {
 
         let lineCounter = 0;
         let promise = new Promise<void>((resolve, reject) => {
-            let statementList = [];
-            let tmp = '', t: RegExpExecArray;
-            let consumer;
-            let inQuotedString:string;
+            let statementList: string[] = [];
+            let tmp = '', t: RegExpExecArray | null;
+            let consumer: Promise<any> | null;
+            let inQuotedString: string | null;
             let rl = readline.createInterface({
                 input: fs.createReadStream(fileName),
                 terminal: false
@@ -498,7 +593,7 @@ export class PgDb extends 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;
@@ -563,7 +658,7 @@ export class PgDb extends QueryAble {
                 }
             });
         });
-        let error;
+        let error: Error | null;
         return promise
             .catch((e) => {
                 error = e;
@@ -586,21 +681,37 @@ export class PgDb extends QueryAble {
     }
 
     private listeners = new EventEmitter();
+    private connectionForListen: pg.PoolClient | null = null;
+    private _needToRestartConnectionForListen = false;
+    private restartConnectionForListen: Promise<Error | null> | null = null;
 
     /** 
      * LISTEN to a channel for a NOTIFY (https://www.postgresql.org/docs/current/sql-listen.html)
      * One connection will be dedicated for listening if there are any listeners.
      * When there is no other callback for a channel, LISTEN command is executed
      */
-    async listen(channel: string, callback: (notification:Notification) => void) {
-        if (!this.connectionForListen) {
-            this.connectionForListen = await this.pool.connect();
-            this.connectionForListen.on('notification', (notification: Notification) => this.listeners.emit(notification.channel, notification));
+    async listen(channel: string, callback: (notification: Notification) => void) {
+        let restartConnectionError: Error | null = null;
+        if (this.needToFixConnectionForListen()) {
+            restartConnectionError = await this.runRestartConnectionForListen();
         }
-        if (!this.listeners.listenerCount(channel)) {
-            await this.connectionForListen.query('LISTEN ' + channel);
+        if (this.listeners.listenerCount(channel)) {
+            this.listeners.on(channel, callback);
+        } else {
+            if (restartConnectionError) {
+                throw restartConnectionError;
+            }
+            try {
+                if (!this.connectionForListen) {
+                    await this.initConnectionForListen();
+                }
+                await this.connectionForListen!.query(`LISTEN "${channel}"`);
+            } catch (err) {
+                this._needToRestartConnectionForListen = true;
+                throw err;
+            }
+            this.listeners.on(channel, callback);
         }
-        this.listeners.on(channel, callback);
     }
 
     /**
@@ -608,37 +719,122 @@ export class PgDb extends QueryAble {
      * When all callback is removed from a channel UNLISTEN command is executed
      * When all callback is removed from all channel, dedicated connection is released
      */
-    async unlisten(channel: string, callback?: (Notification) => void) {
-        if (!this.connectionForListen) {
-            this.listeners.removeAllListeners();
-            return;
+    async unlisten(channel: string, callback?: (notification: Notification) => void) {
+        let restartConnectionError: Error | null = null;
+        if (this.needToFixConnectionForListen()) {
+            restartConnectionError = await this.runRestartConnectionForListen();
         }
-        if (callback) {
+        if (callback && this.listeners.listenerCount(channel) > 1) {
             this.listeners.removeListener(channel, callback);
         } else {
+            if (restartConnectionError) {
+                throw restartConnectionError;
+            }
+            try {
+                await 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)) {
-            await 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 a channel (https://www.postgresql.org/docs/current/sql-notify.html)
      */
     async notify(channel: string, payload?: string) {
+        if (this.needToFixConnectionForListen()) {
+            let restartConnectionError = await this.runRestartConnectionForListen();
+            if (restartConnectionError) {
+                throw restartConnectionError;
+            }
+        }
+        let hasConnectionForListen = !!this.connectionForListen;
         let connection = this.connectionForListen || this.connection;
         //let sql = 'NOTIFY ' + channel + ', :payload';
         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;
+        }
+    }
+
+    async runRestartConnectionForListen(): Promise<Error | null> {
+        if (!this._needToRestartConnectionForListen) {
+            return null;
+        }
+        let errorResult: Error | null = null;
+        if (!this.restartConnectionForListen) {
+            this.restartConnectionForListen = (async () => {
+                let eventNames = this.listeners.eventNames();
+                if (this.connectionForListen) {
+                    try {
+                        this.connectionForListen.on('notification', this.notificationListener);
+                        this.connectionForListen.on('error', this.errorListener);
+                    } catch (e) { }
+                    try {
+                        await this.connectionForListen.release();
+                    } catch (e) { }
+                    this.connectionForListen = null;
+                }
+                let error: Error | null = null;
+                if (eventNames.length) {
+                    try {
+                        await this.initConnectionForListen();
+                        for (let channel of eventNames) {
+                            await this.connectionForListen!.query(`LISTEN "${channel as string}"`);
+                        }
+                    } catch (err) {
+                        error = <Error>err;
+                    }
+                }
+                return error;
+            })();
+            errorResult = await this.restartConnectionForListen;
+            this.restartConnectionForListen = null;
+        } else {
+            errorResult = await this.restartConnectionForListen;
+        }
+        if (!errorResult) {
+            this._needToRestartConnectionForListen = false;
+        }
+        return errorResult;
+    }
+
+    needToFixConnectionForListen(): boolean {
+        return this._needToRestartConnectionForListen;
+    }
+
+    private async tryToFixConnectionForListenActively() {
+        await new Promise(r => setTimeout(r, 1000));
+        let error = await this.runRestartConnectionForListen();
+        if (error) {
+            await this.tryToFixConnectionForListenActively();
+        }
+    }
+
+    notificationListener = (notification: Notification) => this.listeners.emit(notification.channel, notification)
+
+    errorListener = (e: Error) => {
+        this._needToRestartConnectionForListen = true;
+        this.tryToFixConnectionForListenActively();
+    };
+
+    private async initConnectionForListen() {
+        this.connectionForListen = await this.pool.connect();
+        this.connectionForListen.on('notification', this.notificationListener);
+        this.connectionForListen.on('error', this.errorListener);
     }
 }