File size: 3,380 Bytes
1e92f2d |
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 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 |
import type {
ProxyFetchRequest,
ProxyFetchResponse,
ProxyResponse,
} from './proxy'
import { getTestReqInfo, type TestRequestReader } from './context'
type Fetch = typeof fetch
type FetchInputArg = Parameters<Fetch>[0]
type FetchInitArg = Parameters<Fetch>[1]
export const reader: TestRequestReader<Request> = {
url(req) {
return req.url
},
header(req, name) {
return req.headers.get(name)
},
}
function getTestStack(): string {
let stack = (new Error().stack ?? '').split('\n')
// Skip the first line and find first non-empty line.
for (let i = 1; i < stack.length; i++) {
if (stack[i].length > 0) {
stack = stack.slice(i)
break
}
}
// Filter out franmework lines.
stack = stack.filter((f) => !f.includes('/next/dist/'))
// At most 5 lines.
stack = stack.slice(0, 5)
// Cleanup some internal info and trim.
stack = stack.map((s) => s.replace('webpack-internal:///(rsc)/', '').trim())
return stack.join(' ')
}
async function buildProxyRequest(
testData: string,
request: Request
): Promise<ProxyFetchRequest> {
const {
url,
method,
headers,
body,
cache,
credentials,
integrity,
mode,
redirect,
referrer,
referrerPolicy,
} = request
return {
testData,
api: 'fetch',
request: {
url,
method,
headers: [...Array.from(headers), ['next-test-stack', getTestStack()]],
body: body
? Buffer.from(await request.arrayBuffer()).toString('base64')
: null,
cache,
credentials,
integrity,
mode,
redirect,
referrer,
referrerPolicy,
},
}
}
function buildResponse(proxyResponse: ProxyFetchResponse): Response {
const { status, headers, body } = proxyResponse.response
return new Response(body ? Buffer.from(body, 'base64') : null, {
status,
headers: new Headers(headers),
})
}
export async function handleFetch(
originalFetch: Fetch,
request: Request
): Promise<Response> {
const testInfo = getTestReqInfo(request, reader)
if (!testInfo) {
// Passthrough non-test requests.
return originalFetch(request)
}
const { testData, proxyPort } = testInfo
const proxyRequest = await buildProxyRequest(testData, request)
const resp = await originalFetch(`http://localhost:${proxyPort}`, {
method: 'POST',
body: JSON.stringify(proxyRequest),
next: {
// @ts-ignore
internal: true,
},
})
if (!resp.ok) {
throw new Error(`Proxy request failed: ${resp.status}`)
}
const proxyResponse = (await resp.json()) as ProxyResponse
const { api } = proxyResponse
switch (api) {
case 'continue':
return originalFetch(request)
case 'abort':
case 'unhandled':
throw new Error(
`Proxy request aborted [${request.method} ${request.url}]`
)
case 'fetch':
return buildResponse(proxyResponse)
default:
return api satisfies never
}
}
export function interceptFetch(originalFetch: Fetch) {
global.fetch = function testFetch(
input: FetchInputArg,
init?: FetchInitArg
): Promise<Response> {
// Passthrough internal requests.
// @ts-ignore
if (init?.next?.internal) {
return originalFetch(input, init)
}
return handleFetch(originalFetch, new Request(input, init))
}
return () => {
global.fetch = originalFetch
}
}
|