@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/src/cmp/clojure/ReadmeHowto_clojure.ts

@@ -1,15 +1,18 @@
 
-import { cmp, Content, canonKey, canonScalarKey, entityIdField, pickExampleEntity, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, Content, canonKey, canonScalarKey, entityIdField, pickExampleEntity, opRequestShape, requiredItems } from '@voxgig/sdkgen'
 
 import {
   KIT,
   getModelPath,
 } from '@voxgig/apidef'
 
+import { cljString } from './utility_clojure'
+
 
 // A type-correct Clojure literal for a field's canonical type.
 function cljLit(type: any): string {
   const k = canonScalarKey(type)
+  if ('NULL' === k) return 'nil'
   if ('INTEGER' === k || 'NUMBER' === k) return '1'
   if ('BOOLEAN' === k) return 'true'
   if ('ARRAY' === k) return '(vs/jt)'
@@ -32,20 +35,28 @@ const ReadmeHowto = cmp(function ReadmeHowto(props: any) {
   let testArg = 'nil'
   if (exampleEntity && isMatchOp) {
     testArg = idF ? `(vs/jm "${idF}" "test01")` : 'nil'
-  } else if (exampleEntity && ('create' === primaryOp || 'update' === primaryOp)) {
+  } else if (exampleEntity && 'list' === primaryOp && 0 < requiredItems(exampleEntity, 'list').length) {
+    const chosen = requiredItems(exampleEntity, 'list')
+    testArg = `(vs/jm ${chosen.map((it: any) => `${cljString(it.name)} ${cljLit(it.type)}`).join(' ')})`
+  } else if (exampleEntity && ('create' === primaryOp || 'update' === primaryOp || 'patch' === primaryOp)) {
     const items = opRequestShape(exampleEntity, primaryOp).items
       .filter((it: any) => it.name !== idF && it.name !== 'id')
     const required = items.filter((it: any) => !it.optional)
     const chosen = required.length ? required : items.slice(0, 3)
-    testArg = `(vs/jm ${chosen.map((it: any) => `"${it.name}" ${cljLit(it.type)}`).join(' ')})`
+    testArg = `(vs/jm ${chosen.map((it: any) => `${cljString(it.name)} ${cljLit(it.type)}`).join(' ')})`
   }
 
   // The op-driven test-mode line, shown only when the SDK has an entity op.
-  const testModeExample = primaryOp
-    ? `;; Entity ops return the bare record and raise on error.
+  const testModeExample = 'list' === primaryOp
+    ? `;; list returns a vector of entities, one per mock record; it raises on error.
+(def ${eLow}s (e-${eLow}/list (api/${eLow} client nil) ${testArg} nil))
+(doseq [item ${eLow}s]
+  (println ((:data-get item))))`
+    : primaryOp
+    ? `;; Entity ops return the entity; they raise on error.
 (def ${eLow} (e-${eLow}/${primaryOp} (api/${eLow} client nil) ${testArg} nil))
-;; ${eLow} contains the mock response record
-(println ${eLow})`
+;; ((:data-get ${eLow})) reads the entity's mock record
+(println ((:data-get ${eLow})))`
     : `(def result (api/direct client (vs/jm "path" "/api/resource" "method" "GET")))
 (println result)`
 

package/project/.sdk/src/cmp/clojure/ReadmeInstall_clojure.ts

@@ -5,7 +5,7 @@ import { cmp, Content, isPublished, repoInfo } from '@voxgig/sdkgen'
 const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
   const { target, ctx$ } = props
   const { model } = ctx$
-  const { origin, repo, repoUrl, releasesUrl } = repoInfo(model)
+  const { hostName, origin, repo, repoUrl, tagsUrl } = repoInfo(model)
 
   if (isPublished(model, target.name)) {
     // Live on Clojars: add the published coordinate to deps.edn.
@@ -21,9 +21,9 @@ const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
   }
 
   // Publish pending: not yet on Clojars. Depend on the library directly from
-  // the GitHub release tag, or from a local checkout via :local/root.
+  // the release tag, or from a local checkout via :local/root.
   Content(`This package is not yet published to Clojars. Depend on it directly from the
-GitHub release tag (\`${target.name}/vX.Y.Z\`, see [Releases](${releasesUrl})),
+${hostName} release tag (\`${target.name}/vX.Y.Z\`, see [Tags](${tagsUrl})),
 using a \`tools.deps\` git dependency:
 
 \`\`\`clojure

package/project/.sdk/src/cmp/clojure/ReadmeIntro_clojure.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Content } from '@voxgig/sdkgen'
+import { cmp, Content, modelText } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -9,7 +9,7 @@ import {
 
 const ReadmeIntro = cmp(function ReadmeIntro(props: any) {
   const { target, ctx$: { model } } = props
-  const info = (model.main && model.main.kit && model.main.kit.info) || {}
+  const info = modelText(model)
   const tagline = info.tagline || ''
 
   Content(`# ${model.Name} ${target.title} SDK
@@ -36,7 +36,7 @@ the vendored \`voxgig.struct\` value model).
   // Model-driven op list — only the operations the active entities actually
   // expose (a read-only entity has just list+load); never claim
   // create/update/remove exist when no entity has them.
-  const CANON_OPS = ['list', 'load', 'create', 'update', 'remove']
+  const CANON_OPS = ['list', 'load', 'create', 'update', 'patch', 'remove']
   const opSet = new Set<string>()
   Object.values(entity || {}).forEach((e: any) => {
     if (!e || e.active === false) return

package/project/.sdk/src/cmp/clojure/ReadmeModel_clojure.ts

@@ -20,13 +20,14 @@ const ReadmeModel = cmp(function ReadmeModel(props: any) {
   entityList.forEach((e: any) => Object.keys(e.op || {})
     .forEach((o: string) => { if (e.op[o] && e.op[o].active !== false) opUnion.add(o) }))
   const opRowDefs: Record<string, string> = {
-    load: '| `load` | `(ent reqmatch ctrl) -> map` | Load a single entity by match criteria. Raises on error. |',
-    list: '| `list` | `(ent reqmatch ctrl) -> vector` | List entities matching the criteria. Raises on error. |',
-    create: '| `create` | `(ent reqdata ctrl) -> map` | Create a new entity. Raises on error. |',
-    update: '| `update` | `(ent reqdata ctrl) -> map` | Update an existing entity. Raises on error. |',
-    remove: '| `remove` | `(ent reqmatch ctrl) -> map` | Remove an entity. Raises on error. |',
+    load: '| `load` | `(ent reqmatch ctrl) -> entity` | Load a single entity by match criteria, and return it. Raises on error. |',
+    list: '| `list` | `(ent reqmatch ctrl) -> vector` | List entities matching the criteria, one per record. Raises on error. |',
+    create: '| `create` | `(ent reqdata ctrl) -> entity` | Create a new entity, and return it. Raises on error. |',
+    update: '| `update` | `(ent reqdata ctrl) -> entity` | Update an existing entity, and return it. Raises on error. |',
+    patch: '| `patch` | `(ent reqdata ctrl) -> entity` | Change part of an existing entity, and return it. Raises on error. |',
+    remove: '| `remove` | `(ent reqmatch ctrl) -> entity` | Remove an entity, and return it marked as deleted. Raises on error. |',
   }
-  const opRows = ['load', 'list', 'create', 'update', 'remove']
+  const opRows = ['load', 'list', 'create', 'update', 'patch', 'remove']
     .filter((o) => opUnion.has(o)).map((o) => opRowDefs[o]).join('\n')
 
   const apikeyOptionRow = isAuthActive(model)
@@ -99,9 +100,10 @@ State accessors are called by looking up the fn and applying it, e.g.
 
 ### Result shape
 
-Entity operations return the bare result data (a \`map\` for single-entity
-ops, a \`vector\` for \`list\`) and raise (via \`ex-info\`) on error. Wrap
-calls in \`try\`/\`catch\` to handle failures.
+Entity operations resolve to the entity, and \`list\` to a \`vector\` of
+entities, one per record. Read an entity's record with
+\`((:data-get ent))\`. They raise (via \`ex-info\`) on error, so wrap calls
+in \`try\`/\`catch\` to handle failures.
 
 The \`direct\` escape hatch never raises — it returns a result \`map\` you
 branch on via \`(vs/getprop result "ok")\`:

package/project/.sdk/src/cmp/clojure/ReadmeQuick_clojure.ts

@@ -6,6 +6,8 @@ import {
   getModelPath,
 } from '@voxgig/apidef'
 
+import { cljListMatch } from './utility_clojure'
+
 
 const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
   const { target, ctx$: { model } } = props
@@ -32,6 +34,7 @@ const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
   // A type-correct Clojure literal for a param.
   const cljLit = (type: any, placeholder: string = 'example'): string => {
     const k = canonScalarKey(type)
+    if ('NULL' === k) return 'nil'
     if ('INTEGER' === k || 'NUMBER' === k) return '1'
     if ('BOOLEAN' === k) return 'true'
     if ('ARRAY' === k) return '(vs/jt)'
@@ -72,13 +75,13 @@ ${requireLines.join('\n')}
     if (opnames.includes('list')) {
       Content(`### 2. List ${eLow} records
 
-\`list\` returns a vector of records (each a map) and raises on error —
-iterate it directly.
+\`list\` returns a vector of entities, one per record, and raises on error.
+Read each record with \`((:data-get ${eLow}))\`.
 
 \`\`\`clojure
 (try
-  (doseq [${eLow} (e-${eLow}/list (api/${eLow} client nil) nil nil)]
-    (println ${eLow}))
+  (doseq [${eLow} (e-${eLow}/list (api/${eLow} client nil) ${cljListMatch(exampleEntity)} nil)]
+    (println ((:data-get ${eLow}))))
   (catch Exception err
     (println "list failed:" (.getMessage err))))
 \`\`\`
@@ -107,12 +110,13 @@ iterate it directly.
       Content(`### 3. Load ${neArticle} ${neLow}
 
 ${nestedEntity.Name} is nested under ${parentName}, so provide the
-\`${parentParam}\`. \`load\` returns the bare record (a map) and raises on error.
+\`${parentParam}\`. \`load\` returns the entity and raises on error;
+\`((:data-get ${neLow}))\` reads its record.
 
 \`\`\`clojure
 (try
   (let [${neLow} (e-${neLow}/load (api/${neLow} client nil) (vs/jm ${neMatch.join(' ')}) nil)]
-    (println ${neLow}))
+    (println ((:data-get ${neLow}))))
   (catch Exception err
     (println "load failed:" (.getMessage err))))
 \`\`\`
@@ -132,12 +136,13 @@ ${nestedEntity.Name} is nested under ${parentName}, so provide the
 
       Content(`### 3. Load ${article} ${eLow}
 
-\`load\` returns the bare record (a map) and raises on error.
+\`load\` returns the entity and raises on error; \`((:data-get ${eLow}))\` reads
+its record.
 
 \`\`\`clojure
 (try
   (let [${eLow} (e-${eLow}/load (api/${eLow} client nil) ${loadArg} nil)]
-    (println ${eLow}))
+    (println ((:data-get ${eLow}))))
   (catch Exception err
     (println "load failed:" (.getMessage err))))
 \`\`\`
@@ -163,16 +168,17 @@ ${nestedEntity.Name} is nested under ${parentName}, so provide the
       return it && it.type
     }
     const idValueFor = (opname: string): string => (null != dataIdF && opnames.includes('create'))
-      ? `(vs/getprop created "${dataIdF}")`
+      ? `(vs/getprop ((:data-get created)) "${dataIdF}")`
       : cljLit(idParamType(opname), 'example_id')
 
-    if (opnames.includes('create') || opnames.includes('update') || opnames.includes('remove')) {
+    if (opnames.includes('create') || opnames.includes('update') || opnames.includes('patch') ||
+      opnames.includes('remove')) {
       Content(`### 4. Create, update, and remove
 
 \`\`\`clojure
 `)
       if (opnames.includes('create')) {
-        Content(`;; Create — returns the bare created record (a map)
+        Content(`;; Create — returns the created entity
 (def created (e-${eLow}/create (api/${eLow} client nil) (vs/jm ${examplePairs('create').join(' ')}) nil))
 
 `)
@@ -180,9 +186,16 @@ ${nestedEntity.Name} is nested under ${parentName}, so provide the
       if (opnames.includes('update')) {
         const updatePairs = (idF ? [`"${idF}" ${idValueFor('update')}`] : []).concat(examplePairs('update'))
         const fromCreated = null != dataIdF && opnames.includes('create')
-        Content(`;; Update${fromCreated ? " — the created record's id is a plain map key" : ''}
+        Content(`;; Update${fromCreated ? " — the created entity's record holds its id" : ''}
 (e-${eLow}/update (api/${eLow} client nil) (vs/jm ${updatePairs.join(' ')}) nil)
 
+`)
+      }
+      if (opnames.includes('patch')) {
+        const patchPairs = (idF ? [`"${idF}" ${idValueFor('patch')}`] : []).concat(examplePairs('patch'))
+        Content(`;; Patch — sends only the fields given
+(e-${eLow}/patch (api/${eLow} client nil) (vs/jm ${patchPairs.join(' ')}) nil)
+
 `)
       }
       if (opnames.includes('remove')) {

package/project/.sdk/src/cmp/clojure/ReadmeRef_clojure.ts

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape , targetFeatures } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonKey, canonScalarKey, File, isAuthActive, entityIdField, opRequestShape , targetFeatures, opNeedsAction, bodyNote } from '@voxgig/sdkgen'
 import { ReadmeRefFeatures } from '@voxgig/sdkgen'
 
 import {
@@ -7,10 +7,13 @@ import {
   getModelPath,
 } from '@voxgig/apidef'
 
+import { cljListMatch } from './utility_clojure'
+
 
 // A type-correct Clojure literal for a field's canonical type.
 function cljLit(type: any, placeholder: string = 'example'): string {
   const k = canonScalarKey(type)
+  if ('NULL' === k) return 'nil'
   if ('INTEGER' === k || 'NUMBER' === k) return '1'
   if ('BOOLEAN' === k) return 'true'
   if ('ARRAY' === k) return '(vs/jt)'
@@ -34,29 +37,34 @@ function cljType(type: any): string {
 
 const OP_SIGNATURES: Record<string, { sig: string, returns: string, desc: string }> = {
   load: {
-    sig: '(load ent reqmatch ctrl) -> map',
-    returns: 'the entity data',
-    desc: 'Load a single entity matching the given criteria. Returns the entity data and raises on error.',
+    sig: '(load ent reqmatch ctrl) -> entity',
+    returns: 'the entity',
+    desc: 'Load a single entity matching the given criteria. Returns the entity, whose record `((:data-get ent))` reads, and raises on error.',
   },
   list: {
     sig: '(list ent reqmatch ctrl) -> vector',
-    returns: 'a vector of entities',
-    desc: 'List entities matching the given criteria. The match is optional — call with `nil` to list all records. Returns a vector and raises on error.',
+    returns: 'a vector of entities, one per record',
+    desc: 'List entities matching the given criteria. The match is optional — call with `nil` to list all records. Returns a vector of entities, one per record, and raises on error.',
   },
   create: {
-    sig: '(create ent reqdata ctrl) -> map',
-    returns: 'the created entity data',
-    desc: 'Create a new entity with the given data. Returns the created entity data and raises on error.',
+    sig: '(create ent reqdata ctrl) -> entity',
+    returns: 'the created entity',
+    desc: 'Create a new entity with the given data. Returns the created entity and raises on error.',
   },
   update: {
-    sig: '(update ent reqdata ctrl) -> map',
-    returns: 'the updated entity data',
-    desc: 'Update an existing entity. The data must include the entity `id`. Returns the updated entity data and raises on error.',
+    sig: '(update ent reqdata ctrl) -> entity',
+    returns: 'the updated entity',
+    desc: 'Update an existing entity. The data must include the entity `id`. Returns the updated entity and raises on error.',
+  },
+  patch: {
+    sig: '(patch ent reqdata ctrl) -> entity',
+    returns: 'the patched entity',
+    desc: 'Change part of an existing entity: only the fields given are sent. The data must include the entity `id`. Returns the patched entity and raises on error.',
   },
   remove: {
-    sig: '(remove ent reqmatch ctrl) -> map',
-    returns: 'the removed entity data',
-    desc: 'Remove the entity matching the given criteria. Raises on error.',
+    sig: '(remove ent reqmatch ctrl) -> entity',
+    returns: 'the removed entity',
+    desc: 'Remove the entity matching the given criteria. Returns the entity, marked as deleted, and raises on error.',
   },
 }
 
@@ -221,7 +229,7 @@ Prepare a fetch definition without sending. Returns the \`fetchdef\` and raises
         // Field operations breakdown
         const hasFieldOps = fields.some((f: any) => f.op && Object.keys(f.op).length > 0)
         if (hasFieldOps) {
-          const opcols = ['load', 'list', 'create', 'update', 'remove']
+          const opcols = ['load', 'list', 'create', 'update', 'patch', 'remove']
             .filter((op: string) => opnames.includes(op) && ent.op[op]?.active !== false)
           Content(`### Field Usage by Operation
 
@@ -262,6 +270,10 @@ ${info.desc}
 
 `)
 
+          if (opNeedsAction(ent.op[opname])) {
+            return
+          }
+
           if ('load' === opname || 'remove' === opname) {
             const matchItems = opRequestShape(ent, opname).items
               .filter((it: any) => !it.optional || it.name === idF)
@@ -280,8 +292,8 @@ ${info.desc}
           }
           else if ('list' === opname) {
             Content(`\`\`\`clojure
-(doseq [${eLow} (e-${eLow}/list (api/${eLow} client nil) nil nil)]
-  (println ${eLow}))
+(doseq [${eLow} (e-${eLow}/list (api/${eLow} client nil) ${cljListMatch(ent)} nil)]
+  (println ((:data-get ${eLow}))))
 \`\`\`
 
 `)
@@ -304,8 +316,8 @@ ${info.desc}
 
 `)
           }
-          else if ('update' === opname) {
-            const updateItems = opRequestShape(ent, 'update').items
+          else if ('update' === opname || 'patch' === opname) {
+            const updateItems = opRequestShape(ent, opname).items
               .filter((it: any) => !it.optional || it.name === idF)
               .sort((a: any, b: any) =>
                 (a.name === idF ? 0 : 1) - (b.name === idF ? 0 : 1))
@@ -314,15 +326,23 @@ ${info.desc}
                 it.name === idF ? ent.name + '_id' : it.name)}\n`).join('')
             Content(`\`\`\`clojure
 (def result
-  (e-${eLow}/update (api/${eLow} client nil)
+  (e-${eLow}/${opname} (api/${eLow} client nil)
     (vs/jm
-${updateLines}      ;; Fields to update
+${updateLines}      ;; ${'patch' === opname ? 'Only the fields to change' : 'Fields to update'}
       )
     nil))
 \`\`\`
 
 `)
           }
+
+          if ('create' === opname || 'update' === opname || 'patch' === opname) {
+            const note = bodyNote(ent.op[opname], {
+              values: 'a byte array, a `String` or an `InputStream`',
+              once: 'an `InputStream`',
+            })
+            if ('' !== note) Content(note)
+          }
         })
       }
 

package/project/.sdk/src/cmp/clojure/ReadmeTopQuick_clojure.ts

@@ -7,11 +7,14 @@ import {
   nom,
 } from '@voxgig/apidef'
 
+import { cljListMatch } from './utility_clojure'
+
 
 // A type-correct Clojure literal for a param: numeric/boolean/array/object
 // params render a typed literal; strings render the quoted placeholder.
 function cljLit(type: any, placeholder: string = 'example'): string {
   const k = canonScalarKey(type)
+  if ('NULL' === k) return 'nil'
   if ('INTEGER' === k || 'NUMBER' === k) return '1'
   if ('BOOLEAN' === k) return 'true'
   if ('ARRAY' === k) return '(vs/jt)'
@@ -51,9 +54,9 @@ const ReadmeTopQuick = cmp(function ReadmeTopQuick(props: any) {
     const idF = entityIdField(exampleEntity)
 
     if (opnames.includes('list')) {
-      Content(`;; List all ${eLow}s (returns a vector, raises on error)
-(doseq [${eLow} (e-${eLow}/list (api/${eLow} client nil) nil nil)]
-  (println ${eLow}))
+      Content(`;; List all ${eLow}s (a vector of entities, one per record; raises on error)
+(doseq [${eLow} (e-${eLow}/list (api/${eLow} client nil) ${cljListMatch(exampleEntity)} nil)]
+  (println ((:data-get ${eLow}))))
 `)
     }
 
@@ -71,9 +74,9 @@ const ReadmeTopQuick = cmp(function ReadmeTopQuick(props: any) {
             it.name === idF ? 'example_id' : 'example_' + it.name)}`).join(' ')})`
         : 'nil'
       Content(`
-;; Load a specific ${eLow} (returns the record, raises on error)
+;; Load a specific ${eLow} (returns the entity, raises on error)
 (def ${eLow} (e-${eLow}/load (api/${eLow} client nil) ${loadArg} nil))
-(println ${eLow})
+(println ((:data-get ${eLow})))
 `)
     }
 

package/project/.sdk/src/cmp/clojure/ReadmeTopTest_clojure.ts

@@ -1,15 +1,18 @@
 
-import { cmp, Content, canonKey, canonScalarKey, entityIdField, pickExampleEntity, opRequestShape } from '@voxgig/sdkgen'
+import { cmp, Content, canonKey, canonScalarKey, entityIdField, pickExampleEntity, opRequestShape, requiredItems } from '@voxgig/sdkgen'
 
 import {
   KIT,
   getModelPath,
 } from '@voxgig/apidef'
 
+import { cljString } from './utility_clojure'
+
 
 // A type-correct Clojure literal for a field's canonical type.
 function cljLit(type: any): string {
   const k = canonScalarKey(type)
+  if ('NULL' === k) return 'nil'
   if ('INTEGER' === k || 'NUMBER' === k) return '1'
   if ('BOOLEAN' === k) return 'true'
   if ('ARRAY' === k) return '(vs/jt)'
@@ -43,27 +46,31 @@ const ReadmeTopTest = cmp(function ReadmeTopTest(props: any) {
     const idF = entityIdField(exampleEntity)
     const isMatchOp = 'load' === primaryOp || 'remove' === primaryOp
     let arg = 'nil'
-    if (isMatchOp) {
+    if (isMatchOp || ('list' === primaryOp && 0 < requiredItems(exampleEntity, 'list').length)) {
       // Every REQUIRED match key (id first) — the same shape that generates
       // the op's match handling.
-      const items = opRequestShape(exampleEntity, primaryOp).items
-        .filter((it: any) => !it.optional || it.name === idF)
+      const items = (isMatchOp ? opRequestShape(exampleEntity, primaryOp).items
+        .filter((it: any) => !it.optional || it.name === idF) : requiredItems(exampleEntity, 'list'))
         .sort((a: any, b: any) =>
           (a.name === idF ? 0 : 1) - (b.name === idF ? 0 : 1))
       arg = 0 < items.length
         ? `(vs/jm ${items.map((it: any) =>
-          `"${it.name}" ${it.name === idF ? '"test01"' : cljLit(it.type)}`).join(' ')})`
+          `${cljString(it.name)} ${isMatchOp && it.name === idF ? '"test01"' : cljLit(it.type)}`).join(' ')})`
         : 'nil'
-    } else if ('create' === primaryOp || 'update' === primaryOp) {
+    } else if ('create' === primaryOp || 'update' === primaryOp || 'patch' === primaryOp) {
       const items = opRequestShape(exampleEntity, primaryOp).items
         .filter((it: any) => it.name !== idF && it.name !== 'id')
       const required = items.filter((it: any) => !it.optional)
       const chosen = required.length ? required : items.slice(0, 3)
-      arg = `(vs/jm ${chosen.map((it: any) => `"${it.name}" ${cljLit(it.type)}`).join(' ')})`
+      arg = `(vs/jm ${chosen.map((it: any) => `${cljString(it.name)} ${cljLit(it.type)}`).join(' ')})`
     }
-    const eVar = eLow + ('list' === primaryOp ? 's' : '')
-    Content(`(def ${eVar} (e-${eLow}/${primaryOp} (api/${eLow} client nil) ${arg} nil))
-(println ${eVar})
+    Content('list' === primaryOp
+      ? `(def ${eLow}s (e-${eLow}/list (api/${eLow} client nil) ${arg} nil))
+(doseq [item ${eLow}s]
+  (println ((:data-get item))))
+`
+      : `(def ${eLow} (e-${eLow}/${primaryOp} (api/${eLow} client nil) ${arg} nil))
+(println ((:data-get ${eLow})))
 `)
   }
 

package/project/.sdk/src/cmp/clojure/TestClean_clojure.ts

@@ -28,7 +28,7 @@ const TestClean = cmp(function TestClean(props: any) {
 
 
 const OP_ORDER: Record<string, number> = { list: 0, load: 1 }
-const OPS = ['list', 'load', 'create', 'update', 'remove']
+const OPS = ['list', 'load', 'create', 'update', 'patch', 'remove']
 
 
 // The path parameters an operation's points declare, as the runtime config
@@ -182,7 +182,23 @@ function render(model: any, entity: any[], auth: {
                                     "body" "<html>"
                                     "json" (fn [] (throw (RuntimeException. "Unexpected token < in JSON")))) nil])}])
 
-(defn- make-sdk [scenario sinks cleanopts & extra]
+;; Offline, as every generated suite is: the test OPTION resolves a required
+;; server variable to test-<name>, and installs no transport.
+(defn- offline [opts]
+  (.put ^java.util.Map opts "test" (vs/jm "active" true))
+  opts)
+
+;; A client the sweep cannot build leaves nothing swept: a harness error, not
+;; a leak.
+(defn- construct [opts]
+  (try (api/make-sdk (offline opts))
+       (catch Throwable e
+         (throw (IllegalStateException.
+                 (str "clean harness: the client could not be constructed, so nothing was swept: "
+                      (.getMessage e))
+                 e)))))
+
+(defn- sdk-opts [scenario sinks cleanopts extra]
   (let [capture (fn [name] (fn [rec] (swap! sinks into (forms name rec))))
         feature (vs/jm)
         on (fn [name & kvs] (when (feature/feature-present? name)
@@ -196,12 +212,15 @@ function render(model: any, entity: any[], auth: {
     (on "clienttrack")
     (let [clean (vs/jm "values" (:value CANARY))]
       (doseq [[k v] (or cleanopts {})] (.put ^java.util.Map clean k v))
-      (api/make-sdk (vs/jm "apikey" (:apikey CANARY) "secret" (:secret CANARY)
-                           "headers" (vs/jm "X-Custom-Token" (:header CANARY))
-                           "clean" clean
-                           "feature" feature
-                           "extend" (apply vs/jt (capture-feature sinks) extra)
-                           "utility" (vs/jm "fetcher" (fn [_fctx url fd] ((:respond scenario) url fd))))))))
+      (vs/jm "apikey" (:apikey CANARY) "secret" (:secret CANARY)
+             "headers" (vs/jm "X-Custom-Token" (:header CANARY))
+             "clean" clean
+             "feature" feature
+             "extend" (apply vs/jt (capture-feature sinks) extra)
+             "utility" (vs/jm "fetcher" (fn [_fctx url fd] ((:respond scenario) url fd)))))))
+
+(defn- make-sdk [scenario sinks cleanopts & extra]
+  (construct (sdk-opts scenario sinks cleanopts extra)))
 
 ;; A fresh struct map of the match, since an operation may keep what it is
 ;; given.
@@ -219,8 +238,8 @@ ${candidates(entity)}
 ;; The first operation that completes against a plain 200: with no
 ;; arguments, else with every path parameter its points declare filled in.
 (defn- usable-op []
-  (let [plain (api/make-sdk (vs/jm "apikey" (:apikey CANARY)
-                                   "utility" (vs/jm "fetcher" (fn [_ _ _] [(response 200 (vs/jm "id" "i1") {}) nil]))))]
+  (let [plain (construct (vs/jm "apikey" (:apikey CANARY)
+                                "utility" (vs/jm "fetcher" (fn [_ _ _] [(response 200 (vs/jm "id" "i1") {}) nil]))))]
     (some (fn [c]
             (some (fn [match]
                     (try ((:op c) ((:accessor c) plain) match (vs/jm))
@@ -278,6 +297,8 @@ ${candidates(entity)}
         explain (vs/getprop ctrl "explain")]
     (when err (swap! sinks into (forms "error" err)))
     (when (some? out) (swap! sinks into (forms "result" out)))
+    ;; Raw, as a caller copying the match into another query reads it.
+    (swap! sinks into (forms "match" ((:match-get ent))))
     (when (some? explain) (swap! sinks into (forms "explain" explain)))
     (when (and (some? held) (not (identical? held explain))) (swap! sinks into (forms "explain:held" held)))
     err))
@@ -301,10 +322,15 @@ ${candidates(entity)}
               (when-let [ex (vs/getprop ctrl "explain")] (swap! explains assoc key ex))
               (swap! sinks into (forms "sdk" sdk))
               (swap! sinks conj {:name "sdk:slots" :text (pr-str (into {} sdk))})))
+          ;; A name given at run time replaces the declared one: the match
+          ;; leaves out whichever name prepare-auth placed.
+          (let [opts (sdk-opts (first SCENARIOS) sinks nil nil)]
+            (.put ^java.util.Map opts "auth" (vs/jm "name" "zzcred"))
+            (drive (construct opts) target (vs/jm) sinks))
           ;; A credential mistyped as a map is rejected by validation, whose
           ;; message quotes the value it rejected.
-          (let [rejected (try (api/make-sdk (vs/jm "apikey" (vs/jm "value" (:apikey CANARY))
-                                                   "clean" (vs/jm "values" (:value CANARY))))
+          (let [rejected (try (api/make-sdk (offline (vs/jm "apikey" (vs/jm "value" (:apikey CANARY))
+                                                            "clean" (vs/jm "values" (:value CANARY)))))
                               nil
                               (catch Throwable e e))]
             (t/is-some rejected "a credential mistyped as a map should be rejected")
@@ -352,25 +378,28 @@ ${candidates(entity)}
             (t/is-deep (vs/getpath config "options.clean") (vs/jm "keys" "zzsens" "values" (:config CANARY))
                        "the config's clean block is unchanged"))
           ;; With no clean option at all, the schema defaults still apply.
-          (let [bare (api/make-sdk (vs/jm "apikey" (:apikey CANARY) "secret" (:secret CANARY)
-                                          "headers" (vs/jm "X-Custom-Token" (:header CANARY))
-                                          "utility" (vs/jm "fetcher" (fn [_fctx url fd]
-                                                                       ((:respond (nth SCENARIOS 1)) url fd)))))]
+          (let [bare (construct (vs/jm "apikey" (:apikey CANARY) "secret" (:secret CANARY)
+                                       "headers" (vs/jm "X-Custom-Token" (:header CANARY))
+                                       "utility" (vs/jm "fetcher" (fn [_fctx url fd]
+                                                                    ((:respond (nth SCENARIOS 1)) url fd)))))]
             (t/is-some (drive bare target (vs/jm "explain" (vs/jm)) sinks) "the 404 should fail without a clean option"))
           ;; A feature's name is not a field name: only the sensitive names
           ;; inside its settings register. An entity block, of entity settings
-          ;; or seeded records keyed by entity name and id, is not read at all.
+          ;; or seeded records keyed by entity name and id, is not read at all,
+          ;; and nor are rbac's rules, keyed by entity and operation names.
           (let [record (vs/jm "zztoken" (vs/jm "ZZTOKEN01" (vs/jm "note" "PLAINRECORD-t5r3e1w9")))
-                sdk (api/make-sdk (vs/jm "apikey" (:apikey CANARY)
-                                         "feature" (vs/jm "zzsecrets" (vs/jm "active" false "kind" "PLAINSETTING-q8w2e4r6")
-                                                          "zzfeat" (vs/jm "active" false "apitoken" "FEATTOKEN-z9y8x7w6")
-                                                          "test" (vs/jm "active" false "entity" record))
-                                         "entity" (vs/jm "zztoken" (vs/jm "alias" (vs/jm "zzkey" "PLAINALIAS-m2n4b6v8")))))
+                sdk (construct (vs/jm "apikey" (:apikey CANARY)
+                                      "feature" (vs/jm "zzsecrets" (vs/jm "active" false "kind" "PLAINSETTING-q8w2e4r6")
+                                                       "zzfeat" (vs/jm "active" false "apitoken" "FEATTOKEN-z9y8x7w6")
+                                                       "rbac" (vs/jm "active" false "rules" (vs/jm "zztoken.load" "PLAINRULE-k7j5h3g1"))
+                                                       "test" (vs/jm "active" false "entity" record))
+                                      "entity" (vs/jm "zztoken" (vs/jm "alias" (vs/jm "zzkey" "PLAINALIAS-m2n4b6v8")))))
                 root (core/client-root-ctx sdk)]
             (reset! featured {:plain (core/u-clean root "kind PLAINSETTING-q8w2e4r6")
                               :token (core/u-clean root "token FEATTOKEN-z9y8x7w6")
                               :record (core/u-clean root "record PLAINRECORD-t5r3e1w9")
-                              :alias (core/u-clean root "alias PLAINALIAS-m2n4b6v8")}))
+                              :alias (core/u-clean root "alias PLAINALIAS-m2n4b6v8")
+                              :rule (core/u-clean root "rule PLAINRULE-k7j5h3g1")}))
           (let [leaked (filterv (fn [s] (seq (leaks (:text s)))) @sinks)]
             (println (str "clean: swept " (count @sinks) " surface(s), " (count leaked) " leak(s)"))
             (t/is-eq (count leaked) 0
@@ -407,6 +436,7 @@ ${candidates(entity)}
           (t/is-eq (:token @featured) (str "token " MASK) "a sensitive setting inside a feature registers")
           (t/is-eq (:record @featured) "record PLAINRECORD-t5r3e1w9" "a seeded record does not register")
           (t/is-eq (:alias @featured) "alias PLAINALIAS-m2n4b6v8" "an entity setting does not register")
+          (t/is-eq (:rule @featured) "rule PLAINRULE-k7j5h3g1" "an rbac rule keyed by entity and operation does not register")
           (let [explained (get @explains "ok/explain")
                 result (vs/getprop explained "result")]
             (t/is-some result "the explain record should carry the result")
@@ -449,11 +479,11 @@ ${candidates(entity)}
     (fn []
       (let [cfg (core/make-clean-config (vs/jm "keys" "key,secret,token"))
             ctx (atom {:options (vs/jm "__derived__" (vs/jm "clean" cfg))})
+            _ (core/u-clean-add-sensitive ctx (vs/jm "apikey" (vs/jm "value" "NESTED-SECRET-1")
+                                                     "headers" (vs/jm "X-Api-Token" (vs/jt "LISTED-SECRET-2"))
+                                                     "secret" 123456789
+                                                     "name" "not-a-secret"))
             values (vs/getprop cfg "values")]
-        (core/u-clean-add-sensitive ctx (vs/jm "apikey" (vs/jm "value" "NESTED-SECRET-1")
-                                               "headers" (vs/jm "X-Api-Token" (vs/jt "LISTED-SECRET-2"))
-                                               "secret" 123456789
-                                               "name" "not-a-secret"))
         (t/is-true (.contains ^java.util.List values "NESTED-SECRET-1") "nested under apikey")
         (t/is-true (.contains ^java.util.List values "LISTED-SECRET-2") "listed under a token header")
         (t/is-true (.contains ^java.util.List values "123456789") "a number, as its text")