@voxgig/sdkgen 1.5.1 → 2.0.1

package/project/.sdk/tm/dart/lib/utility/GraphqlUtility.dart

@@ -0,0 +1,162 @@
+import 'voxgig_struct.dart' as vs;
+
+// GraphQL transport. API-INDEPENDENT: every GraphQL SDK this generator
+// produces uses this file 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.
+//
+// Two jobs:
+//
+//   graphqlBody   — build { query, variables } for a point, binding the
+//                   op's arguments to the document's declared variables.
+//
+//   graphqlErrors — lift a GraphQL failure into an SDK error. GraphQL
+//                   reports failures as a top-level `errors` array under
+//                   HTTP 200, so the status-driven path in resultBasic
+//                   never sees them.
+
+// Content type every GraphQL-over-HTTP request uses.
+const String graphqlContentType = '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`.
+String graphqlErrorCode(dynamic gqlerr) {
+  final ext = vs.getprop(gqlerr, 'extensions');
+
+  var raw = vs.getprop(ext, 'code');
+  if (null == raw || '' == raw) {
+    raw = vs.getprop(ext, 'type');
+  }
+  final code = (raw is String) ? raw.toUpperCase() : '';
+
+  if (code.contains('AUTH') ||
+      code.contains('FORBIDDEN') ||
+      code.contains('UNAUTHENTICATED')) {
+    return 'request_auth';
+  }
+  if (code.contains('RATELIMIT') ||
+      code.contains('RATE_LIMIT') ||
+      code.contains('TOO_MANY')) {
+    return 'request_ratelimit';
+  }
+  if (code.contains('BAD_USER_INPUT') ||
+      code.contains('VALIDATION') ||
+      code.contains('INVALID')) {
+    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.
+dynamic graphqlBody(dynamic ctx) {
+  final gql = ctx.point?.graphql;
+
+  if (gql is! Map) {
+    return null;
+  }
+
+  // reqmatch/reqdata hold the caller's arguments for THIS call; data/match
+  // hold the entity's current state. Which pair depends on whether the op
+  // takes match or data input. A named variable falls back to the current
+  // state, so updating a loaded entity with just {title} still binds the
+  // stored id the mutation requires.
+  var reqsrc = ctx.reqmatch;
+  var datasrc = ctx.match;
+  if (null != ctx.op && 'data' == ctx.op.input) {
+    reqsrc = ctx.reqdata;
+    datasrc = ctx.data;
+  }
+  if (reqsrc is! Map) {
+    reqsrc = <String, dynamic>{};
+  }
+  if (datasrc is! Map) {
+    datasrc = <String, dynamic>{};
+  }
+
+  final variables = <String, dynamic>{};
+
+  final varlist = vs.getprop(gql, 'vars');
+  if (varlist is List) {
+    for (final spec in varlist) {
+      if (spec is! Map) {
+        continue;
+      }
+
+      final name = vs.getprop(spec, 'name');
+      final from = vs.getprop(spec, 'from');
+      if (null == name) {
+        continue;
+      }
+
+      if (null == from || '' == from) {
+        // The input object IS the request body. Strip the action selector,
+        // which is an SDK-side point discriminator, not an API field.
+        final body = <String, dynamic>{};
+        reqsrc.forEach((k, v) {
+          if ('\$action' != k) {
+            body[k.toString()] = v;
+          }
+        });
+        variables[name.toString()] = body;
+        continue;
+      }
+
+      // Only send variables the caller actually supplied: sending an
+      // explicit null would clear a field on many APIs.
+      final val = vs.getprop(reqsrc, from) ?? vs.getprop(datasrc, from);
+      if (null != val) {
+        variables[name.toString()] = val;
+      }
+    }
+  }
+
+  return {
+    'query': vs.getprop(gql, 'doc'),
+    'variables': variables,
+  };
+}
+
+// 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.
+bool graphqlErrors(dynamic ctx) {
+  final result = ctx.result;
+
+  if (null == result || null == ctx.point) {
+    return false;
+  }
+
+  if ('graphql' != ctx.point.kind) {
+    return false;
+  }
+
+  final errors = vs.getprop(result.body, 'errors');
+  if (errors is! List || 0 == errors.length) {
+    return false;
+  }
+
+  final first = errors[0];
+  var msg = vs.getprop(first, 'message');
+  if (msg is! String || '' == msg) {
+    msg = 'graphql error';
+  }
+  if (1 < errors.length) {
+    msg = msg + ' (+' + (errors.length - 1).toString() + ' more)';
+  }
+
+  result.err = ctx.error(graphqlErrorCode(first), 'graphql: ' + msg);
+  result.ok = false;
+
+  return true;
+}

package/project/.sdk/tm/dart/lib/utility/MakeOptionsUtility.dart

@@ -29,7 +29,7 @@ dynamic makeOptions(dynamic ctx) {
     },
     '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`': {

package/project/.sdk/tm/dart/lib/utility/MakeResponseUtility.dart

@@ -37,6 +37,11 @@ Future<dynamic> makeResponse(dynamic ctx) async {
     resultBasic(ctx);
     resultHeaders(ctx);
     await Future.value(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.
+    utility.graphqlErrors(ctx);
     transformResponse(ctx);
 
     if (null == result.err) {

package/project/.sdk/tm/dart/lib/utility/MakeSpecUtility.dart

@@ -1,3 +1,4 @@
+import 'GraphqlUtility.dart';
 import '../Spec.dart';
 
 import 'ErrUtility.dart';
@@ -44,8 +45,23 @@ dynamic makeSpec(dynamic ctx) {
   ctx.spec.params = prepareParams(ctx);
   ctx.spec.query = prepareQuery(ctx);
   ctx.spec.headers = prepareHeaders(ctx);
-  ctx.spec.body = prepareBody(ctx);
-  ctx.spec.path = preparePath(ctx);
+
+  if ('graphql' == 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 = utility.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 = <String, dynamic>{};
+    ctx.spec.headers['content-type'] = graphqlContentType;
+  } else {
+    ctx.spec.body = prepareBody(ctx);
+    ctx.spec.path = preparePath(ctx);
+  }
 
   if (null != ctx.ctrl['explain']) {
     ctx.ctrl['explain']['spec'] = ctx.spec;

package/project/.sdk/tm/dart/lib/utility/PrepareMethodUtility.dart

@@ -16,7 +16,12 @@ dynamic prepareMethod(dynamic ctx) {
   // The API definition is authoritative: a POST-only or PATCH-based API
   // exposes `update` as POST or PATCH, not the PUT the op name implies.
   // Only fall back to the op-name convention when the point has no method.
-  final method = vs.getprop(ctx.point, 'method');
+  // Read the field off the Point object directly: vs.getprop only handles
+  // maps and lists, so going through it always missed the point's method and
+  // fell back to the op-name convention below. A GraphQL point synthesizes
+  // POST for every op, and a POST-only or PATCH-based REST API states its own
+  // method too — both were being overridden.
+  final method = ctx.point?.method;
   if (method is String && '' != method) {
     return method.toUpperCase();
   }

package/project/.sdk/tm/dart/lib/utility/Utility.dart

@@ -28,6 +28,7 @@ import 'ResultHeadersUtility.dart' as u;
 import 'TransformRequestUtility.dart' as u;
 import 'TransformResponseUtility.dart' as u;
 
+import 'GraphqlUtility.dart' as u;
 import 'StructUtility.dart';
 
 class Utility {
@@ -55,6 +56,8 @@ class Utility {
   dynamic prepareParams = u.prepareParams;
   dynamic preparePath = u.preparePath;
   dynamic prepareQuery = u.prepareQuery;
+  dynamic graphqlBody = u.graphqlBody;
+  dynamic graphqlErrors = u.graphqlErrors;
   dynamic resultBasic = u.resultBasic;
   dynamic resultBody = u.resultBody;
   dynamic resultHeaders = u.resultHeaders;
@@ -139,6 +142,12 @@ class Utility {
       case 'preparePath':
         preparePath = fn;
         break;
+      case 'graphqlBody':
+        graphqlBody = fn;
+        break;
+      case 'graphqlErrors':
+        graphqlErrors = fn;
+        break;
       case 'prepareQuery':
         prepareQuery = fn;
         break;

package/project/.sdk/tm/elixir/lib/projectname/feature/paging.ex

@@ -55,24 +55,93 @@ defmodule ProjectName.Feature.Paging do
         paging = if ctrl != nil, do: S.getprop(ctrl, "paging"), else: nil
         paging = if S.ismap(paging), do: paging, else: S.jm([])
 
-        cond do
-          S.getprop(paging, "cursor") != nil ->
-            S.setprop(query, cursor_param, S.getprop(paging, "cursor"))
+        # 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" == S.getprop(S.getprop(ctx, "point"), "kind") do
+          graphql_pre_request(f, ctx, paging)
+        else
+          cond do
+            S.getprop(paging, "cursor") != nil ->
+              S.setprop(query, cursor_param, S.getprop(paging, "cursor"))
+
+            S.getprop(query, page_param) == nil ->
+              page = S.getprop(paging, "page")
+              page = if page == nil, do: por(S.getprop(opts, "startPage"), 1), else: page
+              S.setprop(query, page_param, page)
+
+            true ->
+              nil
+          end
 
-          S.getprop(query, page_param) == nil ->
-            page = S.getprop(paging, "page")
-            page = if page == nil, do: por(S.getprop(opts, "startPage"), 1), else: page
-            S.setprop(query, page_param, page)
+          limit = S.getprop(opts, "limit")
 
-          true ->
-            nil
+          if limit != nil and S.getprop(query, limit_param) == nil do
+            S.setprop(query, limit_param, limit)
+          end
         end
+      end
+    end
 
-        limit = S.getprop(opts, "limit")
+    nil
+  end
+
+  # Relay pagination: the cursor is the `after` variable (or whatever the model
+  # named it), and the page size is `first`.
+  defp graphql_pre_request(f, ctx, paging) do
+    opts = F.opts(f)
+    point = S.getprop(ctx, "point")
+    body = S.getprop(S.getprop(ctx, "spec"), "body")
+
+    if S.ismap(body) do
+      variables =
+        case S.getprop(body, "variables") do
+          v when not is_nil(v) ->
+            if S.ismap(v) do
+              v
+            else
+              nv = S.jm([])
+              S.setprop(body, "variables", nv)
+              nv
+            end
 
-        if limit != nil and S.getprop(query, limit_param) == nil do
-          S.setprop(query, limit_param, limit)
+          _ ->
+            nv = S.jm([])
+            S.setprop(body, "variables", nv)
+            nv
         end
+
+      after_var = por(S.getprop(opts, "afterVar"), "after")
+      first_var = por(S.getprop(opts, "firstVar"), "first")
+
+      # Only bind variables the operation actually declares, or the server
+      # rejects the document.
+      varlist = S.getpath(point, "graphql.vars")
+
+      declared =
+        if S.islist(varlist) and S.size(varlist) > 0 do
+          Enum.reduce(0..(S.size(varlist) - 1), MapSet.new(), fn i, acc ->
+            case S.getprop(S.getelem(varlist, i), "name") do
+              nil -> acc
+              name -> MapSet.put(acc, name)
+            end
+          end)
+        else
+          MapSet.new()
+        end
+
+      cursor = S.getprop(paging, "cursor")
+
+      if cursor != nil and MapSet.member?(declared, after_var) do
+        S.setprop(variables, after_var, cursor)
+      end
+
+      limit = S.getprop(opts, "limit")
+
+      if limit != nil and S.getprop(variables, first_var) == nil and
+           MapSet.member?(declared, first_var) do
+        S.setprop(variables, first_var, limit)
       end
     end
 
@@ -131,8 +200,62 @@ defmodule ProjectName.Feature.Paging do
             {next_from_link, nil, false}
           end
 
+        # Relay connections carry the cursor in pageInfo, at the path the
+        # model recorded for this op. `explicit_more` is set when the server
+        # states hasMore outright, rather than leaving it to be inferred from
+        # the presence of a cursor.
+        gqlpage = S.getpath(S.getprop(ctx, "point"), "graphql.page")
+
+        {cursor_val, has_more, explicit_more} =
+          if S.ismap(gqlpage) and S.ismap(body) do
+            # `connpath` locates the connection object inside the response
+            # envelope (data.<field>); the cursor/more paths are relative
+            # to it.
+            connpath = S.getprop(gqlpage, "connpath")
+
+            conn =
+              if is_binary(connpath) and connpath != "" do
+                por(S.getpath(body, connpath), body)
+              else
+                body
+              end
+
+            cursorpath = S.getprop(gqlpage, "cursor")
+
+            c =
+              if is_binary(cursorpath) and cursorpath != "" do
+                por(S.getpath(conn, cursorpath), cursor_val)
+              else
+                cursor_val
+              end
+
+            morepath = S.getprop(gqlpage, "more")
+
+            case (is_binary(morepath) and morepath != "" and S.getpath(conn, morepath)) do
+              v when is_boolean(v) ->
+                {c, v, true}
+
+              _ ->
+                # No usable relay `more` path, but a top-level body hasMore is
+                # still an outright statement — keep it explicit, or cursor
+                # inference below would flip an explicit false to true.
+                {c, has_more, is_boolean(S.getprop(body, "hasMore"))}
+            end
+          else
+            {cursor_val, has_more, is_boolean(S.getprop(body, "hasMore"))}
+          end
+
+        # 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.
         has_more =
-          has_more or next_val != nil or cursor_val != nil or next_page != nil
+          if explicit_more do
+            has_more
+          else
+            has_more or next_val != nil or cursor_val != nil or next_page != nil
+          end
 
         paging =
           S.jm([

package/project/.sdk/tm/elixir/lib/projectname/utility.ex

@@ -13,6 +13,9 @@ defmodule ProjectName.Utility do
 
   @default_user_agent "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)"
 
+  # Content type every GraphQL-over-HTTP request uses.
+  @graphql_content_type "application/json"
+
   # ---- construction / registration ----------------------------------------
 
   def new do
@@ -45,6 +48,8 @@ defmodule ProjectName.Utility do
       {"prepare_params", &prepare_params_impl/1},
       {"prepare_path", &prepare_path_impl/1},
       {"prepare_query", &prepare_query_impl/1},
+      {"graphql_body", &graphql_body_impl/1},
+      {"graphql_errors", &graphql_errors_impl/1},
       {"result_basic", &result_basic_impl/1},
       {"result_body", &result_body_impl/1},
       {"result_headers", &result_headers_impl/1},
@@ -83,6 +88,8 @@ defmodule ProjectName.Utility do
   def prepare_params(ctx), do: u(ctx, "prepare_params").(ctx)
   def prepare_path(ctx), do: u(ctx, "prepare_path").(ctx)
   def prepare_query(ctx), do: u(ctx, "prepare_query").(ctx)
+  def graphql_body(ctx), do: u(ctx, "graphql_body").(ctx)
+  def graphql_errors(ctx), do: u(ctx, "graphql_errors").(ctx)
   def result_basic(ctx), do: u(ctx, "result_basic").(ctx)
   def result_body(ctx), do: u(ctx, "result_body").(ctx)
   def result_headers(ctx), do: u(ctx, "result_headers").(ctx)
@@ -249,7 +256,7 @@ defmodule ProjectName.Utility do
         "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" => %{}}},
         "feature" => %{"`$CHILD`" => %{"`$OPEN`" => true, "active" => false}},
@@ -474,8 +481,23 @@ defmodule ProjectName.Utility do
         S.setprop(spec, "params", prepare_params(ctx))
         S.setprop(spec, "query", prepare_query(ctx))
         S.setprop(spec, "headers", prepare_headers(ctx))
-        S.setprop(spec, "body", prepare_body(ctx))
-        S.setprop(spec, "path", prepare_path(ctx))
+
+        if S.getprop(point, "kind") == "graphql" do
+          # GraphQL addresses one endpoint: no path parts, no query string,
+          # and the body carries the operation. prepare_body is skipped
+          # deliberately — it only emits a body for data-input ops, whereas
+          # every GraphQL op posts one, including load/list/remove.
+          S.setprop(spec, "body", graphql_body(ctx))
+          S.setprop(spec, "path", "")
+          # prepare_query 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.
+          S.setprop(spec, "query", S.jm([]))
+          S.setprop(S.getprop(spec, "headers"), "content-type", @graphql_content_type)
+        else
+          S.setprop(spec, "body", prepare_body(ctx))
+          S.setprop(spec, "path", prepare_path(ctx))
+        end
 
         ctrl = S.getprop(ctx, "ctrl")
         explain = S.getprop(ctrl, "explain")
@@ -580,6 +602,13 @@ defmodule ProjectName.Utility do
           result_basic(ctx)
           result_headers(ctx)
           result_body(ctx)
+
+          # GraphQL reports failures as a top-level `errors` array under HTTP
+          # 200, so result_basic's status check never sees them. Lift them
+          # here, before the response transform tries to unwrap data that is
+          # not there.
+          graphql_errors(ctx)
+
           transform_response(ctx)
 
           if S.getprop(result, "err") == nil, do: S.setprop(result, "ok", true)
@@ -994,6 +1023,161 @@ defmodule ProjectName.Utility do
     out
   end
 
+  # ---- graphql -------------------------------------------------------------
+  #
+  # GraphQL transport. API-INDEPENDENT: every GraphQL SDK this generator
+  # produces uses this code 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.
+  #
+  # Two jobs:
+  #
+  #   graphql_body   — build %{query, variables} for a point, binding the
+  #                    op's arguments to the document's declared variables.
+  #
+  #   graphql_errors — lift a GraphQL failure into an SDK error. GraphQL
+  #                    reports failures as a top-level `errors` array under
+  #                    HTTP 200, so the status-driven path in result_basic
+  #                    never sees them.
+
+  # 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`.
+  def graphql_error_code(gqlerr) do
+    ext = S.getprop(gqlerr, "extensions")
+
+    code = strv(S.getprop(ext, "code"))
+    code = if code == "", do: strv(S.getprop(ext, "type")), else: code
+    raw = String.upcase(code)
+
+    cond do
+      String.contains?(raw, "AUTH") or String.contains?(raw, "FORBIDDEN") or
+          String.contains?(raw, "UNAUTHENTICATED") ->
+        "request_auth"
+
+      String.contains?(raw, "RATELIMIT") or String.contains?(raw, "RATE_LIMIT") or
+          String.contains?(raw, "TOO_MANY") ->
+        "request_ratelimit"
+
+      String.contains?(raw, "BAD_USER_INPUT") or String.contains?(raw, "VALIDATION") or
+          String.contains?(raw, "INVALID") ->
+        "request_invalid"
+
+      true ->
+        "request_graphql"
+    end
+  end
+
+  # 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.
+  def graphql_body_impl(ctx) do
+    gql = S.getprop(S.getprop(ctx, "point"), "graphql")
+
+    if not S.ismap(gql) do
+      nil
+    else
+      # reqmatch/reqdata hold the caller's arguments for THIS call; data/match
+      # hold the entity's current state. Which pair depends on whether the op
+      # takes match or data input. A named variable falls back to the current
+      # state, so updating a loaded entity with just {title} still binds the
+      # stored id the mutation requires.
+      op = S.getprop(ctx, "op")
+      datainput = S.getprop(op, "input") == "data"
+
+      reqsrc =
+        if datainput, do: S.getprop(ctx, "reqdata"), else: S.getprop(ctx, "reqmatch")
+
+      datasrc =
+        if datainput, do: S.getprop(ctx, "data"), else: S.getprop(ctx, "match")
+
+      reqsrc = if S.ismap(reqsrc), do: reqsrc, else: S.jm([])
+      datasrc = if S.ismap(datasrc), do: datasrc, else: S.jm([])
+
+      variables = S.jm([])
+      varlist = S.getprop(gql, "vars")
+      n = if S.islist(varlist), do: S.size(varlist), else: 0
+
+      if n > 0 do
+        Enum.each(0..(n - 1), fn i ->
+          spec = S.getelem(varlist, i)
+
+          if S.ismap(spec) do
+            name = strv(S.getprop(spec, "name"))
+            from = strv(S.getprop(spec, "from"))
+
+            cond do
+              name == "" ->
+                nil
+
+              from == "" ->
+                # The input object IS the request body. Strip the action
+                # selector, which is an SDK-side point discriminator, not an
+                # API field.
+                body = S.jm([])
+
+                Enum.each(H.entries(reqsrc), fn {key, val} ->
+                  if key != "$action", do: S.setprop(body, key, val)
+                end)
+
+                S.setprop(variables, name, body)
+
+              true ->
+                # Only send variables the caller actually supplied: sending
+                # an explicit null would clear a field on many APIs.
+                # Explicit nil check, not `||`: a caller-supplied `false` is a
+                # value, and `||` would treat it as absent and substitute the
+                # current state — sending the opposite of what was asked.
+                val = S.getprop(reqsrc, from)
+                val = if val == nil, do: S.getprop(datasrc, from), else: val
+                if val != nil, do: S.setprop(variables, name, val)
+            end
+          end
+        end)
+      end
+
+      S.jm(["query", S.getprop(gql, "doc"), "variables", variables])
+    end
+  end
+
+  # 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.
+  def graphql_errors_impl(ctx) do
+    result = S.getprop(ctx, "result")
+    point = S.getprop(ctx, "point")
+
+    errors = if result == nil, do: nil, else: S.getprop(S.getprop(result, "body"), "errors")
+
+    count = if S.islist(errors), do: S.size(errors), else: 0
+
+    if result == nil or S.getprop(point, "kind") != "graphql" or count == 0 do
+      false
+    else
+      first = S.getelem(errors, 0)
+      msg = strv(S.getprop(first, "message"))
+      msg = if msg == "", do: "graphql error", else: msg
+      msg = if 1 < count, do: msg <> " (+" <> Integer.to_string(count - 1) <> " more)", else: msg
+
+      S.setprop(
+        result,
+        "err",
+        Context.make_error(ctx, graphql_error_code(first), "graphql: " <> msg)
+      )
+
+      S.setprop(result, "ok", false)
+
+      true
+    end
+  end
+
   def prepare_auth_impl(ctx) do
     spec = S.getprop(ctx, "spec")
 

package/project/.sdk/tm/go/core/utility_type.go

@@ -25,6 +25,8 @@ type Utility struct {
 	PrepareParams     func(ctx *Context) map[string]any
 	PreparePath       func(ctx *Context) string
 	PrepareQuery      func(ctx *Context) map[string]any
+	GraphqlBody       func(ctx *Context) any
+	GraphqlErrors     func(ctx *Context) bool
 	ResultBasic       func(ctx *Context) *Result
 	ResultBody        func(ctx *Context) *Result
 	ResultHeaders     func(ctx *Context) *Result