add postProcessingResult function

 add missing configuration options (min, max)

Author: radicsge

docs/API/PgDb.md

@@ -142,6 +142,11 @@ See the [mapping database types to js types](/mappingDatabaseTypes) section
 
 See the [mapping database types to js types](/mappingDatabaseTypes) section
 
+---
+## setPostProcessResult
+<span class="def"><span class="func">setPostProcessResult</span>(f:(res: <span class="type">any[]</span>, fields: <span class="type">ResultFieldType[]</span>, logger:<span class="type">PgDbLogger</span>)=&gt;<span class="type">void</span>): <span class="type">void</span></span>
+You can add a postprocessor function that will be executed for every result (even empty ones), if you want to do something extra.
+If you call it twice the second function will overwrite the first. So you can easily unset also if you call it will null; 
 
 ---
 ## transactionBegin 

docs/connection.md

@@ -24,16 +24,19 @@ let pgdb = await PgDb.connect({
 With the following options:
 ``` js
 export interface ConnectionOptions {
+    //--- node-postgres specific ----------------------
     host?:string;
     user?:string;     //can be specified through PGUSER     env variable (defaults USER env var)
     database?:string; //can be specified through PGDATABASE env variable (defaults USER env var)
     password?:string; //can be specified through PGPASSWORD env variable
     port?:number;     //can be specified through PGPORT     env variable
-    poolSize?:number;
-    rows?:number;
+    poolSize?:number; //number of connections to use in connection pool. 0 - disable pooling
+    min?:number;                   //minimum number of resources to keep in pool at any given time.  
+    max?:number;      
+    rows?:number;                  //number of rows to return at a time from a prepared statement's portal. 0 will return all rows at once
     binary?:boolean;
-    reapIntervalMillis?:number;
-    poolLog?:boolean;
+    reapIntervalMillis?:number;    //frequency to check for idle clients within the client pool
+    poolLog?:boolean;              //pool log function / boolean
     client_encoding?:string;
     ssl?:boolean| any; // TlsOptions;
     application_name?:string;
@@ -43,10 +46,17 @@ export interface ConnectionOptions {
     idleTimeoutMillis?:number;     // how long a client is allowed to remain idle before being closed
     poolIdleTimeout?:number;
 
+    //--- pogi specific ----------------------------
     logger?:PgDbLogger;
     skipUndefined?: 'all' | 'select' | 'none'; //if there is a undefined value in the query condition, what should pogi do. Default is 'none', meaning raise an error if a value is undefined.
 }
 ```
+
+About node-postgres specific, more explanation can be found at
+https://github.com/brianc/node-postgres/blob/f6c40b9331c90d794d5fcbb1d4ae2f28eabd4d42/lib/defaults.js 
+and 
+https://github.com/coopernurse/node-pool
+
 ##skipUndefined
 while most settings are self explanatory, this parameter is important. In the first version of pogi
 we ignored the condition if the value was undefined in order for ease the use e.g.:

lib/pgDb.d.ts

@@ -1,4 +1,4 @@
-import { QueryAble } from "./queryAble";
+import { QueryAble, ResultFieldType } from "./queryAble";
 import { PgTable } from "./pgTable";
 import { PgSchema } from "./pgSchema";
 export declare enum FieldType {
@@ -25,6 +25,8 @@ export interface ConnectionOptions {
     port?: number;
     poolSize?: number;
     rows?: number;
+    min?: number;
+    max?: number;
     binary?: boolean;
     poolIdleTimeout?: number;
     reapIntervalMillis?: number;
@@ -49,12 +51,13 @@ export interface PgDbLogger {
     log: Function;
     error: Function;
 }
+export declare type PostProcessResultFunc = (res: any[], fields: ResultFieldType[], logger: PgDbLogger) => void;
 export declare class PgDb extends QueryAble {
     protected static instances: {
         [index: string]: Promise<PgDb>;
     };
     pool: any;
-    connection: any;
+    protected connection: any;
     config: ConnectionOptions;
     db: any;
     schemas: {
@@ -68,7 +71,9 @@ export declare class PgDb extends QueryAble {
     };
     [name: string]: any | PgSchema;
     pgdbTypeParsers: {};
+    postProcessResult: PostProcessResultFunc;
     private constructor(pgdb?);
+    setPostProcessResult(f: (res: any[], fields: ResultFieldType[], logger: PgDbLogger) => void): void;
     /** If planned to used as a static singleton */
     static getInstance(config: ConnectionOptions): Promise<PgDb>;
     close(): Promise<void>;

lib/pgDb.js

@@ -1,4 +1,4 @@
-import {QueryAble} from "./queryAble";
+import {QueryAble, ResultFieldType} from "./queryAble";
 var pg = require('pg');
 var util = require('util');
 var readline = require('readline');
@@ -74,14 +74,20 @@ export interface ConnectionOptions {
     password?: string; // can be specified through PGPASSWORD env variable
     port?: number; // can be specified through PGPORT env variable
     poolSize?: number;
+
+    //number of rows to return at a time from a prepared statement's portal. 0 will return all rows at once
     rows?: number;
+
+    min?: number; //set min pool size
+    max?: number; //set pool max size
+
     binary?: boolean;
     poolIdleTimeout?: number;
     reapIntervalMillis?: number;
     poolLog?: boolean;
     client_encoding?: string;
     ssl?: boolean| any; //| TlsOptions;
-    application_name?: string;
+    application_name?: string; //default:process.env.PGAPPNAME - name displayed in the pg_stat_activity view and included in CSV log entries
     fallback_application_name?: string;
     parseInputDatesAsUTC?: boolean;
     connectionString?: string;
@@ -102,23 +108,28 @@ export interface PgDbLogger {
     error: Function;
 }
 
+export type PostProcessResultFunc = (res: any[], fields: ResultFieldType[], logger:PgDbLogger)=>void;
+
+
 export class PgDb extends QueryAble {
     protected static instances: {[index: string]: Promise<PgDb>};
-    pool;
-    connection;
-    config: ConnectionOptions;
+    /*protected*/ pool;
+    protected connection;
+    /*protected*/ config: ConnectionOptions;
     db;
     schemas: {[name: string]: PgSchema};
     tables: {[name: string]: PgTable<any>} = {};
     fn: {[name: string]: (...any)=>any} = {};
     [name: string]: any|PgSchema;
-    pgdbTypeParsers = {};
+    /*protected*/ pgdbTypeParsers = {};
+    /*protected*/ postProcessResult: PostProcessResultFunc;
 
-    private constructor(pgdb: {config?,schemas?,pool?,pgdbTypeParsers?,getLogger?:()=>any} = {}) {
+    private constructor(pgdb: {config?,schemas?,pool?,pgdbTypeParsers?,getLogger?:()=>any, postProcessResult?:PostProcessResultFunc } = {}) {
         super();
         this.schemas = {};
         this.config = pgdb.config;
         this.pool = pgdb.pool;
+        this.postProcessResult = pgdb.postProcessResult;
         this.pgdbTypeParsers = pgdb.pgdbTypeParsers || {};
         this.db = this;
         if (pgdb.getLogger) {
@@ -139,6 +150,8 @@ export class PgDb extends QueryAble {
         }
     }
 
+    setPostProcessResult(f:(res: any[], fields: ResultFieldType[], logger:PgDbLogger)=>void) {this.postProcessResult = f;}
+
     /** If planned to used as a static singleton */
     static async getInstance(config: ConnectionOptions): Promise<PgDb> {
         if (config.connectionString) {

lib/pgDb.js.map

@@ -88,6 +88,8 @@ export class QueryAble {
                 logger.log('reused connection', sql, util.inspect(params, false, null), connection.processID);
                 let res = await connection.query(sql, params);
                 pgUtils.postProcessResult(res.rows, res.fields, this.db.pgdbTypeParsers);
+                if (this.db.postProcessResult) this.db.postProcessResult(res.rows, res.fields, logger);
+
                 return res.rows;
             } else {
                 connection = await this.db.pool.connect();
@@ -98,6 +100,8 @@ export class QueryAble {
                     connection.release();
                     connection = null;
                     pgUtils.postProcessResult(res.rows, res.fields, this.db.pgdbTypeParsers);
+                    if (this.db.postProcessResult) this.db.postProcessResult(res.rows, res.fields, logger);
+
                     return res.rows;
                 } catch(e){
                     logger.error(sql, util.inspect(params, false, null), connection ? connection.processID : null, e);
@@ -139,6 +143,8 @@ export class QueryAble {
                         stream.on('data', (res) => {
                             try {
                                 pgUtils.postProcessResult([res], stream._result.fields, this.db.pgdbTypeParsers);
+                                if (this.db.postProcessResult) this.db.postProcessResult([res], stream._result.fields, this.getLogger(false));
+
                                 if (callback(res)) {
                                     stream.emit('close');
                                 }
@@ -160,6 +166,8 @@ export class QueryAble {
                         stream.on('data', (res) => {
                             try {
                                 pgUtils.postProcessResult([res], stream._result.fields, this.db.pgdbTypeParsers);
+                                if (this.db.postProcessResult) this.db.postProcessResult([res], stream._result.fields, this.getLogger(false));
+
                                 if (callback(res)) {
                                     stream.emit('close');
                                 }
@@ -195,6 +203,8 @@ export class QueryAble {
         let convertTypeFilter = through(function(data) {
             try {
                 pgUtils.postProcessResult([data], pgStream._result.fields, pgdb.pgdbTypeParsers);
+                if (pgdb.postProcessResult) pgdb.postProcessResult([data], pgStream._result.fields, logger);
+
                 this.emit('data', data);
             } catch (err) {
                 this.emit('error', err);

lib/queryAble.js

@@ -123,6 +123,8 @@ describe("pgdb", () => {
     }));
 
 
+
+
     it("After adding parser should be able to parse complex type", w(async() => {
         await pgdb.setTypeParser('permissionForResourceType', (val) => parseComplexType(val));
         await pgdb.setTypeParser('_permissionForResourceType', (val) => val=="{}" ? [] : parseComplexTypeArray(val));
@@ -692,4 +694,17 @@ describe("pgdb", () => {
 
     }));
 
+
+    it("Testing postprocess function",  w(async() => {
+        await table.insert({name: 'A'});
+
+        pgdb.setPostProcessResult((res, fields, logger)=> {
+            res[0].name='B';
+        });
+        let res = await pgdb.query(`select * from ${table}`);
+        expect(res[0].name=='B').toBeTruthy();
+        res = await table.findAll();
+        expect(res[0].name=='B').toBeTruthy();
+        pgdb.setPostProcessResult(null);
+    }));
 });

lib/queryAble.js.map

@@ -0,0 +1,4 @@
+CREATE OR REPLACE FUNCTION LOWER(text[]) RETURNS text[] LANGUAGE SQL IMMUTABLE AS
+$$
+    SELECT array_agg(LOWER(value)) FROM unnest($1) value;
+$$;