@voxgig/sdkgen 4.34.0 → 4.34.1

package/project/.sdk/tm/c/utility/prepare_headers.c

@@ -3,6 +3,7 @@
 #include "sdk.h"
 
 #include <ctype.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -13,6 +14,142 @@ static bool same_name(const char* a, const char* b) {
   return *a == *b;
 }
 
+// Appends a part to a joined string, growing it.
+static void join_part(char** text, size_t* len, const char* sep, const char* part) {
+  size_t plen = strlen(part);
+  size_t slen = 0 < *len ? strlen(sep) : 0;
+  char* grown = (char*)realloc(*text, *len + slen + plen + 1);
+  if (slen) memcpy(grown + *len, sep, slen);
+  memcpy(grown + *len + slen, part, plen);
+  *len += slen + plen;
+  grown[*len] = '\0';
+  *text = grown;
+}
+
+// Strips the blanks around a cookie piece, in place.
+static char* trim_blank(char* s) {
+  while (isspace((unsigned char)*s)) s++;
+  size_t n = strlen(s);
+  while (0 < n && isspace((unsigned char)s[n - 1])) s[--n] = '\0';
+  return s;
+}
+
+static bool same_text(const char* name, const char* text, size_t len) {
+  return strlen(name) == len && 0 == strncmp(name, text, len);
+}
+
+// Whether a cookie the caller sends has a name a cookie argument sends: a
+// map's own keys as the pair sends them, percent-encoded, else the
+// argument's wire name.
+static bool sent_named(const char* name, size_t nlen, void* ud) {
+  voxgig_list* cargs = (voxgig_list*)ud;
+  for (size_t i = 0; i < cargs->len; i++) {
+    voxgig_list* arg = voxgig_as_list(cargs->items[i]);
+    voxgig_value* val = arg->items[2];
+    if (v_is_noval(val) || v_is_null(val)) continue;
+    if (voxgig_is_map(val)) {
+      voxgig_strvec keys = voxgig_keysof(val);
+      bool found = false;
+      for (size_t k = 0; k < keys.len && !found; k++) {
+        voxgig_value* kv = voxgig_new_string(keys.data[k]);
+        char* key = voxgig_escurl(kv);
+        found = same_text(key, name, nlen);
+        free(key);
+        voxgig_release(kv);
+      }
+      voxgig_strvec_free(&keys);
+      if (found) return true;
+    } else if (same_text(voxgig_as_string(arg->items[1]), name, nlen)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// A value's text, percent-encoded, as a new string.
+static char* esc_text(voxgig_value* val) {
+  char* text = voxgig_stringify(val, -1);
+  voxgig_value* sv = voxgig_new_string(text);
+  char* out = voxgig_escurl(sv);
+  voxgig_release(sv);
+  free(text);
+  return out;
+}
+
+static char* name_value(const char* name, const char* value) {
+  size_t len = strlen(name) + 1 + strlen(value);
+  char* pair = (char*)malloc(len + 1);
+  snprintf(pair, len + 1, "%s=%s", name, value);
+  return pair;
+}
+
+// Whether a cookie's name, blanks aside, is one the predicate owns.
+static bool cookie_named(const char* cookie, bool (*named)(const char* name, size_t nlen, void* ud), void* ud) {
+  size_t nlen = strcspn(cookie, "=");
+  while (0 < nlen && isspace((unsigned char)cookie[nlen - 1])) nlen--;
+  return named(cookie, nlen, ud);
+}
+
+// The caller's cookie pieces with the owned cookies removed, "; "-joined and
+// malloc'd, or NULL when none is kept: a cookie is one ;-delimited piece,
+// whatever its value holds.
+char* cookie_keep(const char* header, bool (*named)(const char* name, size_t nlen, void* ud), void* ud) {
+  char* joined = NULL;
+  size_t jlen = 0;
+  const char* text = header;
+  while ('\0' != *text) {
+    size_t plen = strcspn(text, ";");
+    char* piece = (char*)malloc(plen + 1);
+    memcpy(piece, text, plen);
+    piece[plen] = '\0';
+    char* cookie = trim_blank(piece);
+    if ('\0' != *cookie && !cookie_named(cookie, named, ud)) join_part(&joined, &jlen, "; ", cookie);
+    free(piece);
+    text += plen + (';' == text[plen] ? 1 : 0);
+  }
+  return joined;
+}
+
+// The form style of a cookie parameter: a list repeats the name, a map sends
+// its own keys, and every value is percent-encoded.
+static char* cookie_pair(const char* wire, voxgig_value* val) {
+  char* joined = NULL;
+  size_t jlen = 0;
+  if (voxgig_is_list(val)) {
+    voxgig_list* items = voxgig_as_list(val);
+    for (size_t i = 0; i < items->len; i++) {
+      char* text = esc_text(items->items[i]);
+      char* pair = name_value(wire, text);
+      join_part(&joined, &jlen, "; ", pair);
+      free(pair);
+      free(text);
+    }
+  } else if (voxgig_is_map(val)) {
+    voxgig_strvec keys = voxgig_keysof(val);
+    for (size_t i = 0; i < keys.len; i++) {
+      voxgig_value* kv = voxgig_new_string(keys.data[i]);
+      char* name = voxgig_escurl(kv);
+      voxgig_release(kv);
+      char* text = esc_text(getp(val, keys.data[i]));
+      char* pair = name_value(name, text);
+      join_part(&joined, &jlen, "; ", pair);
+      free(pair);
+      free(text);
+      free(name);
+    }
+    voxgig_strvec_free(&keys);
+  } else {
+    char* text = esc_text(val);
+    joined = name_value(wire, text);
+    free(text);
+  }
+  if (NULL == joined) {
+    joined = (char*)malloc(1);
+    joined[0] = '\0';
+  }
+  return joined;
+}
+
 voxgig_value* prepare_headers_util(Context* ctx) {
   voxgig_value* options = ctx->client ? sdk_options_map(ctx->client) : ctx->options;
 
@@ -23,41 +160,74 @@ voxgig_value* prepare_headers_util(Context* ctx) {
     if (voxgig_is_map(cloned)) out = cloned;
   }
   if (NULL == out) out = voxgig_new_map();
+  media_headers(ctx->point, 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.
-  voxgig_value* aheader = getpath2(ctx->point, "args", "header");
-  if (voxgig_is_list(aheader)) {
-    voxgig_list* hl = voxgig_as_list(aheader);
-    for (size_t i = 0; i < hl->len; i++) {
-      voxgig_value* name = getp(hl->items[i], "name");
-      if (!voxgig_is_string(name) || voxgig_as_string(name)[0] == '\0') continue;
-      voxgig_value* orig = getp(hl->items[i], "orig");
-      const char* wire = voxgig_is_string(orig) && voxgig_as_string(orig)[0] != '\0'
-        ? voxgig_as_string(orig) : voxgig_as_string(name);
-
-      voxgig_value* val = getp(ctx->reqmatch, voxgig_as_string(name));
-      if (v_is_noval(val) || v_is_null(val)) val = getp(ctx->reqdata, voxgig_as_string(name));
-      if (v_is_noval(val) || v_is_null(val)) continue;
+  // A header argument replaces a default of the same name, whatever its case.
+  voxgig_value* hargs = call_args(ctx, "header");
+  voxgig_list* hl = voxgig_as_list(hargs);
+  for (size_t i = 0; i < hl->len; i++) {
+    voxgig_list* arg = voxgig_as_list(hl->items[i]);
+    const char* wire = voxgig_as_string(arg->items[1]);
+    voxgig_value* val = arg->items[2];
+    if (v_is_noval(val) || v_is_null(val)) continue;
+
+    size_t n = strlen(wire);
+    char* key = (char*)malloc(n + 1);
+    for (size_t k = 0; k < n; k++) key[k] = (char)tolower((unsigned char)wire[k]);
+    key[n] = '\0';
+    voxgig_map* om = voxgig_as_map(out);
+    for (size_t j = om->len; j > 0; j--) {
+      if (same_name(om->entries[j - 1].key, key)) {
+        voxgig_value* dk = voxgig_new_string(om->entries[j - 1].key);
+        voxgig_delprop(out, dk);
+        voxgig_release(dk);
+      }
+    }
+    char* text = voxgig_stringify(val, -1);
+    setp(out, key, voxgig_new_string_take(text, strlen(text)));
+    free(key);
+  }
+  voxgig_release(hargs);
 
-      size_t n = strlen(wire);
-      char* key = (char*)malloc(n + 1);
-      for (size_t k = 0; k < n; k++) key[k] = (char)tolower((unsigned char)wire[k]);
-      key[n] = '\0';
-      voxgig_map* om = voxgig_as_map(out);
-      for (size_t j = om->len; j > 0; j--) {
-        if (same_name(om->entries[j - 1].key, key)) {
-          voxgig_value* dk = voxgig_new_string(om->entries[j - 1].key);
-          voxgig_delprop(out, dk);
-          voxgig_release(dk);
+  // 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.
+  voxgig_value* cargs = call_args(ctx, "cookie");
+  voxgig_list* cl = voxgig_as_list(cargs);
+  bool any = false;
+  for (size_t i = 0; i < cl->len; i++) {
+    voxgig_value* val = voxgig_as_list(cl->items[i])->items[2];
+    if (!v_is_noval(val) && !v_is_null(val)) any = true;
+  }
+  if (any) {
+    char* joined = NULL;
+    size_t jlen = 0;
+    voxgig_map* om = voxgig_as_map(out);
+    for (size_t j = om->len; j > 0; j--) {
+      if (!same_name(om->entries[j - 1].key, "cookie")) continue;
+      voxgig_value* given = om->entries[j - 1].value;
+      if (voxgig_is_string(given)) {
+        char* rest = cookie_keep(voxgig_as_string(given), sent_named, cl);
+        if (NULL != rest) {
+          join_part(&joined, &jlen, "; ", rest);
+          free(rest);
         }
       }
-      char* text = voxgig_stringify(val, -1);
-      setp(out, key, voxgig_new_string_take(text, strlen(text)));
-      free(key);
+      voxgig_value* dk = voxgig_new_string(om->entries[j - 1].key);
+      voxgig_delprop(out, dk);
+      voxgig_release(dk);
+    }
+    for (size_t i = 0; i < cl->len; i++) {
+      voxgig_list* arg = voxgig_as_list(cl->items[i]);
+      voxgig_value* val = arg->items[2];
+      if (v_is_noval(val) || v_is_null(val)) continue;
+      char* pair = cookie_pair(voxgig_as_string(arg->items[1]), val);
+      if ('\0' != *pair) join_part(&joined, &jlen, "; ", pair);
+      free(pair);
     }
+    if (NULL != joined) setp(out, "cookie", voxgig_new_string_take(joined, jlen));
   }
+  voxgig_release(cargs);
 
   return out;
 }

package/project/.sdk/tm/c/utility/prepare_query.c

@@ -28,6 +28,14 @@ static bool args_params_contains(voxgig_value* aparams, const char* key) {
   return false;
 }
 
+// A header or cookie parameter travels in the headers, which prepare_headers
+// fills, unless a query parameter shares its name: then both are sent.
+static bool routed_elsewhere(voxgig_value* aheader, voxgig_value* acookie, voxgig_value* aquery,
+                             const char* key) {
+  return (args_params_contains(aheader, key) || args_params_contains(acookie, key)) &&
+         !args_params_contains(aquery, key);
+}
+
 // A query parameter travels under the name the definition gives it, its orig,
 // which the model may have renamed for the caller.
 static const char* query_wire_name(voxgig_value* aquery, const char* key) {
@@ -52,8 +60,8 @@ voxgig_value* prepare_query_util(Context* ctx) {
   voxgig_value* params = getp(point, "params");
   if (!voxgig_is_list(params)) params = voxgig_new_list();
   voxgig_value* aparams = getpath2(point, "args", "params");
-  // A header parameter travels in the headers, which prepare_headers fills.
   voxgig_value* aheader = getpath2(point, "args", "header");
+  voxgig_value* acookie = getpath2(point, "args", "cookie");
   voxgig_value* aquery = getpath2(point, "args", "query");
 
   voxgig_value* out = voxgig_new_map();
@@ -64,10 +72,24 @@ voxgig_value* prepare_query_util(Context* ctx) {
       voxgig_value* val = rm->entries[i].value;
       if (!v_is_noval(val) && !v_is_null(val) && strcmp(key, "$action") != 0 &&
           !params_contains(params, key) && !args_params_contains(aparams, key) &&
-          !args_params_contains(aheader, key)) {
+          !routed_elsewhere(aheader, acookie, aquery, key)) {
         setp(out, query_wire_name(aquery, key), v_share(val));
       }
     }
   }
+
+  // A create or update passes its query arguments in its data.
+  voxgig_value* qargs = call_args(ctx, "query");
+  voxgig_list* ql = voxgig_as_list(qargs);
+  for (size_t i = 0; i < ql->len; i++) {
+    voxgig_list* arg = voxgig_as_list(ql->items[i]);
+    const char* name = voxgig_as_string(arg->items[0]);
+    voxgig_value* val = arg->items[2];
+    if (!v_is_noval(val) && !v_is_null(val) && !params_contains(params, name) &&
+        !args_params_contains(aparams, name) && !routed_elsewhere(aheader, acookie, aquery, name)) {
+      setp(out, voxgig_as_string(arg->items[1]), v_share(val));
+    }
+  }
+  voxgig_release(qargs);
   return out;
 }

package/project/.sdk/tm/c/utility/result_body.c

@@ -12,6 +12,10 @@ SdkResult* result_body_util(Context* ctx) {
     if (voxgig_is_func(json) && !v_is_noval(body) && !v_is_null(body)) {
       result->body = call_json(json);
     }
+    if (response->unreadable) {
+      voxgig_value* sent = ctx->spec ? ctx->spec->headers : NULL;
+      result->err = unreadable_body(ctx, result->status, result->headers, body, sent, result->err);
+    }
   }
   return result;
 }

package/project/.sdk/tm/c/utility/transform_request.c

@@ -4,37 +4,72 @@
 
 #include <string.h>
 
-/* A header argument travels as a header, which prepare_headers_util sends,
-   so the body is built from the request data without it. */
-static bool header_arg(voxgig_value* point, const char* key) {
-  voxgig_value* aheader = getpath2(point, "args", "header");
-  if (!voxgig_is_list(aheader)) return false;
-  voxgig_list* hl = voxgig_as_list(aheader);
-  for (size_t i = 0; i < hl->len; i++) {
-    voxgig_value* name = getp(hl->items[i], "name");
-    if (voxgig_is_string(name) && strcmp(voxgig_as_string(name), key) == 0) return true;
+static const char* ROUTED_KINDS[] = { "header", "cookie", "query" };
+
+static bool field_arg(Context* ctx, const char* name) {
+  bool found = false;
+  for (size_t k = 0; k < 3 && !found; k++) {
+    voxgig_value* defs = getpath2(ctx->point, "args", ROUTED_KINDS[k]);
+    if (voxgig_is_list(defs)) {
+      voxgig_list* dl = voxgig_as_list(defs);
+      for (size_t i = 0; i < dl->len && !found; i++) {
+        voxgig_value* n = getp(dl->items[i], "name");
+        voxgig_value* f = getp(dl->items[i], "field");
+        found = v_str_eq(n, name) && voxgig_is_bool(f) && voxgig_as_bool(f);
+        voxgig_release(n);
+        voxgig_release(f);
+      }
+    }
+    voxgig_release(defs);
+  }
+  return found;
+}
+
+/* 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. */
+static voxgig_value* routed_args(Context* ctx) {
+  voxgig_value* routed = voxgig_new_list();
+  for (size_t k = 0; k < 3; k++) {
+    voxgig_value* more = call_args(ctx, ROUTED_KINDS[k]);
+    voxgig_list* ml = voxgig_as_list(more);
+    for (size_t i = 0; i < ml->len; i++) {
+      voxgig_list* arg = voxgig_as_list(ml->items[i]);
+      if (field_arg(ctx, voxgig_as_string(arg->items[0]))) continue;
+      voxgig_list_push(voxgig_as_list(routed), v_share(ml->items[i]));
+    }
+    voxgig_release(more);
+  }
+  return routed;
+}
+
+static bool routed_arg(voxgig_value* routed, const char* key) {
+  voxgig_list* rl = voxgig_as_list(routed);
+  for (size_t i = 0; i < rl->len; i++) {
+    voxgig_list* arg = voxgig_as_list(rl->items[i]);
+    if (strcmp(voxgig_as_string(arg->items[0]), key) == 0) return true;
   }
   return false;
 }
 
 /* `$action` selects the point (see make_point_util); it is never an API
-   field, so the body is a copy without it, or, given a point, without its
-   header arguments. The caller's map is left untouched. */
-static bool dropped(const char* key, voxgig_value* point) {
-  return NULL == point ? strcmp(key, "$action") == 0 : header_arg(point, key);
+   field, so the body is a copy without it, or, given the routed arguments,
+   without those. The caller's map is left untouched. */
+static bool dropped(const char* key, voxgig_value* routed) {
+  return NULL == routed ? strcmp(key, "$action") == 0 : routed_arg(routed, key);
 }
 
-static voxgig_value* omit_keys(voxgig_value* reqdata, voxgig_value* point) {
+static voxgig_value* omit_keys(voxgig_value* reqdata, voxgig_value* routed) {
   if (!voxgig_is_map(reqdata)) return reqdata;
   voxgig_map* rm = voxgig_as_map(reqdata);
   bool has = false;
   for (size_t i = 0; i < rm->len; i++) {
-    if (dropped(rm->entries[i].key, point)) { has = true; break; }
+    if (dropped(rm->entries[i].key, routed)) { has = true; break; }
   }
   if (!has) return reqdata;
   voxgig_value* body = voxgig_new_map();
   for (size_t i = 0; i < rm->len; i++) {
-    if (!dropped(rm->entries[i].key, point)) {
+    if (!dropped(rm->entries[i].key, routed)) {
       setp(body, rm->entries[i].key, v_share(rm->entries[i].value));
     }
   }
@@ -51,7 +86,9 @@ voxgig_value* transform_request_util(Context* ctx) {
 
   if (spec) spec_set_step(spec, "reqform");
 
-  voxgig_value* data = NULL == point ? ctx->reqdata : omit_keys(ctx->reqdata, point);
+  voxgig_value* routed = NULL == point ? NULL : routed_args(ctx);
+  voxgig_value* data = NULL == routed ? ctx->reqdata : omit_keys(ctx->reqdata, routed);
+  if (NULL != routed) voxgig_release(routed);
 
   voxgig_value* transform = to_map(getp(point, "transform"));
   if (v_is_noval(transform)) return strip_action(data);

package/project/.sdk/tm/clojure/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/clojure/feature/secrets/sdk/feature/secrets.clj

@@ -236,9 +236,6 @@
         (throw (sekreto/sekretoerror
                 (str "secrets: token exchange failed: " (core/err-msg err) " from " url))))
 
-      ;; core/default-http-fetch NEVER returns an err - a connection failure
-      ;; comes back as status 0 with the exception in statusText - so the
-      ;; STATUS is what decides, not a nil error.
       (let [status (core/to-int (vs/getprop res "status"))]
         (when (or (< status 200) (>= status 300))
           (throw (sekreto/sekretoerror

package/project/.sdk/tm/clojure/src/sdk/client.clj

@@ -78,7 +78,13 @@
         path0 (vs/getprop fetchargs "path")
         path (if (string? path0) path0 "")
         method0 (vs/getprop fetchargs "method")
-        method (if (string? method0) method0 "GET")
+        method (.toUpperCase ^String (if (and (string? method0) (not= "" method0)) method0 "GET")
+                             java.util.Locale/ROOT)
+        allow-method (vs/getpath opts "allow.method")
+        _ (when-not (core/allowed? allow-method method)
+            (core/sdk-throw (core/ctx-error ctx "spec_method_allow"
+                                            (str "Method \"" method "\" not allowed by SDK option allow.method value: \""
+                                                 (if (string? allow-method) allow-method "") "\""))))
         params (let [p (core/to-map (vs/getprop fetchargs "params"))] (if p p (vs/jm)))
         query (let [q (core/to-map (vs/getprop fetchargs "query"))] (if q q (vs/jm)))
         headers ((core/uget ctx :prepare-headers) ctx)
@@ -99,8 +105,7 @@
 
 ;; Is this raw-access op permitted by the SDK's allow.op option?
 (defn- op-allowed? [client op]
-  (let [allow (vs/getpath (core/client-options-map client) "allow.op")]
-    (and (string? allow) (str/includes? allow op))))
+  (core/allowed? (vs/getpath (core/client-options-map client) "allow.op") op))
 
 (defn- op-denied [client op]
   (let [allow (vs/getpath (core/client-options-map client) "allow.op")]
@@ -136,8 +141,17 @@
                 no-body (or (= status 204) (= status 304) (= (str content-length) "0"))
                 json-data (when-not no-body
                             (let [jf (vs/getprop fetched "json")]
-                              (when (fn? jf) (try (jf) (catch Throwable _ nil)))))]
-            (vs/jm "ok" (and (>= status 200) (< status 300)) "status" status "headers" headers "data" json-data))
+                              (when (fn? jf) (try (jf) (catch Throwable _ nil)))))
+                body-err (when (and (not no-body) (true? (vs/getprop fetched "unreadable")))
+                           (core/unreadable-body
+                             ctx status headers (vs/getprop fetched "body") (vs/getprop fetchdef "headers")
+                             (when-not (and (>= status 200) (< status 300))
+                               (core/ctx-error ctx "request_status"
+                                               (str "request: " status ": " (or (vs/getprop fetched "statusText") ""))))))
+                out (vs/jm "ok" (and (nil? body-err) (>= status 200) (< status 300))
+                           "status" status "headers" headers "data" json-data)]
+            (when body-err (vs/setprop out "err" (core/ucall ctx :clean body-err)))
+            out)
           :else (vs/jm "ok" false "err" (core/ctx-error ctx "direct_invalid" "invalid response type")))))))
 
 ;; Raw endpoint access is operator-controllable, like every entity op.