harperdb 3.1.3 → 3.1.4

package/node_modules/light-my-request/node_modules/ajv/lib/compile/validate/keyword.ts

@@ -0,0 +1,171 @@
+import type {KeywordCxt} from "."
+import type {
+  AnySchema,
+  SchemaValidateFunction,
+  AnyValidateFunction,
+  AddedKeywordDefinition,
+  MacroKeywordDefinition,
+  FuncKeywordDefinition,
+} from "../../types"
+import type {SchemaObjCxt} from ".."
+import {_, nil, not, stringify, Code, Name, CodeGen} from "../codegen"
+import N from "../names"
+import type {JSONType} from "../rules"
+import {callValidateCode} from "../../vocabularies/code"
+import {extendErrors} from "../errors"
+
+type KeywordCompilationResult = AnySchema | SchemaValidateFunction | AnyValidateFunction
+
+export function macroKeywordCode(cxt: KeywordCxt, def: MacroKeywordDefinition): void {
+  const {gen, keyword, schema, parentSchema, it} = cxt
+  const macroSchema = def.macro.call(it.self, schema, parentSchema, it)
+  const schemaRef = useKeyword(gen, keyword, macroSchema)
+  if (it.opts.validateSchema !== false) it.self.validateSchema(macroSchema, true)
+
+  const valid = gen.name("valid")
+  cxt.subschema(
+    {
+      schema: macroSchema,
+      schemaPath: nil,
+      errSchemaPath: `${it.errSchemaPath}/${keyword}`,
+      topSchemaRef: schemaRef,
+      compositeRule: true,
+    },
+    valid
+  )
+  cxt.pass(valid, () => cxt.error(true))
+}
+
+export function funcKeywordCode(cxt: KeywordCxt, def: FuncKeywordDefinition): void {
+  const {gen, keyword, schema, parentSchema, $data, it} = cxt
+  checkAsyncKeyword(it, def)
+  const validate =
+    !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate
+  const validateRef = useKeyword(gen, keyword, validate)
+  const valid = gen.let("valid")
+  cxt.block$data(valid, validateKeyword)
+  cxt.ok(def.valid ?? valid)
+
+  function validateKeyword(): void {
+    if (def.errors === false) {
+      assignValid()
+      if (def.modifying) modifyData(cxt)
+      reportErrs(() => cxt.error())
+    } else {
+      const ruleErrs = def.async ? validateAsync() : validateSync()
+      if (def.modifying) modifyData(cxt)
+      reportErrs(() => addErrs(cxt, ruleErrs))
+    }
+  }
+
+  function validateAsync(): Name {
+    const ruleErrs = gen.let("ruleErrs", null)
+    gen.try(
+      () => assignValid(_`await `),
+      (e) =>
+        gen.assign(valid, false).if(
+          _`${e} instanceof ${it.ValidationError as Name}`,
+          () => gen.assign(ruleErrs, _`${e}.errors`),
+          () => gen.throw(e)
+        )
+    )
+    return ruleErrs
+  }
+
+  function validateSync(): Code {
+    const validateErrs = _`${validateRef}.errors`
+    gen.assign(validateErrs, null)
+    assignValid(nil)
+    return validateErrs
+  }
+
+  function assignValid(_await: Code = def.async ? _`await ` : nil): void {
+    const passCxt = it.opts.passContext ? N.this : N.self
+    const passSchema = !(("compile" in def && !$data) || def.schema === false)
+    gen.assign(
+      valid,
+      _`${_await}${callValidateCode(cxt, validateRef, passCxt, passSchema)}`,
+      def.modifying
+    )
+  }
+
+  function reportErrs(errors: () => void): void {
+    gen.if(not(def.valid ?? valid), errors)
+  }
+}
+
+function modifyData(cxt: KeywordCxt): void {
+  const {gen, data, it} = cxt
+  gen.if(it.parentData, () => gen.assign(data, _`${it.parentData}[${it.parentDataProperty}]`))
+}
+
+function addErrs(cxt: KeywordCxt, errs: Code): void {
+  const {gen} = cxt
+  gen.if(
+    _`Array.isArray(${errs})`,
+    () => {
+      gen
+        .assign(N.vErrors, _`${N.vErrors} === null ? ${errs} : ${N.vErrors}.concat(${errs})`)
+        .assign(N.errors, _`${N.vErrors}.length`)
+      extendErrors(cxt)
+    },
+    () => cxt.error()
+  )
+}
+
+function checkAsyncKeyword({schemaEnv}: SchemaObjCxt, def: FuncKeywordDefinition): void {
+  if (def.async && !schemaEnv.$async) throw new Error("async keyword in sync schema")
+}
+
+function useKeyword(gen: CodeGen, keyword: string, result?: KeywordCompilationResult): Name {
+  if (result === undefined) throw new Error(`keyword "${keyword}" failed to compile`)
+  return gen.scopeValue(
+    "keyword",
+    typeof result == "function" ? {ref: result} : {ref: result, code: stringify(result)}
+  )
+}
+
+export function validSchemaType(
+  schema: unknown,
+  schemaType: JSONType[],
+  allowUndefined = false
+): boolean {
+  // TODO add tests
+  return (
+    !schemaType.length ||
+    schemaType.some((st) =>
+      st === "array"
+        ? Array.isArray(schema)
+        : st === "object"
+        ? schema && typeof schema == "object" && !Array.isArray(schema)
+        : typeof schema == st || (allowUndefined && typeof schema == "undefined")
+    )
+  )
+}
+
+export function validateKeywordUsage(
+  {schema, opts, self, errSchemaPath}: SchemaObjCxt,
+  def: AddedKeywordDefinition,
+  keyword: string
+): void {
+  /* istanbul ignore if */
+  if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
+    throw new Error("ajv implementation error")
+  }
+
+  const deps = def.dependencies
+  if (deps?.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) {
+    throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`)
+  }
+
+  if (def.validateSchema) {
+    const valid = def.validateSchema(schema[keyword])
+    if (!valid) {
+      const msg =
+        `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` +
+        self.errorsText(def.validateSchema.errors)
+      if (opts.validateSchema === "log") self.logger.error(msg)
+      else throw new Error(msg)
+    }
+  }
+}

package/node_modules/light-my-request/node_modules/ajv/lib/compile/validate/subschema.ts

@@ -0,0 +1,135 @@
+import type {AnySchema} from "../../types"
+import type {SchemaObjCxt} from ".."
+import {_, str, getProperty, Code, Name} from "../codegen"
+import {escapeFragment, getErrorPath, Type} from "../util"
+import type {JSONType} from "../rules"
+
+export interface SubschemaContext {
+  // TODO use Optional? align with SchemCxt property types
+  schema: AnySchema
+  schemaPath: Code
+  errSchemaPath: string
+  topSchemaRef?: Code
+  errorPath?: Code
+  dataLevel?: number
+  dataTypes?: JSONType[]
+  data?: Name
+  parentData?: Name
+  parentDataProperty?: Code | number
+  dataNames?: Name[]
+  dataPathArr?: (Code | number)[]
+  propertyName?: Name
+  jtdDiscriminator?: string
+  jtdMetadata?: boolean
+  compositeRule?: true
+  createErrors?: boolean
+  allErrors?: boolean
+}
+
+export type SubschemaArgs = Partial<{
+  keyword: string
+  schemaProp: string | number
+  schema: AnySchema
+  schemaPath: Code
+  errSchemaPath: string
+  topSchemaRef: Code
+  data: Name | Code
+  dataProp: Code | string | number
+  dataTypes: JSONType[]
+  definedProperties: Set<string>
+  propertyName: Name
+  dataPropType: Type
+  jtdDiscriminator: string
+  jtdMetadata: boolean
+  compositeRule: true
+  createErrors: boolean
+  allErrors: boolean
+}>
+
+export function getSubschema(
+  it: SchemaObjCxt,
+  {keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef}: SubschemaArgs
+): SubschemaContext {
+  if (keyword !== undefined && schema !== undefined) {
+    throw new Error('both "keyword" and "schema" passed, only one allowed')
+  }
+
+  if (keyword !== undefined) {
+    const sch = it.schema[keyword]
+    return schemaProp === undefined
+      ? {
+          schema: sch,
+          schemaPath: _`${it.schemaPath}${getProperty(keyword)}`,
+          errSchemaPath: `${it.errSchemaPath}/${keyword}`,
+        }
+      : {
+          schema: sch[schemaProp],
+          schemaPath: _`${it.schemaPath}${getProperty(keyword)}${getProperty(schemaProp)}`,
+          errSchemaPath: `${it.errSchemaPath}/${keyword}/${escapeFragment(schemaProp)}`,
+        }
+  }
+
+  if (schema !== undefined) {
+    if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {
+      throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"')
+    }
+    return {
+      schema,
+      schemaPath,
+      topSchemaRef,
+      errSchemaPath,
+    }
+  }
+
+  throw new Error('either "keyword" or "schema" must be passed')
+}
+
+export function extendSubschemaData(
+  subschema: SubschemaContext,
+  it: SchemaObjCxt,
+  {dataProp, dataPropType: dpType, data, dataTypes, propertyName}: SubschemaArgs
+): void {
+  if (data !== undefined && dataProp !== undefined) {
+    throw new Error('both "data" and "dataProp" passed, only one allowed')
+  }
+
+  const {gen} = it
+
+  if (dataProp !== undefined) {
+    const {errorPath, dataPathArr, opts} = it
+    const nextData = gen.let("data", _`${it.data}${getProperty(dataProp)}`, true)
+    dataContextProps(nextData)
+    subschema.errorPath = str`${errorPath}${getErrorPath(dataProp, dpType, opts.jsPropertySyntax)}`
+    subschema.parentDataProperty = _`${dataProp}`
+    subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty]
+  }
+
+  if (data !== undefined) {
+    const nextData = data instanceof Name ? data : gen.let("data", data, true) // replaceable if used once?
+    dataContextProps(nextData)
+    if (propertyName !== undefined) subschema.propertyName = propertyName
+    // TODO something is possibly wrong here with not changing parentDataProperty and not appending dataPathArr
+  }
+
+  if (dataTypes) subschema.dataTypes = dataTypes
+
+  function dataContextProps(_nextData: Name): void {
+    subschema.data = _nextData
+    subschema.dataLevel = it.dataLevel + 1
+    subschema.dataTypes = []
+    it.definedProperties = new Set<string>()
+    subschema.parentData = it.data
+    subschema.dataNames = [...it.dataNames, _nextData]
+  }
+}
+
+export function extendSubschemaMode(
+  subschema: SubschemaContext,
+  {jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors}: SubschemaArgs
+): void {
+  if (compositeRule !== undefined) subschema.compositeRule = compositeRule
+  if (createErrors !== undefined) subschema.createErrors = createErrors
+  if (allErrors !== undefined) subschema.allErrors = allErrors
+  subschema.jtdDiscriminator = jtdDiscriminator // not inherited
+  subschema.jtdMetadata = jtdMetadata // not inherited
+}