Socket
Socket
Sign inDemoInstall

h3

Package Overview
Dependencies
Maintainers
1
Versions
98
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

h3 - npm Package Compare versions

Comparing version 0.7.21 to 0.8.0

183

dist/index.d.ts

@@ -1,5 +0,27 @@

import { IncomingMessage as IncomingMessage$1, ServerResponse as ServerResponse$1, OutgoingMessage } from 'http';
import { IncomingMessage, ServerResponse, OutgoingMessage } from 'http';
export { IncomingMessage as NodeIncomingMessage, ServerResponse as NodeServerResponse } from 'http';
import { CookieSerializeOptions } from 'cookie-es';
import * as ufo from 'ufo';
declare type HTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
declare type Encoding = false | 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'latin1' | 'binary' | 'hex';
interface H3EventContext extends Record<string, any> {
}
declare type EventHandlerResponse<T = any> = T | Promise<T>;
interface EventHandler<T = any> {
'__is_handler__'?: true;
(event: H3Event): EventHandlerResponse<T>;
}
declare type LazyEventHandler = () => EventHandler | Promise<EventHandler>;
declare type NodeListener = (req: IncomingMessage, res: ServerResponse) => void;
declare type NodePromisifiedHandler = (req: IncomingMessage, res: ServerResponse) => Promise<any>;
declare type NodeMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: Error) => any) => any;
declare const defineNodeListener: (handler: NodeListener) => NodeListener;
declare const defineNodeMiddleware: (middleware: NodeMiddleware) => NodeMiddleware;
declare function fromNodeMiddleware(handler: NodeListener | NodeMiddleware): EventHandler;
declare function toNodeListener(app: App): NodeListener;
declare function promisifyNodeListener(handler: NodeListener | NodeMiddleware): NodePromisifiedHandler;
declare function callNodeListener(handler: NodeMiddleware, req: IncomingMessage, res: ServerResponse): Promise<unknown>;
declare class H3Headers implements Headers {

@@ -27,3 +49,3 @@ _headers: Record<string, string>;

readonly bodyUsed = false;
constructor(body?: BodyInit | HandlerResponse | null, init?: ResponseInit);
constructor(body?: BodyInit | EventHandlerResponse | null, init?: ResponseInit);
clone(): H3Response;

@@ -41,9 +63,8 @@ arrayBuffer(): Promise<ArrayBuffer>;

res: ServerResponse;
event: H3Event;
context: H3EventContext;
constructor(req: IncomingMessage$1 | IncomingMessage, res: ServerResponse$1 | ServerResponse);
constructor(req: IncomingMessage, res: ServerResponse);
respondWith(r: H3Response | PromiseLike<H3Response>): void;
}
declare function isEvent(input: any): input is H3Event;
declare function createEvent(req: IncomingMessage$1, res: ServerResponse$1): H3Event;
declare function createEvent(req: IncomingMessage, res: ServerResponse): H3Event;

@@ -53,3 +74,3 @@ declare function defineEventHandler<T = any>(handler: EventHandler<T>): EventHandler<T>;

declare function isEventHandler(input: any): input is EventHandler;
declare function toEventHandler(handler: CompatibilityEventHandler): EventHandler;
declare function toEventHandler(input: any, _?: any, _route?: string): EventHandler;
interface DynamicEventHandler extends EventHandler {

@@ -62,34 +83,2 @@ set: (handler: EventHandler) => void;

interface CompatibilityRequestProps {
event: H3Event;
context: H3EventContext;
/** Only available with connect and press */
originalUrl?: string;
}
interface IncomingMessage extends IncomingMessage$1, CompatibilityRequestProps {
req: H3Event['req'];
res: H3Event['res'];
}
interface ServerResponse extends ServerResponse$1 {
event: H3Event;
res: H3Event['res'];
req: ServerResponse$1['req'] & CompatibilityRequestProps;
}
declare type Handler<T = any, ReqT = {}> = (req: IncomingMessage & ReqT, res: ServerResponse) => T;
declare type PromisifiedHandler = Handler<Promise<any>>;
declare type Middleware = (req: IncomingMessage, res: ServerResponse, next: (err?: Error) => any) => any;
declare type LazyHandler = () => Handler | Promise<Handler>;
declare type Encoding = false | 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'latin1' | 'binary' | 'hex';
declare type HTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
interface H3EventContext extends Record<string, any> {
}
declare type CompatibilityEvent = H3Event | IncomingMessage;
declare type HandlerResponse<T = any> = T | Promise<T>;
interface EventHandler<T = any> {
'__is_handler__'?: true;
(event: H3Event): HandlerResponse<T>;
}
declare type LazyEventHandler = () => EventHandler | Promise<EventHandler>;
declare type CompatibilityEventHandler = EventHandler | Handler | Middleware;
interface Layer {

@@ -104,29 +93,24 @@ route: string;

match?: Matcher;
handler: Handler | LazyHandler | EventHandler | LazyEventHandler;
handler: EventHandler;
lazy?: boolean;
/** @deprecated */
handle?: Handler;
/** @deprecated */
promisify?: boolean;
}
declare type InputStack = InputLayer[];
declare type Matcher = (url: string, event?: CompatibilityEvent) => boolean;
declare type Matcher = (url: string, event?: H3Event) => boolean;
interface AppUse {
(route: string | string[], handler: CompatibilityEventHandler | CompatibilityEventHandler[], options?: Partial<InputLayer>): App;
(handler: CompatibilityEventHandler | CompatibilityEventHandler[], options?: Partial<InputLayer>): App;
(route: string | string[], handler: EventHandler | EventHandler[], options?: Partial<InputLayer>): App;
(handler: EventHandler | EventHandler[], options?: Partial<InputLayer>): App;
(options: InputLayer): App;
}
declare type NodeHandler = (req: IncomingMessage$1, res: ServerResponse$1) => Promise<void>;
interface App extends NodeHandler {
interface AppOptions {
debug?: boolean;
onError?: (error: Error, event: H3Event) => any;
}
interface App {
stack: Stack;
handler: EventHandler;
nodeHandler: NodeHandler;
options: AppOptions;
use: AppUse;
}
interface AppOptions {
debug?: boolean;
onError?: (error: Error, event: CompatibilityEvent) => any;
}
declare function createApp(options?: AppOptions): App;
declare function use(app: App, arg1: string | Handler | InputLayer | InputLayer[], arg2?: Handler | Partial<InputLayer> | Handler[] | Middleware | Middleware[], arg3?: Partial<InputLayer>): App;
declare function use(app: App, arg1: string | EventHandler | InputLayer | InputLayer[], arg2?: Partial<InputLayer> | EventHandler | EventHandler[], arg3?: Partial<InputLayer>): App;
declare function createAppEventHandler(stack: Stack, options: AppOptions): EventHandler<void>;

@@ -151,3 +135,3 @@

unhandled: boolean;
statusMessage: string;
statusMessage?: string;
data?: any;

@@ -167,3 +151,3 @@ }

*
@param event {CompatibilityEvent} H3 event or req passed by h3 handler
@param event {H3Event} H3 event or req passed by h3 handler
* @param error {H3Error|Error} Raised error

@@ -173,21 +157,10 @@ * @param debug {Boolean} Whether application is in debug mode.<br>

*/
declare function sendError(event: CompatibilityEvent, error: Error | H3Error, debug?: boolean): void;
declare function sendError(event: H3Event, error: Error | H3Error, debug?: boolean): void;
declare function isError(input: any): input is H3Error;
declare const defineHandler: <T>(handler: Handler<T, {}>) => Handler<T, {}>;
/** @deprecated Use defineHandler */
declare const defineHandle: <T>(handler: Handler<T, {}>) => Handler<T, {}>;
declare const defineMiddleware: (middleware: Middleware) => Middleware;
declare function promisifyHandler(handler: Handler | Middleware): PromisifiedHandler;
/** @deprecated Use defineHandler */
declare const promisifyHandle: typeof promisifyHandler;
declare function callHandler(handler: Middleware, req: IncomingMessage, res: ServerResponse): Promise<unknown>;
declare function defineLazyHandler(handler: LazyHandler, promisify?: boolean): Handler;
/** @deprecated Use defineLazyHandler */
declare const lazyHandle: typeof defineLazyHandler;
declare function useBase(base: string, handler: Handler): Handler;
declare function useBase(base: string, handler: EventHandler): EventHandler;
/**
* Reads body of the request and returns encoded raw string (default) or `Buffer` if encoding if falsy.
* @param event {CompatibilityEvent} H3 event or req passed by h3 handler
* @param event {H3Event} H3 event or req passed by h3 handler
* @param encoding {Encoding} encoding="utf-8" - The character encoding to use.

@@ -197,3 +170,3 @@ *

*/
declare function readRawBody(event: CompatibilityEvent, encoding?: Encoding): Encoding extends false ? Buffer : Promise<string | Buffer>;
declare function readRawBody(event: H3Event, encoding?: Encoding): Encoding extends false ? Buffer : Promise<string | Buffer>;
/** @deprecated Use `h3.readRawBody` */

@@ -203,3 +176,3 @@ declare const useRawBody: typeof readRawBody;

* Reads request body and try to safely parse using [destr](https://github.com/unjs/destr)
* @param event {CompatibilityEvent} H3 event or req passed by h3 handler
* @param event {H3Event} H3 event or req passed by h3 handler
* @param encoding {Encoding} encoding="utf-8" - The character encoding to use.

@@ -213,3 +186,3 @@ *

*/
declare function readBody<T = any>(event: CompatibilityEvent): Promise<T>;
declare function readBody<T = any>(event: H3Event): Promise<T>;
/** @deprecated Use `h3.readBody` */

@@ -229,3 +202,3 @@ declare const useBody: typeof readBody;

*/
declare function handleCacheHeaders(event: CompatibilityEvent, opts: CacheConditions): boolean;
declare function handleCacheHeaders(event: H3Event, opts: CacheConditions): boolean;

@@ -239,3 +212,3 @@ declare const MIMES: {

* Parse the request to get HTTP Cookie header string and returning an object of all cookie name-value pairs.
* @param event {CompatibilityEvent} H3 event or req passed by h3 handler
* @param event {H3Event} H3 event or req passed by h3 handler
* @returns Object of cookie name-value pairs

@@ -246,3 +219,3 @@ * ```ts

*/
declare function parseCookies(event: CompatibilityEvent): Record<string, string>;
declare function parseCookies(event: H3Event): Record<string, string>;
/** @deprecated Use `h3.parseCookies` */

@@ -252,3 +225,3 @@ declare const useCookies: typeof parseCookies;

* Get a cookie value by name.
* @param event {CompatibilityEvent} H3 event or req passed by h3 handler
* @param event {H3Event} H3 event or req passed by h3 handler
* @param name Name of the cookie to get

@@ -260,3 +233,3 @@ * @returns {*} Value of the cookie (String or undefined)

*/
declare function getCookie(event: CompatibilityEvent, name: string): string | undefined;
declare function getCookie(event: H3Event, name: string): string | undefined;
/** @deprecated Use `h3.getCookie` */

@@ -266,3 +239,3 @@ declare const useCookie: typeof getCookie;

* Set a cookie value by name.
* @param event {CompatibilityEvent} H3 event or res passed by h3 handler
* @param event {H3Event} H3 event or res passed by h3 handler
* @param name Name of the cookie to set

@@ -275,6 +248,6 @@ * @param value Value of the cookie to set

*/
declare function setCookie(event: CompatibilityEvent, name: string, value: string, serializeOptions?: CookieSerializeOptions): void;
declare function setCookie(event: H3Event, name: string, value: string, serializeOptions?: CookieSerializeOptions): void;
/**
* Set a cookie value by name.
* @param event {CompatibilityEvent} H3 event or res passed by h3 handler
* @param event {H3Event} H3 event or res passed by h3 handler
* @param name Name of the cookie to delete

@@ -286,37 +259,38 @@ * @param serializeOptions {CookieSerializeOptions} Cookie options

*/
declare function deleteCookie(event: CompatibilityEvent, name: string, serializeOptions?: CookieSerializeOptions): void;
declare function deleteCookie(event: H3Event, name: string, serializeOptions?: CookieSerializeOptions): void;
declare function getQuery(event: CompatibilityEvent): ufo.QueryObject;
declare function getQuery(event: H3Event): ufo.QueryObject;
/** @deprecated Use `h3.getQuery` */
declare const useQuery: typeof getQuery;
declare function getRouterParams(event: CompatibilityEvent): CompatibilityEvent['context'];
declare function getRouterParam(event: CompatibilityEvent, name: string): CompatibilityEvent['context'][string];
declare function getMethod(event: CompatibilityEvent, defaultMethod?: HTTPMethod): HTTPMethod;
declare function getRouterParams(event: H3Event): H3Event['context'];
declare function getRouterParam(event: H3Event, name: string): H3Event['context'][string];
declare function getMethod(event: H3Event, defaultMethod?: HTTPMethod): HTTPMethod;
/** @deprecated Use `h3.getMethod` */
declare const useMethod: typeof getMethod;
declare function isMethod(event: CompatibilityEvent, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): boolean;
declare function assertMethod(event: CompatibilityEvent, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): void;
declare function getRequestHeaders(event: CompatibilityEvent): CompatibilityEvent['req']['headers'];
declare function isMethod(event: H3Event, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): boolean;
declare function assertMethod(event: H3Event, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): void;
declare function getRequestHeaders(event: H3Event): H3Event['req']['headers'];
declare const getHeaders: typeof getRequestHeaders;
declare function getRequestHeader(event: CompatibilityEvent, name: string): CompatibilityEvent['req']['headers'][string];
declare function getRequestHeader(event: H3Event, name: string): H3Event['req']['headers'][string];
declare const getHeader: typeof getRequestHeader;
declare function send(event: CompatibilityEvent, data?: any, type?: string): Promise<void>;
declare function defaultContentType(event: CompatibilityEvent, type?: string): void;
declare function sendRedirect(event: CompatibilityEvent, location: string, code?: number): Promise<void>;
declare function getResponseHeaders(event: CompatibilityEvent): ReturnType<CompatibilityEvent['res']['getHeaders']>;
declare function getResponseHeader(event: CompatibilityEvent, name: string): ReturnType<CompatibilityEvent['res']['getHeader']>;
declare function setResponseHeaders(event: CompatibilityEvent, headers: Record<string, Parameters<OutgoingMessage['setHeader']>[1]>): void;
declare function send(event: H3Event, data?: any, type?: string): Promise<void>;
declare function defaultContentType(event: H3Event, type?: string): void;
declare function sendRedirect(event: H3Event, location: string, code?: number): Promise<void>;
declare function getResponseHeaders(event: H3Event): ReturnType<H3Event['res']['getHeaders']>;
declare function getResponseHeader(event: H3Event, name: string): ReturnType<H3Event['res']['getHeader']>;
declare function setResponseHeaders(event: H3Event, headers: Record<string, Parameters<OutgoingMessage['setHeader']>[1]>): void;
declare const setHeaders: typeof setResponseHeaders;
declare function setResponseHeader(event: CompatibilityEvent, name: string, value: Parameters<OutgoingMessage['setHeader']>[1]): void;
declare function setResponseHeader(event: H3Event, name: string, value: Parameters<OutgoingMessage['setHeader']>[1]): void;
declare const setHeader: typeof setResponseHeader;
declare function appendResponseHeaders(event: CompatibilityEvent, headers: Record<string, string>): void;
declare function appendResponseHeaders(event: H3Event, headers: Record<string, string>): void;
declare const appendHeaders: typeof appendResponseHeaders;
declare function appendResponseHeader(event: CompatibilityEvent, name: string, value: string): void;
declare function appendResponseHeader(event: H3Event, name: string, value: string): void;
declare const appendHeader: typeof appendResponseHeader;
declare function isStream(data: any): any;
declare function sendStream(event: CompatibilityEvent, data: any): Promise<void>;
declare function sendStream(event: H3Event, data: any): Promise<void>;
declare function writeEarlyHints(event: H3Event, links: string | string[], callback?: () => void): void;
declare type RouterMethod = Lowercase<HTTPMethod>;
declare type RouterUse = (path: string, handler: CompatibilityEventHandler, method?: RouterMethod | RouterMethod[]) => Router;
declare type RouterUse = (path: string, handler: EventHandler, method?: RouterMethod | RouterMethod[]) => Router;
declare type AddRouteShortcuts = Record<RouterMethod, RouterUse>;

@@ -328,4 +302,7 @@ interface Router extends AddRouteShortcuts {

}
declare function createRouter(): Router;
interface CreateRouterOptions {
preemtive?: boolean;
}
declare function createRouter(opts?: CreateRouterOptions): Router;
export { AddRouteShortcuts, App, AppOptions, AppUse, CacheConditions, CompatibilityEvent, CompatibilityEventHandler, DynamicEventHandler, Encoding, EventHandler, H3Error, H3Event, H3EventContext, H3Headers, H3Response, HTTPMethod, Handler, HandlerResponse, IncomingMessage, InputLayer, InputStack, Layer, LazyEventHandler, LazyHandler, MIMES, Matcher, Middleware, NodeHandler, PromisifiedHandler, Router, RouterMethod, RouterUse, ServerResponse, Stack, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callHandler, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineHandle, defineHandler, defineLazyEventHandler, defineLazyHandler, defineMiddleware, deleteCookie, dynamicEventHandler, eventHandler, getCookie, getHeader, getHeaders, getMethod, getQuery, getRequestHeader, getRequestHeaders, getResponseHeader, getResponseHeaders, getRouterParam, getRouterParams, handleCacheHeaders, isError, isEvent, isEventHandler, isMethod, isStream, lazyEventHandler, lazyHandle, parseCookies, promisifyHandle, promisifyHandler, readBody, readRawBody, send, sendError, sendRedirect, sendStream, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, toEventHandler, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody };
export { AddRouteShortcuts, App, AppOptions, AppUse, CacheConditions, CreateRouterOptions, DynamicEventHandler, Encoding, EventHandler, EventHandlerResponse, H3Error, H3Event, H3EventContext, H3Headers, H3Response, HTTPMethod, InputLayer, InputStack, Layer, LazyEventHandler, MIMES, Matcher, NodeListener, NodeMiddleware, NodePromisifiedHandler, Router, RouterMethod, RouterUse, Stack, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callNodeListener, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineLazyEventHandler, defineNodeListener, defineNodeMiddleware, deleteCookie, dynamicEventHandler, eventHandler, fromNodeMiddleware, getCookie, getHeader, getHeaders, getMethod, getQuery, getRequestHeader, getRequestHeaders, getResponseHeader, getResponseHeaders, getRouterParam, getRouterParams, handleCacheHeaders, isError, isEvent, isEventHandler, isMethod, isStream, lazyEventHandler, parseCookies, promisifyNodeListener, readBody, readRawBody, send, sendError, sendRedirect, sendStream, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, toEventHandler, toNodeListener, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody, writeEarlyHints };

33

package.json
{
"name": "h3",
"version": "0.7.21",
"version": "0.8.0",
"description": "Tiny JavaScript Server",

@@ -9,2 +9,3 @@ "repository": "unjs/h3",

"exports": {
"./package.json": "./package.json",
".": {

@@ -25,3 +26,3 @@ "types": "./dist/index.d.ts",

"destr": "^1.1.1",
"radix3": "^0.1.2",
"radix3": "^0.2.0",
"ufo": "^0.8.5"

@@ -32,20 +33,20 @@ },

"@nuxtjs/eslint-config-typescript": "^11.0.0",
"@types/express": "^4.17.13",
"@types/node": "^18.7.14",
"@types/express": "^4.17.14",
"@types/node": "^18.11.0",
"@types/supertest": "^2.0.12",
"@vitest/coverage-c8": "^0.22.1",
"autocannon": "^7.9.0",
"changelogen": "^0.3.0",
"@vitest/coverage-c8": "^0.24.3",
"autocannon": "^7.10.0",
"changelogen": "^0.3.2",
"connect": "^3.7.0",
"eslint": "^8.23.0",
"express": "^4.18.1",
"eslint": "^8.25.0",
"express": "^4.18.2",
"get-port": "^6.1.2",
"jiti": "^1.14.0",
"listhen": "^0.2.15",
"supertest": "^6.2.4",
"typescript": "^4.8.2",
"unbuild": "^0.8.10",
"vitest": "^0.22.1"
"jiti": "^1.16.0",
"listhen": "^0.3.4",
"supertest": "^6.3.0",
"typescript": "^4.8.4",
"unbuild": "^0.9.2",
"vitest": "^0.24.3"
},
"packageManager": "pnpm@7.9.5",
"packageManager": "pnpm@7.13.4",
"scripts": {

@@ -52,0 +53,0 @@ "build": "unbuild",

90

README.md

@@ -16,6 +16,4 @@ [![npm downloads](https://img.shields.io/npm/dm/h3.svg?style=flat-square)](https://npmjs.com/package/h3)

✔️ &nbsp;**Compatible:** Support connect/express middleware
✔️ &nbsp;**Minimal:** Small and tree-shakable
✔️ &nbsp;**Minimal:** Small, tree-shakable and zero-dependency
✔️ &nbsp;**Modern:** Native promise support

@@ -27,2 +25,4 @@

✔️ &nbsp;**Compatible:** Compatibility layer with node/connect/express middleware
## Install

@@ -45,8 +45,8 @@

import { createServer } from 'http'
import { createApp } from 'h3'
import { createApp, eventHandler } from 'h3'
const app = createApp()
app.use('/', () => 'Hello world!')
app.use('/', eventHandler(() => 'Hello world!'))
createServer(app).listen(process.env.PORT || 3000)
createServer(toNodeListener(app)).listen(process.env.PORT || 3000)
```

@@ -58,9 +58,9 @@

```ts
import { createApp } from 'h3'
import { createApp, toNodeListener } from 'h3'
import { listen } from 'listhen'
const app = createApp()
app.use('/', () => 'Hello world!')
app.use('/', eventHandler(() => 'Hello world!'))
listen(app)
listen(toNodeListener(app))
```

@@ -76,3 +76,3 @@ </details>

```ts
import { createApp, createRouter } from 'h3'
import { createApp, eventHandler, createRouter } from 'h3'

@@ -82,4 +82,4 @@ const app = createApp()

const router = createRouter()
.get('/', () => 'Hello World!')
.get('/hello/:name', req => `Hello ${req.context.params.name}!`)
.get('/', eventHandler(() => 'Hello World!'))
.get('/hello/:name', eventHandler(event => `Hello ${event.context.params.name}!`))

@@ -93,26 +93,23 @@ app.use(router)

## More usage examples
## More app usage examples
```js
// Handle can directly return object or Promise<object> for JSON response
app.use('/api', (req) => ({ url: req.url }))
app.use('/api', eventHandler((event) => ({ url: event.req.url }))
// We can have better matching other than quick prefix match
app.use('/odd', () => 'Is odd!', { match: url => url.substr(1) % 2 })
app.use('/odd', eventHandler(() => 'Is odd!'), { match: url => url.substr(1) % 2 })
// Handle can directly return string for HTML response
app.use(() => '<h1>Hello world!</h1>')
app.use(eventHandler(() => '<h1>Hello world!</h1>'))
// We can chain calls to .use()
app.use('/1', () => '<h1>Hello world!</h1>')
.use('/2', () => '<h1>Goodbye!</h1>')
app.use('/1', eventHandler(() => '<h1>Hello world!</h1>'))
.use('/2', eventHandler(() => '<h1>Goodbye!</h1>'))
// Legacy middleware with 3rd argument are automatically promisified
app.use((req, res, next) => { req.setHeader('X-Foo', 'bar'); next() })
app.use(fromNodeMiddleware((req, res, next) => { req.setHeader('X-Foo', 'bar'); next() }))
// Force promisify a legacy middleware
// app.use(someMiddleware, { promisify: true })
// Lazy loaded routes using { lazy: true }
// app.use('/big', () => import('./big'), { lazy: true })
app.use('/big', () => import('./big-handler'), { lazy: true })
```

@@ -122,16 +119,16 @@

H3 has concept of compasable utilities that accept `event` (from `eventHandler((event) => {})`) as their first argument. This has several performance benefits over injecting them to `event` or `app` instances and global middleware commonly used in Node.js frameworks such as Express, which Only required code is evaluated and bundled and rest of utils can be tree-shaken when not used.
### Built-in
Instead of adding helpers to `req` and `res`, h3 exposes them as composable utilities.
- `useRawBody(req, encoding?)`
- `useBody(req)`
- `useCookies(req)`
- `useCookie(req, name)`
- `setCookie(res, name, value, opts?)`
- `deleteCookie(res, name, opts?)`
- `useQuery(req)`
- `useRawBody(event, encoding?)`
- `useBody(event)`
- `useCookies(event)`
- `useCookie(event, name)`
- `setCookie(event, name, value, opts?)`
- `deleteCookie(event, name, opts?)`
- `useQuery(event)`
- `getRouterParams(event)`
- `send(res, data, type?)`
- `sendRedirect(res, location, code=302)`
- `send(event, data, type?)`
- `sendRedirect(event, location, code=302)`
- `getRequestHeaders(event, headers)` (alias: `getHeaders`)

@@ -143,9 +140,9 @@ - `getRequestHeader(event, name)` (alias: `getHeader`)

- `appendResponseHeader(event, name, value)` (alias: `appendHeader`)
- `writeEarlyHints(event, links, callback)`
- `sendStream(event, data)`
- `sendError(event, error, debug?)`
- `useMethod(event, default?)`
- `isMethod(event, expected, allowHead?)`
- `assertMethod(event, expected, allowHead?)`
- `createError({ statusCode, statusMessage, data? })`
- `sendError(res, error, debug?)`
- `defineHandle(handle)`
- `defineMiddleware(middlware)`
- `useMethod(req, default?)`
- `isMethod(req, expected, allowHead?)`
- `assertMethod(req, expected, allowHead?)`

@@ -161,17 +158,4 @@ 👉 You can learn more about usage in [JSDocs Documentation](https://www.jsdocs.io/package/h3#package-functions).

## How it works?
Using `createApp`, it returns a standard `(req, res)` handler function and internally an array called middleware stack. using`use()` method we can add an item to this internal stack.
When a request comes, each stack item that matches the route will be called and resolved until [`res.writableEnded`](https://nodejs.org/api/http.html#http_response_writableended) flag is set, which means the response is sent. If `writableEnded` is not set after all middleware, a `404` error will be thrown. And if one of the stack items resolves to a value, it will be serialized and sent as response as a shorthand method to sending responses.
For maximum compatibility with connect/express middleware (`req, res, next?` signature), h3 converts classic middleware into a promisified version ready to use with stack runner:
- If middleware has 3rd next/callback param, the promise will `resolve/reject` when called
- If middleware returns a promise, it will be **chained** to the main promise
- If calling middleware throws an immediate error, the promise will be rejected
- On `close` and `error` events of res, the promise will `resolve/reject` (to ensure if middleware simply calls `res.end`)
## License
MIT
dist/index.cjs

Sorry, the diff of this file is not supported yet

dist/index.mjs

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc