@voxgig/sdkgen 1.5.1 → 2.0.0

package/project/.sdk/src/cmp/rb/fragment/Main.fragment.rb

@@ -149,7 +149,37 @@ class ProjectNameSDK
     fetchdef
   end
 
+  # 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.
   def direct(fetchargs = {})
+    return op_denied("direct") unless op_allowed?("direct")
+
+    raw_request(fetchargs)
+  end
+
+  # Is this raw-access op permitted by the SDK's allow.op option?
+  def op_allowed?(op)
+    allow_op = VoxgigStruct.getpath(@options, "allow.op")
+    allow_op.is_a?(String) && allow_op.include?(op)
+  end
+
+  def op_denied(op)
+    allow_op = VoxgigStruct.getpath(@options, "allow.op")
+    {
+      "ok" => false,
+      "err" => ProjectNameError.new(
+        "#{op}_allow",
+        "ProjectNameSDK: #{op}: operation not allowed by" \
+        " SDK option allow.op value: \"#{allow_op}\""),
+    }
+  end
+
+  # Ungated request path shared by direct and graphql, each of which checks
+  # its own allow.op token first. Separate, rather than a flag on fetchargs:
+  # a caller-supplied marker would let anyone opt straight back out of the
+  # gate by passing it.
+  def raw_request(fetchargs = {})
     utility = @_utility
 
     # direct() is the raw-HTTP escape hatch: it always returns a result hash
@@ -217,6 +247,47 @@ class ProjectNameSDK
     }
   end
 
+  # 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.
+  def graphql(query, variables = nil, ctrl = nil)
+    return op_denied("graphql") unless op_allowed?("graphql")
+
+    res = raw_request({
+      "method" => "POST",
+      "headers" => { "content-type" => "application/json" },
+      "body" => { "query" => query, "variables" => variables || {} },
+      "ctrl" => ctrl || {},
+    })
+
+    # 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.
+    errors = VoxgigStruct.getpath(res, "data.errors")
+
+    if errors.is_a?(Array) && !errors.empty?
+      first = errors[0].is_a?(Hash) ? errors[0] : {}
+      msg = first["message"]
+      msg = "graphql error" if msg.nil? || msg.to_s.empty?
+      res["ok"] = false
+      res["err"] = ProjectNameError.new(
+        "graphql_error", "ProjectNameSDK: graphql: #{msg}")
+      res["graphql"] = errors
+    end
+
+    res
+  end
+
   # <[SLOT]>
 
   def self.test(testopts = nil, sdkopts = nil)

package/project/.sdk/src/cmp/rust/fragment/Main.fragment.rs

@@ -179,7 +179,43 @@ impl ProjectNameSDK {
         utility.make_fetch_def(&ctx)
     }
 
+    // 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.
     pub fn direct(&self, fetchargs: Value) -> Result<Value, ProjectNameError> {
+        if !self.op_allowed("direct") {
+            return Ok(self.op_denied("direct"));
+        }
+
+        self.raw_request(fetchargs)
+    }
+
+    // Is this raw-access op permitted by the SDK's allow.op option?
+    fn op_allowed(&self, op: &str) -> bool {
+        match getpath(&["allow", "op"], &self.options_map()) {
+            Value::Str(s) => s.contains(op),
+            _ => false,
+        }
+    }
+
+    fn op_denied(&self, op: &str) -> Value {
+        let allow = match getpath(&["allow", "op"], &self.options_map()) {
+            Value::Str(s) => s,
+            _ => String::new(),
+        };
+        jo(vec![
+            ("ok", Value::Bool(false)),
+            ("err", Value::str(format!(
+                "ProjectNameSDK: {}: operation not allowed by SDK option \
+                 allow.op value: \"{}\"", op, allow))),
+        ])
+    }
+
+    // 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.
+    fn raw_request(&self, fetchargs: Value) -> Result<Value, ProjectNameError> {
         let utility = &self.utility;
 
         let fetchdef = match self.prepare(fetchargs.clone()) {
@@ -264,6 +300,65 @@ impl ProjectNameSDK {
         ]))
     }
 
+    // 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.
+    pub fn graphql(
+        &self, query: &str, variables: Value, ctrl: Value,
+    ) -> Result<Value, ProjectNameError> {
+        if !self.op_allowed("graphql") {
+            return Ok(self.op_denied("graphql"));
+        }
+
+        let vars = match &variables {
+            Value::Map(_) => variables,
+            _ => Value::empty_map(),
+        };
+        let ctl = match &ctrl {
+            Value::Map(_) => ctrl,
+            _ => Value::empty_map(),
+        };
+
+        let res = self.raw_request(jo(vec![
+            ("method", Value::str("POST")),
+            ("headers", jo(vec![("content-type", Value::str("application/json"))])),
+            ("body", jo(vec![("query", Value::str(query)), ("variables", vars)])),
+            ("ctrl", ctl),
+        ]))?;
+
+        // 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.
+        let errors = getpath(&["data", "errors"], &res);
+
+        if let Value::List(items) = &errors {
+            let first = items.borrow().first().cloned();
+            if let Some(first) = first {
+                let msg = get_str(&first, "message")
+                    .filter(|m| !m.is_empty())
+                    .unwrap_or_else(|| "graphql error".to_string());
+                setp(&res, "ok", Value::Bool(false));
+                setp(&res, "err",
+                     Value::str(format!("ProjectNameSDK: graphql: {}", msg)));
+                setp(&res, "graphql", errors.clone());
+            }
+        }
+
+        Ok(res)
+    }
+
     // <[SLOT]>
 }
 

package/project/.sdk/src/cmp/swift/fragment/Main.fragment.swift

@@ -126,7 +126,39 @@ public final class ProjectNameSDK {
     return try utility.makeFetchDef(ctx)
   }
 
+  // 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.
   public func direct(_ fetchargsIn: VMap?) -> VMap {
+    if !opAllowed("direct") {
+      return opDenied("direct")
+    }
+
+    return rawRequest(fetchargsIn)
+  }
+
+  // Is this raw-access op permitted by the SDK's allow.op option?
+  private func opAllowed(_ op: String) -> Bool {
+    guard let allow = gpath(options, "allow", "op").asString else { return false }
+    return allow.contains(op)
+  }
+
+  private func opDenied(_ op: String) -> VMap {
+    let allow = gpath(options, "allow", "op").asString ?? ""
+    let r = VMap()
+    r.entries["ok"] = .bool(false)
+    r.entries["err"] = .nat(ProjectNameError(
+      op + "_allow",
+      "ProjectNameSDK: \(op): operation not allowed by SDK option "
+        + "allow.op value: \"\(allow)\"", nil))
+    return r
+  }
+
+  // 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.
+  private func rawRequest(_ fetchargsIn: VMap?) -> VMap {
     let utility = self.utility
 
     let fetchdef: VMap
@@ -194,6 +226,60 @@ public final class ProjectNameSDK {
     return r
   }
 
+  // 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.
+  public func graphql(
+    _ query: String, _ variables: VMap? = nil, _ ctrl: VMap? = nil
+  ) -> VMap {
+    if !opAllowed("graphql") {
+      return opDenied("graphql")
+    }
+
+    let headers = VMap()
+    headers.entries["content-type"] = .string("application/json")
+
+    let body = VMap()
+    body.entries["query"] = .string(query)
+    body.entries["variables"] = .map(variables ?? VMap())
+
+    let fetchargs = VMap()
+    fetchargs.entries["method"] = .string("POST")
+    fetchargs.entries["headers"] = .map(headers)
+    fetchargs.entries["body"] = .map(body)
+    fetchargs.entries["ctrl"] = .map(ctrl ?? VMap())
+
+    let res = rawRequest(fetchargs)
+
+    // 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.
+    guard let errors = gp(gp(.map(res), "data"), "errors").asList,
+          !errors.items.isEmpty else {
+      return res
+    }
+
+    var msg = gp(errors.items[0], "message").asString ?? ""
+    if msg.isEmpty { msg = "graphql error" }
+
+    res.entries["ok"] = .bool(false)
+    res.entries["err"] = .nat(ProjectNameError(
+      "graphql_error", "ProjectNameSDK: graphql: " + msg, nil))
+    res.entries["graphql"] = .list(errors)
+
+    return res
+  }
+
   // <[SLOT]>
 
   public static func testSDK(_ testoptsIn: VMap?, _ sdkoptsIn: VMap?) -> ProjectNameSDK {

package/project/.sdk/src/cmp/ts/fragment/Main.fragment.ts

@@ -140,8 +140,29 @@ class ProjectNameSDK {
   }
 
 
+  // 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.
   async direct(fetchargs?: any) {
+    if (!this._options.allow.op.includes('direct')) {
+      return {
+        ok: false,
+        err: new Error('ProjectNameSDK: direct: operation not allowed by' +
+          ' SDK option allow.op value: "' + this._options.allow.op + '"'),
+      }
+    }
+
+    return this._rawRequest(fetchargs)
+  }
+
+
+  // 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.
+  async _rawRequest(fetchargs?: any) {
     const utility = this._utility
+
     const fetcher = utility.fetcher
     const makeContext = utility.makeContext
 
@@ -201,6 +222,60 @@ class ProjectNameSDK {
   }
 
 
+
+  // 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.
+  async graphql(query: string, variables?: any, ctrl?: any) {
+    const options = this._options
+
+    if (!options.allow.op.includes('graphql')) {
+      return {
+        ok: false,
+        err: new Error('ProjectNameSDK: graphql: operation not allowed by' +
+          ' SDK option allow.op value: "' + options.allow.op + '"'),
+      }
+    }
+
+    const res: any = await this._rawRequest({
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: { query, variables: variables || {} },
+      ctrl,
+    })
+
+    if (res instanceof Error) {
+      return res
+    }
+
+    // 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.
+    const errors = null == res.data ? undefined : res.data.errors
+
+    if (null != errors && Array.isArray(errors) && 0 < errors.length) {
+      const first = errors[0] || {}
+      const err: any = new Error('ProjectNameSDK: graphql: ' +
+        (first.message || 'graphql error'))
+      err.graphql = errors
+      return { ok: false, status: res.status, headers: res.headers, err, data: res.data }
+    }
+
+    return res
+  }
+
+
   // <[SLOT]>
 
 

package/project/.sdk/src/cmp/zig/fragment/Main.fragment.zig

@@ -163,7 +163,43 @@ pub const ProjectNameSDK = struct {
         return utility.make_fetch_def(ctx);
     }
 
+    // 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.
     pub fn direct(self: *ProjectNameSDK, fetchargs_in: Value) Value {
+        if (!self.op_allowed("direct")) return self.op_denied("direct");
+
+        return self.raw_request(fetchargs_in);
+    }
+
+    // Is this raw-access op permitted by the SDK's allow.op option?
+    fn op_allowed(self: *ProjectNameSDK, op: []const u8) bool {
+        const allow: []const u8 = switch (h.getpath(&.{ "allow", "op" }, self.options)) {
+            .string => |s| s,
+            else => "",
+        };
+        return std.mem.indexOf(u8, allow, op) != null;
+    }
+
+    fn op_denied(self: *ProjectNameSDK, op: []const u8) Value {
+        const allow: []const u8 = switch (h.getpath(&.{ "allow", "op" }, self.options)) {
+            .string => |s| s,
+            else => "",
+        };
+        const msg = std.fmt.allocPrint(h.A(),
+            "ProjectNameSDK: {s}: operation not allowed by" ++
+            " SDK option allow.op value: \"{s}\"", .{ op, allow }) catch "";
+        return h.jo(&.{
+            .{ "ok", h.vbool(false) },
+            .{ "err", h.vstr(msg) },
+        });
+    }
+
+    // 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.
+    fn raw_request(self: *ProjectNameSDK, fetchargs_in: Value) Value {
         const utility = self.utility;
 
         const fetchdef = self.prepare(fetchargs_in) catch {
@@ -232,6 +268,65 @@ pub const ProjectNameSDK = struct {
         });
     }
 
+    // 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.
+    pub fn graphql(
+        self: *ProjectNameSDK, query: []const u8, variables: Value, ctrl: Value,
+    ) Value {
+        if (!self.op_allowed("graphql")) return self.op_denied("graphql");
+
+        const vars: Value = switch (variables) {
+            .object => variables,
+            else => h.omap(),
+        };
+        const ctl: Value = switch (ctrl) {
+            .object => ctrl,
+            else => h.omap(),
+        };
+
+        const res = self.raw_request(h.jo(&.{
+            .{ "method", h.vstr("POST") },
+            .{ "headers", h.jo(&.{.{ "content-type", h.vstr(utility_mod.GRAPHQL_CONTENT_TYPE) }}) },
+            .{ "body", h.jo(&.{ .{ "query", h.vstr(query) }, .{ "variables", vars } }) },
+            .{ "ctrl", ctl },
+        }));
+
+        if (res != .object) return res;
+
+        // 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.
+        const errors = h.getp(h.getp(res, "data"), "errors");
+
+        if (errors == .array and 0 < errors.array.data.items.len) {
+            const first = errors.array.data.items[0];
+            const m: []const u8 = switch (h.getp(first, "message")) {
+                .string => |x| if (x.len == 0) "graphql error" else x,
+                else => "graphql error",
+            };
+            const msg = std.fmt.allocPrint(h.A(),
+                "ProjectNameSDK: graphql: {s}", .{m}) catch "";
+            h.setp(res, "ok", h.vbool(false));
+            h.setp(res, "err", h.vstr(msg));
+            h.setp(res, "graphql", errors);
+        }
+
+        return res;
+    }
+
     // <[SLOT]>
 };
 

package/project/.sdk/tm/c/core/sdk.h

@@ -423,6 +423,9 @@ ProjectNameSDK* projectname_sdk_new(voxgig_value* options);
 ProjectNameSDK* test_sdk(voxgig_value* testopts, voxgig_value* sdkopts);
 voxgig_value* sdk_prepare(ProjectNameSDK* sdk, voxgig_value* fetchargs, PNError** err);
 voxgig_value* sdk_direct(ProjectNameSDK* sdk, voxgig_value* fetchargs, PNError** err);
+voxgig_value* sdk_graphql(ProjectNameSDK* sdk, const char* query,
+                          voxgig_value* variables, voxgig_value* ctrl,
+                          PNError** err);
 
 // Generated config (core/config.c).
 voxgig_value* make_config(void);
@@ -456,6 +459,10 @@ const char* prepare_method_util(Context* ctx); // static string
 voxgig_value* prepare_params_util(Context* ctx);
 char* prepare_path_util(Context* ctx); // malloc'd
 voxgig_value* prepare_query_util(Context* ctx);
+const char* graphql_error_code(voxgig_value* gqlerr);
+voxgig_value* graphql_body_util(Context* ctx);
+bool graphql_errors_util(Context* ctx);
+#define GRAPHQL_CONTENT_TYPE "application/json"
 SdkResult* result_basic_util(Context* ctx);
 SdkResult* result_body_util(Context* ctx);
 SdkResult* result_headers_util(Context* ctx);