graphql-http 1.11.0 → 1.13.0

package/lib/audits/utils.d.mts

@@ -11,27 +11,46 @@ export * from '../utils';
  *
  * @private
  */
-export declare function audit(name: AuditName, fn: () => Promise<void>): Audit;
+export declare function audit(id: string, name: AuditName, fn: () => Promise<void>): Audit;
 /**
- * Will throw a string if the assertion fails.
- *
- * All fatal problems will throw an instance of Error.
+ * Error thrown when an assertion test fails.
  *
  * @private
  */
-export declare function assert<T = unknown>(name: string, actual: T): {
-    toBe: (expected: T) => 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;
-    notToHaveProperty: (prop: T extends Record<any, any> ? PropertyKey : never) => void;
-};
+export declare class AuditError {
+    /**
+     * Response from the server.
+     */
+    response: Response;
+    /**
+     * Reason for the failing audit.
+     */
+    reason: string;
+    constructor(response: Response, reason: string);
+}
 /**
- * Parses the string as JSON and safely reports parsing issues for audits.
+ * Will throw an AuditError if the assertion on Response fails.
+ *
+ * All fatal problems will throw an instance of an Error.
  *
- * Assumes the parsed JSON will be an `ExecutionResult`.
+ * The name "ressert" is a wordplay combining "response" and "assert".
  *
  * @private
- * */
-export declare function assertBodyAsExecutionResult(res: Response): Promise<ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>>>;
+ */
+export declare function ressert(res: Response): {
+    status: {
+        toBe(code: number): void;
+        toBeBetween: (min: number, max: number) => void;
+    };
+    header(key: 'content-type'): {
+        toContain(part: string): void;
+        notToContain(part: string): void;
+    };
+    bodyAsExecutionResult: {
+        data: {
+            toBe(val: ExecutionResult['data']): Promise<void>;
+        };
+        toHaveProperty(key: keyof ExecutionResult): Promise<void>;
+        notToHaveProperty(key: keyof ExecutionResult): Promise<void>;
+    };
+};

package/lib/audits/utils.d.ts

@@ -11,27 +11,46 @@ export * from '../utils';
  *
  * @private
  */
-export declare function audit(name: AuditName, fn: () => Promise<void>): Audit;
+export declare function audit(id: string, name: AuditName, fn: () => Promise<void>): Audit;
 /**
- * Will throw a string if the assertion fails.
- *
- * All fatal problems will throw an instance of Error.
+ * Error thrown when an assertion test fails.
  *
  * @private
  */
-export declare function assert<T = unknown>(name: string, actual: T): {
-    toBe: (expected: T) => 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;
-    notToHaveProperty: (prop: T extends Record<any, any> ? PropertyKey : never) => void;
-};
+export declare class AuditError {
+    /**
+     * Response from the server.
+     */
+    response: Response;
+    /**
+     * Reason for the failing audit.
+     */
+    reason: string;
+    constructor(response: Response, reason: string);
+}
 /**
- * Parses the string as JSON and safely reports parsing issues for audits.
+ * Will throw an AuditError if the assertion on Response fails.
+ *
+ * All fatal problems will throw an instance of an Error.
  *
- * Assumes the parsed JSON will be an `ExecutionResult`.
+ * The name "ressert" is a wordplay combining "response" and "assert".
  *
  * @private
- * */
-export declare function assertBodyAsExecutionResult(res: Response): Promise<ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>>>;
+ */
+export declare function ressert(res: Response): {
+    status: {
+        toBe(code: number): void;
+        toBeBetween: (min: number, max: number) => void;
+    };
+    header(key: 'content-type'): {
+        toContain(part: string): void;
+        notToContain(part: string): void;
+    };
+    bodyAsExecutionResult: {
+        data: {
+            toBe(val: ExecutionResult['data']): Promise<void>;
+        };
+        toHaveProperty(key: keyof ExecutionResult): Promise<void>;
+        notToHaveProperty(key: keyof ExecutionResult): Promise<void>;
+    };
+};

package/lib/audits/utils.js

@@ -19,37 +19,41 @@ 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.
  *
  * @private
  */
-function audit(name, fn) {
+function audit(id, name, fn) {
     return {
+        id,
         name,
         fn: async () => {
             try {
                 await fn();
                 return {
+                    id,
                     name,
                     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 {
+                    id,
                     name,
                     status: name.startsWith('MUST')
                         ? // only failing MUSTs are considered errors
                             'error'
                         : // everything else is optional and considered a warning
                             'warn',
-                    reason: errOrReason,
+                    reason: err.reason,
+                    response: err.response,
                 };
             }
         },
@@ -57,71 +61,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

@@ -9,99 +9,130 @@ export * from '../utils.mjs';
  *
  * @private
  */
-export function audit(name, fn) {
+export function audit(id, name, fn) {
     return {
+        id,
         name,
         fn: async () => {
             try {
                 await fn();
                 return {
+                    id,
                     name,
                     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 {
+                    id,
                     name,
                     status: name.startsWith('MUST')
                         ? // only failing MUSTs are considered errors
                             '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) {