@trenskow/pged 4.1.6 → 5.0.0

package/{.eslintrc.js → .eslintrc.cjs}

@@ -5,14 +5,14 @@ module.exports = {
 		'mocha': true
 	},
 	'parserOptions': {
-		'ecmaVersion': 2017
+		'ecmaVersion': 2017,
+		'sourceType': 'module'
 	},
 	'extends': 'eslint:recommended',
 	'rules': {
 		'indent': [
 			'error',
-			'tab',
-			{ 'SwitchCase': 1 }
+			'tab'
 		],
 		'linebreak-style': [
 			'error',
@@ -45,15 +45,6 @@ module.exports = {
 				'allowEmptyCatch': true
 			}
 		],
-		'no-trailing-spaces': [
-			'error', {
-				'ignoreComments': true
-			}
-		],
-		'require-atomic-updates': 'off',
-		'eol-last': [
-			'error',
-			'always'
-		]
+		'require-atomic-updates': 'off'
 	}
 };

package/index.js

@@ -1,20 +1,18 @@
 'use strict';
 
-const
-	Puqeue = require('puqeue'),
-	caseit = require('@trenskow/caseit'),
-	{ Pool } = require('pg');
+import Puqeue from 'puqeue';
+import caseit from '@trenskow/caseit';
+import { Pool } from 'pg';
 
-const
-	QueryBuilder = require('./query-builder'),
-	EventEmitter = require('./event-emitter');
+import QueryBuilder from './query-builder';
+import EventEmitter from '@trenskow/async-event-emitter';
 
 let id = 0;
 
 let pgOptions;
 let pool;
 
-module.exports = exports = class PGed extends EventEmitter {
+export default exports = class PGed extends EventEmitter {
 
 	static get pg() {
 		return pgOptions;

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@trenskow/pged",
-  "version": "4.1.6",
+  "version": "5.0.0",
   "description": "Just a silly little db management and query builder for PostgreSQL.",
   "main": "index.js",
+  "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -22,6 +23,7 @@
   },
   "homepage": "https://github.com/trenskow/pged#readme",
   "dependencies": {
+    "@trenskow/async-event-emitter": "^0.0.1",
     "@trenskow/caseit": "^1.3.0",
     "@trenskow/custom-promise": "^0.10.1",
     "pg": "^8.7.3",

package/query-builder.js

@@ -1,14 +1,13 @@
 'use strict';
 
-const
-	caseit = require('@trenskow/caseit'),
-	CustomPromise = require('@trenskow/custom-promise'),
-	Puqeue = require('puqeue');
+import caseit from '@trenskow/caseit';
+import CustomPromise from '@trenskow/custom-promise';
+import Puqeue from 'puqeue';
 
 const tableInformationQueue = new Puqeue();
 const tableInformation = {};
 
-module.exports = exports = class QueryBuilder extends CustomPromise {
+export default exports = class QueryBuilder extends CustomPromise {
 
 	constructor(table, options = {}, connection) {
 
@@ -248,15 +247,15 @@ module.exports = exports = class QueryBuilder extends CustomPromise {
 		if (!Array.isArray(keys)) keys = keys.split(/, ?/);
 
 		switch (Object.keys(action || {})[0] || 'nothing') {
-			case 'nothing':
-				break;
-			case 'update': {
-				const [keys, values] = this._deconstructKeyValues(action.update);
-				action.update = { keys, values };
-				break;
-			}
-			default:
-				throw new Error('Action `update` is only supported at this moment.');
+		case 'nothing':
+			break;
+		case 'update': {
+			const [keys, values] = this._deconstructKeyValues(action.update);
+			action.update = { keys, values };
+			break;
+		}
+		default:
+			throw new Error('Action `update` is only supported at this moment.');
 		}
 
 		this._onConflict = {
@@ -293,10 +292,10 @@ module.exports = exports = class QueryBuilder extends CustomPromise {
 		let [table, key] = keyPath.split('.');
 		if (typeof key === 'undefined') [table, key] = [this._table, table];
 		switch ((tableInformation[caseit(table, this._options.casing.db)] || {})[caseit(key, this._options.casing.db)]) {
-			case 'jsonb':
-				return typeof value === 'string' ? value : JSON.stringify(value);
-			default:
-				return value;
+		case 'jsonb':
+			return typeof value === 'string' ? value : JSON.stringify(value);
+		default:
+			return value;
 		}
 	}
 
@@ -347,23 +346,23 @@ module.exports = exports = class QueryBuilder extends CustomPromise {
 
 			if (key.substring(0, 1) == '$') {
 				switch (caseit(key)) {
-					case '$or':
-					case '$and':
-						return this._buildConditions(condition[key], key, comparer, true);
-					case '$eq':
-					case '$ne':
-					case '$neq':
-					case '$lt':
-					case '$lte':
-					case '$gt':
-					case '$gte':
-					case '$regexp':
-					case '$jsonContains':
-					case '$jsonNotContains':
-					case '$jsonArrayContains':
-						return this._buildConditions(condition[key], operator, key, true);
-					default:
-						throw new TypeError(`Unknown modifier ${caseit(key)}.`);
+				case '$or':
+				case '$and':
+					return this._buildConditions(condition[key], key, comparer, true);
+				case '$eq':
+				case '$ne':
+				case '$neq':
+				case '$lt':
+				case '$lte':
+				case '$gt':
+				case '$gte':
+				case '$regexp':
+				case '$jsonContains':
+				case '$jsonNotContains':
+				case '$jsonArrayContains':
+					return this._buildConditions(condition[key], operator, key, true);
+				default:
+					throw new TypeError(`Unknown modifier ${caseit(key)}.`);
 				}
 			}
 
@@ -386,12 +385,12 @@ module.exports = exports = class QueryBuilder extends CustomPromise {
 
 			if (condition[key] == null) {
 				switch (comparer) {
-					case '$eq':
-						return `${dbKey} is null`;
-					case '$ne':
-						return `${dbKey} is not null`;
-					default:
-						throw new TypeError(`Modifier ${comparer} is not usable with \`null\` values.`);
+				case '$eq':
+					return `${dbKey} is null`;
+				case '$ne':
+					return `${dbKey} is not null`;
+				default:
+					throw new TypeError(`Modifier ${comparer} is not usable with \`null\` values.`);
 				}
 			}
 
@@ -429,10 +428,10 @@ module.exports = exports = class QueryBuilder extends CustomPromise {
 			if (join.conditions) {
 				let type;
 				switch (join.required) {
-					case 'both': type = 'join'; break;
-					case 'local': type = 'left join'; break;
-					case 'foreign': type = 'right join'; break;
-					case 'none': type = 'outer join'; break;
+				case 'both': type = 'join'; break;
+				case 'local': type = 'left join'; break;
+				case 'foreign': type = 'right join'; break;
+				case 'none': type = 'outer join'; break;
 				}
 				return `${type} ${this._dbCase(join.table)} on ${this._buildConditions(join.conditions)}`;
 			} else {
@@ -512,14 +511,14 @@ module.exports = exports = class QueryBuilder extends CustomPromise {
 		if (!this._onConflict) return '';
 		let result = `on conflict (${this._buildKeys(this._onConflict.keys, true)}) do `;
 		switch (Object.keys(this._onConflict.action || {})[0] || 'nothing') {
-			case 'nothing':
-				result += 'nothing';
-				break;
-			case 'update':
-				result += `update ${this._buildUpdateKeysAndValues(this._onConflict.action.update.keys, this._onConflict.action.update.values)}`;
-				break;
-			default:
-				break;
+		case 'nothing':
+			result += 'nothing';
+			break;
+		case 'update':
+			result += `update ${this._buildUpdateKeysAndValues(this._onConflict.action.update.keys, this._onConflict.action.update.values)}`;
+			break;
+		default:
+			break;
 		}
 		return result;
 	}
@@ -533,46 +532,46 @@ module.exports = exports = class QueryBuilder extends CustomPromise {
 		let parts = [command];
 
 		switch (command) {
-			case 'select':
-				parts = parts.concat([
-					this._buildKeys(this._selectKeys, true),
-					'from',
-					this._table,
-					this._buildJoins(),
-					this._buildWhere(),
-					this._buildGroup(),
-					this._buildHaving(),
-					this._buildSorting(),
-					this._buildOffset(),
-					this._buildLimit()
-				]);
-				break;
-			case 'update':
-				parts = parts.concat([
-					this._table,
-					this._buildUpdate(),
-					this._buildWhere(),
-					'returning',
-					this._buildKeys(this._selectKeys, true)
-				]);
-				break;
-			case 'insert':
-				parts = parts.concat([
-					'into',
-					this._table,
-					this._buildInsert(),
-					this._buildOnConflict(),
-					'returning',
-					this._buildKeys(this._selectKeys, true)
-				]);
-				break;
-			case 'delete':
-				parts = parts.concat([
-					'from',
-					this._table,
-					this._buildWhere()
-				]);
-				break;
+		case 'select':
+			parts = parts.concat([
+				this._buildKeys(this._selectKeys, true),
+				'from',
+				this._table,
+				this._buildJoins(),
+				this._buildWhere(),
+				this._buildGroup(),
+				this._buildHaving(),
+				this._buildSorting(),
+				this._buildOffset(),
+				this._buildLimit()
+			]);
+			break;
+		case 'update':
+			parts = parts.concat([
+				this._table,
+				this._buildUpdate(),
+				this._buildWhere(),
+				'returning',
+				this._buildKeys(this._selectKeys, true)
+			]);
+			break;
+		case 'insert':
+			parts = parts.concat([
+				'into',
+				this._table,
+				this._buildInsert(),
+				this._buildOnConflict(),
+				'returning',
+				this._buildKeys(this._selectKeys, true)
+			]);
+			break;
+		case 'delete':
+			parts = parts.concat([
+				'from',
+				this._table,
+				this._buildWhere()
+			]);
+			break;
 		}
 
 		return [parts.filter((part) => part && part.length).join(' '), this._queryParameters];

package/event-emitter.js

@@ -1,43 +0,0 @@
-'use strict';
-
-module.exports = exports = class EventEmitter {
-
-	constructor() {
-		this._identifier = -1;
-		this._listeners = {};
-	}
-
-	on(name, handler) {
-		this._listeners[name] = this._listeners[name] || [];
-		this._listeners[name].push({
-			handler,
-			identifier: ++this._identifier
-		});
-		return this._identifier;
-	}
-
-	remove(name, identifier) {
-		if (typeof this._listeners[name] === 'undefined') return;
-		this._listeners[name] = this._listeners[name].filter((listener) => {
-			return listener.handler !== identifier && listener.identifier !== identifier;
-		});
-	}
-
-	once(name, handler) {
-		const identifier = this.on(name, async (...args) => {
-			this.remove(name, identifier);
-			await handler(...args);
-		});
-	}
-
-	removeAll(name) {
-		this._identifier[name] = undefined;
-	}
-
-	async emit(name, ...args) {
-		await Promise.all((this._listeners[name] || []).map(async (listener) => {
-			await listener.handler(...args);
-		}));
-	}
-
-};