@voxgig/sdkgen 1.3.17 → 1.3.18

package/project/.sdk/tm/php/test/PrimaryUtilityTest.php

@@ -1136,16 +1136,18 @@ class PrimaryUtilityTest extends TestCase
 
     public function test_prepare_path_basic(): void
     {
+        // Was hand-written cases that had drifted out of the shared corpus
+        // (the preparePath fixture shipped as an empty `set: []`).
+        $spec = self::load_test_spec();
+        $primary = self::get_spec($spec, 'primary');
         $client = ProjectNameSDK::test(null, null);
         $utility = $client->get_utility();
-        $ctx = self::make_test_full_ctx($client, $utility);
-        $ctx->point = [
-            'parts' => ['api', 'planet', '{id}'],
-            'args' => ['params' => []],
-        ];
 
-        $path = ($utility->prepare_path)($ctx);
-        $this->assertEquals('api/planet/{id}', $path);
+        $this->runset(self::get_spec($primary, 'preparePath', 'basic'), function (array $entry) use ($client, $utility) {
+            $ctxmap = $entry['ctx'] ?? [];
+            $ctx = self::make_ctx_from_map($ctxmap, $client, $utility);
+            return [($utility->prepare_path)($ctx), null];
+        });
     }
 
 

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

@@ -1,6 +1,7 @@
 # ProjectName SDK test feature
 
 from __future__ import annotations
+import re
 import random
 import time
 
@@ -8,6 +9,11 @@ from utility.voxgig_struct import voxgig_struct as vs
 from feature.base_feature import ProjectNameBaseFeature
 
 
+# The `body.<key>` form of an op's response transform: the mock wraps its
+# payload in <key> so the transform can unwrap it again.
+ENVELOPE_RES_RE = re.compile(r"^`body\.([^`.]+)`$")
+
+
 class ProjectNameTestFeature(ProjectNameBaseFeature):
     def __init__(self):
         super().__init__()
@@ -36,11 +42,32 @@ class ProjectNameTestFeature(ProjectNameBaseFeature):
         test_self = self
 
         def test_fetcher(fctx, _fullurl, _fetchdef):
+            # 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 of `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 None.
+            # The mock has to agree with the model, or it only ever simulates
+            # APIs whose responses happen to be unwrapped. Mirrors the ts mock.
+            def envelope(data):
+                point = getattr(fctx, "point", None)
+                if data is None or not isinstance(point, dict):
+                    return data
+                transform = point.get("transform")
+                if not isinstance(transform, dict):
+                    return data
+                restf = transform.get("res")
+                if not isinstance(restf, str):
+                    return data
+                m = ENVELOPE_RES_RE.match(restf)
+                return data if m is None else {m.group(1): data}
+
             def respond(status, data, extra=None):
+                payload = envelope(data)
                 out = {
                     "status": status,
                     "statusText": "OK",
-                    "json": lambda: data,
+                    "json": lambda: payload,
                     "body": "not-used",
                 }
                 if isinstance(extra, dict):

package/project/.sdk/tm/py/test/test_primary_utility.py

@@ -945,28 +945,23 @@ class TestPrimaryUtility:
         _runset(_get_spec(primary, "prepareParams", "basic"), subject)
 
     def test_prepare_path_basic(self):
+        # 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.
+        spec = _load_test_spec()
+        primary = _get_spec(spec, "primary")
         client = ProjectNameSDK.test(None, None)
         utility = client._utility
-        ctx = _make_test_full_ctx(client, utility)
-        ctx.point = {
-            "parts": ["api", "planet", "{id}"],
-            "args": {"params": []},
-        }
-
-        path = utility.prepare_path(ctx)
-        assert path == "api/planet/{id}"
 
-    def test_prepare_path_single(self):
-        client = ProjectNameSDK.test(None, None)
-        utility = client._utility
-        ctx = _make_test_full_ctx(client, utility)
-        ctx.point = {
-            "parts": ["items"],
-            "args": {"params": []},
-        }
+        def subject(entry):
+            ctxmap = entry.get("ctx")
+            if not isinstance(ctxmap, dict):
+                ctxmap = {}
+            ctx = _make_ctx_from_map(ctxmap, client, utility)
+            return utility.prepare_path(ctx), None
 
-        path = utility.prepare_path(ctx)
-        assert path == "items"
+        _runset(_get_spec(primary, "preparePath", "basic"), subject)
 
     def test_prepare_query_basic(self):
         spec = _load_test_spec()

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

@@ -4,6 +4,10 @@ require_relative '../utility/struct/voxgig_struct'
 require_relative 'base_feature'
 
 class ProjectNameTestFeature < ProjectNameBaseFeature
+  # The `body.<key>` form of an op's response transform: the mock wraps its
+  # payload in <key> so the transform can unwrap it again.
+  ENVELOPE_RES_RE = /\A`body\.([^`.]+)`\z/
+
   def initialize
     super
     @version = "0.0.1"
@@ -33,11 +37,30 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
     test_self = self
 
     test_fetcher = ->(fctx, _fullurl, _fetchdef) {
+      # 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 of `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 = ->(data) {
+        point = fctx.point
+        next data if data.nil? || !point.is_a?(Hash)
+        transform = point["transform"]
+        next data unless transform.is_a?(Hash)
+        restf = transform["res"]
+        next data unless restf.is_a?(String)
+        m = ENVELOPE_RES_RE.match(restf)
+        m.nil? ? data : { m[1] => data }
+      }
+
       respond = ->(status, data, extra) {
+        payload = envelope.call(data)
         out = {
           "status" => status,
           "statusText" => "OK",
-          "json" => -> { data },
+          "json" => -> { payload },
           "body" => "not-used",
         }
         extra&.each { |k, v| out[k] = v }

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

@@ -610,14 +610,13 @@ class PrimaryUtilityTest < Minitest::Test
   # === preparePath ===
 
   def test_prepare_path_basic
-    ctx = make_test_full_ctx(@client, @utility)
-    ctx.point = {
-      "parts" => ["api", "planet", "{id}"],
-      "args" => { "params" => [] },
-    }
-
-    path = @utility.prepare_path.call(ctx)
-    assert_equal "api/planet/{id}", path
+    # Was hand-written cases that had drifted out of the shared corpus
+    # (the preparePath fixture shipped as an empty `set: []`).
+    runset(get_spec(@primary, "preparePath", "basic")) do |entry|
+      ctxmap = entry["ctx"] || {}
+      ctx = make_ctx_from_map(ctxmap, @client, @utility)
+      @utility.prepare_path.call(ctx)
+    end
   end
 
   def test_prepare_path_single

package/project/.sdk/tm/rust/tests/common/mod.rs

@@ -291,15 +291,51 @@ pub fn match_deep(check: &Value, base: &Value) -> Option<String> {
 
 // ---- runset (mirrors go runner_test.go runset) -----------------------------------
 
+// Sections deliberately left empty in the shared corpus
+// (.sdk/test/primary/<name>.aontu carries a PENDING header). Everything else
+// MUST contribute cases.
+pub const PENDING_SECTIONS: &[&str] = &[
+    "fetcher", "makeFetchDef", "makePoint", "makeResult", "featureAdd",
+    "featureHook", "featureInit",
+];
+
 pub fn runset(
     testspec: &Value,
     subject: &mut dyn FnMut(&Value) -> Result<Value, ProjectNameError>,
+) {
+    runset_named("", testspec, subject)
+}
+
+/// Drive one section of the shared test corpus.
+///
+/// This used to `return` silently when "set" was missing or not a list, so a
+/// renamed section, a fixture that failed to compile, or an empty set reported
+/// PASS while running zero assertions — the whole point of a shared oracle lost
+/// without a single red test. Both conditions now panic, except for the
+/// sections explicitly marked PENDING in the corpus.
+pub fn runset_named(
+    name: &str,
+    testspec: &Value,
+    subject: &mut dyn FnMut(&Value) -> Result<Value, ProjectNameError>,
 ) {
     let set = match getp(testspec, "set") {
         Value::List(l) => Value::List(l),
-        _ => return,
+        _ => panic!(
+            "test corpus section {:?} has no `set` list — zero cases would run",
+            name
+        ),
     };
 
+    if let Value::List(l) = &set {
+        if l.borrow().is_empty() && !PENDING_SECTIONS.contains(&name) {
+            panic!(
+                "test corpus section {:?} is EMPTY — zero cases would run; add \
+                 cases, or mark the fixture PENDING in .sdk/test/primary/",
+                name
+            );
+        }
+    }
+
     let entries: Vec<Value> = match &set {
         Value::List(l) => l.borrow().clone(),
         _ => Vec::new(),

package/project/.sdk/tm/rust/tests/primary_utility_test.rs

@@ -810,35 +810,21 @@ fn primary_prepare_params_basic() {
     );
 }
 
+// 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.
 #[test]
 fn primary_prepare_path_basic() {
     let (client, utility) = base_client();
-    let ctx = make_test_full_ctx(&client, &utility);
-    *ctx.point.borrow_mut() = jo(vec![
-        (
-            "parts",
-            ja(vec![
-                Value::str("api"),
-                Value::str("planet"),
-                Value::str("{id}"),
-            ]),
-        ),
-        ("args", jo(vec![("params", Value::empty_list())])),
-    ]);
-
-    assert_eq!(utility.prepare_path(&ctx), "api/planet/{id}");
-}
-
-#[test]
-fn primary_prepare_path_single() {
-    let (client, utility) = base_client();
-    let ctx = make_test_full_ctx(&client, &utility);
-    *ctx.point.borrow_mut() = jo(vec![
-        ("parts", ja(vec![Value::str("items")])),
-        ("args", jo(vec![("params", Value::empty_list())])),
-    ]);
-
-    assert_eq!(utility.prepare_path(&ctx), "items");
+    let primary = primary();
+    runset(
+        &get_spec(&primary, &["preparePath", "basic"]),
+        &mut |entry| {
+            let ctx = make_ctx_from_map(&getp(entry, "ctx"), &client, &utility);
+            Ok(Value::str(utility.prepare_path(&ctx)))
+        },
+    );
 }
 
 #[test]

package/project/.sdk/tm/swift/Tests/ProjectNameSDKTests/PrimaryUtilityTest.swift

@@ -629,14 +629,13 @@ final class PrimaryUtilityTest: XCTestCase {
   }
 
   func testPreparePathBasic() {
-    let ctx = makeTestFullCtx(client, utility)
-    ctx.point = vm(
-      ("parts", .list([.string("api"), .string("planet"), .string("{id}")])),
-      ("args", .map(vm(("params", .list([])))))
-    )
-
-    let path = utility.preparePath(ctx)
-    XCTAssertEqual(path, "api/planet/{id}")
+    // Was hand-written cases that had drifted out of the shared corpus
+    // (the preparePath fixture shipped as an empty `set: []`).
+    SdkRunner.runSet(SdkRunner.spec(primary, "preparePath", "basic")) { entry in
+      let ctxmap = entry.entries["ctx"]?.asMap
+      let ctx = SdkRunner.makeCtxFromMap(ctxmap, self.client, self.utility)
+      return .string(self.utility.preparePath(ctx))
+    }
   }
 
   func testPreparePathSingle() {

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -52,12 +52,29 @@ class TestFeature extends BaseFeature {
       const delprop = struct.delprop
       const getdef = struct.getdef
 
+      // 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 undefined.
+      // The mock has to agree with the model, or it only ever simulates APIs
+      // whose responses happen to be unwrapped.
+      function envelope(data: any) {
+        const restf = getprop(getprop(ctx.point, 'transform', {}), 'res')
+        if (null == data || 'string' !== typeof restf) {
+          return data
+        }
+        const m = restf.match(/^`body\.([^`.]+)`$/)
+        return null == m ? data : { [m[1]]: data }
+      }
+
       function respond(status: number, data?: any, res?: any) {
+        const payload = envelope(data)
         const out = merge([
           {
             status,
             statusText: 'OK',
-            json: async () => data,
+            json: async () => payload,
             body: 'not-used',
           },
           getdef(res, {})

package/project/.sdk/tm/ts/test/utility/PrimaryUtility.test.ts

@@ -31,6 +31,38 @@ describe('PrimaryUtility', async () => {
   }
 
 
+  // Sections deliberately left empty in the shared corpus
+  // (.sdk/test/primary/<name>.aontu carries a PENDING header). Everything
+  // else MUST contribute cases.
+  const PENDING = new Set([
+    'fetcher', 'makeFetchDef', 'makePoint', 'makeResult',
+    'featureAdd', 'featureHook', 'featureInit',
+  ])
+
+  // Run one corpus section, failing loudly when it would run ZERO cases.
+  // A renamed section or a fixture that compiled to an empty `set` used to
+  // pass silently, which defeats the point of a shared oracle. (The guard
+  // lives here rather than in runner.ts, which is vendored verbatim from
+  // @voxgig/struct and must stay byte-identical to upstream.)
+  //
+  // EVERY corpus-backed test goes through here — a guard that only some
+  // sections opt into leaves the rest able to run zero assertions, which is
+  // the exact hole it was added to close.
+  async function runsection(name: string, subject: Function) {
+    const section = spec[name]
+    ok(null != section,
+      `test corpus section '${name}' missing — check the name against .sdk/test/primary/`)
+    ok(null != section.basic && Array.isArray(section.basic.set),
+      `test corpus section '${name}' has no basic.set list`)
+    if (0 === section.basic.set.length && !PENDING.has(name)) {
+      throw new Error(
+        `test corpus section '${name}' is EMPTY — zero cases would run; ` +
+        `add cases, or mark the fixture PENDING in .sdk/test/primary/`)
+    }
+    return runset(section.basic, subject)
+  }
+
+
   before(async () => {
     const runner = await makeRunner(TEST_JSON_FILE, await SDK.test())
     const run = await runner('primary')
@@ -61,24 +93,24 @@ describe('PrimaryUtility', async () => {
 
 
   test('context-basic', async () => {
-    await runset(spec.makeContext.basic, utility.makeContext)
+    await runsection('makeContext', utility.makeContext)
   })
 
 
   test('method-basic', async () => {
-    await runset(spec.prepareMethod.basic, utility.prepareMethod)
+    await runsection('prepareMethod', utility.prepareMethod)
   })
 
 
   test('headers-basic', async () => {
-    await runset(spec.prepareHeaders.basic, utility.prepareHeaders)
+    await runsection('prepareHeaders', utility.prepareHeaders)
   })
 
 
   test('auth-basic', async () => {
     const sdkopts = spec.prepareAuth?.DEF?.setup?.a || {}
     const authClient = SDK.test({}, sdkopts)
-    await runset(spec.prepareAuth.basic, (ctx: any) => {
+    await runsection('prepareAuth', (ctx: any) => {
       ctx.client = authClient
       fixctx(ctx)
       return utility.prepareAuth(ctx)
@@ -87,17 +119,17 @@ describe('PrimaryUtility', async () => {
 
 
   test('params-basic', async () => {
-    await runset(spec.prepareParams.basic, utility.prepareParams)
+    await runsection('prepareParams', utility.prepareParams)
   })
 
 
   test('query-basic', async () => {
-    await runset(spec.prepareQuery.basic, utility.prepareQuery)
+    await runsection('prepareQuery', utility.prepareQuery)
   })
 
 
   test('body-basic', async () => {
-    await runset(spec.prepareBody.basic, (ctx: any) => {
+    await runsection('prepareBody', (ctx: any) => {
       fixctx(ctx)
       return utility.prepareBody(ctx)
     })
@@ -105,17 +137,17 @@ describe('PrimaryUtility', async () => {
 
 
   test('findparam-basic', async () => {
-    await runset(spec.param.basic, utility.param)
+    await runsection('param', utility.param)
   })
 
 
   test('fullurl-basic', async () => {
-    await runset(spec.makeUrl.basic, utility.makeUrl)
+    await runsection('makeUrl', utility.makeUrl)
   })
 
 
   test('operator-basic', async () => {
-    await runset(spec.operator.basic, (opmap: any) => ({
+    await runsection('operator', (opmap: any) => ({
       entity: opmap.entity || '_',
       name: opmap.name || '_',
       input: opmap.input || '_',
@@ -125,7 +157,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('options-basic', async () => {
-    await runset(spec.makeOptions.basic, (vin: any) => {
+    await runsection('makeOptions', (vin: any) => {
       const ctx = utility.makeContext({ options: vin.options, config: vin.config })
       ctx.client = client
       ctx.utility = utility
@@ -137,7 +169,7 @@ describe('PrimaryUtility', async () => {
   test('spec-basic', async () => {
     const sdkopts = spec.makeSpec?.DEF?.setup?.a || {}
     const specClient = SDK.test({}, sdkopts)
-    await runset(spec.makeSpec.basic, (ctx: any) => {
+    await runsection('makeSpec', (ctx: any) => {
       ctx.client = specClient
       ctx.options = specClient.options()
       return utility.makeSpec(ctx)
@@ -146,17 +178,17 @@ describe('PrimaryUtility', async () => {
 
 
   test('reqform-basic', async () => {
-    await runset(spec.transformRequest.basic, utility.transformRequest)
+    await runsection('transformRequest', utility.transformRequest)
   })
 
 
   test('resform-basic', async () => {
-    await runset(spec.transformResponse.basic, utility.transformResponse)
+    await runsection('transformResponse', utility.transformResponse)
   })
 
 
   test('resbasic-basic', async () => {
-    await runset(spec.resultBasic.basic, (ctx: any) => {
+    await runsection('resultBasic', (ctx: any) => {
       fixctx(ctx)
       return utility.resultBasic(ctx)
     })
@@ -164,7 +196,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('resheaders-basic', async () => {
-    await runset(spec.resultHeaders.basic, (ctx: any) => {
+    await runsection('resultHeaders', (ctx: any) => {
       // Convert plain headers map to forEach-based (browser Response API)
       if (ctx.response?.headers && !ctx.response.headers.forEach) {
         const h = ctx.response.headers
@@ -178,7 +210,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('resbody-basic', async () => {
-    await runset(spec.resultBody.basic, async (ctx: any) => {
+    await runsection('resultBody', async (ctx: any) => {
       if (ctx.response && !ctx.response.json) {
         const body = ctx.response.body
         ctx.response.json = async () => body
@@ -200,7 +232,7 @@ describe('PrimaryUtility', async () => {
       system: { fetch: mockFetch }
     })
     const reqUtility = reqClient.utility()
-    await runset(spec.makeRequest.basic, async (ctx: any) => {
+    await runsection('makeRequest', async (ctx: any) => {
       ctx.client = reqClient
       ctx.utility = reqUtility
       ctx.options = reqClient.options()
@@ -210,7 +242,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('response-basic', async () => {
-    await runset(spec.makeResponse.basic, async (ctx: any) => {
+    await runsection('makeResponse', async (ctx: any) => {
       fixctx(ctx)
       // Add json() and forEach to response for proper TS handling
       if (ctx.response && !ctx.response.json) {
@@ -229,7 +261,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('done-basic', async () => {
-    await runset(spec.done.basic, (ctx: any) => {
+    await runsection('done', (ctx: any) => {
       fixctx(ctx)
       return utility.done(ctx)
     })
@@ -237,7 +269,7 @@ describe('PrimaryUtility', async () => {
 
 
   test('error-basic', async () => {
-    await runset(spec.makeError.basic, (...args: any[]) => {
+    await runsection('makeError', (...args: any[]) => {
       const ctx = args[0]
       fixctx(ctx)
       return utility.makeError(...args)
@@ -424,6 +456,18 @@ describe('PrimaryUtility', async () => {
   })
 
 
+  test('path-basic', async () => {
+    // preparePath shipped as an empty `set: []` — every port "passed" it while
+    // running zero cases. Now corpus-driven like every other section.
+    await runsection('preparePath', (ctx: any) => utility.preparePath(ctx))
+  })
+
+
+  test('clean-corpus', async () => {
+    await runsection('clean', (...args: any[]) => utility.clean(args[0], args[1]))
+  })
+
+
   test('clean', () => {
     const ctx = makeFullCtx()
     const val = { key: 'secret123', name: 'test' }

package/src/cmp/Entity.ts

@@ -21,8 +21,12 @@ const Entity = cmp(function Entity(props: any) {
   const Entity_sdk = requirePath(ctx$, `./cmp/${target.name}/Entity_${target.name}`)
   Entity_sdk['Entity']({ target, entity, entitySDK })
 
+  // Log identifiers, not the model subtrees. `target` and `entity` are large
+  // aontu nodes and this fires once per entity per target (thousands of times
+  // for a big API x 22 targets), so passing them serialised the whole model
+  // fragment each time at default log level.
   log.info({
-    point: 'generate-entity', target, entity,
+    point: 'generate-entity', target: target.name, entity: entity.name,
     note: 'target:' + target.name + ', ' + 'entity: ' + entity.name
   })
 })

package/src/cmp/Feature.ts

@@ -19,7 +19,8 @@ const Feature = cmp(function Feature(props: any) {
   }
 
   log.info({
-    point: 'generate-feature', target, feature,
+    // Identifiers only — see the note in Entity.ts.
+    point: 'generate-feature', target: target.name, feature: feature.name,
     note: 'target:' + target.name + ', ' + 'feature: ' + feature.name
   })
 

package/src/helpers/canonType.ts

@@ -14,9 +14,14 @@
 // the SINGLE mapping per language: components must not keep local copies.
 //
 // Kept as a small mirror here (rather than importing VALID_CANON at runtime)
-// because apidef is a peer dependency and the table is the INVERSE direction;
-// `ts/test/canontype.test.ts` asserts this table covers apidef's exported
-// sentinel vocabulary whenever apidef is installed, so drift fails the suite.
+// because apidef is a peer dependency and the table is the INVERSE direction.
+//
+// `ts/test/canonsync.test.ts` guards it two ways: the vocabulary and every
+// language column are pinned LOCALLY (that check always runs), and the table
+// is cross-checked against apidef's exported VALID_CANON/CANON_ONE when the
+// installed apidef exports them. Note that the currently published apidef
+// (6.3.1) does NOT export them, so the cross-check skips — do not rely on it
+// alone; add a new sentinel to the local list in the same change.
 //
 // KNOWN GAPS (papered over sanely, documented for the port):
 //  - Unknown / missing sentinel  -> the language's "any" (never throws).