fixes, tidy up options and added testing on new features

Author: stuartaharrison

README.md

@@ -79,7 +79,9 @@ const { Op } = require('sequelize');
 
 const minimumAgeHandler = (column, value, options) => {
     return {
-        'age': [Op.gte]: value
+        'age': {
+            [Op.gte]: value
+        }
     }
 };
 

index.js

@@ -21,19 +21,38 @@ class SequelizeQS {
     };
 
     constructor(options) {
+        // check and configure all the options are okay
         this.opt = options || {}
-        this.ops = this.opt.ops || Object.keys(this.#opMaps);
-        this.alias = this.opt.alias || {};
-        this.blacklist = this.opt.blacklist || [];
-        this.customHandlers = this.opt.custom || {};
-        this.defaultPaginationLimit = this.opt.defaultPaginationLimit || 25;
-        this.maximumPageSize = this.opt.maximumPageSize || 100;
-
-        if (!this.opt.dateFields) {
+
+        if (!this.opt.ops || !Array.isArray(this.opt.ops)) {
+            this.opt.ops = Object.keys(this.#opMaps);
+        }
+
+        if (!this.opt.alias || typeof(this.opt.alias) !== 'object') {
+            this.opt.alias = {};
+        }
+
+        if (!this.opt.blacklist || !Array.isArray(this.opt.blacklist)) {
+            this.opt.blacklist = [];
+        }
+
+        if (!this.opt.customHandlers || typeof(this.opt.customHandlers) !== 'object') {
+            this.opt.customHandlers = {};
+        }
+
+        if (!this.opt.defaultPaginationLimit || isNaN(this.opt.defaultPaginationLimit)) {
+            this.opt.defaultPaginationLimit = 25;
+        }
+
+        if (!this.opt.maximumPageSize || isNaN(this.opt.maximumPageSize)) {
+            this.opt.maximumPageSize = 100;
+        }
+
+        if (!this.opt.dateFields || !Array.isArray(this.opt.dateFields)) {
             this.opt.dateFields = ['createdAt', 'updatedAt'];
         }
 
-        if (!(typeof(this.opt.dateOnlyCompare) === 'boolean')) {
+        if (!this.opt.dateOnlyCompare || typeof(this.opt.dateOnlyCompare) !== 'boolean') {
             this.opt.dateOnlyCompare = false;
         }
     }
@@ -62,8 +81,10 @@ class SequelizeQS {
     }
 
     #parsePagination(page, limit) {
+        const { defaultPaginationLimit, maximumPageSize } = this.opt;
+
         let realPage = page || 1;
-        let realLimit = limit || this.defaultPaginationLimit;
+        let realLimit = limit || defaultPaginationLimit;
 
         // prevent negative page number
         try {
@@ -79,12 +100,12 @@ class SequelizeQS {
         // prevent negative limit value or trying to get too many
         try {
             realLimit = parseInt(limit);
-            if (isNaN(realLimit) || realLimit < 1 || (this.maximumPageSize && realLimit > this.maximumPageSize)) {
-                realLimit = this.defaultPaginationLimit;
+            if (isNaN(realLimit) || realLimit < 1 || (maximumPageSize && realLimit > maximumPageSize)) {
+                realLimit = defaultPaginationLimit;
             }
         }
         catch {
-            realLimit = this.defaultPaginationLimit;
+            realLimit = defaultPaginationLimit;
         }
 
         return { page: realPage, limit: realLimit };
@@ -113,22 +134,23 @@ class SequelizeQS {
     #parseWhereProperties(properties) {
         let where = {};
         let columns = Object.keys(properties);
+        const { alias, blacklist, customHandlers, ops } = this.opt;
 
         for (const column of columns) {
-            let key = this.alias[column] || column; // handles an alias
-            let value = properties[key];
+            let key = alias[column] || column; // handles an alias
+            let value = properties[column];
 
             // check the blacklist
-            if (this.blacklist.some(el => el === key)) {
+            if (blacklist.some(el => el === key)) {
                 break;
             }
 
             // TODO: do we need to check for whitelist & let more dangerous query run?
 
             // handles a custom function when we want to override the base functionality
-            if (this.customHandlers[key] && typeof(this.customHandlers[key]) === 'function') {
+            if (customHandlers[key] && typeof(customHandlers[key]) === 'function') {
                 // call the custom handler function and get the operation to apply
-                let customOperation = this.customHandlers[key](key, value, this.opt);
+                let customOperation = customHandlers[key](key, value, this.opt);
                 where = {
                     ...where,
                     ...customOperation
@@ -160,8 +182,8 @@ class SequelizeQS {
             }
 
             // check if we have an operator to handle a special type (not a basic `=` equals basically)
-            if (typeof(value) === 'string' && this.ops.some(op => value.startsWith(op))) {
-                let op = this.ops.find(op => value.startsWith(op));
+            if (typeof(value) === 'string' && ops.some(op => value.startsWith(op))) {
+                let op = ops.find(op => value.startsWith(op));
                 let fn = this.#opMaps[op];
 
                 if (!fn || !typeof (fn) === 'function') {

tests/test.js

@@ -1,23 +1,43 @@
 const connect = require('./db');
 const assert = require('assert');
+const { Op } = require('sequelize');
 const SequelizeQS = require('../index');
 
 let models = null;
 let sequelize = null;
 let sequelizeQS = null;
 let sequelizeDateQS = null;
+let sequelizeCustomQS = null;
 
 before(async () => {
     sequelize = await connect();
     models = sequelize.models;
 });
 
 beforeEach(() => {
+    // setup a basic parser
     sequelizeQS = new SequelizeQS();
+
+    // setup a parser that handlers dates as DATEONLY basically
     sequelizeDateQS = new SequelizeQS({
         dateOnlyCompare: true,
         dateFields: ['createdAt', 'updatedAt', 'lastLogin']
     });
+
+    // setup a parser that handlers blacklists, aliases and custom handlers
+    sequelizeCustomQS = new SequelizeQS({
+        blacklist: ['isActive'],
+        alias: { 'customerAge': 'age' },
+        customHandlers: {
+            minAge: (column, value, options) => {
+                return {
+                    'age': {
+                        [Op.gte]: value
+                    }
+                }
+            }
+        }
+    });
 });
 
 describe('Basic Operations', () => {
@@ -324,6 +344,36 @@ describe('Operations - Date Only', () => {
     });
 });
 
+describe('Alias', () => {
+    it('should return 4', async () => {
+        let options = sequelizeCustomQS.parse({
+            customerAge: '|20|30'
+        });
+        let countResult = await models.customers.count(options);
+        assert.equal(countResult, 4);
+    });
+});
+
+describe('Blacklist', () => {
+    it('should return 10', async () => {
+        let options = sequelizeCustomQS.parse({
+            isActive: false
+        });
+        let countResult = await models.customers.count(options);
+        assert.equal(countResult, 10);
+    });
+});
+
+describe('Custom Handlers', () => {
+    it('should return 4', async () => {
+        let options = sequelizeCustomQS.parse({
+            minAge: 30
+        });
+        let countResult = await models.customers.count(options);
+        assert.equal(countResult, 4);
+    });
+});
+
 describe('Pagination', () => {
     // no limit defined
     describe('No Limits', () => {