feat(3163): Handle params with greater than or less than filter [1]

index.js

@@ -10,6 +10,8 @@ const MODELS = schemas.models;
 const MODEL_NAMES = Object.keys(MODELS);
 const logger = require('screwdriver-logger');
 const pg = require('pg');
+// Regex patten for gt:123, lt:456
+const INEQUALITY_SIGNS = /^(gt|lt):([\d]+)$/;
 
 /**
  * Converts data from the value stored in the datastore
@@ -474,7 +476,23 @@ class Squeakquel extends Datastore {
                     if (this._fieldInvalid({ validFields, field: paramName })) {
                         throw new Error(`Invalid param "${paramName}"`);
                     }
-                    findParams.where[paramName] = paramValue;
+                    // Check for gt: or lt: prefix to set greater than or less than operator
+                    // Currently only matching for number values
+                    if (INEQUALITY_SIGNS.test(paramValue)) {
+                        const [, sign, paramVal] = paramValue.match(INEQUALITY_SIGNS);
+
+                        if (sign === 'gt') {
+                            findParams.where[paramName] = {
+                                [Sequelize.Op.gt]: paramVal
+                            };
+                        } else if (sign === 'lt') {
+                            findParams.where[paramName] = {
+                                [Sequelize.Op.lt]: paramVal
+                            };
+                        }
+                    } else {
+                        findParams.where[paramName] = paramValue;
+                    }
                 }
 
                 const indexIndex = model.indexes && model.rangeKeys ? model.indexes.indexOf(paramName) : -1;

test/index.test.js

@@ -169,6 +169,8 @@ describe('index test', function () {
             or: 'OR',
             gte: 'GTE',
             lte: 'LTE',
+            gt: 'GT',
+            lt: 'LT',
             eq: 'EQ'
         };
         sequelizeMock.col = sinon.stub().returns('col');
@@ -1259,6 +1261,47 @@ describe('index test', function () {
             });
         });
 
+        it('scans for some data with params with inequality sign (gt or lt)', () => {
+            const testData = [
+                {
+                    id: 7,
+                    name: 'foo'
+                },
+                {
+                    id: 6,
+                    name: 'foo'
+                }
+            ];
+            const testInternal = [
+                {
+                    toJSON: sinon.stub().returns(testData[0])
+                },
+                {
+                    toJSON: sinon.stub().returns(testData[1])
+                }
+            ];
+
+            testParams.params = {
+                name: 'foo',
+                id: 'gt:5'
+            };
+
+            sequelizeTableMock.findAll.resolves(testInternal);
+
+            return datastore.scan(testParams).then(data => {
+                assert.deepEqual(data, testData);
+                assert.calledWith(sequelizeTableMock.findAll, {
+                    where: {
+                        name: 'foo',
+                        id: {
+                            GT: '5'
+                        }
+                    },
+                    order: [['id', 'DESC']]
+                });
+            });
+        });
+
         it('throws an error when the param is not valid', () => {
             testParams.params = {
                 foo: 'banana'