reorganization and cleanup

Author: akrouk

index.d.ts

@@ -1,7 +1,18 @@
 declare module "promisesql";
 
+type DataObject = Object;
+type DataArray = DataObject[];
+
+type QueryRetval = void | DataObject | DataArray | undefined;
+type QueryPromise = Promise<QueryRetval>;
+
 interface BaseOptions {
-    filepath?: string,
+    file?: string,
+}
+
+interface RunOptions extends BaseOptions {
+    statement: string,
+    args?: any[]
 }
 
 interface InsertOptions extends BaseOptions {
@@ -10,7 +21,11 @@ interface InsertOptions extends BaseOptions {
     values: string[]
 }
 
+type SelectionRetval = DataObject | DataArray | undefined;
+type SelectionPromise = Promise<SelectionRetval>;
+
 interface SelectionOptions extends BaseOptions {
+    first?: boolean,
     all?: boolean,
     columns?: string[],
     from: string,
@@ -28,7 +43,7 @@ interface DeleteOptions extends BaseOptions {
     where?: (string | Expression)[]
 }
 
-interface Expression {
+interface BooleanExpression {
     lhs: string,
     operator: string,
     rhs: string

index.js

@@ -5,6 +5,9 @@ module.exports = require('./lib/queries');
 module.exports.PromiseDB = PromiseDB;
 
 // Export conditions (expressions, logic operators, etc.)
-module.exports.expression = require('./util/operators/expression');
-module.exports.logic = require('./util/operators/logic');
-module.exports.aggregate = require('./util/operators/aggregate');
+module.exports.expression = {
+    ...require('./util/expressions/boolean'),
+    ...require('./util/expressions/numeric')
+};
+
+module.exports.operator = require('./util/operators/logic');

lib/promisedb.js

@@ -15,7 +15,7 @@ class PromiseDB extends sqlite.Database {
      * Promise-based query OR command. 
      * @param {string} sql 
      * @param {string[]} args 
-     * @returns {Promise<object>}
+     * @returns {QueryPromise}
      */
     query(sql, args = []) {
         return new Promise((resolve, reject) => {

lib/queries.js

@@ -7,10 +7,10 @@ var db = undefined;
 
 /**
  * Opens a database file.
- * @param {string} filepath Path to the database file
+ * @param {string} file Path to the database file
  */
-function open(filepath) {
-    db = new PromiseDB(filepath);
+function open(file) {
+    db = new PromiseDB(file);
 }
 
 /**
@@ -22,25 +22,22 @@ function close() {
 }
 
 /**
- * Dynamically opens and closes a database if a filepath is provided.
- * @param {string} filepath 
+ * Dynamically opens and closes a database if a file is provided.
+ * @param {string} file 
  * @returns {Promise<Function>}
  */
-function dynamicAccess(filepath) {
-    // If filepath is undefined or db is already open, do nothing
-    if (!filepath || db) {
+function dynamicAccess(file) {
+    // If file is undefined or db is already open, do nothing
+    if (!file || db) {
         return;
     }
 
     // Open db and then close it when promise is fulfilled 
     return new Promise((resolve, reject) => {
         try {
-            open(filepath);
-            resolve({
-                then: () => close()
-            });
-        }
-        catch(error) {
+            open(file);
+            resolve({ then: close });
+        } catch(error) {
             reject(error);
         }
     });
@@ -50,68 +47,66 @@ module.exports = {
     // Export database open/close functions (synchronous!)
     open, close,
 
-    print: function() {
-        console.log(typeof db);
-    },
-
     /**
      * Asynchronous database query.
-     * @param {string} sql SQL statement
-     * @param {string[]} args The arguments of the statement
-     * @param {string} filepath Path to the database file
-     * @returns {undefined|object}
+     * @param {RunOptions} options SQL statement
+     * @returns {QueryPromise}
      */
-    query: async function(sql, args = [], filepath = undefined) {
-        dynamicAccess(filepath);
-        return await db.query(sql, args);
+    run: async function(options) {
+        dynamicAccess(options.file);
+        return await db.query(options.statement, options.args);
     },
 
     /**
      * Asynchronous instert query.
      * @param {InsertOptions} options 
+     * @returns {Promise<void>}
      */
-     insert: async function(options) {
-        dynamicAccess(options.filepath);
+    insert: async function(options) {
+        dynamicAccess(options.file);
         const sql = sqlstr.insertStr(options);
         await db.query(sql, options.values);
     },
 
     /**
      * Asynchronous selection query.
      * @param {SelectionOptions} options 
-     * @returns 
+     * @returns {SelectionPromise}
      */
     select: async function(options) {
-        dynamicAccess(options.filepath);
+        dynamicAccess(options.file);
         const { sql, args } = sqlstr.selectStr(options);
-        return await db.query(sql, args);
+        const data = await db.query(sql, args);
+        return (data.length > 0 && options.first) ? data[0] : data;
     },
 
     /**
      * Asynchronous update query.
      * @param {UpdateOptions} options 
+     * @returns {Promise<void>}
      */
     update: async function(options) {
-        dynamicAccess(options.filepath);
+        dynamicAccess(options.file);
         const { sql, args } = sqlstr.updateStr(options);
         await db.query(sql, args);
     },
 
     /**
      * Asynchronous delete query.
      * @param {DeleteOptions} options 
+     * @returns {Promise<void>}
      */
     delete: async function(options) {
-        dynamicAccess(options.filepath);
+        dynamicAccess(options.file);
         const { sql, args } = sqlstr.deleteStr(options);
         await db.query(sql, args);
     },
 
     /**
-     * Synchronous query 
+     * Synchronous query.
      * @param {function} query 
      * @param {string[]|BaseOptions} options 
-     * @returns {undefined|object}
+     * @returns {QueryRetval}
      */
     sync: function(query, options = []) {
         if (query.constructor.name !== 'AsyncFunction') 

util/operators/expression.js util/expressions/boolean.jsutil/operators/expression.js renamed to util/expressions/boolean.js

@@ -3,7 +3,7 @@ module.exports = {
      * Equals expression (lhs = rhs)
      * @param {string} lhs 
      * @param {string} rhs 
-     * @returns 
+     * @returns {BooleanExpression}
      */
     eq: function(lhs, rhs) {
         return { lhs: lhs, operator: '=', rhs: rhs };
@@ -13,7 +13,7 @@ module.exports = {
      * Less than expression (lhs < rhs)
      * @param {string} lhs 
      * @param {string} rhs 
-     * @returns 
+     * @returns {BooleanExpression}
      */
     lt: function(lhs, rhs) {
         return { lhs: lhs, operator: '<', rhs: rhs };
@@ -23,7 +23,7 @@ module.exports = {
      * Greater than expression (lhs > rhs)
      * @param {string} lhs 
      * @param {string} rhs 
-     * @returns 
+     * @returns {BooleanExpression}
      */
     gt: function(lhs, rhs) {
         return { lhs: lhs, operator: '>', rhs: rhs };
@@ -33,7 +33,7 @@ module.exports = {
      * Less than or equal to expression (lhs <= rhs)
      * @param {string} lhs 
      * @param {string} rhs 
-     * @returns 
+     * @returns {BooleanExpression}
      */
     leq: function(lhs, rhs) {
         return { lhs: lhs, operator: '<=', rhs: rhs };
@@ -43,7 +43,7 @@ module.exports = {
      * Greater than or equal to expression (lhs >= rhs)
      * @param {string} lhs 
      * @param {string} rhs 
-     * @returns 
+     * @returns {BooleanExpression}
      */
     geq: function(lhs, rhs) {
         return { lhs: lhs, operator: '>=', rhs: rhs };

util/expressions/numeric.js

@@ -0,0 +1,46 @@
+module.exports = {
+    /**
+     * Returns a max expression [MAX(column_name)]
+     * @param {string} column 
+     * @returns {string}
+     */
+    max: function(column) {
+        return `MAX(${column})`;
+    },
+
+    /**
+     * Returns a min expression [MIN(column_name)]
+     * @param {string} column 
+     * @returns {string}
+     */
+    min: function(column) {
+        return `MIN(${column})`;
+    },
+
+    /**
+     * Returns a count expression [COUNT(column_name)]
+     * @param {string} column 
+     * @returns {string}
+     */
+    count: function(column) {
+        return `COUNT(${column})`;
+    },
+
+    /**
+     * Returns an average expression [AVG(column_name)]
+     * @param {string} column 
+     * @returns {string}
+     */
+    avg: function(column) {
+        return `AVG(${column})`;
+    },
+
+    /**
+     * Returns a sum expression [SUM(column_name)]
+     * @param {string} column 
+     * @returns {string}
+     */
+    sum: function(column) {
+        return `SUM(${column})`;
+    }
+}