refactor: $ref keyword

lib/ajv.ts

@@ -304,9 +304,11 @@ export default class Ajv {
           delete this._schemas[id]
           delete this._refs[id]
         }
+        return this
       }
+      default:
+        throw new Error("ajv.removeSchema: invalid parameter")
     }
-    return this
   }
 
   // add "vocabulary" - a collection of keywords

lib/compile/index.ts

@@ -160,7 +160,7 @@ export function compileSchema(this: Ajv, env: SchemaEnv): ValidateFunction {
     }
   }
 
-  function resolveRef(baseId: string, ref: string): Schema | ValidateFunction | void {
+  function resolveRef(baseId: string, ref: string): Schema | ValidateFunction | undefined {
     ref = resolveUrl(baseId, ref)
     // TODO root.refs check should be unnecessary, it is only needed because in some cases root is passed without refs (see type casts to SchemaEnv)
     const schOrFunc = env.refs[ref] || env.root.refs[ref]
@@ -173,6 +173,7 @@ export function compileSchema(this: Ajv, env: SchemaEnv): ValidateFunction {
     }
 
     if (_sch !== undefined) return (env.refs[ref] = inlineOrCompile(_sch))
+    return
   }
 
   function inlineOrCompile(sch: SchemaEnv): Schema | ValidateFunction {

lib/types.ts

@@ -171,7 +171,7 @@ export interface SchemaCxt {
   compositeRule?: boolean
   createErrors?: boolean
   opts: InstanceOptions
-  resolveRef: (baseId: string, ref: string) => Schema | ValidateFunction | void
+  resolveRef: (baseId: string, ref: string) => Schema | ValidateFunction | undefined
   self: Ajv
 }
 

lib/vocabularies/core/ref.ts

@@ -1,58 +1,54 @@
-import {CodeKeywordDefinition, Schema} from "../../types"
+import {CodeKeywordDefinition, Schema, ValidateFunction} from "../../types"
 import KeywordCxt from "../../compile/context"
 import {MissingRefError} from "../../compile/error_classes"
 import {applySubschema} from "../../compile/subschema"
 import {callValidateCode} from "../util"
 import {_, str, nil, Code, Name} from "../../compile/codegen"
 import N from "../../compile/names"
 
-// TODO remove these interfaces
-type ResolvedRef = InlineResolvedRef | FuncResolvedRef
-
-interface InlineResolvedRef {
-  code: Code
-  schema: Schema
-  inline: true
-}
-
-interface FuncResolvedRef {
-  code: Code
-  $async?: boolean
-  inline?: false
-}
-
 const def: CodeKeywordDefinition = {
   keyword: "$ref",
   schemaType: "string",
   code(cxt: KeywordCxt) {
     const {gen, schema, it} = cxt
     const {resolveRef, allErrors, baseId, isRoot, root, opts, validateName, self} = it
-    const ref = getRef()
     const passCxt = opts.passContext ? N.this : nil
-    if (ref === undefined) missingRef()
-    else if (ref.inline) applyRefSchema(ref)
-    else if (ref.$async || it.async) validateAsyncRef(ref.code)
-    else validateRef(ref.code)
+    if (schema === "#" || schema === "#/") return callRootRef()
+    const schOrFunc = resolveRef(baseId, schema)
+    if (schOrFunc === undefined) return missingRef()
+    if (typeof schOrFunc == "function") return callCompiledRef(schOrFunc)
+    return inlineRefSchema(schOrFunc)
 
-    function getRef(): ResolvedRef | undefined {
-      if (schema === "#" || schema === "#/") {
-        if (isRoot) return {code: validateName, $async: it.async}
-        const rootName = gen.scopeValue("root", {ref: root.localRoot})
-        return {
-          code: _`${rootName}.validate`,
-          $async: typeof root.schema == "object" && root.schema.$async === true,
-        }
-      }
+    function callRootRef(): void {
+      if (isRoot) return callRef(validateName, it.async)
+      const rootName = gen.scopeValue("root", {ref: root.localRoot})
+      return callRef(_`${rootName}.validate`, root.$async)
+    }
 
-      const schOrFunc = resolveRef(baseId, schema)
-      if (typeof schOrFunc == "function") {
-        const code = gen.scopeValue("validate", {ref: schOrFunc})
-        return {code, $async: schOrFunc.$async}
-      } else if (typeof schOrFunc == "boolean" || typeof schOrFunc == "object") {
-        const code = gen.scopeValue("schema", {ref: schOrFunc})
-        return {code, schema: schOrFunc, inline: true}
-      }
-      return undefined
+    function callCompiledRef(func: ValidateFunction): void {
+      const v = gen.scopeValue("validate", {ref: func})
+      return callRef(v, func.$async)
+    }
+
+    function callRef(v: Code, $async?: boolean): void {
+      if ($async || it.async) validateAsyncRef(v)
+      else validateSyncRef(v)
+    }
+
+    function inlineRefSchema(sch: Schema): void {
+      const schName = gen.scopeValue("schema", {ref: sch})
+      const valid = gen.name("valid")
+      applySubschema(
+        it,
+        {
+          schema: sch,
+          schemaPath: nil,
+          topSchemaRef: schName,
+          errSchemaPath: schema,
+        },
+        valid
+      )
+      cxt.ok(valid)
     }
 
     function missingRef(): void {
@@ -70,21 +66,6 @@ const def: CodeKeywordDefinition = {
       }
     }
 
-    function applyRefSchema(inlineRef: InlineResolvedRef): void {
-      const valid = gen.name("valid")
-      applySubschema(
-        it,
-        {
-          schema: inlineRef.schema,
-          schemaPath: nil,
-          topSchemaRef: inlineRef.code,
-          errSchemaPath: schema,
-        },
-        valid
-      )
-      cxt.ok(valid)
-    }
-
     function validateAsyncRef(v: Code): void {
       if (!it.async) throw new Error("async schema referenced by sync schema")
       const valid = gen.let("valid")
@@ -102,7 +83,7 @@ const def: CodeKeywordDefinition = {
       cxt.ok(valid)
     }
 
-    function validateRef(v: Code): void {
+    function validateSyncRef(v: Code): void {
       cxt.pass(callValidateCode(cxt, v, passCxt), () => addErrorsFrom(v))
     }
 

spec/resolve.spec.ts

@@ -321,7 +321,7 @@ describe("resolve", () => {
     }
 
     function testInlined(validate: ValidateFunction, expectedInlined) {
-      const inlined: any = !/scope\.validate/.test(validate.source?.code || "")
+      const inlined: any = !validate.source?.code.includes("scope.validate")
       inlined.should.equal(expectedInlined)
     }
   })