Add initial version

Author: Hans Kristian Flaatten

src/index.litcoffee

@@ -0,0 +1,103 @@
+    module.exports = MongoQS = (opts) ->
+      @ops = opts?.ops or ['!', '^', '$', '~', '>', '<']
+      @alias = opts?.alias or {}
+      @ignore = opts?.ignore or {}
+      @custom = opts?.custom or {}
+
+      for param, field of @custom
+        switch param
+          when 'bbox' then @custom.bbox = @customBBOX field
+          when 'near' then @custom.near = @customNear field
+          when 'after' then @custom.near = @customNear field
+
+      return @
+
+    MongoQS.prototype.customBBOX = (field) ->
+      (res, bbox) ->
+        bbox = bbox.split ','
+
+        if bbox.length is 4
+          val = parseFloat(val) for val in bbox
+
+          res[field] = $geoWithin: $geometry:
+            type: 'Polygon'
+            coordinates: [[
+              [bbox[0], bbox[1]]
+              [bbox[2], bbox[1]]
+              [bbox[2], bbox[3]]
+              [bbox[0], bbox[3]]
+              [bbox[0], bbox[1]]
+            ]]
+
+        return
+
+    MongoQS.prototype.customNear = (field) ->
+      (query, input) ->
+        input = input.split ','
+
+        if input.length is 2
+          val = parseFloat(val) for val in input
+
+          query[field] = $near: $geometry:
+            type: 'Point'
+            coordinates: input
+
+        return
+
+    MongoQS.prototype.customAfter = (field) ->
+      (query, input) ->
+
+        if not isNaN input
+          input = input + '000' if (input + '').length is 10
+          input = parseInt input
+
+        input = new Date input
+
+        if input.toString() isnt 'Invalid Date'
+          query[field] = $gte: input.toISOString()
+
+
+    MongoQS.prototype.parse = (query) ->
+      res = {}
+
+      for key, val of query
+        continue if @ignore[key]
+        continue if typeof val isnt 'string'
+        continue if not /^[a-zæøå0-9-_.]+$/i.test key
+
+        key = @alias[key] if @alias[key]
+
+If the value is empty we treat the query parameter as an
+[$exists](http://docs.mongodb.org/manual/reference/operator/query/exists/)
+operator.
+
+        if not val
+          res[key] = $exists: true
+
+Check for supported operators in `@ops`. This is configured when
+instanciating `MongoQS` and the defaults are `!`, `^`, `$`, `~`, `>`, and `<`.
+
+        else if val.charAt(0) in @ops
+          op = val.charAt(0)
+          val = val.substr(1)
+
+          res[key] = switch op
+            when '!'
+              if val
+                $ne: if isNaN(val) then val else parseFloat(val, 10)
+              else
+                $exists: false
+            when '>' then $gt: parseFloat(val, 10)
+            when '<' then $lt: parseFloat(val, 10)
+            else
+              val = val.replace /[^a-zæøå0-9-_.* ]/i, ''
+              switch op
+                when '^' then $regex: '^' + val, $options: 'i'
+                when '$' then $regex: val + '$', $options: 'i'
+                else $regex: val, $options: 'i'
+
+        else
+          res[key] = if isNaN(val) then val else parseFloat(val, 10)
+
+      res
+

test/suite.coffee

@@ -0,0 +1,152 @@
+assert = require 'assert'
+MongoQS = require '../src/'
+
+qs = query = null
+
+beforeEach ->
+  qs = new MongoQS()
+  query = {}
+
+describe 'customBBOX()', ->
+  it 'should not genearate $geoWithin query for invalid bbox', ->
+    for input in ['0123', '0,1,2']
+      qs.customBBOX('geojson') query, input
+      assert.deepEqual query, {}, "#{input} should not be valid BBOX input"
+
+  it 'should generate $geoWithin query for valid bbox', ->
+    qs.customBBOX('geojson') query, '0,1,2,3'
+    assert.deepEqual query, geojson: $geoWithin: $geometry:
+      type: 'Polygon'
+      coordinates: [[
+        [0, 1]
+        [2, 1]
+        [2, 3]
+        [0, 3]
+        [0, 1]
+      ]]
+
+describe 'customNear()', ->
+  it 'should not genearate $near query for invalid point', ->
+    for input in ['0123']
+      qs.customNear('geojson') query, input
+      assert.deepEqual query, {}, "#{input} should not be valid BBOX input"
+
+  it 'should generate $near query for valid point', ->
+    qs.customNear('geojson') query, '0,1'
+    assert.deepEqual query, geojson: $near: $geometry:
+      type: 'Point'
+      coordinates: [0, 1]
+
+describe 'customAfter()', ->
+  it 'should not generate after query for invalid date', ->
+    for input in ['foo']
+      qs.customAfter('endret') query, input
+      assert.deepEqual query, {}, "#{input} should not be valid after date"
+
+  it 'should generate after query for ISO date', ->
+    qs.customAfter('endret') query, '2014-09-22T11:50:37.843Z'
+    assert.deepEqual query, endret: $gte: '2014-09-22T11:50:37.843Z'
+
+  it 'should generate after query for milliseconds timestamp', ->
+    qs.customAfter('endret') query, '1411386637843'
+    assert.deepEqual query, endret: $gte: '2014-09-22T11:50:37.843Z'
+
+  it 'should generate after query for unix timestamp', ->
+    qs.customAfter('endret') query, '1411386637'
+    assert.deepEqual query, endret: $gte: '2014-09-22T11:50:37.000Z'
+
+describe 'parse()', ->
+  describe 'parsing', ->
+    describe 'key value validation', ->
+      it 'should allow basic alpha num key names', ->
+        assert.deepEqual qs.parse({'Abc.Æøå_123-456': 'bix'}), 'Abc.Æøå_123-456': "bix"
+
+      it 'should discard keys with special chars', ->
+        assert.deepEqual qs.parse({'h4xor$': 'bix'}), {}
+
+      it 'should discard non-string values', ->
+        assert.deepEqual qs.parse({'foo': []}), {}
+        assert.deepEqual qs.parse({'foo': {}}), {}
+        assert.deepEqual qs.parse({'foo': false}), {}
+
+    describe 'no operator', ->
+      it 'should return empty query set', ->
+        assert.deepEqual qs.parse({}), {}
+
+      it 'should return equal query', ->
+        assert.deepEqual qs.parse({navn: 'foo'}), navn: 'foo'
+
+      it 'should parse float if applicable', ->
+        query = qs.parse navn: '10'
+        assert.deepEqual query, navn: 10
+        assert.strictEqual query.navn, 10
+
+      it 'should return empty equal query', ->
+        assert.deepEqual qs.parse({navn: ''}), navn: $exists: true
+
+    describe '! operator', ->
+      it 'should return not equal query', ->
+        assert.deepEqual qs.parse({navn: '!foo'}), navn: $ne: 'foo'
+
+      it 'should parse float if applicable', ->
+        query = qs.parse navn: '!10'
+        assert.deepEqual query, navn: $ne: 10
+        assert.strictEqual query.navn.$ne, 10
+
+      it 'should return empty not equal query', ->
+        assert.deepEqual qs.parse({navn: '!'}), navn: $exists: false
+
+    describe '> operator', ->
+      it 'should return greater than query', ->
+        query = qs.parse navn: '>10'
+        assert.deepEqual query, navn: $gt: 10
+        assert.strictEqual query.navn.$gt, 10
+
+    describe '< operator', ->
+      it 'should return less than query', ->
+        query = qs.parse navn: '<10'
+        assert.deepEqual query, navn: $lt: 10
+        assert.strictEqual query.navn.$lt, 10
+
+    describe '^ operator', ->
+      it 'should return starts with query', ->
+        assert.deepEqual qs.parse({navn: '^foo'}), navn: $regex: '^foo', $options: 'i'
+
+    describe '$ operator', ->
+      it 'should return ends with query', ->
+        assert.deepEqual qs.parse({navn: '$foo'}), navn: $regex: 'foo$', $options: 'i'
+
+    describe '~ operator', ->
+      it 'should return contains query', ->
+        assert.deepEqual qs.parse({navn: '~foo'}), navn: $regex: 'foo', $options: 'i'
+
+    it 'should parse multiple keys', ->
+      query = qs.parse
+        foo: ''
+        bar: '!foo'
+        '%foo': 'bar'
+        'bix.bax': 'that'
+        'foo-bar': 'bar-foo'
+
+      assert.deepEqual query,
+        foo: $exists: true
+        bar: $ne: 'foo'
+        'bix.bax': 'that'
+        'foo-bar': 'bar-foo'
+
+  describe 'aliasing', ->
+    it 'should alias key', ->
+      qs = new MongoQS alias: foo: 'bar'
+      assert.deepEqual qs.parse({foo: 'bix'}), bar: 'bix'
+
+    it 'should alias multiple keys'
+
+  describe 'ignoring', ->
+    it 'should ignore key', ->
+      qs = new MongoQS ignore: foo: true
+      assert.deepEqual qs.parse({foo: 'bar', bar: 'foo'}), bar: 'foo'
+
+    it 'should ingore multiple keys'
+
+  describe 'custom', ->
+