query {
  postsWithThumbnail: posts( filter: {
    metaQuery: {
      key: "_thumbnail_id",
      compareBy: {
        key: { operator: EXISTS }
      }
    }
  } ) {
    id
    title
    featuredImage {
      src
    }
  }

  usersWithSpanishLocale: users( filter: {
    metaQuery: {
      key: "locale",
      compareBy: { stringValue: {
        operator: REGEXP
        value: "es_[A-Z]+"
      } }
    }
  } ) {
    id
    name
    locale: metaValue(key: "locale")
  }
}

query {
  timeNow: _time  
  time24HsAgo: _intSubstract(
    substract: 86400,
    from: $__timeNow
  )
  date24HsAgo: _date(
    format: "Y-m-d\\TH:i:sO",
    timestamp: $__time24HsAgo
  )  
  commentsAddedInLast24Hs: comments(
    filter: {
      dateQuery: {
        after: $__date24HsAgo
      }
    }
  ) {
    date
    content
    author {
      name
    }
  }
}

GRAPHQL_QUERY='
  query RetrieveData {
    users( filter: {
      metaQuery: {
        key: "locale",
        compareBy: { stringValue: {
          value: "es_[A-Z]+"
          operator: REGEXP
        } }
      }
    } ) {
      id @export(
        as: "userIDs",
        type: LIST
      )
    }
  }

  query FormatAndPrintData @depends(on: "RetrieveData") {
    spanishLocaleUserIDs: _arrayJoin(
      array: $userIDs,
      separator: " "
    )
  }
'
GRAPHQL_BODY="{\"operationName\": \"FormatAndPrintData\", \"query\": \"$(echo $GRAPHQL_QUERY | tr '\n' ' ' | sed 's/"/\\"/g')\"}"
GRAPHQL_RESPONSE=$(curl -X POST -H "Content-Type: application/json" -d $GRAPHQL_BODY https://mysite.com/graphql/)
SPANISH_LOCALE_USER_IDS=$(echo $GRAPHQL_RESPONSE | grep -E -o '"spanishLocaleUserIDs\":"((\d|\s)+)"' | cut -d':' -f2- | cut -d'"' -f2- | rev | cut -d'"' -f2- | rev)
for USER_ID in $(echo $SPANISH_LOCALE_USER_IDS); \
  do wp user update "$(echo $USER_ID)" --locale=es_AR; \
done

mutation {
  users {
    email
    displayName
    remainingCredits: metaValue(key: "credits")

    emailMessageTemplate: _strConvertMarkdownToHTML(
      text: """
Hello %s,

Your have **%s remaining credits** in your account.

Would you like to [buy more](%s)?
      """
    )
    emailMessage: _sprintf(
      string: $__emailMessageTemplate,
      values: [ $__displayName, $__remainingCredits, "https://mysite.com/buy-credits" ]
    )

    _sendEmail( input: {
      to: $__email
      subject: "Remaining credits alert"
      messageAs: {
        html: $__emailMessage
      }
    } ) {
      status
    }
  }
}

/** JavaScript: Fetch data to render the block on the client (CSR) */
import dryGraphQLQuery from './graphql-documents/fetch-posts-for-my-block.gql';

const response = await fetch(endpoint, {
  body: JSON.stringify({
    query: dryGraphQLQuery
  )
} );
// Do something with the data
// ...

use GatoGraphQL\InternalGraphQLServer\GraphQLServer;

/** PHP: Fetch data to render the block on the server (SSR) */
$block = [
  'render_callback' => function(array $attributes, string $content): string {
    $dryGraphQLQuery = __DIR__ . '/blocks/my-block/graphql-documents/fetch-posts-for-my-block.gql';
    $response = GraphQLServer::executeQueryInFile($dryGraphQLQuery);
    $responseContent = json_decode($response->getContent(), true);
    if (isset($responseContent["errors"]) {
      return __('Oops, executing the query produced errors');
    }
    $data = $responseContent["data"];
    // Do something with the data
    // $content = $this->useGraphQLData($content, $data);
    return $content;
  },
];
register_block_type("namespace/my-block", $block);

<script type="module">
import { h, render } from 'https://esm.sh/preact';
renderPost(1);
async function renderPost(postId) {
  const response = await fetch( "https://mysite.com/graphql/", {
    body: JSON.stringify( {
      query: `{ post(by: { id: ${ postId } }) { blockDataItems } }`
    } )
  } );
  const json = await response.json();
  if (json.errors) { return; }
  const blocks = json.data.post?.blockDataItems;
  const App = h('div', {}, blocks.map(mapBlockToComponent));
  render(App, document.body);
}
function mapBlockToComponent(block) {
  if (block.name === 'core/heading') return Heading(block);
  if (block.name === 'core/paragraph') return Paragraph(block);
  if (block.name === 'core/image') return Image(block);
  return null;
}
function Heading(props) {
  return h('h2', { dangerouslySetInnerHTML: { __html: props.attributes.content } });
}
function Paragraph(props) {
  return h('p', { dangerouslySetInnerHTML: { __html: props.attributes.content } });
}
function Image(props) {
  return h('img', { src: props.attributes.url });
}
</script>

query GetPostAndExportData($postId: ID!) {
  post(by: { id : $postId }) {
    author {
      id @export(as: "authorID")
    }
    categories {
      id @export(as: "categoryIDs", type: LIST)
    }
    rawContent @export(as: "rawContent")
    rawExcerpt @export(as: "excerpt")
    featuredImage {
      id @export(as: "featuredImageID")
    }
    tags {
      id @export(as: "tagIDs", type: LIST)
    }
    rawTitle @strAppend(string: " (Copy)") @export(as: "title")
  }
}

mutation DuplicatePost @depends(on: "GetPostAndExportData") {
  createPost(input: {
    authorBy: { id: $authorID },
    categoriesBy: { ids: $categoryIDs },
    contentAs: { html: $rawContent },
    excerpt: $excerpt
    featuredImageBy: { id: $featuredImageID },
    tagsBy: { ids: $tagIDs },
    title: $title
  }) {
    status
  }
}

query ExportConditionalVariables {
  me {
    roleNames @remove
    isAdminUser: _inArray(value: "administrator", array: $__roleNames)
      @export(as: "isAdminUser")
  }
}

query RetrieveContentForAdminUser($postId: ID!)
  @include(if: $isAdminUser)
{
  post(by: { id : $postId }) {
    originalContent: content @remove
    wpAdminEditURL @remove
    content: _sprintf(
      string: "%s<p><a href=\"%s\">%s</a></p>",
      values: [ $__originalContent, $__wpAdminEditURL, "(Admin only) Edit post" ]
    )
  }
}

query RetrieveContentForNonAdminUser($postId: ID!)
  @skip(if: $isAdminUser)
{
  post(by: { id : $postId }) {
    content
  }
}

query ExecuteAll
  @depends(on: ["ExportConditionalVariables", "RetrieveContentForAdminUser", "RetrieveContentForNonAdminUser"]
) {
  id @remove
}

query TransformAndExportData($replaceFrom: [String!]!, $replaceTo: [String!]!, $limit: Int! = 5, $offset: Int! = 0) {
  posts: posts( pagination: { limit: $limit, offset: $offset } ) {
    title
    excerpt
      @strReplaceMultiple(
        search: $replaceFrom
        replaceWith: $replaceTo
        affectAdditionalFieldsUnderPos: 1
      )
      @deferredExport(
        as: "postInputs"
        type: DICTIONARY
        affectAdditionalFieldsUnderPos: 1
      )
  }
}

mutation UpdatePost($limit: Int! = 5, $offset: Int! = 0)
  @depends(on: "TransformAndExportData")
{
  adaptedPosts: posts( pagination: { limit: $limit, offset: $offset } ) {
    id
    postInput: _objectProperty(
      object: $postInputs,
      by: { key: $__id }
    ) @remove
    update(input: $__postInput) {
      status
    }
  }
}

query ExportData($oldPageSlug: String!, $newPageSlug: String!) {
  siteURL: optionValue(name: "siteurl")
  oldPageURL: _strAppend(after: $__siteURL, append: $oldPageSlug)
    @export(as: "oldPageURL")
  newPageURL: _strAppend(after: $__siteURL, append: $newPageSlug)
    @export(as: "newPageURL")
}

mutation ReplaceOldWithNewURLInPosts
  @depends(on: "ExportData")
{
  posts( filter: { search: $oldPageURL } ) {
    id
    rawContent
    adaptedRawContent: _strReplace(
      search: $oldPageURL
      replaceWith: $newPageURL
      in: $__rawContent
    )
    update(input: {
      contentAs: { html: $__adaptedRawContent }
    }) {
      status
      post {
        title
        excerpt
      }
    }
  }
}

mutation InjectBlock($limit: Int! = 5, $offset: Int! = 0) {
  posts: posts( pagination: { limit: $limit, offset: $offset } ) {
    rawContent
    adaptedRawContent: _strRegexReplace(
      in: $__rawContent,
      searchRegex: "#(<!-- /wp:paragraph -->[\\s\\S]+<!-- /wp:paragraph -->[\\s\\S]+<!-- /wp:paragraph -->)#U",
      replaceWith: "$1<!-- mycompany:black-friday-campaign-video -->\n<figure class=\"wp-block-video\"><video controls src=\"https://mysite.com/videos/BlackFriday2023.mp4\"></video></figure>\n<!-- /mycompany:black-friday-campaign-video -->",
      limit: 1
    )
    update(input: { contentAs: { html: $__adaptedRawContent } }) {
      status
    }
  }
}

mutation RemoveBlock {
  posts(filter: { search: "\"<!-- /mycompany:black-friday-campaign-video -->\"" } ) {
    rawContent
    adaptedRawContent: _strRegexReplace(
      in: $__rawContent,
      searchRegex: "#(<!-- mycompany:black-friday-campaign-video -->[\\s\\S]+<!-- /mycompany:black-friday-campaign-video -->)#",
      replaceWith: ""
    )
    update(input: { contentAs: { html: $__adaptedRawContent } }) {
      status
    }
  }
}

query GetImageBlockImageURLs($postID: ID!) {
  post(by: { id: $postID } ) {
    coreImageURLs: blockFlattenedDataItems(
      filterBy: { include: "core/image" }
    )
      @underEachArrayItem(
        passValueOnwardsAs: "blockDataItem"
      )
        @applyField(
          name: "_objectProperty"
          arguments: {
            object: $blockDataItem,
            by: {
              path: "attributes.url"
            }
          }
          setResultInResponse: true
        )
      @arrayUnique
  }
}

use \GatoGraphQL\InternalGraphQLServer\GraphQLServer;

add_action(
  'wp_insert_post',
  function (int $postID, WP_Post $post) {
    // Provide the query to execute
    $query = '{ ... }';
    $variables = [
      'postTitle' => $post->post_title,
      'postContent' => $post->post_content,
      'postURL' => get_permalink($post->ID),
    ]
    GraphQLServer::executeQuery($query, $variables, 'SendEmail');
  },
  10,
  2
);

wp_schedule_event(
  time(),
  'daily',
  'gatographql__execute_persisted_query',
  [
    'daily-stats-by-email-number-of-comments',
    [ 'to' => ['admin@mysite.com'] ],
    'SendDailyStatsByEmailNumberOfComments',
    1 // This is the admin user's ID
  ]
);

query GetDataFromMailchimp {
  mailchimpListMembersJSONObject: _sendJSONObjectItemHTTPRequest(input: {
    url: "https://us7.api.mailchimp.com/3.0/lists/{LIST_ID}/members",
    method: GET,
    options: {
      auth: {
        username: "{ USER }",
        password: "{ API_TOKEN }"
      }
    }
  })
    @underJSONObjectProperty(by: { key: "members"})
      @underEachArrayItem
        @underJSONObjectProperty(by: { key: "email_address"})
          @export(as: "mailchimpListMemberEmails")
}

query GetUsersUsingMailchimpSubscriberEmails
  @depends(on: "GetDataFromMailchimp")
{
  users(filter: { searchBy: { emails: $mailchimpListMemberEmails } } ) {
    id
    name
    email
  }
}

query {
  usersWithWebsiteURL: _sendJSONObjectCollectionHTTPRequest(
    input: {
      url: "https://some-wp-rest-api.com/wp-json/wp/v2/users/?_fields=id,name,url"
    }
  )
    @underEachArrayItem(
      passValueOnwardsAs: "userDataEntry"
      affectDirectivesUnderPos: [1, 2, 3]
    )
      @applyField(
        name: "_objectProperty"
        arguments: {
          object: $userDataEntry
          by: {
            key: "url"
          }
        }
        passOnwardsAs: "websiteURL"
      )
      @applyField(
        name: "_isEmpty"
        arguments: {
          value: $websiteURL
        }
        passOnwardsAs: "isWebsiteURLEmpty"
      )
      @if(condition: $isWebsiteURLEmpty)
        @setNull
    @arrayFilter
}