@voxgig/sdkgen 4.34.0 → 4.34.1

package/project/.sdk/tm/ts/src/feature/ratelimit/RatelimitFeature.ts

@@ -34,13 +34,13 @@ class RatelimitFeature extends BaseFeature {
     const inner = utility.fetcher
 
     utility.fetcher = async function (ctx2: any, url: string, fetchdef: any) {
-      await self._acquire(ctx2)
+      await self._acquire(ctx2, fetchdef?.signal)
       return inner(ctx2, url, fetchdef)
     }
   }
 
 
-  async _acquire(this: any, ctx: any): Promise<void> {
+  async _acquire(this: any, ctx: any, signal?: any): Promise<void> {
     const rate = this._options.rate || 5
     const burst = null == this._options.burst ? rate : this._options.burst
 
@@ -59,7 +59,7 @@ class RatelimitFeature extends BaseFeature {
     const needed = 1 - this._tokens
     const waitMs = Math.ceil((needed / rate) * 1000)
     this._track(ctx, waitMs)
-    await this._sleep(waitMs)
+    await this._sleep(waitMs, signal)
     this._last = this._now()
     this._tokens = 0
   }
@@ -74,15 +74,17 @@ class RatelimitFeature extends BaseFeature {
   }
 
 
-  _sleep(this: any, ms: number): Promise<void> {
+  _sleep(this: any, ms: number, signal?: any): Promise<void> {
     if (null == ms || 0 >= ms) {
       return Promise.resolve()
     }
     const sleep = this._options.sleep
     if ('function' === typeof sleep) {
-      return Promise.resolve(sleep(ms))
+      return this._untilAbort(Promise.resolve(sleep(ms)), signal)
     }
-    return new Promise((r) => setTimeout(r, ms))
+    let timer: any
+    return this._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+      () => clearTimeout(timer))
   }
 
 

package/project/.sdk/tm/ts/src/feature/retry/RetryFeature.ts

@@ -40,6 +40,7 @@ class RetryFeature extends BaseFeature {
     const maxDelay = null == opts.maxDelay ? 2000 : opts.maxDelay
     const factor = null == opts.factor ? 2 : opts.factor
 
+    const signal = fetchdef?.signal
     let attempt = 0
     let last: any
 
@@ -56,6 +57,12 @@ class RetryFeature extends BaseFeature {
 
       last = res
 
+      // An abort is never retried, whatever the transport threw for it: the
+      // reason need not be an Error, so decide before the retryable test.
+      if (threw && true === signal?.aborted) {
+        throw signal.reason
+      }
+
       const retryable = this._retryable(res)
       if (!retryable || attempt >= max) {
         // Out of attempts: rethrow a thrown error to preserve pipeline
@@ -66,9 +73,13 @@ class RetryFeature extends BaseFeature {
         return res
       }
 
+      if (true === signal?.aborted) {
+        throw signal.reason
+      }
+
       const wait = this._backoff(res, attempt, minDelay, maxDelay, factor)
       this._track(ctx, attempt + 1, res, wait)
-      await this._sleep(wait)
+      await this._sleep(wait, signal)
       attempt++
     }
   }
@@ -121,15 +132,17 @@ class RetryFeature extends BaseFeature {
   }
 
 
-  _sleep(this: any, ms: number): Promise<void> {
+  _sleep(this: any, ms: number, signal?: any): Promise<void> {
     if (null == ms || 0 >= ms) {
       return Promise.resolve()
     }
     const sleep = this._options.sleep
     if ('function' === typeof sleep) {
-      return Promise.resolve(sleep(ms))
+      return this._untilAbort(Promise.resolve(sleep(ms)), signal)
     }
-    return new Promise((r) => setTimeout(r, ms))
+    let timer: any
+    return this._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+      () => clearTimeout(timer))
   }
 
 

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -22,7 +22,7 @@ function mintId(): string {
 function ownIdField(config: any, getpath: any, entityName: string): string {
   let fallback = ''
 
-  for (const opname of ['load', 'remove', 'update']) {
+  for (const opname of ['load', 'remove', 'update', 'patch']) {
     const points = getpath(config, ['entity', entityName, 'op', opname, 'points']) || []
     const canonical = points.filter((pt: any) =>
       null == (pt && pt.select && pt.select['$action']))
@@ -66,6 +66,28 @@ function ownIdField(config: any, getpath: any, entityName: string): string {
 }
 
 
+// The record the mock keeps: the request data without `$body`, which only the
+// wire carries.
+function recordOf(reqdata: any): any {
+  const out = { ...(reqdata || {}) }
+  delete out.$body
+  return out
+}
+
+
+// The key a list response wraps each record under, where the response
+// transform is `["`$EACH`", "body", { "`$MERGE`": "`.<key>`" }]`.
+function itemEnvelopeKey(restf: any): string | null {
+  if (!Array.isArray(restf) || 3 !== restf.length ||
+    '`$EACH`' !== restf[0] || 'body' !== restf[1]) {
+    return null
+  }
+  const merge = restf[2]?.['`$MERGE`']
+  const m = 'string' === typeof merge ? merge.match(/^`\.([^.`$]+)`$/) : null
+  return null == m ? null : m[1]
+}
+
+
 class TestFeature extends BaseFeature {
   version = '0.0.1'
   name = 'test'
@@ -118,6 +140,10 @@ class TestFeature extends BaseFeature {
 
       function envelope(data: any) {
         const restf = getprop(getprop(ctx.point, 'transform', {}), 'res')
+        const itemkey = itemEnvelopeKey(restf)
+        if (null != itemkey && Array.isArray(data)) {
+          return data.map((item: any) => ({ [itemkey]: item }))
+        }
         if (null == data || 'string' !== typeof restf) {
           return data
         }
@@ -188,8 +214,8 @@ class TestFeature extends BaseFeature {
           return respond(200, out)
         }
       }
-      else if ('update' === op.name) {
-        const args = self.buildArgs(ctx, op, ctx.reqdata)
+      else if ('update' === op.name || 'patch' === op.name) {
+        const args = self.buildArgs(ctx, op, recordOf(ctx.reqdata))
         const found = select(entmap, args)
         const ent = getelem(found, 0)
         if (null == ent) {
@@ -197,7 +223,7 @@ class TestFeature extends BaseFeature {
           return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
         else {
-          merge([ent, (ctx.reqdata || {})])
+          merge([ent, recordOf(ctx.reqdata)])
           delprop(ent, '$KEY')
           const out = clone(ent)
           return respond(200, out)
@@ -215,13 +241,13 @@ class TestFeature extends BaseFeature {
         return respond(200)
       }
       else if ('create' === op.name) {
-        const args = self.buildArgs(ctx, op, ctx.reqdata)
+        const args = self.buildArgs(ctx, op, recordOf(ctx.reqdata))
         let id = param(ctx, 'id')
         if (null == id) {
           id = mintId()
         }
 
-        const ent = clone(ctx.reqdata)
+        const ent = clone(recordOf(ctx.reqdata))
         setprop(ent, 'id', id)
 
         // A record created during the run needs the same real-key seeding
@@ -268,10 +294,12 @@ class TestFeature extends BaseFeature {
       return max <= min ? min : min + ((max - min) >> 1)
     }
 
-    function sleep(ms: number): Promise<void> {
+    function sleep(ms: number, signal?: any): Promise<void> {
       if (null == ms || 0 >= ms) { return Promise.resolve() }
-      if ('function' === typeof net.sleep) { return Promise.resolve(net.sleep(ms)) }
-      return new Promise((r) => setTimeout(r, ms))
+      if ('function' === typeof net.sleep) { return self._untilAbort(Promise.resolve(net.sleep(ms)), signal) }
+      let timer: any
+      return self._untilAbort(new Promise((r) => { timer = setTimeout(r, ms) }), signal,
+        () => clearTimeout(timer))
     }
 
     return async function netsimFetcher(ctx: any, url: string, fetchdef: any) {
@@ -279,15 +307,15 @@ class TestFeature extends BaseFeature {
       const call = self._netcalls
 
       if (true === net.offline) {
-        await sleep(pickLatency())
+        await sleep(pickLatency(), fetchdef?.signal)
         return ctx.error('netsim_offline', 'Simulated network offline (URL was: "' + url + '")')
       }
       if (call <= (net.errorTimes | 0)) {
-        await sleep(pickLatency())
+        await sleep(pickLatency(), fetchdef?.signal)
         return ctx.error('netsim_conn', 'Simulated connection error (call ' + call + ')')
       }
       if (call <= (net.failTimes | 0)) {
-        await sleep(pickLatency())
+        await sleep(pickLatency(), fetchdef?.signal)
         const status = null == net.failStatus ? 503 : net.failStatus
         return {
           status,
@@ -297,7 +325,7 @@ class TestFeature extends BaseFeature {
           headers: { forEach(_cb: any) { }, get(_k: string) { return undefined } },
         }
       }
-      await sleep(pickLatency())
+      await sleep(pickLatency(), fetchdef?.signal)
       return inner(ctx, url, fetchdef)
     }
   }

package/project/.sdk/tm/ts/src/feature/timeout/TimeoutFeature.ts

@@ -7,9 +7,9 @@ import { BaseFeature } from '../base/BaseFeature'
 
 // Per-request timeout. Wraps the active transport and races each attempt
 // against a deadline; if the deadline wins, the request resolves to a
-// timeout error instead of hanging. An `AbortController` is signalled (via
-// `fetchdef.signal`) so a live `fetch` is actually cancelled, while the
-// mock transport simply loses the race.
+// timeout error instead of hanging. The `AbortController` behind
+// `fetchdef.signal` cancels a live `fetch` at the deadline or at the caller's
+// own abort, while the mock transport simply loses the race.
 class TimeoutFeature extends BaseFeature {
   version = '0.0.1'
   name = 'timeout'
@@ -46,9 +46,20 @@ class TimeoutFeature extends BaseFeature {
 
     // Attach an abort signal so a real fetch can be cancelled on timeout.
     let controller: any
+    const caller = fetchdef.signal
+    let follow: any
     if ('function' === typeof (globalThis as any).AbortController) {
       controller = new (globalThis as any).AbortController()
       fetchdef = { ...fetchdef, signal: controller.signal }
+      if (null != caller) {
+        follow = () => controller.abort(caller.reason)
+        if (caller.aborted) {
+          follow()
+        }
+        else {
+          caller.addEventListener('abort', follow, { once: true })
+        }
+      }
     }
 
     let timer: any
@@ -84,6 +95,9 @@ class TimeoutFeature extends BaseFeature {
       else if (null != timer) {
         clearTimeout(timer)
       }
+      if (null != follow) {
+        caller.removeEventListener('abort', follow)
+      }
     }
   }
 

package/project/.sdk/tm/ts/src/feature/validate/ValidateFeature.ts

@@ -123,6 +123,8 @@ class ValidateFeature extends BaseFeature {
     // fields will never name it — and under `strict` every custom-action
     // call would be rejected for the one key that made it reachable.
     delete out.$action
+    // Nor is `$body`, the raw request body.
+    delete out.$body
 
     return out
   }

package/project/.sdk/tm/ts/src/tsconfig.json

@@ -12,6 +12,7 @@
     "target": "es2022",
     "types": ["node"],
     "declaration": true,
-    "declarationDir": "../dist"
+    "declarationDir": "../dist",
+    "composite": true
   }
 }

package/project/.sdk/tm/ts/src/utility/CleanUtility.ts

@@ -236,7 +236,7 @@ function clean(ctx: Context, val: any) {
   }
 
   if (val instanceof Error) {
-    val.message = cleanString(cfg, String(val.message))
+    setMessage(val, cleanString(cfg, String(val.message)))
     if ('string' === typeof val.stack) {
       val.stack = cleanString(cfg, val.stack)
     }
@@ -261,6 +261,29 @@ function clean(ctx: Context, val: any) {
 }
 
 
+// Assigned where assignment works. A DOMException's message is an inherited
+// getter with no setter, which strict code cannot assign, so it is defined
+// on the instance; an own message that can be neither is left as it is.
+function setMessage(err: any, text: string): void {
+  let owner = err
+  let desc = Object.getOwnPropertyDescriptor(owner, 'message')
+  while (null == desc && null != (owner = Object.getPrototypeOf(owner))) {
+    desc = Object.getOwnPropertyDescriptor(owner, 'message')
+  }
+  if (null == desc || desc.writable || null != desc.set) {
+    err.message = text
+  }
+  else if (owner !== err || desc.configurable) {
+    Object.defineProperty(err, 'message', {
+      value: text,
+      writable: true,
+      enumerable: owner === err && !!desc.enumerable,
+      configurable: true,
+    })
+  }
+}
+
+
 function cleanKey(ctx: Context, key: any): boolean {
   return sensitiveKey(cleanConfig(ctx), key)
 }
@@ -298,5 +321,6 @@ export {
   cleanAddSensitive,
   cleanKey,
   makeCleanConfig,
+  setMessage,
   splitvalues,
 }

package/project/.sdk/tm/ts/src/utility/FetcherUtility.ts

@@ -1,6 +1,26 @@
 
 import { Context, Response } from '../types'
 
+
+// Several CDNs refuse a library's own agent, so outside a browser a request
+// without one carries the browser-shaped agent most other targets send.
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (compatible; ProjectNameSDK/1.0)'
+
+
+function defaultUserAgent(fetchdef: Record<string, any>) {
+  if (null == (globalThis as any).process?.versions?.node) {
+    return
+  }
+  const headers = fetchdef.headers = fetchdef.headers || {}
+  for (const name of Object.keys(headers)) {
+    if ('user-agent' === name.toLowerCase()) {
+      return
+    }
+  }
+  headers['user-agent'] = DEFAULT_USER_AGENT
+}
+
+
 // Make HTTP call using library. Replace this utility for mocking etc.
 async function fetcher(
   ctx: Context,
@@ -24,6 +44,8 @@ async function fetcher(
 
   const fetch = options.system.fetch
 
+  defaultUserAgent(fetchdef)
+
   const response = await fetch(fullurl, fetchdef)
 
   return response
@@ -31,5 +53,6 @@ async function fetcher(
 
 
 export {
-  fetcher
+  fetcher,
+  DEFAULT_USER_AGENT,
 }

package/project/.sdk/tm/ts/src/utility/MakeErrorUtility.ts

@@ -2,7 +2,7 @@
 import { Result, Context } from '../types'
 
 
-import { clean } from './CleanUtility'
+import { clean, setMessage } from './CleanUtility'
 
 import { clone, delprop } from './StructUtility'
 
@@ -31,7 +31,7 @@ function makeError(ctx: Context, err?: any) {
   }
 
   const errmsg = err.message || 'unknown error'
-  err.message = 'ProjectNameSDK: ' + op.name + ': ' + errmsg
+  setMessage(err, 'ProjectNameSDK: ' + op.name + ': ' + errmsg)
 
   // Reachable for a debugger, invisible to a serialiser.
   if (null != err.ctx) {

package/project/.sdk/tm/ts/src/utility/MakeFetchDefUtility.ts

@@ -1,6 +1,8 @@
 
 import { Context, Result } from '../types'
 
+import { isJsonRequest, isRawValue, isStream } from './MediaUtility'
+
 
 function makeFetchDef(ctx: Context): any | Error {
   const spec = ctx.spec
@@ -32,9 +34,20 @@ function makeFetchDef(ctx: Context): any | Error {
     headers: spec.headers,
   }
 
+  if (null != ctx.ctrl?.signal) {
+    fetchdef.signal = ctx.ctrl.signal
+  }
+
   if (null != spec.body) {
-    fetchdef.body =
-      'object' === typeof spec.body ? jsonify(spec.body) : spec.body
+    const body = spec.body
+    // A JSON point's body is JSON whatever its value; a scalar elsewhere goes as given.
+    fetchdef.body = isRawValue(body) || ('object' !== typeof body && !isJsonRequest(ctx.point)) ?
+      body : jsonify(body)
+
+    // Node's fetch refuses a stream body without it.
+    if (isStream(body)) {
+      fetchdef.duplex = 'half'
+    }
   }
 
   return fetchdef

package/project/.sdk/tm/ts/src/utility/MakeOptionsUtility.ts

@@ -124,16 +124,16 @@ function makeOptions(ctx: Context) {
 }
 
 
-// Registration skips entity blocks: entity settings and seed records hold no credential.
+// Registration skips entity blocks, and rbac's rules, keyed by entity and op names.
 function settings(opts: any): any {
-  const noent = (b: any) => null != b && 'object' === typeof b && !Array.isArray(b)
-    ? { ...b, entity: undefined } : b
-  const feature = Array.isArray(opts.feature) ? opts.feature.map(noent)
+  const plain = (b: any, name?: string) => null != b && 'object' === typeof b && !Array.isArray(b)
+    ? { ...b, entity: undefined, ...('rbac' === name ? { rules: undefined } : {}) } : b
+  const feature = Array.isArray(opts.feature) ? opts.feature.map((b: any) => plain(b, b?.name))
     : null != opts.feature && 'object' === typeof opts.feature
-      ? Object.fromEntries(Object.entries(opts.feature).map(([k, v]) => [k, noent(v)]))
+      ? Object.fromEntries(Object.entries(opts.feature).map(([k, v]) => [k, plain(v, k)]))
       : opts.feature
   return { ...opts, clean: undefined, __derived__: undefined, entity: undefined,
-    test: noent(opts.test), feature }
+    test: plain(opts.test), feature }
 }
 
 

package/project/.sdk/tm/ts/src/utility/MakePointUtility.ts

@@ -1,6 +1,9 @@
 
 import { Context, Point } from '../types'
 
+import { paramValue } from './ParamUtility'
+import { allowed } from './PrepareMethodUtility'
+
 
 function terminalParam(point: any): boolean {
   const parts = point.parts
@@ -26,6 +29,22 @@ function ownPoint(points: any[]): any {
 }
 
 
+// The path parameters of a point that neither the call nor the entity gives a
+// value for, looked up as prepareParams looks them up.
+function unfilled(ctx: Context, point: any): string[] {
+  const missing: string[] = []
+
+  for (const part of (point.parts || [])) {
+    const name = /^\{([^{}\/]+)\}$/.exec(String(part))?.[1]
+    if (null != name && null == paramValue(ctx, point, name)) {
+      missing.push(name)
+    }
+  }
+
+  return missing
+}
+
+
 function makePoint(ctx: Context): Point | Error {
   if (ctx.out.point) {
     return ctx.point = ctx.out.point
@@ -35,7 +54,7 @@ function makePoint(ctx: Context): Point | Error {
   const op = ctx.op
   const options = ctx.options
 
-  if (!options.allow.op.includes(op.name)) {
+  if (!allowed(options.allow.op, op.name)) {
     return ctx.error('point_op_allow', 'Operation "' + op.name +
       '" not allowed by SDK option allow.op value: "' + options.allow.op + '"')
   }
@@ -93,7 +112,24 @@ function makePoint(ctx: Context): Point | Error {
           '" action "' + reqselector.$action + '" is not valid.')
       }
 
-      point = ownPoint(op.points)
+      // A call without an action falls back to a point without one, as
+      // generation does, and only to a route the call can fill.
+      const plain = op.points.filter((cand: any) => null == cand.select?.$action)
+
+      if (0 === plain.length) {
+        return ctx.error('point_action_required', 'Operation "' + op.name +
+          '" has only action endpoints; pass $action to choose one.')
+      }
+
+      const fillable = plain.filter((cand: any) => 0 === unfilled(ctx, cand).length)
+
+      if (0 === fillable.length) {
+        return ctx.error('point_no_match', 'Operation "' + op.name +
+          '" has no endpoint whose path parameters are all given (missing: ' +
+          unfilled(ctx, ownPoint(plain)).join(', ') + ').')
+      }
+
+      point = ownPoint(fillable)
     }
 
     if (

package/project/.sdk/tm/ts/src/utility/MakeRequestUtility.ts

@@ -1,6 +1,8 @@
 
 import { Context, Response, Result } from '../types'
 
+import { isStream, readStream } from './MediaUtility'
+
 
 async function makeRequest(ctx: Context): Promise<Response | Error> {
   // PreRequest feature hook has already provided a result.
@@ -30,6 +32,16 @@ async function makeRequest(ctx: Context): Promise<Response | Error> {
       throw fetchdef
     }
 
+    if (true === fetchdef.signal?.aborted) {
+      throw fetchdef.signal.reason
+    }
+
+    // A stream can be read once; read it now, so that a retry sends the same bytes.
+    if (isStream(fetchdef.body)) {
+      fetchdef.body = await readStream(fetchdef.body)
+      delete fetchdef.duplex
+    }
+
     if (ctx.ctrl.explain) {
       ctx.ctrl.explain.fetchdef = fetchdef
     }
@@ -42,14 +54,14 @@ async function makeRequest(ctx: Context): Promise<Response | Error> {
       response = new Response({ err: ctx.error('request_no_response', 'response: undefined') })
     }
     else if (fetched instanceof Error) {
-      response = new Response({ err: fetched })
+      response = new Response({ err: abortError(ctx, fetched) })
     }
     else {
       response = new Response(fetched)
     }
   }
   catch (err) {
-    response.err = err as Error
+    response.err = abortError(ctx, err)
   }
 
   spec.step = 'postrequest'
@@ -60,6 +72,21 @@ async function makeRequest(ctx: Context): Promise<Response | Error> {
 }
 
 
+// A request that failed once its signal aborted failed because of it, whatever
+// the transport rejected with.
+function abortError(ctx: Context, err: any): any {
+  const signal = ctx.ctrl?.signal
+  if (true !== signal?.aborted) {
+    return err
+  }
+  const abort = ctx.error('request_aborted', 'request aborted')
+  // Not enumerable, as a native cause is: the reason is the caller's own value.
+  Object.defineProperty(abort, 'cause', { value: signal.reason, writable: true, configurable: true })
+  return abort
+}
+
+
 export {
+  abortError,
   makeRequest
 }

package/project/.sdk/tm/ts/src/utility/MakeResponseUtility.ts

@@ -1,6 +1,8 @@
 
 import { Context, Response } from '../types'
 
+import { abortError } from './MakeRequestUtility'
+
 
 async function makeResponse(ctx: Context): Promise<Response | Error> {
   // PreResponse feature hook has already provided a result.
@@ -52,7 +54,7 @@ async function makeResponse(ctx: Context): Promise<Response | Error> {
     }
   }
   catch (err) {
-    result.err = err
+    result.err = abortError(ctx, err)
   }
 
   if (ctx.ctrl.explain) {

package/project/.sdk/tm/ts/src/utility/MakeSpecUtility.ts

@@ -1,9 +1,15 @@
 
 import { Context, Spec } from '../types'
 
+import { allowed } from './PrepareMethodUtility'
+
 
-// Create request specificaton.
 function makeSpec(ctx: Context): Spec | Error {
+  // A PreSpec hook's rejection, which the pipeline raises; ctx.spec stays a spec.
+  if (ctx.out.spec instanceof Error) {
+    return ctx.out.spec
+  }
+
   if (ctx.out.spec) {
     return ctx.spec = ctx.out.spec
   }
@@ -30,7 +36,7 @@ function makeSpec(ctx: Context): Spec | Error {
 
   ctx.spec.method = prepareMethod(ctx)
 
-  if (!options.allow.method.includes(ctx.spec.method)) {
+  if (!allowed(options.allow.method, ctx.spec.method)) {
     return ctx.error('spec_method_allow', 'Method "' + ctx.spec.method +
       '" not allowed by SDK option allow.method value: "' + options.allow.method + '"')
   }
@@ -42,10 +48,8 @@ function makeSpec(ctx: Context): Spec | Error {
   if ('graphql' === (point as any).kind) {
     ctx.spec.body = utility.graphqlBody(ctx)
     ctx.spec.path = ''
-    // prepareQuery already copied the op's match arguments into the query
-    // string. Those same values are bound as operation variables, so leaving
-    // them would send /graphql?id=i1 — duplicating the argument, leaking it
-    // into the URL, and failing servers that reject unknown query params.
+    // The match arguments prepareQuery copied here travel as operation
+    // variables; sent twice, they would also leak into the URL.
     ctx.spec.query = {}
     ctx.spec.headers['content-type'] = utility.GRAPHQL_CONTENT_TYPE
   }
@@ -58,9 +62,15 @@ function makeSpec(ctx: Context): Spec | Error {
     ctx.ctrl.explain.spec = ctx.spec
   }
 
+  // Whatever prepareAuth sets in the query, under whichever name, is the
+  // credential; a key it leaves as it was is the caller's.
+  const query: Record<string, any> = { ...ctx.spec.query }
+
   const spec = prepareAuth(ctx)
 
   if (!(spec instanceof Error)) {
+    spec.authquery = Object.keys(spec.query || {})
+      .filter((key) => spec.query[key] !== query[key])
     ctx.spec = spec
   }