@voxgig/sdkgen 4.34.0 → 4.34.2

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

@@ -15,6 +15,8 @@ import {
   serverVarEnv,
   serverVariables, envName, envToken,
   pointParts,
+  liveStrict,
+  liveStrictNote,
 } from '@voxgig/sdkgen'
 
 
@@ -56,6 +58,17 @@ function normalizePathParams(
 }
 
 
+// Blocked without the ids its request needs, rather than sent with None.
+function liveKeysBlock(keys: string[], entidEnvVar: string): string {
+  return 0 === keys.length ? '' : `        if setup["live"]:
+            for _live_key in [${keys.map((k) => JSON.stringify(k)).join(', ')}]:
+                if setup["idmap"].get(_live_key) is None:
+                    runner.live_miss(LIVE_STRICT, f"Live test blocked: needs {_live_key} via ${entidEnvVar}")
+
+`
+}
+
+
 const TestDirect = cmp(function TestDirect(props: any) {
   const ctx$ = props.ctx$
   const model: Model = ctx$.model
@@ -145,6 +158,10 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   const entidEnvVar = `${PROJECTNAME}_TEST_${envToken(entity.name)}_ENTID`
 
+  // The *_ENTID key a live test reads a parameter's value from.
+  const liveKey = (param: any): string =>
+    ('id' === param.n ? entity.name : param.n.replace(/_id$/, '')) + '01'
+
   File({ name: 'test_' + entity.name + '_direct.' + target.ext }, () => {
 
     Content(`# ${entity.Name} direct test
@@ -158,27 +175,21 @@ from ${model.const.Name.toLowerCase()}_sdk.core import helpers
 from test import runner
 
 
+${liveStrictNote(liveStrict(model, target.name), '#')}
+LIVE_STRICT = ${liveStrict(model, target.name) ? 'True' : 'False'}
+
+
+def _live_ok(result):
+    status = helpers.to_int(result.get("status"))
+    return result.get("err") is None and bool(result.get("ok")) and 200 <= status < 300
+
+
 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.n === 'id'
-          ? entity.name + '01'
-          : lp.n.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
-
-`
-        : ''
+      const listLiveIdKeys: string[] = listParams.map(liveKey)
       Content(`    def test_should_direct_list_${entity.name}(self):
         setup = _${entity.name}_direct_setup([
             {"id": "direct01"},
@@ -186,57 +197,30 @@ class Test${entity.Name}Direct:
         ])
         _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"]
-
-`)
+${liveKeysBlock(listLiveIdKeys, entidEnvVar)}        client = setup["client"]
 
-      if (listParams.length > 0) {
-        Content(`        params = {}
+        params = {}
 `)
-        for (const lp of listParams) {
-          const key = lp.n === 'id'
-            ? entity.name + '01'
-            : lp.n.replace(/_id$/, '') + '01'
-          Content(`        if setup["live"]:
-            params["${lp.n}"] = setup["idmap"]["${key}"]
+      listParams.forEach((lp: any, i: number) => {
+        Content(`        if setup["live"]:
+            params["${lp.n}"] = setup["idmap"].get("${liveKey(lp)}")
         else:
-            params["${lp.n}"] = "direct01"
+            params["${lp.n}"] = "direct0${i + 1}"
 `)
-        }
-        Content(`
+      })
+      Content(`
         result = client.direct({
             "path": "${listPath}",
             "method": "GET",
             "params": params,
         })
-`)
-      } else {
-        Content(`
-        result = client.direct({
-            "path": "${listPath}",
-            "method": "GET",
-            "params": {},
-        })
-`)
-      }
-
-      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 result.get("err") is not None:
-                pytest.skip(f"list call failed (likely synthetic IDs against live API): {result.get('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
+        if setup["live"]:
+            if not _live_ok(result):
+                runner.live_miss(LIVE_STRICT, "Live list failed: " + runner.live_describe(result))
+            if runner.live_list(result.get("data")) is None:
+                runner.live_miss(LIVE_STRICT, "Live list returned no list: " + runner.live_describe(result))
         else:
             assert result["ok"] is True
             assert helpers.to_int(result["status"]) == 200
@@ -248,90 +232,75 @@ ${listSkipBlock}        client = setup["client"]
     }
 
     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
-
-`
-        : ''
+      const discover = !loadAllHaveExamples && hasList && 0 < loadParams.length
+      const idParam = loadParams.find((p: any) => 'id' === p.n)?.n ?? loadParams[0]?.n ?? 'id'
+      const loadLiveIdKeys: string[] = loadAllHaveExamples ? [] :
+        discover ? listParams.map(liveKey).concat(loadParams.filter((p: any) => idParam !== p.n).map(liveKey)) :
+          loadParams.map(liveKey)
       Content(`    def test_should_direct_load_${entity.name}(self):
         setup = _${entity.name}_direct_setup({"id": "direct01"})
         _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"]
+${liveKeysBlock([...new Set(loadLiveIdKeys)], entidEnvVar)}        client = setup["client"]
 
-`)
-
-      const needsQuery = loadParams.length > 0 || loadLiveQueryLines !== ''
-      if (needsQuery) {
-        Content(`        params = {}
+        params = {}
         query = {}
+        if setup["live"]:
+${loadLiveQueryLines ? loadLiveQueryLines + '\n' : ''}`)
+      if (loadAllHaveExamples) {
+        Content(loadExampleLines + '\n')
+      }
+      else if (discover) {
+        Content(`            list_result = client.direct({
+                "path": "${listPath}",
+                "method": "GET",
+                "params": {${listParams.map((p: any) => `"${p.n}": setup["idmap"].get("${liveKey(p)}")`).join(', ')}},
+            })
+            if not _live_ok(list_result):
+                runner.live_miss(LIVE_STRICT, "Live list discovery failed: " + runner.live_describe(list_result))
+            records = runner.live_list(list_result.get("data"))
+            if records is None:
+                runner.live_miss(LIVE_STRICT, "Live list discovery returned no list: " + runner.live_describe(list_result))
+            if 0 == len(records):
+                runner.live_empty("The account has no ${entity.name} record to load")
+            first = records[0] if isinstance(records[0], dict) else {}
+            if first.get("${idParam}", first.get("id")) is None:
+                runner.live_miss(LIVE_STRICT, "Live load blocked: discovery returned no usable identity")
+            params["${idParam}"] = first.get("${idParam}", first.get("id"))
 `)
-        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].n}"] = "direct0${i + 1}"
+        for (const p of loadParams.filter((p: any) => idParam !== p.n)) {
+          Content(`            params["${p.n}"] = setup["idmap"].get("${liveKey(p)}")
 `)
-          }
-        } else if (loadParams.length > 0) {
-          if (loadLiveQueryLines) {
-            Content(`        if setup["live"]:
-${loadLiveQueryLines}
-`)
-          }
-          Content(`        if not setup["live"]:
+        }
+      }
+      else {
+        for (const p of loadParams) {
+          Content(`            params["${p.n}"] = setup["idmap"].get("${liveKey(p)}")
 `)
-          for (let i = 0; i < loadParams.length; i++) {
-            Content(`            params["${loadParams[i].n}"] = "direct0${i + 1}"
+        }
+      }
+      Content(`            pass
+        else:
 `)
-          }
-        } else if (loadLiveQueryLines) {
-          // Required-query only, no path params.
-          Content(`        if setup["live"]:
-${loadLiveQueryLines}
+      for (let i = 0; i < loadParams.length; i++) {
+        Content(`            params["${loadParams[i].n}"] = "direct0${i + 1}"
 `)
-        }
       }
+      Content(`            pass
 
-      Content(`
         result = client.direct({
             "path": "${loadPath}",
             "method": "GET",
-`)
-      if (needsQuery) {
-        Content(`            "params": params,
+            "params": params,
             "query": query,
-`)
-      } else {
-        Content(`            "params": {},
-`)
-      }
-      Content(`        })
+        })
         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 result.get("err") is not None:
-                pytest.skip(f"load call failed (likely synthetic IDs against live API): {result.get('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
+            if not _live_ok(result):
+                runner.live_miss(LIVE_STRICT, "Live load failed: " + runner.live_describe(result))
+            if result.get("data") is None:
+                runner.live_miss(LIVE_STRICT, "Live load returned no data: " + runner.live_describe(result))
         else:
             assert result["ok"] is True
             assert helpers.to_int(result["status"]) == 200
@@ -364,11 +333,12 @@ def _${entity.name}_direct_setup(mockres):
         merged_opts.update({${apikeyLiveField}${serverLiveField}
         })
         client = ${model.const.Name}SDK(merged_opts)
+        idmap = env.get("${entidEnvVar}")
         return {
             "client": client,
             "calls": calls,
             "live": True,
-            "idmap": {},
+            "idmap": idmap if isinstance(idmap, dict) else {},
         }
 
     def mock_fetch(url, init):

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

@@ -1,4 +1,4 @@
-import { flowSteps } from '@voxgig/sdkgen'
+import { flowSteps, opReachable } from '@voxgig/sdkgen'
 
 import {
   flatten,
@@ -27,10 +27,41 @@ import {
   isAuthActive,
   serverVarEnv,
   serverVariables,
-  entityDataIdField, envName, envToken
+  entityDataIdField, envName, envToken,
+  invalidRequest,
+  liveFlowNeeds, liveStrict, liveStrictNote,
 } from '@voxgig/sdkgen'
 
 
+// The live prologue of a flow built from offline fixtures: blocked without
+// the ids it binds, and a create-less load reading the first listed record.
+function liveFlowGate(entity: any, needs: any, entidEnv: string): string {
+  let out = ''
+  if (0 < needs.keys.length) {
+    out += `        if setup["live"]:
+            for _live_key in [${needs.keys.map((k: string) => JSON.stringify(k)).join(', ')}]:
+                if setup.get("synthetic_only") or setup["idmap"].get(_live_key) is None:
+                    runner.live_miss(LIVE_STRICT, f"Live entity test blocked: needs {_live_key} via ${entidEnv}")
+`
+  }
+  if (null != needs.blocked) {
+    out += `        if setup["live"]:
+            runner.live_miss(LIVE_STRICT, "Live entity test blocked: " + ${JSON.stringify(needs.blocked)})
+`
+  }
+  out += '        client = setup["client"]\n'
+  if (null != needs.discover) {
+    const match = Object.entries(needs.discover)
+      .map(([k, v]: any) => `${JSON.stringify(k)}: setup["idmap"].get(${JSON.stringify(v)})`).join(', ')
+    out += `        if setup["live"]:
+            runner.live_existing(setup, LIVE_STRICT, ${JSON.stringify(entity.name)},
+                                 lambda: client.${entity.Name}(None).list({${match}}, None))
+`
+  }
+  return out
+}
+
+
 // See TestEntity_ts.ts for the GenCtx/OpGen contract.
 type GenCtx = {
   model: Model
@@ -95,11 +126,15 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
   const genCtx: GenCtx = { model, entity, flow: basicflow, PROJUPPER }
 
-  // The stream test streams the "list" op and asserts a 3-item collection, so
-  // it only applies to entities that actually declare a `list` op. Others
-  // (e.g. Batch = create/load) have no list endpoint — make_point would error
-  // and the stream would yield nothing — so skip the test for them.
-  const hasList = !!(entity.op && (entity.op as any)?.list)
+  const strict = liveStrict(model, target.name)
+  const needs = liveFlowNeeds(entity, basicflow)
+  const entidEnv = PROJUPPER + '_TEST_' + envToken(entity.name) + '_ENTID'
+
+  // The stream test streams the "list" op with no match and asserts a 3-item
+  // collection, so it only applies to an entity whose list a bare call can
+  // reach: not one without a list (e.g. Batch = create/load), not a nested
+  // list needing its parent's id, and not one whose routes all need an action.
+  const hasList = opReachable((entity.op as any)?.list, [])
 
   File({ name: 'test_' + entity.name + '_entity.' + target.ext }, () => {
 
@@ -114,9 +149,16 @@ import pytest
 from ${model.const.Name.toLowerCase()}_sdk.utility.voxgig_struct import voxgig_struct as vs
 from ${model.const.Name.toLowerCase()}_sdk import ${model.const.Name}SDK
 from ${model.const.Name.toLowerCase()}_sdk.core import helpers
+from ${model.const.Name.toLowerCase()}_sdk.config import shared_config
+from ${model.const.Name.toLowerCase()}_sdk.feature.base_feature import ${model.const.Name}BaseFeature
 
 _TEST_DIR = os.path.dirname(os.path.abspath(__file__))
 from test import runner
+${hasList ? failHookClass(model, entity) : ''}
+
+
+${liveStrictNote(strict, '#')}
+LIVE_STRICT = ${strict ? 'True' : 'False'}
 
 
 class Test${entity.Name}Entity:
@@ -159,8 +201,8 @@ ${hasList ? `
                 else:
                     got.append(item)
             assert len(got) == 3
-` : ''}
-    def test_should_run_basic_flow(self):
+${failureTests(model, entity)}` : ''}${validateTest(model, entity)}
+${strict ? '' : `    @runner.live_observe("${PROJUPPER}_TEST_LIVE", LIVE_STRICT)\n`}    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
@@ -171,13 +213,7 @@ ${hasList ? `
             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_${envToken(entity.name)}_ENTID JSON to run live")
-        client = setup["client"]
-
+${liveFlowGate(entity, needs, entidEnv)}
 `)
 
     // Check if the flow has a create step
@@ -216,7 +252,7 @@ def _${entity.name}_basic_setup(extra):
     runner.load_env_local()
 
     entity_data_file = os.path.join(_TEST_DIR, "../../.sdk/test/entity/${entity.name}/${entity.Name}TestData.json")
-    with open(entity_data_file, "r") as f:
+    with open(entity_data_file, "r", encoding="utf-8") as f:
         entity_data_source = f.read()
 
     entity_data = json.loads(entity_data_source)
@@ -242,9 +278,8 @@ def _${entity.name}_basic_setup(extra):
 
 `)
 
-    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.
+    Content(`    # Whether *_ENTID supplied the idmap, read before env_override consumes
+    # it: without it, the ids a live flow binds are the fixture's synthetic ones.
     _entid_env_raw = os.environ.get(
         "${PROJUPPER}_TEST_${envToken(entity.name)}_ENTID")
     _idmap_overridden = _entid_env_raw is not None and _entid_env_raw.strip().startswith("{")
@@ -591,6 +626,97 @@ const GENERATE_OP: Record<string, OpGen> = {
 }
 
 
+// A feature whose PreSpec hook raises, counting the PreUnexpected calls it sees.
+function failHookClass(model: Model, entity: ModelEntity): string {
+  return `
+
+class _FailHook(${model.const.Name}BaseFeature):
+    def __init__(self):
+        super().__init__()
+        self.name = "failhook"
+        self.unexpected = 0
+
+    def init(self, ctx, options):
+        pass
+
+    def PreSpec(self, ctx):
+        raise RuntimeError("${entity.name} hook failed")
+
+    def PreUnexpected(self, ctx):
+        self.unexpected += 1
+`
+}
+
+
+// A failed operation raises from a stream as it does from the operation: a
+// transport failure, and a hook that rejects the call. A raising hook fires
+// PreUnexpected. The caller's ctrl stays its own.
+function failureTests(model: Model, entity: ModelEntity): string {
+  const Name = model.const.Name
+  const Entity = entity.Name
+  return `
+    def test_should_report_a_failed_stream(self):
+        offline = {"net": {"offline": True}}
+        with pytest.raises(Exception, match="offline"):
+            list(${Name}SDK.test(offline, None).${Entity}(None).stream("list", None, None))
+
+        quiet = {"ctrl": {"throw": False}}
+        list(${Name}SDK.test(offline, None).${Entity}(None).stream("list", None, quiet))
+
+        if "rbac" in (shared_config().get("feature") or {}):
+            denied = ${Name}SDK.test(
+                None, {"feature": {"rbac": {"active": True, "deny": True}}})
+            with pytest.raises(Exception) as err:
+                list(denied.${Entity}(None).stream("list", None, None))
+            assert "rbac_denied" == getattr(err.value, "code", None)
+
+    def test_should_leave_the_callers_ctrl(self):
+        explain = {}
+        ctrl = {"explain": explain}
+        list(${Name}SDK.test(None, None).${Entity}(None).stream("list", None, {"ctrl": ctrl}))
+        assert ["explain"] == list(ctrl.keys())
+        assert explain is ctrl["explain"] and 0 < len(explain)
+
+    def test_should_fire_pre_unexpected(self):
+        hook = _FailHook()
+        client = ${Name}SDK({"feature": {"test": {"active": True}}, "extend": [hook]})
+        with pytest.raises(Exception, match="hook failed"):
+            client.${Entity}(None).list(None, None)
+        assert 0 < hook.unexpected
+
+        fired = hook.unexpected
+        assert client.${Entity}(None).list(None, {"throw": False}) is None
+        assert fired < hook.unexpected
+`
+}
+
+
+// An invalid request fails with validate's own error, before it is sent.
+function validateTest(model: Model, entity: ModelEntity): string {
+  const bad = invalidRequest(entity)
+  if (null == bad) {
+    return ''
+  }
+  const args = Object.entries(bad.args)
+    .map(([k, v]) => JSON.stringify(k) + ': ' + pyLit(v)).join(', ')
+  return `
+    def test_should_refuse_an_invalid_request(self):
+        if "validate" not in (shared_config().get("feature") or {}):
+            pytest.skip("feature not present in this SDK: validate")
+        client = ${model.const.Name}SDK.test(
+            None, {"feature": {"validate": {"active": True}}})
+        with pytest.raises(Exception) as err:
+            client.${entity.Name}(None).${bad.op}({${args}}, None)
+        assert "validate_failed" == getattr(err.value, "code", None)
+`
+}
+
+
+function pyLit(v: any): string {
+  return true === v ? 'True' : false === v ? 'False' : JSON.stringify(v)
+}
+
+
 export {
   TestEntity
 }

package/project/.sdk/src/cmp/py/fragment/Entity.fragment.py

@@ -120,43 +120,13 @@ class EntyClass:
         # The pipeline runs as the caller iterates, so its errors leave
         # through the same catch path as an operation's.
         try:
-            utility.feature_hook(ctx, "PrePoint")
-            point, err = utility.make_point(ctx)
-            ctx.out["point"] = point
-            if err is not None:
-                return
-
-            utility.feature_hook(ctx, "PreSpec")
-            spec, err = utility.make_spec(ctx)
-            ctx.out["spec"] = spec
-            if err is not None:
-                return
-
-            utility.feature_hook(ctx, "PreRequest")
-            resp, err = utility.make_request(ctx)
-            ctx.out["request"] = resp
-            if err is not None:
-                return
-
-            utility.feature_hook(ctx, "PreResponse")
-            resp2, err = utility.make_response(ctx)
-            ctx.out["response"] = resp2
-            if err is not None:
-                return
-
-            utility.feature_hook(ctx, "PreResult")
-            result, err = utility.make_result(ctx)
-            ctx.out["result"] = result
-            if err is not None:
-                return
-
-            utility.feature_hook(ctx, "PreDone")
-
+            failed = self._stream_steps(ctx)
             result = ctx.result
 
             # Inbound: prefer the streaming feature's incremental generator;
             # else fall back to the materialised items so stream always yields.
-            stream_fn = getattr(result, "stream", None) if result is not None else None
+            stream_fn = getattr(result, "stream", None) \
+                if failed is None and result is not None else None
             if callable(stream_fn):
                 # done() does not run on this path, so its record is cleaned here.
                 utility.clean_explain(ctx)
@@ -165,7 +135,9 @@ class EntyClass:
                         return
                     yield item
             else:
-                data = utility.done(ctx)
+                # A failed step leaves through make_error, as an operation's does.
+                data = utility.done(ctx) if failed is None \
+                    else utility.make_error(ctx, failed)
                 if isinstance(data, list):
                     items = data
                 elif data is None:
@@ -177,8 +149,51 @@ class EntyClass:
                         return
                     yield item
         except Exception as err:
-            self._unexpected(ctx, err)
-            raise
+            # What a hook raises here must not escape the cleaning below.
+            try:
+                utility.feature_hook(ctx, "PreUnexpected")
+            except Exception as hookerr:
+                err = hookerr
+            if self._unexpected(ctx, err) is not None:
+                raise err from None
+
+    # The steps an operation runs, with their hooks; the first that fails
+    # hands back its error.
+    def _stream_steps(self, ctx):
+        utility = self._utility
+
+        utility.feature_hook(ctx, "PrePoint")
+        point, err = utility.make_point(ctx)
+        ctx.out["point"] = point
+        if err is not None:
+            return err
+
+        utility.feature_hook(ctx, "PreSpec")
+        spec, err = utility.make_spec(ctx)
+        ctx.out["spec"] = spec
+        if err is not None:
+            return err
+
+        utility.feature_hook(ctx, "PreRequest")
+        resp, err = utility.make_request(ctx)
+        ctx.out["request"] = resp
+        if err is not None:
+            return err
+
+        utility.feature_hook(ctx, "PreResponse")
+        resp2, err = utility.make_response(ctx)
+        ctx.out["response"] = resp2
+        if err is not None:
+            return err
+
+        utility.feature_hook(ctx, "PreResult")
+        result, err = utility.make_result(ctx)
+        ctx.out["result"] = result
+        if err is not None:
+            return err
+
+        utility.feature_hook(ctx, "PreDone")
+        return None
 
     # #LoadOp
 
@@ -188,6 +203,8 @@ class EntyClass:
 
     # #UpdateOp
 
+    # #PatchOp
+
     # #RemoveOp
 
     def _run_op(self, ctx, post_done):
@@ -257,14 +274,14 @@ class EntyClass:
             try:
                 # #PreUnexpected-Hook
             except Exception as hookerr:
-                self._unexpected(ctx, hookerr)
-                raise hookerr from None
-
-            self._unexpected(ctx, err)
-            raise
+                err = hookerr
+            if self._unexpected(ctx, err) is None:
+                return None
+            raise err from None
 
     # An error a hook raised never passed through make_error: it is cleaned,
-    # and so is the explain record it interrupted.
+    # and so is the explain record it interrupted. None when the caller
+    # switched throwing off.
     def _unexpected(self, ctx, err):
         clean = self._utility.clean
         explain = ctx.ctrl.explain
@@ -276,3 +293,6 @@ class EntyClass:
             elif explain["err"].get("message") != cleanerr.get("message"):
                 explain["unexpected"] = cleanerr
         clean(ctx, err)
+        if ctx.ctrl.throw_err is False:
+            return None
+        return err