@voxgig/sdkgen 4.34.0 → 4.34.1

package/project/.sdk/tm/elixir/test/support/feature_harness.ex

@@ -84,6 +84,7 @@ defmodule ProjectName.FeatureHarness do
 
   def default_method("create"), do: "POST"
   def default_method("update"), do: "PATCH"
+  def default_method("patch"), do: "PATCH"
   def default_method("remove"), do: "DELETE"
   def default_method(_), do: "GET"
 

package/project/.sdk/tm/go/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/project/.sdk/tm/go/core/context.go

@@ -255,7 +255,7 @@ func (ctx *Context) resolveOp(opname string) *Operation {
 	opcfg := vs.GetPath(ctx.Config, []any{"entity", entname, "op", opname})
 
 	input := "match"
-	if opname == "update" || opname == "create" {
+	if opname == "update" || opname == "create" || opname == "patch" {
 		input = "data"
 	}
 

package/project/.sdk/tm/go/core/helpers.go

@@ -1,6 +1,9 @@
 package core
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+)
 
 // UnsupportedOp is returned by entity stub methods for operations the
 // underlying API spec doesn't define. The static ProjectNameEntity interface
@@ -10,6 +13,21 @@ func UnsupportedOp(opname, entityname string) (any, error) {
 	return nil, fmt.Errorf("operation '%s' not supported by entity '%s'", opname, entityname)
 }
 
+// Allowed reports whether a comma-separated allow option names the item:
+// whole names, any case.
+func Allowed(names any, item string) bool {
+	list, ok := names.(string)
+	if !ok || "" == item {
+		return false
+	}
+	for _, name := range strings.Split(list, ",") {
+		if strings.EqualFold(strings.TrimSpace(name), item) {
+			return true
+		}
+	}
+	return false
+}
+
 func ToMapAny(v any) map[string]any {
 	if v == nil {
 		return nil

package/project/.sdk/tm/go/core/response.go

@@ -1,6 +1,10 @@
 package core
 
 import (
+	"fmt"
+	"regexp"
+	"strings"
+
 	vs "github.com/voxgig/struct"
 )
 
@@ -11,6 +15,8 @@ type Response struct {
 	JsonFunc   func() any
 	Body       any
 	Err        error
+	// Set by a transport that could not read a non-blank body as JSON.
+	Unreadable bool
 }
 
 func NewResponse(resmap map[string]any) *Response {
@@ -44,6 +50,8 @@ func NewResponse(resmap map[string]any) *Response {
 		}
 	}
 
+	unreadable, _ := vs.GetProp(resmap, "unreadable").(bool)
+
 	return &Response{
 		Status:     status,
 		StatusText: statusText,
@@ -51,5 +59,69 @@ func NewResponse(resmap map[string]any) *Response {
 		JsonFunc:   jsonFunc,
 		Body:       body,
 		Err:        err,
+		Unreadable: unreadable,
+	}
+}
+
+const previewLength = 160
+
+var spaceRun = regexp.MustCompile(`\s+`)
+
+// UnreadableBody describes a body that is not JSON. An HTTP failure keeps its
+// own error, with the response described; otherwise the code tells a wrong
+// content type from malformed JSON.
+func UnreadableBody(ctx *Context, status int, headers any, text any, sent any, failed error) error {
+	ctype := headerValue(headers, "content-type")
+	agent, _ := ctx.Utility.Clean(ctx, headerValue(sent, "user-agent")).(string)
+	if agent == "" {
+		agent = "transport default"
+	}
+	shown := ctype
+	if shown == "" {
+		shown = "none"
+	}
+	detail := fmt.Sprintf("HTTP %d, content-type %s, user-agent %s", status, shown, agent)
+	if text != nil {
+		detail += ", body: " + bodyPreview(ctx, text)
+	}
+
+	if failed != nil {
+		if pe, ok := failed.(*ProjectNameError); ok {
+			pe.Msg += " (" + detail + ")"
+			return pe
+		}
+		return fmt.Errorf("%s (%s)", failed.Error(), detail)
+	}
+
+	if ctype == "" || strings.Contains(strings.ToLower(ctype), "json") {
+		return ctx.MakeError("response_json_invalid", "response: body is not valid JSON ("+detail+")")
+	}
+	return ctx.MakeError("response_content_type",
+		"response: expected JSON, got "+ctype+" ("+detail+")")
+}
+
+func headerValue(headers any, name string) string {
+	hm, ok := headers.(map[string]any)
+	if !ok {
+		return ""
+	}
+	for key, val := range hm {
+		if strings.EqualFold(key, name) {
+			return fmt.Sprint(val)
+		}
+	}
+	return ""
+}
+
+// Cleaned whole: a secret the bound would split could leave its prefix.
+func bodyPreview(ctx *Context, text any) string {
+	flat := strings.TrimSpace(spaceRun.ReplaceAllString(fmt.Sprint(text), " "))
+	if cleaned, ok := ctx.Utility.Clean(ctx, flat).(string); ok {
+		flat = cleaned
+	}
+	runes := []rune(flat)
+	if len(runes) > previewLength {
+		return string(runes[:previewLength]) + "..."
 	}
+	return flat
 }

package/project/.sdk/tm/go/core/spec.go

@@ -14,6 +14,9 @@ type Spec struct {
 	Body    any
 	Url     string
 	Path    string
+	// The query parameters PrepareAuth placed: the credential, which the
+	// request sends and the entity's match leaves out.
+	AuthQuery []string
 }
 
 func NewSpec(specmap map[string]any) *Spec {

package/project/.sdk/tm/go/core/types.go

@@ -39,8 +39,16 @@ type ProjectNameEntity interface {
 	List(reqmatch map[string]any, ctrl map[string]any) (any, error)
 	Create(reqdata map[string]any, ctrl map[string]any) (any, error)
 	Update(reqdata map[string]any, ctrl map[string]any) (any, error)
+	Patch(reqdata map[string]any, ctrl map[string]any) (any, error)
 	Remove(reqmatch map[string]any, ctrl map[string]any) (any, error)
-	Stream(action string, args map[string]any, callopts map[string]any) <-chan any
+	Stream(action string, args map[string]any, callopts map[string]any) <-chan StreamItem
+}
+
+// A StreamItem is one value from an entity's Stream channel: an item of the
+// result, or the error that ended the stream, which is sent last.
+type StreamItem struct {
+	Item any
+	Err  error
 }
 
 type FetcherFunc func(ctx *Context, fullurl string, fetchdef map[string]any) (any, error)

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

@@ -15,6 +15,23 @@ import (
 // payload in <key> so the transform can unwrap it again.
 var envelopeResRe = regexp.MustCompile("^`body\\.(.+)`$")
 
+// The key a list's response transform
+// ["`$EACH`", "body", {"`$MERGE`": "`.<key>`"}] reads each item's record under.
+var itemEnvelopeRe = regexp.MustCompile("^`\\.([^.`$]+)`$")
+
+func itemEnvelopeKey(restf any) string {
+	list, ok := restf.([]any)
+	if !ok || len(list) != 3 || list[0] != "`$EACH`" || list[1] != "body" {
+		return ""
+	}
+	child, _ := list[2].(map[string]any)
+	merge, _ := child["`$MERGE`"].(string)
+	if m := itemEnvelopeRe.FindStringSubmatch(merge); m != nil {
+		return m[1]
+	}
+	return ""
+}
+
 type TestFeature struct {
 	BaseFeature
 	client   *core.ProjectNameSDK
@@ -63,6 +80,15 @@ func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
 			if !ok {
 				return data
 			}
+			if key := itemEnvelopeKey(tm["res"]); key != "" {
+				if items, isList := data.([]any); isList {
+					out := make([]any, len(items))
+					for i, item := range items {
+						out[i] = map[string]any{key: item}
+					}
+					return out
+				}
+			}
 			restf, ok := tm["res"].(string)
 			if !ok {
 				return data
@@ -142,7 +168,7 @@ func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
 			}
 			out := vs.Clone(found)
 			return respond(200, out, nil), nil
-		} else if op.Name == "update" {
+		} else if op.Name == "update" || op.Name == "patch" {
 			updateMatch := map[string]any{}
 			if ctx.Reqdata != nil {
 				if v, has := ctx.Reqdata["id"]; has {
@@ -169,7 +195,7 @@ func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
 				return respond(404, nil, map[string]any{"statusText": "Not found"}), nil
 			}
 			if _, ok := ent.(map[string]any); ok && ctx.Reqdata != nil {
-				vs.Merge([]any{ent, ctx.Reqdata})
+				vs.Merge([]any{ent, testRecord(ctx.Reqdata)})
 			}
 			vs.DelProp(ent, "$KEY")
 			out := vs.Clone(ent)
@@ -194,7 +220,7 @@ func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
 					rand.Intn(0x10000), rand.Intn(0x10000))
 			}
 
-			ent := vs.Clone(ctx.Reqdata)
+			ent := vs.Clone(testRecord(ctx.Reqdata))
 			if entm, ok := ent.(map[string]any); ok {
 				entm["id"] = id
 				if idStr, ok := id.(string); ok {
@@ -287,6 +313,21 @@ func (f *TestFeature) makeNetsim(net map[string]any, inner core.FetcherFunc) cor
 	}
 }
 
+// The record the mock keeps: the request data without `$body`, which only the
+// wire carries.
+func testRecord(reqdata map[string]any) map[string]any {
+	if reqdata == nil {
+		return nil
+	}
+	out := make(map[string]any, len(reqdata))
+	for k, v := range reqdata {
+		if k != "$body" {
+			out[k] = v
+		}
+	}
+	return out
+}
+
 func (f *TestFeature) buildArgs(ctx *core.Context, op *core.Operation, args map[string]any) any {
 	opname := op.Name
 

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

@@ -1,7 +1,6 @@
 package feature
 
 import (
-	"context"
 	"fmt"
 	"time"
 
@@ -9,10 +8,10 @@ import (
 )
 
 // Per-request timeout. Wraps the active transport and races each attempt
-// against a context.WithTimeout deadline; if the deadline wins, the request
-// resolves to a `timeout` error instead of hanging. The inner transport is
-// left to finish in its own goroutine (its result is discarded), matching
-// how the ts feature lets the losing racer resolve unobserved.
+// against a deadline; if the deadline wins, the request resolves to a
+// `timeout` error instead of hanging. The inner transport is left to finish
+// in its own goroutine (its result is discarded), matching how the ts
+// feature lets the losing racer resolve unobserved.
 type TimeoutFeature struct {
 	BaseFeature
 	client  *core.ProjectNameSDK
@@ -57,29 +56,47 @@ func (f *TimeoutFeature) withTimeout(ctx *core.Context, url string, fetchdef map
 		return inner(ctx, url, fetchdef)
 	}
 
-	tctx, cancel := context.WithTimeout(context.Background(), time.Duration(ms)*time.Millisecond)
-	defer cancel()
-
-	type fetched struct {
-		res any
-		err error
+	// The deadline runs from here, not from the wait. Deadline and response land
+	// in one channel, first in first out: a response that arrived in time is
+	// taken however late the caller is scheduled, a late one is a timeout.
+	type landed struct {
+		res      any
+		err      error
+		at       int64
+		deadline bool
 	}
-
-	// Buffered so the inner transport never blocks after a timeout loss.
-	out := make(chan fetched, 1)
+	now := foptNow(f.options)
+	start := now()
+	out := make(chan landed, 2)
+	remaining := int64(ms) - (now() - start)
+	if remaining < 0 {
+		remaining = 0
+	}
+	timer := time.AfterFunc(time.Duration(remaining)*time.Millisecond, func() {
+		out <- landed{deadline: true}
+	})
+	defer timer.Stop()
 	go func() {
 		res, err := inner(ctx, url, fetchdef)
-		out <- fetched{res: res, err: err}
+		out <- landed{res: res, err: err, at: now()}
 	}()
 
-	select {
-	case got := <-out:
-		return got.res, got.err
-	case <-tctx.Done():
-		f.track(ms)
-		return nil, ctx.MakeError("timeout",
-			fmt.Sprintf("Request exceeded timeout of %dms", ms))
+	got := <-out
+	if got.deadline {
+		select {
+		case got = <-out:
+		default:
+		}
 	}
+	if got.deadline || int64(ms) < got.at-start {
+		return nil, f.timeout(ctx, ms)
+	}
+	return got.res, got.err
+}
+
+func (f *TimeoutFeature) timeout(ctx *core.Context, ms int) error {
+	f.track(ms)
+	return ctx.MakeError("timeout", fmt.Sprintf("Request exceeded timeout of %dms", ms))
 }
 
 func (f *TimeoutFeature) track(ms int) {

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

@@ -162,6 +162,8 @@ func (f *ValidateFeature) payload(ctx *core.Context, opname string) map[string]a
 	// fields will never name it - and under `strict` every custom-action call
 	// would be rejected for the one key that made it reachable.
 	delete(out, "$action")
+	// Nor is `$body`, the raw request body.
+	delete(out, "$body")
 
 	return out
 }

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

@@ -18,7 +18,7 @@ import (
 // added under .sdk/test/feature/ — runs without editing this file. An
 // SDK generated without a listed feature still skips, not fails.
 
-var featureCorpusOps = []string{"Load", "List", "Create", "Update", "Remove"}
+var featureCorpusOps = []string{"Load", "List", "Create", "Update", "Patch", "Remove"}
 
 // One operation this SDK can actually perform.
 type fcOp struct {
@@ -382,6 +382,43 @@ func fcRecord(client *sdk.ProjectNameSDK, name string) any {
 	return nil
 }
 
+// fcMissingFeature names the first feature a case composes that this SDK
+// does not generate, probed as a section's own feature is. Such a case is
+// skipped rather than failed.
+func fcMissingFeature(kase map[string]any, have map[string]bool) string {
+	var names []string
+	switch f := kase["feature"].(type) {
+	case []any:
+		for _, one := range f {
+			if m, ok := one.(map[string]any); ok {
+				if n, ok := m["name"].(string); ok {
+					names = append(names, n)
+				}
+			}
+		}
+	case map[string]any:
+		for n := range f {
+			names = append(names, n)
+		}
+		sort.Strings(names)
+	}
+
+	for _, name := range names {
+		known, seen := have[name]
+		if !seen {
+			probe := fcClient(map[string]any{
+				"feature": []any{map[string]any{"name": name, "active": true}},
+			})
+			known = fcRecord(probe, name) != nil
+			have[name] = known
+		}
+		if !known {
+			return name
+		}
+	}
+	return ""
+}
+
 func TestFeatureCorpus(t *testing.T) {
 	spec := loadTestSpec(t)
 
@@ -391,6 +428,7 @@ func TestFeatureCorpus(t *testing.T) {
 	}
 
 	ops := fcUsableOps(2)
+	have := map[string]bool{}
 
 	// At least one operation, or every case below would skip and this would
 	// report green having run nothing.
@@ -446,6 +484,12 @@ func TestFeatureCorpus(t *testing.T) {
 					continue
 				}
 
+				if missing := fcMissingFeature(kase, have); missing != "" {
+					t.Logf("skip %q: needs the %s feature, which this SDK does not generate",
+						kase["name"], missing)
+					continue
+				}
+
 				tokens := map[string]string{}
 				for i := 0; i < need; i++ {
 					tokens[fmt.Sprintf("#OP%d", i+1)] = ops[i].key

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

@@ -170,7 +170,7 @@ func fhDefaultMethod(op string) string {
 	switch op {
 	case "create":
 		return "POST"
-	case "update":
+	case "update", "patch":
 		return "PATCH"
 	case "remove":
 		return "DELETE"

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

@@ -2,11 +2,13 @@ package sdktest
 
 import (
 	"encoding/json"
+	"errors"
 	"os"
 	"reflect"
 	"regexp"
 	"strconv"
 	"strings"
+	"sync/atomic"
 	"testing"
 	"time"
 
@@ -14,6 +16,27 @@ import (
 	feat "GOMODULE/feature"
 )
 
+// fhWorkerClock is a clock standing at 0 until the transport has run and at
+// later from then on, with a server that runs it: the caller reads the start,
+// the worker reads the arrival. A failure makes the server fail with it.
+func fhWorkerClock(later int64, failure error) (func() int64, sdk.FetcherFunc) {
+	var fetched int32
+	now := func() int64 {
+		if 1 == atomic.LoadInt32(&fetched) {
+			return later
+		}
+		return 0
+	}
+	server := func(ctx *sdk.Context, url string, fetchdef map[string]any) (any, error) {
+		atomic.StoreInt32(&fetched, 1)
+		if failure != nil {
+			return nil, failure
+		}
+		return fhResponse(200, map[string]any{"ok": true}, nil), nil
+	}
+	return now, server
+}
+
 // --- option coercion --------------------------------------------------------
 
 type fhRetries int
@@ -379,6 +402,69 @@ func TestFeatureTimeout(t *testing.T) {
 		}
 	})
 
+	// The deadline runs from the request's start, not from the wait: a
+	// response that arrives after it is a timeout even when the caller only
+	// looks once it is complete. The clock stands at the start until the
+	// transport has run, then 300 ms later, so the response is instant in
+	// real time and late by the clock.
+	t.Run("late-response-times-out-however-late-the-caller-looks", func(t *testing.T) {
+		now, server := fhWorkerClock(300, nil)
+		f := feat.NewTimeoutFeature()
+		h := fhMake(server, fhF(f, map[string]any{"ms": 20, "now": now}))
+		res := h.op(fhOpSpec{op: "load"})
+		if fhErrCode(res.err) != "timeout" {
+			t.Errorf("expected timeout error, got %v", res.err)
+		}
+		if f.Count != 1 {
+			t.Errorf("expected 1 timeout, got %d", f.Count)
+		}
+	})
+
+	// A transport failure after the deadline is a timeout too, not the failure.
+	t.Run("late-failure-times-out", func(t *testing.T) {
+		now, server := fhWorkerClock(300, errors.New("socket closed"))
+		f := feat.NewTimeoutFeature()
+		h := fhMake(server, fhF(f, map[string]any{"ms": 20, "now": now}))
+		res := h.op(fhOpSpec{op: "load"})
+		if fhErrCode(res.err) != "timeout" {
+			t.Errorf("expected timeout error, got %v", res.err)
+		}
+		if f.Count != 1 {
+			t.Errorf("expected 1 timeout, got %d", f.Count)
+		}
+	})
+
+	// A deadline already spent when the request is armed times out at once,
+	// not after another full period: the clock stands at the start, then
+	// past the deadline for every later read, and the transport never answers
+	// until the verdict is in.
+	t.Run("a-spent-deadline-times-out-at-once", func(t *testing.T) {
+		var reads int64
+		now := func() int64 {
+			if 1 == atomic.AddInt64(&reads, 1) {
+				return 0
+			}
+			return 2001
+		}
+		release := make(chan struct{})
+		server := func(ctx *sdk.Context, url string, fetchdef map[string]any) (any, error) {
+			<-release
+			return fhResponse(200, map[string]any{"ok": true}, nil), nil
+		}
+		f := feat.NewTimeoutFeature()
+		h := fhMake(server, fhF(f, map[string]any{"ms": 2000, "now": now}))
+		began := time.Now()
+		res := h.op(fhOpSpec{op: "load"})
+		took := time.Since(began)
+		close(release)
+		if fhErrCode(res.err) != "timeout" {
+			t.Errorf("expected timeout error, got %v", res.err)
+		}
+		if time.Second < took {
+			t.Errorf("expected the spent deadline to time out at once, took %v", took)
+		}
+	})
+
 	t.Run("fast-request-passes", func(t *testing.T) {
 		h := fhMake(nil, fhF(feat.NewTimeoutFeature(), map[string]any{"ms": 1000}))
 		if res := h.op(fhOpSpec{op: "load"}); !res.ok {

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

@@ -806,6 +806,43 @@ func (f *testInitFeature) Init(ctx *sdk.Context, options map[string]any) {
 	}
 }
 
+// A typed slice in the call's match is a list to the struct port, so a cookie
+// argument repeats its name for each item rather than sending the slice's
+// text.
+func TestPrepareHeadersCookieTypedSlice(t *testing.T) {
+	client := sdk.TestSDK(nil, nil)
+	utility := client.GetUtility()
+	ctx := makeTestCtx(client, utility, nil)
+	ctx.Point = map[string]any{
+		"args": map[string]any{"cookie": []any{
+			map[string]any{"name": "theme", "orig": "theme", "kind": "cookie"},
+		}},
+	}
+	ctx.Reqmatch = map[string]any{"theme": []string{"dark", "x y"}}
+	headers := utility.PrepareHeaders(ctx)
+	if "theme=dark; theme=x%20y" != headers["cookie"] {
+		t.Errorf("expected the slice as repeated pairs, got %v", headers["cookie"])
+	}
+}
+
+// A typed map is a map to a cookie argument as a typed slice is a list: its
+// keys go out as pairs, and replace the caller's cookies of those names.
+func TestPrepareHeadersCookieTypedMap(t *testing.T) {
+	client := sdk.TestSDK(nil, map[string]any{"headers": map[string]any{"Cookie": "lang=old; theme=dark"}})
+	utility := client.GetUtility()
+	ctx := makeTestCtx(client, utility, nil)
+	ctx.Point = map[string]any{
+		"args": map[string]any{"cookie": []any{
+			map[string]any{"name": "prefs", "orig": "prefs", "kind": "cookie"},
+		}},
+	}
+	ctx.Reqmatch = map[string]any{"prefs": map[string]string{"size": "2", "lang": "en gb"}}
+	headers := utility.PrepareHeaders(ctx)
+	if "theme=dark; lang=en%20gb; size=2" != headers["cookie"] {
+		t.Errorf("expected the map as its pairs, got %v", headers["cookie"])
+	}
+}
+
 // Helper: create basic test context
 func makeTestCtx(client *sdk.ProjectNameSDK, utility *sdk.Utility, overrides map[string]any) *sdk.Context {
 	ctxmap := map[string]any{
@@ -841,7 +878,6 @@ func makeTestFullCtx(client *sdk.ProjectNameSDK, utility *sdk.Utility) *sdk.Cont
 // useVS prevents unused import error
 var _ = vs.Clone
 
-
 // retargetAuth rewrites the corpus's `headers` bag to the container this
 // SDK's PrepareAuth writes to, and the `authorization` key inside it to the
 // API's own credential name. Applied only to the prepareAuth section, so