@voxgig/sdkgen 4.1.0 → 4.2.0

package/bin/voxgig-sdkgen

@@ -8,7 +8,7 @@ const { Shape, One, Skip } = require('shape')
 
 const { SdkGen } = require('../dist/sdkgen.js')
 
-const VERSION = '4.1.0'
+const VERSION = '4.2.0'
 const KONSOLE = console
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxgig/sdkgen",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "main": "dist/sdkgen.js",
   "type": "commonjs",
   "engines": {

package/project/.sdk/src/cmp/scala/TestDirect_scala.ts

@@ -118,7 +118,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
 import java.util.{ArrayList, LinkedHashMap, List => JList, Map => JMap}
 import java.util.function.{BiFunction, Supplier}
 
-import ${scalapackage}.core.{Helpers, ${SDK}}
+import ${scalapackage}.core.{Helpers, SdkEntity, ${SDK}}
 
 object ${EntityName}DirectTest {
 

package/project/.sdk/src/cmp/scala/TestEntity_scala.ts

@@ -90,7 +90,7 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
 import java.util.{ArrayList, LinkedHashMap, List => JList, Map => JMap}
 
-import ${scalapackage}.core.{Helpers, ${SDK}}
+import ${scalapackage}.core.{Helpers, SdkEntity, ${SDK}}
 import ${scalapackage}.utility.struct.Struct
 
 object ${EntityName}EntityTest {

package/project/.sdk/tm/clojure/src/sdk/features.clj

@@ -104,9 +104,27 @@
                                  val))
                (let [test-fetcher
                      (fn [fctx _fullurl _fetchdef]
-                       (let [respond (fn [status data extra]
-                                       (let [out (vs/jm "status" status "statusText" "OK"
-                                                        "json" (fn [] data) "body" "not-used")]
+                       ;; 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. `fctx` is in
+                       ;; scope here, so the point is the one being served.
+                       (let [envelope (fn [data]
+                                        (let [tm (vs/getprop (core/oget fctx :point) "transform")
+                                              spec (vs/getprop tm "res")]
+                                          ;; Exactly `body.<key>`; a deeper path is not an
+                                          ;; envelope this mock can synthesise.
+                                          (if (and (some? data) (string? spec))
+                                            (if-let [m (re-matches #"`body\.([^`.]+)`" spec)]
+                                              (vs/jm (second m) data)
+                                              data)
+                                            data)))
+                             respond (fn [status data extra]
+                                       (let [payload (envelope data)
+                                             out (vs/jm "status" status "statusText" "OK"
+                                                        "json" (fn [] payload) "body" "not-used")]
                                          (when extra (doseq [item (or (vs/items extra) [])]
                                                        (.put ^java.util.Map out (vs/getprop item 0) (vs/getprop item 1))))
                                          [out nil]))

package/project/.sdk/tm/cpp/Makefile

@@ -10,6 +10,16 @@ CXXFLAGS ?= -std=c++17 -O0 -g -Wall -Wextra -Wno-unused-parameter -pthread
 TEST_SRCS := $(wildcard test/*.cpp)
 TEST_BINS := $(TEST_SRCS:.cpp=.out)
 
+# REBUILD WHEN A HEADER CHANGES. The runtime is header-only, so a test binary
+# depends on far more than its own .cpp — but the pattern rule below names
+# only that .cpp, so make happily reused a stale .out after every change to
+# core/, feature/, entity/ or utility/. A real fix to the mock transport read
+# as "still failing" through several rebuilds because the binary under test
+# predated it. Listing the headers is cheap and makes `make test` mean what it
+# says.
+SDK_HDRS := $(wildcard core/*.hpp entity/*.hpp feature/*.hpp \
+                       utility/*.hpp utility/*/*.hpp *.hpp)
+
 .PHONY: test build clean
 
 build: $(TEST_BINS)
@@ -23,7 +33,7 @@ test: build
 	if [ $$fail -ne 0 ]; then echo "SOME TESTS FAILED"; exit 1; fi; \
 	echo "ALL TESTS PASSED"
 
-test/%.out: test/%.cpp
+test/%.out: test/%.cpp $(SDK_HDRS)
 	$(CXX) $(CXXFLAGS) $< -o $@
 
 clean:

package/project/.sdk/tm/dart/lib/feature/test/TestFeature.dart

@@ -38,12 +38,40 @@ class TestFeature extends BaseFeature {
 
     final self = this;
 
-    dynamic respond(int status, [dynamic data, dynamic res]) {
+    // 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.
+    dynamic envelope(dynamic fctx, dynamic data) {
+      if (null == data || null == fctx || null == fctx.point) {
+        return data;
+      }
+      // dart wraps the point in a Point OBJECT (Context._aspoint), so its
+      // fields are typed properties, not map keys — vs.getprop on it returns
+      // null and the envelope silently never applies.
+      final tm = fctx.point.transform;
+      final spec = vs.getprop(tm, 'res');
+      if (spec is! 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.
+      final m = RegExp(r'^`body\.([^`.]+)`$').firstMatch(spec);
+      if (null == m) {
+        return data;
+      }
+      return <String, dynamic>{m.group(1)!: data};
+    }
+
+    dynamic respond(dynamic fctx, int status, [dynamic data, dynamic res]) {
+      final payload = envelope(fctx, data);
       final out = vs.merge([
         <String, dynamic>{
           'status': status,
           'statusText': 'OK',
-          'json': () => data,
+          'json': () => payload,
           'body': 'not-used',
         },
         vs.getdef(res, {}),
@@ -66,30 +94,30 @@ class TestFeature extends BaseFeature {
         final found = vs.select(entmap, args);
         final ent = vs.getelem(found, 0);
         if (null == ent) {
-          return respond(404, null, {'statusText': S_NOT_FOUND});
+          return respond(fctx, 404, null, {'statusText': S_NOT_FOUND});
         } else {
           vs.delprop(ent, r'$KEY');
           final out = vs.clone(ent);
-          return respond(200, out);
+          return respond(fctx, 200, out);
         }
       } else if ('list' == op.name) {
         final args = self.buildArgs(fctx, op, fctx.reqmatch);
         final found = vs.select(entmap, args);
         if (null == found) {
-          return respond(404, null, {'statusText': S_NOT_FOUND});
+          return respond(fctx, 404, null, {'statusText': S_NOT_FOUND});
         } else {
           for (final ent in found) {
             vs.delprop(ent, r'$KEY');
           }
           final out = vs.clone(found);
-          return respond(200, out);
+          return respond(fctx, 200, out);
         }
       } else if ('update' == op.name) {
         final args = self.buildArgs(fctx, op, fctx.reqdata);
         final found = vs.select(entmap, args);
         final ent = vs.getelem(found, 0);
         if (null == ent) {
-          return respond(404, null, {'statusText': S_NOT_FOUND});
+          return respond(fctx, 404, null, {'statusText': S_NOT_FOUND});
         } else {
           // Dart's single null stands in for the donor's undefined: merge
           // must not overwrite stored values with absent ones.
@@ -104,7 +132,7 @@ class TestFeature extends BaseFeature {
           vs.merge([ent, upddata]);
           vs.delprop(ent, r'$KEY');
           final out = vs.clone(ent);
-          return respond(200, out);
+          return respond(fctx, 200, out);
         }
       } else if ('remove' == op.name) {
         final args = self.buildArgs(fctx, op, fctx.reqmatch);
@@ -115,7 +143,7 @@ class TestFeature extends BaseFeature {
         if (null != ent) {
           vs.delprop(entmap, vs.getprop(ent, 'id'));
         }
-        return respond(200);
+        return respond(fctx, 200);
       } else if ('create' == op.name) {
         self.buildArgs(fctx, op, fctx.reqdata);
         dynamic id = param(fctx, 'id');
@@ -130,7 +158,7 @@ class TestFeature extends BaseFeature {
         vs.setprop(entmap, id, ent);
         vs.delprop(ent, r'$KEY');
         final out = vs.clone(ent);
-        return respond(200, out);
+        return respond(fctx, 200, out);
       }
 
       return null;

package/project/.sdk/tm/elixir/lib/projectname/feature/test.ex

@@ -285,7 +285,7 @@ defmodule ProjectName.Feature.Test do
           netsleep.(pick_latency(net))
           status = H.or_(S.getprop(net, "failStatus"), 503)
 
-          respond(status, nil,
+          respond(fctx, status, nil,
             S.jm(["statusText", "Simulated Failure", "headers", S.jm([])]))
 
         true ->

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/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/swift/Sources/ProjectNameSDK/feature/TestFeature.swift

@@ -172,22 +172,22 @@ public final class TestFeature: BaseFeature {
         if isNil(ent) {
           let extra = VMap()
           extra.entries["statusText"] = .string("Not found")
-          return testRespond(ctx, 404, .noval, extra)
+          return testRespond(ctx2, 404, .noval, extra)
         }
         delprop(ent, .string("$KEY"))
-        return testRespond(ctx, 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(ctx, 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(ctx, 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"] {
@@ -209,13 +209,13 @@ public final class TestFeature: BaseFeature {
         if isNil(ent) {
           let extra = VMap()
           extra.entries["statusText"] = .string("Not found")
-          return testRespond(ctx, 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(ctx, 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)
@@ -224,7 +224,7 @@ public final class TestFeature: BaseFeature {
           let id = gp(entm2, "id")
           delprop(.map(entmap), id)
         }
-        return testRespond(ctx, 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"))
@@ -239,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(ctx, 200, clone(.map(entm)), nil)
+          return testRespond(ctx2, 200, clone(.map(entm)), nil)
         }
-        return testRespond(ctx, 200, ent, nil)
+        return testRespond(ctx2, 200, ent, nil)
       }
 
       let extra = VMap()
       extra.entries["statusText"] = .string("Unknown operation")
-      return testRespond(ctx, 404, .noval, extra)
+      return testRespond(ctx2, 404, .noval, extra)
     }
 
     // Optional network behaviour simulation over the mock transport.

package/project/sdkgen-package.json

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