@voxgig/sdkgen 1.3.7 → 1.3.9

package/project/.sdk/tm/c/feature/ratelimit.c

@@ -0,0 +1,124 @@
+// Client-side rate limiting via a token bucket (mirrors feature/
+// ratelimit.rs). Each request consumes a token; when the bucket is empty the
+// request waits until the bucket refills at `rate` tokens per second (with
+// capacity `burst`, default: rate). The clock (`now`) and the wait (`sleep`)
+// are injectable so the accounting can be tested deterministically.
+
+#include "sdk.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+  double tokens;
+  int64_t last;
+
+  // Activity tracking (mirrors the ts client._ratelimit record).
+  int64_t throttled;
+  int64_t wait_ms;
+} RatelimitTrack;
+
+typedef struct {
+  Feature base;
+  char* name;
+  bool active;
+  voxgig_value* add_opts;
+  voxgig_value* options;
+  RatelimitTrack* track;
+} RatelimitFeature;
+
+typedef struct {
+  Fetcher* inner;
+  voxgig_value* options;
+  RatelimitTrack* track;
+} RatelimitState;
+
+static void acquire(RatelimitTrack* t, voxgig_value* options) {
+  double rate = fopt_num(options, "rate", 5.0);
+  double burst = fopt_num(options, "burst", rate);
+
+  // Refill according to elapsed time.
+  int64_t now = fopt_now_call(options);
+  int64_t elapsed = now - t->last;
+  t->last = now;
+  double refilled = t->tokens + ((double)elapsed / 1000.0) * rate;
+  t->tokens = burst < refilled ? burst : refilled; // burst.min(...)
+
+  if (t->tokens >= 1.0) {
+    t->tokens -= 1.0;
+    return;
+  }
+
+  // Not enough tokens: wait for one to accrue, then consume it.
+  double needed = 1.0 - t->tokens;
+  int64_t wait_ms = (int64_t)ceil((needed / rate) * 1000.0);
+  t->throttled += 1;
+  t->wait_ms += wait_ms;
+
+  if (wait_ms > 0) {
+    fopt_sleep_call(options, wait_ms);
+  }
+  t->last = fopt_now_call(options);
+  t->tokens = 0.0;
+}
+
+static voxgig_value* ratelimit_fetch(Fetcher* self, Context* ctx, const char* url,
+                                     voxgig_value* fetchdef, PNError** err) {
+  RatelimitState* st = (RatelimitState*)self->state;
+  acquire(st->track, st->options);
+  return st->inner->fn(st->inner, ctx, url, fetchdef, err);
+}
+
+static const char* ratelimit_name(Feature* f) { return ((RatelimitFeature*)f)->name; }
+static bool ratelimit_active(Feature* f) { return ((RatelimitFeature*)f)->active; }
+static voxgig_value* ratelimit_add_options(Feature* f) { return ((RatelimitFeature*)f)->add_opts; }
+
+static void ratelimit_init(Feature* f, Context* ctx, voxgig_value* options) {
+  RatelimitFeature* rf = (RatelimitFeature*)f;
+  rf->options = options;
+  rf->active = fopt_bool(options, "active", false);
+  if (!rf->active) return;
+
+  double rate = fopt_num(options, "rate", 5.0);
+  double burst = fopt_num(options, "burst", rate);
+  rf->track->tokens = burst;
+  rf->track->last = fopt_now_call(options);
+
+  Utility* util = context_util(ctx);
+  RatelimitState* st = (RatelimitState*)calloc(1, sizeof(RatelimitState));
+  st->inner = util->fetcher;
+  st->options = options;
+  st->track = rf->track;
+
+  Fetcher* wrapped = (Fetcher*)calloc(1, sizeof(Fetcher));
+  wrapped->fn = ratelimit_fetch;
+  wrapped->state = st;
+  util->fetcher = wrapped;
+}
+
+static void ratelimit_hook(Feature* f, const char* name, Context* ctx) {
+  (void)f; (void)name; (void)ctx;
+}
+
+static voxgig_value* ratelimit_track(Feature* f) {
+  RatelimitTrack* t = ((RatelimitFeature*)f)->track;
+  return cmap(2, "throttled", v_num((double)t->throttled),
+              "waitMs", v_num((double)t->wait_ms));
+}
+
+static const FeatureVT RATELIMIT_VT = {
+  ratelimit_name, ratelimit_active, ratelimit_add_options, ratelimit_init, ratelimit_hook,
+  ratelimit_track,
+};
+
+Feature* feature_ratelimit_new(void) {
+  RatelimitFeature* rf = (RatelimitFeature*)calloc(1, sizeof(RatelimitFeature));
+  rf->base.vt = &RATELIMIT_VT;
+  rf->name = strdup("ratelimit");
+  rf->active = true; // matches rust default (overridden by init from options)
+  rf->add_opts = NULL;
+  rf->options = voxgig_new_undef();
+  rf->track = (RatelimitTrack*)calloc(1, sizeof(RatelimitTrack));
+  return (Feature*)rf;
+}

package/project/.sdk/tm/c/feature/rbac.c

@@ -0,0 +1,167 @@
+// Client-side role/permission enforcement (mirrors feature/rbac.rs). Before
+// an operation resolves its endpoint, the required permission for that
+// entity+operation is checked against the permissions the client holds; a
+// disallowed call is short-circuited with an `rbac_denied` error (via
+// ctx.out point, which make_point surfaces) and never touches the network.
+// Required permissions come from `rules` (keyed by `<entity>.<op>`, `<op>`,
+// or `*`); the default when no rule matches is controlled by `deny` (default:
+// allow when unspecified). Held permissions are the `permissions` list (a `*`
+// grants everything).
+
+#include "sdk.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+  Feature base;
+  char* name;
+  bool active;
+  voxgig_value* add_opts;
+  voxgig_value* options;
+  voxgig_value* granted; // Map of permission string -> bool(true)
+
+  // Activity tracking (mirrors the ts client._rbac record).
+  int64_t allowed;
+  int64_t denied;
+  voxgig_value* last;
+} RbacFeature;
+
+// The entity name for the current op: the resolved entity when present, else
+// the operation's declared entity.
+static const char* rbac_entity_name(Context* ctx) {
+  if (ctx->entity) return ctx->entity->vt->get_name(ctx->entity);
+  return ctx->op->entity;
+}
+
+// Look up the required permission for this operation. Returns true and fills
+// `out` when a rule matches (checking `<entity>.<op>`, `<op>`, then `*`).
+static bool rbac_required(RbacFeature* rf, Context* ctx, char* out, size_t outsz) {
+  voxgig_value* rules = fopt_map(rf->options, "rules");
+  if (!voxgig_is_map(rules)) return false;
+
+  const char* entity = rbac_entity_name(ctx);
+  const char* opname = ctx->op->name;
+
+  char k0[512];
+  snprintf(k0, sizeof(k0), "%s.%s", entity, opname);
+  const char* keys[3] = {k0, opname, "*"};
+  for (int i = 0; i < 3; i++) {
+    const char* r = get_str(rules, keys[i]);
+    if (r) {
+      snprintf(out, outsz, "%s", r);
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool rbac_granted_has(RbacFeature* rf, const char* key) {
+  voxgig_value* v = getp(rf->granted, key);
+  return voxgig_is_bool(v) && voxgig_as_bool(v);
+}
+
+static void rbac_track(RbacFeature* rf, Context* ctx, const char* required, bool allowed) {
+  if (allowed) {
+    rf->allowed += 1;
+  } else {
+    rf->denied += 1;
+  }
+  const char* opname = ctx->op->name;
+  voxgig_value* last = v_map();
+  setp(last, "required", v_str(required));
+  setp(last, "allowed", v_bool(allowed));
+  setp(last, "op", v_str(opname));
+  rf->last = last;
+}
+
+static void rbac_reject(RbacFeature* rf, Context* ctx, const char* required) {
+  rbac_track(rf, ctx, required, false);
+
+  const char* opname = ctx->op->name;
+  if (opname[0] == '\0') opname = "?";
+
+  char msg[640];
+  snprintf(msg, sizeof(msg), "Permission \"%s\" required for operation \"%s\"", required,
+           opname);
+  PNError* err = context_make_error(ctx, "rbac_denied", msg);
+
+  // Short-circuit endpoint resolution; make_point surfaces this error before
+  // any network activity.
+  ctx_out_set_point_err(ctx, err);
+}
+
+static void rbac_pre_point(RbacFeature* rf, Context* ctx) {
+  if (!rf->active) return;
+
+  char required[512];
+  if (!rbac_required(rf, ctx, required, sizeof(required))) {
+    // No rule: honour the default policy.
+    if (fopt_bool(rf->options, "deny", false)) {
+      rbac_reject(rf, ctx, "<default-deny>");
+    }
+    return;
+  }
+
+  if (rbac_granted_has(rf, "*") || rbac_granted_has(rf, required)) {
+    rbac_track(rf, ctx, required, true);
+    return;
+  }
+
+  rbac_reject(rf, ctx, required);
+}
+
+static const char* rbac_name(Feature* f) { return ((RbacFeature*)f)->name; }
+static bool rbac_active(Feature* f) { return ((RbacFeature*)f)->active; }
+static voxgig_value* rbac_add_options(Feature* f) { return ((RbacFeature*)f)->add_opts; }
+
+static void rbac_init(Feature* f, Context* ctx, voxgig_value* options) {
+  (void)ctx;
+  RbacFeature* rf = (RbacFeature*)f;
+  rf->options = options;
+  rf->active = fopt_bool(options, "active", false);
+
+  rf->granted = v_map();
+  voxgig_value* perms = fopt_list(options, "permissions");
+  if (voxgig_is_list(perms)) {
+    voxgig_list* l = voxgig_as_list(perms);
+    for (size_t i = 0; i < l->len; i++) {
+      if (voxgig_is_string(l->items[i])) {
+        setp(rf->granted, voxgig_as_string(l->items[i]), v_bool(true));
+      }
+    }
+  }
+}
+
+static void rbac_hook(Feature* f, const char* name, Context* ctx) {
+  RbacFeature* rf = (RbacFeature*)f;
+  if (strcmp(name, "PrePoint") == 0) {
+    rbac_pre_point(rf, ctx);
+  }
+}
+
+static voxgig_value* rbac_track_snapshot(Feature* f) {
+  RbacFeature* rf = (RbacFeature*)f;
+  return cmap(2, "allowed", v_num((double)rf->allowed),
+              "denied", v_num((double)rf->denied));
+}
+
+static const FeatureVT RBAC_VT = {
+  rbac_name, rbac_active, rbac_add_options, rbac_init, rbac_hook,
+  rbac_track_snapshot,
+};
+
+Feature* feature_rbac_new(void) {
+  RbacFeature* rf = (RbacFeature*)calloc(1, sizeof(RbacFeature));
+  rf->base.vt = &RBAC_VT;
+  rf->name = strdup("rbac");
+  rf->active = true; // matches rust new() (overridden by init from options)
+  rf->add_opts = NULL;
+  rf->options = voxgig_new_undef();
+  rf->granted = voxgig_new_map();
+  rf->allowed = 0;
+  rf->denied = 0;
+  rf->last = voxgig_new_undef();
+  return (Feature*)rf;
+}

package/project/.sdk/tm/c/feature/retry.c

@@ -0,0 +1,164 @@
+// Automatic retry with exponential backoff + jitter (mirrors feature/
+// retry.rs). Wraps the active transport in init; a Retry-After header
+// overrides the computed backoff. All features inactive by default.
+
+#include "sdk.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+  int64_t attempts;
+  voxgig_value* retries; // List of attempt records
+} RetryTrack;
+
+typedef struct {
+  Feature base;
+  char* name;
+  bool active;
+  voxgig_value* add_opts;
+  voxgig_value* options;
+  RetryTrack* track;
+} RetryFeature;
+
+typedef struct {
+  Fetcher* inner;
+  voxgig_value* options;
+  RetryTrack* track;
+} RetryState;
+
+static bool retryable(voxgig_value* options, voxgig_value* out, PNError* e) {
+  if (e) return true;
+  if (v_is_noval(out) || v_is_null(out)) return true;
+  int64_t status;
+  if (!fres_status(out, &status)) return false;
+
+  voxgig_value* sl = fopt_list(options, "statuses");
+  if (voxgig_is_list(sl)) {
+    voxgig_list* l = voxgig_as_list(sl);
+    for (size_t i = 0; i < l->len; i++) {
+      if (voxgig_is_number(l->items[i]) && to_int(l->items[i]) == status) return true;
+    }
+    return false;
+  }
+  static const int64_t DEF[] = {408, 425, 429, 500, 502, 503, 504};
+  for (size_t i = 0; i < sizeof(DEF) / sizeof(DEF[0]); i++) {
+    if (DEF[i] == status) return true;
+  }
+  return false;
+}
+
+static bool retry_after(voxgig_value* res, int64_t* out) {
+  const char* v = fres_header(res, "retry-after");
+  if (!v) return false;
+  int64_t seconds = fparse_int(v, -1);
+  if (seconds < 0) return false;
+  *out = seconds * 1000;
+  return true;
+}
+
+static int64_t backoff(voxgig_value* options, voxgig_value* out, PNError* e, int64_t attempt,
+                       int64_t min_delay, int64_t max_delay, double factor) {
+  if (!e) {
+    int64_t ra;
+    if (retry_after(out, &ra)) {
+      return ra < max_delay ? ra : max_delay;
+    }
+  }
+  double base = (double)min_delay * pow(factor, (double)attempt);
+  int64_t jitter = (fopt_bool(options, "jitter", true) && min_delay > 0) ? rand_int(min_delay) : 0;
+  int64_t wait = (int64_t)base + jitter;
+  return wait < max_delay ? wait : max_delay;
+}
+
+static void track_attempt(RetryTrack* track, int64_t attempt, voxgig_value* out, PNError* e,
+                          int64_t wait) {
+  track->attempts += 1;
+  voxgig_value* entry = voxgig_new_map();
+  setp(entry, "attempt", v_num((double)attempt));
+  setp(entry, "wait", v_num((double)wait));
+  if (!e) {
+    int64_t status;
+    if (fres_status(out, &status)) setp(entry, "status", v_num((double)status));
+  } else {
+    setp(entry, "error", v_str(e->msg));
+  }
+  voxgig_list_push(voxgig_as_list(track->retries), entry);
+}
+
+static voxgig_value* retry_fetch(Fetcher* self, Context* ctx, const char* url,
+                                 voxgig_value* fetchdef, PNError** err) {
+  RetryState* st = (RetryState*)self->state;
+  voxgig_value* options = st->options;
+
+  int64_t max = fopt_int(options, "retries", 2);
+  int64_t min_delay = fopt_int(options, "minDelay", 50);
+  int64_t max_delay = fopt_int(options, "maxDelay", 2000);
+  double factor = fopt_num(options, "factor", 2.0);
+
+  int64_t attempt = 0;
+  while (1) {
+    PNError* e = NULL;
+    voxgig_value* out = st->inner->fn(st->inner, ctx, url, fetchdef, &e);
+
+    if (!retryable(options, out, e) || attempt >= max) {
+      *err = e;
+      return out;
+    }
+
+    int64_t wait = backoff(options, out, e, attempt, min_delay, max_delay, factor);
+    track_attempt(st->track, attempt + 1, out, e, wait);
+    if (wait > 0) fopt_sleep_call(options, wait);
+    attempt++;
+  }
+}
+
+static const char* retry_name(Feature* f) { return ((RetryFeature*)f)->name; }
+static bool retry_active(Feature* f) { return ((RetryFeature*)f)->active; }
+static voxgig_value* retry_add_options(Feature* f) { return ((RetryFeature*)f)->add_opts; }
+
+static void retry_init(Feature* f, Context* ctx, voxgig_value* options) {
+  RetryFeature* rf = (RetryFeature*)f;
+  rf->options = options;
+  rf->active = fopt_bool(options, "active", false);
+  if (!rf->active) return;
+
+  Utility* util = context_util(ctx);
+  RetryState* st = (RetryState*)calloc(1, sizeof(RetryState));
+  st->inner = util->fetcher;
+  st->options = options;
+  st->track = rf->track;
+
+  Fetcher* wrapped = (Fetcher*)calloc(1, sizeof(Fetcher));
+  wrapped->fn = retry_fetch;
+  wrapped->state = st;
+  util->fetcher = wrapped;
+}
+
+static void retry_hook(Feature* f, const char* name, Context* ctx) {
+  (void)f; (void)name; (void)ctx;
+}
+
+static voxgig_value* retry_track(Feature* f) {
+  RetryTrack* t = ((RetryFeature*)f)->track;
+  return cmap(1, "attempts", v_num((double)t->attempts));
+}
+
+static const FeatureVT RETRY_VT = {
+  retry_name, retry_active, retry_add_options, retry_init, retry_hook,
+  retry_track,
+};
+
+Feature* feature_retry_new(void) {
+  RetryFeature* rf = (RetryFeature*)calloc(1, sizeof(RetryFeature));
+  rf->base.vt = &RETRY_VT;
+  rf->name = strdup("retry");
+  rf->active = true; // matches rust default (overridden by init from options)
+  rf->add_opts = NULL;
+  rf->options = voxgig_new_undef();
+  rf->track = (RetryTrack*)calloc(1, sizeof(RetryTrack));
+  rf->track->attempts = 0;
+  rf->track->retries = voxgig_new_list();
+  return (Feature*)rf;
+}

package/project/.sdk/tm/c/feature/streaming.c

@@ -0,0 +1,147 @@
+// Streaming result support (mirrors feature/streaming.rs, a synchronous
+// runtime). For list-style operations it attaches a `result.stream` producer
+// so callers can consume items incrementally instead of materialising the
+// whole list themselves. A `chunkSize` groups items into list batches when
+// set; a `chunkDelay` (ms) paces delivery via the injectable `sleep` for
+// offline tests.
+
+#include "sdk.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+  Feature base;
+  char* name;
+  bool active;
+  voxgig_value* add_opts;
+  voxgig_value* options;
+
+  // Activity tracking (mirrors the ts client._streaming record).
+  int64_t opened;
+} StreamingFeature;
+
+// Heap ud for the stream producer closure: captures the options and the
+// result whose resdata is read lazily on each call. The rust version uses a
+// Weak reference to avoid an Rc cycle; C is never-free, so we hold the
+// SdkResult pointer directly (leaks are acceptable).
+typedef struct {
+  voxgig_value* options;
+  SdkResult* result;
+} StreamUd;
+
+// True when opname is in the configured "ops" list (default ["list"]).
+static bool streamable_op(voxgig_value* options, const char* opname) {
+  voxgig_value* ops = fopt_list(options, "ops");
+  if (voxgig_is_list(ops)) {
+    voxgig_list* l = voxgig_as_list(ops);
+    for (size_t i = 0; i < l->len; i++) {
+      voxgig_value* v = l->items[i];
+      if (voxgig_is_string(v) && strcmp(voxgig_as_string(v), opname) == 0) return true;
+    }
+    return false;
+  }
+  return strcmp(opname, "list") == 0;
+}
+
+// Produce the (possibly chunked, possibly paced) list of items from resdata.
+static voxgig_value* iterate(voxgig_value* options, voxgig_value* resdata) {
+  int64_t chunk_delay = fopt_int(options, "chunkDelay", 0);
+  int64_t chunk_size = fopt_int(options, "chunkSize", 0);
+
+  voxgig_list* items = NULL;
+  size_t nitems = 0;
+  if (voxgig_is_list(resdata)) {
+    items = voxgig_as_list(resdata);
+    nitems = items->len;
+  }
+
+  voxgig_value* out = voxgig_new_list();
+
+  if (chunk_size > 0) {
+    size_t i = 0;
+    while (i < nitems) {
+      if (chunk_delay > 0) fopt_sleep_call(options, chunk_delay);
+      size_t end = i + (size_t)chunk_size;
+      if (end > nitems) end = nitems;
+      voxgig_value* chunk = voxgig_new_list();
+      for (size_t j = i; j < end; j++) {
+        voxgig_list_push(voxgig_as_list(chunk), voxgig_retain(items->items[j]));
+      }
+      voxgig_list_push(voxgig_as_list(out), chunk);
+      i = end;
+    }
+    return out;
+  }
+
+  for (size_t i = 0; i < nitems; i++) {
+    if (chunk_delay > 0) fopt_sleep_call(options, chunk_delay);
+    voxgig_list_push(voxgig_as_list(out), voxgig_retain(items->items[i]));
+  }
+  return out;
+}
+
+// The stream producer attached to the result (StreamFn). Reads resdata at
+// call time, mirroring the rust closure that upgrades the weak result then
+// reads `resdata`.
+static voxgig_value* streaming_stream(void* ud) {
+  StreamUd* s = (StreamUd*)ud;
+  voxgig_value* resdata = s->result->resdata;
+  return iterate(s->options, resdata);
+}
+
+static const char* streaming_name(Feature* f) { return ((StreamingFeature*)f)->name; }
+static bool streaming_active(Feature* f) { return ((StreamingFeature*)f)->active; }
+static voxgig_value* streaming_add_options(Feature* f) {
+  return ((StreamingFeature*)f)->add_opts;
+}
+
+static void streaming_init(Feature* f, Context* ctx, voxgig_value* options) {
+  (void)ctx;
+  StreamingFeature* sf = (StreamingFeature*)f;
+  sf->options = options;
+  sf->active = fopt_bool(options, "active", false);
+}
+
+static void streaming_pre_result(StreamingFeature* sf, Context* ctx) {
+  if (!sf->active || !streamable_op(sf->options, ctx->op->name)) return;
+  if (!ctx->result) return;
+
+  StreamUd* ud = (StreamUd*)calloc(1, sizeof(StreamUd));
+  ud->options = sf->options;
+  ud->result = ctx->result;
+
+  ctx->result->streaming = true;
+  ctx->result->stream = streaming_stream;
+  ctx->result->stream_ud = ud;
+
+  sf->opened += 1;
+}
+
+static void streaming_hook(Feature* f, const char* name, Context* ctx) {
+  StreamingFeature* sf = (StreamingFeature*)f;
+  if (strcmp(name, "PreResult") == 0) {
+    streaming_pre_result(sf, ctx);
+  }
+}
+
+static voxgig_value* streaming_track(Feature* f) {
+  StreamingFeature* sf = (StreamingFeature*)f;
+  return cmap(1, "opened", v_num((double)sf->opened));
+}
+
+static const FeatureVT STREAMING_VT = {
+  streaming_name, streaming_active, streaming_add_options, streaming_init, streaming_hook,
+  streaming_track,
+};
+
+Feature* feature_streaming_new(void) {
+  StreamingFeature* sf = (StreamingFeature*)calloc(1, sizeof(StreamingFeature));
+  sf->base.vt = &STREAMING_VT;
+  sf->name = strdup("streaming");
+  sf->active = true; // matches rust new() (overridden by init from options)
+  sf->add_opts = NULL;
+  sf->options = voxgig_new_undef();
+  sf->opened = 0;
+  return (Feature*)sf;
+}