@voxgig/sdkgen 4.32.0 → 4.33.0

package/project/.sdk/src/cmp/kotlin/fragment/EntityBase.fragment.kt

@@ -137,15 +137,33 @@ abstract class EntityBase(nm: String, clientIn: SdkClient, entoptsIn: MutableMap
 
       return out
     } catch (err: RuntimeException) {
-      // An error already finalised by makeError (e.g. via done) must not be
-      // wrapped a second time.
-      if (err === ctx.ctrl.err) {
-        throw err
-      }
-      return utility.makeError(ctx, err)
+      return unexpected(ctx, err)
+    }
+  }
+
+  // The catch path. An error already finalised by makeError (e.g. via done)
+  // must not be wrapped a second time.
+  private fun unexpected(ctx: Context, err: RuntimeException): Any? {
+    if (err === ctx.ctrl.err) {
+      throw err
+    }
+    try {
+      return this.utility.makeError(ctx, err)
+    } catch (thrown: RuntimeException) {
+      throw if (thrown === ctx.ctrl.err) thrown else cleanError(ctx, thrown)
     }
   }
 
+  // A source is called directly, not through featureHook, so its plain
+  // Exception is wrapped here as featureHook wraps a hook's.
+  private fun unexpectedSource(ctx: Context, err: Exception): Any? =
+    unexpected(ctx, err as? RuntimeException ?: RuntimeException(err))
+
+  // makeError fires PreUnexpected; an error a hook throws there escapes it,
+  // even under throw false, so it is cleaned here.
+  private fun cleanError(ctx: Context, err: RuntimeException): RuntimeException =
+    this.utility.clean(ctx, err) as? RuntimeException ?: err
+
   /**
    * Streaming operations. Runs `action` through the full pipeline and returns
    * a Sequence over result items, so the streaming feature's incremental
@@ -195,7 +213,13 @@ abstract class EntityBase(nm: String, clientIn: SdkClient, entoptsIn: MutableMap
 
     // Inbound: prefer the streaming feature's incremental iterator; else fall
     // back to the materialised items so `stream` always yields.
-    val source: Iterator<Any?> = ctx.result?.stream?.get()
+    val streamed: Iterator<Any?>? = try {
+      ctx.result?.stream?.get()
+    } catch (err: Exception) {
+      unexpectedSource(ctx, err)
+      emptyList<Any?>().iterator()
+    }
+    val source: Iterator<Any?> = streamed
       ?: run {
         val items: List<Any?> = when (materialised) {
           is List<*> -> materialised
@@ -214,12 +238,21 @@ abstract class EntityBase(nm: String, clientIn: SdkClient, entoptsIn: MutableMap
       }
     }
 
+    // The caller iterates after runOp has returned, so a failing source takes
+    // the catch path here; under throw false the stream then ends.
+    val end = Any()
     return sequence {
-      while (source.hasNext()) {
-        if (aborted()) {
-          return@sequence
+      while (true) {
+        val item = try {
+          if (source.hasNext() && !aborted()) source.next() else end
+        } catch (err: Exception) {
+          unexpectedSource(ctx, err)
+          end
+        }
+        if (item === end) {
+          break
         }
-        yield(source.next())
+        yield(item)
       }
     }
   }

package/project/.sdk/src/cmp/kotlin/fragment/SdkError.fragment.kt

@@ -1,5 +1,7 @@
 package KOTLINPACKAGE.core
 
+import KOTLINPACKAGE.utility.struct.Struct
+
 /**
  * ProjectName SDK error. Carries the SDK error code, the operation context,
  * and cleaned copies of the result and spec at failure time.
@@ -10,6 +12,11 @@ class SdkError(code: String?, msg: String, ctx: Context?) : RuntimeException(msg
   var code: String = code ?: ""
   var msg: String = msg
 
+  // The HTTP status when there was a response, -1 otherwise.
+  var status: Int = -1
+
+  // Reachable for a debugger, out of every serialisation: the context holds
+  // the live spec and options, and an error is what gets logged.
   @Transient
   var ctx: Context? = ctx
 
@@ -19,6 +26,30 @@ class SdkError(code: String?, msg: String, ctx: Context?) : RuntimeException(msg
   @Transient
   var spec: Any? = null
 
+  val notFound: Boolean
+    get() = 404 == this.status
+
   override val message: String
     get() = this.msg
+
+  // What makeError attached is already cleaned; the context is not part of
+  // the record.
+  fun toMap(): MutableMap<String, Any?> {
+    val out = linkedMapOf<String, Any?>()
+    out["sdk"] = this.sdk
+    out["code"] = this.code
+    out["message"] = this.msg
+    out["status"] = this.status
+    out["result"] = this.result
+    out["spec"] = this.spec
+    return out
+  }
+
+  fun toJson(): String {
+    return Struct.jsonify(this.toMap())
+  }
+
+  override fun toString(): String {
+    return "ProjectNameError " + this.toJson()
+  }
 }

package/project/.sdk/src/cmp/lua/PrepareAuth_lua.ts

@@ -211,6 +211,9 @@ const BASIC = `
         auth_prefix = ap
       end
       local joined = base64(tostring(apikey) .. ":" .. tostring(secret))
+      -- The joined, encoded pair is a wire form neither credential's own
+      -- registration covers.
+      ctx.utility.clean_add(ctx, joined)
       if auth_prefix == "" then
         headers[HEADER_AUTH] = joined
       else