@voxgig/sdkgen 3.5.0 → 3.6.0

package/project/.sdk/tm/kotlin/utility/MakePoint.kt

@@ -4,6 +4,27 @@ import KOTLINPACKAGE.core.Context
 import KOTLINPACKAGE.core.Helpers
 import KOTLINPACKAGE.utility.struct.Struct
 
+// How many path segments a point has.
+private fun partsLen(point: Map<String, Any?>?): Int {
+  val parts = Struct.getprop(point, "parts")
+  return if (parts is List<*>) parts.size else 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 fun terminalParam(point: Map<String, Any?>?): Boolean {
+  val parts = Struct.getprop(point, "parts")
+  if (parts !is List<*> || parts.isEmpty()) {
+    return false
+  }
+  val last = parts[parts.size - 1]
+  return last is String && last.startsWith("{")
+}
+
 @Suppress("UNCHECKED_CAST")
 fun makePoint(ctx: Context): Map<String, Any?> {
   val outPoint = ctx.out["point"]
@@ -55,9 +76,10 @@ fun makePoint(ctx: Context): Map<String, Any?> {
     }
 
     var point: MutableMap<String, Any?>? = null
+    var matched = false
     for (i in op.points.indices) {
-      point = op.points[i]
-      val selectDef = Helpers.toMapAny(Struct.getprop(point, "select"))
+      val cand = op.points[i]
+      val selectDef = Helpers.toMapAny(Struct.getprop(cand, "select"))
       var found = true
 
       if (selectDef != null) {
@@ -84,10 +106,44 @@ fun makePoint(ctx: Context): Map<String, Any?> {
       }
 
       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.
+      val unmatchedAction = Struct.getprop(reqselector, "\$action", null)
+      if (unmatchedAction != null) {
+        throw ctx.makeError(
+          "point_action_invalid",
+          "Operation \"" + op.name +
+            "\" action \"" + Struct.stringify(unmatchedAction) + "\" is not valid.",
+        )
+      }
+
+      point = op.points[0]
+      for (cand in op.points) {
+        val candTerm = terminalParam(cand)
+        val bestTerm = terminalParam(point)
+        if (candTerm != bestTerm) {
+          if (candTerm) {
+            point = cand
+          }
+        } else if (partsLen(cand) < partsLen(point)) {
+          point = cand
+        }
+      }
+    }
+
     val reqAction = Struct.getprop(reqselector, "\$action", null)
     if (reqAction != null && point != null) {
       val pointSelect = Helpers.toMapAny(Struct.getprop(point, "select"))

package/project/.sdk/tm/lean/src/SdkUtility.lean

@@ -597,6 +597,20 @@ def makeResult (ctx : Value) : SIO Value := do
 
 /-- Select the endpoint for this operation: the single point, else the first
     whose `select.exist` keys are all present and whose `$action` agrees. -/
+/-- How many path segments a point has, and whether its path ends 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. -/
+def pointShape (pt : Value) : SIO (Nat × Bool) := do
+  match (← gp pt "parts") with
+  | .list i =>
+    let items ← listItems i
+    if items.size == 0 then pure (0, false)
+    else pure (items.size, (vs items[items.size - 1]!).startsWith "{")
+  | _ => pure (0, false)
+
 def makePoint (ctx : Value) : SIO Value := do
   let op ← gp ctx "op"
   let matchV ← gp ctx "reqmatch"
@@ -622,6 +636,20 @@ def makePoint (ctx : Value) : SIO Value := do
         | _ => pure ()
         if ok && ((← gp sel "$action") == (← gp matchV "$action")) then
           chosen := pt
+    -- 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 and this loop chose no point at all. Fall
+    -- back to the entity's own route rather than sending nowhere.
+    if isNov chosen then
+      let mut best := pts[0]!
+      for cand in pts do
+        let (candLen, candTerm) ← pointShape cand
+        let (bestLen, bestTerm) ← pointShape best
+        if candTerm && !bestTerm then
+          best := cand
+        else if candTerm == bestTerm && candLen < bestLen then
+          best := cand
+      chosen := best
     if !(isNov chosen) then sp ctx "point" chosen
     pure chosen
 

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

@@ -3,6 +3,32 @@
 local vs = require("utility.struct.struct")
 local helpers = require("core.helpers")
 
+-- How many path segments a point has.
+local function parts_len(point)
+  local parts = vs.getprop(point, "parts")
+  if type(parts) == "table" then
+    return #parts
+  end
+  return 0
+end
+
+
+-- 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.
+local function terminal_param(point)
+  local parts = vs.getprop(point, "parts")
+  if type(parts) ~= "table" or #parts == 0 then
+    return false
+  end
+  local last = parts[#parts]
+  return type(last) == "string" and last:sub(1, 1) == "{"
+end
+
+
 local function make_point_util(ctx)
   if ctx.out["point"] ~= nil then
     local preset = ctx.out["point"]
@@ -44,9 +70,10 @@ local function make_point_util(ctx)
     end
 
     local point = nil
+    local matched = false
     for i = 1, #op.points do
-      point = op.points[i]
-      local select_def = helpers.to_map(vs.getprop(point, "select"))
+      local cand = op.points[i]
+      local select_def = helpers.to_map(vs.getprop(cand, "select"))
       local found = true
 
       if selector ~= nil and select_def ~= nil then
@@ -73,10 +100,46 @@ local function make_point_util(ctx)
       end
 
       if found then
+        point = cand
+        matched = true
         break
       end
     end
 
+    -- 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 not matched then
+      -- 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.
+      local unmatched_action = nil
+      if reqselector ~= nil then
+        unmatched_action = vs.getprop(reqselector, "$action")
+      end
+      if unmatched_action ~= nil then
+        return nil, ctx:make_error("point_action_invalid",
+          'Operation "' .. op.name ..
+          '" action "' .. vs.stringify(unmatched_action) .. '" is not valid.')
+      end
+
+      point = op.points[1]
+      for i = 1, #op.points do
+        local cand = op.points[i]
+        local cand_term = terminal_param(cand)
+        local best_term = terminal_param(point)
+        if cand_term ~= best_term then
+          if cand_term then
+            point = cand
+          end
+        elseif parts_len(cand) < parts_len(point) then
+          point = cand
+        end
+      end
+    end
+
     if reqselector ~= nil then
       local req_action = vs.getprop(reqselector, "$action")
       if req_action ~= nil and point ~= nil then

package/project/.sdk/tm/ocaml/sdk_runtime.ml

@@ -636,12 +636,12 @@ let make_point_util (ctx : ctx) : (value * sdk_error option) =
           if op.op_input = "data" then ctx.c_reqdata, ctx.c_data
           else ctx.c_reqmatch, ctx.c_match in
         let chosen = ref Noval in
+        let matched = ref false in
         let n = List.length points in
         let arr = Array.of_list points in
         let i = ref 0 and stop = ref false in
         while not !stop && !i < n do
           let point = arr.(!i) in
-          chosen := point;
           let select_def = to_map (getp point "select") in
           let found = ref true in
           (match select_def with
@@ -661,8 +661,46 @@ let make_point_util (ctx : ctx) : (value * sdk_error option) =
             let select_action = getp select_def "$action" in
             if req_action <> select_action then found := false
           end;
-          if !found then stop := true else incr i
+          if !found then begin chosen := point; matched := true; stop := true end
+          else incr i
         done;
+        (* 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 not !matched then begin
+          (* 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" in
+          if not (is_noval unmatched_action) then
+            raise (Sdk_error_exc (ctx_make_error ctx "point_action_invalid"
+              ("Operation \"" ^ op.op_name ^ "\" action \"" ^ (stringify unmatched_action) ^ "\" 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. *)
+          let parts_len p =
+            match getp p "parts" with List r -> List.length !r | _ -> 0 in
+          let terminal_param p =
+            match getp p "parts" with
+            | List r ->
+              (match List.rev !r with
+               | last :: _ ->
+                 let s = vstring last in
+                 String.length s > 0 && s.[0] = '{'
+               | [] -> false)
+            | _ -> false in
+          chosen := arr.(0);
+          Array.iter (fun cand ->
+              let ct = terminal_param cand and bt = terminal_param !chosen in
+              if ct <> bt then (if ct then chosen := cand)
+              else if parts_len cand < parts_len !chosen then chosen := cand) arr
+        end;
         let req_action = getp reqselector "$action" in
         if not (is_noval req_action) && not (is_noval !chosen) then begin
           let point_select = to_map (getp !chosen "select") in

package/project/.sdk/tm/perl/utility/make_point.pm

@@ -17,6 +17,27 @@ package ProjectNameUtilities;
 
 our %REGISTRY;
 
+# How many path segments a point has.
+sub _parts_len {
+  my ($point) = @_;
+  my $parts = ProjectNameHelpers::gp($point, 'parts');
+  return Voxgig::Struct::islist($parts) ? scalar(@$parts) : 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.
+sub _terminal_param {
+  my ($point) = @_;
+  my $parts = ProjectNameHelpers::gp($point, 'parts');
+  return 0 unless Voxgig::Struct::islist($parts) && 0 < scalar(@$parts);
+  my $last = $parts->[-1];
+  return (defined $last && !ref $last && $last =~ /^\{/) ? 1 : 0;
+}
+
 $REGISTRY{make_point} = sub {
   my ($ctx) = @_;
 
@@ -54,8 +75,8 @@ $REGISTRY{make_point} = sub {
     my $selector = ('data' eq $op->{input}) ? $ctx->{data} : $ctx->{match};
 
     my $point;
+    my $matched = 0;
     for my $p (@{ $op->{points} }) {
-      $point = $p;
       my $select_def = ProjectNameHelpers::to_map(ProjectNameHelpers::gp($p, 'select'));
       my $found = 1;
 
@@ -79,7 +100,39 @@ $REGISTRY{make_point} = sub {
         $found = 0 unless ProjectNameHelpers::eqv($req_action, $select_action);
       }
 
-      last if $found;
+      if ($found) {
+        $point = $p;
+        $matched = 1;
+        last;
+      }
+    }
+
+    # 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.
+    unless ($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.
+      my $unmatched_action = $reqselector
+        ? ProjectNameHelpers::gp($reqselector, '$action') : undef;
+      if (defined $unmatched_action) {
+        return (undef, $ctx->make_error('point_action_invalid',
+          'Operation "' . $op->{name} . '" action "' .
+          Voxgig::Struct::stringify($unmatched_action) . '" is not valid.'));
+      }
+
+      $point = $op->{points}[0];
+      for my $p (@{ $op->{points} }) {
+        if (_terminal_param($p) != _terminal_param($point)) {
+          $point = $p if _terminal_param($p);
+        }
+        elsif (_parts_len($p) < _parts_len($point)) {
+          $point = $p;
+        }
+      }
     }
 
     if ($reqselector) {

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

@@ -369,11 +369,40 @@ class ProjectNameTestFeature extends ProjectNameBaseFeature
         // any missing piece falls back to "no required params".
         $reqd_names = [];
         if (is_string($opname) && is_string($entityName) && isset($ctx->config)) {
+            // 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.
             $points = \Voxgig\Struct\Struct::getpath(
                 ['entity', $entityName, 'op', $opname, 'points'],
                 $ctx->config
             );
-            $point = \Voxgig\Struct\Struct::getelem($points, -1);
+            $point = \Voxgig\Struct\Struct::getelem($points, 0);
+            if (is_array($points)) {
+                $point_parts_len = function ($p) {
+                    $parts = \Voxgig\Struct\Struct::getprop($p, 'parts');
+                    return is_array($parts) ? count($parts) : 0;
+                };
+                $point_terminal_param = function ($p) {
+                    $parts = \Voxgig\Struct\Struct::getprop($p, 'parts');
+                    if (!is_array($parts) || 0 === count($parts)) {
+                        return false;
+                    }
+                    $last = $parts[count($parts) - 1];
+                    return is_string($last) && 0 === strpos($last, '{');
+                };
+                foreach ($points as $cand) {
+                    if ($point_terminal_param($cand) !== $point_terminal_param($point)) {
+                        if ($point_terminal_param($cand)) {
+                            $point = $cand;
+                        }
+                    } elseif ($point_parts_len($cand) < $point_parts_len($point)) {
+                        $point = $cand;
+                    }
+                }
+            }
             $params = is_array($point) ? ($point['args']['params'] ?? null) : null;
             if (is_array($params)) {
                 foreach ($params as $p) {

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

@@ -42,8 +42,8 @@ class ProjectNameMakePoint
             $selector = $op->input === 'data' ? $ctx->data : $ctx->match;
 
             $point = null;
+            $matched = false;
             foreach ($op->points as $p) {
-                $point = $p;
                 $select_def = ProjectNameHelpers::to_map(\Voxgig\Struct\Struct::getprop($p, 'select'));
                 $found = true;
 
@@ -70,10 +70,58 @@ class ProjectNameMakePoint
                 }
 
                 if ($found) {
+                    $point = $p;
+                    $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 the last point.
+            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.
+                $unmatched_action = $reqselector
+                    ? \Voxgig\Struct\Struct::getprop($reqselector, '$action') : null;
+                if (null !== $unmatched_action) {
+                    return [null, $ctx->make_error('point_action_invalid',
+                        "Operation \"{$op->name}\" action \"" .
+                        \Voxgig\Struct\Struct::stringify($unmatched_action) .
+                        "\" 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 wins.
+                $parts_len = function ($p) {
+                    $parts = \Voxgig\Struct\Struct::getprop($p, 'parts');
+                    return is_array($parts) ? count($parts) : 0;
+                };
+                $terminal_param = function ($p) {
+                    $parts = \Voxgig\Struct\Struct::getprop($p, 'parts');
+                    if (!is_array($parts) || 0 === count($parts)) {
+                        return false;
+                    }
+                    $last = $parts[count($parts) - 1];
+                    return is_string($last) && 0 === strpos($last, '{');
+                };
+                $point = $op->points[0];
+                foreach ($op->points as $p) {
+                    if ($terminal_param($p) !== $terminal_param($point)) {
+                        if ($terminal_param($p)) {
+                            $point = $p;
+                        }
+                    } elseif ($parts_len($p) < $parts_len($point)) {
+                        $point = $p;
+                    }
+                }
+            }
+
             if ($reqselector) {
                 $req_action = \Voxgig\Struct\Struct::getprop($reqselector, '$action');
                 if ($req_action && $point) {

package/project/.sdk/tm/py/pkg/utility/make_point.py

@@ -5,6 +5,38 @@ from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
 from projectname_sdk.core.helpers import to_map
 
 
+def _parts_len(point):
+    parts = vs.getprop(point, "parts")
+    return len(parts) if isinstance(parts, list) else 0
+
+
+def _terminal_param(point):
+    # 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).
+    parts = vs.getprop(point, "parts")
+    if not isinstance(parts, list) or 0 == len(parts):
+        return False
+    return str(parts[-1]).startswith("{")
+
+
+def _own_point(points):
+    # The entity's OWN route: 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 — both sides must move together.
+    best = points[0]
+    for cand in points:
+        cand_term = _terminal_param(cand)
+        best_term = _terminal_param(best)
+        if cand_term != best_term:
+            if cand_term:
+                best = cand
+        elif _parts_len(cand) < _parts_len(best):
+            best = cand
+    return best
+
+
 def make_point_util(ctx):
     pre = ctx.out.get("point")
     if pre is not None:
@@ -40,9 +72,10 @@ def make_point_util(ctx):
             selector = ctx.match
 
         point = None
+        matched = False
         for i in range(len(op.points)):
-            point = op.points[i]
-            select_def = to_map(vs.getprop(point, "select"))
+            cand = op.points[i]
+            select_def = to_map(vs.getprop(cand, "select"))
             found = True
 
             if selector is not None and select_def is not None:
@@ -63,8 +96,29 @@ def make_point_util(ctx):
                     found = False
 
             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 not 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.
+            req_action = vs.getprop(reqselector, "$action") \
+                if reqselector is not None else None
+            if req_action is not None:
+                return None, ctx.make_error("point_action_invalid",
+                    'Operation "' + op.name + '" action "' +
+                    vs.stringify(req_action) + '" is not valid.')
+
+            point = _own_point(op.points)
+
         if reqselector is not None:
             req_action = vs.getprop(reqselector, "$action")
             if req_action is not None and point is not None:

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

@@ -35,8 +35,8 @@ module ProjectNameUtilities
       selector = op.input == "data" ? ctx.data : ctx.match
 
       point = nil
+      matched = false
       op.points.each do |p|
-        point = p
         select_def = ProjectNameHelpers.to_map(VoxgigStruct.getprop(p, "select"))
         found = true
 
@@ -60,7 +60,47 @@ module ProjectNameUtilities
           found = false if req_action != select_action
         end
 
-        break if found
+        if found
+          point = p
+          matched = true
+          break
+        end
+      end
+
+      # 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.
+      unless 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.
+        req_action = reqselector ? VoxgigStruct.getprop(reqselector, "$action") : nil
+        if req_action
+          return nil, ctx.make_error("point_action_invalid",
+            "Operation \"#{op.name}\" action \"#{VoxgigStruct.stringify(req_action)}\" is not valid.")
+        end
+
+        # 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.
+        parts_len = ->(p) {
+          parts = VoxgigStruct.getprop(p, "parts")
+          parts.is_a?(Array) ? parts.length : 0
+        }
+        terminal_param = ->(p) {
+          parts = VoxgigStruct.getprop(p, "parts")
+          parts.is_a?(Array) && parts.length > 0 && parts[-1].to_s.start_with?("{")
+        }
+        point = op.points[0]
+        op.points.each do |p|
+          if terminal_param.call(p) != terminal_param.call(point)
+            point = p if terminal_param.call(p)
+          elsif parts_len.call(p) < parts_len.call(point)
+            point = p
+          end
+        end
       end
 
       if reqselector