@voxgig/sdkgen 1.3.7 → 1.3.9

package/project/.sdk/tm/rust/utility/clean.rs

@@ -0,0 +1,13 @@
+use std::rc::Rc;
+
+use crate::core::context::Context;
+use crate::utility::voxgigstruct::Value;
+
+pub fn clean_util(_ctx: &Rc<Context>, val: &Value) -> Value {
+    val.clone()
+}
+
+/// String flavour of clean (go clean returns the value unchanged).
+pub fn clean_str(_ctx: &Rc<Context>, val: &str) -> String {
+    val.to_string()
+}

package/project/.sdk/tm/rust/utility/done.rs

@@ -0,0 +1,31 @@
+use std::rc::Rc;
+
+use crate::core::context::Context;
+use crate::core::error::ProjectNameError;
+use crate::core::helpers::{getp, to_map};
+use crate::utility::voxgigstruct as vs;
+use crate::utility::voxgigstruct::Value;
+
+pub fn done_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
+    {
+        let ctrl = ctx.ctrl.borrow().clone();
+        let mut c = ctrl.borrow_mut();
+        if c.has_explain() {
+            let explain = crate::utility::clean::clean_util(ctx, &c.explain);
+            if let Value::Map(_) = getp(&explain, "result") {
+                let rm = to_map(&getp(&explain, "result"));
+                vs::del_prop(rm, &Value::str("err"));
+            }
+            c.explain = explain;
+        }
+    }
+
+    let result = ctx.result.borrow().clone();
+    if let Some(res) = result {
+        if res.borrow().ok {
+            return Ok(res.borrow().resdata.clone());
+        }
+    }
+
+    crate::utility::make_error::make_error_util(ctx, None)
+}

package/project/.sdk/tm/rust/utility/feature_add.rs

@@ -0,0 +1,46 @@
+use std::rc::Rc;
+
+use crate::core::context::Context;
+use crate::core::helpers::get_str;
+use crate::core::types::FeatureRef;
+
+// feature_add_util appends a feature to the client's feature list. A
+// feature whose add_options() names an already-added feature with
+// "__before__", "__after__" or "__replace__" positions itself relative to
+// it — mirroring the ts featureAdd. The first match wins; when no ordering
+// option matches, the feature is appended.
+pub fn feature_add_util(ctx: &Rc<Context>, f: FeatureRef) {
+    let client = match ctx.client.borrow().clone() {
+        Some(c) => c,
+        None => return,
+    };
+
+    let fopts = f.borrow().add_options();
+
+    if let Some(fopts) = fopts {
+        let before = get_str(&fopts, "__before__").unwrap_or_default();
+        let after = get_str(&fopts, "__after__").unwrap_or_default();
+        let replace = get_str(&fopts, "__replace__").unwrap_or_default();
+
+        if !before.is_empty() || !after.is_empty() || !replace.is_empty() {
+            let mut features = client.features.borrow_mut();
+            for i in 0..features.len() {
+                let name = features[i].borrow().name();
+                if before == name {
+                    features.insert(i, f);
+                    return;
+                }
+                if after == name {
+                    features.insert(i + 1, f);
+                    return;
+                }
+                if replace == name {
+                    features[i] = f;
+                    return;
+                }
+            }
+        }
+    }
+
+    client.features.borrow_mut().push(f);
+}

package/project/.sdk/tm/rust/utility/feature_hook.rs

@@ -0,0 +1,18 @@
+use std::rc::Rc;
+
+use crate::core::context::Context;
+
+pub fn feature_hook_util(ctx: &Rc<Context>, name: &str) {
+    let client = match ctx.client.borrow().clone() {
+        Some(c) => c,
+        None => return,
+    };
+
+    // Snapshot the list so a hook that mutates the feature set does not
+    // invalidate iteration.
+    let features: Vec<_> = client.features.borrow().iter().cloned().collect();
+
+    for f in features {
+        f.borrow_mut().dispatch(name, ctx);
+    }
+}

package/project/.sdk/tm/rust/utility/feature_init.rs

@@ -0,0 +1,26 @@
+use std::rc::Rc;
+
+use crate::core::context::Context;
+use crate::core::helpers::{get_bool, getp, to_map};
+use crate::core::types::FeatureRef;
+use crate::utility::voxgigstruct::Value;
+
+pub fn feature_init_util(ctx: &Rc<Context>, f: &FeatureRef) {
+    let fname = f.borrow().name();
+    let mut fopts = Value::empty_map();
+
+    let options = ctx.options.borrow().clone();
+    if let Value::Map(_) = options {
+        let feature_opts = to_map(&getp(&options, "feature"));
+        if let Value::Map(_) = feature_opts {
+            let fo = to_map(&getp(&feature_opts, &fname));
+            if let Value::Map(_) = fo {
+                fopts = fo;
+            }
+        }
+    }
+
+    if get_bool(&fopts, "active") == Some(true) {
+        f.borrow_mut().init(ctx, &fopts);
+    }
+}

package/project/.sdk/tm/rust/utility/fetcher.rs

@@ -0,0 +1,142 @@
+use std::rc::Rc;
+
+use crate::core::context::Context;
+use crate::core::error::ProjectNameError;
+use crate::core::helpers::{call_vfn, get_str, getp, getpath, ja, jo, json_thunk, setp};
+use crate::utility::voxgigstruct::Value;
+
+// Default live transport: ureq (blocking, minimal). Honours a `proxy`
+// annotation on the fetch definition (set by the proxy feature) by routing
+// the request through an agent configured with that proxy.
+fn default_http_fetch(fullurl: &str, fetchdef: &Value) -> Result<Value, ProjectNameError> {
+    let method = get_str(fetchdef, "method")
+        .filter(|m| !m.is_empty())
+        .unwrap_or_else(|| "GET".to_string());
+
+    let mut builder = ureq::AgentBuilder::new();
+    if let Some(proxy) = get_str(fetchdef, "proxy").filter(|p| !p.is_empty()) {
+        if let Ok(p) = ureq::Proxy::new(&proxy) {
+            builder = builder.proxy(p);
+        }
+    }
+    let agent = builder.build();
+
+    let mut req = agent.request(&method, fullurl);
+
+    let mut has_ua = false;
+    if let Value::Map(m) = getp(fetchdef, "headers") {
+        for (k, v) in m.borrow().iter() {
+            if let Value::Str(sv) = v {
+                if k.eq_ignore_ascii_case("user-agent") {
+                    has_ua = true;
+                }
+                req = req.set(k, sv);
+            }
+        }
+    }
+    // Default User-Agent — some CDNs block library defaults. Use a
+    // Mozilla-shaped UA unless the caller already set one.
+    if !has_ua {
+        req = req.set("User-Agent", "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)");
+    }
+
+    let body = get_str(fetchdef, "body").filter(|b| !b.is_empty());
+
+    let sent = match body {
+        Some(b) => req.send_string(&b),
+        None => req.call(),
+    };
+
+    // ureq reports non-2xx as Err(Status) — unwrap those back into normal
+    // responses so the result pipeline classifies them.
+    let resp = match sent {
+        Ok(r) => r,
+        Err(ureq::Error::Status(_code, r)) => r,
+        Err(e) => {
+            return Err(ProjectNameError::new("fetch_transport", &format!("{}", e)));
+        }
+    };
+
+    let status = resp.status() as i64;
+    let status_text = resp.status_text().to_string();
+
+    let headers = Value::empty_map();
+    for name in resp.headers_names() {
+        if let Some(val) = resp.header(&name) {
+            setp(&headers, &name.to_lowercase(), Value::str(val));
+        }
+    }
+
+    let body_txt = resp
+        .into_string()
+        .map_err(|e| ProjectNameError::new("fetch_body", &format!("{}", e)))?;
+
+    let json_body = if body_txt.is_empty() {
+        Value::Noval
+    } else {
+        crate::utility::jsonparse::json_parse(&body_txt).unwrap_or(Value::Noval)
+    };
+
+    Ok(jo(vec![
+        ("status", Value::Num(status as f64)),
+        ("statusText", Value::str(status_text)),
+        ("headers", headers),
+        ("json", json_thunk(json_body)),
+        ("body", Value::str(body_txt)),
+    ]))
+}
+
+pub fn fetcher_util(
+    ctx: &Rc<Context>,
+    fullurl: &str,
+    fetchdef: &Value,
+) -> Result<Value, ProjectNameError> {
+    let client = ctx
+        .client
+        .borrow()
+        .clone()
+        .ok_or_else(|| ctx.make_error("fetch_no_client", "Expected context client."))?;
+
+    let mode = client.mode.borrow().clone();
+    if mode != "live" {
+        return Err(ctx.make_error(
+            "fetch_mode_block",
+            &format!(
+                "Request blocked by mode: \"{}\" (URL was: \"{}\")",
+                mode, fullurl
+            ),
+        ));
+    }
+
+    let options = client.options_map();
+    if getpath(&["feature", "test", "active"], &options) == Value::Bool(true) {
+        return Err(ctx.make_error(
+            "fetch_test_block",
+            &format!(
+                "Request blocked as test feature is active (URL was: \"{}\")",
+                fullurl
+            ),
+        ));
+    }
+
+    let sys_fetch = getpath(&["system", "fetch"], &options);
+
+    if sys_fetch.is_noval() || sys_fetch.is_null() {
+        return default_http_fetch(fullurl, fetchdef);
+    }
+
+    if let Value::Func(_) = sys_fetch {
+        // Caller-supplied transport: called with [url, fetchdef]; returns a
+        // transport-shaped response map (an "__err__" entry signals failure).
+        let out = call_vfn(
+            &sys_fetch,
+            &ja(vec![Value::str(fullurl), fetchdef.clone()]),
+        );
+        if let Some(msg) = get_str(&out, "__err__") {
+            return Err(ctx.make_error("fetch_system", &msg));
+        }
+        return Ok(out);
+    }
+
+    Err(ctx.make_error("fetch_invalid", "system.fetch is not a valid function"))
+}

package/project/.sdk/tm/rust/utility/jsonparse.rs

@@ -0,0 +1,211 @@
+// Minimal recursive-descent JSON parser producing voxgig struct Values.
+// Keeps the SDK runtime dependency-free (the struct port has jsonify for
+// serialisation; this is the matching parse). Object key order is
+// preserved (OrderedMap), numbers are f64 (JSON semantics).
+
+use crate::utility::voxgigstruct::ordered_map::OrderedMap;
+use crate::utility::voxgigstruct::Value;
+
+pub fn json_parse(src: &str) -> Result<Value, String> {
+    let bytes: Vec<char> = src.chars().collect();
+    let mut p = Parser { c: &bytes, i: 0 };
+    p.ws();
+    let v = p.value()?;
+    p.ws();
+    if p.i != p.c.len() {
+        return Err(format!("unexpected trailing input at {}", p.i));
+    }
+    Ok(v)
+}
+
+struct Parser<'a> {
+    c: &'a [char],
+    i: usize,
+}
+
+impl<'a> Parser<'a> {
+    fn peek(&self) -> Option<char> {
+        self.c.get(self.i).copied()
+    }
+
+    fn ws(&mut self) {
+        while let Some(ch) = self.peek() {
+            if ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' {
+                self.i += 1;
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn expect(&mut self, ch: char) -> Result<(), String> {
+        if self.peek() == Some(ch) {
+            self.i += 1;
+            Ok(())
+        } else {
+            Err(format!("expected '{}' at {}", ch, self.i))
+        }
+    }
+
+    fn lit(&mut self, word: &str, val: Value) -> Result<Value, String> {
+        for wc in word.chars() {
+            if self.peek() != Some(wc) {
+                return Err(format!("invalid literal at {}", self.i));
+            }
+            self.i += 1;
+        }
+        Ok(val)
+    }
+
+    fn value(&mut self) -> Result<Value, String> {
+        match self.peek() {
+            Some('{') => self.object(),
+            Some('[') => self.array(),
+            Some('"') => Ok(Value::Str(self.string()?)),
+            Some('t') => self.lit("true", Value::Bool(true)),
+            Some('f') => self.lit("false", Value::Bool(false)),
+            Some('n') => self.lit("null", Value::Null),
+            Some(ch) if ch == '-' || ch.is_ascii_digit() => self.number(),
+            other => Err(format!("unexpected {:?} at {}", other, self.i)),
+        }
+    }
+
+    fn object(&mut self) -> Result<Value, String> {
+        self.expect('{')?;
+        let mut m = OrderedMap::new();
+        self.ws();
+        if self.peek() == Some('}') {
+            self.i += 1;
+            return Ok(Value::map(m));
+        }
+        loop {
+            self.ws();
+            let key = self.string()?;
+            self.ws();
+            self.expect(':')?;
+            self.ws();
+            let val = self.value()?;
+            m.insert(key, val);
+            self.ws();
+            match self.peek() {
+                Some(',') => {
+                    self.i += 1;
+                }
+                Some('}') => {
+                    self.i += 1;
+                    return Ok(Value::map(m));
+                }
+                other => return Err(format!("unexpected {:?} in object at {}", other, self.i)),
+            }
+        }
+    }
+
+    fn array(&mut self) -> Result<Value, String> {
+        self.expect('[')?;
+        let mut items = Vec::new();
+        self.ws();
+        if self.peek() == Some(']') {
+            self.i += 1;
+            return Ok(Value::list(items));
+        }
+        loop {
+            self.ws();
+            items.push(self.value()?);
+            self.ws();
+            match self.peek() {
+                Some(',') => {
+                    self.i += 1;
+                }
+                Some(']') => {
+                    self.i += 1;
+                    return Ok(Value::list(items));
+                }
+                other => return Err(format!("unexpected {:?} in array at {}", other, self.i)),
+            }
+        }
+    }
+
+    fn string(&mut self) -> Result<String, String> {
+        self.expect('"')?;
+        let mut out = String::new();
+        loop {
+            match self.peek() {
+                None => return Err("unterminated string".to_string()),
+                Some('"') => {
+                    self.i += 1;
+                    return Ok(out);
+                }
+                Some('\\') => {
+                    self.i += 1;
+                    match self.peek() {
+                        Some('"') => out.push('"'),
+                        Some('\\') => out.push('\\'),
+                        Some('/') => out.push('/'),
+                        Some('b') => out.push('\u{0008}'),
+                        Some('f') => out.push('\u{000C}'),
+                        Some('n') => out.push('\n'),
+                        Some('r') => out.push('\r'),
+                        Some('t') => out.push('\t'),
+                        Some('u') => {
+                            let mut code = 0u32;
+                            for _ in 0..4 {
+                                self.i += 1;
+                                let d = self
+                                    .peek()
+                                    .and_then(|c| c.to_digit(16))
+                                    .ok_or_else(|| format!("bad \\u escape at {}", self.i))?;
+                                code = code * 16 + d;
+                            }
+                            // Surrogate pairs.
+                            if (0xD800..0xDC00).contains(&code) {
+                                if self.c.get(self.i + 1) == Some(&'\\')
+                                    && self.c.get(self.i + 2) == Some(&'u')
+                                {
+                                    self.i += 2;
+                                    let mut low = 0u32;
+                                    for _ in 0..4 {
+                                        self.i += 1;
+                                        let d = self
+                                            .peek()
+                                            .and_then(|c| c.to_digit(16))
+                                            .ok_or_else(|| {
+                                                format!("bad \\u escape at {}", self.i)
+                                            })?;
+                                        low = low * 16 + d;
+                                    }
+                                    code = 0x10000 + ((code - 0xD800) << 10) + (low - 0xDC00);
+                                }
+                            }
+                            out.push(char::from_u32(code).unwrap_or('\u{FFFD}'));
+                        }
+                        other => return Err(format!("bad escape {:?} at {}", other, self.i)),
+                    }
+                    self.i += 1;
+                }
+                Some(ch) => {
+                    out.push(ch);
+                    self.i += 1;
+                }
+            }
+        }
+    }
+
+    fn number(&mut self) -> Result<Value, String> {
+        let start = self.i;
+        if self.peek() == Some('-') {
+            self.i += 1;
+        }
+        while let Some(ch) = self.peek() {
+            if ch.is_ascii_digit() || ch == '.' || ch == 'e' || ch == 'E' || ch == '+' || ch == '-'
+            {
+                self.i += 1;
+            } else {
+                break;
+            }
+        }
+        let txt: String = self.c[start..self.i].iter().collect();
+        txt.parse::<f64>()
+            .map(Value::Num)
+            .map_err(|e| format!("bad number '{}': {}", txt, e))
+    }
+}

package/project/.sdk/tm/rust/utility/make_context.rs

@@ -0,0 +1,7 @@
+use std::rc::Rc;
+
+use crate::core::context::{Context, CtxSpec};
+
+pub fn make_context_util(ctxspec: CtxSpec, basectx: Option<&Rc<Context>>) -> Rc<Context> {
+    Context::new(ctxspec, basectx)
+}

package/project/.sdk/tm/rust/utility/make_error.rs

@@ -0,0 +1,79 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use crate::core::context::Context;
+use crate::core::error::ProjectNameError;
+use crate::core::helpers::{jo, setp};
+use crate::core::result::SdkResult;
+use crate::utility::voxgigstruct::Value;
+
+pub fn make_error_util(
+    ctx: &Rc<Context>,
+    err: Option<ProjectNameError>,
+) -> Result<Value, ProjectNameError> {
+    let op = ctx.op.borrow().clone();
+    let mut opname = op.name.clone();
+    if opname.is_empty() || opname == "_" {
+        opname = "unknown operation".to_string();
+    }
+
+    // Bind the clone to a local first: a `match` scrutinee keeps its
+    // temporary `Ref` alive for the whole match, which would collide with the
+    // `borrow_mut()` in the None arm ("RefCell already borrowed").
+    let cur_result = ctx.result.borrow().clone();
+    let result = match cur_result {
+        Some(r) => r,
+        None => {
+            let r = Rc::new(RefCell::new(SdkResult::new(&Value::empty_map())));
+            *ctx.result.borrow_mut() = Some(r.clone());
+            r
+        }
+    };
+    result.borrow_mut().ok = false;
+
+    let err = err
+        .or_else(|| result.borrow().err.clone())
+        .unwrap_or_else(|| ctx.make_error("unknown", "unknown error"));
+
+    let errmsg = err.msg.clone();
+    let msg = format!("ProjectNameSDK: {}: {}", opname, errmsg);
+    let msg = crate::utility::clean::clean_str(ctx, &msg);
+
+    result.borrow_mut().err = None;
+
+    let spec_val = match ctx.spec.borrow().clone() {
+        Some(s) => s.borrow().to_value(),
+        None => Value::Noval,
+    };
+
+    let ctrl = ctx.ctrl.borrow().clone();
+    {
+        let c = ctrl.borrow();
+        if c.has_explain() {
+            setp(
+                &c.explain,
+                "err",
+                jo(vec![("message", Value::str(msg.clone()))]),
+            );
+        }
+    }
+
+    let mut sdk_err = ProjectNameError::new("", &msg);
+    sdk_err.code = err.code.clone();
+    sdk_err.result = crate::utility::clean::clean_util(ctx, &result.borrow().to_value());
+    sdk_err.spec = crate::utility::clean::clean_util(ctx, &spec_val);
+
+    ctrl.borrow_mut().err = Some(sdk_err.clone());
+
+    // Fire PreUnexpected so observability features (metrics, telemetry, audit,
+    // debug) close/record error paths that never reach PreDone (e.g. a PrePoint
+    // rbac short-circuit). Fires after ctx.ctrl.err is set so hooks can read the
+    // error; features guard against double-recording when PreDone already fired.
+    crate::utility::feature_hook::feature_hook_util(ctx, "PreUnexpected");
+
+    if ctrl.borrow().throw == Some(false) {
+        return Ok(result.borrow().resdata.clone());
+    }
+
+    Err(sdk_err)
+}

package/project/.sdk/tm/rust/utility/make_fetch_def.rs

@@ -0,0 +1,42 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use crate::core::context::Context;
+use crate::core::error::ProjectNameError;
+use crate::core::helpers::setp;
+use crate::core::result::SdkResult;
+use crate::utility::voxgigstruct as vs;
+use crate::utility::voxgigstruct::Value;
+
+pub fn make_fetch_def_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
+    let spec = ctx.spec.borrow().clone().ok_or_else(|| {
+        ctx.make_error("fetchdef_no_spec", "Expected context spec property to be defined.")
+    })?;
+
+    if ctx.result.borrow().is_none() {
+        *ctx.result.borrow_mut() =
+            Some(Rc::new(RefCell::new(SdkResult::new(&Value::empty_map()))));
+    }
+
+    spec.borrow_mut().step = "prepare".to_string();
+
+    let url = crate::utility::make_url::make_url_util(ctx)?;
+
+    spec.borrow_mut().url = url.clone();
+
+    let fetchdef = Value::empty_map();
+    setp(&fetchdef, "url", Value::str(url));
+    setp(&fetchdef, "method", Value::str(spec.borrow().method.clone()));
+    setp(&fetchdef, "headers", spec.borrow().headers.clone());
+
+    let body = spec.borrow().body.clone();
+    if !body.is_noval() {
+        if let Value::Map(_) = body {
+            setp(&fetchdef, "body", Value::str(vs::jsonify(&body, None)));
+        } else {
+            setp(&fetchdef, "body", body);
+        }
+    }
+
+    Ok(fetchdef)
+}