hono 0.2.0 → 0.2.4

package/README.md

@@ -23,12 +23,12 @@ app.fire()
 **Hono is fastest** compared to other routers for Cloudflare Workers.
 
 ```plain
-hono x 748,188 ops/sec ±5.40% (77 runs sampled)
-itty-router x 158,817 ops/sec ±3.62% (87 runs sampled)
-sunder x 332,339 ops/sec ±1.11% (95 runs sampled)
-worktop x 205,906 ops/sec ±4.43% (83 runs sampled)
+hono x 708,671 ops/sec ±2.58% (58 runs sampled)
+itty-router x 159,610 ops/sec ±2.86% (87 runs sampled)
+sunder x 322,846 ops/sec ±2.24% (86 runs sampled)
+worktop x 223,625 ops/sec ±2.01% (95 runs sampled)
 Fastest is hono
-✨  Done in 52.79s.
+✨  Done in 57.83s.
 ```
 
 ## Hono in 1 minute
@@ -114,6 +114,16 @@ app
     .put(() => {...})
 ```
 
+### Custom 404 Response
+
+You can customize 404 Not Found response:
+
+```js
+app.get('*', (c) => {
+  return c.text('Custom 404 Error', 404)
+})
+```
+
 ## async/await
 
 ```js
@@ -165,19 +175,6 @@ app.use('/message/*', async (c, next) => {
 app.get('/message/hello', (c) => c.text('Hello Middleware!'))
 ```
 
-### Custom 404 Response
-
-You can customize 404 Not Found response:
-
-```js
-app.use('*', async (c, next) => {
-  await next()
-  if (c.res.status === 404) {
-    c.res = new Response('Custom 404 Not Found', { status: 404 })
-  }
-})
-```
-
 ### Handling Error
 
 ```js
@@ -186,7 +183,7 @@ app.use('*', async (c, next) => {
     await next()
   } catch (err) {
     console.error(`${err}`)
-    c.res = new Response('Custom Error Message', { status: 500 })
+    c.res = c.text('Custom Error Message', { status: 500 })
   }
 })
 ```
@@ -252,7 +249,9 @@ app.get('/welcome', (c) => {
   c.header('Content-Type', 'text/plain')
   c.status(201)
   c.statusText('201 Content Created')
+
   return c.body('Thank you for comming')
+
   /*
   Same as:
   return new Response('Thank you for comming', {
@@ -260,7 +259,8 @@ app.get('/welcome', (c) => {
     statusText: '201 Content Created',
     headers: {
       'X-Message': 'Hello',
-      'Content-Type': 'text/plain'
+      'Content-Type': 'text/plain',
+      'Content-Length: '22'
     }
   })
   */
@@ -358,6 +358,11 @@ export default {
     return app.fetch(request, env, event)
   },
 }
+
+/*
+or just do this:
+export default app
+*/
 ```
 
 ## Cloudflare Workers with Hono

package/dist/context.d.ts

@@ -12,7 +12,7 @@ export declare class Context {
     private _headers;
     private _status;
     private _statusText;
-    body: (body: BodyInit, init?: ResponseInit) => Response;
+    render: (template: string, params?: object, options?: object) => Promise<Response>;
     constructor(req: Request, opts?: {
         res: Response;
         env: Env;
@@ -21,7 +21,8 @@ export declare class Context {
     header(name: string, value: string): void;
     status(number: number): void;
     statusText(text: string): void;
-    newResponse(body: BodyInit, init?: ResponseInit): Response;
+    newResponse(data: any, init?: ResponseInit): Response;
+    body(data: any, status?: number, headers?: Headers): Response;
     text(text: string, status?: number, headers?: Headers): Response;
     json(object: object, status?: number, headers?: Headers): Response;
     html(html: string, status?: number, headers?: Headers): Response;

package/dist/context.js

@@ -11,7 +11,6 @@ class Context {
             this.event = opts.event;
         }
         this._headers = {};
-        this.body = this.newResponse;
     }
     header(name, value) {
         this._headers[name] = value;
@@ -22,42 +21,54 @@ class Context {
     statusText(text) {
         this._statusText = text;
     }
-    newResponse(body, init = {}) {
-        init.status = this._status || init.status;
-        init.statusText = this._statusText || init.statusText;
-        init.headers = Object.assign(Object.assign({}, init.headers), this._headers);
-        return new Response(body, init);
+    newResponse(data, init = {}) {
+        init.status = init.status || this._status;
+        init.statusText = init.statusText || this._statusText;
+        init.headers = Object.assign(Object.assign({}, this._headers), init.headers);
+        // Content-Length
+        let length = 0;
+        if (data) {
+            if (data instanceof ArrayBuffer) {
+                length = data.byteLength;
+            }
+            else if (typeof data == 'string') {
+                const Encoder = new TextEncoder();
+                length = Encoder.encode(data).byteLength || 0;
+            }
+            else {
+                length = data.bytelength;
+            }
+        }
+        init.headers = Object.assign(Object.assign({}, init.headers), { 'Content-Length': length.toString() });
+        return new Response(data, init);
     }
-    text(text, status = 200, headers = {}) {
+    body(data, status = this._status, headers = this._headers) {
+        return this.newResponse(data, {
+            status: status,
+            headers: headers,
+        });
+    }
+    text(text, status = this._status, headers = {}) {
         if (typeof text !== 'string') {
             throw new TypeError('text method arg must be a string!');
         }
         headers['Content-Type'] = 'text/plain';
-        return this.newResponse(text, {
-            status: status,
-            headers: headers,
-        });
+        return this.body(text, status, headers);
     }
-    json(object, status = 200, headers = {}) {
+    json(object, status = this._status, headers = {}) {
         if (typeof object !== 'object') {
             throw new TypeError('json method arg must be a object!');
         }
         const body = JSON.stringify(object);
         headers['Content-Type'] = 'application/json; charset=UTF-8';
-        return this.newResponse(body, {
-            status: status,
-            headers: headers,
-        });
+        return this.body(body, status, headers);
     }
-    html(html, status = 200, headers = {}) {
+    html(html, status = this._status, headers = {}) {
         if (typeof html !== 'string') {
             throw new TypeError('html method arg must be a string!');
         }
         headers['Content-Type'] = 'text/html; charset=UTF-8';
-        return this.newResponse(html, {
-            status: status,
-            headers: headers,
-        });
+        return this.body(html, status, headers);
     }
     redirect(location, status = 302) {
         if (typeof location !== 'string') {

package/dist/hono.d.ts

@@ -8,7 +8,6 @@ declare global {
         param: (key: string) => string;
         query: (key: string) => string | null;
         header: (name: string) => string;
-        parsedBody: any;
     }
 }
 export declare type Handler = (c: Context, next?: Function) => Response | Promise<Response>;

package/dist/hono.js

@@ -48,6 +48,7 @@ class Hono {
         return this.addRoute('patch', arg, ...args);
     }
     /*
+    We may implement these HTTP methods:
     trace
     copy
     lock
@@ -137,11 +138,23 @@ class Hono {
         });
     }
     onError(err) {
-        console.error(err);
-        return new Response('Internal Server Error', { status: 500 });
+        console.error(`${err}`);
+        const message = 'Internal Server Error';
+        return new Response(message, {
+            status: 500,
+            headers: {
+                'Content-Length': message.length.toString(),
+            },
+        });
     }
     notFound() {
-        return new Response('Not Found', { status: 404 });
+        const message = 'Not Found';
+        return new Response('Not Found', {
+            status: 404,
+            headers: {
+                'Content-Length': message.length.toString(),
+            },
+        });
     }
 }
 exports.Hono = Hono;

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

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

package/dist/middleware/cookie/cookie.d.ts

@@ -3,7 +3,9 @@ declare global {
     interface Request {
         cookie: (name: string) => string;
     }
-    interface Response {
+}
+declare module '../../context' {
+    interface Context {
         cookie: (name: string, value: string, options?: CookieOptions) => void;
     }
 }

package/dist/middleware/cookie/cookie.js

@@ -9,12 +9,11 @@ const cookie = () => {
             const value = obj[name];
             return value;
         };
-        await next();
-        c.res.cookie = (name, value, options) => {
-            console.log('c.res.cookie!');
-            const cookie = serialize(name, value);
-            c.res.headers.set('Set-Cookie', cookie);
+        c.cookie = (name, value, opt) => {
+            const cookie = serialize(name, value, opt);
+            c.header('Set-Cookie', cookie);
         };
+        await next();
     };
 };
 exports.cookie = cookie;
@@ -27,8 +26,29 @@ const parse = (cookie) => {
     }
     return parsedCookie;
 };
-const serialize = (name, value, options = {}) => {
+const serialize = (name, value, opt = {}) => {
     value = encodeURIComponent(value);
-    const cookie = `${name}=${value}`;
+    let cookie = `${name}=${value}`;
+    if (opt.maxAge) {
+        cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
+    }
+    if (opt.domain) {
+        cookie += '; Domain=' + opt.domain;
+    }
+    if (opt.path) {
+        cookie += '; Path=' + opt.path;
+    }
+    if (opt.expires) {
+        cookie += '; Expires=' + opt.expires.toUTCString();
+    }
+    if (opt.httpOnly) {
+        cookie += '; HttpOnly';
+    }
+    if (opt.secure) {
+        cookie += '; Secure';
+    }
+    if (opt.sameSite) {
+        cookie += `; SameSaite=${opt.sameSite}`;
+    }
     return cookie;
 };

package/dist/middleware/cors/cors.js

@@ -45,6 +45,8 @@ const cors = (options) => {
                 set('Access-Control-Allow-Headers', headers.join(','));
                 set('Vary', 'Access-Control-Request-Headers');
             }
+            c.res.headers.delete('Content-Length');
+            c.res.headers.delete('Content-Type');
             c.res = new Response(null, {
                 headers: c.res.headers,
                 status: 204,

package/dist/middleware/default.js

@@ -11,16 +11,5 @@ const defaultMiddleware = async (c, next) => {
         return c.req.headers.get(name);
     };
     await next();
-    if (c.res.body) {
-        // Do not clone Response, ex: c.res.clone().arrayBuffer()
-        const buffer = await c.res.arrayBuffer();
-        const res = new Response(buffer, {
-            status: c.res.status,
-            statusText: c.res.statusText,
-            headers: c.res.headers,
-        });
-        res.headers.append('Content-Length', buffer.byteLength.toString());
-        c.res = res;
-    }
 };
 exports.defaultMiddleware = defaultMiddleware;

package/dist/middleware/mustache/mustache.d.ts

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

package/dist/middleware/mustache/mustache.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mustache = void 0;
+const cloudflare_1 = require("../../utils/cloudflare");
+const EXTENSION = '.mustache';
+const mustache = () => {
+    let Mustache;
+    try {
+        Mustache = require('mustache');
+    }
+    catch (_a) {
+        // Do nothing.
+    }
+    return async (c, next) => {
+        if (!Mustache) {
+            throw new Error('If you want to use Mustache Middleware, install mustache module.');
+        }
+        c.render = async (filename, view = {}, options) => {
+            const buffer = await (0, cloudflare_1.getContentFromKVAsset)(`${filename}${EXTENSION}`);
+            if (!buffer) {
+                throw new Error(`Template "${filename}${EXTENSION}" is not found or blank.`);
+            }
+            const content = bufferToString(buffer);
+            const partialArgs = {};
+            if (options) {
+                const partials = options;
+                for (const key of Object.keys(partials)) {
+                    const partialBuffer = await (0, cloudflare_1.getContentFromKVAsset)(`${partials[key]}${EXTENSION}`);
+                    if (!partialBuffer) {
+                        throw new Error(`Partial Template "${partials[key]}${EXTENSION}" is not found or blank.`);
+                    }
+                    partialArgs[key] = bufferToString(partialBuffer);
+                }
+            }
+            const output = Mustache.render(content, view, partialArgs);
+            return c.html(output);
+        };
+        await next();
+    };
+};
+exports.mustache = mustache;
+const bufferToString = (buffer) => {
+    if (buffer instanceof ArrayBuffer) {
+        const enc = new TextDecoder('utf-8');
+        return enc.decode(buffer);
+    }
+    return buffer;
+};

package/dist/middleware/serve-static/serve-static.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '../../context';
+declare type Options = {
+    root: string;
+};
+export declare const serveStatic: (opt?: Options) => (c: Context, next: Function) => Promise<void>;
+export {};

package/dist/middleware/serve-static/serve-static.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = void 0;
+const cloudflare_1 = require("../../utils/cloudflare");
+const mime_1 = require("../../utils/mime");
+const DEFAULT_DOCUMENT = 'index.html';
+// This middleware is available only on Cloudflare Workers.
+const serveStatic = (opt = { root: '' }) => {
+    return async (c, next) => {
+        await next();
+        const url = new URL(c.req.url);
+        const path = getKVPath(url.pathname, opt.root);
+        const content = await (0, cloudflare_1.getContentFromKVAsset)(path);
+        if (content) {
+            const mimeType = (0, mime_1.getMimeType)(path);
+            if (mimeType) {
+                c.header('Content-Type', mimeType);
+            }
+            c.res = c.body(content);
+        }
+        else {
+            // console.debug(`Static file: ${path} is not found`)
+        }
+    };
+};
+exports.serveStatic = serveStatic;
+const getKVPath = (filename, root) => {
+    if (filename.endsWith('/')) {
+        // /top/ => /top/index.html
+        filename = filename.concat(DEFAULT_DOCUMENT);
+    }
+    else if (!(0, mime_1.getMimeType)(filename)) {
+        // /top => /top/index.html
+        filename = filename.concat('/' + DEFAULT_DOCUMENT);
+    }
+    // /foo.html => foo.html
+    filename = filename.replace(/^\//, '');
+    // assets/ => assets
+    root = root.replace(/\/$/, '');
+    // ./assets/foo.html => assets/foo.html
+    let path = root + '/' + filename;
+    path = path.replace(/^\.?\//, '');
+    return path;
+};

package/dist/middleware.d.ts

@@ -20,4 +20,9 @@ export declare class Middleware {
         credentials?: boolean;
         exposeHeaders?: string[];
     }) => (c: import("./context").Context, next: Function) => Promise<void>;
+    static cookie: () => (c: import("./context").Context, next: Function) => Promise<void>;
+    static mustache: () => (c: import("./context").Context, next: Function) => Promise<void>;
+    static serveStatic: (opt?: {
+        root: string;
+    }) => (c: import("./context").Context, next: Function) => Promise<void>;
 }

package/dist/middleware.js

@@ -7,6 +7,9 @@ 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");
 const cors_1 = require("./middleware/cors/cors");
+const cookie_1 = require("./middleware/cookie/cookie");
+const mustache_1 = require("./middleware/mustache/mustache");
+const serve_static_1 = require("./middleware/serve-static/serve-static");
 class Middleware {
 }
 exports.Middleware = Middleware;
@@ -16,3 +19,6 @@ Middleware.logger = logger_1.logger;
 Middleware.basicAuth = basic_auth_1.basicAuth;
 Middleware.bodyParse = body_parse_1.bodyParse;
 Middleware.cors = cors_1.cors;
+Middleware.cookie = cookie_1.cookie;
+Middleware.mustache = mustache_1.mustache;
+Middleware.serveStatic = serve_static_1.serveStatic;

package/dist/utils/cloudflare.d.ts

@@ -0,0 +1 @@
+export declare const getContentFromKVAsset: (path: string) => Promise<ArrayBuffer>;

package/dist/utils/cloudflare.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContentFromKVAsset = void 0;
+const getContentFromKVAsset = async (path) => {
+    let ASSET_MANIFEST;
+    if (typeof __STATIC_CONTENT_MANIFEST === 'string') {
+        ASSET_MANIFEST = JSON.parse(__STATIC_CONTENT_MANIFEST);
+    }
+    else {
+        ASSET_MANIFEST = __STATIC_CONTENT_MANIFEST;
+    }
+    const ASSET_NAMESPACE = __STATIC_CONTENT;
+    const key = ASSET_MANIFEST[path] || path;
+    if (!key) {
+        return;
+    }
+    let content = await ASSET_NAMESPACE.get(key, { type: 'arrayBuffer' });
+    if (content) {
+        content = content;
+    }
+    return content;
+};
+exports.getContentFromKVAsset = getContentFromKVAsset;

package/dist/utils/mime.d.ts

@@ -0,0 +1 @@
+export declare const getMimeType: (filename: string) => string;

package/dist/utils/mime.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMimeType = void 0;
+const getMimeType = (filename) => {
+    const regexp = /\.([a-zA-Z0-9]+?)$/;
+    const match = filename.match(regexp);
+    if (!match) {
+        return;
+    }
+    let mimeType = mimes[match[1]];
+    if (mimeType.startsWith('text') || mimeType === 'application/json') {
+        mimeType += '; charset=utf-8';
+    }
+    return mimeType;
+};
+exports.getMimeType = getMimeType;
+const mimes = {
+    aac: 'audio/aac',
+    abw: 'application/x-abiword',
+    arc: 'application/x-freearc',
+    avi: 'video/x-msvideo',
+    azw: 'application/vnd.amazon.ebook',
+    bin: 'application/octet-stream',
+    bmp: 'image/bmp',
+    bz: 'application/x-bzip',
+    bz2: 'application/x-bzip2',
+    csh: 'application/x-csh',
+    css: 'text/css',
+    csv: 'text/csv',
+    doc: 'application/msword',
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    eot: 'application/vnd.ms-fontobject',
+    epub: 'application/epub+zip',
+    gz: 'application/gzip',
+    gif: 'image/gif',
+    htm: 'text/html',
+    html: 'text/html',
+    ico: 'image/vnd.microsoft.icon',
+    ics: 'text/calendar',
+    jar: 'application/java-archive',
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    js: 'text/javascript',
+    json: 'application/json',
+    jsonld: 'application/ld+json',
+    mid: 'audio/x-midi',
+    midi: 'audio/x-midi',
+    mjs: 'text/javascript',
+    mp3: 'audio/mpeg',
+    mpeg: 'video/mpeg',
+    mpkg: 'application/vnd.apple.installer+xml',
+    odp: 'application/vnd.oasis.opendocument.presentation',
+    ods: 'application/vnd.oasis.opendocument.spreadsheet',
+    odt: 'application/vnd.oasis.opendocument.text',
+    oga: 'audio/ogg',
+    ogv: 'video/ogg',
+    ogx: 'application/ogg',
+    opus: 'audio/opus',
+    otf: 'font/otf',
+    png: 'image/png',
+    pdf: 'application/pdf',
+    php: 'application/php',
+    ppt: 'application/vnd.ms-powerpoint',
+    pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    rar: 'application/vnd.rar',
+    rtf: 'application/rtf',
+    sh: 'application/x-sh',
+    svg: 'image/svg+xml',
+    swf: 'application/x-shockwave-flash',
+    tar: 'application/x-tar',
+    tif: 'image/tiff',
+    tiff: 'image/tiff',
+    ts: 'video/mp2t',
+    ttf: 'font/ttf',
+    txt: 'text/plain',
+    vsd: 'application/vnd.visio',
+    wav: 'audio/wav',
+    weba: 'audio/webm',
+    webm: 'video/webm',
+    webp: 'image/webp',
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    xhtml: 'application/xhtml+xml',
+    xls: 'application/vnd.ms-excel',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    xml: 'application/xml',
+    xul: 'application/vnd.mozilla.xul+xml',
+    zip: 'application/zip',
+    '3gp': 'video/3gpp',
+    '3g2': 'video/3gpp2',
+    '7z': 'application/x-7z-compressed',
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "0.2.0",
+  "version": "0.2.4",
   "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,6 +36,7 @@
   "devDependencies": {
     "@cloudflare/workers-types": "^3.3.0",
     "@types/jest": "^27.4.0",
+    "@types/mustache": "^4.1.2",
     "@types/node": "^17.0.8",
     "@typescript-eslint/eslint-plugin": "^5.9.0",
     "@typescript-eslint/parser": "^5.9.0",
@@ -51,6 +52,7 @@
     "form-data": "^4.0.0",
     "jest": "^27.4.5",
     "jest-environment-miniflare": "^2.0.0",
+    "mustache": "^4.2.0",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.1.2",
     "typescript": "^4.5.4"