@voxgig/sdkgen 4.20.0 → 4.22.0

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,60 +102,7 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 		}
 	}
 
-	optspec := map[string]any{
-		"apikey": "",
-		"base":   "http://localhost:8000",
-		"prefix": "",
-		"suffix": "",
-		"auth": map[string]any{
-			"prefix": "",
-		},
-		"headers": map[string]any{
-			"`$CHILD`": "`$STRING`",
-		},
-		"allow": map[string]any{
-			"method": "GET,PUT,POST,PATCH,DELETE,OPTIONS",
-			"op":     "create,update,load,list,remove,command,direct,graphql",
-		},
-		"entity": map[string]any{
-			"`$CHILD`": map[string]any{
-				"`$OPEN`": true,
-				"active":  false,
-				"alias":   map[string]any{},
-			},
-		},
-		"feature": map[string]any{
-			"`$CHILD`": map[string]any{
-				"`$OPEN`": true,
-				"active":  false,
-			},
-		},
-		"utility": map[string]any{},
-		// Feature INSTANCES supplied at construction (the station adopt
-		// path): consumed by the constructor's featureAdd loop, so they
-		// are class instances, not data - `$ANY` accepts them verbatim.
-		// Without this entry the seam is dead: the constructor reads
-		// options.extend, but validate rejected the key (mirrors
-		// MakeOptionsUtility.ts).
-		"extend": "`$ANY`",
-		"system": map[string]any{},
-		"test": map[string]any{
-			"active": false,
-			"entity": map[string]any{
-				"`$OPEN`": true,
-			},
-		},
-		"clean": map[string]any{
-			"keys": "key,token,id",
-		},
-		// Server-variable values for a templated base URL (OpenAPI server
-		// variables): {name} placeholders in "base" are substituted from this
-		// map at construction. Spec defaults arrive via the generated config;
-		// user values override them.
-		"server": map[string]any{
-			"`$CHILD`": "",
-		},
-	}
+	optspec := core.OPTSPEC
 
 	// Preserve system.fetch before merge/validate.
 	var sysFetch any
@@ -159,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)
 
@@ -167,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 {
@@ -260,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/struct/voxgigstruct.go

@@ -1,5 +1,5 @@
 // VENDORED: @voxgig/struct 0.1.0 (go/voxgigstruct.go)
-// Source: https://github.com/voxgig/struct @ abd93227e3295151f8dcd18597c3f3f2577af8b7  [tag: sdk-20260911-2013-0]
+// Source: https://github.com/voxgig/struct @ 3110e839a3f35b2fbdb047bf0c24f29d144027ea  [tag: sdk-20260917-1242-0]
 // License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
 /* Copyright (c) 2025 Voxgig Ltd. MIT LICENSE. */
 
@@ -3867,13 +3867,29 @@ func init_validate_ONE() {
 				return nil
 			}
 
-			// Get grandparent and grandkey to replace the structure
-			grandparent := inj.Nodes.List[len(inj.Nodes.List)-2]
-			grandkey := inj.Path.List[len(inj.Path.List)-2]
+			// PATCH (optspec port, pending upstream fix): use inj.setval, as
+			// the ts reference and the py/java ports do, instead of writing
+			// through a hand-held grandparent.
+			//
+			// setval DELETES on a nil value; SetProp deliberately keeps one
+			// ("Preserve nil values (like JS null)"). For a key the DATA does
+			// not have, the reference therefore removes the `[$ONE, ...]` node
+			// outright, while this set it to the data's nil and then, below,
+			// to whichever alternative matched. An OPTIONAL entry
+			// (`['`$ONE`', <spec>, '`$NIL`']`) that the caller omitted came
+			// back MATERIALISED, complete with the spec's `$OPEN` marker and a
+			// null for every option — which is exactly what that encoding
+			// exists to prevent. In an SDK's option spec that put an entry in
+			// `options.feature` for every feature the model declares, and the
+			// feature ADD ORDER is derived from those keys.
+			//
+			// Reassigning inj.Parent is part of the same divergence: the
+			// reference leaves it pointing at the `[$ONE, ...]` LIST, so the
+			// write-back below lands on a list under a string key and is a
+			// no-op — the data node, already replaced above, is what survives.
 
 			// Clean up structure by replacing [$ONE, ...] with current value
-			SetProp(grandparent, grandkey, inj.Dparent)
-			inj.Parent = inj.Dparent
+			inj.setval(inj.Dparent, 2)
 
 			// Adjust the path
 			inj.Path.List = inj.Path.List[:len(inj.Path.List)-1]
@@ -3902,8 +3918,8 @@ func init_validate_ONE() {
 				// Attempt validation of data with shape `tval`
 				vcurrent, err := Validate(inj.Dparent, tval, &Injection{Extra: vstore, Errs: terrs})
 
-				// Update the value in the grandparent
-				SetProp(grandparent, grandkey, vcurrent)
+				// PATCH (optspec port, pending upstream fix): see above.
+				inj.setval(vcurrent, -2)
 
 				// If no errors, we found a match
 				if err == nil && len(terrs.List) == 0 {

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