@voxgig/sdkgen 3.5.1 → 3.6.0

package/project/.sdk/tm/dart/lib/utility/MakePointUtility.dart

@@ -34,9 +34,10 @@ dynamic makePoint(dynamic ctx) {
     final selector = 'data' == op.input ? ctx.data : ctx.match;
 
     dynamic point;
+    var matched = false;
     for (var i = 0; i < op.points.length; i++) {
-      point = op.points[i];
-      final select = point.select;
+      final cand = op.points[i];
+      final select = cand.select;
       var found = true;
 
       final exist = vs.getprop(select, 'exist');
@@ -60,10 +61,55 @@ dynamic makePoint(dynamic ctx) {
       }
 
       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 (null != vs.getprop(reqselector, r'$action')) {
+        return ctx.error(
+            'point_action_invalid',
+            'Operation "' +
+                op.name.toString() +
+                '" action "' +
+                vs.getprop(reqselector, r'$action').toString() +
+                '" is not valid.');
+      }
+
+      // A terminal parameter marks a record route (/boards/{id}); a
+      // cross-reference ends in the relationship's name
+      // (/posts/{id}/author). Failing that, the shallower path wins.
+      bool terminalParam(dynamic p) {
+        final parts = p.parts;
+        if (parts.isEmpty) {
+          return false;
+        }
+        final last = parts[parts.length - 1];
+        return last is String && last.startsWith('{');
+      }
+
+      point = op.points[0];
+      for (final cand in op.points) {
+        if (terminalParam(cand) != terminalParam(point)) {
+          if (terminalParam(cand)) {
+            point = cand;
+          }
+        } else if (cand.parts.length < point.parts.length) {
+          point = cand;
+        }
+      }
+    }
+
     if (null != vs.getprop(reqselector, r'$action') &&
         null != point &&
         vs.getprop(reqselector, r'$action') !=

package/project/.sdk/tm/elixir/lib/projectname/utility.ex

@@ -465,21 +465,81 @@ defmodule ProjectName.Utility do
 
                 if found, do: {:halt, point}, else: {:cont, point}
             end)
-            |> elem(1)
 
-          err =
-            if reqselector != nil do
-              req_action = S.getprop(reqselector, "$action")
+          matched? = match?({:halt, _}, point)
+
+          point =
+            if matched? do
+              elem(point, 1)
+            else
+              # select.exist can list more than the params needed to pick a
+              # point, so nothing matched. Fall back to the entity's own
+              # route: a terminal parameter marks a record route
+              # (/boards/{id}) where a cross-reference ends in the
+              # relationship's name (/posts/{id}/author), and failing that
+              # the shallower path wins. The same rule runs at generation
+              # time, in helpers/opShape.ts — both sides must move together.
+              parts_len = fn p ->
+                parts = S.getprop(p, "parts")
+                if S.islist(parts), do: S.size(parts), else: 0
+              end
 
-              if req_action != nil and point != nil do
-                point_select = H.to_map(S.getprop(point, "select"))
-                point_action = S.getprop(point_select, "$action")
+              terminal_param? = fn p ->
+                parts = S.getprop(p, "parts")
 
-                if req_action != point_action do
-                  Context.make_error(ctx, "point_action_invalid",
-                    "Operation \"" <> opname <> "\" action \"" <> S.stringify(req_action) <> "\" is not valid.")
+                if S.islist(parts) and S.size(parts) > 0 do
+                  last = S.getelem(parts, S.size(parts) - 1)
+                  is_binary(last) and String.starts_with?(last, "{")
+                else
+                  false
                 end
               end
+
+              Enum.reduce(0..(npoints - 1), S.getelem(points, 0), fn i, best ->
+                cand = S.getelem(points, i)
+                ct = terminal_param?.(cand)
+                bt = terminal_param?.(best)
+
+                cond do
+                  ct != bt -> if ct, do: cand, else: best
+                  parts_len.(cand) < parts_len.(best) -> cand
+                  true -> best
+                end
+              end)
+            end
+
+          unmatched_action =
+            if not matched? and reqselector != nil,
+              do: S.getprop(reqselector, "$action"),
+              else: nil
+
+          err =
+            cond do
+              # A request naming an action reaches the fallback only because
+              # that action's own point failed its exist test, so it is
+              # unbuildable whatever we pick. Refuse it BEFORE the guard
+              # below, which compares the chosen point's $action and would
+              # wave the request through whenever the fallback lands on the
+              # action point itself.
+              unmatched_action != nil ->
+                Context.make_error(ctx, "point_action_invalid",
+                  "Operation \"" <> opname <> "\" action \"" <> S.stringify(unmatched_action) <> "\" is not valid.")
+
+              reqselector != nil ->
+                req_action = S.getprop(reqselector, "$action")
+
+                if req_action != nil and point != nil do
+                  point_select = H.to_map(S.getprop(point, "select"))
+                  point_action = S.getprop(point_select, "$action")
+
+                  if req_action != point_action do
+                    Context.make_error(ctx, "point_action_invalid",
+                      "Operation \"" <> opname <> "\" action \"" <> S.stringify(req_action) <> "\" is not valid.")
+                  end
+                end
+
+              true ->
+                nil
             end
 
           if err != nil do

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/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/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/MakePointUtility.js

@@ -1,4 +1,50 @@
 
+// The entity's OWN route among an op's points, as opposed to a
+// CROSS-REFERENCE: another resource's route that happens to return this
+// entity (`/notifications/{id}/board` for a board). Both are plain GETs
+// with no `$action`, so the path itself is all there is to go on.
+//
+// Two signals, in order:
+//
+//   1. A record route ends in the record's identifier (`/boards/{id}`,
+//      `/accounts/{account_id}/users/{id}`); a cross-reference ends in the
+//      relationship's name (`/posts/{id}/author`). A terminal parameter is
+//      therefore the stronger signal, and unlike depth it survives an entity
+//      nested more deeply than the route pointing at it.
+//   2. Failing that, fewest path segments — the shallower route is the one
+//      the entity is named for.
+//
+// Ties keep the earlier point, so the sorted-key order of the model decides
+// and the output stays byte-stable.
+//
+// The same rule runs at GENERATION time, in `ownPoint` in
+// helpers/opShape.ts. It cannot be shared with this file — a template ships
+// standalone, outside that package — so it is written twice on purpose, and
+// both sides must move together.
+function terminalParam(point) {
+  const parts = point.parts
+  const last = 0 < parts.length ? parts[parts.length - 1] : ''
+  return 'string' === typeof last && 0 === last.indexOf('{')
+}
+
+
+function ownPoint(points) {
+  let best = points[0]
+
+  for (const cand of points) {
+    const candterm = terminalParam(cand)
+    const bestterm = terminalParam(best)
+
+    if (candterm !== bestterm ? candterm :
+      cand.parts.length < best.parts.length) {
+      best = cand
+    }
+  }
+
+  return best
+}
+
+
 function makePoint(ctx) {
   if (ctx.out.point) {
     return ctx.point = ctx.out.point
@@ -28,9 +74,10 @@ function makePoint(ctx) {
     const selector = getprop(ctx, op.input)
 
     let point
+    let matched = false
     for (let i = 0; i < op.points.length; i++) {
-      point = op.points[i]
-      const select = point.select
+      const cand = op.points[i]
+      const select = cand.select
       let found = true
 
       if (selector && select.exist) {
@@ -53,10 +100,33 @@ function makePoint(ctx) {
       }
 
       if (found) {
+        point = cand
+        matched = true
         break
       }
     }
 
+    // select.exist can list more than the params needed to pick a point (for
+    // /boards/{id} it is Trello's 17 optional query-includes), so a plain
+    // {id} call matches NOTHING. 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 the request 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 action point is itself the one the
+      // fallback selects (a short action route folded into an entity whose
+      // canonical route is longer). An unbuildable action request is an
+      // error, never a silent request to some other endpoint.
+      if (null != reqselector.$action) {
+        return ctx.error('point_action_invalid', 'Operation "' + op.name +
+          '" action "' + reqselector.$action + '" is not valid.')
+      }
+
+      point = ownPoint(op.points)
+    }
+
     if (
       null != reqselector.$action &&
       null != point &&

package/project/.sdk/tm/kotlin/feature/TestFeature.kt

@@ -262,12 +262,41 @@ class TestFeature : BaseFeature("test", "0.0.1", true) {
   private fun buildArgs(ctx: Context, op: Operation, args: MutableMap<String, Any?>?): Any? {
     val 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.
     val points = Struct.getpath(
       ctx.config,
       listOf("entity", if (ctx.entity == null) "" else ctx.entity!!.name, "op", opname, "points"),
     )
-    val point = Struct.getelem(points, -1)
+    var point = Struct.getelem(points, 0)
+    if (points is List<*>) {
+      fun pointPartsLen(p: Any?): Int {
+        val parts = Struct.getprop(p, "parts")
+        return if (parts is List<*>) parts.size else 0
+      }
+      fun pointTerminalParam(p: Any?): Boolean {
+        val parts = Struct.getprop(p, "parts")
+        if (parts !is List<*> || parts.isEmpty()) {
+          return false
+        }
+        val last = parts[parts.size - 1]
+        return last is String && last.startsWith("{")
+      }
+      for (cand in points) {
+        val candTerm = pointTerminalParam(cand)
+        val bestTerm = pointTerminalParam(point)
+        if (candTerm != bestTerm) {
+          if (candTerm) {
+            point = cand
+          }
+        } else if (pointPartsLen(cand) < pointPartsLen(point)) {
+          point = cand
+        }
+      }
+    }
 
     // Get required params.
     val paramsPath = Struct.getpath(point, listOf("args", "params"))