@voxgig/sdkgen 4.32.1 → 4.34.0

package/project/.sdk/src/cmp/rb/fragment/Entity.fragment.rb

@@ -34,6 +34,21 @@ class EntyClass
     @_name
   end
 
+  # The entity serialises and prints as its data (clean honours `to_h`),
+  # never as the client it holds or the match it absorbed: a query
+  # credential comes back in resmatch.
+  def to_h
+    VoxgigStruct.clone(@_data)
+  end
+
+  def to_s
+    "EntityName " + VoxgigStruct.jsonify(@_data)
+  end
+
+  def inspect
+    to_s
+  end
+
   # Every operation resolves to the entity; `remove` additionally marks
   # it. The instance KEEPS the data it held — a caller can still read what
   # was deleted — but it is no longer a live record. See AGENTS.md.
@@ -119,53 +134,71 @@ class EntyClass
       false
     end
 
+    # The pipeline runs as the caller iterates, so its errors leave through
+    # the same catch path as an operation's. The caller's block runs on this
+    # stack too, and what it raises is left alone.
     Enumerator.new do |yielder|
-      catch(:stream_stop) do
-        utility.feature_hook.call(ctx, "PrePoint")
-        point, err = utility.make_point.call(ctx)
-        ctx.out["point"] = point
-        throw :stream_stop if err
-
-        utility.feature_hook.call(ctx, "PreSpec")
-        spec, err = utility.make_spec.call(ctx)
-        ctx.out["spec"] = spec
-        throw :stream_stop if err
-
-        utility.feature_hook.call(ctx, "PreRequest")
-        resp, err = utility.make_request.call(ctx)
-        ctx.out["request"] = resp
-        throw :stream_stop if err
-
-        utility.feature_hook.call(ctx, "PreResponse")
-        resp2, err = utility.make_response.call(ctx)
-        ctx.out["response"] = resp2
-        throw :stream_stop if err
-
-        utility.feature_hook.call(ctx, "PreResult")
-        result, err = utility.make_result.call(ctx)
-        ctx.out["result"] = result
-        throw :stream_stop if err
-
-        utility.feature_hook.call(ctx, "PreDone")
-
-        result = ctx.result
-
-        # Inbound: prefer the streaming feature's incremental Enumerator; else
-        # fall back to the materialised items so stream always yields.
-        stream_enum = result ? result.stream : nil
-        if stream_enum
-          stream_enum.each do |item|
-            throw :stream_stop if aborted.call
-            yielder << item
-          end
-        else
-          data = utility.done.call(ctx)
-          items = data.is_a?(Array) ? data : (data.nil? ? [] : [data])
-          items.each do |item|
-            throw :stream_stop if aborted.call
-            yielder << item
+      inblock = false
+      give = lambda do |item|
+        inblock = true
+        yielder << item
+        inblock = false
+      end
+      begin
+        catch(:stream_stop) do
+          utility.feature_hook.call(ctx, "PrePoint")
+          point, err = utility.make_point.call(ctx)
+          ctx.out["point"] = point
+          throw :stream_stop if err
+
+          utility.feature_hook.call(ctx, "PreSpec")
+          spec, err = utility.make_spec.call(ctx)
+          ctx.out["spec"] = spec
+          throw :stream_stop if err
+
+          utility.feature_hook.call(ctx, "PreRequest")
+          resp, err = utility.make_request.call(ctx)
+          ctx.out["request"] = resp
+          throw :stream_stop if err
+
+          utility.feature_hook.call(ctx, "PreResponse")
+          resp2, err = utility.make_response.call(ctx)
+          ctx.out["response"] = resp2
+          throw :stream_stop if err
+
+          utility.feature_hook.call(ctx, "PreResult")
+          result, err = utility.make_result.call(ctx)
+          ctx.out["result"] = result
+          throw :stream_stop if err
+
+          utility.feature_hook.call(ctx, "PreDone")
+
+          result = ctx.result
+
+          # Inbound: prefer the streaming feature's incremental Enumerator;
+          # else fall back to the materialised items so stream always yields.
+          stream_enum = result ? result.stream : nil
+          if stream_enum
+            # done does not run on this path, so its record is cleaned here.
+            utility.clean_explain.call(ctx)
+            stream_enum.each do |item|
+              throw :stream_stop if aborted.call
+              give.call(item)
+            end
+          else
+            data = utility.done.call(ctx)
+            items = data.is_a?(Array) ? data : (data.nil? ? [] : [data])
+            items.each do |item|
+              throw :stream_stop if aborted.call
+              give.call(item)
+            end
           end
         end
+      rescue StandardError => operr
+        raise if inblock
+        ctx.ctrl.err = operr
+        e = _unexpected(ctx, operr)
+        raise e, cause: nil unless e.nil?
       end
     end
   end
@@ -239,9 +272,38 @@ class EntyClass
 
       out
     rescue StandardError => operr
-      # #PreUnexpected-Hook
+      ctx.ctrl.err = operr
+
+      # What a hook raises here must not escape the cleaning below.
+      begin
+        # #PreUnexpected-Hook
+      rescue StandardError => hookerr
+        operr = hookerr
+        ctx.ctrl.err = operr
+      end
 
-      raise operr
+      e = _unexpected(ctx, operr)
+      # Not a cause: the raw error would print beneath the cleaned one.
+      raise e, cause: nil unless e.nil?
+      nil
+    end
+  end
+
+  # An exception the pipeline did not build still leaves through the
+  # caller: it is cleaned, and so is the explain record it interrupted.
+  # Answers nil when throwing is disabled, as the pipeline's own errors do.
+  def _unexpected(ctx, err)
+    clean = @_utility.clean
+    if ctx.ctrl.explain.is_a?(Hash)
+      @_utility.clean_explain.call(ctx)
+      cleanerr = clean.call(ctx, { "message" => err.message.to_s, "class" => err.class.name })
+      if ctx.ctrl.explain["err"].nil?
+        ctx.ctrl.explain["err"] = cleanerr
+      elsif ctx.ctrl.explain["err"]["message"] != cleanerr["message"]
+        ctx.ctrl.explain["unexpected"] = cleanerr
+      end
     end
+    return nil if ctx.ctrl.throw_err == false
+    clean.call(ctx, err)
   end
 end

package/project/.sdk/src/cmp/rb/fragment/Main.fragment.rb

@@ -95,6 +95,17 @@ class ProjectNameSDK
     @_rootctx
   end
 
+  # The options and the root context both hold the credential, so the
+  # client's printed form is its name alone; `options_map` is the
+  # documented way to read them back.
+  def to_s
+    "ProjectName " + VoxgigStruct.jsonify({ "name" => "ProjectName" })
+  end
+
+  def inspect
+    to_s
+  end
+
   def prepare(fetchargs = {})
     utility = @_utility
     fetchargs ||= {}
@@ -202,7 +213,7 @@ class ProjectNameSDK
     url = fetchdef["url"] || ""
     fetched, fetch_err = utility.fetcher.call(ctx, url, fetchdef)
 
-    return { "ok" => false, "err" => fetch_err } if fetch_err
+    return { "ok" => false, "err" => utility.clean.call(ctx, fetch_err) } if fetch_err
 
     if fetched.nil?
       return {

package/project/.sdk/src/cmp/rust/PrepareAuth_rust.ts

@@ -76,9 +76,9 @@ pub fn prepare_auth_util(ctx: &Rc<Context>) -> Result<Rc<RefCell<Spec>>, ${spec.
 
   // HTTP Basic is header-only by definition: the scheme is
   // `Authorization: Basic base64(user:pass)`. It cannot be expressed as a
-  // query parameter or a cookie, so the branch — and the base64 encoder it
-  // needs, which the rust core does not otherwise ship — is emitted only
-  // where it can mean something.
+  // query parameter or a cookie, so the branch is emitted only where it can
+  // mean something. The encoder is the clean utility's, which needs it for
+  // the base64 form of every registered value.
   const withBasic = spec.basic && 'header' === spec.where
 
   const withGetpath = 'header' === spec.where
@@ -98,7 +98,8 @@ use crate::core::context::Context;
 use crate::core::error::${spec.errtype};
 use crate::core::helpers::{getp, ${withGetpath ? 'getpath, ' : ''}setp};
 use crate::core::spec::Spec;
-use crate::utility::voxgigstruct as vs;
+${withBasic ? `use crate::utility::clean::{base64_encode, clean_add};
+` : ''}use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
 ${credComment(spec.where)}
@@ -162,6 +163,9 @@ pub fn prepare_auth_util(ctx: &Rc<Context>) -> Result<Rc<RefCell<Spec>>, ${spec.
                 _ => String::new(),
             };
             let b64 = base64_encode(format!("{}:{}", apikey_val, secret_val).as_bytes());
+            // The joined, encoded pair is a wire form neither credential's own
+            // registration covers.
+            clean_add(ctx, &b64);
 
             let auth_prefix = match getpath(&["auth", "prefix"], &options) {
                 Value::Str(s) => s,
@@ -194,47 +198,7 @@ ${place(spec.where)}
 }
 `
 
-  const encoder = !withBasic ? '' : `
-/// Standard base64, for the \`Authorization: Basic base64(user:pass)\` value.
-///
-/// In-tree because the crate takes no dependency for it: the secrets
-/// feature's base64 DECODER lives behind a feature module this utility
-/// cannot reach, and adding a crate for twenty lines would put a dependency
-/// into every SDK whose API happens to use HTTP Basic.
-fn base64_encode(input: &[u8]) -> String {
-    const ALPHABET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-    let mut out = String::with_capacity((input.len() + 2) / 3 * 4);
-
-    for chunk in input.chunks(3) {
-        // \`chunks\` hands back a 1- or 2-byte tail for input that is not a
-        // multiple of three; the missing bytes read as zero and are padded out
-        // below.
-        let b0 = chunk[0] as usize;
-        let b1 = *chunk.get(1).unwrap_or(&0) as usize;
-        let b2 = *chunk.get(2).unwrap_or(&0) as usize;
-
-        out.push(ALPHABET[b0 >> 2] as char);
-        out.push(ALPHABET[((b0 & 0x03) << 4) | (b1 >> 4)] as char);
-        // The tail is padded, never truncated: a decoder that counts groups
-        // of four needs the '=' to know how many bytes came back.
-        out.push(if 1 < chunk.len() {
-            ALPHABET[((b1 & 0x0f) << 2) | (b2 >> 6)] as char
-        } else {
-            '='
-        });
-        out.push(if 2 < chunk.len() {
-            ALPHABET[b2 & 0x3f] as char
-        } else {
-            '='
-        });
-    }
-
-    out
-}
-`
-
-  return head + basicBlock + tail + encoder
+  return head + basicBlock + tail
 }