Skip to content

GitLab

J
jsonschema-extra
Commit 27ddedc3 authored by Jaap Karan Singh's avatar Jaap Karan Singh
Browse files
Options

Changed public api

parent 27f97490
Hide whitespace changes
Inline Side-by-side
Showing with 269 additions and 133 deletions
.jshintrc deleted 100644 → 0
View file @ 27f97490
{
"node": true,
"curly": true,
"latedef": true,
"quotmark": true,
"undef": true,
"unused": true,
"trailing": true
}
src/attributes.js → attributes.js
View file @ 27ddedc3
......@@ -6,14 +6,4 @@ exports.validate = function customValidate(instance, schema, opt, ctx) {
if (instance || schema.required) {
return schema.validate(instance, schema, opt, ctx);
}
};
exports.conditionalEnum = function conditionalEnum(instance, schema, options, ctx) {
var res;
if (instance) {
schema.enum = schema.conditionalEnum;
res = this.attributes.enum(instance, schema, options, ctx);
delete schema.enum/* = void 0 */;
}
return res;
};
\ No newline at end of file
index.js
View file @ 27ddedc3
......@@ -2,6 +2,26 @@
'use strict';
console.info('[DANGER] Overriding jsonschema module manually. It will be replaced once the module is updated. Pull request submitted - https://github.com/tdegrunt/jsonschema/pull/62');
var assert = require('assert');
module.exports = require(__dirname + '/src');
\ No newline at end of file
var types = require(__dirname + '/types');
var attributes = require(__dirname + '/attributes');
function extend(a, b) {
Object.keys(b).forEach(function(prop) {
a[prop] = b[prop];
});
return a;
}
module.exports = function(validator) {
assert(validator && validator.attributes && validator.types, 'Missing / invalid validator');
validator.types = Object.create(validator.types);
extend(validator.types, types);
validator.attributes = Object.create(validator.attributes);
extend(validator.attributes, attributes);
return validator;
};
\ No newline at end of file
package.json
View file @ 27ddedc3
{
"name": "js_jsonschema-validator",
"version": "0.1.1",
"description": "jsonschema validator with custom types and attributes",
"name": "jsonschema-extra",
"version": "1.0.0",
"description": "Extends jsonschema with custom types and attributes",
"main": "index.js",
"directories": {
"test": "test"
},
"scripts": {
"test": "./node_modules/.bin/mocha --bail --reporter spec"
"test": "./node_modules/.bin/mocha --bail --harmony --reporter spec"
},
"author": "Jaap Karan Singh <jksdua@gmail.com>",
"repository": {
"type": "git",
"url": "https://gitlab.com/jksdua__common/jsonschema-validator"
},
"dependencies": {
"js-quantities": "^1.4.1",
"jshint": "^2.5.2",
"jsonschema": "~0.4.0",
"lodash": "~2.4.1",
"precommit-hook": "^1.0.2"
"lodash.isplainobject": "^2.4.1"
},
"devDependencies": {
"chai": "^1.9.1",
"mocha": "^1.20.1",
"monk": "^0.9.0"
"jsonschema": "^1.0.0",
"mongodb": "^1.4.16"
}
}
readme.md
View file @ 27ddedc3
JSON Schema Validator
jsonschema EXTRAAA!!!
=====================
jsonschema validator with custom types and attributes
**Extends jsonschema validator with some common custom types and attributes**
Usage
......@@ -10,11 +10,17 @@ Usage
### Installation
```bash
$ npm install --save git+ssh://git@gitlab.com:jksdua__common/jsonschema-validator.git#v0.1.1
npm install jsonschema-extra --save
```
### Example
```js
var validator = require('js_jsonschema-validator').validator;
var jsonschema = require('jsonschema');
var extend = require('jsonschema-extra');
var validator = new (jsonschema.Validator)();
extend(validator);
// regexp
validator.validate(/abc/, { type: 'regexp' });
......@@ -22,17 +28,68 @@ validator.validate(/abc/, { type: 'regexp' });
// error
validator.validate(new Error(), { type: 'error' });
// objectid
// mongodb objectid
validator.validate('123456789012345678901234', { type: 'objectId' });
```
### Details
#### Attributes
See `jsonschema` documentation for more detailed documentation on custom attributes.
##### validate
Custom validator when `jsonschema` just isn't what you are after. This one is my absolute favourite! It comes in handy whenever you are trying to do something complex.
> One of the features of jsonschema is that you can share it across client and server which is exactly what I do! However, if your schema contains a validate attribute it will no longer be valid json. This is not a big issue if you are ok for client side code to not contain all your validation logic if schema is sent from the server.
```js
var schema = {
validate: function(instance, schema, options) {
// do your crazy validation here
// return an error string if not valid
return 'is not a valid instance';
}
};
```
#### Types
Supported types:
- error (instanceof Error)
- regexp (instanceof RegExp)
- function (Function - also works for Generator Function)
- generatorFunction (ES6 Generator Function)
- objectId (MongoDb objectId)
- plainObject (calls _.isPlainObject)
```js
validator.validate(new Error(), { type: 'error' });
validator.validate(/regexp/, { type: 'regexp' });
validator.validate(function() {}, { type: 'function' });
validator.validate(function *() {}, { type: 'generatorFunction' });
validator.validate('123456789012345678901234', { type: 'objectId' });
validator.validate(new ObjectID(), { type: 'objectId' });
validator.validate({ a: 'a', b: 'b' }, { type: 'plainObject' });
```
Changelog
---------
### v0.1.1 (17 July 2014)
- Added `speed` type
- Fixed bug where custom types were not getting picked up
### v1.0.0 (27 Sep 2014)
- Changed public API
- Name of module changed to jsonschema-extra
- Removed conditionalEnum custom attribute since this has been fixed in the latest versions of jsonschema
### v0.1.0 (24 June 2014)
- Changed namespace to `js` from `ht`
......
src/Class.Validator.js deleted 100644 → 0
View file @ 27f97490
'use strict';
var _ = require('lodash');
var jsonschema = require('jsonschema');
var customTypes = require(__dirname + '/types');
var BasicValidator = jsonschema.Validator;
var customAttributes = require(__dirname + '/attributes');
function Validator() {
BasicValidator.apply(this, arguments);
_.extend(this.types, customTypes);
_.extend(this.attributes, customAttributes);
}
Validator.prototype = Object.create(BasicValidator.prototype);
module.exports = Validator;
\ No newline at end of file
src/index.js deleted 100644 → 0
View file @ 27f97490
/* jshint node:true */
'use strict';
var jsonschema = require('jsonschema');
exports.ValidationError = jsonschema.ValidationError;
exports.SchemaError = jsonschema.SchemaError;
exports.Validator = require(__dirname + '/Class.Validator');
exports.validator = new exports.Validator();
exports.custom = {
attributes: require(__dirname + '/attributes'),
types: require(__dirname + '/types')
};
\ No newline at end of file
test.js
View file @ 27ddedc3
......@@ -3,71 +3,178 @@
'use strict';
var monk = require('monk');
var chai = require('chai');
var expect = chai.expect;
describe('#jsonschema-extra', function() {
var assert = require('assert');
var ObjectID = require('mongodb').ObjectID;
var validator = require(__dirname + '/src').validator;
var validator = new (require('jsonschema').Validator)();
require(__dirname)(validator);
var db = monk('localhost/test');
var collection = db.get('collection');
var extras = {
types: require(__dirname + '/types'),
attributes: require(__dirname + '/attributes')
};
describe('#types', function() {
describe('#regexp', function() {
it('should not work', function() {
var res = validator.validate('abc', { type: 'regexp' });
expect(res.valid).to.be.false; // jshint ignore:line
});
var assertions = {
types: {
error: [
{
instance: 123,
pass: false
},
{
instance: new Error(),
pass: true
}
],
regexp: [
{
instance: 'abc',
pass: false
},
{
instance: /a/,
pass: true
},
{
instance: new RegExp('a', 'i'),
pass: true
}
],
function: [
{
instance: new Function(), // jshint ignore:line
pass: true
},
{
instance: eval('function a() {}'), // jshint ignore:line
pass: true
},
{
instance: function() {},
pass: true
},
{
instance: function *() {}, // jshint ignore:line
pass: true
}
],
generatorFunction: [
{
instance: function() {},
pass: false
},
{
instance: function *() {}, // jshint ignore:line
pass: true
}
],
objectId: [
{
instance: 123,
pass: false
},
{
instance: '123456789012345678901234',
pass: true
},
{
instance: new ObjectID('123456789012345678901234'),
pass: true
},
{
instance: new ObjectID(),
pass: true
}
],
plainObject: [
{
instance: 123,
pass: false
},
{
instance: new String('abc'), // jshint ignore:line
pass: false
},
{
instance: new ObjectID('123456789012345678901234'),
pass: false
},
{
instance: { a: 1 },
pass: true
},
{
instance: { a: { a: 1 } },
pass: true
}
]
},
attributes: {
validate: [
{
instance: 1,
schema: {
validate: function() {
return 'is not valid';
}
},
pass: false
},
{
instance: 2,
schema: {
validate: function() {
return;
}
},
pass: true
}
]
}
};
it('should work', function() {
var res = validator.validate(/abc/, { type: 'regexp' });
expect(res.valid).to.be.true; // jshint ignore:line
it('should test everything', function() {
Object.keys(extras).forEach(function(category) {
Object.keys(extras[category]).forEach(function(name) {
assert(
name in assertions[category],
'Missing assertions for ' + category + '.' + name
);
});
});
});
describe('#objectid', function() {
it('should not work for an invalid id', function() {
var res = validator.validate('1234', { type: 'objectId' });
expect(res.valid).to.be.false; // jshint ignore:line
});
describe('#types', function() {
Object.keys(assertions.types).forEach(function(type) {
var category = assertions.types[type];
var schema = { type: type };
it('should work for string representation', function() {
var res = validator.validate('123456789012', { type: 'objectId' });
expect(res.valid).to.be.true; // jshint ignore:line
});
it('should work for hex representation', function() {
var res = validator.validate('123456789012345678901234', { type: 'objectId' });
expect(res.valid).to.be.true; // jshint ignore:line
});
describe('#' + type, function() {
category.forEach(function(assertion) {
it('should ' + (assertion.pass ? '' : 'not ') + 'work for ' + assertion.instance, function() {
var res = validator.validate(assertion.instance, schema);
assert.equal(res.valid, assertion.pass, res.errors);
});
});
});
it('should work for objectid instance', function() {
var res = validator.validate(collection.id(), { type: 'objectId' });
expect(res.valid).to.be.true; // jshint ignore:line
});
});
describe('#speed', function() {
it('should not work for non string', function() {
var res = validator.validate(1234, { type: 'speed' });
expect(res.valid).to.be.false; // jshint ignore:line
});
describe('#attributes', function() {
Object.keys(assertions.attributes).forEach(function(attribute) {
var category = assertions.attributes[attribute];
it('should not work for a string that is not a quantity', function() {
var res = validator.validate('abc', { type: 'speed' });
expect(res.valid).to.be.false; // jshint ignore:line
});
describe('#' + attribute, function() {
category.forEach(function(assertion) {
it('should ' + (assertion.pass ? '' : 'not ') + 'work for ' + assertion.instance, function() {
var res = validator.validate(assertion.instance, assertion.schema);
assert.equal(res.valid, assertion.pass, res.errors);
});
});
});
it('should not work for a string that is of the wrong type', function() {
var res = validator.validate('1 metre', { type: 'speed' });
expect(res.valid).to.be.false; // jshint ignore:line
});
it('should work for the correct quantity type', function() {
var res = validator.validate('1 kph', { type: 'speed' });
expect(res.valid).to.be.true; // jshint ignore:line
});
});
});
describe('#attributes', function() {});
\ No newline at end of file
});
\ No newline at end of file
src/types.js → types.js
View file @ 27ddedc3
......@@ -2,27 +2,22 @@
'use strict';
var _ = require('lodash');
var Quantity = require('js-quantities');
var isPlainObject = require('lodash.isPlainObject');
exports.error = function testError(er) {
return (er instanceof Error);
};
exports.speed = function testSpeed(sp) {
try {
return ('speed' === (new Quantity(sp)).kind());
} catch(e) {
return false;
}
};
exports.regexp = function testRegexp(re) {
return (re instanceof RegExp);
};
exports.function = function testFunction(fn) {
return (fn instanceof Function);
return ('function' === typeof fn);
};
exports.generatorFunction = function testGeneratorFunction(fn) {
return ('function' === typeof fn && 'GeneratorFunction' === fn.constructor.name);
};
exports.objectId = function testObjectId(id) {
......@@ -36,5 +31,5 @@ exports.objectId = function testObjectId(id) {
};
exports.plainObject = function testPlainObject(ob) {
return _.isPlainObject(ob);
return isPlainObject(ob);
};
\ No newline at end of file
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment