App Deployments

import { type CodegenConfig } from '@graphql-codegen/cli'
 
const config: CodegenConfig = {
  schema: 'schema.graphql',
  documents: ['src/**/*.tsx'],
  generates: {
    './src/gql/': {
      preset: 'client',
      presetConfig: {
        persistedDocuments: true
      }
    }
  }
}

module.exports = {
  src: './src',
  language: 'javascript',
  schema: './data/schema.graphql',
  excludes: ['**/node_modules/**', '**/__mocks__/**', '**/__generated__/**'],
  persistConfig: {
    file: './persisted-documents.json'
  }
}

import { defineConfig } from '@graphql-hive/gateway'
 
export const gatewayConfig = defineConfig({
  persistedDocuments: {
    type: 'hive',
    // The endpoint of Hive's CDN
    endpoint: '<supergraph endpoint>',
    // The CDN token provided by Hive Registry
    key: '<cdn access token>'
  }
})

import { createYoga } from 'graphql-hive'
import { useHive } from '@graphql-hive/yoga'
import schema from './schema.js'
 
const yoga = createYoga({
  schema,
  plugins: [
    useHive({
      enabled: false
      experimental__persistedDocuments: {
        cdn: {
          // replace <target_id> and <cdn_access_token> with your values
          endpoint: 'https://cdn.graphql-hive.com/<target_id>',
          accessToken: '<cdn_access_token>'
        }
      }
    })
  ]
})

import { ApolloServer } from '@apollo/server'
import { useHive } from '@graphql-hive/apollo'
import schema from './schema.js'
 
const server = new ApolloServer({
  schema,
  plugins: [
    useHive({
      experimental__persistedDocuments: {
        cdn: {
          // replace <target_id> and <cdn_access_token> with your values
          endpoint: 'https://cdn.graphql-hive.com/<target_id>',
          accessToken: '<cdn_access_token>'
        }
      }
    })
  ]
})

GET https://cdn.graphql-hive.com/<target_id>/apps/<app_name>/<app_version>/<document_hash>

curl \
  -L \
  -H 'X-Hive-CDN-Key: CDN_ACCESS_TOKEN' \
  https://cdn.graphql-hive.com/<target_id>/apps/<app_name>/<app_version>/<document_hash>

POST /graphql
Content-Type: application/json
{
  "documentId": "<app_name>~<app_version>~<document_hash>",
}

curl \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{"documentId": "<app_name>~<app_version>~<document_hash>"}' \
  http://localhost:4000/graphql

import { ApolloClient, HttpLink, InMemoryCache } from '@apollo/client'
import { createPersistedQueryLink } from '@apollo/client/link/persisted-queries'
 
// replace <app_name>, <app_version>, and with your values
const appVersionPrefix = '<app_name>~<app_version>~'
 
const persistedQueriesLink = createPersistedQueryLink({
  generateHash(document) {
    // GraphQL Code Generator Client Preset generates
    // the persisted document ID within the document node.
    // For other implementations return the hash prefixed with the app version.
    if (document?.['__metadata__']?.['hash']) {
      throw Error('Hash not available for document')
    }
    return appVersionPrefix + document['__metadata__']['hash']
  }
})
 
const httpLink = new HttpLink({
  uri: '/graphql',
  fetch(url, init) {
    const parsedBody = JSON.parse(init!.body as string)
    return fetch(url, {
      ...init,
      body: JSON.stringify({
        variables: parsedBody.variables,
        documentId: parsedBody.extensions.persistedQuery.sha256Hash,
        extensions: { ...parsedBody.extensions, persistedQuery: undefined }
      })
    })
  }
})
 
const client = new ApolloClient({
  cache: new InMemoryCache(),
  link: persistedQueriesLink.concat(httpLink)
})

import { createClient, fetchExchange, mapExchange } from 'urql'
 
// replace <app_name>, <app_version>, and with your values
const appVersionPrefix = '<app_name>~<app_version>~'
 
const urqlClient = createClient({
  url: '/graphql',
  exchanges: [
    mapExchange({
      onOperation(op) {
        if (op.query?.['__metadata__']?.['hash']) {
          throw Error('Hash not available for document')
        }
 
        return {
          ...op,
          query: {
            documentId:
              // GraphQL Code Generator Client Preset generates
              // the persisted document ID within the document node.
              // For other implementations return the hash prefixed with the app version.
              appVersionPrefix + op.query['__meta__']['hash'],
            definitions: []
          }
        }
      }
    }),
    fetchExchange
  ]
})

// replace <app_name>, <app_version>, and with your values
const appVersionPrefix = '<app_name>~<app_version>~'
 
function fetchQuery(operation, variables) {
  if (!operation.id) {
    throw new Error('No persisted document hash provided.')
  }
 
  return fetch('/graphql', {
    method: 'POST',
    headers: {
      'content-type': 'application/json'
    },
    body: JSON.stringify({
      documentId: appVersionPrefix + operation.id,
      variables
    })
  }).then(response => response.json())
}