@voxgig/sdkgen 4.34.0 → 4.34.1

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
+}

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

@@ -2,6 +2,7 @@ use std::rc::Rc;
 
 use crate::core::context::Context;
 use crate::core::helpers::{getp, setp};
+use crate::utility::param::call_args;
 use crate::utility::voxgigstruct::Value;
 
 pub fn prepare_query_util(ctx: &Rc<Context>) -> Value {
@@ -45,14 +46,28 @@ pub fn prepare_query_util(ctx: &Rc<Context>) -> Value {
         false
     };
 
-    // A header parameter travels in the headers, which prepare_headers fills.
+    // A header or cookie parameter travels in the headers, which prepare_headers
+    // fills, unless a query parameter shares its name: then both are sent.
     let aheader = getp(&getp(&point, "args"), "header");
+    let acookie = getp(&getp(&point, "args"), "cookie");
+    let declared = getp(&getp(&point, "args"), "query");
     let in_header = |key: &str| -> bool {
-        if let Value::List(hl) = &aheader {
-            for hd in hl.borrow().iter() {
-                if let Value::Str(s) = getp(hd, "name") {
+        if let Value::List(ql) = &declared {
+            for qd in ql.borrow().iter() {
+                if let Value::Str(s) = getp(qd, "name") {
                     if s == key {
-                        return true;
+                        return false;
+                    }
+                }
+            }
+        }
+        for located in [&aheader, &acookie] {
+            if let Value::List(hl) = located {
+                for hd in hl.borrow().iter() {
+                    if let Value::Str(s) = getp(hd, "name") {
+                        if s == key {
+                            return true;
+                        }
                     }
                 }
             }
@@ -92,5 +107,12 @@ pub fn prepare_query_util(ctx: &Rc<Context>) -> Value {
         }
     }
 
+    // A create or update passes its query arguments in its data.
+    for (name, wire, val) in call_args(ctx, "query") {
+        if !val.is_noval() && !val.is_null() && !contains(&name) && !in_args(&name) && !in_header(&name) {
+            setp(&out, &wire, val);
+        }
+    }
+
     out
 }

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

@@ -3,6 +3,7 @@ use std::rc::Rc;
 
 use crate::core::context::Context;
 use crate::core::helpers::call_json;
+use crate::core::response::unreadable_body;
 use crate::core::result::SdkResult;
 use crate::utility::voxgigstruct::Value;
 
@@ -12,13 +13,25 @@ pub fn result_body_util(ctx: &Rc<Context>) -> Option<Rc<RefCell<SdkResult>>> {
 
     if let Some(result) = &result {
         if let Some(response) = &response {
-            let (json, body) = {
+            let (json, body, unreadable) = {
                 let r = response.borrow();
-                (r.json.clone(), r.body.clone())
+                (r.json.clone(), r.body.clone(), r.unreadable)
             };
             if matches!(json, Value::Func(_)) && !body.is_noval() && !body.is_null() {
                 result.borrow_mut().body = call_json(&json);
             }
+            if unreadable {
+                let sent = match ctx.spec.borrow().clone() {
+                    Some(spec) => spec.borrow().headers.clone(),
+                    None => Value::Noval,
+                };
+                let (status, headers, failed) = {
+                    let r = result.borrow();
+                    (r.status, r.headers.clone(), r.err.clone())
+                };
+                result.borrow_mut().err =
+                    Some(unreadable_body(ctx, status, &headers, &body, &sent, failed));
+            }
         }
     }
 

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

@@ -2,6 +2,7 @@ use std::rc::Rc;
 
 use crate::core::context::Context;
 use crate::core::helpers::{getp, jo, setp, to_map};
+use crate::utility::param::call_args;
 use crate::utility::voxgigstruct as vs;
 use crate::utility::voxgigstruct::Value;
 
@@ -11,20 +12,32 @@ fn strip_action(reqdata: Value) -> Value {
     omit_keys(reqdata, &["$action".to_string()])
 }
 
-// A header argument travels as a header, which prepare_headers_util sends, so
-// the body is built from the request data without it.
-fn header_arg_names(point: &Value) -> Vec<String> {
-    match getp(&getp(point, "args"), "header") {
-        Value::List(hl) => hl
-            .borrow()
-            .iter()
-            .filter_map(|hd| match getp(hd, "name") {
-                Value::Str(n) if !n.is_empty() => Some(n),
-                _ => None,
-            })
-            .collect(),
-        _ => Vec::new(),
+// A header, cookie or query argument travels where prepare_headers_util or
+// prepare_query_util sends it, so the body is built from the request data
+// without it, unless the entity declares it as a field too.
+fn routed_arg_names(ctx: &Rc<Context>) -> Vec<String> {
+    let mut names = Vec::new();
+    for kind in ["header", "cookie", "query"] {
+        for (name, _, _) in call_args(ctx, kind) {
+            if !field_arg(ctx, &name) {
+                names.push(name);
+            }
+        }
     }
+    names
+}
+
+fn field_arg(ctx: &Rc<Context>, name: &str) -> bool {
+    let point = ctx.point.borrow().clone();
+    ["header", "cookie", "query"].iter().any(|kind| {
+        match getp(&getp(&point, "args"), kind) {
+            Value::List(al) => al.borrow().iter().any(|ad| {
+                matches!(getp(ad, "name"), Value::Str(ref n) if n == name)
+                    && matches!(getp(ad, "field"), Value::Bool(true))
+            }),
+            _ => false,
+        }
+    })
 }
 
 fn omit_keys(reqdata: Value, names: &[String]) -> Value {
@@ -59,7 +72,7 @@ pub fn transform_request_util(ctx: &Rc<Context>) -> Value {
         sp.borrow_mut().step = "reqform".to_string();
     }
 
-    let reqdata = omit_keys(ctx.reqdata.borrow().clone(), &header_arg_names(&point));
+    let reqdata = omit_keys(ctx.reqdata.borrow().clone(), &routed_arg_names(ctx));
 
     let transform = to_map(&getp(&point, "transform"));
     if transform.is_noval() {

package/project/.sdk/tm/scala/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/project/.sdk/tm/scala/Makefile

@@ -16,12 +16,14 @@ build:
 # Main classes are NAMED here rather than globbed, so a per-feature suite has
 # to be listed. SecretsTestMain drives the feature through the `extend` seam
 # and so runs in every scala SDK, model-activated or not. SdkCleanTestMain is
-# the canary sweep: no credential leaves the SDK in any form.
+# the canary sweep: no credential leaves the SDK in any form. SdkServerTestMain
+# checks how a templated base URL takes its server variables.
 test:
 	scala-cli run . --main-class OmniSmoke
 	scala-cli run . --main-class SdkTestMain
 	scala-cli run . --main-class SdkEntityTestMain
 	scala-cli run . --main-class SdkCleanTestMain
+	scala-cli run . --main-class SdkServerTestMain
 	scala-cli run . --main-class SecretsTestMain
 	scala-cli run . --main-class Runner -- ../.sdk/test/test.json
 	scala-cli run . --main-class PrimaryCorpusMain -- ../.sdk/test/test.json

package/project/.sdk/tm/scala/core/Context.scala

@@ -133,7 +133,7 @@ class Context(ctxmap: JMap[String, Object], basectx: Context) {
     val opcfg = Struct.getpath(config, java.util.List.of("entity", entname, "op", opname))
 
     var input = "match"
-    if ("update" == opname || "create" == opname) input = "data"
+    if ("update" == opname || "create" == opname || "patch" == opname) input = "data"
 
     var points: JList[Object] = null
     opcfg match {

package/project/.sdk/tm/scala/core/Contracts.scala

@@ -18,6 +18,7 @@ trait SdkEntity extends Entity {
   def list(reqmatch: JMap[String, Object], ctrl: JMap[String, Object]): Object
   def create(reqdata: JMap[String, Object], ctrl: JMap[String, Object]): Object
   def update(reqdata: JMap[String, Object], ctrl: JMap[String, Object]): Object
+  def patch(reqdata: JMap[String, Object], ctrl: JMap[String, Object]): Object
   def remove(reqmatch: JMap[String, Object], ctrl: JMap[String, Object]): Object
   // Runs `action` through the pipeline and returns an Iterator over result
   // items (the streaming feature's incremental output when active, else the