simplify output function

Author: akrouk

lib/expressions/boolean.js

@@ -1,14 +1,14 @@
 const booleanExpressions = new Object();
 
-const funcData = [ 
+const fnData = [ 
     { name: 'eq', sign: '='}, 
     { name: 'lt', sign: '<' },
     { name: 'gt', sign: '>' },
     { name: 'leq', sign: '<=' },
     { name: 'geq', sign: '>=' }
 ];
 
-funcData.forEach(expr => {
+fnData.forEach(expr => {
     booleanExpressions[expr.name] = (lhs, rhs) => new Object({ lhs, operator: expr.sign, rhs });
 });
 

lib/expressions/numeric.js

@@ -1,7 +1,7 @@
 const numericExpressions = new Object();
 
-[ 'max', 'min', 'count', 'avg', 'sum' ].forEach(func => {
-    numericExpressions[func] = options => `${func.toUpperCase()}(${options.all ? '*' : options})`;
+[ 'max', 'min', 'count', 'avg', 'sum' ].forEach(fn => {
+    numericExpressions[fn] = options => `${fn.toUpperCase()}(${options.all ? '*' : options})`;
 });
 
 module.exports = numericExpressions;

lib/queries.js

@@ -1,24 +1,33 @@
 const { PromiseDB } = require('./promisedb');
 const { accessError, asyncError } = require('../util/psql-error');
+const { simplifyArray, simplifyObject } = require('../util/helpers');
 const str = require('../util/string');
 const sp = require('synchronized-promise');
 
 // Current database (undefined if not open)
 var db = undefined;
+var simplify = false; 
 
 /**
  * Opens a database file.
  * @param {string} file Relative path to the database file
+ * @returns {void|never}
  */
 function open(file) {
+    if (db instanceof PromiseDB) {
+        close();
+        accessError(true);
+    }
+
     db = new PromiseDB(file);
 }
 
 /**
  * Closes an open database.
+ * @returns {void|never}
  */
 function close() {
-    db.close();
+    db instanceof PromiseDB ? db.close() : accessError();
     db = undefined;
 }
 
@@ -55,72 +64,72 @@ function dynamicAccess(file) {
 
 /* ================ QUERIES ================ */
 
-/**
- * Asynchronous database query.
- * @param {RunOptions} options SQL statement
- * @returns {QueryPromise}
- */
-async function run(options) {
-    dynamicAccess(options.file);
-    return await db.query(options.statement, options.args);
-}
+class Query {
+    /**
+     * Query constructor - handles dynamic database access
+     * @param {BaseOptions} options 
+     */
+    constructor(options) {
+        this.options = options;
+        dynamicAccess(options.file);
+    }
 
-/**
- * Asynchronous instert query.
- * @param {InsertOptions} options 
- * @returns {Promise<void>}
- */
-async function insert(options) {
-    dynamicAccess(options.file);
-    const sql = str.insertStr(options);
-    await db.query(sql, options.values);
-}
+    /**
+     * Asynchronous database query.
+     * @returns {QueryPromise}
+     */
+    async run() {
+        return await db.query(this.options.statement, this.options.args);
+    }
 
-/**
- * Asynchronous selection query.
- * @param {SelectionOptions} options 
- * @returns {SelectionPromise}
- */
-async function select(options) {
-    dynamicAccess(options.file);
-    const { sql, args } = str.selectStr(options);
-    const data = await db.query(sql, args);
-    return (data.length > 0 && options.first) ? data[0] : data;
-}
+    /**
+     * Asynchronous instert query.
+     * @returns {Promise<void>}
+     */
+    async insert() {
+        const sql = str.insertStr(this.options);
+        await db.query(sql, this.options.values);
+    }
 
-/**
- * Asynchronous update query.
- * @param {UpdateOptions} options 
- * @returns {Promise<void>}
- */
-async function update(options) {
-    dynamicAccess(options.file);
-    const { sql, args } = str.updateStr(options);
-    await db.query(sql, args);
-}
+    /**
+     * Asynchronous selection query.
+     * @returns {SelectionPromise}
+     */
+    async select() {
+        const { sql, args } = str.selectStr(this.options);
+        const data = await db.query(sql, args);
+        return (data.length > 0 && this.options.first) ? data[0] : data;
+    }
 
-/**
- * Asynchronous delete query.
- * @param {DeleteOptions} options 
- * @returns {Promise<void>}
- */
-async function remove(options) {
-    dynamicAccess(options.file);
-    const { sql, args } = str.deleteStr(options);
-    await db.query(sql, args);
-}
+    /**
+     * Asynchronous update query.
+     * @returns {Promise<void>}
+     */
+    async update() {
+        const { sql, args } = str.updateStr(this.options);
+        await db.query(sql, args);
+    }
 
-/**
- * Asynchronous upsert query. 
- * @param {UpsertOptions} options 
- * @returns {Promise<void>}
- */
-async function upsert(options) {
-    await insert(options).catch(async error => {
-        if (error.code !== 'SQLITE_CONSTRAINT') throw new error; 
-        if (!options.table) options.table = options.into;
-        await update(options);
-    });
+    /**
+     * Asynchronous delete query.
+     * @returns {Promise<void>}
+     */
+    async remove() {
+        const { sql, args } = str.deleteStr(this.options);
+        await db.query(sql, args);
+    }
+
+    /**
+     * Asynchronous upsert query. 
+     * @returns {Promise<void>}
+     */
+    async upsert() {
+        await this.insert(this.options).catch(async error => {
+            if (error.code !== 'SQLITE_CONSTRAINT') throw new error; 
+            if (!this.options.table) this.options.table = this.options.into;
+            await this.update(this.options);
+        });
+    }
 }
 
 /**
@@ -134,17 +143,30 @@ function sync(query, options = []) {
     return sp(query)(options);
 }
 
+const queryNames = Object.getOwnPropertyNames(Query.prototype).filter(name => name !== 'constructor'), queries = new Object();
+
+queryNames.forEach(name => {
+    queries[name] = async options => {
+        const query = new Query(options);
+        const run = query[name]();
+        if (simplify) run.then(data => Array.isArray(data) ? simplifyArray(data) : simplifyObject(data));
+        return await run;
+    }
+});
+
 module.exports = {
+    simplifyOutput: (bit = undefined) => typeof bit === 'boolean' ? simplify = bit : simplify = !simplify,
+
     // Export database open/close functions (synchronous!)
     open, close, get,
 
     // Queries
-    run, insert, select, update, remove, upsert, sync,
+    ...queries, sync,
 
     /**
      * Asynchronous delete query. Optional overload, since 'delete' is reserved keyword.
      * @param {DeleteOptions} options 
      * @returns {Promise<void>}
      */
-    delete: async options => await remove(options)
+    delete: async options => await queries.remove(options)
 }

util/helpers.js

@@ -1,4 +1,28 @@
+/**
+ * 
+ * @param {Object} data 
+ */
+ function simplifyObject(datum) {
+    for (const key of Object.keys(datum)) {
+        if (!key.includes('(') || !key.includes(')')) continue;
+        const newKey = key.substring(0, key.indexOf('(')).toLowerCase();
+        Object.assign(datum, { [newKey]: datum[key] });
+        delete datum[key];
+    }
+}
+
+/**
+ * 
+ * @param {Object[]} data 
+ */
+function simplifyArray(data) {
+    if (!data) return;
+    data.forEach(datum => simplifyObject(datum));
+}
+
 module.exports = {
+    simplifyArray, simplifyObject,
+
     /**
      * Parses the columns of an SQL statement.
      * @param {string[]} columns 

util/psql-error.js

@@ -11,8 +11,8 @@ module.exports = {
     /**
      * Access error - database is not open!
      */
-    accessError: function() {
-        throw new PSQLError('PSQLAccessError', 'Database is not open.');
+    accessError: function(open = false) {
+        throw new PSQLError('PSQLAccessError', open ? 'Database is already open.' : 'Database is not open.');
     },
 
     /**