@opennextjs/aws 3.4.1 → 3.5.0

package/dist/adapters/cache.d.ts

@@ -1,63 +1,4 @@
-interface CachedFetchValue {
-    kind: "FETCH";
-    data: {
-        headers: {
-            [k: string]: string;
-        };
-        body: string;
-        url: string;
-        status?: number;
-        tags?: string[];
-    };
-    revalidate: number;
-}
-interface CachedRedirectValue {
-    kind: "REDIRECT";
-    props: Object;
-}
-interface CachedRouteValue {
-    kind: "ROUTE" | "APP_ROUTE";
-    body: Buffer;
-    status: number;
-    headers: Record<string, undefined | string | string[]>;
-}
-interface CachedImageValue {
-    kind: "IMAGE";
-    etag: string;
-    buffer: Buffer;
-    extension: string;
-    isMiss?: boolean;
-    isStale?: boolean;
-}
-interface IncrementalCachedPageValue {
-    kind: "PAGE" | "PAGES";
-    html: string;
-    pageData: Object;
-    status?: number;
-    headers?: Record<string, undefined | string>;
-}
-interface IncrementalCachedAppPageValue {
-    kind: "APP_PAGE";
-    html: string;
-    rscData: Buffer;
-    headers?: Record<string, undefined | string | string[]>;
-    postponed?: string;
-    status?: number;
-}
-type IncrementalCacheValue = CachedRedirectValue | IncrementalCachedPageValue | IncrementalCachedAppPageValue | CachedImageValue | CachedFetchValue | CachedRouteValue;
-type IncrementalCacheContext = {
-    revalidate?: number | false | undefined;
-    fetchCache?: boolean | undefined;
-    fetchUrl?: string | undefined;
-    fetchIdx?: number | undefined;
-    tags?: string[] | undefined;
-};
-interface CacheHandlerValue {
-    lastModified?: number;
-    age?: number;
-    cacheState?: string;
-    value: IncrementalCacheValue | null;
-}
+import type { CacheHandlerValue, IncrementalCacheContext, IncrementalCacheValue } from "../types/cache";
 export default class Cache {
     get(key: string, options?: boolean | {
         fetchCache?: boolean;
@@ -70,5 +11,5 @@ export default class Cache {
     getIncrementalCache(key: string): Promise<CacheHandlerValue | null>;
     set(key: string, data?: IncrementalCacheValue, ctx?: IncrementalCacheContext): Promise<void>;
     revalidateTag(tags: string | string[]): Promise<void>;
+    private updateTagsOnSet;
 }
-export {};

package/dist/adapters/cache.js

@@ -1,3 +1,4 @@
+import { getTagsFromValue, hasBeenRevalidated } from "../utils/cache";
 import { isBinaryContentType } from "../utils/binary";
 import { debug, error, warn } from "./logger";
 function isFetchCache(options) {
@@ -28,13 +29,13 @@ export default class Cache {
     async getFetchCache(key, softTags, tags) {
         debug("get fetch cache", { key, softTags, tags });
         try {
-            const { value, lastModified } = await globalThis.incrementalCache.get(key, true);
-            const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
-            if (_lastModified === -1) {
-                // If some tags are stale we need to force revalidation
+            const cachedEntry = await globalThis.incrementalCache.get(key, true);
+            if (cachedEntry?.value === undefined)
                 return null;
-            }
-            if (value === undefined)
+            const _tags = [...(tags ?? []), ...(softTags ?? [])];
+            const _lastModified = cachedEntry.lastModified ?? Date.now();
+            const _hasBeenRevalidated = await hasBeenRevalidated(key, _tags, cachedEntry);
+            if (_hasBeenRevalidated)
                 return null;
             // For cases where we don't have tags, we need to ensure that the soft tags are not being revalidated
             // We only need to check for the path as it should already contain all the tags
@@ -44,8 +45,8 @@ export default class Cache {
                     !tag.endsWith("layout") &&
                     !tag.endsWith("page"));
                 if (path) {
-                    const pathLastModified = await globalThis.tagCache.getLastModified(path.replace("_N_T_/", ""), lastModified);
-                    if (pathLastModified === -1) {
+                    const hasPathBeenUpdated = await hasBeenRevalidated(path.replace("_N_T_/", ""), [], cachedEntry);
+                    if (hasPathBeenUpdated) {
                         // In case the path has been revalidated, we don't want to use the fetch cache
                         return null;
                     }
@@ -53,7 +54,7 @@ export default class Cache {
             }
             return {
                 lastModified: _lastModified,
-                value: value,
+                value: cachedEntry.value,
             };
         }
         catch (e) {
@@ -64,15 +65,21 @@ export default class Cache {
     }
     async getIncrementalCache(key) {
         try {
-            const { value: cacheData, lastModified } = await globalThis.incrementalCache.get(key, false);
-            const meta = cacheData?.meta;
-            const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
-            if (_lastModified === -1) {
-                // If some tags are stale we need to force revalidation
+            const cachedEntry = await globalThis.incrementalCache.get(key, false);
+            if (!cachedEntry?.value) {
+                return null;
+            }
+            const cacheData = cachedEntry.value;
+            const meta = cacheData.meta;
+            const tags = getTagsFromValue(cacheData);
+            const _lastModified = cachedEntry.lastModified ?? Date.now();
+            const _hasBeenRevalidated = await hasBeenRevalidated(key, tags, cachedEntry);
+            if (_hasBeenRevalidated)
                 return null;
+            const store = globalThis.__openNextAls.getStore();
+            if (store) {
+                store.lastModified = _lastModified;
             }
-            const requestId = globalThis.__openNextAls.getStore()?.requestId ?? "";
-            globalThis.lastModified[requestId] = _lastModified;
             if (cacheData?.type === "route") {
                 return {
                     lastModified: _lastModified,
@@ -210,27 +217,7 @@ export default class Cache {
                         break;
                 }
             }
-            // Write derivedTags to dynamodb
-            // If we use an in house version of getDerivedTags in build we should use it here instead of next's one
-            const derivedTags = data?.kind === "FETCH"
-                ? (ctx?.tags ?? data?.data?.tags ?? []) // before version 14 next.js used data?.data?.tags so we keep it for backward compatibility
-                : data?.kind === "PAGE"
-                    ? (data.headers?.["x-next-cache-tags"]?.split(",") ?? [])
-                    : [];
-            debug("derivedTags", derivedTags);
-            // Get all tags stored in dynamodb for the given key
-            // If any of the derived tags are not stored in dynamodb for the given key, write them
-            const storedTags = await globalThis.tagCache.getByPath(key);
-            const tagsToWrite = derivedTags.filter((tag) => !storedTags.includes(tag));
-            if (tagsToWrite.length > 0) {
-                await globalThis.tagCache.writeTags(tagsToWrite.map((tag) => ({
-                    path: key,
-                    tag: tag,
-                    // In case the tags are not there we just need to create them
-                    // but we don't want them to return from `getLastModified` as they are not stale
-                    revalidatedAt: 1,
-                })));
-            }
+            await this.updateTagsOnSet(key, data, ctx);
             debug("Finished setting cache");
         }
         catch (e) {
@@ -248,6 +235,26 @@ export default class Cache {
         }
         try {
             const _tags = Array.isArray(tags) ? tags : [tags];
+            if (globalThis.tagCache.mode === "nextMode") {
+                const paths = (await globalThis.tagCache.getPathsByTags?.(_tags)) ?? [];
+                await globalThis.tagCache.writeTags(_tags);
+                if (paths.length > 0) {
+                    // TODO: we should introduce a new method in cdnInvalidationHandler to invalidate paths by tags for cdn that supports it
+                    // It also means that we'll need to provide the tags used in every request to the wrapper or converter.
+                    await globalThis.cdnInvalidationHandler.invalidatePaths(paths.map((path) => ({
+                        initialPath: path,
+                        rawPath: path,
+                        resolvedRoutes: [
+                            {
+                                route: path,
+                                // TODO: ideally here we should check if it's an app router page or route
+                                type: "app",
+                            },
+                        ],
+                    })));
+                }
+                return;
+            }
             for (const tag of _tags) {
                 debug("revalidateTag", tag);
                 // Find all keys with the given tag
@@ -301,4 +308,35 @@ export default class Cache {
             error("Failed to revalidate tag", e);
         }
     }
+    // TODO: We should delete/update tags in this method
+    // This will require an update to the tag cache interface
+    async updateTagsOnSet(key, data, ctx) {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache ||
+            globalThis.tagCache.mode === "nextMode" ||
+            // Here it means it's a delete
+            !data) {
+            return;
+        }
+        // Write derivedTags to the tag cache
+        // If we use an in house version of getDerivedTags in build we should use it here instead of next's one
+        const derivedTags = data?.kind === "FETCH"
+            ? (ctx?.tags ?? data?.data?.tags ?? []) // before version 14 next.js used data?.data?.tags so we keep it for backward compatibility
+            : data?.kind === "PAGE"
+                ? (data.headers?.["x-next-cache-tags"]?.split(",") ?? [])
+                : [];
+        debug("derivedTags", derivedTags);
+        // Get all tags stored in dynamodb for the given key
+        // If any of the derived tags are not stored in dynamodb for the given key, write them
+        const storedTags = await globalThis.tagCache.getByPath(key);
+        const tagsToWrite = derivedTags.filter((tag) => !storedTags.includes(tag));
+        if (tagsToWrite.length > 0) {
+            await globalThis.tagCache.writeTags(tagsToWrite.map((tag) => ({
+                path: key,
+                tag: tag,
+                // In case the tags are not there we just need to create them
+                // but we don't want them to return from `getLastModified` as they are not stale
+                revalidatedAt: 1,
+            })));
+        }
+    }
 }

package/dist/adapters/config/index.d.ts

@@ -27,3 +27,4 @@ export declare const AppPathsManifestKeys: string[];
 export declare const MiddlewareManifest: import("../../types/next-types").MiddlewareManifest;
 export declare const AppPathsManifest: Record<string, string>;
 export declare const AppPathRoutesManifest: Record<string, string>;
+export declare const FunctionsConfigManifest: import("../../types/next-types").FunctionsConfigManifest;

package/dist/adapters/config/index.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { debug } from "../logger";
-import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "./util.js";
+import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadFunctionsConfigManifest, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "./util.js";
 export const NEXT_DIR = path.join(__dirname, ".next");
 export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");
 debug({ NEXT_DIR, OPEN_NEXT_DIR });
@@ -20,3 +20,5 @@ export const MiddlewareManifest =
 export const AppPathsManifest = /* @__PURE__ */ loadAppPathsManifest(NEXT_DIR);
 export const AppPathRoutesManifest = 
 /* @__PURE__ */ loadAppPathRoutesManifest(NEXT_DIR);
+export const FunctionsConfigManifest = 
+/* @__PURE__ */ loadFunctionsConfigManifest(NEXT_DIR);

package/dist/adapters/config/util.d.ts

@@ -1,4 +1,4 @@
-import type { MiddlewareManifest, NextConfig, PrerenderManifest } from "../../types/next-types";
+import type { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest } from "../../types/next-types";
 import type { PublicFiles } from "../../build";
 export declare function loadConfig(nextDir: string): NextConfig;
 export declare function loadBuildId(nextDir: string): string;
@@ -28,3 +28,4 @@ export declare function loadAppPathsManifest(nextDir: string): Record<string, st
 export declare function loadAppPathRoutesManifest(nextDir: string): Record<string, string>;
 export declare function loadAppPathsManifestKeys(nextDir: string): string[];
 export declare function loadMiddlewareManifest(nextDir: string): MiddlewareManifest;
+export declare function loadFunctionsConfigManifest(nextDir: string): FunctionsConfigManifest;

package/dist/adapters/config/util.js

@@ -11,7 +11,7 @@ export function loadBuildId(nextDir) {
     return fs.readFileSync(filePath, "utf-8").trim();
 }
 export function loadHtmlPages(nextDir) {
-    const filePath = path.join(nextDir, "server", "pages-manifest.json");
+    const filePath = path.join(nextDir, "server/pages-manifest.json");
     const json = fs.readFileSync(filePath, "utf-8");
     return Object.entries(JSON.parse(json))
         .filter(([_, value]) => value.endsWith(".html"))
@@ -61,7 +61,7 @@ export function loadPrerenderManifest(nextDir) {
     return JSON.parse(json);
 }
 export function loadAppPathsManifest(nextDir) {
-    const appPathsManifestPath = path.join(nextDir, "server", "app-paths-manifest.json");
+    const appPathsManifestPath = path.join(nextDir, "server/app-paths-manifest.json");
     const appPathsManifestJson = fs.existsSync(appPathsManifestPath)
         ? fs.readFileSync(appPathsManifestPath, "utf-8")
         : "{}";
@@ -88,7 +88,17 @@ export function loadAppPathsManifestKeys(nextDir) {
     });
 }
 export function loadMiddlewareManifest(nextDir) {
-    const filePath = path.join(nextDir, "server", "middleware-manifest.json");
+    const filePath = path.join(nextDir, "server/middleware-manifest.json");
     const json = fs.readFileSync(filePath, "utf-8");
     return JSON.parse(json);
 }
+export function loadFunctionsConfigManifest(nextDir) {
+    const filePath = path.join(nextDir, "server/functions-config-manifest.json");
+    try {
+        const json = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(json);
+    }
+    catch (e) {
+        return { functions: {}, version: 1 };
+    }
+}

package/dist/adapters/dynamo-provider.js

@@ -16,6 +16,14 @@ async function defaultHandler(event) {
     }
 }
 async function insert(requestType) {
+    // If it is in nextMode, we don't need to do anything
+    if (tagCache.mode === "nextMode") {
+        return {
+            type: "initializationFunction",
+            requestType,
+            resourceId: PHYSICAL_RESOURCE_ID,
+        };
+    }
     const file = readFileSync("dynamodb-cache.json", "utf8");
     const data = JSON.parse(file);
     const parsedData = data.map((item) => ({

package/dist/adapters/edge-adapter.js

@@ -3,18 +3,12 @@ import { emptyReadableStream } from "../utils/stream";
 // We import it like that so that the edge plugin can replace it
 import { NextConfig } from "../adapters/config";
 import { createGenericHandler } from "../core/createGenericHandler";
-import { convertBodyToReadableStream, convertToQueryString, } from "../core/routing/util";
+import { convertBodyToReadableStream } from "../core/routing/util";
 globalThis.__openNextAls = new AsyncLocalStorage();
-const defaultHandler = async (internalEvent) => {
+const defaultHandler = async (internalEvent, options) => {
     globalThis.isEdgeRuntime = true;
     // We run everything in the async local storage context so that it is available in edge runtime functions
-    return runWithOpenNextRequestContext({ isISRRevalidation: false }, async () => {
-        const host = internalEvent.headers.host
-            ? `https://${internalEvent.headers.host}`
-            : "http://localhost:3000";
-        const initialUrl = new URL(internalEvent.rawPath, host);
-        initialUrl.search = convertToQueryString(internalEvent.query);
-        const url = initialUrl.toString();
+    return runWithOpenNextRequestContext({ isISRRevalidation: false, waitUntil: options?.waitUntil }, async () => {
         // @ts-expect-error - This is bundled
         const handler = await import("./middleware.mjs");
         const response = await handler.default({
@@ -25,7 +19,7 @@ const defaultHandler = async (internalEvent) => {
                 i18n: NextConfig.i18n,
                 trailingSlash: NextConfig.trailingSlash,
             },
-            url,
+            url: internalEvent.url,
             body: convertBodyToReadableStream(internalEvent.method, internalEvent.body),
         });
         const responseHeaders = {};

package/dist/adapters/image-optimization-adapter.d.ts

@@ -1,3 +1,4 @@
-import type { InternalEvent, InternalResult, StreamCreator } from "../types/open-next.js";
+import type { InternalEvent, InternalResult } from "../types/open-next.js";
+import type { OpenNextHandlerOptions } from "../types/overrides.js";
 export declare const handler: (...args: any[]) => any;
-export declare function defaultHandler(event: InternalEvent, streamCreator?: StreamCreator): Promise<InternalResult>;
+export declare function defaultHandler(event: InternalEvent, options?: OpenNextHandlerOptions): Promise<InternalResult>;

package/dist/adapters/image-optimization-adapter.js

@@ -36,7 +36,7 @@ export const handler = await createGenericHandler({
     handler: defaultHandler,
     type: "imageOptimization",
 });
-export async function defaultHandler(event, streamCreator) {
+export async function defaultHandler(event, options) {
     // Images are handled via header and query param information.
     debug("handler event", event);
     const { headers, query: queryString } = event;
@@ -65,10 +65,10 @@ export async function defaultHandler(event, streamCreator) {
             };
         }
         const result = await optimizeImage(headers, imageParams, nextConfig, downloadHandler);
-        return buildSuccessResponse(result, streamCreator, etag);
+        return buildSuccessResponse(result, options?.streamCreator, etag);
     }
     catch (e) {
-        return buildFailureResponse(e, streamCreator);
+        return buildFailureResponse(e, options?.streamCreator);
     }
 }
 //////////////////////

package/dist/adapters/middleware.js

@@ -2,10 +2,11 @@ import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
 import { resolveIncrementalCache, resolveOriginResolver, resolveProxyRequest, resolveQueue, resolveTagCache, } from "../core/resolve";
-import routingHandler, { INTERNAL_HEADER_INITIAL_PATH, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
+import { constructNextUrl } from "../core/routing/util";
+import routingHandler, { INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, } from "../core/routingHandler";
 globalThis.internalFetch = fetch;
 globalThis.__openNextAls = new AsyncLocalStorage();
-const defaultHandler = async (internalEvent) => {
+const defaultHandler = async (internalEvent, options) => {
     const originResolver = await resolveOriginResolver(globalThis.openNextConfig.middleware?.originResolver);
     const externalRequestProxy = await resolveProxyRequest(globalThis.openNextConfig.middleware?.override?.proxyExternalRequest);
     //#override includeCacheInMiddleware
@@ -14,7 +15,10 @@ const defaultHandler = async (internalEvent) => {
     globalThis.incrementalCache = await resolveIncrementalCache(globalThis.openNextConfig.middleware?.override?.incrementalCache);
     //#endOverride
     // We run everything in the async local storage context so that it is available in the external middleware
-    return runWithOpenNextRequestContext({ isISRRevalidation: internalEvent.headers["x-isr"] === "1" }, async () => {
+    return runWithOpenNextRequestContext({
+        isISRRevalidation: internalEvent.headers["x-isr"] === "1",
+        waitUntil: options?.waitUntil,
+    }, async () => {
         const result = await routingHandler(internalEvent);
         if ("internalEvent" in result) {
             debug("Middleware intercepted event", internalEvent);
@@ -26,14 +30,14 @@ const defaultHandler = async (internalEvent) => {
                         ...result.internalEvent,
                         headers: {
                             ...result.internalEvent.headers,
-                            [INTERNAL_HEADER_INITIAL_PATH]: internalEvent.rawPath,
-                            [INTERNAL_HEADER_RESOLVED_ROUTES]: JSON.stringify(result.resolvedRoutes) ?? "[]",
+                            [INTERNAL_HEADER_INITIAL_URL]: internalEvent.url,
+                            [INTERNAL_HEADER_RESOLVED_ROUTES]: JSON.stringify(result.resolvedRoutes),
                         },
                     },
                     isExternalRewrite: result.isExternalRewrite,
                     origin,
                     isISR: result.isISR,
-                    initialPath: result.initialPath,
+                    initialURL: result.initialURL,
                     resolvedRoutes: result.resolvedRoutes,
                 };
             }
@@ -47,14 +51,14 @@ const defaultHandler = async (internalEvent) => {
                     internalEvent: {
                         ...result.internalEvent,
                         rawPath: "/500",
-                        url: "/500",
+                        url: constructNextUrl(result.internalEvent.url, "/500"),
                         method: "GET",
                     },
                     // On error we need to rewrite to the 500 page which is an internal rewrite
                     isExternalRewrite: false,
                     origin: false,
                     isISR: result.isISR,
-                    initialPath: result.internalEvent.rawPath,
+                    initialURL: result.internalEvent.url,
                     resolvedRoutes: [{ route: "/500", type: "page" }],
                 };
             }

package/dist/build/compileConfig.js

@@ -29,7 +29,7 @@ export async function compileOpenNextConfig(baseDir, openNextConfigPath, nodeExt
     validateConfig(config);
     // We need to check if the config uses the edge runtime at any point
     // If it does, we need to compile it with the edge runtime
-    const usesEdgeRuntime = config.middleware?.external ||
+    const usesEdgeRuntime = (config.middleware?.external && config.middleware.runtime !== "node") ||
         Object.values(config.functions || {}).some((fn) => fn.runtime === "edge");
     if (!usesEdgeRuntime) {
         logger.debug("No edge runtime found in the open-next.config.ts. Using default config.");

package/dist/build/compileTagCacheProvider.js

@@ -18,6 +18,7 @@ export async function compileTagCacheProvider(options) {
                 overrides: {
                     converter: overrides?.converter ?? "dummy",
                     wrapper: overrides?.wrapper,
+                    tagCache: options.config.initializationFunction?.tagCache,
                 },
             }),
         ],

package/dist/build/constant.d.ts

@@ -0,0 +1 @@
+export declare const MIDDLEWARE_TRACE_FILE = "server/middleware.js.nft.json";

package/dist/build/constant.js

@@ -0,0 +1,2 @@
+//TODO: Move all other manifest path here as well
+export const MIDDLEWARE_TRACE_FILE = "server/middleware.js.nft.json";

package/dist/build/copyTracedFiles.d.ts

@@ -1 +1,10 @@
-export declare function copyTracedFiles(buildOutputPath: string, packagePath: string, outputDir: string, routes: string[], bundledNextServer: boolean): Promise<void>;
+interface CopyTracedFilesOptions {
+    buildOutputPath: string;
+    packagePath: string;
+    outputDir: string;
+    routes: string[];
+    bundledNextServer: boolean;
+    skipServerFiles?: boolean;
+}
+export declare function copyTracedFiles({ buildOutputPath, packagePath, outputDir, routes, bundledNextServer, skipServerFiles, }: CopyTracedFilesOptions): Promise<void>;
+export {};

package/dist/build/copyTracedFiles.js

@@ -1,7 +1,9 @@
 import url from "node:url";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
+import { loadConfig, loadPrerenderManifest } from "../adapters/config/util.js";
 import logger from "../logger.js";
+import { MIDDLEWARE_TRACE_FILE } from "./constant.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 function copyPatchFile(outputDir) {
     const patchFile = path.join(__dirname, "patch", "patchedAsyncStorage.js");
@@ -9,11 +11,12 @@ function copyPatchFile(outputDir) {
     copyFileSync(patchFile, outputPatchFile);
 }
 // eslint-disable-next-line sonarjs/cognitive-complexity
-export async function copyTracedFiles(buildOutputPath, packagePath, outputDir, routes, bundledNextServer) {
+export async function copyTracedFiles({ buildOutputPath, packagePath, outputDir, routes, bundledNextServer, skipServerFiles, }) {
     const tsStart = Date.now();
     const dotNextDir = path.join(buildOutputPath, ".next");
     const standaloneDir = path.join(dotNextDir, "standalone");
     const standaloneNextDir = path.join(standaloneDir, packagePath, ".next");
+    const standaloneServerDir = path.join(standaloneNextDir, "server");
     const outputNextDir = path.join(outputDir, packagePath, ".next");
     const extractFiles = (files, from = standaloneNextDir) => files.map((f) => path.resolve(from, f));
     // On next 14+, we might not have to include those files
@@ -23,16 +26,18 @@ export async function copyTracedFiles(buildOutputPath, packagePath, outputDir, r
         : "next-server.js.nft.json"), "utf8"));
     const filesToCopy = new Map();
     // Files necessary by the server
-    extractFiles(requiredServerFiles.files).forEach((f) => {
-        filesToCopy.set(f, f.replace(standaloneDir, outputDir));
-    });
+    if (!skipServerFiles) {
+        extractFiles(requiredServerFiles.files).forEach((f) => {
+            filesToCopy.set(f, f.replace(standaloneDir, outputDir));
+        });
+    }
     // create directory for pages
-    if (existsSync(path.join(standaloneDir, ".next/server/pages"))) {
+    if (existsSync(path.join(standaloneServerDir, "pages"))) {
         mkdirSync(path.join(outputNextDir, "server/pages"), {
             recursive: true,
         });
     }
-    if (existsSync(path.join(standaloneDir, ".next/server/app"))) {
+    if (existsSync(path.join(standaloneServerDir, "app"))) {
         mkdirSync(path.join(outputNextDir, "server/app"), {
             recursive: true,
         });
@@ -83,6 +88,11 @@ File ${fullFilePath} does not exist
             }
         }
     };
+    if (existsSync(path.join(dotNextDir, MIDDLEWARE_TRACE_FILE))) {
+        // We still need to copy the nft.json file so that computeCopyFilesForPage doesn't throw
+        copyFileSync(path.join(dotNextDir, MIDDLEWARE_TRACE_FILE), path.join(standaloneNextDir, MIDDLEWARE_TRACE_FILE));
+        computeCopyFilesForPage("middleware");
+    }
     const hasPageDir = routes.some((route) => route.startsWith("pages/"));
     const hasAppDir = routes.some((route) => route.startsWith("app/"));
     // We need to copy all the base files like _app, _document, _error, etc
@@ -145,10 +155,10 @@ File ${fullFilePath} does not exist
         .forEach((file) => copyFileSync(path.join(standaloneNextDir, file), path.join(outputNextDir, file)));
     // We then need to copy all the files at the root of server
     mkdirSync(path.join(outputNextDir, "server"), { recursive: true });
-    readdirSync(path.join(standaloneNextDir, "server"))
-        .filter((fileOrDir) => !statSync(path.join(standaloneNextDir, "server", fileOrDir)).isDirectory())
+    readdirSync(standaloneServerDir)
+        .filter((fileOrDir) => !statSync(path.join(standaloneServerDir, fileOrDir)).isDirectory())
         .filter((file) => file !== "server.js")
-        .forEach((file) => copyFileSync(path.join(standaloneNextDir, "server", file), path.join(path.join(outputNextDir, "server"), file)));
+        .forEach((file) => copyFileSync(path.join(standaloneServerDir, file), path.join(path.join(outputNextDir, "server"), file)));
     // Copy patch file
     copyPatchFile(path.join(outputDir, packagePath));
     // TODO: Recompute all the files.
@@ -172,10 +182,10 @@ File ${fullFilePath} does not exist
     // Maybe even move this to s3 directly
     if (hasPageDir) {
         // First we get truly static files - i.e. pages without getStaticProps
-        const staticFiles = Object.values(JSON.parse(readFileSync(path.join(standaloneNextDir, "server/pages-manifest.json"), "utf8")));
+        const staticFiles = Object.values(JSON.parse(readFileSync(path.join(standaloneServerDir, "pages-manifest.json"), "utf8")));
         // Then we need to get all fallback: true dynamic routes html
-        const prerenderManifest = JSON.parse(readFileSync(path.join(standaloneNextDir, "prerender-manifest.json"), "utf8"));
-        const config = JSON.parse(readFileSync(path.join(standaloneNextDir, "required-server-files.json"), "utf8")).config;
+        const prerenderManifest = loadPrerenderManifest(standaloneNextDir);
+        const config = loadConfig(standaloneNextDir);
         const locales = config.i18n?.locales;
         Object.values(prerenderManifest.dynamicRoutes).forEach((route) => {
             if (typeof route.fallback === "string") {

package/dist/build/createAssets.d.ts

@@ -1,11 +1,13 @@
+import type { TagCacheMetaFile } from "../types/cache.js";
 import * as buildHelper from "./helper.js";
 export declare function createStaticAssets(options: buildHelper.BuildOptions): void;
 /**
  * Create the cache assets.
  *
  * @param options Build options.
- * @returns Whether tag cache is used.
+ * @returns Whether the tag cache is used, and the meta files collected.
  */
 export declare function createCacheAssets(options: buildHelper.BuildOptions): {
     useTagCache: boolean;
+    metaFiles: TagCacheMetaFile[];
 };

package/dist/build/createAssets.js

@@ -39,13 +39,13 @@ export function createStaticAssets(options) {
  * Create the cache assets.
  *
  * @param options Build options.
- * @returns Whether tag cache is used.
+ * @returns Whether the tag cache is used, and the meta files collected.
  */
 export function createCacheAssets(options) {
     logger.info("Bundling cache assets...");
     const { appBuildOutputPath, outputDir } = options;
     const packagePath = buildHelper.getPackagePath(options);
-    const buildId = buildHelper.getBuildId(appBuildOutputPath);
+    const buildId = buildHelper.getBuildId(options);
     let useTagCache = false;
     // Copy pages to cache folder
     const dotNextPath = path.join(appBuildOutputPath, ".next/standalone", packagePath);
@@ -165,5 +165,5 @@ export function createCacheAssets(options) {
     }
     // We need to remove files later because we need the metafiles for dynamodb tags cache
     buildHelper.removeFiles(outputPath, ({ relativePath }) => !relativePath.endsWith(".cache"));
-    return { useTagCache };
+    return { useTagCache, metaFiles };
 }