@voxgig/apidef 6.3.7 → 6.3.9

package/src/apidef.ts

@@ -61,6 +61,8 @@ import {
   writeFileSyncWarn,
   relativizePath,
   getModelPath,
+  VALID_CANON,
+  CANON_ONE,
 } from './utility'
 
 
@@ -75,6 +77,7 @@ import { flowstepTransform } from './transform/flowstep'
 import { cleanTransform } from './transform/clean'
 
 import { makeEntityBuilder } from './builder/entity'
+import { gcEntityFiles } from './builder/entity/entity'
 import { makeFlowBuilder } from './builder/flow'
 
 // Log non-fatal wierdness.
@@ -144,6 +147,7 @@ function ApiDef(opts: ApiDefOptions) {
       // TODO: Validate spec
       ctx = {
         fs,
+        fsInjected: null != opts.fs,
         log,
         spec,
         opts,
@@ -199,7 +203,7 @@ function ApiDef(opts: ApiDefOptions) {
 
       // Step: guide (derive).
       if (!ctrl.step.guide) {
-        return { ok: false, steps, start, end: Date.now(), ctrl }
+        return { ok: false, steps, start, end: Date.now(), ctrl, ctx }
       }
 
       const guideModel = await buildGuide(ctx)
@@ -214,8 +218,15 @@ function ApiDef(opts: ApiDefOptions) {
 
 
       // Step: transformers (transform spec and guide into core structures).
+      // Early stops return the model built so far: `ctrl.step.generate = false`
+      // is the documented way to build the model in memory without writing
+      // files (see AGENTS.md), which requires `apimodel` in the result. The Go
+      // port already returns it from every early return.
       if (!ctrl.step.transformers) {
-        return { ok: true, steps, start, end: Date.now(), ctrl, guide: ctx.guide }
+        return {
+          ok: true, steps, start, end: Date.now(), ctrl,
+          guide: ctx.guide, apimodel: ctx.apimodel, ctx
+        }
       }
 
       await topTransform(ctx)
@@ -232,7 +243,10 @@ function ApiDef(opts: ApiDefOptions) {
 
       // Step: builders (build generated sub models).
       if (!ctrl.step.builders) {
-        return { ok: true, steps, start, end: Date.now(), ctrl, guide: ctx.guide }
+        return {
+          ok: true, steps, start, end: Date.now(), ctrl,
+          guide: ctx.guide, apimodel: ctx.apimodel, ctx
+        }
       }
 
       const builders = [
@@ -247,7 +261,10 @@ function ApiDef(opts: ApiDefOptions) {
 
       // Step: generate (generate model files).
       if (!ctrl.step.generate) {
-        return { ok: true, steps, start, end: Date.now(), ctrl, guide: ctx.guide }
+        return {
+          ok: true, steps, start, end: Date.now(), ctrl,
+          guide: ctx.guide, apimodel: ctx.apimodel, ctx
+        }
       }
 
       const jostraca = Jostraca({
@@ -285,6 +302,20 @@ function ApiDef(opts: ApiDefOptions) {
 
       steps.push('generate')
 
+      // Garbage-collect entity model files no longer derived from the def.
+      // The builders only ever WRITE: a spec change that removes or renames a
+      // derived entity used to leave the old <name>.aontu behind forever.
+      // Runs after generate so the current set is on disk; guarded so only
+      // apidef-generated files under this build's outprefix are touched.
+      try {
+        const kitEntity = (ctx.apimodel?.main as any)?.[KIT]?.entity || {}
+        gcEntityFiles(fs, log, opts.folder as string, opts.outprefix,
+          Object.keys(kitEntity))
+      }
+      catch (err: any) {
+        log.warn({ point: 'entity-gc-failed', err, note: String(err?.message) })
+      }
+
       const hasWarnings = 0 < warn.history.length
       const endnote =
         hasWarnings ? `PARTIAL BUILD! There were ${warn.history.length} warnings (see above).` :
@@ -450,6 +481,7 @@ export type {
 export {
   KIT,
   ApiDef,
+  gcEntityFiles,
   parse,
   formatJSONIC,
   depluralize,
@@ -457,4 +489,6 @@ export {
   slugToPascalCase,
   getModelPath,
   nom,
+  VALID_CANON,
+  CANON_ONE,
 }

package/src/builder/entity/entity.ts

@@ -66,6 +66,74 @@ function resolveEntity(
 }
 
 
+// Garbage-collect orphaned entity model files.
+//
+// The builder above EMITS one <outprefix><name>.aontu per derived entity but
+// never removes anything, so an entity that disappears from the def — a spec
+// rename, a dropped path, a schema rename that changes the derived entity
+// name — leaves its old file behind on every regen. The orphan is not in the
+// regenerated entity-index barrel, so it is silently dead weight at best; at
+// worst a later hand-include resurrects a stale surface.
+//
+// Deletion is guarded three ways, so nothing a user could own is touched:
+//   1. only `<outprefix>*.aontu` files inside the entity folder are candidates
+//      (a different outprefix belongs to a different def sharing the folder);
+//   2. the current entity set and the index barrel are always kept;
+//   3. the file must START with the generated header (`# Entity: `) — a file
+//      apidef did not write is left alone.
+//
+// GC failure must never fail a build: errors are logged and swallowed.
+function gcEntityFiles(
+  fs: any,
+  log: any,
+  modelFolder: string,
+  outprefix: string | undefined,
+  entityNames: string[],
+): string[] {
+  const removed: string[] = []
+  const prefix = null == outprefix ? '' : outprefix
+  const entityFolder = Path.join(modelFolder, 'entity')
+
+  const keep = new Set<string>(
+    entityNames.map((name) => prefix + name + '.aontu'))
+  keep.add(prefix + 'entity-index.aontu')
+
+  let entries: string[] = []
+  try {
+    entries = fs.readdirSync(entityFolder)
+  }
+  catch (_err: any) {
+    return removed // no entity folder yet — nothing to collect
+  }
+
+  for (const entry of entries) {
+    if (!entry.endsWith('.aontu')) { continue }
+    if (!entry.startsWith(prefix)) { continue }
+    if (keep.has(entry)) { continue }
+
+    const file = Path.join(entityFolder, entry)
+    try {
+      const head = String(fs.readFileSync(file)).slice(0, 64)
+      if (!head.startsWith('# Entity: ')) { continue }
+      fs.unlinkSync(file)
+      removed.push(entry)
+      log?.info?.({
+        point: 'entity-gc', file: entry,
+        note: `removed orphaned entity model file ${entry} (no longer derived from the def)`,
+      })
+    }
+    catch (err: any) {
+      log?.warn?.({
+        point: 'entity-gc-failed', file: entry, err,
+        note: `could not gc ${entry}: ${err?.message}`,
+      })
+    }
+  }
+
+  return removed
+}
+
+
 function fieldAliases(_entity: any): string {
   // Field aliasing (mapping e.g. a `<name>_id` field onto the canonical
   // `id`) is not currently implemented. The original heuristic referenced
@@ -81,5 +149,6 @@ function fieldAliases(_entity: any): string {
 
 
 export {
-  resolveEntity
+  resolveEntity,
+  gcEntityFiles,
 }

package/src/guide/guide.ts

@@ -88,7 +88,36 @@ async function buildGuide(ctx: ApiDefContext): Promise<any> {
       errs,
     }
 
-    opts.fs = ctx.fs
+    // Only forward a *genuinely injected* fs.
+    //
+    // aontu resolves `@`-includes through @tabnas/multisource, which does:
+    //   const P = null != ctx.meta?.fs ? Path.posix : Path
+    // i.e. it switches to POSIX path semantics whenever an fs is present, on
+    // the assumption that an injected fs is memfs keyed by POSIX paths.
+    //
+    // apidef defaults ctx.fs to the real node:fs (`opts.fs || Fs`), so
+    // forwarding it unconditionally made multisource parse *Windows* paths
+    // with Path.posix. 'D:\...\guide\x-guide.aontu' contains no '/', so the
+    // include base resolved to '' and sibling includes were looked up against
+    // the cwd instead of the guide folder — every build failed on Windows
+    // with `source not found: <prefix>base-guide.aontu`. Linux and macOS were
+    // unaffected because there Path and Path.posix are the same module.
+    //
+    // Callers that supply a real memfs (e.g. apidef-validate) still get it,
+    // and still get the POSIX semantics they need.
+    //
+    // Uses the explicit ctx.fsInjected flag rather than `Fs !== ctx.fs`:
+    // esModuleInterop compiles `import * as Fs` to __importStar(), which
+    // builds a fresh wrapper per module, so identity comparison across
+    // modules is always false.
+    if (ctx.fsInjected) {
+      opts.fs = ctx.fs
+    }
+
+    // Record what was actually handed to aontu, not what we intended to hand
+    // it, so the regression test fails if this block is ever changed back to
+    // an unconditional assignment.
+    ctx.work.guideAontuFs = undefined !== opts.fs
 
     const guideModel = aontu.generate(src, opts)
 
@@ -212,15 +241,30 @@ async function buildBaseGuide(ctx: ApiDefContext) {
       items(path.op).map(([opname, op]: [string, GuidePathOp]) => {
         guideBlocks.push(`      op: ${opname}: method: *${op.method}` +
           sw(0 < op.why_op.length ? '  # ' + op.why_op : ''))
-        // Only the res transform is emitted, and only when set. (The
-        // previous req-guarded block pushed a *second* res line built from
-        // op.transform.res — emitting `transform: res: *undefined` whenever
-        // a request was wrapped but the response was not.) Matches the Go
-        // guide builder, which gates solely on res.
+        // Each transform is emitted only when set, and each on its own terms.
+        // (An earlier req-GUARDED block pushed a second res line built from
+        // op.transform.res — emitting `transform: res: *undefined` whenever a
+        // request was wrapped but the response was not. Hence the separate
+        // null checks below rather than one shared guard.)
         if (null != op.transform.res) {
           guideBlocks.push(
             `      op: ${opname}: transform: res: *${qt(op.transform.res)}|top`)
         }
+        // The req transform is a MAP of body property -> source expression
+        // (see closedBodyTransform), so it takes one line per property. THE
+        // SERIALISED GUIDE IS WHAT THE TRANSFORM STEP READS: a transform not
+        // written here never reaches the model, which is why restricting a
+        // closed request body had no effect until this existed. Only the map
+        // form is representable as aontu paths; a scalar req is left alone.
+        const reqmap: any = op.transform.req
+        if (null != reqmap && 'object' === typeof reqmap) {
+          items(reqmap).map(([bodykey, source]: [string, any]) => {
+            if ('string' === typeof source) {
+              guideBlocks.push(`      op: ${opname}: transform: req: ` +
+                `${qs(bodykey)}: *${qt(source)}|top`)
+            }
+          })
+        }
       })
 
       guideBlocks.push(`    }`)

package/src/guide/heuristic01.ts

@@ -7,6 +7,8 @@ import { each } from 'jostraca'
 
 import { size, merge, getelem, isempty, items, keysof } from '@voxgig/struct'
 
+import { isEntityWrapperProp, envelopeProp, closedBodyTransform } from '../utility'
+
 
 import {
   ApiDefContext,
@@ -1126,17 +1128,48 @@ function ResolveTransform(spec: TaskSpec) {
     else if (isEntityWrapperProp(resprops[entdesc.name])) {
       transform.res = '`body.' + entdesc.name + '`'
     }
+    else {
+      // The wrapper is often named for the CARDINALITY rather than the
+      // entity — `{item: {...}}` from a load, `{items: [...]}` from a list —
+      // which the entity-name rules above cannot see. Left unwrapped, list()
+      // hands back the envelope where the caller expects an array, and the
+      // envelope key is mistaken for a field of the entity.
+      const envelope = envelopeProp(resprops, opname)
+      if (null != envelope) {
+        transform.res = '`body.' + envelope + '`'
+      }
+    }
   }
 
-  const reqprops = getRequestBodySchema(mdesc.requestBody)
+  // The SCHEMA is what closedBodyTransform needs (it reads
+  // additionalProperties); the wrapper-name checks need its PROPERTIES. They
+  // used to share one value and index the schema itself, so
+  // `schema['todoitem']` was always undefined and the entity-name request
+  // envelope was never detected — while the Go port read `.properties` and
+  // did detect it. That divergence was inert only because `req` was never
+  // serialised; now that it is, the two implementations would emit different
+  // request bodies for the same spec.
+  const reqschema = getRequestBodySchema(mdesc.requestBody)
+  const reqprops = reqschema?.properties
   debugpath(pathStr, methodName, 'TRANSFORM-REQ', keysof(reqprops))
-  if (reqprops) {
-    if (reqprops[entdesc.origname]) {
+  if (reqschema) {
+    if (null != reqprops?.[entdesc.origname]) {
       transform.req = { [entdesc.origname]: '`reqdata`' }
     }
-    else if (reqprops[entdesc.name]) {
+    else if (null != reqprops?.[entdesc.name]) {
       transform.req = { [entdesc.name]: '`reqdata`' }
     }
+    else {
+      // A CLOSED body schema names every property the server will accept, so
+      // the body is those properties — not the whole request payload. The
+      // payload also carries the op's PATH params (`id` for
+      // `PUT /item/{id}`), and a closed shape rejects the entire request over
+      // that one extra key: every update came back 400 with `invalid-data`.
+      const body = closedBodyTransform(reqschema)
+      if (null != body) {
+        transform.req = body
+      }
+    }
   }
 
   if (!isempty(transform) && null != op[opname]) {
@@ -1365,30 +1398,6 @@ function getResponseSchema(response: any) {
 }
 
 
-// A response property only "wraps" the entity when it is itself a structured
-// value that could contain the entity: an object, an array, a $ref, or a
-// composed (allOf/oneOf/anyOf) schema. A scalar property (string, integer,
-// number, boolean) that merely shares the entity's name is a field of the
-// entity, not a wrapper, so the response must not be unwrapped down to it.
-function isEntityWrapperProp(propSchema: any): boolean {
-  if (null == propSchema || 'object' !== typeof propSchema) {
-    return false
-  }
-  if (null != propSchema.$ref) {
-    return true
-  }
-  if (null != propSchema.properties ||
-    null != propSchema.items ||
-    null != propSchema.allOf ||
-    null != propSchema.oneOf ||
-    null != propSchema.anyOf) {
-    return true
-  }
-  const t = propSchema.type
-  return 'object' === t || 'array' === t
-}
-
-
 function inferEntityName(
   mdesc: any,
   parts: string[],

package/src/parse.ts

@@ -1,14 +1,15 @@
 /* Copyright (c) 2024-2025 Voxgig, MIT License */
 
-import { Jsonic } from 'jsonic'
-import { Yaml } from '@jsonic/yaml'
-
-import { decircular } from '@voxgig/util'
+import { Jsonic } from '@tabnas/jsonic'
+import { Yaml } from '@tabnas/yaml'
 
 import { relativizePath } from './utility'
 
 
-const yamlParser = Jsonic.make().use(Yaml)
+// NOTE: @tabnas/yaml types its Plugin against @tabnas/parser, while
+// Jsonic.use expects @tabnas/jsonic's own (structurally identical) Plugin
+// type - hence the cast.
+const yamlParser = Jsonic.make().use(Yaml as any)
 
 // Matches any line that is not purely a YAML comment or whitespace.
 const RE_HAS_CONTENT = /^\s*[^#\s]/m
@@ -100,12 +101,80 @@ async function parseOpenAPI(source: any, _meta?: any) {
   // Single-pass: add x-ref properties and resolve $ref pointers together.
   addXRefsAndResolve(parsed, parsed)
 
-  const def = decircular(parsed)
+  const def = decycle(parsed)
 
   return def
 }
 
 
+// Break reference cycles so the parsed spec stays JSON-serializable, WITHOUT
+// destroying the structure sharing that $ref inlining deliberately creates.
+//
+// @voxgig/util's decircular() rebuilds the tree — it allocates a fresh object
+// per *visit*, so a component reachable by k distinct paths is copied k times
+// and the result is the tree-expansion of the DAG, size O(fanout^depth). That
+// is catastrophic on exactly the shape real specs have (components reused
+// across nesting levels): a 2.3 KB spec with 12 levels and 3 refs per level
+// expanded to a 172 MB model, and 13 levels exhausted a 2 GB heap.
+//
+// Cycles are real here — inlining a self-referential schema makes the copy's
+// `properties` the same object as the original's, so the copy contains
+// itself — so they still have to be cut. This does it in place: only the edge
+// that closes a cycle is replaced (with decircular's marker string, so the
+// output shape is unchanged), every other node is visited exactly once and
+// left shared. Linear in the number of distinct nodes.
+function decycle(root: any) {
+  // Entry path of each node on the current ancestor chain; presence in this
+  // map is what identifies a back-edge. Nodes are removed on the way out, so
+  // a node reachable twice as a *sibling* is not treated as a cycle.
+  const onPath = new Map<any, string[]>()
+  // Fully-processed nodes. Revisiting one is legitimate sharing, not a cycle,
+  // and must not be walked (or copied) again.
+  const done = new WeakSet<any>()
+  const path: string[] = []
+
+  const walk = (node: any) => {
+    if (null == node || 'object' !== typeof node) return
+    if (done.has(node)) return
+
+    // The YAML parser hands back null-prototype objects. decircular() used to
+    // launder them into plain objects as a side effect of rebuilding the tree;
+    // parse()'s result is public, so keep that contract (callers reasonably
+    // expect `hasOwnProperty` etc. on a parsed spec) rather than leaking the
+    // parser's internal shape now that nothing is rebuilt.
+    if (!Array.isArray(node) && null === Object.getPrototypeOf(node)) {
+      Object.setPrototypeOf(node, Object.prototype)
+    }
+
+    onPath.set(node, path.slice())
+
+    const keys = Array.isArray(node) ?
+      node.map((_: any, i: number) => i) : Object.keys(node)
+
+    for (const key of keys as any[]) {
+      const val = node[key]
+      if (null == val || 'object' !== typeof val) continue
+
+      const cyclePath = onPath.get(val)
+      if (undefined !== cyclePath) {
+        node[key] = `[Circular *${cyclePath.join('.')}]`
+        continue
+      }
+
+      path.push(String(key))
+      walk(val)
+      path.pop()
+    }
+
+    onPath.delete(node)
+    done.add(node)
+  }
+
+  walk(root)
+  return root
+}
+
+
 // Single-pass tree walk that:
 // 1. Preserves original $ref values as x-ref
 // 2. Resolves $ref JSON pointers in-place
@@ -117,6 +186,20 @@ async function parseOpenAPI(source: any, _meta?: any) {
 // across every site that referenced the same component. (A deep clone is
 // deliberately avoided: schemas can be self-referential, which would make
 // cloning non-terminating.)
+// Keywords sitting beside a `$ref` on the *referring* node. OpenAPI 3.1 and
+// JSON Schema 2020-12 both allow them (`description`, `required`,
+// constraints, ...) and they still apply, so inlining must not drop them.
+// Applied over the resolved target, so the local statement wins.
+function refSiblings(node: any): any {
+  const out: any = {}
+  for (const k of Object.keys(node)) {
+    if ('$ref' === k) continue
+    out[k] = node[k]
+  }
+  return out
+}
+
+
 function addXRefsAndResolve(obj: any, root: any, visited?: WeakSet<any>) {
   if (!obj || typeof obj !== 'object') return
   if (!visited) visited = new WeakSet()
@@ -131,7 +214,7 @@ function addXRefsAndResolve(obj: any, root: any, visited?: WeakSet<any>) {
           const xref = item.$ref
           const resolved = resolvePointer(root, xref)
           if (resolved !== undefined) {
-            obj[i] = { ...resolved, 'x-ref': xref }
+            obj[i] = { ...resolved, ...refSiblings(item), 'x-ref': xref }
             addXRefsAndResolve(obj[i], root, visited)
           } else {
             item['x-ref'] = xref
@@ -150,7 +233,7 @@ function addXRefsAndResolve(obj: any, root: any, visited?: WeakSet<any>) {
           const xref = val.$ref
           const resolved = resolvePointer(root, xref)
           if (resolved !== undefined) {
-            obj[key] = { ...resolved, 'x-ref': xref }
+            obj[key] = { ...resolved, ...refSiblings(val), 'x-ref': xref }
             addXRefsAndResolve(obj[key], root, visited)
           } else {
             val['x-ref'] = xref
@@ -165,22 +248,80 @@ function addXRefsAndResolve(obj: any, root: any, visited?: WeakSet<any>) {
 }
 
 
-// Follow a JSON pointer like "#/components/schemas/Planet"
+// Follow a JSON pointer like "#/components/schemas/Planet".
+//
+// Alias components — `Foo: { $ref: '#/components/schemas/Bar' }` — are a
+// normal OpenAPI idiom, so a pointer can land on another bare $ref node.
+// Follow the chain to its end rather than returning the intermediate: the
+// caller inlines `{ ...resolved }`, and a `$ref` *string* key in that spread
+// is never followed by the object-valued recursion in addXRefsAndResolve, so
+// stopping early yields a schema with no properties and every field is
+// silently dropped. Whether that happened used to depend on whether `paths`
+// or `components` came first in the document, because resolution reads a root
+// the same walk is still mutating.
+//
+// `seen` holds pointer strings (not object identities) so a self- or
+// mutually-referential alias cycle terminates instead of looping forever.
 function resolvePointer(root: any, ref: string): any {
-  if (!ref.startsWith('#/')) return undefined
+  const seen = new Set<string>()
+  // Keywords sitting beside a `$ref` along the chain, outermost first.
+  // OpenAPI 3.1 / JSON Schema 2020-12 allow `$ref` to carry siblings
+  // (`description`, `required`, constraints, ...) and they still apply, so
+  // following the chain must not discard them. Merged onto the final target
+  // below, outermost last so the most specific alias wins.
+  const siblings: any[] = []
+  let current: any = undefined
+  let pointer = ref
+
+  for (; ;) {
+    if (!pointer.startsWith('#/')) return undefined
+    if (seen.has(pointer)) return undefined
+    seen.add(pointer)
+
+    const parts = pointer
+      .substring(2)
+      .split('/')
+      .map(p => p.replace(/~1/g, '/').replace(/~0/g, '~'))
+
+    current = root
+    for (const part of parts) {
+      if (current == null || typeof current !== 'object') return undefined
+      current = current[part]
+    }
 
-  const parts = ref
-    .substring(2)
-    .split('/')
-    .map(p => p.replace(/~1/g, '/').replace(/~0/g, '~'))
+    // Landed on another alias: follow it. Anything else is the target.
+    if (current != null &&
+      'object' === typeof current &&
+      !Array.isArray(current) &&
+      'string' === typeof current.$ref) {
+      const sib: any = {}
+      let hasSib = false
+      for (const k of Object.keys(current)) {
+        if ('$ref' === k) continue
+        sib[k] = current[k]
+        hasSib = true
+      }
+      if (hasSib) siblings.push(sib)
+      pointer = current.$ref
+      continue
+    }
 
-  let current = root
-  for (const part of parts) {
-    if (current == null || typeof current !== 'object') return undefined
-    current = current[part]
-  }
+    if (0 === siblings.length) {
+      // No siblings anywhere on the chain: return the target itself, so
+      // multiple references keep sharing one object (see the note on
+      // addXRefsAndResolve — a fresh copy per site would defeat that).
+      return current
+    }
 
-  return current
+    // Siblings present: a merged view is necessarily a new object. Apply
+    // deepest-first so the outermost alias's keywords win.
+    const merged: any = (null != current && 'object' === typeof current &&
+      !Array.isArray(current)) ? { ...current } : {}
+    for (let i = siblings.length - 1; 0 <= i; i--) {
+      Object.assign(merged, siblings[i])
+    }
+    return merged
+  }
 }
 
 

package/src/transform/field.ts

@@ -4,7 +4,7 @@ import { each, getx } from 'jostraca'
 
 import type { TransformResult, Transform } from '../transform'
 
-import { validator, canonize, inferFieldType, normalizeFieldName } from '../utility'
+import { validator, canonize, inferFieldType, normalizeFieldName, envelopeProp } from '../utility'
 
 import { KIT } from '../types'
 
@@ -150,6 +150,21 @@ function findFieldDefs(
         fieldSets = getx(responses, '201 content "application/json" schema') ??
           getx(responses, '201 schema')
       }
+
+      // Single-entity responses get the same treatment the list branch above
+      // already gives collections: a body that is only an envelope around the
+      // entity — `{item: {...}}` — describes the WRAPPER, not the entity, so
+      // its sole property would otherwise be harvested as a field. That is
+      // how an entity `todoitem` ended up with a required `item` field of
+      // type object, which then appeared in the generated create/update data
+      // types. envelopeProp applies the same two rules used to pick the
+      // response transform, so the field list and the transform agree.
+      if ('list' != mop.name) {
+        const envelope = envelopeProp(fieldSets?.properties, mop.name)
+        if (null != envelope) {
+          fieldSets = fieldSets.properties[envelope]
+        }
+      }
     }
 
     // A QUERY (RFC 10008) request body is a filter/query schema, not the