@voxgig/sdkgen 4.34.0 → 4.34.2

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

@@ -4,6 +4,7 @@
 #include "sdk.h"
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 static voxgig_value* get_elem_i(voxgig_value* list, int64_t i) {
@@ -36,6 +37,63 @@ static bool terminal_param(voxgig_value* point) {
   return NULL != s && '{' == s[0];
 }
 
+static voxgig_value* own_point(voxgig_value* points) {
+  voxgig_list* pl = voxgig_as_list(points);
+  voxgig_value* best = pl->items[0];
+  for (size_t i = 0; i < pl->len; i++) {
+    voxgig_value* cand = pl->items[i];
+    bool cand_term = terminal_param(cand);
+    bool best_term = terminal_param(best);
+    if (cand_term != best_term) {
+      if (cand_term) best = cand;
+    }
+    else if (parts_len(cand) < parts_len(best)) {
+      best = cand;
+    }
+  }
+  return 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: a list of names.
+static voxgig_value* unfilled(Context* ctx, voxgig_value* point) {
+  voxgig_value* missing = voxgig_new_list();
+  voxgig_value* parts = getp(point, "parts");
+  if (!voxgig_is_list(parts)) return missing;
+
+  voxgig_list* pl = voxgig_as_list(parts);
+  for (size_t i = 0; i < pl->len; i++) {
+    if (!voxgig_is_string(pl->items[i])) continue;
+    const char* part = voxgig_as_string(pl->items[i]);
+    size_t n = strlen(part);
+    if (n < 3 || '{' != part[0] || '}' != part[n - 1] || n - 2 != strcspn(part + 1, "{}/")) continue;
+
+    char* name = (char*)malloc(n - 1);
+    memcpy(name, part + 1, n - 2);
+    name[n - 2] = '\0';
+    voxgig_value* val = param_value(ctx, point, name);
+    if (v_is_noval(val) || v_is_null(val)) {
+      voxgig_list_push(voxgig_as_list(missing), voxgig_new_string(name));
+    }
+    free(name);
+  }
+  return missing;
+}
+
+// The names in a list, joined with a comma, malloc'd.
+static char* join_names(voxgig_value* names) {
+  voxgig_list* nl = voxgig_as_list(names);
+  size_t len = 1;
+  for (size_t i = 0; i < nl->len; i++) len += strlen(voxgig_as_string(nl->items[i])) + 2;
+  char* out = (char*)malloc(len);
+  out[0] = '\0';
+  for (size_t i = 0; i < nl->len; i++) {
+    if (0 < i) strcat(out, ", ");
+    strcat(out, voxgig_as_string(nl->items[i]));
+  }
+  return out;
+}
+
 voxgig_value* make_point_util(Context* ctx, PNError** err) {
   *err = NULL;
 
@@ -54,7 +112,7 @@ voxgig_value* make_point_util(Context* ctx, PNError** err) {
 
   voxgig_value* allow_op_v = getpath2(options, "allow", "op");
   const char* allow_op = voxgig_is_string(allow_op_v) ? voxgig_as_string(allow_op_v) : "";
-  if (!strstr(allow_op, op->name)) {
+  if (!allow_list_has(allow_op_v, op->name)) {
     char buf[512];
     snprintf(buf, sizeof(buf),
              "Operation \"%s\" not allowed by SDK option allow.op value: \"%s\"",
@@ -135,18 +193,52 @@ voxgig_value* make_point_util(Context* ctx, PNError** err) {
         return NULL;
       }
 
-      point = get_elem_i(points, 0);
+      // A call without an action falls back to a point without one, as
+      // generation does, and only to a route the call can fill.
+      voxgig_value* plain = voxgig_new_list();
       for (int64_t i = 0; i < plen; i++) {
         voxgig_value* cand = get_elem_i(points, i);
-        bool cand_term = terminal_param(cand);
-        bool best_term = terminal_param(point);
-        if (cand_term != best_term) {
-          if (cand_term) point = cand;
+        if (v_is_noval(getp(to_map(getp(cand, "select")), "$action"))) {
+          voxgig_list_push(voxgig_as_list(plain), v_share(cand));
         }
-        else if (parts_len(cand) < parts_len(point)) {
-          point = cand;
+      }
+      if (0 == voxgig_as_list(plain)->len) {
+        voxgig_release(plain);
+        char buf[512];
+        snprintf(buf, sizeof(buf),
+                 "Operation \"%s\" has only action endpoints; pass $action to choose one.",
+                 op->name);
+        *err = context_make_error(ctx, "point_action_required", buf);
+        return NULL;
+      }
+      voxgig_value* fillable = voxgig_new_list();
+      voxgig_list* plain_l = voxgig_as_list(plain);
+      for (size_t i = 0; i < plain_l->len; i++) {
+        voxgig_value* missing = unfilled(ctx, plain_l->items[i]);
+        if (0 == voxgig_as_list(missing)->len) {
+          voxgig_list_push(voxgig_as_list(fillable), v_share(plain_l->items[i]));
         }
+        voxgig_release(missing);
+      }
+
+      if (0 == voxgig_as_list(fillable)->len) {
+        voxgig_value* missing = unfilled(ctx, own_point(plain));
+        char* names = join_names(missing);
+        char buf[512];
+        snprintf(buf, sizeof(buf),
+                 "Operation \"%s\" has no endpoint whose path parameters are all given (missing: %s).",
+                 op->name, names);
+        free(names);
+        voxgig_release(missing);
+        voxgig_release(fillable);
+        voxgig_release(plain);
+        *err = context_make_error(ctx, "point_no_match", buf);
+        return NULL;
       }
+
+      point = own_point(fillable);
+      voxgig_release(fillable);
+      voxgig_release(plain);
     }
 
     voxgig_value* req_action = getp(reqselector, "$action");

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

@@ -39,7 +39,7 @@ Spec* make_spec_util(Context* ctx, PNError** err) {
 
   voxgig_value* allow_method_v = getpath2(options, "allow", "method");
   const char* allow_method = voxgig_is_string(allow_method_v) ? voxgig_as_string(allow_method_v) : "";
-  if (!strstr(allow_method, method)) {
+  if (!allow_list_has(allow_method_v, method)) {
     char buf[512];
     snprintf(buf, sizeof(buf),
              "Method \"%s\" not allowed by SDK option allow.method value: \"%s\"",
@@ -80,9 +80,25 @@ Spec* make_spec_util(Context* ctx, PNError** err) {
     setp(c->explain, "spec", spec_to_value(spec));
   }
 
+  // Whatever prepare_auth sets in the query, under whichever name, is the
+  // credential; a key it leaves as it was is the caller's.
+  voxgig_value* query = v_clone(spec->query);
+
   Spec* spec2 = prepare_auth_util(ctx, err);
   if (*err) return NULL;
 
+  spec2->authquery = voxgig_new_list();
+  if (voxgig_is_map(spec2->query)) {
+    voxgig_map* qm = voxgig_as_map(spec2->query);
+    for (size_t i = 0; i < qm->len; i++) {
+      voxgig_value* was = getp(query, qm->entries[i].key);
+      if (v_is_noval(was) || !v_eq(was, qm->entries[i].value)) {
+        voxgig_list_push(voxgig_as_list(spec2->authquery),
+          voxgig_new_string(qm->entries[i].key));
+      }
+    }
+  }
+
   ctx->spec = spec2;
   return spec2;
 }

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

@@ -15,6 +15,28 @@ static char* str_append(char* buf, const char* add) {
   return nb;
 }
 
+// The {name} placeholders in a text, joined with a comma, malloc'd, or NULL
+// when there are none.
+static char* placeholders(const char* text) {
+  char* out = NULL;
+  const char* at = text;
+  while (*at) {
+    size_t n = '{' == *at ? strcspn(at + 1, "{}/") : 0;
+    if (0 < n && '}' == at[1 + n]) {
+      if (NULL != out) out = str_append(out, ", ");
+      size_t ol = NULL == out ? 0 : strlen(out);
+      out = (char*)realloc(out, ol + n + 3);
+      memcpy(out + ol, at, n + 2);
+      out[ol + n + 2] = '\0';
+      at += n + 2;
+    }
+    else {
+      at++;
+    }
+  }
+  return out;
+}
+
 char* make_url_util(Context* ctx, PNError** err) {
   *err = NULL;
   Spec* spec = ctx->spec;
@@ -72,6 +94,20 @@ char* make_url_util(Context* ctx, PNError** err) {
     }
   }
 
+  // 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.
+  size_t blen = NULL == spec->base ? 0 : strlen(spec->base);
+  while (0 < blen && '/' == spec->base[blen - 1]) blen--;
+  char* unfilled = placeholders(0 == strncmp(url, NULL == spec->base ? "" : spec->base, blen) ? url + blen : url);
+  if (NULL != unfilled) {
+    char buf[512];
+    snprintf(buf, sizeof(buf), "URL path has no value for %s.", unfilled);
+    free(unfilled);
+    free(url);
+    *err = context_make_error(ctx, "url_param_missing", buf);
+    return NULL;
+  }
+
   // Query string.
   const char* qsep = "?";
   if (voxgig_is_map(spec->query)) {
@@ -90,7 +126,8 @@ char* make_url_util(Context* ctx, PNError** err) {
         free(eval);
         url = str_append(url, frag);
         qsep = "&";
-        setp(resmatch, key, v_share(val));
+        // Sent with the request, never recorded as the entity's match.
+        if (!spec_authquery_has(spec, key)) setp(resmatch, key, v_share(val));
       }
     }
   }

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

@@ -0,0 +1,107 @@
+// The media types a point declares (mirrors utility/media.rs): `response`
+// (the model's `rs`) for the Accept header, and `body` (the model's `rb`)
+// for the request body.
+
+#include "sdk.h"
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+static bool ieq_n(const char* s, size_t n, const char* lit) {
+  if (strlen(lit) != n) return false;
+  for (size_t i = 0; i < n; i++) {
+    if (tolower((unsigned char)s[i]) != lit[i]) return false;
+  }
+  return true;
+}
+
+bool media_is_json(const char* media) {
+  if (NULL == media) return false;
+  size_t n = strcspn(media, ";");
+  while (n > 0 && isspace((unsigned char)media[n - 1])) n--;
+  while (n > 0 && isspace((unsigned char)*media)) {
+    media++;
+    n--;
+  }
+  return ieq_n(media, n, "application/json") || ieq_n(media, n, "text/json") ||
+         (n >= 5 && ieq_n(media + n - 5, 5, "+json"));
+}
+
+// The declared JSON type alone, else every declared type in the model's
+// order; NULL when no success response declares a body. Malloc'd.
+char* media_accept_of(voxgig_value* point) {
+  voxgig_value* res = getp(point, "response");
+  const char* media = get_str(res, "media");
+  if (NULL == media || '\0' == *media) return NULL;
+  bool json = v_str_eq(getp(res, "kind"), "json");
+
+  voxgig_value* alts = getp(res, "alternatives");
+  voxgig_list* al = !json && v_is_list(alts) ? voxgig_as_list(alts) : NULL;
+  size_t cap = strlen(media) + 1;
+  for (size_t i = 0; NULL != al && i < al->len; i++) {
+    const char* m = get_str(al->items[i], "media");
+    if (NULL != m && '\0' != *m) cap += strlen(m) + 2;
+  }
+  char* out = (char*)malloc(cap);
+  strcpy(out, media);
+  for (size_t i = 0; NULL != al && i < al->len; i++) {
+    const char* m = get_str(al->items[i], "media");
+    if (NULL != m && '\0' != *m) {
+      strcat(out, ", ");
+      strcat(out, m);
+    }
+  }
+  return out;
+}
+
+bool media_is_raw_request(voxgig_value* point) {
+  return v_str_eq(getp(getp(point, "body"), "kind"), "raw");
+}
+
+bool media_is_json_request(voxgig_value* point) {
+  return v_str_eq(getp(getp(point, "body"), "kind"), "json");
+}
+
+static bool has_header(voxgig_value* headers, const char* name) {
+  voxgig_map* hm = voxgig_as_map(headers);
+  for (size_t j = 0; j < hm->len; j++) {
+    if (ieq_n(hm->entries[j].key, strlen(hm->entries[j].key), name)) return true;
+  }
+  return 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.
+void media_headers(voxgig_value* point, voxgig_value* headers) {
+  if (!v_is_map(headers)) return;
+
+  char* accept = media_accept_of(point);
+  if (NULL != accept) {
+    if (!has_header(headers, "accept")) setp(headers, "accept", v_str(accept));
+    free(accept);
+  }
+
+  voxgig_value* body = getp(point, "body");
+  const char* media = get_str(body, "media");
+  if ((v_str_eq(getp(body, "kind"), "raw") || v_str_eq(getp(body, "kind"), "json")) &&
+      NULL != media && '\0' != *media) {
+    voxgig_map* hm = voxgig_as_map(headers);
+    for (size_t j = hm->len; j > 0; j--) {
+      const char* key = hm->entries[j - 1].key;
+      voxgig_value* val = hm->entries[j - 1].value;
+      if (ieq_n(key, strlen(key), "content-type") && voxgig_is_string(val) &&
+          media_is_json(voxgig_as_string(val))) {
+        voxgig_value* dk = voxgig_new_string(key);
+        voxgig_delprop(headers, dk);
+        voxgig_release(dk);
+      }
+    }
+    if (!has_header(headers, "content-type")) setp(headers, "content-type", v_str(media));
+  }
+}
+
+// A string value of text or bytes: its length, not a NUL, ends it.
+voxgig_value* media_raw_body(voxgig_value* reqdata) {
+  return getp(reqdata, "$body");
+}

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

@@ -5,14 +5,9 @@
 #include <stdio.h>   // snprintf
 #include <string.h>
 
-voxgig_value* param_util(Context* ctx, voxgig_value* paramdef) {
-  voxgig_value* point = ctx->point;
-  Spec* spec = ctx->spec;
-  voxgig_value* mtch = ctx->mtch;
-  voxgig_value* reqmatch = ctx->reqmatch;
-  voxgig_value* data = ctx->data;
-  voxgig_value* reqdata = ctx->reqdata;
+static const char* param_alias(voxgig_value* point, const char* key);
 
+voxgig_value* param_util(Context* ctx, voxgig_value* paramdef) {
   int pt = voxgig_typify(paramdef);
 
   char key[256];
@@ -27,33 +22,62 @@ voxgig_value* param_util(Context* ctx, voxgig_value* paramdef) {
     if (n) snprintf(key, sizeof(key), "%s", n);
   }
 
-  char akey[256];
-  akey[0] = '\0';
-  if (!v_is_noval(point)) {
-    voxgig_value* alias = to_map(getp(point, "alias"));
-    if (!v_is_noval(alias)) {
-      const char* ak = get_str(alias, key);
-      if (ak) snprintf(akey, sizeof(akey), "%s", ak);
-    }
+  const char* akey = param_alias(ctx->point, key);
+  if (ctx->spec && akey &&
+      v_is_noval(getp(ctx->reqmatch, key)) && v_is_noval(getp(ctx->mtch, key))) {
+    setp(ctx->spec->alias, akey, v_str(key));
   }
 
-  voxgig_value* val = getp(reqmatch, key);
-  if (v_is_noval(val)) val = getp(mtch, key);
+  return param_value(ctx, ctx->point, key);
+}
 
-  if (v_is_noval(val) && akey[0] != '\0') {
-    if (spec) {
-      setp(spec->alias, akey, v_str(key));
-    }
-    val = getp(reqmatch, akey);
-  }
+// The name a point gives a parameter in the call, if it renames it.
+static const char* param_alias(voxgig_value* point, const char* key) {
+  if (v_is_noval(point)) return NULL;
+  voxgig_value* alias = to_map(getp(point, "alias"));
+  if (v_is_noval(alias)) return NULL;
+  const char* ak = get_str(alias, key);
+  return (ak && ak[0] != '\0') ? ak : NULL;
+}
 
-  if (v_is_noval(val)) val = getp(reqdata, key);
-  if (v_is_noval(val)) val = getp(data, key);
+// The value the call or its entity gives a point's parameter, under its name
+// or the point's alias for it.
+voxgig_value* param_value(Context* ctx, voxgig_value* point, const char* key) {
+  const char* akey = param_alias(point, key);
 
-  if (v_is_noval(val) && akey[0] != '\0') {
-    val = getp(reqdata, akey);
-    if (v_is_noval(val)) val = getp(data, akey);
+  voxgig_value* val = getp(ctx->reqmatch, key);
+  if (v_is_noval(val)) val = getp(ctx->mtch, key);
+  if (v_is_noval(val) && akey) val = getp(ctx->reqmatch, akey);
+  if (v_is_noval(val)) val = getp(ctx->reqdata, key);
+  if (v_is_noval(val)) val = getp(ctx->data, key);
+
+  if (v_is_noval(val) && akey) {
+    val = getp(ctx->reqdata, akey);
+    if (v_is_noval(val)) val = getp(ctx->data, akey);
   }
 
   return val;
 }
+
+// The arguments a point declares in one location, query or header, each as
+// [name, wire, val]: 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.
+voxgig_value* call_args(Context* ctx, const char* kind) {
+  voxgig_value* out = voxgig_new_list();
+  voxgig_value* defs = getpath2(ctx->point, "args", kind);
+  if (!voxgig_is_list(defs)) return out;
+
+  voxgig_list* dl = voxgig_as_list(defs);
+  for (size_t i = 0; i < dl->len; i++) {
+    voxgig_value* name = getp(dl->items[i], "name");
+    if (!voxgig_is_string(name) || voxgig_as_string(name)[0] == '\0') continue;
+    voxgig_value* orig = getp(dl->items[i], "orig");
+    voxgig_value* wire = voxgig_is_string(orig) && voxgig_as_string(orig)[0] != '\0' ? orig : 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));
+    voxgig_list_push(voxgig_as_list(out), clist(3, name, wire, val));
+  }
+  return out;
+}

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

@@ -6,6 +6,7 @@
 
 voxgig_value* prepare_body_util(Context* ctx) {
   if (strcmp(ctx->op->input, "data") == 0) {
+    if (media_is_raw_request(ctx->point)) return media_raw_body(ctx->reqdata);
     return transform_request_util(ctx);
   }
   return voxgig_new_undef();