@voxgig/sdkgen 4.3.0 → 4.4.1

package/project/.sdk/tm/ocaml/test/primary_utility_test.ml

@@ -0,0 +1,238 @@
+(* ProjectName SDK primary-utility corpus.
+ *
+ * Drives the SHARED language-neutral corpus (.sdk/test/test.json -> "primary")
+ * through this SDK's request-shaping utilities, so the cases cannot drift from
+ * the reference implementation. Each section is looked up with getSpec and
+ * executed with runset, as the ts/js reference harness does.
+ *
+ * ocaml had NO primary-utility suite at all before this: its request-shaping
+ * utilities were unverified in every language-neutral sense. The harness is
+ * Corpus_runner, shared with the struct corpus.
+ *)
+
+open Voxgig_struct
+open Sdk_types
+open Sdk_helpers
+open Sdk_runtime
+open Corpus_runner
+
+let client () : sdk_client = Sdk_client.test ()
+
+(* A client built from a section's DEF.setup.a block. prepare_auth reads the
+ * CLIENT's options, as the ts reference does via client.options(), so a
+ * section's setup cannot reach it through ctx.options. *)
+let client_for primary name =
+  let setup =
+    List.fold_left (fun acc k -> getprop_raw_pub acc k) primary [name; "DEF"; "setup"; "a"]
+  in
+  match setup with
+  | Map _ -> Sdk_client.test_with Noval setup
+  | _ -> Sdk_client.test ()
+
+let getspec root path =
+  List.fold_left (fun acc k -> getprop_raw_pub acc k) root path
+
+(* A LIVE context from a corpus map. The utilities read and MUTATE spec,
+ * result and response through their record types, so a bare value map leaves
+ * them nothing to work on and every match reads null. *)
+let ctx_from (cl : sdk_client) (ctxmap : value) : ctx =
+  let u = cl.cl_utility in
+  (* The corpus names the op — {"ctx": {"opname": "create"}} — and
+   * prepare_method reads it. Hardcoding "load" made every method GET. *)
+  (* Only when the corpus names one. Defaulting to "load" made the SDK report
+   * the wrong operation in error messages the corpus matches on — it expects
+   * "unknown operation" where no op is named. *)
+  let cs =
+    match getprop_raw_pub ctxmap "opname" with
+    | Str s -> { (default_ctxspec ()) with cs_opname = Some s }
+    | _ -> default_ctxspec ()
+  in
+  let c = u.u_make_context cs cl.cl_rootctx in
+  (match getprop_raw_pub ctxmap "spec" with
+   | Map _ as m -> c.c_spec <- Some (new_spec m)
+   | _ -> ());
+  (match getprop_raw_pub ctxmap "result" with
+   | Map _ as m ->
+     let rt = new_result m in
+     (* new_result hardcodes rt_err = None, so a corpus result carrying an err
+      * arrives empty and result_basic has no previous message to prepend —
+      * it produced "request: 400: BAD" where the contract says
+      * "Foo: request: 400: BAD". The lua and elixir drivers build it too. *)
+     (match getprop_raw_pub m "err" with
+      | Map _ as em ->
+        (match getprop_raw_pub em "message" with
+         | Str msg when msg <> "" ->
+           rt.rt_err <- Some { err_code = ""; err_msg = msg; err_result = Noval; err_spec = Noval }
+         | _ -> ())
+      | _ -> ());
+     c.c_result <- Some rt
+   | _ -> ());
+  (match getprop_raw_pub ctxmap "response" with
+   | Map _ as m ->
+     let r = new_response m in
+     (* result_body_util reads response.json and requires it to be CALLABLE;
+      * the corpus supplies a plain `body`, so wrap it, as the lua and elixir
+      * drivers do. Without this every ctx.result.body match reads empty. *)
+     (match getprop_raw_pub m "body" with
+      | Noval -> ()
+      | b -> r.rs_json <- Func (fun _ _ _ _ -> b));
+     (* Header names arrive from the wire in any case and the contract is
+      * lowercase; the lua and elixir drivers normalise here rather than in
+      * result_headers_util, which copies them verbatim. *)
+     (match getprop_raw_pub m "headers" with
+      | Map hm ->
+        let low = empty_map () in
+        List.iter (fun (k, v) -> ignore (setprop low (Str (String.lowercase_ascii k)) v))
+          hm.entries;
+        r.rs_headers <- low
+      | _ -> ());
+     c.c_response <- Some r
+   | _ -> ());
+  (match getprop_raw_pub ctxmap "point" with
+   | Map _ as m -> c.c_point <- m
+   | _ -> ());
+  (match getprop_raw_pub ctxmap "reqdata" with Noval -> () | v -> c.c_reqdata <- v);
+  (match getprop_raw_pub ctxmap "reqmatch" with Noval -> () | v -> c.c_reqmatch <- v);
+  (match getprop_raw_pub ctxmap "data" with Noval -> () | v -> c.c_data <- v);
+  (match getprop_raw_pub ctxmap "match" with Noval -> () | v -> c.c_match <- v);
+  c
+
+(* The corpus speaks camelCase; this port stores rs_status_text / rt_ok. A
+ * neutral-named view is what the match assertions read. *)
+let result_value (r : result option) : value =
+  match r with
+  | None -> Noval
+  | Some rt -> result_to_value rt
+
+let ctx_arg args = match args with x :: _ -> x | [] -> Noval
+
+(* The harness reports a non-Struct_error exception via Printexc, which renders
+ * a branded SDK error as "Sdk_types.Sdk_error_exc(_)" and loses the message the
+ * corpus matches on. Convert here rather than teaching the shared harness about
+ * SDK types — corpus_runner is struct's, not this SDK's. *)
+let run_guarded f c =
+  try f c with
+  | Sdk_error_exc e -> raise (Struct_error e.err_msg)
+
+(* Publish the MUTATED ctx back onto the corpus map the match reads.
+ * check_result matches against entry.ctx, which is the raw corpus map; the
+ * utilities mutate the live records beside it, so without this every
+ * `match: ctx.spec.*` / `ctx.result.*` assertion reads empty. Neutral names,
+ * because the corpus is camelCase and this port stores rs_status_text/rt_ok. *)
+let publish (ctxmap : value) (c : ctx) =
+  (match c.c_spec with
+   | Some sp -> ignore (setprop ctxmap (Str "spec") (spec_to_value sp))
+   | None -> ());
+  (match c.c_result with
+   | Some _ -> ignore (setprop ctxmap (Str "result") (result_value c.c_result))
+   | None -> ());
+  (match c.c_response with
+   | Some _ -> ignore (setprop ctxmap (Str "response") (Str "__EXISTS__"))
+   | None -> ());
+  ()
+
+let () =
+  let testfile = if Array.length Sys.argv > 1 then Sys.argv.(1) else "../.sdk/test/test.json" in
+  let ic = open_in_bin testfile in
+  let len = in_channel_length ic in
+  let raw = really_input_string ic len in
+  close_in ic;
+  let alltests = json_read raw in
+  let primary = getprop_raw_pub alltests "primary" in
+
+  let cl = client () in
+  let u = cl.cl_utility in
+
+  (* Sections configured by their own DEF.setup block get their own client. *)
+  let ctx_section_with cl2 primary name f =
+    run_set name (getspec primary [name; "basic"])
+      (fun args ->
+         let ctxmap = ctx_arg args in
+         let c = ctx_from cl2 ctxmap in
+         let out = run_guarded f c in
+         publish ctxmap c;
+         out)
+  in
+
+  let ctx_section primary name f =
+    run_set name (getspec primary [name; "basic"])
+      (fun args ->
+         let ctxmap = ctx_arg args in
+         let c = ctx_from cl ctxmap in
+         let out = run_guarded f c in
+         publish ctxmap c;
+         out)
+  in
+
+  ctx_section primary "done" (fun c -> u.u_done c);
+  ctx_section primary "makeUrl" (fun c -> match make_url_util c with (s, _) -> Str s);
+  ctx_section primary "makeRequest"
+    (fun c -> ignore (make_request_util c); result_value c.c_result);
+  ctx_section primary "makeResponse"
+    (fun c -> ignore (make_response_util c); result_value c.c_result);
+  ctx_section_with (client_for primary "makeSpec") primary "makeSpec"
+    (fun c -> match make_spec_util c with
+       | (Some s, _) -> spec_to_value s | _ -> Noval);
+  ctx_section_with (client_for primary "prepareAuth") primary "prepareAuth"
+    (fun c -> ignore (prepare_auth_util c);
+      match c.c_spec with Some s -> spec_to_value s | None -> Noval);
+  ctx_section primary "prepareBody" (fun c -> prepare_body_util c);
+  ctx_section primary "prepareHeaders" (fun c -> prepare_headers_util c);
+  ctx_section primary "prepareMethod"
+    (fun c -> match prepare_method_util c with "" -> Noval | m -> Str m);
+  ctx_section primary "prepareParams" (fun c -> prepare_params_util c);
+  ctx_section primary "preparePath" (fun c -> Str (prepare_path_util c));
+  ctx_section primary "prepareQuery" (fun c -> prepare_query_util c);
+  ctx_section primary "resultBasic" (fun c -> result_basic_util c; result_value c.c_result);
+  ctx_section primary "resultBody" (fun c -> result_body_util c; result_value c.c_result);
+  ctx_section primary "resultHeaders" (fun c -> result_headers_util c; result_value c.c_result);
+  ctx_section primary "transformRequest" (fun c -> transform_request_util c);
+  ctx_section primary "transformResponse" (fun c -> transform_response_util c);
+
+  (* Sections that take a bare map or explicit args rather than a ctx. *)
+  let arg_section primary name f =
+    run_set name (getspec primary [name; "basic"]) (fun args -> run_guarded f args)
+  in
+
+  arg_section primary "makeContext" (fun args ->
+      let inv = ctx_arg args in
+      let c = ctx_from cl inv in
+      jo [("op", jo [("entity", Str c.c_op.op_entity); ("name", Str c.c_op.op_name);
+                     ("input", Str c.c_op.op_input); ("points", c.c_op.op_points)])]);
+
+  arg_section primary "makeOptions" (fun args ->
+      let inv = ctx_arg args in
+      let c = ctx_from cl (jo []) in
+      c.c_config <- getprop_raw_pub inv "config";
+      c.c_options <- getprop_raw_pub inv "options";
+      make_options_util c);
+
+  arg_section primary "makeError" (fun args ->
+      let a0 = ctx_arg args in
+      let a1 = (match args with _ :: y :: _ -> y | _ -> Noval) in
+      let c = ctx_from cl a0 in
+      let msg = (match getprop_raw_pub a1 "message" with Str m -> m | _ -> "") in
+      let e = { err_code = ""; err_msg = msg; err_result = Noval; err_spec = Noval } in
+      let out = make_error_util c (if msg = "" then None else Some e) in
+      publish a0 c;
+      out);
+
+  arg_section primary "operator" (fun args ->
+      let inv = ctx_arg args in
+      let op = new_operation inv in
+      jo [("entity", Str op.op_entity); ("input", Str op.op_input);
+          ("name", Str op.op_name); ("points", op.op_points)]);
+
+  arg_section primary "param" (fun args ->
+      let a0 = ctx_arg args in
+      let a1 = (match args with _ :: y :: _ -> y | _ -> Noval) in
+      let c = ctx_from cl a0 in
+      let out = param_util c a1 in
+      publish a0 c;
+      out);
+
+  List.iter print_endline (List.rev !failures);
+  Printf.printf "\nPRIMARY CORPUS: PASS %d  FAIL %d\n" !npass !nfail;
+  (* A run that executes nothing is not a pass. *)
+  if !npass = 0 then (print_endline "the primary corpus executed no cases"; exit 1);
+  if !nfail > 0 then exit 1

package/project/.sdk/tm/ocaml/test/struct_corpus.ml

@@ -1,165 +1,10 @@
-(* Test runner for the shared JSON corpus (build/test/test.json).
- * Self-contained: an in-tree JSON reader builds the library's `value` type
- * directly, so the OCaml port is exercised exactly as in production. *)
+(* Struct corpus: drives test.json -> "struct" through the vendored
+ * Voxgig_struct implementation. The harness itself lives in Corpus_runner so
+ * the primary-utility suite can share it.
+ *)
 
 open Voxgig_struct
-
-let nullmark = "__NULL__"
-let undefmark = "__UNDEF__"
-let existsmark = "__EXISTS__"
-
-(* The JSON reader now lives in the runtime (sdk_json.ml) so the SDK's
- * generated config can use it; the corpus runs against that same function
- * rather than a second copy that could drift from it. *)
-let json_read = Sdk_json.json_read
-
-(* ---------------- fixJSON / equality ---------------- *)
-
-let rec fix_json v flag_null =
-  match v with
-  | Noval | Null -> if flag_null then Str nullmark else v
-  | Map m -> let o = empty_map () in
-    List.iter (fun (k, x) -> ignore (setprop o (Str k) (fix_json x flag_null))) m.entries; o
-  | List r -> lst (List.map (fun x -> fix_json x flag_null) !r)
-  | _ -> v
-
-(* Order-independent deep equality for maps; sequence equality for lists. *)
-let rec eqv a b =
-  match a, b with
-  | (Noval | Null), (Noval | Null) -> true
-  | Bool x, Bool y -> x = y
-  | Num x, Num y -> x = y
-  | Str x, Str y -> x = y
-  | List x, List y -> List.length !x = List.length !y && List.for_all2 eqv !x !y
-  | Map x, Map y ->
-    omap_len x = omap_len y &&
-    List.for_all (fun (k, v) -> match omap_get y k with Some w -> eqv v w | None -> false) x.entries
-  | _ -> a == b
-
-(* ---------------- match support ---------------- *)
-
-let matchval check base =
-  let check = if check = Str undefmark || check = Str nullmark then Noval else check in
-  if eqv check base then true
-  else match check with
-    | Str cs ->
-      let basestr = stringify base in
-      if String.length cs >= 2 && cs.[0] = '/' && cs.[String.length cs - 1] = '/' then
-        Vregex.test_str (String.sub cs 1 (String.length cs - 2)) basestr
-      else
-        let low s = String.lowercase_ascii s in
-        let contains hay needle =
-          let hl = String.length hay and nl = String.length needle in
-          let rec go i = if i + nl > hl then false
-            else if String.sub hay i nl = needle then true else go (i + 1) in
-          nl = 0 || go 0 in
-        contains (low basestr) (low (stringify check))
-    | Func _ -> true
-    | _ -> false
-
-let do_match check base =
-  let base = clone base in
-  ignore (walk ~before:(fun _k v _p path ->
-      (if not (isnode v) then begin
-          let baseval = getpath base path in
-          if eqv baseval v then ()
-          else if v = Str undefmark && is_nullish baseval then ()
-          else if v = Str existsmark && not (is_nullish baseval) then ()
-          else if not (matchval v baseval) then
-            raise (Struct_error (Printf.sprintf "MATCH: %s: [%s] <=> [%s]"
-                                   (String.concat "." (List.map js_string (match path with List r -> !r | _ -> [])))
-                                   (stringify v) (stringify baseval)))
-        end);
-      v) check)
-
-(* ---------------- result tracking ---------------- *)
-
-let npass = ref 0
-let nfail = ref 0
-let failures = ref []
-
-let record group name ok msg =
-  if ok then incr npass
-  else (incr nfail; failures := Printf.sprintf "FAIL %s %s - %s" group name msg :: !failures)
-
-(* ---------------- per-entry runner ---------------- *)
-
-let omap_v kvs =
-  let m = empty_map () in
-  List.iter (fun (k, v) -> ignore (setprop m (Str k) v)) kvs; m
-
-let getprop_raw_pub e k = (match e with Map m -> (match omap_get m k with Some x -> x | None -> Noval) | _ -> Noval)
-let entry_get e k = getprop_raw_pub e k
-let entry_has e k = match e with Map m -> omap_has m k | _ -> false
-let default_injdef_pub () =
-  { d_meta = Noval; d_extra = Noval; d_errs = Noval; d_modify = None; d_handler = None;
-    d_base = Noval; d_dparent = Noval; d_dpath = Noval; d_key = Noval }
-
-let resolve_args entry =
-  if entry_has entry "ctx" then [entry_get entry "ctx"]
-  else if entry_has entry "args" then (match entry_get entry "args" with List r -> !r | _ -> [])
-  else if entry_has entry "in" then [clone (entry_get entry "in")]
-  else [Noval]
-
-let check_result entry args res =
-  let matched = ref false in
-  (if entry_has entry "match" then begin
-      do_match (entry_get entry "match")
-        (omap_v ["in", entry_get entry "in"; "args", lst args;
-                 "out", entry_get entry "res"; "ctx", entry_get entry "ctx"]);
-      matched := true
-    end);
-  let out = entry_get entry "out" in
-  if eqv out res then ()
-  else if !matched && (out = Str nullmark || is_nullish out) then ()
-  else raise (Struct_error (Printf.sprintf "Expected: %s, got: %s" (stringify out) (stringify res)))
-
-let handle_error entry err =
-  let msg = (match err with Struct_error m -> m | e -> Printexc.to_string e) in
-  if entry_has entry "err" then begin
-    let entry_err = entry_get entry "err" in
-    if entry_err = Bool true || matchval entry_err (Str msg) then begin
-      if entry_has entry "match" then
-        do_match (entry_get entry "match")
-          (omap_v ["in", entry_get entry "in"; "out", entry_get entry "res";
-                   "ctx", entry_get entry "ctx"; "err", Str msg])
-    end else
-      raise (Struct_error (Printf.sprintf "ERROR MATCH: [%s] <=> [%s]" (stringify entry_err) msg))
-  end else raise err
-
-let run_set ?(flags = []) group node subject =
-  let flag_null = (match List.assoc_opt "null" flags with Some b -> b | None -> true) in
-  let fixed = fix_json node flag_null in
-  let testset = (match getprop fixed (Str "set") with List r -> !r | _ -> []) in
-  List.iter (fun entry ->
-      let name = js_string (entry_get entry "name") in
-      try
-        (if not (entry_has entry "out") && flag_null then ignore (setprop entry (Str "out") (Str nullmark)));
-        let args = resolve_args entry in
-        let res = fix_json (subject args) flag_null in
-        ignore (setprop entry (Str "res") res);
-        check_result entry args res;
-        record group name true ""
-      with
-      | e ->
-        (try handle_error entry e; record group name true ""
-         with e2 -> record group name false
-                      (match e2 with Struct_error m -> m | _ -> Printexc.to_string e2)))
-    testset
-
-let run_single group node actual_fn =
-  try
-    let expected = getprop_raw_pub node "out" in
-    let actual = actual_fn (getprop_raw_pub node "in") in
-    if eqv expected actual then record group "single" true ""
-    else record group "single" false (Printf.sprintf "Expected: %s, got: %s" (stringify expected) (stringify actual))
-  with e -> record group "single" false (match e with Struct_error m -> m | _ -> Printexc.to_string e)
-
-(* ---------------- arg helpers ---------------- *)
-
-let arg1 f = fun args -> f (match args with x :: _ -> x | [] -> Noval)
-let vget vin k = match vin with Map m -> (match omap_get m k with Some x -> x | None -> Noval) | _ -> Noval
-let vhas vin k = match vin with Map m -> omap_has m k | _ -> false
+open Corpus_runner
 
 (* ---------------- test groups ---------------- *)
 

package/project/.sdk/tm/perl/t/feature_corpus.t

@@ -144,7 +144,15 @@ sub candidates {
       };
     }
   }
-  return @out;
+
+  # SAFE OPS FIRST - see the ts harness for the reasoning: the cache stores
+  # only successful GETs, so an SDK whose first usable op is a `create`
+  # (POST) can never satisfy "a hit served from cache costs nothing".
+  my %safe = (list => 0, load => 1);
+  return sort {
+    ($safe{ $a->{op} } // 2) <=> ($safe{ $b->{op} } // 2)
+      || $a->{key} cmp $b->{key}
+  } @out;
 }
 
 

package/project/.sdk/tm/php/test/FeatureCorpusTest.php

@@ -145,6 +145,17 @@ class FeatureCorpusTest extends TestCase
                 }
             }
         }
+
+        // SAFE OPS FIRST — see the ts harness for the reasoning: the cache
+        // stores only successful GETs, so an SDK whose first usable op is a
+        // `create` (POST) can never satisfy "a hit served from cache costs
+        // nothing".
+        $safe = ['list' => 0, 'load' => 1];
+        usort($out, function ($a, $b) use ($safe) {
+            $ra = $safe[$a['op']] ?? 2;
+            $rb = $safe[$b['op']] ?? 2;
+            return $ra === $rb ? strcmp($a['key'], $b['key']) : $ra - $rb;
+        });
         return $out;
     }
 

package/project/.sdk/tm/py/test/feature_harness.py

@@ -165,6 +165,12 @@ class _Ctx:
         self.meta = {}
         self.op = op
         self.entity = entity
+        # The pipeline always resolves a point before a feature sees the ctx,
+        # so features read ctx.point freely — paging checks `point.kind` for
+        # graphql. This stub had no such attribute, so every paging test died
+        # with AttributeError before reaching the transport. Those tests were
+        # SKIPPED until an SDK activated paging, which is why it went unseen.
+        self.point = {}
         self.spec = None
         self.response = None
         self.result = None

package/project/.sdk/tm/py/test/test_feature_corpus.py

@@ -129,6 +129,12 @@ def _candidates(client):
                     "accessor": accessor,
                     "op": opname,
                 })
+
+    # SAFE OPS FIRST - see the ts harness for the reasoning: the cache stores
+    # only successful GETs, so an SDK whose first usable op is a `create`
+    # (POST) can never satisfy "a hit served from cache costs nothing".
+    safe = {"list": 0, "load": 1}
+    out.sort(key=lambda o: (safe.get(o["op"], 2), o["key"]))
     return out
 
 

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

@@ -108,7 +108,12 @@ class FeatureCorpusTest < Minitest::Test
         out << { "key" => "#{entname}.#{opname}", "accessor" => accessor, "op" => opname }
       end
     end
-    out
+
+    # SAFE OPS FIRST - see the ts harness for the reasoning: the cache stores
+    # only successful GETs, so an SDK whose first usable op is a `create`
+    # (POST) can never satisfy "a hit served from cache costs nothing".
+    safe = { "list" => 0, "load" => 1 }
+    out.sort_by { |o| [safe.fetch(o["op"], 2), o["key"]] }
   end
 
   def invoke(client, op, ctrl)

package/project/.sdk/tm/rust/feature/cost.rs

@@ -41,7 +41,10 @@ pub struct CostBucket {
     pub amount: f64,
 }
 
-#[derive(Default)]
+// NOT `#[derive(Default)]`: the struct holds a `Value`, and `Value` has no
+// `Default` impl — deriving it does not compile. This file only ships when the
+// cost feature is active, so no SDK had ever built it. `Value::Noval` is the
+// absent value, which is what a fresh track should carry.
 pub struct CostTrack {
     // Aggregates (mirrors the ts client._cost record).
     pub currency: String,
@@ -60,6 +63,27 @@ pub struct CostTrack {
     pub seq: i64,
 }
 
+impl Default for CostTrack {
+    fn default() -> Self {
+        CostTrack {
+            currency: String::new(),
+            calls: 0,
+            attempts: 0,
+            amount: 0.0,
+            reported: 0.0,
+            estimated: 0.0,
+            ops: HashMap::new(),
+            actors: HashMap::new(),
+            limit: 0.0,
+            spent: 0.0,
+            remaining: 0.0,
+            exceeded: false,
+            last: Value::Noval,
+            seq: 0,
+        }
+    }
+}
+
 pub struct CostFeature {
     pub name: String,
     pub active: bool,

package/project/.sdk/tm/scala/Makefile

@@ -12,6 +12,7 @@ test:
 	scala-cli run . --main-class SdkTestMain
 	scala-cli run . --main-class SdkEntityTestMain
 	scala-cli run . --main-class Runner -- ../.sdk/test/test.json
+	scala-cli run . --main-class PrimaryCorpusMain -- ../.sdk/test/test.json
 
 corpus:
 	scala-cli run . --main-class Runner -- ../.sdk/test/test.json