@voxgig/sdkgen 1.3.8 → 1.3.10

package/project/.sdk/tm/kotlin/core/Context.kt

@@ -0,0 +1,247 @@
+package KOTLINPACKAGE.core
+
+import java.util.concurrent.ThreadLocalRandom
+
+import KOTLINPACKAGE.utility.struct.Struct
+
+/** Per-operation context threaded through the pipeline and feature hooks. */
+@Suppress("UNCHECKED_CAST")
+class Context(ctxmap: MutableMap<String, Any?>?, basectx: Context?) {
+
+  var id: String
+  var out: MutableMap<String, Any?> = linkedMapOf()
+  var ctrl: Control = Control()
+  var meta: MutableMap<String, Any?> = linkedMapOf()
+  var client: SdkClient? = null
+  var utility: Utility? = null
+  lateinit var op: Operation
+  var point: MutableMap<String, Any?>? = null
+  var config: MutableMap<String, Any?>? = null
+  var entopts: MutableMap<String, Any?>? = null
+  var options: MutableMap<String, Any?>? = null
+  var opmap: MutableMap<String, Operation>? = null
+  var response: Response? = null
+  var result: Result? = null
+  var spec: Spec? = null
+  var data: MutableMap<String, Any?> = linkedMapOf()
+  var reqdata: MutableMap<String, Any?> = linkedMapOf()
+  var match: MutableMap<String, Any?> = linkedMapOf()
+  var reqmatch: MutableMap<String, Any?> = linkedMapOf()
+  var entity: Entity? = null
+  var shared: MutableMap<String, Any?>? = null
+
+  init {
+    this.id = "C" + (ThreadLocalRandom.current().nextInt(90000000) + 10000000)
+
+    // Client
+    val c = Helpers.getCtxProp(ctxmap, "client")
+    if (c is SdkClient) {
+      this.client = c
+    }
+    if (this.client == null && basectx != null) {
+      this.client = basectx.client
+    }
+
+    // Utility
+    val u = Helpers.getCtxProp(ctxmap, "utility")
+    if (u is Utility) {
+      this.utility = u
+    }
+    if (this.utility == null && basectx != null) {
+      this.utility = basectx.utility
+    }
+
+    // Ctrl
+    this.ctrl = Control()
+    val cv = Helpers.getCtxProp(ctxmap, "ctrl")
+    if (cv != null) {
+      if (cv is MutableMap<*, *>) {
+        val cm = cv as MutableMap<String, Any?>
+        val t = cm["throw"]
+        if (t is Boolean) {
+          this.ctrl.throwing = t
+        }
+        val e = cm["explain"]
+        if (e is MutableMap<*, *>) {
+          this.ctrl.explain = e as MutableMap<String, Any?>
+        }
+        val a = cm["actor"]
+        if (a is String) {
+          this.ctrl.actor = a
+        }
+        val p = cm["paging"]
+        if (p is MutableMap<*, *>) {
+          this.ctrl.paging = p as MutableMap<String, Any?>
+        }
+      } else if (cv is Control) {
+        this.ctrl = cv
+      }
+    } else if (basectx != null) {
+      this.ctrl = basectx.ctrl
+    }
+
+    // Meta
+    this.meta = linkedMapOf()
+    val m = Helpers.getCtxProp(ctxmap, "meta")
+    if (m is MutableMap<*, *>) {
+      this.meta = m as MutableMap<String, Any?>
+    } else if (basectx != null) {
+      this.meta = basectx.meta
+    }
+
+    // Config
+    val cfg = Helpers.getCtxProp(ctxmap, "config")
+    if (cfg is MutableMap<*, *>) {
+      this.config = cfg as MutableMap<String, Any?>
+    }
+    if (this.config == null && basectx != null) {
+      this.config = basectx.config
+    }
+
+    // Entopts
+    val eo = Helpers.getCtxProp(ctxmap, "entopts")
+    if (eo is MutableMap<*, *>) {
+      this.entopts = eo as MutableMap<String, Any?>
+    }
+    if (this.entopts == null && basectx != null) {
+      this.entopts = basectx.entopts
+    }
+
+    // Options
+    val o = Helpers.getCtxProp(ctxmap, "options")
+    if (o is MutableMap<*, *>) {
+      this.options = o as MutableMap<String, Any?>
+    }
+    if (this.options == null && basectx != null) {
+      this.options = basectx.options
+    }
+
+    // Entity
+    val e = Helpers.getCtxProp(ctxmap, "entity")
+    if (e is Entity) {
+      this.entity = e
+    }
+    if (this.entity == null && basectx != null) {
+      this.entity = basectx.entity
+    }
+
+    // Shared
+    val s = Helpers.getCtxProp(ctxmap, "shared")
+    if (s is MutableMap<*, *>) {
+      this.shared = s as MutableMap<String, Any?>
+    }
+    if (this.shared == null && basectx != null) {
+      this.shared = basectx.shared
+    }
+
+    // Opmap
+    val om = Helpers.getCtxProp(ctxmap, "opmap")
+    if (om is MutableMap<*, *>) {
+      this.opmap = om as MutableMap<String, Operation>
+    }
+    if (this.opmap == null && basectx != null) {
+      this.opmap = basectx.opmap
+    }
+    if (this.opmap == null) {
+      this.opmap = linkedMapOf()
+    }
+
+    // Data
+    this.data = Helpers.toMapAny(Helpers.getCtxProp(ctxmap, "data")) ?: linkedMapOf()
+    this.reqdata = Helpers.toMapAny(Helpers.getCtxProp(ctxmap, "reqdata")) ?: linkedMapOf()
+    this.match = Helpers.toMapAny(Helpers.getCtxProp(ctxmap, "match")) ?: linkedMapOf()
+    this.reqmatch = Helpers.toMapAny(Helpers.getCtxProp(ctxmap, "reqmatch")) ?: linkedMapOf()
+
+    // Point
+    val t = Helpers.getCtxProp(ctxmap, "point")
+    if (t is MutableMap<*, *>) {
+      this.point = t as MutableMap<String, Any?>
+    }
+    if (this.point == null && basectx != null) {
+      this.point = basectx.point
+    }
+
+    // Spec
+    val sp = Helpers.getCtxProp(ctxmap, "spec")
+    if (sp is Spec) {
+      this.spec = sp
+    }
+    if (this.spec == null && basectx != null) {
+      this.spec = basectx.spec
+    }
+
+    // Result
+    val r = Helpers.getCtxProp(ctxmap, "result")
+    if (r is Result) {
+      this.result = r
+    }
+    if (this.result == null && basectx != null) {
+      this.result = basectx.result
+    }
+
+    // Response
+    val resp = Helpers.getCtxProp(ctxmap, "response")
+    if (resp is Response) {
+      this.response = resp
+    }
+    if (this.response == null && basectx != null) {
+      this.response = basectx.response
+    }
+
+    // Resolve operation
+    val opname = Helpers.getCtxProp(ctxmap, "opname")
+    this.op = resolveOp(if (opname is String) opname else "")
+  }
+
+  private fun resolveOp(opname: String): Operation {
+    // Cache key is `<entity>:<opname>` so two entities with the same op
+    // (e.g. both have a "list") get distinct cached Operations.
+    var entname = ""
+    if (this.entity != null) {
+      entname = this.entity!!.name
+    }
+    val cacheKey = "$entname:$opname"
+
+    val cached = this.opmap!![cacheKey]
+    if (cached != null) {
+      return cached
+    }
+
+    if ("" == opname) {
+      return Operation(linkedMapOf())
+    }
+
+    val opcfg = Struct.getpath(this.config, listOf("entity", entname, "op", opname))
+
+    var input = "match"
+    if ("update" == opname || "create" == opname) {
+      input = "data"
+    }
+
+    var points: MutableList<Any?>? = null
+    if (opcfg is MutableMap<*, *>) {
+      val t = Struct.getprop(opcfg, "points")
+      if (t is MutableList<*>) {
+        points = t as MutableList<Any?>
+      }
+    }
+    if (points == null) {
+      points = mutableListOf()
+    }
+
+    val opdef = linkedMapOf<String, Any?>()
+    opdef["entity"] = entname
+    opdef["name"] = opname
+    opdef["input"] = input
+    opdef["points"] = points
+
+    val op = Operation(opdef)
+
+    this.opmap!![cacheKey] = op
+    return op
+  }
+
+  fun makeError(code: String, msg: String): SdkError {
+    return SdkError(code, msg, this)
+  }
+}

package/project/.sdk/tm/kotlin/core/Control.kt

@@ -0,0 +1,21 @@
+package KOTLINPACKAGE.core
+
+/** Per-call control state: throw behaviour, explain capture, actor, paging. */
+class Control {
+
+  // Tri-state: null (default: throw), true, or false (return fallback data).
+  var throwing: Boolean? = null
+
+  var err: RuntimeException? = null
+
+  var explain: MutableMap<String, Any?>? = null
+
+  var actor: String = ""
+
+  var paging: MutableMap<String, Any?>? = null
+
+  // Outbound streaming marker: the entity `stream` method sets this to the
+  // caller-supplied streamable payload so the request builder / transport can
+  // stream it as the request body.
+  var streamOut: Any? = null
+}

package/project/.sdk/tm/kotlin/core/Helpers.kt

@@ -0,0 +1,49 @@
+package KOTLINPACKAGE.core
+
+/** Small shared conversions used across the ProjectName SDK runtime. */
+object Helpers {
+
+  // unsupportedOp is thrown by entity stub methods for operations the
+  // underlying API spec doesn't define. The static SdkEntity interface
+  // requires every CRUD method on every entity, so absent ops must still be
+  // callable — they error at runtime instead of failing to compile.
+  fun unsupportedOp(opname: String, entityname: String): SdkError {
+    return SdkError(
+      "op_unsupported",
+      "operation '" + opname + "' not supported by entity '" + entityname + "'",
+      null,
+    )
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  fun toMapAny(v: Any?): MutableMap<String, Any?>? {
+    if (v == null) {
+      return null
+    }
+    if (v is MutableMap<*, *>) {
+      return v as MutableMap<String, Any?>
+    }
+    return null
+  }
+
+  fun toInt(v: Any?): Int {
+    if (v is Number) {
+      return v.toInt()
+    }
+    return -1
+  }
+
+  fun toLong(v: Any?, def: Long): Long {
+    if (v is Number) {
+      return v.toLong()
+    }
+    return def
+  }
+
+  fun getCtxProp(m: Map<String, Any?>?, key: String): Any? {
+    if (m == null) {
+      return null
+    }
+    return m[key]
+  }
+}

package/project/.sdk/tm/kotlin/core/Interfaces.kt

@@ -0,0 +1,88 @@
+package KOTLINPACKAGE.core
+
+/** Minimal entity contract used by the result pipeline (list wrapping). */
+interface Entity {
+  val name: String
+
+  fun make(): Entity
+
+  fun data(vararg args: Any?): Any?
+
+  fun match(vararg args: Any?): Any?
+}
+
+/**
+ * The full CRUD entity contract of the ProjectName SDK. Every generated
+ * entity implements every operation; unsupported operations throw an
+ * SdkError at runtime (see Helpers.unsupportedOp).
+ */
+interface SdkEntity : Entity {
+  fun load(reqmatch: MutableMap<String, Any?>?, ctrl: MutableMap<String, Any?>?): Any?
+
+  fun list(reqmatch: MutableMap<String, Any?>?, ctrl: MutableMap<String, Any?>?): Any?
+
+  fun create(reqdata: MutableMap<String, Any?>?, ctrl: MutableMap<String, Any?>?): Any?
+
+  fun update(reqdata: MutableMap<String, Any?>?, ctrl: MutableMap<String, Any?>?): Any?
+
+  fun remove(reqmatch: MutableMap<String, Any?>?, ctrl: MutableMap<String, Any?>?): Any?
+
+  // Runs `action` through the pipeline and returns a Sequence over result
+  // items (the streaming feature's incremental output when active, else the
+  // materialised items). See EntityBase.stream.
+  fun stream(
+    action: String,
+    args: MutableMap<String, Any?>?,
+    callopts: MutableMap<String, Any?>?,
+  ): Sequence<Any?>
+}
+
+/**
+ * A ProjectName SDK feature. Hook methods are dispatched by name via the
+ * featureHook utility (reflectively, so features may also define extra
+ * hooks beyond this interface).
+ */
+interface Feature {
+  val version: String
+
+  val name: String
+
+  val active: Boolean
+
+  fun init(ctx: Context, options: MutableMap<String, Any?>)
+
+  fun postConstruct(ctx: Context)
+
+  fun postConstructEntity(ctx: Context)
+
+  fun setData(ctx: Context)
+
+  fun getData(ctx: Context)
+
+  fun getMatch(ctx: Context)
+
+  fun setMatch(ctx: Context)
+
+  fun prePoint(ctx: Context)
+
+  fun preSpec(ctx: Context)
+
+  fun preRequest(ctx: Context)
+
+  fun preResponse(ctx: Context)
+
+  fun preResult(ctx: Context)
+
+  fun preDone(ctx: Context)
+
+  fun preUnexpected(ctx: Context)
+}
+
+/**
+ * Optional capability: a feature exposing add-time placement options
+ * ("__before__", "__after__", "__replace__") read by the featureAdd
+ * utility. Every BaseFeature implements this via its addOpts field.
+ */
+interface FeaturePlacement {
+  fun addOptions(): MutableMap<String, Any?>?
+}

package/project/.sdk/tm/kotlin/core/Operation.kt

@@ -0,0 +1,43 @@
+package KOTLINPACKAGE.core
+
+import KOTLINPACKAGE.utility.struct.Struct
+
+/** A resolved entity operation (name, input kind, endpoint definitions). */
+@Suppress("UNCHECKED_CAST")
+class Operation(opmap: Map<String, Any?>?) {
+
+  var entity: String = "_"
+  var name: String = "_"
+  var input: String = "_"
+  var points: MutableList<MutableMap<String, Any?>> = mutableListOf()
+  var alias: MutableMap<String, Any?>? = null
+
+  init {
+    var v = Struct.getprop(opmap, "entity")
+    if (v is String && v != "") {
+      this.entity = v
+    }
+    v = Struct.getprop(opmap, "name")
+    if (v is String && v != "") {
+      this.name = v
+    }
+    v = Struct.getprop(opmap, "input")
+    if (v is String && v != "") {
+      this.input = v
+    }
+
+    val rawPoints = Struct.getprop(opmap, "points")
+    if (rawPoints is List<*>) {
+      for (t in rawPoints) {
+        if (t is MutableMap<*, *>) {
+          this.points.add(t as MutableMap<String, Any?>)
+        }
+      }
+    }
+
+    val rawAlias = Struct.getprop(opmap, "alias")
+    if (rawAlias is MutableMap<*, *>) {
+      this.alias = rawAlias as MutableMap<String, Any?>
+    }
+  }
+}

package/project/.sdk/tm/kotlin/core/Point.kt

@@ -0,0 +1,83 @@
+package KOTLINPACKAGE.core
+
+import KOTLINPACKAGE.utility.struct.Struct
+
+/** A single endpoint definition (typed view over a point map). */
+@Suppress("UNCHECKED_CAST")
+class Point(pointmap: Map<String, Any?>?) {
+
+  var args: MutableMap<String, Any?>
+  var rename: MutableMap<String, Any?>
+  var method: String = ""
+  var orig: String = ""
+  var parts: MutableList<Any?> = mutableListOf()
+  var params: MutableList<Any?>? = null
+  var select: MutableMap<String, Any?>? = null
+  var active: Boolean = false
+  var relations: MutableList<Any?>? = null
+  var alias: MutableMap<String, Any?> = linkedMapOf()
+  var transform: MutableMap<String, Any?> = linkedMapOf()
+
+  init {
+    var v = Struct.getprop(pointmap, "args")
+    if (v is MutableMap<*, *>) {
+      this.args = v as MutableMap<String, Any?>
+    } else {
+      this.args = linkedMapOf()
+      this.args["params"] = mutableListOf<Any?>()
+    }
+
+    v = Struct.getprop(pointmap, "rename")
+    if (v is MutableMap<*, *>) {
+      this.rename = v as MutableMap<String, Any?>
+    } else {
+      this.rename = linkedMapOf()
+      this.rename["params"] = linkedMapOf<String, Any?>()
+    }
+
+    v = Struct.getprop(pointmap, "method")
+    if (v is String) {
+      this.method = v
+    }
+
+    v = Struct.getprop(pointmap, "orig")
+    if (v is String) {
+      this.orig = v
+    }
+
+    v = Struct.getprop(pointmap, "parts")
+    if (v is MutableList<*>) {
+      this.parts = v as MutableList<Any?>
+    }
+
+    v = Struct.getprop(pointmap, "params")
+    if (v is MutableList<*>) {
+      this.params = v as MutableList<Any?>
+    }
+
+    v = Struct.getprop(pointmap, "select")
+    if (v is MutableMap<*, *>) {
+      this.select = v as MutableMap<String, Any?>
+    }
+
+    v = Struct.getprop(pointmap, "active")
+    if (v is Boolean) {
+      this.active = v
+    }
+
+    v = Struct.getprop(pointmap, "relations")
+    if (v is MutableList<*>) {
+      this.relations = v as MutableList<Any?>
+    }
+
+    v = Struct.getprop(pointmap, "alias")
+    if (v is MutableMap<*, *>) {
+      this.alias = v as MutableMap<String, Any?>
+    }
+
+    v = Struct.getprop(pointmap, "transform")
+    if (v is MutableMap<*, *>) {
+      this.transform = v as MutableMap<String, Any?>
+    }
+  }
+}

package/project/.sdk/tm/kotlin/core/Response.kt

@@ -0,0 +1,43 @@
+package KOTLINPACKAGE.core
+
+import java.util.function.Supplier
+
+import KOTLINPACKAGE.utility.struct.Struct
+
+/** A transport-level response (thin wrapper over the fetcher's map shape). */
+@Suppress("UNCHECKED_CAST")
+class Response(resmap: Map<String, Any?>?) {
+
+  var status: Int = -1
+  var statusText: String = ""
+  var headers: Any? = null
+  var jsonFunc: Supplier<Any?>? = null
+  var body: Any? = null
+  var err: RuntimeException? = null
+
+  init {
+    val s = Struct.getprop(resmap, "status")
+    if (s is Number) {
+      this.status = Helpers.toInt(s)
+    }
+
+    val st = Struct.getprop(resmap, "statusText")
+    if (st is String) {
+      this.statusText = st
+    }
+
+    this.headers = Struct.getprop(resmap, "headers", null)
+
+    val jf = Struct.getprop(resmap, "json")
+    if (jf is Supplier<*>) {
+      this.jsonFunc = jf as Supplier<Any?>
+    }
+
+    this.body = Struct.getprop(resmap, "body", null)
+
+    val e = Struct.getprop(resmap, "err")
+    if (e is RuntimeException) {
+      this.err = e
+    }
+  }
+}

package/project/.sdk/tm/kotlin/core/Result.kt

@@ -0,0 +1,61 @@
+package KOTLINPACKAGE.core
+
+import java.util.function.Supplier
+
+import KOTLINPACKAGE.utility.struct.Struct
+
+/** The processed outcome of one operation. */
+@Suppress("UNCHECKED_CAST")
+class Result(resmap: Map<String, Any?>?) {
+
+  var ok: Boolean = false
+  var status: Int = -1
+  var statusText: String = ""
+  var headers: MutableMap<String, Any?> = linkedMapOf()
+  var body: Any? = null
+  var err: RuntimeException? = null
+  var resdata: Any? = null
+  var resmatch: MutableMap<String, Any?>? = null
+
+  // Feature extensions: pagination signals (paging feature) and the
+  // incremental item iterator (streaming feature).
+  var paging: MutableMap<String, Any?>? = null
+  var streaming: Boolean = false
+  var stream: Supplier<Iterator<Any?>>? = null
+
+  init {
+    val o = Struct.getprop(resmap, "ok")
+    if (o is Boolean) {
+      this.ok = o
+    }
+
+    val s = Struct.getprop(resmap, "status")
+    if (s is Number) {
+      this.status = Helpers.toInt(s)
+    }
+
+    val st = Struct.getprop(resmap, "statusText")
+    if (st is String) {
+      this.statusText = st
+    }
+
+    val h = Struct.getprop(resmap, "headers")
+    if (h is MutableMap<*, *>) {
+      this.headers = h as MutableMap<String, Any?>
+    }
+
+    this.body = Struct.getprop(resmap, "body", null)
+
+    val e = Struct.getprop(resmap, "err")
+    if (e is RuntimeException) {
+      this.err = e
+    }
+
+    this.resdata = Struct.getprop(resmap, "resdata", null)
+
+    val rm = Struct.getprop(resmap, "resmatch")
+    if (rm is MutableMap<*, *>) {
+      this.resmatch = rm as MutableMap<String, Any?>
+    }
+  }
+}