@voxgig/sdkgen 1.3.8 → 1.3.9

package/project/.sdk/tm/cpp/feature/idempotency.hpp

@@ -0,0 +1,119 @@
+// ProjectName SDK — idempotency feature (mirrors java feature/IdempotencyFeature.java).
+// Idempotency keys for mutating operations. Adds an `Idempotency-Key` header
+// (name configurable via `header`) to unsafe requests so a server can
+// de-duplicate retried writes. The key is set once, at PreRequest, before the
+// request is built. A caller-supplied header is never overwritten
+// (case-insensitive). The key generator is injectable (`keygen`).
+
+#ifndef SDK_FEATURE_IDEMPOTENCY_HPP
+#define SDK_FEATURE_IDEMPOTENCY_HPP
+
+#include <cctype>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+#include "../core/types.hpp"
+#include "base.hpp"
+#include "options.hpp"
+
+namespace sdk {
+
+class IdempotencyFeature : public BaseFeature {
+public:
+  SdkClient* client = nullptr;
+  Value options = Value::undef();
+  long long kseed = 1;
+
+  // Activity tracking (mirrors the ts client._idempotency record).
+  int issued = 0;
+  std::string last = "";
+
+  IdempotencyFeature() : BaseFeature("idempotency", "0.0.1", true) {}
+
+  void init(CtxPtr ctx, const Value& options_) override {
+    client = ctx->client;
+    options = options_;
+    active = fopt::foptBool(options, "active", false);
+  }
+
+  void preRequest(CtxPtr ctx) override {
+    if (!active) return;
+
+    SpecPtr spec = ctx->spec;
+    if (!spec) return;
+
+    if (!mutating(ctx)) return;
+
+    std::string header = fopt::foptStr(options, "header", "Idempotency-Key");
+    if (!spec->headers.is_map()) spec->headers = vmap();
+
+    // Respect a key the caller already provided.
+    if (fopt::fheaderHas(spec->headers, header)) return;
+
+    std::string key = genkey();
+    map_put(spec->headers, header, Value(key));
+
+    issued++;
+    last = key;
+  }
+
+private:
+  static std::string upper(std::string s) {
+    for (auto& c : s) c = static_cast<char>(std::toupper((unsigned char)c));
+    return s;
+  }
+
+  bool mutating(CtxPtr ctx) {
+    std::vector<std::string> methods = fopt::foptStrList(options, "methods");
+    if (!fopt::foptList(options, "methods").is_list()) {
+      methods = {"POST", "PUT", "PATCH", "DELETE"};
+    }
+    std::string method = "";
+    if (ctx->spec) method = upper(ctx->spec->method);
+    if (!method.empty()) {
+      for (const auto& m : methods) {
+        if (upper(m) == method) return true;
+      }
+    }
+
+    std::string opname = "";
+    if (ctx->op) opname = ctx->op->name;
+    std::vector<std::string> ops = fopt::foptStrList(options, "ops");
+    if (!fopt::foptList(options, "ops").is_list()) {
+      ops = {"create", "update", "remove"};
+    }
+    for (const auto& o : ops) {
+      if (o == opname) return true;
+    }
+    return false;
+  }
+
+  unsigned long long nextRand() {
+    kseed = (kseed * 1103515245LL + 12345LL) & 0x7fffffffLL;
+    return (unsigned long long) kseed;
+  }
+
+  std::string genkey() {
+    Value kg = getp(options, "keygen");
+    if (kg.is_injector()) {
+      vs::Injection inj(Value::undef(), Value::undef());
+      Value r = kg.as_injector()(inj, vlist(), std::string(""), Value::undef());
+      return r.is_string() ? r.as_string() : Struct::stringify(r);
+    }
+
+    unsigned a = (unsigned)(nextRand() % 0x1000000);
+    unsigned b = (unsigned)(nextRand() % 0x1000000);
+    unsigned c = (unsigned)(nextRand() % 0x1000000);
+    unsigned d = (unsigned)(nextRand() % 0x1000000);
+    char buf[64];
+    std::snprintf(buf, sizeof(buf), "%06x%06x%06x%06x", a, b, c, d);
+    std::string key(buf);
+    if (key.size() > 24) key = key.substr(0, 24);
+    return key;
+  }
+};
+
+} // namespace sdk
+
+#endif // SDK_FEATURE_IDEMPOTENCY_HPP

package/project/.sdk/tm/cpp/feature/log.hpp

@@ -0,0 +1,90 @@
+// ProjectName SDK — log feature (mirrors java feature/LogFeature.java).
+// Hook logging. The java donor uses java.util.logging; the C++ target has no
+// such facility, so this emits the same "hook=… op=… spec=…" lines to
+// std::cerr, gated by a level threshold. Active by default (like the java
+// donor: the constructor sets active=true and init only overrides it when
+// options.active is an explicit boolean).
+
+#ifndef SDK_FEATURE_LOG_HPP
+#define SDK_FEATURE_LOG_HPP
+
+#include <iostream>
+#include <string>
+
+#include "../core/types.hpp"
+#include "base.hpp"
+#include "options.hpp"
+
+namespace sdk {
+
+class LogFeature : public BaseFeature {
+public:
+  SdkClient* client = nullptr;
+  Value options = Value::undef();
+  bool hasLogger = false;
+  // java.util.logging levels: FINE=500, INFO=800, WARNING=900, SEVERE=1000.
+  int levelThreshold = 800;
+
+  LogFeature() : BaseFeature("log", "0.0.1", true) {}
+
+  void init(CtxPtr ctx, const Value& options_) override {
+    client = ctx->client;
+    options = options_;
+
+    Value a = getp(options, "active");
+    if (a.is_bool()) active = a.as_bool();
+
+    if (active) {
+      hasLogger = true;
+      Value lvl = getp(options, "level");
+      if (lvl.is_string()) {
+        std::string s = lvl.as_string();
+        if (s == "debug") levelThreshold = 500;
+        else if (s == "warn") levelThreshold = 900;
+        else if (s == "error") levelThreshold = 1000;
+        else levelThreshold = 800;
+      } else {
+        levelThreshold = 800;
+      }
+    }
+  }
+
+  void postConstruct(CtxPtr ctx) override { loghook("PostConstruct", ctx, ""); }
+  void postConstructEntity(CtxPtr ctx) override { loghook("PostConstructEntity", ctx, ""); }
+  void setData(CtxPtr ctx) override { loghook("SetData", ctx, ""); }
+  void getData(CtxPtr ctx) override { loghook("GetData", ctx, ""); }
+  void setMatch(CtxPtr ctx) override { loghook("SetMatch", ctx, ""); }
+  void getMatch(CtxPtr ctx) override { loghook("GetMatch", ctx, ""); }
+  void prePoint(CtxPtr ctx) override { loghook("PrePoint", ctx, ""); }
+  void preSpec(CtxPtr ctx) override { loghook("PreSpec", ctx, ""); }
+  void preRequest(CtxPtr ctx) override { loghook("PreRequest", ctx, ""); }
+  void preResponse(CtxPtr ctx) override { loghook("PreResponse", ctx, ""); }
+  void preResult(CtxPtr ctx) override { loghook("PreResult", ctx, ""); }
+
+private:
+  void loghook(const std::string& hook, CtxPtr ctx, std::string level) {
+    if (!hasLogger) return;
+
+    if (level.empty()) level = "info";
+
+    std::string msg = "hook=" + hook;
+    if (ctx->op) msg += " op=" + ctx->op->name;
+    if (ctx->spec) msg += " spec=" + ctx->spec->method + " " + ctx->spec->path;
+
+    // The per-call level (always "info" here) is emitted iff it clears the
+    // configured threshold (mirrors Logger.info() vs Logger.setLevel()).
+    int callLevel = 800;
+    std::string tag = "INFO";
+    if (level == "debug") { callLevel = 500; tag = "FINE"; }
+    else if (level == "warn") { callLevel = 900; tag = "WARNING"; }
+    else if (level == "error") { callLevel = 1000; tag = "SEVERE"; }
+
+    if (callLevel >= levelThreshold) {
+      std::cerr << "ProjectNameSDK.log " << tag << ": " << msg << "\n";
+    }
+  }
+};
+
+} // namespace sdk
+
+#endif // SDK_FEATURE_LOG_HPP

package/project/.sdk/tm/cpp/feature/metrics.hpp

@@ -0,0 +1,103 @@
+// ProjectName SDK — metrics feature (mirrors java feature/MetricsFeature.java).
+// Statistics capture. Records per-operation counters and latency for every
+// call: totals plus a breakdown keyed by `<entity>.<op>`. Timing starts at
+// endpoint resolution (PrePoint) and stops when the call returns (PreDone) or
+// fails (PreUnexpected); each operation is recorded exactly once (the
+// per-context start marker — java ctx.out — is kept here keyed by ctx.id).
+// The clock is injectable (`now`).
+
+#ifndef SDK_FEATURE_METRICS_HPP
+#define SDK_FEATURE_METRICS_HPP
+
+#include <map>
+#include <string>
+
+#include "../core/types.hpp"
+#include "base.hpp"
+#include "options.hpp"
+
+namespace sdk {
+
+class MetricsFeature : public BaseFeature {
+public:
+  struct MetricsBucket {
+    int count = 0;
+    int ok = 0;
+    int err = 0;
+    long long totalMs = 0;
+    long long maxMs = 0;
+  };
+
+  SdkClient* client = nullptr;
+  Value options = Value::undef();
+
+  // Aggregates (mirrors the ts client._metrics record).
+  MetricsBucket total;
+  std::map<std::string, MetricsBucket> ops;
+
+  MetricsFeature() : BaseFeature("metrics", "0.0.1", true) {}
+
+  void init(CtxPtr ctx, const Value& options_) override {
+    client = ctx->client;
+    options = options_;
+    active = fopt::foptBool(options, "active", false);
+
+    total = MetricsBucket();
+    ops.clear();
+  }
+
+  void prePoint(CtxPtr ctx) override {
+    if (!active) return;
+    starts[ctx->id] = fopt::foptNow(options)();
+  }
+
+  void preDone(CtxPtr ctx) override {
+    // Classify by the actual result: a 4xx/5xx that flows through still
+    // reaches PreDone before the pipeline errors.
+    record(ctx, ctx->result && ctx->result->ok && !ctx->result->err);
+  }
+
+  void preUnexpected(CtxPtr ctx) override {
+    record(ctx, false);
+  }
+
+private:
+  std::map<std::string, long long> starts;
+
+  void record(CtxPtr ctx, bool ok) {
+    // Record once per operation: the missing start marker makes a second
+    // call (PreDone followed by PreUnexpected on failure) a no-op.
+    auto it = starts.find(ctx->id);
+    if (it == starts.end()) return;
+    long long start = it->second;
+    starts.erase(it);
+
+    long long dur = fopt::foptNow(options)() - start;
+    if (dur < 0) dur = 0;
+
+    std::string entity = "_";
+    std::string opname = "_";
+    if (ctx->op) {
+      entity = ctx->op->entity;
+      opname = ctx->op->name;
+    }
+    std::string key = entity + "." + opname;
+
+    MetricsBucket& op = ops[key];
+
+    bump(total, ok, dur);
+    bump(op, ok, dur);
+  }
+
+  void bump(MetricsBucket& bucket, bool ok, long long dur) {
+    bucket.count++;
+    if (ok) bucket.ok++;
+    else bucket.err++;
+    bucket.totalMs += dur;
+    if (dur > bucket.maxMs) bucket.maxMs = dur;
+  }
+};
+
+} // namespace sdk
+
+#endif // SDK_FEATURE_METRICS_HPP

package/project/.sdk/tm/cpp/feature/netsim.hpp

@@ -0,0 +1,152 @@
+// ProjectName SDK — netsim feature (mirrors java feature/NetsimFeature.java).
+// Wraps the active transport and injects deterministic network conditions
+// (latency, transient failures, rate limits, outages). Counter-driven per
+// client; `failRate` uses a seeded LCG.
+
+#ifndef SDK_FEATURE_NETSIM_HPP
+#define SDK_FEATURE_NETSIM_HPP
+
+#include <string>
+
+#include "../core/types.hpp"
+#include "base.hpp"
+#include "options.hpp"
+
+namespace sdk {
+
+class NetsimFeature : public BaseFeature {
+public:
+  SdkClient* client = nullptr;
+  Value options = Value::undef();
+  long long seed = 1;
+
+  int calls = 0;
+  Value applied = vlist();
+
+  NetsimFeature() : BaseFeature("netsim", "0.0.1", true) {}
+
+  void init(CtxPtr ctx, const Value& options_) override {
+    client = ctx->client;
+    options = options_;
+    active = fopt::foptBool(options, "active", false);
+
+    seed = fopt::foptInt(options, "seed", 0);
+    if (seed == 0) seed = 1;
+
+    if (!active) return;
+
+    auto inner = ctx->utility->fetcher;
+    ctx->utility->fetcher = [this, inner](CtxPtr ctx2, const std::string& url,
+                                          const Value& fetchdef) -> Value {
+      return simulate(ctx2, url, fetchdef, inner);
+    };
+  }
+
+private:
+  Value simulate(CtxPtr ctx, const std::string& url, const Value& fetchdef,
+                 std::function<Value(CtxPtr, const std::string&, const Value&)> inner) {
+    Value opts = options;
+    calls++;
+    int call = calls;
+
+    Value appliedRec = vmap();
+
+    if (fopt::foptBool(opts, "offline", false)) {
+      sleep(pickLatency());
+      map_put(appliedRec, "offline", Value(true));
+      track(ctx, appliedRec);
+      throw ctx->makeError("netsim_offline", "Simulated network offline (URL was: \"" + url + "\")");
+    }
+
+    if (call <= fopt::foptInt(opts, "errorTimes", 0)) {
+      sleep(pickLatency());
+      map_put(appliedRec, "error", Value(true));
+      track(ctx, appliedRec);
+      throw ctx->makeError("netsim_conn", "Simulated connection error (call " + std::to_string(call) + ")");
+    }
+
+    if (call <= fopt::foptInt(opts, "rateLimitTimes", 0)) {
+      sleep(pickLatency());
+      map_put(appliedRec, "rateLimited", Value(true));
+      track(ctx, appliedRec);
+      Value extra = vmap();
+      map_put(extra, "statusText", Value("Too Many Requests"));
+      Value headers = vmap();
+      map_put(headers, "retry-after", Value(std::to_string(fopt::foptInt(opts, "retryAfter", 0))));
+      map_put(extra, "headers", headers);
+      return respond(429, Value(nullptr), extra);
+    }
+
+    int failStatus = fopt::foptInt(opts, "failStatus", 503);
+    int failEvery = fopt::foptInt(opts, "failEvery", 0);
+    bool failByCount = call <= fopt::foptInt(opts, "failTimes", 0);
+    bool failByEvery = failEvery > 0 && call % failEvery == 0;
+    double failRate = fopt::foptNum(opts, "failRate", 0);
+    bool failByRate = failRate > 0 && rand01() < failRate;
+    if (failByCount || failByEvery || failByRate) {
+      sleep(pickLatency());
+      map_put(appliedRec, "failStatus", Value(failStatus));
+      track(ctx, appliedRec);
+      Value extra = vmap();
+      map_put(extra, "statusText", Value("Simulated Failure"));
+      return respond(failStatus, Value(nullptr), extra);
+    }
+
+    int latency = pickLatency();
+    map_put(appliedRec, "latency", Value(latency));
+    track(ctx, appliedRec);
+    sleep(latency);
+    return inner(ctx, url, fetchdef);
+  }
+
+  int pickLatency() {
+    Value l = getp(options, "latency");
+    if (is_nullish(l)) return 0;
+    if (l.is_map()) {
+      int mn = fopt::foptInt(l, "min", 0);
+      int mx = fopt::foptInt(l, "max", mn);
+      if (mx <= mn) return mn;
+      return mn + (int)(rand01() * (mx - mn));
+    }
+    int fixed = fopt::foptInt(options, "latency", 0);
+    return fixed < 0 ? 0 : fixed;
+  }
+
+  void sleep(int ms) {
+    if (ms <= 0) return;
+    fopt::foptSleep(options)(ms);
+  }
+
+  // Deterministic 0..1 pseudo-random via a linear congruential generator.
+  double rand01() {
+    seed = (seed * 1103515245LL + 12345LL) & 0x7fffffffLL;
+    return (double)seed / (double)0x7fffffffLL;
+  }
+
+  void track(CtxPtr ctx, const Value& appliedRec) {
+    applied.as_list()->push_back(appliedRec);
+    if (ctx->ctrl && ctx->ctrl->explain.is_map()) {
+      Value rec = vmap();
+      map_put(rec, "calls", Value(calls));
+      map_put(rec, "applied", applied);
+      map_put(ctx->ctrl->explain, "netsim", rec);
+    }
+  }
+
+  Value respond(int status, const Value& data, const Value& extra) {
+    Value out = vmap();
+    map_put(out, "status", Value(status));
+    map_put(out, "statusText", Value("OK"));
+    map_put(out, "json", json_thunk(data));
+    map_put(out, "body", Value("not-used"));
+    map_put(out, "headers", vmap());
+    if (extra.is_map()) {
+      for (const auto& kv : *extra.as_map()) map_put(out, kv.first, kv.second);
+    }
+    return out;
+  }
+};
+
+} // namespace sdk
+
+#endif // SDK_FEATURE_NETSIM_HPP

package/project/.sdk/tm/cpp/feature/options.hpp

@@ -0,0 +1,156 @@
+// ProjectName SDK — shared feature option readers (mirrors java
+// feature/FeatureOptions.java). Feature options arrive as struct Value
+// maps; injectable clocks (now/sleep) arrive as struct function Values so
+// tests can drive timing-based features deterministically.
+
+#ifndef SDK_FEATURE_OPTIONS_HPP
+#define SDK_FEATURE_OPTIONS_HPP
+
+#include <chrono>
+#include <functional>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "../core/types.hpp"
+
+namespace sdk {
+namespace fopt {
+
+inline bool foptBool(const Value& options, const std::string& key, bool def) {
+  Value v = getp(options, key);
+  return v.is_bool() ? v.as_bool() : def;
+}
+
+inline int foptInt(const Value& options, const std::string& key, int def) {
+  Value v = getp(options, key);
+  return v.is_number() ? static_cast<int>(v.as_int()) : def;
+}
+
+inline long long foptLong(const Value& options, const std::string& key, long long def) {
+  Value v = getp(options, key);
+  return v.is_number() ? static_cast<long long>(v.as_int()) : def;
+}
+
+inline double foptNum(const Value& options, const std::string& key, double def) {
+  Value v = getp(options, key);
+  return v.is_number() ? v.as_double() : def;
+}
+
+inline std::string foptStr(const Value& options, const std::string& key, const std::string& def) {
+  Value v = getp(options, key);
+  return (v.is_string() && !v.as_string().empty()) ? v.as_string() : def;
+}
+
+inline Value foptMap(const Value& options, const std::string& key) {
+  Value v = getp(options, key);
+  return v.is_map() ? v : Value::undef();
+}
+
+inline Value foptList(const Value& options, const std::string& key) {
+  Value v = getp(options, key);
+  return v.is_list() ? v : Value::undef();
+}
+
+inline std::vector<std::string> foptStrList(const Value& options, const std::string& key) {
+  std::vector<std::string> out;
+  Value raw = foptList(options, key);
+  if (raw.is_list()) {
+    for (const auto& v : *raw.as_list()) {
+      if (v.is_string()) out.push_back(v.as_string());
+    }
+  }
+  return out;
+}
+
+using SleepFn = std::function<void(int)>;
+using NowFn = std::function<long long()>;
+
+// The injectable sleep: option "sleep" is a struct func taking [ms].
+inline SleepFn foptSleep(const Value& options) {
+  Value v = getp(options, "sleep");
+  if (v.is_injector()) {
+    Value fn = v;
+    return [fn](int ms) {
+      vs::Injection inj(Value::undef(), Value::undef());
+      fn.as_injector()(inj, vlist({Value(ms)}), std::string(""), Value::undef());
+    };
+  }
+  return [](int ms) {
+    if (ms > 0) std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+  };
+}
+
+// The injectable clock: option "now" is a struct func returning ms.
+inline NowFn foptNow(const Value& options) {
+  Value v = getp(options, "now");
+  if (v.is_injector()) {
+    Value fn = v;
+    return [fn]() -> long long {
+      vs::Injection inj(Value::undef(), Value::undef());
+      Value r = fn.as_injector()(inj, vlist(), std::string(""), Value::undef());
+      return r.is_number() ? static_cast<long long>(r.as_int()) : 0;
+    };
+  }
+  return []() -> long long {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+               std::chrono::system_clock::now().time_since_epoch())
+        .count();
+  };
+}
+
+// Header helpers (case-insensitive), operating on struct Value maps.
+inline Value fheaderGet(const Value& headers, const std::string& name) {
+  if (!headers.is_map()) return Value::undef();
+  std::string lname = name;
+  for (auto& c : lname) c = static_cast<char>(std::tolower((unsigned char)c));
+  for (const auto& kv : *headers.as_map()) {
+    std::string k = kv.first;
+    for (auto& c : k) c = static_cast<char>(std::tolower((unsigned char)c));
+    if (k == lname) return kv.second;
+  }
+  return Value::undef();
+}
+
+inline bool fheaderHas(const Value& headers, const std::string& name) {
+  return !fheaderGet(headers, name).is_undef();
+}
+
+inline void fheaderSetDefault(const Value& headers, const std::string& name,
+                              const std::string& value) {
+  if (!headers.is_map()) return;
+  if (fheaderHas(headers, name)) return;
+  map_put(headers, name, Value(value));
+}
+
+inline int fresStatus(const Value& res) {
+  if (!res.is_map()) return -1;
+  Value s = getp(res, "status");
+  return s.is_number() ? static_cast<int>(s.as_int()) : -1;
+}
+
+inline std::string fresHeader(const Value& res, const std::string& name) {
+  if (!res.is_map()) return "";
+  Value headers = getp(res, "headers");
+  if (!headers.is_map()) return "";
+  Value v = fheaderGet(headers, name);
+  return v.is_string() ? v.as_string() : "";
+}
+
+inline int fparseInt(const std::string& s, int def) {
+  try {
+    size_t pos = 0;
+    std::string t = s;
+    size_t a = t.find_first_not_of(" \t");
+    if (a != std::string::npos) t = t.substr(a);
+    int r = std::stoi(t, &pos);
+    return r;
+  } catch (...) {
+    return def;
+  }
+}
+
+} // namespace fopt
+} // namespace sdk
+
+#endif // SDK_FEATURE_OPTIONS_HPP