@voxgig/sdkgen 0.44.0 → 1.0.1

package/project/.sdk/src/cmp/py/TestDirect_py.ts

@@ -1,5 +1,8 @@
 
 import {
+  Model,
+  ModelEntity,
+  nom,
   depluralize,
 } from '@voxgig/apidef'
 
@@ -8,6 +11,7 @@ import {
   File,
   cmp,
   snakify,
+  isAuthActive,
 } from '@voxgig/sdkgen'
 
 
@@ -51,12 +55,20 @@ function normalizePathParams(
 
 const TestDirect = cmp(function TestDirect(props: any) {
   const ctx$ = props.ctx$
-  const model = ctx$.model
+  const model: Model = ctx$.model
 
   const target = props.target
-  const entity = props.entity
+  const entity: ModelEntity = props.entity
 
-  const PROJECTNAME = model.Name.toUpperCase().replace(/[^A-Z_]/g, '_')
+  const PROJECTNAME = nom(model, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
+
+  const authActive = isAuthActive(model)
+  const apikeyEnvEntry = authActive
+    ? `\n        "${PROJECTNAME}_APIKEY": "NONE",`
+    : ''
+  const apikeyLiveField = authActive
+    ? `\n            "apikey": env.get("${PROJECTNAME}_APIKEY"),`
+    : ''
 
   const opnames = Object.keys(entity.op)
   const hasLoad = opnames.includes('load')
@@ -71,13 +83,52 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   const loadPoint = loadOp?.points?.[0]
   const loadPath = loadPoint ? normalizePathParams(loadPoint.parts || [], loadPoint?.args?.params || [], loadPoint?.rename?.param) : ''
-  const loadParams = loadPoint?.args?.params || []
+  const allLoadParams = loadPoint?.args?.params || []
+  // Some upstream OpenAPI specs declare a parameter as `in: path` even when
+  // that path has no `{name}` placeholder for it. Only path params that
+  // actually appear in the URL template should drive direct-test path-param
+  // setup and URL-substitution asserts; otherwise the SDK silently drops
+  // them and the URL-includes assert fails.
+  const _pathPlaceholders = new Set<string>()
+  for (const part of (loadPoint?.parts || [])) {
+    if (typeof part === 'string' && part.startsWith('{') && part.endsWith('}')) {
+      _pathPlaceholders.add(part.slice(1, -1))
+    }
+  }
+  const _renameMap = (loadPoint?.rename?.param || {}) as Record<string, string>
+  const _renamedPlaceholders = new Set<string>()
+  for (const ph of _pathPlaceholders) {
+    _renamedPlaceholders.add(ph)
+    for (const [orig, renamed] of Object.entries(_renameMap)) {
+      if (renamed === ph) _renamedPlaceholders.add(orig)
+    }
+  }
+  const loadParams = allLoadParams.filter((p: any) =>
+    _renamedPlaceholders.has(p.name) || _renamedPlaceholders.has(p.orig))
 
   const listPoint = listOp?.points?.[0]
   const listPath = listPoint ? normalizePathParams(listPoint.parts || [], listPoint?.args?.params || [], listPoint?.rename?.param) : ''
   const listParams = listPoint?.args?.params || []
 
-  const entidEnvVar = `${PROJECTNAME}_TEST_${entity.Name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID`
+  // Required query params with spec-provided examples — needed in live mode
+  // to satisfy API contracts (e.g. /v2018/history requires city/start/end).
+  const loadQuery = loadPoint?.args?.query || []
+  const loadLiveQueryEntries = loadQuery
+    .filter((q: any) => q.reqd && undefined !== q.example && null !== q.example)
+  const loadLiveQueryLines = loadLiveQueryEntries
+    .map((q: any) => `            query["${q.name}"] = ${JSON.stringify(q.example)}`)
+    .join('\n')
+
+  // Path params with spec-provided examples — when ALL load params have
+  // spec examples, prefer them over list-bootstrap.
+  const loadAllHaveExamples =
+    loadParams.length > 0 &&
+    loadParams.every((p: any) => undefined !== p.example && null !== p.example)
+  const loadExampleLines = loadAllHaveExamples
+    ? loadParams.map((p: any) => `            params["${p.name}"] = ${JSON.stringify(p.example)}`).join('\n')
+    : ''
+
+  const entidEnvVar = `${PROJECTNAME}_TEST_${nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')}_ENTID`
 
   File({ name: 'test_' + entity.name + '_direct.' + target.ext }, () => {
 
@@ -97,12 +148,33 @@ class Test${entity.Name}Direct:
 `)
 
     if (hasList && listPoint) {
+      // Track idmap keys this list test consumes in live mode.
+      const listLiveIdKeys: string[] = listParams.map((lp: any) => {
+        return lp.name === 'id'
+          ? entity.name + '01'
+          : lp.name.replace(/_id$/, '') + '01'
+      })
+      const listSkipBlock = listLiveIdKeys.length > 0
+        ? `        if setup["live"]:
+            for _live_key in [${listLiveIdKeys.map(k => `"${k}"`).join(', ')}]:
+                if setup["idmap"].get(_live_key) is None:
+                    # pytest already imported at module scope
+                    pytest.skip(f"live test needs {_live_key} via *_ENTID env var (synthetic IDs only)")
+                    return
+
+`
+        : ''
       Content(`    def test_should_direct_list_${entity.name}(self):
         setup = _${entity.name}_direct_setup([
             {"id": "direct01"},
             {"id": "direct02"},
         ])
-        client = setup["client"]
+        _skip, _reason = runner.is_control_skipped("direct", "direct-list-${entity.name}", "live" if setup["live"] else "unit")
+        if _skip:
+            # pytest already imported at module scope
+            pytest.skip(_reason or "skipped via sdk-test-control.json")
+            return
+${listSkipBlock}        client = setup["client"]
 
 `)
 
@@ -136,11 +208,24 @@ class Test${entity.Name}Direct:
 `)
       }
 
-      Content(`        assert err is None
-        assert result["ok"] is True
-        assert helpers.to_int(result["status"]) == 200
-
-        if not setup["live"]:
+      Content(`        if setup["live"]:
+            # Live mode is lenient: synthetic IDs frequently 4xx and the
+            # list-response shape varies wildly across public APIs. Skip
+            # rather than fail when the call doesn't return a usable list.
+            if err is not None:
+                pytest.skip(f"list call failed (likely synthetic IDs against live API): {err}")
+                return
+            if not result.get("ok"):
+                pytest.skip("list call not ok (likely synthetic IDs against live API)")
+                return
+            status = helpers.to_int(result["status"])
+            if status < 200 or status >= 300:
+                pytest.skip(f"expected 2xx status, got {status}")
+                return
+        else:
+            assert err is None
+            assert result["ok"] is True
+            assert helpers.to_int(result["status"]) == 200
             assert isinstance(result["data"], list)
             assert len(result["data"]) == 2
             assert len(setup["calls"]) == 1
@@ -149,18 +234,58 @@ class Test${entity.Name}Direct:
     }
 
     if (hasLoad && loadPoint) {
+      // Python's direct-load test has no list-bootstrap, so when load path
+      // params can't be filled (no spec examples + no override), skip cleanly.
+      const loadSkipBlock = (loadParams.length > 0 && !loadAllHaveExamples)
+        ? `        if setup["live"]:
+            # pytest already imported at module scope
+            pytest.skip("live direct-load needs real ID — set *_ENTID env var with real IDs to run")
+            return
+
+`
+        : ''
       Content(`    def test_should_direct_load_${entity.name}(self):
         setup = _${entity.name}_direct_setup({"id": "direct01"})
-        client = setup["client"]
+        _skip, _reason = runner.is_control_skipped("direct", "direct-load-${entity.name}", "live" if setup["live"] else "unit")
+        if _skip:
+            # pytest already imported at module scope
+            pytest.skip(_reason or "skipped via sdk-test-control.json")
+            return
+${loadSkipBlock}        client = setup["client"]
 
 `)
 
-      if (loadParams.length > 0) {
+      const needsQuery = loadParams.length > 0 || loadLiveQueryLines !== ''
+      if (needsQuery) {
         Content(`        params = {}
-        if not setup["live"]:
+        query = {}
+`)
+        if (loadAllHaveExamples) {
+          // Use spec-provided path-param examples in live mode.
+          Content(`        if setup["live"]:
+${loadLiveQueryLines ? loadLiveQueryLines + '\n' : ''}${loadExampleLines}
+        else:
 `)
-        for (let i = 0; i < loadParams.length; i++) {
-          Content(`            params["${loadParams[i].name}"] = "direct0${i + 1}"
+          for (let i = 0; i < loadParams.length; i++) {
+            Content(`            params["${loadParams[i].name}"] = "direct0${i + 1}"
+`)
+          }
+        } else if (loadParams.length > 0) {
+          if (loadLiveQueryLines) {
+            Content(`        if setup["live"]:
+${loadLiveQueryLines}
+`)
+          }
+          Content(`        if not setup["live"]:
+`)
+          for (let i = 0; i < loadParams.length; i++) {
+            Content(`            params["${loadParams[i].name}"] = "direct0${i + 1}"
+`)
+          }
+        } else if (loadLiveQueryLines) {
+          // Required-query only, no path params.
+          Content(`        if setup["live"]:
+${loadLiveQueryLines}
 `)
         }
       }
@@ -170,20 +295,34 @@ class Test${entity.Name}Direct:
             "path": "${loadPath}",
             "method": "GET",
 `)
-      if (loadParams.length > 0) {
+      if (needsQuery) {
         Content(`            "params": params,
+            "query": query,
 `)
       } else {
         Content(`            "params": {},
 `)
       }
       Content(`        })
-        assert err is None
-        assert result["ok"] is True
-        assert helpers.to_int(result["status"]) == 200
-        assert result["data"] is not None
-
-        if not setup["live"]:
+        if setup["live"]:
+            # Live mode is lenient: synthetic IDs frequently 4xx. Skip
+            # rather than fail when the load endpoint isn't reachable
+            # with the IDs we can construct from setup.idmap.
+            if err is not None:
+                pytest.skip(f"load call failed (likely synthetic IDs against live API): {err}")
+                return
+            if not result.get("ok"):
+                pytest.skip("load call not ok (likely synthetic IDs against live API)")
+                return
+            status = helpers.to_int(result["status"])
+            if status < 200 or status >= 300:
+                pytest.skip(f"expected 2xx status, got {status}")
+                return
+        else:
+            assert err is None
+            assert result["ok"] is True
+            assert helpers.to_int(result["status"]) == 200
+            assert result["data"] is not None
             if isinstance(result["data"], dict):
                 assert result["data"]["id"] == "direct01"
             assert len(setup["calls"]) == 1
@@ -200,15 +339,13 @@ def _${entity.name}_direct_setup(mockres):
 
     env = runner.env_override({
         "${entidEnvVar}": {},
-        "${PROJECTNAME}_TEST_LIVE": "FALSE",
-        "${PROJECTNAME}_APIKEY": "NONE",
+        "${PROJECTNAME}_TEST_LIVE": "FALSE",${apikeyEnvEntry}
     })
 
     live = env.get("${PROJECTNAME}_TEST_LIVE") == "TRUE"
 
     if live:
-        merged_opts = {
-            "apikey": env.get("${PROJECTNAME}_APIKEY"),
+        merged_opts = {${apikeyLiveField}
         }
         client = ${model.const.Name}SDK(merged_opts)
         return {

package/project/.sdk/src/cmp/py/TestEntity_py.ts

@@ -7,7 +7,12 @@ import {
 
 import {
   KIT,
+  Model,
+  ModelEntity,
+  ModelEntityFlow,
+  ModelEntityFlowStep,
   getModelPath,
+  nom,
 } from '@voxgig/apidef'
 
 
@@ -18,34 +23,47 @@ import {
   each,
   buildIdNames,
   getMatchEntries,
+  isAuthActive,
 } from '@voxgig/sdkgen'
 
 
-type OpGen = (ctx: GenCtx, step: any, index: any) => void
-
+// See TestEntity_ts.ts for the GenCtx/OpGen contract.
 type GenCtx = {
-  model: any
-  entity: any
-  flow: any
+  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 target = props.target
-  const entity = props.entity
+  const entity: ModelEntity = props.entity
 
-  const basicflow = getModelPath(model, `main.${KIT}.flow.Basic${entity.Name}Flow`)
-  const dobasic = basicflow && true === basicflow.active
+  const basicflow: ModelEntityFlow | undefined =
+    getModelPath(model, `main.${KIT}.flow.Basic${nom(entity, 'Name')}Flow`)
 
-  if (!dobasic) {
+  // No flow or flow inactive — nothing to generate. The narrowed-form
+  // check (rather than `if (!dobasic)`) is what lets TS know `basicflow`
+  // is non-null in the rest of the cmp body.
+  if (null == basicflow || true !== basicflow.active) {
     return
   }
 
-  const PROJUPPER = model.const.Name.toUpperCase().replace(/[^A-Z_]/g, '_')
+  const PROJUPPER = nom(model.const, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
+
+  const authActive = isAuthActive(model)
+  const apikeyEnvEntry = authActive
+    ? `\n        "${PROJUPPER}_APIKEY": "NONE",`
+    : ''
+  const apikeyLiveField = authActive
+    ? `\n                "apikey": env.get("${PROJUPPER}_APIKEY"),`
+    : ''
 
   const idnames = buildIdNames(entity, basicflow)
   const idnamesStr = idnames.map(n => `"${n}"`).join(', ')
@@ -86,6 +104,20 @@ class Test${entity.Name}Entity:
 
     def test_should_run_basic_flow(self):
         setup = _${entity.name}_basic_setup(None)
+        # Per-op sdk-test-control.json skip — basic test exercises a flow with
+        # multiple ops; skipping any one skips the whole flow (steps depend
+        # on each other).
+        _live = setup.get("live", False)
+        for _op in [${(Array.from(new Set((basicflow.step as any[]).map((s: any) => s.op).filter(Boolean)))).map(o => `"${o}"`).join(', ')}]:
+            _skip, _reason = runner.is_control_skipped("entityOp", "${entity.name}." + _op, "live" if _live else "unit")
+            if _skip:
+                pytest.skip(_reason or "skipped via sdk-test-control.json")
+                return
+        # The basic flow consumes synthetic IDs from the fixture. In live mode
+        # without an *_ENTID env override, those IDs hit the live API and 4xx.
+        if setup.get("synthetic_only"):
+            pytest.skip("live entity test uses synthetic IDs from fixture — "
+                        "set ${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID JSON to run live")
         client = setup["client"]
 
 `)
@@ -144,11 +176,17 @@ def _${entity.name}_basic_setup(extra):
 
 `)
 
-    Content(`    env = runner.env_override({
+    Content(`    # Detect ENTID env override before envOverride consumes it. When live
+    # mode is on without a real override, the basic test runs against synthetic
+    # IDs from the fixture and 4xx's. We surface this so the test can skip.
+    _entid_env_raw = os.environ.get(
+        "${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID")
+    _idmap_overridden = _entid_env_raw is not None and _entid_env_raw.strip().startswith("{")
+
+    env = runner.env_override({
         "${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID": idmap,
         "${PROJUPPER}_TEST_LIVE": "FALSE",
-        "${PROJUPPER}_TEST_EXPLAIN": "FALSE",
-        "${PROJUPPER}_APIKEY": "NONE",
+        "${PROJUPPER}_TEST_EXPLAIN": "FALSE",${apikeyEnvEntry}
     })
 
     idmap_resolved = helpers.to_map(
@@ -167,19 +205,21 @@ def _${entity.name}_basic_setup(extra):
     Content(`
     if env.get("${PROJUPPER}_TEST_LIVE") == "TRUE":
         merged_opts = vs.merge([
-            {
-                "apikey": env.get("${PROJUPPER}_APIKEY"),
+            {${apikeyLiveField}
             },
             extra or {},
         ])
         client = ${model.const.Name}SDK(helpers.to_map(merged_opts))
 
+    _live = env.get("${PROJUPPER}_TEST_LIVE") == "TRUE"
     return {
         "client": client,
         "data": entity_data,
         "idmap": idmap_resolved,
         "env": env,
         "explain": env.get("${PROJUPPER}_TEST_EXPLAIN") == "TRUE",
+        "live": _live,
+        "synthetic_only": _live and not _idmap_overridden,
         "now": int(time.time() * 1000),
     }
 `)
@@ -189,9 +229,9 @@ def _${entity.name}_basic_setup(extra):
 
 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 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)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
@@ -199,8 +239,8 @@ const generateCreate: OpGen = (ctx, step, index) => {
 
   const hasDatvar = priorSteps.some((s: any) => {
     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
@@ -229,22 +269,27 @@ const generateCreate: OpGen = (ctx, step, index) => {
 `)
   }
 
+  const hasEntIdC = null != ctx.entity.id
+
   Content(`
         ${datavar}_result, err = ${entvar}.create(${datavar}, None)
         assert err is None
         ${datavar} = helpers.to_map(${datavar}_result)
         assert ${datavar} is not None
-        assert ${datavar}["id"] is not None
 `)
+  if (hasEntIdC) {
+    Content(`        assert ${datavar}["id"] is not None
+`)
+  }
 }
 
 
 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 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)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
@@ -284,7 +329,7 @@ const generateList: OpGen = (ctx, step, index) => {
     for (const validator of step.valid) {
       const validRef = validator.def?.ref
       const hasRefData = validRef && allSteps.some((s: any) => 'create' === s.op &&
-        ((s.input?.ref ?? entity.name + '_ref01') === validRef))
+        ((s.input.ref ?? entity.name + '_ref01') === validRef))
 
       if ('ItemExists' === validator.apply && hasRefData) {
         const refDataVar = validRef + '_data'
@@ -310,17 +355,19 @@ const generateList: OpGen = (ctx, step, index) => {
 
 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 ?? ''))
-  const resdatavar = step.input?.resdatavar ?? (ref + '_resdata' + (step.input?.suffix ?? ''))
-  const markdefvar = step.input?.markdefvar ?? (ref + '_markdef' + (step.input?.suffix ?? ''))
-  const srcdatavar = step.input?.srcdatavar ?? (ref + '_data' + (step.input?.suffix ?? ''))
+  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 resdatavar = step.input.resdatavar ?? (ref + '_resdata' + (step.input.suffix ?? ''))
+  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)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
     ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
 
+  const hasEntIdU = null != entity.id
+
   Content(`        # UPDATE
 `)
   if (needsEnt) {
@@ -328,8 +375,11 @@ const generateUpdate: OpGen = (ctx, step, index) => {
 `)
   }
   Content(`        ${datavar}_up = {
-            "id": ${srcdatavar}["id"],
 `)
+  if (hasEntIdU) {
+    Content(`            "id": ${srcdatavar}["id"],
+`)
+  }
 
   if (step.data) {
     const dataEntries = Object.entries(step.data).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
@@ -344,7 +394,7 @@ const generateUpdate: OpGen = (ctx, step, index) => {
 
   if (step.spec) {
     for (const spec of step.spec) {
-      if ('TextFieldMark' === spec.apply && null != step.input?.textfield) {
+      if ('TextFieldMark' === spec.apply && null != step.input.textfield) {
         const fieldname = step.input.textfield
         const fieldvalue = spec.def?.mark ?? `Mark01-${ref}`
         Content(`
@@ -361,12 +411,15 @@ const generateUpdate: OpGen = (ctx, step, index) => {
         assert err is None
         ${resdatavar} = helpers.to_map(${resdatavar}_result)
         assert ${resdatavar} is not None
-        assert ${resdatavar}["id"] == ${datavar}_up["id"]
 `)
+  if (hasEntIdU) {
+    Content(`        assert ${resdatavar}["id"] == ${datavar}_up["id"]
+`)
+  }
 
   if (step.spec) {
     for (const spec of step.spec) {
-      if ('TextFieldMark' === spec.apply && null != step.input?.textfield) {
+      if ('TextFieldMark' === spec.apply && null != step.input.textfield) {
         Content(`        assert ${resdatavar}[${markdefvar}_name] == ${markdefvar}_value
 `)
       }
@@ -377,11 +430,11 @@ const generateUpdate: OpGen = (ctx, step, index) => {
 
 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 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)) as any[]
   const hasEntVar = priorSteps.some((s: any) =>
@@ -392,20 +445,22 @@ const generateLoad: OpGen = (ctx, step, index) => {
   const hasSrcData = (!flowHasCreate && srcdatavar === (preambleRef + '_data')) ||
     priorSteps.some((s: any) => {
       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
+
   Content(`        # LOAD
 `)
   if (!hasEntVar) {
     Content(`        ${entvar} = client.${entity.Name}(None)
 `)
   }
-  if (!hasSrcData) {
+  if (!hasSrcData && hasEntId) {
     Content(`        ${srcdatavar}_raw = vs.items(helpers.to_map(
             vs.getpath(setup["data"], "existing.${entity.name}")))
         ${srcdatavar} = None
@@ -413,7 +468,8 @@ const generateLoad: OpGen = (ctx, step, index) => {
             ${srcdatavar} = helpers.to_map(${srcdatavar}_raw[0][1])
 `)
   }
-  Content(`        ${matchvar} = {
+  if (hasEntId) {
+    Content(`        ${matchvar} = {
             "id": ${srcdatavar}["id"],
         }
         ${datavar}_loaded, err = ${entvar}.load(${matchvar}, None)
@@ -422,32 +478,50 @@ const generateLoad: OpGen = (ctx, step, index) => {
         assert ${datavar}_load_result is not None
         assert ${datavar}_load_result["id"] == ${srcdatavar}["id"]
 `)
+  }
+  else {
+    Content(`        ${matchvar} = {}
+        ${datavar}_loaded, err = ${entvar}.load(${matchvar}, None)
+        assert err is None
+        assert ${datavar}_loaded is not None
+`)
+  }
 }
 
 
 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 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)) as any[]
   const needsEnt = !priorSteps.some((s: any) =>
     ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
 
+  const hasEntIdR = null != entity.id
+
   Content(`        # REMOVE
 `)
   if (needsEnt) {
     Content(`        ${entvar} = client.${entity.Name}(None)
 `)
   }
-  Content(`        ${matchvar} = {
+  if (hasEntIdR) {
+    Content(`        ${matchvar} = {
             "id": ${srcdatavar}["id"],
         }
         _, err = ${entvar}.remove(${matchvar}, None)
         assert err is None
 `)
+  }
+  else {
+    Content(`        ${matchvar} = {}
+        _, err = ${entvar}.remove(${matchvar}, None)
+        assert err is None
+`)
+  }
 }