@voxgig/sdkgen 1.5.0 → 2.0.0

package/project/.sdk/tm/perl/utility/graphql.pm

@@ -0,0 +1,150 @@
+# ProjectName SDK utility: graphql
+#
+# 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:
+#
+#   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.
+
+use strict;
+use warnings;
+
+use File::Basename ();
+use Cwd ();
+
+my $__dir;
+BEGIN { $__dir = File::Basename::dirname(Cwd::abs_path(__FILE__)) }
+require(Cwd::abs_path("$__dir/../lib/Voxgig/Struct.pm"));
+require(Cwd::abs_path("$__dir/../core/helpers.pm"));
+
+package ProjectNameUtilities;
+
+our %REGISTRY;
+
+# Content type every GraphQL-over-HTTP request uses.
+our $GRAPHQL_CONTENT_TYPE = '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`.
+sub graphql_error_code {
+  my ($gqlerr) = @_;
+
+  my $ext = ProjectNameHelpers::gp($gqlerr, 'extensions');
+
+  my $raw = ProjectNameHelpers::gp($ext, 'code');
+  $raw = ProjectNameHelpers::gp($ext, 'type') if !defined $raw || '' eq $raw;
+  $raw = defined $raw ? uc("$raw") : '';
+
+  return 'request_auth'
+    if $raw =~ /AUTH/ || $raw =~ /FORBIDDEN/ || $raw =~ /UNAUTHENTICATED/;
+  return 'request_ratelimit'
+    if $raw =~ /RATELIMIT/ || $raw =~ /RATE_LIMIT/ || $raw =~ /TOO_MANY/;
+  return 'request_invalid'
+    if $raw =~ /BAD_USER_INPUT/ || $raw =~ /VALIDATION/ || $raw =~ /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.
+$REGISTRY{graphql_body} = sub {
+  my ($ctx) = @_;
+
+  my $gql = ProjectNameHelpers::gp($ctx->{point}, 'graphql');
+  return undef unless ref($gql) eq 'HASH';
+
+  # 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.
+  my $datainput =
+    $ctx->{op} && defined $ctx->{op}{input} && 'data' eq $ctx->{op}{input};
+  my $reqsrc = $datainput ? $ctx->{reqdata} : $ctx->{reqmatch};
+  my $datasrc = $datainput ? $ctx->{data} : $ctx->{match};
+  $reqsrc = {} unless ref($reqsrc) eq 'HASH';
+  $datasrc = {} unless ref($datasrc) eq 'HASH';
+
+  my %variables;
+
+  my $varlist = ProjectNameHelpers::gp($gql, 'vars');
+  $varlist = [] unless ref($varlist) eq 'ARRAY';
+
+  for my $spec (@$varlist) {
+    next unless ref($spec) eq 'HASH';
+
+    my $name = ProjectNameHelpers::gp($spec, 'name');
+    my $from = ProjectNameHelpers::gp($spec, 'from');
+    next unless defined $name;
+
+    if (!defined $from || '' eq $from) {
+      # The input object IS the request body. Strip the action selector,
+      # which is an SDK-side point discriminator, not an API field.
+      my %body;
+      for my $k (keys %$reqsrc) {
+        $body{$k} = $reqsrc->{$k} unless '$action' eq $k;
+      }
+      $variables{$name} = \%body;
+      next;
+    }
+
+    # Only send variables the caller actually supplied: sending an explicit
+    # null would clear a field on many APIs.
+    my $val = ProjectNameHelpers::gp($reqsrc, $from);
+    $val = ProjectNameHelpers::gp($datasrc, $from) unless defined $val;
+    $variables{$name} = $val if defined $val;
+  }
+
+  return {
+    query     => ProjectNameHelpers::gp($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.
+$REGISTRY{graphql_errors} = sub {
+  my ($ctx) = @_;
+
+  my $result = $ctx->{result};
+  return 0 unless $result && $ctx->{point};
+
+  my $kind = ProjectNameHelpers::gp($ctx->{point}, 'kind');
+  return 0 unless defined $kind && 'graphql' eq $kind;
+
+  my $errors = ProjectNameHelpers::gp($result->{body}, 'errors');
+  return 0 unless ref($errors) eq 'ARRAY' && 0 < scalar(@$errors);
+
+  my $first = $errors->[0];
+  my $msg = ProjectNameHelpers::gp($first, 'message');
+  $msg = 'graphql error' unless defined $msg && '' ne $msg;
+  $msg = $msg . ' (+' . (scalar(@$errors) - 1) . ' more)'
+    if 1 < scalar(@$errors);
+
+  $result->{err} =
+    $ctx->make_error(graphql_error_code($first), 'graphql: ' . $msg);
+  $result->{ok} = 0;
+
+  return 1;
+};
+
+1;

package/project/.sdk/tm/perl/utility/make_options.pm

@@ -70,7 +70,7 @@ $REGISTRY{make_options} = sub {
     '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`' => $JT, 'active' => $JF, 'alias' => {} } },
     'feature' => { '`$CHILD`' => { '`$OPEN`' => $JT, 'active' => $JF } },

package/project/.sdk/tm/perl/utility/make_response.pm

@@ -27,6 +27,12 @@ $REGISTRY{make_response} = sub {
   $utility->{result_basic}->($ctx);
   $utility->{result_headers}->($ctx);
   $utility->{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.
+  $utility->{graphql_errors}->($ctx);
+
   $utility->{transform_response}->($ctx);
 
   $result->{ok} = 1 if !defined $result->{err};

package/project/.sdk/tm/perl/utility/make_spec.pm

@@ -56,8 +56,26 @@ $REGISTRY{make_spec} = sub {
   $ctx->{spec}{params} = $utility->{prepare_params}->($ctx);
   $ctx->{spec}{query} = $utility->{prepare_query}->($ctx);
   $ctx->{spec}{headers} = $utility->{prepare_headers}->($ctx);
-  $ctx->{spec}{body} = $utility->{prepare_body}->($ctx);
-  $ctx->{spec}{path} = $utility->{prepare_path}->($ctx);
+
+  my $pkind = ProjectNameHelpers::gp($ctx->{point}, 'kind');
+  if (defined $pkind && 'graphql' eq $pkind) {
+    # 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.
+    $ctx->{spec}{body} = $utility->{graphql_body}->($ctx);
+    $ctx->{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.
+    $ctx->{spec}{query} = {};
+    $ctx->{spec}{headers}{'content-type'} =
+      $ProjectNameUtilities::GRAPHQL_CONTENT_TYPE;
+  }
+  else {
+    $ctx->{spec}{body} = $utility->{prepare_body}->($ctx);
+    $ctx->{spec}{path} = $utility->{prepare_path}->($ctx);
+  }
 
   $ctx->{ctrl}{explain}{spec} = $ctx->{spec} if $ctx->{ctrl}{explain};
 

package/project/.sdk/tm/perl/utility/register.pm

@@ -35,6 +35,7 @@ require(Cwd::abs_path("$__dir/prepare_method.pm"));
 require(Cwd::abs_path("$__dir/prepare_params.pm"));
 require(Cwd::abs_path("$__dir/prepare_path.pm"));
 require(Cwd::abs_path("$__dir/prepare_query.pm"));
+require(Cwd::abs_path("$__dir/graphql.pm"));
 require(Cwd::abs_path("$__dir/result_basic.pm"));
 require(Cwd::abs_path("$__dir/result_body.pm"));
 require(Cwd::abs_path("$__dir/result_headers.pm"));

package/project/.sdk/tm/php/core/UtilityType.php

@@ -29,6 +29,8 @@ class ProjectNameUtility
     public mixed $prepare_params = null;
     public mixed $prepare_path = null;
     public mixed $prepare_query = null;
+    public mixed $graphql_body = null;
+    public mixed $graphql_errors = null;
     public mixed $result_basic = null;
     public mixed $result_body = null;
     public mixed $result_headers = null;

package/project/.sdk/tm/php/feature/PagingFeature.php

@@ -57,6 +57,15 @@ class ProjectNamePagingFeature extends ProjectNameBaseFeature
             $paging = [];
         }
 
+        // 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' === \Voxgig\Struct\Struct::getprop($ctx->point, 'kind')) {
+            $this->_graphql_pre_request($ctx, $paging);
+            return;
+        }
+
         if (($paging['cursor'] ?? null) !== null) {
             $spec->query[$cursor_param] = $paging['cursor'];
         } elseif (($spec->query[$page_param] ?? null) === null) {
@@ -72,6 +81,53 @@ class ProjectNamePagingFeature extends ProjectNameBaseFeature
         }
     }
 
+    // Relay pagination: the cursor is the `after` variable (or whatever the
+    // model named it), and the page size is `first`.
+    private function _graphql_pre_request(ProjectNameContext $ctx, array $paging): void
+    {
+        $body = $ctx->spec->body;
+        if (!is_array($body)) {
+            return;
+        }
+
+        $variables = $body['variables'] ?? null;
+        if (!is_array($variables)) {
+            $variables = [];
+        }
+
+        $after_var = $this->options['afterVar'] ?? 'after';
+        $first_var = $this->options['firstVar'] ?? 'first';
+
+        // Only bind variables the operation actually declares, or the server
+        // rejects the document.
+        $declared = [];
+        $varlist = \Voxgig\Struct\Struct::getpath($ctx->point, 'graphql.vars');
+        if (is_array($varlist)) {
+            foreach ($varlist as $v) {
+                $name = \Voxgig\Struct\Struct::getprop($v, 'name');
+                if (null !== $name) {
+                    $declared[$name] = true;
+                }
+            }
+        }
+
+        if (($paging['cursor'] ?? null) !== null
+            && ($declared[$after_var] ?? false)) {
+            $variables[$after_var] = $paging['cursor'];
+        }
+
+        if (($this->options['limit'] ?? null) !== null
+            && ($variables[$first_var] ?? null) === null
+            && ($declared[$first_var] ?? false)) {
+            $variables[$first_var] = $this->options['limit'];
+        }
+
+        // PHP arrays are values, not references: write the whole envelope
+        // back or the bindings are lost.
+        $body['variables'] = $variables;
+        $ctx->spec->body = $body;
+    }
+
     public function PreResult(ProjectNameContext $ctx): void
     {
         if (!$this->active || !$this->_is_list($ctx)) {
@@ -100,6 +156,44 @@ class ProjectNamePagingFeature extends ProjectNameBaseFeature
             $paging['next'] = $m[1];
         }
 
+        // Set when the response states hasMore outright, rather than leaving
+        // it to be inferred from the presence of a cursor.
+        $explicit_more = false;
+
+        // Relay connections carry the cursor in pageInfo, at the path the
+        // model recorded for this op.
+        $page = \Voxgig\Struct\Struct::getpath($ctx->point, 'graphql.page');
+        if (is_array($page) && is_array($body)) {
+            // `connpath` locates the connection object inside the response
+            // envelope (data.<field>); the cursor/more paths are relative
+            // to it.
+            $connpath = $page['connpath'] ?? null;
+            $conn = $body;
+            if (is_string($connpath) && '' !== $connpath) {
+                $sub = \Voxgig\Struct\Struct::getpath($body, $connpath);
+                if (null !== $sub) {
+                    $conn = $sub;
+                }
+            }
+
+            $cursorpath = $page['cursor'] ?? null;
+            if (is_string($cursorpath) && '' !== $cursorpath) {
+                $cursor = \Voxgig\Struct\Struct::getpath($conn, $cursorpath);
+                if (null !== $cursor) {
+                    $paging['cursor'] = $cursor;
+                }
+            }
+
+            $morepath = $page['more'] ?? null;
+            if (is_string($morepath) && '' !== $morepath) {
+                $more = \Voxgig\Struct\Struct::getpath($conn, $morepath);
+                if (is_bool($more)) {
+                    $paging['hasMore'] = $more;
+                    $explicit_more = true;
+                }
+            }
+        }
+
         // Body-level cursors.
         if (is_array($body)) {
             if (($body['next'] ?? null) !== null) {
@@ -113,13 +207,21 @@ class ProjectNamePagingFeature extends ProjectNameBaseFeature
             }
             if (is_bool($body['hasMore'] ?? null)) {
                 $paging['hasMore'] = $body['hasMore'];
+                $explicit_more = true;
             }
         }
 
-        $paging['hasMore'] = $paging['hasMore']
-            || $paging['next'] !== null
-            || $paging['cursor'] !== null
-            || $paging['nextPage'] !== null;
+        // 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 (!$explicit_more) {
+            $paging['hasMore'] = $paging['hasMore']
+                || $paging['next'] !== null
+                || $paging['cursor'] !== null
+                || $paging['nextPage'] !== null;
+        }
 
         $result->paging = $paging;
 

package/project/.sdk/tm/php/utility/Graphql.php

@@ -0,0 +1,176 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK utility: graphql
+//
+// 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:
+//
+//   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.
+
+class ProjectNameGraphql
+{
+    // Content type every GraphQL-over-HTTP request uses.
+    public const CONTENT_TYPE = '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`.
+    public static function errorCode(mixed $gqlerr): string
+    {
+        $ext = \Voxgig\Struct\Struct::getprop($gqlerr, 'extensions');
+        if (!is_array($ext)) {
+            $ext = [];
+        }
+
+        $raw = \Voxgig\Struct\Struct::getprop($ext, 'code');
+        if (null === $raw || '' === $raw) {
+            $raw = \Voxgig\Struct\Struct::getprop($ext, 'type');
+        }
+        $raw = strtoupper(is_string($raw) ? $raw : '');
+
+        if (str_contains($raw, 'AUTH') || str_contains($raw, 'FORBIDDEN')
+            || str_contains($raw, 'UNAUTHENTICATED')) {
+            return 'request_auth';
+        }
+        if (str_contains($raw, 'RATELIMIT') || str_contains($raw, 'RATE_LIMIT')
+            || str_contains($raw, 'TOO_MANY')) {
+            return 'request_ratelimit';
+        }
+        if (str_contains($raw, 'BAD_USER_INPUT') || str_contains($raw, 'VALIDATION')
+            || str_contains($raw, '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.
+    public static function body(ProjectNameContext $ctx): mixed
+    {
+        $gql = \Voxgig\Struct\Struct::getprop($ctx->point, 'graphql');
+        if (!is_array($gql)) {
+            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.
+        $reqsrc = $ctx->reqmatch;
+        $datasrc = $ctx->match;
+        if (null !== $ctx->op && 'data' === $ctx->op->input) {
+            $reqsrc = $ctx->reqdata;
+            $datasrc = $ctx->data;
+        }
+        if (!is_array($reqsrc)) {
+            $reqsrc = [];
+        }
+        if (!is_array($datasrc)) {
+            $datasrc = [];
+        }
+
+        $variables = [];
+
+        $varlist = \Voxgig\Struct\Struct::getprop($gql, 'vars');
+        if (!is_array($varlist)) {
+            $varlist = [];
+        }
+
+        foreach ($varlist as $spec) {
+            if (!is_array($spec)) {
+                continue;
+            }
+
+            $name = \Voxgig\Struct\Struct::getprop($spec, 'name');
+            $from = \Voxgig\Struct\Struct::getprop($spec, 'from');
+
+            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.
+                $body = [];
+                foreach ($reqsrc as $k => $v) {
+                    if ('$action' !== $k) {
+                        $body[$k] = $v;
+                    }
+                }
+                $variables[$name] = $body;
+                continue;
+            }
+
+            // Only send variables the caller actually supplied: sending an
+            // explicit null would clear a field on many APIs.
+            $val = \Voxgig\Struct\Struct::getprop($reqsrc, $from);
+            if (null === $val) {
+                $val = \Voxgig\Struct\Struct::getprop($datasrc, $from);
+            }
+            if (null !== $val) {
+                $variables[$name] = $val;
+            }
+        }
+
+        return [
+            'query' => \Voxgig\Struct\Struct::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. The raw envelope stays
+    // available on the result for callers that need it.
+    public static function errors(ProjectNameContext $ctx): bool
+    {
+        $result = $ctx->result;
+        $point = $ctx->point;
+
+        if (null === $result || null === $point) {
+            return false;
+        }
+
+        if ('graphql' !== \Voxgig\Struct\Struct::getprop($point, 'kind')) {
+            return false;
+        }
+
+        $errors = \Voxgig\Struct\Struct::getprop($result->body, 'errors');
+        if (!is_array($errors) || 0 === count($errors)) {
+            return false;
+        }
+
+        $first = $errors[0];
+        $msg = \Voxgig\Struct\Struct::getprop($first, 'message');
+        if (!is_string($msg) || '' === $msg) {
+            $msg = 'graphql error';
+        }
+        if (1 < count($errors)) {
+            $msg = $msg . ' (+' . (count($errors) - 1) . ' more)';
+        }
+
+        $result->err = $ctx->make_error(self::errorCode($first), 'graphql: ' . $msg);
+        $result->ok = false;
+
+        return true;
+    }
+}

package/project/.sdk/tm/php/utility/MakeOptions.php

@@ -80,7 +80,7 @@ class ProjectNameMakeOptions
             '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' => (object)[]]],
             'feature' => ['`$CHILD`' => ['`$OPEN`' => true, 'active' => false]],

package/project/.sdk/tm/php/utility/MakeResponse.php

@@ -29,6 +29,13 @@ class ProjectNameMakeResponse
         ($utility->result_basic)($ctx);
         ($utility->result_headers)($ctx);
         ($utility->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.
+        ($utility->graphql_errors)($ctx);
+
         ($utility->transform_response)($ctx);
 
         if ($result->err === null) {

package/project/.sdk/tm/php/utility/MakeSpec.php

@@ -3,6 +3,8 @@ declare(strict_types=1);
 
 // ProjectName SDK utility: make_spec
 
+require_once __DIR__ . '/Graphql.php';
+
 require_once __DIR__ . '/../core/Spec.php';
 
 class ProjectNameMakeSpec
@@ -46,8 +48,24 @@ class ProjectNameMakeSpec
         $ctx->spec->params = ($utility->prepare_params)($ctx);
         $ctx->spec->query = ($utility->prepare_query)($ctx);
         $ctx->spec->headers = ($utility->prepare_headers)($ctx);
-        $ctx->spec->body = ($utility->prepare_body)($ctx);
-        $ctx->spec->path = ($utility->prepare_path)($ctx);
+
+        if ('graphql' === \Voxgig\Struct\Struct::getprop($point, 'kind')) {
+            // 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.
+            $ctx->spec->body = ($utility->graphql_body)($ctx);
+            $ctx->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.
+            $ctx->spec->query = [];
+            $ctx->spec->headers['content-type'] = ProjectNameGraphql::CONTENT_TYPE;
+        } else {
+            $ctx->spec->body = ($utility->prepare_body)($ctx);
+            $ctx->spec->path = ($utility->prepare_path)($ctx);
+        }
 
         if ($ctx->ctrl->explain) {
             $ctx->ctrl->explain['spec'] = $ctx->spec;

package/project/.sdk/tm/php/utility/Register.php

@@ -23,6 +23,7 @@ require_once __DIR__ . '/MakeUrl.php';
 require_once __DIR__ . '/Param.php';
 require_once __DIR__ . '/PrepareAuth.php';
 require_once __DIR__ . '/PrepareBody.php';
+require_once __DIR__ . '/Graphql.php';
 require_once __DIR__ . '/PrepareHeaders.php';
 require_once __DIR__ . '/PrepareMethod.php';
 require_once __DIR__ . '/PrepareParams.php';
@@ -59,6 +60,8 @@ ProjectNameUtility::setRegistrar(function (ProjectNameUtility $u): void {
     $u->prepare_params = [ProjectNamePrepareParams::class, 'call'];
     $u->prepare_path = [ProjectNamePreparePath::class, 'call'];
     $u->prepare_query = [ProjectNamePrepareQuery::class, 'call'];
+    $u->graphql_body = [ProjectNameGraphql::class, 'body'];
+    $u->graphql_errors = [ProjectNameGraphql::class, 'errors'];
     $u->result_basic = [ProjectNameResultBasic::class, 'call'];
     $u->result_body = [ProjectNameResultBody::class, 'call'];
     $u->result_headers = [ProjectNameResultHeaders::class, 'call'];

package/project/.sdk/tm/py/{core → pkg/core}/context.py

@@ -3,14 +3,14 @@
 from __future__ import annotations
 import random
 
-from utility.voxgig_struct import voxgig_struct as vs
-from core.control import ProjectNameControl
-from core.operation import ProjectNameOperation
-from core.spec import ProjectNameSpec
-from core.result import ProjectNameResult
-from core.response import ProjectNameResponse
-from core.error import ProjectNameError
-from core.helpers import get_ctx_prop, to_map
+from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
+from projectname_sdk.core.control import ProjectNameControl
+from projectname_sdk.core.operation import ProjectNameOperation
+from projectname_sdk.core.spec import ProjectNameSpec
+from projectname_sdk.core.result import ProjectNameResult
+from projectname_sdk.core.response import ProjectNameResponse
+from projectname_sdk.core.error import ProjectNameError
+from projectname_sdk.core.helpers import get_ctx_prop, to_map
 
 
 class ProjectNameContext:

package/project/.sdk/tm/py/{core → pkg/core}/operation.py

@@ -1,7 +1,7 @@
 # ProjectName SDK operation
 
 from __future__ import annotations
-from utility.voxgig_struct import voxgig_struct as vs
+from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
 
 
 class ProjectNameOperation:

package/project/.sdk/tm/py/{core → pkg/core}/response.py

@@ -1,7 +1,7 @@
 # ProjectName SDK response
 
 from __future__ import annotations
-from utility.voxgig_struct import voxgig_struct as vs
+from projectname_sdk.utility.voxgig_struct import voxgig_struct as vs
 
 
 class ProjectNameResponse: