@pi-r/postgres 0.7.2 → 0.8.0

package/client/index.js

@@ -1,50 +1,18 @@
 "use strict";
-exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = exports.checkTimeout = exports.executeBatchQuery = exports.executeQuery = exports.setCredential = exports.setAuthentication = void 0;
+exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = void 0;
+exports.setAuthentication = setAuthentication;
+exports.setCredential = setCredential;
+exports.executeQuery = executeQuery;
+exports.executeBatchQuery = executeBatchQuery;
+exports.checkTimeout = checkTimeout;
 const postgres = require("pg");
 const connectionString = require("pg-connection-string");
+const QueryStream = require("pg-query-stream");
+const Db = require("@e-mc/db");
 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() {
-        return this.client.connect();
-    }
-    async close() {
-        return this.client.end();
-    }
-    isEmpty() {
-        return this.closed || this.client.totalCount === 0 && this.client.waitingCount === 0;
-    }
-    get closed() {
-        return this.client.ended;
-    }
-}
+const DbPool = require("@pi-r/postgres/client/pool");
 const POOL_STATE = {};
-const POOL_UNUSED = ['ssl', 'keepAlive', 'statement_timeout', 'query_timeout', 'keepAliveInitialDelayMillis', 'idle_in_transaction_session_timeout', 'connectionTimeoutMillis', 'max', 'min', 'idleTimeoutMillis', 'log', 'allowExitOnIdle', 'maxUses'];
-const POOL_ACTIVE = new WeakSet();
-function removePoolProperties(credential) {
-    if (!credential.uuidKey && POOL_ACTIVE.has(credential)) {
-        let result;
-        for (let i = 0, length = POOL_UNUSED.length; i < length; ++i) {
-            const attr = POOL_UNUSED[i];
-            if (attr in credential) {
-                result ||= { ...credential };
-                if (attr === 'ssl' && (0, types_1.isObject)(result[attr])) {
-                    result[attr] = true;
-                }
-                else {
-                    delete result[attr];
-                }
-            }
-        }
-        if (result) {
-            return result;
-        }
-    }
-    return credential;
-}
 function fromConnectionString(credential, uri) {
     const { user, password, host, port, database, application_name, ssl } = connectionString.parse(uri);
     if (!credential.user) {
@@ -62,15 +30,6 @@ function fromConnectionString(credential, uri) {
     }
     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 ||= auth.hostname;
@@ -82,7 +41,6 @@ function setAuthentication(credential) {
         this.readTLSConfig(credential.ssl);
     }
 }
-exports.setAuthentication = setAuthentication;
 function setCredential(item) {
     let credential = this.getCredential(item);
     if (credential) {
@@ -90,7 +48,7 @@ function setCredential(item) {
     }
     else {
         credential = {};
-        if ((0, types_1.isString)(item.uri)) {
+        if (item.uri) {
             item.credential = fromConnectionString(credential, item.uri);
         }
     }
@@ -102,10 +60,21 @@ function setCredential(item) {
         if (!credential.user) {
             errors.push('user');
         }
-        if (errors.length) {
+        if (errors.length > 0) {
             throw (0, types_1.errorMessage)("postgres", 'Not defined - ' + errors.join(' | '));
         }
     }
+    if (credential.host?.endsWith('.rds.amazonaws.com')) {
+        try {
+            const ssl = credential.ssl ||= {};
+            if ((0, types_1.isPlainObject)(ssl) && !ssl.ca) {
+                const bundle = require('aws-ssl-profiles');
+                ssl.ca = bundle.ca;
+            }
+        }
+        catch {
+        }
+    }
     const usePool = item.usePool;
     if (!item.usePool || typeof credential.password === 'function') {
         if ('usePool' in item) {
@@ -143,18 +112,19 @@ function setCredential(item) {
             credential.connectionTimeoutMillis ??= timeout;
         }
     }
-    const poolKey = getPoolKey(credential);
+    const poolKey = DbPool.asString(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;
+    const client = new postgres.Pool(credential);
+    new DbPool(client, poolKey, username && password ? { username, password } : undefined)
+        .add(item)
+        .parent = POOL_STATE;
 }
-exports.setCredential = setCredential;
 async function executeQuery(item, options) {
     return (await executeBatchQuery.call(this, [item], options))[0] || [];
 }
-exports.executeQuery = executeQuery;
 async function executeBatchQuery(batch, options = '', outResult) {
     const length = batch.length;
     if (length === 0) {
@@ -189,20 +159,18 @@ async function executeBatchQuery(batch, options = '', outResult) {
         item.transactionState = 64;
         let client;
         if (postgresPool) {
-            pools.push(client = await postgresPool.getConnection());
+            pools.push(client = await postgresPool.getConnection(credential));
             item.transactionState &= ~64;
-            POOL_ACTIVE.add(credential);
             return client;
         }
-        const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, getPoolKey(credential), ...connectOnce ? [item, batch[0]] : [item]);
+        const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, DbPool.asString(credential), ...connectOnce ? [item, batch[0]] : [item]);
         if (pool) {
             try {
-                pools.push(client = await pool.getConnection());
+                pools.push(client = await pool.getConnection(credential));
                 if (connectOnce) {
                     postgresPool = pool;
                 }
                 pool.connected = true;
-                POOL_ACTIVE.add(credential);
             }
             catch (err) {
                 let close;
@@ -267,7 +235,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         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);
+                const result = this.getQueryResult(source, DbPool.sanitize(credential), queryString, cacheValue);
                 if (result) {
                     if (parallel) {
                         tasks[i] = Promise.resolve(result);
@@ -303,7 +271,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                 commandType = this.commandType.SELECT;
                 if (streamRow && (0, types_1.isString)(query)) {
                     const rows = [];
-                    const processRow = typeof streamRow === 'function' && streamRow;
+                    const processRow = typeof streamRow === 'function' ? streamRow : null;
                     const stream = client.query(new QueryStream(query, params));
                     stream
                         .on('data', row => {
@@ -326,7 +294,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                         }
                         else {
                             this.add(item, 4);
-                            resolve(!error ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : rows);
+                            resolve(!error ? this.setQueryResult(source, DbPool.sanitize(credential), queryString, rows, cacheValue) : rows);
                         }
                     })
                         .on('end', () => stream.destroy());
@@ -334,7 +302,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                 else {
                     const { rows, command } = await client.query(query, params);
                     this.add(item, 4);
-                    resolve(rows.length || command === 'SELECT' ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : null);
+                    resolve(rows.length || command === 'SELECT' ? this.setQueryResult(source, DbPool.sanitize(credential), queryString, rows, cacheValue) : null);
                 }
             }
             catch (err) {
@@ -357,25 +325,23 @@ async function executeBatchQuery(batch, options = '', outResult) {
         }
     }
     return this.processRows(batch, tasks, {
+        parallel,
         disconnect: () => {
-            clients.forEach(item => {
+            for (const item of clients) {
                 item.end(err => {
                     if (err) {
                         this.writeFail(["Unable to close connnection", "postgres"], err, { type: 65536, fatal: false });
                     }
                 });
-            });
-            pools.forEach(item => {
+            }
+            for (const item of pools) {
                 item.release();
-            });
-        },
-        parallel
+            }
+        }
     }, outResult);
 }
-exports.executeBatchQuery = executeBatchQuery;
 async function checkTimeout(value, limit = 0) {
     return DbPool.checkTimeout(POOL_STATE, value, limit);
 }
-exports.checkTimeout = checkTimeout;
 exports.DB_SOURCE_CLIENT = true;
 exports.DB_SOURCE_TYPE = types_1.DB_TYPE.SQL;

package/client/pool.d.ts

@@ -0,0 +1,9 @@
+import type { DbPoolConstructor } from '@e-mc/types/lib/db';
+
+import type { DbPoolCredential, PostgresDataSource } from '../types';
+
+import type { Pool, PoolClient } from 'pg';
+
+declare const PostgresPool: DbPoolConstructor<PostgresDataSource, Pool, PoolClient, DbPoolCredential>;
+
+export = PostgresPool;

package/client/pool.js

@@ -0,0 +1,55 @@
+"use strict";
+const types_1 = require("@e-mc/types");
+const DbPool = require('@e-mc/db/pool');
+const POOL_ACTIVE = new WeakSet();
+class PostgresPool extends DbPool {
+    static CACHE_UNUSED = ['keepAlive', 'statement_timeout', 'query_timeout', 'keepAliveInitialDelayMillis', 'idle_in_transaction_session_timeout', 'connectionTimeoutMillis', 'max', 'min', 'idleTimeoutMillis', 'log', 'allowExitOnIdle', 'maxUses'];
+    static asString(credential) {
+        if (credential.host && credential.user) {
+            return JSON.stringify(this.removeUUIDKey(credential));
+        }
+        return super.asString(credential);
+    }
+    static sanitize(credential) {
+        if (!POOL_ACTIVE.has(credential) || credential.uuidKey) {
+            return credential;
+        }
+        const ssl = credential.ssl;
+        let result = super.sanitize(credential);
+        if ((0, types_1.isObject)(ssl)) {
+            if (result === credential) {
+                result = { ...credential };
+            }
+            const cert = ssl.cert;
+            if ((0, types_1.isString)(cert)) {
+                result.ssl = { cert };
+            }
+            else if (Buffer.isBuffer(cert)) {
+                result.ssl = { cert: cert.toString('utf-8') };
+            }
+            else if ((0, types_1.isArray)(cert)) {
+                result.ssl = { cert: cert.reduce((a, b) => a + (Buffer.isBuffer(b) ? b.toString('utf-8') : b), '') };
+            }
+            else {
+                result.ssl = { cert: "Unknown" };
+            }
+        }
+        return result;
+    }
+    async getConnection(credential) {
+        if (credential) {
+            POOL_ACTIVE.add(credential);
+        }
+        return this.client.connect();
+    }
+    async close() {
+        return this.client.end();
+    }
+    isEmpty() {
+        return this.closed || this.client.totalCount === 0 && this.client.waitingCount === 0;
+    }
+    get closed() {
+        return this.client.ended;
+    }
+}
+module.exports = PostgresPool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/postgres",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "PostgreSQL client driver for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
@@ -21,8 +21,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/db": "^0.9.4",
-    "@e-mc/types": "^0.9.4",
+    "@e-mc/db": "^0.10.0",
+    "@e-mc/types": "^0.10.0",
     "pg": "^8.12.0",
     "pg-connection-string": "^2.6.4",
     "pg-query-stream": "^4.6.0"

package/types/index.d.ts

@@ -1,5 +1,6 @@
 import type { DbDataSource } from '@e-mc/types/lib/squared';
 
+import type { IdentifierAction } from '@e-mc/types/lib/core';
 import type { ExecuteAction, ServerAuth } from '@e-mc/types/lib/db';
 
 // @ts-ignore
@@ -9,4 +10,5 @@ export interface PostgresDataSource<T = unknown[]> extends DbDataSource<string |
     source: "postgres";
 }
 
-export interface PostgresCredential extends Omit<ServerAuth, "password">, PoolConfig {}
+export interface PostgresCredential extends Omit<ServerAuth, "password">, PoolConfig {}
+export type DbPoolCredential = PoolConfig & IdentifierAction;