hono 1.3.6 → 1.4.2

package/README.md

@@ -38,13 +38,13 @@ app.fire()
 **Hono is fastest**, compared to other routers for Cloudflare Workers.
 
 ```plain
-hono - trie-router(default) x 737,602 ops/sec ±3.65% (67 runs sampled)
-hono - regexp-router x 1,188,203 ops/sec ±6.42% (60 runs sampled)
-itty-router x 163,970 ops/sec ±3.05% (91 runs sampled)
-sunder x 344,468 ops/sec ±0.87% (97 runs sampled)
-worktop x 222,044 ops/sec ±2.13% (85 runs sampled)
+hono - trie-router(default) x 724,143 ops/sec ±3.63% (80 runs sampled)
+hono - regexp-router x 1,236,810 ops/sec ±6.77% (72 runs sampled)
+itty-router x 161,786 ops/sec ±2.28% (97 runs sampled)
+sunder x 312,262 ops/sec ±2.59% (85 runs sampled)
+worktop x 224,979 ops/sec ±1.13% (96 runs sampled)
 Fastest is hono - regexp-router
-✨  Done in 84.04s.
+✨  Done in 95.05s.
 ```
 
 ## Why so fast?
@@ -137,15 +137,15 @@ npm install hono
 
 An instance of `Hono` has these methods.
 
-- app.**HTTP_METHOD**(\[パス,\]handler|middleware...)
-- app.**all**(\[パス,\]handler|middleware...)
-- app.**route**(パス, \[app\])
-- app.**use**(\[パス,\]middleware)
+- app.**HTTP_METHOD**(\[path,\]handler|middleware...)
+- app.**all**(\[path,\]handler|middleware...)
+- app.**route**(path, \[app\])
+- app.**use**(\[path,\]middleware)
 - app.**notFound**(handler)
 - app.**onError**(err, handler)
 - app.**fire**()
 - app.**fetch**(request, env, event)
-- app.**request**(パス, options)
+- app.**request**(path, options)
 
 ## Routing
 
@@ -249,12 +249,37 @@ app.route('/book', book)
 
 ## Middleware
 
-Middleware operate after/before executing Handler. We can get `Response` before dispatching or manipulate `Response` after dispatching.
+Middleware works after/before Handler. We can get `Request` before dispatching or manipulate `Response` after dispatching.
 
 ### Definition of Middleware
 
-- Handler - should return `Response` object.
-- Middleware - should return nothing, do `await next()`
+- Handler - should return `Response` object. Only one handler will be called.
+- Middleware - should return nothing, will be proceeded to next middleware with `await next()`
+
+The user can register middleware using `c.use` or using `c.HTTP_METHOD` as well as the handlers. For this feature, it's easy to specify the path and the method.
+
+```ts
+// match any method, all routes
+app.use('*', logger())
+
+// specify path
+app.use('/posts/*', cors())
+
+// specify method and path
+app.post('/posts/*', basicAuth(), bodyParse())
+```
+
+If the handler returns `Response`, it will be used for the end-user, and stopping the processing.
+
+```ts
+app.post('/posts', (c) => c.text('Created!', 201))
+```
+
+In this case, four middleware are processed before dispatching like this:
+
+```ts
+logger() -> cors() -> basicAuth() -> bodyParse() -> *handler*
+```
 
 ### Built-in Middleware
 
@@ -390,7 +415,6 @@ The Response is the same as below.
 ```ts
 new Response('Thank you for comming', {
   status: 201,
-  statusText: 'Created',
   headers: {
     'X-Message': 'Hello',
     'Content-Type': 'text/plain',
@@ -518,14 +542,47 @@ test('GET /hello is ok', async () => {
 })
 ```
 
-## routerClass
+## router
 
-The `routerClass` option specify which router is used inside. The default router is `TrieRouter`. If you want to use `RexExpRouter`, write like this:
+The `router` option specify which router is used inside. The default router is `TrieRouter`. If you want to use `RexExpRouter`, write like this:
 
 ```ts
 import { RegExpRouter } from 'hono/router/reg-exp-router'
 
-const app = new Hono({ routerClass: RegExpRouter })
+const app = new Hono({ router: new RegExpRouter() })
+```
+
+## Routing Ordering
+
+The routing priority is decided by the order of registration. Only one handler will be dispatched.
+
+```ts
+app.get('/book/a', (c) => c.text('a')) // a
+app.get('/book/:slug', (c) => c.text('common')) // common
+```
+
+```http
+GET /book/a ---> `a` // common will not be dispatched
+GET /book/b ---> `common` // a will not be dispatched
+```
+
+All scoring rules:
+
+```ts
+app.get('/api/*', 'c') // score 1.1 <--- `/*` is special wildcard
+app.get('/api/:type/:id', 'd') // score 3.2
+app.get('/api/posts/:id', 'e') // score 3.3
+app.get('/api/posts/123', 'f') // score 3.4
+app.get('/*/*/:id', 'g') // score 3.5
+app.get('/api/posts/*/comment', 'h') // score 4.6 - not match
+app.get('*', 'a') // score 0.7
+app.get('*', 'b') // score 0.8
+```
+
+```plain
+GET /api/posts/123
+---> will match => c, d, e, f, b, a, b
+---> sort by score => a, b, c, d, e, f, g
 ```
 
 ## Cloudflare Workers with Hono
@@ -615,6 +672,7 @@ export interface Bindings {
 }
 
 const api = new Hono<Bindings>()
+api.use('/posts/*', cors())
 
 api.get('/posts', (c) => {
   const { limit, offset } = c.req.query()
@@ -641,8 +699,6 @@ api.post(
   }
 )
 
-app.use('/posts/*', cors())
-
 app.route('/api', api)
 
 export default app

package/dist/compose.d.ts

@@ -1,2 +1,2 @@
 import type { ErrorHandler, NotFoundHandler } from './hono';
-export declare const compose: <C>(middleware: Function[], onError?: ErrorHandler, onNotFound?: NotFoundHandler) => (context: C, next?: Function) => Promise<C>;
+export declare const compose: <C>(middleware: Function[], onError?: ErrorHandler<import("./context").Env> | undefined, onNotFound?: NotFoundHandler<import("./context").Env> | undefined) => (context: C, next?: Function | undefined) => Promise<C>;

package/dist/compose.js

@@ -13,12 +13,12 @@ const compose = (middleware, onError, onNotFound) => {
             }
             let handler = middleware[i];
             index = i;
-            if (i === middleware.length)
+            if (i === middleware.length && next)
                 handler = next;
-            if (handler === undefined) {
-                if (context instanceof context_1.Context && context.res.finalized === false) {
+            if (!handler) {
+                if (context instanceof context_1.Context && context.res._finalized === false && onNotFound) {
                     context.res = onNotFound(context);
-                    context.res.finalized = true;
+                    context.res._finalized = true;
                 }
                 return Promise.resolve(context);
             }
@@ -27,16 +27,15 @@ const compose = (middleware, onError, onNotFound) => {
                 // If handler return Response like `return c.text('foo')`
                 if (res && context instanceof context_1.Context) {
                     context.res = res;
-                    context.res.finalized = true;
-                    await dispatch(i + 1); // <--- Call next()
+                    context.res._finalized = true;
                 }
                 return context;
             })
                 .catch((err) => {
-                if (onError && context instanceof context_1.Context) {
+                if (context instanceof context_1.Context && onError) {
                     if (err instanceof Error) {
                         context.res = onError(err, context);
-                        context.res.finalized = true;
+                        context.res._finalized = true;
                     }
                     return context;
                 }

package/dist/context.d.ts

@@ -1,14 +1,14 @@
 /// <reference types="@cloudflare/workers-types" />
+import { HonoResponse } from './response';
 import type { StatusCode } from './utils/http-status';
 declare type Headers = Record<string, string>;
-declare type Data = string | ArrayBuffer | ReadableStream;
+export declare type Data = string | ArrayBuffer | ReadableStream;
 export declare type Env = Record<string, any>;
 export declare class Context<RequestParamKeyType extends string = string, E = Env> {
     req: Request<RequestParamKeyType>;
     res: Response;
     env: E;
-    event: FetchEvent;
-    private _headers;
+    event: FetchEvent | undefined;
     private _status;
     private _pretty;
     private _prettySpace;
@@ -16,9 +16,9 @@ export declare class Context<RequestParamKeyType extends string = string, E = En
     render: (template: string, params?: object, options?: object) => Promise<Response>;
     notFound: () => Response | Promise<Response>;
     constructor(req: Request<RequestParamKeyType>, opts?: {
-        env: E;
-        event: FetchEvent;
-        res?: Response;
+        env?: Env;
+        event?: FetchEvent;
+        res?: Response | HonoResponse;
     });
     private initRequest;
     header(name: string, value: string): void;
@@ -26,7 +26,7 @@ export declare class Context<RequestParamKeyType extends string = string, E = En
     set(key: string, value: any): void;
     get(key: string): any;
     pretty(prettyJSON: boolean, space?: number): void;
-    newResponse(data: Data, init?: ResponseInit): Response;
+    newResponse(data: Data | null, init?: ResponseInit): Response;
     body(data: Data | null, status?: StatusCode, headers?: Headers): Response;
     text(text: string, status?: StatusCode, headers?: Headers): Response;
     json(object: object, status?: StatusCode, headers?: Headers): Response;

package/dist/context.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
+const response_1 = require("./response");
 const url_1 = require("./utils/url");
 class Context {
-    constructor(req, opts) {
-        this._headers = {};
+    constructor(req, opts = {
+        env: {},
+        event: undefined,
+        res: undefined,
+    }) {
         this._status = 200;
         this._pretty = false;
         this._prettySpace = 2;
@@ -12,8 +16,8 @@ class Context {
         this._map = {};
         Object.assign(this, opts);
         if (!this.res) {
-            const res = new Response(null, { status: 404 });
-            res.finalized = false;
+            const res = new response_1.HonoResponse(null, { status: 404 });
+            res._finalized = false;
             this.res = res;
         }
     }
@@ -38,7 +42,7 @@ class Context {
             else {
                 const result = {};
                 for (const key of url.searchParams.keys()) {
-                    result[key] = url.searchParams.get(key);
+                    result[key] = url.searchParams.get(key) || '';
                 }
                 return result;
             }
@@ -59,10 +63,7 @@ class Context {
         return req;
     }
     header(name, value) {
-        if (this.res) {
-            this.res.headers.set(name, value);
-        }
-        this._headers[name] = value;
+        this.res.headers.set(name, value);
     }
     status(status) {
         this._status = status;
@@ -79,10 +80,14 @@ class Context {
     }
     newResponse(data, init = {}) {
         init.status = init.status || this._status || 200;
-        init.headers = Object.assign(Object.assign({}, this._headers), init.headers);
+        const headers = {};
+        this.res.headers.forEach((v, k) => {
+            headers[k] = v;
+        });
+        init.headers = Object.assign(headers, init.headers);
         return new Response(data, init);
     }
-    body(data, status = this._status, headers = this._headers) {
+    body(data, status = this._status, headers = {}) {
         return this.newResponse(data, {
             status: status,
             headers: headers,

package/dist/hono.d.ts

@@ -22,10 +22,10 @@ declare global {
         };
     }
     interface Response {
-        finalized: boolean;
+        _finalized: boolean;
     }
 }
-export declare type Handler<RequestParamKeyType extends string = string, E = Env> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | void | Promise<void>;
+export declare type Handler<RequestParamKeyType extends string = string, E = Env> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | Promise<void> | Promise<Response | undefined>;
 export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response;
 export declare type ErrorHandler<E = Env> = (err: Error, c: Context<string, E>) => Response;
 export declare type Next = () => Promise<void>;
@@ -44,26 +44,22 @@ interface Route<E extends Env> {
     handler: Handler<string, E>;
 }
 declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
-    delete: HandlerInterface<T, E_1, U>;
-    get: HandlerInterface<T, E_1, U>;
     all: HandlerInterface<T, E_1, U>;
+    get: HandlerInterface<T, E_1, U>;
     post: HandlerInterface<T, E_1, U>;
     put: HandlerInterface<T, E_1, U>;
+    delete: HandlerInterface<T, E_1, U>;
     head: HandlerInterface<T, E_1, U>;
     options: HandlerInterface<T, E_1, U>;
     patch: HandlerInterface<T, E_1, U>;
 };
 export declare class Hono<E = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
-    readonly routerClass: {
-        new (): Router<any>;
-    };
+    readonly router: Router<Handler<string, E>>;
     readonly strict: boolean;
-    private _router;
     private _tempPath;
     private path;
-    private _cacheResponse;
     routes: Route<E>[];
-    constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
+    constructor(init?: Partial<Pick<Hono, 'router' | 'strict'>>);
     private notFoundHandler;
     private errorHandler;
     route(path: string, app?: Hono<any>): Hono<E, P>;

package/dist/hono.js

@@ -4,7 +4,6 @@ exports.Hono = void 0;
 const compose_1 = require("./compose");
 const context_1 = require("./context");
 const router_1 = require("./router");
-const router_2 = require("./router");
 const trie_router_1 = require("./router/trie-router"); // Default Router
 const url_1 = require("./utils/url");
 const methods = ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'];
@@ -15,8 +14,9 @@ function defineDynamicClass() {
 class Hono extends defineDynamicClass() {
     constructor(init = {}) {
         super();
-        this.routerClass = trie_router_1.TrieRouter;
+        this.router = new trie_router_1.TrieRouter();
         this.strict = true; // strict routing - default is true
+        this._tempPath = '';
         this.path = '/';
         this.routes = [];
         this.notFoundHandler = (c) => {
@@ -28,7 +28,7 @@ class Hono extends defineDynamicClass() {
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
-        const allMethods = [...methods, router_2.METHOD_NAME_ALL_LOWERCASE];
+        const allMethods = [...methods, router_1.METHOD_NAME_ALL_LOWERCASE];
         allMethods.map((method) => {
             this[method] = (args1, ...args) => {
                 if (typeof args1 === 'string') {
@@ -46,10 +46,6 @@ class Hono extends defineDynamicClass() {
             };
         });
         Object.assign(this, init);
-        this._router = new this.routerClass();
-        this._tempPath = null;
-        this._cacheResponse = new Response(null, { status: 404 });
-        this._cacheResponse.finalized = false;
     }
     route(path, app) {
         this._tempPath = path;
@@ -57,7 +53,7 @@ class Hono extends defineDynamicClass() {
             app.routes.map((r) => {
                 this.addRoute(r.method, r.path, r.handler);
             });
-            this._tempPath = null;
+            this._tempPath = '';
         }
         return this;
     }
@@ -86,12 +82,12 @@ class Hono extends defineDynamicClass() {
         if (this._tempPath) {
             path = (0, url_1.mergePath)(this._tempPath, path);
         }
-        this._router.add(method, path, handler);
+        this.router.add(method, path, handler);
         const r = { path: path, method: method, handler: handler };
         this.routes.push(r);
     }
     async matchRoute(method, path) {
-        return this._router.match(method, path);
+        return this.router.match(method, path);
     }
     async dispatch(request, event, env) {
         const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
@@ -106,12 +102,12 @@ class Hono extends defineDynamicClass() {
                     return result.params;
                 }
             }
+            return null;
         });
         const handlers = result ? result.handlers : [this.notFoundHandler];
         const c = new context_1.Context(request, {
             env: env,
             event: event,
-            res: this._cacheResponse,
         });
         c.notFound = () => this.notFoundHandler(c);
         const composed = (0, compose_1.compose)(handlers, this.errorHandler, this.notFoundHandler);
@@ -123,6 +119,7 @@ class Hono extends defineDynamicClass() {
             if (err instanceof Error) {
                 return this.errorHandler(err, c);
             }
+            throw err;
         }
         if (!context.res)
             return context.notFound();

package/dist/middleware/basic-auth/index.js

@@ -15,7 +15,7 @@ const auth = (req) => {
     if (!req.headers || typeof req.headers !== 'object') {
         throw new TypeError('argument req is required to have headers property');
     }
-    const match = CREDENTIALS_REGEXP.exec(req.headers.get('Authorization'));
+    const match = CREDENTIALS_REGEXP.exec(req.headers.get('Authorization') || '');
     if (!match) {
         return undefined;
     }
@@ -34,6 +34,7 @@ const basicAuth = (options, ...users) => {
     }
     users.unshift({ username: options.username, password: options.password });
     return async (ctx, next) => {
+        var _a;
         const requestUser = auth(ctx.req);
         if (requestUser) {
             for (const user of users) {
@@ -49,7 +50,7 @@ const basicAuth = (options, ...users) => {
         ctx.res = new Response('Unauthorized', {
             status: 401,
             headers: {
-                'WWW-Authenticate': 'Basic realm="' + options.realm.replace(/"/g, '\\"') + '"',
+                'WWW-Authenticate': 'Basic realm="' + ((_a = options.realm) === null || _a === void 0 ? void 0 : _a.replace(/"/g, '\\"')) + '"',
             },
         });
     };

package/dist/middleware/cookie/index.js

@@ -4,7 +4,7 @@ exports.cookie = void 0;
 const cookie = () => {
     return async (c, next) => {
         c.req.cookie = ((name) => {
-            const cookie = c.req.headers.get('Cookie');
+            const cookie = c.req.headers.get('Cookie') || '';
             const obj = parse(cookie);
             if (name) {
                 const value = obj[name];

package/dist/middleware/cors/index.d.ts

@@ -8,5 +8,5 @@ declare type CORSOptions = {
     credentials?: boolean;
     exposeHeaders?: string[];
 };
-export declare const cors: (options?: CORSOptions) => (c: Context, next: Next) => Promise<void>;
+export declare const cors: (options?: CORSOptions | undefined) => (c: Context, next: Next) => Promise<void>;
 export {};

package/dist/middleware/cors/index.js

@@ -10,6 +10,7 @@ const cors = (options) => {
     };
     const opts = Object.assign(Object.assign({}, defaults), options);
     return async (c, next) => {
+        var _a, _b;
         await next();
         function set(key, value) {
             c.res.headers.append(key, value);
@@ -23,7 +24,7 @@ const cors = (options) => {
         if (opts.credentials) {
             set('Access-Control-Allow-Credentials', 'true');
         }
-        if (opts.exposeHeaders.length) {
+        if ((_a = opts.exposeHeaders) === null || _a === void 0 ? void 0 : _a.length) {
             set('Access-Control-Expose-Headers', opts.exposeHeaders.join(','));
         }
         if (c.req.method === 'OPTIONS') {
@@ -31,17 +32,17 @@ const cors = (options) => {
             if (opts.maxAge != null) {
                 set('Access-Control-Max-Age', opts.maxAge.toString());
             }
-            if (opts.allowMethods.length) {
+            if ((_b = opts.allowMethods) === null || _b === void 0 ? void 0 : _b.length) {
                 set('Access-Control-Allow-Methods', opts.allowMethods.join(','));
             }
             let headers = opts.allowHeaders;
-            if (!headers.length) {
+            if (!(headers === null || headers === void 0 ? void 0 : headers.length)) {
                 const requestHeaders = c.req.headers.get('Access-Control-Request-Headers');
                 if (requestHeaders) {
                     headers = requestHeaders.split(/\s*,\s*/);
                 }
             }
-            if (headers.length) {
+            if (headers === null || headers === void 0 ? void 0 : headers.length) {
                 set('Access-Control-Allow-Headers', headers.join(','));
                 set('Vary', 'Access-Control-Request-Headers');
             }

package/dist/middleware/etag/index.js

@@ -7,8 +7,9 @@ const etag = (options = { weak: false }) => {
     return async (c, next) => {
         const ifNoneMatch = c.req.header('If-None-Match') || c.req.header('if-none-match');
         await next();
-        const clone = c.res.clone();
-        const body = await (0, body_1.parseBody)(c.res);
+        const res = c.res;
+        const clone = res.clone();
+        const body = await (0, body_1.parseBody)(res);
         const hash = await (0, crypto_1.sha1)(body);
         const etag = options.weak ? `W/"${hash}"` : `"${hash}"`;
         if (ifNoneMatch && ifNoneMatch === etag) {

package/dist/middleware/graphql-server/index.d.ts

@@ -8,7 +8,7 @@ declare type Options = {
     pretty?: boolean;
     validationRules?: ReadonlyArray<ValidationRule>;
 };
-export declare const graphqlServer: (options: Options) => (c: Context, next: Next) => Promise<void>;
+export declare const graphqlServer: (options: Options) => (c: Context, next: Next) => Promise<Response>;
 export interface GraphQLParams {
     query: string | null;
     variables: {
@@ -18,7 +18,7 @@ export interface GraphQLParams {
     raw: boolean;
 }
 export declare const getGraphQLParams: (request: Request) => Promise<GraphQLParams>;
-export declare const errorMessages: (messages: string[], graphqlErrors?: readonly GraphQLError[] | readonly GraphQLFormattedError[]) => {
+export declare const errorMessages: (messages: string[], graphqlErrors?: readonly GraphQLError[] | readonly GraphQLFormattedError[] | undefined) => {
     errors: readonly GraphQLError[] | readonly GraphQLFormattedError[];
 } | {
     errors: {

package/dist/middleware/graphql-server/index.js

@@ -13,13 +13,11 @@ const graphqlServer = (options) => {
     const validationRules = (_b = options.validationRules) !== null && _b !== void 0 ? _b : [];
     // const showGraphiQL = options.graphiql ?? false
     return async (c, next) => {
-        await next();
         // GraphQL HTTP only supports GET and POST methods.
         if (c.req.method !== 'GET' && c.req.method !== 'POST') {
-            c.res = c.json((0, exports.errorMessages)(['GraphQL only supports GET and POST requests.']), 405, {
+            return c.json((0, exports.errorMessages)(['GraphQL only supports GET and POST requests.']), 405, {
                 Allow: 'GET, POST',
             });
-            return;
         }
         let params;
         try {
@@ -28,20 +26,18 @@ const graphqlServer = (options) => {
         catch (e) {
             if (e instanceof Error) {
                 console.error(`${e.stack || e.message}`);
-                c.res = c.json((0, exports.errorMessages)([e.message], [e]), 400);
+                return c.json((0, exports.errorMessages)([e.message], [e]), 400);
             }
-            return;
+            throw e;
         }
         const { query, variables, operationName } = params;
         if (query == null) {
-            c.res = c.json((0, exports.errorMessages)(['Must provide query string.']), 400);
-            return;
+            return c.json((0, exports.errorMessages)(['Must provide query string.']), 400);
         }
         const schemaValidationErrors = (0, graphql_1.validateSchema)(schema);
         if (schemaValidationErrors.length > 0) {
             // Return 500: Internal Server Error if invalid schema.
-            c.res = c.json((0, exports.errorMessages)(['GraphQL schema validation error.'], schemaValidationErrors), 500);
-            return;
+            return c.json((0, exports.errorMessages)(['GraphQL schema validation error.'], schemaValidationErrors), 500);
         }
         let documentAST;
         try {
@@ -54,16 +50,15 @@ const graphqlServer = (options) => {
                 const e = new graphql_1.GraphQLError(syntaxError.message, {
                     originalError: syntaxError,
                 });
-                c.res = c.json((0, exports.errorMessages)(['GraphQL syntax error.'], [e]), 400);
+                return c.json((0, exports.errorMessages)(['GraphQL syntax error.'], [e]), 400);
             }
-            return;
+            throw syntaxError;
         }
         // Validate AST, reporting any errors.
         const validationErrors = (0, graphql_1.validate)(schema, documentAST, [...graphql_1.specifiedRules, ...validationRules]);
         if (validationErrors.length > 0) {
             // Return 400: Bad Request if any validation errors exist.
-            c.res = c.json((0, exports.errorMessages)(['GraphQL validation error.'], validationErrors), 400);
-            return;
+            return c.json((0, exports.errorMessages)(['GraphQL validation error.'], validationErrors), 400);
         }
         if (c.req.method === 'GET') {
             // Determine if this GET request will perform a non-query.
@@ -76,10 +71,9 @@ const graphqlServer = (options) => {
                 }
                 */
                 // Otherwise, report a 405: Method Not Allowed error.
-                c.res = c.json((0, exports.errorMessages)([
+                return c.json((0, exports.errorMessages)([
                     `Can only perform a ${operationAST.operation} operation from a POST request.`,
                 ]), 405, { Allow: 'POST' });
-                return;
             }
         }
         let result;
@@ -100,13 +94,14 @@ const graphqlServer = (options) => {
                     nodes: documentAST,
                 });
                 // Return 400: Bad Request if any execution context errors exist.
-                c.res = c.json((0, exports.errorMessages)(['GraphQL execution context error.'], [e]), 400);
+                return c.json((0, exports.errorMessages)(['GraphQL execution context error.'], [e]), 400);
             }
-            return;
+            throw contextError;
         }
-        if (result.data == null) {
-            c.res = c.json((0, exports.errorMessages)([result.errors.toString()], result.errors), 500);
-            return;
+        if (!result.data) {
+            if (result.errors) {
+                return c.json((0, exports.errorMessages)([result.errors.toString()], result.errors), 500);
+            }
         }
         /*
         Now, does not support GraphiQL
@@ -115,14 +110,14 @@ const graphqlServer = (options) => {
         */
         if (pretty) {
             const payload = JSON.stringify(result, null, pretty ? 2 : 0);
-            c.res = c.text(payload, 200, {
+            return c.text(payload, 200, {
                 'Content-Type': 'application/json',
             });
         }
         else {
-            c.res = c.json(result);
+            return c.json(result);
         }
-        return;
+        await next(); // XXX
     };
 };
 exports.graphqlServer = graphqlServer;