@voxgig/sdkgen 1.3.8 → 1.3.9

package/project/.sdk/tm/rust/core/operation.rs

@@ -0,0 +1,35 @@
+// Operation description (mirrors go core/operation.go).
+
+use crate::core::helpers::{get_str, getp, to_map};
+use crate::utility::voxgigstruct::Value;
+
+pub struct Operation {
+    pub entity: String,
+    pub name: String,
+    pub input: String,
+    pub points: Value,
+    pub alias: Value,
+}
+
+impl Operation {
+    pub fn new(opmap: &Value) -> Operation {
+        let entity = get_str(opmap, "entity").filter(|s| !s.is_empty());
+        let name = get_str(opmap, "name").filter(|s| !s.is_empty());
+        let input = get_str(opmap, "input").filter(|s| !s.is_empty());
+
+        let points = match getp(opmap, "points") {
+            Value::List(l) => Value::List(l),
+            _ => Value::empty_list(),
+        };
+
+        let alias = to_map(&getp(opmap, "alias"));
+
+        Operation {
+            entity: entity.unwrap_or_else(|| "_".to_string()),
+            name: name.unwrap_or_else(|| "_".to_string()),
+            input: input.unwrap_or_else(|| "_".to_string()),
+            points,
+            alias,
+        }
+    }
+}

package/project/.sdk/tm/rust/core/point.rs

@@ -0,0 +1,68 @@
+// Endpoint point description (mirrors go core/target.go NewPoint). Points
+// stay Value maps in the pipeline; this typed view is a convenience for
+// callers that want field access.
+
+use crate::core::helpers::{get_bool, get_str, getp, jo, to_map};
+use crate::utility::voxgigstruct::Value;
+
+pub struct Point {
+    pub args: Value,
+    pub rename: Value,
+    pub method: String,
+    pub orig: String,
+    pub parts: Value,
+    pub params: Value,
+    pub select: Value,
+    pub active: bool,
+    pub relations: Value,
+    pub alias: Value,
+    pub transform: Value,
+}
+
+impl Point {
+    pub fn new(altmap: &Value) -> Point {
+        let args = match to_map(&getp(altmap, "args")) {
+            Value::Map(m) => Value::Map(m),
+            _ => jo(vec![("params", Value::empty_list())]),
+        };
+
+        let rename = match to_map(&getp(altmap, "rename")) {
+            Value::Map(m) => Value::Map(m),
+            _ => jo(vec![("params", Value::empty_map())]),
+        };
+
+        let parts = match getp(altmap, "parts") {
+            Value::List(l) => Value::List(l),
+            _ => Value::empty_list(),
+        };
+
+        let params = match getp(altmap, "params") {
+            Value::List(l) => Value::List(l),
+            _ => Value::Noval,
+        };
+
+        let alias = match to_map(&getp(altmap, "alias")) {
+            Value::Map(m) => Value::Map(m),
+            _ => Value::empty_map(),
+        };
+
+        let transform = match to_map(&getp(altmap, "transform")) {
+            Value::Map(m) => Value::Map(m),
+            _ => Value::empty_map(),
+        };
+
+        Point {
+            args,
+            rename,
+            method: get_str(altmap, "method").unwrap_or_default(),
+            orig: get_str(altmap, "orig").unwrap_or_default(),
+            parts,
+            params,
+            select: to_map(&getp(altmap, "select")),
+            active: get_bool(altmap, "active").unwrap_or(false),
+            relations: getp(altmap, "relations"),
+            alias,
+            transform,
+        }
+    }
+}

package/project/.sdk/tm/rust/core/response.rs

@@ -0,0 +1,38 @@
+// Transport response wrapper (mirrors go core/response.go). The `json`
+// entry stays a Value::Func thunk so bodies can be re-read repeatedly.
+
+use crate::core::error::ProjectNameError;
+use crate::core::helpers::{get_str, getp, to_int};
+use crate::utility::voxgigstruct::Value;
+
+pub struct Response {
+    pub status: i64,
+    pub status_text: String,
+    pub headers: Value,
+    pub json: Value,
+    pub body: Value,
+    pub err: Option<ProjectNameError>,
+}
+
+impl Response {
+    pub fn new(resmap: &Value) -> Response {
+        let status = match getp(resmap, "status") {
+            Value::Noval => -1,
+            s => to_int(&s),
+        };
+
+        let status_text = get_str(resmap, "statusText").unwrap_or_default();
+        let headers = getp(resmap, "headers");
+        let json = getp(resmap, "json");
+        let body = getp(resmap, "body");
+
+        Response {
+            status,
+            status_text,
+            headers,
+            json,
+            body,
+            err: None,
+        }
+    }
+}

package/project/.sdk/tm/rust/core/result.rs

@@ -0,0 +1,90 @@
+// Operation result (mirrors go core/result.go).
+
+use std::rc::Rc;
+
+use crate::core::error::ProjectNameError;
+use crate::core::helpers::{get_bool, get_str, getp, setp, to_int};
+use crate::utility::voxgigstruct::Value;
+
+/// Stream producer attached by the streaming feature: yields the result
+/// items (or chunked batches) with configured pacing applied.
+pub type StreamFn = Rc<dyn Fn() -> Vec<Value>>;
+
+pub struct SdkResult {
+    pub ok: bool,
+    pub status: i64,
+    pub status_text: String,
+    pub headers: Value,
+    pub body: Value,
+    pub err: Option<ProjectNameError>,
+    pub resdata: Value,
+    pub resmatch: Value,
+
+    // Feature extensions: pagination signals (paging feature) and the
+    // incremental item iterator (streaming feature).
+    pub paging: Value,
+    pub streaming: bool,
+    pub stream: Option<StreamFn>,
+}
+
+impl SdkResult {
+    pub fn new(resmap: &Value) -> SdkResult {
+        let ok = get_bool(resmap, "ok").unwrap_or(false);
+        let status = match getp(resmap, "status") {
+            Value::Noval => -1,
+            s => to_int(&s),
+        };
+        let status_text = get_str(resmap, "statusText").unwrap_or_default();
+        let headers = match getp(resmap, "headers") {
+            Value::Map(m) => Value::Map(m),
+            _ => Value::empty_map(),
+        };
+        let body = getp(resmap, "body");
+        let resdata = getp(resmap, "resdata");
+        let resmatch = match getp(resmap, "resmatch") {
+            Value::Map(m) => Value::Map(m),
+            _ => Value::Noval,
+        };
+
+        SdkResult {
+            ok,
+            status,
+            status_text,
+            headers,
+            body,
+            err: None,
+            resdata,
+            resmatch,
+            paging: Value::Noval,
+            streaming: false,
+            stream: None,
+        }
+    }
+
+    /// Match-map view for tests and explain records.
+    pub fn to_value(&self) -> Value {
+        let out = Value::empty_map();
+        setp(&out, "ok", Value::Bool(self.ok));
+        setp(&out, "status", Value::Num(self.status as f64));
+        setp(&out, "statusText", Value::str(self.status_text.clone()));
+        setp(&out, "headers", self.headers.clone());
+        if !self.body.is_noval() {
+            setp(&out, "body", self.body.clone());
+        }
+        if let Some(e) = &self.err {
+            let em = Value::empty_map();
+            setp(&em, "message", Value::str(e.msg.clone()));
+            setp(&out, "err", em);
+        }
+        if !self.resdata.is_noval() {
+            setp(&out, "resdata", self.resdata.clone());
+        }
+        if !self.resmatch.is_noval() {
+            setp(&out, "resmatch", self.resmatch.clone());
+        }
+        if !self.paging.is_noval() {
+            setp(&out, "paging", self.paging.clone());
+        }
+        out
+    }
+}

package/project/.sdk/tm/rust/core/spec.rs

@@ -0,0 +1,109 @@
+// Request specification (mirrors go core/spec.go).
+
+use crate::core::helpers::{get_str, getp};
+use crate::utility::voxgigstruct::Value;
+
+pub struct Spec {
+    pub parts: Value,
+    pub headers: Value,
+    pub alias: Value,
+    pub base: String,
+    pub prefix: String,
+    pub suffix: String,
+    pub params: Value,
+    pub query: Value,
+    pub step: String,
+    pub method: String,
+    pub body: Value,
+    pub url: String,
+    pub path: String,
+}
+
+impl Spec {
+    pub fn new(specmap: &Value) -> Spec {
+        let mut s = Spec {
+            parts: Value::Noval,
+            headers: Value::empty_map(),
+            alias: Value::empty_map(),
+            base: String::new(),
+            prefix: String::new(),
+            suffix: String::new(),
+            params: Value::empty_map(),
+            query: Value::empty_map(),
+            step: String::new(),
+            method: "GET".to_string(),
+            body: Value::Noval,
+            url: String::new(),
+            path: String::new(),
+        };
+
+        if !matches!(specmap, Value::Map(_)) {
+            return s;
+        }
+
+        if let Value::List(_) = getp(specmap, "parts") {
+            s.parts = getp(specmap, "parts");
+        }
+        if let Value::Map(_) = getp(specmap, "headers") {
+            s.headers = getp(specmap, "headers");
+        }
+        if let Value::Map(_) = getp(specmap, "alias") {
+            s.alias = getp(specmap, "alias");
+        }
+        if let Some(b) = get_str(specmap, "base") {
+            s.base = b;
+        }
+        if let Some(p) = get_str(specmap, "prefix") {
+            s.prefix = p;
+        }
+        if let Some(sf) = get_str(specmap, "suffix") {
+            s.suffix = sf;
+        }
+        if let Value::Map(_) = getp(specmap, "params") {
+            s.params = getp(specmap, "params");
+        }
+        if let Value::Map(_) = getp(specmap, "query") {
+            s.query = getp(specmap, "query");
+        }
+        if let Some(st) = get_str(specmap, "step") {
+            s.step = st;
+        }
+        if let Some(m) = get_str(specmap, "method") {
+            s.method = m;
+        }
+        let body = getp(specmap, "body");
+        if !body.is_noval() {
+            s.body = body;
+        }
+        if let Some(u) = get_str(specmap, "url") {
+            s.url = u;
+        }
+        if let Some(p) = get_str(specmap, "path") {
+            s.path = p;
+        }
+
+        s
+    }
+
+    /// Match-map view for tests and explain records.
+    pub fn to_value(&self) -> Value {
+        let out = Value::empty_map();
+        crate::core::helpers::setp(&out, "base", Value::str(self.base.clone()));
+        crate::core::helpers::setp(&out, "prefix", Value::str(self.prefix.clone()));
+        crate::core::helpers::setp(&out, "suffix", Value::str(self.suffix.clone()));
+        crate::core::helpers::setp(&out, "path", Value::str(self.path.clone()));
+        crate::core::helpers::setp(&out, "method", Value::str(self.method.clone()));
+        crate::core::helpers::setp(&out, "params", self.params.clone());
+        crate::core::helpers::setp(&out, "query", self.query.clone());
+        crate::core::helpers::setp(&out, "headers", self.headers.clone());
+        crate::core::helpers::setp(&out, "step", Value::str(self.step.clone()));
+        crate::core::helpers::setp(&out, "alias", self.alias.clone());
+        if !self.body.is_noval() {
+            crate::core::helpers::setp(&out, "body", self.body.clone());
+        }
+        if !self.url.is_empty() {
+            crate::core::helpers::setp(&out, "url", Value::str(self.url.clone()));
+        }
+        out
+    }
+}

package/project/.sdk/tm/rust/core/types.rs

@@ -0,0 +1,105 @@
+// Core traits and shared type aliases (mirrors go core/types.go).
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use crate::core::context::Context;
+use crate::core::error::ProjectNameError;
+use crate::core::response::Response;
+use crate::core::result::SdkResult;
+use crate::core::spec::Spec;
+use crate::utility::voxgigstruct::Value;
+
+/// Feature: every pipeline hook, with no-op defaults. Features are trait
+/// objects (`FeatureRef`); `add_options` mirrors go's AddOptions so
+/// featureAdd `__before__` / `__after__` / `__replace__` ordering works.
+pub trait Feature {
+    fn version(&self) -> String {
+        "0.0.1".to_string()
+    }
+    fn name(&self) -> String;
+    fn active(&self) -> bool;
+
+    /// Ordering options consulted by the featureAdd utility. Default: None.
+    fn add_options(&self) -> Option<Value> {
+        None
+    }
+
+    fn init(&mut self, _ctx: &Rc<Context>, _options: &Value) {}
+
+    fn post_construct(&mut self, _ctx: &Rc<Context>) {}
+    fn post_construct_entity(&mut self, _ctx: &Rc<Context>) {}
+    fn set_data(&mut self, _ctx: &Rc<Context>) {}
+    fn get_data(&mut self, _ctx: &Rc<Context>) {}
+    fn get_match(&mut self, _ctx: &Rc<Context>) {}
+    fn set_match(&mut self, _ctx: &Rc<Context>) {}
+
+    fn pre_point(&mut self, _ctx: &Rc<Context>) {}
+    fn pre_spec(&mut self, _ctx: &Rc<Context>) {}
+    fn pre_request(&mut self, _ctx: &Rc<Context>) {}
+    fn pre_response(&mut self, _ctx: &Rc<Context>) {}
+    fn pre_result(&mut self, _ctx: &Rc<Context>) {}
+    fn pre_done(&mut self, _ctx: &Rc<Context>) {}
+    fn pre_unexpected(&mut self, _ctx: &Rc<Context>) {}
+
+    /// Non-standard hooks (go dispatches these reflectively; rust routes
+    /// unknown hook names here).
+    fn custom_hook(&mut self, _name: &str, _ctx: &Rc<Context>) {}
+
+    /// Hook dispatch by name (called by the featureHook utility).
+    fn dispatch(&mut self, name: &str, ctx: &Rc<Context>) {
+        match name {
+            "PostConstruct" => self.post_construct(ctx),
+            "PostConstructEntity" => self.post_construct_entity(ctx),
+            "SetData" => self.set_data(ctx),
+            "GetData" => self.get_data(ctx),
+            "GetMatch" => self.get_match(ctx),
+            "SetMatch" => self.set_match(ctx),
+            "PrePoint" => self.pre_point(ctx),
+            "PreSpec" => self.pre_spec(ctx),
+            "PreRequest" => self.pre_request(ctx),
+            "PreResponse" => self.pre_response(ctx),
+            "PreResult" => self.pre_result(ctx),
+            "PreDone" => self.pre_done(ctx),
+            "PreUnexpected" => self.pre_unexpected(ctx),
+            _ => self.custom_hook(name, ctx),
+        }
+    }
+}
+
+pub type FeatureRef = Rc<RefCell<dyn Feature>>;
+
+/// Entity: the dynamic entity contract (mirrors go core Entity interface).
+/// `matchv` is go's Match (— `match` is a rust keyword).
+pub trait Entity {
+    fn get_name(&self) -> String;
+    fn make(&self) -> Rc<dyn Entity>;
+    fn data(&self, args: Option<&Value>) -> Value;
+    fn matchv(&self, args: Option<&Value>) -> Value;
+}
+
+/// ProjectNameEntity: the full CRUD contract every generated entity
+/// implements. Ops the API spec doesn't define are runtime-error stubs.
+pub trait ProjectNameEntity: Entity {
+    fn load(&self, reqmatch: Value, ctrl: Value) -> Result<Value, ProjectNameError>;
+    fn list(&self, reqmatch: Value, ctrl: Value) -> Result<Value, ProjectNameError>;
+    fn create(&self, reqdata: Value, ctrl: Value) -> Result<Value, ProjectNameError>;
+    fn update(&self, reqdata: Value, ctrl: Value) -> Result<Value, ProjectNameError>;
+    fn remove(&self, reqmatch: Value, ctrl: Value) -> Result<Value, ProjectNameError>;
+}
+
+/// Transport: `(ctx, url, fetchdef) -> transport-shaped response map`.
+/// An Ok(Value::Noval) mirrors go's (nil, nil) transport result.
+pub type FetcherFn =
+    Rc<dyn Fn(&Rc<Context>, &str, &Value) -> Result<Value, ProjectNameError>>;
+
+/// Pipeline stage products staged on ctx.out (go stores these in the
+/// untyped ctx.Out map; rust keeps them in one typed enum).
+#[derive(Clone)]
+pub enum OutVal {
+    Val(Value),
+    Err(ProjectNameError),
+    Spec(Rc<RefCell<Spec>>),
+    Response(Rc<RefCell<Response>>),
+    Result(Rc<RefCell<SdkResult>>),
+}

package/project/.sdk/tm/rust/core/utility_type.rs

@@ -0,0 +1,184 @@
+// The Utility bundle (mirrors go core/utility_type.go). Go carries the
+// utilities as swappable function pointers; rust binds them statically and
+// keeps the two members that genuinely vary per client swappable: the
+// transport (`fetcher`, wrapped by features like retry/cache/netsim) and
+// the `custom` map of caller-supplied utility callables.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use crate::core::context::{Context, CtxSpec};
+use crate::core::error::ProjectNameError;
+use crate::core::response::Response;
+use crate::core::result::SdkResult;
+use crate::core::spec::Spec;
+use crate::core::types::{FeatureRef, FetcherFn};
+use crate::utility as u;
+use crate::utility::voxgigstruct::Value;
+
+pub struct Utility {
+    pub fetcher: RefCell<FetcherFn>,
+    pub custom: RefCell<Value>,
+}
+
+impl Utility {
+    pub fn new() -> Rc<Utility> {
+        Rc::new(Utility {
+            fetcher: RefCell::new(Rc::new(|ctx, url, fetchdef| {
+                u::fetcher::fetcher_util(ctx, url, fetchdef)
+            })),
+            custom: RefCell::new(Value::empty_map()),
+        })
+    }
+
+    /// CopyUtility: a fresh view sharing the (possibly feature-wrapped)
+    /// fetcher, with a shallow copy of the custom map.
+    pub fn copy(src: &Utility) -> Rc<Utility> {
+        let custom = Value::empty_map();
+        if let Value::Map(m) = &*src.custom.borrow() {
+            for (k, v) in m.borrow().iter() {
+                crate::core::helpers::setp(&custom, k, v.clone());
+            }
+        }
+        Rc::new(Utility {
+            fetcher: RefCell::new(src.fetcher.borrow().clone()),
+            custom: RefCell::new(custom),
+        })
+    }
+
+    /// Invoke the active transport.
+    pub fn fetch(
+        &self,
+        ctx: &Rc<Context>,
+        url: &str,
+        fetchdef: &Value,
+    ) -> Result<Value, ProjectNameError> {
+        let f = self.fetcher.borrow().clone();
+        f(ctx, url, fetchdef)
+    }
+
+    pub fn clean(&self, ctx: &Rc<Context>, val: &Value) -> Value {
+        u::clean::clean_util(ctx, val)
+    }
+
+    pub fn done(&self, ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
+        u::done::done_util(ctx)
+    }
+
+    pub fn make_error(
+        &self,
+        ctx: &Rc<Context>,
+        err: Option<ProjectNameError>,
+    ) -> Result<Value, ProjectNameError> {
+        u::make_error::make_error_util(ctx, err)
+    }
+
+    pub fn feature_add(&self, ctx: &Rc<Context>, f: FeatureRef) {
+        u::feature_add::feature_add_util(ctx, f)
+    }
+
+    pub fn feature_hook(&self, ctx: &Rc<Context>, name: &str) {
+        u::feature_hook::feature_hook_util(ctx, name)
+    }
+
+    pub fn feature_init(&self, ctx: &Rc<Context>, f: &FeatureRef) {
+        u::feature_init::feature_init_util(ctx, f)
+    }
+
+    pub fn make_fetch_def(&self, ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
+        u::make_fetch_def::make_fetch_def_util(ctx)
+    }
+
+    pub fn make_context(&self, spec: CtxSpec, basectx: Option<&Rc<Context>>) -> Rc<Context> {
+        u::make_context::make_context_util(spec, basectx)
+    }
+
+    pub fn make_options(&self, ctx: &Rc<Context>) -> Value {
+        u::make_options::make_options_util(ctx)
+    }
+
+    pub fn make_request(
+        &self,
+        ctx: &Rc<Context>,
+    ) -> Result<Rc<RefCell<Response>>, ProjectNameError> {
+        u::make_request::make_request_util(ctx)
+    }
+
+    pub fn make_response(
+        &self,
+        ctx: &Rc<Context>,
+    ) -> Result<Rc<RefCell<Response>>, ProjectNameError> {
+        u::make_response::make_response_util(ctx)
+    }
+
+    pub fn make_result(
+        &self,
+        ctx: &Rc<Context>,
+    ) -> Result<Rc<RefCell<SdkResult>>, ProjectNameError> {
+        u::make_result::make_result_util(ctx)
+    }
+
+    pub fn make_point(&self, ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
+        u::make_point::make_point_util(ctx)
+    }
+
+    pub fn make_spec(&self, ctx: &Rc<Context>) -> Result<Rc<RefCell<Spec>>, ProjectNameError> {
+        u::make_spec::make_spec_util(ctx)
+    }
+
+    pub fn make_url(&self, ctx: &Rc<Context>) -> Result<String, ProjectNameError> {
+        u::make_url::make_url_util(ctx)
+    }
+
+    pub fn param(&self, ctx: &Rc<Context>, paramdef: &Value) -> Value {
+        u::param::param_util(ctx, paramdef)
+    }
+
+    pub fn prepare_auth(&self, ctx: &Rc<Context>) -> Result<Rc<RefCell<Spec>>, ProjectNameError> {
+        u::prepare_auth::prepare_auth_util(ctx)
+    }
+
+    pub fn prepare_body(&self, ctx: &Rc<Context>) -> Value {
+        u::prepare_body::prepare_body_util(ctx)
+    }
+
+    pub fn prepare_headers(&self, ctx: &Rc<Context>) -> Value {
+        u::prepare_headers::prepare_headers_util(ctx)
+    }
+
+    pub fn prepare_method(&self, ctx: &Rc<Context>) -> String {
+        u::prepare_method::prepare_method_util(ctx)
+    }
+
+    pub fn prepare_params(&self, ctx: &Rc<Context>) -> Value {
+        u::prepare_params::prepare_params_util(ctx)
+    }
+
+    pub fn prepare_path(&self, ctx: &Rc<Context>) -> String {
+        u::prepare_path::prepare_path_util(ctx)
+    }
+
+    pub fn prepare_query(&self, ctx: &Rc<Context>) -> Value {
+        u::prepare_query::prepare_query_util(ctx)
+    }
+
+    pub fn result_basic(&self, ctx: &Rc<Context>) -> Option<Rc<RefCell<SdkResult>>> {
+        u::result_basic::result_basic_util(ctx)
+    }
+
+    pub fn result_body(&self, ctx: &Rc<Context>) -> Option<Rc<RefCell<SdkResult>>> {
+        u::result_body::result_body_util(ctx)
+    }
+
+    pub fn result_headers(&self, ctx: &Rc<Context>) -> Option<Rc<RefCell<SdkResult>>> {
+        u::result_headers::result_headers_util(ctx)
+    }
+
+    pub fn transform_request(&self, ctx: &Rc<Context>) -> Value {
+        u::transform_request::transform_request_util(ctx)
+    }
+
+    pub fn transform_response(&self, ctx: &Rc<Context>) -> Value {
+        u::transform_response::transform_response_util(ctx)
+    }
+}