326 lines
17 KiB
JavaScript
326 lines
17 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
0 && (module.exports = {
|
|
AppRouteRouteModule: null,
|
|
default: null
|
|
});
|
|
function _export(target, all) {
|
|
for(var name in all)Object.defineProperty(target, name, {
|
|
enumerable: true,
|
|
get: all[name]
|
|
});
|
|
}
|
|
_export(exports, {
|
|
AppRouteRouteModule: function() {
|
|
return AppRouteRouteModule;
|
|
},
|
|
default: function() {
|
|
return _default;
|
|
}
|
|
});
|
|
const _routemodule = require("../route-module");
|
|
const _requestasyncstoragewrapper = require("../../../async-storage/request-async-storage-wrapper");
|
|
const _staticgenerationasyncstoragewrapper = require("../../../async-storage/static-generation-async-storage-wrapper");
|
|
const _responsehandlers = require("../helpers/response-handlers");
|
|
const _http = require("../../../web/http");
|
|
const _patchfetch = require("../../../lib/patch-fetch");
|
|
const _tracer = require("../../../lib/trace/tracer");
|
|
const _constants = require("../../../lib/trace/constants");
|
|
const _getpathnamefromabsolutepath = require("./helpers/get-pathname-from-absolute-path");
|
|
const _proxyrequest = require("./helpers/proxy-request");
|
|
const _resolvehandlererror = require("./helpers/resolve-handler-error");
|
|
const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../../build/output/log"));
|
|
const _autoimplementmethods = require("./helpers/auto-implement-methods");
|
|
const _getnonstaticmethods = require("./helpers/get-non-static-methods");
|
|
const _requestcookies = require("../../../web/spec-extension/adapters/request-cookies");
|
|
const _routekind = require("../../route-kind");
|
|
const _parsedurlquerytoparams = require("./helpers/parsed-url-query-to-params");
|
|
const _hooksservercontext = /*#__PURE__*/ _interop_require_wildcard(require("../../../../client/components/hooks-server-context"));
|
|
const _headers = /*#__PURE__*/ _interop_require_wildcard(require("../../../../client/components/headers"));
|
|
const _staticgenerationbailout = require("../../../../client/components/static-generation-bailout");
|
|
const _requestasyncstorageexternal = require("../../../../client/components/request-async-storage.external");
|
|
const _staticgenerationasyncstorageexternal = require("../../../../client/components/static-generation-async-storage.external");
|
|
const _actionasyncstorageexternal = require("../../../../client/components/action-async-storage.external");
|
|
const _sharedmodules = /*#__PURE__*/ _interop_require_wildcard(require("./shared-modules"));
|
|
function _getRequireWildcardCache(nodeInterop) {
|
|
if (typeof WeakMap !== "function") return null;
|
|
var cacheBabelInterop = new WeakMap();
|
|
var cacheNodeInterop = new WeakMap();
|
|
return (_getRequireWildcardCache = function(nodeInterop) {
|
|
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
|
})(nodeInterop);
|
|
}
|
|
function _interop_require_wildcard(obj, nodeInterop) {
|
|
if (!nodeInterop && obj && obj.__esModule) {
|
|
return obj;
|
|
}
|
|
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
|
return {
|
|
default: obj
|
|
};
|
|
}
|
|
var cache = _getRequireWildcardCache(nodeInterop);
|
|
if (cache && cache.has(obj)) {
|
|
return cache.get(obj);
|
|
}
|
|
var newObj = {};
|
|
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for(var key in obj){
|
|
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
|
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
|
if (desc && (desc.get || desc.set)) {
|
|
Object.defineProperty(newObj, key, desc);
|
|
} else {
|
|
newObj[key] = obj[key];
|
|
}
|
|
}
|
|
}
|
|
newObj.default = obj;
|
|
if (cache) {
|
|
cache.set(obj, newObj);
|
|
}
|
|
return newObj;
|
|
}
|
|
class AppRouteRouteModule extends _routemodule.RouteModule {
|
|
static #_ = this.sharedModules = _sharedmodules;
|
|
static is(route) {
|
|
return route.definition.kind === _routekind.RouteKind.APP_ROUTE;
|
|
}
|
|
constructor({ userland, definition, resolvedPagePath, nextConfigOutput }){
|
|
super({
|
|
userland,
|
|
definition
|
|
});
|
|
/**
|
|
* A reference to the request async storage.
|
|
*/ this.requestAsyncStorage = _requestasyncstorageexternal.requestAsyncStorage;
|
|
/**
|
|
* A reference to the static generation async storage.
|
|
*/ this.staticGenerationAsyncStorage = _staticgenerationasyncstorageexternal.staticGenerationAsyncStorage;
|
|
/**
|
|
* An interface to call server hooks which interact with the underlying
|
|
* storage.
|
|
*/ this.serverHooks = _hooksservercontext;
|
|
/**
|
|
* An interface to call header hooks which interact with the underlying
|
|
* request storage.
|
|
*/ this.headerHooks = _headers;
|
|
/**
|
|
* An interface to call static generation bailout hooks which interact with
|
|
* the underlying static generation storage.
|
|
*/ this.staticGenerationBailout = _staticgenerationbailout.staticGenerationBailout;
|
|
/**
|
|
* A reference to the mutation related async storage, such as mutations of
|
|
* cookies.
|
|
*/ this.actionAsyncStorage = _actionasyncstorageexternal.actionAsyncStorage;
|
|
this.resolvedPagePath = resolvedPagePath;
|
|
this.nextConfigOutput = nextConfigOutput;
|
|
// Automatically implement some methods if they aren't implemented by the
|
|
// userland module.
|
|
this.methods = (0, _autoimplementmethods.autoImplementMethods)(userland);
|
|
// Get the non-static methods for this route.
|
|
this.nonStaticMethods = (0, _getnonstaticmethods.getNonStaticMethods)(userland);
|
|
// Get the dynamic property from the userland module.
|
|
this.dynamic = this.userland.dynamic;
|
|
if (this.nextConfigOutput === "export") {
|
|
if (!this.dynamic || this.dynamic === "auto") {
|
|
this.dynamic = "error";
|
|
} else if (this.dynamic === "force-dynamic") {
|
|
throw new Error(`export const dynamic = "force-dynamic" on page "${definition.pathname}" cannot be used with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export`);
|
|
}
|
|
}
|
|
// We only warn in development after here, so return if we're not in
|
|
// development.
|
|
if (process.env.NODE_ENV === "development") {
|
|
// Print error in development if the exported handlers are in lowercase, only
|
|
// uppercase handlers are supported.
|
|
const lowercased = _http.HTTP_METHODS.map((method)=>method.toLowerCase());
|
|
for (const method of lowercased){
|
|
if (method in this.userland) {
|
|
_log.error(`Detected lowercase method '${method}' in '${this.resolvedPagePath}'. Export the uppercase '${method.toUpperCase()}' method name to fix this error.`);
|
|
}
|
|
}
|
|
// Print error if the module exports a default handler, they must use named
|
|
// exports for each HTTP method.
|
|
if ("default" in this.userland) {
|
|
_log.error(`Detected default export in '${this.resolvedPagePath}'. Export a named export for each HTTP method instead.`);
|
|
}
|
|
// If there is no methods exported by this module, then return a not found
|
|
// response.
|
|
if (!_http.HTTP_METHODS.some((method)=>method in this.userland)) {
|
|
_log.error(`No HTTP methods exported in '${this.resolvedPagePath}'. Export a named export for each HTTP method.`);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Resolves the handler function for the given method.
|
|
*
|
|
* @param method the requested method
|
|
* @returns the handler function for the given method
|
|
*/ resolve(method) {
|
|
// Ensure that the requested method is a valid method (to prevent RCE's).
|
|
if (!(0, _http.isHTTPMethod)(method)) return _responsehandlers.handleBadRequestResponse;
|
|
// Return the handler.
|
|
return this.methods[method];
|
|
}
|
|
/**
|
|
* Executes the route handler.
|
|
*/ async execute(request, context) {
|
|
// Get the handler function for the given method.
|
|
const handler = this.resolve(request.method);
|
|
// Get the context for the request.
|
|
const requestContext = {
|
|
req: request
|
|
};
|
|
requestContext.renderOpts = {
|
|
previewProps: context.prerenderManifest.preview
|
|
};
|
|
// Get the context for the static generation.
|
|
const staticGenerationContext = {
|
|
urlPathname: request.nextUrl.pathname,
|
|
renderOpts: context.renderOpts
|
|
};
|
|
// Add the fetchCache option to the renderOpts.
|
|
staticGenerationContext.renderOpts.fetchCache = this.userland.fetchCache;
|
|
// Run the handler with the request AsyncLocalStorage to inject the helper
|
|
// support. We set this to `unknown` because the type is not known until
|
|
// runtime when we do a instanceof check below.
|
|
const response = await this.actionAsyncStorage.run({
|
|
isAppRoute: true
|
|
}, ()=>_requestasyncstoragewrapper.RequestAsyncStorageWrapper.wrap(this.requestAsyncStorage, requestContext, ()=>_staticgenerationasyncstoragewrapper.StaticGenerationAsyncStorageWrapper.wrap(this.staticGenerationAsyncStorage, staticGenerationContext, (staticGenerationStore)=>{
|
|
var _getTracer_getRootSpanAttributes;
|
|
// Check to see if we should bail out of static generation based on
|
|
// having non-static methods.
|
|
if (this.nonStaticMethods) {
|
|
this.staticGenerationBailout(`non-static methods used ${this.nonStaticMethods.join(", ")}`);
|
|
}
|
|
// Update the static generation store based on the dynamic property.
|
|
switch(this.dynamic){
|
|
case "force-dynamic":
|
|
// The dynamic property is set to force-dynamic, so we should
|
|
// force the page to be dynamic.
|
|
staticGenerationStore.forceDynamic = true;
|
|
this.staticGenerationBailout(`force-dynamic`, {
|
|
dynamic: this.dynamic
|
|
});
|
|
break;
|
|
case "force-static":
|
|
// The dynamic property is set to force-static, so we should
|
|
// force the page to be static.
|
|
staticGenerationStore.forceStatic = true;
|
|
break;
|
|
case "error":
|
|
// The dynamic property is set to error, so we should throw an
|
|
// error if the page is being statically generated.
|
|
staticGenerationStore.dynamicShouldError = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
// If the static generation store does not have a revalidate value
|
|
// set, then we should set it the revalidate value from the userland
|
|
// module or default to false.
|
|
staticGenerationStore.revalidate ??= this.userland.revalidate ?? false;
|
|
// Wrap the request so we can add additional functionality to cases
|
|
// that might change it's output or affect the rendering.
|
|
const wrappedRequest = (0, _proxyrequest.proxyRequest)(request, {
|
|
dynamic: this.dynamic
|
|
}, {
|
|
headerHooks: this.headerHooks,
|
|
serverHooks: this.serverHooks,
|
|
staticGenerationBailout: this.staticGenerationBailout
|
|
});
|
|
// TODO: propagate this pathname from route matcher
|
|
const route = (0, _getpathnamefromabsolutepath.getPathnameFromAbsolutePath)(this.resolvedPagePath);
|
|
(_getTracer_getRootSpanAttributes = (0, _tracer.getTracer)().getRootSpanAttributes()) == null ? void 0 : _getTracer_getRootSpanAttributes.set("next.route", route);
|
|
return (0, _tracer.getTracer)().trace(_constants.AppRouteRouteHandlersSpan.runHandler, {
|
|
spanName: `executing api route (app) ${route}`,
|
|
attributes: {
|
|
"next.route": route
|
|
}
|
|
}, async ()=>{
|
|
var _staticGenerationStore_tags;
|
|
// Patch the global fetch.
|
|
(0, _patchfetch.patchFetch)({
|
|
serverHooks: this.serverHooks,
|
|
staticGenerationAsyncStorage: this.staticGenerationAsyncStorage
|
|
});
|
|
const res = await handler(wrappedRequest, {
|
|
params: context.params ? (0, _parsedurlquerytoparams.parsedUrlQueryToParams)(context.params) : undefined
|
|
});
|
|
if (!(res instanceof Response)) {
|
|
throw new Error(`No response is returned from route handler '${this.resolvedPagePath}'. Ensure you return a \`Response\` or a \`NextResponse\` in all branches of your handler.`);
|
|
}
|
|
context.renderOpts.fetchMetrics = staticGenerationStore.fetchMetrics;
|
|
context.renderOpts.waitUntil = Promise.all(staticGenerationStore.pendingRevalidates || []);
|
|
(0, _patchfetch.addImplicitTags)(staticGenerationStore);
|
|
context.renderOpts.fetchTags = (_staticGenerationStore_tags = staticGenerationStore.tags) == null ? void 0 : _staticGenerationStore_tags.join(",");
|
|
// It's possible cookies were set in the handler, so we need
|
|
// to merge the modified cookies and the returned response
|
|
// here.
|
|
const requestStore = this.requestAsyncStorage.getStore();
|
|
if (requestStore && requestStore.mutableCookies) {
|
|
const headers = new Headers(res.headers);
|
|
if ((0, _requestcookies.appendMutableCookies)(headers, requestStore.mutableCookies)) {
|
|
return new Response(res.body, {
|
|
status: res.status,
|
|
statusText: res.statusText,
|
|
headers
|
|
});
|
|
}
|
|
}
|
|
return res;
|
|
});
|
|
})));
|
|
// If the handler did't return a valid response, then return the internal
|
|
// error response.
|
|
if (!(response instanceof Response)) {
|
|
// TODO: validate the correct handling behavior, maybe log something?
|
|
return (0, _responsehandlers.handleInternalServerErrorResponse)();
|
|
}
|
|
if (response.headers.has("x-middleware-rewrite")) {
|
|
// TODO: move this error into the `NextResponse.rewrite()` function.
|
|
// TODO-APP: re-enable support below when we can proxy these type of requests
|
|
throw new Error("NextResponse.rewrite() was used in a app route handler, this is not currently supported. Please remove the invocation to continue.");
|
|
// // This is a rewrite created via `NextResponse.rewrite()`. We need to send
|
|
// // the response up so it can be handled by the backing server.
|
|
// // If the server is running in minimal mode, we just want to forward the
|
|
// // response (including the rewrite headers) upstream so it can perform the
|
|
// // redirect for us, otherwise return with the special condition so this
|
|
// // server can perform a rewrite.
|
|
// if (!minimalMode) {
|
|
// return { response, condition: 'rewrite' }
|
|
// }
|
|
// // Relativize the url so it's relative to the base url. This is so the
|
|
// // outgoing headers upstream can be relative.
|
|
// const rewritePath = response.headers.get('x-middleware-rewrite')!
|
|
// const initUrl = getRequestMeta(req, '__NEXT_INIT_URL')!
|
|
// const { pathname } = parseUrl(relativizeURL(rewritePath, initUrl))
|
|
// response.headers.set('x-middleware-rewrite', pathname)
|
|
}
|
|
if (response.headers.get("x-middleware-next") === "1") {
|
|
// TODO: move this error into the `NextResponse.next()` function.
|
|
throw new Error("NextResponse.next() was used in a app route handler, this is not supported. See here for more info: https://nextjs.org/docs/messages/next-response-next-in-app-route-handler");
|
|
}
|
|
return response;
|
|
}
|
|
async handle(request, context) {
|
|
try {
|
|
// Execute the route to get the response.
|
|
const response = await this.execute(request, context);
|
|
// The response was handled, return it.
|
|
return response;
|
|
} catch (err) {
|
|
// Try to resolve the error to a response, else throw it again.
|
|
const response = (0, _resolvehandlererror.resolveHandlerError)(err);
|
|
if (!response) throw err;
|
|
// The response was resolved, return it.
|
|
return response;
|
|
}
|
|
}
|
|
}
|
|
const _default = AppRouteRouteModule;
|
|
|
|
//# sourceMappingURL=module.js.map
|