@opennextjs/aws 3.2.1 → 3.2.2

package/README.md

@@ -36,7 +36,7 @@ OpenNext aims to support all Next.js 14 features. Some features are work in prog
 - [x] Image optimization
 - [x] [NextAuth.js](https://next-auth.js.org)
 - [x] Running at edge
-- [x] [Almost no coldstart (*)](#coldstart)
+- [x] [Almost no coldstart (\*)](#coldstart)
 
 ## Who is using OpenNext?
 
@@ -56,6 +56,20 @@ This will output A LOT of additional logs to the console. This also disable mini
 
 You can read more about the configuration in the [docs](https://opennext.js.org/aws/config)
 
+## Preleases
+
+Besides the standard npm releases we also automatically publish prerelease packages on branch pushes (using [`pkg.pr.new`](https://github.com/stackblitz-labs/pkg.pr.new)):
+
+- `https://pkg.pr.new/@opennextjs/aws@main`:
+  Updated with every push to the `main` branch, this prerelease contains the most up to date yet (reasonably) stable version of the package.
+- `https://pkg.pr.new/@opennextjs/aws@experimental`
+  Updated with every push to the `experimental` branch, this prerelease contains the latest experimental version of the package (containing features that we want to test/experiment on before committing to).
+
+Which you can simply install directly with your package manager of choice, for example:
+
+```bash
+npm i https://pkg.pr.new/@opennextjs/aws@main
+```
 
 ## Contribute
 

package/dist/adapters/cache.d.ts

@@ -1,7 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { IncrementalCache } from "../overrides/incrementalCache/types.js";
-import type { TagCache } from "../overrides/tagCache/types.js";
 interface CachedFetchValue {
     kind: "FETCH";
     data: {
@@ -56,16 +52,6 @@ type IncrementalCacheContext = {
     fetchIdx?: number | undefined;
     tags?: string[] | undefined;
 };
-interface CacheHandlerContext {
-    fs?: never;
-    dev?: boolean;
-    flushToDisk?: boolean;
-    serverDistDir?: string;
-    maxMemoryCacheSize?: number;
-    _appDir: boolean;
-    _requestHeaders: never;
-    fetchCacheKeyPrefix?: string;
-}
 interface CacheHandlerValue {
     lastModified?: number;
     age?: number;
@@ -73,16 +59,7 @@ interface CacheHandlerValue {
     value: IncrementalCacheValue | null;
 }
 export declare function hasCacheExtension(key: string): boolean;
-declare global {
-    var incrementalCache: IncrementalCache;
-    var tagCache: TagCache;
-    var disableDynamoDBCache: boolean;
-    var disableIncrementalCache: boolean;
-    var lastModified: Record<string, number>;
-    var isNextAfter15: boolean;
-}
 export default class S3Cache {
-    constructor(_ctx: CacheHandlerContext);
     get(key: string, options?: boolean | {
         fetchCache?: boolean;
         kindHint?: "app" | "pages" | "fetch";

package/dist/adapters/cache.js

@@ -1,5 +1,5 @@
-import { isBinaryContentType } from "./binary.js";
-import { debug, error, warn } from "./logger.js";
+import { isBinaryContentType } from "./binary";
+import { debug, error, warn } from "./logger";
 /** Beginning single backslash is intentional, to look for the dot + the extension. Do not escape it again. */
 const CACHE_EXTENSION_REGEX = /\.(cache|fetch)$/;
 export function hasCacheExtension(key) {
@@ -18,7 +18,6 @@ function isFetchCache(options) {
 }
 // We need to use globalThis client here as this class can be defined at load time in next 12 but client is not available at load time
 export default class S3Cache {
-    constructor(_ctx) { }
     async get(key, 
     // fetchCache is for next 13.5 and above, kindHint is for next 14 and above and boolean is for earlier versions
     options) {
@@ -82,7 +81,7 @@ export default class S3Cache {
                 // If some tags are stale we need to force revalidation
                 return null;
             }
-            const requestId = globalThis.__als.getStore()?.requestId ?? "";
+            const requestId = globalThis.__openNextAls.getStore()?.requestId ?? "";
             globalThis.lastModified[requestId] = _lastModified;
             if (cacheData?.type === "route") {
                 return {
@@ -97,7 +96,7 @@ export default class S3Cache {
                     },
                 };
             }
-            else if (cacheData?.type === "page" || cacheData?.type === "app") {
+            if (cacheData?.type === "page" || cacheData?.type === "app") {
                 if (globalThis.isNextAfter15 && cacheData?.type === "app") {
                     return {
                         lastModified: _lastModified,
@@ -122,7 +121,7 @@ export default class S3Cache {
                     },
                 };
             }
-            else if (cacheData?.type === "redirect") {
+            if (cacheData?.type === "redirect") {
                 return {
                     lastModified: _lastModified,
                     value: {
@@ -131,10 +130,8 @@ export default class S3Cache {
                     },
                 };
             }
-            else {
-                warn("Unknown cache type", cacheData);
-                return null;
-            }
+            warn("Unknown cache type", cacheData);
+            return null;
         }
         catch (e) {
             // We can usually ignore errors here as they are usually due to cache not being found
@@ -148,7 +145,7 @@ export default class S3Cache {
         }
         // This one might not even be necessary anymore
         // Better be safe than sorry
-        const detachedPromise = globalThis.__als
+        const detachedPromise = globalThis.__openNextAls
             .getStore()
             ?.pendingPromiseRunner.withResolvers();
         try {
@@ -158,7 +155,7 @@ export default class S3Cache {
             else {
                 switch (data.kind) {
                     case "ROUTE":
-                    case "APP_ROUTE":
+                    case "APP_ROUTE": {
                         const { body, status, headers } = data;
                         await globalThis.incrementalCache.set(key, {
                             type: "route",
@@ -171,6 +168,7 @@ export default class S3Cache {
                             },
                         }, false);
                         break;
+                    }
                     case "PAGE":
                     case "PAGES": {
                         const { html, pageData, status, headers } = data;

package/dist/adapters/config/index.js

@@ -1,4 +1,4 @@
-import path from "path";
+import path from "node:path";
 import { debug } from "../logger";
 import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, 
 // loadPublicAssets,

package/dist/adapters/config/util.js

@@ -1,5 +1,5 @@
-import fs from "fs";
-import path from "path";
+import fs from "node:fs";
+import path from "node:path";
 export function loadConfig(nextDir) {
     const filePath = path.join(nextDir, "required-server-files.json");
     const json = fs.readFileSync(filePath, "utf-8");

package/dist/adapters/dynamo-provider.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "fs";
+import { readFileSync } from "node:fs";
 import { createGenericHandler } from "../core/createGenericHandler.js";
 import { resolveTagCache } from "../core/resolve.js";
 const PHYSICAL_RESOURCE_ID = "dynamodb-cache";
@@ -11,19 +11,17 @@ async function defaultHandler(event) {
     switch (event.requestType) {
         case "delete":
             return remove();
-        case "create":
-        case "update":
         default:
             return insert(event.requestType);
     }
 }
 async function insert(requestType) {
-    const file = readFileSync(`dynamodb-cache.json`, "utf8");
+    const file = readFileSync("dynamodb-cache.json", "utf8");
     const data = JSON.parse(file);
     const parsedData = data.map((item) => ({
         tag: item.tag.S,
         path: item.path.S,
-        revalidatedAt: parseInt(item.revalidatedAt.N),
+        revalidatedAt: Number.parseInt(item.revalidatedAt.N),
     }));
     await tagCache.writeTags(parsedData);
     return {

package/dist/adapters/edge-adapter.d.ts

@@ -1,6 +1,3 @@
-declare global {
-    var isEdgeRuntime: true;
-}
 export declare const handler: (...args: any[]) => any;
 declare const _default: {
     fetch: (...args: any[]) => any;

package/dist/adapters/edge-adapter.js

@@ -1,49 +1,54 @@
+import { runWithOpenNextRequestContext } from "../utils/promise";
 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";
+globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent) => {
     globalThis.isEdgeRuntime = true;
-    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();
-    // @ts-expect-error - This is bundled
-    const handler = await import(`./middleware.mjs`);
-    const response = await handler.default({
-        headers: internalEvent.headers,
-        method: internalEvent.method || "GET",
-        nextConfig: {
-            basePath: NextConfig.basePath,
-            i18n: NextConfig.i18n,
-            trailingSlash: NextConfig.trailingSlash,
-        },
-        url,
-        body: convertBodyToReadableStream(internalEvent.method, internalEvent.body),
+    // 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();
+        // @ts-expect-error - This is bundled
+        const handler = await import("./middleware.mjs");
+        const response = await handler.default({
+            headers: internalEvent.headers,
+            method: internalEvent.method || "GET",
+            nextConfig: {
+                basePath: NextConfig.basePath,
+                i18n: NextConfig.i18n,
+                trailingSlash: NextConfig.trailingSlash,
+            },
+            url,
+            body: convertBodyToReadableStream(internalEvent.method, internalEvent.body),
+        });
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+            if (key.toLowerCase() === "set-cookie") {
+                responseHeaders[key] = responseHeaders[key]
+                    ? [...responseHeaders[key], value]
+                    : [value];
+            }
+            else {
+                responseHeaders[key] = value;
+            }
+        });
+        const body = response.body ?? emptyReadableStream();
+        return {
+            type: "core",
+            statusCode: response.status,
+            headers: responseHeaders,
+            body: body,
+            // Do we need to handle base64 encoded response?
+            isBase64Encoded: false,
+        };
     });
-    const responseHeaders = {};
-    response.headers.forEach((value, key) => {
-        if (key.toLowerCase() === "set-cookie") {
-            responseHeaders[key] = responseHeaders[key]
-                ? [...responseHeaders[key], value]
-                : [value];
-        }
-        else {
-            responseHeaders[key] = value;
-        }
-    });
-    const body = response.body ?? emptyReadableStream();
-    return {
-        type: "core",
-        statusCode: response.status,
-        headers: responseHeaders,
-        body: body,
-        // Do we need to handle base64 encoded response?
-        isBase64Encoded: false,
-    };
 };
 export const handler = await createGenericHandler({
     handler: defaultHandler,

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

@@ -46,7 +46,7 @@ export async function defaultHandler(event, streamCreator) {
         // It might be useful for cases where the user wants to use a different host than the one in the request
         // It could even allow to have multiple hosts for the image optimization by setting the HOST environment variable in the wrapper for example
         if (!process.env.HOST) {
-            const headersHost = headers["x-forwarded-host"] || headers["host"];
+            const headersHost = headers["x-forwarded-host"] || headers.host;
             process.env.HOST = headersHost;
         }
         const imageParams = validateImageParams(headers, queryString === null ? undefined : queryString);
@@ -104,7 +104,7 @@ function buildSuccessResponse(result, streamCreator, etag) {
     };
     debug("result", result);
     if (etag) {
-        headers["ETag"] = etag;
+        headers.ETag = etag;
     }
     if (streamCreator) {
         const response = new OpenNextNodeResponse(() => void 0, async () => void 0, streamCreator);
@@ -125,7 +125,7 @@ function buildFailureResponse(e, streamCreator) {
         const response = new OpenNextNodeResponse(() => void 0, async () => void 0, streamCreator);
         response.writeHead(500, {
             Vary: "Accept",
-            "Cache-Control": `public,max-age=60,immutable`,
+            "Cache-Control": "public,max-age=60,immutable",
             "Content-Type": "application/json",
         });
         response.end(e?.message || e?.toString() || "An error occurred");
@@ -137,7 +137,7 @@ function buildFailureResponse(e, streamCreator) {
         headers: {
             Vary: "Accept",
             // For failed images, allow client to retry after 1 minute.
-            "Cache-Control": `public,max-age=60,immutable`,
+            "Cache-Control": "public,max-age=60,immutable",
             "Content-Type": "application/json",
         },
         body: toReadableStream(e?.message || e?.toString() || "An error occurred"),

package/dist/adapters/logger.d.ts

@@ -1,6 +1,3 @@
-declare global {
-    var openNextDebug: boolean;
-}
 export declare function debug(...args: any[]): void;
 export declare function warn(...args: any[]): void;
 export declare function error(...args: any[]): void;

package/dist/adapters/logger.js

@@ -29,14 +29,12 @@ export function error(...args) {
             debug(...args);
             return;
         }
-        else if (error.logLevel === 1) {
+        if (error.logLevel === 1) {
             warn(...args);
             return;
         }
-        else {
-            console.error(...args);
-            return;
-        }
+        console.error(...args);
+        return;
     }
     else {
         console.error(...args);

package/dist/adapters/middleware.js

@@ -1,32 +1,56 @@
-import { debug } from "../adapters/logger";
+import { runWithOpenNextRequestContext } from "../utils/promise";
+import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
-import { resolveIncrementalCache, resolveOriginResolver, resolveQueue, resolveTagCache, } from "../core/resolve";
+import { resolveIncrementalCache, resolveOriginResolver, resolveProxyRequest, resolveQueue, resolveTagCache, } from "../core/resolve";
 import routingHandler from "../core/routingHandler";
 globalThis.internalFetch = fetch;
+globalThis.__openNextAls = new AsyncLocalStorage();
 const defaultHandler = async (internalEvent) => {
     const originResolver = await resolveOriginResolver(globalThis.openNextConfig.middleware?.originResolver);
+    const externalRequestProxy = await resolveProxyRequest(globalThis.openNextConfig.middleware?.override?.proxyExternalRequest);
     //#override includeCacheInMiddleware
     globalThis.tagCache = await resolveTagCache(globalThis.openNextConfig.middleware?.override?.tagCache);
     globalThis.queue = await resolveQueue(globalThis.openNextConfig.middleware?.override?.queue);
     globalThis.incrementalCache = await resolveIncrementalCache(globalThis.openNextConfig.middleware?.override?.incrementalCache);
     //#endOverride
-    const result = await routingHandler(internalEvent);
-    if ("internalEvent" in result) {
-        debug("Middleware intercepted event", internalEvent);
-        let origin = false;
-        if (!result.isExternalRewrite) {
-            origin = await originResolver.resolve(result.internalEvent.rawPath);
+    // 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 () => {
+        const result = await routingHandler(internalEvent);
+        if ("internalEvent" in result) {
+            debug("Middleware intercepted event", internalEvent);
+            if (!result.isExternalRewrite) {
+                const origin = await originResolver.resolve(result.internalEvent.rawPath);
+                return {
+                    type: "middleware",
+                    internalEvent: result.internalEvent,
+                    isExternalRewrite: result.isExternalRewrite,
+                    origin,
+                    isISR: result.isISR,
+                };
+            }
+            try {
+                return externalRequestProxy.proxy(result.internalEvent);
+            }
+            catch (e) {
+                error("External request failed.", e);
+                return {
+                    type: "middleware",
+                    internalEvent: {
+                        ...result.internalEvent,
+                        rawPath: "/500",
+                        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,
+                };
+            }
         }
-        return {
-            type: "middleware",
-            internalEvent: result.internalEvent,
-            isExternalRewrite: result.isExternalRewrite,
-            origin,
-            isISR: result.isISR,
-        };
-    }
-    debug("Middleware response", result);
-    return result;
+        debug("Middleware response", result);
+        return result;
+    });
 };
 export const handler = await createGenericHandler({
     handler: defaultHandler,

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

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { APIGatewayProxyEventHeaders } from "aws-lambda";
 import type { NextConfig } from "next/dist/server/config-shared";

package/dist/adapters/plugins/image-optimization/image-optimization.replacement.d.ts

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { APIGatewayProxyEventHeaders } from "aws-lambda";
 import type { NextConfig } from "next/dist/server/config-shared";

package/dist/adapters/revalidate.js

@@ -8,7 +8,7 @@ const defaultHandler = async (event) => {
     const failedRecords = [];
     for (const record of event.records) {
         const { host, url } = record;
-        debug(`Revalidating stale page`, { host, url });
+        debug("Revalidating stale page", { host, url });
         // Make a HEAD request to the page to revalidate it. This will trigger
         // the page to be re-rendered and cached in S3
         // - HEAD request is used b/c it's not necessary to make a GET request
@@ -39,7 +39,7 @@ const defaultHandler = async (event) => {
                     resolve(res);
                 });
                 req.on("error", (err) => {
-                    error(`Error revalidating page`, { host, url });
+                    error("Error revalidating page", { host, url });
                     reject(err);
                 });
                 req.end();

package/dist/adapters/server-adapter.d.ts

@@ -1,4 +1 @@
-declare global {
-    var internalFetch: typeof fetch;
-}
 export declare const handler: (...args: any[]) => any;

package/dist/adapters/server-adapter.js

@@ -8,6 +8,7 @@ import { setNodeEnv } from "./util.js";
 setNodeEnv();
 setBuildIdEnv();
 setNextjsServerWorkingDirectory();
+// Because next is messing with fetch, we have to make sure that we use an untouched version of fetch
 globalThis.internalFetch = fetch;
 /////////////
 // Handler //
@@ -17,7 +18,8 @@ export const handler = await createMainHandler();
 // Helper functions //
 //////////////////////
 function setNextjsServerWorkingDirectory() {
-    // WORKAROUND: Set `NextServer` working directory (AWS specific) — https://github.com/serverless-stack/open-next#workaround-set-nextserver-working-directory-aws-specific
+    // WORKAROUND: Set `NextServer` working directory (AWS specific)
+    // See https://opennext.js.org/aws/v2/advanced/workaround#workaround-set-nextserver-working-directory-aws-specific
     process.chdir(__dirname);
 }
 function setBuildIdEnv() {

package/dist/adapters/util.js

@@ -23,6 +23,6 @@ export function parseNumberFromEnv(envValue) {
     if (typeof envValue !== "string") {
         return envValue;
     }
-    const parsedValue = parseInt(envValue);
-    return isNaN(parsedValue) ? undefined : parsedValue;
+    const parsedValue = Number.parseInt(envValue);
+    return Number.isNaN(parsedValue) ? undefined : parsedValue;
 }

package/dist/build/bundleNextServer.d.ts

@@ -1 +1,3 @@
-export declare function bundleNextServer(outputDir: string, appPath: string): Promise<void>;
+export declare function bundleNextServer(outputDir: string, appPath: string, { debug }: {
+    debug?: boolean | undefined;
+}): Promise<void>;

package/dist/build/bundleNextServer.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
+import path from "node:path";
 import { build } from "esbuild";
-import path from "path";
 const externals = [
     // This one was causing trouble, don't know why
     "../experimental/testmode/server",
@@ -35,7 +35,7 @@ const externals = [
     // Adding it cause to add a lot of unnecessary deps
     "next/dist/compiled/next-server",
 ];
-export async function bundleNextServer(outputDir, appPath) {
+export async function bundleNextServer(outputDir, appPath, { debug = false }) {
     const require = createRequire(`${appPath}/package.json`);
     const entrypoint = require.resolve("next/dist/esm/server/next-server.js");
     await build({
@@ -46,7 +46,7 @@ export async function bundleNextServer(outputDir, appPath) {
         // packages: "external",
         format: "cjs",
         external: externals,
-        minify: true,
+        minify: !debug,
         outfile: path.join(outputDir, "next-server.runtime.prod.js"),
         sourcemap: false,
         plugins: [

package/dist/build/compileConfig.js

@@ -23,7 +23,7 @@ export async function compileOpenNextConfig(baseDir, openNextConfigPath, nodeExt
         configPath = `file://${configPath}`;
     const config = (await import(configPath)).default;
     if (!config || !config.default) {
-        logger.error(`config.default cannot be empty, it should be at least {}, see more info here: https://opennext.js.org/config#configuration-file`);
+        logger.error("config.default cannot be empty, it should be at least {}, see more info here: https://opennext.js.org/config#configuration-file");
         process.exit(1);
     }
     validateConfig(config);

package/dist/build/copyTracedFiles.js

@@ -1,6 +1,6 @@
 import url from "node:url";
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "fs";
-import path from "path";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
+import path from "node:path";
 import logger from "../logger.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 function copyPatchFile(outputDir) {
@@ -15,9 +15,7 @@ export async function copyTracedFiles(buildOutputPath, packagePath, outputDir, r
     const standaloneDir = path.join(dotNextDir, "standalone");
     const standaloneNextDir = path.join(standaloneDir, packagePath, ".next");
     const outputNextDir = path.join(outputDir, packagePath, ".next");
-    const extractFiles = (files, from = standaloneNextDir) => {
-        return files.map((f) => path.resolve(from, f));
-    };
+    const extractFiles = (files, from = standaloneNextDir) => files.map((f) => path.resolve(from, f));
     // On next 14+, we might not have to include those files
     // For next 13, we need to include them otherwise we get runtime error
     const requiredServerFiles = JSON.parse(readFileSync(path.join(dotNextDir, bundledNextServer
@@ -59,13 +57,11 @@ See the docs for more information on how to bundle edge runtime functions.
 --------------------------------------------------------------------------------
         `);
             }
-            else {
-                throw new Error(`
+            throw new Error(`
 --------------------------------------------------------------------------------
 We cannot find the route for ${pagePath}.
 File ${fullFilePath} does not exist
 --------------------------------------------------------------------------------`);
-            }
         }
         const dir = path.dirname(fullFilePath);
         extractFiles(requiredFiles.files, path.join(standaloneNextDir, dir)).forEach((f) => {
@@ -144,20 +140,15 @@ File ${fullFilePath} does not exist
             copyFileSync(from, to);
         }
     });
-    readdirSync(standaloneNextDir).forEach((f) => {
-        if (statSync(path.join(standaloneNextDir, f)).isDirectory())
-            return;
-        copyFileSync(path.join(standaloneNextDir, f), path.join(outputNextDir, f));
-    });
+    readdirSync(standaloneNextDir)
+        .filter((fileOrDir) => !statSync(path.join(standaloneNextDir, fileOrDir)).isDirectory())
+        .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")).forEach((f) => {
-        if (statSync(path.join(standaloneNextDir, "server", f)).isDirectory())
-            return;
-        if (f !== "server.js") {
-            copyFileSync(path.join(standaloneNextDir, "server", f), path.join(path.join(outputNextDir, "server"), f));
-        }
-    });
+    readdirSync(path.join(standaloneNextDir, "server"))
+        .filter((fileOrDir) => !statSync(path.join(standaloneNextDir, "server", fileOrDir)).isDirectory())
+        .filter((file) => file !== "server.js")
+        .forEach((file) => copyFileSync(path.join(standaloneNextDir, "server", file), path.join(path.join(outputNextDir, "server"), file)));
     // Copy patch file
     copyPatchFile(path.join(outputDir, packagePath));
     // TODO: Recompute all the files.
@@ -198,11 +189,9 @@ File ${fullFilePath} does not exist
                 }
             }
         });
-        staticFiles.forEach((f) => {
-            if (f.endsWith(".html")) {
-                copyStaticFile(`server/${f}`);
-            }
-        });
+        staticFiles
+            .filter((file) => file.endsWith(".html"))
+            .forEach((file) => copyStaticFile(`server/${file}`));
     }
     logger.debug("copyTracedFiles:", Date.now() - tsStart, "ms");
 }