pogi 2.11.0

package/docs/transaction.md

@@ -0,0 +1,65 @@
+## Transaction
+as simple as:
+```js
+    let pgdb_nt; //no   transaction (using the pool)
+    let pgdb_wt; //with transaction
+
+    pgdb_nt = await PgDb.connect(..);
+    pgdb_wt = await pgdb_nt.transactionBegin();
+    try {
+        //look busy
+        
+        await pgdb_nt.query(..) //executed outside of the transaction
+        await pgdb_wt.query(..) //executed inside of the transaction
+        
+        await pgdb_wt.transactionCommit();
+    } catch(e) {
+        await pgdb_wt.transactionRollback();
+    }
+```
+
+active transaction can be tested with
+```js
+    if (pgdb.isTransactionActive()) {
+        //...
+    }
+```
+## Savepoint transaction like a subtransaction
+
+```js
+    //connection with transaction
+    let pgdb_wt = await pgdb.transactionBegin();
+    // ... do some work
+    pgdb_wt = await pgdb.savePoint('import');
+    try {
+        //... do import
+        await pgdb_wt.transactionCommit();
+    } catch(e) {
+        // rollback to "import" savepoint
+        await pgdb_wt.transactionRollback({savepoint:'import'}); 
+    }
+    // transaction continue from "import" savepoint
+```
+
+See [Postgresql documentation](https://www.postgresql.org/docs/current/sql-savepoint.html)
+
+## Dedicated connection
+PgDb use connection pool, so it run every query in a random connection from the pool. Connection pool size can be set at connection time with "poolSize" attribute, see [connection](/connection).
+Sometimes single connection mode is desired (ex: execute an SQL file), or if you want to use variables, or set the `search_path`.
+It is posibble and its usage very similar to transactions. `dedicatedConnectionBegin()` will create a new PgDb instance which is now in a dedicated connection mode.
+All further query will be run in the same connection, no pool is used. Programmer responsible to close dedicated connection with `dedicatedConnectionEnd()` to avoid leaking. 
+If closed, connection will get back to the pool and pgdb instance will work in pool mode.
+
+```js
+pgdb = await PgDb.connect(..);
+pgdb_1con = await pgdb.dedicatedConnectionBegin();
+try {
+    //do magic
+    await pgdb_1con.query(..);
+    await pgdb_1con.schema.table.find(..);
+    
+} finally {
+    //lets release it
+    await pgdb_1con.dedicatedConnectionEnd();
+}
+```

package/lib/bin/generateInterface.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/bin/generateInterface.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const pgDb_1 = require("../pgDb");
+const pgSchema_1 = require("../pgSchema");
+const pgTable_1 = require("../pgTable");
+(function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            let pgdb = yield pgDb_1.PgDb.connect({
+                logger: {
+                    log: () => {
+                    }, error: console.error
+                }
+            });
+            console.log('import {PgDb, PgSchema, PgTable} from "pogi";\n');
+            console.log('export interface PgDbType extends PgDb {');
+            for (let schemaName in pgdb.schemas) {
+                if (!(pgdb[schemaName] instanceof pgSchema_1.PgSchema)) {
+                    throw Error('Already existing property: ' + schemaName + '!');
+                }
+                console.log(`    '${schemaName}': PgSchema_${schemaName};`);
+            }
+            console.log(`    'schemas': {`);
+            for (let schemaName in pgdb.schemas) {
+                console.log(`        '${schemaName}': PgSchema_${schemaName};`);
+            }
+            console.log('    }');
+            console.log('}');
+            for (let schemaName in pgdb.schemas) {
+                console.log(`export interface PgSchema_${schemaName} extends PgSchema {`);
+                for (let tableName in pgdb.schemas[schemaName].tables) {
+                    if (!(pgdb[schemaName][tableName] instanceof pgTable_1.PgTable)) {
+                        throw Error('Already existing property: ' + tableName + ' on schema:' + schemaName + '!');
+                    }
+                    console.log(`    '${tableName}': PgTable<any>;`);
+                }
+                console.log(`    tables: {`);
+                for (let tableName in pgdb.schemas[schemaName].tables) {
+                    console.log(`        '${tableName}': PgTable<any>;`);
+                }
+                console.log('    }');
+                console.log('}');
+            }
+            pgdb.close();
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return Promise.resolve();
+    });
+})();
+//# sourceMappingURL=generateInterface.js.map

package/lib/bin/generateInterface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateInterface.js","sourceRoot":"","sources":["../../src/bin/generateInterface.ts"],"names":[],"mappings":";;;AAAA,kCAA6B;AAC7B,0CAAqC;AACrC,wCAAmC;AAEnC,CAAC;;QACG,IAAI;YACA,IAAI,IAAI,GAAG,MAAM,WAAI,CAAC,OAAO,CAAC;gBAC1B,MAAM,EAAE;oBACJ,GAAG,EAAE,GAAG,EAAE;oBACV,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK;iBAC1B;aACJ,CAAC,CAAC;YAEH,OAAO,CAAC,GAAG,CAAC,iDAAiD,CAAC,CAAC;YAC/D,OAAO,CAAC,GAAG,CAAC,0CAA0C,CAAC,CAAC;YAExD,KAAK,IAAI,UAAU,IAAI,IAAI,CAAC,OAAO,EAAE;gBACjC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,mBAAQ,CAAC,EAAE;oBACzC,MAAM,KAAK,CAAC,6BAA6B,GAAG,UAAU,GAAG,GAAG,CAAC,CAAC;iBACjE;gBACD,OAAO,CAAC,GAAG,CAAC,QAAQ,UAAU,eAAe,UAAU,GAAG,CAAC,CAAC;aAC/D;YAED,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;YAChC,KAAK,IAAI,UAAU,IAAI,IAAI,CAAC,OAAO,EAAE;gBACjC,OAAO,CAAC,GAAG,CAAC,YAAY,UAAU,eAAe,UAAU,GAAG,CAAC,CAAC;aACnE;YACD,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACrB,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAEjB,KAAK,IAAI,UAAU,IAAI,IAAI,CAAC,OAAO,EAAE;gBACjC,OAAO,CAAC,GAAG,CAAC,6BAA6B,UAAU,qBAAqB,CAAC,CAAC;gBAC1E,KAAK,IAAI,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE;oBACnD,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,YAAY,iBAAO,CAAC,EAAE;wBACnD,MAAM,KAAK,CAAC,6BAA6B,GAAG,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,GAAG,CAAC,CAAC;qBAC7F;oBACD,OAAO,CAAC,GAAG,CAAC,QAAQ,SAAS,kBAAkB,CAAC,CAAC;iBACpD;gBACD,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;gBAC7B,KAAK,IAAI,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE;oBACnD,OAAO,CAAC,GAAG,CAAC,YAAY,SAAS,kBAAkB,CAAC,CAAC;iBACxD;gBACD,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAErB,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;aACpB;YAGD,IAAI,CAAC,KAAK,EAAE,CAAC;SAChB;QAAC,OAAO,CAAC,EAAE;YACR,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SACpB;QACD,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;CAAA,CAAC,EAAE,CAAC"}

package/lib/connectionOptions.d.ts

@@ -0,0 +1,25 @@
+import { PgDbLogger } from './pgDbLogger';
+export interface ConnectionOptions {
+    host?: string;
+    user?: string;
+    database?: string;
+    password?: string;
+    port?: number;
+    poolSize?: number;
+    rows?: number;
+    min?: number;
+    max?: number;
+    binary?: boolean;
+    poolIdleTimeout?: number;
+    reapIntervalMillis?: number;
+    poolLog?: boolean;
+    client_encoding?: string;
+    ssl?: boolean | any;
+    application_name?: string;
+    fallback_application_name?: string;
+    parseInputDatesAsUTC?: boolean;
+    connectionString?: string;
+    idleTimeoutMillis?: number;
+    logger?: PgDbLogger;
+    skipUndefined?: 'all' | 'select' | 'none';
+}

package/lib/connectionOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=connectionOptions.js.map

package/lib/connectionOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionOptions.js","sourceRoot":"","sources":["../src/connectionOptions.ts"],"names":[],"mappings":""}

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { PgDb } from './pgDb';
+export { ConnectionOptions } from './connectionOptions';
+export { PgDbLogger } from './pgDbLogger';
+export { PgTable } from './pgTable';
+export { PgSchema } from './pgSchema';
+export { QueryOptions } from './queryAble';

package/lib/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgSchema = exports.PgTable = exports.PgDb = void 0;
+var pgDb_1 = require("./pgDb");
+Object.defineProperty(exports, "PgDb", { enumerable: true, get: function () { return pgDb_1.PgDb; } });
+var pgTable_1 = require("./pgTable");
+Object.defineProperty(exports, "PgTable", { enumerable: true, get: function () { return pgTable_1.PgTable; } });
+var pgSchema_1 = require("./pgSchema");
+Object.defineProperty(exports, "PgSchema", { enumerable: true, get: function () { return pgSchema_1.PgSchema; } });
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,+BAA8B;AAArB,4FAAA,IAAI,OAAA;AAGb,qCAAoC;AAA3B,kGAAA,OAAO,OAAA;AAChB,uCAAsC;AAA7B,oGAAA,QAAQ,OAAA"}

package/lib/pgConverters.d.ts

@@ -0,0 +1,10 @@
+export declare let arraySplit: (str: any) => any[];
+export declare let numWithValidation: (val: any) => number;
+export declare let numberOrNull: (val: any) => number;
+export declare let boolOrNull: (val: any) => boolean;
+export declare let arraySplitToBool: (val: any) => any;
+export declare let arraySplitToNum: (val: any) => any;
+export declare let arraySplitToNumWithValidation: (val: any) => any;
+export declare let stringArrayToNumWithValidation: (val: any) => any;
+export declare let arraySplitToDate: (val: any) => any;
+export declare let arraySplitToJson: (str: any) => any[];

package/lib/pgConverters.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arraySplitToJson = exports.arraySplitToDate = exports.stringArrayToNumWithValidation = exports.arraySplitToNumWithValidation = exports.arraySplitToNum = exports.arraySplitToBool = exports.boolOrNull = exports.numberOrNull = exports.numWithValidation = exports.arraySplit = void 0;
+const moment = require("moment");
+let arraySplit = (str) => {
+    if (str == "{}")
+        return [];
+    str = str.substring(1, str.length - 1);
+    let e = /(?:("(?:[^"\\]|\\.)*")|([^,"]*))(?:,|$)/g;
+    let valList = [];
+    let parsingResult;
+    do {
+        parsingResult = e.exec(str);
+        let valStr = (parsingResult[2] == 'NULL') ? null :
+            (parsingResult[1] == null ? parsingResult[2] : unescapeString(parsingResult[1]));
+        valList.push(valStr);
+    } while (e.lastIndex < str.length);
+    return valList;
+};
+exports.arraySplit = arraySplit;
+let numWithValidation = val => {
+    if (val === 'NULL') {
+        return null;
+    }
+    let v = +val;
+    if (v > Number.MAX_SAFE_INTEGER || v < Number.MIN_SAFE_INTEGER) {
+        throw Error("Number can't be represented in javascript precisely: " + val);
+    }
+    return v;
+};
+exports.numWithValidation = numWithValidation;
+let numberOrNull = val => {
+    if (val === 'NULL') {
+        return null;
+    }
+    return +val;
+};
+exports.numberOrNull = numberOrNull;
+let boolOrNull = val => {
+    if (val === 'NULL') {
+        return null;
+    }
+    return val == 't';
+};
+exports.boolOrNull = boolOrNull;
+let arraySplitToBool = val => val == "{}" ? [] : val.substring(1, val.length - 1).split(',').map(exports.boolOrNull);
+exports.arraySplitToBool = arraySplitToBool;
+let arraySplitToNum = val => val == "{}" ? [] : val.substring(1, val.length - 1).split(',').map(exports.numberOrNull);
+exports.arraySplitToNum = arraySplitToNum;
+let arraySplitToNumWithValidation = val => val == "{}" ? [] : val.substring(1, val.length - 1).split(',').map(exports.numWithValidation);
+exports.arraySplitToNumWithValidation = arraySplitToNumWithValidation;
+let stringArrayToNumWithValidation = val => val.map(exports.numWithValidation);
+exports.stringArrayToNumWithValidation = stringArrayToNumWithValidation;
+let arraySplitToDate = val => val == "{}" ? [] : val.substring(1, val.length - 1).split(',').map(d => d == 'NULL' ? null : moment(d.substring(1, d.length - 1)).toDate());
+exports.arraySplitToDate = arraySplitToDate;
+let arraySplitToJson = (str) => {
+    let vals = exports.arraySplit(str);
+    return vals.map(s => typeof s === 'string' ? JSON.parse(s) : s);
+};
+exports.arraySplitToJson = arraySplitToJson;
+function unescapeString(s) {
+    return s.slice(1, s.length - 1)
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, '\\');
+}
+//# sourceMappingURL=pgConverters.js.map

package/lib/pgConverters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgConverters.js","sourceRoot":"","sources":["../src/pgConverters.ts"],"names":[],"mappings":";;;AAAA,iCAAiC;AAG1B,IAAI,UAAU,GAAG,CAAC,GAAG,EAAE,EAAE;IAC5B,IAAI,GAAG,IAAI,IAAI;QAAE,OAAO,EAAE,CAAC;IAC3B,GAAG,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvC,IAAI,CAAC,GAAG,0CAA0C,CAAC;IACnD,IAAI,OAAO,GAAG,EAAE,CAAC;IACjB,IAAI,aAAa,CAAC;IAClB,GAAG;QACC,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC5B,IAAI,MAAM,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAC9C,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACrF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;KACxB,QAAQ,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,MAAM,EAAE;IACnC,OAAO,OAAO,CAAC;AACnB,CAAC,CAAC;AAbS,QAAA,UAAU,cAanB;AACK,IAAI,iBAAiB,GAAG,GAAG,CAAC,EAAE;IACjC,IAAI,GAAG,KAAK,MAAM,EAAE;QAChB,OAAO,IAAI,CAAC;KACf;IACD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;IACb,IAAI,CAAC,GAAG,MAAM,CAAC,gBAAgB,IAAI,CAAC,GAAG,MAAM,CAAC,gBAAgB,EAAE;QAC5D,MAAM,KAAK,CAAC,uDAAuD,GAAG,GAAG,CAAC,CAAC;KAC9E;IACD,OAAO,CAAC,CAAC;AACb,CAAC,CAAC;AATS,QAAA,iBAAiB,qBAS1B;AACK,IAAI,YAAY,GAAG,GAAG,CAAC,EAAE;IAC5B,IAAI,GAAG,KAAK,MAAM,EAAE;QAChB,OAAO,IAAI,CAAC;KACf;IACD,OAAO,CAAC,GAAG,CAAC;AAChB,CAAC,CAAC;AALS,QAAA,YAAY,gBAKrB;AACK,IAAI,UAAU,GAAG,GAAG,CAAC,EAAE;IAC1B,IAAI,GAAG,KAAK,MAAM,EAAE;QAChB,OAAO,IAAI,CAAC;KACf;IACD,OAAO,GAAG,IAAI,GAAG,CAAC;AACtB,CAAC,CAAA;AALU,QAAA,UAAU,cAKpB;AAEM,IAAI,gBAAgB,GAAG,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,kBAAU,CAAC,CAAC;AAAzG,QAAA,gBAAgB,oBAAyF;AAC7G,IAAI,eAAe,GAAG,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,oBAAY,CAAC,CAAC;AAA1G,QAAA,eAAe,mBAA2F;AAC9G,IAAI,6BAA6B,GAAG,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,yBAAiB,CAAC,CAAC;AAA7H,QAAA,6BAA6B,iCAAgG;AACjI,IAAI,8BAA8B,GAAG,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,yBAAiB,CAAC,CAAC;AAAnE,QAAA,8BAA8B,kCAAqC;AACvE,IAAI,gBAAgB,GAAG,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;AAAtK,QAAA,gBAAgB,oBAAsJ;AAC1K,IAAI,gBAAgB,GAAG,CAAC,GAAG,EAAE,EAAE;IAClC,IAAI,IAAI,GAAG,kBAAU,CAAC,GAAG,CAAC,CAAC;IAC3B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACpE,CAAC,CAAC;AAHS,QAAA,gBAAgB,oBAGzB;AAEF,SAAS,cAAc,CAAC,CAAC;IACrB,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;SAC1B,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC;SACpB,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;AAC/B,CAAC"}

package/lib/pgDb.d.ts

@@ -0,0 +1,86 @@
+import { QueryAble, ResultFieldType } from "./queryAble";
+import { PgTable } from "./pgTable";
+import { PgSchema } from "./pgSchema";
+import { PgDbLogger } from './pgDbLogger';
+import { ConnectionOptions } from './connectionOptions';
+export declare enum FieldType {
+    JSON = 0,
+    ARRAY = 1,
+    TIME = 2,
+    TSVECTOR = 3
+}
+export declare enum TranzactionIsolationLevel {
+    serializable = "SERIALIZABLE",
+    repeatableRead = "REPEATABLE READ",
+    readCommitted = "READ COMMITTED",
+    readUncommitted = "READ UNCOMMITTED"
+}
+export declare type PostProcessResultFunc = (res: any[], fields: ResultFieldType[], logger: PgDbLogger) => void;
+export interface Notification {
+    processId: number;
+    channel: string;
+    payload?: string;
+}
+export declare class PgDb extends QueryAble {
+    protected static instances: {
+        [index: string]: Promise<PgDb>;
+    };
+    pool: any;
+    connection: any;
+    config: ConnectionOptions;
+    defaultSchemas: any;
+    db: any;
+    schemas: {
+        [name: string]: PgSchema;
+    };
+    tables: {
+        [name: string]: PgTable<any>;
+    };
+    fn: {
+        [name: string]: (...any: any[]) => any;
+    };
+    [name: string]: any | PgSchema;
+    pgdbTypeParsers: {};
+    knownOids: Record<number, boolean>;
+    postProcessResult: PostProcessResultFunc;
+    private constructor();
+    setPostProcessResult(f: (res: any[], fields: ResultFieldType[], logger: PgDbLogger) => void): void;
+    static getInstance(config: ConnectionOptions): Promise<PgDb>;
+    close(): Promise<void>;
+    static connect(config: ConnectionOptions): Promise<PgDb>;
+    private init;
+    reload(): Promise<void>;
+    private initSchemasAndTables;
+    private setDefaultTablesAndFunctions;
+    private initFieldTypes;
+    setTypeParser(typeName: string, parser: (string: any) => any, schemaName?: string): Promise<void>;
+    setPgDbTypeParser(typeName: string, parser: (string: any) => any, schemaName?: string): Promise<void>;
+    resetMissingParsers(connection: any, oidList: number[]): Promise<void>;
+    dedicatedConnectionBegin(): Promise<PgDb>;
+    dedicatedConnectionEnd(): Promise<PgDb>;
+    savePoint(name: string): Promise<PgDb>;
+    savePointRelease(name: string): Promise<PgDb>;
+    transactionBegin(options?: {
+        isolationLevel?: TranzactionIsolationLevel;
+        deferrable?: boolean;
+        readOnly?: boolean;
+    }): Promise<PgDb>;
+    transactionCommit(): Promise<PgDb>;
+    transactionRollback(options?: {
+        savePoint?: string;
+    }): Promise<PgDb>;
+    isTransactionActive(): boolean;
+    execute(fileName: string, statementTransformerFunction?: (string: any) => string): Promise<void>;
+    private listeners;
+    private connectionForListen;
+    private _needToRestartConnectionForListen;
+    private restartConnectionForListen;
+    listen(channel: string, callback: (notification: Notification) => void): Promise<void>;
+    unlisten(channel: string, callback?: (Notification: any) => void): Promise<void>;
+    notify(channel: string, payload?: string): Promise<any[]>;
+    runRestartConnectionForListen(): Promise<Error>;
+    needToFixConnectionForListen(): boolean;
+    private tryToFixConnectionForListenActively;
+    private initConnectionForListen;
+}
+export default PgDb;

package/lib/pgDb.js

@@ -0,0 +1,745 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgDb = exports.TranzactionIsolationLevel = exports.FieldType = void 0;
+const tslib_1 = require("tslib");
+const queryAble_1 = require("./queryAble");
+const pgTable_1 = require("./pgTable");
+const pgSchema_1 = require("./pgSchema");
+const PgConverters = require("./pgConverters");
+const pgUtils_1 = require("./pgUtils");
+const _ = require("lodash");
+const pg = require("pg");
+const readline = require("readline");
+const fs = require("fs");
+const EventEmitter = require("events");
+const CONNECTION_URL_REGEXP = /^postgres:\/\/(?:([^:]+)(?::([^@]*))?@)?([^\/:]+)?(?::([^\/]+))?\/(.*)$/;
+const SQL_TOKENIZER_REGEXP = /''|'|""|"|;|\$|--|\/\*|\*\/|(.+?)/g;
+const SQL_$_ESCAPE_REGEXP = /\$[^$]*\$/g;
+const LIST_SCHEMAS_TABLES = `SELECT table_schema as schema, table_name as name 
+     FROM information_schema.tables 
+     WHERE table_schema NOT IN ('pg_catalog', 'pg_constraint', 'information_schema')`;
+const GET_OID_FOR_COLUMN_TYPE_FOR_SCHEMA = "SELECT t.oid FROM pg_catalog.pg_type t, pg_namespace n WHERE typname=:typeName and n.oid=t.typnamespace and n.nspname=:schemaName;";
+const GET_OID_FOR_COLUMN_TYPE = "SELECT t.oid FROM pg_catalog.pg_type t WHERE typname=:typeName";
+const GET_SCHEMAS_PROCEDURES = `SELECT
+    n.nspname as "schema",
+    p.proname as "name",
+    (not p.proretset) as "return_single_row",
+    (t.typtype in ('b', 'd', 'e', 'r')) as "return_single_value"
+FROM pg_proc p
+     inner join pg_namespace n on (p.pronamespace = n.oid)
+     inner join pg_type t on (p.prorettype = t.oid)
+     left outer join pg_trigger tr on (tr.tgfoid = p.oid)
+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 
+    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 `;
+var FieldType;
+(function (FieldType) {
+    FieldType[FieldType["JSON"] = 0] = "JSON";
+    FieldType[FieldType["ARRAY"] = 1] = "ARRAY";
+    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 = {}) {
+        super();
+        this.tables = {};
+        this.fn = {};
+        this.pgdbTypeParsers = {};
+        this.knownOids = {};
+        this.listeners = new EventEmitter();
+        this._needToRestartConnectionForListen = false;
+        this.restartConnectionForListen = null;
+        this.schemas = {};
+        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());
+        }
+        for (let schemaName in pgdb.schemas) {
+            let schema = new pgSchema_1.PgSchema(this, schemaName);
+            this.schemas[schemaName] = schema;
+            if (!(schemaName in this))
+                this[schemaName] = schema;
+            for (let tableName in pgdb.schemas[schemaName].tables) {
+                schema.tables[tableName] = new pgTable_1.PgTable(schema, pgdb.schemas[schemaName][tableName].desc, pgdb.schemas[schemaName][tableName].fieldTypes);
+                if (!(tableName in schema))
+                    schema[tableName] = schema.tables[tableName];
+            }
+        }
+        this.defaultSchemas = pgdb.defaultSchemas;
+        this.setDefaultTablesAndFunctions();
+    }
+    setPostProcessResult(f) {
+        this.postProcessResult = f;
+    }
+    static getInstance(config) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (config.connectionString) {
+                let res = CONNECTION_URL_REGEXP.exec(config.connectionString);
+                if (res) {
+                    config.user = res[1];
+                    config.password = res[2] ? res[2] : '';
+                    config.host = res[3] ? res[3] : 'localhost';
+                    config.port = res[4] ? +res[4] : 5432;
+                    config.database = res[5];
+                }
+            }
+            let connectionString = `postgres://${config.user}@${config.host}:${config.port}/${config.database}`;
+            if (!PgDb.instances) {
+                PgDb.instances = {};
+            }
+            if (PgDb.instances[connectionString]) {
+                return PgDb.instances[connectionString];
+            }
+            else {
+                let pgdb = new PgDb({ config: config });
+                PgDb.instances[connectionString] = pgdb.init();
+                return PgDb.instances[connectionString];
+            }
+        });
+    }
+    close() {
+        return 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((err) => { });
+        });
+    }
+    static connect(config) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (config.connectionString) {
+                let res = CONNECTION_URL_REGEXP.exec(config.connectionString);
+                if (res) {
+                    config.user = res[1];
+                    if (res[2])
+                        config.password = res[2];
+                    config.host = res[3] ? res[3] : 'localhost';
+                    config.port = res[4] ? +res[4] : 5432;
+                    config.database = res[5];
+                }
+            }
+            let pgdb = new PgDb({ config: config });
+            return pgdb.init();
+        });
+    }
+    init() {
+        return 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);
+            this.pool.on('error', (e, client) => {
+                this.getLogger(true).error('pool error', e);
+            });
+            yield this.reload();
+            this.getLogger().log('Successfully connected to Db');
+            return this;
+        });
+    }
+    reload() {
+        return 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* () {
+            let schemasAndTables = yield this.query(LIST_SCHEMAS_TABLES);
+            let functions = yield this.query(GET_SCHEMAS_PROCEDURES);
+            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])
+                    delete this[sc];
+            }
+            this.schemas = {};
+            for (let r of schemasAndTables) {
+                let schema = this.schemas[r.schema] = this.schemas[r.schema] || new pgSchema_1.PgSchema(this, r.schema);
+                if (!(r.schema in this))
+                    this[r.schema] = schema;
+                schema.tables[r.name] = new pgTable_1.PgTable(schema, r);
+                if (!(r.name in schema))
+                    schema[r.name] = schema.tables[r.name];
+            }
+            for (let r of functions) {
+                let schema = this.schemas[r.schema] = this.schemas[r.schema] || new pgSchema_1.PgSchema(this, r.schema);
+                if (!(r.schema in this))
+                    this[r.schema] = schema;
+                schema.fn[r.name] = pgUtils_1.pgUtils.createFunctionCaller(schema, r);
+            }
+            this.setDefaultTablesAndFunctions();
+        });
+    }
+    setDefaultTablesAndFunctions() {
+        this.tables = {};
+        this.fn = {};
+        if (!this.defaultSchemas)
+            return;
+        for (let sc of this.defaultSchemas) {
+            let schema = this.schemas[sc];
+            if (!schema)
+                continue;
+            for (let table in schema.tables)
+                this.tables[table] = this.tables[table] || schema.tables[table];
+            for (let fn in schema.fn)
+                this.fn[fn] = this.fn[fn] || schema.fn[fn];
+        }
+    }
+    initFieldTypes() {
+        return 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 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 :
+                                    FieldType.ARRAY;
+                }
+            }
+            let builtInArrayTypeParsers = [
+                {
+                    oidList: [
+                        1000
+                    ],
+                    parser: PgConverters.arraySplitToBool
+                },
+                {
+                    oidList: [
+                        1005,
+                        1007,
+                        1021
+                    ],
+                    parser: PgConverters.arraySplitToNum
+                },
+                {
+                    oidList: [
+                        1009,
+                        1015
+                    ],
+                    parser: PgConverters.arraySplit
+                },
+                {
+                    oidList: [
+                        199,
+                        3807
+                    ],
+                    parser: PgConverters.arraySplitToJson
+                },
+                {
+                    oidList: [
+                        1115,
+                        1182,
+                        1183,
+                        1185,
+                        1270
+                    ],
+                    parser: PgConverters.arraySplitToDate
+                }
+            ];
+            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 1016:
+                    case 1022:
+                        break;
+                    default:
+                        pg.types.setTypeParser(r.typid, PgConverters.arraySplit);
+                        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);
+            let allUsedTypeFields = yield this.queryOneColumn(`
+            SELECT 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* () {
+            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);
+            }
+        });
+    }
+    setPgDbTypeParser(typeName, parser, schemaName) {
+        return 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;
+                        this.knownOids[oid] = true;
+                    });
+                }
+            }
+            catch (e) {
+                throw Error('Not existing type: ' + typeName);
+            }
+        });
+    }
+    resetMissingParsers(connection, oidList) {
+        return 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.arraySplit;
+                    }
+                    this.knownOids[fieldData.oid] = true;
+                });
+            }
+        });
+    }
+    dedicatedConnectionBegin() {
+        return 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', () => { });
+            return pgDb;
+        });
+    }
+    dedicatedConnectionEnd() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.connection) {
+                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* () {
+            if (this.isTransactionActive()) {
+                name = (name || '').replace(/"/g, '');
+                yield this.query(`SAVEPOINT "${name}"`);
+            }
+            else {
+                throw Error('No active transaction');
+            }
+            return this;
+        });
+    }
+    savePointRelease(name) {
+        return 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');
+            }
+            return this;
+        });
+    }
+    transactionBegin(options) {
+        return 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) {
+                q += ' ISOLATION LEVEL ' + options.isolationLevel;
+            }
+            if (options === null || options === void 0 ? void 0 : options.readOnly) {
+                q += ' READ ONLY';
+            }
+            if (options === null || options === void 0 ? void 0 : options.deferrable) {
+                q += ' DEFERRABLE ';
+            }
+            yield pgDb.query(q);
+            return pgDb;
+        });
+    }
+    transactionCommit() {
+        return 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* () {
+            if (options === null || options === void 0 ? void 0 : options.savePoint) {
+                let name = (options.savePoint || '').replace(/"/g, '');
+                yield this.query(`ROLLBACK TO SAVEPOINT "${name}"`);
+                return this;
+            }
+            else {
+                yield this.query('ROLLBACK');
+                return this.dedicatedConnectionEnd();
+            }
+        });
+    }
+    isTransactionActive() {
+        return this.connection != null;
+    }
+    execute(fileName, statementTransformerFunction) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let isTransactionInPlace = this.isTransactionActive();
+            let pgdb = isTransactionInPlace ? this : yield this.dedicatedConnectionBegin();
+            let runStatementList = (statementList) => {
+                return new Promise((resolve, reject) => {
+                    let currentStatement = 0;
+                    let runStatement = () => {
+                        if (statementList.length == currentStatement) {
+                            resolve(undefined);
+                        }
+                        else {
+                            let statement = statementList[currentStatement++];
+                            if (statementTransformerFunction) {
+                                statement = statementTransformerFunction(statement);
+                            }
+                            this.getLogger(true).log('run', statementList[currentStatement - 1]);
+                            pgdb.query(statement)
+                                .then(() => runStatement(), reject)
+                                .catch(reject);
+                        }
+                    };
+                    runStatement();
+                }).catch((e) => {
+                    this.getLogger(true).error(e);
+                    throw e;
+                });
+            };
+            let lineCounter = 0;
+            let promise = new Promise((resolve, reject) => {
+                let statementList = [];
+                let tmp = '', t;
+                let consumer;
+                let inQuotedString;
+                let rl = readline.createInterface({
+                    input: fs.createReadStream(fileName),
+                    terminal: false
+                }).on('line', (line) => {
+                    lineCounter++;
+                    try {
+                        while (t = SQL_TOKENIZER_REGEXP.exec(line)) {
+                            if (!inQuotedString && (t[0] == '"' || t[0] == "'") || inQuotedString == '"' || inQuotedString == "'") {
+                                if (!inQuotedString) {
+                                    inQuotedString = t[0];
+                                }
+                                else if (inQuotedString == t[0]) {
+                                    inQuotedString = null;
+                                }
+                                tmp += t[0];
+                            }
+                            else if (!inQuotedString && t[0] == '$' || inQuotedString && inQuotedString[0] == '$') {
+                                if (!inQuotedString) {
+                                    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);
+                                    }
+                                    inQuotedString = token[0];
+                                    SQL_TOKENIZER_REGEXP.lastIndex += inQuotedString.length - 1;
+                                    tmp += inQuotedString;
+                                }
+                                else {
+                                    tmp += t[0];
+                                    if (tmp.endsWith(inQuotedString)) {
+                                        inQuotedString = null;
+                                    }
+                                }
+                            }
+                            else if (!inQuotedString && t[0] == '/*' || inQuotedString == '/*') {
+                                if (!inQuotedString) {
+                                    inQuotedString = t[0];
+                                }
+                                else if (t[0] == '*/') {
+                                    inQuotedString = null;
+                                }
+                            }
+                            else if (!inQuotedString && t[0] == '--') {
+                                line = '';
+                            }
+                            else if (!inQuotedString && t[0] == ';') {
+                                if (tmp.trim() != '') {
+                                    statementList.push(tmp);
+                                    if (!consumer) {
+                                        consumer = runStatementList(statementList).then(() => {
+                                            consumer = null;
+                                            statementList.length = 0;
+                                            rl.resume();
+                                        }, reject);
+                                        rl.pause();
+                                    }
+                                }
+                                tmp = '';
+                            }
+                            else {
+                                tmp += t[0];
+                            }
+                        }
+                        if (tmp && line) {
+                            tmp += '\n';
+                        }
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                }).on('close', () => {
+                    if (inQuotedString) {
+                        reject(Error('Invalid SQL, unterminated string'));
+                    }
+                    if (tmp.trim() != '') {
+                        statementList.push(tmp);
+                    }
+                    if (!consumer) {
+                        if (statementList.length) {
+                            consumer = runStatementList(statementList).catch(reject);
+                        }
+                        else {
+                            resolve();
+                        }
+                    }
+                    if (consumer) {
+                        consumer = consumer.then(resolve, reject);
+                    }
+                });
+            });
+            let error;
+            return promise
+                .catch((e) => {
+                error = e;
+                this.getLogger(true).error('Error at line ' + lineCounter + ' in ' + fileName + '. ' + e);
+            })
+                .then(() => {
+                if (!isTransactionInPlace) {
+                    return pgdb.dedicatedConnectionEnd();
+                }
+            }).catch((e) => {
+                this.getLogger(true).error(e);
+            }).then(() => {
+                if (error) {
+                    throw error;
+                }
+            });
+        });
+    }
+    listen(channel, callback) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let restartConnectionError = null;
+            if (this.needToFixConnectionForListen()) {
+                restartConnectionError = yield this.runRestartConnectionForListen();
+            }
+            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);
+            }
+        });
+    }
+    unlisten(channel, callback) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let restartConnectionError = null;
+            if (this.needToFixConnectionForListen()) {
+                restartConnectionError = yield this.runRestartConnectionForListen();
+            }
+            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.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);
+            }
+        });
+    }
+    notify(channel, payload) {
+        return 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 };
+            try {
+                return this.internalQuery({ connection, sql, params });
+            }
+            catch (err) {
+                if (hasConnectionForListen) {
+                    this._needToRestartConnectionForListen = true;
+                }
+                throw err;
+            }
+        });
+    }
+    runRestartConnectionForListen() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this._needToRestartConnectionForListen) {
+                return null;
+            }
+            let errorResult = null;
+            if (!this.restartConnectionForListen) {
+                this.restartConnectionForListen = (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    let eventNames = this.listeners.eventNames();
+                    try {
+                        yield this.connectionForListen.release();
+                    }
+                    catch (e) {
+                    }
+                    this.connectionForListen = null;
+                    let error;
+                    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 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 tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.connectionForListen = yield this.pool.connect();
+            this.connectionForListen.on('notification', (notification) => this.listeners.emit(notification.channel, notification));
+            this.connectionForListen.on('error', (e) => {
+                this._needToRestartConnectionForListen = true;
+                this.tryToFixConnectionForListenActively();
+            });
+        });
+    }
+}
+exports.PgDb = PgDb;
+exports.default = PgDb;
+//# sourceMappingURL=pgDb.js.map