@voxgig/sdkgen 1.5.1 → 2.0.0

package/project/.sdk/tm/clojure/src/sdk/features.clj

@@ -480,6 +480,29 @@
       (or (try (Long/parseLong s) (catch Exception _ nil))
           (try (Double/parseDouble s) (catch Exception _ nil))))))
 
+;; Relay pagination: the cursor is the `after` variable (or whatever the model
+;; named it), and the page size is `first`.
+(defn- graphql-pre-request [fa spec point paging]
+  (let [body (core/oget spec :body)]
+    (when (vs/ismap body)
+      (let [variables (let [v (mget body "variables")]
+                        (if (vs/ismap v)
+                          v
+                          (let [nv (vs/jm)] (.put ^java.util.Map body "variables" nv) nv)))
+            after-var (opt fa "afterVar" "after")
+            first-var (opt fa "firstVar" "first")
+            ;; Only bind variables the operation actually declares, or the
+            ;; server rejects the document.
+            declared (let [vl (vs/getpath point "graphql.vars")]
+                       (if (vs/islist vl)
+                         (into #{} (keep #(vs/getprop % "name") (vec vl)))
+                         #{}))]
+        (when (and (some? (mget paging "cursor")) (declared after-var))
+          (.put ^java.util.Map variables after-var (mget paging "cursor")))
+        (when (and (some? (opt fa "limit")) (nil? (mget variables first-var))
+                   (declared first-var))
+          (.put ^java.util.Map variables first-var (opt fa "limit")))))))
+
 (defn paging-feature []
   (let [fa (new-feature "paging" false "0.0.1")
         list? (fn [ctx] (let [ops (or (opt fa "ops") (vs/jt "list"))
@@ -501,12 +524,19 @@
                          cursor-param (opt fa "cursorParam" "cursor")
                          ctrl (core/oget ctx :ctrl)
                          paging (let [p (when ctrl (core/oget ctrl :paging))] (if (vs/ismap p) p (vs/jm)))]
-                     (cond
-                       (some? (mget paging "cursor")) (.put ^java.util.Map q cursor-param (mget paging "cursor"))
-                       (nil? (mget q page-param))
-                       (.put ^java.util.Map q page-param (if (nil? (mget paging "page")) (opt fa "startPage" 1) (mget paging "page"))))
-                     (when (and (some? (opt fa "limit")) (nil? (mget q limit-param)))
-                       (.put ^java.util.Map q limit-param (opt fa "limit"))))))))
+                     ;; GraphQL paginates through operation VARIABLES, not
+                     ;; the query string. This hook runs after make-spec, so
+                     ;; spec.body already holds the { query, variables }
+                     ;; envelope, and before make-fetch-def serialises it.
+                     (if (= "graphql" (vs/getprop (core/oget ctx :point) "kind"))
+                       (graphql-pre-request fa spec (core/oget ctx :point) paging)
+                       (do
+                         (cond
+                           (some? (mget paging "cursor")) (.put ^java.util.Map q cursor-param (mget paging "cursor"))
+                           (nil? (mget q page-param))
+                           (.put ^java.util.Map q page-param (if (nil? (mget paging "page")) (opt fa "startPage" 1) (mget paging "page"))))
+                         (when (and (some? (opt fa "limit")) (nil? (mget q limit-param)))
+                           (.put ^java.util.Map q limit-param (opt fa "limit"))))))))))
            "PreResult"
            (fn [ctx]
              (when (and (active? fa) (list? ctx))
@@ -522,14 +552,50 @@
                      (when (some? link)
                        (when-let [m (re-find #"(?i)<([^>]+)>\s*;\s*rel=\"?next\"?" (str link))]
                          (.put ^java.util.Map paging "next" (nth m 1))))
-                     (when (vs/ismap body)
-                       (when (some? (mget body "next")) (when (nil? (mget paging "next")) (.put ^java.util.Map paging "next" (mget body "next"))))
-                       (when (some? (mget body "cursor")) (.put ^java.util.Map paging "cursor" (mget body "cursor")))
-                       (when (some? (mget body "nextCursor")) (.put ^java.util.Map paging "cursor" (mget body "nextCursor")))
-                       (let [hm (mget body "hasMore")] (when (or (= hm true) (= hm false)) (.put ^java.util.Map paging "hasMore" hm))))
-                     (.put ^java.util.Map paging "hasMore"
-                           (boolean (or (mget paging "hasMore") (some? (mget paging "next"))
-                                        (some? (mget paging "cursor")) (some? (mget paging "nextPage")))))
+                     ;; Set when the response states hasMore outright, rather
+                     ;; than leaving it to be inferred from a cursor.
+                     (let [explicit-more (atom false)
+                           point (core/oget ctx :point)
+                           page (vs/getpath point "graphql.page")]
+                       ;; Relay connections carry the cursor in pageInfo, at
+                       ;; the path the model recorded for this op.
+                       (when (and (vs/ismap page) (vs/ismap body))
+                         ;; `connpath` locates the connection object inside the
+                         ;; response envelope (data.<field>); the cursor/more
+                         ;; paths are relative to it.
+                         (let [connpath (mget page "connpath")
+                               conn (if (and (string? connpath) (seq connpath))
+                                      (or (vs/getpath body connpath) body)
+                                      body)
+                               cursorpath (mget page "cursor")
+                               morepath (mget page "more")]
+                           (when (and (string? cursorpath) (seq cursorpath))
+                             (when-let [c (vs/getpath conn cursorpath)]
+                               (.put ^java.util.Map paging "cursor" c)))
+                           (when (and (string? morepath) (seq morepath))
+                             (let [more (vs/getpath conn morepath)]
+                               (when (or (= more true) (= more false))
+                                 (.put ^java.util.Map paging "hasMore" more)
+                                 (reset! explicit-more true))))))
+                       (when (vs/ismap body)
+                         (when (some? (mget body "next")) (when (nil? (mget paging "next")) (.put ^java.util.Map paging "next" (mget body "next"))))
+                         (when (some? (mget body "cursor")) (.put ^java.util.Map paging "cursor" (mget body "cursor")))
+                         (when (some? (mget body "nextCursor")) (.put ^java.util.Map paging "cursor" (mget body "nextCursor")))
+                         (let [hm (mget body "hasMore")]
+                           (when (or (= hm true) (= hm false))
+                             (.put ^java.util.Map paging "hasMore" hm)
+                             (reset! explicit-more true))))
+                       ;; Cursor presence only INFERS another page. When the
+                       ;; server stated the answer outright — relay's
+                       ;; `hasNextPage: false`, or a body `hasMore` — that
+                       ;; wins: a final page normally carries both an end
+                       ;; cursor and hasNextPage false, and inferring from the
+                       ;; cursor there would send the caller back for a page
+                       ;; that does not exist, forever.
+                       (when-not @explicit-more
+                         (.put ^java.util.Map paging "hasMore"
+                               (boolean (or (mget paging "hasMore") (some? (mget paging "next"))
+                                            (some? (mget paging "cursor")) (some? (mget paging "nextPage")))))))
                      (core/oset! result :paging paging)
                      (track-set! fa "_paging" (vs/jm "last" paging)))))))
            )

package/project/.sdk/tm/cpp/core/types.hpp

@@ -560,6 +560,15 @@ public:
 
   Value prepare(const Value& fetchargs);
   Value direct(const Value& fetchargs);
+  Value graphql(const std::string& query, const Value& variables = Value::undef(),
+                const Value& ctrl = Value::undef());
+
+private:
+  bool opAllowed(const std::string& op);
+  Value opDenied(const std::string& op);
+  Value rawRequest(const Value& fetchargs);
+
+public:
 
   static Value testOptions(const Value& testopts, const Value& sdkopts);
 };
@@ -868,7 +877,81 @@ inline Value SdkClient::prepare(const Value& fetchargs_) {
   return u->makeFetchDef(ctx);
 }
 
+// Is this raw-access op permitted by the SDK's allow.op option?
+inline bool SdkClient::opAllowed(const std::string& op) {
+  Value allow = Struct::getpath(options, {"allow", "op"});
+  if (!allow.is_string()) return false;
+  return std::string::npos != allow.as_string().find(op);
+}
+
+inline Value SdkClient::opDenied(const std::string& op) {
+  Value allow = Struct::getpath(options, {"allow", "op"});
+  std::string a = allow.is_string() ? allow.as_string() : "";
+  Value out = vmap();
+  map_put(out, "ok", Value(false));
+  map_put(out, "err", vmap({{"message", Value(
+    "ProjectNameSDK: " + op + ": operation not allowed by"
+    " SDK option allow.op value: \"" + a + "\"")}}));
+  return out;
+}
+
+// Raw endpoint access is operator-controllable, like every entity op.
+// Blocking it means denying BOTH the 'direct' and 'graphql' tokens, since
+// either one reaches the same endpoint.
 inline Value SdkClient::direct(const Value& fetchargs_) {
+  if (!opAllowed("direct")) return opDenied("direct");
+  return rawRequest(fetchargs_);
+}
+
+// Raw GraphQL access: the pressure valve that makes the generated surface's
+// deliberate omissions (per-call selection sets, typed filter builders,
+// batching, subscriptions) livable — the whole schema stays reachable.
+//
+// Thin wrapper over the same prepare/fetch path direct uses, with the one
+// thing raw direct cannot do for GraphQL: a GraphQL failure rides HTTP 200 as
+// a top-level `errors` array, so status alone would report a failed query as
+// ok.
+//
+// NOTE: like direct, this bypasses the feature pipeline — no retry, ratelimit
+// or paging features apply.
+inline Value SdkClient::graphql(const std::string& query, const Value& variables,
+                                const Value& ctrl) {
+  if (!opAllowed("graphql")) return opDenied("graphql");
+
+  Value res = rawRequest(vmap({
+    {"method", Value(std::string("POST"))},
+    {"headers", vmap({{"content-type", Value(std::string("application/json"))}})},
+    {"body", vmap({
+      {"query", Value(query)},
+      {"variables", variables.is_map() ? variables : vmap()}})},
+    {"ctrl", ctrl.is_map() ? ctrl : vmap()}}));
+
+  // Errors are read BEFORE any status check: a GraphQL parse or validation
+  // failure comes back as HTTP 400 carrying the standard { errors: [...] }
+  // body, and the raw path represents a non-2xx as ok:false with no err — so
+  // returning early on status would discard the server's own diagnostics,
+  // which are the only useful part of that response.
+  Value errors = getp(getp(res, "data"), "errors");
+
+  if (errors.is_list() && !errors.as_list()->empty()) {
+    Value first = (*errors.as_list())[0];
+    Value m = getp(first, "message");
+    std::string msg = m.is_string() && !m.as_string().empty()
+      ? m.as_string() : "graphql error";
+    map_put(res, "ok", Value(false));
+    map_put(res, "err", vmap({{"message",
+      Value("ProjectNameSDK: graphql: " + msg)}}));
+    map_put(res, "graphql", errors);
+  }
+
+  return res;
+}
+
+// Ungated request path shared by direct and graphql, each of which checks its
+// own allow.op token first. Private, rather than a flag on fetchargs: a
+// caller-supplied marker would let anyone opt straight back out of the gate
+// by passing it.
+inline Value SdkClient::rawRequest(const Value& fetchargs_) {
   UtilityPtr u = utility;
   Value fetchargs = fetchargs_.is_map() ? fetchargs_ : vmap();
 

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

@@ -49,6 +49,14 @@ public:
     Value paging = ctx->ctrl ? ctx->ctrl->paging : Value::undef();
     if (!paging.is_map()) paging = vmap();
 
+    // GraphQL paginates through operation VARIABLES, not the query string.
+    // This hook runs after makeSpec, so spec->body already holds the
+    // { query, variables } envelope, and before makeFetchDef serialises it.
+    if ("graphql" == as_str(getp(ctx->point, "kind"))) {
+      graphqlPreRequest(ctx, paging);
+      return;
+    }
+
     Value cursor = getp(paging, "cursor");
     if (!is_nullish(cursor)) {
       map_put(spec->query, cursorParam, cursor);
@@ -66,6 +74,44 @@ public:
     }
   }
 
+  // Relay pagination: the cursor is the `after` variable (or whatever the
+  // model named it), and the page size is `first`.
+  void graphqlPreRequest(CtxPtr ctx, const Value& paging) {
+    Value body = ctx->spec->body;
+    if (!body.is_map()) return;
+
+    Value variables = getp(body, "variables");
+    if (!variables.is_map()) {
+      variables = vmap();
+      map_put(body, "variables", variables);
+    }
+
+    std::string afterVar = fopt::foptStr(options, "afterVar", "after");
+    std::string firstVar = fopt::foptStr(options, "firstVar", "first");
+
+    // Only bind variables the operation actually declares, or the server
+    // rejects the document.
+    bool afterDeclared = false, firstDeclared = false;
+    Value varlist = Struct::getpath(ctx->point, {"graphql", "vars"});
+    if (varlist.is_list()) {
+      for (const auto& v : *varlist.as_list()) {
+        std::string n = as_str(getp(v, "name"));
+        if (n == afterVar) afterDeclared = true;
+        if (n == firstVar) firstDeclared = true;
+      }
+    }
+
+    Value cursor = getp(paging, "cursor");
+    if (afterDeclared && !is_nullish(cursor)) {
+      map_put(variables, afterVar, cursor);
+    }
+
+    if (firstDeclared && !is_nullish(getp(options, "limit")) &&
+        is_nullish(getp(variables, firstVar))) {
+      map_put(variables, firstVar, Value(fopt::foptInt(options, "limit", 0)));
+    }
+  }
+
   void preResult(CtxPtr ctx) override {
     if (!active || !isList(ctx)) return;
     ResultPtr result = ctx->result;
@@ -92,6 +138,39 @@ public:
       }
     }
 
+    // Set when the response states hasMore outright, rather than leaving it
+    // to be inferred from the presence of a cursor.
+    bool explicitMore = false;
+
+    // Relay connections carry the cursor in pageInfo, at the path the model
+    // recorded for this op.
+    Value page = Struct::getpath(ctx->point, {"graphql", "page"});
+    if (page.is_map() && body.is_map()) {
+      // `connpath` locates the connection object inside the response
+      // envelope (data.<field>); the cursor/more paths are relative to it.
+      Value conn = body;
+      std::string connpath = as_str(getp(page, "connpath"));
+      if (!connpath.empty()) {
+        Value sub = Struct::getpath(body, splitDots(connpath));
+        if (!is_nullish(sub)) conn = sub;
+      }
+
+      std::string cursorpath = as_str(getp(page, "cursor"));
+      if (!cursorpath.empty()) {
+        Value c = Struct::getpath(conn, splitDots(cursorpath));
+        if (!is_nullish(c)) map_put(paging, "cursor", c);
+      }
+
+      std::string morepath = as_str(getp(page, "more"));
+      if (!morepath.empty()) {
+        Value m = Struct::getpath(conn, splitDots(morepath));
+        if (m.is_bool()) {
+          map_put(paging, "hasMore", m);
+          explicitMore = true;
+        }
+      }
+    }
+
     // Body-level cursors.
     if (body.is_map()) {
       Value bnext = getp(body, "next");
@@ -109,10 +188,16 @@ public:
       Value bhasMore = getp(body, "hasMore");
       if (bhasMore.is_bool()) {
         map_put(paging, "hasMore", bhasMore);
+        explicitMore = true;
       }
     }
 
-    if (!is_true(getp(paging, "hasMore")) &&
+    // Cursor presence only INFERS another page. When the server stated the
+    // answer outright — relay's `hasNextPage: false`, or a body `hasMore` —
+    // that wins: a final page normally carries both an end cursor and
+    // hasNextPage false, and inferring from the cursor there would send the
+    // caller back for a page that does not exist, forever.
+    if (!explicitMore && !is_true(getp(paging, "hasMore")) &&
         (!is_nullish(getp(paging, "next")) || !is_nullish(getp(paging, "cursor")) ||
          !is_nullish(getp(paging, "nextPage")))) {
       map_put(paging, "hasMore", Value(true));
@@ -123,6 +208,23 @@ public:
   }
 
 private:
+  // The model records connection/cursor/more as dot paths; Struct::getpath
+  // takes pre-split segments.
+  static std::vector<std::string> splitDots(const std::string& path) {
+    std::vector<std::string> out;
+    size_t start = 0;
+    while (true) {
+      size_t dot = path.find('.', start);
+      if (std::string::npos == dot) {
+        out.push_back(path.substr(start));
+        break;
+      }
+      out.push_back(path.substr(start, dot - start));
+      start = dot + 1;
+    }
+    return out;
+  }
+
   bool isList(CtxPtr ctx) {
     std::string opname = "";
     if (ctx->op) opname = ctx->op->name;

package/project/.sdk/tm/cpp/utility/pipeline.hpp

@@ -9,6 +9,7 @@
 
 #include <algorithm>
 #include <memory>
+#include <cctype>
 #include <string>
 #include <vector>
 
@@ -376,6 +377,133 @@ inline Value makePoint(CtxPtr ctx) {
   return ctx->point;
 }
 
+// ---- graphql ----------------------------------------------------------
+//
+// GraphQL transport. API-INDEPENDENT: every GraphQL SDK this generator
+// produces uses this unchanged. The API-specific part — which operations
+// exist and what each one's document is — is model data, computed once by
+// apidef and emitted into Config.
+
+// Content type every GraphQL-over-HTTP request uses.
+inline const char* graphqlContentType() { return "application/json"; }
+
+// Map a GraphQL error to the same error codes the HTTP path produces, so a
+// caller handles auth or rate limiting identically on both transports.
+// Servers put the machine-readable code in `extensions.code`; Linear-style
+// APIs use `extensions.type`.
+inline std::string graphqlErrorCode(const Value& gqlerr) {
+  Value ext = getp(gqlerr, "extensions");
+
+  std::string raw = as_str(getp(ext, "code"));
+  if (raw.empty()) raw = as_str(getp(ext, "type"));
+  for (auto& ch : raw) ch = (char)std::toupper((unsigned char)ch);
+
+  if (raw.find("AUTH") != std::string::npos ||
+      raw.find("FORBIDDEN") != std::string::npos ||
+      raw.find("UNAUTHENTICATED") != std::string::npos) {
+    return "request_auth";
+  }
+  if (raw.find("RATELIMIT") != std::string::npos ||
+      raw.find("RATE_LIMIT") != std::string::npos ||
+      raw.find("TOO_MANY") != std::string::npos) {
+    return "request_ratelimit";
+  }
+  if (raw.find("BAD_USER_INPUT") != std::string::npos ||
+      raw.find("VALIDATION") != std::string::npos ||
+      raw.find("INVALID") != std::string::npos) {
+    return "request_invalid";
+  }
+
+  return "request_graphql";
+}
+
+// Build the request body for a GraphQL point.
+//
+// Variables come from the op's own arguments: a named variable binds to the
+// like-named argument (`from`), and the input-object variable (empty
+// `from`) takes the request data as a whole — which is what makes a
+// generated create/update call look exactly like its REST equivalent.
+inline Value graphqlBody(CtxPtr ctx) {
+  Value gql = getp(ctx->point, "graphql");
+  if (!gql.is_map()) return Value::undef();
+
+  // reqmatch/reqdata hold the caller's arguments for this operation; which
+  // one depends on whether the op takes match or data input.
+  Value reqsrc = ctx->reqmatch;
+  Value datasrc = ctx->match;
+  if (ctx->op && ctx->op->input == "data") {
+    reqsrc = ctx->reqdata;
+    datasrc = ctx->data;
+  }
+  if (!reqsrc.is_map()) reqsrc = vmap();
+  if (!datasrc.is_map()) datasrc = vmap();
+
+  Value variables = vmap();
+
+  Value varlist = getp(gql, "vars");
+  if (varlist.is_list()) {
+    for (const auto& spec : *varlist.as_list()) {
+      if (!spec.is_map()) continue;
+
+      std::string name = as_str(getp(spec, "name"));
+      std::string from = as_str(getp(spec, "from"));
+
+      if (from.empty()) {
+        // The input object IS the request body. Strip the action selector,
+        // which is an SDK-side point discriminator, not an API field.
+        Value body = vmap();
+        for (const auto& item : Struct::items(reqsrc)) {
+          std::string key = as_str(pair_key(item));
+          if ("$action" != key) map_put(body, key, pair_val(item));
+        }
+        map_put(variables, name, body);
+        continue;
+      }
+
+      // Only send variables the caller actually supplied: sending an
+      // explicit null would clear a field on many APIs.
+      Value val = getp(reqsrc, from);
+      if (is_nullish(val)) val = getp(datasrc, from);
+      if (!is_nullish(val)) map_put(variables, name, val);
+    }
+  }
+
+  Value out = vmap();
+  map_put(out, "query", getp(gql, "doc"));
+  map_put(out, "variables", variables);
+
+  return out;
+}
+
+// Inspect a decoded GraphQL response body and record a failure when the
+// server reported one. Returns true when an error was recorded.
+//
+// Partial data (`data` alongside `errors`) is treated as failure: the REST
+// surface has no partial-success concept, and silently returning half an
+// object would be worse than failing.
+inline bool graphqlErrors(CtxPtr ctx) {
+  if (!ctx->result) return false;
+  if ("graphql" != as_str(getp(ctx->point, "kind"))) return false;
+
+  Value errors = getp(ctx->result->body, "errors");
+  if (!errors.is_list()) return false;
+
+  const auto& el = *errors.as_list();
+  if (el.empty()) return false;
+
+  Value first = el[0];
+  std::string msg = as_str(getp(first, "message"));
+  if (msg.empty()) msg = "graphql error";
+  if (1 < el.size()) {
+    msg = msg + " (+" + std::to_string(el.size() - 1) + " more)";
+  }
+
+  ctx->result->err = ctx->makeError(graphqlErrorCode(first), "graphql: " + msg);
+  ctx->result->ok = false;
+
+  return true;
+}
+
 // ---- makeSpec ---------------------------------------------------------
 
 inline SpecPtr makeSpec(CtxPtr ctx) {
@@ -412,8 +540,23 @@ inline SpecPtr makeSpec(CtxPtr ctx) {
   ctx->spec->params = utility->prepareParams(ctx);
   ctx->spec->query = utility->prepareQuery(ctx);
   ctx->spec->headers = utility->prepareHeaders(ctx);
-  ctx->spec->body = utility->prepareBody(ctx);
-  ctx->spec->path = utility->preparePath(ctx);
+
+  if ("graphql" == as_str(getp(ctx->point, "kind"))) {
+    // GraphQL addresses one endpoint: no path parts, no query string, and
+    // the body carries the operation. prepareBody is skipped deliberately
+    // — it only emits a body for data-input ops, whereas every GraphQL op
+    // posts one, including load/list/remove.
+    ctx->spec->body = graphqlBody(ctx);
+    ctx->spec->path = "";
+    // prepareQuery already copied the op's match arguments into the query
+    // string. Those same values are bound as operation variables, so
+    // leaving them would send /graphql?id=i1.
+    ctx->spec->query = vmap();
+    map_put(ctx->spec->headers, "content-type", Value(graphqlContentType()));
+  } else {
+    ctx->spec->body = utility->prepareBody(ctx);
+    ctx->spec->path = utility->preparePath(ctx);
+  }
 
   if (ctx->ctrl->explain.is_map()) {
     map_put(ctx->ctrl->explain, "spec", ctx->spec->toValue());
@@ -591,6 +734,12 @@ inline ResponsePtr makeResponse(CtxPtr ctx) {
   utility->resultBasic(ctx);
   utility->resultHeaders(ctx);
   utility->resultBody(ctx);
+
+  // GraphQL reports failures as a top-level `errors` array under HTTP 200,
+  // so resultBasic's status check never sees them. Lift them here, before
+  // the response transform tries to unwrap data that is not there.
+  graphqlErrors(ctx);
+
   utility->transformResponse(ctx);
 
   if (!result->err) result->ok = true;
@@ -879,7 +1028,7 @@ inline const char* OPTSPEC_JSON() {
     "\"headers\": { \"`$CHILD`\": \"`$STRING`\" },"
     "\"allow\": {"
     "  \"method\": \"GET,PUT,POST,PATCH,DELETE,OPTIONS\","
-    "  \"op\": \"create,update,load,list,remove,command,direct\""
+    "  \"op\": \"create,update,load,list,remove,command,direct,graphql\""
     "},"
     "\"entity\": { \"`$CHILD`\": {"
     "  \"`$OPEN`\": true, \"active\": false, \"alias\": {} } },"

package/project/.sdk/tm/csharp/core/Utility.cs

@@ -30,6 +30,8 @@ public class Utility
     public Func<Context, Dictionary<string, object?>> PrepareParams = null!;
     public Func<Context, string> PreparePath = null!;
     public Func<Context, Dictionary<string, object?>> PrepareQuery = null!;
+    public Func<Context, object?> GraphqlBody = null!;
+    public Func<Context, bool> GraphqlErrors = null!;
     public Func<Context, Result> ResultBasic = null!;
     public Func<Context, Result> ResultBody = null!;
     public Func<Context, Result> ResultHeaders = null!;
@@ -76,6 +78,8 @@ public class Utility
             PrepareParams = src.PrepareParams,
             PreparePath = src.PreparePath,
             PrepareQuery = src.PrepareQuery,
+            GraphqlBody = src.GraphqlBody,
+            GraphqlErrors = src.GraphqlErrors,
             ResultBasic = src.ResultBasic,
             ResultBody = src.ResultBody,
             ResultHeaders = src.ResultHeaders,