GiraphQL now supports deno, but the server implmementations available for deno are relativly new and take a bit more effort to set up than on node



Most of the setup for deno works exactly the same way as it does for node. The main difference is where things are imported from. GiraphQL and all its plugins are published as a single package on Each of the node packages available on npm are available in the packages directory:

// Core
import SchemaBuilder from '';
// Plugins:
import ValidationPlugin from '';
import ScopeAuthPlugin from '';
// ...etc


Most of the docs and examples currently use apollo-server, because it is the simplest to set up for node. Unfortunately apollo-server does not work in deno. Instead we can use GraphQL Helix:

import { Application, Router } from '[email protected]/mod.ts';
// Currently the way helix exports graphiql doesn't work in deno, so we import the other parts directly, and import a very simple playground file from a gist.
import { shouldRenderGraphiQL } from '[email protected]/packages/deno/should-render-graphiql.ts';
import { processRequest } from '[email protected]/packages/deno/process-request.ts';
import { getGraphQLParameters } from '[email protected]/packages/deno/get-graphql-parameters.ts';
import playground from '';
// GiraphQL
import SchemaBuilder from '';
// Create app and router
const app = new Application();
const router = new Router();
// Create a very simple schema
const builder = new SchemaBuilder({});
fields: (t) => ({
hello: t.string({
args: {
name: t.arg.string({}),
resolve: (parent, { name }) => `hello, ${name || 'World'}`,
const schema = builder.toSchema({});
// Mount a route to serve the graphql API and playground
router.all('/graphql', async (context) => {
// parse request
const request = {
body: await context.request.body({}).value,
headers: context.request.headers,
method: context.request.method,
query: context.request.url.searchParams,
if (shouldRenderGraphiQL(request)) {
context.response.body = playground({ endpoint: 'localhost:8080/graphql' });
// Extract the GraphQL parameters from the request
const { operationName, query, variables } = getGraphQLParameters(request);
// Validate and execute the query
const result = await processRequest({
if (result.type === 'RESPONSE') {
// We set the provided status and headers and just the send the payload back to the client
result.headers.forEach(({ name, value }) => context.response.headers.set(name, value));
context.response.status = result.status;
context.response.body = result.payload;
} else {
// Omitting other response types for brevity, see graphql-helix docs for more a complete implementation
throw new Error('Unsupported result type');
console.log('Go to http://localhost:8080/graphql to open the playground');
await app.listen({ port: 8080 });

GraphQL versions

The graphql library is written in a way that make tools that import different copies of graphql incompatible. This means that we need a way to ensure that our graphql library versions are the same across our dependencies. There isn't a perfect solution right now, but import-maps give us something that works.

GiraphQL uses to make it easy to replace with an import map. GraphQL Helix currently uses[email protected]?dts

To get these 2 libraries to work together, we can define an import map like:

"imports": {
"[email protected]?dts": "[email protected]?dts",
"": "[email protected]?dts"

This will let us run our app with both libraries using[email protected]?dts (or any other version you want to use). It will be important to keep the versions in sync if you update your dependencies.

Running the app:

deno run --allow-net --import-map=import-map.json server-example.ts