@voxgig/sdkgen 4.21.0 → 4.23.0

package/project/.sdk/tm/go/test/struct_utility_test.go

@@ -1,6 +1,3 @@
-// Vendored from github.com/voxgig/struct/go/voxgigstruct_test.go
-// RUN: go test
-// RUN-SOME: go test -v -run=TestStructUtility/getpath
 
 package sdktest
 
@@ -160,13 +157,6 @@ func TestStructUtility(t *testing.T) {
 	})
 
 	t.Run("minor-escurl", func(t *testing.T) {
-		// Passed BARE, like every other minor subject. This used to wrap
-		// EscUrl in ReplaceAll(..., "+", "%20") because the vendored copy
-		// implemented it with net/url.QueryEscape, which form-encodes: a
-		// space became '+' rather than '%20'. The workaround made the
-		// shared corpus pass while make_url.go still emitted '+' into real
-		// paths and query strings. Upstream's EscUrl matches the reference
-		// encodeURIComponent exactly, so there is nothing left to paper over.
 		structRunSet(t, minorSpec["escurl"], voxgigstruct.EscUrl)
 	})
 
@@ -179,21 +169,6 @@ func TestStructUtility(t *testing.T) {
 				val = "null"
 			}
 
-			// Go has no `undefined`. Upstream Stringify renders nil as
-			// "null" ON PURPOSE - in Go nil IS JSON null, and
-			// JSON.stringify(null) is "null" - so the corpus's two
-			// separate cases,
-			//
-			//   {"val": null} -> "null"      and      {} -> ""
-			//
-			// both arrive here as a nil val and cannot be told apart by
-			// VALUE. They can be told apart by PRESENCE: the second case
-			// is the JavaScript stringify(undefined), and an absent key
-			// is the only thing Go has that means undefined.
-			//
-			// The runner is the right place for this: it is the seam
-			// between a language-neutral corpus and one language's type
-			// system, and it already bridges the same gap for pathify.
 			if !hasVal {
 				return ""
 			}
@@ -658,12 +633,6 @@ func TestStructUtility(t *testing.T) {
 				ks = *k
 			}
 
-			// The ROOT node has no parent. The reference passes
-			// `undefined` there and logs `p=`; Go has only nil, which
-			// Stringify renders as "null" (its documented choice - see
-			// minor-stringify above). Rendering the absent parent as ""
-			// keeps the log identical to the reference's, which is what
-			// the corpus records.
 			ps := ""
 			if nil != p {
 				ps = voxgigstruct.Stringify(p)
@@ -1506,13 +1475,6 @@ func IsSameFunc(target any, candidate any) bool {
 	return reflect.ValueOf(target).Pointer() == reflect.ValueOf(candidate).Pointer()
 }
 
-// ---------------------------------------------------------------------
-// Struct-corpus SUPPORT, retained from the retired struct_runner_test.go
-// (its engine half is superseded by the vendored omni runner driven
-// through omniresolver_test.go). The StructSDK below is the client the
-// runner wraps for the struct sections; NullModifier names struct's own
-// *voxgigstruct.Injection and so cannot live in the language-neutral
-// resolver; Fdt/ToJSONString are debug helpers, not runner API.
 
 type StructUtility struct {
 	IsNode     func(val any) bool

package/project/.sdk/tm/go/test/testsupport_test.go

@@ -1,11 +1,3 @@
-// SDK test SUPPORT: the helpers the generated entity/direct tests and the
-// corpus call sites share - env loading, the sdk-test-control.json skip and
-// pacing machinery, corpus access, and entity-data conversion.
-//
-// Split out of the retired runner_test.go (vendor-tag rollout: the corpus
-// ENGINE half of that file is superseded by the vendored omni runner driven
-// through the resolver in omniresolver_test.go; this support half is
-// retained). Same package, same names - the emitted call sites did not move.
 
 package sdktest
 
@@ -159,23 +151,6 @@ func isControlSkipped(kind, name, mode string) (bool, string) {
 	return false, ""
 }
 
-// liveDelayMs returns the configured per-test live delay in ms; default 500.
-// liveClientOptions returns the extra SDK options every LIVE client is
-// constructed with, from sdk-test-control.json `test.client.options`.
-//
-// The generated live client knows two things: the base URL (from the spec)
-// and the credential (from the environment). Everything else about how a
-// particular API wants to be talked to - which features to switch on, and
-// with what settings - is a property of THAT API, known to the project and
-// to nothing in the toolchain.
-//
-// Merged UNDER the generated fields, so the suite's own base/apikey/server
-// values win: this ADDS to the live client, it does not redirect it.
-//
-// That contract is enforced HERE rather than left to each merge site: the
-// generated map only names a field when the model calls for one, so a
-// "base" in this block would face no competing value and would silently
-// redirect the whole suite - credential included - to another host.
 var liveReserved = map[string]bool{
 	"base": true, "prefix": true, "suffix": true,
 	"server": true, "apikey": true, "secret": true,

package/project/.sdk/tm/go/utility/feature_add.go

@@ -2,12 +2,6 @@ package utility
 
 import "GOMODULE/core"
 
-// featureAddUtil appends a feature to the client's feature list. A feature
-// that implements AddOptions (every BaseFeature embedder does, via the
-// AddOpts field) can instead position itself relative to an already-added
-// feature with "__before__", "__after__" or "__replace__" naming that
-// feature — mirroring the ts featureAdd. The first match wins; when no
-// ordering option matches, the feature is appended.
 func featureAddUtil(ctx *core.Context, f core.Feature) {
 	client := ctx.Client
 	features := client.Features

package/project/.sdk/tm/go/utility/fetcher.go

@@ -57,12 +57,6 @@ func defaultHTTPFetch(fullurl string, fetchdef map[string]any) (map[string]any,
 		}
 	}
 
-	// Honour a redirect annotation: "manual" surfaces a 3xx as an ordinary
-	// response instead of auto-following it. In the ts/js targets fetchdef
-	// rides straight into fetch(), where `redirect` is a native option -
-	// this is the same seam for Go's auto-following http.Client. The
-	// station feature sets it under a hosts egress policy, so a Location
-	// off the allowlist cannot pull an automatic credentialed follow-up.
 	if redirect, ok := fetchdef["redirect"].(string); ok && redirect == "manual" {
 		manual := *client
 		manual.CheckRedirect = func(req *http.Request, via []*http.Request) error {

package/project/.sdk/tm/go/utility/graphql.go

@@ -9,22 +9,7 @@ import (
 	"GOMODULE/core"
 )
 
-// GraphQL transport. API-INDEPENDENT: every GraphQL SDK this generator
-// produces uses this file unchanged. The API-specific part — which
-// operations exist and what each one's document is — is model data,
-// computed once by apidef and emitted into Config.
-//
-// Two jobs:
-//
-//	GraphqlBody   — build { query, variables } for a point, binding the
-//	                op's arguments to the document's declared variables.
-//
-//	GraphqlErrors — lift a GraphQL failure into an SDK error. GraphQL
-//	                reports failures as a top-level `errors` array under
-//	                HTTP 200, so the status-driven path in resultBasic
-//	                never sees them.
-
-// Content type every GraphQL-over-HTTP request uses.
+
 const GraphqlContentType = "application/json"
 
 // Map a GraphQL error to the same error codes the HTTP path produces, so a
@@ -56,12 +41,6 @@ func graphqlErrorCodeUtil(gqlerr any) string {
 	return "request_graphql"
 }
 
-// Build the request body for a GraphQL point.
-//
-// Variables come from the op's own arguments: a named variable binds to the
-// like-named argument (`from`), and the input-object variable (empty `from`)
-// takes the request data as a whole — which is what makes a generated
-// create/update call look exactly like its REST equivalent.
 func graphqlBodyUtil(ctx *core.Context) any {
 	gql, _ := vs.GetProp(ctx.Point, "graphql").(map[string]any)
 	if gql == nil {
@@ -110,8 +89,6 @@ func graphqlBodyUtil(ctx *core.Context) any {
 			continue
 		}
 
-		// Only send variables the caller actually supplied: sending an
-		// explicit null would clear a field on many APIs.
 		val := vs.GetProp(reqsrc, from)
 		if val == nil {
 			val = vs.GetProp(datasrc, from)
@@ -129,13 +106,6 @@ func graphqlBodyUtil(ctx *core.Context) any {
 	}
 }
 
-// Inspect a decoded GraphQL response body and record a failure when the
-// server reported one. Returns true when an error was recorded.
-//
-// Partial data (`data` alongside `errors`) is treated as failure: the REST
-// surface has no partial-success concept, and silently returning half an
-// object would be worse than failing. The raw envelope stays available on
-// the result for callers that need it.
 func graphqlErrorsUtil(ctx *core.Context) bool {
 	if ctx.Result == nil || ctx.Point == nil {
 		return false

package/project/.sdk/tm/go/utility/make_options.go

@@ -1,6 +1,7 @@
 package utility
 
 import (
+	"encoding/json"
 	"regexp"
 	"sort"
 	"strings"
@@ -13,18 +14,43 @@ import (
 // {name} placeholders in a templated server URL (OpenAPI server variables).
 var serverVarRe = regexp.MustCompile(`\{[A-Za-z0-9_]+\}`)
 
+func canonNumbers(node any) {
+	switch n := node.(type) {
+	case map[string]any:
+		for k, v := range n {
+			if num, ok := v.(json.Number); ok {
+				n[k] = canonNumber(num)
+			} else {
+				canonNumbers(v)
+			}
+		}
+	case []any:
+		for i, v := range n {
+			if num, ok := v.(json.Number); ok {
+				n[i] = canonNumber(num)
+			} else {
+				canonNumbers(v)
+			}
+		}
+	}
+}
+
+func canonNumber(n json.Number) any {
+	if i, err := n.Int64(); err == nil {
+		return i
+	}
+	if f, err := n.Float64(); err == nil {
+		return f
+	}
+	return n
+}
+
 func makeOptionsUtil(ctx *core.Context) map[string]any {
 	options := ctx.Options
 	if options == nil {
 		options = map[string]any{}
 	}
 
-	// Merge custom utility overrides onto the utility object.
-	// Read from original options before clone, since vs.Clone strips functions.
-	//
-	// A key naming a real utility member REPLACES it (overrideUtil); anything
-	// else is attached as a custom extra. This mirrors ts, where the utility is
-	// an open object and `setprop` does both at once.
 	if customUtils := core.ToMapAny(options["utility"]); customUtils != nil {
 		utility := ctx.Utility
 		if utility != nil {
@@ -36,28 +62,11 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 		}
 	}
 
-	// `auth: nil` is the documented way to disable auth outright, and
-	// prepareAuth honours it before it ever reads the apikey. But validate
-	// treats a stored nil as "no value", so the optspec's `auth` default
-	// fires and the suppression silently becomes "use default auth" —
-	// transmitting a credential the caller explicitly asked not to send.
-	//
-	// Suppliedness cannot be recovered after validate, hence here. The
-	// two-value form is required: options["auth"] reads nil both when the
-	// key is ABSENT and when it is present and nil, and only the second is
-	// a suppression. (ts gets this for free — `null === options.auth` is
-	// false for an omitted key, since that reads undefined.)
 	authval, authgiven := options["auth"]
 	authsuppressed := authgiven && authval == nil
 
 	opts := vs.Clone(options).(map[string]any)
 
-	// Feature add-order (feature #2). options.feature may be given as an ordered
-	// ARRAY of {name, active, ...opts} entries (the array position IS the order
-	// in which features are added), or as a {name:{opts}} map. Normalize an
-	// array to a map (so merge/validate/init are unchanged) and remember the
-	// explicit order; a map defaults to test-first so the `test` mock transport
-	// is installed as the base of the transport wrapper chain.
 	var featureorder []any
 	if farr, ok := opts["feature"].([]any); ok {
 		fmap := map[string]any{}
@@ -93,18 +102,6 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 		}
 	}
 
-	// THE OPTION SPEC IS GENERATED, NOT WRITTEN HERE.
-	//
-	// core.OPTSPEC is built from the model: `main.kit.optspec` for the
-	// standard options, plus one entry per feature this target carries, taken
-	// from that feature's own `config.options` / `config.optspec`. Editing
-	// this file to add an option would put it back where it was — one of
-	// twenty hand-maintained copies of a schema nothing cross-checked — so
-	// add it to the model instead and every ported target validates it.
-	//
-	// NOT MUTATED. It is a package-level map shared by every client this
-	// process constructs; the platform default below is applied to the
-	// RESULT, never to the spec.
 	optspec := core.OPTSPEC
 
 	// Preserve system.fetch before merge/validate.
@@ -118,6 +115,12 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 	// nested maps as merge TARGETS — one instance's options (server, headers,
 	// ...) would contaminate every instance constructed after it.
 	merged := vs.Merge([]any{map[string]any{}, vs.Clone(cfgopts), opts})
+
+	// To reflect a json.Number is a string, so the validator refuses one where
+	// the feature readers accept it. Canonicalise first: options decoded with
+	// UseNumber() are otherwise judged by a rule nothing else applies.
+	canonNumbers(merged)
+
 	validated, _ := vs.Validate(merged, optspec)
 	opts = validated.(map[string]any)
 
@@ -126,14 +129,6 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 		opts["auth"] = nil
 	}
 
-	// Resolve a templated base URL (e.g. https://{tenant_id}.hanko.io).
-	// Every placeholder must resolve to a non-empty value: from
-	// options["server"] (user), else the config default. A placeholder that
-	// resolves to "" is a construction error in live mode — the URL cannot
-	// work — but in test mode substitutes the deterministic value
-	// "test-<name>" so offline tests need no configuration. The SDK
-	// constructor has no error return, so a missing required variable
-	// PANICS (construction-time misconfiguration, as regexp.MustCompile).
 	if base, ok := opts["base"].(string); ok && strings.Contains(base, "{") {
 		testmode := false
 		if ta, ok := vs.GetPath(opts, []any{"test", "active"}).(bool); ok && ta {
@@ -219,12 +214,6 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 		} else {
 			ordered = append(ordered, names...)
 		}
-		// Station special case, mirroring test's: its transport wrap must
-		// sit immediately outside the base transport (inside retry/cache/
-		// netsim), so map-form activation hoists it to just after test -
-		// or first, when no test entry exists. Without this the sorted
-		// default would init station last and wrap OUTSIDE the recording
-		// features, turning its wire-truth events into fiction.
 		si := -1
 		for i, n := range ordered {
 			if n == "station" {

package/project/.sdk/tm/go/utility/make_point.go

@@ -28,11 +28,6 @@ func terminalParam(point map[string]any) bool {
 	return strings.HasPrefix(last, "{")
 }
 
-// The entity's OWN route among an op's points: a terminal parameter first,
-// then the fewest path segments. Ties keep the earlier point, so the model's
-// sorted-key order decides. The same rule runs at generation time, in
-// helpers/opShape.ts — a template ships standalone, so both sides must move
-// together.
 func ownPoint(points []map[string]any) map[string]any {
 	best := points[0]
 	for _, cand := range points {
@@ -134,12 +129,6 @@ func makePointUtil(ctx *core.Context) (map[string]any, error) {
 		// so nothing matches — fall back to the entity's own route rather
 		// than whichever point came last.
 		if !matched {
-			// A request naming an action reaches here only because that
-			// action's own point failed its exist test, so it is unbuildable
-			// whatever we pick. Refuse it BEFORE choosing a fallback: the
-			// guard below compares the chosen point's $action and would wave
-			// the request through whenever the fallback lands on the action
-			// point itself.
 			if reqselector != nil && vs.GetProp(reqselector, "$action") != nil {
 				return nil, ctx.MakeError("point_action_invalid",
 					"Operation \""+op.Name+

package/project/.sdk/tm/go/utility/make_spec.go

@@ -55,10 +55,6 @@ func makeSpecUtil(ctx *core.Context) (*core.Spec, error) {
 	kind, _ := vs.GetProp(point, "kind").(string)
 
 	if kind == "graphql" {
-		// GraphQL addresses one endpoint: no path parts, no query string,
-		// and the body carries the operation. PrepareBody is skipped
-		// deliberately — it only emits a body for data-input ops, whereas
-		// every GraphQL op posts one, including load/list/remove.
 		ctx.Spec.Body = utility.GraphqlBody(ctx)
 		ctx.Spec.Path = ""
 		// PrepareQuery already copied the op's match arguments into the
@@ -69,17 +65,6 @@ func makeSpecUtil(ctx *core.Context) (*core.Spec, error) {
 	} else {
 		ctx.Spec.Body = utility.PrepareBody(ctx)
 
-		// A failed request transform has nowhere else to report: the
-		// PrepareBody seam returns a plain value, and go's makeError RETURNS
-		// the error where the TS reference THROWS it, unwinding the operation
-		// from inside transformRequest. So the abort lands here. Without it
-		// the error object travels on as the request body and the call still
-		// goes out — a 200 would then make a failed transform look like a
-		// successful operation.
-		//
-		// Only the throwing path produces an error value: with ctrl.throw
-		// false, makeError hands back result.Resdata instead, and the
-		// pipeline continues, exactly as it does in ts.
 		if berr, isErr := ctx.Spec.Body.(error); isErr {
 			return nil, berr
 		}

package/project/.sdk/tm/go/utility/register.go

@@ -40,25 +40,6 @@ func registerAll(u *core.Utility) {
 	u.TransformResponse = transformResponseUtil
 }
 
-// overrideUtil replaces one utility member from `options.utility`, matching
-// the ts reference: a key naming a real utility member REPLACES it, and any
-// other key is attached as a custom extra.
-//
-// Without this the override was a no-op here. `makeOptions` put every entry
-// in `u.Custom`, which nothing reads, so a caller passing
-// `utility: {"fetcher": myTransport}` - the documented way to script the
-// transport, and the seam the shared feature corpus runs on - was silently
-// ignored while ts and js honoured it. The custom-utility test did not catch
-// it because it asserted the side map rather than the behaviour.
-//
-// Returns false when the key names no member, or when the value is not that
-// member's signature; the caller then keeps it in Custom. A wrong signature
-// is deliberately NOT an error: ts attaches whatever it is given, so a typed
-// port that rejected it outright would diverge in the other direction.
-//
-// Keep this list in step with registerAll above - a utility added to one and
-// not the other is overridable in ts and not here, which is the divergence
-// this exists to remove.
 func overrideUtil(u *core.Utility, key string, val any) bool {
 	switch key {
 	case "clean":
@@ -92,15 +73,6 @@ func overrideUtil(u *core.Utility, key string, val any) bool {
 			return true
 		}
 	case "fetcher":
-		// BOTH SPELLINGS. Fetcher is the one member declared as a NAMED type,
-		// and a type assertion to a defined type matches only that exact
-		// dynamic type. A plain function literal in a map[string]any - the
-		// ordinary way to write this - carries the UNNAMED signature and
-		// asserts to `func(...)` but not to `core.FetcherFunc`; a value the
-		// caller converted asserts to `core.FetcherFunc` but not to the
-		// unnamed one. Accepting only the named type shelved every ordinary
-		// caller's transport in Custom, which is the exact defect this
-		// function exists to remove.
 		if fn, ok := val.(core.FetcherFunc); ok {
 			u.Fetcher = fn
 			return true

package/project/.sdk/tm/go/utility/transform_request.go

@@ -24,31 +24,11 @@ func transformRequestUtil(ctx *core.Context) any {
 		return ctx.Reqdata
 	}
 
-	// Transform gained an error return in struct go 0.1.3. The TS reference
-	// wraps this call in try/catch and returns makeError(ctx, err) — but ts's
-	// makeError THROWS unless ctrl.throw is false, so that `return` is only
-	// ever reached on the non-throwing path. go's makeError cannot throw; it
-	// returns the error instead. Handing that back as the `any` this seam
-	// returns would make it the request BODY, so makeSpec re-raises it (see
-	// the abort there). On the ctrl.throw-false path makeError yields
-	// result.Resdata and this returns a real value, as ts does.
 	reqdata, terr := vs.Transform(map[string]any{
 		"reqdata": ctx.Reqdata,
 	}, reqform)
 
 	if terr != nil {
-		// Only the NON-throwing path goes through makeError here. With
-		// ctrl.throw false, ts's makeError returns result.resdata and the
-		// pipeline continues with it as the body; mirror that.
-		//
-		// On the throwing path the error is handed back raw, for makeSpec to
-		// re-raise and the operation to process once. Calling makeError here
-		// as well would report the same failure TWICE — it fires the
-		// PreUnexpected hook, and the operation fires it again when it
-		// handles what makeSpec re-raised. The built-in observability
-		// features happen to dedupe on a per-context marker, but a
-		// project-supplied feature may legitimately count or log on every
-		// dispatch, and ts dispatches once.
 		if ctx.Ctrl != nil && ctx.Ctrl.Throw != nil && !*ctx.Ctrl.Throw {
 			out, _ := makeErrorUtil(ctx, terr)
 			return out

package/project/.sdk/tm/go/utility/transform_response.go

@@ -46,14 +46,6 @@ func transformResponseUtil(ctx *core.Context) any {
 	}, resform)
 
 	if terr != nil {
-		// Ok must be cleared as well as Err. This runs from BOTH makeResponse
-		// and makeResult, and only the makeResult call actually reaches the
-		// transform: resultBasic never sets Ok, so the makeResponse call
-		// returns at the !result.Ok guard above, and makeResponse then sets
-		// Ok true. By the time the transform really runs, Ok is already true —
-		// and doneUtil returns result.Resdata whenever Ok is true, without
-		// ever consulting Err. Recording only the error would leave a failed
-		// response transform resolving successfully.
 		result.Err = ctx.MakeError("resform", "resform: "+terr.Error())
 		result.Ok = false
 		return nil

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

@@ -109,18 +109,23 @@ public class TestFeature extends BaseFeature {
       return data;
     }
     String spec = (String) restf;
-    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    // synthesise, so it is left alone rather than guessed at.
+    // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     if (!spec.startsWith("`body.") || !spec.endsWith("`") || spec.length() < 8) {
       return data;
     }
     String inner = spec.substring(6, spec.length() - 1);
-    if (inner.isEmpty() || inner.contains(".")) {
+    if (inner.isEmpty()) {
       return data;
     }
-    Map<String, Object> wrapped = new LinkedHashMap<>();
-    wrapped.put(inner, data);
-    return wrapped;
+    String[] segs = inner.split("\\.", -1);
+    Object out = data;
+    for (int i = segs.length - 1; 0 <= i; i--) {
+      Map<String, Object> wrapped = new LinkedHashMap<>();
+      wrapped.put(segs[i], out);
+      out = wrapped;
+    }
+    return out;
   }
 
   private Map<String, Object> respond(Context ctx, int status, Object data, Map<String, Object> extra) {

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

@@ -4,6 +4,17 @@ const { BaseFeature } = require('../base/BaseFeature')
 
 const S_NOT_FOUND = 'Not found'
 
+// The `%04x%04x%04x%04x` every other target mints, so the id's shape does not
+// depend on which language answered.
+function mintId() {
+  let out = ''
+  for (let i = 0; i < 4; i++) {
+    out += ((Math.random() * 0x10000) | 0).toString(16).padStart(4, '0')
+  }
+  return out
+}
+
+
 
 class TestFeature extends BaseFeature {
   version = '0.0.1'
@@ -162,10 +173,7 @@ class TestFeature extends BaseFeature {
         const args = self.buildArgs(ctx, op, ctx.reqdata)
         let id = param(ctx, 'id')
         if (null == id) {
-          id = ((1e4 * Math.random() | 0).toString(16) +
-            (1e4 * Math.random() | 0).toString(16) +
-            (1e4 * Math.random() | 0).toString(16) +
-            (1e4 * Math.random() | 0).toString(16)).padEnd(16, '0')
+          id = mintId()
         }
 
         const ent = clone(ctx.reqdata)