@kubb/agent 5.0.0-beta.75 → 5.0.0-beta.8

package/.output/server/node_modules/ajv/lib/compile/index.ts

@@ -56,6 +56,7 @@ export interface SchemaCxt {
   readonly createErrors?: boolean
   readonly opts: InstanceOptions // Ajv instance option.
   readonly self: Ajv // current Ajv instance
+  readonly isAllOfVariant?: boolean // if the current schema is direct child of allOf
 }
 
 export interface SchemaObjCxt extends SchemaCxt {
@@ -116,6 +117,7 @@ export function compileSchema(this: Ajv, sch: SchemaEnv): SchemaEnv {
   const {es5, lines} = this.opts.code
   const {ownProperties} = this.opts
   const gen = new CodeGen(this.scope, {es5, lines, ownProperties})
+
   let _ValidationError
   if (sch.$async) {
     _ValidationError = gen.scopeValue("Error", {
@@ -164,7 +166,9 @@ export function compileSchema(this: Ajv, sch: SchemaEnv): SchemaEnv {
     gen.optimize(this.opts.code.optimize)
     // gen.optimize(1)
     const validateCode = gen.toString()
-    sourceCode = `${gen.scopeRefs(N.scope)}return ${validateCode}`
+    sourceCode = `const visitedNodesForRef = new WeakMap(); ${gen.scopeRefs(
+      N.scope
+    )}return ${validateCode}`
     // console.log((codeSize += sourceCode.length), (nodeCount += gen.nodeCount))
     if (this.opts.code.process) sourceCode = this.opts.code.process(sourceCode, sch)
     // console.log("\n\n\n *** \n", sourceCode)
@@ -206,9 +210,9 @@ export function resolveRef(
   this: Ajv,
   root: SchemaEnv,
   baseId: string,
-  ref: string
+  origRef: string
 ): AnySchema | SchemaEnv | undefined {
-  ref = resolveUrl(this.opts.uriResolver, baseId, ref)
+  const ref = resolveUrl(this.opts.uriResolver, baseId, origRef)
   const schOrFunc = root.refs[ref]
   if (schOrFunc) return schOrFunc
 
@@ -219,6 +223,15 @@ export function resolveRef(
     if (schema) _sch = new SchemaEnv({schema, schemaId, root, baseId})
   }
 
+  if (_sch === undefined && this.opts.loadSchemaSync) {
+    const remoteSchema = this.opts.loadSchemaSync(baseId, origRef, ref)
+
+    if (remoteSchema && !(this.refs[ref] || this.schemas[ref])) {
+      this.addSchema(remoteSchema, ref, undefined)
+      _sch = resolve.call(this, root, ref)
+    }
+  }
+
   if (_sch === undefined) return
   return (root.refs[ref] = inlineOrCompile.call(this, _sch))
 }

package/.output/server/node_modules/ajv/lib/compile/jtd/parse.ts

@@ -65,7 +65,9 @@ export default function compileParser(
     parserFunction(cxt)
     gen.optimize(this.opts.code.optimize)
     const parseFuncCode = gen.toString()
-    sourceCode = `${gen.scopeRefs(N.scope)}return ${parseFuncCode}`
+    sourceCode = `const visitedNodesForRef = new WeakMap(); ${gen.scopeRefs(
+      N.scope
+    )}return ${parseFuncCode}`
     const makeParse = new Function(`${N.scope}`, sourceCode)
     const parse: (json: string) => unknown = makeParse(this.scope.get())
     this.scope.value(parseName, {ref: parse})

package/.output/server/node_modules/ajv/lib/compile/jtd/serialize.ts

@@ -61,7 +61,9 @@ export default function compileSerializer(
     })
     gen.optimize(this.opts.code.optimize)
     const serializeFuncCode = gen.toString()
-    sourceCode = `${gen.scopeRefs(N.scope)}return ${serializeFuncCode}`
+    sourceCode = `const visitedNodesForRef = new WeakMap(); ${gen.scopeRefs(
+      N.scope
+    )}return ${serializeFuncCode}`
     const makeSerialize = new Function(`${N.scope}`, sourceCode)
     const serialize: (data: unknown) => string = makeSerialize(this.scope.get())
     this.scope.value(serializeName, {ref: serialize})

package/.output/server/node_modules/ajv/lib/compile/names.ts

@@ -10,6 +10,7 @@ const names = {
   parentDataProperty: new Name("parentDataProperty"),
   rootData: new Name("rootData"), // root data - same as the data passed to the first/top validation function
   dynamicAnchors: new Name("dynamicAnchors"), // used to support recursiveRef and dynamicRef
+  isAllOfVariant: new Name("isAllOfVariant"), // used to check in runtime if the current function (ref) is called from allOf
   // function scoped variables
   vErrors: new Name("vErrors"), // null or array of validation errors
   errors: new Name("errors"), // counter of validation errors

package/.output/server/node_modules/ajv/lib/compile/validate/index.ts

@@ -66,7 +66,7 @@ function validateFunction(
 function destructureValCxt(opts: InstanceOptions): Code {
   return _`{${N.instancePath}="", ${N.parentData}, ${N.parentDataProperty}, ${N.rootData}=${
     N.data
-  }${opts.dynamicRef ? _`, ${N.dynamicAnchors}={}` : nil}}={}`
+  }${opts.dynamicRef ? _`, ${N.dynamicAnchors}={}` : nil}, ${N.isAllOfVariant} = 0}={}`
 }
 
 function destructureValCxtES5(gen: CodeGen, opts: InstanceOptions): void {
@@ -77,6 +77,7 @@ function destructureValCxtES5(gen: CodeGen, opts: InstanceOptions): void {
       gen.var(N.parentData, _`${N.valCxt}.${N.parentData}`)
       gen.var(N.parentDataProperty, _`${N.valCxt}.${N.parentDataProperty}`)
       gen.var(N.rootData, _`${N.valCxt}.${N.rootData}`)
+      gen.var(N.isAllOfVariant, _`${N.valCxt}.${N.isAllOfVariant}`)
       if (opts.dynamicRef) gen.var(N.dynamicAnchors, _`${N.valCxt}.${N.dynamicAnchors}`)
     },
     () => {
@@ -84,6 +85,7 @@ function destructureValCxtES5(gen: CodeGen, opts: InstanceOptions): void {
       gen.var(N.parentData, _`undefined`)
       gen.var(N.parentDataProperty, _`undefined`)
       gen.var(N.rootData, N.data)
+      gen.var(N.isAllOfVariant, _`0`)
       if (opts.dynamicRef) gen.var(N.dynamicAnchors, _`{}`)
     }
   )
@@ -261,11 +263,20 @@ function iterateKeywords(it: SchemaObjCxt, group: RuleGroup): void {
   if (useDefaults) assignDefaults(it, group.type)
   gen.block(() => {
     for (const rule of group.rules) {
-      if (shouldUseRule(schema, rule)) {
+      if (shouldUseRule(schema, rule) || shouldForceUnevaluatedProperties(schema, rule)) {
         keywordCode(it, rule.keyword, rule.definition, group.type)
       }
     }
   })
+
+  function shouldForceUnevaluatedProperties(schemaObj: AnySchemaObject, rule: Rule): boolean {
+    return !!(
+      rule.keyword === "unevaluatedProperties" &&
+      (schemaObj.properties || schemaObj.patternProperties) &&
+      !it.isAllOfVariant &&
+      it.opts.defaultUnevaluatedProperties === false
+    )
+  }
 }
 
 function checkStrictTypes(it: SchemaObjCxt, types: JSONType[]): void {
@@ -492,11 +503,17 @@ export class KeywordCxt implements KeywordErrorCxt {
     }
   }
 
-  subschema(appl: SubschemaArgs, valid: Name): SchemaCxt {
+  subschema(appl: SubschemaArgs, valid: Name, isAllOfVariant?: boolean): SchemaCxt {
     const subschema = getSubschema(this.it, appl)
     extendSubschemaData(subschema, this.it, appl)
     extendSubschemaMode(subschema, appl)
-    const nextContext = {...this.it, ...subschema, items: undefined, props: undefined}
+    const nextContext = {
+      ...this.it,
+      ...subschema,
+      items: undefined,
+      props: undefined,
+      isAllOfVariant,
+    }
     subschemaCode(nextContext, valid)
     return nextContext
   }

package/.output/server/node_modules/ajv/lib/core.ts

@@ -68,7 +68,13 @@ import DefaultUriResolver from "./runtime/uri"
 const defaultRegExp: RegExpEngine = (str, flags) => new RegExp(str, flags)
 defaultRegExp.code = "new RegExp"
 
-const META_IGNORE_OPTIONS: (keyof Options)[] = ["removeAdditional", "useDefaults", "coerceTypes"]
+const META_IGNORE_OPTIONS: (keyof Options)[] = [
+  "removeAdditional",
+  "useDefaults",
+  "coerceTypes",
+  "defaultUnevaluatedProperties",
+  "defaultAdditionalProperties",
+]
 const EXT_SCOPE_NAMES = new Set([
   "validate",
   "serialize",
@@ -116,8 +122,12 @@ export interface CurrentOptions {
   schemas?: AnySchema[] | {[Key in string]?: AnySchema}
   logger?: Logger | false
   loadSchema?: (uri: string) => Promise<AnySchemaObject>
+  loadSchemaSync?: (base: string, $ref: string, id: string) => AnySchemaObject | boolean
   // options to modify validated data:
   removeAdditional?: boolean | "all" | "failing"
+  defaultUnevaluatedProperties?: boolean
+  defaultAdditionalProperties?: boolean // @deprecated
+
   useDefaults?: boolean | "empty"
   coerceTypes?: boolean | "array"
   // advanced options:
@@ -334,6 +344,15 @@ export default class Ajv {
     return (this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : undefined)
   }
 
+  // Set the defaultUnevaluatedProperties option.
+  // WARNING: This only affects schemas compiled AFTER this method is called.
+  // Already-compiled schemas in the cache will NOT be affected.
+  // Consider clearing the cache or creating a new Ajv instance if you need
+  // different behavior for the same schemas.
+  setDefaultUnevaluatedProperties(value: boolean): void {
+    this.opts.defaultUnevaluatedProperties = value
+  }
+
   // Validate data using schema
   // AnySchema will be compiled and cached using schema itself as a key for Map
   validate(schema: Schema | string, data: unknown): boolean

package/.output/server/node_modules/ajv/lib/draft4.ts

@@ -0,0 +1,79 @@
+import type {AnySchemaObject, Options} from "./core"
+import AjvCore from "./core"
+import draft4Vocabularies from "./vocabularies/draft4"
+import discriminator from "./vocabularies/discriminator"
+import * as draft4MetaSchema from "./refs/json-schema-draft-04.json"
+
+const META_SUPPORT_DATA = ["/properties"]
+
+const META_SCHEMA_ID = "http://json-schema.org/draft-04/schema"
+
+export class Ajv extends AjvCore {
+  constructor(opts: Options = {}) {
+    super({
+      ...opts,
+      schemaId: "id",
+      dynamicRef: true,
+      unevaluated: true,
+    })
+  }
+
+  _addVocabularies(): void {
+    super._addVocabularies()
+    draft4Vocabularies.forEach((v) => this.addVocabulary(v))
+    if (this.opts.discriminator) this.addKeyword(discriminator)
+  }
+
+  _addDefaultMetaSchema(): void {
+    super._addDefaultMetaSchema()
+    if (!this.opts.meta) return
+    const metaSchema = this.opts.$data
+      ? this.$dataMetaSchema(draft4MetaSchema, META_SUPPORT_DATA)
+      : draft4MetaSchema
+    this.addMetaSchema(metaSchema, META_SCHEMA_ID, false)
+    this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID
+  }
+
+  defaultMeta(): string | AnySchemaObject | undefined {
+    return (this.opts.defaultMeta =
+      super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))
+  }
+}
+
+module.exports = exports = Ajv
+Object.defineProperty(exports, "__esModule", {value: true})
+
+export default Ajv
+
+export {
+  Format,
+  FormatDefinition,
+  AsyncFormatDefinition,
+  KeywordDefinition,
+  KeywordErrorDefinition,
+  CodeKeywordDefinition,
+  MacroKeywordDefinition,
+  FuncKeywordDefinition,
+  Vocabulary,
+  Schema,
+  SchemaObject,
+  AnySchemaObject,
+  AsyncSchema,
+  AnySchema,
+  ValidateFunction,
+  AsyncValidateFunction,
+  SchemaValidateFunction,
+  ErrorObject,
+  ErrorNoParams,
+  Context,
+} from "./types"
+
+export {Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions} from "./core"
+export {SchemaCxt, SchemaObjCxt} from "./compile"
+export {KeywordCxt} from "./compile/validate"
+export {DefinedError} from "./vocabularies/errors"
+export {JSONType} from "./compile/rules"
+export {JSONSchemaType} from "./types/json-schema"
+export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
+export {default as ValidationError} from "./runtime/validation_error"
+export {default as MissingRefError} from "./compile/ref_error"

package/.output/server/node_modules/ajv/lib/refs/json-schema-draft-04.json

@@ -0,0 +1,138 @@
+{
+  "id": "http://json-schema.org/draft-04/schema#",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "description": "Core schema meta-schema",
+  "definitions": {
+    "schemaArray": {
+      "type": "array",
+      "minItems": 1,
+      "items": {"$ref": "#"}
+    },
+    "positiveInteger": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "positiveIntegerDefault0": {
+      "allOf": [{"$ref": "#/definitions/positiveInteger"}, {"default": 0}]
+    },
+    "simpleTypes": {
+      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
+    },
+    "stringArray": {
+      "type": "array",
+      "items": {"type": "string"},
+      "minItems": 1,
+      "uniqueItems": true
+    }
+  },
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "format": "uri"
+    },
+    "$schema": {
+      "type": "string",
+      "format": "uri"
+    },
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "default": {},
+    "multipleOf": {
+      "type": "number",
+      "minimum": 0,
+      "exclusiveMinimum": true
+    },
+    "maximum": {
+      "type": "number"
+    },
+    "exclusiveMaximum": {
+      "type": "boolean",
+      "default": false
+    },
+    "minimum": {
+      "type": "number"
+    },
+    "exclusiveMinimum": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxLength": {"$ref": "#/definitions/positiveInteger"},
+    "minLength": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "pattern": {
+      "type": "string",
+      "format": "regex"
+    },
+    "additionalItems": {
+      "anyOf": [{"type": "boolean"}, {"$ref": "#"}],
+      "default": {}
+    },
+    "items": {
+      "anyOf": [{"$ref": "#"}, {"$ref": "#/definitions/schemaArray"}],
+      "default": {}
+    },
+    "maxItems": {"$ref": "#/definitions/positiveInteger"},
+    "minItems": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "uniqueItems": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxProperties": {"$ref": "#/definitions/positiveInteger"},
+    "minProperties": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "required": {"$ref": "#/definitions/stringArray"},
+    "additionalProperties": {
+      "anyOf": [{"type": "boolean"}, {"$ref": "#"}],
+      "default": {}
+    },
+    "definitions": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "properties": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "patternProperties": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "dependencies": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [{"$ref": "#"}, {"$ref": "#/definitions/stringArray"}]
+      }
+    },
+    "enum": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "type": {
+      "anyOf": [
+        {"$ref": "#/definitions/simpleTypes"},
+        {
+          "type": "array",
+          "items": {"$ref": "#/definitions/simpleTypes"},
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      ]
+    },
+    "allOf": {"$ref": "#/definitions/schemaArray"},
+    "anyOf": {"$ref": "#/definitions/schemaArray"},
+    "oneOf": {"$ref": "#/definitions/schemaArray"},
+    "not": {"$ref": "#"}
+  },
+  "dependencies": {
+    "exclusiveMaximum": ["maximum"],
+    "exclusiveMinimum": ["minimum"]
+  },
+  "default": {}
+}

package/.output/server/node_modules/ajv/lib/types/index.ts

@@ -242,3 +242,7 @@ export interface UriResolver {
   resolve(base: string, path: string): string
   serialize(component: URIComponent): string
 }
+
+export interface Context {
+  apiContext?: "request" | "response"
+}

package/.output/server/node_modules/ajv/lib/vocabularies/applicator/additionalProperties.ts

@@ -30,7 +30,8 @@ const def: CodeKeywordDefinition & AddedKeywordDefinition = {
   trackErrors: true,
   error,
   code(cxt) {
-    const {gen, schema, parentSchema, data, errsCount, it} = cxt
+    const {gen, parentSchema, data, errsCount, it} = cxt
+    const {schema = it.opts.defaultAdditionalProperties} = cxt
     /* istanbul ignore if */
     if (!errsCount) throw new Error("ajv implementation error")
     const {allErrors, opts} = it

package/.output/server/node_modules/ajv/lib/vocabularies/applicator/allOf.ts

@@ -12,7 +12,7 @@ const def: CodeKeywordDefinition = {
     const valid = gen.name("valid")
     schema.forEach((sch: AnySchema, i: number) => {
       if (alwaysValidSchema(it, sch)) return
-      const schCxt = cxt.subschema({keyword: "allOf", schemaProp: i}, valid)
+      const schCxt = cxt.subschema({keyword: "allOf", schemaProp: i}, valid, true)
       cxt.ok(valid)
       cxt.mergeEvaluated(schCxt)
     })

package/.output/server/node_modules/ajv/lib/vocabularies/applicator/properties.ts

@@ -10,7 +10,10 @@ const def: CodeKeywordDefinition = {
   schemaType: "object",
   code(cxt: KeywordCxt) {
     const {gen, schema, parentSchema, data, it} = cxt
-    if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === undefined) {
+    if (
+      (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === undefined) ||
+      it.opts.defaultAdditionalProperties === false
+    ) {
       apDef.code(new KeywordCxt(it, apDef, "additionalProperties"))
     }
     const allProps = allSchemaProperties(schema)

package/.output/server/node_modules/ajv/lib/vocabularies/code.ts

@@ -5,6 +5,7 @@ import {CodeGen, _, and, or, not, nil, strConcat, getProperty, Code, Name} from
 import {alwaysValidSchema, Type} from "../compile/util"
 import N from "../compile/names"
 import {useFunc} from "../compile/util"
+import {getSkipCondition} from "./oasContext"
 export function checkReportMissingProp(cxt: KeywordCxt, prop: string): void {
   const {gen, data, it} = cxt
   gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
@@ -14,13 +15,17 @@ export function checkReportMissingProp(cxt: KeywordCxt, prop: string): void {
 }
 
 export function checkMissingProp(
-  {gen, data, it: {opts}}: KeywordCxt,
+  {gen, data, it: {opts}, parentSchema}: KeywordCxt,
   properties: string[],
   missing: Name
 ): Code {
   return or(
     ...properties.map((prop) =>
-      and(noPropertyInData(gen, data, prop, opts.ownProperties), _`${missing} = ${prop}`)
+      and(
+        not(getSkipCondition(parentSchema, prop) ?? _`false`),
+        noPropertyInData(gen, data, prop, opts.ownProperties),
+        _`${missing} = ${prop}`
+      )
     )
   )
 }
@@ -84,6 +89,7 @@ export function callValidateCode(
     [N.parentData, it.parentData],
     [N.parentDataProperty, it.parentDataProperty],
     [N.rootData, N.rootData],
+    [N.isAllOfVariant, it.isAllOfVariant ? 1 : 0],
   ]
   if (it.opts.dynamicRef) valCxt.push([N.dynamicAnchors, N.dynamicAnchors])
   const args = _`${dataAndSchema}, ${gen.object(...valCxt)}`
@@ -133,9 +139,10 @@ export function validateArray(cxt: KeywordCxt): Name {
 }
 
 export function validateUnion(cxt: KeywordCxt): void {
-  const {gen, schema, keyword, it} = cxt
+  const {gen, schema, keyword, parentSchema, it} = cxt
   /* istanbul ignore if */
   if (!Array.isArray(schema)) throw new Error("ajv implementation error")
+  if (it.opts.discriminator && parentSchema.discriminator) return
   const alwaysValid = schema.some((sch: AnySchema) => alwaysValidSchema(it, sch))
   if (alwaysValid && !it.opts.unevaluated) return
 

package/.output/server/node_modules/ajv/lib/vocabularies/core/ref.ts

@@ -45,7 +45,8 @@ const def: CodeKeywordDefinition = {
           topSchemaRef: schName,
           errSchemaPath: $ref,
         },
-        valid
+        valid,
+        it.isAllOfVariant // pass isAllOfVariant into inlined $ref
       )
       cxt.mergeEvaluated(schCxt)
       cxt.ok(valid)
@@ -86,11 +87,26 @@ export function callRef(cxt: KeywordCxt, v: Code, sch?: SchemaEnv, $async?: bool
   }
 
   function callSyncRef(): void {
-    cxt.result(
-      callValidateCode(cxt, v, passCxt),
-      () => addEvaluatedFrom(v),
-      () => addErrorsFrom(v)
+    const visitedNodes: Name = gen.name("visitedNodes")
+    gen.code(
+      _`const ${visitedNodes} = (typeof visitedNodesForRef !== 'undefined') && visitedNodesForRef.get(${v}) || new Set()`
     )
+    gen.if(_`!${visitedNodes}.has(${cxt.data})`, () => {
+      gen.code(
+        _`if (typeof visitedNodesForRef !== 'undefined') visitedNodesForRef.set(${v}, ${visitedNodes})`
+      )
+      gen.code(_`const dataNode = ${cxt.data}`)
+      gen.code(
+        _`if (typeof dataNode === "object" && dataNode !== null) ${visitedNodes}.add(dataNode)`
+      )
+      const res = cxt.result(
+        callValidateCode(cxt, v, passCxt),
+        () => addEvaluatedFrom(v),
+        () => addErrorsFrom(v)
+      )
+      gen.code(_`${visitedNodes}.delete(dataNode)`)
+      return res
+    })
   }
 
   function addErrorsFrom(source: Code): void {