@voxgig/sdkgen 0.44.0 → 1.0.1

package/project/.sdk/src/cmp/ts/TestEntity_ts.ts

@@ -29,6 +29,7 @@ import {
   Slot,
   cmp,
   each,
+  isAuthActive,
 } from '@voxgig/sdkgen'
 
 
@@ -37,19 +38,38 @@ import {
 } from './utility_ts'
 
 
-type OpGen = (model: any, entity: any, flow: any, step: any, index: { key$: number, val$: any }) => void
+// GenCtx is the per-language generation context passed to every OpGen.
+// Languages with extra needs (Go's `gomodule`, PHP's `accessor`) extend
+// this shape locally. The signature `(ctx, step, index)` is now uniform
+// across all seven language tracks (Phase 1 of the templates refactor).
+type GenCtx = {
+  model: Model
+  entity: ModelEntity
+  flow: ModelEntityFlow
+  PROJUPPER: string
+}
+
+type OpGen = (ctx: GenCtx, step: ModelEntityFlowStep, index: number) => void
 
 
 const TestEntity = cmp(function TestEntity(props: any) {
   const ctx$ = props.ctx$
-  const model = ctx$.model
+  const model: Model = ctx$.model
   const stdrep = ctx$.stdrep
 
   const target = props.target
-  const entity = props.entity
+  const entity: ModelEntity = props.entity
 
   const PROJENVNAME = nom(model.const, 'NAME').replace(/[^A-Z_]/g, '_')
   const ENTENVNAME = nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')
+  const authActive = isAuthActive(model)
+  const apikeyEnvEntry = authActive
+    ? `\n    '${PROJENVNAME}_APIKEY': 'NONE',`
+    : ''
+  const apikeyLiveField = authActive
+    ? `
+        apikey: env.${PROJENVNAME}_APIKEY,`
+    : ''
 
   // TODO: should be a utility function
   const ff = projectPath('src/cmp/ts/fragment/')
@@ -63,11 +83,13 @@ const TestEntity = cmp(function TestEntity(props: any) {
         replace: {
           SdkName: nom(model.const, 'Name'),
           EntityName: nom(entity, 'Name'),
+          entityname: entity.name,
+          PROJECTNAME: PROJENVNAME,
           ...stdrep,
         }
       }, () => {
 
-        const basicflow = getModelPath(model, `main.${KIT}.flow.Basic${entity.Name}Flow`)
+        const basicflow = getModelPath(model, `main.${KIT}.flow.Basic${nom(entity, 'Name')}Flow`)
 
         const dobasic = basicflow && true === basicflow.active
 
@@ -120,19 +142,26 @@ function basicSetup(extra?: any) {
       }]
     })
 
+  // Detect whether the user provided a real ENTID JSON via env var. The
+  // basic flow consumes synthetic IDs from the fixture file; without an
+  // override those synthetic IDs reach the live API and 4xx. Surface this
+  // to the test so it can skip rather than fail.
+  const idmapEnvVal = process.env['${PROJENVNAME}_TEST_${ENTENVNAME}_ENTID']
+  const idmapOverridden = null != idmapEnvVal && idmapEnvVal.trim().startsWith('{')
+
   const env = envOverride({
     '${PROJENVNAME}_TEST_${ENTENVNAME}_ENTID': idmap,
     '${PROJENVNAME}_TEST_LIVE': 'FALSE',
-    '${PROJENVNAME}_TEST_EXPLAIN': 'FALSE',
-    '${PROJENVNAME}_APIKEY': 'NONE',
+    '${PROJENVNAME}_TEST_EXPLAIN': 'FALSE',${apikeyEnvEntry}
   })
 
   idmap = env['${PROJENVNAME}_TEST_${ENTENVNAME}_ENTID']
 
-  if ('TRUE' === env.${PROJENVNAME}_TEST_LIVE) {
+  const live = 'TRUE' === env.${PROJENVNAME}_TEST_LIVE
+
+  if (live) {
     client = new ${model.Name}SDK(merge([
-      {
-        apikey: env.${PROJENVNAME}_APIKEY,
+      {${apikeyLiveField}
       },
       extra
     ]))
@@ -146,6 +175,8 @@ function basicSetup(extra?: any) {
     struct,
     data: entityData,
     explain: 'TRUE' === env.${PROJENVNAME}_TEST_EXPLAIN,
+    live,
+    syntheticOnly: live && !idmapOverridden,
     now: Date.now(),
   }
 
@@ -160,8 +191,30 @@ function basicSetup(extra?: any) {
             (s: any) => s.op === 'create'
           )
 
+          // The basic test exercises a flow with one or more ops (load,
+          // list, create, update, remove, ...). The control file lets users
+          // skip per-op for an entity. Since the flow is sequential and
+          // dependent (e.g. update needs prior load), skipping ANY op the
+          // flow exercises skips the whole basic test.
+          const flowOps = Array.from(new Set(
+            (basicflow.step as any[]).map((s: any) => s.op).filter(Boolean)
+          ))
+          const flowOpsLiteral = '[' + flowOps.map((o: any) => `'${o}'`).join(', ') + ']'
+
           Content(`
+    const live = 'TRUE' === process.env.${PROJENVNAME}_TEST_LIVE
+    for (const op of ${flowOpsLiteral}) {
+      if (maybeSkipControl(t, 'entityOp', '${entity.name}.' + op, live)) return
+    }
+
     const setup = basicSetup()
+    // The basic flow consumes synthetic IDs and field values from the
+    // fixture (entity TestData.json). Those don't exist on the live API.
+    // Skip live runs unless the user provided a real ENTID env override.
+    if (setup.syntheticOnly) {
+      t.skip('live entity test uses synthetic IDs from fixture — set ${PROJENVNAME}_TEST_${ENTENVNAME}_ENTID JSON to run live')
+      return
+    }
     const client = setup.client
     const struct = setup.struct
 
@@ -179,10 +232,15 @@ function basicSetup(extra?: any) {
 `)
           }
 
-          each(basicflow.step, (step: any, index: any) => {
-            const opgen: OpGen = GENERATE_OP[step.op]
-            opgen(model, entity, basicflow, step, index)
-            Content('\n')
+          const genCtx: GenCtx = {
+            model, entity, flow: basicflow, PROJUPPER: PROJENVNAME,
+          }
+          each(basicflow.step, (step: ModelEntityFlowStep, index: number) => {
+            const opgen = GENERATE_OP[step.op]
+            if (null != opgen) {
+              opgen(genCtx, step, index)
+              Content('\n')
+            }
           })
         })
       })
@@ -191,25 +249,20 @@ function basicSetup(extra?: any) {
 })
 
 
-const generateCreate: OpGen = (
-  model: Model,
-  entity: ModelEntity,
-  flow: ModelEntityFlow,
-  step: ModelEntityFlowStep,
-  index: any
-) => {
+const generateCreate: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
   const ref = step.input.ref ?? entity.name + '_ref01'
   const entvar = step.input.entvar ?? ref + '_ent'
   const datavar = step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? ''))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index))
-  const needsEnt = !priorSteps.some((s: any) =>
+  const priorSteps = flow.step.slice(0, Number(index))
+  const needsEnt = !priorSteps.some(s =>
     ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
 
-  const hasDatvar = priorSteps.some((s: any) => {
+  const hasDatvar = priorSteps.some(s => {
     if ('create' === s.op) {
-      const priorRef = s.input?.ref ?? entity.name + '_ref01'
-      const priorDatvar = s.input?.datavar ?? (priorRef + '_data' + (s.input?.suffix ?? ''))
+      const priorRef = s.input.ref ?? entity.name + '_ref01'
+      const priorDatvar = s.input.datavar ?? (priorRef + '_data' + (s.input.suffix ?? ''))
       return priorDatvar === datavar
     }
     return false
@@ -235,27 +288,31 @@ const generateCreate: OpGen = (
 `)
   })
 
+  const hasEntIdC = null != entity.id
+
   Content(`
     ${datavar} = await ${entvar}.create(${datavar})
-    assert(null != ${datavar}.id)
 `)
+  if (hasEntIdC) {
+    Content(`    assert(null != ${datavar}.id)
+`)
+  }
+  else {
+    Content(`    assert(null != ${datavar})
+`)
+  }
 }
 
 
-const generateList: OpGen = (
-  model: Model,
-  entity: ModelEntity,
-  flow: ModelEntityFlow,
-  step: ModelEntityFlowStep,
-  index: any
-) => {
+const generateList: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
   const ref = step.input.ref ?? entity.name + '_ref01'
   const entvar = step.input.entvar ?? ref + '_ent'
   const matchvar = step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? ''))
   const listvar = step.input.listvar ?? (ref + '_list' + (step.input.suffix ?? ''))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index))
-  const needsEnt = !priorSteps.some((s: any) =>
+  const priorSteps = flow.step.slice(0, Number(index))
+  const needsEnt = !priorSteps.some(s =>
     ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
 
   Content(`
@@ -276,12 +333,12 @@ const generateList: OpGen = (
   Content(`
     const ${listvar} = await ${entvar}.list(${matchvar})
 `)
-  const allSteps = Object.values(flow.step)
+  const allSteps = flow.step
   for (let vI = 0; vI < step.valid.length; vI++) {
     const validator = step.valid[vI]
     const validRef = validator.def?.ref
-    const hasRefData = validRef && allSteps.some((s: any) => 'create' === s.op &&
-      ((s.input?.ref ?? entity.name + '_ref01') === validRef))
+    const hasRefData = validRef && allSteps.some(s => 'create' === s.op &&
+      ((s.input.ref ?? entity.name + '_ref01') === validRef))
 
     if ('ItemExists' === validator.apply && hasRefData) {
       Content(`
@@ -297,13 +354,8 @@ const generateList: OpGen = (
 }
 
 
-const generateUpdate: OpGen = (
-  model: Model,
-  entity: ModelEntity,
-  flow: ModelEntityFlow,
-  step: ModelEntityFlowStep,
-  index: any
-) => {
+const generateUpdate: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
   const ref = step.input.ref ?? entity.name + '_ref01'
   const entvar = step.input.entvar ?? ref + '_ent'
   const datavar = step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? ''))
@@ -311,10 +363,12 @@ const generateUpdate: OpGen = (
   const markdefvar = step.input.markdefvar ?? (ref + '_markdef' + (step.input.suffix ?? ''))
   const srcdatavar = step.input.srcdatavar ?? (ref + '_data' + (step.input.suffix ?? ''))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index))
-  const needsEnt = !priorSteps.some((s: any) =>
+  const priorSteps = flow.step.slice(0, Number(index))
+  const needsEnt = !priorSteps.some(s =>
     ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
 
+  const hasEntIdU = null != entity.id
+
   Content(`
     // UPDATE
 `)
@@ -323,8 +377,11 @@ const generateUpdate: OpGen = (
 `)
   }
   Content(`    const ${datavar}: any = {}
-    ${datavar}.id = ${srcdatavar}.id
 `)
+  if (hasEntIdU) {
+    Content(`    ${datavar}.id = ${srcdatavar}.id
+`)
+  }
 
   each(step.data, (mi: any) => {
     if ('id' !== mi.key$) {
@@ -348,8 +405,15 @@ const generateUpdate: OpGen = (
 
   Content(`
     const ${resdatavar} = await ${entvar}.update(${datavar})
-    assert(${resdatavar}.id === ${datavar}.id)
 `)
+  if (hasEntIdU) {
+    Content(`    assert(${resdatavar}.id === ${datavar}.id)
+`)
+  }
+  else {
+    Content(`    assert(null != ${resdatavar})
+`)
+  }
 
   for (let sI = 0; sI < step.spec.length; sI++) {
     const spec = step.spec[sI]
@@ -363,37 +427,57 @@ const generateUpdate: OpGen = (
 }
 
 
-const generateLoad: OpGen = (
-  model: Model,
-  entity: ModelEntity,
-  flow: ModelEntityFlow,
-  step: ModelEntityFlowStep,
-  index: any
-) => {
+const generateLoad: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
   const ref = step.input.ref ?? entity.name + '_ref01'
   const entvar = step.input.entvar ?? ref + '_ent'
   const matchvar = step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? ''))
   const datavar = step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? ''))
   const srcdatavar = step.input.srcdatavar ?? (ref + '_data' + (step.input.suffix ?? ''))
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index))
-  const hasEntVar = priorSteps.some((s: any) =>
+  const priorSteps = flow.step.slice(0, Number(index))
+  const hasEntVar = priorSteps.some(s =>
     ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
 
   // Check if srcdatavar was declared by a prior create step or by the
   // preamble bootstrap (which runs when the flow has no create step)
-  const flowHasCreate = Object.values(flow.step).some((s: any) => s.op === 'create')
+  const flowHasCreate = flow.step.some(s => s.op === 'create')
   const preambleRef = entity.name + '_ref01'
   const hasSrcData = (!flowHasCreate && srcdatavar === preambleRef + '_data') ||
-    priorSteps.some((s: any) => {
+    priorSteps.some(s => {
       if ('create' === s.op) {
-        const priorRef = s.input?.ref ?? entity.name + '_ref01'
-        const priorDatvar = s.input?.datavar ?? (priorRef + '_data' + (s.input?.suffix ?? ''))
+        const priorRef = s.input.ref ?? entity.name + '_ref01'
+        const priorDatvar = s.input.datavar ?? (priorRef + '_data' + (s.input.suffix ?? ''))
         return priorDatvar === srcdatavar
       }
       return false
     })
 
+  const hasEntId = null != entity.id
+
+  // When the entity has no id model field but the load operation requires
+  // path parameters (e.g. cotizacion needs {casa}/{fecha}), calling
+  // load({}) leaves the URL with literal {param} placeholders and the live
+  // API returns 404 HTML, which the SDK then fails to parse as JSON. There
+  // is no synthetic identifier to substitute, so skip emitting the load
+  // step's call in that case — but still declare the entity-var if no
+  // prior step has, so that later flow steps (e.g. remove) referencing
+  // ${entvar} compile.
+  const loadOp = entity.op?.load
+  const loadPoint = loadOp?.points?.[0]
+  const loadPathParams = loadPoint?.args?.params || []
+  const loadHasRequiredParams = loadPathParams.some((p: any) => p.reqd !== false)
+  if (!hasEntId && loadHasRequiredParams) {
+    if (!hasEntVar) {
+      Content(`
+    // LOAD: skipped — no entity id field and load requires path params.
+    // Entity-var is declared here so later flow steps still compile.
+    const ${entvar} = client.${nom(entity, 'Name')}()
+`)
+    }
+    return
+  }
+
   Content(`
     // LOAD
 `)
@@ -401,34 +485,39 @@ const generateLoad: OpGen = (
     Content(`    const ${entvar} = client.${nom(entity, 'Name')}()
 `)
   }
-  if (!hasSrcData) {
+  if (!hasSrcData && hasEntId) {
     Content(`    const ${srcdatavar} = Object.values(setup.data.existing.${entity.name})[0] as any
 `)
   }
-  Content(`    const ${matchvar}: any = {}
+  if (hasEntId) {
+    Content(`    const ${matchvar}: any = {}
     ${matchvar}.id = ${srcdatavar}.id
     const ${datavar} = await ${entvar}.load(${matchvar})
     assert(${datavar}.id === ${srcdatavar}.id)
 `)
+  }
+  else {
+    Content(`    const ${matchvar}: any = {}
+    const ${datavar} = await ${entvar}.load(${matchvar})
+    assert(null != ${datavar})
+`)
+  }
 }
 
 
-const generateRemove: OpGen = (
-  model: Model,
-  entity: ModelEntity,
-  flow: ModelEntityFlow,
-  step: ModelEntityFlowStep,
-  index: any
-) => {
+const generateRemove: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
   const ref = step.input.ref ?? entity.name + '_ref01'
   const entvar = step.input.entvar ?? ref + '_ent'
   const matchvar = step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? ''))
   const srcdatavar = step.input.srcdatavar ?? (ref + '_data')
 
-  const priorSteps = Object.values(flow.step).slice(0, Number(index))
-  const needsEnt = !priorSteps.some((s: any) =>
+  const priorSteps = flow.step.slice(0, Number(index))
+  const needsEnt = !priorSteps.some(s =>
     ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
 
+  const hasEntIdR = null != entity.id
+
   Content(`
     // REMOVE
 `)
@@ -437,8 +526,12 @@ const generateRemove: OpGen = (
 `)
   }
   Content(`    const ${matchvar}: any = {}
-    ${matchvar}.id = ${srcdatavar}.id
-    await ${entvar}.remove(${matchvar})
+`)
+  if (hasEntIdR) {
+    Content(`    ${matchvar}.id = ${srcdatavar}.id
+`)
+  }
+  Content(`    await ${entvar}.remove(${matchvar})
   `)
 }
 

package/project/.sdk/src/cmp/ts/fragment/Config.fragment.ts

@@ -31,11 +31,7 @@ class Config {
   options = {
     base: '$$main.kit.info.servers.0.url$$',
 
-    auth: {
-      prefix: '$$main.kit.config.auth.prefix$$',
-    },
-
-    headers: 'HEADERS',
+    'AUTHBLOCK'headers: 'HEADERS',
 
     entity: {
       // #EntityConfigs

package/project/.sdk/src/cmp/ts/fragment/Direct.test.fragment.ts

@@ -2,7 +2,7 @@
 const envlocal = __dirname + '/../../../.env.local'
 require('dotenv').config({ quiet: true, path: [envlocal] })
 
-import { test, describe } from 'node:test'
+import { test, describe, afterEach } from 'node:test'
 import assert from 'node:assert'
 
 
@@ -10,11 +10,18 @@ import { ProjectNameSDK } from '../../..'
 
 import {
   envOverride,
+  liveDelay,
+  maybeSkipControl,
+  skipIfMissingIds,
 } from '../../utility'
 
 
 describe('EntityNameDirect', async () => {
 
+  // Per-test live pacing. Delay is read from sdk-test-control.json's
+  // `test.live.delayMs`; only sleeps when PROJECTNAME_TEST_LIVE=TRUE.
+  afterEach(liveDelay('PROJECTNAME_TEST_LIVE'))
+
   test('direct-exists', async () => {
     const sdk = new ProjectNameSDK({
       system: { fetch: async () => ({}) }

package/project/.sdk/src/cmp/ts/fragment/Entity.test.fragment.ts

@@ -5,7 +5,7 @@ require('dotenv').config({ quiet: true, path: [envlocal] })
 import Path from 'node:path'
 import * as Fs from 'node:fs'
 
-import { test, describe } from 'node:test'
+import { test, describe, afterEach } from 'node:test'
 import assert from 'node:assert'
 
 
@@ -13,16 +13,22 @@ import { ProjectNameSDK, BaseFeature, stdutil } from '../../..'
 
 import {
   envOverride,
+  liveDelay,
   makeCtrl,
   makeMatch,
   makeReqdata,
   makeStepData,
   makeValid,
+  maybeSkipControl,
 } from '../../utility'
 
 
 describe('EntityNameEntity', async () => {
 
+  // Per-test live pacing. Delay is read from sdk-test-control.json's
+  // `test.live.delayMs`; only sleeps when PROJECTNAME_TEST_LIVE=TRUE.
+  afterEach(liveDelay('PROJECTNAME_TEST_LIVE'))
+
   test('instance', async () => {
     const testsdk = ProjectNameSDK.test()
     const ent = testsdk.EntityName()
@@ -30,7 +36,7 @@ describe('EntityNameEntity', async () => {
   })
 
 
-  test('basic', async () => {
+  test('basic', async (t) => {
     // <[SLOT:basic]>
   })
 })

package/project/.sdk/src/cmp/ts/fragment/Main.fragment.ts

@@ -162,7 +162,27 @@ class ProjectNameSDK {
       }
 
       const status = fetched.status
-      const json = 'function' === typeof fetched.json ? await fetched.json() : fetched.json
+
+      // No body responses (204 No Content, 304 Not Modified) and explicit
+      // zero content-length must skip JSON parsing — fetched.json() would
+      // throw `Unexpected end of JSON input` on an empty body.
+      const headers = fetched.headers
+      const contentLength = headers && 'function' === typeof headers.get
+        ? headers.get('content-length')
+        : (headers || {})['content-length']
+      const noBody = 204 === status || 304 === status || '0' === String(contentLength)
+
+      let json: any = undefined
+      if (!noBody) {
+        try {
+          json = 'function' === typeof fetched.json ? await fetched.json() : fetched.json
+        }
+        catch (parseErr) {
+          // Body wasn't valid JSON — surface the raw response rather than
+          // throwing. data stays undefined; callers can inspect status/headers.
+          json = undefined
+        }
+      }
 
       return {
         ok: status >= 200 && status < 300,

package/project/.sdk/tm/go/feature/test_feature.go

@@ -69,8 +69,28 @@ func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
 			entmap = map[string]any{}
 		}
 
+		// For single-entity ops (load, remove) with an empty explicit match,
+		// fall back to the id the entity client already knows from a prior
+		// create/load (in ctx.Match / ctx.Data). Mirrors the TS mock where
+		// param() resolves the id from that accumulated state.
+		resolveMatch := func(explicit map[string]any) map[string]any {
+			if len(explicit) > 0 {
+				return explicit
+			}
+			for _, src := range []any{ctx.Match, ctx.Data} {
+				if src == nil {
+					continue
+				}
+				v := vs.GetProp(src, "id")
+				if v != nil && v != "__UNDEFINED__" {
+					return map[string]any{"id": v}
+				}
+			}
+			return map[string]any{}
+		}
+
 		if op.Name == "load" {
-			args := self.buildArgs(ctx, op, ctx.Reqmatch)
+			args := self.buildArgs(ctx, op, resolveMatch(ctx.Reqmatch))
 			found := vs.Select(entmap, args)
 			ent := vs.GetElem(found, 0)
 			if ent == nil {
@@ -91,9 +111,37 @@ func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
 			out := vs.Clone(found)
 			return respond(200, out, nil), nil
 		} else if op.Name == "update" {
-			args := self.buildArgs(ctx, op, ctx.Reqdata)
+			// Match the existing entity by id only (or its alias). Reqdata
+			// also contains the new field values, which would otherwise
+			// cause Select to filter out the entity we want to update.
+			// Falls back to first entity when no match found, mirroring
+			// the TS mock.
+			updateMatch := map[string]any{}
+			if ctx.Reqdata != nil {
+				if v, has := ctx.Reqdata["id"]; has {
+					updateMatch["id"] = v
+				}
+				if op.Alias != nil {
+					if aliasIdRaw := vs.GetProp(op.Alias, "id"); aliasIdRaw != nil {
+						if aliasId, ok := aliasIdRaw.(string); ok {
+							if v, has := ctx.Reqdata[aliasId]; has {
+								updateMatch[aliasId] = v
+							}
+						}
+					}
+				}
+			}
+			args := self.buildArgs(ctx, op, updateMatch)
 			found := vs.Select(entmap, args)
 			ent := vs.GetElem(found, 0)
+			if ent == nil && entmap != nil {
+				for _, e := range entmap {
+					if _, ok := e.(map[string]any); ok {
+						ent = e
+						break
+					}
+				}
+			}
 			if ent == nil {
 				return respond(404, nil, map[string]any{"statusText": "Not found"}), nil
 			}
@@ -109,7 +157,7 @@ func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
 			out := vs.Clone(ent)
 			return respond(200, out, nil), nil
 		} else if op.Name == "remove" {
-			args := self.buildArgs(ctx, op, ctx.Reqmatch)
+			args := self.buildArgs(ctx, op, resolveMatch(ctx.Reqmatch))
 			found := vs.Select(entmap, args)
 			ent := vs.GetElem(found, 0)
 			if ent == nil {