@kubb/agent 5.0.0-beta.3 → 5.0.0-beta.31

package/.output/server/node_modules/ajv/lib/vocabularies/discriminator/index.ts

@@ -12,11 +12,28 @@ const error: KeywordErrorDefinition = {
   message: ({params: {discrError, tagName}}) =>
     discrError === DiscrError.Tag
       ? `tag "${tagName}" must be string`
-      : `value of tag "${tagName}" must be in oneOf`,
+      : `value of tag "${tagName}" must be in oneOf or anyOf`,
   params: ({params: {discrError, tag, tagName}}) =>
     _`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`,
 }
 
+function getDiscriminatorPropertyFromAllOf(
+  sch: AnySchemaObject,
+  tagName: string
+): AnySchemaObject | undefined {
+  if (!sch.allOf || !Array.isArray(sch.allOf)) {
+    return undefined
+  }
+
+  for (const subschema of sch.allOf) {
+    if (subschema?.properties?.[tagName]) {
+      return subschema.properties[tagName] as AnySchemaObject
+    }
+  }
+
+  return undefined
+}
+
 const def: CodeKeywordDefinition = {
   keyword: "discriminator",
   type: "object",
@@ -24,14 +41,16 @@ const def: CodeKeywordDefinition = {
   error,
   code(cxt: KeywordCxt) {
     const {gen, data, schema, parentSchema, it} = cxt
-    const {oneOf} = parentSchema
+
+    const keyword = parentSchema.oneOf ? "oneOf" : parentSchema.anyOf ? "anyOf" : undefined
+
     if (!it.opts.discriminator) {
       throw new Error("discriminator: requires discriminator option")
     }
     const tagName = schema.propertyName
     if (typeof tagName != "string") throw new Error("discriminator: requires propertyName")
-    if (schema.mapping) throw new Error("discriminator: mapping is not supported")
-    if (!oneOf) throw new Error("discriminator: requires oneOf keyword")
+    if (!keyword) throw new Error("discriminator: requires oneOf or anyOf composite keyword")
+    const parentSchemaVariants = parentSchema[keyword]
     const valid = gen.let("valid", false)
     const tag = gen.const("tag", _`${data}${getProperty(tagName)}`)
     gen.if(
@@ -55,37 +74,68 @@ const def: CodeKeywordDefinition = {
 
     function applyTagSchema(schemaProp?: number): Name {
       const _valid = gen.name("valid")
-      const schCxt = cxt.subschema({keyword: "oneOf", schemaProp}, _valid)
+      const schCxt = cxt.subschema({keyword, schemaProp}, _valid)
       cxt.mergeEvaluated(schCxt, Name)
       return _valid
     }
 
     function getMapping(): {[T in string]?: number} {
-      const oneOfMapping: {[T in string]?: number} = {}
+      const discriminatorMapping: {[T in string]?: number} = {}
       const topRequired = hasRequired(parentSchema)
       let tagRequired = true
-      for (let i = 0; i < oneOf.length; i++) {
-        let sch = oneOf[i]
-        if (sch?.$ref && !schemaHasRulesButRef(sch, it.self.RULES)) {
-          const ref = sch.$ref
-          sch = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref)
+      for (let i = 0; i < parentSchemaVariants.length; i++) {
+        let sch = parentSchemaVariants[i]
+        const schRef = sch?.$ref
+
+        if (schRef && schema.mapping) {
+          const {mapping} = schema
+          const matchedKeys = Object.keys(mapping).filter((key) => mapping[key] === sch.$ref)
+
+          if (matchedKeys.length) {
+            for (const key of matchedKeys) {
+              addMapping(key, i)
+            }
+            continue
+          }
+        }
+
+        if (schRef && !schemaHasRulesButRef(sch, it.self.RULES)) {
+          sch = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, schRef)
           if (sch instanceof SchemaEnv) sch = sch.schema
-          if (sch === undefined) throw new MissingRefError(it.opts.uriResolver, it.baseId, ref)
+          if (sch === undefined) throw new MissingRefError(it.opts.uriResolver, it.baseId, schRef)
         }
-        const propSch = sch?.properties?.[tagName]
+
+        let propSch = sch?.properties?.[tagName]
+        if (!propSch && sch?.allOf) {
+          propSch = getDiscriminatorPropertyFromAllOf(sch, tagName)
+        }
+
         if (typeof propSch != "object") {
           throw new Error(
-            `discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`
+            `discriminator: ${keyword} subschemas (or referenced schemas) must have "properties/${tagName}" or match mapping`
           )
         }
         tagRequired = tagRequired && (topRequired || hasRequired(sch))
         addMappings(propSch, i)
       }
       if (!tagRequired) throw new Error(`discriminator: "${tagName}" must be required`)
-      return oneOfMapping
+      return discriminatorMapping
+
+      function hasRequired(sch: AnySchemaObject): boolean {
+        if (Array.isArray(sch.required) && sch.required.includes(tagName)) {
+          return true
+        }
+
+        if (sch.allOf && Array.isArray(sch.allOf)) {
+          for (const subschema of sch.allOf) {
+            const subSch = subschema as AnySchemaObject
+            if (Array.isArray(subSch.required) && subSch.required.includes(tagName)) {
+              return true
+            }
+          }
+        }
 
-      function hasRequired({required}: AnySchemaObject): boolean {
-        return Array.isArray(required) && required.includes(tagName)
+        return false
       }
 
       function addMappings(sch: AnySchemaObject, i: number): void {
@@ -101,10 +151,10 @@ const def: CodeKeywordDefinition = {
       }
 
       function addMapping(tagValue: unknown, i: number): void {
-        if (typeof tagValue != "string" || tagValue in oneOfMapping) {
+        if (typeof tagValue != "string" || tagValue in discriminatorMapping) {
           throw new Error(`discriminator: "${tagName}" values must be unique strings`)
         }
-        oneOfMapping[tagValue] = i
+        discriminatorMapping[tagValue] = i
       }
     }
   },

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

@@ -0,0 +1,32 @@
+import {Vocabulary} from "../types"
+import refKeyword from "./core/ref"
+import getApplicatorVocabulary from "./applicator"
+import unevaluatedVocabulary from "./unevaluated"
+import formatVocabulary from "./format"
+import validationVocabulary from "./validation"
+import limitNumber from "./validation/draft04/limitNumber"
+import limitNumberExclusive from "./validation/draft04/limitNumberExclusive"
+
+const metadataVocabulary: Vocabulary = ["title", "description", "default"]
+
+const coreVocabulary: Vocabulary = [
+  "$schema",
+  "id",
+  "$defs",
+  {keyword: "$comment"},
+  "definitions",
+  refKeyword,
+]
+
+const validation: Vocabulary = [...validationVocabulary.slice(1), limitNumber, limitNumberExclusive]
+
+const draft4Vocabularies: Vocabulary[] = [
+  coreVocabulary,
+  validation,
+  getApplicatorVocabulary(),
+  formatVocabulary,
+  metadataVocabulary,
+  unevaluatedVocabulary,
+]
+
+export default draft4Vocabularies

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

@@ -5,8 +5,16 @@ export const metadataVocabulary: Vocabulary = [
   "description",
   "default",
   "deprecated",
-  "readOnly",
-  "writeOnly",
+  /**
+   * readOnly/writeOnly are handled as validation keywords when OAS context is provided.
+   * Keeping them here would register them as annotation-only metadata and would
+   * prevent the context-aware validation behavior.
+   *
+   * @see ./validation/readOnly.ts
+   * @see ./validation/writeOnly.ts
+   */
+  // "readOnly",
+  // "writeOnly",
   "examples",
 ]
 

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

@@ -0,0 +1,27 @@
+import type {AnySchemaObject} from "../types"
+
+import {_, or, type Code} from "../compile/codegen"
+import N from "../compile/names"
+
+export function getSkipCondition(schema: AnySchemaObject, prop: string): Code | undefined {
+  const propSchema = schema.properties?.[prop]
+  if (!propSchema) return undefined
+
+  const hasReadOnly = propSchema.readOnly === true
+  const hasWriteOnly = propSchema.writeOnly === true
+
+  if (!hasReadOnly && !hasWriteOnly) return undefined
+
+  const conditions: Code[] = []
+  const apiContext = _`typeof ${N.this} == "object" && ${N.this} && ${N.this}.apiContext`
+
+  if (hasReadOnly) {
+    conditions.push(_`${apiContext} === "request"`)
+  }
+
+  if (hasWriteOnly) {
+    conditions.push(_`${apiContext} === "response"`)
+  }
+
+  return or(...conditions)
+}

package/.output/server/node_modules/ajv/lib/vocabularies/unevaluated/unevaluatedProperties.ts

@@ -23,10 +23,12 @@ const def: CodeKeywordDefinition = {
   keyword: "unevaluatedProperties",
   type: "object",
   schemaType: ["boolean", "object"],
+  allowUndefined: true,
   trackErrors: true,
   error,
   code(cxt) {
-    const {gen, schema, data, errsCount, it} = cxt
+    const {gen, schema = cxt.it.opts.defaultUnevaluatedProperties, data, errsCount, it} = cxt
+    const isForced = cxt.schema === undefined && cxt.it.opts.defaultUnevaluatedProperties === false
     /* istanbul ignore if */
     if (!errsCount) throw new Error("ajv implementation error")
     const {allErrors, props} = it
@@ -37,13 +39,33 @@ const def: CodeKeywordDefinition = {
         )
       )
     } else if (props !== true) {
-      gen.forIn("key", data, (key: Name) =>
-        props === undefined
-          ? unevaluatedPropCode(key)
-          : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key))
-      )
+      // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+      const staticCheck = () =>
+        gen.forIn("key", data, (key: Name) =>
+          props === undefined
+            ? unevaluatedPropCode(key)
+            : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key))
+        )
+
+      if (isForced && it.errorPath.emptyStr() && !it.compositeRule) {
+        // $refs are compiled into functions
+        // We need to check in runtime if function was called from allOf.
+        // We need to check only on the top level of the function:
+        // it is ensured with `it.errorPath.emptyStr()` check
+        gen.if(_`${N.isAllOfVariant} === 0`, staticCheck)
+      } else {
+        if (!it.compositeRule || cxt.schema !== undefined) {
+          staticCheck()
+        }
+      }
+    }
+
+    if (!isForced) {
+      // disable shot-circut for forced unevaluatedProperties=false
+      // we may run or not the check in runtime so we can't short-circuit in compile-time
+      it.props = true
     }
-    it.props = true
+
     cxt.ok(_`${errsCount} === ${N.errors}`)
 
     function unevaluatedPropCode(key: Name): void {

package/.output/server/node_modules/ajv/lib/vocabularies/validation/draft04/limitNumber.ts

@@ -0,0 +1,75 @@
+import type {
+  CodeKeywordDefinition,
+  ErrorObject,
+  KeywordErrorDefinition,
+  KeywordErrorCxt,
+} from "../../../types"
+import type {KeywordCxt} from "../../../compile/validate"
+import {_, str, operators, Code} from "../../../compile/codegen"
+
+const ops = operators
+
+export type LimitKwd = "maximum" | "minimum"
+
+export type ExclusiveLimitKwd = "exclusiveMaximum" | "exclusiveMinimum"
+
+type Comparison = "<=" | ">=" | "<" | ">"
+
+interface KwdOp {
+  okStr: Comparison
+  ok: Code
+  fail: Code
+}
+
+interface KwdDef {
+  exclusive: ExclusiveLimitKwd
+  ops: [KwdOp, KwdOp]
+}
+
+const KWDs: {[K in LimitKwd]: KwdDef} = {
+  maximum: {
+    exclusive: "exclusiveMaximum",
+    ops: [
+      {okStr: "<=", ok: ops.LTE, fail: ops.GT},
+      {okStr: "<", ok: ops.LT, fail: ops.GTE},
+    ],
+  },
+  minimum: {
+    exclusive: "exclusiveMinimum",
+    ops: [
+      {okStr: ">=", ok: ops.GTE, fail: ops.LT},
+      {okStr: ">", ok: ops.GT, fail: ops.LTE},
+    ],
+  },
+}
+
+export type LimitNumberError = ErrorObject<
+  LimitKwd,
+  {limit: number; comparison: Comparison},
+  number | {$data: string}
+>
+
+const error: KeywordErrorDefinition = {
+  message: (cxt) => str`must be ${kwdOp(cxt).okStr} ${cxt.schemaCode}`,
+  params: (cxt) => _`{comparison: ${kwdOp(cxt).okStr}, limit: ${cxt.schemaCode}}`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: Object.keys(KWDs),
+  type: "number",
+  schemaType: "number",
+  $data: true,
+  error,
+  code(cxt: KeywordCxt) {
+    const {data, schemaCode} = cxt
+    cxt.fail$data(_`${data} ${kwdOp(cxt).fail} ${schemaCode} || isNaN(${data})`)
+  },
+}
+
+function kwdOp(cxt: KeywordErrorCxt): KwdOp {
+  const keyword = cxt.keyword as LimitKwd
+  const opsIdx = cxt.parentSchema?.[KWDs[keyword].exclusive] ? 1 : 0
+  return KWDs[keyword].ops[opsIdx]
+}
+
+export default def

package/.output/server/node_modules/ajv/lib/vocabularies/validation/draft04/limitNumberExclusive.ts

@@ -0,0 +1,26 @@
+import type {
+  CodeKeywordDefinition,
+  // ErrorObject,
+  // KeywordErrorDefinition,
+} from "../../../types"
+import type {KeywordCxt} from "../../../compile/validate"
+import {LimitKwd, ExclusiveLimitKwd} from "./limitNumber"
+
+const KWDs: {[K in ExclusiveLimitKwd]: LimitKwd} = {
+  exclusiveMaximum: "maximum",
+  exclusiveMinimum: "minimum",
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: Object.keys(KWDs),
+  type: "number",
+  schemaType: "boolean",
+  code({keyword, parentSchema}: KeywordCxt) {
+    const limitKwd = KWDs[keyword as ExclusiveLimitKwd]
+    if (parentSchema[limitKwd] === undefined) {
+      throw new Error(`${keyword} can only be used with ${limitKwd}`)
+    }
+  },
+}
+
+export default def

package/.output/server/node_modules/ajv/lib/vocabularies/validation/index.ts

@@ -5,6 +5,8 @@ import limitLength from "./limitLength"
 import pattern, {PatternError} from "./pattern"
 import limitProperties from "./limitProperties"
 import required, {RequiredError} from "./required"
+import readOnlyKeyword from "./readOnly"
+import writeOnlyKeyword from "./writeOnly"
 import limitItems from "./limitItems"
 import uniqueItems, {UniqueItemsError} from "./uniqueItems"
 import constKeyword, {ConstError} from "./const"
@@ -20,6 +22,8 @@ const validation: Vocabulary = [
   // object
   limitProperties,
   required,
+  readOnlyKeyword,
+  writeOnlyKeyword,
   // array
   limitItems,
   uniqueItems,

package/.output/server/node_modules/ajv/lib/vocabularies/validation/readOnly.ts

@@ -0,0 +1,23 @@
+import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {_, str} from "../../compile/codegen"
+import N from "../../compile/names"
+
+const error: KeywordErrorDefinition = {
+  message: () => str`must NOT be present in request context`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: "readOnly",
+  schemaType: "boolean",
+  error,
+  code(cxt: KeywordCxt) {
+    if (cxt.schema !== true) return
+
+    const apiContext = _`(${N.this} && ${N.this}.apiContext)`
+
+    cxt.fail(_`${apiContext} === "request"`)
+  },
+}
+
+export default def

package/.output/server/node_modules/ajv/lib/vocabularies/validation/required.ts

@@ -7,6 +7,7 @@ import {
   propertyInData,
   noPropertyInData,
 } from "../code"
+import {getSkipCondition} from "../oasContext"
 import {_, str, nil, not, Name, Code} from "../../compile/codegen"
 import {checkStrictMode} from "../../compile/util"
 
@@ -52,7 +53,12 @@ const def: CodeKeywordDefinition = {
         cxt.block$data(nil, loopAllRequired)
       } else {
         for (const prop of schema) {
-          checkReportMissingProp(cxt, prop)
+          const skip = getSkipCondition(cxt.parentSchema, prop) ?? _`false`
+          /**
+           * Generate a runtime check: validate `required` only when this property
+           * should NOT be skipped in the current context (readOnly/writeOnly).
+           */
+          gen.if(not(skip), () => checkReportMissingProp(cxt, prop))
         }
       }
     }

package/.output/server/node_modules/ajv/lib/vocabularies/validation/writeOnly.ts

@@ -0,0 +1,22 @@
+import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {_, str} from "../../compile/codegen"
+import N from "../../compile/names"
+
+const error: KeywordErrorDefinition = {
+  message: () => str`must NOT be present in response context`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: "writeOnly",
+  schemaType: "boolean",
+  error,
+  code(cxt: KeywordCxt) {
+    if (cxt.schema !== true) return
+    const apiContext = _`(${N.this} && ${N.this}.apiContext)`
+
+    cxt.fail(_`${apiContext} === "response"`)
+  },
+}
+
+export default def

package/.output/server/node_modules/ajv/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "ajv",
-  "version": "8.18.0",
+  "name": "@redocly/ajv",
+  "version": "8.18.1",
   "description": "Another JSON Schema Validator",
   "main": "dist/ajv.js",
   "types": "dist/ajv.d.ts",
@@ -30,7 +30,9 @@
     "prepublish": "npm run build",
     "benchmark": "npm i && npm run build && npm link && cd ./benchmark && npm link --legacy-peer-deps ajv && npm i && node ./jtd",
     "docs:dev": "./scripts/prepare-site && vuepress dev docs",
-    "docs:build": "./scripts/prepare-site && vuepress build docs"
+    "docs:build": "./scripts/prepare-site && vuepress build docs",
+    "pretest": "npx npe name ajv",
+    "posttest": "npx npe name @redocly/ajv"
   },
   "nyc": {
     "exclude": [
@@ -42,7 +44,10 @@
       "text-summary"
     ]
   },
-  "repository": "ajv-validator/ajv",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Redocly/ajv.git"
+  },
   "keywords": [
     "JSON",
     "schema",
@@ -55,8 +60,6 @@
   ],
   "author": "Evgeny Poberezkin",
   "license": "MIT",
-  "bugs": "https://github.com/ajv-validator/ajv/issues",
-  "homepage": "https://ajv.js.org",
   "runkitExampleFilename": ".runkit_example.js",
   "dependencies": {
     "fast-deep-equal": "^3.1.3",