diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml new file mode 100644 index 000000000..88fc551fa --- /dev/null +++ b/.github/FUNDING.yml @@ -0,0 +1,3 @@ +github: epoberezkin +tidelift: "npm/ajv" +open_collective: "ajv" diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md index 1deda1e23..558501036 100644 --- a/.github/ISSUE_TEMPLATE.md +++ b/.github/ISSUE_TEMPLATE.md @@ -1,11 +1,12 @@ @@ -15,7 +16,7 @@ This template is for bug reports. For other issues please use: **Ajv options object** - + ```javascript @@ -48,7 +49,7 @@ This template is for bug reports. For other issues please use: + +**What version of Ajv are you using? Does the issue happen if you use the latest version?** + + + +**Ajv options object** + + + +```javascript + + +``` + + +**JSON Schema** + + + +```json + + +``` + + +**Sample data** + + + +```json + + +``` + + +**Your code** + + + +```javascript + + +``` + + +**Validation result, data AFTER validation, error messages** + +``` + + +``` + +**What results did you expect?** + + +**Are you going to resolve the issue?** diff --git a/.github/ISSUE_TEMPLATE/change.md b/.github/ISSUE_TEMPLATE/change.md index 965bd02ff..0c8035d1a 100644 --- a/.github/ISSUE_TEMPLATE/change.md +++ b/.github/ISSUE_TEMPLATE/change.md @@ -1,9 +1,18 @@ +--- +name: Feature or change proposal +about: For proposals of new features, options or some other improvements +title: '' +labels: 'enhancement' +assignees: '' + +--- + **What version of Ajv you are you using?** diff --git a/.github/ISSUE_TEMPLATE/compatibility.md b/.github/ISSUE_TEMPLATE/compatibility.md index 4203ad43f..79aa63999 100644 --- a/.github/ISSUE_TEMPLATE/compatibility.md +++ b/.github/ISSUE_TEMPLATE/compatibility.md @@ -1,19 +1,28 @@ +--- +name: Browser and compatibility issue +about: For issues that only happen in a specific environment +title: '' +labels: 'compatibility' +assignees: '' + +--- + **The version of Ajv you are using** -**The environment you have the problem with.** +**The environment you have the problem with** -**Your code (please make it as small as possible to reproduce the issue).** +**Your code (please make it as small as possible to reproduce the issue)** -**If your issue is in the browser, please list the other packages loaded in the page in the order they are loaded. Please check if the issue gets resolved (or results change) if you move Ajv bundle closer to the top.** +**If your issue is in the browser, please list the other packages loaded in the page in the order they are loaded. Please check if the issue gets resolved (or results change) if you move Ajv bundle closer to the top** -**Results in node.js v4.** +**Results in node.js v8+** -**Results and error messages in your platform.** +**Results and error messages in your platform** diff --git a/.github/ISSUE_TEMPLATE/installation.md b/.github/ISSUE_TEMPLATE/installation.md new file mode 100644 index 000000000..1786e9f2f --- /dev/null +++ b/.github/ISSUE_TEMPLATE/installation.md @@ -0,0 +1,33 @@ +--- +name: Installation and dependency issue +about: For issues that happen during installation +title: '' +labels: 'installation' +assignees: '' + +--- + + + +**The version of Ajv you are using** + +**Operating system and node.js version** + +**Package manager and its version** + +**Link to (or contents of) package.json** + +**Error messages** + +**The output of `npm ls`** diff --git a/.github/ISSUE_TEMPLATE/typescript.md b/.github/ISSUE_TEMPLATE/typescript.md new file mode 100644 index 000000000..de3c20168 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/typescript.md @@ -0,0 +1,42 @@ +--- +name: Missing or incorrect type definition +about: Please use for issues related to typescript types +title: '' +labels: 'typescript' +assignees: '' + +--- + + + +**What version of Ajv are you using? Does the issue happen if you use the latest version?** + + +**Your typescript code** + + + +```typescript + + +``` + + +**Typescript compiler error messages** + +``` + + +``` + +**Describe the change that should be made to address the issue?** + + +**Are you going to resolve the issue?** diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index d7feecdbd..7abf655f1 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -2,7 +2,7 @@ Thank you for submitting a pull request to Ajv. Before continuing, please read the guidelines: -https://github.com/epoberezkin/ajv/blob/master/CONTRIBUTING.md#pull-requests +https://github.com/ajv-validator/ajv/blob/master/CONTRIBUTING.md#pull-requests If the pull request contains code please make sure there is an issue that we agreed to resolve (if it is a documentation improvement there is no need for an issue). diff --git a/.github/config.yml b/.github/config.yml new file mode 100644 index 000000000..1f6c1054f --- /dev/null +++ b/.github/config.yml @@ -0,0 +1,32 @@ +# Please supply comments to be used for GitHub labels +githubLabels: + bug: > + Bug confirmed - to be fixed. PR is welcome! + +# duplicate: > +# enhancement: > +# good first issue: > +# help wanted: > +# invalid: > +# question: > +# wont fix: > + + bug report: > + Thank you for the report! If you didn't post a code sample to RunKit yet, + please clone this notebook https://runkit.com/esp/ajv-issue, + post the code sample that demonstrates the bug and post the link here. + It will speed up the investigation and fixing! + + json schema: > + This question is about the usage of JSON Schema specification - it is not specific to Ajv. + Please use JSON Schema reference materials or [submit the question to Stack Overflow](https://stackoverflow.com/questions/ask?tags=jsonschema,ajv). + + - [JSON Schema specification](http://json-schema.org/) + + - [Tutorial by Space Telescope Science Institute](http://json-schema.org/understanding-json-schema/) + + - [validation keywords](https://github.com/ajv-validator/ajv#validation-keywords) (in Ajv docs) + + - [combining schemas](https://github.com/ajv-validator/ajv#ref) (in Ajv docs) + + - [Tutorial by @epoberezkin](https://code.tutsplus.com/tutorials/validating-data-with-json-schema-part-1--cms-25343) diff --git a/.travis.yml b/.travis.yml index c0cfe4295..80bb5bf49 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,10 +3,9 @@ before_script: - git submodule update --init - npm install -g codeclimate-test-reporter node_js: - - "6" - - "8" - - "9" - - "10" + - 10 + - 12 + - 14 after_script: - codeclimate-test-reporter < coverage/lcov.info - coveralls < coverage/lcov.info diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 000000000..410cda641 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,76 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or + advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at ajv.validator@gmail.com. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq diff --git a/COERCION.md b/COERCION.md index f310c2d67..6a0a41a68 100644 --- a/COERCION.md +++ b/COERCION.md @@ -1,6 +1,6 @@ # Ajv type coercion rules -To enable type coercion pass option `coerceTypes` to Ajv with `true` or `array` (it is `false` by default). See [example](https://github.com/epoberezkin/ajv#coercing-data-types). +To enable type coercion pass option `coerceTypes` to Ajv with `true` or `array` (it is `false` by default). See [example](https://github.com/ajv-validator/ajv#coercing-data-types). The coercion rules are different from JavaScript: - to validate user input as expected diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 6082d0d88..4f2f8aaed 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -5,8 +5,10 @@ Thank you for your help making Ajv better! Every contribution is appreciated. If - [Documentation](#documentation) - [Issues](#issues) - [Bug reports](#bug-reports) + - [Security vulnerabilities](#security-vulnerabilities) - [Change proposals](#changes) - [Browser and compatibility issues](#compatibility) + - [Installation and dependency issues](#installation) - [JSON Schema standard](#json-schema) - [Ajv usage questions](#usage) - [Code](#code) @@ -22,7 +24,7 @@ Ajv has a lot of features and maintaining documentation takes time. I appreciate ## Issues -Before submitting the issue please search the existing issues and also review [Frequently Asked Questions](https://github.com/epoberezkin/ajv/blob/master/FAQ.md). +Before submitting the issue please search the existing issues and also review [Frequently Asked Questions](https://github.com/ajv-validator/ajv/blob/master/FAQ.md). I would really appreciate the time you spend providing all the information and reducing both your schema and data to the smallest possible size when they still have the issue. Simplifying the issue also makes it more valuable for other users (in cases it turns out to be an incorrect usage rather than a bug). @@ -32,18 +34,29 @@ I would really appreciate the time you spend providing all the information and r Please make sure to include the following information in the issue: 1. What version of Ajv are you using? Does the issue happen if you use the latest version? -2. Ajv options object (see https://github.com/epoberezkin/ajv#options). +2. Ajv options object (see https://github.com/ajv-validator/ajv#options). 3. JSON Schema and the data you are validating (please make it as small as possible to reproduce the issue). 4. Your code (please use `options`, `schema` and `data` as variables). 5. Validation result, data AFTER validation, error messages. 6. What results did you expect? -[Create bug report](https://github.com/epoberezkin/ajv/issues/new). +Please include the link to the working code sample at Runkit.com (please clone https://runkit.com/esp/ajv-issue) - it will speed up investigation and fixing. + +[Create bug report](https://github.com/ajv-validator/ajv/issues/new?template=bug-or-error-report.md). + + +#### Security vulnerabilities + +To report a security vulnerability, please use the +[Tidelift security contact](https://tidelift.com/security). +Tidelift will coordinate the fix and disclosure. + +Please do NOT report security vulnerabilities via GitHub issues. #### Change proposals -[Create a proposal](https://github.com/epoberezkin/ajv/issues/new?template=change.md) for a new feature, option or some other improvement. +[Create a proposal](https://github.com/ajv-validator/ajv/issues/new?template=change.md) for a new feature, option or some other improvement. Please include this information: @@ -63,7 +76,7 @@ Please include as much details as possible. #### Browser and compatibility issues -[Create an issue](https://github.com/epoberezkin/ajv/issues/new?template=compatibility.md) to report a compatibility problem that only happens in a particular environment (when your code works correctly in node.js v4 in linux systems but fails in some other environment). +[Create an issue](https://github.com/ajv-validator/ajv/issues/new?template=compatibility.md) to report a compatibility problem that only happens in a particular environment (when your code works correctly in node.js v8+ in linux systems but fails in some other environment). Please include this information: @@ -71,15 +84,34 @@ Please include this information: 2. The environment you have the problem with. 3. Your code (please make it as small as possible to reproduce the issue). 4. If your issue is in the browser, please list the other packages loaded in the page in the order they are loaded. Please check if the issue gets resolved (or results change) if you move Ajv bundle closer to the top. -5. Results in node.js v4. +5. Results in node.js v8+. 6. Results and error messages in your platform. +#### Installation and dependency issues + +[Create an issue](https://github.com/ajv-validator/ajv/issues/new?template=installation.md) to report problems that happen during Ajv installation or when Ajv is missing some dependency. + +Before submitting the issue, please try the following: +- use the latest stable Node.js and `npm` +- use `yarn` instead of `npm` - the issue can be related to https://github.com/npm/npm/issues/19877 +- remove `node_modules` and `package-lock.json` and run install again + +If nothing helps, please submit: + +1. The version of Ajv you are using +2. Operating system and node.js version +3. Package manager and its version +4. Link to (or contents of) package.json +5. Error messages +6. The output of `npm ls` + + #### Using JSON Schema standard Ajv implements JSON Schema standard draft-04 and draft-06/07. -If it is a general issue related to using the standard keywords included in JSON Schema or implementing some advanced validation logic please ask the question on [Stack Overflow](http://stackoverflow.com/questions/ask?tags=jsonschema,ajv) (my account is [esp](http://stackoverflow.com/users/1816503/esp)) or submitting the question to [JSON-Schema.org](https://github.com/json-schema-org/json-schema-spec/issues/new). Please mention @epoberezkin. +If it is a general issue related to using the standard keywords included in JSON Schema or implementing some advanced validation logic please ask the question on [Stack Overflow](https://stackoverflow.com/questions/ask?tags=jsonschema,ajv) (my account is [esp](https://stackoverflow.com/users/1816503/esp)) or submitting the question to [JSON-Schema.org](https://github.com/json-schema-org/json-schema-spec/issues/new). Please mention @epoberezkin. #### Ajv usage questions @@ -111,9 +143,9 @@ npm run test-fast git commit -nm 'type: message' ``` -All validation functions are generated using doT templates in [dot](https://github.com/epoberezkin/ajv/tree/master/lib/dot) folder. Templates are precompiled so doT is not a run-time dependency. +All validation functions are generated using doT templates in [dot](https://github.com/ajv-validator/ajv/tree/master/lib/dot) folder. Templates are precompiled so doT is not a run-time dependency. -`npm run build` - compiles templates to [dotjs](https://github.com/epoberezkin/ajv/tree/master/lib/dotjs) folder. +`npm run build` - compiles templates to [dotjs](https://github.com/ajv-validator/ajv/tree/master/lib/dotjs) folder. `npm run watch` - automatically compiles templates when files in dot folder change @@ -122,7 +154,7 @@ All validation functions are generated using doT templates in [dot](https://gith To make accepting your changes faster please follow these steps: -1. Submit an [issue with the bug](https://github.com/epoberezkin/ajv/issues/new) or with the proposed change (unless the contribution is to fix the documentation typos and mistakes). +1. Submit an [issue with the bug](https://github.com/ajv-validator/ajv/issues/new) or with the proposed change (unless the contribution is to fix the documentation typos and mistakes). 2. Please describe the proposed api and implementation plan (unless the issue is a relatively simple bug and fixing it doesn't change any api). 3. Once agreed, please write as little code as possible to achieve the desired result. 4. Please avoid unnecessary changes, refactoring or changing coding styles as part of your change (unless the change was proposed as refactoring). diff --git a/CUSTOM.md b/CUSTOM.md index 6a5cbe8f1..68cac5ab3 100644 --- a/CUSTOM.md +++ b/CUSTOM.md @@ -34,7 +34,7 @@ This way to define keywords is useful for: - testing your keywords before converting them to compiled/inlined keywords - defining keywords that do not depend on the schema value (e.g., when the value is always `true`). In this case you can add option `schema: false` to the keyword definition and the schemas won't be passed to the validation function, it will only receive the same 4 parameters as compiled validation function (see the next section). - defining keywords where the schema is a value used in some expression. -- defining keywords that support [$data reference](https://github.com/epoberezkin/ajv#data-reference) - in this case validation function is required, either as the only option or in addition to compile, macro or inline function (see below). +- defining keywords that support [$data reference](https://github.com/ajv-validator/ajv#data-reference) - in this case validation function is required, either as the only option or in addition to compile, macro or inline function (see below). __Please note__: In cases when validation flow is different depending on the schema and you have to use `if`s, this way to define keywords will have worse performance than compiled keyword returning different validation functions depending on the schema. @@ -92,6 +92,8 @@ In some cases it is the best approach to define keywords, but it has the perform All custom keywords types can have an optional `metaSchema` property in their definitions. It is a schema against which the value of keyword will be validated during schema compilation. +Custom keyword can also have an optional `dependencies` property in their definitions - it is a list of required keywords in a containing (parent) schema. + Example. `range` and `exclusiveRange` keywords using compiled schema: ```javascript @@ -195,7 +197,7 @@ console.log(validate([3,4,5])); // true, number 5 matches schema inside "contain `contains` keyword is already available in Ajv with option `v5: true`. -See the example of defining recursive macro keyword `deepProperties` in the [test](https://github.com/epoberezkin/ajv/blob/master/spec/custom.spec.js#L151). +See the example of defining recursive macro keyword `deepProperties` in the [test](https://github.com/ajv-validator/ajv/blob/master/spec/custom.spec.js#L151). ### Define keyword with "inline" compilation function @@ -292,7 +294,7 @@ The first parameter passed to inline keyword compilation function (and the 3rd p - _opts_ - Ajv instance option. You should not be changing them. - _formats_ - all formats available in Ajv instance, including the custom ones. - _compositeRule_ - boolean indicating that the current schema is inside the compound keyword where failing some rule doesn't mean validation failure (`anyOf`, `oneOf`, `not`, `if` in `switch`). This flag is used to determine whether you can return validation result immediately after any error in case the option `allErrors` is not `true. You only need to do it if you have many steps in your keywords and potentially can define multiple errors. -- _validate_ - the function you need to use to compile subschemas in your keywords (see the [implementation](https://github.com/epoberezkin/ajv/blob/master/lib/dot/v5/switch.jst) of `switch` keyword for example). +- _validate_ - the function you need to use to compile subschemas in your keywords (see the [implementation](https://github.com/ajv-validator/ajv-keywords/blob/master/keywords/dot/switch.jst) of `switch` keyword for example). - _util_ - [Ajv utilities](#ajv-utilities) you can use in your inline compilation functions. - _self_ - Ajv instance. @@ -309,8 +311,8 @@ There is a number of variables and expressions you can use in the generated (val - `'validate.schema' + it.schemaPath` - current level schema available at validation time (the same schema at compile time is `it.schema`). - `'validate.schema' + it.schemaPath + '.' + keyword` - the value of your custom keyword at validation-time. Keyword is passed as the second parameter to the inline compilation function to allow using the same function to compile multiple keywords. - `'valid' + it.level` - the variable that you have to declare and to assign the validation result to if your keyword returns statements rather than expression (`statements: true`). -- `'errors'` - the number of encountered errors. See [Reporting errors in custom keywords](https://github.com/epoberezkin/ajv/blob/master/CUSTOM.md#reporting-errors-in-custom-keywords). -- `'vErrors'` - the array with errors collected so far. See [Reporting errors in custom keywords](https://github.com/epoberezkin/ajv/blob/master/CUSTOM.md#reporting-errors-in-custom-keywords). +- `'errors'` - the number of encountered errors. See [Reporting errors in custom keywords](https://github.com/ajv-validator/ajv/blob/master/CUSTOM.md#reporting-errors-in-custom-keywords). +- `'vErrors'` - the array with errors collected so far. See [Reporting errors in custom keywords](https://github.com/ajv-validator/ajv/blob/master/CUSTOM.md#reporting-errors-in-custom-keywords). ## Ajv utilities @@ -408,7 +410,7 @@ All custom keywords but macro keywords can optionally create custom error messag Synchronous validating and compiled keywords should define errors by assigning them to `.errors` property of the validation function. Asynchronous keywords can return promise that rejects with `new Ajv.ValidationError(errors)`, where `errors` is an array of custom validation errors (if you don't want to define custom errors in asynchronous keyword, its validation function can return the promise that resolves with `false`). -Inline custom keyword should increase error counter `errors` and add error to `vErrors` array (it can be null). This can be done for both synchronous and asynchronous keywords. See [example range keyword](https://github.com/epoberezkin/ajv/blob/master/spec/custom_rules/range_with_errors.jst). +Inline custom keyword should increase error counter `errors` and add error to `vErrors` array (it can be null). This can be done for both synchronous and asynchronous keywords. See [example range keyword](https://github.com/ajv-validator/ajv/blob/master/spec/custom_rules/range_with_errors.jst). When inline keyword performs validation Ajv checks whether it created errors by comparing errors count before and after validation. To skip this check add option `errors` (can be `"full"`, `true` or `false`) to keyword definition: @@ -427,7 +429,7 @@ Each error object should at least have properties `keyword`, `message` and `para Inlined keywords can optionally define `dataPath` and `schemaPath` properties in error objects, that will be assigned by Ajv unless `errors` option of the keyword is `"full"`. -If custom keyword doesn't create errors, the default error will be created in case the keyword fails validation (see [Validation errors](https://github.com/epoberezkin/ajv#validation-errors)). +If custom keyword doesn't create errors, the default error will be created in case the keyword fails validation (see [Validation errors](https://github.com/ajv-validator/ajv#validation-errors)). ## Short-circuit validation diff --git a/FAQ.md b/FAQ.md index 472a5edb0..f010a51c8 100644 --- a/FAQ.md +++ b/FAQ.md @@ -9,7 +9,7 @@ The purpose of this document is to help find answers quicker. I am happy to cont Ajv implements JSON schema specification. Before submitting the issue about the behaviour of any validation keywords please review them in: - [JSON Schema specification](https://tools.ietf.org/html/draft-handrews-json-schema-validation-00) (draft-07) -- [Validation keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md) in Ajv documentation +- [Validation keywords](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md) in Ajv documentation - [JSON Schema tutorial](https://spacetelescope.github.io/understanding-json-schema/) (for draft-04) @@ -20,13 +20,13 @@ Ajv implements JSON schema specification. Before submitting the issue about the ##### Why Ajv validates only the first item of the array? -"items" keyword support [two syntaxes](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#items) - 1) when the schema applies to all items; 2) when there is a different schema for each item in the beginning of the array. This problem means you are using the second syntax. +"items" keyword support [two syntaxes](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#items) - 1) when the schema applies to all items; 2) when there is a different schema for each item in the beginning of the array. This problem means you are using the second syntax. ## Ajv API for returning validation errors -See [#65](https://github.com/epoberezkin/ajv/issues/65), [#212](https://github.com/epoberezkin/ajv/issues/212), [#236](https://github.com/epoberezkin/ajv/issues/236), [#242](https://github.com/epoberezkin/ajv/issues/242), [#256](https://github.com/epoberezkin/ajv/issues/256). +See [#65](https://github.com/ajv-validator/ajv/issues/65), [#212](https://github.com/ajv-validator/ajv/issues/212), [#236](https://github.com/ajv-validator/ajv/issues/236), [#242](https://github.com/ajv-validator/ajv/issues/242), [#256](https://github.com/ajv-validator/ajv/issues/256). ##### Why Ajv assigns errors as a property of validation function (or instance) instead of returning an object with validation results and errors? @@ -56,7 +56,7 @@ Since the property name is already in the params object, in an application you c ## Additional properties inside compound keywords anyOf, oneOf, etc. -See [#127](https://github.com/epoberezkin/ajv/issues/127), [#129](https://github.com/epoberezkin/ajv/issues/129), [#134](https://github.com/epoberezkin/ajv/issues/134), [#140](https://github.com/epoberezkin/ajv/issues/140), [#193](https://github.com/epoberezkin/ajv/issues/193), [#205](https://github.com/epoberezkin/ajv/issues/205), [#238](https://github.com/epoberezkin/ajv/issues/238), [#264](https://github.com/epoberezkin/ajv/issues/264). +See [#127](https://github.com/ajv-validator/ajv/issues/127), [#129](https://github.com/ajv-validator/ajv/issues/129), [#134](https://github.com/ajv-validator/ajv/issues/134), [#140](https://github.com/ajv-validator/ajv/issues/140), [#193](https://github.com/ajv-validator/ajv/issues/193), [#205](https://github.com/ajv-validator/ajv/issues/205), [#238](https://github.com/ajv-validator/ajv/issues/238), [#264](https://github.com/ajv-validator/ajv/issues/264). ##### Why the keyword `additionalProperties: false` fails validation when some properties are "declared" inside a subschema in `anyOf`/etc.? @@ -83,15 +83,15 @@ There are several ways to implement the described logic that would allow two pro ##### Why the validation fails when I use option `removeAdditional` with the keyword `anyOf`/etc.? -This problem is related to the problem explained above - properties treated as additional in the sence of `additionalProperties` keyword, based on `properties`/`patternProperties` keyword in the same schema object. +This problem is related to the problem explained above - properties treated as additional in the sense of `additionalProperties` keyword, based on `properties`/`patternProperties` keyword in the same schema object. -See the exemple in [Filtering Data](https://github.com/epoberezkin/ajv#filtering-data) section of readme. +See the exemple in [Filtering Data](https://github.com/ajv-validator/ajv#filtering-data) section of readme. ## Generating schemas with resolved references ($ref) -See [#22](https://github.com/epoberezkin/ajv/issues/22), [#125](https://github.com/epoberezkin/ajv/issues/125), [#146](https://github.com/epoberezkin/ajv/issues/146), [#228](https://github.com/epoberezkin/ajv/issues/228), [#336](https://github.com/epoberezkin/ajv/issues/336), [#454](https://github.com/epoberezkin/ajv/issues/454). +See [#22](https://github.com/ajv-validator/ajv/issues/22), [#125](https://github.com/ajv-validator/ajv/issues/125), [#146](https://github.com/ajv-validator/ajv/issues/146), [#228](https://github.com/ajv-validator/ajv/issues/228), [#336](https://github.com/ajv-validator/ajv/issues/336), [#454](https://github.com/ajv-validator/ajv/issues/454). ##### Why Ajv does not replace references ($ref) with the actual referenced schemas as some validators do? @@ -108,4 +108,4 @@ There were many conversations about the meaning of `$ref` in [JSON Schema GitHub There are two possible approaches: 1. Traverse schema (e.g. with json-schema-traverse) and replace every `$ref` with the referenced schema. -2. Use a specially constructed JSON Schema with a [custom keyword](https://github.com/epoberezkin/ajv/blob/master/CUSTOM.md) to traverse and modify your schema. +2. Use a specially constructed JSON Schema with a [custom keyword](https://github.com/ajv-validator/ajv/blob/master/CUSTOM.md) to traverse and modify your schema. diff --git a/KEYWORDS.md b/KEYWORDS.md index 32740dc41..6601a9a1b 100644 --- a/KEYWORDS.md +++ b/KEYWORDS.md @@ -202,7 +202,7 @@ _invalid_: `"abc"` ### `formatMaximum` / `formatMinimum` and `formatExclusiveMaximum` / `formatExclusiveMinimum` (proposed) -Defined in [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) package. +Defined in [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package. The value of keyword `formatMaximum` (`formatMinimum`) should be a string. This value is the maximum (minimum) allowed value for the data to be valid as determined by `format` keyword. @@ -618,7 +618,7 @@ _invalid_: `{"foo": "any value"}` ### `patternRequired` (proposed) -Defined in [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) package. +Defined in [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package. The value of this keyword should be an array of strings, each string being a regular expression. For data object to be valid each regular expression in this array should match at least one property name in the data object. @@ -670,7 +670,7 @@ _valid_: `"foo"` _invalid_: any other value -The same can be achieved with `enum` keyword using the array with one item. But `const` keyword is more than just a syntax sugar for `enum`. In combination with the [$data reference](https://github.com/epoberezkin/ajv#data-reference) it allows to define equality relations between different parts of the data. This cannot be achieved with `enum` keyword even with `$data` reference because `$data` cannot be used in place of one item - it can only be used in place of the whole array in `enum` keyword. +The same can be achieved with `enum` keyword using the array with one item. But `const` keyword is more than just a syntax sugar for `enum`. In combination with the [$data reference](https://github.com/ajv-validator/ajv#data-reference) it allows to define equality relations between different parts of the data. This cannot be achieved with `enum` keyword even with `$data` reference because `$data` cannot be used in place of one item - it can only be used in place of the whole array in `enum` keyword. __Example__ diff --git a/README.md b/README.md index 15b1e6a18..5aa2078d8 100644 --- a/README.md +++ b/README.md @@ -1,23 +1,91 @@ -Ajv logo +Ajv logo # Ajv: Another JSON Schema Validator The fastest JSON Schema validator for Node.js and browser. Supports draft-04/06/07. - -[![Build Status](https://travis-ci.org/epoberezkin/ajv.svg?branch=master)](https://travis-ci.org/epoberezkin/ajv) +[![Build Status](https://travis-ci.org/ajv-validator/ajv.svg?branch=master)](https://travis-ci.org/ajv-validator/ajv) [![npm](https://img.shields.io/npm/v/ajv.svg)](https://www.npmjs.com/package/ajv) +[![npm (beta)](https://img.shields.io/npm/v/ajv/beta)](https://www.npmjs.com/package/ajv/v/7.0.0-beta.0) [![npm downloads](https://img.shields.io/npm/dm/ajv.svg)](https://www.npmjs.com/package/ajv) -[![Coverage Status](https://coveralls.io/repos/epoberezkin/ajv/badge.svg?branch=master&service=github)](https://coveralls.io/github/epoberezkin/ajv?branch=master) -[![Greenkeeper badge](https://badges.greenkeeper.io/epoberezkin/ajv.svg)](https://greenkeeper.io/) +[![Coverage Status](https://coveralls.io/repos/github/ajv-validator/ajv/badge.svg?branch=master)](https://coveralls.io/github/ajv-validator/ajv?branch=master) [![Gitter](https://img.shields.io/gitter/room/ajv-validator/ajv.svg)](https://gitter.im/ajv-validator/ajv) +[![GitHub Sponsors](https://img.shields.io/badge/$-sponsors-brightgreen)](https://github.com/sponsors/epoberezkin) + + +## Ajv v7 beta is released + +[Ajv version 7.0.0-beta.0](https://github.com/ajv-validator/ajv/tree/v7-beta) is released with these changes: + +- to reduce the mistakes in JSON schemas and unexpected validation results, [strict mode](./docs/strict-mode.md) is added - it prohibits ignored or ambiguous JSON Schema elements. +- to make code injection from untrusted schemas impossible, [code generation](./docs/codegen.md) is fully re-written to be safe. +- to simplify Ajv extensions, the new keyword API that is used by pre-defined keywords is available to user-defined keywords - it is much easier to define any keywords now, especially with subschemas. +- schemas are compiled to ES6 code (ES5 code generation is supported with an option). +- to improve reliability and maintainability the code is migrated to TypeScript. + +**Please note**: + +- the support for JSON-Schema draft-04 is removed - if you have schemas using "id" attributes you have to replace them with "\$id" (or continue using version 6 that will be supported until 02/28/2021). +- all formats are separated to ajv-formats package - they have to be explicitely added if you use them. + +See [release notes](https://github.com/ajv-validator/ajv/releases/tag/v7.0.0-beta.0) for the details. + +To install the new version: + +```bash +npm install ajv@beta +``` + +See [Getting started with v7](https://github.com/ajv-validator/ajv/tree/v7-beta#usage) for code example. + + +## Mozilla MOSS grant and OpenJS Foundation + +[](https://www.mozilla.org/en-US/moss/)     [](https://openjsf.org/blog/2020/08/14/ajv-joins-openjs-foundation-as-an-incubation-project/) + +Ajv has been awarded a grant from Mozilla’s [Open Source Support (MOSS) program](https://www.mozilla.org/en-US/moss/) in the “Foundational Technology” track! It will sponsor the development of Ajv support of [JSON Schema version 2019-09](https://tools.ietf.org/html/draft-handrews-json-schema-02) and of [JSON Type Definition](https://tools.ietf.org/html/draft-ucarion-json-type-definition-04). + +Ajv also joined [OpenJS Foundation](https://openjsf.org/) – having this support will help ensure the longevity and stability of Ajv for all its users. + +This [blog post](https://www.poberezkin.com/posts/2020-08-14-ajv-json-validator-mozilla-open-source-grant-openjs-foundation.html) has more details. + +I am looking for the long term maintainers of Ajv – working with [ReadySet](https://www.thereadyset.co/), also sponsored by Mozilla, to establish clear guidelines for the role of a "maintainer" and the contribution standards, and to encourage a wider, more inclusive, contribution from the community. + + +## Please [sponsor Ajv development](https://github.com/sponsors/epoberezkin) + +Since I asked to support Ajv development 40 people and 6 organizations contributed via GitHub and OpenCollective - this support helped receiving the MOSS grant! + +Your continuing support is very important - the funds will be used to develop and maintain Ajv once the next major version is released. + +Please sponsor Ajv via: +- [GitHub sponsors page](https://github.com/sponsors/epoberezkin) (GitHub will match it) +- [Ajv Open Collective️](https://opencollective.com/ajv) + +Thank you. + + +#### Open Collective sponsors + + + + + + + + + + + + + ## Using version 6 [JSON Schema draft-07](http://json-schema.org/latest/json-schema-validation.html) is published. -[Ajv version 6.0.0](https://github.com/epoberezkin/ajv/releases/tag/v6.0.0) that supports draft-07 is released. It may require either migrating your schemas or updating your code (to continue using draft-04 and v5 schemas, draft-06 schemas will be supported without changes). +[Ajv version 6.0.0](https://github.com/ajv-validator/ajv/releases/tag/v6.0.0) that supports draft-07 is released. It may require either migrating your schemas or updating your code (to continue using draft-04 and v5 schemas, draft-06 schemas will be supported without changes). __Please note__: To use Ajv with draft-06 schemas you need to explicitly add the meta-schema to the validator instance: @@ -40,8 +108,9 @@ ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-04.json')); - [Performance](#performance) - [Features](#features) - [Getting started](#getting-started) -- [Frequently Asked Questions](https://github.com/epoberezkin/ajv/blob/master/FAQ.md) +- [Frequently Asked Questions](https://github.com/ajv-validator/ajv/blob/master/FAQ.md) - [Using in browser](#using-in-browser) + - [Ajv and Content Security Policies (CSP)](#ajv-and-content-security-policies-csp) - [Command line interface](#command-line-interface) - Validation - [Keywords](#validation-keywords) @@ -53,6 +122,12 @@ ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-04.json')); - [Defining custom keywords](#defining-custom-keywords) - [Asynchronous schema compilation](#asynchronous-schema-compilation) - [Asynchronous validation](#asynchronous-validation) +- [Security considerations](#security-considerations) + - [Security contact](#security-contact) + - [Untrusted schemas](#untrusted-schemas) + - [Circular references in objects](#circular-references-in-javascript-objects) + - [Trusted schemas](#security-risks-of-trusted-schemas) + - [ReDoS attack](#redos-attack) - Modifying data during validation - [Filtering data](#filtering-data) - [Assigning defaults](#assigning-defaults) @@ -63,8 +138,9 @@ ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-04.json')); - [Validation errors](#validation-errors) - [Plugins](#plugins) - [Related packages](#related-packages) -- [Packages using Ajv](#some-packages-using-ajv) -- [Tests, Contributing, History, License](#tests) +- [Some packages using Ajv](#some-packages-using-ajv) +- [Tests, Contributing, Changes history](#tests) +- [Support, Code of conduct, License](#open-source-software-support) ## Performance @@ -87,29 +163,27 @@ Performance of different validators by [json-schema-benchmark](https://github.co ## Features - Ajv implements full JSON Schema [draft-06/07](http://json-schema.org/) and draft-04 standards: - - all validation keywords (see [JSON Schema validation keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md)) + - all validation keywords (see [JSON Schema validation keywords](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md)) - full support of remote refs (remote schemas have to be added with `addSchema` or compiled to be available) - support of circular references between schemas - correct string lengths for strings with unicode pairs (can be turned off) - [formats](#formats) defined by JSON Schema draft-07 standard and custom formats (can be turned off) - [validates schemas against meta-schema](#api-validateschema) -- supports [browsers](#using-in-browser) and Node.js 0.10-8.x +- supports [browsers](#using-in-browser) and Node.js 0.10-14.x - [asynchronous loading](#asynchronous-schema-compilation) of referenced schemas during compilation - "All errors" validation mode with [option allErrors](#options) - [error messages with parameters](#validation-errors) describing error reasons to allow creating custom error messages -- i18n error messages support with [ajv-i18n](https://github.com/epoberezkin/ajv-i18n) package +- i18n error messages support with [ajv-i18n](https://github.com/ajv-validator/ajv-i18n) package - [filtering data](#filtering-data) from additional properties - [assigning defaults](#assigning-defaults) to missing properties and items - [coercing data](#coercing-data-types) to the types specified in `type` keywords - [custom keywords](#defining-custom-keywords) - draft-06/07 keywords `const`, `contains`, `propertyNames` and `if/then/else` - draft-06 boolean schemas (`true`/`false` as a schema to always pass/fail). -- keywords `switch`, `patternRequired`, `formatMaximum` / `formatMinimum` and `formatExclusiveMaximum` / `formatExclusiveMinimum` from [JSON Schema extension proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) with [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) package +- keywords `switch`, `patternRequired`, `formatMaximum` / `formatMinimum` and `formatExclusiveMaximum` / `formatExclusiveMinimum` from [JSON Schema extension proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) with [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package - [$data reference](#data-reference) to use values from the validated data as values for the schema keywords - [asynchronous validation](#asynchronous-validation) of custom formats and keywords -Currently Ajv is the only validator that passes all the tests from [JSON Schema Test Suite](https://github.com/json-schema/JSON-Schema-Test-Suite) (according to [json-schema-benchmark](https://github.com/ebdrup/json-schema-benchmark), apart from the test that requires that `1.0` is not an integer that is impossible to satisfy in JavaScript). - ## Install @@ -126,7 +200,11 @@ Try it in the Node.js REPL: https://tonicdev.com/npm/ajv The fastest validation call: ```javascript +// Node.js require: var Ajv = require('ajv'); +// or ESM/TypeScript import +import Ajv from 'ajv'; + var ajv = new Ajv(); // options can be passed, e.g. {allErrors: true} var validate = ajv.compile(schema); var valid = validate(data); @@ -160,6 +238,10 @@ The best performance is achieved when using compiled functions returned by `comp __Please note__: every time a validation function or `ajv.validate` are called `errors` property is overwritten. You need to copy `errors` array reference to another variable if you want to use it later (e.g., in the callback). See [Validation errors](#validation-errors) +__Note for TypeScript users__: `ajv` provides its own TypeScript declarations +out of the box, so you don't need to install the deprecated `@types/ajv` +module. + ## Using in browser @@ -180,21 +262,31 @@ Ajv is tested with these browsers: [![Sauce Test Status](https://saucelabs.com/browser-matrix/epoberezkin.svg)](https://saucelabs.com/u/epoberezkin) -__Please note__: some frameworks, e.g. Dojo, may redefine global require in such way that is not compatible with CommonJS module format. In such case Ajv bundle has to be loaded before the framework and then you can use global Ajv (see issue [#234](https://github.com/epoberezkin/ajv/issues/234)). +__Please note__: some frameworks, e.g. Dojo, may redefine global require in such way that is not compatible with CommonJS module format. In such case Ajv bundle has to be loaded before the framework and then you can use global Ajv (see issue [#234](https://github.com/ajv-validator/ajv/issues/234)). + + +### Ajv and Content Security Policies (CSP) + +If you're using Ajv to compile a schema (the typical use) in a browser document that is loaded with a Content Security Policy (CSP), that policy will require a `script-src` directive that includes the value `'unsafe-eval'`. +:warning: NOTE, however, that `unsafe-eval` is NOT recommended in a secure CSP[[1]](https://developer.chrome.com/extensions/contentSecurityPolicy#relaxing-eval), as it has the potential to open the document to cross-site scripting (XSS) attacks. + +In order to make use of Ajv without easing your CSP, you can [pre-compile a schema using the CLI](https://github.com/ajv-validator/ajv-cli#compile-schemas). This will transpile the schema JSON into a JavaScript file that exports a `validate` function that works simlarly to a schema compiled at runtime. + +Note that pre-compilation of schemas is performed using [ajv-pack](https://github.com/ajv-validator/ajv-pack) and there are [some limitations to the schema features it can compile](https://github.com/ajv-validator/ajv-pack#limitations). A successfully pre-compiled schema is equivalent to the same schema compiled at runtime. ## Command line interface -CLI is available as a separate npm package [ajv-cli](https://github.com/jessedc/ajv-cli). It supports: +CLI is available as a separate npm package [ajv-cli](https://github.com/ajv-validator/ajv-cli). It supports: - compiling JSON Schemas to test their validity -- BETA: generating standalone module exporting a validation function to be used without Ajv (using [ajv-pack](https://github.com/epoberezkin/ajv-pack)) +- BETA: generating standalone module exporting a validation function to be used without Ajv (using [ajv-pack](https://github.com/ajv-validator/ajv-pack)) - migrate schemas to draft-07 (using [json-schema-migrate](https://github.com/epoberezkin/json-schema-migrate)) - validating data file(s) against JSON Schema - testing expected validity of data against JSON Schema - referenced schemas - custom meta-schemas -- files in JSON and JavaScript format +- files in JSON, JSON5, YAML, and JavaScript format - all Ajv options - reporting changes in data after validation in [JSON-patch](https://tools.ietf.org/html/rfc6902) format @@ -203,20 +295,20 @@ CLI is available as a separate npm package [ajv-cli](https://github.com/jessedc/ Ajv supports all validation keywords from draft-07 of JSON Schema standard: -- [type](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#type) -- [for numbers](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-numbers) - maximum, minimum, exclusiveMaximum, exclusiveMinimum, multipleOf -- [for strings](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-strings) - maxLength, minLength, pattern, format -- [for arrays](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-arrays) - maxItems, minItems, uniqueItems, items, additionalItems, [contains](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#contains) -- [for objects](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-objects) - maxProperties, minProperties, required, properties, patternProperties, additionalProperties, dependencies, [propertyNames](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#propertynames) -- [for all types](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#keywords-for-all-types) - enum, [const](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#const) -- [compound keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#compound-keywords) - not, oneOf, anyOf, allOf, [if/then/else](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#ifthenelse) +- [type](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#type) +- [for numbers](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#keywords-for-numbers) - maximum, minimum, exclusiveMaximum, exclusiveMinimum, multipleOf +- [for strings](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#keywords-for-strings) - maxLength, minLength, pattern, format +- [for arrays](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#keywords-for-arrays) - maxItems, minItems, uniqueItems, items, additionalItems, [contains](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#contains) +- [for objects](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#keywords-for-objects) - maxProperties, minProperties, required, properties, patternProperties, additionalProperties, dependencies, [propertyNames](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#propertynames) +- [for all types](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#keywords-for-all-types) - enum, [const](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#const) +- [compound keywords](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#compound-keywords) - not, oneOf, anyOf, allOf, [if/then/else](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#ifthenelse) -With [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) package Ajv also supports validation keywords from [JSON Schema extension proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) for JSON Schema standard: +With [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package Ajv also supports validation keywords from [JSON Schema extension proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) for JSON Schema standard: -- [patternRequired](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#patternrequired-proposed) - like `required` but with patterns that some property should match. -- [formatMaximum, formatMinimum, formatExclusiveMaximum, formatExclusiveMinimum](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#formatmaximum--formatminimum-and-exclusiveformatmaximum--exclusiveformatminimum-proposed) - setting limits for date, time, etc. +- [patternRequired](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#patternrequired-proposed) - like `required` but with patterns that some property should match. +- [formatMaximum, formatMinimum, formatExclusiveMaximum, formatExclusiveMinimum](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#formatmaximum--formatminimum-and-exclusiveformatmaximum--exclusiveformatminimum-proposed) - setting limits for date, time, etc. -See [JSON Schema validation keywords](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md) for more details. +See [JSON Schema validation keywords](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md) for more details. ## Annotation keywords @@ -226,7 +318,7 @@ JSON Schema specification defines several annotation keywords that describe sche - `title` and `description`: information about the data represented by that schema - `$comment` (NEW in draft-07): information for developers. With option `$comment` Ajv logs or passes the comment string to the user-supplied function. See [Options](#options). - `default`: a default value of the data instance, see [Assigning defaults](#assigning-defaults). -- `examples` (NEW in draft-07): an array of data instances. Ajv does not check the validity of these instances against the schema. +- `examples` (NEW in draft-06): an array of data instances. Ajv does not check the validity of these instances against the schema. - `readOnly` and `writeOnly` (NEW in draft-07): marks data-instance as read-only or write-only in relation to the source of the data (database, api, etc.). - `contentEncoding`: [RFC 2045](https://tools.ietf.org/html/rfc2045#section-6.1 ), e.g., "base64". - `contentMediaType`: [RFC 2046](https://tools.ietf.org/html/rfc2046), e.g., "image/png". @@ -236,7 +328,11 @@ __Please note__: Ajv does not implement validation of the keywords `examples`, ## Formats -The following formats are supported for string validation with "format" keyword: +Ajv implements formats defined by JSON Schema specification and several other formats. It is recommended NOT to use "format" keyword implementations with untrusted data, as they use potentially unsafe regular expressions - see [ReDoS attack](#redos-attack). + +__Please note__: if you need to use "format" keyword to validate untrusted data, you MUST assess their suitability and safety for your validation scenarios. + +The following formats are implemented for string validation with "format" keyword: - _date_: full-date according to [RFC3339](http://tools.ietf.org/html/rfc3339#section-5.6). - _time_: time with optional time-zone. @@ -256,13 +352,13 @@ The following formats are supported for string validation with "format" keyword: __Please note__: JSON Schema draft-07 also defines formats `iri`, `iri-reference`, `idn-hostname` and `idn-email` for URLs, hostnames and emails with international characters. Ajv does not implement these formats. If you create Ajv plugin that implements them please make a PR to mention this plugin here. -There are two modes of format validation: `fast` and `full`. This mode affects formats `date`, `time`, `date-time`, `uri`, `uri-reference`, `email`, and `hostname`. See [Options](#options) for details. +There are two modes of format validation: `fast` and `full`. This mode affects formats `date`, `time`, `date-time`, `uri`, `uri-reference`, and `email`. See [Options](#options) for details. You can add additional formats and replace any of the formats above using [addFormat](#api-addformat) method. -The option `unknownFormats` allows changing the default behaviour when an unknown format is encountered. In this case Ajv can either fail schema compilation (default) or ignore it (default in versions before 5.0.0). You also can whitelist specific format(s) to be ignored. See [Options](#options) for details. +The option `unknownFormats` allows changing the default behaviour when an unknown format is encountered. In this case Ajv can either fail schema compilation (default) or ignore it (default in versions before 5.0.0). You also can allow specific format(s) that will be ignored. See [Options](#options) for details. -You can find patterns used for format validation and the sources that were used in [formats.js](https://github.com/epoberezkin/ajv/blob/master/lib/compile/formats.js). +You can find regular expressions used for format validation and the sources that were used in [formats.js](https://github.com/ajv-validator/ajv/blob/master/lib/compile/formats.js). ## Combining schemas with $ref @@ -319,7 +415,7 @@ __Please note__: ## $data reference -With `$data` option you can use values from the validated data as the values for the schema keywords. See [proposal](https://github.com/json-schema/json-schema/wiki/$data-(v5-proposal)) for more information about how it works. +With `$data` option you can use values from the validated data as the values for the schema keywords. See [proposal](https://github.com/json-schema-org/json-schema-spec/issues/51) for more information about how it works. `$data` reference is supported in the keywords: const, enum, format, maximum/minimum, exclusiveMaximum / exclusiveMinimum, maxLength / minLength, maxItems / minItems, maxProperties / minProperties, formatMaximum / formatMinimum, formatExclusiveMaximum / formatExclusiveMinimum, multipleOf, pattern, required, uniqueItems. @@ -371,7 +467,7 @@ var validData = { ## $merge and $patch keywords -With the package [ajv-merge-patch](https://github.com/epoberezkin/ajv-merge-patch) you can use the keywords `$merge` and `$patch` that allow extending JSON Schemas with patches using formats [JSON Merge Patch (RFC 7396)](https://tools.ietf.org/html/rfc7396) and [JSON Patch (RFC 6902)](https://tools.ietf.org/html/rfc6902). +With the package [ajv-merge-patch](https://github.com/ajv-validator/ajv-merge-patch) you can use the keywords `$merge` and `$patch` that allow extending JSON Schemas with patches using formats [JSON Merge Patch (RFC 7396)](https://tools.ietf.org/html/rfc7396) and [JSON Patch (RFC 6902)](https://tools.ietf.org/html/rfc6902). To add keywords `$merge` and `$patch` to Ajv instance use this code: @@ -430,7 +526,7 @@ The schemas above are equivalent to this schema: The properties `source` and `with` in the keywords `$merge` and `$patch` can use absolute or relative `$ref` to point to other schemas previously added to the Ajv instance or to the fragments of the current schema. -See the package [ajv-merge-patch](https://github.com/epoberezkin/ajv-merge-patch) for more information. +See the package [ajv-merge-patch](https://github.com/ajv-validator/ajv-merge-patch) for more information. ## Defining custom keywords @@ -478,9 +574,9 @@ console.log(validate(2)); // false console.log(validate(4)); // false ``` -Several custom keywords (typeof, instanceof, range and propertyNames) are defined in [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) package - they can be used for your schemas and as a starting point for your own custom keywords. +Several custom keywords (typeof, instanceof, range and propertyNames) are defined in [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package - they can be used for your schemas and as a starting point for your own custom keywords. -See [Defining custom keywords](https://github.com/epoberezkin/ajv/blob/master/CUSTOM.md) for more details. +See [Defining custom keywords](https://github.com/ajv-validator/ajv/blob/master/CUSTOM.md) for more details. ## Asynchronous schema compilation @@ -579,7 +675,7 @@ validate({ userId: 1, postId: 19 }) ### Using transpilers with asynchronous validation functions. -[ajv-async](https://github.com/epoberezkin/ajv-async) uses [nodent](https://github.com/MatAtBread/nodent) to transpile async functions. To use another transpiler you should separately install it (or load its bundle in the browser). +[ajv-async](https://github.com/ajv-validator/ajv-async) uses [nodent](https://github.com/MatAtBread/nodent) to transpile async functions. To use another transpiler you should separately install it (or load its bundle in the browser). #### Using nodent @@ -605,6 +701,84 @@ validate(data).then(successFunc).catch(errorFunc); See [Options](#options). +## Security considerations + +JSON Schema, if properly used, can replace data sanitisation. It doesn't replace other API security considerations. It also introduces additional security aspects to consider. + + +##### Security contact + +To report a security vulnerability, please use the +[Tidelift security contact](https://tidelift.com/security). +Tidelift will coordinate the fix and disclosure. Please do NOT report security vulnerabilities via GitHub issues. + + +##### Untrusted schemas + +Ajv treats JSON schemas as trusted as your application code. This security model is based on the most common use case, when the schemas are static and bundled together with the application. + +If your schemas are received from untrusted sources (or generated from untrusted data) there are several scenarios you need to prevent: +- compiling schemas can cause stack overflow (if they are too deep) +- compiling schemas can be slow (e.g. [#557](https://github.com/ajv-validator/ajv/issues/557)) +- validating certain data can be slow + +It is difficult to predict all the scenarios, but at the very least it may help to limit the size of untrusted schemas (e.g. limit JSON string length) and also the maximum schema object depth (that can be high for relatively small JSON strings). You also may want to mitigate slow regular expressions in `pattern` and `patternProperties` keywords. + +Regardless the measures you take, using untrusted schemas increases security risks. + + +##### Circular references in JavaScript objects + +Ajv does not support schemas and validated data that have circular references in objects. See [issue #802](https://github.com/ajv-validator/ajv/issues/802). + +An attempt to compile such schemas or validate such data would cause stack overflow (or will not complete in case of asynchronous validation). Depending on the parser you use, untrusted data can lead to circular references. + + +##### Security risks of trusted schemas + +Some keywords in JSON Schemas can lead to very slow validation for certain data. These keywords include (but may be not limited to): + +- `pattern` and `format` for large strings - in some cases using `maxLength` can help mitigate it, but certain regular expressions can lead to exponential validation time even with relatively short strings (see [ReDoS attack](#redos-attack)). +- `patternProperties` for large property names - use `propertyNames` to mitigate, but some regular expressions can have exponential evaluation time as well. +- `uniqueItems` for large non-scalar arrays - use `maxItems` to mitigate + +__Please note__: The suggestions above to prevent slow validation would only work if you do NOT use `allErrors: true` in production code (using it would continue validation after validation errors). + +You can validate your JSON schemas against [this meta-schema](https://github.com/ajv-validator/ajv/blob/master/lib/refs/json-schema-secure.json) to check that these recommendations are followed: + +```javascript +const isSchemaSecure = ajv.compile(require('ajv/lib/refs/json-schema-secure.json')); + +const schema1 = {format: 'email'}; +isSchemaSecure(schema1); // false + +const schema2 = {format: 'email', maxLength: MAX_LENGTH}; +isSchemaSecure(schema2); // true +``` + +__Please note__: following all these recommendation is not a guarantee that validation of untrusted data is safe - it can still lead to some undesirable results. + + +##### Content Security Policies (CSP) +See [Ajv and Content Security Policies (CSP)](#ajv-and-content-security-policies-csp) + + +## ReDoS attack + +Certain regular expressions can lead to the exponential evaluation time even with relatively short strings. + +Please assess the regular expressions you use in the schemas on their vulnerability to this attack - see [safe-regex](https://github.com/substack/safe-regex), for example. + +__Please note__: some formats that Ajv implements use [regular expressions](https://github.com/ajv-validator/ajv/blob/master/lib/compile/formats.js) that can be vulnerable to ReDoS attack, so if you use Ajv to validate data from untrusted sources __it is strongly recommended__ to consider the following: + +- making assessment of "format" implementations in Ajv. +- using `format: 'fast'` option that simplifies some of the regular expressions (although it does not guarantee that they are safe). +- replacing format implementations provided by Ajv with your own implementations of "format" keyword that either uses different regular expressions or another approach to format validation. Please see [addFormat](#api-addformat) method. +- disabling format validation by ignoring "format" keyword with option `format: false` + +Whatever mitigation you choose, please assume all formats provided by Ajv as potentially unsafe and make your own assessment of their suitability for your validation scenarios. + + ## Filtering data With [option `removeAdditional`](#options) (added by [andyscott](https://github.com/andyscott)) you can filter data during the validation. @@ -675,7 +849,7 @@ The intention of the schema above is to allow objects with either the string pro With the option `removeAdditional: true` the validation will pass for the object `{ "foo": "abc"}` but will fail for the object `{"bar": 1}`. It happens because while the first subschema in `oneOf` is validated, the property `bar` is removed because it is an additional property according to the standard (because it is not included in `properties` keyword in the same schema). -While this behaviour is unexpected (issues [#129](https://github.com/epoberezkin/ajv/issues/129), [#134](https://github.com/epoberezkin/ajv/issues/134)), it is correct. To have the expected behaviour (both objects are allowed and additional properties are removed) the schema has to be refactored in this way: +While this behaviour is unexpected (issues [#129](https://github.com/ajv-validator/ajv/issues/129), [#134](https://github.com/ajv-validator/ajv/issues/134)), it is correct. To have the expected behaviour (both objects are allowed and additional properties are removed) the schema has to be refactored in this way: ```json { @@ -699,13 +873,11 @@ The schema above is also more efficient - it will compile into a faster function With [option `useDefaults`](#options) Ajv will assign values from `default` keyword in the schemas of `properties` and `items` (when it is the array of schemas) to the missing properties and items. -This option modifies original data. - -__Please note__: by default the default value is inserted in the generated validation code as a literal (starting from v4.0), so the value inserted in the data will be the deep clone of the default in the schema. +With the option value `"empty"` properties and items equal to `null` or `""` (empty string) will be considered missing and assigned defaults. -If you need to insert the default value in the data by reference pass the option `useDefaults: "shared"`. +This option modifies original data. -Inserting defaults by reference can be faster (in case you have an object in `default`) and it allows to have dynamic values in defaults, e.g. timestamp, without recompiling the schema. The side effect is that modifying the default value in any validated data instance will change the default in the schema and in other validated data instances. See example 3 below. +__Please note__: the default value is inserted in the generated validation code as a literal, so the value inserted in the data will be the deep clone of the default in the schema. Example 1 (`default` in `properties`): @@ -748,39 +920,15 @@ console.log(validate(data)); // true console.log(data); // [ 1, "foo" ] ``` -Example 3 (inserting "defaults" by reference): - -```javascript -var ajv = new Ajv({ useDefaults: 'shared' }); - -var schema = { - properties: { - foo: { - default: { bar: 1 } - } - } -} - -var validate = ajv.compile(schema); - -var data = {}; -console.log(validate(data)); // true -console.log(data); // { foo: { bar: 1 } } - -data.foo.bar = 2; - -var data2 = {}; -console.log(validate(data2)); // true -console.log(data2); // { foo: { bar: 2 } } -``` - `default` keywords in other cases are ignored: - not in `properties` or `items` subschemas -- in schemas inside `anyOf`, `oneOf` and `not` (see [#42](https://github.com/epoberezkin/ajv/issues/42)) +- in schemas inside `anyOf`, `oneOf` and `not` (see [#42](https://github.com/ajv-validator/ajv/issues/42)) - in `if` subschema of `switch` keyword - in schemas generated by custom macro keywords +The [`strictDefaults` option](#options) customizes Ajv's behavior for the defaults that Ajv ignores (`true` raises an error, and `"log"` outputs a warning). + ## Coercing data types @@ -833,7 +981,7 @@ console.log(data); // { "foo": [1], "bar": false } The coercion rules, as you can see from the example, are different from JavaScript both to validate user input as expected and to have the coercion reversible (to correctly validate cases where different types are defined in subschemas of "anyOf" and other compound keywords). -See [Coercion rules](https://github.com/epoberezkin/ajv/blob/master/COERCION.md) for details. +See [Coercion rules](https://github.com/ajv-validator/ajv/blob/master/COERCION.md) for details. ## API @@ -951,9 +1099,9 @@ Function should return validation result as `true` or `false`. If object is passed it should have properties `validate`, `compare` and `async`: - _validate_: a string, RegExp or a function as described above. -- _compare_: an optional comparison function that accepts two strings and compares them according to the format meaning. This function is used with keywords `formatMaximum`/`formatMinimum` (defined in [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) package). It should return `1` if the first value is bigger than the second value, `-1` if it is smaller and `0` if it is equal. +- _compare_: an optional comparison function that accepts two strings and compares them according to the format meaning. This function is used with keywords `formatMaximum`/`formatMinimum` (defined in [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package). It should return `1` if the first value is bigger than the second value, `-1` if it is smaller and `0` if it is equal. - _async_: an optional `true` value if `validate` is an asynchronous function; in this case it should return a promise that resolves with a value `true` or `false`. -- _type_: an optional type of data that the format applies to. It can be `"string"` (default) or `"number"` (see https://github.com/epoberezkin/ajv/issues/291#issuecomment-259923858). If the type of data is different, the validation will pass. +- _type_: an optional type of data that the format applies to. It can be `"string"` (default) or `"number"` (see https://github.com/ajv-validator/ajv/issues/291#issuecomment-259923858). If the type of data is different, the validation will pass. Custom formats can be also added via `formats` option. @@ -981,11 +1129,13 @@ Keyword definition is an object with the following properties: - _inline_: compiling function that returns code (as string) - _schema_: an optional `false` value used with "validate" keyword to not pass schema - _metaSchema_: an optional meta-schema for keyword schema +- _dependencies_: an optional list of properties that must be present in the parent schema - it will be checked during schema compilation - _modifying_: `true` MUST be passed if keyword modifies data +- _statements_: `true` can be passed in case inline keyword generates statements (as opposed to expression) - _valid_: pass `true`/`false` to pre-define validation result, the result returned from validation function will be ignored. This option cannot be used with macro keywords. - _$data_: an optional `true` value to support [$data reference](#data-reference) as the value of custom keyword. The reference will be resolved at validation time. If the keyword has meta-schema it would be extended to allow $data and it will be used to validate the resolved value. Supporting $data reference requires that keyword has validating function (as the only option or in addition to compile, macro or inline function). - _async_: an optional `true` value if the validation function is asynchronous (whether it is compiled or passed in _validate_ property); in this case it should return a promise that resolves with a value `true` or `false`. This option is ignored in case of "macro" and "inline" keywords. -- _errors_: an optional boolean indicating whether keyword returns errors. If this property is not set Ajv will determine if the errors were set in case of failed validation. +- _errors_: an optional boolean or string `"full"` indicating whether keyword returns errors. If this property is not set Ajv will determine if the errors were set in case of failed validation. _compile_, _macro_ and _inline_ are mutually exclusive, only one should be used at a time. _validate_ can be used separately or in addition to them to support $data reference. @@ -1044,6 +1194,10 @@ Defaults: removeAdditional: false, useDefaults: false, coerceTypes: false, + // strict mode options + strictDefaults: false, + strictKeywords: false, + strictNumbers: false, // asynchronous validation options: transpile: undefined, // requires ajv-async package // advanced options: @@ -1058,7 +1212,7 @@ Defaults: errorDataPath: 'object', // deprecated messages: true, sourceCode: false, - processCode: undefined, // function (str: string): string {} + processCode: undefined, // function (str: string, schema: object): string {} cache: new Cache, serialize: undefined } @@ -1077,14 +1231,18 @@ Defaults: - _uniqueItems_: validate `uniqueItems` keyword (true by default). - _unicode_: calculate correct length of strings with unicode pairs (true by default). Pass `false` to use `.length` of strings that is faster, but gives "incorrect" lengths of strings with unicode pairs - each unicode pair is counted as two characters. - _nullable_: support keyword "nullable" from [Open API 3 specification](https://swagger.io/docs/specification/data-models/data-types/). -- _format_: formats validation mode ('fast' by default). Pass 'full' for more correct and slow validation or `false` not to validate formats at all. E.g., 25:00:00 and 2015/14/33 will be invalid time and date in 'full' mode but it will be valid in 'fast' mode. +- _format_: formats validation mode. Option values: + - `"fast"` (default) - simplified and fast validation (see [Formats](#formats) for details of which formats are available and affected by this option). + - `"full"` - more restrictive and slow validation. E.g., 25:00:00 and 2015/14/33 will be invalid time and date in 'full' mode but it will be valid in 'fast' mode. + - `false` - ignore all format keywords. - _formats_: an object with custom formats. Keys and values will be passed to `addFormat` method. +- _keywords_: an object with custom keywords. Keys and values will be passed to `addKeyword` method. - _unknownFormats_: handling of unknown formats. Option values: - `true` (default) - if an unknown format is encountered the exception is thrown during schema compilation. If `format` keyword value is [$data reference](#data-reference) and it is unknown the validation will fail. - `[String]` - an array of unknown format names that will be ignored. This option can be used to allow usage of third party schemas with format(s) for which you don't have definitions, but still fail if another unknown format is used. If `format` keyword value is [$data reference](#data-reference) and it is not in this array the validation will fail. - `"ignore"` - to log warning during schema compilation and always pass validation (the default behaviour in versions before 5.0.0). This option is not recommended, as it allows to mistype format name and it won't be validated without any error message. This behaviour is required by JSON Schema specification. - _schemas_: an array or object of schemas that will be added to the instance. In case you pass the array the schemas must have IDs in them. When the object is passed the method `addSchema(value, key)` will be called for each schema in this object. -- _logger_: sets the logging method. Default is the global `console` object that should have methods `log`, `warn` and `error`. Option values: +- _logger_: sets the logging method. Default is the global `console` object that should have methods `log`, `warn` and `error`. See [Error logging](#error-logging). Option values: - custom logger - it should have methods `log`, `warn` and `error`. If any of these methods is missing an exception will be thrown. - `false` - logging is disabled. @@ -1113,19 +1271,34 @@ Defaults: - `"all"` - all additional properties are removed, regardless of `additionalProperties` keyword in schema (and no validation is made for them). - `true` - only additional properties with `additionalProperties` keyword equal to `false` are removed. - `"failing"` - additional properties that fail schema validation will be removed (where `additionalProperties` keyword is `false` or schema). -- _useDefaults_: replace missing properties and items with the values from corresponding `default` keywords. Default behaviour is to ignore `default` keywords. This option is not used if schema is added with `addMetaSchema` method. See examples in [Assigning defaults](#assigning-defaults). Option values: +- _useDefaults_: replace missing or undefined properties and items with the values from corresponding `default` keywords. Default behaviour is to ignore `default` keywords. This option is not used if schema is added with `addMetaSchema` method. See examples in [Assigning defaults](#assigning-defaults). Option values: - `false` (default) - do not use defaults - - `true` - insert defaults by value (safer and slower, object literal is used). - - `"shared"` - insert defaults by reference (faster). If the default is an object, it will be shared by all instances of validated data. If you modify the inserted default in the validated data, it will be modified in the schema as well. -- _coerceTypes_: change data type of data to match `type` keyword. See the example in [Coercing data types](#coercing-data-types) and [coercion rules](https://github.com/epoberezkin/ajv/blob/master/COERCION.md). Option values: + - `true` - insert defaults by value (object literal is used). + - `"empty"` - in addition to missing or undefined, use defaults for properties and items that are equal to `null` or `""` (an empty string). + - `"shared"` (deprecated) - insert defaults by reference. If the default is an object, it will be shared by all instances of validated data. If you modify the inserted default in the validated data, it will be modified in the schema as well. +- _coerceTypes_: change data type of data to match `type` keyword. See the example in [Coercing data types](#coercing-data-types) and [coercion rules](https://github.com/ajv-validator/ajv/blob/master/COERCION.md). Option values: - `false` (default) - no type coercion. - `true` - coerce scalar data types. - `"array"` - in addition to coercions between scalar types, coerce scalar data to an array with one element and vice versa (as required by the schema). +##### Strict mode options + +- _strictDefaults_: report ignored `default` keywords in schemas. Option values: + - `false` (default) - ignored defaults are not reported + - `true` - if an ignored default is present, throw an error + - `"log"` - if an ignored default is present, log warning +- _strictKeywords_: report unknown keywords in schemas. Option values: + - `false` (default) - unknown keywords are not reported + - `true` - if an unknown keyword is present, throw an error + - `"log"` - if an unknown keyword is present, log warning +- _strictNumbers_: validate numbers strictly, failing validation for NaN and Infinity. Option values: + - `false` (default) - NaN or Infinity will pass validation for numeric types + - `true` - NaN or Infinity will not pass validation for numeric types + ##### Asynchronous validation options -- _transpile_: Requires [ajv-async](https://github.com/epoberezkin/ajv-async) package. It determines whether Ajv transpiles compiled asynchronous validation function. Option values: +- _transpile_: Requires [ajv-async](https://github.com/ajv-validator/ajv-async) package. It determines whether Ajv transpiles compiled asynchronous validation function. Option values: - `undefined` (default) - transpile with [nodent](https://github.com/MatAtBread/nodent) if async functions are not supported. - `true` - always transpile with nodent. - `false` - do not transpile; if async functions are not supported an exception will be thrown. @@ -1146,13 +1319,13 @@ Defaults: - _passContext_: pass validation context to custom keyword functions. If this option is `true` and you pass some context to the compiled validation function with `validate.call(context, data)`, the `context` will be available as `this` in your custom keywords. By default `this` is Ajv instance. - _loopRequired_: by default `required` keyword is compiled into a single expression (or a sequence of statements in `allErrors` mode). In case of a very large number of properties in this keyword it may result in a very big validation function. Pass integer to set the number of properties above which `required` keyword will be validated in a loop - smaller validation function size but also worse performance. - _ownProperties_: by default Ajv iterates over all enumerable object properties; when this option is `true` only own enumerable object properties (i.e. found directly on the object rather than on its prototype) are iterated. Contributed by @mbroadst. -- _multipleOfPrecision_: by default `multipleOf` keyword is validated by comparing the result of division with parseInt() of that result. It works for dividers that are bigger than 1. For small dividers such as 0.01 the result of the division is usually not integer (even when it should be integer, see issue [#84](https://github.com/epoberezkin/ajv/issues/84)). If you need to use fractional dividers set this option to some positive integer N to have `multipleOf` validated using this formula: `Math.abs(Math.round(division) - division) < 1e-N` (it is slower but allows for float arithmetics deviations). +- _multipleOfPrecision_: by default `multipleOf` keyword is validated by comparing the result of division with parseInt() of that result. It works for dividers that are bigger than 1. For small dividers such as 0.01 the result of the division is usually not integer (even when it should be integer, see issue [#84](https://github.com/ajv-validator/ajv/issues/84)). If you need to use fractional dividers set this option to some positive integer N to have `multipleOf` validated using this formula: `Math.abs(Math.round(division) - division) < 1e-N` (it is slower but allows for float arithmetics deviations). - _errorDataPath_ (deprecated): set `dataPath` to point to 'object' (default) or to 'property' when validating keywords `required`, `additionalProperties` and `dependencies`. -- _messages_: Include human-readable messages in errors. `true` by default. `false` can be passed when custom messages are used (e.g. with [ajv-i18n](https://github.com/epoberezkin/ajv-i18n)). +- _messages_: Include human-readable messages in errors. `true` by default. `false` can be passed when custom messages are used (e.g. with [ajv-i18n](https://github.com/ajv-validator/ajv-i18n)). - _sourceCode_: add `sourceCode` property to validating function (for debugging; this code can be different from the result of toString call). - _processCode_: an optional function to process generated code before it is passed to Function constructor. It can be used to either beautify (the validating function is generated without line-breaks) or to transpile code. Starting from version 5.0.0 this option replaced options: - - `beautify` that formatted the generated function using [js-beautify](https://github.com/beautify-web/js-beautify). If you want to beautify the generated code pass `require('js-beautify').js_beautify`. - - `transpile` that transpiled asynchronous validation function. You can still use `transpile` option with [ajv-async](https://github.com/epoberezkin/ajv-async) package. See [Asynchronous validation](#asynchronous-validation) for more information. + - `beautify` that formatted the generated function using [js-beautify](https://github.com/beautify-web/js-beautify). If you want to beautify the generated code pass a function calling `require('js-beautify').js_beautify` as `processCode: code => js_beautify(code)`. + - `transpile` that transpiled asynchronous validation function. You can still use `transpile` option with [ajv-async](https://github.com/ajv-validator/ajv-async) package. See [Asynchronous validation](#asynchronous-validation) for more information. - _cache_: an optional instance of cache to store compiled schemas using stable-stringified schema as a key. For example, set-associative cache [sacjs](https://github.com/epoberezkin/sacjs) can be used. If not passed then a simple hash is used which is good enough for the common use case (a limited number of statically defined schemas). Cache should have methods `put(key, value)`, `get(key)`, `del(key)` and `clear()`. - _serialize_: an optional function to serialize schema to cache key. Pass `false` to use schema itself as a key (e.g., if WeakMap used as a cache). By default [fast-json-stable-stringify](https://github.com/epoberezkin/fast-json-stable-stringify) is used. @@ -1169,7 +1342,7 @@ Each error is an object with the following properties: - _keyword_: validation keyword. - _dataPath_: the path to the part of the data that was validated. By default `dataPath` uses JavaScript property access notation (e.g., `".prop[1].subProp"`). When the option `jsonPointers` is true (see [Options](#options)) `dataPath` will be set using JSON pointer standard (e.g., `"/prop/1/subProp"`). - _schemaPath_: the path (JSON-pointer as a URI fragment) to the schema of the keyword that failed validation. -- _params_: the object with the additional information about error that can be used to create custom error messages (e.g., using [ajv-i18n](https://github.com/epoberezkin/ajv-i18n) package). See below for parameters set by all keywords. +- _params_: the object with the additional information about error that can be used to create custom error messages (e.g., using [ajv-i18n](https://github.com/ajv-validator/ajv-i18n) package). See below for parameters set by all keywords. - _message_: the standard error message (can be excluded with option `messages` set to false). - _schema_: the schema of the keyword (added with `verbose` option). - _parentSchema_: the schema containing the keyword (added with `verbose` option) @@ -1209,6 +1382,28 @@ Properties of `params` object in errors depend on the keyword that failed valida - custom keywords (in case keyword definition doesn't create errors) - property `keyword` (the keyword name). +### Error logging + +Using the `logger` option when initiallizing Ajv will allow you to define custom logging. Here you can build upon the exisiting logging. The use of other logging packages is supported as long as the package or its associated wrapper exposes the required methods. If any of the required methods are missing an exception will be thrown. +- **Required Methods**: `log`, `warn`, `error` + +```javascript +var otherLogger = new OtherLogger(); +var ajv = new Ajv({ + logger: { + log: console.log.bind(console), + warn: function warn() { + otherLogger.logWarn.apply(otherLogger, arguments); + }, + error: function error() { + otherLogger.logError.apply(otherLogger, arguments); + console.error.apply(console, arguments); + } + } +}); +``` + + ## Plugins Ajv can be extended with plugins that add custom keywords, formats or functions to process generated code. When such plugin is published as npm package it is recommended that it follows these conventions: @@ -1222,16 +1417,16 @@ If you have published a useful plugin please submit a PR to add it to the next s ## Related packages -- [ajv-async](https://github.com/epoberezkin/ajv-async) - plugin to configure async validation mode +- [ajv-async](https://github.com/ajv-validator/ajv-async) - plugin to configure async validation mode - [ajv-bsontype](https://github.com/BoLaMN/ajv-bsontype) - plugin to validate mongodb's bsonType formats - [ajv-cli](https://github.com/jessedc/ajv-cli) - command line interface -- [ajv-errors](https://github.com/epoberezkin/ajv-errors) - plugin for custom error messages -- [ajv-i18n](https://github.com/epoberezkin/ajv-i18n) - internationalised error messages -- [ajv-istanbul](https://github.com/epoberezkin/ajv-istanbul) - plugin to instrument generated validation code to measure test coverage of your schemas -- [ajv-keywords](https://github.com/epoberezkin/ajv-keywords) - plugin with custom validation keywords (if/then/else, select, typeof, etc.) -- [ajv-merge-patch](https://github.com/epoberezkin/ajv-merge-patch) - plugin with keywords $merge and $patch -- [ajv-pack](https://github.com/epoberezkin/ajv-pack) - produces a compact module exporting validation functions - +- [ajv-errors](https://github.com/ajv-validator/ajv-errors) - plugin for custom error messages +- [ajv-i18n](https://github.com/ajv-validator/ajv-i18n) - internationalised error messages +- [ajv-istanbul](https://github.com/ajv-validator/ajv-istanbul) - plugin to instrument generated validation code to measure test coverage of your schemas +- [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) - plugin with custom validation keywords (select, typeof, etc.) +- [ajv-merge-patch](https://github.com/ajv-validator/ajv-merge-patch) - plugin with keywords $merge and $patch +- [ajv-pack](https://github.com/ajv-validator/ajv-pack) - produces a compact module exporting validation functions +- [ajv-formats-draft2019](https://github.com/luzlab/ajv-formats-draft2019) - format validators for draft2019 that aren't already included in ajv (ie. `idn-hostname`, `idn-email`, `iri`, `iri-reference` and `duration`). ## Some packages using Ajv @@ -1268,30 +1463,35 @@ npm test ## Contributing -All validation functions are generated using doT templates in [dot](https://github.com/epoberezkin/ajv/tree/master/lib/dot) folder. Templates are precompiled so doT is not a run-time dependency. +All validation functions are generated using doT templates in [dot](https://github.com/ajv-validator/ajv/tree/master/lib/dot) folder. Templates are precompiled so doT is not a run-time dependency. -`npm run build` - compiles templates to [dotjs](https://github.com/epoberezkin/ajv/tree/master/lib/dotjs) folder. +`npm run build` - compiles templates to [dotjs](https://github.com/ajv-validator/ajv/tree/master/lib/dotjs) folder. `npm run watch` - automatically compiles templates when files in dot folder change -Please see [Contributing guidelines](https://github.com/epoberezkin/ajv/blob/master/CONTRIBUTING.md) +Please see [Contributing guidelines](https://github.com/ajv-validator/ajv/blob/master/CONTRIBUTING.md) ## Changes history -See https://github.com/epoberezkin/ajv/releases +See https://github.com/ajv-validator/ajv/releases + +__Please note__: [Changes in version 7.0.0-beta](https://github.com/ajv-validator/ajv/releases/tag/v7.0.0-beta.0) + +[Version 6.0.0](https://github.com/ajv-validator/ajv/releases/tag/v6.0.0). + +## Code of conduct -__Please note__: [Changes in version 6.0.0](https://github.com/epoberezkin/ajv/releases/tag/v6.0.0). +Please review and follow the [Code of conduct](https://github.com/ajv-validator/ajv/blob/master/CODE_OF_CONDUCT.md). -[Version 5.0.0](https://github.com/epoberezkin/ajv/releases/tag/5.0.0). +Please report any unacceptable behaviour to ajv.validator@gmail.com - it will be reviewed by the project team. -[Version 4.0.0](https://github.com/epoberezkin/ajv/releases/tag/4.0.0). -[Version 3.0.0](https://github.com/epoberezkin/ajv/releases/tag/3.0.0). +## Open-source software support -[Version 2.0.0](https://github.com/epoberezkin/ajv/releases/tag/2.0.0). +Ajv is a part of [Tidelift subscription](https://tidelift.com/subscription/pkg/npm-ajv?utm_source=npm-ajv&utm_medium=referral&utm_campaign=readme) - it provides a centralised support to open-source software users, in addition to the support provided by software maintainers. ## License -[MIT](https://github.com/epoberezkin/ajv/blob/master/LICENSE) +[MIT](https://github.com/ajv-validator/ajv/blob/master/LICENSE) diff --git a/bower.json b/bower.json index 048c089b6..507989c62 100644 --- a/bower.json +++ b/bower.json @@ -11,7 +11,7 @@ "schema", "validator" ], - "homepage": "https://github.com/epoberezkin/ajv", + "homepage": "https://github.com/ajv-validator/ajv", "moduleType": [ "amd", "globals", diff --git a/lib/ajv.d.ts b/lib/ajv.d.ts index 763a09be6..078364d8c 100644 --- a/lib/ajv.d.ts +++ b/lib/ajv.d.ts @@ -1,12 +1,36 @@ declare var ajv: { (options?: ajv.Options): ajv.Ajv; - new (options?: ajv.Options): ajv.Ajv; - ValidationError: ValidationError; - MissingRefError: MissingRefError; + new(options?: ajv.Options): ajv.Ajv; + ValidationError: typeof AjvErrors.ValidationError; + MissingRefError: typeof AjvErrors.MissingRefError; $dataMetaSchema: object; } +declare namespace AjvErrors { + class ValidationError extends Error { + constructor(errors: Array); + + message: string; + errors: Array; + ajv: true; + validation: true; + } + + class MissingRefError extends Error { + constructor(baseId: string, ref: string, message?: string); + static message: (baseId: string, ref: string) => string; + + message: string; + missingRef: string; + missingSchema: string; + } +} + declare namespace ajv { + type ValidationError = AjvErrors.ValidationError; + + type MissingRefError = AjvErrors.MissingRefError; + interface Ajv { /** * Validate data using schema @@ -56,9 +80,9 @@ declare namespace ajv { /** * Get compiled schema from the instance by `key` or `ref`. * @param {string} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id). - * @return {Function} schema validating function (with property `schema`). + * @return {Function} schema validating function (with property `schema`). Returns undefined if keyRef can't be resolved to an existing schema. */ - getSchema(keyRef: string): ValidateFunction; + getSchema(keyRef: string): ValidateFunction | undefined; /** * Remove cached schema(s). * If no parameter is passed all schemas but meta-schemas are removed. @@ -98,6 +122,14 @@ declare namespace ajv { */ removeKeyword(keyword: string): Ajv; /** + * Validate keyword + * @this Ajv + * @param {object} definition keyword definition object + * @param {boolean} throwError true to throw exception if definition is invalid + * @return {boolean} validation result + */ + validateKeyword(definition: KeywordDefinition, throwError: boolean): boolean; + /** * Convert array of error message objects to string * @param {Array} errors optional array of validation errors, if not passed errors from the instance are used. * @param {object} options optional options with properties `separator` and `dataVar`. @@ -105,6 +137,7 @@ declare namespace ajv { */ errorsText(errors?: Array | null, options?: ErrorsTextOptions): string; errors?: Array | null; + _opts: Options; } interface CustomLogger { @@ -137,8 +170,9 @@ declare namespace ajv { jsonPointers?: boolean; uniqueItems?: boolean; unicode?: boolean; - format?: string; + format?: false | string; formats?: object; + keywords?: object; unknownFormats?: true | string[] | 'ignore'; schemas?: Array | object; schemaId?: '$id' | 'id' | 'auto'; @@ -146,8 +180,11 @@ declare namespace ajv { extendRefs?: true | 'ignore' | 'fail'; loadSchema?: (uri: string, cb?: (err: Error, schema: object) => void) => PromiseLike; removeAdditional?: boolean | 'all' | 'failing'; - useDefaults?: boolean | 'shared'; + useDefaults?: boolean | 'empty' | 'shared'; coerceTypes?: boolean | 'array'; + strictDefaults?: boolean | 'log'; + strictKeywords?: boolean | 'log'; + strictNumbers?: boolean; async?: boolean | string; transpile?: string | ((code: string) => string); meta?: boolean | object; @@ -161,7 +198,7 @@ declare namespace ajv { errorDataPath?: string, messages?: boolean; sourceCode?: boolean; - processCode?: (code: string) => string; + processCode?: (code: string, schema: object) => string; cache?: object; logger?: CustomLogger | false; nullable?: boolean; @@ -195,6 +232,8 @@ declare namespace ajv { metaSchema?: object; // schema: false makes validate not to expect schema (ValidateFunction) schema?: boolean; + statements?: boolean; + dependencies?: Array; modifying?: boolean; valid?: boolean; // one and only one of the following properties should be present @@ -207,6 +246,7 @@ declare namespace ajv { interface CompilationContext { level: number; dataLevel: number; + dataPathArr: string[]; schema: any; schemaPath: string; baseId: string; @@ -215,6 +255,9 @@ declare namespace ajv { formats: { [index: string]: FormatDefinition | undefined; }; + keywords: { + [index: string]: KeywordDefinition | undefined; + }; compositeRule: boolean; validate: (schema: object) => boolean; util: { @@ -268,11 +311,11 @@ declare namespace ajv { } type ErrorParameters = RefParams | LimitParams | AdditionalPropertiesParams | - DependenciesParams | FormatParams | ComparisonParams | - MultipleOfParams | PatternParams | RequiredParams | - TypeParams | UniqueItemsParams | CustomParams | - PatternRequiredParams | PropertyNamesParams | - IfParams | SwitchParams | NoParams | EnumParams; + DependenciesParams | FormatParams | ComparisonParams | + MultipleOfParams | PatternParams | RequiredParams | + TypeParams | UniqueItemsParams | CustomParams | + PatternRequiredParams | PropertyNamesParams | + IfParams | SwitchParams | NoParams | EnumParams; interface RefParams { ref: string; @@ -344,29 +387,11 @@ declare namespace ajv { caseIndex: number; } - interface NoParams {} + interface NoParams { } interface EnumParams { allowedValues: Array; } } -declare class ValidationError extends Error { - constructor(errors: Array); - - message: string; - errors: Array; - ajv: true; - validation: true; -} - -declare class MissingRefError extends Error { - constructor(baseId: string, ref: string, message?: string); - static message: (baseId: string, ref: string) => string; - - message: string; - missingRef: string; - missingSchema: string; -} - export = ajv; diff --git a/lib/ajv.js b/lib/ajv.js index 7a83e3b5e..06a45b650 100644 --- a/lib/ajv.js +++ b/lib/ajv.js @@ -30,6 +30,7 @@ var customKeyword = require('./keyword'); Ajv.prototype.addKeyword = customKeyword.add; Ajv.prototype.getKeyword = customKeyword.get; Ajv.prototype.removeKeyword = customKeyword.remove; +Ajv.prototype.validateKeyword = customKeyword.validate; var errorClasses = require('./compile/error_classes'); Ajv.ValidationError = errorClasses.Validation; @@ -38,7 +39,7 @@ Ajv.$dataMetaSchema = $dataMetaSchema; var META_SCHEMA_ID = 'http://json-schema.org/draft-07/schema'; -var META_IGNORE_OPTIONS = [ 'removeAdditional', 'useDefaults', 'coerceTypes' ]; +var META_IGNORE_OPTIONS = [ 'removeAdditional', 'useDefaults', 'coerceTypes', 'strictDefaults' ]; var META_SUPPORT_DATA = ['/properties']; /** @@ -68,9 +69,10 @@ function Ajv(opts) { this._metaOpts = getMetaSchemaOptions(this); if (opts.formats) addInitialFormats(this); + if (opts.keywords) addInitialKeywords(this); addDefaultMetaSchema(this); if (typeof opts.meta == 'object') this.addMetaSchema(opts.meta); - if (opts.nullable) this.addKeyword('nullable', {metaSchema: {const: true}}); + if (opts.nullable) this.addKeyword('nullable', {metaSchema: {type: 'boolean'}}); addInitialSchemas(this); } @@ -466,6 +468,14 @@ function addInitialFormats(self) { } +function addInitialKeywords(self) { + for (var name in self._opts.keywords) { + var keyword = self._opts.keywords[name]; + self.addKeyword(name, keyword); + } +} + + function checkUnique(self, id) { if (self._schemas[id] || self._refs[id]) throw new Error('schema with key or id "' + id + '" already exists'); diff --git a/lib/compile/equal.js b/lib/compile/equal.js index 911774c85..d6c2acef8 100644 --- a/lib/compile/equal.js +++ b/lib/compile/equal.js @@ -1,3 +1,5 @@ 'use strict'; +// do NOT remove this file - it would break pre-compiled schemas +// https://github.com/ajv-validator/ajv/issues/889 module.exports = require('fast-deep-equal'); diff --git a/lib/compile/formats.js b/lib/compile/formats.js index 5c0fb9ef5..de94a63bb 100644 --- a/lib/compile/formats.js +++ b/lib/compile/formats.js @@ -4,8 +4,8 @@ var util = require('./util'); var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/; var DAYS = [0,31,28,31,30,31,30,31,31,30,31,30,31]; -var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d:\d\d)?$/i; -var HOSTNAME = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*$/i; +var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i; +var HOSTNAME = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i; var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i; var URIREF = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i; // uri-template: https://tools.ietf.org/html/rfc6570 @@ -13,8 +13,8 @@ var URITEMPLATE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@| // For the source: https://gist.github.com/dperini/729294 // For test cases: https://mathiasbynens.be/demo/url-regex // @todo Delete current URL in favour of the commented out URL rule when this issue is fixed https://github.com/eslint/eslint/issues/7983. -// var URL = /^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!10(?:\.\d{1,3}){3})(?!127(?:\.\d{1,3}){3})(?!169\.254(?:\.\d{1,3}){2})(?!192\.168(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)(?:\.(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu; -var URL = /^(?:(?:http[s\u017F]?|ftp):\/\/)(?:(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+(?::(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?@)?(?:(?!10(?:\.[0-9]{1,3}){3})(?!127(?:\.[0-9]{1,3}){3})(?!169\.254(?:\.[0-9]{1,3}){2})(?!192\.168(?:\.[0-9]{1,3}){2})(?!172\.(?:1[6-9]|2[0-9]|3[01])(?:\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-?)*(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)(?:\.(?:(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-?)*(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)*(?:\.(?:(?:[KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\/(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?$/i; +// var URL = /^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!10(?:\.\d{1,3}){3})(?!127(?:\.\d{1,3}){3})(?!169\.254(?:\.\d{1,3}){2})(?!192\.168(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u{00a1}-\u{ffff}0-9]+-)*[a-z\u{00a1}-\u{ffff}0-9]+)(?:\.(?:[a-z\u{00a1}-\u{ffff}0-9]+-)*[a-z\u{00a1}-\u{ffff}0-9]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu; +var URL = /^(?:(?:http[s\u017F]?|ftp):\/\/)(?:(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+(?::(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?@)?(?:(?!10(?:\.[0-9]{1,3}){3})(?!127(?:\.[0-9]{1,3}){3})(?!169\.254(?:\.[0-9]{1,3}){2})(?!192\.168(?:\.[0-9]{1,3}){2})(?!172\.(?:1[6-9]|2[0-9]|3[01])(?:\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-)*(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)(?:\.(?:(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-)*(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)*(?:\.(?:(?:[a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\/(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?$/i; var UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i; var JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/; var JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i; @@ -33,11 +33,11 @@ formats.fast = { // date: http://tools.ietf.org/html/rfc3339#section-5.6 date: /^\d\d\d\d-[0-1]\d-[0-3]\d$/, // date-time: http://tools.ietf.org/html/rfc3339#section-5.6 - time: /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d:\d\d)?$/i, - 'date-time': /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d:\d\d)$/i, + time: /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, + 'date-time': /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js - uri: /^(?:[a-z][a-z0-9+-.]*:)(?:\/?\/)?[^\s]*$/i, - 'uri-reference': /^(?:(?:[a-z][a-z0-9+-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i, + uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i, + 'uri-reference': /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i, 'uri-template': URITEMPLATE, url: URL, // email (sources from jsen validator): @@ -70,7 +70,7 @@ formats.full = { 'uri-template': URITEMPLATE, url: URL, email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i, - hostname: hostname, + hostname: HOSTNAME, ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/, ipv6: /^\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(?:%.+)?\s*$/i, regex: regex, @@ -123,13 +123,6 @@ function date_time(str) { } -function hostname(str) { - // https://tools.ietf.org/html/rfc1034#section-3.5 - // https://tools.ietf.org/html/rfc1123#section-2 - return str.length <= 255 && HOSTNAME.test(str); -} - - var NOT_URI_FRAGMENT = /\/|:/; function uri(str) { // http://jmrware.com/articles/2009/uri_regexp/URI_regex.html + optional protocol + required "." diff --git a/lib/compile/index.js b/lib/compile/index.js index 8e369db3d..97518c424 100644 --- a/lib/compile/index.js +++ b/lib/compile/index.js @@ -113,7 +113,7 @@ function compile(schema, root, localRefs, baseId) { + vars(defaults, defaultCode) + vars(customRules, customRuleCode) + sourceCode; - if (opts.processCode) sourceCode = opts.processCode(sourceCode); + if (opts.processCode) sourceCode = opts.processCode(sourceCode, _schema); // console.log('\n\n\n *** \n', JSON.stringify(sourceCode)); var validate; try { @@ -255,13 +255,21 @@ function compile(schema, root, localRefs, baseId) { } function useCustomRule(rule, schema, parentSchema, it) { - var validateSchema = rule.definition.validateSchema; - if (validateSchema && self._opts.validateSchema !== false) { - var valid = validateSchema(schema); - if (!valid) { - var message = 'keyword schema is invalid: ' + self.errorsText(validateSchema.errors); - if (self._opts.validateSchema == 'log') self.logger.error(message); - else throw new Error(message); + if (self._opts.validateSchema !== false) { + var deps = rule.definition.dependencies; + if (deps && !deps.every(function(keyword) { + return Object.prototype.hasOwnProperty.call(parentSchema, keyword); + })) + throw new Error('parent schema must have all required keywords: ' + deps.join(',')); + + var validateSchema = rule.definition.validateSchema; + if (validateSchema) { + var valid = validateSchema(schema); + if (!valid) { + var message = 'keyword schema is invalid: ' + self.errorsText(validateSchema.errors); + if (self._opts.validateSchema == 'log') self.logger.error(message); + else throw new Error(message); + } } } diff --git a/lib/compile/rules.js b/lib/compile/rules.js index 66f196a93..08b25aeb9 100644 --- a/lib/compile/rules.js +++ b/lib/compile/rules.js @@ -20,7 +20,7 @@ module.exports = function rules() { var ALL = [ 'type', '$comment' ]; var KEYWORDS = [ - '$schema', '$id', 'id', '$data', 'title', + '$schema', '$id', 'id', '$data', '$async', 'title', 'description', 'default', 'definitions', 'examples', 'readOnly', 'writeOnly', 'contentMediaType', 'contentEncoding', diff --git a/lib/compile/util.js b/lib/compile/util.js index 263891c33..ef07b8c75 100644 --- a/lib/compile/util.js +++ b/lib/compile/util.js @@ -13,10 +13,9 @@ module.exports = { ucs2length: require('./ucs2length'), varOccurences: varOccurences, varReplace: varReplace, - cleanUpCode: cleanUpCode, - finalCleanUpCode: finalCleanUpCode, schemaHasRules: schemaHasRules, schemaHasRulesExcept: schemaHasRulesExcept, + schemaUnknownRules: schemaUnknownRules, toQuotedString: toQuotedString, getPathExpr: getPathExpr, getPath: getPath, @@ -35,7 +34,7 @@ function copy(o, to) { } -function checkDataType(dataType, data, negate) { +function checkDataType(dataType, data, strictNumbers, negate) { var EQUAL = negate ? ' !== ' : ' === ' , AND = negate ? ' || ' : ' && ' , OK = negate ? '!' : '' @@ -48,15 +47,18 @@ function checkDataType(dataType, data, negate) { NOT + 'Array.isArray(' + data + '))'; case 'integer': return '(typeof ' + data + EQUAL + '"number"' + AND + NOT + '(' + data + ' % 1)' + - AND + data + EQUAL + data + ')'; + AND + data + EQUAL + data + + (strictNumbers ? (AND + OK + 'isFinite(' + data + ')') : '') + ')'; + case 'number': return '(typeof ' + data + EQUAL + '"' + dataType + '"' + + (strictNumbers ? (AND + OK + 'isFinite(' + data + ')') : '') + ')'; default: return 'typeof ' + data + EQUAL + '"' + dataType + '"'; } } -function checkDataTypes(dataTypes, data) { +function checkDataTypes(dataTypes, data, strictNumbers) { switch (dataTypes.length) { - case 1: return checkDataType(dataTypes[0], data, true); + case 1: return checkDataType(dataTypes[0], data, strictNumbers, true); default: var code = ''; var types = toHash(dataTypes); @@ -69,7 +71,7 @@ function checkDataTypes(dataTypes, data) { } if (types.number) delete types.integer; for (var t in types) - code += (code ? ' && ' : '' ) + checkDataType(t, data, true); + code += (code ? ' && ' : '' ) + checkDataType(t, data, strictNumbers, true); return code; } @@ -135,42 +137,6 @@ function varReplace(str, dataVar, expr) { } -var EMPTY_ELSE = /else\s*{\s*}/g - , EMPTY_IF_NO_ELSE = /if\s*\([^)]+\)\s*\{\s*\}(?!\s*else)/g - , EMPTY_IF_WITH_ELSE = /if\s*\(([^)]+)\)\s*\{\s*\}\s*else(?!\s*if)/g; -function cleanUpCode(out) { - return out.replace(EMPTY_ELSE, '') - .replace(EMPTY_IF_NO_ELSE, '') - .replace(EMPTY_IF_WITH_ELSE, 'if (!($1))'); -} - - -var ERRORS_REGEXP = /[^v.]errors/g - , REMOVE_ERRORS = /var errors = 0;|var vErrors = null;|validate.errors = vErrors;/g - , REMOVE_ERRORS_ASYNC = /var errors = 0;|var vErrors = null;/g - , RETURN_VALID = 'return errors === 0;' - , RETURN_TRUE = 'validate.errors = null; return true;' - , RETURN_ASYNC = /if \(errors === 0\) return data;\s*else throw new ValidationError\(vErrors\);/ - , RETURN_DATA_ASYNC = 'return data;' - , ROOTDATA_REGEXP = /[^A-Za-z_$]rootData[^A-Za-z0-9_$]/g - , REMOVE_ROOTDATA = /if \(rootData === undefined\) rootData = data;/; - -function finalCleanUpCode(out, async) { - var matches = out.match(ERRORS_REGEXP); - if (matches && matches.length == 2) { - out = async - ? out.replace(REMOVE_ERRORS_ASYNC, '') - .replace(RETURN_ASYNC, RETURN_DATA_ASYNC) - : out.replace(REMOVE_ERRORS, '') - .replace(RETURN_VALID, RETURN_TRUE); - } - - matches = out.match(ROOTDATA_REGEXP); - if (!matches || matches.length !== 3) return out; - return out.replace(REMOVE_ROOTDATA, ''); -} - - function schemaHasRules(schema, rules) { if (typeof schema == 'boolean') return !schema; for (var key in schema) if (rules[key]) return true; @@ -183,6 +149,12 @@ function schemaHasRulesExcept(schema, rules, exceptKeyword) { } +function schemaUnknownRules(schema, rules) { + if (typeof schema == 'boolean') return; + for (var key in schema) if (!rules[key]) return key; +} + + function toQuotedString(str) { return '\'' + escapeQuotes(str) + '\''; } @@ -243,7 +215,7 @@ function getData($data, lvl, paths) { function joinPaths (a, b) { if (a == '""') return b; - return (a + ' + ' + b).replace(/' \+ '/g, ''); + return (a + ' + ' + b).replace(/([^\\])' \+ '/g, '$1'); } diff --git a/lib/data.js b/lib/data.js index 5f1ad85ef..f11142bec 100644 --- a/lib/data.js +++ b/lib/data.js @@ -38,7 +38,7 @@ module.exports = function (metaSchema, keywordsJsonPointers) { keywords[key] = { anyOf: [ schema, - { $ref: 'https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/data.json#' } + { $ref: 'https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#' } ] }; } diff --git a/lib/definition_schema.js b/lib/definition_schema.js new file mode 100644 index 000000000..ad86d4f0b --- /dev/null +++ b/lib/definition_schema.js @@ -0,0 +1,37 @@ +'use strict'; + +var metaSchema = require('./refs/json-schema-draft-07.json'); + +module.exports = { + $id: 'https://github.com/ajv-validator/ajv/blob/master/lib/definition_schema.js', + definitions: { + simpleTypes: metaSchema.definitions.simpleTypes + }, + type: 'object', + dependencies: { + schema: ['validate'], + $data: ['validate'], + statements: ['inline'], + valid: {not: {required: ['macro']}} + }, + properties: { + type: metaSchema.properties.type, + schema: {type: 'boolean'}, + statements: {type: 'boolean'}, + dependencies: { + type: 'array', + items: {type: 'string'} + }, + metaSchema: {type: 'object'}, + modifying: {type: 'boolean'}, + valid: {type: 'boolean'}, + $data: {type: 'boolean'}, + async: {type: 'boolean'}, + errors: { + anyOf: [ + {type: 'boolean'}, + {const: 'full'} + ] + } + } +}; diff --git a/lib/dot/_limit.jst b/lib/dot/_limit.jst index e10806fd3..f15218922 100644 --- a/lib/dot/_limit.jst +++ b/lib/dot/_limit.jst @@ -17,6 +17,15 @@ , $op = $isMax ? '<' : '>' , $notOp = $isMax ? '>' : '<' , $errorKeyword = undefined; + + if (!($isData || typeof $schema == 'number' || $schema === undefined)) { + throw new Error($keyword + ' must be number'); + } + if (!($isDataExcl || $schemaExcl === undefined + || typeof $schemaExcl == 'number' + || typeof $schemaExcl == 'boolean')) { + throw new Error($exclusiveKeyword + ' must be number or boolean'); + } }} {{? $isDataExcl }} diff --git a/lib/dot/_limitItems.jst b/lib/dot/_limitItems.jst index a3e078e51..741329e77 100644 --- a/lib/dot/_limitItems.jst +++ b/lib/dot/_limitItems.jst @@ -3,6 +3,8 @@ {{# def.setupKeyword }} {{# def.$data }} +{{# def.numberKeyword }} + {{ var $op = $keyword == 'maxItems' ? '>' : '<'; }} if ({{# def.$dataNotType:'number' }} {{=$data}}.length {{=$op}} {{=$schemaValue}}) { {{ var $errorKeyword = $keyword; }} diff --git a/lib/dot/_limitLength.jst b/lib/dot/_limitLength.jst index cfc8dbb01..285c66bd2 100644 --- a/lib/dot/_limitLength.jst +++ b/lib/dot/_limitLength.jst @@ -3,6 +3,8 @@ {{# def.setupKeyword }} {{# def.$data }} +{{# def.numberKeyword }} + {{ var $op = $keyword == 'maxLength' ? '>' : '<'; }} if ({{# def.$dataNotType:'number' }} {{# def.strLength }} {{=$op}} {{=$schemaValue}}) { {{ var $errorKeyword = $keyword; }} diff --git a/lib/dot/_limitProperties.jst b/lib/dot/_limitProperties.jst index da7ea776f..c4c21551a 100644 --- a/lib/dot/_limitProperties.jst +++ b/lib/dot/_limitProperties.jst @@ -3,6 +3,8 @@ {{# def.setupKeyword }} {{# def.$data }} +{{# def.numberKeyword }} + {{ var $op = $keyword == 'maxProperties' ? '>' : '<'; }} if ({{# def.$dataNotType:'number' }} Object.keys({{=$data}}).length {{=$op}} {{=$schemaValue}}) { {{ var $errorKeyword = $keyword; }} diff --git a/lib/dot/allOf.jst b/lib/dot/allOf.jst index 4c2836311..0e782fe98 100644 --- a/lib/dot/allOf.jst +++ b/lib/dot/allOf.jst @@ -30,5 +30,3 @@ {{= $closingBraces.slice(0,-1) }} {{?}} {{?}} - -{{# def.cleanUp }} diff --git a/lib/dot/anyOf.jst b/lib/dot/anyOf.jst index 086cf2b33..ea909ee62 100644 --- a/lib/dot/anyOf.jst +++ b/lib/dot/anyOf.jst @@ -39,8 +39,6 @@ } else { {{# def.resetErrors }} {{? it.opts.allErrors }} } {{?}} - - {{# def.cleanUp }} {{??}} {{? $breakOnError }} if (true) { diff --git a/lib/dot/coerce.def b/lib/dot/coerce.def index 86e0e18af..c947ed6af 100644 --- a/lib/dot/coerce.def +++ b/lib/dot/coerce.def @@ -4,55 +4,45 @@ , $coerced = 'coerced' + $lvl; }} var {{=$dataType}} = typeof {{=$data}}; - {{? it.opts.coerceTypes == 'array'}} - if ({{=$dataType}} == 'object' && Array.isArray({{=$data}})) {{=$dataType}} = 'array'; - {{?}} - var {{=$coerced}} = undefined; - {{ var $bracesCoercion = ''; }} - {{~ $coerceToTypes:$type:$i }} - {{? $i }} - if ({{=$coerced}} === undefined) { - {{ $bracesCoercion += '}'; }} - {{?}} - - {{? it.opts.coerceTypes == 'array' && $type != 'array' }} - if ({{=$dataType}} == 'array' && {{=$data}}.length == 1) { - {{=$coerced}} = {{=$data}} = {{=$data}}[0]; - {{=$dataType}} = typeof {{=$data}}; - /*if ({{=$dataType}} == 'object' && Array.isArray({{=$data}})) {{=$dataType}} = 'array';*/ - } - {{?}} + {{? it.opts.coerceTypes == 'array' }} + if ({{=$dataType}} == 'object' && Array.isArray({{=$data}}) && {{=$data}}.length == 1) { + {{=$data}} = {{=$data}}[0]; + {{=$dataType}} = typeof {{=$data}}; + if ({{=it.util.checkDataType(it.schema.type, $data, it.opts.strictNumbers)}}) {{=$coerced}} = {{=$data}}; + } + {{?}} + if ({{=$coerced}} !== undefined) ; + {{~ $coerceToTypes:$type:$i }} {{? $type == 'string' }} - if ({{=$dataType}} == 'number' || {{=$dataType}} == 'boolean') + else if ({{=$dataType}} == 'number' || {{=$dataType}} == 'boolean') {{=$coerced}} = '' + {{=$data}}; else if ({{=$data}} === null) {{=$coerced}} = ''; {{?? $type == 'number' || $type == 'integer' }} - if ({{=$dataType}} == 'boolean' || {{=$data}} === null + else if ({{=$dataType}} == 'boolean' || {{=$data}} === null || ({{=$dataType}} == 'string' && {{=$data}} && {{=$data}} == +{{=$data}} {{? $type == 'integer' }} && !({{=$data}} % 1){{?}})) {{=$coerced}} = +{{=$data}}; {{?? $type == 'boolean' }} - if ({{=$data}} === 'false' || {{=$data}} === 0 || {{=$data}} === null) + else if ({{=$data}} === 'false' || {{=$data}} === 0 || {{=$data}} === null) {{=$coerced}} = false; else if ({{=$data}} === 'true' || {{=$data}} === 1) {{=$coerced}} = true; {{?? $type == 'null' }} - if ({{=$data}} === '' || {{=$data}} === 0 || {{=$data}} === false) + else if ({{=$data}} === '' || {{=$data}} === 0 || {{=$data}} === false) {{=$coerced}} = null; {{?? it.opts.coerceTypes == 'array' && $type == 'array' }} - if ({{=$dataType}} == 'string' || {{=$dataType}} == 'number' || {{=$dataType}} == 'boolean' || {{=$data}} == null) + else if ({{=$dataType}} == 'string' || {{=$dataType}} == 'number' || {{=$dataType}} == 'boolean' || {{=$data}} == null) {{=$coerced}} = [{{=$data}}]; {{?}} {{~}} - - {{= $bracesCoercion }} - - if ({{=$coerced}} === undefined) { + else { {{# def.error:'type' }} - } else { + } + + if ({{=$coerced}} !== undefined) { {{# def.setParentData }} {{=$data}} = {{=$coerced}}; {{? !$dataLvl }}if ({{=$parentData}} !== undefined){{?}} diff --git a/lib/dot/contains.jst b/lib/dot/contains.jst index 925d2c84b..4dc996741 100644 --- a/lib/dot/contains.jst +++ b/lib/dot/contains.jst @@ -53,5 +53,3 @@ var {{=$valid}}; {{# def.resetErrors }} {{?}} {{? it.opts.allErrors }} } {{?}} - -{{# def.cleanUp }} diff --git a/lib/dot/defaults.def b/lib/dot/defaults.def index 5ad8d1d2d..a844cf285 100644 --- a/lib/dot/defaults.def +++ b/lib/dot/defaults.def @@ -1,10 +1,25 @@ {{## def.assignDefault: - if ({{=$passData}} === undefined) - {{=$passData}} = {{? it.opts.useDefaults == 'shared' }} - {{= it.useDefault($sch.default) }} - {{??}} - {{= JSON.stringify($sch.default) }} - {{?}}; + {{? it.compositeRule }} + {{ + if (it.opts.strictDefaults) { + var $defaultMsg = 'default is ignored for: ' + $passData; + if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg); + else throw new Error($defaultMsg); + } + }} + {{??}} + if ({{=$passData}} === undefined + {{? it.opts.useDefaults == 'empty' }} + || {{=$passData}} === null + || {{=$passData}} === '' + {{?}} + ) + {{=$passData}} = {{? it.opts.useDefaults == 'shared' }} + {{= it.useDefault($sch.default) }} + {{??}} + {{= JSON.stringify($sch.default) }} + {{?}}; + {{?}} #}} diff --git a/lib/dot/definitions.def b/lib/dot/definitions.def index cdbe140bb..709cce36d 100644 --- a/lib/dot/definitions.def +++ b/lib/dot/definitions.def @@ -63,7 +63,10 @@ {{## def.nonEmptySchema:_schema: - it.util.schemaHasRules(_schema, it.RULES.all) + (it.opts.strictKeywords + ? (typeof _schema == 'object' && Object.keys(_schema).length > 0) + || _schema === false + : it.util.schemaHasRules(_schema, it.RULES.all)) #}} @@ -110,12 +113,6 @@ #}} -{{## def.cleanUp: {{ out = it.util.cleanUpCode(out); }} #}} - - -{{## def.finalCleanUp: {{ out = it.util.finalCleanUpCode(out, $async); }} #}} - - {{## def.$data: {{ var $isData = it.opts.$data && $schema && $schema.$data @@ -142,6 +139,13 @@ #}} +{{## def.numberKeyword: + {{? !($isData || typeof $schema == 'number') }} + {{ throw new Error($keyword + ' must be number'); }} + {{?}} +#}} + + {{## def.beginDefOut: {{ var $$outStack = $$outStack || []; diff --git a/lib/dot/dependencies.jst b/lib/dot/dependencies.jst index c41f33422..e4bdddec8 100644 --- a/lib/dot/dependencies.jst +++ b/lib/dot/dependencies.jst @@ -19,6 +19,7 @@ , $ownProperties = it.opts.ownProperties; for ($property in $schema) { + if ($property == '__proto__') continue; var $sch = $schema[$property]; var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps; $deps[$property] = $sch; @@ -76,5 +77,3 @@ var missing{{=$lvl}}; {{= $closingBraces }} if ({{=$errs}} == errors) { {{?}} - -{{# def.cleanUp }} diff --git a/lib/dot/if.jst b/lib/dot/if.jst index 7ccc9b7f7..adb503612 100644 --- a/lib/dot/if.jst +++ b/lib/dot/if.jst @@ -65,8 +65,6 @@ {{# def.extraError:'if' }} } {{? $breakOnError }} else { {{?}} - - {{# def.cleanUp }} {{??}} {{? $breakOnError }} if (true) { diff --git a/lib/dot/items.jst b/lib/dot/items.jst index 8c0f5acb5..acc932a26 100644 --- a/lib/dot/items.jst +++ b/lib/dot/items.jst @@ -96,5 +96,3 @@ var {{=$valid}}; {{= $closingBraces }} if ({{=$errs}} == errors) { {{?}} - -{{# def.cleanUp }} diff --git a/lib/dot/multipleOf.jst b/lib/dot/multipleOf.jst index 5f8dd33b5..6d88a456f 100644 --- a/lib/dot/multipleOf.jst +++ b/lib/dot/multipleOf.jst @@ -3,6 +3,8 @@ {{# def.setupKeyword }} {{# def.$data }} +{{# def.numberKeyword }} + var division{{=$lvl}}; if ({{?$isData}} {{=$schemaValue}} !== undefined && ( diff --git a/lib/dot/properties.jst b/lib/dot/properties.jst index 862067e75..5cebb9b12 100644 --- a/lib/dot/properties.jst +++ b/lib/dot/properties.jst @@ -28,9 +28,9 @@ , $nextData = 'data' + $dataNxt , $dataProperties = 'dataProperties' + $lvl; - var $schemaKeys = Object.keys($schema || {}) + var $schemaKeys = Object.keys($schema || {}).filter(notProto) , $pProperties = it.schema.patternProperties || {} - , $pPropertyKeys = Object.keys($pProperties) + , $pPropertyKeys = Object.keys($pProperties).filter(notProto) , $aProperties = it.schema.additionalProperties , $someProperties = $schemaKeys.length || $pPropertyKeys.length , $noAdditional = $aProperties === false @@ -42,8 +42,11 @@ , $currentBaseId = it.baseId; var $required = it.schema.required; - if ($required && !(it.opts.$data && $required.$data) && $required.length < it.opts.loopRequired) + if ($required && !(it.opts.$data && $required.$data) && $required.length < it.opts.loopRequired) { var $requiredHash = it.util.toHash($required); + } + + function notProto(p) { return p !== '__proto__'; } }} @@ -240,5 +243,3 @@ var {{=$nextValid}} = true; {{= $closingBraces }} if ({{=$errs}} == errors) { {{?}} - -{{# def.cleanUp }} diff --git a/lib/dot/propertyNames.jst b/lib/dot/propertyNames.jst index ee52b2151..d456ccafc 100644 --- a/lib/dot/propertyNames.jst +++ b/lib/dot/propertyNames.jst @@ -50,5 +50,3 @@ var {{=$errs}} = errors; {{= $closingBraces }} if ({{=$errs}} == errors) { {{?}} - -{{# def.cleanUp }} diff --git a/lib/dot/uniqueItems.jst b/lib/dot/uniqueItems.jst index 22f82f99d..e69b8308d 100644 --- a/lib/dot/uniqueItems.jst +++ b/lib/dot/uniqueItems.jst @@ -38,7 +38,7 @@ for (;i--;) { var item = {{=$data}}[i]; {{ var $method = 'checkDataType' + ($typeIsArray ? 's' : ''); }} - if ({{= it.util[$method]($itemType, 'item', true) }}) continue; + if ({{= it.util[$method]($itemType, 'item', it.opts.strictNumbers, true) }}) continue; {{? $typeIsArray}} if (typeof item == 'string') item = '"' + item; {{?}} diff --git a/lib/dot/validate.jst b/lib/dot/validate.jst index 89a5b3b49..32087e71c 100644 --- a/lib/dot/validate.jst +++ b/lib/dot/validate.jst @@ -20,6 +20,17 @@ , $id = it.self._getId(it.schema); }} +{{ + if (it.opts.strictKeywords) { + var $unknownKwd = it.util.schemaUnknownRules(it.schema, it.RULES.keywords); + if ($unknownKwd) { + var $keywordsMsg = 'unknown keyword: ' + $unknownKwd; + if (it.opts.strictKeywords === 'log') it.logger.warn($keywordsMsg); + else throw new Error($keywordsMsg); + } + } +}} + {{? it.isTop }} var validate = {{?$async}}{{it.async = true;}}async {{?}}function(data, dataPath, parentData, parentDataProperty, rootData) { 'use strict'; @@ -70,7 +81,13 @@ it.baseId = it.baseId || it.rootId; delete it.isTop; - it.dataPathArr = [undefined]; + it.dataPathArr = [""]; + + if (it.schema.default !== undefined && it.opts.useDefaults && it.opts.strictDefaults) { + var $defaultMsg = 'default is ignored in the schema root'; + if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg); + else throw new Error($defaultMsg); + } }} var vErrors = null; {{ /* don't edit, used in replace */ }} @@ -123,7 +140,7 @@ , $method = $typeIsArray ? 'checkDataTypes' : 'checkDataType'; }} - if ({{= it.util[$method]($typeSchema, $data, true) }}) { + if ({{= it.util[$method]($typeSchema, $data, it.opts.strictNumbers, true) }}) { #}} {{? it.schema.$ref && $refKeywords }} @@ -175,9 +192,9 @@ {{~ it.RULES:$rulesGroup }} {{? $shouldUseGroup($rulesGroup) }} {{? $rulesGroup.type }} - if ({{= it.util.checkDataType($rulesGroup.type, $data) }}) { + if ({{= it.util.checkDataType($rulesGroup.type, $data, it.opts.strictNumbers) }}) { {{?}} - {{? it.opts.useDefaults && !it.compositeRule }} + {{? it.opts.useDefaults }} {{? $rulesGroup.type == 'object' && it.schema.properties }} {{# def.defaultProperties }} {{?? $rulesGroup.type == 'array' && Array.isArray(it.schema.items) }} @@ -237,12 +254,6 @@ var {{=$valid}} = errors === errs_{{=$lvl}}; {{?}} -{{# def.cleanUp }} - -{{? $top }} - {{# def.finalCleanUp }} -{{?}} - {{ function $shouldUseGroup($rulesGroup) { var rules = $rulesGroup.rules; diff --git a/lib/keyword.js b/lib/keyword.js index 6ed84c10a..06da9a2df 100644 --- a/lib/keyword.js +++ b/lib/keyword.js @@ -2,13 +2,16 @@ var IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i; var customRuleCode = require('./dotjs/custom'); +var definitionSchema = require('./definition_schema'); module.exports = { add: addKeyword, get: getKeyword, - remove: removeKeyword + remove: removeKeyword, + validate: validateKeyword }; + /** * Define custom keyword * @this Ajv @@ -20,7 +23,6 @@ function addKeyword(keyword, definition) { /* jshint validthis: true */ /* eslint no-shadow: 0 */ var RULES = this.RULES; - if (RULES.keywords[keyword]) throw new Error('Keyword ' + keyword + ' is already defined'); @@ -28,30 +30,23 @@ function addKeyword(keyword, definition) { throw new Error('Keyword ' + keyword + ' is not a valid identifier'); if (definition) { - if (definition.macro && definition.valid !== undefined) - throw new Error('"valid" option cannot be used with macro keywords'); + this.validateKeyword(definition, true); var dataType = definition.type; if (Array.isArray(dataType)) { - var i, len = dataType.length; - for (i=0; i= schema; + }; + }, + metaSchema: {type: 'integer'} + }); + + var schema = { + type: 'object', + properties: { + foo: { + type: 'string', + minTrimmedLength: 3 + } + }, + required: ['foo'] + }; + + var validate = ajv.compile(schema); + + var data = { + foo: ' bar ', + baz: '' + }; + validate(data) .should.equal(true); + data .should.not.have.property('baz'); + + data = { + foo: ' ba ', + baz: '' + }; + validate(data) .should.equal(false); + data .should.not.have.property('baz'); + }); +}); diff --git a/spec/options.spec.js b/spec/options.spec.js deleted file mode 100644 index 1754fa8fd..000000000 --- a/spec/options.spec.js +++ /dev/null @@ -1,1502 +0,0 @@ -'use strict'; - -var Ajv = require('./ajv') - , getAjvInstances = require('./ajv_instances') - , should = require('./chai').should(); - - -describe('Ajv Options', function () { - describe('removeAdditional', function() { - it('should remove all additional properties', function() { - var ajv = new Ajv({ removeAdditional: 'all' }); - - ajv.addSchema({ - $id: '//test/fooBar', - properties: { foo: { type: 'string' }, bar: { type: 'string' } } - }); - - var object = { - foo: 'foo', bar: 'bar', baz: 'baz-to-be-removed' - }; - - ajv.validate('//test/fooBar', object).should.equal(true); - object.should.have.property('foo'); - object.should.have.property('bar'); - object.should.not.have.property('baz'); - }); - - - it('should remove properties that would error when `additionalProperties = false`', function() { - var ajv = new Ajv({ removeAdditional: true }); - - ajv.addSchema({ - $id: '//test/fooBar', - properties: { foo: { type: 'string' }, bar: { type: 'string' } }, - additionalProperties: false - }); - - var object = { - foo: 'foo', bar: 'bar', baz: 'baz-to-be-removed' - }; - - ajv.validate('//test/fooBar', object).should.equal(true); - object.should.have.property('foo'); - object.should.have.property('bar'); - object.should.not.have.property('baz'); - }); - - - it('should remove properties that would error when `additionalProperties = false` (many properties, boolean schema)', function() { - var ajv = new Ajv({removeAdditional: true}); - - var schema = { - properties: { - obj: { - additionalProperties: false, - properties: { - a: { type: 'string' }, - b: false, - c: { type: 'string' }, - d: { type: 'string' }, - e: { type: 'string' }, - f: { type: 'string' }, - g: { type: 'string' }, - h: { type: 'string' }, - i: { type: 'string' } - } - } - } - }; - - var data = { - obj: { - a: 'valid', - b: 'should not be removed', - additional: 'will be removed' - } - }; - - ajv.validate(schema, data) .should.equal(false); - data .should.eql({ - obj: { - a: 'valid', - b: 'should not be removed' - } - }); - }); - - - it('should remove properties that would error when `additionalProperties` is a schema', function() { - var ajv = new Ajv({ removeAdditional: 'failing' }); - - ajv.addSchema({ - $id: '//test/fooBar', - properties: { foo: { type: 'string' }, bar: { type: 'string' } }, - additionalProperties: { type: 'string' } - }); - - var object = { - foo: 'foo', bar: 'bar', baz: 'baz-to-be-kept', fizz: 1000 - }; - - ajv.validate('//test/fooBar', object).should.equal(true); - object.should.have.property('foo'); - object.should.have.property('bar'); - object.should.have.property('baz'); - object.should.not.have.property('fizz'); - - ajv.addSchema({ - $id: '//test/fooBar2', - properties: { foo: { type: 'string' }, bar: { type: 'string' } }, - additionalProperties: { type: 'string', pattern: '^to-be-', maxLength: 10 } - }); - - object = { - foo: 'foo', bar: 'bar', baz: 'to-be-kept', quux: 'to-be-removed', fizz: 1000 - }; - - ajv.validate('//test/fooBar2', object).should.equal(true); - object.should.have.property('foo'); - object.should.have.property('bar'); - object.should.have.property('baz'); - object.should.not.have.property('fizz'); - }); - }); - - - describe('ownProperties', function() { - var ajv, ajvOP, ajvOP1; - - beforeEach(function() { - ajv = new Ajv({ allErrors: true }); - ajvOP = new Ajv({ ownProperties: true, allErrors: true }); - ajvOP1 = new Ajv({ ownProperties: true }); - }); - - it('should only validate own properties with additionalProperties', function() { - var schema = { - properties: { a: { type: 'number' } }, - additionalProperties: false - }; - - var obj = { a: 1 }; - var proto = { b: 2 }; - test(schema, obj, proto); - }); - - it('should only validate own properties with properties keyword', function() { - var schema = { - properties: { - a: { type: 'number' }, - b: { type: 'number' } - } - }; - - var obj = { a: 1 }; - var proto = { b: 'not a number' }; - test(schema, obj, proto); - }); - - it('should only validate own properties with required keyword', function() { - var schema = { - required: ['a', 'b'] - }; - - var obj = { a: 1 }; - var proto = { b: 2 }; - test(schema, obj, proto, 1, true); - }); - - it('should only validate own properties with required keyword - many properties', function() { - ajv = new Ajv({ allErrors: true, loopRequired: 1 }); - ajvOP = new Ajv({ ownProperties: true, allErrors: true, loopRequired: 1 }); - ajvOP1 = new Ajv({ ownProperties: true, loopRequired: 1 }); - - var schema = { - required: ['a', 'b', 'c', 'd'] - }; - - var obj = { a: 1, b: 2 }; - var proto = { c: 3, d: 4 }; - test(schema, obj, proto, 2, true); - }); - - it('should only validate own properties with required keyword as $data', function() { - ajv = new Ajv({ allErrors: true, $data: true }); - ajvOP = new Ajv({ ownProperties: true, allErrors: true, $data: true }); - ajvOP1 = new Ajv({ ownProperties: true, $data: true }); - - var schema = { - required: { $data: '0/req' }, - properties: { - req: { - type: 'array', - items: { type: 'string' } - } - } - }; - - var obj = { - req: ['a', 'b'], - a: 1 - }; - var proto = { b: 2 }; - test(schema, obj, proto, 1, true); - }); - - it('should only validate own properties with properties and required keyword', function() { - var schema = { - properties: { - a: { type: 'number' }, - b: { type: 'number' } - }, - required: ['a', 'b'] - }; - - var obj = { a: 1 }; - var proto = { b: 2 }; - test(schema, obj, proto, 1, true); - }); - - it('should only validate own properties with dependencies keyword', function() { - var schema = { - dependencies: { - a: ['c'], - b: ['d'] - } - }; - - var obj = { a: 1, c: 3 }; - var proto = { b: 2 }; - test(schema, obj, proto); - - obj = { a: 1, b: 2, c: 3 }; - proto = { d: 4 }; - test(schema, obj, proto, 1, true); - }); - - it('should only validate own properties with schema dependencies', function() { - var schema = { - dependencies: { - a: { not: { required: ['c'] } }, - b: { not: { required: ['d'] } } - } - }; - - var obj = { a: 1, d: 3 }; - var proto = { b: 2 }; - test(schema, obj, proto); - - obj = { a: 1, b: 2 }; - proto = { d: 4 }; - test(schema, obj, proto); - }); - - it('should only validate own properties with patternProperties', function() { - var schema = { - patternProperties: { 'f.*o': { type: 'integer' } }, - }; - - var obj = { fooo: 1 }; - var proto = { foo: 'not a number' }; - test(schema, obj, proto); - }); - - it('should only validate own properties with propertyNames', function() { - var schema = { - propertyNames: { - format: 'email' - } - }; - - var obj = { 'e@example.com': 2 }; - var proto = { 'not email': 1 }; - test(schema, obj, proto, 2); - }); - - function test(schema, obj, proto, errors, reverse) { - errors = errors || 1; - var validate = ajv.compile(schema); - var validateOP = ajvOP.compile(schema); - var validateOP1 = ajvOP1.compile(schema); - var data = Object.create(proto); - for (var key in obj) data[key] = obj[key]; - - if (reverse) { - validate(data) .should.equal(true); - validateOP(data) .should.equal(false); - validateOP.errors .should.have.length(errors); - validateOP1(data) .should.equal(false); - validateOP1.errors .should.have.length(1); - } else { - validate(data) .should.equal(false); - validate.errors .should.have.length(errors); - validateOP(data) .should.equal(true); - validateOP1(data) .should.equal(true); - } - } - }); - - describe('meta and validateSchema', function() { - it('should add draft-7 meta schema by default', function() { - testOptionMeta(new Ajv); - testOptionMeta(new Ajv({ meta: true })); - - function testOptionMeta(ajv) { - ajv.getSchema('http://json-schema.org/draft-07/schema') .should.be.a('function'); - ajv.validateSchema({ type: 'integer' }) .should.equal(true); - ajv.validateSchema({ type: 123 }) .should.equal(false); - should.not.throw(function() { ajv.addSchema({ type: 'integer' }); }); - should.throw(function() { ajv.addSchema({ type: 123 }); }); - } - }); - - it('should throw if meta: false and validateSchema: true', function() { - var ajv = new Ajv({ meta: false }); - should.not.exist(ajv.getSchema('http://json-schema.org/draft-07/schema')); - should.not.throw(function() { ajv.addSchema({ type: 'wrong_type' }, 'integer'); }); - }); - - it('should skip schema validation with validateSchema: false', function() { - var ajv = new Ajv; - should.throw(function() { ajv.addSchema({ type: 123 }, 'integer'); }); - - ajv = new Ajv({ validateSchema: false }); - should.not.throw(function() { ajv.addSchema({ type: 123 }, 'integer'); }); - - ajv = new Ajv({ validateSchema: false, meta: false }); - should.not.throw(function() { ajv.addSchema({ type: 123 }, 'integer'); }); - }); - - it('should not throw on invalid schema with validateSchema: "log"', function() { - var logError = console.error; - var loggedError = false; - console.error = function() { loggedError = true; logError.apply(console, arguments); }; - - var ajv = new Ajv({ validateSchema: 'log' }); - should.not.throw(function() { ajv.addSchema({ type: 123 }, 'integer'); }); - loggedError .should.equal(true); - - loggedError = false; - ajv = new Ajv({ validateSchema: 'log', meta: false }); - should.not.throw(function() { ajv.addSchema({ type: 123 }, 'integer'); }); - loggedError .should.equal(false); - console.error = logError; - }); - - it('should validate v6 schema', function() { - var ajv = new Ajv; - ajv.validateSchema({ contains: { minimum: 2 } }) .should.equal(true); - ajv.validateSchema({ contains: 2 }). should.equal(false); - }); - - it('should use option meta as default meta schema', function() { - var meta = { - $schema: 'http://json-schema.org/draft-07/schema', - properties: { - myKeyword: { type: 'boolean' } - } - }; - var ajv = new Ajv({ meta: meta }); - ajv.validateSchema({ myKeyword: true }) .should.equal(true); - ajv.validateSchema({ myKeyword: 2 }) .should.equal(false); - ajv.validateSchema({ - $schema: 'http://json-schema.org/draft-07/schema', - myKeyword: 2 - }) .should.equal(true); - - ajv = new Ajv; - ajv.validateSchema({ myKeyword: true }) .should.equal(true); - ajv.validateSchema({ myKeyword: 2 }) .should.equal(true); - }); - }); - - - describe('schemas', function() { - it('should add schemas from object', function() { - var ajv = new Ajv({ schemas: { - int: { type: 'integer' }, - str: { type: 'string' } - }}); - - ajv.validate('int', 123) .should.equal(true); - ajv.validate('int', 'foo') .should.equal(false); - ajv.validate('str', 'foo') .should.equal(true); - ajv.validate('str', 123) .should.equal(false); - }); - - it('should add schemas from array', function() { - var ajv = new Ajv({ schemas: [ - { $id: 'int', type: 'integer' }, - { $id: 'str', type: 'string' }, - { $id: 'obj', properties: { int: { $ref: 'int' }, str: { $ref: 'str' } } } - ]}); - - ajv.validate('obj', { int: 123, str: 'foo' }) .should.equal(true); - ajv.validate('obj', { int: 'foo', str: 'bar' }) .should.equal(false); - ajv.validate('obj', { int: 123, str: 456 }) .should.equal(false); - }); - }); - - - describe('format', function() { - it('should not validate formats if option format == false', function() { - var ajv = new Ajv - , ajvFF = new Ajv({ format: false }); - - var schema = { format: 'date-time' }; - var invalideDateTime = '06/19/1963 08:30:06 PST'; - - ajv.validate(schema, invalideDateTime) .should.equal(false); - ajvFF.validate(schema, invalideDateTime) .should.equal(true); - }); - }); - - - describe('formats', function() { - it('should add formats from options', function() { - var ajv = new Ajv({ formats: { - identifier: /^[a-z_$][a-z0-9_$]*$/i - }}); - - var validate = ajv.compile({ format: 'identifier' }); - validate('Abc1') .should.equal(true); - validate('123') .should.equal(false); - validate(123) .should.equal(true); - }); - }); - - - describe('missingRefs', function() { - it('should throw if ref is missing without this option', function() { - var ajv = new Ajv; - should.throw(function() { - ajv.compile({ $ref: 'missing_reference' }); - }); - }); - - it('should not throw and pass validation with missingRef == "ignore"', function() { - testMissingRefsIgnore(new Ajv({ missingRefs: 'ignore' })); - testMissingRefsIgnore(new Ajv({ missingRefs: 'ignore', allErrors: true })); - - function testMissingRefsIgnore(ajv) { - var validate = ajv.compile({ $ref: 'missing_reference' }); - validate({}) .should.equal(true); - } - }); - - it('should not throw and fail validation with missingRef == "fail" if the ref is used', function() { - testMissingRefsFail(new Ajv({ missingRefs: 'fail' })); - testMissingRefsFail(new Ajv({ missingRefs: 'fail', verbose: true })); - testMissingRefsFail(new Ajv({ missingRefs: 'fail', allErrors: true })); - testMissingRefsFail(new Ajv({ missingRefs: 'fail', allErrors: true, verbose: true })); - - function testMissingRefsFail(ajv) { - var validate = ajv.compile({ - anyOf: [ - { type: 'number' }, - { $ref: 'missing_reference' } - ] - }); - validate(123) .should.equal(true); - validate('foo') .should.equal(false); - - validate = ajv.compile({ $ref: 'missing_reference' }); - validate({}) .should.equal(false); - } - }); - }); - - - describe('uniqueItems', function() { - it('should not validate uniqueItems with uniqueItems option == false', function() { - testUniqueItems(new Ajv({ uniqueItems: false })); - testUniqueItems(new Ajv({ uniqueItems: false, allErrors: true })); - - function testUniqueItems(ajv) { - var validate = ajv.compile({ uniqueItems: true }); - validate([1,2,3]) .should.equal(true); - validate([1,1,1]) .should.equal(true); - } - }); - }); - - - describe('unicode', function() { - it('should use String.prototype.length with unicode option == false', function() { - var ajvUnicode = new Ajv; - testUnicode(new Ajv({ unicode: false })); - testUnicode(new Ajv({ unicode: false, allErrors: true })); - - function testUnicode(ajv) { - var validateWithUnicode = ajvUnicode.compile({ minLength: 2 }); - var validate = ajv.compile({ minLength: 2 }); - - validateWithUnicode('😀') .should.equal(false); - validate('😀') .should.equal(true); - - validateWithUnicode = ajvUnicode.compile({ maxLength: 1 }); - validate = ajv.compile({ maxLength: 1 }); - - validateWithUnicode('😀') .should.equal(true); - validate('😀') .should.equal(false); - } - }); - }); - - - describe('verbose', function() { - it('should add schema, parentSchema and data to errors with verbose option == true', function() { - testVerbose(new Ajv({ verbose: true })); - testVerbose(new Ajv({ verbose: true, allErrors: true })); - - function testVerbose(ajv) { - var schema = { properties: { foo: { minimum: 5 } } }; - var validate = ajv.compile(schema); - - var data = { foo: 3 }; - validate(data) .should.equal(false); - validate.errors .should.have.length(1); - var err = validate.errors[0]; - - should.equal(err.schema, 5); - err.parentSchema .should.eql({ minimum: 5 }); - err.parentSchema .should.equal(schema.properties.foo); // by reference - should.equal(err.data, 3); - } - }); - }); - - - describe('multipleOfPrecision', function() { - it('should allow for some deviation from 0 when validating multipleOf with value < 1', function() { - test(new Ajv({ multipleOfPrecision: 7 })); - test(new Ajv({ multipleOfPrecision: 7, allErrors: true })); - - function test(ajv) { - var schema = { multipleOf: 0.01 }; - var validate = ajv.compile(schema); - - validate(4.18) .should.equal(true); - validate(4.181) .should.equal(false); - - schema = { multipleOf: 0.0000001 }; - validate = ajv.compile(schema); - - validate(53.198098) .should.equal(true); - validate(53.1980981) .should.equal(true); - validate(53.19809811) .should.equal(false); - } - }); - }); - - - describe('useDefaults', function() { - it('should replace undefined property with default value', function() { - var instances = getAjvInstances({ - allErrors: true, - loopRequired: 3 - }, { useDefaults: true }); - - instances.forEach(test); - - - function test(ajv) { - var schema = { - properties: { - foo: { type: 'string', default: 'abc' }, - bar: { type: 'number', default: 1 }, - baz: { type: 'boolean', default: false }, - nil: { type: 'null', default: null }, - obj: { type: 'object', default: {} }, - arr: { type: 'array', default: [] } - }, - required: ['foo', 'bar', 'baz', 'nil', 'obj', 'arr'], - minProperties: 6 - }; - - var validate = ajv.compile(schema); - - var data = {}; - validate(data) .should.equal(true); - data .should.eql({ foo: 'abc', bar: 1, baz: false, nil: null, obj: {}, arr:[] }); - - data = { foo: 'foo', bar: 2, obj: { test: true } }; - validate(data) .should.equal(true); - data .should.eql({ foo: 'foo', bar: 2, baz: false, nil: null, obj: { test: true }, arr:[] }); - } - }); - - it('should replace undefined item with default value', function() { - test(new Ajv({ useDefaults: true })); - test(new Ajv({ useDefaults: true, allErrors: true })); - - function test(ajv) { - var schema = { - items: [ - { type: 'string', default: 'abc' }, - { type: 'number', default: 1 }, - { type: 'boolean', default: false } - ], - minItems: 3 - }; - - var validate = ajv.compile(schema); - - var data = []; - validate(data) .should.equal(true); - data .should.eql([ 'abc', 1, false ]); - - data = [ 'foo' ]; - validate(data) .should.equal(true); - data .should.eql([ 'foo', 1, false ]); - - data = ['foo', 2,'false']; - validate(data) .should.equal(false); - validate.errors .should.have.length(1); - data .should.eql([ 'foo', 2, 'false' ]); - } - }); - - it('should apply default in "then" subschema (issue #635)', function() { - test(new Ajv({ useDefaults: true })); - test(new Ajv({ useDefaults: true, allErrors: true })); - - function test(ajv) { - var schema = { - if: { required: ['foo'] }, - then: { - properties: { - bar: { default: 2 } - } - }, - else: { - properties: { - foo: { default: 1 } - } - } - }; - - var validate = ajv.compile(schema); - - var data = {}; - validate(data) .should.equal(true); - data .should.eql({foo: 1}); - - data = {foo: 1}; - validate(data) .should.equal(true); - data .should.eql({foo: 1, bar: 2}); - } - }); - - - describe('useDefaults: by value / by reference', function() { - describe('using by value', function() { - it('should NOT modify underlying defaults when modifying validated data', function() { - test('value', new Ajv({ useDefaults: true })); - test('value', new Ajv({ useDefaults: true, allErrors: true })); - }); - }); - - describe('using by reference', function() { - it('should modify underlying defaults when modifying validated data', function() { - test('reference', new Ajv({ useDefaults: 'shared' })); - test('reference', new Ajv({ useDefaults: 'shared', allErrors: true })); - }); - }); - - function test(useDefaultsMode, ajv) { - var schema = { - properties: { - items: { - type: 'array', - default: ['a-default'] - } - } - }; - - var validate = ajv.compile(schema); - - var data = {}; - validate(data) .should.equal(true); - data.items .should.eql([ 'a-default' ]); - - data.items.push('another-value'); - data.items .should.eql([ 'a-default', 'another-value' ]); - - var data2 = {}; - validate(data2) .should.equal(true); - - if (useDefaultsMode == 'reference') - data2.items .should.eql([ 'a-default', 'another-value' ]); - else if (useDefaultsMode == 'value') - data2.items .should.eql([ 'a-default' ]); - else - throw new Error('unknown useDefaults mode'); - } - }); - }); - - - describe('addUsedSchema', function() { - [true, undefined].forEach(function (optionValue) { - describe('= ' + optionValue, function() { - var ajv; - - beforeEach(function() { - ajv = new Ajv({ addUsedSchema: optionValue }); - }); - - describe('compile and validate', function() { - it('should add schema', function() { - var schema = { $id: 'str', type: 'string' }; - var validate = ajv.compile(schema); - validate('abc') .should.equal(true); - validate(1) .should.equal(false); - ajv.getSchema('str') .should.equal(validate); - - schema = { $id: 'int', type: 'integer' }; - ajv.validate(schema, 1) .should.equal(true); - ajv.validate(schema, 'abc') .should.equal(false); - ajv.getSchema('int') .should.be.a('function'); - }); - - it('should throw with duplicate ID', function() { - ajv.compile({ $id: 'str', type: 'string' }); - should.throw(function() { - ajv.compile({ $id: 'str', minLength: 2 }); - }); - - var schema = { $id: 'int', type: 'integer' }; - var schema2 = { $id: 'int', minimum: 0 }; - ajv.validate(schema, 1) .should.equal(true); - should.throw(function() { - ajv.validate(schema2, 1); - }); - }); - }); - }); - }); - - describe('= false', function() { - var ajv; - - beforeEach(function() { - ajv = new Ajv({ addUsedSchema: false }); - }); - - - describe('compile and validate', function() { - it('should NOT add schema', function() { - var schema = { $id: 'str', type: 'string' }; - var validate = ajv.compile(schema); - validate('abc') .should.equal(true); - validate(1) .should.equal(false); - should.equal(ajv.getSchema('str'), undefined); - - schema = { $id: 'int', type: 'integer' }; - ajv.validate(schema, 1) .should.equal(true); - ajv.validate(schema, 'abc') .should.equal(false); - should.equal(ajv.getSchema('int'), undefined); - }); - - it('should NOT throw with duplicate ID', function() { - ajv.compile({ $id: 'str', type: 'string' }); - should.not.throw(function() { - ajv.compile({ $id: 'str', minLength: 2 }); - }); - - var schema = { $id: 'int', type: 'integer' }; - var schema2 = { $id: 'int', minimum: 0 }; - ajv.validate(schema, 1) .should.equal(true); - should.not.throw(function() { - ajv.validate(schema2, 1) .should.equal(true); - }); - }); - }); - }); - }); - - - describe('passContext', function() { - var ajv, contexts; - - beforeEach(function() { - contexts = []; - }); - - describe('= true', function() { - it('should pass this value as context to custom keyword validation function', function() { - var validate = getValidate(true); - var self = {}; - validate.call(self, {}); - contexts .should.have.length(4); - contexts.forEach(function(ctx) { - ctx .should.equal(self); - }); - }); - }); - - describe('= false', function() { - it('should pass ajv instance as context to custom keyword validation function', function() { - var validate = getValidate(false); - var self = {}; - validate.call(self, {}); - contexts .should.have.length(4); - contexts.forEach(function(ctx) { - ctx .should.equal(ajv); - }); - }); - }); - - function getValidate(passContext) { - ajv = new Ajv({ passContext: passContext, inlineRefs: false }); - ajv.addKeyword('testValidate', { validate: storeContext }); - ajv.addKeyword('testCompile', { compile: compileTestValidate }); - - var schema = { - definitions: { - test1: { - testValidate: true, - testCompile: true, - }, - test2: { - allOf: [ { $ref: '#/definitions/test1' } ] - } - }, - allOf: [ - { $ref: '#/definitions/test1' }, - { $ref: '#/definitions/test2' } - ] - }; - - return ajv.compile(schema); - } - - function storeContext() { - contexts.push(this); - return true; - } - - function compileTestValidate() { - return storeContext; - } - }); - - - describe('allErrors', function() { - it('should be disabled inside "not" keyword', function() { - test(new Ajv, false); - test(new Ajv({ allErrors: true }), true); - - function test(ajv, allErrors) { - var format1called = false - , format2called = false; - - ajv.addFormat('format1', function() { - format1called = true; - return false; - }); - - ajv.addFormat('format2', function() { - format2called = true; - return false; - }); - - var schema1 = { - allOf: [ - { format: 'format1' }, - { format: 'format2' } - ] - }; - - ajv.validate(schema1, 'abc') .should.equal(false); - ajv.errors .should.have.length(allErrors ? 2 : 1); - format1called .should.equal(true); - format2called .should.equal(allErrors); - - var schema2 = { - not: schema1 - }; - - format1called = format2called = false; - ajv.validate(schema2, 'abc') .should.equal(true); - should.equal(ajv.errors, null); - format1called .should.equal(true); - format2called .should.equal(false); - } - }); - }); - - - describe('extendRefs', function() { - describe('= true', function() { - it('should allow extending $ref with other keywords', function() { - test(new Ajv({ extendRefs: true }), true); - }); - - it('should NOT log warning if extendRefs is true', function() { - testWarning(new Ajv({ extendRefs: true })); - }); - }); - - describe('= "ignore" and default', function() { - it('should ignore other keywords when $ref is used', function() { - test(new Ajv); - test(new Ajv({ extendRefs: 'ignore' }), false); - }); - - it('should log warning when other keywords are used with $ref', function() { - testWarning(new Ajv, /keywords\signored/); - testWarning(new Ajv({ extendRefs: 'ignore' }), /keywords\signored/); - }); - }); - - describe('= "fail"', function() { - it('should fail schema compilation if other keywords are used with $ref', function() { - testFail(new Ajv({ extendRefs: 'fail' })); - - function testFail(ajv) { - should.throw(function() { - var schema = { - "definitions": { - "int": { "type": "integer" } - }, - "$ref": "#/definitions/int", - "minimum": 10 - }; - ajv.compile(schema); - }); - - should.not.throw(function() { - var schema = { - "definitions": { - "int": { "type": "integer" } - }, - "allOf": [ - { "$ref": "#/definitions/int" }, - { "minimum": 10 } - ] - }; - ajv.compile(schema); - }); - } - }); - }); - - function test(ajv, shouldExtendRef) { - var schema = { - "definitions": { - "int": { "type": "integer" } - }, - "$ref": "#/definitions/int", - "minimum": 10 - }; - - var validate = ajv.compile(schema); - validate(10) .should.equal(true); - validate(1) .should.equal(!shouldExtendRef); - - schema = { - "definitions": { - "int": { "type": "integer" } - }, - "type": "object", - "properties": { - "foo": { - "$ref": "#/definitions/int", - "minimum": 10 - }, - "bar": { - "allOf": [ - { "$ref": "#/definitions/int" }, - { "minimum": 10 } - ] - } - } - }; - - validate = ajv.compile(schema); - validate({ foo: 10, bar: 10 }) .should.equal(true); - validate({ foo: 1, bar: 10 }) .should.equal(!shouldExtendRef); - validate({ foo: 10, bar: 1 }) .should.equal(false); - } - - function testWarning(ajv, msgPattern) { - var oldConsole; - try { - oldConsole = console.warn; - var consoleMsg; - console.warn = function() { - consoleMsg = Array.prototype.join.call(arguments, ' '); - }; - - var schema = { - "definitions": { - "int": { "type": "integer" } - }, - "$ref": "#/definitions/int", - "minimum": 10 - }; - - ajv.compile(schema); - if (msgPattern) consoleMsg .should.match(msgPattern); - else should.not.exist(consoleMsg); - } finally { - console.warn = oldConsole; - } - } - }); - - - describe('sourceCode', function() { - describe('= true', function() { - it('should add source.code property', function() { - test(new Ajv({sourceCode: true})); - - function test(ajv) { - var validate = ajv.compile({ "type": "number" }); - validate.source.code .should.be.a('string'); - } - }); - }); - - describe('= false and default', function() { - it('should not add source and sourceCode properties', function() { - test(new Ajv); - test(new Ajv({sourceCode: false})); - - function test(ajv) { - var validate = ajv.compile({ "type": "number" }); - should.not.exist(validate.source); - should.not.exist(validate.sourceCode); - } - }); - }); - }); - - - describe('unknownFormats', function() { - describe('= true (default)', function() { - it('should fail schema compilation if unknown format is used', function() { - test(new Ajv); - test(new Ajv({unknownFormats: true})); - - function test(ajv) { - should.throw(function() { - ajv.compile({ format: 'unknown' }); - }); - } - }); - - it('should fail validation if unknown format is used via $data', function() { - test(new Ajv({$data: true})); - test(new Ajv({$data: true, unknownFormats: true})); - - function test(ajv) { - var validate = ajv.compile({ - properties: { - foo: { format: { $data: '1/bar' } }, - bar: { type: 'string' } - } - }); - - validate({foo: 1, bar: 'unknown'}) .should.equal(false); - validate({foo: '2016-10-16', bar: 'date'}) .should.equal(true); - validate({foo: '20161016', bar: 'date'}) .should.equal(false); - validate({foo: '20161016'}) .should.equal(true); - - validate({foo: '2016-10-16', bar: 'unknown'}) .should.equal(false); - } - }); - }); - - describe('= "ignore (default before 5.0.0)"', function() { - it('should pass schema compilation and be valid if unknown format is used', function() { - test(new Ajv({unknownFormats: 'ignore'})); - - function test(ajv) { - var validate = ajv.compile({ format: 'unknown' }); - validate('anything') .should.equal(true); - } - }); - - it('should be valid if unknown format is used via $data', function() { - test(new Ajv({$data: true, unknownFormats: 'ignore'})); - - function test(ajv) { - var validate = ajv.compile({ - properties: { - foo: { format: { $data: '1/bar' } }, - bar: { type: 'string' } - } - }); - - validate({foo: 1, bar: 'unknown'}) .should.equal(true); - validate({foo: '2016-10-16', bar: 'date'}) .should.equal(true); - validate({foo: '20161016', bar: 'date'}) .should.equal(false); - validate({foo: '20161016'}) .should.equal(true); - validate({foo: '2016-10-16', bar: 'unknown'}) .should.equal(true); - } - }); - }); - - describe('= [String]', function() { - it('should pass schema compilation and be valid if whitelisted unknown format is used', function() { - test(new Ajv({unknownFormats: ['allowed']})); - - function test(ajv) { - var validate = ajv.compile({ format: 'allowed' }); - validate('anything') .should.equal(true); - - should.throw(function() { - ajv.compile({ format: 'unknown' }); - }); - } - }); - - it('should be valid if whitelisted unknown format is used via $data', function() { - test(new Ajv({$data: true, unknownFormats: ['allowed']})); - - function test(ajv) { - var validate = ajv.compile({ - properties: { - foo: { format: { $data: '1/bar' } }, - bar: { type: 'string' } - } - }); - - validate({foo: 1, bar: 'allowed'}) .should.equal(true); - validate({foo: 1, bar: 'unknown'}) .should.equal(false); - validate({foo: '2016-10-16', bar: 'date'}) .should.equal(true); - validate({foo: '20161016', bar: 'date'}) .should.equal(false); - validate({foo: '20161016'}) .should.equal(true); - - validate({foo: '2016-10-16', bar: 'allowed'}) .should.equal(true); - validate({foo: '2016-10-16', bar: 'unknown'}) .should.equal(false); - } - }); - }); - }); - - - describe('processCode', function() { - it('should process generated code', function() { - var ajv = new Ajv; - var validate = ajv.compile({type: 'string'}); - validate.toString().split('\n').length .should.equal(1); - - var beautify = require('js-beautify').js_beautify; - var ajvPC = new Ajv({processCode: beautify}); - validate = ajvPC.compile({type: 'string'}); - validate.toString().split('\n').length .should.be.above(1); - validate('foo') .should.equal(true); - validate(1) .should.equal(false); - }); - }); - - - describe('serialize', function() { - var serializeCalled; - - it('should use custom function to serialize schema to string', function() { - serializeCalled = undefined; - var ajv = new Ajv({ serialize: serialize }); - ajv.addSchema({ type: 'string' }); - should.equal(serializeCalled, true); - }); - - function serialize(schema) { - serializeCalled = true; - return JSON.stringify(schema); - } - }); - - - describe('schemaId', function() { - describe('= "$id" (default)', function() { - it('should use $id and ignore id', function() { - test(new Ajv); - test(new Ajv({schemaId: '$id'})); - - function test(ajv) { - ajv.addSchema({ $id: 'mySchema1', type: 'string' }); - var validate = ajv.getSchema('mySchema1'); - validate('foo') .should.equal(true); - validate(1) .should.equal(false); - - validate = ajv.compile({ id: 'mySchema2', type: 'string' }); - should.not.exist(ajv.getSchema('mySchema2')); - } - }); - }); - - describe('= "id"', function() { - it('should use id and ignore $id', function() { - var ajv = new Ajv({schemaId: 'id', meta: false}); - ajv.addMetaSchema(require('../lib/refs/json-schema-draft-04.json')); - ajv._opts.defaultMeta = 'http://json-schema.org/draft-04/schema#'; - - ajv.addSchema({ id: 'mySchema1', type: 'string' }); - var validate = ajv.getSchema('mySchema1'); - validate('foo') .should.equal(true); - validate(1) .should.equal(false); - - validate = ajv.compile({ $id: 'mySchema2', type: 'string' }); - should.not.exist(ajv.getSchema('mySchema2')); - }); - }); - - describe('= "auto"', function() { - it('should use both id and $id', function() { - var ajv = new Ajv({schemaId: 'auto'}); - - ajv.addSchema({ $id: 'mySchema1', type: 'string' }); - var validate = ajv.getSchema('mySchema1'); - validate('foo') .should.equal(true); - validate(1) .should.equal(false); - - ajv.addSchema({ id: 'mySchema2', type: 'string' }); - validate = ajv.getSchema('mySchema2'); - validate('foo') .should.equal(true); - validate(1) .should.equal(false); - }); - - it('should throw if both id and $id are available and different', function() { - var ajv = new Ajv({schemaId: 'auto'}); - - ajv.compile({ - id: 'mySchema', - $id: 'mySchema' - }); - - should.throw(function() { - ajv.compile({ - id: 'mySchema1', - $id: 'mySchema2' - }); - }); - }); - }); - }); - - - describe('$comment', function() { - describe('= true', function() { - var logCalls, consoleLog; - - beforeEach(function () { - consoleLog = console.log; - console.log = log; - }); - - afterEach(function () { - console.log = consoleLog; - }); - - function log() { - logCalls.push(Array.prototype.slice.call(arguments)); - } - - it('should log the text from $comment keyword', function() { - var schema = { - properties: { - foo: {$comment: 'property foo'}, - bar: {$comment: 'property bar', type: 'integer'} - } - }; - - var ajv = new Ajv({$comment: true}); - var fullAjv = new Ajv({allErrors: true, $comment: true}); - - [ajv, fullAjv].forEach(function (_ajv) { - var validate = _ajv.compile(schema); - - test({}, true, []); - test({foo: 1}, true, [['property foo']]); - test({foo: 1, bar: 2}, true, [['property foo'], ['property bar']]); - test({foo: 1, bar: 'baz'}, false, [['property foo'], ['property bar']]); - - function test(data, valid, expectedLogCalls) { - logCalls = []; - validate(data) .should.equal(valid); - logCalls .should.eql(expectedLogCalls); - } - }); - - console.log = consoleLog; - }); - }); - - describe('function hook', function() { - var hookCalls; - - function hook() { - hookCalls.push(Array.prototype.slice.call(arguments)); - } - - it('should pass the text from $comment keyword to the hook', function() { - var schema = { - properties: { - foo: {$comment: 'property foo'}, - bar: {$comment: 'property bar', type: 'integer'} - } - }; - - var ajv = new Ajv({$comment: hook}); - var fullAjv = new Ajv({allErrors: true, $comment: hook}); - - [ajv, fullAjv].forEach(function (_ajv) { - var validate = _ajv.compile(schema); - - test({}, true, []); - test({foo: 1}, true, [['property foo', '#/properties/foo/$comment', schema]]); - test({foo: 1, bar: 2}, true, - [['property foo', '#/properties/foo/$comment', schema], - ['property bar', '#/properties/bar/$comment', schema]]); - test({foo: 1, bar: 'baz'}, false, - [['property foo', '#/properties/foo/$comment', schema], - ['property bar', '#/properties/bar/$comment', schema]]); - - function test(data, valid, expectedHookCalls) { - hookCalls = []; - validate(data) .should.equal(valid); - hookCalls .should.eql(expectedHookCalls); - } - }); - }); - }); - }); - - - describe('logger', function() { - - /** - * The logger option tests are based on the meta scenario which writes into the logger.warn - */ - - var origConsoleWarn = console.warn; - var consoleCalled; - - beforeEach(function() { - consoleCalled = false; - console.warn = function() { - consoleCalled = true; - }; - }); - - afterEach(function() { - console.warn = origConsoleWarn; - }); - - it('no custom logger is given - global console should be used', function() { - var ajv = new Ajv({ - meta: false - }); - - ajv.compile({ - type: 'number', - minimum: 1 - }); - - should.equal(consoleCalled, true); - }); - - it('custom logger is an object - logs should only report to it', function() { - var loggerCalled = false; - - var logger = { - warn: log, - log: log, - error: log - }; - - var ajv = new Ajv({ - meta: false, - logger: logger - }); - - ajv.compile({ - type: 'number', - minimum: 1 - }); - - should.equal(loggerCalled, true); - should.equal(consoleCalled, false); - - function log() { - loggerCalled = true; - } - }); - - it('logger option is false - no logs should be reported', function() { - var ajv = new Ajv({ - meta: false, - logger: false - }); - - ajv.compile({ - type: 'number', - minimum: 1 - }); - - should.equal(consoleCalled, false); - }); - - it('logger option is an object without required methods - an error should be thrown', function() { - (function(){ - new Ajv({ - meta: false, - logger: {} - }); - }).should.throw(Error, /logger must implement log, warn and error methods/); - }); - }); - - - describe('nullable', function() { - var ajv; - - describe('= true', function() { - beforeEach(function () { - ajv = new Ajv({ - nullable: true - }); - }); - - it('should add keyword "nullable"', function() { - testNullable({ - type: 'number', - nullable: true - }); - - testNullable({ - type: ['number'], - nullable: true - }); - - testNullable({ - type: ['number', 'null'] - }); - - testNullable({ - type: ['number', 'null'], - nullable: true - }); - - testNotNullable({type: 'number'}); - - testNotNullable({type: ['number']}); - }); - - it('"nullable" keyword must be "true" if present', function() { - should.throw(function() { - ajv.compile({nullable: false}); - }); - }); - }); - - describe('without option "nullable"', function() { - it('should ignore keyword nullable', function() { - ajv = new Ajv; - - testNotNullable({ - type: 'number', - nullable: true - }); - - testNotNullable({ - type: ['number'], - nullable: true - }); - - testNullable({ - type: ['number', 'null'], - }); - - testNullable({ - type: ['number', 'null'], - nullable: true - }); - - should.not.throw(function () { - ajv.compile({nullable: false}); - }); - }); - }); - - function testNullable(schema) { - var validate = ajv.compile(schema); - validate(1) .should.equal(true); - validate(null) .should.equal(true); - validate('1') .should.equal(false); - } - - function testNotNullable(schema) { - var validate = ajv.compile(schema); - validate(1) .should.equal(true); - validate(null) .should.equal(false); - validate('1') .should.equal(false); - } - }); -}); diff --git a/spec/options/comment.spec.js b/spec/options/comment.spec.js new file mode 100644 index 000000000..efdc98b5e --- /dev/null +++ b/spec/options/comment.spec.js @@ -0,0 +1,92 @@ +'use strict'; + +var Ajv = require('../ajv'); +require('../chai').should(); + + +describe('$comment option', function() { + describe('= true', function() { + var logCalls, consoleLog; + + beforeEach(function () { + consoleLog = console.log; + console.log = log; + }); + + afterEach(function () { + console.log = consoleLog; + }); + + function log() { + logCalls.push(Array.prototype.slice.call(arguments)); + } + + it('should log the text from $comment keyword', function() { + var schema = { + properties: { + foo: {$comment: 'property foo'}, + bar: {$comment: 'property bar', type: 'integer'} + } + }; + + var ajv = new Ajv({$comment: true}); + var fullAjv = new Ajv({allErrors: true, $comment: true}); + + [ajv, fullAjv].forEach(function (_ajv) { + var validate = _ajv.compile(schema); + + test({}, true, []); + test({foo: 1}, true, [['property foo']]); + test({foo: 1, bar: 2}, true, [['property foo'], ['property bar']]); + test({foo: 1, bar: 'baz'}, false, [['property foo'], ['property bar']]); + + function test(data, valid, expectedLogCalls) { + logCalls = []; + validate(data) .should.equal(valid); + logCalls .should.eql(expectedLogCalls); + } + }); + + console.log = consoleLog; + }); + }); + + describe('function hook', function() { + var hookCalls; + + function hook() { + hookCalls.push(Array.prototype.slice.call(arguments)); + } + + it('should pass the text from $comment keyword to the hook', function() { + var schema = { + properties: { + foo: {$comment: 'property foo'}, + bar: {$comment: 'property bar', type: 'integer'} + } + }; + + var ajv = new Ajv({$comment: hook}); + var fullAjv = new Ajv({allErrors: true, $comment: hook}); + + [ajv, fullAjv].forEach(function (_ajv) { + var validate = _ajv.compile(schema); + + test({}, true, []); + test({foo: 1}, true, [['property foo', '#/properties/foo/$comment', schema]]); + test({foo: 1, bar: 2}, true, + [['property foo', '#/properties/foo/$comment', schema], + ['property bar', '#/properties/bar/$comment', schema]]); + test({foo: 1, bar: 'baz'}, false, + [['property foo', '#/properties/foo/$comment', schema], + ['property bar', '#/properties/bar/$comment', schema]]); + + function test(data, valid, expectedHookCalls) { + hookCalls = []; + validate(data) .should.equal(valid); + hookCalls .should.eql(expectedHookCalls); + } + }); + }); + }); +}); diff --git a/spec/options/meta_validateSchema.spec.js b/spec/options/meta_validateSchema.spec.js new file mode 100644 index 000000000..2e287da75 --- /dev/null +++ b/spec/options/meta_validateSchema.spec.js @@ -0,0 +1,79 @@ +'use strict'; + +var Ajv = require('../ajv'); +var should = require('../chai').should(); + + +describe('meta and validateSchema options', function() { + it('should add draft-7 meta schema by default', function() { + testOptionMeta(new Ajv); + testOptionMeta(new Ajv({ meta: true })); + + function testOptionMeta(ajv) { + ajv.getSchema('http://json-schema.org/draft-07/schema') .should.be.a('function'); + ajv.validateSchema({ type: 'integer' }) .should.equal(true); + ajv.validateSchema({ type: 123 }) .should.equal(false); + should.not.throw(function() { ajv.addSchema({ type: 'integer' }); }); + should.throw(function() { ajv.addSchema({ type: 123 }); }); + } + }); + + it('should throw if meta: false and validateSchema: true', function() { + var ajv = new Ajv({ meta: false }); + should.not.exist(ajv.getSchema('http://json-schema.org/draft-07/schema')); + should.not.throw(function() { ajv.addSchema({ type: 'wrong_type' }, 'integer'); }); + }); + + it('should skip schema validation with validateSchema: false', function() { + var ajv = new Ajv; + should.throw(function() { ajv.addSchema({ type: 123 }, 'integer'); }); + + ajv = new Ajv({ validateSchema: false }); + should.not.throw(function() { ajv.addSchema({ type: 123 }, 'integer'); }); + + ajv = new Ajv({ validateSchema: false, meta: false }); + should.not.throw(function() { ajv.addSchema({ type: 123 }, 'integer'); }); + }); + + it('should not throw on invalid schema with validateSchema: "log"', function() { + var logError = console.error; + var loggedError = false; + console.error = function() { loggedError = true; logError.apply(console, arguments); }; + + var ajv = new Ajv({ validateSchema: 'log' }); + should.not.throw(function() { ajv.addSchema({ type: 123 }, 'integer'); }); + loggedError .should.equal(true); + + loggedError = false; + ajv = new Ajv({ validateSchema: 'log', meta: false }); + should.not.throw(function() { ajv.addSchema({ type: 123 }, 'integer'); }); + loggedError .should.equal(false); + console.error = logError; + }); + + it('should validate v6 schema', function() { + var ajv = new Ajv; + ajv.validateSchema({ contains: { minimum: 2 } }) .should.equal(true); + ajv.validateSchema({ contains: 2 }). should.equal(false); + }); + + it('should use option meta as default meta schema', function() { + var meta = { + $schema: 'http://json-schema.org/draft-07/schema', + properties: { + myKeyword: { type: 'boolean' } + } + }; + var ajv = new Ajv({ meta: meta }); + ajv.validateSchema({ myKeyword: true }) .should.equal(true); + ajv.validateSchema({ myKeyword: 2 }) .should.equal(false); + ajv.validateSchema({ + $schema: 'http://json-schema.org/draft-07/schema', + myKeyword: 2 + }) .should.equal(true); + + ajv = new Ajv; + ajv.validateSchema({ myKeyword: true }) .should.equal(true); + ajv.validateSchema({ myKeyword: 2 }) .should.equal(true); + }); +}); diff --git a/spec/options/nullable.spec.js b/spec/options/nullable.spec.js new file mode 100644 index 000000000..df1bda5e4 --- /dev/null +++ b/spec/options/nullable.spec.js @@ -0,0 +1,97 @@ +'use strict'; + +var Ajv = require('../ajv'); +var should = require('../chai').should(); + + +describe('nullable option', function() { + var ajv; + + describe('= true', function() { + beforeEach(function () { + ajv = new Ajv({ + nullable: true + }); + }); + + it('should add keyword "nullable"', function() { + testNullable({ + type: 'number', + nullable: true + }); + + testNullable({ + type: ['number'], + nullable: true + }); + + testNullable({ + type: ['number', 'null'] + }); + + testNullable({ + type: ['number', 'null'], + nullable: true + }); + + testNotNullable({type: 'number'}); + + testNotNullable({type: ['number']}); + }); + + it('should respect "nullable" == false with opts.nullable == true', function() { + testNotNullable({ + type: 'number', + nullable: false + }); + + testNotNullable({ + type: ['number'], + nullable: false + }); + }); + }); + + describe('without option "nullable"', function() { + it('should ignore keyword nullable', function() { + ajv = new Ajv; + + testNotNullable({ + type: 'number', + nullable: true + }); + + testNotNullable({ + type: ['number'], + nullable: true + }); + + testNullable({ + type: ['number', 'null'], + }); + + testNullable({ + type: ['number', 'null'], + nullable: true + }); + + should.not.throw(function () { + ajv.compile({nullable: false}); + }); + }); + }); + + function testNullable(schema) { + var validate = ajv.compile(schema); + validate(1) .should.equal(true); + validate(null) .should.equal(true); + validate('1') .should.equal(false); + } + + function testNotNullable(schema) { + var validate = ajv.compile(schema); + validate(1) .should.equal(true); + validate(null) .should.equal(false); + validate('1') .should.equal(false); + } +}); diff --git a/spec/options/options_add_schemas.spec.js b/spec/options/options_add_schemas.spec.js new file mode 100644 index 000000000..e1a59f236 --- /dev/null +++ b/spec/options/options_add_schemas.spec.js @@ -0,0 +1,130 @@ +'use strict'; + +var Ajv = require('../ajv'); +var should = require('../chai').should(); + + +describe('options to add schemas', function() { + describe('schemas', function() { + it('should add schemas from object', function() { + var ajv = new Ajv({ schemas: { + int: { type: 'integer' }, + str: { type: 'string' } + }}); + + ajv.validate('int', 123) .should.equal(true); + ajv.validate('int', 'foo') .should.equal(false); + ajv.validate('str', 'foo') .should.equal(true); + ajv.validate('str', 123) .should.equal(false); + }); + + it('should add schemas from array', function() { + var ajv = new Ajv({ schemas: [ + { $id: 'int', type: 'integer' }, + { $id: 'str', type: 'string' }, + { $id: 'obj', properties: { int: { $ref: 'int' }, str: { $ref: 'str' } } } + ]}); + + ajv.validate('obj', { int: 123, str: 'foo' }) .should.equal(true); + ajv.validate('obj', { int: 'foo', str: 'bar' }) .should.equal(false); + ajv.validate('obj', { int: 123, str: 456 }) .should.equal(false); + }); + }); + + + describe('addUsedSchema', function() { + [true, undefined].forEach(function (optionValue) { + describe('= ' + optionValue, function() { + var ajv; + + beforeEach(function() { + ajv = new Ajv({ addUsedSchema: optionValue }); + }); + + describe('compile and validate', function() { + it('should add schema', function() { + var schema = { $id: 'str', type: 'string' }; + var validate = ajv.compile(schema); + validate('abc') .should.equal(true); + validate(1) .should.equal(false); + ajv.getSchema('str') .should.equal(validate); + + schema = { $id: 'int', type: 'integer' }; + ajv.validate(schema, 1) .should.equal(true); + ajv.validate(schema, 'abc') .should.equal(false); + ajv.getSchema('int') .should.be.a('function'); + }); + + it('should throw with duplicate ID', function() { + ajv.compile({ $id: 'str', type: 'string' }); + should.throw(function() { + ajv.compile({ $id: 'str', minLength: 2 }); + }); + + var schema = { $id: 'int', type: 'integer' }; + var schema2 = { $id: 'int', minimum: 0 }; + ajv.validate(schema, 1) .should.equal(true); + should.throw(function() { + ajv.validate(schema2, 1); + }); + }); + }); + }); + }); + + describe('= false', function() { + var ajv; + + beforeEach(function() { + ajv = new Ajv({ addUsedSchema: false }); + }); + + + describe('compile and validate', function() { + it('should NOT add schema', function() { + var schema = { $id: 'str', type: 'string' }; + var validate = ajv.compile(schema); + validate('abc') .should.equal(true); + validate(1) .should.equal(false); + should.equal(ajv.getSchema('str'), undefined); + + schema = { $id: 'int', type: 'integer' }; + ajv.validate(schema, 1) .should.equal(true); + ajv.validate(schema, 'abc') .should.equal(false); + should.equal(ajv.getSchema('int'), undefined); + }); + + it('should NOT throw with duplicate ID', function() { + ajv.compile({ $id: 'str', type: 'string' }); + should.not.throw(function() { + ajv.compile({ $id: 'str', minLength: 2 }); + }); + + var schema = { $id: 'int', type: 'integer' }; + var schema2 = { $id: 'int', minimum: 0 }; + ajv.validate(schema, 1) .should.equal(true); + should.not.throw(function() { + ajv.validate(schema2, 1) .should.equal(true); + }); + }); + }); + }); + }); + + + describe('serialize', function() { + var serializeCalled; + + it('should use custom function to serialize schema to string', function() { + serializeCalled = undefined; + var ajv = new Ajv({ serialize: serialize }); + ajv.addSchema({ type: 'string' }); + should.equal(serializeCalled, true); + }); + + function serialize(schema) { + serializeCalled = true; + return JSON.stringify(schema); + } + }); +}); diff --git a/spec/options/options_code.spec.js b/spec/options/options_code.spec.js new file mode 100644 index 000000000..8884c8c4c --- /dev/null +++ b/spec/options/options_code.spec.js @@ -0,0 +1,115 @@ +'use strict'; + +var Ajv = require('../ajv'); +var should = require('../chai').should(); + + +describe('code generation options', function () { + describe('sourceCode', function() { + describe('= true', function() { + it('should add source.code property', function() { + test(new Ajv({sourceCode: true})); + + function test(ajv) { + var validate = ajv.compile({ "type": "number" }); + validate.source.code .should.be.a('string'); + } + }); + }); + + describe('= false and default', function() { + it('should not add source and sourceCode properties', function() { + test(new Ajv); + test(new Ajv({sourceCode: false})); + + function test(ajv) { + var validate = ajv.compile({ "type": "number" }); + should.not.exist(validate.source); + should.not.exist(validate.sourceCode); + } + }); + }); + }); + + + describe('processCode', function() { + it('should process generated code', function() { + var ajv = new Ajv; + var validate = ajv.compile({type: 'string'}); + validate.toString().split('\n').length .should.equal(1); + + var beautify = require('js-beautify').js_beautify; + var ajvPC = new Ajv({processCode: beautify}); + validate = ajvPC.compile({type: 'string'}); + validate.toString().split('\n').length .should.be.above(1); + validate('foo') .should.equal(true); + validate(1) .should.equal(false); + }); + }); + + + describe('passContext option', function() { + var ajv, contexts; + + beforeEach(function() { + contexts = []; + }); + + describe('= true', function() { + it('should pass this value as context to custom keyword validation function', function() { + var validate = getValidate(true); + var self = {}; + validate.call(self, {}); + contexts .should.have.length(4); + contexts.forEach(function(ctx) { + ctx .should.equal(self); + }); + }); + }); + + describe('= false', function() { + it('should pass ajv instance as context to custom keyword validation function', function() { + var validate = getValidate(false); + var self = {}; + validate.call(self, {}); + contexts .should.have.length(4); + contexts.forEach(function(ctx) { + ctx .should.equal(ajv); + }); + }); + }); + + function getValidate(passContext) { + ajv = new Ajv({ passContext: passContext, inlineRefs: false }); + ajv.addKeyword('testValidate', { validate: storeContext }); + ajv.addKeyword('testCompile', { compile: compileTestValidate }); + + var schema = { + definitions: { + test1: { + testValidate: true, + testCompile: true, + }, + test2: { + allOf: [ { $ref: '#/definitions/test1' } ] + } + }, + allOf: [ + { $ref: '#/definitions/test1' }, + { $ref: '#/definitions/test2' } + ] + }; + + return ajv.compile(schema); + } + + function storeContext() { + contexts.push(this); + return true; + } + + function compileTestValidate() { + return storeContext; + } + }); +}); diff --git a/spec/options/options_refs.spec.js b/spec/options/options_refs.spec.js new file mode 100644 index 000000000..1f1d20a75 --- /dev/null +++ b/spec/options/options_refs.spec.js @@ -0,0 +1,167 @@ +'use strict'; + +var Ajv = require('../ajv'); +var should = require('../chai').should(); + + +describe('referenced schema options', function() { + describe('extendRefs', function() { + describe('= true', function() { + it('should allow extending $ref with other keywords', function() { + test(new Ajv({ extendRefs: true }), true); + }); + + it('should NOT log warning if extendRefs is true', function() { + testWarning(new Ajv({ extendRefs: true })); + }); + }); + + describe('= "ignore" and default', function() { + it('should ignore other keywords when $ref is used', function() { + test(new Ajv); + test(new Ajv({ extendRefs: 'ignore' }), false); + }); + + it('should log warning when other keywords are used with $ref', function() { + testWarning(new Ajv, /keywords\signored/); + testWarning(new Ajv({ extendRefs: 'ignore' }), /keywords\signored/); + }); + }); + + describe('= "fail"', function() { + it('should fail schema compilation if other keywords are used with $ref', function() { + testFail(new Ajv({ extendRefs: 'fail' })); + + function testFail(ajv) { + should.throw(function() { + var schema = { + "definitions": { + "int": { "type": "integer" } + }, + "$ref": "#/definitions/int", + "minimum": 10 + }; + ajv.compile(schema); + }); + + should.not.throw(function() { + var schema = { + "definitions": { + "int": { "type": "integer" } + }, + "allOf": [ + { "$ref": "#/definitions/int" }, + { "minimum": 10 } + ] + }; + ajv.compile(schema); + }); + } + }); + }); + + function test(ajv, shouldExtendRef) { + var schema = { + "definitions": { + "int": { "type": "integer" } + }, + "$ref": "#/definitions/int", + "minimum": 10 + }; + + var validate = ajv.compile(schema); + validate(10) .should.equal(true); + validate(1) .should.equal(!shouldExtendRef); + + schema = { + "definitions": { + "int": { "type": "integer" } + }, + "type": "object", + "properties": { + "foo": { + "$ref": "#/definitions/int", + "minimum": 10 + }, + "bar": { + "allOf": [ + { "$ref": "#/definitions/int" }, + { "minimum": 10 } + ] + } + } + }; + + validate = ajv.compile(schema); + validate({ foo: 10, bar: 10 }) .should.equal(true); + validate({ foo: 1, bar: 10 }) .should.equal(!shouldExtendRef); + validate({ foo: 10, bar: 1 }) .should.equal(false); + } + + function testWarning(ajv, msgPattern) { + var oldConsole; + try { + oldConsole = console.warn; + var consoleMsg; + console.warn = function() { + consoleMsg = Array.prototype.join.call(arguments, ' '); + }; + + var schema = { + "definitions": { + "int": { "type": "integer" } + }, + "$ref": "#/definitions/int", + "minimum": 10 + }; + + ajv.compile(schema); + if (msgPattern) consoleMsg .should.match(msgPattern); + else should.not.exist(consoleMsg); + } finally { + console.warn = oldConsole; + } + } + }); + + + describe('missingRefs', function() { + it('should throw if ref is missing without this option', function() { + var ajv = new Ajv; + should.throw(function() { + ajv.compile({ $ref: 'missing_reference' }); + }); + }); + + it('should not throw and pass validation with missingRef == "ignore"', function() { + testMissingRefsIgnore(new Ajv({ missingRefs: 'ignore' })); + testMissingRefsIgnore(new Ajv({ missingRefs: 'ignore', allErrors: true })); + + function testMissingRefsIgnore(ajv) { + var validate = ajv.compile({ $ref: 'missing_reference' }); + validate({}) .should.equal(true); + } + }); + + it('should not throw and fail validation with missingRef == "fail" if the ref is used', function() { + testMissingRefsFail(new Ajv({ missingRefs: 'fail' })); + testMissingRefsFail(new Ajv({ missingRefs: 'fail', verbose: true })); + testMissingRefsFail(new Ajv({ missingRefs: 'fail', allErrors: true })); + testMissingRefsFail(new Ajv({ missingRefs: 'fail', allErrors: true, verbose: true })); + + function testMissingRefsFail(ajv) { + var validate = ajv.compile({ + anyOf: [ + { type: 'number' }, + { $ref: 'missing_reference' } + ] + }); + validate(123) .should.equal(true); + validate('foo') .should.equal(false); + + validate = ajv.compile({ $ref: 'missing_reference' }); + validate({}) .should.equal(false); + } + }); + }); +}); diff --git a/spec/options/options_reporting.spec.js b/spec/options/options_reporting.spec.js new file mode 100644 index 000000000..578611e80 --- /dev/null +++ b/spec/options/options_reporting.spec.js @@ -0,0 +1,158 @@ +'use strict'; + +var Ajv = require('../ajv'); +var should = require('../chai').should(); + + +describe('reporting options', function () { + describe('verbose', function() { + it('should add schema, parentSchema and data to errors with verbose option == true', function() { + testVerbose(new Ajv({ verbose: true })); + testVerbose(new Ajv({ verbose: true, allErrors: true })); + + function testVerbose(ajv) { + var schema = { properties: { foo: { minimum: 5 } } }; + var validate = ajv.compile(schema); + + var data = { foo: 3 }; + validate(data) .should.equal(false); + validate.errors .should.have.length(1); + var err = validate.errors[0]; + + should.equal(err.schema, 5); + err.parentSchema .should.eql({ minimum: 5 }); + err.parentSchema .should.equal(schema.properties.foo); // by reference + should.equal(err.data, 3); + } + }); + }); + + + describe('allErrors', function() { + it('should be disabled inside "not" keyword', function() { + test(new Ajv, false); + test(new Ajv({ allErrors: true }), true); + + function test(ajv, allErrors) { + var format1called = false + , format2called = false; + + ajv.addFormat('format1', function() { + format1called = true; + return false; + }); + + ajv.addFormat('format2', function() { + format2called = true; + return false; + }); + + var schema1 = { + allOf: [ + { format: 'format1' }, + { format: 'format2' } + ] + }; + + ajv.validate(schema1, 'abc') .should.equal(false); + ajv.errors .should.have.length(allErrors ? 2 : 1); + format1called .should.equal(true); + format2called .should.equal(allErrors); + + var schema2 = { + not: schema1 + }; + + format1called = format2called = false; + ajv.validate(schema2, 'abc') .should.equal(true); + should.equal(ajv.errors, null); + format1called .should.equal(true); + format2called .should.equal(false); + } + }); + }); + + + describe('logger', function() { + /** + * The logger option tests are based on the meta scenario which writes into the logger.warn + */ + + var origConsoleWarn = console.warn; + var consoleCalled; + + beforeEach(function() { + consoleCalled = false; + console.warn = function() { + consoleCalled = true; + }; + }); + + afterEach(function() { + console.warn = origConsoleWarn; + }); + + it('no custom logger is given - global console should be used', function() { + var ajv = new Ajv({ + meta: false + }); + + ajv.compile({ + type: 'number', + minimum: 1 + }); + + should.equal(consoleCalled, true); + }); + + it('custom logger is an object - logs should only report to it', function() { + var loggerCalled = false; + + var logger = { + warn: log, + log: log, + error: log + }; + + var ajv = new Ajv({ + meta: false, + logger: logger + }); + + ajv.compile({ + type: 'number', + minimum: 1 + }); + + should.equal(loggerCalled, true); + should.equal(consoleCalled, false); + + function log() { + loggerCalled = true; + } + }); + + it('logger option is false - no logs should be reported', function() { + var ajv = new Ajv({ + meta: false, + logger: false + }); + + ajv.compile({ + type: 'number', + minimum: 1 + }); + + should.equal(consoleCalled, false); + }); + + it('logger option is an object without required methods - an error should be thrown', function() { + (function(){ + new Ajv({ + meta: false, + logger: {} + }); + }).should.throw(Error, /logger must implement log, warn and error methods/); + }); + }); +}); diff --git a/spec/options/options_validation.spec.js b/spec/options/options_validation.spec.js new file mode 100644 index 000000000..950a0c289 --- /dev/null +++ b/spec/options/options_validation.spec.js @@ -0,0 +1,116 @@ +'use strict'; + +var Ajv = require('../ajv'); +require('../chai').should(); + + +describe('validation options', function() { + describe('format', function() { + it('should not validate formats if option format == false', function() { + var ajv = new Ajv + , ajvFF = new Ajv({ format: false }); + + var schema = { format: 'date-time' }; + var invalideDateTime = '06/19/1963 08:30:06 PST'; + + ajv.validate(schema, invalideDateTime) .should.equal(false); + ajvFF.validate(schema, invalideDateTime) .should.equal(true); + }); + }); + + + describe('formats', function() { + it('should add formats from options', function() { + var ajv = new Ajv({ formats: { + identifier: /^[a-z_$][a-z0-9_$]*$/i + }}); + + var validate = ajv.compile({ format: 'identifier' }); + + validate('Abc1') .should.equal(true); + validate('foo bar') .should.equal(false); + validate('123') .should.equal(false); + validate(123) .should.equal(true); + }); + }); + + describe('keywords', function() { + it('should add keywords from options', function() { + var ajv = new Ajv({ keywords: { + identifier: { + type: 'string', + validate: function (schema, data ) { + return /^[a-z_$][a-z0-9_$]*$/i.test(data); + } + } + }}); + + var validate = ajv.compile({ identifier: true }); + + validate('Abc1') .should.equal(true); + validate('foo bar') .should.equal(false); + validate('123') .should.equal(false); + validate(123) .should.equal(true); + }); + }); + + + describe('uniqueItems', function() { + it('should not validate uniqueItems with uniqueItems option == false', function() { + testUniqueItems(new Ajv({ uniqueItems: false })); + testUniqueItems(new Ajv({ uniqueItems: false, allErrors: true })); + + function testUniqueItems(ajv) { + var validate = ajv.compile({ uniqueItems: true }); + validate([1,2,3]) .should.equal(true); + validate([1,1,1]) .should.equal(true); + } + }); + }); + + + describe('unicode', function() { + it('should use String.prototype.length with unicode option == false', function() { + var ajvUnicode = new Ajv; + testUnicode(new Ajv({ unicode: false })); + testUnicode(new Ajv({ unicode: false, allErrors: true })); + + function testUnicode(ajv) { + var validateWithUnicode = ajvUnicode.compile({ minLength: 2 }); + var validate = ajv.compile({ minLength: 2 }); + + validateWithUnicode('😀') .should.equal(false); + validate('😀') .should.equal(true); + + validateWithUnicode = ajvUnicode.compile({ maxLength: 1 }); + validate = ajv.compile({ maxLength: 1 }); + + validateWithUnicode('😀') .should.equal(true); + validate('😀') .should.equal(false); + } + }); + }); + + + describe('multipleOfPrecision', function() { + it('should allow for some deviation from 0 when validating multipleOf with value < 1', function() { + test(new Ajv({ multipleOfPrecision: 7 })); + test(new Ajv({ multipleOfPrecision: 7, allErrors: true })); + + function test(ajv) { + var schema = { multipleOf: 0.01 }; + var validate = ajv.compile(schema); + + validate(4.18) .should.equal(true); + validate(4.181) .should.equal(false); + + schema = { multipleOf: 0.0000001 }; + validate = ajv.compile(schema); + + validate(53.198098) .should.equal(true); + validate(53.1980981) .should.equal(true); + validate(53.19809811) .should.equal(false); + } + }); + }); +}); diff --git a/spec/options/ownProperties.spec.js b/spec/options/ownProperties.spec.js new file mode 100644 index 000000000..312579f96 --- /dev/null +++ b/spec/options/ownProperties.spec.js @@ -0,0 +1,178 @@ +'use strict'; + +var Ajv = require('../ajv'); +require('../chai').should(); + + +describe('ownProperties option', function() { + var ajv, ajvOP, ajvOP1; + + beforeEach(function() { + ajv = new Ajv({ allErrors: true }); + ajvOP = new Ajv({ ownProperties: true, allErrors: true }); + ajvOP1 = new Ajv({ ownProperties: true }); + }); + + it('should only validate own properties with additionalProperties', function() { + var schema = { + properties: { a: { type: 'number' } }, + additionalProperties: false + }; + + var obj = { a: 1 }; + var proto = { b: 2 }; + test(schema, obj, proto); + }); + + it('should only validate own properties with properties keyword', function() { + var schema = { + properties: { + a: { type: 'number' }, + b: { type: 'number' } + } + }; + + var obj = { a: 1 }; + var proto = { b: 'not a number' }; + test(schema, obj, proto); + }); + + it('should only validate own properties with required keyword', function() { + var schema = { + required: ['a', 'b'] + }; + + var obj = { a: 1 }; + var proto = { b: 2 }; + test(schema, obj, proto, 1, true); + }); + + it('should only validate own properties with required keyword - many properties', function() { + ajv = new Ajv({ allErrors: true, loopRequired: 1 }); + ajvOP = new Ajv({ ownProperties: true, allErrors: true, loopRequired: 1 }); + ajvOP1 = new Ajv({ ownProperties: true, loopRequired: 1 }); + + var schema = { + required: ['a', 'b', 'c', 'd'] + }; + + var obj = { a: 1, b: 2 }; + var proto = { c: 3, d: 4 }; + test(schema, obj, proto, 2, true); + }); + + it('should only validate own properties with required keyword as $data', function() { + ajv = new Ajv({ allErrors: true, $data: true }); + ajvOP = new Ajv({ ownProperties: true, allErrors: true, $data: true }); + ajvOP1 = new Ajv({ ownProperties: true, $data: true }); + + var schema = { + required: { $data: '0/req' }, + properties: { + req: { + type: 'array', + items: { type: 'string' } + } + } + }; + + var obj = { + req: ['a', 'b'], + a: 1 + }; + var proto = { b: 2 }; + test(schema, obj, proto, 1, true); + }); + + it('should only validate own properties with properties and required keyword', function() { + var schema = { + properties: { + a: { type: 'number' }, + b: { type: 'number' } + }, + required: ['a', 'b'] + }; + + var obj = { a: 1 }; + var proto = { b: 2 }; + test(schema, obj, proto, 1, true); + }); + + it('should only validate own properties with dependencies keyword', function() { + var schema = { + dependencies: { + a: ['c'], + b: ['d'] + } + }; + + var obj = { a: 1, c: 3 }; + var proto = { b: 2 }; + test(schema, obj, proto); + + obj = { a: 1, b: 2, c: 3 }; + proto = { d: 4 }; + test(schema, obj, proto, 1, true); + }); + + it('should only validate own properties with schema dependencies', function() { + var schema = { + dependencies: { + a: { not: { required: ['c'] } }, + b: { not: { required: ['d'] } } + } + }; + + var obj = { a: 1, d: 3 }; + var proto = { b: 2 }; + test(schema, obj, proto); + + obj = { a: 1, b: 2 }; + proto = { d: 4 }; + test(schema, obj, proto); + }); + + it('should only validate own properties with patternProperties', function() { + var schema = { + patternProperties: { 'f.*o': { type: 'integer' } }, + }; + + var obj = { fooo: 1 }; + var proto = { foo: 'not a number' }; + test(schema, obj, proto); + }); + + it('should only validate own properties with propertyNames', function() { + var schema = { + propertyNames: { + format: 'email' + } + }; + + var obj = { 'e@example.com': 2 }; + var proto = { 'not email': 1 }; + test(schema, obj, proto, 2); + }); + + function test(schema, obj, proto, errors, reverse) { + errors = errors || 1; + var validate = ajv.compile(schema); + var validateOP = ajvOP.compile(schema); + var validateOP1 = ajvOP1.compile(schema); + var data = Object.create(proto); + for (var key in obj) data[key] = obj[key]; + + if (reverse) { + validate(data) .should.equal(true); + validateOP(data) .should.equal(false); + validateOP.errors .should.have.length(errors); + validateOP1(data) .should.equal(false); + validateOP1.errors .should.have.length(1); + } else { + validate(data) .should.equal(false); + validate.errors .should.have.length(errors); + validateOP(data) .should.equal(true); + validateOP1(data) .should.equal(true); + } + } +}); diff --git a/spec/options/removeAdditional.spec.js b/spec/options/removeAdditional.spec.js new file mode 100644 index 000000000..1eef0b795 --- /dev/null +++ b/spec/options/removeAdditional.spec.js @@ -0,0 +1,122 @@ +'use strict'; + +var Ajv = require('../ajv'); +require('../chai').should(); + + +describe('removeAdditional option', function() { + it('should remove all additional properties', function() { + var ajv = new Ajv({ removeAdditional: 'all' }); + + ajv.addSchema({ + $id: '//test/fooBar', + properties: { foo: { type: 'string' }, bar: { type: 'string' } } + }); + + var object = { + foo: 'foo', bar: 'bar', baz: 'baz-to-be-removed' + }; + + ajv.validate('//test/fooBar', object).should.equal(true); + object.should.have.property('foo'); + object.should.have.property('bar'); + object.should.not.have.property('baz'); + }); + + + it('should remove properties that would error when `additionalProperties = false`', function() { + var ajv = new Ajv({ removeAdditional: true }); + + ajv.addSchema({ + $id: '//test/fooBar', + properties: { foo: { type: 'string' }, bar: { type: 'string' } }, + additionalProperties: false + }); + + var object = { + foo: 'foo', bar: 'bar', baz: 'baz-to-be-removed' + }; + + ajv.validate('//test/fooBar', object).should.equal(true); + object.should.have.property('foo'); + object.should.have.property('bar'); + object.should.not.have.property('baz'); + }); + + + it('should remove properties that would error when `additionalProperties = false` (many properties, boolean schema)', function() { + var ajv = new Ajv({removeAdditional: true}); + + var schema = { + properties: { + obj: { + additionalProperties: false, + properties: { + a: { type: 'string' }, + b: false, + c: { type: 'string' }, + d: { type: 'string' }, + e: { type: 'string' }, + f: { type: 'string' }, + g: { type: 'string' }, + h: { type: 'string' }, + i: { type: 'string' } + } + } + } + }; + + var data = { + obj: { + a: 'valid', + b: 'should not be removed', + additional: 'will be removed' + } + }; + + ajv.validate(schema, data) .should.equal(false); + data .should.eql({ + obj: { + a: 'valid', + b: 'should not be removed' + } + }); + }); + + + it('should remove properties that would error when `additionalProperties` is a schema', function() { + var ajv = new Ajv({ removeAdditional: 'failing' }); + + ajv.addSchema({ + $id: '//test/fooBar', + properties: { foo: { type: 'string' }, bar: { type: 'string' } }, + additionalProperties: { type: 'string' } + }); + + var object = { + foo: 'foo', bar: 'bar', baz: 'baz-to-be-kept', fizz: 1000 + }; + + ajv.validate('//test/fooBar', object).should.equal(true); + object.should.have.property('foo'); + object.should.have.property('bar'); + object.should.have.property('baz'); + object.should.not.have.property('fizz'); + + ajv.addSchema({ + $id: '//test/fooBar2', + properties: { foo: { type: 'string' }, bar: { type: 'string' } }, + additionalProperties: { type: 'string', pattern: '^to-be-', maxLength: 10 } + }); + + object = { + foo: 'foo', bar: 'bar', baz: 'to-be-kept', quux: 'to-be-removed', fizz: 1000 + }; + + ajv.validate('//test/fooBar2', object).should.equal(true); + object.should.have.property('foo'); + object.should.have.property('bar'); + object.should.have.property('baz'); + object.should.not.have.property('fizz'); + }); +}); diff --git a/spec/options/schemaId.spec.js b/spec/options/schemaId.spec.js new file mode 100644 index 000000000..f8871034f --- /dev/null +++ b/spec/options/schemaId.spec.js @@ -0,0 +1,72 @@ +'use strict'; + +var Ajv = require('../ajv'); +var should = require('../chai').should(); + + +describe('schemaId option', function() { + describe('= "$id" (default)', function() { + it('should use $id and ignore id', function() { + test(new Ajv); + test(new Ajv({schemaId: '$id'})); + + function test(ajv) { + ajv.addSchema({ $id: 'mySchema1', type: 'string' }); + var validate = ajv.getSchema('mySchema1'); + validate('foo') .should.equal(true); + validate(1) .should.equal(false); + + validate = ajv.compile({ id: 'mySchema2', type: 'string' }); + should.not.exist(ajv.getSchema('mySchema2')); + } + }); + }); + + describe('= "id"', function() { + it('should use id and ignore $id', function() { + var ajv = new Ajv({schemaId: 'id', meta: false}); + ajv.addMetaSchema(require('../../lib/refs/json-schema-draft-04.json')); + ajv._opts.defaultMeta = 'http://json-schema.org/draft-04/schema#'; + + ajv.addSchema({ id: 'mySchema1', type: 'string' }); + var validate = ajv.getSchema('mySchema1'); + validate('foo') .should.equal(true); + validate(1) .should.equal(false); + + validate = ajv.compile({ $id: 'mySchema2', type: 'string' }); + should.not.exist(ajv.getSchema('mySchema2')); + }); + }); + + describe('= "auto"', function() { + it('should use both id and $id', function() { + var ajv = new Ajv({schemaId: 'auto'}); + + ajv.addSchema({ $id: 'mySchema1', type: 'string' }); + var validate = ajv.getSchema('mySchema1'); + validate('foo') .should.equal(true); + validate(1) .should.equal(false); + + ajv.addSchema({ id: 'mySchema2', type: 'string' }); + validate = ajv.getSchema('mySchema2'); + validate('foo') .should.equal(true); + validate(1) .should.equal(false); + }); + + it('should throw if both id and $id are available and different', function() { + var ajv = new Ajv({schemaId: 'auto'}); + + ajv.compile({ + id: 'mySchema', + $id: 'mySchema' + }); + + should.throw(function() { + ajv.compile({ + id: 'mySchema1', + $id: 'mySchema2' + }); + }); + }); + }); +}); diff --git a/spec/options/strictDefaults.spec.js b/spec/options/strictDefaults.spec.js new file mode 100644 index 000000000..1f1093a69 --- /dev/null +++ b/spec/options/strictDefaults.spec.js @@ -0,0 +1,165 @@ +'use strict'; + +var Ajv = require('../ajv'); +var should = require('../chai').should(); + + +describe('strictDefaults option', function() { + describe('useDefaults = true', function() { + describe('strictDefaults = false', function() { + it('should NOT throw an error or log a warning given an ignored default', function() { + var output = {}; + var ajv = new Ajv({ + useDefaults: true, + strictDefaults: false, + logger: getLogger(output) + }); + var schema = { + default: 5, + properties: {} + }; + + ajv.compile(schema); + should.not.exist(output.warning); + }); + + it('should NOT throw an error or log a warning given an ignored default', function() { + var output = {}; + var ajv = new Ajv({ + useDefaults: true, + strictDefaults: false, + logger: getLogger(output) + }); + var schema = { + oneOf: [ + { enum: ['foo', 'bar'] }, + { + properties: { + foo: { + default: true + } + } + } + ] + }; + + ajv.compile(schema); + should.not.exist(output.warning); + }); + }); + + describe('strictDefaults = true', function() { + it('should throw an error given an ignored default in the schema root when strictDefaults is true', function() { + var ajv = new Ajv({useDefaults: true, strictDefaults: true}); + var schema = { + default: 5, + properties: {} + }; + should.throw(function() { ajv.compile(schema); }); + }); + + it('should throw an error given an ignored default in oneOf when strictDefaults is true', function() { + var ajv = new Ajv({useDefaults: true, strictDefaults: true}); + var schema = { + oneOf: [ + { enum: ['foo', 'bar'] }, + { + properties: { + foo: { + default: true + } + } + } + ] + }; + should.throw(function() { ajv.compile(schema); }); + }); + }); + + describe('strictDefaults = "log"', function() { + it('should log a warning given an ignored default in the schema root when strictDefaults is "log"', function() { + var output = {}; + var ajv = new Ajv({ + useDefaults: true, + strictDefaults: 'log', + logger: getLogger(output) + }); + var schema = { + default: 5, + properties: {} + }; + ajv.compile(schema); + should.equal(output.warning, 'default is ignored in the schema root'); + }); + + it('should log a warning given an ignored default in oneOf when strictDefaults is "log"', function() { + var output = {}; + var ajv = new Ajv({ + useDefaults: true, + strictDefaults: 'log', + logger: getLogger(output) + }); + var schema = { + oneOf: [ + { enum: ['foo', 'bar'] }, + { + properties: { + foo: { + default: true + } + } + } + ] + }; + ajv.compile(schema); + should.equal(output.warning, 'default is ignored for: data.foo'); + }); + }); + }); + + + describe('useDefaults = false', function() { + describe('strictDefaults = true', function() { + it('should NOT throw an error given an ignored default in the schema root when useDefaults is false', function() { + var ajv = new Ajv({useDefaults: false, strictDefaults: true}); + var schema = { + default: 5, + properties: {} + }; + should.not.throw(function() { ajv.compile(schema); }); + }); + + it('should NOT throw an error given an ignored default in oneOf when useDefaults is false', function() { + var ajv = new Ajv({useDefaults: false, strictDefaults: true}); + var schema = { + oneOf: [ + { enum: ['foo', 'bar'] }, + { + properties: { + foo: { + default: true + } + } + } + ] + }; + should.not.throw(function() { ajv.compile(schema); }); + }); + }); + }); + + + function getLogger(output) { + return { + log: function() { + throw new Error('log should not be called'); + }, + warn: function(warning) { + output.warning = warning; + }, + error: function() { + throw new Error('error should not be called'); + } + }; + } +}); diff --git a/spec/options/strictKeywords.spec.js b/spec/options/strictKeywords.spec.js new file mode 100644 index 000000000..4895b78e4 --- /dev/null +++ b/spec/options/strictKeywords.spec.js @@ -0,0 +1,79 @@ +'use strict'; + +var Ajv = require('../ajv'); +var should = require('../chai').should(); + + +describe('strictKeywords option', function() { + describe('strictKeywords = false', function() { + it('should NOT throw an error or log a warning given an unknown keyword', function() { + var output = {}; + var ajv = new Ajv({ + strictKeywords: false, + logger: getLogger(output) + }); + var schema = { + properties: {}, + unknownKeyword: 1 + }; + + ajv.compile(schema); + should.not.exist(output.warning); + }); + }); + + describe('strictKeywords = true', function() { + it('should throw an error given an unknown keyword in the schema root when strictKeywords is true', function() { + var ajv = new Ajv({strictKeywords: true}); + var schema = { + properties: {}, + unknownKeyword: 1 + }; + should.throw(function() { ajv.compile(schema); }); + }); + }); + + describe('strictKeywords = "log"', function() { + it('should log a warning given an unknown keyword in the schema root when strictKeywords is "log"', function() { + var output = {}; + var ajv = new Ajv({ + strictKeywords: 'log', + logger: getLogger(output) + }); + var schema = { + properties: {}, + unknownKeyword: 1 + }; + ajv.compile(schema); + should.equal(output.warning, 'unknown keyword: unknownKeyword'); + }); + }); + + describe('unknown keyword inside schema that has no known keyword in compound keyword', function() { + it('should throw an error given an unknown keyword when strictKeywords is true', function() { + var ajv = new Ajv({strictKeywords: true}); + var schema = { + anyOf: [ + { + unknownKeyword: 1 + } + ] + }; + should.throw(function() { ajv.compile(schema); }); + }); + }); + + function getLogger(output) { + return { + log: function() { + throw new Error('log should not be called'); + }, + warn: function(warning) { + output.warning = warning; + }, + error: function() { + throw new Error('error should not be called'); + } + }; + } +}); diff --git a/spec/options/strictNumbers.spec.js b/spec/options/strictNumbers.spec.js new file mode 100644 index 000000000..adf63b026 --- /dev/null +++ b/spec/options/strictNumbers.spec.js @@ -0,0 +1,55 @@ +'use strict'; + +var Ajv = require('../ajv'); + +describe('structNumbers option', function() { + var ajv; + describe('strictNumbers default', testWithoutStrictNumbers(new Ajv())); + describe('strictNumbers = false', testWithoutStrictNumbers(new Ajv({strictNumbers: false}))); + describe('strictNumbers = true', function() { + beforeEach(function () { + ajv = new Ajv({strictNumbers: true}); + }); + + it('should fail validation for NaN/Infinity as type number', function() { + var validate = ajv.compile({type: 'number'}); + validate("1.1").should.equal(false); + validate(1.1).should.equal(true); + validate(1).should.equal(true); + validate(NaN).should.equal(false); + validate(Infinity).should.equal(false); + }); + + it('should fail validation for NaN as type integer', function() { + var validate = ajv.compile({type: 'integer'}); + validate("1.1").should.equal(false); + validate(1.1).should.equal(false); + validate(1).should.equal(true); + validate(NaN).should.equal(false); + validate(Infinity).should.equal(false); + }); + }); +}); + + +function testWithoutStrictNumbers(_ajv) { + return function () { + it('should NOT fail validation for NaN/Infinity as type number', function() { + var validate = _ajv.compile({type: 'number'}); + validate("1.1").should.equal(false); + validate(1.1).should.equal(true); + validate(1).should.equal(true); + validate(NaN).should.equal(true); + validate(Infinity).should.equal(true); + }); + + it('should NOT fail validation for NaN/Infinity as type integer', function() { + var validate = _ajv.compile({type: 'integer'}); + validate("1.1").should.equal(false); + validate(1.1).should.equal(false); + validate(1).should.equal(true); + validate(NaN).should.equal(false); + validate(Infinity).should.equal(true); + }); + }; +} diff --git a/spec/options/unknownFormats.spec.js b/spec/options/unknownFormats.spec.js new file mode 100644 index 000000000..6e6dfde3d --- /dev/null +++ b/spec/options/unknownFormats.spec.js @@ -0,0 +1,108 @@ +'use strict'; + +var Ajv = require('../ajv'); +var should = require('../chai').should(); + + +describe('unknownFormats option', function() { + describe('= true (default)', function() { + it('should fail schema compilation if unknown format is used', function() { + test(new Ajv); + test(new Ajv({unknownFormats: true})); + + function test(ajv) { + should.throw(function() { + ajv.compile({ format: 'unknown' }); + }); + } + }); + + it('should fail validation if unknown format is used via $data', function() { + test(new Ajv({$data: true})); + test(new Ajv({$data: true, unknownFormats: true})); + + function test(ajv) { + var validate = ajv.compile({ + properties: { + foo: { format: { $data: '1/bar' } }, + bar: { type: 'string' } + } + }); + + validate({foo: 1, bar: 'unknown'}) .should.equal(false); + validate({foo: '2016-10-16', bar: 'date'}) .should.equal(true); + validate({foo: '20161016', bar: 'date'}) .should.equal(false); + validate({foo: '20161016'}) .should.equal(true); + + validate({foo: '2016-10-16', bar: 'unknown'}) .should.equal(false); + } + }); + }); + + describe('= "ignore (default before 5.0.0)"', function() { + it('should pass schema compilation and be valid if unknown format is used', function() { + test(new Ajv({unknownFormats: 'ignore'})); + + function test(ajv) { + var validate = ajv.compile({ format: 'unknown' }); + validate('anything') .should.equal(true); + } + }); + + it('should be valid if unknown format is used via $data', function() { + test(new Ajv({$data: true, unknownFormats: 'ignore'})); + + function test(ajv) { + var validate = ajv.compile({ + properties: { + foo: { format: { $data: '1/bar' } }, + bar: { type: 'string' } + } + }); + + validate({foo: 1, bar: 'unknown'}) .should.equal(true); + validate({foo: '2016-10-16', bar: 'date'}) .should.equal(true); + validate({foo: '20161016', bar: 'date'}) .should.equal(false); + validate({foo: '20161016'}) .should.equal(true); + validate({foo: '2016-10-16', bar: 'unknown'}) .should.equal(true); + } + }); + }); + + describe('= [String]', function() { + it('should pass schema compilation and be valid if allowed unknown format is used', function() { + test(new Ajv({unknownFormats: ['allowed']})); + + function test(ajv) { + var validate = ajv.compile({ format: 'allowed' }); + validate('anything') .should.equal(true); + + should.throw(function() { + ajv.compile({ format: 'unknown' }); + }); + } + }); + + it('should be valid if allowed unknown format is used via $data', function() { + test(new Ajv({$data: true, unknownFormats: ['allowed']})); + + function test(ajv) { + var validate = ajv.compile({ + properties: { + foo: { format: { $data: '1/bar' } }, + bar: { type: 'string' } + } + }); + + validate({foo: 1, bar: 'allowed'}) .should.equal(true); + validate({foo: 1, bar: 'unknown'}) .should.equal(false); + validate({foo: '2016-10-16', bar: 'date'}) .should.equal(true); + validate({foo: '20161016', bar: 'date'}) .should.equal(false); + validate({foo: '20161016'}) .should.equal(true); + + validate({foo: '2016-10-16', bar: 'allowed'}) .should.equal(true); + validate({foo: '2016-10-16', bar: 'unknown'}) .should.equal(false); + } + }); + }); +}); diff --git a/spec/options/useDefaults.spec.js b/spec/options/useDefaults.spec.js new file mode 100644 index 000000000..7a12e8423 --- /dev/null +++ b/spec/options/useDefaults.spec.js @@ -0,0 +1,223 @@ +'use strict'; + +var Ajv = require('../ajv'); +var getAjvInstances = require('../ajv_instances'); +require('../chai').should(); + + +describe('useDefaults options', function() { + it('should replace undefined property with default value', function() { + var instances = getAjvInstances({ + allErrors: true, + loopRequired: 3 + }, { useDefaults: true }); + + instances.forEach(test); + + + function test(ajv) { + var schema = { + properties: { + foo: { type: 'string', default: 'abc' }, + bar: { type: 'number', default: 1 }, + baz: { type: 'boolean', default: false }, + nil: { type: 'null', default: null }, + obj: { type: 'object', default: {} }, + arr: { type: 'array', default: [] } + }, + required: ['foo', 'bar', 'baz', 'nil', 'obj', 'arr'], + minProperties: 6 + }; + + var validate = ajv.compile(schema); + + var data = {}; + validate(data) .should.equal(true); + data .should.eql({ foo: 'abc', bar: 1, baz: false, nil: null, obj: {}, arr:[] }); + + data = { foo: 'foo', bar: 2, obj: { test: true } }; + validate(data) .should.equal(true); + data .should.eql({ foo: 'foo', bar: 2, baz: false, nil: null, obj: { test: true }, arr:[] }); + } + }); + + it('should replace undefined item with default value', function() { + test(new Ajv({ useDefaults: true })); + test(new Ajv({ useDefaults: true, allErrors: true })); + + function test(ajv) { + var schema = { + items: [ + { type: 'string', default: 'abc' }, + { type: 'number', default: 1 }, + { type: 'boolean', default: false } + ], + minItems: 3 + }; + + var validate = ajv.compile(schema); + + var data = []; + validate(data) .should.equal(true); + data .should.eql([ 'abc', 1, false ]); + + data = [ 'foo' ]; + validate(data) .should.equal(true); + data .should.eql([ 'foo', 1, false ]); + + data = ['foo', 2,'false']; + validate(data) .should.equal(false); + validate.errors .should.have.length(1); + data .should.eql([ 'foo', 2, 'false' ]); + } + }); + + it('should apply default in "then" subschema (issue #635)', function() { + test(new Ajv({ useDefaults: true })); + test(new Ajv({ useDefaults: true, allErrors: true })); + + function test(ajv) { + var schema = { + if: { required: ['foo'] }, + then: { + properties: { + bar: { default: 2 } + } + }, + else: { + properties: { + foo: { default: 1 } + } + } + }; + + var validate = ajv.compile(schema); + + var data = {}; + validate(data) .should.equal(true); + data .should.eql({foo: 1}); + + data = {foo: 1}; + validate(data) .should.equal(true); + data .should.eql({foo: 1, bar: 2}); + } + }); + + + describe('useDefaults: by value / by reference', function() { + describe('using by value', function() { + it('should NOT modify underlying defaults when modifying validated data', function() { + test('value', new Ajv({ useDefaults: true })); + test('value', new Ajv({ useDefaults: true, allErrors: true })); + }); + }); + + describe('using by reference', function() { + it('should modify underlying defaults when modifying validated data', function() { + test('reference', new Ajv({ useDefaults: 'shared' })); + test('reference', new Ajv({ useDefaults: 'shared', allErrors: true })); + }); + }); + + function test(useDefaultsMode, ajv) { + var schema = { + properties: { + items: { + type: 'array', + default: ['a-default'] + } + } + }; + + var validate = ajv.compile(schema); + + var data = {}; + validate(data) .should.equal(true); + data.items .should.eql([ 'a-default' ]); + + data.items.push('another-value'); + data.items .should.eql([ 'a-default', 'another-value' ]); + + var data2 = {}; + validate(data2) .should.equal(true); + + if (useDefaultsMode == 'reference') + data2.items .should.eql([ 'a-default', 'another-value' ]); + else if (useDefaultsMode == 'value') + data2.items .should.eql([ 'a-default' ]); + else + throw new Error('unknown useDefaults mode'); + } + }); + + + describe('defaults with "empty" values', function() { + var schema, data; + + beforeEach(function() { + schema = { + properties: { + obj: { + properties: { + str: {default: 'foo'}, + n1: {default: 1}, + n2: {default: 2}, + n3: {default: 3} + } + }, + arr: { + items: [ + {default: 'foo'}, + {default: 1}, + {default: 2}, + {default: 3} + ] + } + } + }; + + data = { + obj: { + str: '', + n1: null, + n2: undefined + }, + arr: ['', null, undefined] + }; + }); + + it('should NOT assign defaults when useDefaults is true/"shared"', function() { + test(new Ajv({useDefaults: true})); + test(new Ajv({useDefaults: 'shared'})); + + function test(ajv) { + var validate = ajv.compile(schema); + validate(data) .should.equal(true); + data .should.eql({ + obj: { + str: '', + n1: null, + n2: 2, + n3: 3 + }, + arr: ['', null, 2, 3] + }); + } + }); + + it('should assign defaults when useDefaults = "empty"', function() { + var ajv = new Ajv({useDefaults: 'empty'}); + var validate = ajv.compile(schema); + validate(data) .should.equal(true); + data .should.eql({ + obj: { + str: 'foo', + n1: 1, + n2: 2, + n3: 3 + }, + arr: ['foo', 1, 2, 3] + }); + }); + }); +}); diff --git a/spec/security.spec.js b/spec/security.spec.js new file mode 100644 index 000000000..182e8b89f --- /dev/null +++ b/spec/security.spec.js @@ -0,0 +1,27 @@ +'use strict'; + +var jsonSchemaTest = require('json-schema-test') + , getAjvInstances = require('./ajv_instances') + , options = require('./ajv_options') + , suite = require('./browser_test_suite') + , after = require('./after_test'); + +var instances = getAjvInstances(options, { + schemas: [require('../lib/refs/json-schema-secure.json')] +}); + + +jsonSchemaTest(instances, { + description: 'Secure schemas tests of ' + instances.length + ' ajv instances with different options', + suites: { + 'security': typeof window == 'object' + ? suite(require('./security/{**/,}*.json', {mode: 'list'})) + : './security/{**/,}*.json' + }, + assert: require('./chai').assert, + afterError: after.error, + afterEach: after.each, + cwd: __dirname, + hideFolder: 'security/', + timeout: 90000 +}); diff --git a/spec/security/array.json b/spec/security/array.json new file mode 100644 index 000000000..25b655f95 --- /dev/null +++ b/spec/security/array.json @@ -0,0 +1,104 @@ +[ + { + "description": "uniqueItems without type keyword should be used together with maxItems", + "schema": {"$ref": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/json-schema-secure.json#"}, + "tests": [ + { + "description": "uniqueItems keyword used without maxItems is unsafe", + "data": { + "uniqueItems": true + }, + "valid": false + }, + { + "description": "uniqueItems keyword used with maxItems is safe", + "data": { + "uniqueItems": true, + "maxItems": "10" + }, + "valid": true + }, + { + "description": "uniqueItems: false is ignored (and safe)", + "data": { + "uniqueItems": false + }, + "valid": true + } + ] + }, + { + "description": "uniqueItems with scalar type(s) is safe to use without maxItems", + "schema": {"$ref": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/json-schema-secure.json#"}, + "tests": [ + { + "description": "uniqueItems keyword with a single scalar type is safe", + "data": { + "uniqueItems": true, + "items": { + "type": "number" + } + }, + "valid": true + }, + { + "description": "uniqueItems keyword with multiple scalar types is safe", + "data": { + "uniqueItems": true, + "items": { + "type": ["number", "string"] + } + }, + "valid": true + } + ] + }, + { + "description": "uniqueItems with compound type(s) should be used together with maxItems", + "schema": {"$ref": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/json-schema-secure.json#"}, + "tests": [ + { + "description": "uniqueItems keyword with a single compound type and without maxItems is unsafe", + "data": { + "uniqueItems": true, + "items": { + "type": "object" + } + }, + "valid": false + }, + { + "description": "uniqueItems keyword with a single compound type and with maxItems is safe", + "data": { + "uniqueItems": true, + "maxItems": "10", + "items": { + "type": "object" + } + }, + "valid": true + }, + { + "description": "uniqueItems keyword with multiple types including compound type and without maxItems is unsafe", + "data": { + "uniqueItems": true, + "items": { + "type": ["array","number"] + } + }, + "valid": false + }, + { + "description": "uniqueItems keyword with multiple types including compound type and with maxItems is safe", + "data": { + "uniqueItems": true, + "maxItems": "10", + "items": { + "type": ["array","number"] + } + }, + "valid": true + } + ] + } +] diff --git a/spec/security/object.json b/spec/security/object.json new file mode 100644 index 000000000..9de069b8a --- /dev/null +++ b/spec/security/object.json @@ -0,0 +1,29 @@ +[ + { + "description": "patternProperties keyword should be used together with propertyNames", + "schema": { "$ref": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/json-schema-secure.json#" }, + "tests": [ + { + "description": "patternProperties keyword used without propertyNames is unsafe", + "data": { + "patternProperties": { + ".*": {} + } + }, + "valid": false + }, + { + "description": "patternProperties keyword used with propertyNames is safe", + "data": { + "patternProperties": { + ".*": {} + }, + "propertyNames": { + "maxLength": "256" + } + }, + "valid": true + } + ] + } +] diff --git a/spec/security/string.json b/spec/security/string.json new file mode 100644 index 000000000..c6fb55292 --- /dev/null +++ b/spec/security/string.json @@ -0,0 +1,44 @@ +[ + { + "description": "pattern keyword should be used together with maxLength", + "schema": { "$ref": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/json-schema-secure.json#" }, + "tests": [ + { + "description": "pattern keyword used without maxLength is unsafe", + "data": { + "pattern": ".*" + }, + "valid": false + }, + { + "description": "pattern keyword used with maxLength is safe", + "data": { + "pattern": ".*", + "maxLength": "256" + }, + "valid": true + } + ] + }, + { + "description": "format keyword should be used together with maxLength", + "schema": { "$ref": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/json-schema-secure.json#" }, + "tests": [ + { + "description": "format keyword used without maxLength is unsafe", + "data": { + "format": "email" + }, + "valid": false + }, + { + "description": "format keyword used with maxLength is safe", + "data": { + "format": "email", + "maxLength": "256" + }, + "valid": true + } + ] + } +] diff --git a/spec/tests/issues/1061_alternative_time_offsets.json b/spec/tests/issues/1061_alternative_time_offsets.json new file mode 100644 index 000000000..bf80f9581 --- /dev/null +++ b/spec/tests/issues/1061_alternative_time_offsets.json @@ -0,0 +1,74 @@ +[ + { + "description": "Support for alternative ISO-8601 timezone offset formats (#1061)", + "schema": {"format": "date-time"}, + "tests": [ + { + "description": "valid positiive two digit", + "data": "2016-01-31T02:31:17+01", + "valid": true + }, + { + "description": "valid negative two digit", + "data": "2016-01-31T02:31:17-01", + "valid": true + }, + { + "description": "valid positiive four digit no colon", + "data": "2016-01-31T02:31:17+0130", + "valid": true + }, + { + "description": "valid negative four digit no colon", + "data": "2016-01-31T02:31:17-0130", + "valid": true + }, + { + "description": "invalid positiive three digit no colon", + "data": "2016-01-31T02:31:17+013", + "valid": false + }, + { + "description": "invalid negative three digit no colon", + "data": "2016-01-31T02:31:17-013", + "valid": false + } + ] + }, + { + "description": "Support for alternative ISO-8601 timezone offset formats (#1061)", + "schema": {"format": "time"}, + "tests": [ + { + "description": "valid positiive two digit", + "data": "02:31:17+01", + "valid": true + }, + { + "description": "valid negative two digit", + "data": "02:31:17-01", + "valid": true + }, + { + "description": "valid positiive four digit no colon", + "data": "02:31:17+0130", + "valid": true + }, + { + "description": "valid negative four digit no colon", + "data": "02:31:17-0130", + "valid": true + }, + { + "description": "invalid positiive three digit no colon", + "data": "02:31:17+013", + "valid": false + }, + { + "description": "invalid negative three digit no colon", + "data": "02:31:17-013", + "valid": false + } + ] + } +] diff --git a/spec/tests/rules/format.json b/spec/tests/rules/format.json index 226608bd4..433a0aaf8 100644 --- a/spec/tests/rules/format.json +++ b/spec/tests/rules/format.json @@ -1,6 +1,6 @@ [ { - "description": "whitelisted unknown format is valid", + "description": "allowed unknown format is valid", "schema": { "format": "allowedUnknown" }, @@ -82,10 +82,55 @@ "data": "123.example.com", "valid": true }, + { + "description": "valid hostname - trailing dot", + "data": "123.example.com.", + "valid": true + }, + { + "description": "valid hostname - single label", + "data": "localhost", + "valid": true + }, + { + "description": "valid hostname - single label with trailing dot", + "data": "localhost.", + "valid": true + }, { "description": "valid hostname #312", "data": "lead-routing-qa.lvuucj.0001.use1.cache.amazonaws.com", "valid": true + }, + { + "description": "valid hostname - maximum length label (63 chars)", + "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijk.example.com", + "valid": true + }, + { + "description": "invalid hostname - label too long (64 chars)", + "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl.example.com", + "valid": false + }, + { + "description": "valid hostname - maximum length hostname (255 octets)", + "data": "abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxy.example.com", + "valid": true + }, + { + "description": "valid hostname - maximum length hostname (255 octets) with trailing dot", + "data": "abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxy.example.com.", + "valid": true + }, + { + "description": "invalid hostname - hostname too long (256 octets)", + "data": "abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.example.com", + "valid": false + }, + { + "description": "invalid hostname - hostname too long (256 octets) with trailing dot", + "data": "abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz.example.com.", + "valid": false } ] }, diff --git a/spec/typescript/index.ts b/spec/typescript/index.ts new file mode 100644 index 000000000..0858180e9 --- /dev/null +++ b/spec/typescript/index.ts @@ -0,0 +1,60 @@ +import ajv = require("../.."); + +// #region new() +const options: ajv.Options = { + verbose: true, +}; + +let instance: ajv.Ajv; + +instance = ajv(); +instance = ajv(options); + +instance = new ajv(); +instance = new ajv(options); +// #endregion new() + +// #region validate() +let data = { + foo: 42, +} + +let result = instance.validate("", data); + +if (typeof result === "boolean") { + // sync + console.log(result); +} else { + // async + result.then(value => { + data = value; + }); +} +// #endregion validate() + +// #region compile() +const validator = instance.compile({}); +result = validator(data); + +if (typeof result === "boolean") { + // sync + console.log(result); +} else { + // async + result.then(value => { + data = value; + }); +} +// #endregion compile() + +// #region errors +const validationError: ajv.ValidationError = new ajv.ValidationError([]); +validationError instanceof ajv.ValidationError; +validationError.ajv === true; +validationError.validation === true; + +ajv.MissingRefError.message("", ""); +const missingRefError: ajv.MissingRefError = new ajv.MissingRefError("", "", ""); +missingRefError instanceof ajv.MissingRefError; +missingRefError.missingRef; +// #endregion