add any.strip for objects and arrays

hapijs · Feb 28, 2015 · c2841eb · c2841eb
1 parent ca2eea8
commit c2841eb
Show file tree

Hide file tree

Showing 7 changed files with 159 additions and 26 deletions.
diff --git a/README.md b/README.md
@@ -27,6 +27,7 @@ Lead Maintainer: [Nicolas Morel](https://github.com/marsup)
       - [`any.required()`](#anyrequired)
       - [`any.optional()`](#anyoptional)
       - [`any.forbidden()`](#anyforbidden)
+      - [`any.strip()`](#anystrip)
       - [`any.description(desc)`](#anydescriptiondesc)
       - [`any.notes(notes)`](#anynotesnotes)
       - [`any.tags(tags)`](#anytagstags)
@@ -339,6 +340,27 @@ var schema = {
 };
 ```
 
+#### `any.strip()`
+
+Marks a key to be removed from a resulting object or array after validation. Used to sanitize output.
+
+```javascript
+var schema = {
+    username: Joi.string(),
+    password: Joi.string().strip()
+};
+
+schema.validate({ username: 'test', password: 'hunter2' }, function (err, value) {
+    // value = { username: 'test' }
+});
+
+var schema = Joi.array().items(Joi.string(), Joi.any().strip());
+
+schema.validate(['one', 'two', true, false, 1, 2], function (err, value) {
+    // value = ['one', 'two']
+});
+```
+
 #### `any.description(desc)`
 
 Annotates the key where:
@@ -1284,4 +1306,4 @@ var schema = Joi.object().keys({
 });
 
 Joi.validate({ a: 5, b: { c: 5 } }, schema, { context: { x: 5 } }, function (err, value) {});
-```
+```
diff --git a/lib/any.js b/lib/any.js
@@ -21,7 +21,8 @@ internals.defaults = {
     stripUnknown: false,
     language: {},
     presence: 'optional',
-    raw: false
+    raw: false,
+    strip: false
     // context: null
 };
 
@@ -36,7 +37,8 @@ internals.checkOptions = function (options) {
         language: 'object',
         presence: ['string', 'required', 'optional', 'forbidden', 'ignore'],
         raw: 'boolean',
-        context: 'object'
+        context: 'object',
+        strip: 'boolean'
     };
 
     var keys = Object.keys(options);
@@ -295,6 +297,14 @@ internals.Any.prototype.forbidden = function () {
 };
 
 
+internals.Any.prototype.strip = function () {
+
+    var obj = this.clone();
+    obj._flags.strip = true;
+    return obj;
+};
+
+
 internals.Any.prototype.applyFunctionToChildren = function (children, fn, args, root) {
 
     children = [].concat(children);
@@ -450,31 +460,33 @@ internals.Any.prototype._validate = function (value, state, options, reference)
 
         var finalValue;
 
-        if (value !== undefined) {
-            finalValue = options.raw ? originalValue : value;
-        }
-        else if (Ref.isRef(self._flags.default)) {
-            finalValue = self._flags.default(state.parent, options);
-        }
-        else if (typeof self._flags.default === 'function' &&
-                !(self._type === 'func' && !self._flags.default.description)) {
+        if (!self._flags.strip) {
+            if (value !== undefined) {
+                finalValue = options.raw ? originalValue : value;
+            }
+            else if (Ref.isRef(self._flags.default)) {
+                finalValue = self._flags.default(state.parent, options);
+            }
+            else if (typeof self._flags.default === 'function' &&
+                    !(self._type === 'func' && !self._flags.default.description)) {
 
-            var arg;
+                var arg;
 
-            if (state.parent !== null &&
-                self._flags.default.length > 0) {
+                if (state.parent !== null &&
+                    self._flags.default.length > 0) {
 
-                arg = Hoek.clone(state.parent);
-            }
+                    arg = Hoek.clone(state.parent);
+                }
 
-            var defaultValue = internals._try(self._flags.default, arg);
-            finalValue = defaultValue.value;
-            if (defaultValue.error) {
-                errors.push(Errors.create('any.default', defaultValue.error, state, options));
+                var defaultValue = internals._try(self._flags.default, arg);
+                finalValue = defaultValue.value;
+                if (defaultValue.error) {
+                    errors.push(Errors.create('any.default', defaultValue.error, state, options));
+                }
+            }
+            else {
+                finalValue = self._flags.default;
             }
-        }
-        else {
-            finalValue = self._flags.default;
         }
 
         return {

diff --git a/lib/array.js b/lib/array.js
@@ -11,6 +11,19 @@ var Hoek = require('hoek');
 var internals = {};
 
 
+internals.fastSplice = function (arr, i) {
+
+    var il = arr.length;
+    var pos = i;
+
+    while (pos < il) {
+        arr[pos++] = arr[pos];
+    }
+
+    --arr.length;
+};
+
+
 internals.Array = function () {
 
     Any.call(this);
@@ -139,7 +152,7 @@ internals.checkItems = function (items, wasArray, state, options) {
                 items[v] = res.value;
                 isValid = true;
                 inclusions.push(requireds[i]);
-                requireds.splice(i, 1);
+                internals.fastSplice(requireds, i);
                 --i;
                 --il;
                 break;
@@ -155,7 +168,14 @@ internals.checkItems = function (items, wasArray, state, options) {
         for (i = 0, il = inclusions.length; i < il; ++i) {
             var res = inclusions[i]._validate(item, localState, options);
             if (!res.errors) {
-                items[v] = res.value;
+                if (inclusions[i]._flags.strip) {
+                    internals.fastSplice(items, v);
+                    --v;
+                    --vl;
+                }
+                else {
+                    items[v] = res.value;
+                }
                 isValid = true;
                 break;
             }

diff --git a/lib/object.js b/lib/object.js
@@ -157,7 +157,10 @@ internals.Object.prototype._base = function (value, state, options) {
                 }
             }
 
-            if (result.value !== undefined) {
+            if (child.schema._flags.strip) {
+                delete target[key];
+            }
+            else if (result.value !== undefined) {
                 target[key] = result.value;
             }
         }

diff --git a/test/any.js b/test/any.js
@@ -524,6 +524,33 @@ describe('any', function () {
         });
     });
 
+    describe('#strip', function () {
+
+        it('validates and returns undefined', function (done) {
+
+            var schema = Joi.string().strip();
+
+            schema.validate('test', function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value).to.not.exist();
+                done();
+            });
+        });
+
+        it('validates and returns an error', function (done) {
+
+            var schema = Joi.string().strip();
+
+            schema.validate(1, function (err, value) {
+
+                expect(err).to.exist();
+                expect(err.message).to.equal('"value" must be a string');
+                done();
+            });
+        });
+    });
+
     describe('#description', function () {
 
         it('sets the description', function (done) {

diff --git a/test/array.js b/test/array.js
@@ -249,6 +249,17 @@ describe('array', function () {
                 done();
             });
         });
+
+        it('can strip matching items', function (done) {
+
+            var schema = Joi.array().items(Joi.string(), Joi.any().strip());
+            schema.validate(['one', 'two', 3, 4], function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value).to.deep.equal(['one', 'two']);
+                done();
+            });
+        });
     });
 
     describe('#min', function () {

diff --git a/test/object.js b/test/object.js
@@ -383,6 +383,44 @@ describe('object', function () {
                 });
             });
         });
+
+        it('strips keys flagged with strip', function (done) {
+
+            var schema = Joi.object({
+                a: Joi.string().strip(),
+                b: Joi.string()
+            });
+            schema.validate({ a: 'test', b: 'test' }, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value.a).to.not.exist();
+                expect(value.b).to.equal('test');
+                done();
+            });
+        });
+
+        it('does not alter the original object when stripping keys', function (done) {
+
+            var schema = Joi.object({
+                a: Joi.string().strip(),
+                b: Joi.string()
+            });
+
+            var valid = {
+                a: 'test',
+                b: 'test'
+            };
+
+            schema.validate(valid, function (err, value) {
+
+                expect(err).to.not.exist();
+                expect(value.a).to.not.exist();
+                expect(valid.a).to.equal('test');
+                expect(value.b).to.equal('test');
+                expect(valid.b).to.equal('test');
+                done();
+            });
+        });
     });
 
     describe('#unknown', function () {