New

• Set Forwarded and X-Forwarded-For headers via GraphCDN edge workers.
• The GraphCDN CLI serve command now exposes a Purging API in addition to your cached GraphQL API in version 1.11.0
• Added a list of 3rd party subprocessors that GraphCDN uses at https://graphcdn.io/subprocessors.pdf

Fixed

• [Private Beta] If GraphCDN encounters an invalid JWT, requests will be passed on to your backend service instead of being treated like an unscoped request.

We are also working on a new version of our dashboard and shipped some internal improvements and prerequisites for that. See https://twitter.com/mxstbr/status/1516784404777123851 for a sneak peek.

If you want to purge specific results based on fields and arguments passed to your queries, you can use the _purgeQueryField(fields: [QueryFieldInput!]!) mutation.

The QueryFieldInput argument will be an enum based on your schema if you pushed your schema to GraphCDN (or have introspection enabled), or a string if GraphCDN doesn't have access to your schema.

As an example, let's say you have the following query as part of your application:

{
  package(name: "@urql/core") {
    __typname
    name
  }
}

You can then target the package field and purge the above result with the following mutation.

mutation {
  _purgeQueryField(fields: [
    {
      name: "package",
      args: { name: "@urql/core" }
    }
  ])
}

If you pushed your schema to GraphCDN, you could also use more specific mutations based on your schema definition. For example, you would also be able to use the following mutation.

mutation {
  purgeQuery_package(args: [{ name: "@urql/core }])
}

And you can, of course, pass in those arguments via variables as well.

Up to now, GraphCDN could cache GraphQL responses up to 2MB in size. If the response size was larger than this, the response could not be stored in the cache, and any future requests would be passed on to your backend service.

We are happy to announce that we could bump this limit and can now cache responses up to 10MB in size.

You can now define a set of request headers that will cause GraphCDN to bypass the cache and pass the request on to your origin. Any request you send that includes one of those headers (e.g. a x-preview-token header with any value) will not be cached.

You will see a new option called Bypass Headers in the cache configuration on your service dashboard.

However, you can also specify those headers via the graphcdn.yml in a new bypassCacheHeaders section.

name: my-app
schema: https://end.point
originUrl: https://end.point
bypassCacheHeaders:
    - name: x-preview-token
    - name: some-other-token
...

Common use cases for this feature are preview modes for e.g. a headless CMS or specific queries where you always want to get the latest data.

See https://docs.graphcdn.io/docs/bypass-headers for our documentation of this feature.

If you have this shiny "Powered by GraphCDN" badge in the footer of your website, we'll double your free monthly requests to 10M!

Copy-and-paste this HTML code into your website's footer, email us a link, and we'll unlock the extended free plan for you:

<a href="https://graphcdn.io">
  <img src="https://graphcdn.io/badge.svg" alt="Powered by GraphCDN" />
</a>

We now support signing up for GraphCDN, as well as signing in, via GitLab.com. We do not currently support self-hosted GitLab instances.

If there are other identity providers you are looking for, please let us know!

GraphCDN long supported running your service on a custom DNS name provided by you.

However, until now you weren't able to remove a custom domain once it was set and always had to reach out to our support team for changes.

With the latest improvements, you can now delete and reconfigure custom domain names via the dashboard.

We recently shipped support for automatic persisted queries (or APQ for short), which can help drastically reduce the size of your GraphQL payloads sent from your clients to GraphCDN edge locations.

Here is an example request using the { __typename } query. The initial request would look like the following curl command:

curl -g -X POST -H "Content-Type: application/json" \
  -d '{"query": "{__typename}", "extensions": {"persistedQuery": {"version":1, "sha256Hash": "ecf4edb46db40b5132295c0291d62fb65d6759a9eedfa4d5d612dd5ec54a6b38"}}}' \
  https://spacex-api.graphcdn.app

Subsequent requests for the same query would only need to use the hash of the operation, dropping the query key completely:

curl -g -X POST -H "Content-Type: application/json" \
  -d '{"extensions": {"persistedQuery":{"version":1,"sha256Hash": "ecf4edb46db40b5132295c0291d62fb65d6759a9eedfa4d5d612dd5ec54a6b38"}}}' \
  https://spacex-api.graphcdn.app

This example uses a quite small query, which doesn't show the full impact APQs can have. However, keep in mind that the query can be of arbitrary length, whereas the sha256 hash will always have a constant length.

You can read more about Automatic Persisted Queries on the Apollo Documentation at https://www.apollographql.com/docs/apollo-server/performance/apq/ (among other pages). And as with all our changes, we're always looking for your feedback. So let us know if you think we can improve support for APQs via support@graphcdn.io. 

GraphCDN now supports retrying some failed requests right from the edge cache. Instead of your application having to trigger a second network request, we can take care of that.

Retries are available for two types of errors, so-called Network Errors, i.e. any responses with an HTTP status code of 502, 503, 504, or in the 520 to 527 range. For those errors (and if HTTP status codes are used semantically correct) a retry might return a valid response as the underlying error condition might have been resolved. 

The second category is Server Errors, which includes all other HTTP/5xx status codes. In those cases, the chance of resolving the issue with a simple retry is lower, but it might still be a temporary issue and we want to give you the chance to decide whether to try again or not.

By default, any GraphCDN service is configured to not retry any requests. If you want to enable retries you need to set this up for each of your services.

To enable retries, configure them in your graphcdn.yml configuration file and push the new configuration to your service via graphcdn push

name: my-app-with-retries
# (your other GraphCDN configuration)
# ...
retries:
  networkErrors:
    isEnabled: true
    whenGraphQLResponse: false
  serverErrors:
    isEnabled: false

The whenGraphQLResponse option shown above indicates whether you want to retry a request even if the response includes a valid GraphQL payload. By default, any requests containing a valid GraphQL response won't be retried.

We continue to extend and improve our Alerts system. In addition to alerts via email, you can now also connect GraphCDN to your Slack workspace and have alerts show up in your Slack channels.

To use Slack, you'll first need to head over the to the _Integrations_ page for your organization (which is also new) and install the GraphCDN Slack application.

Once Slack is connected, you can select Slack when creating or editing an alert, and then select the Slack channel you'd like to send the alert to.

(As you can see, Max, one of our founders, is blown away by the new feature.)

As with all alerts you can fine-tune when notifications should be sent, and if you alert on GraphQL errors you can also filter based on the error code, or the path.

Which other systems would you like to use for Alerts? We have heard about PagerDuty from a couple of you, but what else is missing? And which other improvements would you like us to make with alerts? Let us know at support@graphcdn.io!