hono 0.5.4 → 0.5.7

package/dist/context.d.ts

@@ -12,7 +12,7 @@ export declare class Context<RequestParamKeyType = string> {
     private _status;
     private _statusText;
     render: (template: string, params?: object, options?: object) => Promise<Response>;
-    notFound: () => Response;
+    notFound: () => Response | Promise<Response>;
     constructor(req: Request<RequestParamKeyType>, opts?: {
         res: Response;
         env: Env;

package/dist/hono.d.ts

@@ -12,7 +12,7 @@ declare global {
 }
 export declare type Handler<RequestParamKeyType = string> = (c: Context<RequestParamKeyType>, next?: Function) => Response | Promise<Response>;
 export declare type MiddlewareHandler = (c: Context, next: Function) => Promise<void>;
-export declare type NotFoundHandler = (c: Context) => Response;
+export declare type NotFoundHandler = (c: Context) => Response | Promise<Response>;
 export declare type ErrorHandler = (err: Error, c: Context) => Response;
 declare type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer _Pattern}` ? Name : NameWithPattern;
 declare type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;

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

@@ -0,0 +1,25 @@
+import type { Context } from '../../context';
+import type { GraphQLSchema, ValidationRule } from 'graphql';
+declare type Options = {
+    schema: GraphQLSchema;
+    rootValue?: unknown;
+    pretty?: boolean;
+    validationRules?: ReadonlyArray<ValidationRule>;
+};
+export declare const graphqlServer: (options: Options) => (c: Context, next: Function) => Promise<void>;
+export interface GraphQLParams {
+    query: string | null;
+    variables: {
+        readonly [name: string]: unknown;
+    } | null;
+    operationName: string | null;
+    raw: boolean;
+}
+export declare const getGraphQLParams: (request: Request) => Promise<GraphQLParams>;
+export declare const errorMessages: (messages: string[]) => {
+    errors: {
+        message: string;
+    }[];
+};
+export declare const graphiQLResponse: () => void;
+export {};

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

@@ -0,0 +1,164 @@
+"use strict";
+// Based on the code in the `express-graphql` package.
+// https://github.com/graphql/express-graphql/blob/main/src/index.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphiQLResponse = exports.errorMessages = exports.getGraphQLParams = exports.graphqlServer = void 0;
+const parse_body_1 = require("./parse-body");
+const graphql_1 = require("graphql");
+const graphqlServer = (options) => {
+    var _a, _b;
+    const schema = options.schema;
+    const rootValue = options.rootValue;
+    const pretty = (_a = options.pretty) !== null && _a !== void 0 ? _a : false;
+    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, {
+                Allow: 'GET, POST',
+            });
+            return;
+        }
+        let params;
+        try {
+            params = await (0, exports.getGraphQLParams)(c.req);
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                c.res = c.json((0, exports.errorMessages)([e.message]), 400);
+            }
+            return;
+        }
+        const { query, variables, operationName } = params;
+        if (query == null) {
+            c.res = c.json((0, exports.errorMessages)(['Must provide query string.']), 400);
+            return;
+        }
+        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.']), 500);
+            return;
+        }
+        let documentAST;
+        try {
+            documentAST = (0, graphql_1.parse)(new graphql_1.Source(query, 'GraphQL request'));
+        }
+        catch (syntaxError) {
+            // Return 400: Bad Request if any syntax errors errors exist.
+            c.res = c.json((0, exports.errorMessages)(['GraphQL syntax error.']), 400);
+            return;
+        }
+        // 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.']), 400);
+            return;
+        }
+        if (c.req.method === 'GET') {
+            // Determine if this GET request will perform a non-query.
+            const operationAST = (0, graphql_1.getOperationAST)(documentAST, operationName);
+            if (operationAST && operationAST.operation !== 'query') {
+                /*
+                Now , does not support GraphiQL
+                if (showGraphiQL) {
+                  //return respondWithGraphiQL(response, graphiqlOptions, params)
+                }
+                */
+                // Otherwise, report a 405: Method Not Allowed error.
+                c.res = c.json((0, exports.errorMessages)([
+                    `Can only perform a ${operationAST.operation} operation from a POST request.`,
+                ]), 405, { Allow: 'POST' });
+                return;
+            }
+        }
+        let result;
+        try {
+            result = await (0, graphql_1.execute)({
+                schema,
+                document: documentAST,
+                rootValue,
+                variableValues: variables,
+                operationName: operationName,
+            });
+        }
+        catch (error) {
+            // Return 400: Bad Request if any execution context errors exist.
+            c.res = c.json((0, exports.errorMessages)(['GraphQL execution context error.']), 400);
+            return;
+        }
+        if (result.data == null) {
+            c.res = c.json((0, exports.errorMessages)([result.errors.toString()]), 500);
+            return;
+        }
+        /*
+        Now, does not support GraphiQL
+        if (showGraphiQL) {
+        }
+        */
+        if (pretty) {
+            const payload = JSON.stringify(result, null, pretty ? 2 : 0);
+            c.res = c.text(payload, 200, {
+                'Content-Type': 'application/json',
+            });
+        }
+        else {
+            c.res = c.json(result);
+        }
+        return;
+    };
+};
+exports.graphqlServer = graphqlServer;
+const getGraphQLParams = async (request) => {
+    var _a, _b, _c;
+    const urlData = new URLSearchParams(request.url.split('?')[1]);
+    const bodyData = await (0, parse_body_1.parseBody)(request);
+    // GraphQL Query string.
+    let query = (_a = urlData.get('query')) !== null && _a !== void 0 ? _a : bodyData.query;
+    if (typeof query !== 'string') {
+        query = null;
+    }
+    // Parse the variables if needed.
+    let variables = ((_b = urlData.get('variables')) !== null && _b !== void 0 ? _b : bodyData.variables);
+    if (typeof variables === 'string') {
+        try {
+            variables = JSON.parse(variables);
+        }
+        catch (_d) {
+            throw Error('Variables are invalid JSON.');
+        }
+    }
+    else if (typeof variables !== 'object') {
+        variables = null;
+    }
+    // Name of GraphQL operation to execute.
+    let operationName = (_c = urlData.get('operationName')) !== null && _c !== void 0 ? _c : bodyData.operationName;
+    if (typeof operationName !== 'string') {
+        operationName = null;
+    }
+    const raw = urlData.get('raw') != null || bodyData.raw !== undefined;
+    const params = {
+        query: query,
+        variables: variables,
+        operationName: operationName,
+        raw: raw,
+    };
+    return params;
+};
+exports.getGraphQLParams = getGraphQLParams;
+const errorMessages = (messages) => {
+    const errors = messages.map((message) => {
+        return {
+            message: message,
+        };
+    });
+    return {
+        errors: errors,
+    };
+};
+exports.errorMessages = errorMessages;
+const graphiQLResponse = () => { };
+exports.graphiQLResponse = graphiQLResponse;

package/dist/middleware/graphql-server/parse-body.d.ts

@@ -0,0 +1,3 @@
+export declare function parseBody(req: Request): Promise<{
+    [param: string]: unknown;
+}>;

package/dist/middleware/graphql-server/parse-body.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBody = void 0;
+async function parseBody(req) {
+    const contentType = req.headers.get('content-type');
+    switch (contentType) {
+        case 'application/graphql':
+            return { query: await req.text() };
+        case 'application/json':
+            try {
+                return await req.json();
+            }
+            catch (e) {
+                throw Error(`POST body sent invalid JSON: ${e}`);
+            }
+        case 'application/x-www-form-urlencoded':
+            return parseFormURL(req);
+    }
+    return {};
+}
+exports.parseBody = parseBody;
+const parseFormURL = async (req) => {
+    const text = await req.text();
+    const searchParams = new URLSearchParams(text);
+    const res = {};
+    searchParams.forEach((v, k) => (res[k] = v));
+    return res;
+};

package/dist/router/reg-exp-router/node.d.ts

@@ -5,9 +5,7 @@ export interface Context {
 export declare class Node {
     index?: number;
     varIndex?: number;
-    children: {
-        [key: string]: Node;
-    };
+    children: Record<string, Node>;
     insert(tokens: readonly string[], index: number, paramMap: ParamMap, context: Context): void;
     buildRegExpStr(): string;
 }

package/dist/router/reg-exp-router/router.d.ts

@@ -1,15 +1,7 @@
 import { Router, Result } from '../../router';
-import type { ParamMap, ReplacementMap } from './trie';
 declare type Route<T> = [string, T];
-declare type HandlerData<T> = [T, ParamMap];
-declare type Matcher<T> = [RegExp | true, ReplacementMap, HandlerData<T>[]];
 export declare class RegExpRouter<T> extends Router<T> {
-    routes?: {
-        [method: string]: Route<T>[];
-    };
-    matchers?: {
-        [method: string]: Matcher<T> | null;
-    };
+    routes?: Record<string, Route<T>[]>;
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T> | null;
     private buildAllMatchers;

package/dist/router/reg-exp-router/router.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegExpRouter = void 0;
 const router_1 = require("../../router");
 const trie_1 = require("./trie");
+const regExpMatchAll = new RegExp('');
+const emptyParam = {};
 class RegExpRouter extends router_1.Router {
     constructor() {
         super(...arguments);
         this.routes = {};
-        this.matchers = null;
     }
     add(method, path, handler) {
         var _a;
@@ -18,43 +19,54 @@ class RegExpRouter extends router_1.Router {
         this.routes[method].push([path, handler]);
     }
     match(method, path) {
-        if (!this.matchers) {
-            this.buildAllMatchers();
-        }
-        const matcher = this.matchers[method] || this.matchers[router_1.METHOD_NAME_OF_ALL];
-        if (!matcher) {
-            return null;
-        }
-        const [regexp, replacementMap, handlers] = matcher;
-        if (regexp === true) {
-            // '*'
-            return new router_1.Result(handlers[0][0], {});
-        }
-        const match = path.match(regexp);
-        if (!match) {
-            return null;
-        }
-        if (!replacementMap) {
-            // there is only one route and no capture
-            return new router_1.Result(handlers[0][0], {});
-        }
-        const index = match.indexOf('', 1);
-        const [handler, paramMap] = handlers[replacementMap[index]];
-        const params = {};
-        for (let i = 0; i < paramMap.length; i++) {
-            params[paramMap[i][0]] = match[paramMap[i][1]];
+        const matchers = this.buildAllMatchers();
+        let match;
+        // Optimization for middleware
+        const methods = Object.keys(matchers);
+        if (methods.length === 1 && methods[0] === router_1.METHOD_NAME_OF_ALL) {
+            const [regexp, handlers] = matchers[router_1.METHOD_NAME_OF_ALL];
+            if (handlers.length === 1) {
+                const result = new router_1.Result(handlers[0][0], emptyParam);
+                if (regexp === regExpMatchAll) {
+                    match = () => result;
+                }
+                else if (handlers.length === 1 && !handlers[0][1]) {
+                    match = (_, path) => (regexp.test(path) ? result : null);
+                }
+            }
         }
-        return new router_1.Result(handler, params);
+        match || (match = (method, path) => {
+            const matcher = matchers[method] || matchers[router_1.METHOD_NAME_OF_ALL];
+            if (!matcher) {
+                return null;
+            }
+            const match = path.match(matcher[0]);
+            if (!match) {
+                return null;
+            }
+            const index = match.indexOf('', 1);
+            const [handler, paramMap] = matcher[1][index];
+            if (!paramMap) {
+                return new router_1.Result(handler, emptyParam);
+            }
+            const params = {};
+            for (let i = 0; i < paramMap.length; i++) {
+                params[paramMap[i][0]] = match[paramMap[i][1]];
+            }
+            return new router_1.Result(handler, params);
+        });
+        this.match = match;
+        return this.match(method, path);
     }
     buildAllMatchers() {
-        this.matchers || (this.matchers = {});
+        const matchers = {};
         Object.keys(this.routes).forEach((method) => {
-            this.buildMatcher(method);
+            matchers[method] = this.buildMatcher(method);
         });
         delete this.routes; // to reduce memory usage
+        return matchers;
     }
     buildMatcher(method) {
-        this.matchers || (this.matchers = {});
         const trie = new trie_1.Trie();
         const handlers = [];
         const targetMethods = [method];
@@ -63,34 +75,40 @@ class RegExpRouter extends router_1.Router {
         }
         const routes = targetMethods.flatMap((method) => this.routes[method] || []);
         if (routes.length === 0) {
-            this.matchers[method] = null;
-            return;
-        }
-        if (routes.length === 1 && routes[0][0] === '*') {
-            this.matchers[method] = [true, null, [[routes[0][1], []]]];
-            return;
+            return null;
         }
-        if (routes.length === 1 && !routes[0][0].match(/:/)) {
-            // there is only one route and no capture
-            const tmp = routes[0][0].endsWith('*')
-                ? routes[0][0].replace(/\/\*$/, '(?:$|/)') // /path/to/* => /path/to(?:$|/)
-                : `${routes[0][0]}$`; // /path/to/action => /path/to/action$
-            const regExpStr = `^${tmp.replace(/\*/g, '[^/]+')}`; // /prefix/*/path/to => /prefix/[^/]+/path/to
-            this.matchers[method] = [new RegExp(regExpStr), null, [[routes[0][1], []]]];
-            return;
+        if (method === router_1.METHOD_NAME_OF_ALL) {
+            if (routes.length === 1 && routes[0][0] === '*') {
+                return [regExpMatchAll, [[routes[0][1], null]]];
+            }
+            if (routes.length === 1 && !routes[0][0].match(/:/)) {
+                // there is only one route and no capture
+                const tmp = routes[0][0].endsWith('*')
+                    ? routes[0][0].replace(/\/\*$/, '(?:$|/)') // /path/to/* => /path/to(?:$|/)
+                    : `${routes[0][0]}$`; // /path/to/action => /path/to/action$
+                const regExpStr = `^${tmp.replace(/\*/g, '[^/]+')}`; // /prefix/*/path/to => /prefix/[^/]+/path/to
+                return [new RegExp(regExpStr), [[routes[0][1], null]]];
+            }
         }
         for (let i = 0; i < routes.length; i++) {
             const paramMap = trie.insert(routes[i][0], i);
-            handlers[i] = [routes[i][1], paramMap];
+            handlers[i] = [routes[i][1], Object.keys(paramMap).length !== 0 ? paramMap : null];
         }
         const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
         for (let i = 0; i < handlers.length; i++) {
             const paramMap = handlers[i][1];
-            for (let i = 0; i < paramMap.length; i++) {
-                paramMap[i][1] = paramReplacementMap[paramMap[i][1]];
+            if (paramMap) {
+                for (let i = 0; i < paramMap.length; i++) {
+                    paramMap[i][1] = paramReplacementMap[paramMap[i][1]];
+                }
             }
         }
-        this.matchers[method] = [new RegExp(regexp), indexReplacementMap, handlers];
+        const handlerMap = [];
+        // using `in` because indexReplacementMap is a sparse array
+        for (const i in indexReplacementMap) {
+            handlerMap[i] = handlers[indexReplacementMap[i]];
+        }
+        return [regexp, handlerMap];
     }
 }
 exports.RegExpRouter = RegExpRouter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "0.5.4",
+  "version": "0.5.7",
   "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,11 +20,16 @@
     "./body-parse": "./dist/middleware/body-parse/body-parse.js",
     "./cookie": "./dist/middleware/cookie/cookie.js",
     "./cors": "./dist/middleware/cors/cors.js",
+    "./etag": "./dist/middleware/etag/etag.js",
+    "./graphql-server": "./dist/middleware/graphql-server/graphql-server.js",
     "./logger": "./dist/middleware/logger/logger.js",
     "./mustache": "./dist/middleware/mustache/mustache.js",
     "./powered-by": "./dist/middleware/powered-by/powered-by.js",
     "./serve-static": "./dist/middleware/serve-static/serve-static.js",
-    "./router/reg-exp-router": "./dist/router/reg-exp-router/index.js"
+    "./router/trie-router": "./dist/router/trie-router/router.js",
+    "./router/reg-exp-router": "./dist/router/reg-exp-router/index.js",
+    "./utils/cloudflare": "./dist/utils/cloudflare.js",
+    "./utils/mime": "./dist/utils/mime.js"
   },
   "typesVersions": {
     "*": {
@@ -40,6 +45,12 @@
       "cors": [
         "./dist/middleware/cors/cors.d.ts"
       ],
+      "etag": [
+        "./dist/middleware/etag/etag.d.ts"
+      ],
+      "graphql-server": [
+        "./dist/middleware/graphql-server/graphql-server.d.ts"
+      ],
       "logger": [
         "./dist/middleware/logger/logger.d.ts"
       ],
@@ -52,8 +63,17 @@
       "serve-static": [
         "./dist/middleware/serve-static/serve-static.d.ts"
       ],
+      "router/trie-router": [
+        "./dist/router/trie-router/router.d.ts"
+      ],
       "router/reg-exp-router": [
         "./dist/router/reg-exp-router/router.d.ts"
+      ],
+      "utils/cloudflare": [
+        "./dist/utils/cloudflare.d.ts"
+      ],
+      "utils/mime": [
+        "./dist/utils/mime.d.ts"
       ]
     }
   },
@@ -94,6 +114,7 @@
     "eslint-plugin-import": "^2.20.2",
     "eslint-plugin-node": "^11.1.0",
     "form-data": "^4.0.0",
+    "graphql": "^16.3.0",
     "jest": "^27.4.5",
     "jest-environment-miniflare": "^2.0.0",
     "mustache": "^4.2.0",