graphql-http 1.6.1 → 1.7.1

package/lib/audits/server.mjs

@@ -16,23 +16,25 @@ export function serverAudits(opts) {
         audit(
         // TODO: convert to MUST after watershed
         'SHOULD accept application/graphql-response+json and match the content-type', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{ __typename }');
-            const res = await fetchFn(url.toString(), {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
                 headers: {
+                    'content-type': 'application/json',
                     accept: 'application/graphql-response+json',
                 },
+                body: JSON.stringify({ query: '{ __typename }' }),
             });
             assert('Status code', res.status).toBe(200);
             assert('Content-Type header', res.headers.get('content-type')).toContain('application/graphql-response+json');
         }),
         audit('MUST accept application/json and match the content-type', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{ __typename }');
-            const res = await fetchFn(url.toString(), {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
                 headers: {
+                    'content-type': 'application/json',
                     accept: 'application/json',
                 },
+                body: JSON.stringify({ query: '{ __typename }' }),
             });
             assert('Status code', res.status).toBe(200);
             assert('Content-Type header', res.headers.get('content-type')).toContain('application/json');
@@ -40,12 +42,13 @@ export function serverAudits(opts) {
         audit(
         // TODO: convert to MUST after watershed
         'SHOULD accept */* and use application/graphql-response+json for the content-type', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{ __typename }');
-            const res = await fetchFn(url.toString(), {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
                 headers: {
+                    'content-type': 'application/json',
                     accept: '*/*',
                 },
+                body: JSON.stringify({ query: '{ __typename }' }),
             });
             assert('Status code', res.status).toBe(200);
             assert('Content-Type header', res.headers.get('content-type')).toContain('application/graphql-response+json');
@@ -53,16 +56,24 @@ export function serverAudits(opts) {
         audit(
         // TODO: convert to MUST after watershed
         'SHOULD assume application/graphql-response+json content-type when accept is missing', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{ __typename }');
-            const res = await fetchFn(url.toString());
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({ query: '{ __typename }' }),
+            });
             assert('Status code', res.status).toBe(200);
             assert('Content-Type header', res.headers.get('content-type')).toContain('application/graphql-response+json');
         }),
         audit('MUST use utf-8 encoding when responding', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{ __typename }');
-            const res = await fetchFn(url.toString());
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({ query: '{ __typename }' }),
+            });
             assert('Status code', res.status).toBe(200);
             // has charset set to utf-8
             try {
@@ -84,24 +95,27 @@ export function serverAudits(opts) {
                 throw 'Body is not UTF-8 encoded';
             }
         }),
-        audit('MUST accept only utf-8 charset', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{ __typename }');
-            const res = await fetchFn(url.toString(), {
+        audit('MUST accept utf-8 encoding', async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
                 headers: {
-                    accept: 'application/graphql-response+json; charset=iso-8859-1',
+                    'content-type': 'application/json; charset=utf-8',
                 },
+                body: JSON.stringify({ query: '{ __typename }' }),
             });
-            // application/json is 200 + errors
-            const contentType = res.headers.get('content-type') || '';
-            if (contentType.includes('application/json')) {
-                assert(`Content-Type ${contentType} status code`, res.status).toBe(200);
-                assert('Execution result', await assertBodyAsExecutionResult(res)).toHaveProperty('errors');
-                return;
-            }
-            // other content-types must be 4xx
-            assert(`Content-Type ${contentType} status code`, res.status).toBeGreaterThanOrEqual(400);
-            assert(`Content-Type ${contentType} status code`, res.status).toBeLessThanOrEqual(499);
+            assert('Status code', res.status).toBe(200);
+            assert('Content-Type header', res.headers.get('content-type')).toContain('utf-8');
+        }),
+        audit('MUST assume utf-8 if encoding is unspecified', async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({ query: '{ __typename }' }),
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Content-Type header', res.headers.get('content-type')).toContain('utf-8');
         }),
         // Request
         audit('MUST accept POST requests', async () => {
@@ -119,7 +133,8 @@ export function serverAudits(opts) {
             assert('Status code', res.status).toBe(200);
         }),
         // Request GET
-        audit('MUST NOT allow executing mutations on GET requests', async () => {
+        // TODO: this is a MUST if the server supports GET requests
+        audit('MAY NOT allow executing mutations on GET requests', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', 'mutation { __typename }');
             const res = await fetchFn(url.toString(), {
@@ -127,15 +142,14 @@ export function serverAudits(opts) {
                     accept: 'application/graphql-response+json',
                 },
             });
-            assert('Status code', res.status).toBe(405);
+            assert('Status code', res.status).toBeBetween(400, 499);
         }),
         // Request POST
         audit('SHOULD respond with 4xx status code if content-type is not supplied on POST requests', async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
             });
-            assert('Status code', res.status).toBeGreaterThanOrEqual(400);
-            assert('Status code', res.status).toBeLessThanOrEqual(499);
+            assert('Status code', res.status).toBeBetween(400, 499);
         }),
         audit('MUST accept application/json POST requests', async () => {
             const res = await fetchFn(opts.url, {
@@ -360,9 +374,7 @@ export function serverAudits(opts) {
             assert('Status code', res.status).toBe(200);
             assert('Execution result', await assertBodyAsExecutionResult(res)).notToHaveProperty('errors');
         }),
-        audit(
-        // TODO: convert to MUST after watershed
-        'SHOULD allow URL-encoded JSON string {variables} parameter in GETs when accepting application/graphql-response+json', async () => {
+        audit('MAY allow URL-encoded JSON string {variables} parameter in GETs when accepting application/graphql-response+json', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', 'query Type($name: String!) { __type(name: $name) { name } }');
             url.searchParams.set('variables', JSON.stringify({ name: 'sometype' }));
@@ -374,7 +386,7 @@ export function serverAudits(opts) {
             });
             assert('Status code', res.status).toBe(200);
         }),
-        audit('MUST allow URL-encoded JSON string {variables} parameter in GETs when accepting application/json', async () => {
+        audit('MAY allow URL-encoded JSON string {variables} parameter in GETs when accepting application/json', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', 'query Type($name: String!) { __type(name: $name) { name } }');
             url.searchParams.set('variables', JSON.stringify({ name: 'sometype' }));
@@ -463,29 +475,39 @@ export function serverAudits(opts) {
             assert('Status code', res.status).toBe(200);
         }),
         audit('SHOULD use 200 status code if parameters are invalid when accepting application/json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('qeury' /* typo */, '{ __typename }');
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    qeury: /* typo */ '{ __typename }',
+                }),
             });
             assert('Status code', res.status).toBe(200);
         }),
         audit('SHOULD use 200 status code on document parsing failure when accepting application/json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{');
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({ query: '{' }),
             });
             assert('Status code', res.status).toBe(200);
         }),
         audit('SHOULD use 200 status code on document validation failure when accepting application/json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{ 8f31403dfe404bccbb0e835f2629c6a7 }'); // making sure the field doesnt exist
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    query: '{ 8f31403dfe404bccbb0e835f2629c6a7 }', // making sure the field doesnt exist
+                }),
             });
             assert('Status code', res.status).toBe(200);
         }),
@@ -501,8 +523,7 @@ export function serverAudits(opts) {
                 },
                 body: '{ "not a JSON',
             });
-            assert('Status code', res.status).toBeGreaterThanOrEqual(400);
-            assert('Status code', res.status).toBeLessThanOrEqual(599);
+            assert('Status code', res.status).toBeBetween(400, 499);
         }),
         audit('SHOULD use 400 status code on JSON parsing failure when accepting application/graphql-response+json', async () => {
             const res = await fetchFn(opts.url, {
@@ -529,90 +550,123 @@ export function serverAudits(opts) {
         audit(
         // TODO: convert to MUST after watershed
         'SHOULD use 4xx or 5xx status codes if parameters are invalid when accepting application/graphql-response+json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('qeury' /* typo */, '{ __typename }');
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/graphql-response+json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/graphql-response+json',
+                },
+                body: JSON.stringify({
+                    qeury /* typo */: '{ __typename }',
+                }),
             });
-            assert('Status code', res.status).toBeGreaterThanOrEqual(400);
-            assert('Status code', res.status).toBeLessThanOrEqual(599);
+            assert('Status code', res.status).toBeBetween(400, 599);
         }),
         audit('SHOULD use 400 status code if parameters are invalid when accepting application/graphql-response+json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('qeury' /* typo */, '{ __typename }');
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/graphql-response+json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/graphql-response+json',
+                },
+                body: JSON.stringify({
+                    qeury: /* typo */ '{ __typename }',
+                }),
             });
             assert('Status code', res.status).toBe(400);
         }),
         audit('SHOULD not contain the data entry if parameters are invalid when accepting application/graphql-response+json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('qeury' /* typo */, '{ __typename }');
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/graphql-response+json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/graphql-response+json',
+                },
+                body: JSON.stringify({
+                    qeury: /* typo */ '{ __typename }',
+                }),
             });
             assert('Data entry', (await assertBodyAsExecutionResult(res)).data).toBe(undefined);
         }),
         audit(
         // TODO: convert to MUST after watershed
         'SHOULD use 4xx or 5xx status codes on document parsing failure when accepting application/graphql-response+json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{');
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/graphql-response+json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/graphql-response+json',
+                },
+                body: JSON.stringify({
+                    query: '{',
+                }),
             });
-            assert('Status code', res.status).toBeGreaterThanOrEqual(400);
-            assert('Status code', res.status).toBeLessThanOrEqual(599);
+            assert('Status code', res.status).toBeBetween(400, 599);
         }),
         audit('SHOULD use 400 status code on document parsing failure when accepting application/graphql-response+json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{');
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/graphql-response+json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/graphql-response+json',
+                },
+                body: JSON.stringify({
+                    query: '{',
+                }),
             });
             assert('Status code', res.status).toBe(400);
         }),
         audit('SHOULD not contain the data entry on document parsing failure when accepting application/graphql-response+json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{');
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/graphql-response+json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/graphql-response+json',
+                },
+                body: JSON.stringify({
+                    query: '{',
+                }),
             });
             assert('Data entry', (await assertBodyAsExecutionResult(res)).data).toBe(undefined);
         }),
         audit(
         // TODO: convert to MUST after watershed
         'SHOULD use 4xx or 5xx status codes on document validation failure when accepting application/graphql-response+json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{ 8f31403dfe404bccbb0e835f2629c6a7 }'); // making sure the field doesnt exist
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/graphql-response+json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/graphql-response+json',
+                },
+                body: JSON.stringify({
+                    query: '{ 8f31403dfe404bccbb0e835f2629c6a7 }', // making sure the field doesnt exist
+                }),
             });
-            assert('Status code', res.status).toBeGreaterThanOrEqual(400);
-            assert('Status code', res.status).toBeLessThanOrEqual(599);
+            assert('Status code', res.status).toBeBetween(400, 599);
         }),
         audit('SHOULD use 400 status code on document validation failure when accepting application/graphql-response+json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{ 8f31403dfe404bccbb0e835f2629c6a7 }'); // making sure the field doesnt exist
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/graphql-response+json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/graphql-response+json',
+                },
+                body: JSON.stringify({
+                    query: '{ 8f31403dfe404bccbb0e835f2629c6a7 }', // making sure the field doesnt exist
+                }),
             });
             assert('Status code', res.status).toBe(400);
         }),
         audit('SHOULD not contain the data entry on document validation failure when accepting application/graphql-response+json', async () => {
-            const url = new URL(opts.url);
-            url.searchParams.set('query', '{ 8f31403dfe404bccbb0e835f2629c6a7 }'); // making sure the field doesnt exist
-            const res = await fetchFn(url.toString(), {
-                method: 'GET',
-                headers: { accept: 'application/graphql-response+json' },
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/graphql-response+json',
+                },
+                body: JSON.stringify({
+                    query: '{ 8f31403dfe404bccbb0e835f2629c6a7 }', // making sure the field doesnt exist
+                }),
             });
             assert('Data entry', (await assertBodyAsExecutionResult(res)).data).toBe(undefined);
         }),

package/lib/audits/utils.d.mts

@@ -3,7 +3,7 @@
  * audit/utils
  *
  */
-import { ExecutionResult } from 'graphql';
+import type { ExecutionResult } from 'graphql';
 import { Audit, AuditName } from './common';
 export * from '../utils';
 /**
@@ -21,8 +21,7 @@ export declare function audit(name: AuditName, fn: () => Promise<void>): Audit;
  */
 export declare function assert<T = unknown>(name: string, actual: T): {
     toBe: (expected: T) => void;
-    toBeLessThanOrEqual: (expected: T extends number ? T : never) => void;
-    toBeGreaterThanOrEqual: (expected: T extends number ? T : never) => void;
+    toBeBetween: (min: T extends number ? T : never, max: T extends number ? T : never) => void;
     toContain: (expected: T extends (infer U)[] ? U : T extends string ? T : never) => void;
     notToContain: (expected: T extends (infer U_1)[] ? U_1 : T extends string ? T : never) => void;
     toHaveProperty: (prop: T extends Record<any, any> ? PropertyKey : never) => void;

package/lib/audits/utils.d.ts

@@ -3,7 +3,7 @@
  * audit/utils
  *
  */
-import { ExecutionResult } from 'graphql';
+import type { ExecutionResult } from 'graphql';
 import { Audit, AuditName } from './common';
 export * from '../utils';
 /**
@@ -21,8 +21,7 @@ export declare function audit(name: AuditName, fn: () => Promise<void>): Audit;
  */
 export declare function assert<T = unknown>(name: string, actual: T): {
     toBe: (expected: T) => void;
-    toBeLessThanOrEqual: (expected: T extends number ? T : never) => void;
-    toBeGreaterThanOrEqual: (expected: T extends number ? T : never) => void;
+    toBeBetween: (min: T extends number ? T : never, max: T extends number ? T : never) => void;
     toContain: (expected: T extends (infer U)[] ? U : T extends string ? T : never) => void;
     notToContain: (expected: T extends (infer U_1)[] ? U_1 : T extends string ? T : never) => void;
     toHaveProperty: (prop: T extends Record<any, any> ? PropertyKey : never) => void;

package/lib/audits/utils.js

@@ -70,14 +70,9 @@ function assert(name, actual) {
                 throw `${name} ${actual} is not ${expected}`;
             }
         },
-        toBeLessThanOrEqual: (expected) => {
-            if (!(actual <= expected)) {
-                throw `${name} ${actual} is not less than or equal to ${expected}`;
-            }
-        },
-        toBeGreaterThanOrEqual: (expected) => {
-            if (!(actual >= expected)) {
-                throw `${name} ${actual} is not greater than or equal to ${expected}`;
+        toBeBetween: (min, max) => {
+            if (!(min <= actual && actual <= max)) {
+                throw `${name} ${actual} is not between ${min} and ${max}`;
             }
         },
         toContain: (expected) => {

package/lib/audits/utils.mjs

@@ -52,14 +52,9 @@ export function assert(name, actual) {
                 throw `${name} ${actual} is not ${expected}`;
             }
         },
-        toBeLessThanOrEqual: (expected) => {
-            if (!(actual <= expected)) {
-                throw `${name} ${actual} is not less than or equal to ${expected}`;
-            }
-        },
-        toBeGreaterThanOrEqual: (expected) => {
-            if (!(actual >= expected)) {
-                throw `${name} ${actual} is not greater than or equal to ${expected}`;
+        toBeBetween: (min, max) => {
+            if (!(min <= actual && actual <= max)) {
+                throw `${name} ${actual} is not between ${min} and ${max}`;
             }
         },
         toContain: (expected) => {

package/lib/handler.d.mts

@@ -8,27 +8,25 @@ import { RequestParams } from './common';
 /**
  * The incoming request headers the implementing server should provide.
  *
- * @category Common
+ * @category Server
  */
-export interface RequestHeaders {
-    accept?: string | undefined;
-    allow?: string | undefined;
-    'content-type'?: string | undefined;
+export declare type RequestHeaders = {
     /**
      * Always an array in Node. Duplicates are added to it.
-     * Not necessarily true for other environments, make sure
-     * to check the type during runtime.
+     * Not necessarily true for other environments.
      */
     'set-cookie'?: string | string[] | undefined;
     [key: string]: string | string[] | undefined;
-}
+} | {
+    get: (key: string) => string | null;
+};
 /**
  * Server agnostic request interface containing the raw request
  * which is server dependant.
  *
- * @category Common
+ * @category Server
  */
-export interface Request<RawRequest, Context> {
+export interface Request<Raw, Context> {
     readonly method: string;
     readonly url: string;
     readonly headers: RequestHeaders;
@@ -45,7 +43,7 @@ export interface Request<RawRequest, Context> {
      * For example: `express.Request` when using Express, or maybe
      * `http.IncomingMessage` when just using Node with `http.createServer`.
      */
-    readonly raw: RawRequest;
+    readonly raw: Raw;
     /**
      * Context value about the incoming request, you're free to pass any information here.
      */
@@ -54,7 +52,7 @@ export interface Request<RawRequest, Context> {
 /**
  * The response headers that get returned from graphql-http.
  *
- * @category Common
+ * @category Server
  */
 export declare type ResponseHeaders = {
     accept?: string;
@@ -65,14 +63,14 @@ export declare type ResponseHeaders = {
  * Server agnostic response body returned from `graphql-http` needing
  * to be coerced to the server implementation in use.
  *
- * @category Common
+ * @category Server
  */
 export declare type ResponseBody = string;
 /**
  * Server agnostic response options (ex. status and headers) returned from
  * `graphql-http` needing to be coerced to the server implementation in use.
  *
- * @category Common
+ * @category Server
  */
 export interface ResponseInit {
     readonly status: number;
@@ -83,13 +81,13 @@ export interface ResponseInit {
  * Server agnostic response returned from `graphql-http` containing the
  * body and init options needing to be coerced to the server implementation in use.
  *
- * @category Common
+ * @category Server
  */
 export declare type Response = readonly [body: ResponseBody | null, init: ResponseInit];
 /**
  * Checks whether the passed value is the `graphql-http` server agnostic response.
  *
- * @category Common
+ * @category Server
  */
 export declare function isResponse(val: unknown): val is Response;
 /**
@@ -102,9 +100,13 @@ export declare function isResponse(val: unknown): val is Response;
  *
  * @category Server
  */
-export declare type ExecutionContext = object | symbol | number | string | boolean | undefined | null;
+export declare type OperationContext = Record<PropertyKey, unknown> | symbol | number | string | boolean | undefined | null;
+/** @category Server */
+export declare type OperationArgs<Context extends OperationContext = undefined> = ExecutionArgs & {
+    contextValue?: Context;
+};
 /** @category Server */
-export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
+export interface HandlerOptions<RequestRaw = unknown, RequestContext = unknown, Context extends OperationContext = undefined> {
     /**
      * The GraphQL schema on which the operations will
      * be executed and validated against.
@@ -121,13 +123,13 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    schema?: GraphQLSchema | ((req: Request<RawRequest, Context>, args: Omit<ExecutionArgs, 'schema'>) => Promise<GraphQLSchema | Response> | GraphQLSchema | Response);
+    schema?: GraphQLSchema | ((req: Request<RequestRaw, RequestContext>, args: Omit<OperationArgs<Context>, 'schema'>) => Promise<GraphQLSchema | Response> | GraphQLSchema | Response);
     /**
      * A value which is provided to every resolver and holds
      * important contextual information like the currently
      * logged in user, or access to a database.
      */
-    context?: ExecutionContext | ((req: Request<RawRequest, Context>, args: ExecutionArgs) => Promise<ExecutionContext | Response> | ExecutionContext | Response);
+    context?: Context | ((req: Request<RequestRaw, RequestContext>, params: RequestParams) => Promise<Context | Response> | Context | Response);
     /**
      * A custom GraphQL validate function allowing you to apply your
      * own validation rules.
@@ -176,7 +178,7 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    onSubscribe?: (req: Request<RawRequest, Context>, params: RequestParams) => Promise<ExecutionResult | ExecutionArgs | readonly GraphQLError[] | Response | void> | ExecutionResult | ExecutionArgs | readonly GraphQLError[] | Response | void;
+    onSubscribe?: (req: Request<RequestRaw, RequestContext>, params: RequestParams) => Promise<ExecutionResult | OperationArgs<Context> | readonly GraphQLError[] | Response | void> | ExecutionResult | OperationArgs<Context> | readonly GraphQLError[] | Response | void;
     /**
      * Executed after the operation call resolves.
      *
@@ -190,7 +192,7 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    onOperation?: (req: Request<RawRequest, Context>, args: ExecutionArgs, result: ExecutionResult) => Promise<ExecutionResult | Response | void> | ExecutionResult | Response | void;
+    onOperation?: (req: Request<RequestRaw, RequestContext>, args: OperationArgs<Context>, result: ExecutionResult) => Promise<ExecutionResult | Response | void> | ExecutionResult | Response | void;
 }
 /**
  * The ready-to-use handler. Simply plug it in your favourite HTTP framework
@@ -202,7 +204,7 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
  *
  * @category Server
  */
-export declare type Handler<RawRequest = unknown, Context = unknown> = (req: Request<RawRequest, Context>) => Promise<Response>;
+export declare type Handler<RequestRaw = unknown, RequestContext = unknown> = (req: Request<RequestRaw, RequestContext>) => Promise<Response>;
 /**
  * Makes a GraphQL over HTTP Protocol compliant server handler. The handler can
  * be used with your favourite server library.
@@ -258,7 +260,7 @@ export declare type Handler<RawRequest = unknown, Context = unknown> = (req: Req
  *
  * @category Server
  */
-export declare function createHandler<RawRequest = unknown, Context = unknown>(options: HandlerOptions<RawRequest, Context>): Handler<RawRequest, Context>;
+export declare function createHandler<RequestRaw = unknown, RequestContext = unknown, Context extends OperationContext = undefined>(options: HandlerOptions<RequestRaw, RequestContext, Context>): Handler<RequestRaw, RequestContext>;
 /**
  * Request's Media-Type that the server accepts.
  *