@aws-amplify/graphql-api-construct 1.18.3-ai-next.0 → 1.18.3

package/node_modules/ajv/lib/vocabularies/applicator/not.ts

@@ -0,0 +1,38 @@
+import type {CodeKeywordDefinition, ErrorNoParams, AnySchema} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {alwaysValidSchema} from "../../compile/util"
+
+export type NotKeywordError = ErrorNoParams<"not", AnySchema>
+
+const def: CodeKeywordDefinition = {
+  keyword: "not",
+  schemaType: ["object", "boolean"],
+  trackErrors: true,
+  code(cxt: KeywordCxt) {
+    const {gen, schema, it} = cxt
+    if (alwaysValidSchema(it, schema)) {
+      cxt.fail()
+      return
+    }
+
+    const valid = gen.name("valid")
+    cxt.subschema(
+      {
+        keyword: "not",
+        compositeRule: true,
+        createErrors: false,
+        allErrors: false,
+      },
+      valid
+    )
+
+    cxt.failResult(
+      valid,
+      () => cxt.reset(),
+      () => cxt.error()
+    )
+  },
+  error: {message: "must NOT be valid"},
+}
+
+export default def

package/node_modules/ajv/lib/vocabularies/applicator/oneOf.ts

@@ -0,0 +1,82 @@
+import type {
+  CodeKeywordDefinition,
+  ErrorObject,
+  KeywordErrorDefinition,
+  AnySchema,
+} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {_, Name} from "../../compile/codegen"
+import {alwaysValidSchema} from "../../compile/util"
+import {SchemaCxt} from "../../compile"
+
+export type OneOfError = ErrorObject<
+  "oneOf",
+  {passingSchemas: [number, number] | null},
+  AnySchema[]
+>
+
+const error: KeywordErrorDefinition = {
+  message: "must match exactly one schema in oneOf",
+  params: ({params}) => _`{passingSchemas: ${params.passing}}`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: "oneOf",
+  schemaType: "array",
+  trackErrors: true,
+  error,
+  code(cxt: KeywordCxt) {
+    const {gen, schema, parentSchema, it} = cxt
+    /* istanbul ignore if */
+    if (!Array.isArray(schema)) throw new Error("ajv implementation error")
+    if (it.opts.discriminator && parentSchema.discriminator) return
+    const schArr: AnySchema[] = schema
+    const valid = gen.let("valid", false)
+    const passing = gen.let("passing", null)
+    const schValid = gen.name("_valid")
+    cxt.setParams({passing})
+    // TODO possibly fail straight away (with warning or exception) if there are two empty always valid schemas
+
+    gen.block(validateOneOf)
+
+    cxt.result(
+      valid,
+      () => cxt.reset(),
+      () => cxt.error(true)
+    )
+
+    function validateOneOf(): void {
+      schArr.forEach((sch: AnySchema, i: number) => {
+        let schCxt: SchemaCxt | undefined
+        if (alwaysValidSchema(it, sch)) {
+          gen.var(schValid, true)
+        } else {
+          schCxt = cxt.subschema(
+            {
+              keyword: "oneOf",
+              schemaProp: i,
+              compositeRule: true,
+            },
+            schValid
+          )
+        }
+
+        if (i > 0) {
+          gen
+            .if(_`${schValid} && ${valid}`)
+            .assign(valid, false)
+            .assign(passing, _`[${passing}, ${i}]`)
+            .else()
+        }
+
+        gen.if(schValid, () => {
+          gen.assign(valid, true)
+          gen.assign(passing, i)
+          if (schCxt) cxt.mergeEvaluated(schCxt, Name)
+        })
+      })
+    }
+  },
+}
+
+export default def

package/node_modules/ajv/lib/vocabularies/applicator/patternProperties.ts

@@ -0,0 +1,91 @@
+import type {CodeKeywordDefinition} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {allSchemaProperties, usePattern} from "../code"
+import {_, not, Name} from "../../compile/codegen"
+import {alwaysValidSchema, checkStrictMode} from "../../compile/util"
+import {evaluatedPropsToName, Type} from "../../compile/util"
+import {AnySchema} from "../../types"
+
+const def: CodeKeywordDefinition = {
+  keyword: "patternProperties",
+  type: "object",
+  schemaType: "object",
+  code(cxt: KeywordCxt) {
+    const {gen, schema, data, parentSchema, it} = cxt
+    const {opts} = it
+    const patterns = allSchemaProperties(schema)
+    const alwaysValidPatterns = patterns.filter((p) =>
+      alwaysValidSchema(it, schema[p] as AnySchema)
+    )
+
+    if (
+      patterns.length === 0 ||
+      (alwaysValidPatterns.length === patterns.length &&
+        (!it.opts.unevaluated || it.props === true))
+    ) {
+      return
+    }
+
+    const checkProperties =
+      opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties
+    const valid = gen.name("valid")
+    if (it.props !== true && !(it.props instanceof Name)) {
+      it.props = evaluatedPropsToName(gen, it.props)
+    }
+    const {props} = it
+    validatePatternProperties()
+
+    function validatePatternProperties(): void {
+      for (const pat of patterns) {
+        if (checkProperties) checkMatchingProperties(pat)
+        if (it.allErrors) {
+          validateProperties(pat)
+        } else {
+          gen.var(valid, true) // TODO var
+          validateProperties(pat)
+          gen.if(valid)
+        }
+      }
+    }
+
+    function checkMatchingProperties(pat: string): void {
+      for (const prop in checkProperties) {
+        if (new RegExp(pat).test(prop)) {
+          checkStrictMode(
+            it,
+            `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`
+          )
+        }
+      }
+    }
+
+    function validateProperties(pat: string): void {
+      gen.forIn("key", data, (key) => {
+        gen.if(_`${usePattern(cxt, pat)}.test(${key})`, () => {
+          const alwaysValid = alwaysValidPatterns.includes(pat)
+          if (!alwaysValid) {
+            cxt.subschema(
+              {
+                keyword: "patternProperties",
+                schemaProp: pat,
+                dataProp: key,
+                dataPropType: Type.Str,
+              },
+              valid
+            )
+          }
+
+          if (it.opts.unevaluated && props !== true) {
+            gen.assign(_`${props}[${key}]`, true)
+          } else if (!alwaysValid && !it.allErrors) {
+            // can short-circuit if `unevaluatedProperties` is not supported (opts.next === false)
+            // or if all properties were evaluated (props === true)
+            gen.if(not(valid), () => gen.break())
+          }
+        })
+      })
+    }
+  },
+}
+
+export default def

package/node_modules/ajv/lib/vocabularies/applicator/prefixItems.ts

@@ -0,0 +1,12 @@
+import type {CodeKeywordDefinition} from "../../types"
+import {validateTuple} from "./items"
+
+const def: CodeKeywordDefinition = {
+  keyword: "prefixItems",
+  type: "array",
+  schemaType: ["array"],
+  before: "uniqueItems",
+  code: (cxt) => validateTuple(cxt, "items"),
+}
+
+export default def

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

@@ -0,0 +1,57 @@
+import type {CodeKeywordDefinition} from "../../types"
+import {KeywordCxt} from "../../compile/validate"
+import {propertyInData, allSchemaProperties} from "../code"
+import {alwaysValidSchema, toHash, mergeEvaluated} from "../../compile/util"
+import apDef from "./additionalProperties"
+
+const def: CodeKeywordDefinition = {
+  keyword: "properties",
+  type: "object",
+  schemaType: "object",
+  code(cxt: KeywordCxt) {
+    const {gen, schema, parentSchema, data, it} = cxt
+    if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === undefined) {
+      apDef.code(new KeywordCxt(it, apDef, "additionalProperties"))
+    }
+    const allProps = allSchemaProperties(schema)
+    for (const prop of allProps) {
+      it.definedProperties.add(prop)
+    }
+    if (it.opts.unevaluated && allProps.length && it.props !== true) {
+      it.props = mergeEvaluated.props(gen, toHash(allProps), it.props)
+    }
+    const properties = allProps.filter((p) => !alwaysValidSchema(it, schema[p]))
+    if (properties.length === 0) return
+    const valid = gen.name("valid")
+
+    for (const prop of properties) {
+      if (hasDefault(prop)) {
+        applyPropertySchema(prop)
+      } else {
+        gen.if(propertyInData(gen, data, prop, it.opts.ownProperties))
+        applyPropertySchema(prop)
+        if (!it.allErrors) gen.else().var(valid, true)
+        gen.endIf()
+      }
+      cxt.it.definedProperties.add(prop)
+      cxt.ok(valid)
+    }
+
+    function hasDefault(prop: string): boolean | undefined {
+      return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== undefined
+    }
+
+    function applyPropertySchema(prop: string): void {
+      cxt.subschema(
+        {
+          keyword: "properties",
+          schemaProp: prop,
+          dataProp: prop,
+        },
+        valid
+      )
+    }
+  },
+}
+
+export default def

package/node_modules/ajv/lib/vocabularies/applicator/propertyNames.ts

@@ -0,0 +1,50 @@
+import type {
+  CodeKeywordDefinition,
+  ErrorObject,
+  KeywordErrorDefinition,
+  AnySchema,
+} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {_, not} from "../../compile/codegen"
+import {alwaysValidSchema} from "../../compile/util"
+
+export type PropertyNamesError = ErrorObject<"propertyNames", {propertyName: string}, AnySchema>
+
+const error: KeywordErrorDefinition = {
+  message: "property name must be valid",
+  params: ({params}) => _`{propertyName: ${params.propertyName}}`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: "propertyNames",
+  type: "object",
+  schemaType: ["object", "boolean"],
+  error,
+  code(cxt: KeywordCxt) {
+    const {gen, schema, data, it} = cxt
+    if (alwaysValidSchema(it, schema)) return
+    const valid = gen.name("valid")
+
+    gen.forIn("key", data, (key) => {
+      cxt.setParams({propertyName: key})
+      cxt.subschema(
+        {
+          keyword: "propertyNames",
+          data: key,
+          dataTypes: ["string"],
+          propertyName: key,
+          compositeRule: true,
+        },
+        valid
+      )
+      gen.if(not(valid), () => {
+        cxt.error(true)
+        if (!it.allErrors) gen.break()
+      })
+    })
+
+    cxt.ok(valid)
+  },
+}
+
+export default def

package/node_modules/ajv/lib/vocabularies/applicator/thenElse.ts

@@ -0,0 +1,13 @@
+import type {CodeKeywordDefinition} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import {checkStrictMode} from "../../compile/util"
+
+const def: CodeKeywordDefinition = {
+  keyword: ["then", "else"],
+  schemaType: ["object", "boolean"],
+  code({keyword, parentSchema, it}: KeywordCxt) {
+    if (parentSchema.if === undefined) checkStrictMode(it, `"${keyword}" without "if" is ignored`)
+  },
+}
+
+export default def

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

@@ -0,0 +1,168 @@
+import type {AnySchema, SchemaMap} from "../types"
+import type {SchemaCxt} from "../compile"
+import type {KeywordCxt} from "../compile/validate"
+import {CodeGen, _, and, or, not, nil, strConcat, getProperty, Code, Name} from "../compile/codegen"
+import {alwaysValidSchema, Type} from "../compile/util"
+import N from "../compile/names"
+import {useFunc} from "../compile/util"
+export function checkReportMissingProp(cxt: KeywordCxt, prop: string): void {
+  const {gen, data, it} = cxt
+  gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
+    cxt.setParams({missingProperty: _`${prop}`}, true)
+    cxt.error()
+  })
+}
+
+export function checkMissingProp(
+  {gen, data, it: {opts}}: KeywordCxt,
+  properties: string[],
+  missing: Name
+): Code {
+  return or(
+    ...properties.map((prop) =>
+      and(noPropertyInData(gen, data, prop, opts.ownProperties), _`${missing} = ${prop}`)
+    )
+  )
+}
+
+export function reportMissingProp(cxt: KeywordCxt, missing: Name): void {
+  cxt.setParams({missingProperty: missing}, true)
+  cxt.error()
+}
+
+export function hasPropFunc(gen: CodeGen): Name {
+  return gen.scopeValue("func", {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    ref: Object.prototype.hasOwnProperty,
+    code: _`Object.prototype.hasOwnProperty`,
+  })
+}
+
+export function isOwnProperty(gen: CodeGen, data: Name, property: Name | string): Code {
+  return _`${hasPropFunc(gen)}.call(${data}, ${property})`
+}
+
+export function propertyInData(
+  gen: CodeGen,
+  data: Name,
+  property: Name | string,
+  ownProperties?: boolean
+): Code {
+  const cond = _`${data}${getProperty(property)} !== undefined`
+  return ownProperties ? _`${cond} && ${isOwnProperty(gen, data, property)}` : cond
+}
+
+export function noPropertyInData(
+  gen: CodeGen,
+  data: Name,
+  property: Name | string,
+  ownProperties?: boolean
+): Code {
+  const cond = _`${data}${getProperty(property)} === undefined`
+  return ownProperties ? or(cond, not(isOwnProperty(gen, data, property))) : cond
+}
+
+export function allSchemaProperties(schemaMap?: SchemaMap): string[] {
+  return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : []
+}
+
+export function schemaProperties(it: SchemaCxt, schemaMap: SchemaMap): string[] {
+  return allSchemaProperties(schemaMap).filter(
+    (p) => !alwaysValidSchema(it, schemaMap[p] as AnySchema)
+  )
+}
+
+export function callValidateCode(
+  {schemaCode, data, it: {gen, topSchemaRef, schemaPath, errorPath}, it}: KeywordCxt,
+  func: Code,
+  context: Code,
+  passSchema?: boolean
+): Code {
+  const dataAndSchema = passSchema ? _`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data
+  const valCxt: [Name, Code | number][] = [
+    [N.instancePath, strConcat(N.instancePath, errorPath)],
+    [N.parentData, it.parentData],
+    [N.parentDataProperty, it.parentDataProperty],
+    [N.rootData, N.rootData],
+  ]
+  if (it.opts.dynamicRef) valCxt.push([N.dynamicAnchors, N.dynamicAnchors])
+  const args = _`${dataAndSchema}, ${gen.object(...valCxt)}`
+  return context !== nil ? _`${func}.call(${context}, ${args})` : _`${func}(${args})`
+}
+
+const newRegExp = _`new RegExp`
+
+export function usePattern({gen, it: {opts}}: KeywordCxt, pattern: string): Name {
+  const u = opts.unicodeRegExp ? "u" : ""
+  const {regExp} = opts.code
+  const rx = regExp(pattern, u)
+
+  return gen.scopeValue("pattern", {
+    key: rx.toString(),
+    ref: rx,
+    code: _`${regExp.code === "new RegExp" ? newRegExp : useFunc(gen, regExp)}(${pattern}, ${u})`,
+  })
+}
+
+export function validateArray(cxt: KeywordCxt): Name {
+  const {gen, data, keyword, it} = cxt
+  const valid = gen.name("valid")
+  if (it.allErrors) {
+    const validArr = gen.let("valid", true)
+    validateItems(() => gen.assign(validArr, false))
+    return validArr
+  }
+  gen.var(valid, true)
+  validateItems(() => gen.break())
+  return valid
+
+  function validateItems(notValid: () => void): void {
+    const len = gen.const("len", _`${data}.length`)
+    gen.forRange("i", 0, len, (i) => {
+      cxt.subschema(
+        {
+          keyword,
+          dataProp: i,
+          dataPropType: Type.Num,
+        },
+        valid
+      )
+      gen.if(not(valid), notValid)
+    })
+  }
+}
+
+export function validateUnion(cxt: KeywordCxt): void {
+  const {gen, schema, keyword, it} = cxt
+  /* istanbul ignore if */
+  if (!Array.isArray(schema)) throw new Error("ajv implementation error")
+  const alwaysValid = schema.some((sch: AnySchema) => alwaysValidSchema(it, sch))
+  if (alwaysValid && !it.opts.unevaluated) return
+
+  const valid = gen.let("valid", false)
+  const schValid = gen.name("_valid")
+
+  gen.block(() =>
+    schema.forEach((_sch: AnySchema, i: number) => {
+      const schCxt = cxt.subschema(
+        {
+          keyword,
+          schemaProp: i,
+          compositeRule: true,
+        },
+        schValid
+      )
+      gen.assign(valid, _`${valid} || ${schValid}`)
+      const merged = cxt.mergeValidEvaluated(schCxt, schValid)
+      // can short-circuit if `unevaluatedProperties/Items` not supported (opts.unevaluated !== true)
+      // or if all properties and items were evaluated (it.props === true && it.items === true)
+      if (!merged) gen.if(not(valid))
+    })
+  )
+
+  cxt.result(
+    valid,
+    () => cxt.reset(),
+    () => cxt.error(true)
+  )
+}

package/node_modules/ajv/lib/vocabularies/core/id.ts

@@ -0,0 +1,10 @@
+import type {CodeKeywordDefinition} from "../../types"
+
+const def: CodeKeywordDefinition = {
+  keyword: "id",
+  code() {
+    throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID')
+  },
+}
+
+export default def

package/node_modules/ajv/lib/vocabularies/core/index.ts

@@ -0,0 +1,16 @@
+import type {Vocabulary} from "../../types"
+import idKeyword from "./id"
+import refKeyword from "./ref"
+
+const core: Vocabulary = [
+  "$schema",
+  "$id",
+  "$defs",
+  "$vocabulary",
+  {keyword: "$comment"},
+  "definitions",
+  idKeyword,
+  refKeyword,
+]
+
+export default core

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

@@ -0,0 +1,129 @@
+import type {CodeKeywordDefinition, AnySchema} from "../../types"
+import type {KeywordCxt} from "../../compile/validate"
+import MissingRefError from "../../compile/ref_error"
+import {callValidateCode} from "../code"
+import {_, nil, stringify, Code, Name} from "../../compile/codegen"
+import N from "../../compile/names"
+import {SchemaEnv, resolveRef} from "../../compile"
+import {mergeEvaluated} from "../../compile/util"
+
+const def: CodeKeywordDefinition = {
+  keyword: "$ref",
+  schemaType: "string",
+  code(cxt: KeywordCxt): void {
+    const {gen, schema: $ref, it} = cxt
+    const {baseId, schemaEnv: env, validateName, opts, self} = it
+    const {root} = env
+    if (($ref === "#" || $ref === "#/") && baseId === root.baseId) return callRootRef()
+    const schOrEnv = resolveRef.call(self, root, baseId, $ref)
+    if (schOrEnv === undefined) throw new MissingRefError(it.opts.uriResolver, baseId, $ref)
+    if (schOrEnv instanceof SchemaEnv) return callValidate(schOrEnv)
+    return inlineRefSchema(schOrEnv)
+
+    function callRootRef(): void {
+      if (env === root) return callRef(cxt, validateName, env, env.$async)
+      const rootName = gen.scopeValue("root", {ref: root})
+      return callRef(cxt, _`${rootName}.validate`, root, root.$async)
+    }
+
+    function callValidate(sch: SchemaEnv): void {
+      const v = getValidate(cxt, sch)
+      callRef(cxt, v, sch, sch.$async)
+    }
+
+    function inlineRefSchema(sch: AnySchema): void {
+      const schName = gen.scopeValue(
+        "schema",
+        opts.code.source === true ? {ref: sch, code: stringify(sch)} : {ref: sch}
+      )
+      const valid = gen.name("valid")
+      const schCxt = cxt.subschema(
+        {
+          schema: sch,
+          dataTypes: [],
+          schemaPath: nil,
+          topSchemaRef: schName,
+          errSchemaPath: $ref,
+        },
+        valid
+      )
+      cxt.mergeEvaluated(schCxt)
+      cxt.ok(valid)
+    }
+  },
+}
+
+export function getValidate(cxt: KeywordCxt, sch: SchemaEnv): Code {
+  const {gen} = cxt
+  return sch.validate
+    ? gen.scopeValue("validate", {ref: sch.validate})
+    : _`${gen.scopeValue("wrapper", {ref: sch})}.validate`
+}
+
+export function callRef(cxt: KeywordCxt, v: Code, sch?: SchemaEnv, $async?: boolean): void {
+  const {gen, it} = cxt
+  const {allErrors, schemaEnv: env, opts} = it
+  const passCxt = opts.passContext ? N.this : nil
+  if ($async) callAsyncRef()
+  else callSyncRef()
+
+  function callAsyncRef(): void {
+    if (!env.$async) throw new Error("async schema referenced by sync schema")
+    const valid = gen.let("valid")
+    gen.try(
+      () => {
+        gen.code(_`await ${callValidateCode(cxt, v, passCxt)}`)
+        addEvaluatedFrom(v) // TODO will not work with async, it has to be returned with the result
+        if (!allErrors) gen.assign(valid, true)
+      },
+      (e) => {
+        gen.if(_`!(${e} instanceof ${it.ValidationError as Name})`, () => gen.throw(e))
+        addErrorsFrom(e)
+        if (!allErrors) gen.assign(valid, false)
+      }
+    )
+    cxt.ok(valid)
+  }
+
+  function callSyncRef(): void {
+    cxt.result(
+      callValidateCode(cxt, v, passCxt),
+      () => addEvaluatedFrom(v),
+      () => addErrorsFrom(v)
+    )
+  }
+
+  function addErrorsFrom(source: Code): void {
+    const errs = _`${source}.errors`
+    gen.assign(N.vErrors, _`${N.vErrors} === null ? ${errs} : ${N.vErrors}.concat(${errs})`) // TODO tagged
+    gen.assign(N.errors, _`${N.vErrors}.length`)
+  }
+
+  function addEvaluatedFrom(source: Code): void {
+    if (!it.opts.unevaluated) return
+    const schEvaluated = sch?.validate?.evaluated
+    // TODO refactor
+    if (it.props !== true) {
+      if (schEvaluated && !schEvaluated.dynamicProps) {
+        if (schEvaluated.props !== undefined) {
+          it.props = mergeEvaluated.props(gen, schEvaluated.props, it.props)
+        }
+      } else {
+        const props = gen.var("props", _`${source}.evaluated.props`)
+        it.props = mergeEvaluated.props(gen, props, it.props, Name)
+      }
+    }
+    if (it.items !== true) {
+      if (schEvaluated && !schEvaluated.dynamicItems) {
+        if (schEvaluated.items !== undefined) {
+          it.items = mergeEvaluated.items(gen, schEvaluated.items, it.items)
+        }
+      } else {
+        const items = gen.var("items", _`${source}.evaluated.items`)
+        it.items = mergeEvaluated.items(gen, items, it.items, Name)
+      }
+    }
+  }
+}
+
+export default def