graphql-http 1.10.0 → 1.12.0

package/lib/audits/utils.js

@@ -19,7 +19,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertBodyAsExecutionResult = exports.assert = exports.audit = void 0;
+exports.ressert = exports.AuditError = exports.audit = void 0;
 __exportStar(require("../utils"), exports);
 /**
  * Wrap and prepare an audit for testing.
@@ -37,10 +37,10 @@ function audit(name, fn) {
                     status: 'ok',
                 };
             }
-            catch (errOrReason) {
-                if (typeof errOrReason !== 'string') {
-                    // anything thrown that is not an assertion string is considered fatal
-                    throw errOrReason;
+            catch (err) {
+                if (!(err instanceof AuditError)) {
+                    // anything thrown that is not an assertion error is considered fatal
+                    throw err;
                 }
                 return {
                     name,
@@ -49,7 +49,8 @@ function audit(name, fn) {
                             'error'
                         : // everything else is optional and considered a warning
                             'warn',
-                    reason: errOrReason,
+                    reason: err.reason,
+                    response: err.response,
                 };
             }
         },
@@ -57,71 +58,98 @@ function audit(name, fn) {
 }
 exports.audit = audit;
 /**
- * Will throw a string if the assertion fails.
+ * Error thrown when an assertion test fails.
  *
- * All fatal problems will throw an instance of Error.
+ * @private
+ */
+class AuditError {
+    constructor(response, reason) {
+        this.response = response;
+        this.reason = reason;
+    }
+}
+exports.AuditError = AuditError;
+/**
+ * Will throw an AuditError if the assertion on Response fails.
+ *
+ * All fatal problems will throw an instance of an Error.
+ *
+ * The name "ressert" is a wordplay combining "response" and "assert".
  *
  * @private
  */
-function assert(name, actual) {
+function ressert(res) {
     return {
-        toBe: (expected) => {
-            if (actual !== expected) {
-                throw `${name} ${actual} is not ${expected}`;
-            }
-        },
-        toBeBetween: (min, max) => {
-            if (!(min <= actual && actual <= max)) {
-                throw `${name} ${actual} is not between ${min} and ${max}`;
-            }
-        },
-        toContain: (expected) => {
-            // @ts-expect-error types will match, otherwise never
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (!actual.includes(expected)) {
-                throw `${name} ${JSON.stringify(actual)} does not contain ${JSON.stringify(expected)}`;
-            }
-        },
-        notToContain: (expected) => {
-            // @ts-expect-error types will match, otherwise never
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (actual.includes(expected)) {
-                throw `${name} ${JSON.stringify(actual)} contains ${JSON.stringify(expected)}`;
-            }
+        status: {
+            toBe(code) {
+                if (res.status !== code) {
+                    throw new AuditError(res, `Response status code is not ${code}`);
+                }
+            },
+            toBeBetween: (min, max) => {
+                if (!(min <= res.status && res.status <= max)) {
+                    throw new AuditError(res, `Response status is not between ${min} and ${max}`);
+                }
+            },
         },
-        toHaveProperty: (
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        prop) => {
-            // @ts-expect-error types will match, otherwise never
-            if (!(prop in actual)) {
-                throw `${name} ${JSON.stringify(actual)} does not have a property '${String(prop)}'`;
-            }
+        header(key) {
+            return {
+                toContain(part) {
+                    var _a;
+                    if (!((_a = res.headers.get(key)) === null || _a === void 0 ? void 0 : _a.includes(part))) {
+                        throw new AuditError(res, `Response header ${key} does not contain ${part}`);
+                    }
+                },
+                notToContain(part) {
+                    var _a;
+                    if ((_a = res.headers.get(key)) === null || _a === void 0 ? void 0 : _a.includes(part)) {
+                        throw new AuditError(res, `Response header ${key} contains ${part}`);
+                    }
+                },
+            };
         },
-        notToHaveProperty: (
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        prop) => {
-            // @ts-expect-error types will match, otherwise never
-            if (prop in actual) {
-                throw `${name} ${JSON.stringify(actual)} does have a property '${String(prop)}'`;
-            }
+        bodyAsExecutionResult: {
+            data: {
+                async toBe(val) {
+                    const body = await assertBodyAsExecutionResult(res);
+                    if (body.data !== val) {
+                        throw new AuditError(res, `Response body execution result data is not "${val}"`);
+                    }
+                },
+            },
+            async toHaveProperty(key) {
+                const body = await assertBodyAsExecutionResult(res);
+                if (!(key in body)) {
+                    throw new AuditError(res, `Response body execution result does not have a property "${key}"`);
+                }
+            },
+            async notToHaveProperty(key) {
+                const body = await assertBodyAsExecutionResult(res);
+                if (key in body) {
+                    throw new AuditError(res, `Response body execution result has a property "${key}"`);
+                }
+            },
         },
     };
 }
-exports.assert = assert;
-/**
- * Parses the string as JSON and safely reports parsing issues for audits.
- *
- * Assumes the parsed JSON will be an `ExecutionResult`.
- *
- * @private
- * */
+exports.ressert = ressert;
+/** @private */
 async function assertBodyAsExecutionResult(res) {
-    const str = await res.text();
+    let decoded;
+    try {
+        const decoder = new TextDecoder('utf-8');
+        const buff = await res.arrayBuffer();
+        decoded = decoder.decode(buff);
+    }
+    catch (err) {
+        throw new AuditError(res, 'Response body is not UTF-8 encoded');
+    }
+    let body;
     try {
-        return JSON.parse(str);
+        body = JSON.parse(decoded);
     }
     catch (err) {
-        throw `Response body is not valid JSON. Got ${JSON.stringify(str)}`;
+        throw new AuditError(res, 'Response body is not valid JSON');
     }
+    return body;
 }
-exports.assertBodyAsExecutionResult = assertBodyAsExecutionResult;

package/lib/audits/utils.mjs

@@ -20,10 +20,10 @@ export function audit(name, fn) {
                     status: 'ok',
                 };
             }
-            catch (errOrReason) {
-                if (typeof errOrReason !== 'string') {
-                    // anything thrown that is not an assertion string is considered fatal
-                    throw errOrReason;
+            catch (err) {
+                if (!(err instanceof AuditError)) {
+                    // anything thrown that is not an assertion error is considered fatal
+                    throw err;
                 }
                 return {
                     name,
@@ -32,76 +32,104 @@ export function audit(name, fn) {
                             'error'
                         : // everything else is optional and considered a warning
                             'warn',
-                    reason: errOrReason,
+                    reason: err.reason,
+                    response: err.response,
                 };
             }
         },
     };
 }
 /**
- * Will throw a string if the assertion fails.
+ * Error thrown when an assertion test fails.
  *
- * All fatal problems will throw an instance of Error.
+ * @private
+ */
+export class AuditError {
+    constructor(response, reason) {
+        this.response = response;
+        this.reason = reason;
+    }
+}
+/**
+ * Will throw an AuditError if the assertion on Response fails.
+ *
+ * All fatal problems will throw an instance of an Error.
+ *
+ * The name "ressert" is a wordplay combining "response" and "assert".
  *
  * @private
  */
-export function assert(name, actual) {
+export function ressert(res) {
     return {
-        toBe: (expected) => {
-            if (actual !== expected) {
-                throw `${name} ${actual} is not ${expected}`;
-            }
-        },
-        toBeBetween: (min, max) => {
-            if (!(min <= actual && actual <= max)) {
-                throw `${name} ${actual} is not between ${min} and ${max}`;
-            }
-        },
-        toContain: (expected) => {
-            // @ts-expect-error types will match, otherwise never
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (!actual.includes(expected)) {
-                throw `${name} ${JSON.stringify(actual)} does not contain ${JSON.stringify(expected)}`;
-            }
-        },
-        notToContain: (expected) => {
-            // @ts-expect-error types will match, otherwise never
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (actual.includes(expected)) {
-                throw `${name} ${JSON.stringify(actual)} contains ${JSON.stringify(expected)}`;
-            }
+        status: {
+            toBe(code) {
+                if (res.status !== code) {
+                    throw new AuditError(res, `Response status code is not ${code}`);
+                }
+            },
+            toBeBetween: (min, max) => {
+                if (!(min <= res.status && res.status <= max)) {
+                    throw new AuditError(res, `Response status is not between ${min} and ${max}`);
+                }
+            },
         },
-        toHaveProperty: (
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        prop) => {
-            // @ts-expect-error types will match, otherwise never
-            if (!(prop in actual)) {
-                throw `${name} ${JSON.stringify(actual)} does not have a property '${String(prop)}'`;
-            }
+        header(key) {
+            return {
+                toContain(part) {
+                    var _a;
+                    if (!((_a = res.headers.get(key)) === null || _a === void 0 ? void 0 : _a.includes(part))) {
+                        throw new AuditError(res, `Response header ${key} does not contain ${part}`);
+                    }
+                },
+                notToContain(part) {
+                    var _a;
+                    if ((_a = res.headers.get(key)) === null || _a === void 0 ? void 0 : _a.includes(part)) {
+                        throw new AuditError(res, `Response header ${key} contains ${part}`);
+                    }
+                },
+            };
         },
-        notToHaveProperty: (
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        prop) => {
-            // @ts-expect-error types will match, otherwise never
-            if (prop in actual) {
-                throw `${name} ${JSON.stringify(actual)} does have a property '${String(prop)}'`;
-            }
+        bodyAsExecutionResult: {
+            data: {
+                async toBe(val) {
+                    const body = await assertBodyAsExecutionResult(res);
+                    if (body.data !== val) {
+                        throw new AuditError(res, `Response body execution result data is not "${val}"`);
+                    }
+                },
+            },
+            async toHaveProperty(key) {
+                const body = await assertBodyAsExecutionResult(res);
+                if (!(key in body)) {
+                    throw new AuditError(res, `Response body execution result does not have a property "${key}"`);
+                }
+            },
+            async notToHaveProperty(key) {
+                const body = await assertBodyAsExecutionResult(res);
+                if (key in body) {
+                    throw new AuditError(res, `Response body execution result has a property "${key}"`);
+                }
+            },
         },
     };
 }
-/**
- * Parses the string as JSON and safely reports parsing issues for audits.
- *
- * Assumes the parsed JSON will be an `ExecutionResult`.
- *
- * @private
- * */
-export async function assertBodyAsExecutionResult(res) {
-    const str = await res.text();
+/** @private */
+async function assertBodyAsExecutionResult(res) {
+    let decoded;
+    try {
+        const decoder = new TextDecoder('utf-8');
+        const buff = await res.arrayBuffer();
+        decoded = decoder.decode(buff);
+    }
+    catch (err) {
+        throw new AuditError(res, 'Response body is not UTF-8 encoded');
+    }
+    let body;
     try {
-        return JSON.parse(str);
+        body = JSON.parse(decoded);
     }
     catch (err) {
-        throw `Response body is not valid JSON. Got ${JSON.stringify(str)}`;
+        throw new AuditError(res, 'Response body is not valid JSON');
     }
+    return body;
 }

package/lib/handler.js

@@ -326,41 +326,40 @@ exports.getAcceptableMediaType = getAcceptableMediaType;
  * @category Server
  */
 function makeResponse(resultOrErrors, acceptedMediaType) {
-    if ((0, utils_1.isExecutionResult)(resultOrErrors)) {
+    const errors = (0, utils_1.isGraphQLError)(resultOrErrors)
+        ? [resultOrErrors]
+        : (0, utils_1.areGraphQLErrors)(resultOrErrors)
+            ? resultOrErrors
+            : null;
+    if (errors) {
         return [
-            JSON.stringify(resultOrErrors),
-            {
-                status: 200,
-                statusText: 'OK',
-                headers: {
+            JSON.stringify({ errors }),
+            Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
+                ? {
+                    status: 200,
+                    statusText: 'OK',
+                }
+                : {
+                    status: 400,
+                    statusText: 'Bad Request',
+                })), { headers: {
                     'content-type': acceptedMediaType === 'application/json'
                         ? 'application/json; charset=utf-8'
                         : 'application/graphql-response+json; charset=utf-8',
-                },
-            },
+                } }),
         ];
     }
     return [
-        JSON.stringify({
-            errors: Array.isArray(resultOrErrors)
-                ? (0, utils_1.isObject)(resultOrErrors)
-                    ? resultOrErrors
-                    : new graphql_1.GraphQLError(String(resultOrErrors))
-                : [resultOrErrors],
-        }),
-        Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-            ? {
-                status: 200,
-                statusText: 'OK',
-            }
-            : {
-                status: 400,
-                statusText: 'Bad Request',
-            })), { headers: {
+        JSON.stringify(resultOrErrors),
+        {
+            status: 200,
+            statusText: 'OK',
+            headers: {
                 'content-type': acceptedMediaType === 'application/json'
                     ? 'application/json; charset=utf-8'
                     : 'application/graphql-response+json; charset=utf-8',
-            } }),
+            },
+        },
     ];
 }
 exports.makeResponse = makeResponse;

package/lib/handler.mjs

@@ -4,7 +4,7 @@
  *
  */
 import { validate as graphqlValidate, execute as graphqlExecute, parse as graphqlParse, getOperationAST as graphqlGetOperationAST, GraphQLError, } from 'graphql';
-import { areGraphQLErrors, isAsyncIterable, isExecutionResult, isObject, } from './utils.mjs';
+import { areGraphQLErrors, isAsyncIterable, isExecutionResult, isGraphQLError, isObject, } from './utils.mjs';
 /**
  * Checks whether the passed value is the `graphql-http` server agnostic response.
  *
@@ -320,41 +320,40 @@ export function getAcceptableMediaType(acceptHeader) {
  * @category Server
  */
 export function makeResponse(resultOrErrors, acceptedMediaType) {
-    if (isExecutionResult(resultOrErrors)) {
+    const errors = isGraphQLError(resultOrErrors)
+        ? [resultOrErrors]
+        : areGraphQLErrors(resultOrErrors)
+            ? resultOrErrors
+            : null;
+    if (errors) {
         return [
-            JSON.stringify(resultOrErrors),
-            {
-                status: 200,
-                statusText: 'OK',
-                headers: {
+            JSON.stringify({ errors }),
+            Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
+                ? {
+                    status: 200,
+                    statusText: 'OK',
+                }
+                : {
+                    status: 400,
+                    statusText: 'Bad Request',
+                })), { headers: {
                     'content-type': acceptedMediaType === 'application/json'
                         ? 'application/json; charset=utf-8'
                         : 'application/graphql-response+json; charset=utf-8',
-                },
-            },
+                } }),
         ];
     }
     return [
-        JSON.stringify({
-            errors: Array.isArray(resultOrErrors)
-                ? isObject(resultOrErrors)
-                    ? resultOrErrors
-                    : new GraphQLError(String(resultOrErrors))
-                : [resultOrErrors],
-        }),
-        Object.assign(Object.assign({}, (acceptedMediaType === 'application/json'
-            ? {
-                status: 200,
-                statusText: 'OK',
-            }
-            : {
-                status: 400,
-                statusText: 'Bad Request',
-            })), { headers: {
+        JSON.stringify(resultOrErrors),
+        {
+            status: 200,
+            statusText: 'OK',
+            headers: {
                 'content-type': acceptedMediaType === 'application/json'
                     ? 'application/json; charset=utf-8'
                     : 'application/graphql-response+json; charset=utf-8',
-            } }),
+            },
+        },
     ];
 }
 function getHeader(req, key) {

package/lib/use/koa.d.mts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import type { Middleware } from 'koa';
+import type { IncomingMessage } from 'http';
+import { HandlerOptions, OperationContext } from '../handler';
+/**
+ * Create a GraphQL over HTTP Protocol compliant request handler for
+ * the Koa framework.
+ *
+ * ```js
+ * import Koa from 'koa'; // yarn add koa
+ * import mount from 'koa-mount'; // yarn add koa-mount
+ * import { createHandler } from 'graphql-http/lib/use/koa';
+ * import { schema } from './my-graphql-schema';
+ *
+ * const app = new Koa();
+ * app.use(mount('/', createHandler({ schema })));
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/koa
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<IncomingMessage, undefined, Context>): Middleware;

package/lib/use/koa.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import type { Middleware } from 'koa';
+import type { IncomingMessage } from 'http';
+import { HandlerOptions, OperationContext } from '../handler';
+/**
+ * Create a GraphQL over HTTP Protocol compliant request handler for
+ * the Koa framework.
+ *
+ * ```js
+ * import Koa from 'koa'; // yarn add koa
+ * import mount from 'koa-mount'; // yarn add koa-mount
+ * import { createHandler } from 'graphql-http/lib/use/koa';
+ * import { schema } from './my-graphql-schema';
+ *
+ * const app = new Koa();
+ * app.use(mount('/', createHandler({ schema })));
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/koa
+ */
+export declare function createHandler<Context extends OperationContext = undefined>(options: HandlerOptions<IncomingMessage, undefined, Context>): Middleware;

package/lib/use/koa.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHandler = void 0;
+const handler_1 = require("../handler");
+/**
+ * Create a GraphQL over HTTP Protocol compliant request handler for
+ * the Koa framework.
+ *
+ * ```js
+ * import Koa from 'koa'; // yarn add koa
+ * import mount from 'koa-mount'; // yarn add koa-mount
+ * import { createHandler } from 'graphql-http/lib/use/koa';
+ * import { schema } from './my-graphql-schema';
+ *
+ * const app = new Koa();
+ * app.use(mount('/', createHandler({ schema })));
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/koa
+ */
+function createHandler(options) {
+    const isProd = process.env.NODE_ENV === 'production';
+    const handle = (0, handler_1.createHandler)(options);
+    return async function requestListener(ctx) {
+        try {
+            const [body, init] = await handle({
+                url: ctx.url,
+                method: ctx.method,
+                headers: ctx.headers,
+                body: () => {
+                    if (ctx.body) {
+                        // in case koa has a body parser
+                        return ctx.body;
+                    }
+                    return new Promise((resolve) => {
+                        let body = '';
+                        ctx.req.on('data', (chunk) => (body += chunk));
+                        ctx.req.on('end', () => resolve(body));
+                    });
+                },
+                raw: ctx.req,
+                context: undefined,
+            });
+            ctx.body = body;
+            ctx.response.status = init.status;
+            ctx.response.message = init.statusText;
+            if (init.headers) {
+                for (const [name, value] of Object.entries(init.headers)) {
+                    ctx.response.set(name, value);
+                }
+            }
+        }
+        catch (err) {
+            // The handler shouldnt throw errors.
+            // If you wish to handle them differently, consider implementing your own request handler.
+            console.error('Internal error occurred during request handling. ' +
+                'Please check your implementation.', err);
+            ctx.response.status = 500;
+            if (!isProd) {
+                ctx.response.set('content-type', 'application/json; charset=utf-8');
+                ctx.body = {
+                    errors: [
+                        err instanceof Error
+                            ? {
+                                message: err.message,
+                                stack: err.stack,
+                            }
+                            : err,
+                    ],
+                };
+            }
+        }
+    };
+}
+exports.createHandler = createHandler;