@voxgig/sdkgen 3.5.0 → 3.6.0

package/project/.sdk/tm/rust/utility/make_point.rs

@@ -7,6 +7,33 @@ use crate::core::types::OutVal;
 use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
+// How many path segments a point has.
+fn parts_len(point: &Value) -> usize {
+    match getp(point, "parts") {
+        Value::List(l) => l.borrow().len(),
+        _ => 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.
+fn terminal_param(point: &Value) -> bool {
+    match getp(point, "parts") {
+        Value::List(l) => {
+            let parts = l.borrow();
+            match parts.last() {
+                Some(Value::Str(s)) => s.starts_with('{'),
+                _ => false,
+            }
+        }
+        _ => false,
+    }
+}
+
 pub fn make_point_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
     match ctx.out_get("point") {
         // A PrePoint feature hook (e.g. rbac) may short-circuit the
@@ -60,9 +87,10 @@ pub fn make_point_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
         };
 
         let mut point = Value::Noval;
+        let mut matched = false;
         for i in 0..plen {
-            point = vs::get_elem(&points, &Value::Num(i as f64), Value::Noval);
-            let select_def = to_map(&getp(&point, "select"));
+            let cand = vs::get_elem(&points, &Value::Num(i as f64), Value::Noval);
+            let select_def = to_map(&getp(&cand, "select"));
             let mut found = true;
 
             if !selector.is_noval() && !select_def.is_noval() {
@@ -89,10 +117,49 @@ pub fn make_point_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
             }
 
             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.
+            let unmatched_action = getp(&reqselector, "$action");
+            if !unmatched_action.is_noval() {
+                return Err(ctx.make_error(
+                    "point_action_invalid",
+                    &format!(
+                        "Operation \"{}\" action \"{}\" is not valid.",
+                        op.name,
+                        vs::stringify(&unmatched_action, None, false)
+                    ),
+                ));
+            }
+
+            point = vs::get_elem(&points, &Value::Num(0.0), Value::Noval);
+            for i in 0..plen {
+                let cand = vs::get_elem(&points, &Value::Num(i as f64), Value::Noval);
+                let cand_term = terminal_param(&cand);
+                let best_term = terminal_param(&point);
+                if cand_term != best_term {
+                    if cand_term {
+                        point = cand;
+                    }
+                } else if parts_len(&cand) < parts_len(&point) {
+                    point = cand;
+                }
+            }
+        }
+
         let req_action = getp(&reqselector, "$action");
         if !req_action.is_noval() && !point.is_noval() {
             let point_select = to_map(&getp(&point, "select"));

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

@@ -215,9 +215,44 @@ class TestFeature extends BaseFeature("test", "0.0.1", true) {
   private def buildArgs(ctx: Context, op: Operation, args: JMap[String, Object]): Object = {
     val opname = op.name
 
+    // 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,
       java.util.List.of("entity", if (ctx.entity == null) "" else ctx.entity.getName(), "op", opname, "points"))
-    val point = Struct.getelem(points, java.lang.Integer.valueOf(-1))
+    var point = Struct.getelem(points, java.lang.Integer.valueOf(0))
+    points match {
+      case plist: java.util.List[_] =>
+        def pointPartsLen(p: Object): Int =
+          Struct.getprop(p, "parts") match {
+            case parts: java.util.List[_] => parts.size()
+            case _ => 0
+          }
+        def pointTerminalParam(p: Object): Boolean =
+          Struct.getprop(p, "parts") match {
+            case parts: java.util.List[_] if parts.size() > 0 =>
+              parts.get(parts.size() - 1) match {
+                case s: String => s.startsWith("{")
+                case _ => false
+              }
+            case _ => false
+          }
+        var k = 0
+        while (k < plist.size()) {
+          val cand = plist.get(k).asInstanceOf[Object]
+          val candTerm = pointTerminalParam(cand)
+          val bestTerm = pointTerminalParam(point)
+          if (candTerm != bestTerm) {
+            if (candTerm) point = cand
+          } else if (pointPartsLen(cand) < pointPartsLen(point)) {
+            point = cand
+          }
+          k += 1
+        }
+      case _ =>
+    }
 
     val paramsPath = Struct.getpath(point, java.util.List.of("args", "params"))
     val reqdParams = Struct.select(paramsPath, Struct.jm("reqd", java.lang.Boolean.TRUE))

package/project/.sdk/tm/scala/utility/Make.scala

@@ -94,11 +94,12 @@ object MakePoint {
       val selector: JMap[String, Object] = if ("data" == op.input) ctx.data else ctx.matchData
 
       var point: JMap[String, Object] = null
+      var matched = false
       var i = 0
       var break = false
       while (i < op.points.size() && !break) {
-        point = op.points.get(i)
-        val selectDef = Helpers.toMapAny(Struct.getprop(point, "select"))
+        val cand = op.points.get(i)
+        val selectDef = Helpers.toMapAny(Struct.getprop(cand, "select"))
         var found = true
 
         if (selector != null && selectDef != null) {
@@ -122,7 +123,60 @@ object MakePoint {
           if (!Objects.equals(reqAction, selectAction)) found = false
         }
 
-        if (found) break = true else i += 1
+        if (found) { point = cand; matched = true; break = true } else i += 1
+      }
+
+      // 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 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.
+        val unmatchedAction =
+          if (reqselector != null) Struct.getprop(reqselector, "$action", null) else null
+        if (unmatchedAction != null) {
+          throw ctx.makeError("point_action_invalid",
+            "Operation \"" + op.name + "\" action \"" +
+              Struct.stringify(unmatchedAction) + "\" 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. The
+        // same rule runs at generation time, in helpers/opShape.ts — both
+        // sides must move together.
+        def partsLen(p: JMap[String, Object]): Int =
+          Struct.getprop(p, "parts") match {
+            case parts: JList[_] => parts.size()
+            case _ => 0
+          }
+        def terminalParam(p: JMap[String, Object]): Boolean =
+          Struct.getprop(p, "parts") match {
+            case parts: JList[_] if parts.size() > 0 =>
+              parts.get(parts.size() - 1) match {
+                case s: String => s.startsWith("{")
+                case _ => false
+              }
+            case _ => false
+          }
+
+        point = op.points.get(0)
+        var j = 0
+        while (j < op.points.size()) {
+          val cand = op.points.get(j)
+          val candTerm = terminalParam(cand)
+          val bestTerm = terminalParam(point)
+          if (candTerm != bestTerm) {
+            if (candTerm) point = cand
+          } else if (partsLen(cand) < partsLen(point)) {
+            point = cand
+          }
+          j += 1
+        }
       }
 
       if (reqselector != null) {

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/feature/TestFeature.swift

@@ -38,7 +38,35 @@ private func testBuildArgs(_ ctx: Context, _ op: Operation, _ args: VMap?) -> Va
 
   let cfg: Value = ctx.config == nil ? .noval : .map(ctx.config!)
   let points = getpath(cfg, jtp("entity", ctx.entity!.getName(), "op", opname, "points"))
-  let point = getelem(points, .int(-1))
+
+  // 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.
+  func pointPartsLen(_ p: Value) -> Int {
+    return getprop(p, .string("parts")).asList?.items.count ?? 0
+  }
+  func pointTerminalParam(_ p: Value) -> Bool {
+    guard let items = getprop(p, .string("parts")).asList?.items, let last = items.last else {
+      return false
+    }
+    return (last.asString ?? "").hasPrefix("{")
+  }
+
+  var point = getelem(points, .int(0))
+  if let candidates = points.asList?.items {
+    for cand in candidates {
+      let candTerm = pointTerminalParam(cand)
+      let bestTerm = pointTerminalParam(point)
+      if candTerm != bestTerm {
+        if candTerm { point = cand }
+      }
+      else if pointPartsLen(cand) < pointPartsLen(point) {
+        point = cand
+      }
+    }
+  }
 
   let paramsPath = getpath(point, jtp("args", "params"))
   let reqdParams = select(paramsPath, .map(vm(("reqd", .bool(true)))))

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/Make.swift

@@ -40,8 +40,8 @@ func makePointUtil(_ ctx: Context) throws -> VMap? {
     }
 
     var point: VMap? = nil
+    var matched = false
     for candidate in op.points {
-      point = candidate
       let selectDef = gp(candidate, "select").asMap
       var found = true
 
@@ -62,7 +62,56 @@ func makePointUtil(_ ctx: Context) throws -> VMap? {
         if reqAction != selectAction { found = false }
       }
 
-      if found { break }
+      if found {
+        point = candidate
+        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 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.
+      let unmatchedAction = gp(reqselector, "$action")
+      if !isNil(unmatchedAction) {
+        throw ctx.makeError("point_action_invalid",
+          "Operation \"\(op.name)\" action \"\(stringify(unmatchedAction))\" 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. The same rule runs at
+      // generation time, in helpers/opShape.ts — both sides must move
+      // together.
+      func partsLen(_ p: VMap) -> Int {
+        return gp(p, "parts").asList?.items.count ?? 0
+      }
+      func terminalParam(_ p: VMap) -> Bool {
+        guard let items = gp(p, "parts").asList?.items, let last = items.last else {
+          return false
+        }
+        return (last.asString ?? "").hasPrefix("{")
+      }
+
+      point = op.points.first
+      for candidate in op.points {
+        guard let best = point else { break }
+        let candTerm = terminalParam(candidate)
+        let bestTerm = terminalParam(best)
+        if candTerm != bestTerm {
+          if candTerm { point = candidate }
+        }
+        else if partsLen(candidate) < partsLen(best) {
+          point = candidate
+        }
+      }
     }
 
     let reqAction = gp(reqselector, "$action")

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

@@ -253,9 +253,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: any) => {
+      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/ts/src/utility/MakePointUtility.ts

@@ -2,6 +2,52 @@
 import { Context, Point } from '../types'
 
 
+// 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 `shortestPoint`/`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: any): boolean {
+  const parts = point.parts
+  const last = 0 < parts.length ? parts[parts.length - 1] : ''
+  return 'string' === typeof last && 0 === last.indexOf('{')
+}
+
+
+function ownPoint(points: any[]): any {
+  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: Context): Point | Error {
   if (ctx.out.point) {
     return ctx.point = ctx.out.point
@@ -31,9 +77,10 @@ function makePoint(ctx: Context): Point | Error {
     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) {
@@ -56,10 +103,33 @@ function makePoint(ctx: Context): Point | Error {
       }
 
       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/zig/core/utility.zig

@@ -521,6 +521,29 @@ pub fn make_options_util(ctx: *Context) Value {
 // make_point (gotcha #2: rbac PrePoint short-circuit)
 // ============================================================================
 
+// How many path segments a point has.
+fn point_parts_len(point: Value) i64 {
+    const parts = h.getp(point, "parts");
+    if (parts != .array) return 0;
+    return @intCast(parts.array.data.items.len);
+}
+
+// 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.
+fn point_terminal_param(point: Value) bool {
+    const parts = h.getp(point, "parts");
+    if (parts != .array) return false;
+    const items = parts.array.data.items;
+    if (0 == items.len) return false;
+    const last = items[items.len - 1];
+    if (last != .string) return false;
+    return 0 < last.string.len and '{' == last.string[0];
+}
+
 pub fn make_point_util(ctx: *Context) E!Value {
     if (ctx.out_get("point")) |ov| {
         switch (ov) {
@@ -560,10 +583,11 @@ pub fn make_point_util(ctx: *Context) E!Value {
         const selector: Value = if (std.mem.eql(u8, op.input, "data")) ctx.data else ctx.mtch;
 
         var point: Value = h.vnull();
+        var matched = false;
         var i: i64 = 0;
         while (i < plen) : (i += 1) {
-            point = h.get_elem(points, h.vnum(i), h.vnull());
-            const select_def = h.to_map(h.getp(point, "select"));
+            const cand = h.get_elem(points, h.vnum(i), h.vnull());
+            const select_def = h.to_map(h.getp(cand, "select"));
             var found = true;
 
             if (!h.is_noval(selector) and !h.is_noval(select_def)) {
@@ -589,7 +613,46 @@ pub fn make_point_util(ctx: *Context) E!Value {
                 if (!h.veq(req_action, select_action)) found = false;
             }
 
-            if (found) break;
+            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 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.
+            const unmatched_action = h.getp(reqselector, "$action");
+            if (!h.is_noval(unmatched_action)) {
+                return ctx.fail("point_action_invalid", fmt("Operation \"{s}\" action \"{s}\" is not valid.", .{ op.name, h.stringify(unmatched_action) }));
+            }
+
+            // 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.
+            // The same rule runs at generation time, in helpers/opShape.ts —
+            // both sides must move together.
+            point = h.get_elem(points, h.vnum(0), h.vnull());
+            var j: i64 = 0;
+            while (j < plen) : (j += 1) {
+                const cand = h.get_elem(points, h.vnum(j), h.vnull());
+                const cand_term = point_terminal_param(cand);
+                const best_term = point_terminal_param(point);
+                if (cand_term != best_term) {
+                    if (cand_term) point = cand;
+                } else if (point_parts_len(cand) < point_parts_len(point)) {
+                    point = cand;
+                }
+            }
         }
 
         const req_action = h.getp(reqselector, "$action");

package/project/sdkgen-package.json

@@ -3,7 +3,7 @@
     "package": 1
   },
   "name": "@voxgig/sdkgen",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "provides": {
     "target": [
       "c",
@@ -15,7 +15,6 @@
       "go",
       "go-cli",
       "go-mcp",
-      "haskell",
       "java",
       "js",
       "kotlin",

package/src/cmp/ExternalTarget.ts

@@ -88,7 +88,7 @@ const ExternalTarget = cmp(function ExternalTarget(props: any) {
     names(target, target.name)
 
     if (phaseActive('entity')) {
-      each(entity, (entity: any) => {
+      each(entity).filter((entity: any) => entity.active).map((entity: any) => {
         names(entity, entity.name)
         Entity({ target, entity })
       })