@voxgig/sdkgen 4.0.1 → 4.2.0

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

@@ -40,8 +40,31 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
     else ctx.utility.fetcher = makeNetsim(net, testFetcher)
   }
 
-  private def respond(status: Int, data: Object, extra: JMap[String, Object]): JMap[String, Object] = {
-    val js: Supplier[Object] = () => data
+  // 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 def envelope(ctx: Context, data: Object): Object = {
+    if (data == null || ctx == null || ctx.point == null) return data
+    val tm = Struct.getprop(ctx.point, "transform")
+    Struct.getprop(tm, "res") match {
+      case spec: String =>
+        // 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
+        val inner = spec.substring(6, spec.length - 1)
+        if (inner.isEmpty || inner.contains(".")) return data
+        val wrapped = new java.util.LinkedHashMap[String, Object]()
+        wrapped.put(inner, data)
+        wrapped
+      case _ => data
+    }
+  }
+
+  private def respond(ctx: Context, status: Int, data: Object, extra: JMap[String, Object]): JMap[String, Object] = {
+    val payload = envelope(ctx, data)
+    val js: Supplier[Object] = () => payload
     val out = new LinkedHashMap[String, Object]()
     out.put("status", java.lang.Integer.valueOf(status))
     out.put("statusText", "OK")
@@ -85,18 +108,18 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
       val args = buildArgs(ctx, op, resolveMatch(ctx, ctx.reqmatch))
       val found = Struct.select(entmap, args)
       val ent = Struct.getelem(found, java.lang.Integer.valueOf(0))
-      if (ent == null) return respond(404, null, extra("statusText", "Not found"))
+      if (ent == null) return respond(ctx, 404, null, extra("statusText", "Not found"))
       Struct.delprop(ent, "$KEY")
       val out = Struct.clone(ent)
-      respond(200, out, null)
+      respond(ctx, 200, out, null)
     } else if ("list" == op.name) {
       val args = buildArgs(ctx, op, ctx.reqmatch)
       val found = Struct.select(entmap, args)
-      if (found == null) return respond(404, null, extra("statusText", "Not found"))
+      if (found == null) return respond(ctx, 404, null, extra("statusText", "Not found"))
       val it = found.iterator()
       while (it.hasNext) Struct.delprop(it.next(), "$KEY")
       val out = Struct.clone(found)
-      respond(200, out, null)
+      respond(ctx, 200, out, null)
     } else if ("update" == op.name) {
       var updateMatch = new LinkedHashMap[String, Object]()
       if (ctx.reqdata != null) {
@@ -119,11 +142,11 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
           vit.next() match { case e: JMap[_, _] => ent = e; brk = true; case _ => }
         }
       }
-      if (ent == null) return respond(404, null, extra("statusText", "Not found"))
+      if (ent == null) return respond(ctx, 404, null, extra("statusText", "Not found"))
       ent match { case m: JMap[_, _] if ctx.reqdata != null => m.asInstanceOf[JMap[String, Object]].putAll(ctx.reqdata); case _ => }
       Struct.delprop(ent, "$KEY")
       val out = Struct.clone(ent)
-      respond(200, out, null)
+      respond(ctx, 200, out, null)
     } else if ("remove" == op.name) {
       val args = buildArgs(ctx, op, resolveMatch(ctx, ctx.reqmatch))
       val found = Struct.select(entmap, args)
@@ -134,7 +157,7 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
           Struct.delprop(entmap, id)
         case _ =>
       }
-      respond(200, null, null)
+      respond(ctx, 200, null, null)
     } else if ("create" == op.name) {
       buildArgs(ctx, op, ctx.reqdata)
       var id = ctx.utility.param(ctx, "id")
@@ -153,11 +176,11 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
           id match { case s: String => entmap.put(s, entm); case _ => }
           Struct.delprop(entm, "$KEY")
           val out = Struct.clone(entm)
-          respond(200, out, null)
-        case _ => respond(200, ent, null)
+          respond(ctx, 200, out, null)
+        case _ => respond(ctx, 200, ent, null)
       }
     } else {
-      respond(404, null, extra("statusText", "Unknown operation"))
+      respond(ctx, 404, null, extra("statusText", "Unknown operation"))
     }
   }
 

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/TestFeature.swift

@@ -5,11 +5,32 @@
 
 import Foundation
 
-private func testRespond(_ status: Int, _ data: Value, _ extra: VMap?) -> 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. 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 func testEnvelope(_ ctx: Context, _ data: Value) -> Value {
+  if case .noval = data { return data }
+  if case .null = data { return data }
+  guard let point = ctx.point else { return data }
+  guard case .map(let tm)? = point.entries["transform"] else { return data }
+  guard case .string(let spec)? = tm.entries["res"] else { 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.
+  guard spec.hasPrefix("`body."), spec.hasSuffix("`"), spec.count >= 8 else { return data }
+  let inner = String(spec.dropFirst(6).dropLast(1))
+  guard !inner.isEmpty, !inner.contains(".") else { return data }
+  let wrapped = VMap()
+  wrapped.entries[inner] = data
+  return .map(wrapped)
+}
+
+private func testRespond(_ ctx: Context, _ status: Int, _ data: Value, _ extra: VMap?) -> Value {
   let res = VMap()
   res.entries["status"] = .int(Int64(status))
   res.entries["statusText"] = .string("OK")
-  let captured = data
+  let captured = testEnvelope(ctx, data)
   res.entries["json"] = .nat({ () -> Value in captured } as NativeCall0)
   res.entries["body"] = .string("not-used")
   if let extra = extra {
@@ -151,22 +172,22 @@ public final class TestFeature: BaseFeature {
         if isNil(ent) {
           let extra = VMap()
           extra.entries["statusText"] = .string("Not found")
-          return testRespond(404, .noval, extra)
+          return testRespond(ctx2, 404, .noval, extra)
         }
         delprop(ent, .string("$KEY"))
-        return testRespond(200, clone(ent), nil)
+        return testRespond(ctx2, 200, clone(ent), nil)
       } else if op.name == "list" {
         let args = testBuildArgs(ctx2, op, ctx2.reqmatch)
         let found = select(.map(entmap), args)
         if isNil(found) {
           let extra = VMap()
           extra.entries["statusText"] = .string("Not found")
-          return testRespond(404, .noval, extra)
+          return testRespond(ctx2, 404, .noval, extra)
         }
         if let fl = found.asList {
           for item in fl.items { delprop(item, .string("$KEY")) }
         }
-        return testRespond(200, clone(found), nil)
+        return testRespond(ctx2, 200, clone(found), nil)
       } else if op.name == "update" {
         var updateMatch = VMap()
         if let idv = ctx2.reqdata.entries["id"] {
@@ -188,13 +209,13 @@ public final class TestFeature: BaseFeature {
         if isNil(ent) {
           let extra = VMap()
           extra.entries["statusText"] = .string("Not found")
-          return testRespond(404, .noval, extra)
+          return testRespond(ctx2, 404, .noval, extra)
         }
         if let entm = ent.asMap {
           for (k, v) in ctx2.reqdata.entries { entm.entries[k] = v }
         }
         delprop(ent, .string("$KEY"))
-        return testRespond(200, clone(ent), nil)
+        return testRespond(ctx2, 200, clone(ent), nil)
       } else if op.name == "remove" {
         let args = testBuildArgs(ctx2, op, testResolveMatch(ctx2, ctx2.reqmatch))
         let found = select(.map(entmap), args)
@@ -203,7 +224,7 @@ public final class TestFeature: BaseFeature {
           let id = gp(entm2, "id")
           delprop(.map(entmap), id)
         }
-        return testRespond(200, .noval, nil)
+        return testRespond(ctx2, 200, .noval, nil)
       } else if op.name == "create" {
         _ = testBuildArgs(ctx2, op, ctx2.reqdata)
         var id = ctx2.utility!.param(ctx2, .string("id"))
@@ -218,14 +239,14 @@ public final class TestFeature: BaseFeature {
           entm.entries["id"] = id
           if let idStr = id.asString { entmap.entries[idStr] = .map(entm) }
           delprop(.map(entm), .string("$KEY"))
-          return testRespond(200, clone(.map(entm)), nil)
+          return testRespond(ctx2, 200, clone(.map(entm)), nil)
         }
-        return testRespond(200, ent, nil)
+        return testRespond(ctx2, 200, ent, nil)
       }
 
       let extra = VMap()
       extra.entries["statusText"] = .string("Unknown operation")
-      return testRespond(404, .noval, extra)
+      return testRespond(ctx2, 404, .noval, extra)
     }
 
     // Optional network behaviour simulation over the mock transport.

package/project/.sdk/tm/zig/feature/test.zig

@@ -93,11 +93,38 @@ fn fixIds(_: Allocator, key: ?[]const u8, val: Value, _: Value, path: []const []
     return val;
 }
 
-fn respond(status: i64, data: Value, extra: []const h.Pair) 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: *Context, data: Value) Value {
+    if (data == .undef or data == .null) return data;
+    const restf = h.getpath(&.{ "transform", "res" }, ctx.point);
+    if (restf != .string) return data;
+    const spec = restf.string;
+    // 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.len < 8) return data;
+    if (!std.mem.startsWith(u8, spec, "`body.")) return data;
+    if (!std.mem.endsWith(u8, spec, "`")) return data;
+    const inner = spec[6 .. spec.len - 1];
+    if (inner.len == 0) return data;
+    if (std.mem.indexOfScalar(u8, inner, '.') != null) return data;
+    return h.jo(&.{.{ inner, data }});
+}
+
+fn respond(ctx: *Context, status: i64, data: Value, extra: []const h.Pair) Value {
     const out = h.jo(&.{
         .{ "status", h.vnum(status) },
         .{ "statusText", h.vstr("OK") },
-        .{ "json", h.json_thunk(data) },
+        .{ "json", h.json_thunk(envelope(ctx, data)) },
         .{ "body", h.vstr("not-used") },
     });
     for (extra) |kv| h.setp(out, kv[0], kv[1]);
@@ -182,20 +209,20 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
         const found = vs.select(h.A(), entmap, args) catch h.olist();
         const ent = h.get_elem(found, h.vnum(0), h.vnull());
         if (h.is_noval(ent)) {
-            return respond(404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
+            return respond(ctx, 404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
         }
         h.del_prop(ent, h.vstr("$KEY"));
-        return respond(200, h.clone(ent), &.{});
+        return respond(ctx, 200, h.clone(ent), &.{});
     } else if (std.mem.eql(u8, op.name, "list")) {
         const args = build_args(ctx, ctx.reqmatch);
         const found = vs.select(h.A(), entmap, args) catch h.olist();
         if (h.is_noval(found)) {
-            return respond(404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
+            return respond(ctx, 404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
         }
         if (found == .array) {
             for (found.array.data.items) |item| h.del_prop(item, h.vstr("$KEY"));
         }
-        return respond(200, h.clone(found), &.{});
+        return respond(ctx, 200, h.clone(found), &.{});
     } else if (std.mem.eql(u8, op.name, "update")) {
         const reqdata = ctx.reqdata;
         var update_match = h.omap();
@@ -221,14 +248,14 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
             }
         }
         if (h.is_noval(ent)) {
-            return respond(404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
+            return respond(ctx, 404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
         }
         if (ent == .object and reqdata == .object) {
             var it = reqdata.object.iterator();
             while (it.next()) |kv| h.setp(ent, kv.key_ptr.*, kv.value_ptr.*);
         }
         h.del_prop(ent, h.vstr("$KEY"));
-        return respond(200, h.clone(ent), &.{});
+        return respond(ctx, 200, h.clone(ent), &.{});
     } else if (std.mem.eql(u8, op.name, "remove")) {
         const m = resolve_match(ctx, ctx.reqmatch);
         const args = build_args(ctx, m);
@@ -238,7 +265,7 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
             const id = h.getp(ent, "id");
             h.del_prop(entmap, id);
         }
-        return respond(200, h.vnull(), &.{});
+        return respond(ctx, 200, h.vnull(), &.{});
     } else if (std.mem.eql(u8, op.name, "create")) {
         _ = build_args(ctx, ctx.reqdata);
         var id = ctx.util().param(ctx, h.vstr("id"));
@@ -255,12 +282,12 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
             h.setp(ent, "id", id);
             if (id == .string) h.setp(entmap, id.string, ent);
             h.del_prop(ent, h.vstr("$KEY"));
-            return respond(200, h.clone(ent), &.{});
+            return respond(ctx, 200, h.clone(ent), &.{});
         }
-        return respond(200, ent, &.{});
+        return respond(ctx, 200, ent, &.{});
     }
 
-    return respond(404, h.vnull(), &.{.{ "statusText", h.vstr("Unknown operation") }});
+    return respond(ctx, 404, h.vnull(), &.{.{ "statusText", h.vstr("Unknown operation") }});
 }
 
 // make_netsim (test-local): counter-driven latency / first-N failures /

package/project/sdkgen-package.json

@@ -3,7 +3,7 @@
     "package": 1
   },
   "name": "@voxgig/sdkgen",
-  "version": "4.0.1",
+  "version": "4.2.0",
   "provides": {
     "target": [
       "c",