@pi-r/postgres 0.6.0 → 0.6.2

package/README.md

@@ -1,5 +1,7 @@
 ### @pi-r/postgres
 
+https://e-mc.readthedocs.io/en/latest/db/postgres.html
+
 ### LICENSE
 
 MIT

package/client/index.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = exports.checkTimeout = exports.executeBatchQuery = exports.executeQuery = exports.setCredential = exports.setAuthentication = void 0;
 const postgres = require("pg");
+const connectionString = require("pg-connection-string");
 const util_1 = require("@e-mc/db/util");
 const types_1 = require("@e-mc/types");
 const Db = require("@e-mc/db");
+const QueryStream = require("pg-query-stream");
 const DbPool = require('@e-mc/db/pool');
 class PostgresPool extends DbPool {
     async getConnection() {
@@ -43,11 +45,39 @@ function removePoolProperties(credential) {
     }
     return credential;
 }
-const getPoolKey = (credential) => (credential.host || '') + '_' + (credential.port || '5432') + (credential.user || '') + '_' + (credential.password || '') + '_' + (credential.database || '') + '_' + (credential.connectionString || '');
+function fromConnectionString(credential, uri) {
+    const { user, password, host, port, database, application_name, ssl } = connectionString.parse(uri);
+    if (!credential.user) {
+        credential.user = user;
+        credential.password = password;
+    }
+    credential.host || (credential.host = host);
+    if (port) {
+        credential.port || (credential.port = parseInt(port));
+    }
+    credential.database || (credential.database = database);
+    credential.application_name || (credential.application_name = application_name);
+    if (ssl) {
+        credential.ssl ?? (credential.ssl = (0, types_1.isPlainObject)(ssl) ? ssl : true);
+    }
+    return credential;
+}
+function getPoolKey(credential) {
+    if (credential.host && credential.user) {
+        if ('uuidKey' in credential) {
+            credential = { ...credential };
+            delete credential.uuidKey;
+        }
+        return JSON.stringify(credential);
+    }
+}
 function setAuthentication(credential) {
     const auth = (0, util_1.parseServerAuth)(credential);
     credential.host || (credential.host = auth.hostname);
     credential.user || (credential.user = auth.username);
+    if ((0, types_1.isString)(credential.connectionString)) {
+        fromConnectionString(credential, credential.connectionString);
+    }
     if ((0, types_1.isPlainObject)(credential.ssl)) {
         this.readTLSConfig(credential.ssl);
     }
@@ -59,8 +89,10 @@ function setCredential(item) {
         setAuthentication.call(this, credential);
     }
     else {
-        credential = { connectionString: item.uri };
-        item.credential = credential;
+        credential = {};
+        if ((0, types_1.isString)(item.uri)) {
+            item.credential = fromConnectionString(credential, item.uri);
+        }
     }
     if (!credential.connectionString) {
         const errors = [];
@@ -82,18 +114,19 @@ function setCredential(item) {
         return;
     }
     let username, password, pool;
-    if (typeof usePool === 'string' && (username = credential.user || credential.connectionString && (0, util_1.parseConnectionString)(credential.connectionString)?.username)) {
-        [password, pool] = DbPool.validateKey(POOL_STATE, username, usePool);
-        if (pool) {
-            pool.add(item, password);
+    if ((0, types_1.isString)(usePool)) {
+        if (username = credential.user || credential.connectionString && (0, util_1.parseConnectionString)(credential.connectionString)?.username) {
+            [password, pool] = DbPool.validateKey(POOL_STATE, username, usePool);
+            if (pool) {
+                pool.add(item, password);
+                return;
+            }
+        }
+        if (!password) {
+            item.usePool = '';
             return;
         }
     }
-    const poolKey = getPoolKey(credential);
-    if ((pool = POOL_STATE[poolKey]) && !pool.closed) {
-        pool.add(item);
-        return;
-    }
     const config = this.getPoolConfig("postgres" /* STRINGS.MODULE_NAME */, password);
     if (config) {
         const { min, max, idle, timeout } = config;
@@ -110,6 +143,11 @@ function setCredential(item) {
             credential.connectionTimeoutMillis ?? (credential.connectionTimeoutMillis = timeout);
         }
     }
+    const poolKey = getPoolKey(credential);
+    if ((pool = POOL_STATE[poolKey]) && !pool.closed) {
+        pool.add(item);
+        return;
+    }
     new PostgresPool(new postgres.Pool(credential), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
 }
 exports.setCredential = setCredential;
@@ -221,10 +259,10 @@ async function executeBatchQuery(batch, options = '', outResult) {
             continue;
         }
         item.transactionState = 1 /* DB_TRANSACTION.ACTIVE */;
-        const renewCache = ignoreCache === 0;
-        const cacheValue = renewCache ? { sessionKey, renewCache } : sessionKey;
+        const streamRow = typeof item.streamRow === 'string' ? this.hasCoerce("postgres" /* STRINGS.MODULE_NAME */, 'options', null, credential) && (0, types_1.asFunction)(item.streamRow) : item.streamRow;
+        const cacheValue = ignoreCache === undefined ? sessionKey : Array.isArray(ignoreCache) ? { sessionKey, exclusiveOf: ignoreCache } : { sessionKey, renewCache: ignoreCache === 0 };
         let queryString = '';
-        if (caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache) {
+        if (caching && ignoreCache !== true) {
             queryString = Db.asString(query, true) + '_' + Db.asString(params, true);
             if (ignoreCache !== 1) {
                 const result = this.getQueryResult(source, removePoolProperties(credential), queryString, cacheValue);
@@ -261,9 +299,41 @@ async function executeBatchQuery(batch, options = '', outResult) {
                     postgresClient = undefined;
                 }
                 commandType = this.commandType.SELECT;
-                const { rows, command } = await client.query(query, params);
-                this.add(item, 4 /* DB_TRANSACTION.COMMIT */);
-                resolve(rows.length || command === 'SELECT' ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : null);
+                if (streamRow && (0, types_1.isString)(query)) {
+                    const rows = [];
+                    const processRow = typeof streamRow === 'function' && streamRow;
+                    const stream = client.query(new QueryStream(query, params));
+                    stream
+                        .on('data', row => {
+                        if (processRow) {
+                            const err = processRow(row);
+                            if (err === false) {
+                                return;
+                            }
+                            if (err instanceof Error) {
+                                error = err;
+                                return;
+                            }
+                        }
+                        rows.push(row);
+                    })
+                        .on('error', err => error || (error = err))
+                        .on('close', () => {
+                        if (error && this.handleFail(error, item, { errorQuery, commandType })) {
+                            reject(error);
+                        }
+                        else {
+                            this.add(item, 4 /* DB_TRANSACTION.COMMIT */);
+                            resolve(!error ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : rows);
+                        }
+                    })
+                        .on('end', () => stream.destroy());
+                }
+                else {
+                    const { rows, command } = await client.query(query, params);
+                    this.add(item, 4 /* DB_TRANSACTION.COMMIT */);
+                    resolve(rows.length || command === 'SELECT' ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : null);
+                }
             }
             catch (err) {
                 if (this.handleFail(err, item, { errorQuery, commandType })) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/postgres",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "PostgreSQL client driver for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
@@ -21,8 +21,10 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/db": "^0.8.0",
-    "@e-mc/types": "^0.8.0",
-    "pg": "^8.11.3"
+    "@e-mc/db": "^0.8.2",
+    "@e-mc/types": "^0.8.2",
+    "pg": "^8.11.3",
+    "pg-connection-string": "^2.6.2",
+    "pg-query-stream": "^4.5.3"
   }
 }