Skip to content
Go to file

Latest commit

* Bump typescript to latest

* Fix a typechecking bug that newer TypeScripts catch

Newer typescripts now catch a valid issue where a property was expected to be defined while being undefined. After bumping the compiler, this came up:

$ yarn run tsc --noEmit
src/ast.ts:374:52 - error TS2322: Type 'undefined' is not assignable to type 'ObjectPath'.

374     return { value: null, variables: [{ valueNode, path: undefined }] };

    338   path: ObjectPath;
    The expected type comes from property 'path' which is declared here on type 'MissingVariablePath'

Since this code has been like this for a while and works just fine, this just updates the types to reflect that the `path` of a `MissingVariablePath` can be undefined, and updates the functions that use it to be a bit simpler when it is undefined.

* Bump @types/node to fix a mismatched node types issue

Before this change, with the newer typescript compiler, this compile issue came up:

kamloop ~/C/graphql-jit (da80a9f...) ➜  yarn run tsc --noEmit
yarn run v1.22.4
$ /Users/airhorns/Code/graphql-jit/node_modules/.bin/tsc --noEmit
node_modules/@types/node/index.d.ts:177:11 - error TS2300: Duplicate identifier 'IteratorResult'.

177 interface IteratorResult<T> { }

    41 type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
    'IteratorResult' was also declared here.

node_modules/typescript/lib/lib.es2015.iterable.d.ts:41:6 - error TS2300: Duplicate identifier 'IteratorResult'.

41 type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;

    177 interface IteratorResult<T> { }
    'IteratorResult' was also declared here.

Bumping @types/node to reflect changes to typescript's internal lib types fixes this issue.

Git stats


Failed to load latest commit information.
Latest commit message
Commit time


Build Status codecov


GraphQL-JS is a very well written runtime implementation of the latest GraphQL spec. However, by compiling to JS, V8 is able to create optimized code which yields much better performance. graphql-jit leverages this behaviour of V8 optimization by compiling the queries into functions to significantly improve performance (See benchmarks below)


$ NODE_ENV=production ts-node -T ./src/__benchmarks__/benchmarks.ts skip-json
Starting introspection
graphql-js x 1,155 ops/sec ±1.55% (215 runs sampled)
graphql-jit x 5,961 ops/sec ±5.34% (216 runs sampled)
Starting fewResolvers
graphql-js x 14,313 ops/sec ±1.43% (224 runs sampled)
graphql-jit x 409,587 ops/sec ±1.08% (216 runs sampled)
Starting manyResolvers
graphql-js x 13,201 ops/sec ±1.50% (216 runs sampled)
graphql-jit x 229,025 ops/sec ±1.18% (216 runs sampled)
Starting nestedArrays
graphql-js x 108 ops/sec ±1.30% (216 runs sampled)
graphql-jit x 1,317 ops/sec ±2.38% (213 runs sampled)
Done in 141.94s.

Support for GraphQL spec

The goal is to support the June 2018 version of the GraphQL spec. At this moment, the only missing feature is support for the @skip and @include directives.

Differences to graphql-js

In order to achieve better performance, the graphql-jit compiler introduces some limitations. The primary limitation is that all computed properties must have a resolver and only these can return a Promise.


yarn add graphql-jit


For complete working examples, check the examples/ directory

Create a schema

const typedefs = `
type Query {
  hello: string
const resolvers = {
  Query: {
    hello() {
      return new Promise(resolve => setTimeout(() => resolve("World!"), 200));

const { makeExecutableSchema } = require("graphql");
const schema = makeExecutableSchema({ typedefs, resolvers });

Compile a Query

const query = `
const { parse } = require("graphql");
const document = parse(query);

const { compileQuery, isCompiledQuery } = require("graphql-jit");
const compiledQuery = compileQuery(schema, document);
// check if the compilation is successful

if (!isCompiledQuery(compiledQuery)) {
  throw new Error("Error compiling query");

Execute the Query

const executionResult = await compiledQuery.query();


compiledQuery = compileQuery(schema, document, operationName, compilerOptions)

Compiles the document AST, using an optional operationName and compiler options.

  • schema {GraphQLSchema} - graphql schema object

  • document {DocumentNode} - document query AST ,can be obtained by parse from graphql

  • operationName {string} - optional operation name in case the document contains multiple operations(queries/mutations/subscription).

  • compilerOptions {Object} - Configurable options for the compiler

    • disableLeafSerialization {boolean, default: false} - disables leaf node serializers. The serializers validate the content of the field at runtime so this option should only be set to true if there are strong assurances that the values are valid.
    • customSerializers {Object as Map, default: {}} - Replace serializer functions for specific types. Can be used as a safer alternative for overly expensive serializers
    • customJSONSerializer {boolean, default: false} - Whether to produce also a JSON serializer function using fast-json-stringify. The default stringifier function is JSON.stringify

compiledQuery.compiled(root: any, context: any, variables: Maybe<{ [key: string]: any }>)

the compiled function that can be called with a root value, a context and the required variables.

compiledQuery.stringify(value: any)

the compiled function for producing a JSON string. It will be JSON.stringify unless compilerOptions.customJSONSerializer is true. The value argument should the return of the compiled GraphQL function.



You can’t perform that action at this time.