orange-orm 4.2.0-beta.6 → 4.3.0-beta.0

package/docs/changelog.md

@@ -1,4 +1,6 @@
 ## Changelog
+__4.2.0__  
+Improved performance.  
 __4.1.4__  
 Better error message when running over http.  
 __4.1.3__  

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orange-orm",
-  "version": "4.2.0-beta.6",
+  "version": "4.3.0-beta.0",
   "main": "./src/index.js",
   "browser": "./src/client/index.mjs",
   "bin": {
@@ -63,6 +63,7 @@
     "glob": "^10.3.4",
     "module-definition": "^4.0.0",
     "node-cls": "^1.0.5",
+    "postgres": "^3.4.4",
     "promise": "^8.0.3",
     "rfdc": "^1.2.0",
     "uuid": "^8.3.2"
@@ -71,6 +72,7 @@
     "msnodesqlv8": "^4.1.0",
     "mysql2": "^2.2.5 || ^3.9.4",
     "oracledb": "^6.3.0",
+    "postgres": "^3.4.4",
     "pg": "^8.5.1",
     "pg-native": "^3.0.0",
     "pg-query-stream": "^3.3.2",
@@ -78,6 +80,9 @@
     "tedious": "^15.1.2 || ^16.0.0 || ^18.1.0"
   },
   "peerDependenciesMeta": {
+    "postgres": {
+      "optional": true
+    },
     "pg": {
       "optional": true
     },
@@ -114,6 +119,7 @@
     "mysql2": "^3.9.4",
     "oracledb": "^6.3.0",
     "owasp-dependency-check": "^0.0.21",
+    "postgres": "^3.4.4",
     "pg": "^8.5.1",
     "pg-query-stream": "^3.3.2",
     "rollup": "^2.52.7",

package/src/client/index.mjs

@@ -815,7 +815,7 @@ var fastJsonPatch = /*#__PURE__*/Object.freeze({
 
 var require$$0 = /*@__PURE__*/getAugmentedNamespace(fastJsonPatch);
 
-function dateToISOString$1(date) {
+function dateToISOString$2(date) {
 	let tzo = -date.getTimezoneOffset();
 	let dif = tzo >= 0 ? '+' : '-';
 
@@ -839,9 +839,9 @@ function dateToISOString$1(date) {
 		':' + pad(tzo % 60);
 }
 
-var dateToISOString_1 = dateToISOString$1;
+var dateToISOString_1 = dateToISOString$2;
 
-let dateToISOString = dateToISOString_1;
+let dateToISOString$1 = dateToISOString_1;
 const isNode = (typeof window === 'undefined');
 
 function stringify$4(value) {
@@ -853,7 +853,7 @@ function replacer(key, value) {
 		return value.toString('base64');
 	// @ts-ignore
 	else if (value instanceof Date  && !isNaN(value))
-		return dateToISOString(value);
+		return dateToISOString$1(value);
 	else
 		return value;
 }
@@ -1587,6 +1587,57 @@ var createPatch$1 = function createPatch(original, dto, options) {
 
 };
 
+let dateToISOString = dateToISOString_1;
+
+function cloneFromDbFast(obj) {
+	if (obj === null || typeof obj !== 'object')
+		return obj;
+	if (Array.isArray(obj)) {
+		const arrClone = [];
+		for (let i = 0; i < obj.length; i++) {
+			arrClone[i] = cloneFromDbFast(obj[i]);
+		}
+		return arrClone;
+	}
+	const clone = {};
+	const keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		clone[key] = cloneFromDbFast(obj[key]);
+	}
+	return clone;
+}
+
+function cloneRegular(obj) {
+	if (obj === null || typeof obj !== 'object')
+		return obj;
+	if (Array.isArray(obj)) {
+		const arrClone = [];
+		for (let i = 0; i < obj.length; i++) {
+			arrClone[i] = cloneRegular(obj[i]);
+		}
+		return arrClone;
+	}
+	else if (obj instanceof Date  && !isNaN(obj))
+		return dateToISOString(obj);
+	const clone = {};
+	const keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		clone[key] = cloneRegular(obj[key]);
+	}
+	return clone;
+}
+
+function cloneFromDb$1(obj, isFast) {
+	if (isFast)
+		return cloneFromDbFast(obj);
+	else
+		return cloneRegular(obj);
+}
+
+var cloneFromDb_1 = cloneFromDb$1;
+
 function bind(fn, thisArg) {
   return function wrap() {
     return fn.apply(thisArg, arguments);
@@ -3607,7 +3658,7 @@ function isAbsoluteURL(url) {
  */
 function combineURLs(baseURL, relativeURL) {
   return relativeURL
-    ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')
+    ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
     : baseURL;
 }
 
@@ -4241,7 +4292,7 @@ function mergeConfig(config1, config2) {
   return config;
 }
 
-const VERSION = "1.6.3";
+const VERSION = "1.6.2";
 
 const validators$1 = {};
 
@@ -5298,6 +5349,7 @@ var axiosInterceptor = function create() {
 
 const createPatch = createPatch$1;
 const stringify = stringify_1;
+const cloneFromDb = cloneFromDb_1;
 const netAdapter = netAdapter_1;
 const toKeyPositionMap = toKeyPositionMap_1;
 const rootMap = new WeakMap();
@@ -5524,7 +5576,7 @@ function rdbClient(options = {}) {
 			let args = [_, strategy].concat(Array.prototype.slice.call(arguments).slice(2));
 			let rows = await getManyCore.apply(null, args);
 			await metaPromise;
-			return proxify(rows, strategy, {fastStringify : true});
+			return proxify(rows, strategy, true);
 		}
 
 		async function groupBy(strategy) {
@@ -5556,7 +5608,7 @@ function rdbClient(options = {}) {
 			await metaPromise;
 			if (rows.length === 0)
 				return;
-			return proxify(rows[0], strategy, {fastStringify : true});
+			return proxify(rows[0], strategy, true);
 		}
 
 		async function getById() {
@@ -5744,14 +5796,14 @@ function rdbClient(options = {}) {
 		}
 
 
-		function proxify(itemOrArray, strategy, options) {
+		function proxify(itemOrArray, strategy, fast) {
 			if (Array.isArray(itemOrArray))
-				return proxifyArray(itemOrArray, strategy, options);
+				return proxifyArray(itemOrArray, strategy, fast);
 			else
-				return proxifyRow(itemOrArray, strategy, options);
+				return proxifyRow(itemOrArray, strategy, fast);
 		}
 
-		function proxifyArray(array, strategy, { fastStringify } = {}) {
+		function proxifyArray(array, strategy, fast) {
 			let _array = array;
 			if (_reactive)
 				array = _reactive(array);
@@ -5778,8 +5830,11 @@ function rdbClient(options = {}) {
 				}
 
 			};
-			let innerProxy = new Proxy(array, handler);
-			rootMap.set(array, { json: fastStringify ? JSON.stringify(array) : stringify(array), strategy, originalArray: [...array] });
+
+			let watcher = onChange(array, () => {
+				rootMap.set(array, { json: cloneFromDb(array, fast), strategy, originalArray: [...array] });
+			});
+			let innerProxy = new Proxy(watcher, handler);
 			if (strategy !== undefined) {
 				const { limit, ...cleanStrategy } = { ...strategy };
 				fetchingStrategyMap.set(array, cleanStrategy);
@@ -5787,18 +5842,18 @@ function rdbClient(options = {}) {
 			return innerProxy;
 		}
 
-		function proxifyRow(row, strategy, { fastStringify } = {}) {
+		function proxifyRow(row, strategy, fast) {
 			let handler = {
 				get(_target, property,) {
 					if (property === 'save' || property === 'saveChanges') //call server then acceptChanges
 						return saveRow.bind(null, row);
-					else if (property === 'delete') //call server then remove from jsonMap and original
+					else if (property === 'delete') //call server then remove from json and original
 						return deleteRow.bind(null, row);
 					else if (property === 'refresh') //refresh from server then acceptChanges
 						return refreshRow.bind(null, row);
-					else if (property === 'clearChanges') //refresh from jsonMap, update original if present
+					else if (property === 'clearChanges') //refresh from json, update original if present
 						return clearChangesRow.bind(null, row);
-					else if (property === 'acceptChanges') //remove from jsonMap
+					else if (property === 'acceptChanges') //remove from json
 						return acceptChangesRow.bind(null, row);
 					else if (property === 'toJSON')
 						return () => {
@@ -5811,8 +5866,10 @@ function rdbClient(options = {}) {
 				}
 
 			};
-			let innerProxy = new Proxy(row, handler);
-			rootMap.set(row, { json: fastStringify ? JSON.stringify(row) : stringify(row), strategy });
+			let watcher = onChange(row, () => {
+				rootMap.set(row, { json: cloneFromDb(row, fast), strategy });
+			});
+			let innerProxy = new Proxy(watcher, handler);
 			fetchingStrategyMap.set(row, strategy);
 			return innerProxy;
 		}
@@ -5882,12 +5939,14 @@ function rdbClient(options = {}) {
 
 		async function saveArray(array, concurrencyOptions, strategy) {
 			let deduceStrategy = false;
-			let { json } = rootMap.get(array);
+			let json = rootMap.get(array)?.json;
+			if (!json)
+				return;
 			strategy = extractStrategy({ strategy }, array);
 			strategy = extractFetchingStrategy(array, strategy);
 
 			let meta = await getMeta();
-			const patch = createPatch(JSON.parse(json), array, meta);
+			const patch = createPatch(json, array, meta);
 			if (patch.length === 0)
 				return;
 			let body = stringify({ patch, options: { strategy, ...tableOptions, ...concurrencyOptions, deduceStrategy } });
@@ -5902,7 +5961,7 @@ function rdbClient(options = {}) {
 			let insertedPositions = getInsertedRowsPosition(array);
 			let { changed, strategy: newStrategy } = await p;
 			copyIntoArray(changed, array, [...insertedPositions, ...updatedPositions]);
-			rootMap.set(array, { json: stringify(array), strategy: newStrategy, originalArray: [...array] });
+			rootMap.set(array, { json: cloneFromDb(array), strategy: newStrategy, originalArray: [...array] });
 		}
 
 		async function patch(patch, concurrencyOptions, strategy) {
@@ -5962,7 +6021,7 @@ function rdbClient(options = {}) {
 				return options.strategy;
 			if (obj) {
 				let context = rootMap.get(obj);
-				if (context.strategy !== undefined) {
+				if (context?.strategy !== undefined) {
 					// @ts-ignore
 					let { limit, ...strategy } = { ...context.strategy };
 					return strategy;
@@ -5981,14 +6040,18 @@ function rdbClient(options = {}) {
 		}
 
 		function clearChangesArray(array) {
-			let { json } = rootMap.get(array);
-			let old = JSON.parse(json);
+			let json = rootMap.get(array)?.json;
+			if (!json)
+				return;
+			let old = cloneFromDb(json);
 			array.splice(0, old.length, ...old);
 		}
 
 		function acceptChangesArray(array) {
 			const map = rootMap.get(array);
-			map.json = stringify(array);
+			if (!map)
+				return;
+			map.json = cloneFromDb(array);
 			map.originalArray = [...array];
 		}
 
@@ -6001,7 +6064,7 @@ function rdbClient(options = {}) {
 			let adapter = netAdapter(url, tableName, { axios: axiosInterceptor, tableOptions });
 			let { strategy } = await adapter.patch(body);
 			array.length = 0;
-			rootMap.set(array, { jsonMap: stringify(array), strategy });
+			rootMap.set(array, { json: cloneFromDb(array), strategy });
 		}
 
 		function setMapValue(rowsMap, keys, row, index) {
@@ -6064,7 +6127,7 @@ function rdbClient(options = {}) {
 				array.splice(i + offset, 1);
 				offset--;
 			}
-			rootMap.set(array, { json: stringify(array), strategy, originalArray: [...array] });
+			rootMap.set(array, { json: cloneFromDb(array), strategy, originalArray: [...array] });
 			fetchingStrategyMap.set(array, strategy);
 		}
 
@@ -6085,12 +6148,12 @@ function rdbClient(options = {}) {
 			strategy = extractStrategy({ strategy }, row);
 			strategy = extractFetchingStrategy(row, strategy);
 
-			let { json } = rootMap.get(row);
+			let json = rootMap.get(row)?.json;
 			if (!json)
 				return;
 			let meta = await getMeta();
 
-			let patch = createPatch([JSON.parse(json)], [row], meta);
+			let patch = createPatch([json], [row], meta);
 			if (patch.length === 0)
 				return;
 
@@ -6099,7 +6162,7 @@ function rdbClient(options = {}) {
 			let adapter = netAdapter(url, tableName, { axios: axiosInterceptor, tableOptions });
 			let { changed, strategy: newStrategy } = await adapter.patch(body);
 			copyInto(changed, [row]);
-			rootMap.set(row, { json: stringify(row), strategy: newStrategy });
+			rootMap.set(row, { json: cloneFromDb(row), strategy: newStrategy });
 		}
 
 		async function refreshRow(row, strategy) {
@@ -6123,20 +6186,23 @@ function rdbClient(options = {}) {
 			for (let p in rows[0]) {
 				row[p] = rows[0][p];
 			}
-			rootMap.set(row, { json: stringify(row), strategy });
+			rootMap.set(row, { json: cloneFromDb(row), strategy });
 			fetchingStrategyMap.set(row, strategy);
 		}
 
 		function acceptChangesRow(row) {
-			const { strategy } = rootMap.get(row);
-			rootMap.set(row, { json: stringify(row), strategy });
+			const data = rootMap.get(row);
+			if (!data)
+				return;
+			const { strategy } = data;
+			rootMap.set(row, { json: cloneFromDb(row), strategy });
 		}
 
 		function clearChangesRow(row) {
-			let { json } = rootMap.get(row);
+			let json = rootMap.get(row)?.json;
 			if (!json)
 				return;
-			let old = JSON.parse(json);
+			let old = cloneFromDb(json);
 			for (let p in row) {
 				delete row[p];
 			}
@@ -6298,6 +6364,38 @@ function column(path, ...previous) {
 
 }
 
+function onChange(target, onChange) {
+
+	let  notified = false;
+	const handler = {
+		get(target, prop, receiver) {
+			const value = Reflect.get(target, prop, receiver);
+			if (typeof value === 'object' && value !== null) {
+				return new Proxy(value, handler);
+			}
+			return value;
+		},
+		set(target, prop, value, receiver) {
+			if (!notified) {
+				notified = true;
+				onChange(JSON.stringify(target));
+			}
+			return Reflect.set(target, prop, value, receiver);
+
+		},
+		deleteProperty(target, prop) {
+			if (!notified) {
+				notified = true;
+				onChange(JSON.stringify(target));
+			}
+			return Reflect.deleteProperty(target, prop);
+		}
+	};
+
+	return new Proxy(target, handler);
+}
+
+
 var client = rdbClient();
 
 export { client as default };

package/src/getManyDto2.js

@@ -0,0 +1,301 @@
+const emptyFilter = require('./emptyFilter');
+const newQuery = require('./getManyDto/newQuery');
+const negotiateRawSqlFilter = require('./table/column/negotiateRawSqlFilter');
+const strategyToSpan = require('./table/strategyToSpan');
+const executeQueries = require('./table/executeQueries');
+
+async function getManyDto(table, filter, strategy, spanFromParent) {
+	filter = negotiateRawSqlFilter(filter, table);
+	if (strategy && strategy.where) {
+		let arg = typeof strategy.where === 'function' ? strategy.where(table) : strategy.where;
+		filter = filter.and(arg);
+	}
+
+	let span = spanFromParent || strategyToSpan(table, strategy);
+	let alias = table._dbName;
+
+	const query = newQuery(table, filter, span, alias);
+	const res = await executeQueries([query]);
+	return decode(strategy, span, await res[0]);
+}
+
+function newCreateRow(span) {
+	let columnsMap = span.columns;
+	const columns = span.table._columns.filter(column => !columnsMap || columnsMap.get(column));
+	const protoRow = createProto(columns, span);
+	const manyNames = [];
+
+	const c = {};
+	c.visitJoin = () => { };
+	c.visitOne = () => { };
+	c.visitMany = function(leg) {
+		manyNames.push(leg.name);
+	};
+
+	span.legs.forEach(onEachLeg);
+	return createRow;
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	function createRow() {
+		const obj = Object.create(protoRow);
+		for (let i = 0; i < manyNames.length; i++) {
+			obj[manyNames[i]] = [];
+		}
+		return obj;
+	}
+}
+
+function createProto(columns, span) {
+	let obj = {};
+	for (let i = 0; i < columns.length; i++) {
+		obj[columns[i].alias] = null;
+	}
+	for (let key in span.aggregates) {
+		obj[key] = null;
+	}
+	const c = {};
+
+	c.visitJoin = function(leg) {
+		obj[leg.name] = null;
+	};
+	c.visitOne = c.visitJoin;
+	c.visitMany = function(leg) {
+		obj[leg.name] = null;
+	};
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	return obj;
+}
+
+function hasManyRelations(span) {
+	let result;
+	const c = {};
+	c.visitJoin = () => { };
+	c.visitOne = c.visitJoin;
+	c.visitMany = function() {
+		result = true;
+	};
+
+	span.legs.forEach(onEachLeg);
+	return result;
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+}
+
+async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys(rows[0]) : []) {
+	const table = span.table;
+	let columnsMap = span.columns;
+	const columns = table._columns.filter(column => !columnsMap || columnsMap.get(column));
+	const rowsLength = rows.length;
+	const columnsLength = columns.length;
+	const primaryColumns = table._primaryColumns;
+	const primaryColumnsLength = primaryColumns.length;
+	const rowsMap = new Map();
+	const fkIds = new Array(rows.length);
+	const getIds = createGetIds();
+	const aggregateKeys = Object.keys(span.aggregates);
+
+	const outRows = new Array(rowsLength);
+	const createRow = newCreateRow(span);
+	const shouldCreateMap = hasManyRelations(span);
+	for (let i = 0; i < rowsLength; i++) {
+		const row = rows[i];
+		let outRow = createRow();
+		let pkWithNullCount = 0;
+		for (let j = 0; j < primaryColumnsLength; j++) {
+			if (row[keys[j]] === null)
+				pkWithNullCount++;
+			if (pkWithNullCount === primaryColumnsLength) {
+				outRow = null;
+				break;
+			}
+			const column = columns[j];
+			outRow[column.alias] = column.decode(row[keys[j]]);
+		}
+
+		outRows[i] = outRow;
+		if (shouldCreateMap) {
+			fkIds[i] = getIds(outRow);
+			addToMap(rowsMap, primaryColumns, outRow);
+		}
+	}	
+	span._rowsMap = rowsMap;
+	span._ids = fkIds;
+	const manyPromise = decodeManyRelations(strategy, span, rows, outRows, keys);
+
+	for (let i = 0; i < rowsLength; i++) {
+		const row = rows[i];
+		let outRow = outRows[i];
+		if (outRow === null)
+			continue;
+		for (let j = primaryColumnsLength; j < columnsLength; j++) {
+			const column = columns[j];
+			outRow[column.alias] = column.decode(row[keys[j]]);
+		}
+
+		for (let j = 0; j < aggregateKeys.length; j++) {
+			const key = aggregateKeys[j];
+			const parse = span.aggregates[key].column?.decode || Number.parseFloat;
+			outRow[key] =  parse(row[keys[j+columnsLength]]);
+		}
+	}
+	
+
+	keys.splice(0, columnsLength + aggregateKeys.length);
+
+	await decodeRelations(strategy, span, rows, outRows, keys);
+	await manyPromise;
+	return outRows;
+
+
+	function createGetIds() {
+		const primaryColumns = table._primaryColumns;
+		const length = primaryColumns.length;
+		if (length === 1) {
+			const alias = table._primaryColumns[0].alias;
+			return (row) => row[alias];
+		}
+		else
+			return (row) => {
+				const result = new Array(length);
+				for (let i = 0; i < length; i++) {
+					result[i] = row[primaryColumns[i].alias];
+				}
+				return result;
+			};
+	}
+
+}
+
+async function decodeManyRelations(strategy, span, rawRows, resultRows, keys) {
+	const promises = [];
+	const c = {};
+	c.visitJoin = () => {};
+	c.visitOne = c.visitJoin;
+
+	c.visitMany = function(leg) {
+		const name = leg.name;
+		const table = span.table;
+		const relation = table._relations[name];
+		const filter = createOneFilter(relation, span._ids);
+		const rowsMap = span._rowsMap;
+		const p = getManyDto(relation.childTable, filter, strategy[name], leg.span).then(subRows => {
+			for (let i = 0; i < subRows.length; i++) {
+				const key = leg.columns.map(column => subRows[i][column.alias]);
+				const parentRow = getFromMap(rowsMap, table._primaryColumns, key);
+				parentRow[name].push(subRows[i]);
+			}
+		});
+		promises.push(p);
+	};
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	await Promise.all(promises);
+}
+async function decodeRelations(strategy, span, rawRows, resultRows, keys) {
+	const promises = [];
+	const c = {};
+	c.visitJoin = function(leg) {
+		const name = leg.name;
+		const p = decode(strategy[name], leg.span, rawRows, keys).then((rows) => {
+			for (let i = 0; i < rows.length; i++) {
+				resultRows[i][name] = rows[i];
+			}
+		});
+		promises.push(p);
+	};
+
+	c.visitOne = c.visitJoin;
+
+	c.visitMany = () => {};
+	// function(leg) {
+	// 	const name = leg.name;
+	// 	const table = span.table;
+	// 	const relation = table._relations[name];
+	// 	const filter = createOneFilter(relation, span._ids);
+	// 	const rowsMap = span._rowsMap;
+	// 	const p = getManyDto(relation.childTable, filter, strategy[name], leg.span).then(subRows => {
+	// 		for (let i = 0; i < subRows.length; i++) {
+	// 			const key = leg.columns.map(column => subRows[i][column.alias]);
+	// 			const parentRow = getFromMap(rowsMap, table._primaryColumns, key);
+	// 			parentRow[name].push(subRows[i]);
+	// 		}
+	// 	});
+	// 	promises.push(p);
+	// };
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	await Promise.all(promises);
+}
+
+function createOneFilter(relation, ids) {
+	const columns = relation.joinRelation.columns;
+
+	if (columns.length === 1)
+		return columns[0].in(ids);
+
+	else
+		return createCompositeFilter();
+
+	function createCompositeFilter() {
+		let filter = emptyFilter;
+		for(let id of ids) {
+			let nextFilter;
+			for (let i = 0; i < columns.length; i++) {
+				if (nextFilter)
+					nextFilter = nextFilter.and(columns[i].eq(id[i]));
+				else
+					nextFilter = columns[i].eq(id[i]);
+			}
+			filter = filter.or(nextFilter);
+		}
+		return filter;
+	}
+}
+
+function addToMap(map, primaryColumns, row) {
+
+	const lastIndex = primaryColumns.length - 1;
+	for (let i = 0; i < lastIndex; i++) {
+		const id = row[primaryColumns[i].alias];
+		if (map.has(id))
+			map = map.get(id);
+		else {
+			const next = new Map();
+			map.set(id, next);
+			map = next;
+		}
+	}
+	map.set(row[primaryColumns[lastIndex].alias], row);
+}
+
+function getFromMap(map, primaryColumns, values) {
+	const length = primaryColumns.length;
+	for (let i = 0; i < length; i++) {
+		map = map.get(values[i]);
+	}
+	return map;
+}
+
+
+module.exports = getManyDto;

package/src/pg/encodeBoolean.js

@@ -1,5 +1,5 @@
 function encodeBoolean(bool) {
-	return bool.toString();
+	return bool;
 }
 
 module.exports = encodeBoolean;

package/src/pg/encodeDate.js

@@ -1,7 +1,7 @@
 function encodeDate(date) {
 	if (date.toISOString)
-		return  '\'' + date.toISOString() + '\'';
-	return '\'' + date + '\'';
+		return  '' + date.toISOString() + '';
+	return '' + date + '';
 }
 
 module.exports = encodeDate;

package/src/pg/encodeJSON.js

@@ -1,15 +1,16 @@
 function encode(arg) {
-	if (Array.isArray(arg))
-		return new JsonBArrayParam(arg);
-	else
-		return arg;
+	// if (Array.isArray(arg))
+	// 	return new JsonBArrayParam(arg);
+	// else
+	return arg;
 }
 
-class JsonBArrayParam {
-	constructor(actualArray) { this.actualArray = actualArray; }
-	toPostgres() {
-		return JSON.stringify(this.actualArray);
-	}
-}
+//todo
+// class JsonBArrayParam {
+// 	constructor(actualArray) { this.actualArray = actualArray; }
+// 	toPostgres() {
+// 		return JSON.stringify(this.actualArray);
+// 	}
+// }
 
 module.exports = encode;

package/src/pg/pool/newPgPool.js

@@ -4,45 +4,19 @@ var EventEmitter = require('events').EventEmitter;
 
 var defaults = require('./defaults');
 var genericPool = require('../../generic-pool');
-var _pg = require('pg');
+var pg = require('postgres');
 
 function newPgPool(connectionString, poolOptions) {
 	poolOptions = poolOptions || {};
-	let pg = poolOptions.native ? _pg.native : _pg;
 	var pool = genericPool.Pool({
 		max: poolOptions.size || poolOptions.poolSize || defaults.poolSize,
 		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
 		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
 		log: poolOptions.log || defaults.poolLog,
 		create: function(cb) {
-			var client = new pg.Client(connectionString);
-			client.connect(function(err) {
-				if (err) return cb(err, null);
-
-				//handle connected client background errors by emitting event
-				//via the pg object and then removing errored client from the pool
-				client.on('error', function(e) {
-					pool.emit('error', e, client);
-
-					// If the client is already being destroyed, the error
-					// occurred during stream ending. Do not attempt to destroy
-					// the client again.
-					if (!client._destroying) {
-						pool.destroy(client);
-					}
-				});
-
-				// Remove connection from pool on disconnect
-				client.on('end', function(_e) {
-					// Do not enter infinite loop between pool.destroy
-					// and client 'end' event...
-					if (!client._destroying) {
-						pool.destroy(client);
-					}
-				});
-				client.poolCount = 0;
-				return cb(null, client);
-			});
+			var client = pg(connectionString, {max: 1});
+			client.poolCount = 0;
+			cb(null, client);
 		},
 		destroy: function(client) {
 			client._destroying = true;

package/src/pg/wrapQuery.js

@@ -2,7 +2,7 @@ var log = require('../table/log');
 var replaceParamChar = require('./replaceParamChar');
 
 function wrapQuery(connection) {
-	var runOriginalQuery = connection.query;
+	// var runOriginalQuery = connection.query;
 	return runQuery;
 
 	function runQuery(query, onCompleted) {
@@ -13,18 +13,15 @@ function wrapQuery(connection) {
 			values: params,
 			types: query.types
 		};
-		log.emitQuery({sql, parameters: params});
+		log.emitQuery({ sql, parameters: params });
 
-		runOriginalQuery.call(connection, query, onInnerCompleted);
+		connection.unsafe(sql, params).then(onInnerCompleted, onCompleted);
+		// runOriginalQuery.call(connection, query, onInnerCompleted);
 
-		function onInnerCompleted(err, result) {
-			if (err)
-				onCompleted(err);
-			else {
-				if (Array.isArray(result))
-					result = result[result.length-1];
-				onCompleted(null, result.rows);
-			}
+		function onInnerCompleted(result) {
+			// if (Array.isArray(result))
+			// 	result = result[result.length - 1];
+			onCompleted(null, result);
 		}
 	}