@voxgig/sdkgen 1.3.14 → 1.3.18

package/project/.sdk/src/cmp/zig/TestEntity_zig.ts

@@ -0,0 +1,79 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+import { zigVarName } from './utility_zig'
+
+
+// Per-entity model-driven smoke tests. Emits `test "..."` blocks INTO the
+// shared generated_test.zig file (opened by Test_zig) — zig's build.zig uses
+// an explicit test-file list, so every generated test must live in that one
+// file rather than a per-entity file (the go/rust one-file-per-entity layout
+// relies on cargo/go auto-discovery, which zig lacks). Each test drives the
+// entity through the full pipeline via the offline `test` transport and
+// asserts a non-error result. `std`, `sdk`, `h`, `Value` and `vnull()` are in
+// scope from the Test_zig header.
+const TestEntity = cmp(function TestEntity(props: any) {
+  const { target, entity } = props
+
+  const method = zigVarName(entity.name)
+  const ops = entity.op || {}
+
+  if (ops.load) {
+    Content(`
+test "${method}_load_smoke" {
+    const fixture = h.jo(&.{.{ "${entity.name}", h.jo(&.{.{ "t01", h.jo(&.{.{ "id", h.vstr("t01") }}) }}) }});
+    const testsdk = sdk.test_sdk(h.jo(&.{.{ "entity", fixture }}), vnull());
+    const e = testsdk.${method}(vnull());
+    const res = e.load(h.jo(&.{.{ "id", h.vstr("t01") }}), vnull());
+    switch (res) {
+        .ok => |data| {
+            try std.testing.expect(std.mem.eql(u8, h.get_str(data, "id") orelse "", "t01"));
+        },
+        .err => |er| {
+            std.debug.print("${method} load failed: {s}\\n", .{er.msg});
+            try std.testing.expect(false);
+        },
+    }
+}
+`)
+  }
+
+  if (ops.list) {
+    Content(`
+test "${method}_list_smoke" {
+    const fixture = h.jo(&.{.{ "${entity.name}", h.jo(&.{.{ "t01", h.jo(&.{.{ "id", h.vstr("t01") }}) }}) }});
+    const testsdk = sdk.test_sdk(h.jo(&.{.{ "entity", fixture }}), vnull());
+    const e = testsdk.${method}(vnull());
+    const res = e.list(vnull(), vnull());
+    try std.testing.expect(res == .ok);
+}
+
+test "${method}_stream_smoke" {
+    // stream() runs the list op through the full pipeline and returns the
+    // result items. Seed two entities via test mode; with the streaming
+    // feature active it yields the feature's incremental items, else it falls
+    // back to the materialised items — either way every item is yielded.
+    const fixture = h.jo(&.{.{ "${entity.name}", h.jo(&.{
+        .{ "strm01", h.jo(&.{.{ "id", h.vstr("strm01") }}) },
+        .{ "strm02", h.jo(&.{.{ "id", h.vstr("strm02") }}) },
+    }) }});
+    const sdkopts = h.jo(&.{.{ "feature", h.jo(&.{.{ "streaming", h.jo(&.{.{ "active", h.vbool(true) }}) }}) }});
+    const testsdk = sdk.test_sdk(h.jo(&.{.{ "entity", fixture }}), sdkopts);
+    const e = testsdk.${method}(vnull());
+    const items = e.stream("list", vnull(), vnull());
+    try std.testing.expect(items.len == 2);
+
+    // Fallback: streaming inactive still yields both materialised items.
+    const plainsdk = sdk.test_sdk(h.jo(&.{.{ "entity", fixture }}), vnull());
+    const pe = plainsdk.${method}(vnull());
+    const pitems = pe.stream("list", vnull(), vnull());
+    try std.testing.expect(pitems.len == 2);
+}
+`)
+  }
+})
+
+
+export {
+  TestEntity
+}

package/project/.sdk/src/cmp/zig/Test_zig.ts

@@ -10,15 +10,22 @@ import type {
 
 import { cmp, each, Folder, File, Content } from '@voxgig/sdkgen'
 
-import { zigVarName } from './utility_zig'
+import { TestEntity } from './TestEntity_zig'
+import { TestDirect } from './TestDirect_zig'
+import { ReadmeExamplesTest } from './ReadmeExamplesTest_zig'
 
 
 // Generated tests. The bulk of behavioural coverage lives in the hand-written
 // template suite (test/*.zig, copied verbatim): the struct corpus, the
-// pipeline, every feature, and the cross-language gotchas. Here we emit a
-// model-driven smoke test per entity that drives the full pipeline
-// (point -> spec -> request -> mock -> response -> result) through the
-// offline `test` transport.
+// pipeline, every feature, and the cross-language gotchas. Here we emit the
+// model-driven smoke tests.
+//
+// zig's build.zig picks up an EXPLICIT test-file list, so every generated test
+// must land in the single `test/generated_test.zig` file it already lists —
+// the per-entity generators (TestEntity, TestDirect) and the readme-examples
+// gate all emit their `test` blocks INTO this one open File rather than opening
+// their own (the go/rust one-file-per-entity split relies on auto-discovery
+// zig does not have).
 const Test = cmp(function Test(props: any) {
   const { model } = props.ctx$
   const { target } = props
@@ -47,63 +54,12 @@ test "sdk_constructs_in_test_mode" {
 `)
 
       each(entity, (ent: ModelEntity) => {
-        const method = zigVarName(ent.name)
-        const ops = ent.op || {}
-
-        if (ops.load) {
-          Content(`
-test "${method}_load_smoke" {
-    const fixture = h.jo(&.{.{ "${ent.name}", h.jo(&.{.{ "t01", h.jo(&.{.{ "id", h.vstr("t01") }}) }}) }});
-    const testsdk = sdk.test_sdk(h.jo(&.{.{ "entity", fixture }}), vnull());
-    const e = testsdk.${method}(vnull());
-    const res = e.load(h.jo(&.{.{ "id", h.vstr("t01") }}), vnull());
-    switch (res) {
-        .ok => |data| {
-            try std.testing.expect(std.mem.eql(u8, h.get_str(data, "id") orelse "", "t01"));
-        },
-        .err => |er| {
-            std.debug.print("${method} load failed: {s}\\n", .{er.msg});
-            try std.testing.expect(false);
-        },
-    }
-}
-`)
-        }
-
-        if (ops.list) {
-          Content(`
-test "${method}_list_smoke" {
-    const fixture = h.jo(&.{.{ "${ent.name}", h.jo(&.{.{ "t01", h.jo(&.{.{ "id", h.vstr("t01") }}) }}) }});
-    const testsdk = sdk.test_sdk(h.jo(&.{.{ "entity", fixture }}), vnull());
-    const e = testsdk.${method}(vnull());
-    const res = e.list(vnull(), vnull());
-    try std.testing.expect(res == .ok);
-}
-
-test "${method}_stream_smoke" {
-    // stream() runs the list op through the full pipeline and returns the
-    // result items. Seed two entities via test mode; with the streaming
-    // feature active it yields the feature's incremental items, else it falls
-    // back to the materialised items — either way every item is yielded.
-    const fixture = h.jo(&.{.{ "${ent.name}", h.jo(&.{
-        .{ "strm01", h.jo(&.{.{ "id", h.vstr("strm01") }}) },
-        .{ "strm02", h.jo(&.{.{ "id", h.vstr("strm02") }}) },
-    }) }});
-    const sdkopts = h.jo(&.{.{ "feature", h.jo(&.{.{ "streaming", h.jo(&.{.{ "active", h.vbool(true) }}) }}) }});
-    const testsdk = sdk.test_sdk(h.jo(&.{.{ "entity", fixture }}), sdkopts);
-    const e = testsdk.${method}(vnull());
-    const items = e.stream("list", vnull(), vnull());
-    try std.testing.expect(items.len == 2);
-
-    // Fallback: streaming inactive still yields both materialised items.
-    const plainsdk = sdk.test_sdk(h.jo(&.{.{ "entity", fixture }}), vnull());
-    const pe = plainsdk.${method}(vnull());
-    const pitems = pe.stream("list", vnull(), vnull());
-    try std.testing.expect(pitems.len == 2);
-}
-`)
-        }
+        TestEntity({ target, entity: ent })
+        TestDirect({ target, entity: ent })
       })
+
+      // Validate the documented zig quick-start examples run.
+      ReadmeExamplesTest({ target })
     })
   })
 })

package/project/.sdk/tm/clojure/src/voxgig/struct.clj

@@ -1534,7 +1534,7 @@
                   (.add ^List (ig inj :errs) (_invalidTypeMsg (ig inj :path) (typename ptype) ctype cval "V0020"))
                   (let [ckeys (keysof cval) pkeys (keysof pval)]
                     (if (and (> (count pkeys) 0) (not (true? (getprop pval "`$OPEN`"))))
-                      (let [badkeys (clojure.core/filter #(not (haskey pval %)) ckeys)]
+                      (let [badkeys (clojure.core/filter #(not (and (instance? Map pval) (.containsKey ^Map pval (str %)))) ckeys)]
                         (when (> (size badkeys) 0)
                           (.add ^List (ig inj :errs)
                                 (str "Unexpected keys at field " (pathify (ig inj :path) 1) S-VIZ (join (alist-of badkeys) ", ")))))

package/project/.sdk/tm/cpp/test/feature_test.cpp

@@ -10,6 +10,25 @@
 
 #include "harness.hpp"
 
+// The enterprise feature classes exercised below. Every feature header is
+// shipped with the runtime; blocks whose feature is absent from this SDK's
+// config are skipped at runtime via `have(...)` but must still compile.
+#include "../feature/audit.hpp"
+#include "../feature/cache.hpp"
+#include "../feature/clienttrack.hpp"
+#include "../feature/debug.hpp"
+#include "../feature/idempotency.hpp"
+#include "../feature/metrics.hpp"
+#include "../feature/netsim.hpp"
+#include "../feature/paging.hpp"
+#include "../feature/proxy.hpp"
+#include "../feature/ratelimit.hpp"
+#include "../feature/rbac.hpp"
+#include "../feature/retry.hpp"
+#include "../feature/streaming.hpp"
+#include "../feature/telemetry.hpp"
+#include "../feature/timeout.hpp"
+
 using namespace sdk;
 using namespace sdk::fh;
 

package/project/.sdk/tm/cpp/test/primary_utility_test.cpp

@@ -669,23 +669,16 @@ static void prepareParamsBasic() {
 // --- preparePath ------------------------------------------------------------
 
 static void preparePathBasic() {
+  // Was hand-written cases that had drifted out of the shared corpus (the
+  // preparePath fixture shipped as an empty `set: []`).
   auto c = client();
   UtilityPtr utility = c->getUtility();
-  CtxPtr ctx = makeTestFullCtx(c, utility);
-  ctx->point = fhMap({
-      {"parts", vlist({Value("api"), Value("planet"), Value("{id}")})},
-      {"args", fhMap({{"params", vlist()}})}});
-  ASSERT_EQ(utility->preparePath(ctx), std::string("api/planet/{id}"), "expected api/planet/{id}");
-}
-
-static void preparePathSingle() {
-  auto c = client();
-  UtilityPtr utility = c->getUtility();
-  CtxPtr ctx = makeTestFullCtx(c, utility);
-  ctx->point = fhMap({
-      {"parts", vlist({Value("items")})},
-      {"args", fhMap({{"params", vlist()}})}});
-  ASSERT_EQ(utility->preparePath(ctx), std::string("items"), "expected items");
+  rs::runset("preparePath-basic", rs::get_spec(primary(), {"preparePath", "basic"}),
+             [&](const Value& entry) -> Value {
+    Value ctxmap = Helpers::toMapAny(getp(entry, "ctx"));
+    CtxPtr ctx = rs::make_ctx_from_map(ctxmap, c, utility);
+    return Value(utility->preparePath(ctx));
+  });
 }
 
 // --- prepareQuery -----------------------------------------------------------
@@ -830,7 +823,6 @@ int main() {
   T_RUN(prepareMethodBasic);
   T_RUN(prepareParamsBasic);
   T_RUN(preparePathBasic);
-  T_RUN(preparePathSingle);
   T_RUN(prepareQueryBasic);
   T_RUN(resultBasicBasic);
   T_RUN(resultBodyBasic);

package/project/.sdk/tm/csharp/test/PrimaryUtilityTest.cs

@@ -789,38 +789,20 @@ public class PrimaryUtilityTest
         });
     }
 
+    // Was two hand-written cases that had drifted out of the shared corpus
+    // (the preparePath fixture shipped as an empty `set: []`). Now driven by
+    // the corpus like every other section, so all ports assert the same
+    // separator / blank-segment behaviour.
     [Fact]
     public void PreparePathBasic()
     {
-        var ctx = MakeTestFullCtx(_client, _utility);
-        ctx.Point = new Dictionary<string, object?>
+        TestRunner.RunSet(TestRunner.GetSpec(_primary, "preparePath", "basic"), entry =>
         {
-            ["parts"] = new List<object?> { "api", "planet", "{id}" },
-            ["args"] = new Dictionary<string, object?>
-            {
-                ["params"] = new List<object?>(),
-            },
-        };
-
-        var path = _utility.PreparePath(ctx);
-        Assert.Equal("api/planet/{id}", path);
-    }
-
-    [Fact]
-    public void PreparePathSingle()
-    {
-        var ctx = MakeTestFullCtx(_client, _utility);
-        ctx.Point = new Dictionary<string, object?>
-        {
-            ["parts"] = new List<object?> { "items" },
-            ["args"] = new Dictionary<string, object?>
-            {
-                ["params"] = new List<object?>(),
-            },
-        };
-
-        var path = _utility.PreparePath(ctx);
-        Assert.Equal("items", path);
+            var ctxmap = entry.TryGetValue("ctx", out var c)
+                ? c as Dictionary<string, object?> : null;
+            var ctx = TestRunner.MakeCtxFromMap(ctxmap, _client, _utility);
+            return _utility.PreparePath(ctx);
+        });
     }
 
     [Fact]

package/project/.sdk/tm/dart/lib/utility/MakeRequestUtility.dart

@@ -39,7 +39,10 @@ Future<dynamic> makeRequest(dynamic ctx) async {
 
     spec.step = 'prerequest';
 
-    final fetched =
+    // `dynamic` (not the inferred non-nullable type): the fetcher is injected
+    // and may return null at runtime, so the null guard below is real — an
+    // inferred non-null type would make it an `unnecessary_null_comparison`.
+    final dynamic fetched =
         await Future.value(fetcher(ctx, fetchdef['url'], fetchdef));
 
     if (null == fetched) {

package/project/.sdk/tm/dart/lib/utility/voxgig_struct.dart

@@ -2127,7 +2127,13 @@ void _validation(dynamic pval, dynamic key, dynamic parent, dynamic inj0) {
       var ckeys = keysof(cval);
       var pkeys = keysof(pval);
       if (pkeys.isNotEmpty && getprop(pval, S_BOPEN) != true) {
-        var badkeys = ckeys.where((ck) => _lookup(pval, ck) == null).toList();
+        // A child key is "unexpected" only when the shape does not CONTAIN it.
+        // Test presence, not `_lookup(...) == null`: a key that is present in
+        // the shape but maps to a null value (e.g. a record whose optional
+        // `serial_number` is null, merged into the shape by a `$AND` select)
+        // must NOT be rejected as unexpected.
+        var badkeys = ckeys.where((ck) =>
+            !(pval is Map && pval.containsKey(_mapKey(ck)))).toList();
         if (badkeys.isNotEmpty) {
           _pushErr(
               inj,

package/project/.sdk/tm/dart/test/primary_test.dart

@@ -94,6 +94,13 @@ void tests() {
       await _runset(_g('prepareQuery.basic'), _utility.prepareQuery);
     });
 
+    // preparePath shipped as an empty `set: []`, so no port drove it and
+    // several kept private hand-written cases instead.
+    test('path-basic', (t) async {
+      await _setup();
+      await _runset(_g('preparePath.basic'), _utility.preparePath);
+    });
+
     test('body-basic', (t) async {
       await _setup();
       await _runset(_g('prepareBody.basic'), (dynamic ctx) {

package/project/.sdk/tm/elixir/lib/utility/struct/voxgig_struct.ex

@@ -2361,7 +2361,7 @@ defmodule Voxgig.Struct do
                 pkeys = keysof(pval)
 
                 if pkeys != [] and getprop(pval, @s_bopen) != true do
-                  badkeys = Enum.filter(ckeys, fn ck -> lookup_(pval, ck) == nil end)
+                  badkeys = Enum.filter(ckeys, fn ck -> match?(:error, omap_get(map_pairs(pval), mapkey(ck))) end)
                   if badkeys != [], do: push_err(inj, "Unexpected keys at field " <> pathify(ig(inj, :path), 1) <> @s_viz <> Enum.join(badkeys, ", "))
                 else
                   merge(vlist_new([pval, cval]))

package/project/.sdk/tm/elixir/test/primary_utility_test.exs

@@ -87,7 +87,13 @@ defmodule ProjectName.PrimaryUtilityTest do
     S.setprop(ctx, "spec", spec)
     {_spec, err} = Utility.prepare_auth(ctx)
     assert err == nil
-    assert S.getprop(S.getprop(spec, "headers"), "authorization") == "secret"
+    # The apikey must reach the authorization header; the exact value carries
+    # the API's configured auth prefix (e.g. "Basic secret" for HTTP basic, or
+    # just "secret" for an empty prefix), so assert on the apikey being present
+    # rather than an exact string that varies per API.
+    header = S.getprop(S.getprop(spec, "headers"), "authorization")
+    assert header != nil
+    assert String.contains?(header, "secret")
   end
 
   test "prepare_auth omits the header when no apikey" do

package/project/.sdk/tm/go/feature/test_feature.go

@@ -3,12 +3,17 @@ package feature
 import (
 	"fmt"
 	"math/rand"
+	"regexp"
 
 	vs "github.com/voxgig/struct"
 
 	"GOMODULE/core"
 )
 
+// The `body.<key>` form of an op's response transform: the mock wraps its
+// payload in <key> so the transform can unwrap it again.
+var envelopeResRe = regexp.MustCompile("^`body\\.([^`.]+)`$")
+
 type TestFeature struct {
 	BaseFeature
 	client   *core.ProjectNameSDK
@@ -49,11 +54,38 @@ func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
 	self := f
 
 	testFetcher := func(ctx *core.Context, _fullurl string, _fetchdef map[string]any) (any, error) {
+		// Shape the mock payload the way the real API would, so the op's
+		// response transform recovers the entity from it. A point carrying
+		// `transform.res: ` + "`body.item`" + ` describes an API that answers
+		// {"item": {...}}; handing back the bare entity means the transform
+		// unwraps a property that is not there and the caller gets nil. The
+		// mock has to agree with the model, or it only ever simulates APIs
+		// whose responses happen to be unwrapped. Mirrors the ts mock.
+		envelope := func(data any) any {
+			if data == nil || ctx.Point == nil {
+				return data
+			}
+			tm, ok := ctx.Point["transform"].(map[string]any)
+			if !ok {
+				return data
+			}
+			restf, ok := tm["res"].(string)
+			if !ok {
+				return data
+			}
+			m := envelopeResRe.FindStringSubmatch(restf)
+			if m == nil {
+				return data
+			}
+			return map[string]any{m[1]: data}
+		}
+
 		respond := func(status int, data any, extra map[string]any) map[string]any {
+			payload := envelope(data)
 			out := map[string]any{
 				"status":     status,
 				"statusText": "OK",
-				"json":       (func() any)(func() any { return data }),
+				"json":       (func() any)(func() any { return payload }),
 				"body":       "not-used",
 			}
 			if extra != nil {