hono 0.0.10 → 0.0.14

package/dist/hono.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hono = exports.Router = void 0;
+const node_1 = require("./node");
+const compose_1 = require("./compose");
+const util_1 = require("./util");
+const middleware_1 = require("./middleware");
+const context_1 = require("./context");
+const METHOD_NAME_OF_ALL = 'ALL';
+class Router {
+    constructor() {
+        this.node = new node_1.Node();
+    }
+    add(method, path, handler) {
+        this.node.insert(method, path, handler);
+    }
+    match(method, path) {
+        return this.node.search(method, path);
+    }
+}
+exports.Router = Router;
+class Hono {
+    constructor() {
+        this.router = new Router();
+        this.middlewareRouters = [];
+        this.tempPath = '/';
+    }
+    /* HTTP METHODS */
+    get(arg, ...args) {
+        return this.addRoute('get', arg, ...args);
+    }
+    post(arg, ...args) {
+        return this.addRoute('post', arg, ...args);
+    }
+    put(arg, ...args) {
+        return this.addRoute('put', arg, ...args);
+    }
+    head(arg, ...args) {
+        return this.addRoute('head', arg, ...args);
+    }
+    delete(arg, ...args) {
+        return this.addRoute('delete', arg, ...args);
+    }
+    options(arg, ...args) {
+        return this.addRoute('options', arg, ...args);
+    }
+    patch(arg, ...args) {
+        return this.addRoute('patch', arg, ...args);
+    }
+    /*
+    trace
+    copy
+    lock
+    purge
+    unlock
+    report
+    checkout
+    merge
+    notify
+    subscribe
+    unsubscribe
+    search
+    connect
+    */
+    all(arg, ...args) {
+        return this.addRoute('all', arg, ...args);
+    }
+    route(path) {
+        this.tempPath = path;
+        return this;
+    }
+    use(path, middleware) {
+        if (middleware.constructor.name !== 'AsyncFunction') {
+            throw new TypeError('middleware must be a async function!');
+        }
+        const router = new Router();
+        router.add(METHOD_NAME_OF_ALL, path, middleware);
+        this.middlewareRouters.push(router);
+    }
+    // addRoute('get', '/', handler)
+    addRoute(method, arg, ...args) {
+        method = method.toUpperCase();
+        if (typeof arg === 'string') {
+            this.tempPath = arg;
+            this.router.add(method, arg, args);
+        }
+        else {
+            args.unshift(arg);
+            this.router.add(method, this.tempPath, args);
+        }
+        return this;
+    }
+    async matchRoute(method, path) {
+        return this.router.match(method, path);
+    }
+    async dispatch(request, env, event) {
+        const [method, path] = [request.method, (0, util_1.getPathFromURL)(request.url)];
+        const result = await this.matchRoute(method, path);
+        request.params = (key) => {
+            if (result) {
+                return result.params[key];
+            }
+            return '';
+        };
+        const handler = result ? result.handler[0] : this.notFound; // XXX
+        const middleware = [];
+        for (const mr of this.middlewareRouters) {
+            const mwResult = mr.match(METHOD_NAME_OF_ALL, path);
+            if (mwResult) {
+                middleware.push(mwResult.handler);
+            }
+        }
+        const wrappedHandler = async (context, next) => {
+            context.res = await handler(context);
+            await next();
+        };
+        middleware.push(middleware_1.Middleware.default);
+        middleware.push(wrappedHandler);
+        const composed = (0, compose_1.compose)(middleware);
+        const c = new context_1.Context(request, { env: env, event: event, res: null });
+        await composed(c);
+        return c.res;
+    }
+    async handleEvent(event) {
+        return this.dispatch(event.request, {}, event).catch((err) => {
+            return this.onError(err);
+        });
+    }
+    async fetch(request, env, event) {
+        return this.dispatch(request, env, event).catch((err) => {
+            return this.onError(err);
+        });
+    }
+    fire() {
+        addEventListener('fetch', (event) => {
+            event.respondWith(this.handleEvent(event));
+        });
+    }
+    onError(err) {
+        console.error(err);
+        return new Response('Internal Server Error', { status: 500 });
+    }
+    notFound() {
+        return new Response('Not Found', { status: 404 });
+    }
+}
+exports.Hono = Hono;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { Hono } from './hono';
+export type { Handler, MiddlewareHandler } from './hono';
+export { Middleware } from './middleware';
+export { Context } from './context';
+export type { Env } from './context';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.Middleware = exports.Hono = void 0;
+var hono_1 = require("./hono");
+Object.defineProperty(exports, "Hono", { enumerable: true, get: function () { return hono_1.Hono; } });
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "Middleware", { enumerable: true, get: function () { return middleware_1.Middleware; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return context_1.Context; } });

package/dist/middleware/basic-auth/basic-auth.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '../../context';
+export declare const basicAuth: (options: {
+    username: string;
+    password: string;
+    realm?: string;
+}) => (ctx: Context, next: Function) => Promise<any>;

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicAuth = void 0;
+const util_1 = require("../../util");
+const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
+const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
+const auth = (req) => {
+    if (!req) {
+        throw new TypeError('argument req is required');
+    }
+    if (typeof req !== 'object') {
+        throw new TypeError('argument req is required to be an object');
+    }
+    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'));
+    if (!match) {
+        return undefined;
+    }
+    const userPass = USER_PASS_REGEXP.exec(decodeBase64(match[1]));
+    if (!userPass) {
+        return undefined;
+    }
+    return { username: userPass[1], password: userPass[2] };
+};
+function decodeBase64(str) {
+    return Buffer.from(str, 'base64').toString();
+}
+const basicAuth = (options) => {
+    if (!options.realm) {
+        options.realm = 'Secure Area';
+    }
+    return async (ctx, next) => {
+        const user = auth(ctx.req);
+        const usernameEqual = user && await (0, util_1.timingSafeEqual)(options.username, user.username);
+        const passwordEqual = user && await (0, util_1.timingSafeEqual)(options.password, user.password);
+        if (!user || !usernameEqual || !passwordEqual) {
+            ctx.res = new Response('Unauthorized', {
+                status: 401,
+                headers: {
+                    'WWW-Authenticate': 'Basic realm="' + options.realm.replace(/"/g, '\\"') + '"',
+                },
+            });
+            return;
+        }
+        return next();
+    };
+};
+exports.basicAuth = basicAuth;

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

@@ -0,0 +1,2 @@
+import type { Context } from '../../context';
+export declare const bodyParse: () => (ctx: Context, next: Function) => Promise<void>;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bodyParse = void 0;
+const bodyParse = () => {
+    return async (ctx, next) => {
+        const contentType = ctx.req.headers.get('Content-Type') || '';
+        if (contentType.includes('application/json')) {
+            ctx.req.parsedBody = await ctx.req.json();
+        }
+        else if (contentType.includes('application/text')) {
+            ctx.req.parsedBody = await ctx.req.text();
+        }
+        else if (contentType.includes('text/html')) {
+            ctx.req.parsedBody = await ctx.req.text();
+        }
+        else if (contentType.includes('form')) {
+            const form = {};
+            const data = [...(await ctx.req.formData())].reduce((acc, cur) => {
+                acc[cur[0]] = cur[1];
+                return acc;
+            }, form);
+            ctx.req.parsedBody = data;
+        }
+        await next();
+    };
+};
+exports.bodyParse = bodyParse;

package/dist/middleware/default.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../context';
+export declare const defaultMiddleware: (c: Context, next: Function) => Promise<void>;

package/dist/middleware/default.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMiddleware = void 0;
+const defaultMiddleware = async (c, next) => {
+    c.req.query = (key) => {
+        // eslint-disable-next-line
+        const url = new URL(c.req.url);
+        return url.searchParams.get(key);
+    };
+    await next();
+    if (c.res.body) {
+        const buff = await c.res.clone().arrayBuffer();
+        c.res.headers.append('Content-Length', buff.byteLength.toString());
+    }
+};
+exports.defaultMiddleware = defaultMiddleware;

package/dist/middleware/logger/logger.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '../../context';
+export declare const logger: (fn?: {
+    (...data: any[]): void;
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+}) => (c: Context, next: Function) => Promise<void>;

package/dist/middleware/logger/logger.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const util_1 = require("../../util");
+const humanize = (n, opts) => {
+    const options = opts || {};
+    const d = options.delimiter || ',';
+    const s = options.separator || '.';
+    n = n.toString().split('.');
+    n[0] = n[0].replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1' + d);
+    return n.join(s);
+};
+const time = (start) => {
+    const delta = Date.now() - start;
+    return humanize([
+        delta < 10000 ? delta + 'ms' : Math.round(delta / 1000) + 's',
+    ]);
+};
+const LogPrefix = {
+    Outgoing: '-->',
+    Incoming: '<--',
+    Error: 'xxx',
+};
+const colorStatus = (status = 0) => {
+    const out = {
+        7: `\x1b[35m${status}\x1b[0m`,
+        5: `\x1b[31m${status}\x1b[0m`,
+        4: `\x1b[33m${status}\x1b[0m`,
+        3: `\x1b[36m${status}\x1b[0m`,
+        2: `\x1b[32m${status}\x1b[0m`,
+        1: `\x1b[32m${status}\x1b[0m`,
+        0: `\x1b[33m${status}\x1b[0m`,
+    };
+    return out[(status / 100) | 0];
+};
+function log(fn, prefix, method, path, status, elasped) {
+    const out = prefix === LogPrefix.Incoming
+        ? `  ${prefix} ${method} ${path}`
+        : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elasped}`;
+    fn(out);
+}
+const logger = (fn = console.log) => {
+    return async (c, next) => {
+        const { method } = c.req;
+        const path = (0, util_1.getPathFromURL)(c.req.url);
+        log(fn, LogPrefix.Incoming, method, path);
+        const start = Date.now();
+        try {
+            await next();
+        }
+        catch (e) {
+            log(fn, LogPrefix.Error, method, path, c.res.status || 500, time(start));
+            throw e;
+        }
+        log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start));
+    };
+};
+exports.logger = logger;

package/dist/middleware/powered-by/powered-by.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../../context';
+export declare const poweredBy: () => (c: Context, next: Function) => Promise<void>;

package/dist/middleware/powered-by/powered-by.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.poweredBy = void 0;
+const poweredBy = () => {
+    return async (c, next) => {
+        await next();
+        // await c.res.headers.append('X-Powered-By', 'Hono')
+        c.res.headers.append('X-Powered-By', 'Hono');
+    };
+};
+exports.poweredBy = poweredBy;

package/dist/middleware.d.ts

@@ -0,0 +1,15 @@
+export declare class Middleware {
+    static default: (c: import("./context").Context, next: Function) => Promise<void>;
+    static poweredBy: () => (c: import("./context").Context, next: Function) => Promise<void>;
+    static logger: (fn?: {
+        (...data: any[]): void;
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    }) => (c: import("./context").Context, next: Function) => Promise<void>;
+    static basicAuth: (options: {
+        username: string;
+        password: string;
+        realm?: string;
+    }) => (ctx: import("./context").Context, next: Function) => Promise<any>;
+    static bodyParse: () => (ctx: import("./context").Context, next: Function) => Promise<void>;
+}

package/dist/middleware.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Middleware = void 0;
+const default_1 = require("./middleware/default");
+const powered_by_1 = require("./middleware/powered-by/powered-by");
+const logger_1 = require("./middleware/logger/logger");
+const basic_auth_1 = require("./middleware/basic-auth/basic-auth");
+const body_parse_1 = require("./middleware/body-parse/body-parse");
+class Middleware {
+}
+exports.Middleware = Middleware;
+Middleware.default = default_1.defaultMiddleware;
+Middleware.poweredBy = powered_by_1.poweredBy;
+Middleware.logger = logger_1.logger;
+Middleware.basicAuth = basic_auth_1.basicAuth;
+Middleware.bodyParse = body_parse_1.bodyParse;

package/dist/node.d.ts

@@ -0,0 +1,24 @@
+export declare class Result<T> {
+    handler: T;
+    params: {
+        [key: string]: string;
+    };
+    constructor(handler: T, params: {
+        [key: string]: string;
+    });
+}
+export declare class Node<T> {
+    method: {
+        [key: string]: T;
+    };
+    handler: T;
+    children: {
+        [key: string]: Node<T>;
+    };
+    middlewares: [];
+    constructor(method?: string, handler?: any, children?: {
+        [key: string]: Node<T>;
+    });
+    insert(method: string, path: string, handler: T): Node<T>;
+    search(method: string, path: string): Result<T>;
+}

package/dist/node.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = exports.Result = void 0;
+const util_1 = require("./util");
+const METHOD_NAME_OF_ALL = 'ALL';
+class Result {
+    constructor(handler, params) {
+        this.handler = handler;
+        this.params = params;
+    }
+}
+exports.Result = Result;
+const noRoute = () => {
+    return null;
+};
+class Node {
+    constructor(method, handler, children) {
+        this.children = children || {};
+        this.method = {};
+        if (method && handler) {
+            this.method[method] = handler;
+        }
+        this.middlewares = [];
+    }
+    insert(method, path, handler) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let curNode = this;
+        const parts = (0, util_1.splitPath)(path);
+        for (let i = 0, len = parts.length; i < len; i++) {
+            const p = parts[i];
+            if (Object.keys(curNode.children).includes(p)) {
+                curNode = curNode.children[p];
+                continue;
+            }
+            curNode.children[p] = new Node();
+            curNode = curNode.children[p];
+        }
+        curNode.method[method] = handler;
+        return curNode;
+    }
+    search(method, path) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let curNode = this;
+        const params = {};
+        const parts = (0, util_1.splitPath)(path);
+        for (let i = 0, len = parts.length; i < len; i++) {
+            const p = parts[i];
+            // '*' => match any path
+            if (curNode.children['*']) {
+                const astNode = curNode.children['*'];
+                if (Object.keys(astNode.children).length === 0) {
+                    curNode = astNode;
+                    break;
+                }
+            }
+            const nextNode = curNode.children[p];
+            if (nextNode) {
+                curNode = nextNode;
+                // '/hello/*' => match '/hello'
+                if (!(i == len - 1 && nextNode.children['*'])) {
+                    continue;
+                }
+            }
+            let isWildcard = false;
+            let isParamMatch = false;
+            const keys = Object.keys(curNode.children);
+            for (let j = 0, len = keys.length; j < len; j++) {
+                const key = keys[j];
+                // Wildcard
+                // '/hello/*/foo' => match /hello/bar/foo
+                if (key === '*') {
+                    curNode = curNode.children['*'];
+                    isWildcard = true;
+                    break;
+                }
+                const pattern = (0, util_1.getPattern)(key);
+                // Named match
+                if (pattern) {
+                    const match = p.match(new RegExp(pattern[1]));
+                    if (match) {
+                        const k = pattern[0];
+                        params[k] = match[1];
+                        curNode = curNode.children[key];
+                        isParamMatch = true;
+                        break;
+                    }
+                    return noRoute();
+                }
+            }
+            if (isWildcard && i === len - 1) {
+                break;
+            }
+            if (isWildcard === false && isParamMatch === false) {
+                return noRoute();
+            }
+        }
+        const handler = curNode.method[METHOD_NAME_OF_ALL] || curNode.method[method];
+        if (!handler) {
+            return noRoute();
+        }
+        return new Result(handler, params);
+    }
+}
+exports.Node = Node;

package/dist/util.d.ts

@@ -0,0 +1,5 @@
+export declare const splitPath: (path: string) => string[];
+export declare const getPattern: (label: string) => string[] | null;
+export declare const getPathFromURL: (url: string) => string;
+export declare const isAbsoluteURL: (url: string) => boolean;
+export declare const timingSafeEqual: (a: any, b: any) => Promise<boolean>;

package/dist/util.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timingSafeEqual = exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
+const URL_REGEXP = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
+const splitPath = (path) => {
+    const paths = path.split(/\//); // faster than path.split('/')
+    if (paths[0] === '') {
+        paths.shift();
+    }
+    return paths;
+};
+exports.splitPath = splitPath;
+const getPattern = (label) => {
+    // :id{[0-9]+}  => ([0-9]+)
+    // :id          => (.+)
+    //const name = ''
+    const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    if (match) {
+        if (match[2]) {
+            return [match[1], '(' + match[2] + ')'];
+        }
+        else {
+            return [match[1], '(.+)'];
+        }
+    }
+    return null;
+};
+exports.getPattern = getPattern;
+const getPathFromURL = (url) => {
+    // XXX
+    const match = url.match(URL_REGEXP);
+    if (match) {
+        return match[5];
+    }
+    return '';
+};
+exports.getPathFromURL = getPathFromURL;
+const isAbsoluteURL = (url) => {
+    const match = url.match(URL_REGEXP);
+    if (match && match[1]) {
+        return true;
+    }
+    return false;
+};
+exports.isAbsoluteURL = isAbsoluteURL;
+const bufferEqual = (a, b) => {
+    if (a === b) {
+        return true;
+    }
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    const va = new DataView(a);
+    const vb = new DataView(b);
+    let i = va.byteLength;
+    while (i--) {
+        if (va.getUint8(i) !== vb.getUint8(i)) {
+            return false;
+        }
+    }
+    return true;
+};
+const timingSafeEqual = async (a, b) => {
+    const sa = await crypto.subtle.digest({
+        name: 'SHA-256',
+    }, new TextEncoder().encode(String(a)));
+    const sb = await crypto.subtle.digest({
+        name: 'SHA-256',
+    }, new TextEncoder().encode(String(b)));
+    return bufferEqual(sa, sb) && a === b;
+};
+exports.timingSafeEqual = timingSafeEqual;

package/package.json

@@ -1,10 +1,18 @@
 {
   "name": "hono",
-  "version": "0.0.10",
-  "description": "Minimal web framework for Cloudflare Workers and Fastly Compute@Edge",
-  "main": "src/hono.js",
+  "version": "0.0.14",
+  "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "test": "jest"
+    "test": "jest",
+    "lint": "eslint --ext js,ts src .eslintrc.js test",
+    "build": "rimraf dist && tsc",
+    "watch": "tsc -w",
+    "prepublishOnly": "yarn build"
   },
   "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
   "license": "MIT",
@@ -26,7 +34,28 @@
     "compute@edge"
   ],
   "devDependencies": {
+    "@cloudflare/workers-types": "^3.3.0",
+    "@types/jest": "^27.4.0",
+    "@types/node": "^17.0.8",
+    "@typescript-eslint/eslint-plugin": "^5.9.0",
+    "@typescript-eslint/parser": "^5.9.0",
+    "eslint": "^7.26.0",
+    "eslint-config-prettier": "^8.1.0",
+    "eslint-define-config": "^1.2.1",
+    "eslint-import-resolver-typescript": "^2.0.0",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-flowtype": "^5.7.2",
+    "eslint-plugin-import": "^2.20.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "form-data": "^4.0.0",
     "jest": "^27.4.5",
-    "node-fetch": "^2.6.6"
+    "jest-environment-miniflare": "^2.0.0",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^27.1.2",
+    "typescript": "^4.5.4"
+  },
+  "engines": {
+    "node": ">=11.0.0"
   }
 }