211 lines
7.9 KiB
JavaScript
211 lines
7.9 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.adapter = adapter;
|
|
exports.enhanceGlobals = enhanceGlobals;
|
|
var _error = require("./error");
|
|
var _utils = require("./utils");
|
|
var _fetchEvent = require("./spec-extension/fetch-event");
|
|
var _request = require("./spec-extension/request");
|
|
var _response = require("./spec-extension/response");
|
|
var _relativizeUrl = require("../../shared/lib/router/utils/relativize-url");
|
|
var _nextUrl = require("./next-url");
|
|
var _internalUtils = require("../internal-utils");
|
|
var _appPaths = require("../../shared/lib/router/utils/app-paths");
|
|
var _appRouterHeaders = require("../../client/components/app-router-headers");
|
|
class NextRequestHint extends _request.NextRequest {
|
|
constructor(params){
|
|
super(params.input, params.init);
|
|
this.sourcePage = params.page;
|
|
}
|
|
get request() {
|
|
throw new _error.PageSignatureError({
|
|
page: this.sourcePage
|
|
});
|
|
}
|
|
respondWith() {
|
|
throw new _error.PageSignatureError({
|
|
page: this.sourcePage
|
|
});
|
|
}
|
|
waitUntil() {
|
|
throw new _error.PageSignatureError({
|
|
page: this.sourcePage
|
|
});
|
|
}
|
|
}
|
|
const FLIGHT_PARAMETERS = [
|
|
[
|
|
_appRouterHeaders.RSC
|
|
],
|
|
[
|
|
_appRouterHeaders.NEXT_ROUTER_STATE_TREE
|
|
],
|
|
[
|
|
_appRouterHeaders.NEXT_ROUTER_PREFETCH
|
|
],
|
|
[
|
|
_appRouterHeaders.FETCH_CACHE_HEADER
|
|
],
|
|
];
|
|
async function adapter(params) {
|
|
// TODO-APP: use explicit marker for this
|
|
const isEdgeRendering = typeof self.__BUILD_MANIFEST !== "undefined";
|
|
params.request.url = (0, _appPaths).normalizeRscPath(params.request.url, true);
|
|
const requestUrl = new _nextUrl.NextURL(params.request.url, {
|
|
headers: params.request.headers,
|
|
nextConfig: params.request.nextConfig
|
|
});
|
|
// Ensure users only see page requests, never data requests.
|
|
const buildId = requestUrl.buildId;
|
|
requestUrl.buildId = "";
|
|
const isDataReq = params.request.headers["x-nextjs-data"];
|
|
if (isDataReq && requestUrl.pathname === "/index") {
|
|
requestUrl.pathname = "/";
|
|
}
|
|
const requestHeaders = (0, _utils).fromNodeHeaders(params.request.headers);
|
|
// Parameters should only be stripped for middleware
|
|
if (!isEdgeRendering) {
|
|
for (const param of FLIGHT_PARAMETERS){
|
|
requestHeaders.delete(param.toString().toLowerCase());
|
|
}
|
|
}
|
|
// Strip internal query parameters off the request.
|
|
(0, _internalUtils).stripInternalSearchParams(requestUrl.searchParams, true);
|
|
const request = new NextRequestHint({
|
|
page: params.page,
|
|
input: String(requestUrl),
|
|
init: {
|
|
body: params.request.body,
|
|
geo: params.request.geo,
|
|
headers: requestHeaders,
|
|
ip: params.request.ip,
|
|
method: params.request.method,
|
|
nextConfig: params.request.nextConfig
|
|
}
|
|
});
|
|
/**
|
|
* This allows to identify the request as a data request. The user doesn't
|
|
* need to know about this property neither use it. We add it for testing
|
|
* purposes.
|
|
*/ if (isDataReq) {
|
|
Object.defineProperty(request, "__isData", {
|
|
enumerable: false,
|
|
value: true
|
|
});
|
|
}
|
|
const event = new _fetchEvent.NextFetchEvent({
|
|
request,
|
|
page: params.page
|
|
});
|
|
let response = await params.handler(request, event);
|
|
// check if response is a Response object
|
|
if (response && !(response instanceof Response)) {
|
|
throw new TypeError("Expected an instance of Response to be returned");
|
|
}
|
|
/**
|
|
* For rewrites we must always include the locale in the final pathname
|
|
* so we re-create the NextURL forcing it to include it when the it is
|
|
* an internal rewrite. Also we make sure the outgoing rewrite URL is
|
|
* a data URL if the request was a data request.
|
|
*/ const rewrite = response == null ? void 0 : response.headers.get("x-middleware-rewrite");
|
|
if (response && rewrite) {
|
|
const rewriteUrl = new _nextUrl.NextURL(rewrite, {
|
|
forceLocale: true,
|
|
headers: params.request.headers,
|
|
nextConfig: params.request.nextConfig
|
|
});
|
|
if (!process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE) {
|
|
if (rewriteUrl.host === request.nextUrl.host) {
|
|
rewriteUrl.buildId = buildId || rewriteUrl.buildId;
|
|
response.headers.set("x-middleware-rewrite", String(rewriteUrl));
|
|
}
|
|
}
|
|
/**
|
|
* When the request is a data request we must show if there was a rewrite
|
|
* with an internal header so the client knows which component to load
|
|
* from the data request.
|
|
*/ if (isDataReq) {
|
|
response.headers.set("x-nextjs-rewrite", (0, _relativizeUrl).relativizeURL(String(rewriteUrl), String(requestUrl)));
|
|
}
|
|
}
|
|
/**
|
|
* For redirects we will not include the locale in case when it is the
|
|
* default and we must also make sure the outgoing URL is a data one if
|
|
* the incoming request was a data request.
|
|
*/ const redirect = response == null ? void 0 : response.headers.get("Location");
|
|
if (response && redirect) {
|
|
const redirectURL = new _nextUrl.NextURL(redirect, {
|
|
forceLocale: false,
|
|
headers: params.request.headers,
|
|
nextConfig: params.request.nextConfig
|
|
});
|
|
/**
|
|
* Responses created from redirects have immutable headers so we have
|
|
* to clone the response to be able to modify it.
|
|
*/ response = new Response(response.body, response);
|
|
if (!process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE) {
|
|
if (redirectURL.host === request.nextUrl.host) {
|
|
redirectURL.buildId = buildId || redirectURL.buildId;
|
|
response.headers.set("Location", String(redirectURL));
|
|
}
|
|
}
|
|
/**
|
|
* When the request is a data request we can't use the location header as
|
|
* it may end up with CORS error. Instead we map to an internal header so
|
|
* the client knows the destination.
|
|
*/ if (isDataReq) {
|
|
response.headers.delete("Location");
|
|
response.headers.set("x-nextjs-redirect", (0, _relativizeUrl).relativizeURL(String(redirectURL), String(requestUrl)));
|
|
}
|
|
}
|
|
return {
|
|
response: response || _response.NextResponse.next(),
|
|
waitUntil: Promise.all(event[_fetchEvent.waitUntilSymbol])
|
|
};
|
|
}
|
|
function getUnsupportedModuleErrorMessage(module) {
|
|
// warning: if you change these messages, you must adjust how react-dev-overlay's middleware detects modules not found
|
|
return `The edge runtime does not support Node.js '${module}' module.
|
|
Learn More: https://nextjs.org/docs/messages/node-module-in-edge-runtime`;
|
|
}
|
|
function __import_unsupported(moduleName) {
|
|
const proxy = new Proxy(function() {}, {
|
|
get (_obj, prop) {
|
|
if (prop === "then") {
|
|
return {};
|
|
}
|
|
throw new Error(getUnsupportedModuleErrorMessage(moduleName));
|
|
},
|
|
construct () {
|
|
throw new Error(getUnsupportedModuleErrorMessage(moduleName));
|
|
},
|
|
apply (_target, _this, args) {
|
|
if (typeof args[0] === "function") {
|
|
return args[0](proxy);
|
|
}
|
|
throw new Error(getUnsupportedModuleErrorMessage(moduleName));
|
|
}
|
|
});
|
|
return new Proxy({}, {
|
|
get: ()=>proxy
|
|
});
|
|
}
|
|
function enhanceGlobals() {
|
|
// The condition is true when the "process" module is provided
|
|
if (process !== global.process) {
|
|
// prefer local process but global.process has correct "env"
|
|
process.env = global.process.env;
|
|
global.process = process;
|
|
}
|
|
// to allow building code that import but does not use node.js modules,
|
|
// webpack will expect this function to exist in global scope
|
|
Object.defineProperty(globalThis, "__import_unsupported", {
|
|
value: __import_unsupported,
|
|
enumerable: false,
|
|
configurable: false
|
|
});
|
|
}
|
|
|
|
//# sourceMappingURL=adapter.js.map
|