.github/workflows/build.yml

@@ -29,7 +29,7 @@ jobs:
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
       - name: update website
-        if: ${{ matrix.node-version == '14.x' }}
+        if: ${{ github.event_name == 'push' && matrix.node-version == '14.x' }}
         run: ./scripts/publish-gh-pages
         env:
           GH_TOKEN_PUBLIC: ${{ secrets.GH_TOKEN_PUBLIC }}

README.md

@@ -19,7 +19,7 @@ The fastest JSON Schema validator for Node.js and browser. Supports draft-06/07/
 
 Ajv version 7 is released with these changes:
 
-- support of JSON Schema draft-2019-09 features: [`unevaluatedProperties`](./json-schema.md#unevaluatedproperties) and [`unevaluatedItems`](./json-schema.md#unevaluateditems), [dynamic recursive references](./validation.md#extending-recursive-schemas) and other [additional keywords](./json-schema.md#json-schema-draft-2019-09).
+- support of JSON Schema draft-2019-09 features: [`unevaluatedProperties`](./docs/json-schema.md#unevaluatedproperties) and [`unevaluatedItems`](./docs/json-schema.md#unevaluateditems), [dynamic recursive references](./docs/validation.md#extending-recursive-schemas) and other [additional keywords](./docs/json-schema.md#json-schema-draft-2019-09).
 - 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 and to allow code optimization (compiled schema code size is reduced by more than 10%).
 - 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. [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package was updated to use the new API (in [v4.0.0](https://github.com/ajv-validator/ajv-keywords/releases/tag/v4.0.0))

lib/compile/codegen/index.ts

@@ -3,7 +3,7 @@ import {_, nil, _Code, Code, Name, UsedNames, CodeItem, addCodeArg, _CodeOrName}
 import {Scope, varKinds} from "./scope"
 
 export {_, str, strConcat, nil, getProperty, stringify, Name, Code} from "./code"
-export {Scope, ScopeStore, ValueScope, ScopeValueSets, varKinds} from "./scope"
+export {Scope, ScopeStore, ValueScope, ValueScopeName, ScopeValueSets, varKinds} from "./scope"
 
 // type for expressions that can be safely inserted in code without quotes
 export type SafeExpr = Code | number | boolean | null

lib/compile/index.ts

@@ -8,7 +8,7 @@ import type {
 } from "../types"
 import type Ajv from "../core"
 import type {InstanceOptions} from "../core"
-import {CodeGen, _, nil, stringify, Name, Code} from "./codegen"
+import {CodeGen, _, nil, stringify, Name, Code, ValueScopeName} from "./codegen"
 import {ValidationError} from "./error_classes"
 import N from "./names"
 import {LocalRefs, getFullPath, _getFullPath, inlineRef, normalizeId, resolveUrl} from "./resolve"
@@ -77,7 +77,7 @@ export class SchemaEnv implements SchemaEnvArgs {
   readonly refs: SchemaRefs = {}
   readonly dynamicAnchors: {[Ref in string]?: true} = {}
   validate?: AnyValidateFunction
-  validateName?: Name
+  validateName?: ValueScopeName
 
   constructor(env: SchemaEnvArgs) {
     let schema: AnySchemaObject | undefined

lib/standalone/index.ts

@@ -51,6 +51,10 @@ export default function standaloneCode(
 
   function validateCode(usedValues: ScopeValueSets, s?: SourceCode): Code {
     if (!s) throw new Error('moduleCode: function does not have "source" property')
+    const {prefix} = s.validateName
+    const nameSet = (usedValues[prefix] = usedValues[prefix] || new Set())
+    nameSet.add(s.validateName)
+
     const scopeCode = ajv.scope.scopeCode(s.scopeValues, usedValues, refValidateCode)
     const code = new _Code(`${scopeCode}${_n}${s.validateCode}`)
     return s.evaluated ? _`${code}${s.validateName}.evaluated = ${s.evaluated};${_n}` : code

lib/types/index.ts

@@ -1,4 +1,4 @@
-import type {CodeGen, Code, Name, ScopeValueSets} from "../compile/codegen"
+import type {CodeGen, Code, Name, ScopeValueSets, ValueScopeName} from "../compile/codegen"
 import type {SchemaEnv, SchemaCxt, SchemaObjCxt} from "../compile"
 import type {JSONType} from "../compile/rules"
 import type KeywordCxt from "../compile/context"
@@ -30,7 +30,7 @@ export type AnySchema = Schema | AsyncSchema
 export type SchemaMap = {[Key in string]?: AnySchema}
 
 export interface SourceCode {
-  validateName: Name
+  validateName: ValueScopeName
   validateCode: string
   scopeValues: ScopeValueSets
   evaluated?: Code

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ajv",
-  "version": "7.0.1",
+  "version": "7.0.2",
   "description": "Another JSON Schema Validator",
   "main": "dist/ajv.js",
   "types": "dist/ajv.d.ts",

spec/standalone.spec.ts

@@ -85,6 +85,82 @@ describe("standalone code generation", () => {
     }
   })
 
+  describe("two refs to the same schema (issue #1361)", () => {
+    const userSchema = {
+      $id: "user.json",
+      type: "object",
+      properties: {
+        name: {type: "string"},
+      },
+      required: ["name"],
+    }
+
+    const infoSchema = {
+      $id: "info.json",
+      type: "object",
+      properties: {
+        author: {$ref: "user.json"},
+        contributors: {
+          type: "array",
+          items: {$ref: "user.json"},
+        },
+      },
+      required: ["author", "contributors"],
+    }
+
+    describe("all exports", () => {
+      it("should not have duplicate functions", () => {
+        const ajv = new _Ajv({
+          allErrors: true,
+          code: {optimize: false, source: true},
+          inlineRefs: false, // it is needed to show the issue, schemas with refs won't be inlined anyway
+          schemas: [userSchema, infoSchema],
+        })
+
+        const moduleCode = standaloneCode(ajv)
+        assertNoDuplicateFunctions(moduleCode)
+        const {"user.json": user, "info.json": info} = requireFromString(moduleCode)
+        testExports({user, info})
+      })
+    })
+
+    describe("named exports", () => {
+      it("should not have duplicate functions", () => {
+        const ajv = new _Ajv({
+          allErrors: true,
+          code: {optimize: false, source: true},
+          inlineRefs: false, // it is needed to show the issue, schemas with refs won't be inlined anyway
+          schemas: [userSchema, infoSchema],
+        })
+
+        const moduleCode = standaloneCode(ajv, {user: "user.json", info: "info.json"})
+        assertNoDuplicateFunctions(moduleCode)
+        testExports(requireFromString(moduleCode))
+      })
+    })
+
+    function assertNoDuplicateFunctions(code: string): void {
+      const funcs = code.match(/function\s+([a-z0-9_$]+)/gi)
+      assert(Array.isArray(funcs))
+      assert(funcs.length > 0)
+      assert.strictEqual(funcs.length, new Set(funcs).size, "should have no duplicates")
+    }
+
+    function testExports(validate: {[n: string]: AnyValidateFunction<unknown>}): void {
+      assert.strictEqual(validate.user({}), false)
+      assert.strictEqual(validate.user({name: "usr1"}), true)
+
+      assert.strictEqual(validate.info({}), false)
+      assert.strictEqual(
+        validate.info({
+          author: {name: "usr1"},
+          contributors: [{name: "usr2"}],
+        }),
+        true
+      )
+    }
+  })
+
   it("should generate module code with a single export (ESM compatible)", () => {
     const ajv = new _Ajv({code: {source: true}})
     const v = ajv.compile({