pogi 3.0.1 → 3.2.0

package/lib/test/pgServiceRestartTest.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const pgDb_1 = require("../pgDb");
-const yargs = require("yargs");
-const shell = require("shelljs");
-let argv = yargs
+import shell from "shelljs";
+import yargs from 'yargs';
+import { PgDb } from "../pgDb.js";
+let argv = await yargs(process.argv.slice(2))
     .usage('node pgServiceRestartTest.js\n Usage: $0')
     .option('postgresOn', {
     describe: 'the command line command which switches on the postgresql server',
@@ -19,19 +16,15 @@ let argv = yargs
     type: "boolean"
 })
     .argv;
-function runCommand(command, options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        return new Promise((resolve, reject) => {
-            shell.exec(command, { silent: options ? options.silent : true }, (code, stdout, stderr) => {
-                resolve({ stdout, stderr });
-            });
+async function runCommand(command, options) {
+    return new Promise((resolve, reject) => {
+        shell.exec(command, { silent: options ? options.silent : true }, (code, stdout, stderr) => {
+            resolve({ stdout, stderr });
         });
     });
 }
-function asyncWaitMs(ms) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        yield new Promise(r => setTimeout(r, ms));
-    });
+async function asyncWaitMs(ms) {
+    await new Promise(r => setTimeout(r, ms));
 }
 function syncWaitMs(ms) {
     let origDate = +new Date();
@@ -40,228 +33,208 @@ function syncWaitMs(ms) {
         actDate = +new Date();
     }
 }
-function postgresOff() {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        console.log('Kill postgres server.');
-        yield runCommand(argv.postgresOff);
-    });
+async function postgresOff() {
+    console.log('Kill postgres server.');
+    await runCommand(argv.postgresOff);
 }
-function postgresOn() {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        console.log('Start postgres server.');
-        yield runCommand(argv.postgresOn);
-        yield asyncWaitMs(500);
-    });
+async function postgresOn() {
+    console.log('Start postgres server.');
+    await runCommand(argv.postgresOn);
+    await asyncWaitMs(500);
 }
 const poolSize = 3;
-function testSchemaClear(db) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        yield db.run(`drop table if exists pgdb_test.names`);
-        yield db.run(`DROP TYPE IF EXISTS pgdb_test.mood CASCADE`);
-        yield db.run(`DROP TABLE IF EXISTS pgdb_test."enumArrayTable"`);
-    });
+async function testSchemaClear(db) {
+    await db.run(`drop table if exists pgdb_test.names`);
+    await db.run(`DROP TYPE IF EXISTS pgdb_test.mood CASCADE`);
+    await db.run(`DROP TABLE IF EXISTS pgdb_test."enumArrayTable"`);
 }
-function testSchemaInit(db) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        yield testSchemaClear(db);
-        yield db.run(`create table pgdb_test.names (name varchar null)`);
-        yield db.run(`insert into pgdb_test.names (name) values ('Kuka'), ('Hapci')`);
-        yield db.run(`CREATE TYPE pgdb_test.mood AS ENUM('sad', 'ok', 'happy')`);
-        yield db.run(`CREATE TABLE pgdb_test."enumArrayTable"(m pgdb_test.mood[] NULL)`);
-        yield db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values (ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood])`);
-    });
+async function testSchemaInit(db) {
+    await testSchemaClear(db);
+    await db.run(`create table pgdb_test.names (name varchar null)`);
+    await db.run(`insert into pgdb_test.names (name) values ('Kuka'), ('Hapci')`);
+    await db.run(`CREATE TYPE pgdb_test.mood AS ENUM('sad', 'ok', 'happy')`);
+    await db.run(`CREATE TABLE pgdb_test."enumArrayTable"(m pgdb_test.mood[] NULL)`);
+    await db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values (ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood])`);
 }
-function testDbFreeConnections(db) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        let dedicatedConnections = new Array(poolSize).fill(null);
-        yield Promise.race([
-            asyncWaitMs(1000),
-            (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                for (let i = 0; i < dedicatedConnections.length; ++i) {
-                    dedicatedConnections[i] = yield db.dedicatedConnectionBegin();
-                }
-            }))()
-        ]);
-        if (dedicatedConnections.some(v => !v)) {
-            return new Error('Some of the connections are not free!');
-        }
-        for (let conn of dedicatedConnections) {
-            yield conn.dedicatedConnectionEnd();
-        }
-        return null;
-    });
+async function testDbFreeConnections(db) {
+    let dedicatedConnections = new Array(poolSize).fill(null);
+    await Promise.race([
+        asyncWaitMs(1000),
+        (async () => {
+            for (let i = 0; i < dedicatedConnections.length; ++i) {
+                dedicatedConnections[i] = await db.dedicatedConnectionBegin();
+            }
+        })()
+    ]);
+    if (dedicatedConnections.some(v => !v)) {
+        return new Error('Some of the connections are not free!');
+    }
+    for (let conn of dedicatedConnections) {
+        await conn.dedicatedConnectionEnd();
+    }
+    return;
 }
-function testInsertQuery(db) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        let tableContents = yield db.query(`select * from pgdb_test.names`);
-        if (tableContents.length != 2) {
-            return new Error('Simple query fails');
-        }
-        let callbackCounter1 = 0;
-        yield db.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => {
-            ++callbackCounter1;
-        });
-        if (callbackCounter1 != 2) {
-            return new Error('Query with cursor callback fails');
-        }
-        let callbackCounter2 = 0;
-        let stream = yield db.queryAsStream(`select * from pgdb_test.names`);
-        yield new Promise((resolve, reject) => {
-            stream.on("data", (data) => {
-                ++callbackCounter2;
-            });
-            stream.on('error', reject);
-            stream.on('close', resolve);
+async function testInsertQuery(db) {
+    let tableContents = await db.query(`select * from pgdb_test.names`);
+    if (tableContents.length != 2) {
+        return new Error('Simple query fails');
+    }
+    let callbackCounter1 = 0;
+    await db.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => {
+        ++callbackCounter1;
+    });
+    if (callbackCounter1 != 2) {
+        return new Error('Query with cursor callback fails');
+    }
+    let callbackCounter2 = 0;
+    let stream = await db.queryAsStream(`select * from pgdb_test.names`);
+    await new Promise((resolve, reject) => {
+        stream.on("data", (data) => {
+            ++callbackCounter2;
         });
-        if (callbackCounter2 != 2) {
-            return new Error('Query as stream fails');
-        }
-        return null;
+        stream.on('error', reject);
+        stream.on('close', resolve);
     });
+    if (callbackCounter2 != 2) {
+        return new Error('Query as stream fails');
+    }
+    return;
 }
-function testNotificationSystem(db) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        let result;
-        yield db.listen('testChannel', (data) => { result = data.payload; });
-        yield db.notify('testChannel', 'newData');
-        yield asyncWaitMs(1000);
-        if (result != 'newData') {
-            return new Error('Notification not working...');
-        }
-        yield db.unlisten('testChannel');
-    });
+async function testNotificationSystem(db) {
+    let result;
+    await db.listen('testChannel', (data) => { result = data.payload; });
+    await db.notify('testChannel', 'newData');
+    await asyncWaitMs(1000);
+    if (result != 'newData') {
+        return new Error('Notification not working...');
+    }
+    await db.unlisten('testChannel');
 }
-function testDbUsability(db) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        try {
-            console.log('TestSchemaInit');
-            yield testSchemaInit(db);
-            console.log('TestFreeConnections');
-            let error = yield testDbFreeConnections(db);
-            if (!error) {
-                console.log('TestInsertQueries');
-                error = yield testInsertQuery(db);
-            }
-            if (!error) {
-                console.log('TestNotifications');
-                error = yield testNotificationSystem(db);
-            }
-            yield testSchemaClear(db);
-            return error;
+async function testDbUsability(db) {
+    try {
+        console.log('TestSchemaInit');
+        await testSchemaInit(db);
+        console.log('TestFreeConnections');
+        let error = await testDbFreeConnections(db);
+        if (!error) {
+            console.log('TestInsertQueries');
+            error = await testInsertQuery(db);
         }
-        catch (e) {
-            return e;
+        if (!error) {
+            console.log('TestNotifications');
+            error = await testNotificationSystem(db);
         }
-    });
+        await testSchemaClear(db);
+        return error;
+    }
+    catch (e) {
+        return e;
+    }
 }
-function runTestInternal(db, test) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        let callCounter = 0;
-        let errorResult = null;
-        try {
-            yield test.fn(db, (value) => {
-                ++callCounter;
-                if (!value && !errorResult) {
-                    errorResult = new Error(`Error in test at the ${callCounter}. call.`);
-                }
-            });
-        }
-        catch (err) {
-            if (!errorResult) {
-                errorResult = err;
+async function runTestInternal(db, test) {
+    let callCounter = 0;
+    let errorResult;
+    try {
+        await test.fn(db, (value) => {
+            ++callCounter;
+            if (!value && !errorResult) {
+                errorResult = new Error(`Error in test at the ${callCounter}. call.`);
             }
+        });
+    }
+    catch (err) {
+        if (!errorResult) {
+            errorResult = err;
         }
-        yield postgresOn();
-        if (!errorResult && !test.skipTestDb) {
-            errorResult = yield testDbUsability(db);
-        }
-        return errorResult;
-    });
+    }
+    await postgresOn();
+    if (!errorResult && !test.skipTestDb) {
+        errorResult = await testDbUsability(db);
+    }
+    return errorResult;
 }
 let actTestCounter = 0;
 let errorMessages = [];
-function runTest(allTestCount, test) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        ++actTestCounter;
-        console.log('====================================================================================');
-        console.log(`${actTestCounter}/${allTestCount} Test starting: "${test.name}"`);
-        console.log('====================================================================================');
-        yield postgresOn();
-        let db = yield pgDb_1.PgDb.connect({
-            poolSize,
-            logger: {
-                log: console.log,
-                error: console.error
-            }
-        });
-        yield testSchemaInit(db);
-        let error = yield runTestInternal(db, test);
-        if (error) {
-            errorMessages.push({ testName: test.name, err: error });
+async function runTest(allTestCount, test) {
+    ++actTestCounter;
+    console.log('====================================================================================');
+    console.log(`${actTestCounter}/${allTestCount} Test starting: "${test.name}"`);
+    console.log('====================================================================================');
+    await postgresOn();
+    let db = await PgDb.connect({
+        poolSize,
+        logger: {
+            log: console.log,
+            error: console.error
         }
-        yield db.close();
-        console.log('====================================================================================');
-        if (error) {
-            console.log(`${actTestCounter}/${allTestCount} Test errored: "${test.name}"`);
-        }
-        else {
-            console.log(`${actTestCounter}/${allTestCount} Test passed: "${test.name}"`);
-        }
-        console.log('====================================================================================');
     });
+    await testSchemaInit(db);
+    let error = await runTestInternal(db, test);
+    if (error) {
+        errorMessages.push({ testName: test.name, err: error });
+    }
+    await db.close();
+    console.log('====================================================================================');
+    if (error) {
+        console.log(`${actTestCounter}/${allTestCount} Test errored: "${test.name}"`);
+    }
+    else {
+        console.log(`${actTestCounter}/${allTestCount} Test passed: "${test.name}"`);
+    }
+    console.log('====================================================================================');
 }
 let newConnectionTests = [
     {
         name: 'simple query 1',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield postgresOff();
+            await postgresOff();
             try {
-                yield db.query(`select * from pgdb_test.names`);
+                await db.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             try {
-                yield db.query(`select * from pgdb_test.names`);
+                await db.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'simple query 2',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield postgresOff();
+            await postgresOff();
             try {
-                yield db.query(`select * from pgdb_test."enumArrayTable"`);
+                await db.query(`select * from pgdb_test."enumArrayTable"`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             try {
-                yield db.query(`select * from pgdb_test."enumArrayTable"`);
+                await db.query(`select * from pgdb_test."enumArrayTable"`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'queryWithCallback 1 - postgresOff before call',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield postgresOff();
+            await postgresOff();
             try {
-                yield db.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, () => {
+                await db.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, () => {
                     isTrue(false);
                 });
                 isTrue(false);
@@ -270,18 +243,18 @@ let newConnectionTests = [
                 ++stageCounter;
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'queryWithCallback 2 - postgresOff between calls',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
             let params = new Array(2000).fill(null).map((v, i) => `'Smith${i}'`).map(v => `(${v})`).join(', ');
-            yield db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
+            await db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
             let i = 0;
-            let fn1 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let fn1 = async () => {
                 try {
-                    yield db.queryWithOnCursorCallback('select * from pgdb_test.names', {}, {}, (data) => {
+                    await db.queryWithOnCursorCallback('select * from pgdb_test.names', {}, {}, (data) => {
                         syncWaitMs(20);
                         ++i;
                         if (i % 10 == 0) {
@@ -293,27 +266,27 @@ let newConnectionTests = [
                 catch (e) {
                     ++stageCounter;
                 }
-            });
-            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            };
+            let fn2 = async () => {
                 console.log('Wait before postgres off...');
-                yield asyncWaitMs(100);
-                yield postgresOff();
-            });
-            yield Promise.all([fn1(), fn2()]);
+                await asyncWaitMs(100);
+                await postgresOff();
+            };
+            await Promise.all([fn1(), fn2()]);
             isTrue(i > 0 && i < 2000);
             isTrue(stageCounter == 1);
-        }),
+        },
     },
     {
         name: 'queryWithCallback 3 - postgresOff between calls, unknown oid',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
             let params = new Array(2000).fill(null).map((v) => `ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood]`).map(v => `(${v})`).join(', ');
-            yield db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
+            await db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
             let i = 0;
-            let fn1 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let fn1 = async () => {
                 try {
-                    yield db.queryWithOnCursorCallback('select * from pgdb_test."enumArrayTable"', {}, {}, (data) => {
+                    await db.queryWithOnCursorCallback('select * from pgdb_test."enumArrayTable"', {}, {}, (data) => {
                         syncWaitMs(20);
                         ++i;
                         if (i % 10 == 0) {
@@ -325,39 +298,39 @@ let newConnectionTests = [
                 catch (e) {
                     ++stageCounter;
                 }
-            });
-            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            };
+            let fn2 = async () => {
                 console.log('Wait before postgres off...');
-                yield asyncWaitMs(100);
-                yield postgresOff();
-            });
-            yield Promise.all([fn1(), fn2()]);
+                await asyncWaitMs(100);
+                await postgresOff();
+            };
+            await Promise.all([fn1(), fn2()]);
             isTrue(i > 0 && i < 2000);
             isTrue(stageCounter == 1);
-        }),
+        },
     },
     {
         name: 'queryAsStream 1 - postgresOff before call',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield postgresOff();
+            await postgresOff();
             try {
-                let stream = yield db.queryAsStream(`select * from pgdb_test.names`);
+                let stream = await db.queryAsStream(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'queryAsStream 2 - postgresOff between calls',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
             let params = new Array(2000).fill(null).map((v, i) => `'Smith${i}'`).map(v => `(${v})`).join(', ');
-            yield db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
-            let stream = yield db.queryAsStream('select * from pgdb_test.names');
+            await db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
+            let stream = await db.queryAsStream('select * from pgdb_test.names');
             let i = 0;
             let promise1 = new Promise((resolve, reject) => {
                 stream.on("data", (data) => {
@@ -373,12 +346,12 @@ let newConnectionTests = [
                 });
                 stream.on('close', resolve);
             });
-            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-                yield asyncWaitMs(100);
-                yield postgresOff();
-            });
+            let fn2 = async () => {
+                await asyncWaitMs(100);
+                await postgresOff();
+            };
             try {
-                yield Promise.all([promise1, fn2()]);
+                await Promise.all([promise1, fn2()]);
                 isTrue(false);
             }
             catch (e) {
@@ -386,15 +359,15 @@ let newConnectionTests = [
             }
             isTrue(i > 0 && i < 2000);
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'queryAsStream 3 - postgresOff between calls, unknown oid',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
             let params = new Array(2000).fill(null).map((v) => `ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood]`).map(v => `(${v})`).join(', ');
-            yield db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
-            let stream = yield db.queryAsStream('select * from pgdb_test."enumArrayTable"');
+            await db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
+            let stream = await db.queryAsStream('select * from pgdb_test."enumArrayTable"');
             let i = 0;
             let promise1 = new Promise((resolve, reject) => {
                 stream.on("data", (data) => {
@@ -410,12 +383,12 @@ let newConnectionTests = [
                 });
                 stream.on('close', resolve);
             });
-            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-                yield asyncWaitMs(100);
-                yield postgresOff();
-            });
+            let fn2 = async () => {
+                await asyncWaitMs(100);
+                await postgresOff();
+            };
             try {
-                yield Promise.all([promise1, fn2()]);
+                await Promise.all([promise1, fn2()]);
                 isTrue(false);
             }
             catch (e) {
@@ -423,393 +396,393 @@ let newConnectionTests = [
             }
             isTrue(i == 0);
             isTrue(stageCounter == 2);
-            yield postgresOff();
-        })
+            await postgresOff();
+        }
     },
 ];
 let dedicatedConnection_SimpleQueryTests = [
     {
         name: 'dedicated connection - empty 1',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield postgresOff();
+            await postgresOff();
             try {
-                let db0 = yield db.dedicatedConnectionBegin();
+                let db0 = await db.dedicatedConnectionBegin();
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'dedicated connection - empty 2',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
             try {
-                yield db0.dedicatedConnectionEnd();
+                await db0.dedicatedConnectionEnd();
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'dedicated connection - simple query 1',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'dedicated connection - simple query 2',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             try {
-                yield db0.dedicatedConnectionEnd();
+                await db0.dedicatedConnectionEnd();
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'dedicated connection - simple query 3',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield db0.run(`truncate pgdb_test.names`);
-            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await db0.run(`truncate pgdb_test.names`);
+            await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            await postgresOff();
             try {
-                yield db0.dedicatedConnectionEnd();
+                await db0.dedicatedConnectionEnd();
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
-            yield postgresOn();
-            let result = yield db.query(`select * from pgdb_test.names`);
+            await postgresOn();
+            let result = await db.query(`select * from pgdb_test.names`);
             isTrue(result[0].name == 'Morgo');
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'dedicated connection - simple query 4',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield db0.run(`truncate pgdb_test.names`);
-            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await db0.run(`truncate pgdb_test.names`);
+            await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
-            yield postgresOn();
-            let result = yield db.query(`select * from pgdb_test.names`);
+            await postgresOn();
+            let result = await db.query(`select * from pgdb_test.names`);
             isTrue(result[0].name == 'Morgo');
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'dedicated connection - simple query 5',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield db0.run(`truncate pgdb_test.names`);
-            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await db0.run(`truncate pgdb_test.names`);
+            await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             try {
-                yield db0.dedicatedConnectionEnd();
+                await db0.dedicatedConnectionEnd();
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
-            yield postgresOn();
-            let result = yield db.query(`select * from pgdb_test.names`);
+            await postgresOn();
+            let result = await db.query(`select * from pgdb_test.names`);
             isTrue(result[0].name == 'Morgo');
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'dedicated connection - simple query 6',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield db0.run(`truncate pgdb_test.names`);
-            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await db0.run(`truncate pgdb_test.names`);
+            await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
-            yield postgresOn();
+            await postgresOn();
             try {
-                yield db0.dedicatedConnectionEnd();
+                await db0.dedicatedConnectionEnd();
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
-            let result = yield db.query(`select * from pgdb_test.names`);
+            let result = await db.query(`select * from pgdb_test.names`);
             isTrue(result[0].name == 'Morgo');
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'transaction - simple query 7',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield db.run(`truncate pgdb_test.names`);
-            let db0 = yield db.transactionBegin();
-            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
-            yield postgresOff();
+            await db.run(`truncate pgdb_test.names`);
+            let db0 = await db.transactionBegin();
+            await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
-            yield postgresOn();
-            let result = yield db.query(`select * from pgdb_test.names`);
+            await postgresOn();
+            let result = await db.query(`select * from pgdb_test.names`);
             isTrue(result.length == 0);
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'transaction - simple query 8',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield db.run(`truncate pgdb_test.names`);
-            let db0 = yield db.transactionBegin();
-            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
-            yield postgresOff();
+            await db.run(`truncate pgdb_test.names`);
+            let db0 = await db.transactionBegin();
+            await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
-            yield postgresOn();
+            await postgresOn();
             try {
-                yield db0.transactionCommit();
+                await db0.transactionCommit();
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
-            let result = yield db.query(`select * from pgdb_test.names`);
+            let result = await db.query(`select * from pgdb_test.names`);
             isTrue(result.length == 0);
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'transaction - simple query 9',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield db.run(`truncate pgdb_test.names`);
-            let db0 = yield db.transactionBegin();
-            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
-            yield postgresOff();
+            await db.run(`truncate pgdb_test.names`);
+            let db0 = await db.transactionBegin();
+            await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             try {
-                yield db0.transactionCommit();
+                await db0.transactionCommit();
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
-            yield postgresOn();
-            let result = yield db.query(`select * from pgdb_test.names`);
+            await postgresOn();
+            let result = await db.query(`select * from pgdb_test.names`);
             isTrue(result.length == 0);
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'transaction - simple query 10',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield db.run(`truncate pgdb_test.names`);
-            let db0 = yield db.transactionBegin();
-            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
-            yield postgresOff();
+            await db.run(`truncate pgdb_test.names`);
+            let db0 = await db.transactionBegin();
+            await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
-            yield postgresOn();
-            let result = yield db.query(`select * from pgdb_test.names`);
+            await postgresOn();
+            let result = await db.query(`select * from pgdb_test.names`);
             isTrue(result.length == 0);
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'transaction - simple query 11',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield db.run(`truncate pgdb_test.names`);
-            let db0 = yield db.transactionBegin();
-            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
-            yield postgresOff();
+            await db.run(`truncate pgdb_test.names`);
+            let db0 = await db.transactionBegin();
+            await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            await postgresOff();
             try {
-                yield db0.transactionCommit();
+                await db0.transactionCommit();
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
-            yield postgresOn();
-            let result = yield db.query(`select * from pgdb_test.names`);
+            await postgresOn();
+            let result = await db.query(`select * from pgdb_test.names`);
             isTrue(result.length == 0);
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'transaction - rollback 1',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield db.run(`truncate pgdb_test.names`);
-            let db0 = yield db.transactionBegin();
-            yield postgresOff();
+            await db.run(`truncate pgdb_test.names`);
+            let db0 = await db.transactionBegin();
+            await postgresOff();
             try {
-                yield db0.transactionRollback();
+                await db0.transactionRollback();
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'transaction - rollback 2',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield db.run(`truncate pgdb_test.names`);
-            let db0 = yield db.transactionBegin();
-            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
-            yield postgresOff();
+            await db.run(`truncate pgdb_test.names`);
+            let db0 = await db.transactionBegin();
+            await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            await postgresOff();
             try {
-                yield db0.transactionRollback();
+                await db0.transactionRollback();
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'transaction - rollback 3',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield db.run(`truncate pgdb_test.names`);
-            let db0 = yield db.transactionBegin();
-            yield postgresOff();
+            await db.run(`truncate pgdb_test.names`);
+            let db0 = await db.transactionBegin();
+            await postgresOff();
             try {
-                yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+                await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             try {
-                yield db0.transactionRollback();
+                await db0.transactionRollback();
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'transaction - rollback 4',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield db.run(`truncate pgdb_test.names`);
-            let db0 = yield db.transactionBegin();
-            yield postgresOff();
+            await db.run(`truncate pgdb_test.names`);
+            let db0 = await db.transactionBegin();
+            await postgresOff();
             try {
-                yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+                await db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
-            yield postgresOn();
+            await postgresOn();
             try {
-                yield db0.transactionRollback();
+                await db0.transactionRollback();
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 2);
-        })
+        }
     }
 ];
 let dedicatedConnection_StreamQueryTests = [
     {
         name: 'dedicated connection queryWithCallback - 1',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
             let i = 0;
             try {
-                yield db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => { ++i; });
+                await db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => { ++i; });
                 isTrue(false);
             }
             catch (e) {
@@ -817,24 +790,24 @@ let dedicatedConnection_StreamQueryTests = [
             }
             isTrue(i == 0);
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'dedicated connection queryWithCallback - 1',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
             let i = 0;
             try {
-                yield db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => { ++i; });
+                await db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => { ++i; });
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             try {
-                yield db0.dedicatedConnectionEnd();
+                await db0.dedicatedConnectionEnd();
                 ++stageCounter;
             }
             catch (e) {
@@ -842,16 +815,16 @@ let dedicatedConnection_StreamQueryTests = [
             }
             isTrue(i == 0);
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'dedicated connection queryWithCallback - 3',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
@@ -859,7 +832,7 @@ let dedicatedConnection_StreamQueryTests = [
             }
             let i = 0;
             try {
-                yield db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => { ++i; });
+                await db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => { ++i; });
                 isTrue(false);
             }
             catch (e) {
@@ -867,19 +840,19 @@ let dedicatedConnection_StreamQueryTests = [
             }
             isTrue(i == 0);
             isTrue(stageCounter == 2);
-        })
+        }
     },
     {
         name: 'dedicated connection queryWithCallback 4 - postgresOff between calls',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
             let params = new Array(2000).fill(null).map((v, i) => `'Smith${i}'`).map(v => `(${v})`).join(', ');
-            yield db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
-            let db0 = yield db.dedicatedConnectionBegin();
+            await db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
+            let db0 = await db.dedicatedConnectionBegin();
             let i = 0;
-            let fn1 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let fn1 = async () => {
                 try {
-                    yield db0.queryWithOnCursorCallback('select * from pgdb_test.names', {}, {}, (data) => {
+                    await db0.queryWithOnCursorCallback('select * from pgdb_test.names', {}, {}, (data) => {
                         syncWaitMs(20);
                         ++i;
                         if (i % 10 == 0) {
@@ -891,28 +864,28 @@ let dedicatedConnection_StreamQueryTests = [
                 catch (e) {
                     ++stageCounter;
                 }
-            });
-            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            };
+            let fn2 = async () => {
                 console.log('Wait before postgres off...');
-                yield asyncWaitMs(100);
-                yield postgresOff();
-            });
-            yield Promise.all([fn1(), fn2()]);
+                await asyncWaitMs(100);
+                await postgresOff();
+            };
+            await Promise.all([fn1(), fn2()]);
             isTrue(i > 0 && i < 2000);
             isTrue(stageCounter == 1);
-        }),
+        },
     },
     {
         name: 'dedicated connection queryWithCallback 5 - postgresOff between calls, unknown oid',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
             let params = new Array(2000).fill(null).map((v) => `ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood]`).map(v => `(${v})`).join(', ');
-            yield db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
-            let db0 = yield db.dedicatedConnectionBegin();
+            await db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
+            let db0 = await db.dedicatedConnectionBegin();
             let i = 0;
-            let fn1 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let fn1 = async () => {
                 try {
-                    yield db0.queryWithOnCursorCallback('select * from pgdb_test."enumArrayTable"', {}, {}, (data) => {
+                    await db0.queryWithOnCursorCallback('select * from pgdb_test."enumArrayTable"', {}, {}, (data) => {
                         syncWaitMs(20);
                         ++i;
                         if (i % 10 == 0) {
@@ -924,33 +897,33 @@ let dedicatedConnection_StreamQueryTests = [
                 catch (e) {
                     ++stageCounter;
                 }
-            });
-            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            };
+            let fn2 = async () => {
                 console.log('Wait before postgres off...');
-                yield asyncWaitMs(100);
-                yield postgresOff();
-            });
-            yield Promise.all([fn1(), fn2()]);
+                await asyncWaitMs(100);
+                await postgresOff();
+            };
+            await Promise.all([fn1(), fn2()]);
             isTrue(i > 0 && i < 2000);
             isTrue(stageCounter == 1);
-        }),
+        },
     },
     {
         name: 'dedicated connection queryAsStream - 1',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
             let stream;
             try {
-                stream = yield db0.queryAsStream(`select * from pgdb_test.names`);
+                stream = await db0.queryAsStream(`select * from pgdb_test.names`);
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
             try {
-                yield new Promise((resolve, reject) => {
+                await new Promise((resolve, reject) => {
                     stream.on("data", (data) => {
                         isTrue(false);
                     });
@@ -966,24 +939,24 @@ let dedicatedConnection_StreamQueryTests = [
                 ++stageCounter;
             }
             isTrue(stageCounter == 3);
-        })
+        }
     },
     {
         name: 'dedicated connection queryAsStream - 2',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
             let stream;
             try {
-                stream = yield db0.queryAsStream(`select * from pgdb_test.names`);
+                stream = await db0.queryAsStream(`select * from pgdb_test.names`);
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
             try {
-                yield new Promise((resolve, reject) => {
+                await new Promise((resolve, reject) => {
                     stream.on("data", (data) => {
                         isTrue(false);
                     });
@@ -999,23 +972,23 @@ let dedicatedConnection_StreamQueryTests = [
                 ++stageCounter;
             }
             try {
-                yield db0.dedicatedConnectionEnd();
+                await db0.dedicatedConnectionEnd();
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
             isTrue(stageCounter == 4);
-        })
+        }
     },
     {
         name: 'dedicated connection queryAsStream - 3',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
             try {
-                yield db0.query(`select * from pgdb_test.names`);
+                await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
@@ -1023,14 +996,14 @@ let dedicatedConnection_StreamQueryTests = [
             }
             let stream;
             try {
-                stream = yield db0.queryAsStream(`select * from pgdb_test.names`);
+                stream = await db0.queryAsStream(`select * from pgdb_test.names`);
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
             try {
-                yield new Promise((resolve, reject) => {
+                await new Promise((resolve, reject) => {
                     stream.on("data", (data) => {
                         isTrue(false);
                     });
@@ -1046,16 +1019,16 @@ let dedicatedConnection_StreamQueryTests = [
                 ++stageCounter;
             }
             isTrue(stageCounter == 4);
-        })
+        }
     },
     {
         name: 'dedicated connection queryAsStream 4 - postgresOff between calls',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
             let params = new Array(2000).fill(null).map((v, i) => `'Smith${i}'`).map(v => `(${v})`).join(', ');
-            yield db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
-            let db0 = yield db.dedicatedConnectionBegin();
-            let stream = yield db0.queryAsStream('select * from pgdb_test.names');
+            await db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
+            let db0 = await db.dedicatedConnectionBegin();
+            let stream = await db0.queryAsStream('select * from pgdb_test.names');
             let i = 0;
             let promise1 = new Promise((resolve, reject) => {
                 stream.on("data", (data) => {
@@ -1071,12 +1044,12 @@ let dedicatedConnection_StreamQueryTests = [
                 });
                 stream.on('close', resolve);
             });
-            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-                yield asyncWaitMs(100);
-                yield postgresOff();
-            });
+            let fn2 = async () => {
+                await asyncWaitMs(100);
+                await postgresOff();
+            };
             try {
-                yield Promise.all([promise1, fn2()]);
+                await Promise.all([promise1, fn2()]);
                 isTrue(false);
             }
             catch (e) {
@@ -1084,16 +1057,16 @@ let dedicatedConnection_StreamQueryTests = [
             }
             isTrue(i > 0 && i < 2000);
             isTrue(stageCounter == 2);
-        }),
+        },
     },
     {
         name: 'dedicated connection queryAsStream 5 - postgresOff between calls, unknown oid',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
             let params = new Array(2000).fill(null).map((v) => `ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood]`).map(v => `(${v})`).join(', ');
-            yield db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
-            let db0 = yield db.dedicatedConnectionBegin();
-            let stream = yield db0.queryAsStream('select * from pgdb_test."enumArrayTable"');
+            await db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
+            let db0 = await db.dedicatedConnectionBegin();
+            let stream = await db0.queryAsStream('select * from pgdb_test."enumArrayTable"');
             let i = 0;
             let promise1 = new Promise((resolve, reject) => {
                 stream.on("data", (data) => {
@@ -1109,12 +1082,12 @@ let dedicatedConnection_StreamQueryTests = [
                 });
                 stream.on('close', resolve);
             });
-            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-                yield asyncWaitMs(100);
-                yield postgresOff();
-            });
+            let fn2 = async () => {
+                await asyncWaitMs(100);
+                await postgresOff();
+            };
             try {
-                yield Promise.all([promise1, fn2()]);
+                await Promise.all([promise1, fn2()]);
                 isTrue(false);
             }
             catch (e) {
@@ -1122,71 +1095,71 @@ let dedicatedConnection_StreamQueryTests = [
             }
             isTrue(i == 0);
             isTrue(stageCounter == 2);
-            yield postgresOff();
-        }),
+            await postgresOff();
+        },
     }
 ];
 let postgresRestartTests = [
     {
         name: 'postgres restart 1',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
-            yield postgresOn();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
+            await postgresOn();
             try {
-                yield db0.dedicatedConnectionEnd();
+                await db0.dedicatedConnectionEnd();
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'postgres restart 2',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.transactionBegin();
-            yield postgresOff();
-            yield postgresOn();
+            let db0 = await db.transactionBegin();
+            await postgresOff();
+            await postgresOn();
             try {
-                yield db0.transactionRollback();
+                await db0.transactionRollback();
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'postgres restart 3',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
-            yield postgresOn();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
+            await postgresOn();
             try {
-                let result = yield db0.query(`select * from pgdb_test.names`);
+                let result = await db0.query(`select * from pgdb_test.names`);
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'postgres restart 4',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
-            yield postgresOn();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
+            await postgresOn();
             try {
-                let result = yield db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => {
+                let result = await db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => {
                     isTrue(false);
                 });
                 isTrue(false);
@@ -1195,25 +1168,25 @@ let postgresRestartTests = [
                 ++stageCounter;
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'postgres restart 5',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
-            yield postgresOn();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
+            await postgresOn();
             let stream;
             try {
-                stream = yield db0.queryAsStream(`select * from pgdb_test.names`);
+                stream = await db0.queryAsStream(`select * from pgdb_test.names`);
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
             try {
-                yield new Promise((resolve, reject) => {
+                await new Promise((resolve, reject) => {
                     stream.on("data", (data) => {
                         isTrue(false);
                     });
@@ -1229,304 +1202,300 @@ let postgresRestartTests = [
                 ++stageCounter;
             }
             isTrue(stageCounter == 3);
-        })
+        }
     },
 ];
 let postgresEndTests = [
     {
         name: 'postgres end 1',
         skipTestDb: true,
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield postgresOff();
+            let db0 = await db.dedicatedConnectionBegin();
+            await postgresOff();
             try {
-                yield db.close();
+                await db.close();
                 ++stageCounter;
             }
             catch (e) {
                 isTrue(false);
             }
             isTrue(stageCounter == 1);
-        })
+        }
     }
 ];
 let notifyTests = [
     {
         name: 'notification 1',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let stageCounter = 0;
-            yield postgresOff();
+            await postgresOff();
             try {
-                yield db.listen('newChannel', (notif) => { });
+                await db.listen('newChannel', (notif) => { });
                 isTrue(false);
             }
             catch (e) {
                 ++stageCounter;
             }
             isTrue(stageCounter == 1);
-        })
+        }
     },
     {
         name: 'notification 2',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-            yield db.listen('newChannel', (notif) => { });
-            yield postgresOff();
-            yield postgresOn();
-            yield db.unlisten('newChannel');
-        })
+        fn: async (db, isTrue) => {
+            await db.listen('newChannel', (notif) => { });
+            await postgresOff();
+            await postgresOn();
+            await db.unlisten('newChannel');
+        }
     },
     {
         name: 'notification 3',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let result;
-            yield db.listen('newChannel', (notif) => { result = notif.payload; });
-            yield postgresOff();
-            yield postgresOn();
-            yield db.notify('newChannel', 'newValue');
-            yield asyncWaitMs(1000);
+            await db.listen('newChannel', (notif) => { result = notif.payload; });
+            await postgresOff();
+            await postgresOn();
+            await db.notify('newChannel', 'newValue');
+            await asyncWaitMs(1000);
             isTrue(result == 'newValue');
-            yield db.unlisten('newChannel');
-        })
+            await db.unlisten('newChannel');
+        }
     },
     {
         name: 'notification 4',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let result;
-            yield db.listen('newChannel', (notif) => { result = notif.payload; });
-            yield postgresOff();
-            yield postgresOn();
-            yield db.run(`notify "newChannel", 'newValue'`);
-            yield asyncWaitMs(1000);
+            await db.listen('newChannel', (notif) => { result = notif.payload; });
+            await postgresOff();
+            await postgresOn();
+            await db.run(`notify "newChannel", 'newValue'`);
+            await asyncWaitMs(1000);
             isTrue(result == 'newValue');
-            yield db.unlisten('newChannel');
-        })
+            await db.unlisten('newChannel');
+        }
     },
     {
         name: 'notification 5',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let result;
-            yield db.listen('newChannel', (notif) => { result = notif.payload; });
-            yield postgresOff();
-            yield postgresOn();
-            let db0 = yield db.dedicatedConnectionBegin();
-            yield db0.run(`notify "newChannel", 'newValue'`);
-            yield asyncWaitMs(1000);
+            await db.listen('newChannel', (notif) => { result = notif.payload; });
+            await postgresOff();
+            await postgresOn();
+            let db0 = await db.dedicatedConnectionBegin();
+            await db0.run(`notify "newChannel", 'newValue'`);
+            await asyncWaitMs(1000);
             isTrue(result == 'newValue');
-            yield db.unlisten('newChannel');
-            yield db0.dedicatedConnectionEnd();
-        })
+            await db.unlisten('newChannel');
+            await db0.dedicatedConnectionEnd();
+        }
     },
     {
         name: 'notification 6',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let i = 0;
             let fn1 = (notif) => { i += +notif.payload; };
             let fn2 = (notif) => { i += 2 * (+notif.payload); };
-            yield db.listen('newChannel', fn1);
-            yield postgresOff();
-            yield db.listen('newChannel', fn2);
-            yield postgresOn();
-            yield db.notify('newChannel', '1');
-            yield asyncWaitMs(1000);
+            await db.listen('newChannel', fn1);
+            await postgresOff();
+            await db.listen('newChannel', fn2);
+            await postgresOn();
+            await db.notify('newChannel', '1');
+            await asyncWaitMs(1000);
             isTrue(i == 3);
-            yield db.unlisten('newChannel');
-        })
+            await db.unlisten('newChannel');
+        }
     },
     {
         name: 'notification 7',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let i = 0;
             let fn1 = (notif) => { i += +notif.payload; };
             let fn2 = (notif) => { i += 2 * (+notif.payload); };
-            yield db.listen('newChannel', fn1);
-            yield postgresOff();
-            yield db.listen('newChannel', fn2);
-            yield db.unlisten('newChannel', fn1);
-            yield postgresOn();
-            yield db.notify('newChannel', '1');
-            yield asyncWaitMs(1000);
+            await db.listen('newChannel', fn1);
+            await postgresOff();
+            await db.listen('newChannel', fn2);
+            await db.unlisten('newChannel', fn1);
+            await postgresOn();
+            await db.notify('newChannel', '1');
+            await asyncWaitMs(1000);
             isTrue(i == 2);
-            yield db.unlisten('newChannel');
-        })
+            await db.unlisten('newChannel');
+        }
     },
     {
         name: 'notification 8',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let i = 0;
             let j = 0;
             let fn1 = (notif) => { i += +notif.payload; };
             let fn2 = (notif) => { j += +notif.payload; };
-            yield db.listen('newChannel', fn1);
-            yield postgresOff();
+            await db.listen('newChannel', fn1);
+            await postgresOff();
             try {
-                yield db.listen('newChannel2', fn2);
+                await db.listen('newChannel2', fn2);
                 isTrue(false);
             }
             catch (e) {
             }
-            yield postgresOn();
-            yield db.notify('newChannel', '1');
-            yield db.notify('newChannel2', '1');
-            yield asyncWaitMs(1000);
+            await postgresOn();
+            await db.notify('newChannel', '1');
+            await db.notify('newChannel2', '1');
+            await asyncWaitMs(1000);
             isTrue(i == 1);
             isTrue(j == 0);
-            yield db.unlisten('newChannel');
-        })
+            await db.unlisten('newChannel');
+        }
     },
     {
         name: 'notification 9',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let i = 0;
             let fn1 = (notif) => { i += +notif.payload; };
-            yield db.listen('newChannel', fn1);
-            yield postgresOff();
+            await db.listen('newChannel', fn1);
+            await postgresOff();
             try {
-                yield db.unlisten('newChannel', fn1);
+                await db.unlisten('newChannel', fn1);
                 isTrue(false);
             }
             catch (e) {
             }
-            yield postgresOn();
-            yield db.notify('newChannel', '1');
-            yield asyncWaitMs(1000);
+            await postgresOn();
+            await db.notify('newChannel', '1');
+            await asyncWaitMs(1000);
             isTrue(i == 1);
-            yield db.unlisten('newChannel');
-        })
+            await db.unlisten('newChannel');
+        }
     },
     {
         name: 'notification 10',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let i = 0;
             let fn1 = (notif) => { i += +notif.payload; };
-            yield db.listen('newChannel', fn1);
-            yield postgresOff();
+            await db.listen('newChannel', fn1);
+            await postgresOff();
             try {
-                yield db.unlisten('newChannel');
+                await db.unlisten('newChannel');
                 isTrue(false);
             }
             catch (e) {
             }
-            yield postgresOn();
-            yield db.notify('newChannel', '1');
-            yield asyncWaitMs(1000);
+            await postgresOn();
+            await db.notify('newChannel', '1');
+            await asyncWaitMs(1000);
             isTrue(i == 1);
-            yield db.unlisten('newChannel');
-        })
+            await db.unlisten('newChannel');
+        }
     },
     {
         name: 'notification 11 - automatic notification restart...',
-        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        fn: async (db, isTrue) => {
             let i = 0;
             let fn1 = (notif) => { i += +notif.payload; };
-            yield db.listen('newChannel', fn1);
-            yield postgresOff();
-            yield postgresOn();
-            yield asyncWaitMs(3000);
-            let db2 = yield pgDb_1.PgDb.connect({});
-            yield db2.notify('newChannel', '1');
-            yield db2.close();
-            yield asyncWaitMs(1000);
+            await db.listen('newChannel', fn1);
+            await postgresOff();
+            await postgresOn();
+            await asyncWaitMs(3000);
+            let db2 = await PgDb.connect({});
+            await db2.notify('newChannel', '1');
+            await db2.close();
+            await asyncWaitMs(1000);
             isTrue(i == 1);
-            yield db.unlisten('newChannel');
-        })
+            await db.unlisten('newChannel');
+        }
     }
 ];
-function testParams() {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        console.log('Start testing params');
-        let postgresOnCommandOk = true;
-        let postgresOffCommandOk = false;
-        let frameworkError = false;
+async function testParams() {
+    console.log('Start testing params');
+    let postgresOnCommandOk = true;
+    let postgresOffCommandOk = false;
+    let frameworkError = false;
+    try {
+        console.log('Postgres On test');
+        await postgresOn();
         try {
-            console.log('Postgres On test');
-            yield postgresOn();
-            try {
-                let db = yield pgDb_1.PgDb.connect({});
-            }
-            catch (e) {
-                postgresOnCommandOk = false;
-            }
-            console.log('Postgres Off test');
-            yield postgresOff();
-            try {
-                let db = yield pgDb_1.PgDb.connect({});
-            }
-            catch (e) {
-                postgresOffCommandOk = postgresOnCommandOk;
-            }
-            console.log('Postgres On test');
-            yield postgresOn();
-            try {
-                let db = yield pgDb_1.PgDb.connect({});
-            }
-            catch (e) {
-                postgresOnCommandOk = false;
-            }
+            let db = await PgDb.connect({});
         }
         catch (e) {
-            console.log('Unknown exception has found', e);
-            frameworkError = true;
+            postgresOnCommandOk = false;
         }
-        if (!frameworkError) {
-            if (postgresOffCommandOk && postgresOnCommandOk) {
-                console.log('Postgres On/Off commands OK');
-            }
-            else {
-                if (!postgresOnCommandOk) {
-                    console.log('Postgres On command NOT OK');
-                }
-                if (!postgresOffCommandOk) {
-                    console.log('Postgres Off command NOT OK');
-                }
-            }
+        console.log('Postgres Off test');
+        await postgresOff();
+        try {
+            let db = await PgDb.connect({});
         }
-        console.log('Postgres On/Off test end');
-    });
-}
-function runTests() {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        console.log('Start tests');
-        let allTests = [
-            ...newConnectionTests,
-            ...dedicatedConnection_SimpleQueryTests,
-            ...dedicatedConnection_StreamQueryTests,
-            ...postgresRestartTests,
-            ...notifyTests,
-            ...postgresEndTests
-        ];
-        let testNamePrefix = '';
+        catch (e) {
+            postgresOffCommandOk = postgresOnCommandOk;
+        }
+        console.log('Postgres On test');
+        await postgresOn();
         try {
-            if (testNamePrefix) {
-                allTests = allTests.filter(v => v.name.startsWith(testNamePrefix));
-            }
-            for (let test of allTests) {
-                yield runTest(allTests.length, test);
+            let db = await PgDb.connect({});
+        }
+        catch (e) {
+            postgresOnCommandOk = false;
+        }
+    }
+    catch (e) {
+        console.log('Unknown exception has found', e);
+        frameworkError = true;
+    }
+    if (!frameworkError) {
+        if (postgresOffCommandOk && postgresOnCommandOk) {
+            console.log('Postgres On/Off commands OK');
+        }
+        else {
+            if (!postgresOnCommandOk) {
+                console.log('Postgres On command NOT OK');
             }
-            console.log('All tests: ', actTestCounter);
-            console.log(`Problematic tests: ${errorMessages.length}`);
-            for (let errorMessage of errorMessages) {
-                console.log(`Error in "${errorMessage.testName}"`);
-                console.log(errorMessage.err);
+            if (!postgresOffCommandOk) {
+                console.log('Postgres Off command NOT OK');
             }
         }
-        catch (e) {
-            console.log('Error has found in the test framework!');
-            console.log(e);
+    }
+    console.log('Postgres On/Off test end');
+}
+async function runTests() {
+    console.log('Start tests');
+    let allTests = [
+        ...newConnectionTests,
+        ...dedicatedConnection_SimpleQueryTests,
+        ...dedicatedConnection_StreamQueryTests,
+        ...postgresRestartTests,
+        ...notifyTests,
+        ...postgresEndTests
+    ];
+    let testNamePrefix = '';
+    try {
+        if (testNamePrefix) {
+            allTests = allTests.filter(v => v.name.startsWith(testNamePrefix));
         }
-        console.log('All tests are finished');
-    });
+        for (let test of allTests) {
+            await runTest(allTests.length, test);
+        }
+        console.log('All tests: ', actTestCounter);
+        console.log(`Problematic tests: ${errorMessages.length}`);
+        for (let errorMessage of errorMessages) {
+            console.log(`Error in "${errorMessage.testName}"`);
+            console.log(errorMessage.err);
+        }
+    }
+    catch (e) {
+        console.log('Error has found in the test framework!');
+        console.log(e);
+    }
+    console.log('All tests are finished');
 }
-(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+(async () => {
     if (!argv.postgresOn || !argv.postgresOff) {
         console.log('postgresOn or postgresOff parameter is missing!');
         return;
     }
     if (argv.testParams) {
-        yield testParams();
+        await testParams();
     }
     else {
-        yield runTests();
+        await runTests();
     }
-}))().catch(console.log);
+})().catch(console.log);
 //# sourceMappingURL=pgServiceRestartTest.js.map