@voxgig/sdkgen 3.5.1 → 3.7.0

package/project/.sdk/tm/elixir/test/primary_utility_test.exs

@@ -112,6 +112,78 @@ defmodule ProjectName.PrimaryUtilityTest do
     assert S.getpath(opts, "__derived__.clean.keyre") == "key|token|id"
   end
 
+  # --- feature add-order ----------------------------------------------------
+  # options.feature accepts an ordered LIST (developer add-order) or a map
+  # (defaults test-first); make_options records the resolved order in
+  # __derived__.featureorder. Driven with a synthetic ctx (empty config
+  # options) so the assertions do not depend on this SDK's own features.
+
+  defp resolve_order(feature) do
+    ctx =
+      S.jm([
+        "utility", Utility.new(),
+        "options", H.deep(%{"feature" => feature}),
+        "config", H.deep(%{"options" => %{}})
+      ])
+
+    fo = S.getpath(Utility.make_options(ctx), "__derived__.featureorder")
+    n = S.size(fo)
+    order = if n == 0, do: [], else: Enum.map(0..(n - 1), fn i -> S.getelem(fo, i) end)
+    Enum.join(order, ",")
+  end
+
+  test "feature order: map form is test-first" do
+    assert "test,metrics" ==
+             resolve_order(%{"metrics" => %{"active" => true}, "test" => %{"active" => true}})
+  end
+
+  test "feature order: an explicit list preserves its order" do
+    assert "metrics,test" ==
+             resolve_order([
+               %{"name" => "metrics", "active" => true},
+               %{"name" => "test", "active" => true}
+             ])
+  end
+
+  # Station special case, mirroring test's: its transport wrap must sit
+  # immediately outside the base transport, so map-form activation hoists
+  # it to just after test - or first, when no test entry exists.
+  test "feature order: map form hoists station after test" do
+    assert "test,station,metrics" ==
+             resolve_order(%{
+               "metrics" => %{"active" => true},
+               "station" => %{"active" => true},
+               "test" => %{"active" => true}
+             })
+  end
+
+  test "feature order: station first when no test entry exists" do
+    assert "station,metrics" ==
+             resolve_order(%{
+               "metrics" => %{"active" => true},
+               "station" => %{"active" => true}
+             })
+  end
+
+  # The extend seam (feature INSTANCES supplied at construction - the
+  # station adopt path): validate must accept the key verbatim, or the
+  # constructor's extend loop reads a stripped option and the seam is dead.
+  test "make_options preserves options.extend through validation" do
+    marker = S.jm(["name", "station"])
+
+    ctx =
+      S.jm([
+        "utility", Utility.new(),
+        "options", S.jm(["extend", S.jt([marker])]),
+        "config", H.deep(%{"options" => %{}})
+      ])
+
+    extend = S.getprop(Utility.make_options(ctx), "extend")
+    assert S.islist(extend)
+    assert S.size(extend) == 1
+    assert S.getprop(S.getelem(extend, 0), "name") == "station"
+  end
+
   test "make_error formats a namespaced message and raises by default" do
     c = client()
     ctx = ctx(c, "load")

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

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"math/rand"
 	"regexp"
+	"strings"
 
 	vs "github.com/voxgig/struct"
 
@@ -310,9 +311,40 @@ func (f *TestFeature) makeNetsim(net map[string]any, inner core.FetcherFunc) cor
 func (f *TestFeature) buildArgs(ctx *core.Context, op *core.Operation, args map[string]any) any {
 	opname := op.Name
 
-	// Get last point from config.
+	// Pick the entity's own endpoint from config, not a cross-reference from
+	// another resource that also returns it — the same rule makePoint falls
+	// back to, so the seed-data query is built from the endpoint the request
+	// will actually be sent to: a terminal `{id}` marks a record route, and
+	// failing that the shallower path wins.
 	points := vs.GetPath([]any{"entity", ctx.Entity.GetName(), "op", opname, "points"}, ctx.Config)
-	point := vs.GetElem(points, -1)
+	point := vs.GetElem(points, 0)
+	if plist, ok := points.([]any); ok {
+		partsLen := func(p any) int {
+			if parts, ok := vs.GetProp(p, "parts").([]any); ok {
+				return len(parts)
+			}
+			return 0
+		}
+		terminalParam := func(p any) bool {
+			parts, ok := vs.GetProp(p, "parts").([]any)
+			if !ok || 0 == len(parts) {
+				return false
+			}
+			last, _ := parts[len(parts)-1].(string)
+			return strings.HasPrefix(last, "{")
+		}
+		for _, cand := range plist {
+			candTerm := terminalParam(cand)
+			bestTerm := terminalParam(point)
+			if candTerm != bestTerm {
+				if candTerm {
+					point = cand
+				}
+			} else if partsLen(cand) < partsLen(point) {
+				point = cand
+			}
+		}
+	}
 
 	// Get required params.
 	paramsPath := vs.GetPath([]any{"args", "params"}, point)

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

@@ -1,6 +1,7 @@
 package sdktest
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 	"testing"
@@ -556,27 +557,48 @@ func TestPrimaryUtility(t *testing.T) {
 		})
 	})
 
+	// Was one hand-written case (the single-point path) covering one of this
+	// utility's seven branches, which is how the corpus fixture came to be
+	// marked deferred as "needs a real client". It does not: NewContext
+	// rebuilds Op from opname + entity + config, and Options can be supplied
+	// literally. Driven from the corpus now, so TS and Go assert the same
+	// branches.
+	//
+	// TS returns the error AS the value; Go returns it as a second result. The
+	// corpus says `match: out: code` for both, so the error is normalised to a
+	// map carrying its code here rather than forking the fixture per language.
 	t.Run("makePoint-basic", func(t *testing.T) {
-		ctx := makeTestCtx(client, utility, nil)
-		point := map[string]any{
-			"parts":     []any{"items", "{id}"},
-			"args":      map[string]any{"params": []any{}},
-			"params":    []any{},
-			"alias":     map[string]any{},
-			"select":    map[string]any{},
-			"active":    true,
-			"transform": map[string]any{},
-		}
-		ctx.Op.Points = []map[string]any{point}
-
-		_, err := utility.MakePoint(ctx)
-		if err != nil {
-			t.Errorf("expected no error, got: %v", err)
-			return
-		}
-		if ctx.Point == nil {
-			t.Error("expected point to be set")
-		}
+		runsetNamed(t, "makePoint", getSpec(primary, "makePoint", "basic"), func(entry map[string]any) (any, error) {
+			ctxmap, _ := entry["ctx"].(map[string]any)
+
+			// NewContext resolves Op from the ENTITY NAME, and reaches it
+			// through the Entity interface — a literal {name:...} map from the
+			// fixture is not one, so entname would be "" and every lookup would
+			// miss, reporting point_no_points for all seven cases. TS reads the
+			// same field with getprop and accepts the plain map. Swap in the
+			// package's minimal Entity so both ports resolve the same op.
+			if em, ok := ctxmap["entity"].(map[string]any); ok {
+				name, _ := em["name"].(string)
+				made := []any{}
+				swapped := map[string]any{}
+				for k, v := range ctxmap {
+					swapped[k] = v
+				}
+				swapped["entity"] = &plEntity{name: name, made: &made}
+				ctxmap = swapped
+			}
+
+			ctx := makeCtxFromMap(ctxmap, client, utility)
+			point, err := utility.MakePoint(ctx)
+			if err != nil {
+				var sdkErr *sdk.ProjectNameError
+				if errors.As(err, &sdkErr) {
+					return map[string]any{"code": sdkErr.Code}, nil
+				}
+				return nil, err
+			}
+			return point, nil
+		})
 	})
 
 	t.Run("makeUrl-basic", func(t *testing.T) {

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

@@ -218,7 +218,7 @@ type RunSubject func(entry map[string]any) (any, error)
 // PENDING sections are the ones deliberately left empty in the shared corpus
 // (.sdk/test/primary/<name>.aontu). Everything else MUST contribute cases.
 var pendingSections = map[string]bool{
-	"fetcher": true, "makeFetchDef": true, "makePoint": true, "makeResult": true,
+	"fetcher": true, "makeFetchDef": true, "makeResult": true,
 	"featureAdd": true, "featureHook": true, "featureInit": true,
 }
 

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

@@ -57,6 +57,20 @@ 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 {
+			return http.ErrUseLastResponse
+		}
+		client = &manual
+	}
+
 	resp, err := client.Do(req)
 	if err != nil {
 		return nil, err

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

@@ -217,17 +217,44 @@ func makeOptionsUtil(ctx *core.Context) map[string]any {
 				hasTest = true
 			}
 		}
+		ordered := make([]string, 0, len(names))
 		if hasTest {
-			featureorder = append(featureorder, "test")
+			ordered = append(ordered, "test")
 			for _, n := range names {
 				if n != "test" {
-					featureorder = append(featureorder, n)
+					ordered = append(ordered, n)
 				}
 			}
 		} else {
-			for _, n := range names {
-				featureorder = append(featureorder, n)
+			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" {
+				si = i
+				break
+			}
+		}
+		if si >= 0 {
+			ordered = append(ordered[:si], ordered[si+1:]...)
+			ti := 0
+			for i, n := range ordered {
+				if n == "test" {
+					ti = i + 1
+					break
+				}
 			}
+			ordered = append(ordered[:ti],
+				append([]string{"station"}, ordered[ti:]...)...)
+		}
+		for _, n := range ordered {
+			featureorder = append(featureorder, n)
 		}
 	}
 

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

@@ -8,6 +8,47 @@ import (
 	"GOMODULE/core"
 )
 
+// How many path segments a point has.
+func partsLen(point map[string]any) int {
+	if parts, ok := vs.GetProp(point, "parts").([]any); ok {
+		return len(parts)
+	}
+	return 0
+}
+
+// Does this point's path end in a parameter? A record route ends in the
+// record's identifier (`/boards/{id}`); a cross-reference that also returns
+// the entity ends in the relationship's name (`/posts/{id}/author`).
+func terminalParam(point map[string]any) bool {
+	parts, ok := vs.GetProp(point, "parts").([]any)
+	if !ok || 0 == len(parts) {
+		return false
+	}
+	last, _ := parts[len(parts)-1].(string)
+	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 {
+		candTerm := terminalParam(cand)
+		bestTerm := terminalParam(best)
+		if candTerm != bestTerm {
+			if candTerm {
+				best = cand
+			}
+		} else if partsLen(cand) < partsLen(best) {
+			best = cand
+		}
+	}
+	return best
+}
+
 func makePointUtil(ctx *core.Context) (map[string]any, error) {
 	if ctx.Out["point"] != nil {
 		// A PrePoint feature hook (e.g. rbac) may short-circuit the
@@ -52,9 +93,10 @@ func makePointUtil(ctx *core.Context) (map[string]any, error) {
 		}
 
 		var point map[string]any
+		matched := false
 		for i := 0; i < len(op.Points); i++ {
-			point = op.Points[i]
-			selectDef := core.ToMapAny(vs.GetProp(point, "select"))
+			cand := op.Points[i]
+			selectDef := core.ToMapAny(vs.GetProp(cand, "select"))
 			found := true
 
 			if selector != nil && selectDef != nil {
@@ -82,10 +124,32 @@ func makePointUtil(ctx *core.Context) (map[string]any, error) {
 			}
 
 			if found {
+				point = cand
+				matched = true
 				break
 			}
 		}
 
+		// select.exist can list more than the params needed to pick a point,
+		// 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+
+						"\" action \""+vs.Stringify(vs.GetProp(reqselector, "$action"))+
+						"\" is not valid.")
+			}
+
+			point = ownPoint(op.Points)
+		}
+
 		if reqselector != nil {
 			reqAction := vs.GetProp(reqselector, "$action")
 			if reqAction != nil && point != nil {

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

@@ -26,6 +26,29 @@ public class TestFeature extends BaseFeature {
   private Map<String, Object> options;
   private int netcalls = 0;
 
+  // How many path segments a point has, and whether its path ends in a
+  // parameter — the rule makePoint uses to tell the entity's own route from a
+  // cross-reference that also returns it.
+  @SuppressWarnings("unchecked")
+  private static int pointPartsLen(Object point) {
+    Object parts = Struct.getprop(point, "parts");
+    return parts instanceof List ? ((List<Object>) parts).size() : 0;
+  }
+
+  @SuppressWarnings("unchecked")
+  private static boolean pointTerminalParam(Object point) {
+    Object parts = Struct.getprop(point, "parts");
+    if (!(parts instanceof List)) {
+      return false;
+    }
+    List<Object> list = (List<Object>) parts;
+    if (list.isEmpty()) {
+      return false;
+    }
+    Object last = list.get(list.size() - 1);
+    return last instanceof String && ((String) last).startsWith("{");
+  }
+
   public TestFeature() {
     super("test", "0.0.1", true);
   }
@@ -289,11 +312,28 @@ public class TestFeature extends BaseFeature {
   private Object buildArgs(Context ctx, Operation op, Map<String, Object> args) {
     String opname = op.name;
 
-    // Get last point from config.
+    // Pick the entity's own endpoint from config, not a cross-reference from
+    // another resource that also returns it — the same rule makePoint falls
+    // back to, so the seed-data query is built from the endpoint the request
+    // will actually be sent to: a terminal `{id}` marks a record route, and
+    // failing that the shallower path wins.
     Object points = Struct.getpath(ctx.config,
         List.of("entity", ctx.entity == null ? "" : ctx.entity.getName(),
             "op", opname, "points"));
-    Object point = Struct.getelem(points, -1);
+    Object point = Struct.getelem(points, 0);
+    if (points instanceof List) {
+      for (Object cand : (List<Object>) points) {
+        boolean candTerm = pointTerminalParam(cand);
+        boolean bestTerm = pointTerminalParam(point);
+        if (candTerm != bestTerm) {
+          if (candTerm) {
+            point = cand;
+          }
+        } else if (pointPartsLen(cand) < pointPartsLen(point)) {
+          point = cand;
+        }
+      }
+    }
 
     // Get required params.
     Object paramsPath = Struct.getpath(point, List.of("args", "params"));

package/project/.sdk/tm/java/utility/Fetcher.java

@@ -59,10 +59,20 @@ final class Fetcher {
       reqb.setHeader("User-Agent", "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)");
     }
 
+    // Honour a redirect annotation on the fetch definition (set by the
+    // station feature's middleware under a hosts policy): "manual" returns
+    // a 3xx like any other response instead of following it — the ts
+    // donor's fetch honours the same key natively, and an automatic follow
+    // would carry injected credentials to a host no policy approved.
+    HttpClient.Redirect redirectPolicy =
+        "manual".equals(fetchdef.get("redirect"))
+            ? HttpClient.Redirect.NEVER
+            : HttpClient.Redirect.NORMAL;
+
     // Honour a proxy annotation on the fetch definition (set by the proxy
     // feature): route the request through a proxied HttpClient.
     HttpClient.Builder clientb = HttpClient.newBuilder()
-        .followRedirects(HttpClient.Redirect.NORMAL);
+        .followRedirects(redirectPolicy);
     Object proxy = fetchdef.get("proxy");
     if (proxy instanceof String && !"".equals(proxy)) {
       try {

package/project/.sdk/tm/java/utility/MakeOptions.java

@@ -156,6 +156,17 @@ final class MakeOptions {
       else {
         featureorder.addAll(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.
+      int si = featureorder.indexOf("station");
+      if (0 <= si) {
+        featureorder.remove(si);
+        featureorder.add(featureorder.indexOf("test") + 1, "station");
+      }
     }
 
     Map<String, Object> derived = new LinkedHashMap<>();

package/project/.sdk/tm/java/utility/MakePoint.java

@@ -14,6 +14,31 @@ final class MakePoint {
 
   private MakePoint() {}
 
+  // How many path segments a point has.
+  private static int partsLen(Map<String, Object> point) {
+    Object parts = Struct.getprop(point, "parts");
+    return parts instanceof List ? ((List<Object>) parts).size() : 0;
+  }
+
+  // Does this point's path end in a parameter? A record route ends in the
+  // record's identifier (/boards/{id}); a cross-reference that also returns
+  // the entity ends in the relationship's name (/posts/{id}/author). That,
+  // then fewest segments, is what tells the entity's own route from a
+  // cross-reference. The same rule runs at generation time, in
+  // helpers/opShape.ts — both sides must move together.
+  private static boolean terminalParam(Map<String, Object> point) {
+    Object parts = Struct.getprop(point, "parts");
+    if (!(parts instanceof List)) {
+      return false;
+    }
+    List<Object> list = (List<Object>) parts;
+    if (list.isEmpty()) {
+      return false;
+    }
+    Object last = list.get(list.size() - 1);
+    return last instanceof String && ((String) last).startsWith("{");
+  }
+
   static Map<String, Object> makePoint(Context ctx) {
     Object outPoint = ctx.out.get("point");
     if (outPoint != null) {
@@ -62,10 +87,11 @@ final class MakePoint {
       }
 
       Map<String, Object> point = null;
+      boolean matched = false;
       for (int i = 0; i < op.points.size(); i++) {
-        point = op.points.get(i);
+        Map<String, Object> cand = op.points.get(i);
         Map<String, Object> selectDef =
-            Helpers.toMapAny(Struct.getprop(point, "select"));
+            Helpers.toMapAny(Struct.getprop(cand, "select"));
         boolean found = true;
 
         if (selector != null && selectDef != null) {
@@ -92,10 +118,43 @@ final class MakePoint {
         }
 
         if (found) {
+          point = cand;
+          matched = true;
           break;
         }
       }
 
+      // select.exist can list more than the params needed to pick a point, 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.
+        Object unmatchedAction =
+            reqselector != null ? Struct.getprop(reqselector, "$action", null) : null;
+        if (unmatchedAction != null) {
+          throw ctx.makeError("point_action_invalid",
+              "Operation \"" + op.name
+                  + "\" action \"" + Struct.stringify(unmatchedAction) + "\" is not valid.");
+        }
+
+        point = op.points.get(0);
+        for (Map<String, Object> cand : op.points) {
+          boolean candTerm = terminalParam(cand);
+          boolean bestTerm = terminalParam(point);
+          if (candTerm != bestTerm) {
+            if (candTerm) {
+              point = cand;
+            }
+          } else if (partsLen(cand) < partsLen(point)) {
+            point = cand;
+          }
+        }
+      }
+
       if (reqselector != null) {
         Object reqAction = Struct.getprop(reqselector, "$action", null);
         if (reqAction != null && point != null) {

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

@@ -251,9 +251,28 @@ class TestFeature extends BaseFeature {
     const isempty = struct.isempty
 
     const opname = getprop(op, 'name')
-    const point =
-      getelem(getpath(ctx.config, [
-        'entity', getprop(ctx.entity, 'name'), 'op', opname, 'points']), -1)
+    const points = getpath(ctx.config, [
+      'entity', getprop(ctx.entity, 'name'), 'op', opname, 'points']) || []
+
+    // Pick the entity's own endpoint, not a cross-reference from another
+    // resource that also returns it — the same rule makePoint falls back to,
+    // so the seed-data query is built from the endpoint the request will
+    // actually be sent to: a terminal `{id}` marks a record route, and
+    // failing that the shallower path wins.
+    const isterm = (pt) => {
+      const parts = pt.parts
+      const last = 0 < parts.length ? parts[parts.length - 1] : ''
+      return 'string' === typeof last && 0 === last.indexOf('{')
+    }
+
+    let point = getelem(points, 0)
+    for (let i = 1; i < points.length; i++) {
+      const cand = getelem(points, i)
+      if (isterm(cand) !== isterm(point) ? isterm(cand) :
+        cand.parts.length < point.parts.length) {
+        point = cand
+      }
+    }
 
     const reqd = transform(
       select(getpath(point, ['args', 'params']), { reqd: true }),

package/project/.sdk/tm/js/src/utility/MakeOptionsUtility.js

@@ -68,6 +68,12 @@ function makeOptions(ctx) {
       }
     },
     utility: {},
+    // 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.
+    extend: '`$ANY`',
     system: {
       fetch: undefined
     },
@@ -131,10 +137,22 @@ function makeOptions(ctx) {
   // otherwise order the map test-first, then the remaining names sorted, so
   // the outcome is deterministic and `test` is always the base transport.
   if (0 === featureorder.length) {
-    const names = Object.keys(opts.feature || {}).sort()
-    featureorder = names.indexOf('test') < 0
+    let names = Object.keys(opts.feature || {}).sort()
+    names = names.indexOf('test') < 0
       ? names
       : ['test'].concat(names.filter((n) => 'test' !== n))
+    // 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.
+    const si = names.indexOf('station')
+    if (0 <= si) {
+      names.splice(si, 1)
+      names.splice(names.indexOf('test') + 1, 0, 'station')
+    }
+    featureorder = names
   }
 
   opts.__derived__ = {