() {
164 | return {
165 | get: (
166 | path: P,
167 | handler: Handler<'GET', P, RequestContext>,
168 | ) => ['GET', path as string, handler] as Route,
169 | post: (
170 | path: P,
171 | handler: Handler<'POST', P, RequestContext>,
172 | ) => ['POST', path as string, handler] as Route,
173 | put: (
174 | path: P,
175 | handler: Handler<'PUT', P, RequestContext>,
176 | ) => ['PUT', path as string, handler] as Route,
177 | delete: (
178 | path: P,
179 | handler: Handler<'DELETE', P, RequestContext>,
180 | ) => ['DELETE', path as string, handler] as Route,
181 | route: (
182 | method: M,
183 | path: P,
184 | handler: Handler, P, RequestContext>,
185 | ) =>
186 | [method.toUpperCase(), path as string, handler] as Route,
187 | };
188 | }
189 |
190 | function toError(e: unknown) {
191 | return e instanceof Error ? e : new Error(String(e));
192 | }
193 |
--------------------------------------------------------------------------------
/packages/core/src/core/index.ts:
--------------------------------------------------------------------------------
1 | export { defineAdapter } from './defineAdapter';
2 | export { HttpError } from './HttpError';
3 | export type { Router } from './Router';
4 |
--------------------------------------------------------------------------------
/packages/core/src/core/support/__tests__/mimeTypes.test.ts:
--------------------------------------------------------------------------------
1 | import { getMimeTypeFromExt, getExtForMimeType } from '../mimeTypes';
2 |
3 | describe('mimeTypes', () => {
4 | it('should look up mime type from file extension', () => {
5 | expect(getMimeTypeFromExt('htm')).toEqual('text/html');
6 | expect(getMimeTypeFromExt('html')).toEqual('text/html');
7 | expect(getMimeTypeFromExt('png')).toEqual('image/png');
8 | expect(getMimeTypeFromExt('asdf')).toEqual(undefined);
9 | });
10 |
11 | it('should look up extension from mime type', () => {
12 | expect(getExtForMimeType('text/html')).toEqual('html');
13 | expect(getExtForMimeType('application/json')).toEqual('json');
14 | expect(getExtForMimeType('application/asdf')).toEqual(undefined);
15 | });
16 | });
17 |
--------------------------------------------------------------------------------
/packages/core/src/core/support/createMeta.ts:
--------------------------------------------------------------------------------
1 | export function createMeta() {
2 | const weakMap = new WeakMap();
3 | const get = (object: object): T | undefined => {
4 | return weakMap.get(object);
5 | };
6 | const set = (object: O, value: T): O => {
7 | weakMap.set(object, value);
8 | return object;
9 | };
10 | return [get, set] as const;
11 | }
12 |
--------------------------------------------------------------------------------
/packages/core/src/core/support/defineErrors.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * This provides a way to create a set of pre-defined custom errors. The reason
3 | * we'd do this is so that our application code can easily determine if a given
4 | * error is of some known kind by checking the `name` property or by using
5 | * `instanceof`.
6 | */
7 |
8 | import type { Expand } from '../../types';
9 |
10 | type StringWithPlaceholder = `${string}{${string}}${string}`;
11 |
12 | type Parse =
13 | T extends `${infer _Start}{${infer Var}}${infer Rest}`
14 | ? Rest extends StringWithPlaceholder
15 | ? Expand<{ [K in Var]: unknown } & Parse>
16 | : { [K in Var]: unknown }
17 | : never;
18 |
19 | export function defineErrors>(
20 | input: T,
21 | ): {
22 | [K in keyof T as K extends `${string}Error`
23 | ? K
24 | : never]: T[K] extends StringWithPlaceholder
25 | ? new (params: Parse, options?: ErrorOptions) => Error
26 | : new (params?: null, options?: ErrorOptions) => Error;
27 | } {
28 | return Object.fromEntries(
29 | Object.entries(input).map(([name, message]) => [
30 | name,
31 | Object.defineProperties(
32 | class extends Error {
33 | constructor(
34 | params?: Record,
35 | options?: ErrorOptions,
36 | ) {
37 | let resolvedMessage = params
38 | ? resolveMessage(message, params)
39 | : message;
40 | if (options?.cause) {
41 | resolvedMessage += '\n' + indent(String(options.cause));
42 | }
43 | super(resolvedMessage, options);
44 | }
45 | get name() {
46 | return name;
47 | }
48 | get [Symbol.toStringTag]() {
49 | return name;
50 | }
51 | },
52 | {
53 | // Defining the name property here is only necessary because we're
54 | // using an anonymous class
55 | name: { value: name, configurable: true },
56 | },
57 | ),
58 | ]),
59 | // eslint-disable-next-line @typescript-eslint/no-explicit-any
60 | ) as any;
61 | }
62 |
63 | function resolveMessage(message: string, params: Record) {
64 | return message.replace(/\{(.*?)\}/g, (_, key) => {
65 | return params[key] == null ? '' : String(params[key]);
66 | });
67 | }
68 |
69 | function indent(message: string) {
70 | const lineBreak = /\r\n|\r|\n/;
71 | return message
72 | .split(lineBreak)
73 | .map((line) => ' ' + line)
74 | .join('\n');
75 | }
76 |
--------------------------------------------------------------------------------
/packages/core/src/core/support/getPlatform.ts:
--------------------------------------------------------------------------------
1 | import { PLATFORM } from '../../constants';
2 |
3 | /**
4 | * The sole purpose of this function is as a helper when testing that symlink'd
5 | * modules work correctly. It imports the PLATFORM constant from two directories
6 | * up which intentionally breaks out of the symlink'd `core` directory.
7 | */
8 | export function getPlatform() {
9 | return PLATFORM;
10 | }
11 |
--------------------------------------------------------------------------------
/packages/core/src/core/support/mimeTypes.ts:
--------------------------------------------------------------------------------
1 | // The 73 most common mime types and their corresponding file extension(s)
2 | // Source: https://github.com/mdn/content/blob/8833cdb/files/en-us/web/http/basics_of_http/mime_types/common_types/index.md
3 | const mimeTypeList =
4 | 'audio/aac=aac&application/x-abiword=abw&application/x-freearc=arc&image/avif=avif&video/x-msvideo=avi&application/vnd.amazon.ebook=azw&application/octet-stream=bin&image/bmp=bmp&application/x-bzip=bz&application/x-bzip2=bz2&application/x-cdf=cda&application/x-csh=csh&text/css=css&text/csv=csv&application/msword=doc&application/vnd.openxmlformats-officedocument.wordprocessingml.document=docx&application/vnd.ms-fontobject=eot&application/epub+zip=epub&application/gzip=gz&image/gif=gif&text/html=html,htm&image/vnd.microsoft.icon=ico&text/calendar=ics&application/java-archive=jar&image/jpeg=jpeg,jpg&text/javascript=js,mjs&application/json=json&application/ld+json=jsonld&audio/midi+audio/x-midi=midi,mid&audio/mpeg=mp3&video/mp4=mp4&video/mpeg=mpeg&application/vnd.apple.installer+xml=mpkg&application/vnd.oasis.opendocument.presentation=odp&application/vnd.oasis.opendocument.spreadsheet=ods&application/vnd.oasis.opendocument.text=odt&audio/ogg=oga&video/ogg=ogv&application/ogg=ogx&audio/opus=opus&font/otf=otf&image/png=png&application/pdf=pdf&application/x-httpd-php=php&application/vnd.ms-powerpoint=ppt&application/vnd.openxmlformats-officedocument.presentationml.presentation=pptx&application/vnd.rar=rar&application/rtf=rtf&application/x-sh=sh&image/svg+xml=svg&application/x-shockwave-flash=swf&application/x-tar=tar&image/tiff=tif,tiff&video/mp2t=ts&font/ttf=ttf&text/plain=txt&application/vnd.visio=vsd&audio/wav=wav&audio/webm=weba&video/webm=webm&image/webp=webp&font/woff=woff&font/woff2=woff2&application/xhtml+xml=xhtml&application/vnd.ms-excel=xls&application/vnd.openxmlformats-officedocument.spreadsheetml.sheet=xlsx&application/xml=xml&application/vnd.mozilla.xul+xml=xul&application/zip=zip&video/3gpp=3gp&video/3gpp2=3g2&application/x-7z-compressed=7z';
5 |
6 | const mimeToExtensions = new Map(
7 | mimeTypeList.split('&').map((item) => {
8 | const [mime = '', exts = ''] = item.split('=');
9 | return [mime, exts.split(',')];
10 | }),
11 | );
12 |
13 | const extToMime = new Map();
14 | for (let [mime, exts] of mimeToExtensions) {
15 | for (let ext of exts) {
16 | extToMime.set(ext, mime);
17 | }
18 | }
19 |
20 | export function getMimeTypeFromExt(ext: string) {
21 | return extToMime.get(ext.toLowerCase());
22 | }
23 |
24 | export function getExtForMimeType(mimeType: string) {
25 | const extensions = mimeToExtensions.get(mimeType.toLowerCase());
26 | return extensions ? extensions[0] : undefined;
27 | }
28 |
--------------------------------------------------------------------------------
/packages/core/src/core/support/parseUrl.ts:
--------------------------------------------------------------------------------
1 | // This is required by `new URL()` if the url is not fully-qualified (e.g. just
2 | // a pathname). In most cases it doesn't matter what value we use here.
3 | // See: https://nodejs.org/docs/latest-v12.x/api/url.html#url_url
4 | const URL_BASE = 'http://0.0.0.0';
5 |
6 | export function parseUrl(url: string) {
7 | return new URL(url, URL_BASE);
8 | }
9 |
--------------------------------------------------------------------------------
/packages/core/src/core/support/tryAsync.ts:
--------------------------------------------------------------------------------
1 | export async function tryAsync(fn: () => Promise): Promise {
2 | try {
3 | return await fn();
4 | } catch (e) {
5 | return null;
6 | }
7 | }
8 |
--------------------------------------------------------------------------------
/packages/core/src/fs/__tests__/resolveFilePath.test.ts:
--------------------------------------------------------------------------------
1 | import { resolveFilePath } from '../resolveFilePath';
2 |
3 | describe('resolveFilePath', () => {
4 | it('should resolve allowed paths relative to root', () => {
5 | const options = {
6 | root: '/foo',
7 | allowStaticFrom: ['public', 'other'],
8 | };
9 | expect(
10 | // should resolve since public is allowed
11 | resolveFilePath('public/bar.html', options),
12 | ).toEqual(['/foo/public/bar.html', 'public']);
13 | expect(
14 | // should not resolve
15 | resolveFilePath('foo/bar.html', options),
16 | ).toEqual(null);
17 | expect(resolveFilePath('index.html', options)).toBe(null);
18 | expect(
19 | // other is also allowed
20 | resolveFilePath('other/thing', options),
21 | ).toEqual(['/foo/other/thing', 'other']);
22 | expect(
23 | // should not be allowed to traverse outside of root
24 | resolveFilePath('public/../bar.html', options),
25 | ).toEqual(null);
26 | });
27 | });
28 |
--------------------------------------------------------------------------------
/packages/core/src/fs/caching.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * Adapted from
3 | * https://github.com/http-party/http-server/blob/b0cb863/lib/core/index.js
4 | * which is licensed under the MIT license.
5 | */
6 | import type { Headers } from '../web-io';
7 |
8 | import type { FileStats } from './fileServing';
9 |
10 | export function shouldSend304(
11 | headers: Headers,
12 | serverLastModified: Date,
13 | serverEtag: string,
14 | ) {
15 | const clientModifiedSince = headers.get('if-modified-since');
16 | const clientEtag = headers.get('if-none-match');
17 | let clientModifiedDate;
18 |
19 | if (!clientModifiedSince && !clientEtag) {
20 | // Client did not provide any conditional caching headers
21 | return false;
22 | }
23 |
24 | if (clientModifiedSince) {
25 | // Catch "illegal access" dates that will crash v8
26 | try {
27 | clientModifiedDate = Date.parse(clientModifiedSince);
28 | } catch (err) {
29 | return false;
30 | }
31 |
32 | // TODO: Better checking here
33 | if (new Date(clientModifiedDate).toString() === 'Invalid Date') {
34 | return false;
35 | }
36 | // If the client's copy is older than the server's, don't return 304
37 | if (clientModifiedDate < serverLastModified.valueOf()) {
38 | return false;
39 | }
40 | }
41 |
42 | if (clientEtag) {
43 | // TODO: Should we trim the `W/` before comparing?
44 | if (clientEtag !== serverEtag) {
45 | return false;
46 | }
47 | }
48 |
49 | return true;
50 | }
51 |
52 | export function generateEtag(stats: FileStats) {
53 | const datePart = stats.mtimeMs.toString(16).padStart(11, '0');
54 | const sizePart = stats.size.toString(16);
55 | return `W/"${sizePart}${datePart}"`;
56 | }
57 |
--------------------------------------------------------------------------------
/packages/core/src/fs/fileServing.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable dot-notation */
2 | import { extname } from 'path';
3 |
4 | import type { StaticFileOptions } from '../core/StaticFile';
5 | import type { Headers } from '../web-io';
6 | import { getMimeTypeFromExt } from '../core/support/mimeTypes';
7 |
8 | import { generateEtag, shouldSend304 } from './caching';
9 |
10 | type Result =
11 | | {
12 | status: 304;
13 | }
14 | | {
15 | status: undefined;
16 | headers: Record;
17 | };
18 |
19 | export type FileStats = {
20 | isFile: () => boolean;
21 | size: number;
22 | mtimeMs: number;
23 | };
24 |
25 | const defaultOptions: StaticFileOptions = {
26 | cachingHeaders: true,
27 | };
28 |
29 | export async function computeHeaders(
30 | requestHeaders: Headers,
31 | fullFilePath: string,
32 | fileStats: FileStats,
33 | options: StaticFileOptions = defaultOptions,
34 | ): Promise {
35 | const { cachingHeaders = true, maxAge } = options;
36 |
37 | if (!fileStats.isFile()) {
38 | return null;
39 | }
40 |
41 | const lastModified = new Date(fileStats.mtimeMs);
42 | const etag = generateEtag(fileStats);
43 |
44 | if (cachingHeaders) {
45 | const send304 = shouldSend304(requestHeaders, lastModified, etag);
46 | if (send304) {
47 | return { status: 304 };
48 | }
49 | }
50 |
51 | const ext = extname(fullFilePath).slice(1);
52 | const headers: Record = {
53 | 'Content-Length': String(fileStats.size),
54 | 'Content-Type': getMimeTypeFromExt(ext) ?? 'application/octet-stream',
55 | };
56 | if (cachingHeaders) {
57 | headers['ETag'] = etag;
58 | headers['Last-Modified'] = lastModified.toGMTString();
59 | }
60 | if (maxAge !== undefined) {
61 | headers['Cache-Control'] = `max-age=${maxAge}`;
62 | }
63 |
64 | return {
65 | // In the case that we're not sending a 304, we don't want to specify the
66 | // status, it should use the default from the call site.
67 | status: undefined,
68 | headers,
69 | };
70 | }
71 |
--------------------------------------------------------------------------------
/packages/core/src/fs/index.ts:
--------------------------------------------------------------------------------
1 | export * from './caching';
2 | export * from './fileServing';
3 | export * from './resolveFilePath';
4 |
--------------------------------------------------------------------------------
/packages/core/src/fs/resolveFilePath.ts:
--------------------------------------------------------------------------------
1 | import { join, resolve } from 'path';
2 |
3 | import type { FileServingOptions } from '../types';
4 |
5 | export function resolveFilePath(filePath: string, options: FileServingOptions) {
6 | const { root = process.cwd(), allowStaticFrom = [] } = options;
7 | const projectRoot = resolve(root);
8 | const fullFilePath = join(projectRoot, filePath);
9 | for (let allowedPath of allowStaticFrom) {
10 | const fullAllowedPath = join(root, allowedPath);
11 | if (fullFilePath.startsWith(fullAllowedPath + '/')) {
12 | return [fullFilePath, allowedPath] as const;
13 | }
14 | }
15 | return null;
16 | }
17 |
--------------------------------------------------------------------------------
/packages/core/src/test/node-fetch.d.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/array-type, @typescript-eslint/consistent-type-imports, import/order */
2 | // Copied from https://unpkg.com/browse/@types/node-fetch@2.6.4/index.d.ts
3 | // The only modifications are:
4 | // - Add `static json()` to `class Response`
5 | // - Remove FormData
6 | // - Allow null for `body` in both Request and Response
7 | declare module 'node-fetch' {
8 | import { RequestOptions } from 'http';
9 | import { URLSearchParams, URL } from 'url';
10 | import { AbortSignal } from './externals';
11 |
12 | export class Request extends Body {
13 | constructor(input: RequestInfo, init?: RequestInit);
14 | clone(): Request;
15 | context: RequestContext;
16 | headers: Headers;
17 | method: string;
18 | redirect: RequestRedirect;
19 | referrer: string;
20 | url: string;
21 |
22 | // node-fetch extensions to the whatwg/fetch spec
23 | agent?:
24 | | RequestOptions['agent']
25 | | ((parsedUrl: URL) => RequestOptions['agent']);
26 | compress: boolean;
27 | counter: number;
28 | follow: number;
29 | hostname: string;
30 | port?: number | undefined;
31 | protocol: string;
32 | size: number;
33 | timeout: number;
34 | }
35 |
36 | export interface RequestInit {
37 | // whatwg/fetch standard options
38 | body?: BodyInit | null | undefined;
39 | headers?: HeadersInit | undefined;
40 | method?: string | undefined;
41 | redirect?: RequestRedirect | undefined;
42 | signal?: AbortSignal | null | undefined;
43 |
44 | // node-fetch extensions
45 | agent?:
46 | | RequestOptions['agent']
47 | | ((parsedUrl: URL) => RequestOptions['agent']); // =null http.Agent instance, allows custom proxy, certificate etc.
48 | compress?: boolean | undefined; // =true support gzip/deflate content encoding. false to disable
49 | follow?: number | undefined; // =20 maximum redirect count. 0 to not follow redirect
50 | size?: number | undefined; // =0 maximum response body size in bytes. 0 to disable
51 | timeout?: number | undefined; // =0 req/res timeout in ms, it resets on redirect. 0 to disable (OS limit applies)
52 |
53 | // node-fetch does not support mode, cache or credentials options
54 | }
55 |
56 | export type RequestContext =
57 | | 'audio'
58 | | 'beacon'
59 | | 'cspreport'
60 | | 'download'
61 | | 'embed'
62 | | 'eventsource'
63 | | 'favicon'
64 | | 'fetch'
65 | | 'font'
66 | | 'form'
67 | | 'frame'
68 | | 'hyperlink'
69 | | 'iframe'
70 | | 'image'
71 | | 'imageset'
72 | | 'import'
73 | | 'internal'
74 | | 'location'
75 | | 'manifest'
76 | | 'object'
77 | | 'ping'
78 | | 'plugin'
79 | | 'prefetch'
80 | | 'script'
81 | | 'serviceworker'
82 | | 'sharedworker'
83 | | 'style'
84 | | 'subresource'
85 | | 'track'
86 | | 'video'
87 | | 'worker'
88 | | 'xmlhttprequest'
89 | | 'xslt';
90 | export type RequestMode = 'cors' | 'no-cors' | 'same-origin';
91 | export type RequestRedirect = 'error' | 'follow' | 'manual';
92 | export type RequestCredentials = 'omit' | 'include' | 'same-origin';
93 |
94 | export type RequestCache =
95 | | 'default'
96 | | 'force-cache'
97 | | 'no-cache'
98 | | 'no-store'
99 | | 'only-if-cached'
100 | | 'reload';
101 |
102 | export class Headers implements Iterable<[string, string]> {
103 | constructor(init?: HeadersInit);
104 | forEach(callback: (value: string, name: string) => void): void;
105 | append(name: string, value: string): void;
106 | delete(name: string): void;
107 | get(name: string): string | null;
108 | has(name: string): boolean;
109 | raw(): { [k: string]: string[] };
110 | set(name: string, value: string): void;
111 |
112 | // Iterable methods
113 | entries(): IterableIterator<[string, string]>;
114 | keys(): IterableIterator;
115 | values(): IterableIterator;
116 | [Symbol.iterator](): Iterator<[string, string]>;
117 | }
118 |
119 | type BlobPart = ArrayBuffer | ArrayBufferView | Blob | string;
120 |
121 | interface BlobOptions {
122 | type?: string | undefined;
123 | endings?: 'transparent' | 'native' | undefined;
124 | }
125 |
126 | export class Blob {
127 | constructor(blobParts?: BlobPart[], options?: BlobOptions);
128 | readonly type: string;
129 | readonly size: number;
130 | slice(start?: number, end?: number): Blob;
131 | text(): Promise;
132 | }
133 |
134 | export class Body {
135 | constructor(
136 | body?: any,
137 | opts?: { size?: number | undefined; timeout?: number | undefined },
138 | );
139 | arrayBuffer(): Promise;
140 | blob(): Promise;
141 | body: NodeJS.ReadableStream;
142 | bodyUsed: boolean;
143 | buffer(): Promise;
144 | json(): Promise;
145 | size: number;
146 | text(): Promise;
147 | textConverted(): Promise;
148 | timeout: number;
149 | }
150 |
151 | interface SystemError extends Error {
152 | code?: string | undefined;
153 | }
154 |
155 | export class FetchError extends Error {
156 | name: 'FetchError';
157 | constructor(message: string, type: string, systemError?: SystemError);
158 | type: string;
159 | code?: string | undefined;
160 | errno?: string | undefined;
161 | }
162 |
163 | export class Response extends Body {
164 | constructor(body?: BodyInit | null, init?: ResponseInit);
165 | static error(): Response;
166 | static redirect(url: string, status: number): Response;
167 | static json(body: unknown, init?: ResponseInit): Response;
168 | clone(): Response;
169 | headers: Headers;
170 | ok: boolean;
171 | redirected: boolean;
172 | status: number;
173 | statusText: string;
174 | type: ResponseType;
175 | url: string;
176 | }
177 |
178 | export type ResponseType =
179 | | 'basic'
180 | | 'cors'
181 | | 'default'
182 | | 'error'
183 | | 'opaque'
184 | | 'opaqueredirect';
185 |
186 | export interface ResponseInit {
187 | headers?: HeadersInit | undefined;
188 | size?: number | undefined;
189 | status?: number | undefined;
190 | statusText?: string | undefined;
191 | timeout?: number | undefined;
192 | url?: string | undefined;
193 | }
194 |
195 | interface URLLike {
196 | href: string;
197 | }
198 |
199 | export type HeadersInit = Headers | string[][] | { [key: string]: string };
200 | // HeaderInit is exported to support backwards compatibility. See PR #34382
201 | export type HeaderInit = HeadersInit;
202 | export type BodyInit =
203 | | ArrayBuffer
204 | | ArrayBufferView
205 | | NodeJS.ReadableStream
206 | | string
207 | | URLSearchParams;
208 | export type RequestInfo = string | URLLike | Request;
209 |
210 | declare function fetch(
211 | url: RequestInfo,
212 | init?: RequestInit,
213 | ): Promise;
214 |
215 | declare namespace fetch {
216 | function isRedirect(code: number): boolean;
217 | }
218 |
219 | export default fetch;
220 | }
221 |
--------------------------------------------------------------------------------
/packages/core/src/test/setup.ts:
--------------------------------------------------------------------------------
1 | import { Response, Headers, type ResponseInit } from 'node-fetch';
2 |
3 | // Polyfill for static methods which are in the standard but not supported by node-fetch
4 | Object.assign(Response, {
5 | json: (body: unknown, init?: ResponseInit) => {
6 | const headers = new Headers(init?.headers);
7 | headers.set('Content-Type', 'application/json');
8 | return new Response(JSON.stringify(body), { ...init, headers });
9 | },
10 | redirect: (url: string, status = 302) => {
11 | return new Response('', {
12 | status,
13 | headers: { Location: url },
14 | });
15 | },
16 | });
17 |
--------------------------------------------------------------------------------
/packages/core/src/types/global.d.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable @typescript-eslint/no-explicit-any */
2 | import type { JSONValue } from './json';
3 |
4 | type Reviver = (this: any, key: string, value: any) => any;
5 | type Replacer = (this: any, key: string, value: any) => any;
6 |
7 | declare global {
8 | interface JSON {
9 | parse(text: string, reviver?: Reviver): JSONValue;
10 | stringify(
11 | value: T,
12 | replacer?: Replacer | Array | null,
13 | space?: string | number,
14 | ): undefined extends T
15 | ? T extends undefined
16 | ? undefined
17 | : string | undefined
18 | : string;
19 | }
20 |
21 | interface ObjectConstructor {
22 | keys(
23 | o: T,
24 | ): T extends Record
25 | ? Array
26 | : Array;
27 | }
28 |
29 | interface Date {
30 | toGMTString(): string;
31 | }
32 | }
33 |
34 | export {};
35 |
--------------------------------------------------------------------------------
/packages/core/src/types/http.ts:
--------------------------------------------------------------------------------
1 | import type { Headers, Response } from '../web-io';
2 | import type { StaticFile, StaticFileOptions } from '../core/StaticFile';
3 | import type { CustomRequest } from '../core/CustomRequest';
4 |
5 | export type RequestOptions = {
6 | /**
7 | * The max number of bytes that will be buffered into memory when parsing a
8 | * request body into a format such as JSON.
9 | */
10 | bodyParserMaxBufferSize?: number;
11 | };
12 |
13 | export type ResponseOptions = {
14 | /**
15 | * This error handler, if specified, will be used to generate a response when
16 | * an exception was raised during the execution of any of the handlers.
17 | */
18 | errorHandler?: (error: Error) => MaybePromise;
19 | };
20 |
21 | export type FileServingOptions = {
22 | /**
23 | * The root from which file paths will be resolved when serving files.
24 | * Defaults to current working directory (or `/` in serverless environments).
25 | */
26 | root?: string;
27 | /**
28 | * An array of paths (relative to `root`) from which static files are allowed
29 | * to be served when invoking `Response.file(filePath)`. If `allowStaticFrom`
30 | * is not specified, or if the fully-resolved filePath does not exist within
31 | * an allowed path, all files will be treated as non-existent, resulting in
32 | * 404.
33 | */
34 | allowStaticFrom?: Array;
35 | /**
36 | * Overrides the default serveFile. Useful within tests or serverless
37 | * environments.
38 | *
39 | * This is invoked when a request handler returns `Response.file(filePath)`.
40 | *
41 | * If the `root` option is specified, `filePath` will be resolved relative to
42 | * that, otherwise it will be resolved relative to process.cwd (or `/` in
43 | * serverless environments). The fully resolved path will be checked against
44 | * `allowStaticFrom` and if that check does not pass (or allowStaticFrom is
45 | * not specified) then `serveFile` will never be invoked and a 404 response
46 | * will be sent.
47 | *
48 | * Return null to indicate no valid file exists at the given path, resulting
49 | * in 404 response.
50 | *
51 | * Note: A comprehensive implementation of serveFile should specify response
52 | * headers such as Content-Type, Last-Modified, ETag and Cache-Control (see
53 | * packages/core/src/fs/fileServing.ts). It should also potentially send a
54 | * response status of 304 based on request headers like `If-Modified-Since`
55 | * and/or `If-None-Match` (see packages/core/src/fs/caching.ts).
56 | */
57 | serveFile?: (params: {
58 | /** The original path specified in Response.file(...) */
59 | filePath: string;
60 | /** The fully resolved path starting with `/` */
61 | fullFilePath: string;
62 | /** Specified at call site, e.g. Response.file(filePath, { status }) */
63 | status: number;
64 | /** Specified at call site, e.g. Response.file(filePath, { statusText }) */
65 | statusText: string;
66 | /** Specified at call site, e.g. Response.file(filePath, { headers }) */
67 | headers: Headers;
68 | /** File serving options such as `maxAge`, specified at call site, e.g. Response.file(filePath, { maxAge }) */
69 | options: StaticFileOptions;
70 | }) => Promise;
71 | };
72 |
73 | export type MaybePromise = T | Promise;
74 |
75 | export type MaybeIntersect = U extends undefined ? T : T & U;
76 |
77 | type JsonPayload = Record | Array;
78 |
79 | type ExtractParams = string extends T
80 | ? never
81 | : T extends `${infer _Start}:${infer Param}/${infer Rest}`
82 | ? Param | ExtractParams
83 | : T extends `${infer _Start}:${infer Param}`
84 | ? Param
85 | : never;
86 |
87 | // List of known methods for auto-complete
88 | export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS';
89 |
90 | // Methods that are not allowed to have a request body
91 | export type MethodNoBody = Exclude;
92 |
93 | export type Handler = (
94 | request: MaybeIntersect>, RequestContext>,
95 | ) => MaybePromise<
96 | Response | StaticFile | JsonPayload | null | undefined | void
97 | >;
98 |
99 | export type Route = [
100 | string,
101 | string,
102 | Handler,
103 | ];
104 |
--------------------------------------------------------------------------------
/packages/core/src/types/index.ts:
--------------------------------------------------------------------------------
1 | export * from './http';
2 | export * from './json';
3 | export * from './utilities';
4 |
--------------------------------------------------------------------------------
/packages/core/src/types/json.ts:
--------------------------------------------------------------------------------
1 | export type JSONValue =
2 | | null
3 | | boolean
4 | | number
5 | | string
6 | | Array
7 | | { [key: string]: JSONValue };
8 |
9 | export type JSONObject = { [key: string]: JSONValue };
10 |
--------------------------------------------------------------------------------
/packages/core/src/types/utilities.ts:
--------------------------------------------------------------------------------
1 | // A helpful utility type to expand an intersection of two or more object.
2 | // Source: https://stackoverflow.com/a/57683652
3 | export type Expand = T extends infer O ? { [K in keyof O]: O[K] } : never;
4 |
5 | /**
6 | * A way to specify a union of string literals (for autocomplete) but also allow
7 | * any string.
8 | * See: https://github.com/Microsoft/TypeScript/issues/29729
9 | * Similar to this implementation:
10 | * https://github.com/sindresorhus/type-fest/blob/e3234d7/source/literal-union.d.ts
11 | */
12 | export type LooseUnion =
13 | | T
14 | // eslint-disable-next-line @typescript-eslint/ban-types
15 | | (string & {});
16 |
--------------------------------------------------------------------------------
/packages/core/src/web-io/index.ts:
--------------------------------------------------------------------------------
1 | export {
2 | Request,
3 | type RequestInit,
4 | Response,
5 | type ResponseInit,
6 | Headers,
7 | type HeadersInit,
8 | type BodyInit,
9 | } from 'node-fetch';
10 |
--------------------------------------------------------------------------------
/packages/core/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "../../tsconfig.json",
3 | "compilerOptions": {
4 | "types": ["vitest/globals"]
5 | },
6 | "include": ["src"]
7 | }
8 |
--------------------------------------------------------------------------------
/packages/core/vitest.config.ts:
--------------------------------------------------------------------------------
1 | import { defineConfig } from 'vitest/config';
2 |
3 | export default defineConfig({
4 | test: {
5 | globals: true,
6 | setupFiles: ['src/test/setup.ts'],
7 | },
8 | resolve: {
9 | preserveSymlinks: true,
10 | },
11 | });
12 |
--------------------------------------------------------------------------------
/packages/express/index.d.ts:
--------------------------------------------------------------------------------
1 | export * from '../node/src/packages/express';
2 |
--------------------------------------------------------------------------------
/packages/express/index.js:
--------------------------------------------------------------------------------
1 | module.exports = require('../node/build/express/index.js');
2 |
--------------------------------------------------------------------------------
/packages/express/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "@nbit/express",
3 | "version": "0.13.4",
4 | "files": [
5 | "index.js",
6 | "index.d.ts"
7 | ],
8 | "main": "index.js",
9 | "types": "index.d.ts",
10 | "scripts": {
11 | "version": "yarn version",
12 | "clean": "rm -rf .turbo"
13 | },
14 | "dependencies": {},
15 | "devDependencies": {},
16 | "license": "ISC"
17 | }
18 |
--------------------------------------------------------------------------------
/packages/node/.eslintignore:
--------------------------------------------------------------------------------
1 | build/
2 |
--------------------------------------------------------------------------------
/packages/node/index.d.ts:
--------------------------------------------------------------------------------
1 | export * from './src';
2 |
--------------------------------------------------------------------------------
/packages/node/index.js:
--------------------------------------------------------------------------------
1 | module.exports = require('./build/node/index.js');
2 |
--------------------------------------------------------------------------------
/packages/node/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "@nbit/node",
3 | "version": "0.13.4",
4 | "files": [
5 | "index.js",
6 | "index.d.ts"
7 | ],
8 | "main": "index.js",
9 | "types": "index.d.ts",
10 | "scripts": {
11 | "lint": "eslint --max-warnings 0 \"src/**/*.ts\"",
12 | "typecheck": "tsc --noEmit",
13 | "format": "prettier --write src",
14 | "format:check": "prettier --check src",
15 | "unit": "vitest run",
16 | "test": "yarn lint && yarn typecheck && yarn format:check && yarn unit",
17 | "clean": "rm -rf .turbo build coverage",
18 | "copy-files:express": "cp ../../README.md build/express/ && lean-package -i ../express/package.json > build/express/package.json",
19 | "copy-files:node": "cp ../../README.md build/node/ && lean-package -n @nbit/node > build/node/package.json",
20 | "copy-files": "yarn copy-files:node && yarn copy-files:express",
21 | "build": "rm -rf build && tsc -p tsconfig.build.json && rollup -c && rm -rf build/dts && yarn copy-files && prettier --write build",
22 | "version": "yarn version"
23 | },
24 | "dependencies": {},
25 | "devDependencies": {
26 | "@rollup/plugin-replace": "^4.0.0",
27 | "@rollup/plugin-typescript": "^8.3.3",
28 | "@types/express": "^4.17.13",
29 | "@types/node": "^16.18.40",
30 | "eslint": "^8.19.0",
31 | "eslint-config-xt": "^1.7.0",
32 | "lean-package": "^1.4.0",
33 | "prettier": "^2.7.1",
34 | "rollup": "^2.76.0",
35 | "rollup-plugin-cleanup": "^3.2.1",
36 | "rollup-plugin-dts": "^4.2.2",
37 | "ts-node-dev": "^2.0.0",
38 | "typescript": "^4.7.4",
39 | "vitest": "^0.34.1"
40 | },
41 | "engines": {
42 | "node": "^14.18.0 || ^16.10.0 || >=18.0.0"
43 | },
44 | "eslintConfig": {
45 | "extends": "xt",
46 | "rules": {
47 | "@typescript-eslint/consistent-type-imports": "warn"
48 | }
49 | },
50 | "prettier": {
51 | "singleQuote": true,
52 | "trailingComma": "all",
53 | "arrowParens": "always"
54 | },
55 | "license": "ISC"
56 | }
57 |
--------------------------------------------------------------------------------
/packages/node/rollup.config.js:
--------------------------------------------------------------------------------
1 | import typescript from '@rollup/plugin-typescript';
2 | import dts from 'rollup-plugin-dts';
3 | import cleanup from 'rollup-plugin-cleanup';
4 | import replace from '@rollup/plugin-replace';
5 |
6 | const external = [
7 | 'fs',
8 | 'fs/promises',
9 | 'http',
10 | 'path',
11 | 'stream',
12 | 'stream/web',
13 | 'util',
14 | ];
15 |
16 | export default [
17 | {
18 | input: 'src/packages/node/index.ts',
19 | output: {
20 | dir: 'build/node',
21 | format: 'cjs',
22 | strict: false,
23 | esModule: false,
24 | },
25 | external,
26 | plugins: [
27 | typescript({
28 | module: 'esnext',
29 | include: ['../**/*.ts'],
30 | }),
31 | replace({
32 | preventAssignment: true,
33 | delimiters: ['', ''],
34 | values: {
35 | '(..._)': '()',
36 | },
37 | }),
38 | cleanup({
39 | extensions: ['js', 'ts'],
40 | }),
41 | ],
42 | },
43 | {
44 | input: 'build/dts/packages/node/index.d.ts',
45 | output: {
46 | file: 'build/node/index.d.ts',
47 | format: 'es',
48 | },
49 | external,
50 | plugins: [dts()],
51 | },
52 | {
53 | input: 'src/packages/express/index.ts',
54 | output: {
55 | dir: 'build/express',
56 | format: 'cjs',
57 | strict: false,
58 | esModule: false,
59 | },
60 | external,
61 | plugins: [
62 | typescript({
63 | module: 'esnext',
64 | include: ['../**/*.ts'],
65 | }),
66 | cleanup({
67 | extensions: ['js', 'ts'],
68 | }),
69 | ],
70 | },
71 | {
72 | input: 'build/dts/packages/express/index.d.ts',
73 | output: {
74 | file: 'build/express/index.d.ts',
75 | format: 'es',
76 | },
77 | external,
78 | plugins: [dts()],
79 | },
80 | ];
81 |
--------------------------------------------------------------------------------
/packages/node/src/__tests__/express.test.ts:
--------------------------------------------------------------------------------
1 | import { Readable } from 'stream';
2 |
3 | import { createApplication } from '../express';
4 | import Response from '../core/CustomResponse';
5 |
6 | import { createMockExpress } from './helpers/createMockExpress';
7 |
8 | const { defineRoutes, attachRoutes } = createApplication({
9 | allowStaticFrom: ['public'],
10 | getContext: (request) => ({
11 | auth: () => {
12 | return request.headers.get('authentication') ?? '';
13 | },
14 | }),
15 | });
16 |
17 | const routes = defineRoutes((app) => [
18 | app.get('/', () => {
19 | return { a: 1 };
20 | }),
21 | app.get('/null', () => {
22 | return new Response(null, { status: 400 });
23 | }),
24 | app.get('/buffer', () => {
25 | return new Response(Buffer.from('foo'), {
26 | status: 418,
27 | statusText: 'Yo',
28 | headers: { foo: 'x' },
29 | });
30 | }),
31 | app.get('/file', () => {
32 | return Response.file('public/foo.txt');
33 | }),
34 | app.get('/stream', () => {
35 | const data = 'Hello';
36 | return new Response(Readable.from(data, { objectMode: false }));
37 | }),
38 | app.get('/error', () => {
39 | throw new Error('Waat');
40 | }),
41 | app.get('/error2', () => {
42 | throw new Error('Rethrow');
43 | }),
44 | ]);
45 |
46 | describe('express', () => {
47 | const expressHandler = attachRoutes(routes);
48 |
49 | it('should handle a json response body', async () => {
50 | const [req, res, next, promise] = createMockExpress('/');
51 | expressHandler(req, res, next);
52 | await promise;
53 | expect(next).toHaveBeenCalledTimes(0);
54 | expect(res.writeHead).toHaveBeenCalledTimes(1);
55 | expect(res.writeHead).toHaveBeenCalledWith(200, '', {
56 | 'Content-Type': 'application/json;charset=UTF-8',
57 | });
58 | expect(res.write).toHaveBeenCalledTimes(1);
59 | expect(res.write).toHaveBeenCalledWith('{"a":1}');
60 | expect(res.end).toHaveBeenCalledTimes(1);
61 | });
62 |
63 | it('should handle a null response body', async () => {
64 | const [req, res, next, promise] = createMockExpress('/null');
65 | expressHandler(req, res, next);
66 | await promise;
67 | expect(next).toHaveBeenCalledTimes(0);
68 | expect(res.writeHead).toHaveBeenCalledTimes(1);
69 | expect(res.writeHead).toHaveBeenCalledWith(400, '', {});
70 | expect(res.write).toHaveBeenCalledTimes(0);
71 | expect(res.end).toHaveBeenCalledTimes(1);
72 | });
73 |
74 | it('should handle a buffer response body', async () => {
75 | const [req, res, next, promise] = createMockExpress('/buffer');
76 | expressHandler(req, res, next);
77 | await promise;
78 | expect(next).toHaveBeenCalledTimes(0);
79 | expect(res.writeHead).toHaveBeenCalledTimes(1);
80 | expect(res.writeHead).toHaveBeenCalledWith(418, 'Yo', { foo: 'x' });
81 | expect(res.write).toHaveBeenCalledTimes(1);
82 | expect(res.write).toHaveBeenCalledWith(Buffer.from('foo'));
83 | expect(res.end).toHaveBeenCalledTimes(1);
84 | });
85 |
86 | it('should forward an error to next', async () => {
87 | const [req, res, next, promise] = createMockExpress('/error');
88 | expressHandler(req, res, next);
89 | await promise;
90 | expect(next).toHaveBeenCalledTimes(1);
91 | expect(next).toHaveBeenCalledWith(new Error('Waat'));
92 | expect(res.writeHead).toHaveBeenCalledTimes(0);
93 | expect(res.write).toHaveBeenCalledTimes(0);
94 | expect(res.end).toHaveBeenCalledTimes(0);
95 | });
96 |
97 | it('should handle an error thrown by the framework', async () => {
98 | const [req, res, next, promise] = createMockExpress('/error2');
99 | expressHandler(req, res, next);
100 | await promise;
101 | expect(next).toHaveBeenCalledTimes(1);
102 | expect(next).toHaveBeenCalledWith(new Error('Rethrow'));
103 | expect(res.writeHead).toHaveBeenCalledTimes(1);
104 | expect(res.writeHead).toHaveBeenCalledWith(500);
105 | expect(res.write).toHaveBeenCalledTimes(0);
106 | expect(res.end).toHaveBeenCalledTimes(1);
107 | expect(res.end).toHaveBeenCalledWith('Error: Rethrow');
108 | });
109 |
110 | it('should call next() on no route', async () => {
111 | const [req, res, next, promise] = createMockExpress('/nothing');
112 | expressHandler(req, res, next);
113 | await promise;
114 | expect(next).toHaveBeenCalledTimes(1);
115 | expect(next).toHaveBeenCalledWith();
116 | expect(res.writeHead).toHaveBeenCalledTimes(0);
117 | expect(res.write).toHaveBeenCalledTimes(0);
118 | expect(res.end).toHaveBeenCalledTimes(0);
119 | });
120 |
121 | it('should use res.sendFile()', async () => {
122 | const [req, res, next, promise] = createMockExpress('/file');
123 | expressHandler(req, res, next);
124 | await promise;
125 | expect(next).toHaveBeenCalledTimes(0);
126 | expect(res.status).toHaveBeenCalledTimes(1);
127 | expect(res.status).toHaveBeenCalledWith(200);
128 | expect(res.writeHead).toHaveBeenCalledTimes(0);
129 | expect(res.write).toHaveBeenCalledTimes(0);
130 | expect(res.end).toHaveBeenCalledTimes(0);
131 | expect(res.sendFile).toHaveBeenCalledTimes(1);
132 | expect(res.sendFile).toHaveBeenCalledWith(
133 | 'foo.txt',
134 | {
135 | headers: {},
136 | lastModified: true,
137 | maxAge: undefined,
138 | root: 'public',
139 | },
140 | next,
141 | );
142 | });
143 |
144 | it('should handle a stream response body', async () => {
145 | const [req, res, next, promise] = createMockExpress('/stream');
146 | expressHandler(req, res, next);
147 | await promise;
148 | expect(next).toHaveBeenCalledTimes(0);
149 | expect(res.writeHead).toHaveBeenCalledTimes(1);
150 | expect(res.writeHead).toHaveBeenCalledWith(200, '', {});
151 | expect(res.write).toHaveBeenCalledTimes(1);
152 | expect(res.write).toHaveBeenCalledWith(Buffer.from('Hello'));
153 | expect(res.end).toHaveBeenCalledTimes(1);
154 | });
155 |
156 | describe('custom serveFile', () => {
157 | const { defineRoutes, attachRoutes } = createApplication({
158 | root: '/home/foo',
159 | allowStaticFrom: ['public'],
160 | serveFile: async (params) => {
161 | const { status, headers, filePath, ...other } = params;
162 | if (filePath.endsWith('/file2.txt')) {
163 | return null;
164 | }
165 | const headersObject = Object.fromEntries(headers.entries());
166 | return Response.json(
167 | { status, headers: headersObject, filePath, ...other },
168 | {
169 | status,
170 | headers: { ...headersObject, ETag: params.filePath },
171 | },
172 | );
173 | },
174 | });
175 |
176 | it('should invoke custom serveFile', async () => {
177 | const routes = defineRoutes((app) => [
178 | app.get('/file', async (_request) => {
179 | return Response.file('public/file.txt');
180 | }),
181 | ]);
182 | const expressHandler = attachRoutes(routes);
183 | const [req, res, next, promise] = createMockExpress('/file');
184 | expressHandler(req, res, next);
185 | await promise;
186 | expect(next).toHaveBeenCalledTimes(0);
187 | expect(res.writeHead).toHaveBeenCalledTimes(1);
188 | expect(res.writeHead).toHaveBeenCalledWith(200, '', {
189 | 'Content-Type': 'application/json;charset=UTF-8',
190 | ETag: 'public/file.txt',
191 | });
192 | expect(res.write).toHaveBeenCalledTimes(1);
193 | const data = Object(res.write).mock.calls[0][0];
194 | const parsed = JSON.parse(String(data));
195 | expect(parsed).toEqual({
196 | filePath: 'public/file.txt',
197 | fullFilePath: '/home/foo/public/file.txt',
198 | status: 200,
199 | statusText: '',
200 | headers: {},
201 | options: {},
202 | });
203 | expect(res.end).toHaveBeenCalledTimes(1);
204 | });
205 |
206 | it('should pass through init options', async () => {
207 | const routes = defineRoutes((app) => [
208 | app.get('/file', async (_request) => {
209 | return Response.file('public/file.txt', {
210 | status: 404,
211 | headers: { foo: '1' },
212 | maxAge: 10,
213 | cachingHeaders: true,
214 | });
215 | }),
216 | ]);
217 | const expressHandler = attachRoutes(routes);
218 | const [req, res, next, promise] = createMockExpress('/file');
219 | expressHandler(req, res, next);
220 | await promise;
221 | expect(next).toHaveBeenCalledTimes(0);
222 | expect(res.writeHead).toHaveBeenCalledTimes(1);
223 | expect(res.writeHead).toHaveBeenCalledWith(404, '', {
224 | 'Content-Type': 'application/json;charset=UTF-8',
225 | foo: '1',
226 | ETag: 'public/file.txt',
227 | });
228 | expect(res.write).toHaveBeenCalledTimes(1);
229 | const data = Object(res.write).mock.calls[0][0];
230 | const parsed = JSON.parse(String(data));
231 | expect(parsed).toEqual({
232 | filePath: 'public/file.txt',
233 | fullFilePath: '/home/foo/public/file.txt',
234 | status: 404,
235 | statusText: '',
236 | headers: { foo: '1' },
237 | options: { maxAge: 10, cachingHeaders: true },
238 | });
239 | expect(res.end).toHaveBeenCalledTimes(1);
240 | });
241 |
242 | it('should allow returning null', async () => {
243 | const routes = defineRoutes((app) => [
244 | app.get('/file2', async (_request) => {
245 | return Response.file('public/file2.txt');
246 | }),
247 | ]);
248 | const expressHandler = attachRoutes(routes);
249 | const [req, res, next, promise] = createMockExpress('/file2');
250 | expressHandler(req, res, next);
251 | await promise;
252 | expect(next).toHaveBeenCalledTimes(0);
253 | expect(res.writeHead).toHaveBeenCalledTimes(1);
254 | expect(res.writeHead).toHaveBeenCalledWith(404, '', {
255 | 'Content-Type': 'text/plain;charset=UTF-8',
256 | });
257 | expect(res.write).toHaveBeenCalledTimes(1);
258 | expect(res.write).toHaveBeenCalledWith('Not found');
259 | expect(res.end).toHaveBeenCalledTimes(1);
260 | });
261 | });
262 | });
263 |
--------------------------------------------------------------------------------
/packages/node/src/__tests__/helpers/createMockExpress.ts:
--------------------------------------------------------------------------------
1 | import { Readable } from 'stream';
2 | import EventEmitter from 'events';
3 |
4 | import type {
5 | Request as ExpressRequest,
6 | Response as ExpressResponse,
7 | NextFunction,
8 | } from 'express';
9 |
10 | type BodyInit =
11 | | Uint8Array // Includes Buffer which is a subclass of Uint8Array
12 | | Readable
13 | | string
14 | | null
15 | | undefined;
16 |
17 | type RequestInit = {
18 | method?: string;
19 | headers?: Record;
20 | body?: BodyInit;
21 | };
22 |
23 | export function createMockExpress(path: string, init?: RequestInit) {
24 | // This is used to emit an `end` event whenever the test request is "over",
25 | // meaning we're ready to start making assertions. This is communicated to the
26 | // caller via a promise. This does not necessarily indicate that the request
27 | // was handled or ended, it could mean that next() was called or something
28 | // threw.
29 | const emitter = new EventEmitter();
30 | const promise = new Promise((resolve) => {
31 | emitter.on('end', (error?: unknown) => resolve(error));
32 | });
33 | const headers: Record = init?.headers ?? {};
34 | const rawHeaders: Array = [];
35 | for (const [key, value] of Object.entries(headers)) {
36 | rawHeaders.push(key);
37 | rawHeaders.push(value);
38 | }
39 | const req: ExpressRequest = Object.assign(toStream(init?.body ?? ''), {
40 | method: init?.method ?? 'GET',
41 | url: path,
42 | headers,
43 | rawHeaders,
44 | }) as never;
45 |
46 | const res: ExpressResponse = Object.assign(new EventEmitter(), {
47 | status: vi.fn(),
48 | headersSent: false,
49 | writeHead: vi.fn().mockImplementation(() => {
50 | res.headersSent = true;
51 | }),
52 | write: vi.fn(),
53 | sendFile: vi.fn().mockImplementation(() => emitter.emit('end')),
54 | end: vi.fn().mockImplementation(() => emitter.emit('end')),
55 | }) as never;
56 |
57 | const next: NextFunction = vi.fn().mockImplementation((error?: unknown) => {
58 | setTimeout(() => {
59 | emitter.emit('end', error);
60 | });
61 | // This allows us to simulate if something throws. Realistically it would be
62 | // if some internal framework function throws, like `toNodeHeaders()` or
63 | // something with .pipe().
64 | if (Object(error).message === 'Rethrow') {
65 | throw error;
66 | }
67 | });
68 | return [req, res, next, promise] as const;
69 | }
70 |
71 | function toStream(body: Uint8Array | Readable | string): Readable {
72 | if (body instanceof Uint8Array || typeof body === 'string') {
73 | return Readable.from(body, { objectMode: false });
74 | }
75 | return body;
76 | }
77 |
--------------------------------------------------------------------------------
/packages/node/src/__tests__/helpers/createMockNode.ts:
--------------------------------------------------------------------------------
1 | import { Readable } from 'stream';
2 | import EventEmitter from 'events';
3 | import type { IncomingMessage, ServerResponse } from 'http';
4 |
5 | type BodyInit =
6 | | Uint8Array // Includes Buffer which is a subclass of Uint8Array
7 | | Readable
8 | | string
9 | | null
10 | | undefined;
11 |
12 | type RequestInit = {
13 | method?: string;
14 | headers?: Record;
15 | body?: BodyInit;
16 | };
17 |
18 | export function createMockNode(path: string, init?: RequestInit) {
19 | // This is used to emit an `end` event whenever the test request is "over",
20 | // meaning we're ready to start making assertions. This is communicated to the
21 | // caller via a promise. This does not necessarily indicate that the request
22 | // was handled or ended, it could mean that something threw.
23 | const emitter = new EventEmitter();
24 | const promise = new Promise((resolve) => {
25 | emitter.on('end', (error?: unknown) => resolve(error));
26 | });
27 | const headers: Record = init?.headers ?? {};
28 | const rawHeaders: Array = [];
29 | for (const [key, value] of Object.entries(headers)) {
30 | rawHeaders.push(key);
31 | rawHeaders.push(value);
32 | }
33 | const req: IncomingMessage = Object.assign(toStream(init?.body ?? ''), {
34 | method: init?.method ?? 'GET',
35 | url: path,
36 | headers,
37 | rawHeaders,
38 | }) as never;
39 |
40 | let hasThrown = false;
41 | const res: ServerResponse = Object.assign(new EventEmitter(), {
42 | status: vi.fn(),
43 | headersSent: false,
44 | writeHead: vi.fn().mockImplementation(() => {
45 | // This allows us to simulate if something right before/during writeHead
46 | // throws. Realistically it would be if some internal framework function
47 | // throws, like `toNodeHeaders()` or something with .pipe().
48 | // We will throw only on the first call to writeHead().
49 | // TODO: A less hacky way might be to mock toNodeHeaders and make it
50 | // throw, because in reality, writeHead should never throw.
51 | const toBeThrown = init?.headers?.throw;
52 | if (toBeThrown && !hasThrown) {
53 | hasThrown = true;
54 | setTimeout(() => {
55 | emitter.emit('end');
56 | });
57 | throw new Error(toBeThrown);
58 | }
59 | // eslint-disable-next-line @typescript-eslint/ban-ts-comment
60 | // @ts-ignore - Readonly property
61 | res.headersSent = true;
62 | }),
63 | write: vi.fn(),
64 | sendFile: vi.fn().mockImplementation(() => emitter.emit('end')),
65 | end: vi.fn().mockImplementation(() => emitter.emit('end')),
66 | }) as never;
67 | return [req, res, promise] as const;
68 | }
69 |
70 | function toStream(body: Uint8Array | Readable | string): Readable {
71 | if (body instanceof Uint8Array || typeof body === 'string') {
72 | return Readable.from(body, { objectMode: false });
73 | }
74 | return body;
75 | }
76 |
--------------------------------------------------------------------------------
/packages/node/src/__tests__/links.test.ts:
--------------------------------------------------------------------------------
1 | import { getPlatform } from '../core/support/getPlatform';
2 |
3 | it('should correctly import across symlinked boundaries', () => {
4 | const platform = getPlatform();
5 | expect(platform).toBe('node');
6 | });
7 |
--------------------------------------------------------------------------------
/packages/node/src/__tests__/node.test.ts:
--------------------------------------------------------------------------------
1 | import { Readable } from 'stream';
2 |
3 | import { createApplication } from '../node';
4 | import Response from '../core/CustomResponse';
5 |
6 | import { createMockNode } from './helpers/createMockNode';
7 |
8 | process.chdir('/project');
9 |
10 | const { defineRoutes, attachRoutes } = createApplication({
11 | root: '/project',
12 | allowStaticFrom: ['public'],
13 | getContext: (request) => ({
14 | auth: () => {
15 | return request.headers.get('authentication') ?? '';
16 | },
17 | }),
18 | });
19 |
20 | const routes = defineRoutes((app) => [
21 | app.get('/', () => {
22 | return { a: 1 };
23 | }),
24 | app.get('/null', () => {
25 | return new Response(null, { status: 400 });
26 | }),
27 | app.get('/buffer', () => {
28 | return new Response(Buffer.from('foo'), {
29 | status: 418,
30 | statusText: 'Yo',
31 | headers: { foo: 'x' },
32 | });
33 | }),
34 | app.get('/file', () => {
35 | return Response.file('public/foo.txt');
36 | }),
37 | app.get('/file2', () => {
38 | return Response.file('public/foo.txt', {
39 | maxAge: 0,
40 | });
41 | }),
42 | app.get('/stream', () => {
43 | const data = 'Hello';
44 | return new Response(Readable.from(data, { objectMode: false }));
45 | }),
46 | app.get('/error', () => {
47 | throw new Error('Waat');
48 | }),
49 | ]);
50 |
51 | describe('node', () => {
52 | const nodeHandler = attachRoutes(routes);
53 |
54 | it('should handle a json response body', async () => {
55 | const [req, res, promise] = createMockNode('/');
56 | nodeHandler(req, res);
57 | await promise;
58 | expect(res.writeHead).toHaveBeenCalledTimes(1);
59 | expect(res.writeHead).toHaveBeenCalledWith(200, '', {
60 | 'Content-Type': 'application/json;charset=UTF-8',
61 | });
62 | expect(res.write).toHaveBeenCalledTimes(1);
63 | expect(res.write).toHaveBeenCalledWith('{"a":1}');
64 | expect(res.end).toHaveBeenCalledTimes(1);
65 | });
66 |
67 | it('should handle a null response body', async () => {
68 | const [req, res, promise] = createMockNode('/null');
69 | nodeHandler(req, res);
70 | await promise;
71 | expect(res.writeHead).toHaveBeenCalledTimes(1);
72 | expect(res.writeHead).toHaveBeenCalledWith(400, '', {});
73 | expect(res.write).toHaveBeenCalledTimes(0);
74 | expect(res.end).toHaveBeenCalledTimes(1);
75 | });
76 |
77 | it('should handle a buffer response body', async () => {
78 | const [req, res, promise] = createMockNode('/buffer');
79 | nodeHandler(req, res);
80 | await promise;
81 | expect(res.writeHead).toHaveBeenCalledTimes(1);
82 | expect(res.writeHead).toHaveBeenCalledWith(418, 'Yo', { foo: 'x' });
83 | expect(res.write).toHaveBeenCalledTimes(1);
84 | expect(res.write).toHaveBeenCalledWith(Buffer.from('foo'));
85 | expect(res.end).toHaveBeenCalledTimes(1);
86 | });
87 |
88 | it('should handle error thrown', async () => {
89 | const [req, res, promise] = createMockNode('/error');
90 | nodeHandler(req, res);
91 | await promise;
92 | expect(res.writeHead).toHaveBeenCalledTimes(1);
93 | expect(res.writeHead).toHaveBeenCalledWith(500, '', {
94 | 'Content-Type': 'text/plain;charset=UTF-8',
95 | });
96 | expect(res.write).toHaveBeenCalledTimes(1);
97 | expect(res.write).toHaveBeenCalledWith('Error: Waat');
98 | expect(res.end).toHaveBeenCalledTimes(1);
99 | });
100 |
101 | it('should handle an error thrown by the framework', async () => {
102 | const [req, res, promise] = createMockNode('/', {
103 | headers: { throw: 'Foo' },
104 | });
105 | nodeHandler(req, res);
106 | await promise;
107 | expect(res.writeHead).toHaveBeenCalledTimes(2);
108 | expect(res.writeHead).toHaveBeenLastCalledWith(500);
109 | expect(res.write).toHaveBeenCalledTimes(0);
110 | expect(res.end).toHaveBeenCalledTimes(1);
111 | expect(res.end).toHaveBeenCalledWith('Error: Foo');
112 | });
113 |
114 | it('should handle no route', async () => {
115 | const [req, res, promise] = createMockNode('/nothing');
116 | nodeHandler(req, res);
117 | await promise;
118 | expect(res.writeHead).toHaveBeenCalledTimes(1);
119 | expect(res.writeHead).toHaveBeenCalledWith(404, '', {
120 | 'Content-Type': 'text/plain;charset=UTF-8',
121 | });
122 | expect(res.write).toHaveBeenCalledTimes(1);
123 | expect(res.write).toHaveBeenCalledWith('Not found');
124 | expect(res.end).toHaveBeenCalledTimes(1);
125 | });
126 |
127 | it('should send file', async () => {
128 | const [req, res, promise] = createMockNode('/file');
129 | nodeHandler(req, res);
130 | await promise;
131 | expect(res.writeHead).toHaveBeenCalledTimes(1);
132 | expect(res.writeHead).toHaveBeenCalledWith(200, '', {
133 | 'Content-Length': '12',
134 | 'Content-Type': 'text/plain',
135 | ETag: 'W/"c18a1eeaccf8"',
136 | 'Last-Modified': 'Tue, 22 Aug 2023 20:23:39 GMT',
137 | });
138 | expect(res.write).toHaveBeenCalledTimes(1);
139 | expect(res.write).toHaveBeenCalledWith(Buffer.from('Some content'));
140 | expect(res.end).toHaveBeenCalledTimes(1);
141 | });
142 |
143 | it('should honor caching options', async () => {
144 | const [req, res, promise] = createMockNode('/file2');
145 | nodeHandler(req, res);
146 | await promise;
147 | expect(res.writeHead).toHaveBeenCalledTimes(1);
148 | expect(res.writeHead).toHaveBeenCalledWith(200, '', {
149 | 'Content-Length': '12',
150 | 'Content-Type': 'text/plain',
151 | ETag: 'W/"c18a1eeaccf8"',
152 | 'Last-Modified': 'Tue, 22 Aug 2023 20:23:39 GMT',
153 | 'Cache-Control': 'max-age=0',
154 | });
155 | expect(res.write).toHaveBeenCalledTimes(1);
156 | expect(res.write).toHaveBeenCalledWith(Buffer.from('Some content'));
157 | expect(res.end).toHaveBeenCalledTimes(1);
158 | });
159 |
160 | it('should handle a stream response body', async () => {
161 | const [req, res, promise] = createMockNode('/stream');
162 | nodeHandler(req, res);
163 | await promise;
164 | expect(res.writeHead).toHaveBeenCalledTimes(1);
165 | expect(res.writeHead).toHaveBeenCalledWith(200, '', {});
166 | expect(res.write).toHaveBeenCalledTimes(1);
167 | expect(res.write).toHaveBeenCalledWith(Buffer.from('Hello'));
168 | expect(res.end).toHaveBeenCalledTimes(1);
169 | });
170 |
171 | describe('custom serveFile', () => {
172 | const { defineRoutes, attachRoutes } = createApplication({
173 | root: '/home/foo',
174 | allowStaticFrom: ['public'],
175 | serveFile: async (params) => {
176 | const { status, headers, filePath, ...other } = params;
177 | if (filePath.endsWith('/file2.txt')) {
178 | return null;
179 | }
180 | const headersObject = Object.fromEntries(headers.entries());
181 | return Response.json(
182 | { status, headers: headersObject, filePath, ...other },
183 | {
184 | status,
185 | headers: { ...headersObject, ETag: params.filePath },
186 | },
187 | );
188 | },
189 | });
190 |
191 | it('should invoke custom serveFile', async () => {
192 | const routes = defineRoutes((app) => [
193 | app.get('/file', async (_request) => {
194 | return Response.file('public/file.txt');
195 | }),
196 | ]);
197 | const nodeHandler = attachRoutes(routes);
198 | const [req, res, promise] = createMockNode('/file');
199 | nodeHandler(req, res);
200 | await promise;
201 | expect(res.writeHead).toHaveBeenCalledTimes(1);
202 | expect(res.writeHead).toHaveBeenCalledWith(200, '', {
203 | 'Content-Type': 'application/json;charset=UTF-8',
204 | ETag: 'public/file.txt',
205 | });
206 | expect(res.write).toHaveBeenCalledTimes(1);
207 | const data = Object(res.write).mock.calls[0][0];
208 | const parsed = JSON.parse(String(data));
209 | expect(parsed).toEqual({
210 | filePath: 'public/file.txt',
211 | fullFilePath: '/home/foo/public/file.txt',
212 | status: 200,
213 | statusText: '',
214 | headers: {},
215 | options: {},
216 | });
217 | expect(res.end).toHaveBeenCalledTimes(1);
218 | });
219 |
220 | it('should pass through init options', async () => {
221 | const routes = defineRoutes((app) => [
222 | app.get('/file', async (_request) => {
223 | return Response.file('public/file.txt', {
224 | status: 404,
225 | headers: { foo: '1' },
226 | maxAge: 10,
227 | cachingHeaders: true,
228 | });
229 | }),
230 | ]);
231 | const nodeHandler = attachRoutes(routes);
232 | const [req, res, promise] = createMockNode('/file');
233 | nodeHandler(req, res);
234 | await promise;
235 | expect(res.writeHead).toHaveBeenCalledTimes(1);
236 | expect(res.writeHead).toHaveBeenCalledWith(404, '', {
237 | 'Content-Type': 'application/json;charset=UTF-8',
238 | foo: '1',
239 | ETag: 'public/file.txt',
240 | });
241 | expect(res.write).toHaveBeenCalledTimes(1);
242 | const data = Object(res.write).mock.calls[0][0];
243 | const parsed = JSON.parse(String(data));
244 | expect(parsed).toEqual({
245 | filePath: 'public/file.txt',
246 | fullFilePath: '/home/foo/public/file.txt',
247 | status: 404,
248 | statusText: '',
249 | headers: { foo: '1' },
250 | options: { maxAge: 10, cachingHeaders: true },
251 | });
252 | expect(res.end).toHaveBeenCalledTimes(1);
253 | });
254 |
255 | it('should allow returning null', async () => {
256 | const routes = defineRoutes((app) => [
257 | app.get('/file2', async (_request) => {
258 | return Response.file('public/file2.txt');
259 | }),
260 | ]);
261 | const nodeHandler = attachRoutes(routes);
262 | const [req, res, promise] = createMockNode('/file2');
263 | nodeHandler(req, res);
264 | await promise;
265 | expect(res.writeHead).toHaveBeenCalledTimes(1);
266 | expect(res.writeHead).toHaveBeenCalledWith(404, '', {
267 | 'Content-Type': 'text/plain;charset=UTF-8',
268 | });
269 | expect(res.write).toHaveBeenCalledTimes(1);
270 | expect(res.write).toHaveBeenCalledWith('Not found');
271 | expect(res.end).toHaveBeenCalledTimes(1);
272 | });
273 | });
274 | });
275 |
--------------------------------------------------------------------------------
/packages/node/src/constants.ts:
--------------------------------------------------------------------------------
1 | export const PLATFORM = 'node';
2 |
--------------------------------------------------------------------------------
/packages/node/src/core:
--------------------------------------------------------------------------------
1 | ../../core/src/core
--------------------------------------------------------------------------------
/packages/node/src/express.ts:
--------------------------------------------------------------------------------
1 | import { relative } from 'path';
2 | import { Readable } from 'stream';
3 |
4 | import type {
5 | Request as ExpressRequest,
6 | Response as ExpressResponse,
7 | NextFunction,
8 | } from 'express';
9 |
10 | import { defineAdapter } from './core';
11 | import { StaticFile } from './core/StaticFile';
12 | import { createMeta } from './core/support/createMeta';
13 | import { defineErrors } from './core/support/defineErrors';
14 | import { Response, Headers } from './web-io';
15 | import { resolveFilePath } from './fs';
16 | import { pipeStreamAsync } from './support/pipeStreamAsync';
17 | import { toNodeHeaders } from './support/headers';
18 | import { fromNodeRequest } from './support/fromNodeRequest';
19 |
20 | type ExpressStaticFileOpts = {
21 | root: string;
22 | headers: Record>;
23 | lastModified: boolean;
24 | maxAge: number | undefined;
25 | };
26 |
27 | // This is roughly the params needed for Express's res.sendFile()
28 | type ExpressStaticFile = [
29 | status: number,
30 | path: string,
31 | options: ExpressStaticFileOpts,
32 | ];
33 |
34 | const Errors = defineErrors({
35 | // This is a placeholder for when no route matches so we can easily identify
36 | // it as a special case of error and hand control over to Express.
37 | NoRouteError: 'No Route',
38 | });
39 |
40 | export const createApplication = defineAdapter((applicationOptions) => {
41 | const [getExpressStaticFile, setExpressStaticFile] =
42 | createMeta();
43 | const [getError, setError] = createMeta();
44 |
45 | const fromStaticFile = async (
46 | requestHeaders: Headers,
47 | staticFile: StaticFile,
48 | ): Promise => {
49 | const { filePath, options, responseInit: init } = staticFile;
50 | const resolved = resolveFilePath(filePath, applicationOptions);
51 | if (!resolved) {
52 | return;
53 | }
54 | const [fullFilePath, allowedRoot] = resolved;
55 | const customServeFile = applicationOptions.serveFile;
56 | if (customServeFile) {
57 | const { status, statusText, headers } = new Response(null, init);
58 | const maybeResponse = await customServeFile({
59 | filePath,
60 | fullFilePath,
61 | status,
62 | statusText,
63 | headers,
64 | options,
65 | });
66 | return maybeResponse ?? undefined;
67 | }
68 |
69 | const { cachingHeaders = true, maxAge } = options;
70 | const response = new Response(filePath);
71 | setExpressStaticFile(response, [
72 | init.status ?? 200,
73 | // Pass the file path relative to allowedRoot. Express will not
74 | // serve the file if it does not exist within the allowed root.
75 | relative(allowedRoot, fullFilePath),
76 | {
77 | root: allowedRoot,
78 | headers: toNodeHeaders(new Headers(init.headers)),
79 | // Note: Express always sends the ETag header
80 | lastModified: cachingHeaders,
81 | maxAge: typeof maxAge === 'number' ? maxAge * 1000 : undefined,
82 | },
83 | ]);
84 | return response;
85 | };
86 |
87 | return {
88 | onError: (request, error) => {
89 | // We're creating a dummy response here and keeping a reference to the
90 | // error for use below.
91 | const response = new Response(String(error), { status: 500 });
92 | setError(response, error);
93 | return response;
94 | },
95 | toResponse: async (request, result) => {
96 | if (result instanceof StaticFile) {
97 | return await fromStaticFile(request.headers, result);
98 | }
99 | if (result === undefined) {
100 | // In the other implementations we return undefined here, causing the
101 | // calling function to create a 404 response. But in this case we're
102 | // throwing a special NoRouteError which will be sent to the onError
103 | // function above, which will use a separate trick to pass the error to
104 | // handleRequest below where we can call Express's next().
105 | throw new Errors.NoRouteError();
106 | }
107 | return result;
108 | },
109 | createNativeHandler: (getResponse) => {
110 | const handleRequest = async (
111 | expressRequest: ExpressRequest,
112 | expressResponse: ExpressResponse,
113 | next: NextFunction,
114 | ) => {
115 | const request = fromNodeRequest(expressRequest, applicationOptions);
116 | const response = await getResponse(request);
117 | const error = getError(response);
118 | if (error) {
119 | return error instanceof Errors.NoRouteError ? next() : next(error);
120 | }
121 | const staticFile = getExpressStaticFile(response);
122 | if (staticFile) {
123 | const [status, path, options] = staticFile;
124 | expressResponse.status(status);
125 | expressResponse.sendFile(path, options, next);
126 | return;
127 | }
128 | const { status, statusText, headers, bodyRaw: body } = response;
129 | if (body instanceof Readable) {
130 | await pipeStreamAsync(body, expressResponse, {
131 | beforeFirstWrite: () =>
132 | expressResponse.writeHead(
133 | status,
134 | statusText,
135 | toNodeHeaders(headers),
136 | ),
137 | });
138 | } else {
139 | expressResponse.writeHead(status, statusText, toNodeHeaders(headers));
140 | if (body != null) {
141 | expressResponse.write(body);
142 | }
143 | expressResponse.end();
144 | }
145 | };
146 | return (
147 | expressRequest: ExpressRequest,
148 | expressResponse: ExpressResponse,
149 | next: NextFunction,
150 | ) => {
151 | handleRequest(expressRequest, expressResponse, next).catch((e) => {
152 | const error = e instanceof Error ? e : new Error(String(e));
153 | // Normally we'd pass the error on to next() but in this case it seems
154 | // something went wrong with streaming so we'll end the request here.
155 | if (!expressResponse.headersSent) {
156 | expressResponse.writeHead(500);
157 | expressResponse.end(String(error));
158 | } else {
159 | expressResponse.end();
160 | }
161 | });
162 | };
163 | },
164 | };
165 | });
166 |
--------------------------------------------------------------------------------
/packages/node/src/fs:
--------------------------------------------------------------------------------
1 | ../../core/src/fs
--------------------------------------------------------------------------------
/packages/node/src/index.ts:
--------------------------------------------------------------------------------
1 | export * from './packages/node';
2 |
--------------------------------------------------------------------------------
/packages/node/src/node.ts:
--------------------------------------------------------------------------------
1 | import { Readable } from 'stream';
2 | import type { IncomingMessage, ServerResponse } from 'http';
3 |
4 | import { defineAdapter } from './core';
5 | import { Response, Headers } from './web-io';
6 | import { StaticFile } from './core/StaticFile';
7 | import { resolveFilePath } from './fs';
8 | import { serveFile } from './support/serveFile';
9 | import { pipeStreamAsync } from './support/pipeStreamAsync';
10 | import { toNodeHeaders } from './support/headers';
11 | import { fromNodeRequest } from './support/fromNodeRequest';
12 |
13 | export const createApplication = defineAdapter((applicationOptions) => {
14 | // This `fromStaticFile` function is identical to that of bun.
15 | const fromStaticFile = async (
16 | requestHeaders: Headers,
17 | staticFile: StaticFile,
18 | ): Promise => {
19 | const { filePath, options, responseInit: init } = staticFile;
20 | const resolved = resolveFilePath(filePath, applicationOptions);
21 | if (!resolved) {
22 | return;
23 | }
24 | const [fullFilePath] = resolved;
25 | const customServeFile = applicationOptions.serveFile;
26 | if (customServeFile) {
27 | const { status, statusText, headers } = new Response(null, init);
28 | const maybeResponse = await customServeFile({
29 | filePath,
30 | fullFilePath,
31 | status,
32 | statusText,
33 | headers,
34 | options,
35 | });
36 | return maybeResponse ?? undefined;
37 | }
38 | const fileResponse = await serveFile(requestHeaders, fullFilePath, options);
39 | if (!fileResponse) {
40 | return;
41 | }
42 | // Use the status from fileResponse if provided (e.g. "304 Not Modified")
43 | // otherwise fall back to user-specified value or default.
44 | const responseStatus = fileResponse.status ?? init.status ?? 200;
45 | const responseHeaders = new Headers(init.headers);
46 | // Merge in the headers without overwriting existing headers
47 | for (const [key, value] of Object.entries(fileResponse.headers ?? {})) {
48 | if (!responseHeaders.has(key)) {
49 | responseHeaders.set(key, value);
50 | }
51 | }
52 | return new Response(fileResponse.body ?? '', {
53 | ...init,
54 | status: responseStatus,
55 | headers: responseHeaders,
56 | });
57 | };
58 |
59 | return {
60 | onError: (request, error) => {
61 | return new Response(String(error), { status: 500 });
62 | },
63 | toResponse: async (request, result) => {
64 | if (result instanceof StaticFile) {
65 | return await fromStaticFile(request.headers, result);
66 | }
67 | return result;
68 | },
69 | createNativeHandler: (getResponse) => {
70 | const handleRequest = async (
71 | nodeRequest: IncomingMessage,
72 | nodeResponse: ServerResponse,
73 | ) => {
74 | const request = fromNodeRequest(nodeRequest, applicationOptions);
75 | const response = await getResponse(request);
76 | const { status, statusText, headers, bodyRaw: body } = response;
77 | if (body instanceof Readable) {
78 | await pipeStreamAsync(body, nodeResponse, {
79 | beforeFirstWrite: () =>
80 | nodeResponse.writeHead(
81 | status,
82 | statusText,
83 | toNodeHeaders(headers),
84 | ),
85 | });
86 | } else {
87 | nodeResponse.writeHead(status, statusText, toNodeHeaders(headers));
88 | if (body != null) {
89 | nodeResponse.write(body);
90 | }
91 | nodeResponse.end();
92 | }
93 | };
94 |
95 | return (nodeRequest: IncomingMessage, nodeResponse: ServerResponse) => {
96 | handleRequest(nodeRequest, nodeResponse).catch((e) => {
97 | const error = e instanceof Error ? e : new Error(String(e));
98 | if (!nodeResponse.headersSent) {
99 | nodeResponse.writeHead(500);
100 | nodeResponse.end(String(error));
101 | } else {
102 | nodeResponse.end();
103 | }
104 | });
105 | };
106 | },
107 | };
108 | });
109 |
--------------------------------------------------------------------------------
/packages/node/src/packages/express/index.ts:
--------------------------------------------------------------------------------
1 | export { HttpError } from '../../core';
2 | export { Request } from '../../web-io';
3 | export { default as Response } from '../../core/CustomResponse';
4 | export { createApplication } from '../../express';
5 |
--------------------------------------------------------------------------------
/packages/node/src/packages/node/index.ts:
--------------------------------------------------------------------------------
1 | export { HttpError } from '../../core';
2 | export { Request } from '../../web-io';
3 | export { default as Response } from '../../core/CustomResponse';
4 | export { createApplication } from '../../node';
5 |
--------------------------------------------------------------------------------
/packages/node/src/support/__tests__/serveFile.test.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable @typescript-eslint/no-explicit-any */
2 | import { serveFile } from '../serveFile';
3 | import { Headers } from '../../web-io';
4 |
5 | vi.mock('fs', async (importOriginal) => {
6 | const fs = await importOriginal();
7 | return {
8 | ...Object(fs),
9 | createReadStream: vi.fn().mockImplementation((filePath) => {
10 | return { _stream: filePath } as any;
11 | }),
12 | };
13 | });
14 |
15 | vi.mock('fs/promises', async (importOriginal) => {
16 | const fs = await importOriginal();
17 | return {
18 | ...Object(fs),
19 | stat: vi.fn().mockImplementation(async (path) => {
20 | const fileName = path.split('/').pop().split('.')[0] ?? '';
21 | const parts = fileName.split('-').slice(1);
22 | if (!parts.length) {
23 | throw new Error('ENOENT: no such file or directory');
24 | }
25 | const [size, isFile] = parts;
26 | return mockStat(Number(size), Boolean(Number(isFile)));
27 | }),
28 | };
29 | });
30 |
31 | describe('serveFile', () => {
32 | it('should serve a file that exists', async () => {
33 | const filePath = '/foo/thing-42-1.png';
34 | const result = await serveFile(new Headers(), filePath);
35 | expect(result).toEqual({
36 | headers: {
37 | 'Content-Length': '42',
38 | 'Content-Type': 'image/png',
39 | ETag: 'W/"2a16806b5bc00"',
40 | 'Last-Modified': 'Tue, 01 Jan 2019 00:00:00 GMT',
41 | },
42 | body: { _stream: filePath },
43 | });
44 | });
45 |
46 | it('should return null if the file does not exist', async () => {
47 | const filePath = './foo.txt';
48 | const result = await serveFile(new Headers(), filePath);
49 | expect(result).toEqual(null);
50 | });
51 |
52 | it('should return null if the entry at path is not a file', async () => {
53 | const filePath = './foo/dir-5-0';
54 | const result = await serveFile(new Headers(), filePath);
55 | expect(result).toEqual(null);
56 | });
57 |
58 | it('should fall back to default content type', async () => {
59 | const filePath = './foo/file-15-1.asdf';
60 | const result = await serveFile(new Headers(), filePath);
61 | expect(result).toEqual({
62 | headers: {
63 | 'Content-Length': '15',
64 | 'Content-Type': 'application/octet-stream',
65 | ETag: 'W/"f16806b5bc00"',
66 | 'Last-Modified': 'Tue, 01 Jan 2019 00:00:00 GMT',
67 | },
68 | body: { _stream: filePath },
69 | });
70 | });
71 | });
72 |
73 | function mockStat(size: number, isFile: boolean) {
74 | return {
75 | size,
76 | mtimeMs: new Date('2019-01-01T00:00:00.000Z').valueOf(),
77 | isFile: () => isFile,
78 | };
79 | }
80 |
--------------------------------------------------------------------------------
/packages/node/src/support/fromNodeRequest.ts:
--------------------------------------------------------------------------------
1 | import type { IncomingMessage } from 'http';
2 |
3 | import type { RequestOptions } from '../types';
4 | import { Request } from '../web-io';
5 |
6 | import { fromNodeRawHeaders } from './headers';
7 |
8 | export function fromNodeRequest(
9 | nodeRequest: IncomingMessage,
10 | options: RequestOptions,
11 | ) {
12 | const method = (nodeRequest.method ?? 'GET').toUpperCase();
13 | const pathname = nodeRequest.url ?? '/';
14 | const headers = fromNodeRawHeaders(nodeRequest.rawHeaders);
15 | return new Request(pathname, {
16 | method,
17 | headers,
18 | body: nodeRequest,
19 | options,
20 | });
21 | }
22 |
--------------------------------------------------------------------------------
/packages/node/src/support/headers.ts:
--------------------------------------------------------------------------------
1 | import { Headers } from '../web-io';
2 |
3 | // https://nodejs.org/docs/latest-v16.x/api/http.html#messagerawheaders
4 | export function fromNodeRawHeaders(rawHeaders: Array) {
5 | const headers = new Headers();
6 | for (let i = 0; i < rawHeaders.length; i++) {
7 | const name = rawHeaders[i] ?? '';
8 | const value = rawHeaders[++i] ?? '';
9 | headers.append(name, value);
10 | }
11 | return headers;
12 | }
13 |
14 | // Helper to convert headers to the object expected by Node's
15 | // response.writeHead().
16 | // https://nodejs.org/docs/latest-v16.x/api/http.html#responsewriteheadstatuscode-statusmessage-headers
17 | export function toNodeHeaders(headers: Headers) {
18 | const result: Record> = {};
19 | for (const [name, values] of headers.headers.values()) {
20 | // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
21 | result[name] = values.length === 1 ? values[0]! : values;
22 | }
23 | return result;
24 | }
25 |
--------------------------------------------------------------------------------
/packages/node/src/support/pipeStreamAsync.ts:
--------------------------------------------------------------------------------
1 | import type { Readable, Writable } from 'stream';
2 |
3 | export function pipeStreamAsync(
4 | readStream: Readable,
5 | writeStream: Writable,
6 | options: { beforeFirstWrite: () => void },
7 | ): Promise {
8 | const { beforeFirstWrite } = options;
9 | return new Promise((resolve, reject) => {
10 | readStream
11 | .once('data', () => {
12 | try {
13 | beforeFirstWrite();
14 | } catch (e) {
15 | try {
16 | readStream.unpipe(writeStream);
17 | } catch (_) {}
18 | reject(e);
19 | }
20 | })
21 | .pipe(writeStream)
22 | .on('close', () => resolve())
23 | .on('error', (error) => {
24 | readStream.off('data', beforeFirstWrite);
25 | reject(error);
26 | });
27 | });
28 | }
29 |
--------------------------------------------------------------------------------
/packages/node/src/support/readEntireStream.ts:
--------------------------------------------------------------------------------
1 | import { type Readable } from 'stream';
2 |
3 | import { defineErrors } from '../core/support/defineErrors';
4 |
5 | type Options = {
6 | expectedSize: number | undefined;
7 | maxBufferSize: number;
8 | };
9 |
10 | export const Errors = defineErrors({
11 | ExpectedSizeMismatchError:
12 | 'Expected {expected} bytes but received {received}',
13 | MaxSizeExceededError: 'Exceeded maximum buffer size of {maxBufferSize} bytes',
14 | });
15 |
16 | // There are two potential opportunities for early return here: (1) check
17 | // content-length against maxBufferSize before we begin and throw
18 | // MaxSizeExceededError if it's too large; (2) on each chunk received check
19 | // totalBytes and throw ExpectedSizeMismatchError if it exceeds expectedSize.
20 | export function readEntireStream(stream: Readable, options: Options) {
21 | const { expectedSize, maxBufferSize } = options;
22 | return new Promise((resolve, reject) => {
23 | const chunks: Array = [];
24 | let totalBytesRead = 0;
25 | stream.on('data', (data) => {
26 | chunks.push(data);
27 | totalBytesRead += data.length;
28 | if (totalBytesRead > maxBufferSize) {
29 | const error = new Errors.MaxSizeExceededError({ maxBufferSize });
30 | reject(error);
31 | }
32 | });
33 | stream.on('error', (error) => {
34 | reject(error);
35 | });
36 | stream.on('end', () => {
37 | if (expectedSize !== undefined && totalBytesRead !== expectedSize) {
38 | const error = new Errors.ExpectedSizeMismatchError({
39 | expected: expectedSize,
40 | received: totalBytesRead,
41 | });
42 | reject(error);
43 | return;
44 | }
45 | try {
46 | resolve(Buffer.concat(chunks, totalBytesRead));
47 | } catch (e) {
48 | reject(e);
49 | }
50 | });
51 | });
52 | }
53 |
--------------------------------------------------------------------------------
/packages/node/src/support/serveFile.ts:
--------------------------------------------------------------------------------
1 | import { createReadStream } from 'fs';
2 | import { stat as statAsync } from 'fs/promises';
3 | import { type Readable } from 'stream';
4 |
5 | import { tryAsync } from '../core/support/tryAsync';
6 | import { computeHeaders } from '../fs';
7 | import type { StaticFileOptions } from '../core/StaticFile';
8 | import type { Headers } from '../web-io';
9 |
10 | type FileResponse = {
11 | status?: number;
12 | headers?: Record;
13 | body?: Readable;
14 | };
15 |
16 | export async function serveFile(
17 | requestHeaders: Headers,
18 | fullFilePath: string,
19 | options: StaticFileOptions = {},
20 | ): Promise {
21 | const fileStats = await tryAsync(() => statAsync(fullFilePath));
22 | if (!fileStats || !fileStats.isFile()) {
23 | return null;
24 | }
25 | const result = await computeHeaders(
26 | requestHeaders,
27 | fullFilePath,
28 | fileStats,
29 | options,
30 | );
31 | if (result == null || result.status === 304) {
32 | return result;
33 | }
34 | return {
35 | headers: result.headers,
36 | body: createReadStream(fullFilePath),
37 | };
38 | }
39 |
--------------------------------------------------------------------------------
/packages/node/src/support/streams.ts:
--------------------------------------------------------------------------------
1 | import { Readable } from 'stream';
2 | import type { ReadableStream } from 'stream/web';
3 |
4 | // Although web streams are available in Node from v16.5, this method is
5 | // available only in v18 and newer.
6 | const fromWeb: ((readableStream: ReadableStream) => Readable) | undefined =
7 | // eslint-disable-next-line @typescript-eslint/no-explicit-any
8 | (Readable as any).fromWeb;
9 |
10 | export function readableFromWeb(readableStream: ReadableStream) {
11 | if (!fromWeb) {
12 | throw new Error(
13 | 'Readable.fromWeb() is only available in Node v18 and above',
14 | );
15 | }
16 | return fromWeb(readableStream);
17 | }
18 |
--------------------------------------------------------------------------------
/packages/node/src/test/setup.ts:
--------------------------------------------------------------------------------
1 | import * as fs from 'fs';
2 | import * as fsp from 'fs/promises';
3 | import { resolve } from 'path';
4 | import { Readable } from 'stream';
5 |
6 | vi.mock('fs');
7 | vi.mock('fs/promises');
8 |
9 | let cwd = '/';
10 |
11 | const files = [
12 | {
13 | path: 'public/foo.txt',
14 | type: 'file',
15 | content: 'Some content',
16 | mtime: 1692735819,
17 | },
18 | ];
19 |
20 | vi.spyOn(process, 'cwd').mockImplementation(() => {
21 | return cwd;
22 | });
23 |
24 | vi.spyOn(process, 'chdir').mockImplementation((path: string) => {
25 | cwd = resolve(cwd, path);
26 | });
27 |
28 | // eslint-disable-next-line @typescript-eslint/ban-ts-comment
29 | // @ts-ignore
30 | vi.spyOn(fsp, 'stat').mockImplementation(async (path: string) => {
31 | const fullPath = resolve(cwd, path);
32 | const file = files.find((file) => fullPath === resolve(cwd, file.path));
33 | if (!file) {
34 | throw Object.assign(
35 | new Error(`ENOENT: no such file or directory, stat '${path}'`),
36 | { errno: -2, code: 'ENOENT', syscall: 'stat', path },
37 | );
38 | }
39 | const { type, content, mtime } = file;
40 | return {
41 | isFile: () => type === 'file',
42 | size: content.length,
43 | mtimeMs: mtime * 1000,
44 | };
45 | });
46 |
47 | // eslint-disable-next-line @typescript-eslint/ban-ts-comment
48 | // @ts-ignore
49 | vi.spyOn(fs, 'createReadStream').mockImplementation((path: string) => {
50 | const fullPath = resolve(cwd, path);
51 | const file = files.find((file) => fullPath === resolve(cwd, file.path));
52 | if (!file) {
53 | return new Readable({
54 | read() {
55 | this.emit(
56 | 'error',
57 | Object.assign(
58 | new Error(`ENOENT: no such file or directory, open '${path}'`),
59 | { errno: -2, code: 'ENOENT', syscall: 'open', path },
60 | ),
61 | );
62 | this.push(null);
63 | },
64 | });
65 | }
66 | return Readable.from(file.content, { objectMode: false });
67 | });
68 |
--------------------------------------------------------------------------------
/packages/node/src/types:
--------------------------------------------------------------------------------
1 | ../../core/src/types
--------------------------------------------------------------------------------
/packages/node/src/web-io/Body.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable @typescript-eslint/no-explicit-any */
2 | import { TextDecoder } from 'util';
3 | import { Readable } from 'stream';
4 | import type { ReadableStream } from 'stream/web';
5 |
6 | import { readEntireStream } from '../support/readEntireStream';
7 | import { readableFromWeb } from '../support/streams';
8 |
9 | export type BodyInit =
10 | | Uint8Array // Includes Buffer which is a subclass of Uint8Array
11 | | Readable // Traditional Node Streams API
12 | | ReadableStream // New Web Streams API (since Node 16.5)
13 | | URLSearchParams
14 | | string
15 | | null
16 | | undefined;
17 |
18 | type BodyInitNormalized = Uint8Array | Readable | string | null;
19 |
20 | // The maximum amount (bytes) we'll read into memory from a body stream.
21 | // Defaults to 100kb, same as Express, see https://github.com/expressjs/body-parser/blob/9db582d/lib/types/json.js#L54
22 | const MAX_BUFFER_SIZE = 100 * 1024;
23 |
24 | export type Options = {
25 | expectedSize?: number | undefined;
26 | maxBufferSize?: number | undefined;
27 | /**
28 | * This allows us to catch an error that occurs while reading the body and
29 | * convert it to a more use-case appropriate error like an HttpError
30 | */
31 | onReadError?: (error: Error) => Error;
32 | };
33 |
34 | export class Body {
35 | private _bodyInit: BodyInitNormalized;
36 | private _bodyStream: Readable | undefined;
37 | private _bodyUsed = false;
38 | private options: Options;
39 |
40 | constructor(body: BodyInit, options?: Options) {
41 | this._bodyInit = normalizeBody(body);
42 | this.options = options ?? {};
43 | }
44 |
45 | // TODO: This is `Readable | null` but it should be `Readable` to allow request.body.pipe(...)
46 | get body() {
47 | if (this._bodyStream) {
48 | return this._bodyStream;
49 | }
50 | const body = this._bodyInit;
51 | if (body == null) {
52 | return null;
53 | }
54 | return (this._bodyStream = toStream(body));
55 | }
56 |
57 | /**
58 | * Non-standard getter for fast-path handling of non-stream response body
59 | */
60 | get bodyRaw() {
61 | const body = this._bodyInit;
62 | if (
63 | body == null ||
64 | body instanceof Uint8Array ||
65 | typeof body === 'string'
66 | ) {
67 | return body;
68 | }
69 | return this.body;
70 | }
71 |
72 | get bodyUsed() {
73 | const body = this._bodyInit;
74 | if (body == null) {
75 | return false;
76 | }
77 | if (
78 | this._bodyUsed ||
79 | body instanceof Uint8Array ||
80 | typeof body === 'string'
81 | ) {
82 | return this._bodyUsed;
83 | }
84 | if (body instanceof Readable) {
85 | // In Node v16.8+ we can rely on Readable.isDisturbed()
86 | if (Readable.isDisturbed) {
87 | return Readable.isDisturbed(body);
88 | }
89 | // In Node v14.18+ we can rely on stream.readableDidRead
90 | // https://nodejs.org/docs/latest-v14.x/api/stream.html#stream_readable_readabledidread
91 | const { readableDidRead } = body;
92 | if (typeof readableDidRead === 'boolean') {
93 | return readableDidRead;
94 | }
95 | // If it's an IncomingMessage, we can rely on the _consuming field
96 | const consuming = (body as any)._consuming as unknown;
97 | if (typeof consuming === 'boolean') {
98 | return consuming;
99 | }
100 | // If nothing else, we'll rely on our own internal flag
101 | return this._bodyUsed;
102 | }
103 | // For Web Streams (Node v16.5+) we'll rely on Readable.isDisturbed() if
104 | // available (Node v16.8+) otherwise fall back to our own internal flag.
105 | if (Readable.isDisturbed) {
106 | return Readable.isDisturbed(body as any);
107 | }
108 | return this._bodyUsed;
109 | }
110 |
111 | private async consumeBody(methodName: string): Promise {
112 | if (this.bodyUsed) {
113 | const className = this.constructor.name;
114 | throw new TypeError(
115 | `TypeError: Failed to execute '${methodName}' on '${className}': body stream already read`,
116 | );
117 | }
118 | const body = this.body;
119 | if (body == null) {
120 | return Buffer.from('');
121 | }
122 | this._bodyUsed = true;
123 | const {
124 | expectedSize,
125 | maxBufferSize = MAX_BUFFER_SIZE,
126 | onReadError,
127 | } = this.options;
128 | try {
129 | return await readEntireStream(body, {
130 | expectedSize,
131 | maxBufferSize,
132 | });
133 | } catch (e) {
134 | if (e instanceof Error && onReadError) {
135 | throw onReadError(e);
136 | }
137 | throw e;
138 | }
139 | }
140 |
141 | async arrayBuffer(): Promise {
142 | const { buffer } = await this.consumeBody('arrayBuffer');
143 | return buffer;
144 | }
145 |
146 | async text(): Promise {
147 | const body = await this.consumeBody('text');
148 | return toString(body);
149 | }
150 |
151 | async json(): Promise {
152 | const body = await this.consumeBody('json');
153 | return JSON.parse(toString(body)) as any;
154 | }
155 | }
156 |
157 | function normalizeBody(body: BodyInit): BodyInitNormalized {
158 | if (
159 | !body ||
160 | typeof body === 'string' ||
161 | body instanceof Uint8Array ||
162 | body instanceof Readable
163 | ) {
164 | return body ?? null;
165 | }
166 | if (body instanceof URLSearchParams) {
167 | return body.toString();
168 | }
169 | return readableFromWeb(body);
170 | }
171 |
172 | function toStream(body: Uint8Array | Readable | string): Readable {
173 | if (body instanceof Uint8Array || typeof body === 'string') {
174 | return Readable.from(body, { objectMode: false });
175 | }
176 | return body;
177 | }
178 |
179 | function toString(body: Uint8Array): string {
180 | return new TextDecoder().decode(body);
181 | }
182 |
--------------------------------------------------------------------------------
/packages/node/src/web-io/Headers.ts:
--------------------------------------------------------------------------------
1 | export type HeadersInit =
2 | | Array<[string, string]>
3 | | Record
4 | | Headers;
5 |
6 | export class Headers {
7 | // TODO: Consider internally storing as a Node-style object, so we can easily
8 | // return it without iterating so often. We might also want to store along
9 | // side it a lower-case -> mixed-case mapping.
10 | // Consider tracking copy-on-write or some other way to do less copying.
11 | readonly headers = new Map]>();
12 |
13 | constructor(init?: HeadersInit) {
14 | // TODO: Should be able to iterate this without using private `.headers`
15 | if (init instanceof Headers) {
16 | for (const [key, [name, values]] of init.headers) {
17 | this.headers.set(key, [name, values.slice()]);
18 | }
19 | } else if (Array.isArray(init)) {
20 | for (const [name, value] of init) {
21 | this.append(name, value);
22 | }
23 | } else if (init) {
24 | for (const [name, value] of Object.entries(init)) {
25 | const key = name.toLowerCase();
26 | this.headers.set(key, [name, [value]]);
27 | }
28 | }
29 | }
30 |
31 | has(name: string) {
32 | return this.headers.has(name.toLowerCase());
33 | }
34 |
35 | get(name: string) {
36 | const entry = this.headers.get(name.toLowerCase());
37 | if (entry) {
38 | // TODO: This is wrong / not spec compliant. Should .join()
39 | return entry[1][0] ?? null;
40 | }
41 | return null;
42 | }
43 |
44 | set(name: string, value: string) {
45 | const key = name.toLowerCase();
46 | this.headers.set(key, [name, [value]]);
47 | }
48 |
49 | append(name: string, value: string) {
50 | const { headers } = this;
51 | const key = name.toLowerCase();
52 | const existing = headers.get(key);
53 | if (existing) {
54 | existing[1].push(value);
55 | } else {
56 | headers.set(key, [name, [value]]);
57 | }
58 | }
59 |
60 | forEach(
61 | fn: (value: string, key: string, container: Headers) => void,
62 | thisArg?: object,
63 | ) {
64 | for (const [_key, [name, values]] of this.headers) {
65 | const value = values.join(', ');
66 | thisArg ? fn.call(thisArg, value, name, this) : fn(value, name, this);
67 | }
68 | }
69 |
70 | keys() {
71 | // TODO: Should we preserve case here?
72 | return this.headers.keys();
73 | }
74 |
75 | values() {
76 | return transformIterator(this.headers.values(), ([_name, values]) =>
77 | values.join(', '),
78 | );
79 | }
80 |
81 | entries() {
82 | return transformIterator(
83 | this.headers.values(),
84 | ([name, values]) => [name, values.join(', ')] as const,
85 | );
86 | }
87 |
88 | [Symbol.iterator]() {
89 | return this.entries();
90 | }
91 | }
92 |
93 | function transformIterator(
94 | upstreamIterator: IterableIterator,
95 | transform: (input: T) => U,
96 | ): IterableIterator {
97 | const iterator = {
98 | [Symbol.iterator]: () => iterator,
99 | next: () => {
100 | const result = upstreamIterator.next();
101 | return result.done
102 | ? result
103 | : { done: false, value: transform(result.value) };
104 | },
105 | };
106 | return iterator;
107 | }
108 |
--------------------------------------------------------------------------------
/packages/node/src/web-io/Request.ts:
--------------------------------------------------------------------------------
1 | import { HttpError } from '../core/HttpError';
2 | import type { RequestOptions } from '../types';
3 |
4 | import { Headers, type HeadersInit } from './Headers';
5 | import { Body, type BodyInit } from './Body';
6 |
7 | // Same as Express
8 | const TOO_LARGE = { status: 413, message: 'Request Entity Too Large' };
9 | const SIZE_MISMATCH = {
10 | status: 400,
11 | message: 'Request body size did not match content-length header',
12 | };
13 |
14 | export type RequestInit = {
15 | method?: string;
16 | headers?: HeadersInit;
17 | body?: BodyInit;
18 | options?: RequestOptions;
19 | };
20 |
21 | export class Request extends Body {
22 | readonly method: string;
23 | readonly url: string;
24 | readonly headers: Headers;
25 |
26 | constructor(url: string, init?: RequestInit) {
27 | const { bodyParserMaxBufferSize: maxBufferSize } = init?.options ?? {};
28 | const headers = new Headers(init?.headers);
29 | const expectedSize = getContentLength(headers);
30 | super(init?.body, {
31 | maxBufferSize,
32 | expectedSize,
33 | onReadError: (error) => {
34 | if (error.name === 'MaxSizeExceededError') {
35 | return new HttpError(TOO_LARGE);
36 | }
37 | if (error.name === 'ExpectedSizeMismatchError') {
38 | return new HttpError(SIZE_MISMATCH);
39 | }
40 | return error;
41 | },
42 | });
43 | this.url = url;
44 | this.method = init?.method?.toUpperCase() ?? 'GET';
45 | this.headers = headers;
46 | }
47 | }
48 |
49 | function getContentLength(headers: Headers) {
50 | const contentLength = headers.get('content-length');
51 | if (contentLength != null) {
52 | const parsed = parseInt(contentLength, 10);
53 | if (isFinite(parsed)) {
54 | return parsed;
55 | }
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/packages/node/src/web-io/Response.ts:
--------------------------------------------------------------------------------
1 | import { Headers, type HeadersInit } from './Headers';
2 | import { Body, type BodyInit } from './Body';
3 |
4 | type RedirectStatus = 301 | 302 | 303 | 307 | 308;
5 |
6 | export type ResponseInit = {
7 | headers?: HeadersInit;
8 | status?: number;
9 | statusText?: string;
10 | };
11 |
12 | export class Response extends Body {
13 | readonly status: number;
14 | readonly statusText: string;
15 | readonly headers: Headers;
16 |
17 | constructor(body?: BodyInit, init?: ResponseInit) {
18 | super(body);
19 | const { status, statusText } = init ?? {};
20 | this.status = status ?? 200;
21 | this.statusText = statusText ?? '';
22 | const headers = new Headers(init?.headers);
23 | if (!headers.has('Content-Type')) {
24 | const contentType = getDefaultContentType(body);
25 | if (contentType) {
26 | headers.set('Content-Type', contentType);
27 | }
28 | }
29 | this.headers = headers;
30 | }
31 |
32 | get ok() {
33 | return this.status >= 200 && this.status <= 299;
34 | }
35 |
36 | static redirect(url: string, status?: RedirectStatus) {
37 | return new Response('', {
38 | status: status ?? 302,
39 | // Note: express would percent-encode this URL using npm.im/encodeurl
40 | // In the spec, there is a well-defined set of valid characters, see https://github.com/nodejs/undici/blob/0ef0e265e1c8edf2614f058ea1a4224349680e99/lib/fetch/util.js#L116
41 | // Invalid characters include, anything above 0x7e, anything below 0x21 or
42 | // any of the following 17 characters: ()<>@,;:\"/[]?={}
43 | headers: { Location: url },
44 | });
45 | }
46 |
47 | // Note: This will throw if payload has circular references
48 | static json(payload: unknown, init?: ResponseInit) {
49 | const body = JSON.stringify(payload) ?? 'null';
50 | const headers = new Headers(init?.headers);
51 | headers.set('Content-Type', enc('application/json'));
52 | return new Response(body, {
53 | ...init,
54 | headers,
55 | });
56 | }
57 | }
58 |
59 | function getDefaultContentType(body: BodyInit) {
60 | if (typeof body === 'string') {
61 | return enc('text/plain');
62 | }
63 | if (body instanceof URLSearchParams) {
64 | return enc('application/x-www-form-urlencoded');
65 | }
66 | return;
67 | }
68 |
69 | /** Add encoding (charset) to content-type value */
70 | function enc(contentType: string) {
71 | return contentType + ';charset=UTF-8';
72 | }
73 |
--------------------------------------------------------------------------------
/packages/node/src/web-io/__tests__/Body.test.ts:
--------------------------------------------------------------------------------
1 | import { TextEncoder } from 'util';
2 | import { Readable } from 'stream';
3 |
4 | import { Body } from '../Body';
5 |
6 | describe('Body', () => {
7 | it('should initialize with null', async () => {
8 | const body = new Body(null);
9 | expect(body.bodyRaw).toBe(null);
10 | expect(body.body).toBe(null);
11 | const text = await body.text();
12 | expect(text).toBe('');
13 | });
14 |
15 | it('should initialize with undefined', async () => {
16 | const body = new Body(undefined);
17 | expect(body.bodyRaw).toBe(null);
18 | expect(body.body).toBe(null);
19 | const text = await body.text();
20 | expect(text).toBe('');
21 | });
22 |
23 | it('should initialize with string', async () => {
24 | const body = new Body('Hello world');
25 | expect(body.bodyRaw).toBe('Hello world');
26 | expect(body.body).toBeInstanceOf(Readable);
27 | const text = await body.text();
28 | expect(text).toBe('Hello world');
29 | });
30 |
31 | it('should initialize with buffer', async () => {
32 | const body = new Body(Buffer.from('Hello world'));
33 | expect(body.bodyRaw).toBeInstanceOf(Buffer);
34 | expect(body.body).toBeInstanceOf(Readable);
35 | const text = await body.text();
36 | expect(text).toBe('Hello world');
37 | });
38 |
39 | it('should initialize with readable stream', async () => {
40 | const body = new Body(Readable.from('Hello world', { objectMode: false }));
41 | expect(body.bodyRaw).toBeInstanceOf(Readable);
42 | expect(body.body).toBeInstanceOf(Readable);
43 | const text = await body.text();
44 | expect(text).toBe('Hello world');
45 | });
46 |
47 | const nodeVersionMajor = Number(process.version.slice(1).split('.')[0]);
48 |
49 | if (nodeVersionMajor < 16) {
50 | it('should not support web stream (Node v14)', async () => {
51 | expect(() => {
52 | createReadableStream('Hello world');
53 | }).toThrow(`Cannot find module 'stream/web'`);
54 | });
55 | }
56 |
57 | if (nodeVersionMajor === 16) {
58 | it('should throw on web stream (Node v16)', async () => {
59 | const readableStream = createReadableStream('Hello world');
60 | expect(() => {
61 | // eslint-disable-next-line no-new
62 | new Body(readableStream);
63 | }).toThrow('Readable.fromWeb() is only available in Node v18 and above');
64 | });
65 | }
66 |
67 | if (nodeVersionMajor >= 18) {
68 | it('should initialize with web stream (Node v18+)', async () => {
69 | const readableStream = createReadableStream('Hello world');
70 | const body = new Body(readableStream);
71 | expect(body.bodyRaw).toBeInstanceOf(Readable);
72 | expect(body.body).toBeInstanceOf(Readable);
73 | const text = await body.text();
74 | expect(text).toBe('Hello world');
75 | });
76 | }
77 | });
78 |
79 | function createReadableStream(string: string) {
80 | // eslint-disable-next-line @typescript-eslint/no-var-requires
81 | const { ReadableStream } = require('stream/web');
82 | const encoder = new TextEncoder();
83 |
84 | return new ReadableStream({
85 | // eslint-disable-next-line @typescript-eslint/no-explicit-any
86 | start(controller: any) {
87 | controller.enqueue(encoder.encode(string));
88 | controller.close();
89 | },
90 | });
91 | }
92 |
--------------------------------------------------------------------------------
/packages/node/src/web-io/__tests__/Request.test.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable @typescript-eslint/no-explicit-any */
2 | import { Readable } from 'stream';
3 |
4 | import { Request } from '../Request';
5 |
6 | describe('Request', () => {
7 | it('should construct with just path', () => {
8 | const request = new Request('/');
9 | expect(request.method).toBe('GET');
10 | expect(request.url).toBe('/');
11 | expect(Object.fromEntries(request.headers)).toEqual({});
12 | expect(request.body).toBe(null);
13 | expect(request.bodyRaw).toBe(null);
14 | });
15 |
16 | it('should respect method and headers', () => {
17 | const request = new Request('/', {
18 | method: 'PUT',
19 | headers: { foo: 'foo', 'content-type': 'bar' },
20 | });
21 | expect(request.method).toBe('PUT');
22 | expect(request.url).toBe('/');
23 | expect(Object.fromEntries(request.headers)).toEqual({
24 | foo: 'foo',
25 | 'content-type': 'bar',
26 | });
27 | expect(request.body).toBe(null);
28 | expect(request.bodyRaw).toBe(null);
29 | });
30 |
31 | it('should construct with a null body', () => {
32 | const request = new Request('/', { body: null });
33 | expect(request.method).toBe('GET');
34 | expect(request.url).toBe('/');
35 | expect(Object.fromEntries(request.headers)).toEqual({});
36 | expect(request.body).toBe(null);
37 | expect(request.bodyRaw).toBe(null);
38 | });
39 |
40 | it('should construct with a string body', () => {
41 | const request = new Request('/', { body: 'foo' });
42 | expect(request.method).toBe('GET');
43 | expect(request.url).toBe('/');
44 | expect(Object.fromEntries(request.headers)).toEqual({});
45 | expect(request.body instanceof Readable).toBe(true);
46 | expect(request.bodyRaw).toBe('foo');
47 | });
48 |
49 | it('should construct with a buffer body', () => {
50 | const buffer = Buffer.from('foo');
51 | const request = new Request('/foo', { method: 'post', body: buffer });
52 | expect(request.method).toBe('POST');
53 | expect(Object.fromEntries(request.headers)).toEqual({});
54 | expect(request.body instanceof Readable).toBe(true);
55 | expect(request.bodyRaw).toBe(buffer);
56 | });
57 |
58 | it('should construct with a stream body', async () => {
59 | const stream = Readable.from('foo', { objectMode: false });
60 | const request = new Request('/foo', { body: stream });
61 | expect(Object.fromEntries(request.headers)).toEqual({});
62 | expect(request.body).toBe(stream);
63 | expect(request.bodyRaw).toBe(stream);
64 | expect(request.bodyUsed).toBe(false);
65 | const text = await request.text();
66 | expect(text).toBe('foo');
67 | expect(request.bodyUsed).toBe(true);
68 | await expect(request.text()).rejects.toThrow(
69 | `TypeError: Failed to execute 'text' on 'Request': body stream already read`,
70 | );
71 | });
72 |
73 | it('should parse a json body from buffer', async () => {
74 | const buffer = Buffer.from(JSON.stringify({ foo: 1 }));
75 | const request = new Request('/foo', {
76 | method: 'post',
77 | headers: { 'content-type': 'application/json' },
78 | body: buffer,
79 | });
80 | expect(Object.fromEntries(request.headers)).toEqual({
81 | 'content-type': 'application/json',
82 | });
83 | expect(request.body instanceof Readable).toBe(true);
84 | expect(request.bodyRaw).toBe(buffer);
85 | expect(request.bodyUsed).toBe(false);
86 | const parsed = await request.json();
87 | expect(parsed).toEqual({ foo: 1 });
88 | expect(request.bodyUsed).toBe(true);
89 | await expect(request.text()).rejects.toThrow(
90 | `TypeError: Failed to execute 'text' on 'Request': body stream already read`,
91 | );
92 | });
93 |
94 | it('should parse a json body from stream', async () => {
95 | const stream = Readable.from(JSON.stringify({ foo: 1 }), {
96 | objectMode: false,
97 | });
98 | const request = new Request('/foo', { method: 'get', body: stream });
99 | expect(Object.fromEntries(request.headers)).toEqual({});
100 | const parsed = await request.json();
101 | expect(parsed).toEqual({ foo: 1 });
102 | expect(request.bodyUsed).toBe(true);
103 | await expect(request.json()).rejects.toThrow(
104 | `TypeError: Failed to execute 'json' on 'Request': body stream already read`,
105 | );
106 | });
107 |
108 | it('should throw if unable to parse json', async () => {
109 | const request = new Request('/foo', {
110 | method: 'post',
111 | body: '[1, 2',
112 | });
113 | await expect(request.json()).rejects.toThrow(
114 | `Unexpected end of JSON input`,
115 | );
116 | });
117 |
118 | it('should throw if content-length smaller than body size', async () => {
119 | const request = new Request('/foo', {
120 | method: 'post',
121 | headers: { 'content-length': '2' },
122 | body: 'foo',
123 | });
124 | await expect(request.text()).rejects.toThrow(
125 | `Request body size did not match content-length header`,
126 | );
127 | });
128 |
129 | it('should throw if content-length greater than body size', async () => {
130 | const request = new Request('/foo', {
131 | method: 'post',
132 | headers: { 'content-length': '4' },
133 | body: 'foo',
134 | });
135 | await expect(request.text()).rejects.toThrow(
136 | `Request body size did not match content-length header`,
137 | );
138 | });
139 |
140 | it('should throw if body size exceeds maximum allowed', async () => {
141 | const request = new Request('/foo', {
142 | method: 'post',
143 | headers: { 'content-length': '4' },
144 | body: 'x'.repeat(1001),
145 | options: { bodyParserMaxBufferSize: 1000 },
146 | });
147 | let error: any;
148 | try {
149 | await request.text();
150 | } catch (e) {
151 | error = e;
152 | }
153 | expect(error.status).toBe(413);
154 | expect(error.message).toBe('Request Entity Too Large');
155 | });
156 | });
157 |
--------------------------------------------------------------------------------
/packages/node/src/web-io/__tests__/Response.test.ts:
--------------------------------------------------------------------------------
1 | import { Readable } from 'stream';
2 |
3 | import { Response } from '../Response';
4 |
5 | describe('Response', () => {
6 | it('should construct with no args', () => {
7 | const response = new Response();
8 | expect(response.body).toBe(null);
9 | expect(response.bodyRaw).toBe(null);
10 | expect(Object.fromEntries(response.headers)).toEqual({});
11 | });
12 |
13 | it('should construct with undefined', () => {
14 | const response = new Response(undefined);
15 | expect(Object.fromEntries(response.headers)).toEqual({});
16 | expect(response.bodyUsed).toBe(false);
17 | expect(response.body).toBe(null);
18 | expect(response.bodyRaw).toBe(null);
19 | expect(response.bodyUsed).toBe(false);
20 | });
21 |
22 | it('should construct with null', () => {
23 | const response = new Response(null);
24 | expect(Object.fromEntries(response.headers)).toEqual({});
25 | expect(response.body).toBe(null);
26 | expect(response.bodyRaw).toBe(null);
27 | });
28 |
29 | it('should construct with string', async () => {
30 | const response = new Response('foo');
31 | expect(Object.fromEntries(response.headers)).toEqual({
32 | 'Content-Type': 'text/plain;charset=UTF-8',
33 | });
34 | expect(response.body instanceof Readable).toBe(true);
35 | expect(response.bodyRaw).toEqual('foo');
36 | expect(response.bodyUsed).toBe(false);
37 | const text = await response.text();
38 | expect(text).toBe('foo');
39 | expect(response.bodyUsed).toBe(true);
40 | await expect(response.text()).rejects.toThrow(
41 | `TypeError: Failed to execute 'text' on 'Response': body stream already read`,
42 | );
43 | });
44 |
45 | it('should honor headers', async () => {
46 | const response = new Response('foo', {
47 | headers: { foo: 'foo', 'content-type': 'bar' },
48 | });
49 | expect(Object.fromEntries(response.headers)).toEqual({
50 | foo: 'foo',
51 | 'content-type': 'bar',
52 | });
53 | expect(response.bodyRaw).toEqual('foo');
54 | expect(response.bodyUsed).toBe(false);
55 | const text = await response.text();
56 | expect(text).toBe('foo');
57 | });
58 |
59 | it('should construct with buffer', async () => {
60 | const response = new Response(Buffer.from('foo'));
61 | expect(Object.fromEntries(response.headers)).toEqual({});
62 | expect(response.body instanceof Readable).toBe(true);
63 | const stream = response.body;
64 | expect(response.body).toBe(stream);
65 | expect(Buffer.isBuffer(response.bodyRaw)).toBe(true);
66 | expect(response.bodyUsed).toBe(false);
67 | const text = await response.text();
68 | expect(text).toBe('foo');
69 | expect(response.bodyUsed).toBe(true);
70 | await expect(response.text()).rejects.toThrow(
71 | `TypeError: Failed to execute 'text' on 'Response': body stream already read`,
72 | );
73 | });
74 |
75 | it('should construct with stream', async () => {
76 | const stream = Readable.from('foo', { objectMode: false });
77 | const response = new Response(stream);
78 | expect(Object.fromEntries(response.headers)).toEqual({});
79 | expect(response.body).toBe(stream);
80 | expect(response.bodyRaw).toBe(stream);
81 | expect(response.bodyUsed).toBe(false);
82 | const text = await response.text();
83 | expect(text).toBe('foo');
84 | expect(response.bodyUsed).toBe(true);
85 | await expect(response.text()).rejects.toThrow(
86 | `TypeError: Failed to execute 'text' on 'Response': body stream already read`,
87 | );
88 | });
89 |
90 | it('should construct with Response.json()', async () => {
91 | const response = Response.json({ foo: 1 });
92 | expect(Object.fromEntries(response.headers)).toEqual({
93 | 'Content-Type': 'application/json;charset=UTF-8',
94 | });
95 | expect(response.body instanceof Readable).toBe(true);
96 | expect(response.bodyRaw).toBe(JSON.stringify({ foo: 1 }));
97 | expect(response.bodyUsed).toBe(false);
98 | const parsed = await response.json();
99 | expect(parsed).toEqual({ foo: 1 });
100 | expect(response.bodyUsed).toBe(true);
101 | await expect(response.text()).rejects.toThrow(
102 | `TypeError: Failed to execute 'text' on 'Response': body stream already read`,
103 | );
104 | await expect(response.json()).rejects.toThrow(
105 | `TypeError: Failed to execute 'json' on 'Response': body stream already read`,
106 | );
107 | });
108 |
109 | it('should parse JSON string regardless of content-type', async () => {
110 | const response = new Response(JSON.stringify({ foo: 1 }));
111 | expect(Object.fromEntries(response.headers)).toEqual({
112 | 'Content-Type': 'text/plain;charset=UTF-8',
113 | });
114 | const parsed = await response.json();
115 | expect(parsed).toEqual({ foo: 1 });
116 | });
117 |
118 | it('should parse JSON buffer regardless of content-type', async () => {
119 | const response = new Response(Buffer.from(JSON.stringify({ foo: 1 })));
120 | expect(Object.fromEntries(response.headers)).toEqual({});
121 | const parsed = await response.json();
122 | expect(parsed).toEqual({ foo: 1 });
123 | });
124 |
125 | it('should throw on invalid JSON', async () => {
126 | const response = new Response(Buffer.from('foo'));
127 | expect(Object.fromEntries(response.headers)).toEqual({});
128 | await expect(response.json()).rejects.toThrow(`Unexpected token`);
129 | });
130 | });
131 |
--------------------------------------------------------------------------------
/packages/node/src/web-io/index.ts:
--------------------------------------------------------------------------------
1 | export { Request, type RequestInit } from './Request';
2 | export { Response, type ResponseInit } from './Response';
3 | export { Headers, type HeadersInit } from './Headers';
4 | export { type BodyInit } from './Body';
5 |
--------------------------------------------------------------------------------
/packages/node/tsconfig.build.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "./tsconfig.json",
3 | "compilerOptions": {
4 | "outDir": "build",
5 | "declaration": true,
6 | "declarationDir": "build/dts",
7 | "emitDeclarationOnly": true
8 | },
9 | "exclude": ["src/**/*.test.ts"]
10 | }
11 |
--------------------------------------------------------------------------------
/packages/node/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "../../tsconfig.json",
3 | "compilerOptions": {
4 | "module": "commonjs",
5 | "types": ["vitest/globals"]
6 | },
7 | "include": ["src"]
8 | }
9 |
--------------------------------------------------------------------------------
/packages/node/vitest.config.ts:
--------------------------------------------------------------------------------
1 | import { defineConfig } from 'vitest/config';
2 |
3 | export default defineConfig({
4 | test: {
5 | globals: true,
6 | setupFiles: ['src/test/setup.ts'],
7 | },
8 | resolve: {
9 | preserveSymlinks: true,
10 | },
11 | });
12 |
--------------------------------------------------------------------------------
/publish.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | yarn build
4 |
5 | if [ $? -eq 0 ]; then
6 | pushd packages/bun/build
7 | npm publish
8 | popd
9 | pushd packages/cfw/build
10 | npm publish
11 | popd
12 | pushd packages/node/build/node
13 | npm publish
14 | popd
15 | pushd packages/node/build/express
16 | npm publish
17 | popd
18 | fi
19 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "target": "es2022",
4 | "lib": ["es2022"],
5 | "module": "esnext",
6 | "esModuleInterop": true,
7 | "moduleResolution": "node",
8 | "preserveSymlinks": true,
9 | "skipLibCheck": true,
10 | "strict": true,
11 | "noUncheckedIndexedAccess": true,
12 | "exactOptionalPropertyTypes": true,
13 | "noFallthroughCasesInSwitch": true,
14 | "isolatedModules": true,
15 | "forceConsistentCasingInFileNames": true
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/turbo.json:
--------------------------------------------------------------------------------
1 | {
2 | "$schema": "https://turborepo.org/schema.json",
3 | "pipeline": {
4 | "lint": {
5 | "outputs": []
6 | },
7 | "typecheck": {
8 | "outputs": []
9 | },
10 | "format:check": {
11 | "outputs": []
12 | },
13 | "unit": {
14 | "outputs": []
15 | },
16 | "version": {
17 | "outputs": []
18 | },
19 | "build": {
20 | "outputs": []
21 | }
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/version.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | if [ -z "$1" ]; then
4 | echo "Please provide an argument: major, minor or patch"
5 | exit 1
6 | fi
7 |
8 | npm version $1 --no-git-tag-version
9 |
--------------------------------------------------------------------------------