-
Notifications
You must be signed in to change notification settings - Fork 2.4k
/
server.ts
121 lines (105 loc) · 3.08 KB
/
server.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
import type { VercelRequest, VercelResponse } from "@vercel/node";
import type {
AppLoadContext,
ServerBuild,
RequestInit as NodeRequestInit,
Response as NodeResponse,
} from "@remix-run/node";
import {
AbortController,
createRequestHandler as createRemixRequestHandler,
Headers as NodeHeaders,
Request as NodeRequest,
writeReadableStreamToWritable,
} from "@remix-run/node";
/**
* A function that returns the value to use as `context` in route `loader` and
* `action` functions.
*
* You can think of this as an escape hatch that allows you to pass
* environment/platform-specific values through to your loader/action.
*/
export type GetLoadContextFunction = (
req: VercelRequest,
res: VercelResponse
) => AppLoadContext;
export type RequestHandler = (
req: VercelRequest,
res: VercelResponse
) => Promise<void>;
/**
* Returns a request handler for Vercel's Node.js runtime that serves the
* response using Remix.
*/
export function createRequestHandler({
build,
getLoadContext,
mode = process.env.NODE_ENV,
}: {
build: ServerBuild;
getLoadContext?: GetLoadContextFunction;
mode?: string;
}): RequestHandler {
let handleRequest = createRemixRequestHandler(build, mode);
return async (req, res) => {
let request = createRemixRequest(req, res);
let loadContext = getLoadContext?.(req, res);
let response = (await handleRequest(request, loadContext)) as NodeResponse;
await sendRemixResponse(res, response);
};
}
export function createRemixHeaders(
requestHeaders: VercelRequest["headers"]
): NodeHeaders {
let headers = new NodeHeaders();
for (let key in requestHeaders) {
let header = requestHeaders[key]!;
// set-cookie is an array (maybe others)
if (Array.isArray(header)) {
for (let value of header) {
headers.append(key, value);
}
} else {
headers.append(key, header);
}
}
return headers;
}
export function createRemixRequest(
req: VercelRequest,
res: VercelResponse
): NodeRequest {
let host = req.headers["x-forwarded-host"] || req.headers["host"];
// doesn't seem to be available on their req object!
let protocol = req.headers["x-forwarded-proto"] || "https";
let url = new URL(req.url!, `${protocol}://${host}`);
// Abort action/loaders once we can no longer write a response
let controller = new AbortController();
res.on("close", () => controller.abort());
let init: NodeRequestInit = {
method: req.method,
headers: createRemixHeaders(req.headers),
signal: controller.signal as NodeRequestInit["signal"],
};
if (req.method !== "GET" && req.method !== "HEAD") {
init.body = req;
}
return new NodeRequest(url.href, init);
}
export async function sendRemixResponse(
res: VercelResponse,
nodeResponse: NodeResponse
): Promise<void> {
res.statusMessage = nodeResponse.statusText;
let multiValueHeaders = nodeResponse.headers.raw();
res.writeHead(
nodeResponse.status,
nodeResponse.statusText,
multiValueHeaders
);
if (nodeResponse.body) {
await writeReadableStreamToWritable(nodeResponse.body, res);
} else {
res.end();
}
}