@voxgig/sdkgen 1.3.8 → 1.3.10

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

@@ -0,0 +1,62 @@
+// make_request utility (mirrors utility/make_request.rs).
+
+#include "sdk.h"
+
+Response* make_request_util(Context* ctx, PNError** err) {
+  *err = NULL;
+
+  if (ctx->out_request) {
+    return ctx->out_request;
+  }
+
+  Response* response = response_new(voxgig_new_map());
+  SdkResult* result = result_new(voxgig_new_map());
+  ctx->result = result;
+
+  Spec* spec = ctx->spec;
+  if (!spec) {
+    *err = context_make_error(ctx, "request_no_spec", "Expected context spec property to be defined.");
+    return NULL;
+  }
+
+  PNError* fderr = NULL;
+  voxgig_value* fetchdef = make_fetch_def_util(ctx, &fderr);
+  if (fderr) {
+    response->err = fderr;
+    ctx->response = response;
+    spec_set_step(spec, "postrequest");
+    return response;  // note: not an *err — pipeline continues
+  }
+
+  Control* c = ctx->ctrl;
+  if (control_has_explain(c)) {
+    setp(c->explain, "fetchdef", v_share(fetchdef));
+  }
+
+  spec_set_step(spec, "prerequest");
+
+  const char* url = get_str(fetchdef, "url");
+  url = url ? url : "";
+  PNError* ferr = NULL;
+  voxgig_value* fetched = utility_fetch(ctx->utility, ctx, url, fetchdef, &ferr);
+
+  Response* out_response;
+  if (ferr) {
+    response->err = ferr;
+    out_response = response;
+  } else if (voxgig_is_map(fetched)) {
+    out_response = response_new(fetched);
+  } else if (v_is_noval(fetched) || v_is_null(fetched)) {
+    Response* r = response_new(voxgig_new_map());
+    r->err = context_make_error(ctx, "request_no_response", "response: undefined");
+    out_response = r;
+  } else {
+    response->err = context_make_error(ctx, "request_invalid_response", "response: invalid type");
+    out_response = response;
+  }
+
+  spec_set_step(spec, "postrequest");
+  ctx->response = out_response;
+
+  return out_response;
+}

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

@@ -0,0 +1,45 @@
+// make_response utility (mirrors utility/make_response.rs).
+
+#include "sdk.h"
+
+Response* make_response_util(Context* ctx, PNError** err) {
+  *err = NULL;
+
+  if (ctx->out_response) {
+    return ctx->out_response;
+  }
+
+  Spec* spec = ctx->spec;
+  if (!spec) {
+    *err = context_make_error(ctx, "response_no_spec", "Expected context spec property to be defined.");
+    return NULL;
+  }
+  Response* response = ctx->response;
+  if (!response) {
+    *err = context_make_error(ctx, "response_no_response", "Expected context response property to be defined.");
+    return NULL;
+  }
+  SdkResult* result = ctx->result;
+  if (!result) {
+    *err = context_make_error(ctx, "response_no_result", "Expected context result property to be defined.");
+    return NULL;
+  }
+
+  spec_set_step(spec, "response");
+
+  result_basic_util(ctx);
+  result_headers_util(ctx);
+  result_body_util(ctx);
+  transform_response_util(ctx);
+
+  if (result->err == NULL) {
+    result->ok = true;
+  }
+
+  Control* c = ctx->ctrl;
+  if (control_has_explain(c)) {
+    setp(c->explain, "result", result_to_value(result));
+  }
+
+  return response;
+}

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

@@ -0,0 +1,61 @@
+// make_result utility (mirrors utility/make_result.rs).
+
+#include "sdk.h"
+
+#include <string.h>
+
+SdkResult* make_result_util(Context* ctx, PNError** err) {
+  *err = NULL;
+
+  if (ctx->out_result) {
+    return ctx->out_result;
+  }
+
+  Operation* op = ctx->op;
+  Entity* entity = ctx->entity;
+  Spec* spec = ctx->spec;
+  if (!spec) {
+    *err = context_make_error(ctx, "result_no_spec", "Expected context spec property to be defined.");
+    return NULL;
+  }
+  SdkResult* result = ctx->result;
+  if (!result) {
+    *err = context_make_error(ctx, "result_no_result", "Expected context result property to be defined.");
+    return NULL;
+  }
+
+  spec_set_step(spec, "result");
+
+  transform_response_util(ctx);
+
+  if (strcmp(op->name, "list") == 0) {
+    voxgig_value* resdata = result->resdata;
+    result->resdata = voxgig_new_list();
+
+    if (voxgig_is_list(resdata) && entity) {
+      voxgig_list* list = voxgig_as_list(resdata);
+      if (list->len > 0) {
+        voxgig_value* entities = voxgig_new_list();
+        for (size_t i = 0; i < list->len; i++) {
+          voxgig_value* entry = list->items[i];
+          Entity* e = entity->vt->make(entity);
+          voxgig_value* out;
+          if (voxgig_is_map(entry)) {
+            out = e->vt->data(e, entry);
+          } else {
+            out = e->vt->data(e, NULL);
+          }
+          voxgig_list_push(voxgig_as_list(entities), voxgig_retain(out));
+        }
+        result->resdata = entities;
+      }
+    }
+  }
+
+  Control* c = ctx->ctrl;
+  if (control_has_explain(c)) {
+    setp(c->explain, "result", result_to_value(result));
+  }
+
+  return result;
+}

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

@@ -0,0 +1,60 @@
+// make_spec utility (mirrors utility/make_spec.rs).
+
+#include "sdk.h"
+
+#include <stdio.h>
+#include <string.h>
+
+Spec* make_spec_util(Context* ctx, PNError** err) {
+  *err = NULL;
+
+  if (ctx->out_spec) {
+    ctx->spec = ctx->out_spec;
+    return ctx->out_spec;
+  }
+
+  voxgig_value* point = ctx->point;
+  voxgig_value* options = ctx->options;
+
+  voxgig_value* specmap = voxgig_new_map();
+  setp(specmap, "base", getp(options, "base"));
+  setp(specmap, "prefix", getp(options, "prefix"));
+  setp(specmap, "suffix", getp(options, "suffix"));
+  setp(specmap, "parts", getp(point, "parts"));
+  setp(specmap, "step", v_str("start"));
+
+  Spec* spec = spec_new(specmap);
+  ctx->spec = spec;
+
+  const char* method = prepare_method_util(ctx);
+  spec_set_method(spec, method);
+
+  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)) {
+    char buf[512];
+    snprintf(buf, sizeof(buf),
+             "Method \"%s\" not allowed by SDK option allow.method value: \"%s\"",
+             method, allow_method);
+    *err = context_make_error(ctx, "spec_method_allow", buf);
+    return NULL;
+  }
+
+  spec->params = prepare_params_util(ctx);
+  spec->query = prepare_query_util(ctx);
+  spec->headers = prepare_headers_util(ctx);
+  spec->body = prepare_body_util(ctx);
+  char* path = prepare_path_util(ctx);
+  spec_set_path(spec, path);
+
+  Control* c = ctx->ctrl;
+  if (control_has_explain(c)) {
+    setp(c->explain, "spec", spec_to_value(spec));
+  }
+
+  Spec* spec2 = prepare_auth_util(ctx, err);
+  if (*err) return NULL;
+
+  ctx->spec = spec2;
+  return spec2;
+}

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

@@ -0,0 +1,88 @@
+// make_url utility (mirrors utility/make_url.rs). Returns a malloc'd URL.
+
+#include "sdk.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+// Append `add` to a heap string `*buf` (realloc), returns new buffer.
+static char* str_append(char* buf, const char* add) {
+  size_t bl = buf ? strlen(buf) : 0;
+  size_t al = strlen(add);
+  char* nb = (char*)realloc(buf, bl + al + 1);
+  memcpy(nb + bl, add, al + 1);
+  return nb;
+}
+
+char* make_url_util(Context* ctx, PNError** err) {
+  *err = NULL;
+  Spec* spec = ctx->spec;
+  if (!spec) {
+    *err = context_make_error(ctx, "url_no_spec", "Expected context spec property to be defined.");
+    return NULL;
+  }
+  SdkResult* result = ctx->result;
+  if (!result) {
+    *err = context_make_error(ctx, "url_no_result", "Expected context result property to be defined.");
+    return NULL;
+  }
+
+  // join([base, prefix, path, suffix], "/", url=true)
+  voxgig_value* parts = clist(4, v_str(spec->base), v_str(spec->prefix),
+                              v_str(spec->path), v_str(spec->suffix));
+  voxgig_value* sep = v_str("/");
+  char* joined = voxgig_join_v(parts, sep, v_bool(true));
+  char* url = str_append(NULL, joined ? joined : "");
+  free(joined);
+
+  voxgig_value* resmatch = voxgig_new_map();
+
+  // Path params substitution.
+  if (voxgig_is_map(spec->params)) {
+    voxgig_map* pm = voxgig_as_map(spec->params);
+    for (size_t i = 0; i < pm->len; i++) {
+      const char* key = pm->entries[i].key;
+      voxgig_value* val = pm->entries[i].value;
+      if (!v_is_noval(val) && !v_is_null(val)) {
+        // pattern: \{escaped_key\}
+        char* esc_key = voxgig_escre(v_str(key));
+        char pat[512];
+        snprintf(pat, sizeof(pat), "\\{%s\\}", esc_key ? esc_key : key);
+        free(esc_key);
+        char* valstr = voxgig_stringify(val, -1);
+        char* sub = voxgig_escurl(v_str(valstr ? valstr : ""));
+        free(valstr);
+        char* newurl = voxgig_re_replace(pat, url, sub ? sub : "");
+        free(sub);
+        if (newurl) { free(url); url = newurl; }
+        setp(resmatch, key, v_share(val));
+      }
+    }
+  }
+
+  // Query string.
+  const char* qsep = "?";
+  if (voxgig_is_map(spec->query)) {
+    voxgig_map* qm = voxgig_as_map(spec->query);
+    for (size_t i = 0; i < qm->len; i++) {
+      const char* key = qm->entries[i].key;
+      voxgig_value* val = qm->entries[i].value;
+      if (!v_is_noval(val) && !v_is_null(val)) {
+        char* ekey = voxgig_escurl(v_str(key));
+        char* valstr = voxgig_stringify(val, -1);
+        char* eval = voxgig_escurl(v_str(valstr ? valstr : ""));
+        free(valstr);
+        char frag[1024];
+        snprintf(frag, sizeof(frag), "%s%s=%s", qsep, ekey ? ekey : key, eval ? eval : "");
+        free(ekey);
+        free(eval);
+        url = str_append(url, frag);
+        qsep = "&";
+        setp(resmatch, key, v_share(val));
+      }
+    }
+  }
+
+  result->resmatch = resmatch;
+  return url;
+}

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

@@ -0,0 +1,58 @@
+// param utility (mirrors utility/param.rs).
+
+#include "sdk.h"
+
+#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;
+
+  int pt = voxgig_typify(paramdef);
+
+  char key[256];
+  key[0] = '\0';
+  if (0 != ((VOXGIG_T_STRING) & pt)) {
+    if (voxgig_is_string(paramdef)) {
+      const char* s = voxgig_as_string(paramdef);
+      snprintf(key, sizeof(key), "%s", s);
+    }
+  } else {
+    const char* n = get_str(paramdef, "name");
+    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);
+    }
+  }
+
+  voxgig_value* val = getp(reqmatch, key);
+  if (v_is_noval(val)) val = getp(mtch, key);
+
+  if (v_is_noval(val) && akey[0] != '\0') {
+    if (spec) {
+      setp(spec->alias, akey, v_str(key));
+    }
+    val = getp(reqmatch, akey);
+  }
+
+  if (v_is_noval(val)) val = getp(reqdata, key);
+  if (v_is_noval(val)) val = getp(data, key);
+
+  if (v_is_noval(val) && akey[0] != '\0') {
+    val = getp(reqdata, akey);
+    if (v_is_noval(val)) val = getp(data, akey);
+  }
+
+  return val;
+}

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

@@ -0,0 +1,65 @@
+// prepare_auth utility (mirrors utility/prepare_auth.rs).
+
+#include "sdk.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#define HEADER_AUTH "authorization"
+#define OPTION_APIKEY "apikey"
+#define NOT_FOUND "__NOTFOUND__"
+
+Spec* prepare_auth_util(Context* ctx, PNError** err) {
+  *err = NULL;
+  Spec* spec = ctx->spec;
+  if (!spec) {
+    *err = context_make_error(ctx, "auth_no_spec", "Expected context spec property to be defined.");
+    return NULL;
+  }
+
+  voxgig_value* headers = spec->headers;
+  voxgig_value* options = ctx->client ? sdk_options_map(ctx->client) : ctx->options;
+
+  voxgig_value* auth = getp(options, "auth");
+  if (v_is_noval(auth) || v_is_null(auth)) {
+    voxgig_value* k = voxgig_new_string(HEADER_AUTH);
+    voxgig_delprop(headers, k);
+    voxgig_release(k);
+    return spec;
+  }
+
+  voxgig_value* akey_key = voxgig_new_string(OPTION_APIKEY);
+  voxgig_value* nf = voxgig_new_string(NOT_FOUND);
+  voxgig_value* apikey = voxgig_getprop(options, akey_key, nf);
+  voxgig_release(akey_key);
+  voxgig_release(nf);
+
+  bool skip;
+  if (v_is_noval(apikey) || v_is_null(apikey)) {
+    skip = true;
+  } else if (voxgig_is_string(apikey)) {
+    const char* s = voxgig_as_string(apikey);
+    skip = (strcmp(s, NOT_FOUND) == 0 || s[0] == '\0');
+  } else {
+    skip = false;
+  }
+
+  if (skip) {
+    voxgig_value* k = voxgig_new_string(HEADER_AUTH);
+    voxgig_delprop(headers, k);
+    voxgig_release(k);
+  } else {
+    voxgig_value* prefix_v = getpath2(options, "auth", "prefix");
+    const char* auth_prefix = voxgig_is_string(prefix_v) ? voxgig_as_string(prefix_v) : "";
+    const char* apikey_val = voxgig_is_string(apikey) ? voxgig_as_string(apikey) : "";
+    if (auth_prefix[0] == '\0') {
+      setp(headers, HEADER_AUTH, v_str(apikey_val));
+    } else {
+      char buf[1024];
+      snprintf(buf, sizeof(buf), "%s %s", auth_prefix, apikey_val);
+      setp(headers, HEADER_AUTH, v_str(buf));
+    }
+  }
+
+  return spec;
+}

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

@@ -0,0 +1,12 @@
+// prepare_body utility (mirrors utility/prepare_body.rs).
+
+#include "sdk.h"
+
+#include <string.h>
+
+voxgig_value* prepare_body_util(Context* ctx) {
+  if (strcmp(ctx->op->input, "data") == 0) {
+    return transform_request_util(ctx);
+  }
+  return voxgig_new_undef();
+}

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

@@ -0,0 +1,13 @@
+// prepare_headers utility (mirrors utility/prepare_headers.rs).
+
+#include "sdk.h"
+
+voxgig_value* prepare_headers_util(Context* ctx) {
+  voxgig_value* options = ctx->client ? sdk_options_map(ctx->client) : ctx->options;
+
+  voxgig_value* headers = getp(options, "headers");
+  if (v_is_noval(headers) || v_is_null(headers)) return voxgig_new_map();
+
+  voxgig_value* cloned = voxgig_clone(headers);
+  return voxgig_is_map(cloned) ? cloned : voxgig_new_map();
+}

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

@@ -0,0 +1,16 @@
+// prepare_method utility (mirrors utility/prepare_method.rs).
+
+#include "sdk.h"
+
+#include <string.h>
+
+const char* prepare_method_util(Context* ctx) {
+  const char* op = ctx->op->name;
+  if (strcmp(op, "create") == 0) return "POST";
+  if (strcmp(op, "update") == 0) return "PUT";
+  if (strcmp(op, "load") == 0) return "GET";
+  if (strcmp(op, "list") == 0) return "GET";
+  if (strcmp(op, "remove") == 0) return "DELETE";
+  if (strcmp(op, "patch") == 0) return "PATCH";
+  return "GET";
+}

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

@@ -0,0 +1,30 @@
+// prepare_params utility (mirrors utility/prepare_params.rs).
+
+#include "sdk.h"
+
+voxgig_value* prepare_params_util(Context* ctx) {
+  voxgig_value* point = ctx->point;
+
+  voxgig_value* args = to_map(getp(point, "args"));
+  voxgig_value* params = voxgig_new_list();
+  if (voxgig_is_map(args)) {
+    voxgig_value* p = getp(args, "params");
+    if (voxgig_is_list(p)) params = p;
+  }
+
+  voxgig_value* out = voxgig_new_map();
+  if (voxgig_is_list(params)) {
+    voxgig_list* pl = voxgig_as_list(params);
+    for (size_t i = 0; i < pl->len; i++) {
+      voxgig_value* pd = pl->items[i];
+      voxgig_value* val = param_util(ctx, pd);
+      if (!v_is_noval(val) && !v_is_null(val) && voxgig_is_map(pd)) {
+        const char* name = get_str(pd, "name");
+        if (name && name[0] != '\0') {
+          setp(out, name, v_share(val));
+        }
+      }
+    }
+  }
+  return out;
+}

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

@@ -0,0 +1,17 @@
+// prepare_path utility (mirrors utility/prepare_path.rs). Returns malloc'd.
+
+#include "sdk.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+char* prepare_path_util(Context* ctx) {
+  voxgig_value* point = ctx->point;
+  voxgig_value* parts = getp(point, "parts");
+  if (!voxgig_is_list(parts)) parts = voxgig_new_list();
+  char* joined = voxgig_join_v(parts, v_str("/"), v_bool(true));
+  if (joined) return joined;
+  char* empty = (char*)malloc(1);
+  empty[0] = '\0';
+  return empty;
+}

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

@@ -0,0 +1,37 @@
+// prepare_query utility (mirrors utility/prepare_query.rs).
+
+#include "sdk.h"
+
+#include <string.h>
+
+static bool params_contains(voxgig_value* params, const char* key) {
+  if (voxgig_is_list(params)) {
+    voxgig_list* pl = voxgig_as_list(params);
+    for (size_t i = 0; i < pl->len; i++) {
+      voxgig_value* v = pl->items[i];
+      if (voxgig_is_string(v) && strcmp(voxgig_as_string(v), key) == 0) return true;
+    }
+  }
+  return false;
+}
+
+voxgig_value* prepare_query_util(Context* ctx) {
+  voxgig_value* point = ctx->point;
+  voxgig_value* reqmatch = voxgig_is_map(ctx->reqmatch) ? ctx->reqmatch : voxgig_new_map();
+
+  voxgig_value* params = getp(point, "params");
+  if (!voxgig_is_list(params)) params = voxgig_new_list();
+
+  voxgig_value* out = voxgig_new_map();
+  if (voxgig_is_map(reqmatch)) {
+    voxgig_map* rm = voxgig_as_map(reqmatch);
+    for (size_t i = 0; i < rm->len; i++) {
+      const char* key = rm->entries[i].key;
+      voxgig_value* val = rm->entries[i].value;
+      if (!v_is_noval(val) && !v_is_null(val) && !params_contains(params, key)) {
+        setp(out, key, v_share(val));
+      }
+    }
+  }
+  return out;
+}

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

@@ -0,0 +1,43 @@
+// result_basic utility (mirrors utility/result_basic.rs).
+
+#include "sdk.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static char* dup_str(const char* s) {
+  if (!s) s = "";
+  size_t n = strlen(s);
+  char* d = (char*)malloc(n + 1);
+  memcpy(d, s, n + 1);
+  return d;
+}
+
+SdkResult* result_basic_util(Context* ctx) {
+  Response* response = ctx->response;
+  SdkResult* result = ctx->result;
+
+  if (result && response) {
+    result->status = response->status;
+    free(result->status_text);
+    result->status_text = dup_str(response->status_text);
+
+    if (result->status >= 400) {
+      char msg[512];
+      snprintf(msg, sizeof(msg), "request: %lld: %s",
+               (long long)result->status, result->status_text);
+      if (result->err) {
+        char buf[1024];
+        snprintf(buf, sizeof(buf), "%s: %s", result->err->msg, msg);
+        result->err = context_make_error(ctx, "request_status", buf);
+      } else {
+        result->err = context_make_error(ctx, "request_status", msg);
+      }
+    } else if (response->err) {
+      result->err = response->err;
+    }
+  }
+
+  return result;
+}

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

@@ -0,0 +1,17 @@
+// result_body utility (mirrors utility/result_body.rs).
+
+#include "sdk.h"
+
+SdkResult* result_body_util(Context* ctx) {
+  Response* response = ctx->response;
+  SdkResult* result = ctx->result;
+
+  if (result && response) {
+    voxgig_value* json = response->json;
+    voxgig_value* body = response->body;
+    if (voxgig_is_func(json) && !v_is_noval(body) && !v_is_null(body)) {
+      result->body = call_json(json);
+    }
+  }
+  return result;
+}

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

@@ -0,0 +1,17 @@
+// result_headers utility (mirrors utility/result_headers.rs).
+
+#include "sdk.h"
+
+SdkResult* result_headers_util(Context* ctx) {
+  Response* response = ctx->response;
+  SdkResult* result = ctx->result;
+
+  if (result) {
+    voxgig_value* headers = voxgig_new_map();
+    if (response && voxgig_is_map(response->headers)) {
+      headers = response->headers;
+    }
+    result->headers = headers;
+  }
+  return result;
+}