hono 2.1.4 → 2.2.0

package/dist/middleware/jwt/index.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jwt = void 0;
-const jwt_1 = require("../../utils/jwt");
-const jwt = (options) => {
+import { Jwt } from '../../utils/jwt';
+export const jwt = (options) => {
     if (!options) {
         throw new Error('JWT auth middleware requires options for "secret');
     }
@@ -42,7 +39,7 @@ const jwt = (options) => {
         let authorized = false;
         let msg = '';
         try {
-            authorized = await jwt_1.Jwt.verify(token, options.secret, options.alg);
+            authorized = await Jwt.verify(token, options.secret, options.alg);
         }
         catch (e) {
             msg = `${e}`;
@@ -60,4 +57,3 @@ const jwt = (options) => {
         await next();
     };
 };
-exports.jwt = jwt;

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

@@ -1,5 +1,4 @@
-import type { Context } from '../../context';
-import type { Next } from '../../hono';
+import type { MiddlewareHandler } from '../../hono';
 declare type PrintFunc = (str: string, ...rest: string[]) => void;
-export declare const logger: (fn?: PrintFunc) => (c: Context, next: Next) => Promise<void>;
+export declare const logger: (fn?: PrintFunc) => MiddlewareHandler;
 export {};

package/dist/middleware/logger/index.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
-const url_1 = require("../../utils/url");
+import { getPathFromURL } from '../../utils/url';
 var LogPrefix;
 (function (LogPrefix) {
     LogPrefix["Outgoing"] = "-->";
@@ -36,14 +33,13 @@ function log(fn, prefix, method, path, status = 0, elapsed) {
         : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
     fn(out);
 }
-const logger = (fn = console.log) => {
+export const logger = (fn = console.log) => {
     return async (c, next) => {
         const { method } = c.req;
-        const path = (0, url_1.getPathFromURL)(c.req.url);
+        const path = getPathFromURL(c.req.url);
         log(fn, LogPrefix.Incoming, method, path);
         const start = Date.now();
         await next();
         log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start));
     };
 };
-exports.logger = logger;

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

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

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

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

package/dist/middleware/pretty-json/index.d.ts

@@ -1,7 +1,6 @@
-import type { Context } from '../../context';
-import type { Next } from '../../hono';
+import type { MiddlewareHandler } from '../../hono';
 declare type prettyOptions = {
     space: number;
 };
-export declare const prettyJSON: (options?: prettyOptions) => (c: Context, next: Next) => Promise<void>;
+export declare const prettyJSON: (options?: prettyOptions) => MiddlewareHandler;
 export {};

package/dist/middleware/pretty-json/index.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prettyJSON = void 0;
-const prettyJSON = (options = { space: 2 }) => {
+export const prettyJSON = (options = { space: 2 }) => {
     return async (c, next) => {
         const pretty = c.req.query('pretty') || c.req.query('pretty') === '' ? true : false;
         c.pretty(pretty, options.space);
         await next();
     };
 };
-exports.prettyJSON = prettyJSON;

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

@@ -1,7 +1,6 @@
-import type { Context } from '../../context';
-import type { Next } from '../../hono';
+import type { MiddlewareHandler } from '../../hono';
 export declare type ServeStaticOptions = {
     root?: string;
     path?: string;
 };
-export declare const serveStatic: (options?: ServeStaticOptions) => (c: Context, next: Next) => Promise<Response | undefined>;
+export declare const serveStatic: (options?: ServeStaticOptions) => MiddlewareHandler;

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

@@ -1,38 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serveStatic = void 0;
-const filepath_1 = require("../../utils/filepath");
-const mime_1 = require("../../utils/mime");
+// @denoify-ignore
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { existsSync } from 'fs';
+import { getFilePath } from '../../utils/filepath';
+import { getMimeType } from '../../utils/mime';
 // @ts-ignore
 const { file } = Bun;
 const DEFAULT_DOCUMENT = 'index.html';
-const serveStatic = (options = { root: '' }) => {
+export const serveStatic = (options = { root: '' }) => {
     return async (c, next) => {
         // Do nothing if Response is already set
         if (c.res && c.finalized) {
             await next();
         }
         const url = new URL(c.req.url);
-        let path = (0, filepath_1.getFilePath)({
+        let path = getFilePath({
             filename: options.path ?? url.pathname,
             root: options.root,
             defaultDocument: DEFAULT_DOCUMENT,
         });
         path = `./${path}`;
-        const content = file(path);
-        if (content) {
-            const mimeType = (0, mime_1.getMimeType)(path);
-            if (mimeType) {
-                c.header('Content-Type', mimeType);
+        if (existsSync(path)) {
+            const content = file(path);
+            if (content) {
+                const mimeType = getMimeType(path);
+                if (mimeType) {
+                    c.header('Content-Type', mimeType);
+                }
+                // Return Response object
+                return c.body(content);
             }
-            // Return Response object
-            return c.body(content);
-        }
-        else {
-            console.warn(`Static file: ${path} is not found`);
-            await next();
         }
+        console.warn(`Static file: ${path} is not found`);
+        await next();
         return;
     };
 };
-exports.serveStatic = serveStatic;

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

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serveStatic = void 0;
-var serve_static_1 = require("./serve-static");
-Object.defineProperty(exports, "serveStatic", { enumerable: true, get: function () { return serve_static_1.serveStatic; } });
+export { serveStatic } from './serve-static';

package/dist/middleware/serve-static/module.d.mts

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from './serve-static';
-declare const module: (options?: ServeStaticOptions) => (c: import("../../context").Context<string, any>, next: import("../../hono").Next) => Promise<Response | undefined>;
+declare const module: (options?: ServeStaticOptions) => import("../../hono").MiddlewareHandler;
 export { module as serveStatic };

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

@@ -1,10 +1,9 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { Context } from '../../context';
-import type { Next } from '../../hono';
+import type { MiddlewareHandler } from '../../hono';
 export declare type ServeStaticOptions = {
     root?: string;
     path?: string;
     manifest?: object | string;
     namespace?: KVNamespace;
 };
-export declare const serveStatic: (options?: ServeStaticOptions) => (c: Context, next: Next) => Promise<Response | undefined>;
+export declare const serveStatic: (options?: ServeStaticOptions) => MiddlewareHandler;

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

@@ -1,29 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serveStatic = void 0;
-const cloudflare_1 = require("../../utils/cloudflare");
-const filepath_1 = require("../../utils/filepath");
-const mime_1 = require("../../utils/mime");
+import { getContentFromKVAsset } from '../../utils/cloudflare';
+import { getFilePath } from '../../utils/filepath';
+import { getMimeType } from '../../utils/mime';
 const DEFAULT_DOCUMENT = 'index.html';
 // This middleware is available only on Cloudflare Workers.
-const serveStatic = (options = { root: '' }) => {
+export const serveStatic = (options = { root: '' }) => {
     return async (c, next) => {
         // Do nothing if Response is already set
         if (c.finalized) {
             await next();
         }
         const url = new URL(c.req.url);
-        const path = (0, filepath_1.getFilePath)({
+        const path = getFilePath({
             filename: options.path ?? url.pathname,
             root: options.root,
             defaultDocument: DEFAULT_DOCUMENT,
         });
-        const content = await (0, cloudflare_1.getContentFromKVAsset)(path, {
+        const content = await getContentFromKVAsset(path, {
             manifest: options.manifest,
             namespace: options.namespace ? options.namespace : c.env ? c.env.__STATIC_CONTENT : undefined,
         });
         if (content) {
-            const mimeType = (0, mime_1.getMimeType)(path);
+            const mimeType = getMimeType(path);
             if (mimeType) {
                 c.header('Content-Type', mimeType);
             }
@@ -37,4 +34,3 @@ const serveStatic = (options = { root: '' }) => {
         return;
     };
 };
-exports.serveStatic = serveStatic;

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

@@ -0,0 +1,2 @@
+import { validatorMiddleware } from './middleware';
+export { validatorMiddleware as validator };

package/dist/middleware/validator/index.js

@@ -0,0 +1,2 @@
+import { validatorMiddleware } from './middleware';
+export { validatorMiddleware as validator };

package/dist/middleware/validator/middleware.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '../../context';
+import type { Environment, Handler } from '../../hono';
+import { Validator } from './validator';
+import type { VString, VNumber, VBoolean, VObject, ValidateResult } from './validator';
+declare type ValidationFunction<T> = (v: Validator, c: Context) => T;
+declare type Schema = {
+    [key: string]: VString | VNumber | VBoolean | VObject | Schema;
+};
+declare type SchemaToProp<T> = {
+    [K in keyof T]: T[K] extends VNumber ? number : T[K] extends VBoolean ? boolean : T[K] extends VString ? string : T[K] extends VObject ? object : T[K] extends Schema ? SchemaToProp<T[K]> : never;
+};
+declare type ResultSet = {
+    hasError: boolean;
+    messages: string[];
+    results: ValidateResult[];
+};
+declare type Done = (resultSet: ResultSet, context: Context) => Response | void;
+export declare const validatorMiddleware: <T extends Schema>(validationFunction: ValidationFunction<T>, options?: {
+    done?: Done;
+}) => Handler<string, Environment, SchemaToProp<T>>;
+export {};

package/dist/middleware/validator/middleware.js

@@ -0,0 +1,52 @@
+import { VBase, Validator } from './validator';
+function getValidatorList(schema) {
+    const map = [];
+    for (const [key, value] of Object.entries(schema)) {
+        if (value instanceof VBase) {
+            map.push([[key], value]);
+        }
+        else {
+            const children = getValidatorList(value);
+            for (const [keys, validator] of children) {
+                map.push([[key, ...keys], validator]);
+            }
+        }
+    }
+    return map;
+}
+export const validatorMiddleware = (validationFunction, options) => {
+    const v = new Validator();
+    const handler = async (c, next) => {
+        const resultSet = {
+            hasError: false,
+            messages: [],
+            results: [],
+        };
+        const validatorList = getValidatorList(validationFunction(v, c));
+        for (const [keys, validator] of validatorList) {
+            const result = await validator.validate(c.req);
+            if (result.isValid) {
+                // Set data on request object
+                c.req.valid(keys, result.value);
+            }
+            else {
+                resultSet.hasError = true;
+                if (result.message !== undefined) {
+                    resultSet.messages.push(result.message);
+                }
+            }
+            resultSet.results.push(result);
+        }
+        if (options && options.done) {
+            const res = options.done(resultSet, c);
+            if (res) {
+                return res;
+            }
+        }
+        if (resultSet.hasError) {
+            return c.text(resultSet.messages.join('\n'), 400);
+        }
+        await next();
+    };
+    return handler;
+};

package/dist/middleware/validator/rule.d.ts

@@ -0,0 +1,21 @@
+export declare const rule: {
+    isEmpty(value: string, options?: {
+        ignore_whitespace: boolean;
+    }): boolean;
+    isLength: (value: string, options: Partial<{
+        min: number;
+        max: number;
+    }> | number, arg2?: number) => boolean;
+    isAlpha: (value: string) => boolean;
+    isNumeric: (value: string) => boolean;
+    contains: (value: string, elem: string, options?: Partial<{
+        ignoreCase: boolean;
+        minOccurrences: number;
+    }>) => boolean;
+    isIn: (value: string, options: string[]) => boolean;
+    match: (value: string, regExp: RegExp) => boolean;
+    isGte: (value: number, min: number) => boolean;
+    isLte: (value: number, max: number) => boolean;
+    isTrue: (value: boolean) => boolean;
+    isFalse: (value: boolean) => boolean;
+};

package/dist/middleware/validator/rule.js

@@ -0,0 +1,63 @@
+// Some validation rules is are based on Validator.js
+// Validator.js
+// License (MIT)
+// Copyright (c) 2018 Chris O'Hara <cohara87@gmail.com>
+// https://github.com/validatorjs/validator.js
+export const rule = {
+    // string
+    isEmpty(value, options = { ignore_whitespace: false }) {
+        return (options.ignore_whitespace ? value.trim().length : value.length) === 0;
+    },
+    isLength: (value, options, arg2) => {
+        let min;
+        let max;
+        if (typeof options === 'object') {
+            min = options.min || 0;
+            max = options.max;
+        }
+        else {
+            // backwards compatibility: isLength(str, min [, max])
+            min = options || 0;
+            max = arg2;
+        }
+        const presentationSequences = value.match(/(\uFE0F|\uFE0E)/g) || [];
+        const surrogatePairs = value.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g) || [];
+        const len = value.length - presentationSequences.length - surrogatePairs.length;
+        return len >= min && (typeof max === 'undefined' || len <= max);
+    },
+    isAlpha: (value) => {
+        return /^[A-Z]+$/i.test(value);
+    },
+    isNumeric: (value) => {
+        return /^[0-9]+$/.test(value);
+    },
+    contains: (value, elem, options = {
+        ignoreCase: false,
+        minOccurrences: 1,
+    }) => {
+        options.ignoreCase || (options.ignoreCase = false);
+        options.minOccurrences || (options.minOccurrences = 1);
+        if (options.ignoreCase) {
+            return value.toLowerCase().split(elem.toLowerCase()).length > options.minOccurrences;
+        }
+        return value.split(elem).length > options.minOccurrences;
+    },
+    isIn: (value, options) => {
+        if (typeof options === 'object') {
+            for (const elem of options) {
+                if (elem === value)
+                    return true;
+            }
+        }
+        return false;
+    },
+    match: (value, regExp) => {
+        return regExp.test(value);
+    },
+    // number
+    isGte: (value, min) => min <= value,
+    isLte: (value, max) => value <= max,
+    // boolean
+    isTrue: (value) => value === true,
+    isFalse: (value) => value === false,
+};

package/dist/middleware/validator/sanitizer.d.ts

@@ -0,0 +1,3 @@
+export declare const sanitizer: {
+    trim: (value: string) => string;
+};

package/dist/middleware/validator/sanitizer.js

@@ -0,0 +1,3 @@
+export const sanitizer = {
+    trim: (value) => value.trim(),
+};

package/dist/middleware/validator/validator.d.ts

@@ -0,0 +1,75 @@
+declare type Target = 'query' | 'header' | 'body' | 'json';
+declare type Type = string | number | boolean | object | undefined;
+declare type Rule = (value: Type) => boolean;
+declare type Sanitizer = (value: Type) => Type;
+export declare class Validator {
+    query: (key: string) => VString;
+    header: (key: string) => VString;
+    body: (key: string) => VString;
+    json: (key: string) => VString;
+}
+export declare type ValidateResult = {
+    isValid: boolean;
+    message: string | undefined;
+    target: Target;
+    key: string;
+    value: Type;
+};
+declare type VOptions = {
+    target: Target;
+    key: string;
+    type?: 'string' | 'number' | 'boolean' | 'object';
+};
+export declare abstract class VBase {
+    type: 'string' | 'number' | 'boolean' | 'object';
+    target: Target;
+    key: string;
+    rules: Rule[];
+    sanitizers: Sanitizer[];
+    private _message;
+    constructor(options: VOptions);
+    addRule: (rule: Rule) => this;
+    addSanitizer: (sanitizer: Sanitizer) => this;
+    isRequired: () => this;
+    isOptional: () => this;
+    isEqual: (comparison: unknown) => this;
+    asNumber: () => VNumber;
+    asBoolean: () => VBoolean;
+    asObject: () => VObject;
+    message(value: string): this;
+    validate: (req: Request) => Promise<ValidateResult>;
+    private validateValue;
+}
+export declare class VString extends VBase {
+    constructor(options: VOptions);
+    isEmpty: (options?: {
+        ignore_whitespace: boolean;
+    }) => this;
+    isLength: (options: Partial<{
+        min: number;
+        max: number;
+    }> | number, arg2?: number) => this;
+    isAlpha: () => this;
+    isNumeric: () => this;
+    contains: (elem: string, options?: Partial<{
+        ignoreCase: boolean;
+        minOccurrences: number;
+    }>) => this;
+    isIn: (options: string[]) => this;
+    match: (regExp: RegExp) => this;
+    trim: () => this;
+}
+export declare class VNumber extends VBase {
+    constructor(options: VOptions);
+    isGte: (min: number) => this;
+    isLte: (min: number) => this;
+}
+export declare class VBoolean extends VBase {
+    constructor(options: VOptions);
+    isTrue: () => this;
+    isFalse: () => this;
+}
+export declare class VObject extends VBase {
+    constructor(options: VOptions);
+}
+export {};