@voxgig/sdkgen 1.3.17 → 1.3.19

package/project/.sdk/src/cmp/ts/MainEntity_ts.ts

@@ -1,6 +1,6 @@
 
 
-import { cmp, Content, entityClassName } from '@voxgig/sdkgen'
+import { cmp, Content, entityClassName, entityCollection } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -14,7 +14,7 @@ const MainEntity = cmp(async function MainEntity(props: any) {
 
   // Return the collision-free class TYPE (entityClassName); the accessor METHOD
   // name (entity.Name) is unchanged so callers still write client.<Name>().
-  const cls = entityClassName(entity, getModelPath(model, `main.${KIT}.entity`))
+  const cls = entityClassName(entity, entityCollection(model))
 
   Content(`
   // Entity access: \`client.${entity.Name}().list()\` / \`client.${entity.Name}().load({ id })\`.

package/project/.sdk/src/cmp/ts/Main_ts.ts

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
-  entityClassName,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 
@@ -57,7 +57,7 @@ const Main = cmp(async function Main(props: any) {
       Line(`// ${model.const.Name} ${target.Name} SDK\n`)
 
       List({ item: entity }, ({ item }: any) => {
-        const cls = entityClassName(item, entity)
+        const cls = entityClassName(item, entityCollection(model))
         return Line(`import { ${cls} } from './entity/${cls}'`)
       })
 

package/project/.sdk/src/cmp/ts/TestDirect_ts.ts

@@ -49,7 +49,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
       apikey: env.${PROJECTNAME}_APIKEY,`
     : ''
 
-  const opnames = Object.keys(entity.op)
+  const opnames = Object.keys(entity.op || {})
   const hasLoad = opnames.includes('load')
   const hasList = opnames.includes('list')
 
@@ -151,7 +151,7 @@ function unwrapListData(data: any): any[] | null {
 
 
 function generateDirectLoad(model: Model, entity: ModelEntity) {
-  const loadOp = entity.op.load
+  const loadOp = entity.op?.load
   const loadPoint: ModelPoint | undefined = loadOp?.points?.[0]
 
   if (null == loadPoint) {
@@ -198,7 +198,7 @@ function generateDirectLoad(model: Model, entity: ModelEntity) {
     .join('\n')
 
   // Get list info for live mode bootstrapping
-  const listOp = entity.op.list
+  const listOp = entity.op?.list
   const listPoint = listOp?.points?.[0]
   const listParams = listPoint?.args?.params || []
   const listPath = listPoint ? normalizePathParams(listPoint.parts || [], listParams, listPoint.rename?.param) : ''
@@ -356,7 +356,7 @@ ${paramAsserts}    }
 
 
 function generateDirectList(model: Model, entity: ModelEntity) {
-  const listOp = entity.op.list
+  const listOp = entity.op?.list
   const listPoint: ModelPoint | undefined = listOp?.points?.[0]
 
   if (null == listPoint) {

package/project/.sdk/src/cmp/ts/fragment/Config.fragment.ts

@@ -19,7 +19,7 @@ class Config {
 
 
   main = {
-    name: 'ProjectName',
+    name: '$$const.Name$$',
   }
 
 
@@ -31,7 +31,7 @@ class Config {
   options = {
     base: '$$main.kit.info.servers.0.url$$',
 
-    'AUTHBLOCK'headers: 'HEADERS',
+    'SERVERBLOCK''AUTHBLOCK'headers: 'HEADERS',
 
     entity: {
       // #EntityConfigs

package/project/.sdk/src/cmp/ts/fragment/Direct.test.fragment.ts

@@ -24,6 +24,10 @@ describe('EntityNameDirect', async () => {
 
   test('direct-exists', async () => {
     const sdk = new ProjectNameSDK({
+      // Concrete base: a live construction must satisfy any server
+      // variables a templated base URL declares; overriding base with a
+      // literal (as the direct flow tests do) sidesteps the requirement.
+      base: 'http://localhost:8080',
       system: { fetch: async () => ({}) }
     })
     assert('function' === typeof sdk.direct)

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

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, camelify,
   File, Content, Folder, Fragment,
-  entityClassName,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 import {
@@ -20,7 +20,7 @@ const Entity = cmp(function Entity(props: any) {
   const { model, stdrep } = props.ctx$
   const { target, entity } = props
 
-  const entityColl = getModelPath(model, `main.${KIT}.entity`)
+  const entityColl = entityCollection(model)
   const cls = entityClassName(entity, entityColl)
 
   const entrep = {
@@ -34,7 +34,7 @@ const Entity = cmp(function Entity(props: any) {
 
     File({ name: zigVarName(entity.name) + '.' + target.ext }, () => {
 
-      const opnames = Object.keys(entity.op)
+      const opnames = Object.keys(entity.op || {})
 
       // For each CRUD op: if the spec defines it, splice in the real
       // implementation. Otherwise emit a stub returning the unsupported_op

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

@@ -1,5 +1,5 @@
 
-import { cmp, Content, entityClassName } from '@voxgig/sdkgen'
+import { cmp, Content, entityClassName, entityCollection } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -16,7 +16,7 @@ const MainEntity = cmp(async function MainEntity(props: any) {
   const { entity } = props
   const { model } = props.ctx$
 
-  const entityColl = getModelPath(model, `main.${KIT}.entity`)
+  const entityColl = entityCollection(model)
   const cls = entityClassName(entity, entityColl)
   const method = zigVarName(entity.name)
   const mod = zigVarName(entity.name)

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

@@ -23,8 +23,16 @@ import { zigModuleName } from './utility_zig'
 //
 // The `.paths` allow-list mirrors the (registry-less) template: it only
 // matters when packaging for a registry, which zig does not do, so it is kept
-// stable. `.name` is a plain string here (matching the target's zig toolchain
-// pin) rather than the newer enum-literal + fingerprint form.
+// stable. `.name` is a plain string here rather than the newer enum-literal +
+// fingerprint form.
+//
+// TOOLCHAIN PIN: the string form REQUIRES zig <= 0.13. Zig 0.14 rejects it
+// outright — `build.zig.zon:2:13: error: expected enum literal` — so the
+// generated SDK will not build at all on a newer toolchain. The consumer CI
+// job pins 0.13.0 to match (create-sdkgen
+// project/standard/.github/workflows/ci.yml). Moving to a newer zig means
+// changing BOTH: `.name = .${name}` plus a `.fingerprint` here, and the CI
+// pin there.
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const model: Model = ctx$.model

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/Makefile

@@ -15,21 +15,21 @@ clean:
 # publishing a version currently means pushing the tag csharp/vX.Y.Z. When the
 # registry goes live, `dotnet pack` + `dotnet nuget push` slot in before the
 # tag (mirroring the voxgig/struct csharp Makefile). Run headless under the
-# aql key vault, which injects the GitHub token so nothing lands on disk or
+# boru key vault, which injects the GitHub token so nothing lands on disk or
 # argv:
-#   aql vault exec --for=github=<alias> -- make publish
-# aql `--dry-run` injects a filler token we detect to rehearse (no tag/push).
+#   boru vault exec --for=github=<alias> -- make publish
+# boru `--dry-run` injects a filler token we detect to rehearse (no tag/push).
 # set -e + tag-last: a failed push never leaves a tag behind.
 VERSION := $(shell cat VERSION)
 TAG := csharp/v$(VERSION)
-AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+BORU_DRY_RUN_FILLER := BORU-DRY-RUN-FILLER-NOT-A-REAL-SECRET
 publish: test
 	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
 	  echo "tag $(TAG) already exists — bump VERSION first"; exit 1; fi
 	@set -e; \
 	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
-	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \
-	  echo "[dry-run] aql filler token detected: would tag $(TAG); nothing pushed."; \
+	if [ "$$token" = "$(BORU_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] boru filler token detected: would tag $(TAG); nothing pushed."; \
 	  exit 0; \
 	fi; \
 	git tag -a "$(TAG)" -m "csharp v$(VERSION)"; \

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/Makefile

@@ -22,14 +22,14 @@ clean:
 # the tag. set -e + tag-last: a failed upload never leaves a tag behind.
 VERSION := $(shell sed -nE 's/^version: *([0-9][^ ]*).*/\1/p' pubspec.yaml | head -1)
 TAG := dart/v$(VERSION)
-AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+BORU_DRY_RUN_FILLER := BORU-DRY-RUN-FILLER-NOT-A-REAL-SECRET
 publish: test
 	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
 	  echo "tag $(TAG) already exists — bump pubspec.yaml version first"; exit 1; fi
 	@set -e; \
 	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
-	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \
-	  echo "[dry-run] aql filler token detected: would publish to pub.dev and tag $(TAG); nothing pushed."; \
+	if [ "$$token" = "$(BORU_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] boru filler token detected: would publish to pub.dev and tag $(TAG); nothing pushed."; \
 	  exit 0; \
 	fi; \
 	if [ -n "$$PUB_CREDENTIALS" ]; then \

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/go/Makefile

@@ -13,10 +13,10 @@ clean:
 # Go modules have no registry upload — publishing a version means pushing the
 # tag go/vX.Y.Z (this module is the go/ subdir, and Go's submodule-tag
 # convention is <subdir>/vX.Y.Z), which the module proxy + pkg.go.dev pick up on
-# first fetch. Run headless under the aql key vault, which injects the GitHub
+# first fetch. Run headless under the boru key vault, which injects the GitHub
 # token so nothing lands on disk or argv:
-#   aql vault exec --for=github=<alias> -- make publish
-# aql `--dry-run` injects a filler token we detect to rehearse (no tag/push).
+#   boru vault exec --for=github=<alias> -- make publish
+# boru `--dry-run` injects a filler token we detect to rehearse (no tag/push).
 # set -e + tag-last: a failed push never leaves a tag behind.
 #
 # NOTE: publishing the git tag is deliberately NOT gated on `go test` (every
@@ -24,14 +24,14 @@ clean:
 # block the module tag). Run `make test` separately in CI to gate quality.
 VERSION := $(shell cat VERSION)
 TAG := go/v$(VERSION)
-AQL_DRY_RUN_FILLER := AQL-DRY-RUN-FILLER-NOT-A-REAL-SECRET
+BORU_DRY_RUN_FILLER := BORU-DRY-RUN-FILLER-NOT-A-REAL-SECRET
 publish:
 	@if git rev-parse -q --verify "refs/tags/$(TAG)" >/dev/null; then \
 	  echo "tag $(TAG) already exists — bump VERSION first"; exit 1; fi
 	@set -e; \
 	token="$${GITHUB_TOKEN:-$$GH_TOKEN}"; \
-	if [ "$$token" = "$(AQL_DRY_RUN_FILLER)" ]; then \
-	  echo "[dry-run] aql filler token detected: would tag $(TAG) for pkg.go.dev; nothing pushed."; \
+	if [ "$$token" = "$(BORU_DRY_RUN_FILLER)" ]; then \
+	  echo "[dry-run] boru filler token detected: would tag $(TAG) for pkg.go.dev; nothing pushed."; \
 	  exit 0; \
 	fi; \
 	git tag -a "$(TAG)" -m "go v$(VERSION)"; \

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 {