Merge branch 'master' into discriminator

.github/workflows/build.yml

@@ -15,9 +15,9 @@ jobs:
         node-version: [16.x, 18.x, 20.x, 21.x]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm install
@@ -32,6 +32,6 @@ jobs:
       - run: npm run build
       - run: npm run test-ci
       - name: coveralls
-        uses: coverallsapp/github-action@master
+        uses: coverallsapp/github-action@v2
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/publish.yml

@@ -8,21 +8,21 @@ jobs:
   publish-npm:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: 18
           registry-url: https://registry.npmjs.org/
       - run: npm install
       - run: git submodule update --init
       - run: npm run test-ci
       - name: Publish beta version to npm
-        if: "github.event.release.prerelease"
+        if: ${{ github.event.release.prerelease }}
         run: npm publish --tag beta
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
       - name: Publish to npm
-        if: "!github.event.release.prerelease"
+        if: ${{ !github.event.release.prerelease }}
         run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

docs/api.md

@@ -251,7 +251,7 @@ Add validation keyword to Ajv instance.
 
 Keyword should be different from all standard JSON Schema keywords and different from previously defined keywords. There is no way to redefine keywords or to remove keyword definition from the instance.
 
-Keyword must start with a letter, `_` or `$`, and may continue with letters, numbers, `_`, `$`, or `-`.
+Keyword must start with an ASCII letter, `_` or `$`, and may continue with ASCII letters, numbers, `_`, `$`, `-`, or `:`.
 It is recommended to use an application-specific prefix for keywords to avoid current and future name collisions.
 
 Example Keywords:

docs/guide/managing-schemas.md

@@ -186,7 +186,7 @@ In the example above, the key passed to the `addSchema` method was used to retri
 
 ### Pre-adding all schemas vs adding on demand
 
-In the example above all schemas were added in advance. It is also possible, to add schemas as they are used - it can be helpful if there is many schemas. In this case, you need to check first whether the schema is already added by calling `getSchema` method - it would return `undefined` if not:
+In the example above all schemas were added in advance. It is also possible, to add schemas as they are used - it can be helpful if there are many schemas. In this case, you need to check first whether the schema is already added by calling `getSchema` method - it would return `undefined` if not:
 
 ```javascript
 const schema_user = require("./schema_user.json")

docs/guide/modifying-data.md

@@ -210,7 +210,7 @@ With `useDefaults` option `default` keywords throws exception during schema comp
 
 The strict mode option can change the behaviour for these unsupported defaults (`strict: false` to ignore them, `"log"` to log a warning).
 
-See [Strict mode](./strict-mode.md).
+See [Strict mode](../strict-mode.md).
 
 ::: tip Default with discriminator keyword
 Defaults will be assigned in schemas inside `oneOf` in case [discriminator](../json-schema.md#discriminator) keyword is used.

docs/json-schema.md

@@ -280,6 +280,10 @@ The value of the keyword should be a number. The data to be valid should be a mu
 
 ### `maxLength` / `minLength`
 
+::: warning Grapheme clusters will count as multiple characters
+Certain charsets have characters that are made up of multiple Unicode code points. These [grapheme clusters](https://www.unicode.org/reports/tr29/tr29-17.html#Grapheme_Cluster_Boundaries) are counted as multiple in length calculations.
+:::
+
 The value of the keywords should be a number. The data to be valid should have length satisfying this rule. Unicode pairs are counted as a single character.
 
 **Examples**
@@ -474,11 +478,11 @@ To create and equivalent schema in draft-2020-12 use keywords [prefixItems](#pre
 
 The value of the keyword should be a boolean or an object.
 
-If `items` keyword is not present or it is an object, `additionalItems` keyword should be ignored regardless of its value. By default Ajv will throw exception in this case - see [Strict mode](./strict-mode.md)
+`additionalItems` keyword is ignored if `items` keyword is not present or is an object. By default Ajv will throw exception in this case - see [Strict mode](./strict-mode.md)
 
-If `items` keyword is an array and data array has not more items than the length of `items` keyword value, `additionalItems` keyword is also ignored.
+`additionalItems` keyword is ignored if `items` keyword has more elements than data array.
 
-If the length of data array is bigger than the length of "items" keyword value than the result of the validation depends on the value of `additionalItems` keyword:
+If the data array has more elements than the `items` keyword value then the result of the validation depends on the value of `additionalItems` keyword:
 
 - `false`: data is invalid
 - `true`: data is valid

docs/options.md

@@ -344,7 +344,7 @@ Include human-readable messages in errors. `true` by default. `false` can be pas
 
 ### uriResolver
 
-By default `uriResolver` is undefined and relies on the embedded uriResolver [uri-js](https://github.com/garycourt/uri-js). Pass an object that satisfies the interface [UriResolver](https://github.com/ajv-validator/ajv/blob/master/lib/types/index.ts) to be used in replacement. One alternative is [fast-uri](https://github.com/fastify/fast-uri).
+By default `uriResolver` is undefined and relies on the embedded uriResolver [fast-uri](https://github.com/fastify/fast-uri). Pass an object that satisfies the interface [UriResolver](https://github.com/ajv-validator/ajv/blob/master/lib/types/index.ts) to be used in replacement. One alternative is [uri-js](https://github.com/garycourt/uri-js).
 
 ### code <Badge text="v7" />
 

docs/strict-mode.md

@@ -42,10 +42,10 @@ By default Ajv fails schema compilation when unknown keywords are used. Users ca
 ajv.addKeyword("allowedKeyword")
 ```
 
-or
+or use the convenience method `addVocabulary` for multiple keywords
 
 ```javascript
-ajv.addVocabulary(["allowed1", "allowed2"])
+ajv.addVocabulary(["allowed1", "allowed2"]) // simply calls addKeyword multiple times
 ```
 
 #### Ignored "additionalItems" keyword

lib/compile/codegen/code.ts

@@ -1,3 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export abstract class _CodeOrName {
   abstract readonly str: string
   abstract readonly names: UsedNames

lib/compile/index.ts

@@ -14,7 +14,7 @@ import N from "./names"
 import {LocalRefs, getFullPath, _getFullPath, inlineRef, normalizeId, resolveUrl} from "./resolve"
 import {schemaHasRulesButRef, unescapeFragment} from "./util"
 import {validateFunctionCode} from "./validate"
-import * as URI from "uri-js"
+import {URIComponent} from "fast-uri"
 import {JSONType} from "./rules"
 
 export type SchemaRefs = {
@@ -295,7 +295,7 @@ const PREVENT_SCOPE_CHANGE = new Set([
 
 function getJsonPointer(
   this: Ajv,
-  parsedRef: URI.URIComponents,
+  parsedRef: URIComponent,
   {baseId, schema, root}: SchemaEnv
 ): SchemaEnv | undefined {
   if (parsedRef.fragment?.[0] !== "/") return

lib/compile/resolve.ts

@@ -1,6 +1,6 @@
 import type {AnySchema, AnySchemaObject, UriResolver} from "../types"
 import type Ajv from "../ajv"
-import type {URIComponents} from "uri-js"
+import type {URIComponent} from "fast-uri"
 import {eachItem} from "./util"
 import * as equal from "fast-deep-equal"
 import * as traverse from "json-schema-traverse"
@@ -73,7 +73,7 @@ export function getFullPath(resolver: UriResolver, id = "", normalize?: boolean)
   return _getFullPath(resolver, p)
 }
 
-export function _getFullPath(resolver: UriResolver, p: URIComponents): string {
+export function _getFullPath(resolver: UriResolver, p: URIComponent): string {
   const serialized = resolver.serialize(p)
   return serialized.split("#")[0] + "#"
 }

lib/runtime/uri.ts

@@ -1,4 +1,4 @@
-import * as uri from "uri-js"
+import * as uri from "fast-uri"
 
 type URI = typeof uri & {code: string}
 ;(uri as URI).code = 'require("ajv/dist/runtime/uri").default'

lib/types/index.ts

@@ -1,4 +1,4 @@
-import * as URI from "uri-js"
+import {URIComponent} from "fast-uri"
 import type {CodeGen, Code, Name, ScopeValueSets, ValueScopeName} from "../compile/codegen"
 import type {SchemaEnv, SchemaCxt, SchemaObjCxt} from "../compile"
 import type {JSONType} from "../compile/rules"
@@ -238,7 +238,7 @@ export interface RegExpLike {
 }
 
 export interface UriResolver {
-  parse(uri: string): URI.URIComponents
+  parse(uri: string): URIComponent
   resolve(base: string, path: string): string
-  serialize(component: URI.URIComponents): string
+  serialize(component: URIComponent): string
 }

lib/types/json-schema.ts

@@ -108,25 +108,25 @@ type UncheckedJSONSchemaType<T, IsPartial extends boolean> = (
             : UncheckedPropertiesSchema<T>
           patternProperties?: Record<string, UncheckedJSONSchemaType<T[string], false>>
           propertyNames?: Omit<UncheckedJSONSchemaType<string, false>, "type"> & {type?: "string"}
-          dependencies?: {[K in keyof T]?: Readonly<(keyof T)[]> | UncheckedPartialSchema<T>}
-          dependentRequired?: {[K in keyof T]?: Readonly<(keyof T)[]>}
+          dependencies?: {[K in keyof T]?: readonly (keyof T)[] | UncheckedPartialSchema<T>}
+          dependentRequired?: {[K in keyof T]?: readonly (keyof T)[]}
           dependentSchemas?: {[K in keyof T]?: UncheckedPartialSchema<T>}
           minProperties?: number
           maxProperties?: number
         } & (IsPartial extends true // "required" is not necessary if it's a non-partial type with no required keys // are listed it only asserts that optional cannot be listed. // "required" type does not guarantee that all required properties
-          ? {required: Readonly<(keyof T)[]>}
+          ? {required: readonly (keyof T)[]}
           : [UncheckedRequiredMembers<T>] extends [never]
-          ? {required?: Readonly<UncheckedRequiredMembers<T>[]>}
-          : {required: Readonly<UncheckedRequiredMembers<T>[]>})
+          ? {required?: readonly UncheckedRequiredMembers<T>[]}
+          : {required: readonly UncheckedRequiredMembers<T>[]})
       : T extends null
       ? {
           type: JSONType<"null", IsPartial>
           nullable: true
         }
       : never) & {
-      allOf?: Readonly<UncheckedPartialSchema<T>[]>
-      anyOf?: Readonly<UncheckedPartialSchema<T>[]>
-      oneOf?: Readonly<UncheckedPartialSchema<T>[]>
+      allOf?: readonly UncheckedPartialSchema<T>[]
+      anyOf?: readonly UncheckedPartialSchema<T>[]
+      oneOf?: readonly UncheckedPartialSchema<T>[]
       if?: UncheckedPartialSchema<T>
       then?: UncheckedPartialSchema<T>
       else?: UncheckedPartialSchema<T>
@@ -176,12 +176,12 @@ type Nullable<T> = undefined extends T
   ? {
       nullable: true
       const?: null // any non-null value would fail `const: null`, `null` would fail any other value in const
-      enum?: Readonly<(T | null)[]> // `null` must be explicitly included in "enum" for `null` to pass
+      enum?: readonly (T | null)[] // `null` must be explicitly included in "enum" for `null` to pass
       default?: T | null
     }
   : {
       nullable?: false
       const?: T
-      enum?: Readonly<T[]>
+      enum?: readonly T[]
       default?: T
     }

lib/vocabularies/discriminator/index.ts

@@ -3,6 +3,7 @@ import type {KeywordCxt} from "../../compile/validate"
 import {_, or, getProperty, Name} from "../../compile/codegen"
 import {DiscrError, DiscrErrorObj} from "../discriminator/types"
 import {resolveRef, SchemaEnv} from "../../compile"
+import MissingRefError from "../../compile/ref_error"
 import {schemaHasRulesButRef} from "../../compile/util"
 
 export type DiscriminatorError = DiscrErrorObj<DiscrError.Tag> | DiscrErrorObj<DiscrError.Mapping>
@@ -69,8 +70,10 @@ const def: CodeKeywordDefinition = {
       for (let i = 0; i < oneOf.length; i++) {
         let sch = oneOf[i]
         if (sch?.$ref && !schemaHasRulesButRef(sch, it.self.RULES)) {
-          sch = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, sch?.$ref)
+          const ref = sch.$ref
+          sch = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref)
           if (sch instanceof SchemaEnv) sch = sch.schema
+          if (sch === undefined) throw new MissingRefError(it.opts.uriResolver, it.baseId, ref)
         }
         const propSch = sch?.properties?.[tagName]
         if (typeof propSch != "object") {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ajv",
-  "version": "8.13.0",
+  "version": "8.17.1",
   "description": "Another JSON Schema Validator",
   "main": "dist/ajv.js",
   "types": "dist/ajv.d.ts",
@@ -9,6 +9,7 @@
     "dist/",
     ".runkit_example.js"
   ],
+  "sideEffects": false,
   "scripts": {
     "eslint": "eslint \"lib/**/*.ts\" \"spec/**/*.*s\" --ignore-pattern spec/JSON-Schema-Test-Suite",
     "prettier:write": "prettier --write \"./**/*.{json,yaml,js,ts}\"",
@@ -59,9 +60,9 @@
   "runkitExampleFilename": ".runkit_example.js",
   "dependencies": {
     "fast-deep-equal": "^3.1.3",
+    "fast-uri": "^3.0.1",
     "json-schema-traverse": "^1.0.0",
-    "require-from-string": "^2.0.2",
-    "uri-js": "^4.4.1"
+    "require-from-string": "^2.0.2"
   },
   "devDependencies": {
     "@ajv-validator/config": "^0.5.0",
@@ -83,7 +84,6 @@
     "dayjs-plugin-utc": "^0.1.2",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
-    "fast-uri": "^2.3.0",
     "glob": "^10.3.10",
     "husky": "^9.0.11",
     "if-node-version": "^1.1.1",
@@ -104,7 +104,8 @@
     "rollup-plugin-terser": "^7.0.2",
     "ts-node": "^10.9.2",
     "tsify": "^5.0.4",
-    "typescript": "5.3.3"
+    "typescript": "5.3.3",
+    "uri-js": "^4.4.1"
   },
   "collective": {
     "type": "opencollective",

spec/discriminator.spec.ts

@@ -292,6 +292,67 @@ describe("discriminator keyword", function () {
     })
   })
 
+  describe("schema with external $refs", () => {
+    const schemas = {
+      main: {
+        type: "object",
+        discriminator: {propertyName: "foo"},
+        required: ["foo"],
+        oneOf: [
+          {
+            $ref: "schema1",
+          },
+          {
+            $ref: "schema2",
+          },
+        ],
+      },
+      schema1: {
+        type: "object",
+        properties: {
+          foo: {const: "x"},
+        },
+      },
+      schema2: {
+        type: "object",
+        properties: {
+          foo: {enum: ["y", "z"]},
+        },
+      },
+    }
+
+    const data = {foo: "x"}
+    const badData = {foo: "w"}
+
+    it("compile should resolve each $ref to a schema that was added with addSchema", () => {
+      const opts = {
+        discriminator: true,
+      }
+      const ajv = new _Ajv(opts)
+      ajv.addSchema(schemas.main, "https://host/main")
+      ajv.addSchema(schemas.schema1, "https://host/schema1")
+      ajv.addSchema(schemas.schema2, "https://host/schema2")
+
+      const validate = ajv.compile({$ref: "https://host/main"})
+      assert.strictEqual(validate(data), true)
+      assert.strictEqual(validate(badData), false)
+    })
+    it("compileAsync should loadSchema each $ref", async () => {
+      const opts = {
+        discriminator: true,
+        loadSchema(url) {
+          if (!url.startsWith("https://host/")) return undefined
+          const name = url.substring("https://host/".length)
+          return schemas[name]
+        },
+      }
+      const ajv = new _Ajv(opts)
+      const validate = await ajv.compileAsync({$ref: "https://host/main"})
+      assert.strictEqual(validate(data), true)
+      assert.strictEqual(validate(badData), false)
+    })
+  })
+
   describe("validation with deeply referenced schemas", () => {
     const schema = [
       {