@voxgig/sdkgen 4.34.0 → 4.34.2

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

@@ -2,8 +2,10 @@ use std::rc::Rc;
 
 use crate::core::context::Context;
 use crate::core::error::ProjectNameError;
-use crate::core::helpers::{getp, getpath, to_map};
+use crate::core::helpers::{allowed, getp, getpath, to_map};
 use crate::core::types::OutVal;
+use crate::utility::make_url::placeholders;
+use crate::utility::param::param_value;
 use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
@@ -28,6 +30,46 @@ fn terminal_param(point: &Value) -> bool {
     }
 }
 
+fn own_point(points: &[Value]) -> Value {
+    let mut best = points[0].clone();
+    for cand in points {
+        let cand_term = terminal_param(cand);
+        let best_term = terminal_param(&best);
+        if cand_term != best_term {
+            if cand_term {
+                best = cand.clone();
+            }
+        } else if parts_len(cand) < parts_len(&best) {
+            best = cand.clone();
+        }
+    }
+    best
+}
+
+// The path parameters of a point that neither the call nor the entity gives a
+// value for, looked up as prepare_params_util looks them up.
+fn unfilled(ctx: &Rc<Context>, point: &Value) -> Vec<String> {
+    let mut missing = Vec::new();
+    if let Value::List(pl) = getp(point, "parts") {
+        for part in pl.borrow().iter() {
+            let text = match part {
+                Value::Str(s) => s,
+                _ => continue,
+            };
+            let found = placeholders(text);
+            if 1 != found.len() || found[0] != *text {
+                continue;
+            }
+            let name = &text[1..text.len() - 1];
+            let val = param_value(ctx, point, name);
+            if val.is_noval() || val.is_null() {
+                missing.push(name.to_string());
+            }
+        }
+    }
+    missing
+}
+
 pub fn make_point_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
     match ctx.out_get("point") {
         // A PrePoint feature hook (e.g. rbac) may short-circuit the
@@ -46,11 +88,12 @@ pub fn make_point_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
     let op = ctx.op.borrow().clone();
     let options = ctx.options.borrow().clone();
 
-    let allow_op = match getpath(&["allow", "op"], &options) {
-        Value::Str(s) => s,
+    let allow_op_val = getpath(&["allow", "op"], &options);
+    let allow_op = match &allow_op_val {
+        Value::Str(s) => s.clone(),
         _ => String::new(),
     };
-    if !allow_op.contains(&op.name) {
+    if !allowed(&allow_op_val, &op.name) {
         return Err(ctx.make_error(
             "point_op_allow",
             &format!(
@@ -133,19 +176,40 @@ pub fn make_point_util(ctx: &Rc<Context>) -> Result<Value, ProjectNameError> {
                 ));
             }
 
-            point = vs::get_elem(&points, &Value::Num(0.0), Value::Noval);
-            for i in 0..plen {
-                let cand = vs::get_elem(&points, &Value::Num(i as f64), Value::Noval);
-                let cand_term = terminal_param(&cand);
-                let best_term = terminal_param(&point);
-                if cand_term != best_term {
-                    if cand_term {
-                        point = cand;
-                    }
-                } else if parts_len(&cand) < parts_len(&point) {
-                    point = cand;
-                }
+            // A call without an action falls back to a point without one, as
+            // generation does, and only to a route the call can fill.
+            let all: Vec<Value> = (0..plen)
+                .map(|i| vs::get_elem(&points, &Value::Num(i as f64), Value::Noval))
+                .collect();
+            let plain: Vec<Value> = all
+                .iter()
+                .filter(|cand| getp(&to_map(&getp(cand, "select")), "$action").is_noval())
+                .cloned()
+                .collect();
+            if plain.is_empty() {
+                return Err(ctx.make_error(
+                    "point_action_required",
+                    &format!(
+                        "Operation \"{}\" has only action endpoints; pass $action to choose one.",
+                        op.name
+                    ),
+                ));
+            }
+            let fillable: Vec<Value> =
+                plain.iter().filter(|cand| unfilled(ctx, cand).is_empty()).cloned().collect();
+
+            if fillable.is_empty() {
+                return Err(ctx.make_error(
+                    "point_no_match",
+                    &format!(
+                        "Operation \"{}\" has no endpoint whose path parameters are all given (missing: {}).",
+                        op.name,
+                        unfilled(ctx, &own_point(&plain)).join(", ")
+                    ),
+                ));
             }
+
+            point = own_point(&fillable);
         }
 
         let req_action = getp(&reqselector, "$action");

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

@@ -3,7 +3,7 @@ use std::rc::Rc;
 
 use crate::core::context::Context;
 use crate::core::error::ProjectNameError;
-use crate::core::helpers::{getp, getpath, setp};
+use crate::core::helpers::{allowed, getp, getpath, setp};
 use crate::core::spec::Spec;
 use crate::core::types::OutVal;
 use crate::utility::voxgigstruct::Value;
@@ -37,11 +37,12 @@ pub fn make_spec_util(ctx: &Rc<Context>) -> Result<Rc<RefCell<Spec>>, ProjectNam
     let method = crate::utility::prepare_method::prepare_method_util(ctx);
     spec.borrow_mut().method = method.clone();
 
-    let allow_method = match getpath(&["allow", "method"], &options) {
-        Value::Str(s) => s,
+    let allow_method_val = getpath(&["allow", "method"], &options);
+    let allow_method = match &allow_method_val {
+        Value::Str(s) => s.clone(),
         _ => String::new(),
     };
-    if !allow_method.contains(&method) {
+    if !allowed(&allow_method_val, &method) {
         return Err(ctx.make_error(
             "spec_method_allow",
             &format!(
@@ -94,8 +95,26 @@ pub fn make_spec_util(ctx: &Rc<Context>) -> Result<Rc<RefCell<Spec>>, ProjectNam
         }
     }
 
+    // Whatever prepare_auth sets in the query, under whichever name, is the
+    // credential; a key it leaves as it was is the caller's.
+    let query: Vec<(String, Value)> = match &spec.borrow().query {
+        Value::Map(qm) => qm.borrow().iter().map(|(k, v)| (k.clone(), v.clone())).collect(),
+        _ => Vec::new(),
+    };
+
     let spec = crate::utility::prepare_auth::prepare_auth_util(ctx)?;
 
+    let authquery: Vec<String> = match &spec.borrow().query {
+        Value::Map(qm) => qm
+            .borrow()
+            .iter()
+            .filter(|(k, v)| !query.iter().any(|(qk, qv)| qk == *k && qv == *v))
+            .map(|(k, _)| k.clone())
+            .collect(),
+        _ => Vec::new(),
+    };
+    spec.borrow_mut().authquery = authquery;
+
     *ctx.spec.borrow_mut() = Some(spec.clone());
     Ok(spec)
 }

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

@@ -6,6 +6,28 @@ use crate::core::helpers::{getp, setp};
 use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
+// The {name} placeholders in a text, in order.
+pub(crate) fn placeholders(text: &str) -> Vec<String> {
+    let bytes = text.as_bytes();
+    let mut out = Vec::new();
+    let mut i = 0;
+    while i < bytes.len() {
+        if b'{' == bytes[i] {
+            let mut j = i + 1;
+            while j < bytes.len() && !b"{}/".contains(&bytes[j]) {
+                j += 1;
+            }
+            if j < bytes.len() && b'}' == bytes[j] && j > i + 1 {
+                out.push(text[i..=j].to_string());
+                i = j + 1;
+                continue;
+            }
+        }
+        i += 1;
+    }
+    out
+}
+
 pub fn make_url_util(ctx: &Rc<Context>) -> Result<String, ProjectNameError> {
     let spec = ctx.spec.borrow().clone().ok_or_else(|| {
         ctx.make_error("url_no_spec", "Expected context spec property to be defined.")
@@ -29,7 +51,7 @@ pub fn make_url_util(ctx: &Rc<Context>) -> Result<String, ProjectNameError> {
     let suffixless = suffix.is_empty();
     let mut url = vs::join(
         &Value::list(vec![
-            Value::str(base),
+            Value::str(base.clone()),
             Value::str(prefix),
             Value::str(path),
             Value::str(suffix),
@@ -48,6 +70,9 @@ pub fn make_url_util(ctx: &Rc<Context>) -> Result<String, ProjectNameError> {
 
     let resmatch = Value::empty_map();
 
+    // Sent with the request, never recorded as the entity's match.
+    let authquery = spec.borrow().authquery.clone();
+
     if let Value::Map(pm) = &params {
         let entries: Vec<(String, Value)> = pm
             .borrow()
@@ -64,6 +89,16 @@ pub fn make_url_util(ctx: &Rc<Context>) -> Result<String, ProjectNameError> {
         }
     }
 
+    // A placeholder left in the route would send the request to the wrong route.
+    // The base's own placeholders are server variables, resolved with the options.
+    let unfilled = placeholders(url.strip_prefix(base.trim_end_matches('/')).unwrap_or(url.as_str()));
+    if !unfilled.is_empty() {
+        return Err(ctx.make_error(
+            "url_param_missing",
+            &format!("URL path has no value for {}.", unfilled.join(", ")),
+        ));
+    }
+
     // Append query string from spec.query.
     let mut qsep = "?";
     if let Value::Map(qm) = &query {
@@ -81,7 +116,9 @@ pub fn make_url_util(ctx: &Rc<Context>) -> Result<String, ProjectNameError> {
                     vs::esc_url(&Value::str(vs::stringify(&val, None, false)))
                 ));
                 qsep = "&";
-                setp(&resmatch, &key, val);
+                if !authquery.contains(&key) {
+                    setp(&resmatch, &key, val);
+                }
             }
         }
     }

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

@@ -0,0 +1,116 @@
+// The media types a point declares: `response` (the model's `rs`) for the
+// Accept header, and `body` (the model's `rb`) for the request body.
+
+use crate::core::helpers::{getp, setp};
+use crate::utility::voxgigstruct::Value;
+
+// The data key holding a raw request body. Like `$action`, it can never be a
+// declared argument name.
+pub const RAW_BODY: &str = "$body";
+
+pub fn is_json_media(media: &str) -> bool {
+    let m = media.split(';').next().unwrap_or("").trim().to_lowercase();
+    m == "application/json" || m == "text/json" || m.ends_with("+json")
+}
+
+fn text_of(v: &Value) -> Option<String> {
+    match v {
+        Value::Str(s) if !s.is_empty() => Some(s.clone()),
+        _ => None,
+    }
+}
+
+// The declared JSON type alone, else every declared type in the model's
+// order; None when no success response declares a body.
+pub fn accept_of(point: &Value) -> Option<String> {
+    let res = getp(point, "response");
+    let media = text_of(&getp(&res, "media"))?;
+    if text_of(&getp(&res, "kind")).as_deref() == Some("json") {
+        return Some(media);
+    }
+    let mut types = vec![media];
+    if let Value::List(alts) = getp(&res, "alternatives") {
+        for alt in alts.borrow().iter() {
+            if let Some(m) = text_of(&getp(alt, "media")) {
+                types.push(m);
+            }
+        }
+    }
+    Some(types.join(", "))
+}
+
+pub fn is_raw_request(point: &Value) -> bool {
+    text_of(&getp(&getp(point, "body"), "kind")).as_deref() == Some("raw")
+}
+
+pub fn is_json_request(point: &Value) -> bool {
+    text_of(&getp(&getp(point, "body"), "kind")).as_deref() == Some("json")
+}
+
+fn has_header(headers: &Value, name: &str) -> bool {
+    match headers {
+        Value::Map(m) => m.borrow().keys().any(|k| k.to_lowercase() == name),
+        _ => false,
+    }
+}
+
+// A caller's accept wins. A declared request type replaces each JSON
+// content-type, the SDK default, and leaves any other the caller set.
+pub fn media_headers(point: &Value, headers: Value) -> Value {
+    if let Some(accept) = accept_of(point) {
+        if !has_header(&headers, "accept") {
+            setp(&headers, "accept", Value::Str(accept));
+        }
+    }
+
+    let body = getp(point, "body");
+    let kind = text_of(&getp(&body, "kind"));
+    if let (Some(kind), Some(media)) = (kind, text_of(&getp(&body, "media"))) {
+        if kind == "raw" || kind == "json" {
+            if let Value::Map(m) = &headers {
+                let json: Vec<String> = m
+                    .borrow()
+                    .iter()
+                    .filter(|(k, v)| {
+                        k.to_lowercase() == "content-type"
+                            && matches!(v, Value::Str(s) if is_json_media(s))
+                    })
+                    .map(|(k, _)| k.clone())
+                    .collect();
+                for k in json {
+                    m.borrow_mut().shift_remove(&k);
+                }
+            }
+            if !has_header(&headers, "content-type") {
+                setp(&headers, "content-type", Value::Str(media));
+            }
+        }
+    }
+
+    headers
+}
+
+pub fn raw_body(reqdata: &Value) -> Value {
+    getp(reqdata, RAW_BODY)
+}
+
+// A struct string must be UTF-8, so a binary body is a list of byte values.
+pub fn bytes_value(bytes: &[u8]) -> Value {
+    Value::list(bytes.iter().map(|b| Value::Num(*b as f64)).collect())
+}
+
+// The bytes a raw body sends: a string's UTF-8, or a list of byte values.
+pub fn body_bytes(body: &Value) -> Option<Vec<u8>> {
+    match body {
+        Value::Str(s) => Some(s.as_bytes().to_vec()),
+        Value::List(items) => items
+            .borrow()
+            .iter()
+            .map(|v| match v {
+                Value::Num(n) if (0.0..=255.0).contains(n) && 0.0 == n.fract() => Some(*n as u8),
+                _ => None,
+            })
+            .collect(),
+        _ => None,
+    }
+}

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

@@ -21,6 +21,7 @@ pub mod make_response;
 pub mod make_result;
 pub mod make_spec;
 pub mod make_url;
+pub mod media;
 pub mod param;
 pub mod prepare_auth;
 pub mod prepare_body;

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

@@ -8,10 +8,6 @@ use crate::utility::voxgigstruct::Value;
 pub fn param_util(ctx: &Rc<Context>, paramdef: &Value) -> Value {
     let point = ctx.point.borrow().clone();
     let spec = ctx.spec.borrow().clone();
-    let mtch = ctx.mtch.borrow().clone();
-    let reqmatch = ctx.reqmatch.borrow().clone();
-    let data = ctx.data.borrow().clone();
-    let reqdata = ctx.reqdata.borrow().clone();
 
     let pt = vs::typify(paramdef);
 
@@ -24,36 +20,57 @@ pub fn param_util(ctx: &Rc<Context>, paramdef: &Value) -> Value {
         get_str(paramdef, "name").unwrap_or_default()
     };
 
-    let mut akey = String::new();
-    if !point.is_noval() {
-        let alias = to_map(&getp(&point, "alias"));
-        if !alias.is_noval() {
-            if let Some(ak) = get_str(&alias, &key) {
-                akey = ak;
-            }
+    let akey = param_alias(&point, &key);
+    if !akey.is_empty()
+        && getp(&ctx.reqmatch.borrow().clone(), &key).is_noval()
+        && getp(&ctx.mtch.borrow().clone(), &key).is_noval()
+    {
+        if let Some(sp) = &spec {
+            let alias = sp.borrow().alias.clone();
+            crate::core::helpers::setp(&alias, &akey, Value::str(key.clone()));
         }
     }
 
-    let mut val = getp(&reqmatch, &key);
+    param_value(ctx, &point, &key)
+}
+
+// The name a point gives a parameter in the call, if it renames it.
+fn param_alias(point: &Value, key: &str) -> String {
+    if point.is_noval() {
+        return String::new();
+    }
+    let alias = to_map(&getp(point, "alias"));
+    if alias.is_noval() {
+        return String::new();
+    }
+    get_str(&alias, key).unwrap_or_default()
+}
+
+// The value the call or its entity gives a point's parameter, under its name
+// or the point's alias for it.
+pub fn param_value(ctx: &Rc<Context>, point: &Value, key: &str) -> Value {
+    let akey = param_alias(point, key);
+    let mtch = ctx.mtch.borrow().clone();
+    let reqmatch = ctx.reqmatch.borrow().clone();
+    let data = ctx.data.borrow().clone();
+    let reqdata = ctx.reqdata.borrow().clone();
+
+    let mut val = getp(&reqmatch, key);
 
     if val.is_noval() {
-        val = getp(&mtch, &key);
+        val = getp(&mtch, key);
     }
 
     if val.is_noval() && !akey.is_empty() {
-        if let Some(sp) = &spec {
-            let alias = sp.borrow().alias.clone();
-            crate::core::helpers::setp(&alias, &akey, Value::str(key.clone()));
-        }
         val = getp(&reqmatch, &akey);
     }
 
     if val.is_noval() {
-        val = getp(&reqdata, &key);
+        val = getp(&reqdata, key);
     }
 
     if val.is_noval() {
-        val = getp(&data, &key);
+        val = getp(&data, key);
     }
 
     if val.is_noval() && !akey.is_empty() {
@@ -65,3 +82,33 @@ pub fn param_util(ctx: &Rc<Context>, paramdef: &Value) -> Value {
 
     val
 }
+
+
+// The arguments a point declares in one location, query or header, each as
+// its name, the name it travels under, and the value this call passes in its
+// match or else its data. Unlike a path parameter, the entity's stored match
+// and data never supply one.
+pub fn call_args(ctx: &Rc<Context>, kind: &str) -> Vec<(String, String, Value)> {
+    let point = ctx.point.borrow().clone();
+    let mut out = Vec::new();
+    if let Value::List(al) = getp(&getp(&point, "args"), kind) {
+        let reqmatch = ctx.reqmatch.borrow().clone();
+        let reqdata = ctx.reqdata.borrow().clone();
+        for ad in al.borrow().iter() {
+            let name = match getp(ad, "name") {
+                Value::Str(n) if !n.is_empty() => n,
+                _ => continue,
+            };
+            let wire = match getp(ad, "orig") {
+                Value::Str(o) if !o.is_empty() => o,
+                _ => name.clone(),
+            };
+            let mut val = getp(&reqmatch, &name);
+            if val.is_noval() || val.is_null() {
+                val = getp(&reqdata, &name);
+            }
+            out.push((name, wire, val));
+        }
+    }
+    out
+}

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

@@ -1,12 +1,16 @@
 use std::rc::Rc;
 
 use crate::core::context::Context;
+use crate::utility::media::{is_raw_request, raw_body};
 use crate::utility::voxgigstruct::Value;
 
 pub fn prepare_body_util(ctx: &Rc<Context>) -> Value {
     let op = ctx.op.borrow().clone();
 
     if op.input == "data" {
+        if is_raw_request(&ctx.point.borrow()) {
+            return raw_body(&ctx.reqdata.borrow());
+        }
         return crate::utility::transform_request::transform_request_util(ctx);
     }
 

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

@@ -2,6 +2,8 @@ use std::rc::Rc;
 
 use crate::core::context::Context;
 use crate::core::helpers::{getp, setp};
+use crate::utility::media::media_headers;
+use crate::utility::param::call_args;
 use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
@@ -20,40 +22,95 @@ pub fn prepare_headers_util(ctx: &Rc<Context>) -> Value {
             _ => Value::empty_map(),
         }
     };
+    let out = media_headers(&ctx.point.borrow(), out);
 
-    // A header parameter travels as a header, under the name the definition
-    // gives it, and only from this call's own arguments. It replaces a default
-    // of the same name, whatever its case.
-    let point = ctx.point.borrow().clone();
-    if let Value::List(hl) = getp(&getp(&point, "args"), "header") {
-        let reqmatch = ctx.reqmatch.borrow().clone();
-        let reqdata = ctx.reqdata.borrow().clone();
-        for hd in hl.borrow().iter() {
-            let name = match getp(hd, "name") {
-                Value::Str(n) if !n.is_empty() => n,
-                _ => continue,
-            };
-            let wire = match getp(hd, "orig") {
-                Value::Str(o) if !o.is_empty() => o,
-                _ => name.clone(),
-            };
-            let mut val = getp(&reqmatch, &name);
-            if val.is_noval() || val.is_null() {
-                val = getp(&reqdata, &name);
+    // A header argument replaces a default of the same name, whatever its case.
+    for (_, wire, val) in call_args(ctx, "header") {
+        if !val.is_noval() && !val.is_null() {
+            let key = wire.to_lowercase();
+            if let Value::Map(m) = &out {
+                let same: Vec<String> =
+                    m.borrow().keys().filter(|k| k.to_lowercase() == key).cloned().collect();
+                for k in same {
+                    m.borrow_mut().shift_remove(&k);
+                }
             }
-            if !val.is_noval() && !val.is_null() {
-                let key = wire.to_lowercase();
-                if let Value::Map(m) = &out {
-                    let same: Vec<String> =
-                        m.borrow().keys().filter(|k| k.to_lowercase() == key).cloned().collect();
-                    for k in same {
-                        m.borrow_mut().shift_remove(&k);
-                    }
+            setp(&out, &key, Value::Str(vs::stringify(&val, None, false)));
+        }
+    }
+
+    // A cookie argument travels in the cookie header, form serialized and
+    // percent-encoded, replacing a cookie of the same name among those the
+    // caller's headers already send.
+    let sent: Vec<(String, String, Value)> = call_args(ctx, "cookie")
+        .into_iter()
+        .filter(|(_, _, val)| !val.is_noval() && !val.is_null())
+        .collect();
+    if !sent.is_empty() {
+        let names: Vec<String> = sent
+            .iter()
+            .flat_map(|(_, wire, val)| match val {
+                Value::Map(_) => vs::keysof_vec(val)
+                    .iter()
+                    .map(|k| vs::esc_url(&Value::Str(k.clone())))
+                    .collect::<Vec<String>>(),
+                _ => vec![wire.clone()],
+            })
+            .collect();
+        let mut kept: Vec<String> = Vec::new();
+        if let Value::Map(m) = &out {
+            let given: Vec<String> =
+                m.borrow().keys().filter(|k| k.to_lowercase() == "cookie").cloned().collect();
+            for k in given {
+                if let Some(Value::Str(s)) = m.borrow_mut().shift_remove(&k) {
+                    kept.extend(cookie_keep(&s, &names));
                 }
-                setp(&out, &key, Value::Str(vs::stringify(&val, None, false)));
             }
         }
+        for (_, wire, val) in &sent {
+            let pair = cookie_pair(wire, val);
+            if !pair.is_empty() {
+                kept.push(pair);
+            }
+        }
+        if !kept.is_empty() {
+            setp(&out, "cookie", Value::Str(kept.join("; ")));
+        }
     }
 
     out
 }
+
+// The form style of a cookie parameter: a list repeats the name, a map sends
+// its own keys, and every value is percent-encoded.
+fn cookie_pair(wire: &str, val: &Value) -> String {
+    let esc = |v: &Value| vs::esc_url(&Value::Str(vs::stringify(v, None, false)));
+    let pairs: Vec<String> = match val {
+        Value::List(items) => {
+            items.borrow().iter().map(|item| format!("{}={}", wire, esc(item))).collect()
+        }
+        Value::Map(m) => vs::keysof_vec(val)
+            .iter()
+            .map(|k| {
+                let v = m.borrow().get(k).cloned().unwrap_or(Value::Null);
+                format!("{}={}", vs::esc_url(&Value::Str(k.clone())), esc(&v))
+            })
+            .collect(),
+        _ => vec![format!("{}={}", wire, esc(val))],
+    };
+    pairs.join("; ")
+}
+
+// The caller's cookie pieces with the named cookies removed: a cookie is one
+// ;-delimited piece, whatever its value holds.
+pub fn cookie_keep(header: &str, names: &[String]) -> Vec<String> {
+    let mut kept: Vec<String> = Vec::new();
+    for piece in header.split(';') {
+        let cookie = piece.trim();
+        let name = cookie.split('=').next().unwrap_or("").trim();
+        if !cookie.is_empty() && !names.iter().any(|n| n == name) {
+            kept.push(cookie.to_string());
+        }
+    }
+    kept
+}