@voxgig/sdkgen 1.3.7 → 1.3.9

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

@@ -0,0 +1,20 @@
+// clean utility (mirrors utility/clean.rs — go clean returns value unchanged).
+
+#include "sdk.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+voxgig_value* clean_util(Context* ctx, voxgig_value* val) {
+  (void)ctx;
+  return val;
+}
+
+char* clean_str(Context* ctx, const char* val) {
+  (void)ctx;
+  if (!val) val = "";
+  size_t n = strlen(val);
+  char* d = (char*)malloc(n + 1);
+  memcpy(d, val, n + 1);
+  return d;
+}

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

@@ -0,0 +1,26 @@
+// done utility (mirrors utility/done.rs).
+
+#include "sdk.h"
+
+voxgig_value* done_util(Context* ctx, PNError** err) {
+  Control* c = ctx->ctrl;
+  if (control_has_explain(c)) {
+    voxgig_value* explain = clean_util(ctx, c->explain);
+    voxgig_value* res = getp(explain, "result");
+    if (voxgig_is_map(res)) {
+      voxgig_value* rm = to_map(res);
+      voxgig_value* k = voxgig_new_string("err");
+      voxgig_delprop(rm, k);
+      voxgig_release(k);
+    }
+    c->explain = explain;
+  }
+
+  SdkResult* result = ctx->result;
+  if (result && result->ok) {
+    if (err) *err = NULL;
+    return v_share(result->resdata);
+  }
+
+  return make_error_util(ctx, NULL, err);
+}

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

@@ -0,0 +1,42 @@
+// feature_add utility (mirrors utility/feature_add.rs). A feature whose
+// add_options() names an already-added feature via __before__/__after__/
+// __replace__ positions itself relative to it; else it is appended.
+
+#include "sdk.h"
+
+#include <string.h>
+
+void feature_add_util(Context* ctx, Feature* f) {
+  ProjectNameSDK* client = ctx->client;
+  if (!client) return;
+
+  voxgig_value* fopts = f->vt->add_options(f);
+  if (fopts && voxgig_is_map(fopts)) {
+    const char* before = get_str(fopts, "__before__");
+    const char* after = get_str(fopts, "__after__");
+    const char* replace = get_str(fopts, "__replace__");
+    before = before ? before : "";
+    after = after ? after : "";
+    replace = replace ? replace : "";
+
+    if (before[0] || after[0] || replace[0]) {
+      for (size_t i = 0; i < client->features_len; i++) {
+        const char* name = client->features[i]->vt->name(client->features[i]);
+        if (before[0] && strcmp(before, name) == 0) {
+          sdk_features_insert(client, i, f);
+          return;
+        }
+        if (after[0] && strcmp(after, name) == 0) {
+          sdk_features_insert(client, i + 1, f);
+          return;
+        }
+        if (replace[0] && strcmp(replace, name) == 0) {
+          sdk_features_replace(client, i, f);
+          return;
+        }
+      }
+    }
+  }
+
+  sdk_features_push(client, f);
+}

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

@@ -0,0 +1,22 @@
+// feature_hook utility (mirrors utility/feature_hook.rs). Snapshot the list
+// so a hook that mutates the feature set does not invalidate iteration.
+
+#include "sdk.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+void feature_hook_util(Context* ctx, const char* name) {
+  ProjectNameSDK* client = ctx->client;
+  if (!client) return;
+
+  size_t n = client->features_len;
+  if (n == 0) return;
+  Feature** snapshot = (Feature**)malloc(n * sizeof(Feature*));
+  memcpy(snapshot, client->features, n * sizeof(Feature*));
+
+  for (size_t i = 0; i < n; i++) {
+    snapshot[i]->vt->hook(snapshot[i], name, ctx);
+  }
+  free(snapshot);
+}

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

@@ -0,0 +1,22 @@
+// feature_init utility (mirrors utility/feature_init.rs).
+
+#include "sdk.h"
+
+void feature_init_util(Context* ctx, Feature* f) {
+  const char* fname = f->vt->name(f);
+  voxgig_value* fopts = voxgig_new_map();
+
+  voxgig_value* options = ctx->options;
+  if (voxgig_is_map(options)) {
+    voxgig_value* feature_opts = to_map(getp(options, "feature"));
+    if (voxgig_is_map(feature_opts)) {
+      voxgig_value* fo = to_map(getp(feature_opts, fname));
+      if (voxgig_is_map(fo)) fopts = fo;
+    }
+  }
+
+  bool active = false;
+  if (get_bool(fopts, "active", &active) && active) {
+    f->vt->init(f, ctx, fopts);
+  }
+}

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

@@ -0,0 +1,78 @@
+// Default transport (mirrors utility/fetcher.rs). The C target ships no HTTP
+// client dependency: live requests without a caller-supplied system.fetch
+// return a transport error. All tests run in test mode (fetch blocked) or
+// inject a system.fetch mock, so the live path is never exercised by tests.
+
+#include "sdk.h"
+
+#include <stdio.h>
+#include <string.h>
+
+static voxgig_value* default_http_fetch(const char* fullurl, voxgig_value* fetchdef,
+                                        Context* ctx, PNError** err) {
+  (void)fetchdef;
+  char buf[512];
+  snprintf(buf, sizeof(buf),
+           "live HTTP transport not available in the C SDK (URL was: \"%s\"); "
+           "supply options.system.fetch",
+           fullurl);
+  *err = context_make_error(ctx, "fetch_transport", buf);
+  return NULL;
+}
+
+voxgig_value* fetcher_util(Fetcher* self, Context* ctx, const char* fullurl,
+                           voxgig_value* fetchdef, PNError** err) {
+  (void)self;
+  *err = NULL;
+
+  ProjectNameSDK* client = ctx->client;
+  if (!client) {
+    *err = context_make_error(ctx, "fetch_no_client", "Expected context client.");
+    return NULL;
+  }
+
+  const char* mode = client->mode;
+  if (strcmp(mode, "live") != 0) {
+    char buf[512];
+    snprintf(buf, sizeof(buf), "Request blocked by mode: \"%s\" (URL was: \"%s\")",
+             mode, fullurl);
+    *err = context_make_error(ctx, "fetch_mode_block", buf);
+    return NULL;
+  }
+
+  voxgig_value* options = sdk_options_map(client);
+  voxgig_value* testactive;
+  {
+    const char* keys[4] = {"feature", "test", "active", NULL};
+    testactive = getpath_c(options, keys);
+  }
+  if (voxgig_is_bool(testactive) && voxgig_as_bool(testactive)) {
+    char buf[512];
+    snprintf(buf, sizeof(buf),
+             "Request blocked as test feature is active (URL was: \"%s\")", fullurl);
+    *err = context_make_error(ctx, "fetch_test_block", buf);
+    return NULL;
+  }
+
+  voxgig_value* sys_fetch = getpath2(options, "system", "fetch");
+
+  if (v_is_noval(sys_fetch) || v_is_null(sys_fetch)) {
+    return default_http_fetch(fullurl, fetchdef, ctx, err);
+  }
+
+  if (voxgig_is_func(sys_fetch)) {
+    // Caller-supplied transport: called with [url, fetchdef]; returns a
+    // transport-shaped response map (an "__err__" entry signals failure).
+    voxgig_value* args = clist(2, v_str(fullurl), v_share(fetchdef));
+    voxgig_value* out = call_vfn(sys_fetch, args);
+    const char* emsg = get_str(out, "__err__");
+    if (emsg) {
+      *err = context_make_error(ctx, "fetch_system", emsg);
+      return NULL;
+    }
+    return out;
+  }
+
+  *err = context_make_error(ctx, "fetch_invalid", "system.fetch is not a valid function");
+  return NULL;
+}

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

@@ -0,0 +1,11 @@
+// JSON parse bridge — wraps the vendored struct JSON parser.
+
+#include "sdk.h"
+
+#include <string.h>
+
+voxgig_value* json_parse(const char* text) {
+  if (!text) return voxgig_new_undef();
+  voxgig_value* v = voxgig_parse_json(text, strlen(text));
+  return v ? v : voxgig_new_undef();
+}

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

@@ -0,0 +1,7 @@
+// make_context utility (mirrors utility/make_context.rs).
+
+#include "sdk.h"
+
+Context* make_context_util(CtxSpec spec, Context* basectx) {
+  return context_new(spec, basectx);
+}

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

@@ -0,0 +1,66 @@
+// make_error utility (mirrors utility/make_error.rs). On success (throw ==
+// false) returns resdata and *out = NULL; otherwise *out = the SDK error and
+// returns NULL.
+
+#include "sdk.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+voxgig_value* make_error_util(Context* ctx, PNError* err, PNError** out) {
+  Operation* op = ctx->op;
+  const char* opname = op->name;
+  if (opname == NULL || opname[0] == '\0' || strcmp(opname, "_") == 0) {
+    opname = "unknown operation";
+  }
+
+  SdkResult* result = ctx->result;
+  if (!result) {
+    result = result_new(voxgig_new_map());
+    ctx->result = result;
+  }
+  result->ok = false;
+
+  PNError* use = err;
+  if (!use) use = result->err;
+  if (!use) use = context_make_error(ctx, "unknown", "unknown error");
+
+  const char* errmsg = use->msg;
+  char msgbuf[1024];
+  snprintf(msgbuf, sizeof(msgbuf), "ProjectNameSDK: %s: %s", opname, errmsg);
+  char* msg = clean_str(ctx, msgbuf);
+
+  result->err = NULL;
+
+  voxgig_value* spec_val = ctx->spec ? spec_to_value(ctx->spec) : voxgig_new_undef();
+
+  Control* c = ctx->ctrl;
+  if (control_has_explain(c)) {
+    setp(c->explain, "err", cmap(1, "message", v_str(msg)));
+  }
+
+  PNError* sdk_err = pn_error_new("", msg);
+  free(sdk_err->code);
+  size_t cn = strlen(use->code);
+  sdk_err->code = (char*)malloc(cn + 1);
+  memcpy(sdk_err->code, use->code, cn + 1);
+  sdk_err->result = clean_util(ctx, result_to_value(result));
+  sdk_err->spec = clean_util(ctx, spec_val);
+
+  c->err = sdk_err;
+
+  // Fire PreUnexpected so observability features (metrics, telemetry, audit,
+  // debug) close/record error paths that never reach PreDone (e.g. a PrePoint
+  // rbac short-circuit). Fires after c->err is set so hooks can read the error;
+  // features guard against double-recording when PreDone already fired.
+  feature_hook_util(ctx, "PreUnexpected");
+
+  if (c->has_throw && c->throw_v == false) {
+    if (out) *out = NULL;
+    return v_share(result->resdata);
+  }
+
+  if (out) *out = sdk_err;
+  return NULL;
+}

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

@@ -0,0 +1,43 @@
+// make_fetch_def utility (mirrors utility/make_fetch_def.rs).
+
+#include "sdk.h"
+
+#include <stdlib.h>
+
+voxgig_value* make_fetch_def_util(Context* ctx, PNError** err) {
+  *err = NULL;
+  Spec* spec = ctx->spec;
+  if (!spec) {
+    *err = context_make_error(ctx, "fetchdef_no_spec", "Expected context spec property to be defined.");
+    return NULL;
+  }
+
+  if (!ctx->result) {
+    ctx->result = result_new(voxgig_new_map());
+  }
+
+  spec_set_step(spec, "prepare");
+
+  char* url = make_url_util(ctx, err);
+  if (*err) return NULL;
+
+  spec_set_url(spec, url);
+
+  voxgig_value* fetchdef = voxgig_new_map();
+  setp(fetchdef, "url", v_str(url));
+  setp(fetchdef, "method", v_str(spec->method));
+  setp(fetchdef, "headers", v_share(spec->headers));
+
+  voxgig_value* body = spec->body;
+  if (!v_is_noval(body)) {
+    if (voxgig_is_map(body)) {
+      char* js = voxgig_jsonify(body, NULL);
+      setp(fetchdef, "body", v_str(js ? js : ""));
+      free(js);
+    } else {
+      setp(fetchdef, "body", v_share(body));
+    }
+  }
+
+  return fetchdef;
+}

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

@@ -0,0 +1,179 @@
+// make_options utility (mirrors utility/make_options.rs).
+
+#include "sdk.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+static int mo_cmp_cstr(const void* a, const void* b) {
+  return strcmp(*(const char* const*)a, *(const char* const*)b);
+}
+
+voxgig_value* make_options_util(Context* ctx) {
+  voxgig_value* options = voxgig_is_map(ctx->options) ? ctx->options : voxgig_new_map();
+
+  // Merge custom utility overrides onto the utility object.
+  voxgig_value* custom_utils = to_map(getp(options, "utility"));
+  if (voxgig_is_map(custom_utils) && ctx->utility) {
+    voxgig_value* custom = ctx->utility->custom;
+    voxgig_map* cm = voxgig_as_map(custom_utils);
+    for (size_t i = 0; i < cm->len; i++) {
+      setp(custom, cm->entries[i].key, voxgig_retain(cm->entries[i].value));
+    }
+  }
+
+  voxgig_value* opts = voxgig_clone(options);
+
+  // Feature add-order. options.feature may be an ordered list of
+  // { name, active, ...opts } entries (the list position IS the order in which
+  // features are added), or a { name: {opts} } map. Normalize a list to a map
+  // (so merge/validate are unchanged) and remember the explicit order; a map
+  // defaults to test-first so the `test` mock transport is installed as the
+  // base of the transport wrapper chain.
+  voxgig_value* feature_order = v_list();
+  voxgig_value* raw_feature = getp(opts, "feature");
+  if (v_is_list(raw_feature)) {
+    voxgig_value* fmap = v_map();
+    voxgig_list* fl = voxgig_as_list(raw_feature);
+    for (size_t i = 0; i < fl->len; i++) {
+      voxgig_value* entry = fl->items[i];
+      if (v_is_map(entry)) {
+        const char* nm = get_str(entry, "name");
+        if (nm) {
+          voxgig_value* fopts = v_clone(entry);
+          voxgig_delprop(fopts, v_str("name"));
+          setp(fmap, nm, fopts);
+          voxgig_list_push(voxgig_as_list(feature_order), v_str(nm));
+        }
+      }
+    }
+    setp(opts, "feature", fmap);
+  }
+
+  voxgig_value* config = ctx->config;
+  voxgig_value* cfgopts = to_map(getp(config, "options"));
+  if (!voxgig_is_map(cfgopts)) cfgopts = voxgig_new_map();
+
+  // Build the option spec (validation shape). Marker keys use backticks.
+  voxgig_value* optspec = cmap(13,
+    "apikey", v_str(""),
+    "base", v_str("http://localhost:8000"),
+    "prefix", v_str(""),
+    "suffix", v_str(""),
+    "auth", cmap(1, "prefix", v_str("")),
+    "headers", cmap(1, "`$CHILD`", v_str("`$STRING`")),
+    "allow", cmap(2,
+      "method", v_str("GET,PUT,POST,PATCH,DELETE,OPTIONS"),
+      "op", v_str("create,update,load,list,remove,command,direct")),
+    "entity", cmap(1, "`$CHILD`", cmap(3,
+      "`$OPEN`", v_bool(true),
+      "active", v_bool(false),
+      "alias", v_map())),
+    "feature", cmap(1, "`$CHILD`", cmap(2,
+      "`$OPEN`", v_bool(true),
+      "active", v_bool(false))),
+    "utility", v_map(),
+    "system", v_map(),
+    "test", cmap(2,
+      "active", v_bool(false),
+      "entity", cmap(1, "`$OPEN`", v_bool(true))),
+    "clean", cmap(1, "keys", v_str("key,token,id")));
+
+  // Preserve system.fetch before merge/validate (validation strips it).
+  voxgig_value* sys_fetch = getpath2(opts, "system", "fetch");
+
+  voxgig_value* mergelist = clist(3, v_map(), v_share(cfgopts), v_share(opts));
+  voxgig_value* merged = voxgig_merge(mergelist, VOXGIG_MAXDEPTH);
+  voxgig_value* validated = voxgig_validate(merged, optspec, NULL);
+  if (voxgig_is_map(validated)) {
+    opts = validated;
+  }
+
+  // Restore system.fetch.
+  if (!v_is_noval(sys_fetch)) {
+    voxgig_value* sys = getp(opts, "system");
+    if (voxgig_is_map(sys)) {
+      setp(sys, "fetch", v_share(sys_fetch));
+    } else {
+      setp(opts, "system", cmap(1, "fetch", v_share(sys_fetch)));
+    }
+  }
+
+  // Derived clean config.
+  voxgig_value* clean_keys_v = getpath2(opts, "clean", "keys");
+  const char* clean_keys = voxgig_is_string(clean_keys_v) ? voxgig_as_string(clean_keys_v)
+                                                          : "key,token,id";
+
+  // Split on ',', trim, filter empty, esc_re each, join with '|'.
+  char* keyre = (char*)malloc(1);
+  keyre[0] = '\0';
+  size_t keyre_len = 0;
+  bool first = true;
+  const char* p = clean_keys;
+  while (1) {
+    const char* comma = strchr(p, ',');
+    size_t seglen = comma ? (size_t)(comma - p) : strlen(p);
+    // trim
+    const char* start = p;
+    const char* end = p + seglen;
+    while (start < end && (*start == ' ' || *start == '\t')) start++;
+    while (end > start && (end[-1] == ' ' || end[-1] == '\t')) end--;
+    if (end > start) {
+      char* seg = (char*)malloc((size_t)(end - start) + 1);
+      memcpy(seg, start, (size_t)(end - start));
+      seg[end - start] = '\0';
+      char* esc = voxgig_escre(v_str(seg));
+      free(seg);
+      const char* e = esc ? esc : "";
+      size_t elen = strlen(e);
+      size_t extra = elen + (first ? 0 : 1);
+      keyre = (char*)realloc(keyre, keyre_len + extra + 1);
+      if (!first) keyre[keyre_len++] = '|';
+      memcpy(keyre + keyre_len, e, elen);
+      keyre_len += elen;
+      keyre[keyre_len] = '\0';
+      free(esc);
+      first = false;
+    }
+    if (!comma) break;
+    p = comma + 1;
+  }
+
+  voxgig_value* derived_clean = (keyre_len == 0) ? v_map()
+                                                 : cmap(1, "keyre", v_str(keyre));
+  free(keyre);
+
+  // Resolve the feature add-order: an explicit list order (above) wins;
+  // otherwise order the map test-first, then the remaining names sorted, so
+  // the outcome is deterministic and `test` is always the base transport.
+  if (voxgig_as_list(feature_order)->len == 0) {
+    voxgig_value* fmap = getp(opts, "feature");
+    if (v_is_map(fmap)) {
+      voxgig_map* fm = voxgig_as_map(fmap);
+      size_t fn = fm->len;
+      if (fn > 0) {
+        const char** names = (const char**)malloc(sizeof(char*) * fn);
+        for (size_t i = 0; i < fn; i++) names[i] = fm->entries[i].key;
+        qsort(names, fn, sizeof(char*), mo_cmp_cstr);
+        bool has_test = false;
+        for (size_t i = 0; i < fn; i++) {
+          if (strcmp(names[i], "test") == 0) has_test = true;
+        }
+        if (has_test) {
+          voxgig_list_push(voxgig_as_list(feature_order), v_str("test"));
+        }
+        for (size_t i = 0; i < fn; i++) {
+          if (strcmp(names[i], "test") != 0) {
+            voxgig_list_push(voxgig_as_list(feature_order), v_str(names[i]));
+          }
+        }
+        free(names);
+      }
+    }
+  }
+
+  setp(opts, "__derived__",
+       cmap(2, "clean", derived_clean, "featureorder", feature_order));
+
+  return opts;
+}

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

@@ -0,0 +1,109 @@
+// make_point utility (mirrors utility/make_point.rs). Honours a PrePoint
+// short-circuit (rbac stores an error in ctx.out point).
+
+#include "sdk.h"
+
+#include <stdio.h>
+#include <string.h>
+
+static voxgig_value* get_elem_i(voxgig_value* list, int64_t i) {
+  voxgig_value* k = v_int(i);
+  voxgig_value* r = voxgig_getelem(list, k, NULL);
+  voxgig_release(k);
+  return r ? r : voxgig_new_undef();
+}
+
+voxgig_value* make_point_util(Context* ctx, PNError** err) {
+  *err = NULL;
+
+  // PrePoint short-circuit.
+  if (ctx->out_point_kind == OUT_ERR) {
+    *err = ctx->out_point_err;
+    return NULL;
+  }
+  if (ctx->out_point_kind == OUT_VAL && voxgig_is_map(ctx->out_point_val)) {
+    ctx->point = ctx->out_point_val;
+    return ctx->out_point_val;
+  }
+
+  Operation* op = ctx->op;
+  voxgig_value* options = ctx->options;
+
+  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)) {
+    char buf[512];
+    snprintf(buf, sizeof(buf),
+             "Operation \"%s\" not allowed by SDK option allow.op value: \"%s\"",
+             op->name, allow_op);
+    *err = context_make_error(ctx, "point_op_allow", buf);
+    return NULL;
+  }
+
+  voxgig_value* points = op->points;
+  int64_t plen = voxgig_size(points);
+
+  if (plen == 0) {
+    char buf[256];
+    snprintf(buf, sizeof(buf), "Operation \"%s\" has no endpoint definitions.", op->name);
+    *err = context_make_error(ctx, "point_no_points", buf);
+    return NULL;
+  }
+
+  if (plen == 1) {
+    ctx->point = get_elem_i(points, 0);
+  } else {
+    bool is_data = strcmp(op->input, "data") == 0;
+    voxgig_value* reqselector = is_data ? ctx->reqdata : ctx->reqmatch;
+    voxgig_value* selector = is_data ? ctx->data : ctx->mtch;
+
+    voxgig_value* point = voxgig_new_undef();
+    for (int64_t i = 0; i < plen; i++) {
+      point = get_elem_i(points, i);
+      voxgig_value* select_def = to_map(getp(point, "select"));
+      bool found = true;
+
+      if (!v_is_noval(selector) && !v_is_noval(select_def)) {
+        voxgig_value* exist = getp(select_def, "exist");
+        if (voxgig_is_list(exist)) {
+          voxgig_list* el = voxgig_as_list(exist);
+          for (size_t j = 0; j < el->len; j++) {
+            voxgig_value* ek = el->items[j];
+            if (voxgig_is_string(ek)) {
+              const char* existkey = voxgig_as_string(ek);
+              voxgig_value* rv = getp(reqselector, existkey);
+              voxgig_value* sv = getp(selector, existkey);
+              if (v_is_noval(rv) && v_is_noval(sv)) { found = false; break; }
+            }
+          }
+        }
+      }
+
+      if (found) {
+        voxgig_value* req_action = getp(reqselector, "$action");
+        voxgig_value* select_action = getp(select_def, "$action");
+        if (!v_eq(req_action, select_action)) found = false;
+      }
+
+      if (found) break;
+    }
+
+    voxgig_value* req_action = getp(reqselector, "$action");
+    if (!v_is_noval(req_action) && !v_is_noval(point)) {
+      voxgig_value* point_select = to_map(getp(point, "select"));
+      voxgig_value* point_action = getp(point_select, "$action");
+      if (!v_eq(req_action, point_action)) {
+        char* actstr = voxgig_stringify(req_action, -1);
+        char buf[512];
+        snprintf(buf, sizeof(buf), "Operation \"%s\" action \"%s\" is not valid.",
+                 op->name, actstr ? actstr : "");
+        *err = context_make_error(ctx, "point_action_invalid", buf);
+        return NULL;
+      }
+    }
+
+    ctx->point = point;
+  }
+
+  return ctx->point;
+}