New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

bedrock-validation

Package Overview
Dependencies
Maintainers
5
Versions
41
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

bedrock-validation - npm Package Compare versions

Comparing version

5.4.1
to
5.5.0

8

CHANGELOG.md
# bedrock-validation ChangeLog
## 5.5.0 - 2022-02-17
### Added
- Add `createValidateMiddleware` to create a more modern validate express-style
middleware. This function has more clear name, simpler parameters, and
ensures that the schemas used are compiled once. It requires schemas to
be passed directly, a string identifying a schema may not be used.
## 5.4.1 - 2022-02-10

@@ -4,0 +12,0 @@

73

lib/index.js

@@ -18,7 +18,4 @@ /*!

const api = {};
module.exports = api;
// available schemas
const schemas = api.schemas = {};
const schemas = exports.schemas = {};

@@ -80,3 +77,3 @@ bedrock.events.on('bedrock.init', init);

*/
api.compile = function(schema) {
exports.compile = function(schema) {
const fn = ajv.compile(schema);

@@ -96,2 +93,5 @@ fn.title = schema.title;

/**
* This method is deprecated for creating middleware. Use
* `createValidateMiddleware` instead.
*
* This method takes one or three parameters.

@@ -122,3 +122,3 @@ *

*/
api.validate = function(name, data, callback) {
exports.validate = function(name, data, callback) {
// NOTE: this cannot be an arrow function due to use of `arguments`

@@ -142,3 +142,3 @@ const options = {};

Object.keys(options).forEach(key => {
schemas[key] = api.getSchema(options[key]);
schemas[key] = exports.getSchema(options[key]);
if(!notFound && !schemas[key]) {

@@ -163,3 +163,3 @@ notFound = options[key];

// use schema.body (assume 3 parameter is called w/string)
return api.validateInstance(data, schemas.body, callback);
return exports.validateInstance(data, schemas.body, callback);
}

@@ -170,3 +170,3 @@

if(schemas.query) {
queryFn = api.compile(schemas.query);
queryFn = exports.compile(schemas.query);
queryFn.title = schemas.query.title;

@@ -176,3 +176,3 @@ }

if(schemas.body) {
bodyFn = api.compile(schemas.body);
bodyFn = exports.compile(schemas.body);
bodyFn.title = schemas.body.title;

@@ -207,6 +207,6 @@ }

*/
api.getSchema = name => {
exports.getSchema = name => {
let schema = null;
if(name in api.schemas) {
schema = api.schemas[name].instance;
if(name in exports.schemas) {
schema = exports.schemas[name].instance;
}

@@ -227,3 +227,3 @@ return schema;

*/
api.validateInstance = (instance, schema, callback) => {
exports.validateInstance = (instance, schema, callback) => {
const schemaIsFunction = typeof schema === 'function';

@@ -256,2 +256,47 @@

/**
* Creates middleware that will validate request body and URL query parameters.
*
* Use this method over the deprecated `validate` to create a middleware.
*
* @param {object} options - The options to use.
* @param {object} [bodySchema] - The JSON schema to use to validate the
* request body.
* @param {object} [querySchema] - The JSON schema to use to validate the
* request URL query parameters.
*
* @returns {Function} An express-style middleware.
*/
exports.createValidateMiddleware = function({bodySchema, querySchema}) {
if(!(bodySchema || querySchema)) {
throw new TypeError(
'One of the following parameters is required: ' +
'"bodySchema", "querySchema".');
}
// pre-compile schemas
let validateBodySchema;
if(bodySchema) {
validateBodySchema = exports.compile(bodySchema);
}
let validateQuerySchema;
if(querySchema) {
validateQuerySchema = exports.compile(querySchema);
}
return function validate(req, res, next) {
if(validateBodySchema) {
const result = validateBodySchema(req.body);
if(!result.valid) {
return next(result.error);
}
}
if(validateQuerySchema) {
const result = validateQuerySchema(req.query);
if(!result.valid) {
return next(result.error);
}
}
next();
};
};
function _createError({schema, instance}) {

@@ -258,0 +303,0 @@ // create public error messages

2

package.json
{
"name": "bedrock-validation",
"version": "5.4.1",
"version": "5.5.0",
"description": "Bedrock validation",

@@ -5,0 +5,0 @@ "main": "./lib",

151

test/mocha/001-schemas.js

@@ -112,47 +112,114 @@ /*

});
it('should return middleware with a ValidationError due to invalid body',
function(done) {
const req = {
body: ''
};
const res = {};
const next = function(err) {
should.exist(err);
err.name.should.equal('ValidationError');
done();
};
it('should raise a body ValidationError via legacy middleware', done => {
const req = {
body: ''
};
const res = {};
const next = function(err) {
should.exist(err);
err.name.should.equal('ValidationError');
done();
};
const result = validation.validate('comment');
result(req, res, next);
});
it('should call middleware with a ValidationError due to invalid query',
function(done) {
const req = {
query: ''
};
const res = {};
const next = function(err) {
should.exist(err);
err.name.should.equal('ValidationError');
done();
};
const middleware = validation.validate('comment');
middleware(req, res, next);
});
it('should raise a query ValidationError via legacy middleware', done => {
const req = {
query: ''
};
const res = {};
const next = function(err) {
should.exist(err);
err.name.should.equal('ValidationError');
done();
};
const result = validation.validate({
query: 'comment'});
result(req, res, next);
});
it('should not return a ValidationError in middleware when valid',
function(done) {
const req = {
body: 'comment'
};
const res = {};
const next = function(err) {
should.not.exist(err);
done();
};
const middleware = validation.validate({query: 'comment'});
middleware(req, res, next);
});
it('should pass body validation via legacy middleware', done => {
const req = {
body: 'comment'
};
const res = {};
const next = function(err) {
should.not.exist(err);
done();
};
const result = validation.validate('comment');
result(req, res, next);
});
const middleware = validation.validate('comment');
middleware(req, res, next);
});
it('should pass query validation via legacy middleware', done => {
const req = {
query: 'comment'
};
const res = {};
const next = function(err) {
should.not.exist(err);
done();
};
const middleware = validation.validate({query: 'comment'});
middleware(req, res, next);
});
it('should raise a body ValidationError via middleware', done => {
const req = {
body: ''
};
const res = {};
const next = function(err) {
should.exist(err);
err.name.should.equal('ValidationError');
done();
};
const bodySchema = validation.getSchema('comment');
const middleware = validation.createValidateMiddleware({bodySchema});
middleware(req, res, next);
});
it('should raise a query ValidationError via middleware', done => {
const req = {
query: ''
};
const res = {};
const next = function(err) {
should.exist(err);
err.name.should.equal('ValidationError');
done();
};
const querySchema = validation.getSchema('comment');
const middleware = validation.createValidateMiddleware({querySchema});
middleware(req, res, next);
});
it('should pass body validation via middleware', done => {
const req = {
body: 'comment'
};
const res = {};
const next = function(err) {
should.not.exist(err);
done();
};
const bodySchema = validation.getSchema('comment');
const middleware = validation.createValidateMiddleware({bodySchema});
middleware(req, res, next);
});
it('should pass query validation via middleware', done => {
const req = {
query: 'comment'
};
const res = {};
const next = function(err) {
should.not.exist(err);
done();
};
const querySchema = validation.getSchema('comment');
const middleware = validation.createValidateMiddleware({querySchema});
middleware(req, res, next);
});
it('should accept valid comment with extend', function() {

@@ -159,0 +226,0 @@ const extend = {name: 'test'};