@voxgig/sdkgen 4.32.1 → 4.33.0

package/project/.sdk/src/cmp/csharp/Test_csharp.ts

@@ -9,6 +9,7 @@ import { cmp, each, Folder, entityCollection,
 
 import { TestEntity } from './TestEntity_csharp'
 import { TestDirect } from './TestDirect_csharp'
+import { TestClean } from './TestClean_csharp'
 import { ReadmeExamplesTest } from './ReadmeExamplesTest_csharp'
 
 
@@ -24,6 +25,7 @@ const Test = cmp(function Test(props: any) {
 
     // Write-once: a project's edited control file survives regeneration.
     TestControl({ target, dir: 'test' })
+    TestClean({ target })
 
     const entity = each(entityCollection(model))
       .filter((e: any) => false !== e.active)

package/project/.sdk/src/cmp/csharp/fragment/EntityBase.fragment.cs

@@ -3,6 +3,7 @@
 // unsupported-op implementations of every CRUD method. Generated entity
 // classes derive from this and override the operations their API defines.
 
+using System.Reflection;
 using System.Runtime.CompilerServices;
 
 using Voxgig.Struct;
@@ -118,6 +119,38 @@ public abstract class ProjectNameEntityBase : IEntity
         => throw Helpers.UnsupportedOp("remove", name);
 
     protected object? RunOp(Context ctx, Action postDone)
+    {
+        try
+        {
+            return RunPipeline(ctx, postDone);
+        }
+        catch (Exception err) when (!ReferenceEquals(err, ctx.Ctrl.Err))
+        {
+            return Unexpected(ctx, err);
+        }
+    }
+
+    // The catch path. A hook's exception never passed through MakeError, and
+    // can quote the request. FeatureHook invokes by reflection, which wraps it.
+    // MakeError fires PreUnexpected; an error a hook throws there escapes it,
+    // even under throw false, so it is cleaned here.
+    private object? Unexpected(Context ctx, Exception err)
+    {
+        try
+        {
+            return utility.MakeError(ctx, Unwrapped(err));
+        }
+        catch (Exception thrown) when (!ReferenceEquals(thrown, ctx.Ctrl.Err))
+        {
+            var cause = Unwrapped(thrown);
+            throw utility.Clean(ctx, cause) as Exception ?? cause;
+        }
+    }
+
+    private static Exception Unwrapped(Exception err) =>
+        err is TargetInvocationException { InnerException: { } inner } ? inner : err;
+
+    private object? RunPipeline(Context ctx, Action postDone)
     {
         // #PrePoint-Hook
 
@@ -276,13 +309,44 @@ public abstract class ProjectNameEntityBase : IEntity
         var stream = ctx.Result?.Stream;
         if (stream != null)
         {
-            foreach (var item in stream())
+            // The caller iterates after RunOp has returned, so a failing source
+            // takes the catch path here; under throw false the stream ends. A
+            // yield cannot sit in a try with a catch: the source is driven by hand.
+            IEnumerator<object?>? source = null;
+            try
             {
-                if (cancel.IsCancellationRequested || signal.IsCancellationRequested)
+                while (true)
                 {
-                    yield break;
+                    var more = false;
+                    object? item = null;
+                    try
+                    {
+                        source ??= stream().GetEnumerator();
+                        more = source.MoveNext();
+                        item = more ? source.Current : null;
+                    }
+                    catch (Exception err) when (!ReferenceEquals(err, ctx.Ctrl.Err))
+                    {
+                        more = false;
+                        Unexpected(ctx, err);
+                    }
+                    if (!more || cancel.IsCancellationRequested || signal.IsCancellationRequested)
+                    {
+                        yield break;
+                    }
+                    yield return item;
+                }
+            }
+            finally
+            {
+                try
+                {
+                    source?.Dispose();
+                }
+                catch (Exception err) when (!ReferenceEquals(err, ctx.Ctrl.Err))
+                {
+                    Unexpected(ctx, err);
                 }
-                yield return item;
             }
         }
         else

package/project/.sdk/src/cmp/csharp/fragment/Main.fragment.cs

@@ -224,7 +224,7 @@ public class ProjectNameSDK
             return new Dictionary<string, object?>
             {
                 ["ok"] = false,
-                ["err"] = err,
+                ["err"] = CleanErr(_rootctx, err),
             };
         }
 
@@ -251,7 +251,7 @@ public class ProjectNameSDK
             return new Dictionary<string, object?>
             {
                 ["ok"] = false,
-                ["err"] = fetchErr,
+                ["err"] = CleanErr(ctx, fetchErr),
             };
         }
 
@@ -302,6 +302,12 @@ public class ProjectNameSDK
         };
     }
 
+    // A raw request returns its error rather than passing it through MakeError.
+    private Exception CleanErr(Context ctx, Exception err)
+    {
+        return _utility.Clean(ctx, err) as Exception ?? err;
+    }
+
     // Raw GraphQL access: the pressure valve that makes the generated
     // surface's deliberate omissions (per-call selection sets, typed filter
     // builders, batching, subscriptions) livable — the whole schema stays

package/project/.sdk/src/cmp/csharp/fragment/SdkError.fragment.cs

@@ -1,6 +1,10 @@
 // ProjectNameError - the SDK error type. Carries the pipeline error code,
 // the originating context and cleaned result/spec snapshots.
 
+using System.Text.Json.Serialization;
+
+using Voxgig.Struct;
+
 namespace ProjectNameSdk;
 
 public class ProjectNameError : Exception
@@ -8,14 +12,59 @@ public class ProjectNameError : Exception
     public bool IsProjectNameError = true;
     public string Sdk = "ProjectName";
     public string Code;
+
+    // Reachable for a debugger, out of every serialiser: the context holds
+    // the live spec and options, and an error is what gets logged.
+    [JsonIgnore]
     public Context? Ctx;
+
+    // The HTTP status, -1 when there was no response.
+    public int Status = -1;
+
     public object? ResultVal;
     public object? SpecVal;
 
+    private string _message;
+
     public ProjectNameError(string code, string msg, Context? ctx)
         : base(msg)
     {
         Code = code;
         Ctx = ctx;
+        _message = msg;
+    }
+
+    public override string Message => _message;
+
+    public bool NotFound => 404 == Status;
+
+    // Clean rewrites the message in place, since the error is about to be
+    // thrown; Exception's own is read-only.
+    internal void SetMessage(string msg)
+    {
+        _message = msg;
+    }
+
+    // What MakeError attached is already cleaned; the context is not part of
+    // the record.
+    public Dictionary<string, object?> ToRecord()
+    {
+        return new Dictionary<string, object?>
+        {
+            ["sdk"] = Sdk,
+            ["code"] = Code,
+            ["message"] = Message,
+            ["status"] = Status,
+            ["result"] = ResultVal,
+            ["spec"] = SpecVal,
+        };
+    }
+
+    public override string ToString()
+    {
+        var text = GetType().FullName + ": [" + Code + "] " + Message +
+            " (status " + Status + ") spec=" + StructUtils.Jsonify(SpecVal, 0);
+        var stack = StackTrace;
+        return null == stack ? text : text + "\n" + stack;
     }
 }

package/project/.sdk/src/cmp/elixir/PrepareAuth_elixir.ts

@@ -156,6 +156,9 @@ ${bag}
             ap = S.getpath(options, "auth.prefix")
             auth_prefix = if is_binary(ap), do: ap, else: ""
             b64 = Base.encode64(apikey <> ":" <> if(no_secret, do: "", else: secret))
+            # The joined, encoded pair is a wire form neither credential's
+            # own registration covers.
+            ${spec.Name}.Utility.clean_add(ctx, b64)
             hv = if auth_prefix != "", do: auth_prefix <> " " <> b64, else: b64
             S.setprop(headers, @cred_name, hv)
           end

package/project/.sdk/src/cmp/elixir/Schema_elixir.ts

@@ -41,16 +41,26 @@ defmodule ${Name}.Schema do
 
   @entityspec_data ${elixirString(JSON.stringify(entityspec))}
 
-  # Parsed at COMPILE time and held as a literal: the spec is read on every
-  # client construction and never mutated, so parsing per call would be pure
-  # waste, and elixir terms are immutable so sharing carries no risk at all.
-  @optspec ${Name}.Json.parse(@optspec_data)
-
-  @entityspec ${Name}.Json.parse(@entityspec_data)
-
-  def optspec, do: @optspec
-
-  def entityspec, do: @entityspec
+  # Parsed once per VM and held in :persistent_term. The parse yields struct
+  # nodes, which are handles into this VM's heap, so a compile-time literal
+  # would point into the heap of whichever VM compiled the module.
+  def optspec, do: memo(:optspec, @optspec_data)
+
+  def entityspec, do: memo(:entityspec, @entityspec_data)
+
+  defp memo(name, data) do
+    key = {__MODULE__, name}
+
+    case :persistent_term.get(key, nil) do
+      nil ->
+        spec = ${Name}.Json.parse(data)
+        :persistent_term.put(key, spec)
+        spec
+
+      spec ->
+        spec
+    end
+  end
 end
 `)
   })