@voxgig/sdkgen 4.0.1 → 4.2.0

package/project/.sdk/tm/java/feature/TestFeature.java

@@ -90,11 +90,45 @@ public class TestFeature extends BaseFeature {
     }
   }
 
-  private Map<String, Object> respond(int status, Object data, Map<String, Object> extra) {
+  // THE MOCK HAS TO AGREE WITH THE MODEL.
+  //
+  // A point carrying `transform.res: `body.item`` describes an API that
+  // answers {"item": {...}}, and the response transform unwraps that key on
+  // the way back. Handing back the bare payload means the transform unwraps a
+  // property that is not there and the caller gets nothing — a mock that only
+  // ever simulates APIs whose responses happen to be unwrapped.
+  //
+  // Mirrors the go/ts/lua/php mocks, which already wrap.
+  private Object envelope(Context ctx, Object data) {
+    if (null == data || null == ctx || null == ctx.point) {
+      return data;
+    }
+    Object tm = Struct.getprop(ctx.point, "transform");
+    Object restf = Struct.getprop(tm, "res");
+    if (!(restf instanceof String)) {
+      return data;
+    }
+    String spec = (String) restf;
+    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
+    // synthesise, so it is left alone rather than guessed at.
+    if (!spec.startsWith("`body.") || !spec.endsWith("`") || spec.length() < 8) {
+      return data;
+    }
+    String inner = spec.substring(6, spec.length() - 1);
+    if (inner.isEmpty() || inner.contains(".")) {
+      return data;
+    }
+    Map<String, Object> wrapped = new LinkedHashMap<>();
+    wrapped.put(inner, data);
+    return wrapped;
+  }
+
+  private Map<String, Object> respond(Context ctx, int status, Object data, Map<String, Object> extra) {
+    Object payload = envelope(ctx, data);
     Map<String, Object> out = new LinkedHashMap<>();
     out.put("status", status);
     out.put("statusText", "OK");
-    out.put("json", (Supplier<Object>) () -> data);
+    out.put("json", (Supplier<Object>) () -> payload);
     out.put("body", "not-used");
     if (extra != null) {
       out.putAll(extra);
@@ -142,23 +176,23 @@ public class TestFeature extends BaseFeature {
       List<Object> found = Struct.select(entmap, args);
       Object ent = Struct.getelem(found, 0);
       if (ent == null) {
-        return respond(404, null, extra("statusText", "Not found"));
+        return respond(ctx, 404, null, extra("statusText", "Not found"));
       }
       Struct.delprop(ent, "$KEY");
       Object out = Struct.clone(ent);
-      return respond(200, out, null);
+      return respond(ctx, 200, out, null);
     }
     else if ("list".equals(op.name)) {
       Object args = buildArgs(ctx, op, ctx.reqmatch);
       List<Object> found = Struct.select(entmap, args);
       if (found == null) {
-        return respond(404, null, extra("statusText", "Not found"));
+        return respond(ctx, 404, null, extra("statusText", "Not found"));
       }
       for (Object item : found) {
         Struct.delprop(item, "$KEY");
       }
       Object out = Struct.clone(found);
-      return respond(200, out, null);
+      return respond(ctx, 200, out, null);
     }
     else if ("update".equals(op.name)) {
       // Match the existing entity by id only (or its alias). Reqdata
@@ -198,14 +232,14 @@ public class TestFeature extends BaseFeature {
         }
       }
       if (ent == null) {
-        return respond(404, null, extra("statusText", "Not found"));
+        return respond(ctx, 404, null, extra("statusText", "Not found"));
       }
       if (ent instanceof Map && ctx.reqdata != null) {
         ((Map<String, Object>) ent).putAll(ctx.reqdata);
       }
       Struct.delprop(ent, "$KEY");
       Object out = Struct.clone(ent);
-      return respond(200, out, null);
+      return respond(ctx, 200, out, null);
     }
     else if ("remove".equals(op.name)) {
       Object args = buildArgs(ctx, op, resolveMatch(ctx, ctx.reqmatch));
@@ -217,7 +251,7 @@ public class TestFeature extends BaseFeature {
         Object id = Struct.getprop(ent, "id", null);
         Struct.delprop(entmap, id);
       }
-      return respond(200, null, null);
+      return respond(ctx, 200, null, null);
     }
     else if ("create".equals(op.name)) {
       buildArgs(ctx, op, ctx.reqdata);
@@ -238,12 +272,12 @@ public class TestFeature extends BaseFeature {
         }
         Struct.delprop(entm, "$KEY");
         Object out = Struct.clone(entm);
-        return respond(200, out, null);
+        return respond(ctx, 200, out, null);
       }
-      return respond(200, ent, null);
+      return respond(ctx, 200, ent, null);
     }
 
-    return respond(404, null, extra("statusText", "Unknown operation"));
+    return respond(ctx, 404, null, extra("statusText", "Unknown operation"));
   }
 
   // makeNetsim wraps a transport with simulated network conditions: latency

package/project/.sdk/tm/kotlin/feature/TestFeature.kt

@@ -54,11 +54,29 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
     }
   }
 
-  private fun respond(status: Int, data: Any?, extra: MutableMap<String, Any?>?): MutableMap<String, Any?> {
+  // THE MOCK HAS TO AGREE WITH THE MODEL. A point carrying
+  // `transform.res: `body.item`` describes an API that answers {"item": {...}}
+  // and the response transform unwraps that key on the way back. Returning the
+  // bare payload means the transform unwraps a property that is not there and
+  // the caller gets nothing. Mirrors the go/ts/lua/php mocks.
+  private fun envelope(ctx: Context?, data: Any?): Any? {
+    if (null == data || null == ctx) return data
+    val tm = Struct.getprop(ctx.point, "transform")
+    val restf = Struct.getprop(tm, "res") as? String ?: return data
+    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
+    // synthesise, so it is left alone rather than guessed at.
+    if (!restf.startsWith("`body.") || !restf.endsWith("`") || restf.length < 8) return data
+    val inner = restf.substring(6, restf.length - 1)
+    if (inner.isEmpty() || inner.contains(".")) return data
+    return linkedMapOf<String, Any?>(inner to data)
+  }
+
+  private fun respond(ctx: Context?, status: Int, data: Any?, extra: MutableMap<String, Any?>?): MutableMap<String, Any?> {
+    val payload = envelope(ctx, data)
     val out = linkedMapOf<String, Any?>()
     out["status"] = status
     out["statusText"] = "OK"
-    out["json"] = Supplier<Any?> { data }
+    out["json"] = Supplier<Any?> { payload }
     out["body"] = "not-used"
     if (extra != null) {
       out.putAll(extra)
@@ -102,11 +120,11 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
         val found = Struct.select(entmap, args)
         val ent = Struct.getelem(found, 0, null)
         if (ent == null) {
-          return respond(404, null, extra("statusText", "Not found"))
+          return respond(ctx, 404, null, extra("statusText", "Not found"))
         }
         Struct.delprop(ent, "\$KEY")
         val out = Struct.clone(ent)
-        return respond(200, out, null)
+        return respond(ctx, 200, out, null)
       }
       "list" -> {
         val args = buildArgs(ctx, op, ctx.reqmatch)
@@ -115,7 +133,7 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
           Struct.delprop(item, "\$KEY")
         }
         val out = Struct.clone(found)
-        return respond(200, out, null)
+        return respond(ctx, 200, out, null)
       }
       "update" -> {
         // Match the existing entity by id only (or its alias).
@@ -148,14 +166,14 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
           }
         }
         if (ent == null) {
-          return respond(404, null, extra("statusText", "Not found"))
+          return respond(ctx, 404, null, extra("statusText", "Not found"))
         }
         if (ent is MutableMap<*, *>) {
           (ent as MutableMap<String, Any?>).putAll(reqdata)
         }
         Struct.delprop(ent, "\$KEY")
         val out = Struct.clone(ent)
-        return respond(200, out, null)
+        return respond(ctx, 200, out, null)
       }
       "remove" -> {
         val args = buildArgs(ctx, op, resolveMatch(ctx, ctx.reqmatch))
@@ -166,7 +184,7 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
           val id = Struct.getprop(ent, "id", null)
           Struct.delprop(entmap, id)
         }
-        return respond(200, null, null)
+        return respond(ctx, 200, null, null)
       }
       "create" -> {
         buildArgs(ctx, op, ctx.reqdata)
@@ -189,13 +207,13 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
           }
           Struct.delprop(entm, "\$KEY")
           val out = Struct.clone(entm)
-          return respond(200, out, null)
+          return respond(ctx, 200, out, null)
         }
-        return respond(200, ent, null)
+        return respond(ctx, 200, ent, null)
       }
     }
 
-    return respond(404, null, extra("statusText", "Unknown operation"))
+    return respond(ctx, 404, null, extra("statusText", "Unknown operation"))
   }
 
   // makeNetsim wraps a transport with simulated network conditions.

package/project/.sdk/tm/lean/src/SdkRuntime.lean

@@ -205,6 +205,23 @@ def liveFetcher : SdkFeature.Fetcher := fun _ctx url fetchdef => do
                       ("body", json), ("headers", ← emptyMap)]
   pure (resp, none)
 
+/-- THE MOCK HAS TO AGREE WITH THE MODEL. A point carrying
+    `transform.res: `body.item`` describes an API that answers {"item": {...}}
+    and the response transform unwraps that key on the way back. Returning the
+    bare payload means the transform unwraps a property that is not there and
+    the caller gets nothing. Mirrors the go/ts/lua/php mocks. -/
+def mockEnvelope (ctx : Value) (data : Value) : SIO Value := do
+  if isNv data then pure data else do
+    let tm ← gp (← gp ctx "point") "transform"
+    let spec := asStr (← gp tm "res")
+    -- Exactly `body.<key>`; a deeper path is not an envelope this mock can
+    -- synthesise, so it is left alone rather than guessed at.
+    if spec.startsWith "`body." && spec.endsWith "`" && spec.length > 7 then
+      let inner := ((spec.drop 6).dropRight 1).toString
+      if inner.isEmpty || inner.contains '.' then pure data
+      else newMap #[(inner, data)]
+    else pure data
+
 /-- The base transport in test mode: answer from the seeded store. -/
 def testFetcher : SdkFeature.Fetcher := fun ctx _url _fetchdef => do
   let client ← gp ctx "client"
@@ -213,8 +230,9 @@ def testFetcher : SdkFeature.Fetcher := fun ctx _url _fetchdef => do
   let matchV ← gp ctx "reqmatch"
   let dataV ← gp ctx "reqdata"
   let out ← mockOp client entityName opName matchV dataV
+  let payload ← mockEnvelope ctx out
   let resp ← newMap #[("status", .num 200.0), ("statusText", .str "OK"),
-                      ("body", out), ("headers", ← emptyMap)]
+                      ("body", payload), ("headers", ← emptyMap)]
   pure (resp, none)
 
 /-- Merge config.feature and options.feature into the client's feature options. -/

package/project/.sdk/tm/lean/src/SdkUtility.lean

@@ -595,8 +595,6 @@ def makeResult (ctx : Value) : SIO Value := do
   sp ctx "result" res
   pure res
 
-/-- Select the endpoint for this operation: the single point, else the first
-    whose `select.exist` keys are all present and whose `$action` agrees. -/
 /-- How many path segments a point has, and whether its path ends in a
     parameter. A record route ends in the record's identifier (/boards/{id});
     a cross-reference that also returns the entity ends in the relationship's
@@ -611,6 +609,8 @@ def pointShape (pt : Value) : SIO (Nat × Bool) := do
     else pure (items.size, (vs items[items.size - 1]!).startsWith "{")
   | _ => pure (0, false)
 
+/-- Select the endpoint for this operation: the single point, else the first
+    whose `select.exist` keys are all present and whose `$action` agrees. -/
 def makePoint (ctx : Value) : SIO Value := do
   let op ← gp ctx "op"
   let matchV ← gp ctx "reqmatch"

package/project/.sdk/tm/ocaml/sdk_features.ml

@@ -980,8 +980,27 @@ let netsim_feature () : feature =
 let test_feature () : feature =
   let f = { f_name = "test"; f_version = "0.0.1"; f_active = true; f_options = Noval;
             f_init = (fun _ _ -> ()); f_hook = (fun _ _ -> ()) } in
-  let respond status data extra =
-    let out = jo [("status", vint_of status); ("statusText", Str "OK"); ("json", json_thunk data); ("body", Str "not-used")] in
+  (* THE MOCK HAS TO AGREE WITH THE MODEL. A point carrying
+     `transform.res: `body.item`` describes an API that answers {"item": {...}}
+     and the response transform unwraps that key on the way back. Returning the
+     bare payload means the transform unwraps a property that is not there and
+     the caller gets nothing. Mirrors the go/ts/lua/php mocks. *)
+  let envelope ctx data =
+    if is_nullish data then data
+    else
+      match getp (getp ctx.c_point "transform") "res" with
+      | Str spec ->
+        let n = String.length spec in
+        (* Exactly `body.<key>`; a deeper path is not an envelope this mock
+           can synthesise, so it is left alone rather than guessed at. *)
+        if n > 7 && String.sub spec 0 6 = "`body." && spec.[n - 1] = '`' then
+          let inner = String.sub spec 6 (n - 7) in
+          if String.length inner = 0 || String.contains inner '.' then data
+          else jo [(inner, data)]
+        else data
+      | _ -> data in
+  let respond ctx status data extra =
+    let out = jo [("status", vint_of status); ("statusText", Str "OK"); ("json", json_thunk (envelope ctx data)); ("body", Str "not-used")] in
     (match extra with Some (Map _ as e) -> List.iter (fun k -> setp out k (getp e k)) (keysof e) | _ -> ());
     (out, None) in
   let build_args ctx (op : operation) args =
@@ -1027,15 +1046,15 @@ let test_feature () : feature =
        | "load" ->
          let args = build_args fctx op (resolve_match fctx fctx.c_reqmatch) in
          let ent = getelem (select entmap args) (Num 0.0) in
-         if is_nullish ent then respond 404 Noval (Some (jo [("statusText", Str "Not found")]))
-         else (ignore (delprop ent (Str "$KEY")); respond 200 (clone ent) None)
+         if is_nullish ent then respond fctx 404 Noval (Some (jo [("statusText", Str "Not found")]))
+         else (ignore (delprop ent (Str "$KEY")); respond fctx 200 (clone ent) None)
        | "list" ->
          let args = build_args fctx op fctx.c_reqmatch in
          let found = select entmap args in
-         if is_nullish found then respond 404 Noval (Some (jo [("statusText", Str "Not found")]))
+         if is_nullish found then respond fctx 404 Noval (Some (jo [("statusText", Str "Not found")]))
          else begin
            (match found with List r -> List.iter (fun item -> ignore (delprop item (Str "$KEY"))) !r | _ -> ());
-           respond 200 (clone found) None
+           respond fctx 200 (clone found) None
          end
        | "update" ->
          let update_match = empty_map () in
@@ -1046,17 +1065,17 @@ let test_feature () : feature =
          (if is_nullish !ent then match entmap with
            | Map m -> (try (match List.find (fun (_, v) -> match v with Map _ -> true | _ -> false) m.entries with (_, v) -> ent := v) with Not_found -> ())
            | _ -> ());
-         if is_nullish !ent then respond 404 Noval (Some (jo [("statusText", Str "Not found")]))
+         if is_nullish !ent then respond fctx 404 Noval (Some (jo [("statusText", Str "Not found")]))
          else begin
            (match !ent with Map _ -> (match fctx.c_reqdata with Map _ -> List.iter (fun k -> setp !ent k (getp fctx.c_reqdata k)) (keysof fctx.c_reqdata) | _ -> ()) | _ -> ());
            ignore (delprop !ent (Str "$KEY"));
-           respond 200 (clone !ent) None
+           respond fctx 200 (clone !ent) None
          end
        | "remove" ->
          let args = build_args fctx op (resolve_match fctx fctx.c_reqmatch) in
          let ent = getelem (select entmap args) (Num 0.0) in
          (match ent with Map _ -> ignore (delprop entmap (getp ent "id")) | _ -> ());
-         respond 200 Noval None
+         respond fctx 200 Noval None
        | "create" ->
          ignore (build_args fctx op fctx.c_reqdata);
          let eid = let v = (cu fctx).u_param fctx (Str "id") in if is_nullish v then Str (random_id16 ()) else v in
@@ -1066,9 +1085,9 @@ let test_feature () : feature =
             setp ent "id" eid;
             (match eid with Str s -> setp entmap s ent | _ -> ());
             ignore (delprop ent (Str "$KEY"));
-            respond 200 (clone ent) None
-          | _ -> respond 200 ent None)
-       | _ -> respond 404 Noval (Some (jo [("statusText", Str "Unknown operation")]))) in
+            respond fctx 200 (clone ent) None
+          | _ -> respond fctx 200 ent None)
+       | _ -> respond fctx 404 Noval (Some (jo [("statusText", Str "Unknown operation")]))) in
   let make_netsim net inner =
     let netcalls = ref 0 in
     let pick_latency () =

package/project/.sdk/tm/perl/feature/test_feature.pm

@@ -51,12 +51,34 @@ sub init {
 
   my $test_self = $self;
 
+  # THE MOCK HAS TO AGREE WITH THE MODEL. A point carrying
+  # `transform.res: `body.item`` describes an API that answers {"item": {...}}
+  # and the response transform unwraps that key on the way back. Returning the
+  # bare payload means the transform unwraps a property that is not there and
+  # the caller gets nothing. Mirrors the go/ts/lua/php mocks.
+  #
+  # Takes the PER-REQUEST context: the point is resolved per call, so the
+  # init-time $ctx this closure would otherwise capture is the wrong one.
+  my $envelope = sub {
+    my ($fctx, $data) = @_;
+    return $data unless defined $data;
+    return $data unless defined $fctx && defined $fctx->{point};
+    my $tm = ProjectNameHelpers::gp($fctx->{point}, 'transform');
+    my $spec = ProjectNameHelpers::gp($tm, 'res');
+    return $data unless defined $spec && !ref($spec);
+    # Exactly `body.<key>`; a deeper path is not an envelope this mock can
+    # synthesise, so it is left alone rather than guessed at.
+    return $data unless $spec =~ /^`body\.([^`.]+)`$/;
+    return { $1 => $data };
+  };
+
   my $respond = sub {
-    my ($status, $data, $extra) = @_;
+    my ($fctx, $status, $data, $extra) = @_;
+    my $payload = $envelope->($fctx, $data);
     my $out = {
       'status' => $status,
       'statusText' => 'OK',
-      'json' => sub { $data },
+      'json' => sub { $payload },
       'body' => 'not-used',
     };
     if (Voxgig::Struct::ismap($extra)) {
@@ -92,22 +114,22 @@ sub init {
       my $args = $test_self->build_args($fctx, $op, $resolve_match->($fctx->{reqmatch}));
       my $found = Voxgig::Struct::select($entmap, $args);
       my $ent = ProjectNameHelpers::ge($found, 0);
-      return $respond->(404, undef, { 'statusText' => 'Not found' })
+      return $respond->($fctx, 404, undef, { 'statusText' => 'Not found' })
         unless ProjectNameHelpers::rb_truthy($ent);
       Voxgig::Struct::delprop($ent, '$KEY');
       my $out = Voxgig::Struct::clone($ent);
-      return $respond->(200, $out, undef);
+      return $respond->($fctx, 200, $out, undef);
     }
     elsif ('list' eq $op->{name}) {
       my $args = $test_self->build_args($fctx, $op, $fctx->{reqmatch});
       my $found = Voxgig::Struct::select($entmap, $args);
-      return $respond->(404, undef, { 'statusText' => 'Not found' })
+      return $respond->($fctx, 404, undef, { 'statusText' => 'Not found' })
         unless defined $found && !Voxgig::Struct::is_none($found);
       if (Voxgig::Struct::islist($found)) {
         Voxgig::Struct::delprop($_, '$KEY') for @$found;
       }
       my $out = Voxgig::Struct::clone($found);
-      return $respond->(200, $out, undef);
+      return $respond->($fctx, 200, $out, undef);
     }
     elsif ('update' eq $op->{name}) {
       # Match the existing entity by id only (or its alias). reqdata also
@@ -138,14 +160,14 @@ sub init {
           }
         }
       }
-      return $respond->(404, undef, { 'statusText' => 'Not found' })
+      return $respond->($fctx, 404, undef, { 'statusText' => 'Not found' })
         unless ProjectNameHelpers::rb_truthy($ent);
       if (Voxgig::Struct::ismap($ent) && $fctx->{reqdata}) {
         $ent->{$_} = $fctx->{reqdata}{$_} for keys %{ $fctx->{reqdata} };
       }
       Voxgig::Struct::delprop($ent, '$KEY');
       my $out = Voxgig::Struct::clone($ent);
-      return $respond->(200, $out, undef);
+      return $respond->($fctx, 200, $out, undef);
     }
     elsif ('remove' eq $op->{name}) {
       my $args = $test_self->build_args($fctx, $op, $resolve_match->($fctx->{reqmatch}));
@@ -157,7 +179,7 @@ sub init {
         my $id = ProjectNameHelpers::gp($ent, 'id');
         Voxgig::Struct::delprop($entmap, $id);
       }
-      return $respond->(200, undef, undef);
+      return $respond->($fctx, 200, undef, undef);
     }
     elsif ('create' eq $op->{name}) {
       $test_self->build_args($fctx, $op, $fctx->{reqdata});
@@ -172,12 +194,12 @@ sub init {
         $entmap->{"$id"} = $ent if defined $id && !ref $id;
         Voxgig::Struct::delprop($ent, '$KEY');
         my $out = Voxgig::Struct::clone($ent);
-        return $respond->(200, $out, undef);
+        return $respond->($fctx, 200, $out, undef);
       }
-      return $respond->(200, $ent, undef);
+      return $respond->($fctx, 200, $ent, undef);
     }
     else {
-      return $respond->(404, undef, { 'statusText' => 'Unknown operation' });
+      return $respond->($fctx, 404, undef, { 'statusText' => 'Unknown operation' });
     }
   };
 

package/project/.sdk/tm/py-data/test/conftest.py

@@ -0,0 +1,24 @@
+# Make the suite runnable with a bare `make test`, the way every other
+# target's is.
+#
+# py-data is the one target that CONSUMES a sibling: its package imports the
+# ProjectName SDK generated into ../py of the same repo. The Makefile's `dev`
+# target pip-installs both editable, but `test` does not depend on it, so
+# `make test` on a fresh clone died in collection with
+# "ModuleNotFoundError: No module named 'projectname_sdk'" — before a single
+# assertion ran.
+#
+# Requiring an install step would also make this target the only one that
+# cannot be tested from a clean checkout. Putting the two source roots on
+# sys.path keeps it self-contained; an installed copy still wins, because
+# these entries are appended only when the import is not already satisfiable.
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_here = Path(__file__).resolve().parent
+for _root in (_here.parent, _here.parent.parent / "py"):
+    _p = str(_root)
+    if _root.is_dir() and _p not in sys.path:
+        sys.path.insert(0, _p)

package/project/.sdk/tm/rust/feature/test.rs

@@ -33,11 +33,40 @@ impl TestFeature {
     }
 }
 
-fn respond(status: i64, data: Value, extra: Vec<(&str, Value)>) -> Value {
+// THE MOCK HAS TO AGREE WITH THE MODEL.
+//
+// A point carrying `transform.res: `body.item`` describes an API that answers
+// {"item": {...}}, and the response transform unwraps that key on the way
+// back. Handing back the bare payload means the transform unwraps a property
+// that is not there, and the caller gets nothing — a mock that only ever
+// simulates APIs whose responses happen to be unwrapped.
+//
+// univec's list op declares `body.data`, so every list returned zero items
+// while the fixture plainly held two. Mirrors the go/ts/lua/php mocks, which
+// already wrap; rust, c and zig were the three that did not.
+fn envelope(ctx: &Rc<Context>, data: Value) -> Value {
+    if data.is_noval() || data.is_null() {
+        return data;
+    }
+    let restf = crate::core::helpers::getpath(&["transform", "res"], &ctx.point.borrow());
+    if let Value::Str(spec) = restf {
+        // Exactly `body.<key>` — a deeper path is not an envelope this mock
+        // can synthesise, so it is left alone rather than guessed at.
+        if let Some(inner) = spec.strip_prefix("`body.").and_then(|r| r.strip_suffix('`')) {
+            if !inner.is_empty() && !inner.contains('.') {
+                return jo(vec![(inner, data)]);
+            }
+        }
+    }
+    data
+}
+
+fn respond(ctx: &Rc<Context>, status: i64, data: Value, extra: Vec<(&str, Value)>) -> Value {
+    let payload = envelope(ctx, data);
     let out = jo(vec![
         ("status", Value::Num(status as f64)),
         ("statusText", Value::str("OK")),
-        ("json", json_thunk(data)),
+        ("json", json_thunk(payload)),
         ("body", Value::str("not-used")),
     ]);
     for (k, v) in extra {
@@ -150,22 +179,20 @@ fn test_fetch(
             let found = vs::select(&entmap, &args);
             let ent = vs::get_elem(&found, &Value::Num(0.0), Value::Noval);
             if ent.is_noval() || ent.is_null() {
-                return Ok(respond(
-                    404,
+                return Ok(respond(ctx, 404,
                     Value::Noval,
                     vec![("statusText", Value::str("Not found"))],
                 ));
             }
             vs::del_prop(ent.clone(), &Value::str("$KEY"));
-            Ok(respond(200, vs::clone(&ent), vec![]))
+            Ok(respond(ctx, 200, vs::clone(&ent), vec![]))
         }
 
         "list" => {
             let args = build_args(ctx, &ctx.reqmatch.borrow().clone());
             let found = vs::select(&entmap, &args);
             if found.is_noval() || found.is_null() {
-                return Ok(respond(
-                    404,
+                return Ok(respond(ctx, 404,
                     Value::Noval,
                     vec![("statusText", Value::str("Not found"))],
                 ));
@@ -175,7 +202,7 @@ fn test_fetch(
                     vs::del_prop(item.clone(), &Value::str("$KEY"));
                 }
             }
-            Ok(respond(200, vs::clone(&found), vec![]))
+            Ok(respond(ctx, 200, vs::clone(&found), vec![]))
         }
 
         "update" => {
@@ -214,8 +241,7 @@ fn test_fetch(
                 }
             }
             if ent.is_noval() || ent.is_null() {
-                return Ok(respond(
-                    404,
+                return Ok(respond(ctx, 404,
                     Value::Noval,
                     vec![("statusText", Value::str("Not found"))],
                 ));
@@ -228,7 +254,7 @@ fn test_fetch(
                 }
             }
             vs::del_prop(ent.clone(), &Value::str("$KEY"));
-            Ok(respond(200, vs::clone(&ent), vec![]))
+            Ok(respond(ctx, 200, vs::clone(&ent), vec![]))
         }
 
         "remove" => {
@@ -242,7 +268,7 @@ fn test_fetch(
                 let id = getp(&ent, "id");
                 vs::del_prop(entmap, &id);
             }
-            Ok(respond(200, Value::Noval, vec![]))
+            Ok(respond(ctx, 200, Value::Noval, vec![]))
         }
 
         "create" => {
@@ -265,13 +291,12 @@ fn test_fetch(
                     setp(&entmap, id_str, ent.clone());
                 }
                 vs::del_prop(ent.clone(), &Value::str("$KEY"));
-                return Ok(respond(200, vs::clone(&ent), vec![]));
+                return Ok(respond(ctx, 200, vs::clone(&ent), vec![]));
             }
-            Ok(respond(200, ent, vec![]))
+            Ok(respond(ctx, 200, ent, vec![]))
         }
 
-        _ => Ok(respond(
-            404,
+        _ => Ok(respond(ctx, 404,
             Value::Noval,
             vec![("statusText", Value::str("Unknown operation"))],
         )),