@netlify/plugin-nextjs 4.27.3 → 4.28.2-appdir.0

package/lib/helpers/edge.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeEdgeFunctions = exports.writeDevEdgeFunction = exports.cleanupEdgeFunctions = exports.loadMiddlewareManifest = void 0;
+exports.writeEdgeFunctions = exports.writeDevEdgeFunction = exports.cleanupEdgeFunctions = exports.loadAppPathRoutesManifest = exports.loadMiddlewareManifest = void 0;
 /* eslint-disable max-lines */
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -13,14 +13,15 @@ const fs_extra_1 = require("fs-extra");
 const outdent_1 = require("outdent");
 const config_1 = require("./config");
 const matchers_1 = require("./matchers");
-const loadMiddlewareManifest = (netlifyConfig) => {
-    const middlewarePath = (0, path_1.resolve)(netlifyConfig.build.publish, 'server', 'middleware-manifest.json');
-    if (!(0, fs_1.existsSync)(middlewarePath)) {
-        return null;
+const maybeLoadJson = (path) => {
+    if ((0, fs_1.existsSync)(path)) {
+        return (0, fs_extra_1.readJson)(path);
     }
-    return (0, fs_extra_1.readJson)(middlewarePath);
 };
+const loadMiddlewareManifest = (netlifyConfig) => maybeLoadJson((0, path_1.resolve)(netlifyConfig.build.publish, 'server', 'middleware-manifest.json'));
 exports.loadMiddlewareManifest = loadMiddlewareManifest;
+const loadAppPathRoutesManifest = (netlifyConfig) => maybeLoadJson((0, path_1.resolve)(netlifyConfig.build.publish, 'app-path-routes-manifest.json'));
+exports.loadAppPathRoutesManifest = loadAppPathRoutesManifest;
 /**
  * Convert the Next middleware name into a valid Edge Function name
  */
@@ -29,13 +30,33 @@ const sanitizeName = (name) => `next_${name.replace(/\W/g, '_')}`;
  * Initialization added to the top of the edge function bundle
  */
 const preamble = /* js */ `
-
-globalThis.process = { env: {...Deno.env.toObject(), NEXT_RUNTIME: 'edge', 'NEXT_PRIVATE_MINIMAL_MODE': '1' } }
-let _ENTRIES = {}
+import {
+  decode as _base64Decode,
+} from "https://deno.land/std@0.159.0/encoding/base64.ts";
 // Deno defines "window", but naughty libraries think this means it's a browser
 delete globalThis.window
+globalThis.process = { env: {...Deno.env.toObject(), NEXT_RUNTIME: 'edge', 'NEXT_PRIVATE_MINIMAL_MODE': '1' } }
 // Next uses "self" as a function-scoped global-like object
 const self = {}
+let _ENTRIES = {}
+
+//  Next uses blob: urls to refer to local assets, so we need to intercept these
+const _fetch = globalThis.fetch
+const fetch = async (url, init) => {
+  try {
+    if (typeof url === 'object' && url.href?.startsWith('blob:')) {
+      const key = url.href.slice(5)
+      if (key in _ASSETS) {
+        return new Response(_base64Decode(_ASSETS[key]))
+      }
+    }
+    return await _fetch(url, init)
+  } catch (error) {
+    console.error(error)
+    throw error
+  }
+}
+
 `;
 // Slightly different spacing in different versions!
 const IMPORT_UNSUPPORTED = [
@@ -48,6 +69,19 @@ const IMPORT_UNSUPPORTED = [
 const getMiddlewareBundle = async ({ edgeFunctionDefinition, netlifyConfig, }) => {
     const { publish } = netlifyConfig.build;
     const chunks = [preamble];
+    if ('wasm' in edgeFunctionDefinition) {
+        for (const { name, filePath } of edgeFunctionDefinition.wasm) {
+            const wasm = await fs_1.promises.readFile((0, path_1.join)(publish, filePath));
+            chunks.push(`const ${name} = _base64Decode(${JSON.stringify(wasm.toString('base64'))}).buffer`);
+        }
+    }
+    if ('assets' in edgeFunctionDefinition) {
+        chunks.push(`const _ASSETS = {}`);
+        for (const { name, filePath } of edgeFunctionDefinition.assets) {
+            const wasm = await fs_1.promises.readFile((0, path_1.join)(publish, filePath));
+            chunks.push(`_ASSETS[${JSON.stringify(name)}] = ${JSON.stringify(wasm.toString('base64'))}`);
+        }
+    }
     for (const file of edgeFunctionDefinition.files) {
         const filePath = (0, path_1.join)(publish, file);
         let data = await fs_1.promises.readFile(filePath, 'utf8');
@@ -62,7 +96,7 @@ const getMiddlewareBundle = async ({ edgeFunctionDefinition, netlifyConfig, }) =
 };
 const getEdgeTemplatePath = (file) => (0, path_1.join)(__dirname, '..', '..', 'src', 'templates', 'edge', file);
 const copyEdgeSourceFile = ({ file, target, edgeFunctionDir, }) => fs_1.promises.copyFile(getEdgeTemplatePath(file), (0, path_1.join)(edgeFunctionDir, target !== null && target !== void 0 ? target : file));
-const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, netlifyConfig, nextConfig, }) => {
+const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, netlifyConfig, pageRegexMap, appPathRoutesManifest = {}, nextConfig, }) => {
     const name = sanitizeName(edgeFunctionDefinition.name);
     const edgeFunctionDir = (0, path_1.join)(edgeFunctionRoot, name);
     const bundle = await getMiddlewareBundle({
@@ -90,6 +124,14 @@ const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, net
     else {
         matchers.push(...edgeFunctionDefinition.matchers);
     }
+    // If the EF matches a page, it's an app dir page so needs a matcher too
+    // The object will be empty if appDir isn't enabled in the Next config
+    if (pageRegexMap && edgeFunctionDefinition.page in appPathRoutesManifest) {
+        const regexp = pageRegexMap.get(appPathRoutesManifest[edgeFunctionDefinition.page]);
+        if (regexp) {
+            matchers.push({ regexp });
+        }
+    }
     await (0, fs_extra_1.writeJson)((0, path_1.join)(edgeFunctionDir, 'matchers.json'), matchers);
     // We add a defintion for each matching path
     return matchers.map((matcher) => {
@@ -122,7 +164,7 @@ exports.writeDevEdgeFunction = writeDevEdgeFunction;
 /**
  * Writes Edge Functions for the Next middleware
  */
-const writeEdgeFunctions = async (netlifyConfig) => {
+const writeEdgeFunctions = async ({ netlifyConfig, routesManifest, }) => {
     const manifest = {
         functions: [],
         version: 1,
@@ -169,12 +211,20 @@ const writeEdgeFunctions = async (netlifyConfig) => {
         // Older versions of the manifest format don't have the functions field
         // No, the version field was not incremented
         if (typeof middlewareManifest.functions === 'object') {
+            // When using the app dir, we also need to check if the EF matches a page
+            const appPathRoutesManifest = await (0, exports.loadAppPathRoutesManifest)(netlifyConfig);
+            const pageRegexMap = new Map([...(routesManifest.dynamicRoutes || []), ...(routesManifest.staticRoutes || [])].map((route) => [
+                route.page,
+                route.regex,
+            ]));
             for (const edgeFunctionDefinition of Object.values(middlewareManifest.functions)) {
                 usesEdge = true;
                 const functionDefinitions = await writeEdgeFunction({
                     edgeFunctionDefinition,
                     edgeFunctionRoot,
                     netlifyConfig,
+                    pageRegexMap,
+                    appPathRoutesManifest,
                     nextConfig,
                 });
                 manifest.functions.push(...functionDefinitions);

package/lib/helpers/files.js

@@ -70,7 +70,6 @@ exports.getMiddleware = getMiddleware;
 const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
     console.log('Moving static page files to serve from CDN...');
     const outputDir = (0, pathe_1.join)(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless');
-    const root = (0, pathe_1.join)(outputDir, 'pages');
     const buildId = (0, fs_extra_1.readFileSync)((0, pathe_1.join)(netlifyConfig.build.publish, 'BUILD_ID'), 'utf8').trim();
     const dataDir = (0, pathe_1.join)('_next', 'data', buildId);
     await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(netlifyConfig.build.publish, dataDir));
@@ -92,14 +91,17 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
             }
         }
     });
-    const files = [];
+    let fileCount = 0;
     const filesManifest = {};
     const moveFile = async (file) => {
+        // Strip the initial 'app' or 'pages' directory from the output path
+        const pathname = file.split('/').slice(1).join('/');
+        // .rsc data files go next to the html file
         const isData = file.endsWith('.json');
-        const source = (0, pathe_1.join)(root, file);
-        const targetFile = isData ? (0, pathe_1.join)(dataDir, file) : file;
+        const source = (0, pathe_1.join)(outputDir, file);
+        const targetFile = isData ? (0, pathe_1.join)(dataDir, pathname) : pathname;
         const targetPath = basePath ? (0, pathe_1.join)(basePath, targetFile) : targetFile;
-        files.push(file);
+        fileCount += 1;
         filesManifest[file] = targetPath;
         const dest = (0, pathe_1.join)(netlifyConfig.build.publish, targetPath);
         try {
@@ -110,8 +112,8 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
         }
     };
     // Move all static files, except error documents and nft manifests
-    const pages = await (0, globby_1.default)(['**/*.{html,json}', '!**/(500|404|*.js.nft).{html,json}'], {
-        cwd: root,
+    const pages = await (0, globby_1.default)(['{app,pages}/**/*.{html,json,rsc}', '!**/(500|404|*.js.nft).{html,json}'], {
+        cwd: outputDir,
         dot: true,
     });
     const matchingMiddleware = new Set();
@@ -149,7 +151,7 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
         return limit(moveFile, filePath);
     });
     await Promise.all(promises);
-    console.log(`Moved ${files.length} files`);
+    console.log(`Moved ${fileCount} files`);
     if (matchedPages.size !== 0) {
         console.log((0, chalk_1.yellowBright)((0, outdent_1.outdent) `
         Skipped moving ${matchedPages.size} ${matchedPages.size === 1 ? 'file because it matches' : 'files because they match'} middleware, so cannot be deployed to the CDN and will be served from the origin instead.

package/lib/helpers/functions.js

@@ -20,10 +20,13 @@ const utils_1 = require("./utils");
 const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir, apiRoutes) => {
     const publish = (0, pathe_1.resolve)(PUBLISH_DIR);
     const functionsDir = (0, pathe_1.resolve)(INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC);
-    console.log({ functionsDir });
     const functionDir = (0, pathe_1.join)(functionsDir, constants_1.HANDLER_FUNCTION_NAME);
     const publishDir = (0, pathe_1.relative)(functionDir, publish);
     for (const { route, config, compiled } of apiRoutes) {
+        // Don't write a lambda if the runtime is edge
+        if (config.runtime === 'experimental-edge') {
+            continue;
+        }
         const apiHandlerSource = await (0, getApiHandler_1.getApiHandler)({
             page: route,
             config,

package/lib/index.js

@@ -44,7 +44,7 @@ const plugin = {
         }
         const { publish } = netlifyConfig.build;
         (0, verification_1.checkNextSiteHasBuilt)({ publish, failBuild });
-        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir, experimental } = await (0, config_1.getNextConfig)({
+        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir, experimental, routesManifest } = await (0, config_1.getNextConfig)({
             publish,
             failBuild,
         });
@@ -82,7 +82,9 @@ const plugin = {
                 await (0, config_1.updateRequiredServerFiles)(publish, config);
             }
             else {
-                const nextAuthUrl = `${process.env.DEPLOY_PRIME_URL}${basePath}`;
+                // Using the deploy prime url in production leads to issues because the unique deploy ID is part of the generated URL
+                // and will not match the expected URL in the callback URL of an OAuth application.
+                const nextAuthUrl = `${process.env.CONTEXT === 'production' ? process.env.URL : process.env.DEPLOY_PRIME_URL}${basePath}`;
                 console.log(`NextAuth package detected, setting NEXTAUTH_URL environment variable to ${nextAuthUrl}`);
                 config.config.env.NEXTAUTH_URL = nextAuthUrl;
                 await (0, config_1.updateRequiredServerFiles)(publish, config);
@@ -116,7 +118,7 @@ const plugin = {
             buildId,
             apiRoutes,
         });
-        await (0, edge_1.writeEdgeFunctions)(netlifyConfig);
+        await (0, edge_1.writeEdgeFunctions)({ netlifyConfig, routesManifest });
     },
     async onPostBuild({ netlifyConfig: { build: { publish }, redirects, headers, }, utils: { status, cache, functions, build: { failBuild }, }, constants: { FUNCTIONS_DIST }, }) {
         await (0, cache_1.saveCache)({ cache, publish });

package/lib/templates/getApiHandler.js

@@ -107,7 +107,7 @@ const getApiHandler = ({ page, config, publishDir = '../../../.next', appDir = '
   const { config }  = require("${publishDir}/required-server-files.json")
   let staticManifest
   const path = require("path");
-  const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", "serverless", "pages"));
+  const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", "server"));
   const handler = (${makeHandler.toString()})(config, "${appDir}", pageRoot, ${JSON.stringify(page)})
   exports.handler = ${config.type === "experimental-scheduled" /* ApiRouteType.SCHEDULED */ ? `schedule(${JSON.stringify(config.schedule)}, handler);` : 'handler'}
 `;

package/lib/templates/getHandler.js

@@ -15,6 +15,7 @@ const { augmentFsModule, getMaxAge, getMultiValueHeaders, getNextServer } = requ
 // eslint-disable-next-line max-params
 const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') => {
     var _a;
+    console.log('makeHandler', process.env);
     // Change working directory into the site root, unless using Nx, which moves the
     // dist directory and handles this itself
     const dir = path.resolve(__dirname, app);
@@ -37,9 +38,7 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
     for (const [key, value] of Object.entries(conf.env)) {
         process.env[key] = String(value);
     }
-    // Set during the request as it needs the host header. Hoisted so we can define the function once
-    let base;
-    augmentFsModule({ promises, staticManifest, pageRoot, getBase: () => base });
+    augmentFsModule({ promises, staticManifest, pageRoot });
     // We memoize this because it can be shared between requests, but don't instantiate it until
     // the first request because we need the host and port.
     let bridge;
@@ -49,9 +48,6 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
         }
         const url = new URL(event.rawUrl);
         const port = Number.parseInt(url.port) || 80;
-        const { host } = event.headers;
-        const protocol = event.headers['x-forwarded-proto'] || 'http';
-        base = `${protocol}://${host}`;
         const NextServer = getNextServer();
         const nextServer = new NextServer({
             conf,
@@ -76,6 +72,8 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
     };
     return async function handler(event, context) {
         var _a, _b, _c;
+        const baseUrl = process.env.CONTEXT === 'production' ? process.env.URL : process.env.DEPLOY_PRIME_URL;
+        console.log('Using baseUrl', baseUrl, process.env);
         let requestMode = mode;
         // Ensure that paths are encoded - but don't double-encode them
         event.path = new URL(event.rawUrl).pathname;
@@ -142,7 +140,7 @@ const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '..
     staticManifest = require("${publishDir}/static-manifest.json")
   } catch {}
   const path = require("path");
-  const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", config.target === "server" ? "server" : "serverless", "pages"));
+  const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", "server"));
   exports.handler = ${isODB
     ? `builder((${makeHandler.toString()})(config, "${appDir}", pageRoot, staticManifest, 'odb'));`
     : `(${makeHandler.toString()})(config, "${appDir}", pageRoot, staticManifest, 'ssr');`}

package/lib/templates/getPageResolver.js

@@ -5,26 +5,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSinglePageResolver = exports.getPageResolver = void 0;
 const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const globby_1 = __importDefault(require("globby"));
 const outdent_1 = require("outdent");
 const pathe_1 = require("pathe");
 const slash_1 = __importDefault(require("slash"));
-const tiny_glob_1 = __importDefault(require("tiny-glob"));
 const constants_1 = require("../constants");
 const files_1 = require("../helpers/files");
 // Generate a file full of require.resolve() calls for all the pages in the
 // build. This is used by the nft bundler to find all the pages.
 const getPageResolver = async ({ publish, target }) => {
-    const functionDir = path_1.posix.resolve(path_1.posix.join('.netlify', 'functions', constants_1.HANDLER_FUNCTION_NAME));
-    const root = path_1.posix.resolve((0, slash_1.default)(publish), target === 'server' ? 'server' : 'serverless', 'pages');
-    const pages = await (0, tiny_glob_1.default)('**/*.js', {
+    const functionDir = (0, path_1.resolve)((0, path_1.join)('.netlify', 'functions', constants_1.HANDLER_FUNCTION_NAME));
+    const root = (0, path_1.resolve)((0, slash_1.default)(publish), target === 'server' ? 'server' : 'serverless');
+    const pages = await (0, globby_1.default)('{pages,app}/**/*.js.nft.json', {
         cwd: root,
         dot: true,
     });
-    const pageFiles = pages
-        .map((page) => `require.resolve('${path_1.posix.relative(functionDir, path_1.posix.join(root, (0, slash_1.default)(page)))}')`)
-        .sort();
+    const dependencies = await Promise.all(pages.map(async (page) => {
+        const dir = (0, path_1.dirname)(page);
+        const { files } = await (0, fs_extra_1.readJSON)((0, path_1.join)(root, page));
+        return files === null || files === void 0 ? void 0 : files.map((file) => (0, path_1.resolve)(root, dir, file));
+    }));
+    const deduped = [...new Set(dependencies.flat())];
+    const pageFiles = deduped.map((file) => `require.resolve('${(0, pathe_1.relative)(functionDir, file)}')`).sort();
     return (0, outdent_1.outdent) `
-    // This file is purely to allow nft to know about these pages. It should be temporary.
+    // This file is purely to allow nft to know about these pages.
     exports.resolvePages = () => {
         try {
             ${pageFiles.join('\n        ')}

package/lib/templates/handlerUtils.js

@@ -20,7 +20,12 @@ const downloadFile = async (url, destination) => {
     console.log(`Downloading ${url} to ${destination}`);
     const httpx = url.startsWith('https') ? https_1.default : http_1.default;
     await new Promise((resolve, reject) => {
-        const req = httpx.get(url, { timeout: 10000 }, (response) => {
+        const req = httpx.get(url, {
+            timeout: 10000,
+            headers: {
+                'x-nf-next-asset-req': 'true',
+            },
+        }, (response) => {
             if (response.statusCode < 200 || response.statusCode > 299) {
                 reject(new Error(`Failed to download ${url}: ${response.statusCode} ${response.statusMessage || ''}`));
                 return;
@@ -76,7 +81,7 @@ exports.getMultiValueHeaders = getMultiValueHeaders;
 /**
  * Monkey-patch the fs module to download missing files from the CDN
  */
-const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
+const augmentFsModule = ({ promises, staticManifest, pageRoot, }) => {
     // Only do this if we have some static files moved to the CDN
     if (staticManifest.length === 0) {
         return;
@@ -94,22 +99,24 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
     const statsOrig = promises.stat;
     // ...then money-patch it to see if it's requesting a CDN file
     promises.readFile = (async (file, options) => {
-        const base = getBase();
+        // In production use the public URL (e.g. https://example.com). Otherwise use the deploy URL, e.g. https://deploy-preview-123--example.netlify.app
+        const baseUrl = process.env.CONTEXT === 'production' ? process.env.URL : process.env.DEPLOY_PRIME_URL;
+        console.log('Using baseUrl', baseUrl);
         // We only care about page files
         if (file.startsWith(pageRoot)) {
-            // We only want the part after `pages/`
+            // We only want the part after `.next/server/`
             const filePath = file.slice(pageRoot.length + 1);
             // Is it in the CDN and not local?
             if (staticFiles.has(filePath) && !(0, fs_1.existsSync)(file)) {
                 // This name is safe to use, because it's one that was already created by Next
                 const cacheFile = path_1.default.join(cacheDir, filePath);
-                const url = `${base}/${staticFiles.get(filePath)}`;
+                const url = `${baseUrl}/${staticFiles.get(filePath)}`;
                 // If it's already downloading we can wait for it to finish
                 if (downloadPromises.has(url)) {
                     await downloadPromises.get(url);
                 }
                 // Have we already cached it? We download every time if running locally to avoid staleness
-                if ((!(0, fs_1.existsSync)(cacheFile) || process.env.NETLIFY_DEV) && base) {
+                if ((!(0, fs_1.existsSync)(cacheFile) || process.env.NETLIFY_DEV) && baseUrl) {
                     await promises.mkdir(path_1.default.dirname(cacheFile), { recursive: true });
                     try {
                         // Append the path to our host and we can load it like a regular page
@@ -130,7 +137,7 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
     promises.stat = ((file, options) => {
         // We only care about page files
         if (file.startsWith(pageRoot)) {
-            // We only want the part after `pages/`
+            // We only want the part after `.next/server`
             const cacheFile = path_1.default.join(cacheDir, file.slice(pageRoot.length + 1));
             if ((0, fs_1.existsSync)(cacheFile)) {
                 return statsOrig(cacheFile, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.27.3",
+  "version": "4.28.2-appdir.0",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "index.js",
   "files": [
@@ -35,12 +35,12 @@
   },
   "devDependencies": {
     "@delucis/if-env": "^1.1.2",
-    "@netlify/build": "^28.1.1",
+    "@netlify/build": "^28.1.2",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.1",
     "@types/merge-stream": "^1.1.2",
     "@types/node": "^17.0.25",
-    "next": "^12.3.0",
+    "next": "^13.0.0",
     "npm-run-all": "^4.1.5",
     "typescript": "^4.6.3"
   },

package/src/templates/edge/bundle.js

@@ -2,6 +2,6 @@
  * This placeholder is replaced with the compiled Next.js bundle at build time
  * @param {Object} props
  * @param {import("./runtime.ts").RequestData} props.request
- * @returns {Promise<import("./utils.ts").FetchEventResult>}
+ * @returns {Promise<import("../edge-shared/utils.ts").FetchEventResult>}
  */
 export default async ({ request }) => {}

package/src/templates/edge/runtime.ts

@@ -13,6 +13,12 @@ export interface FetchEventResult {
   waitUntil: Promise<any>
 }
 
+export interface I18NConfig {
+  defaultLocale: string
+  localeDetection?: false
+  locales: string[]
+}
+
 export interface RequestData {
   geo?: {
     city?: string
@@ -26,14 +32,14 @@ export interface RequestData {
   method: string
   nextConfig?: {
     basePath?: string
-    i18n?: Record<string, unknown>
+    i18n?: I18NConfig | null
     trailingSlash?: boolean
   }
   page?: {
     name?: string
     params?: { [key: string]: string }
   }
-  url: URL
+  url: string
   body?: ReadableStream<Uint8Array>
 }
 
@@ -50,10 +56,10 @@ declare global {
 globalThis.NFRequestContextMap ||= new Map()
 
 const handler = async (req: Request, context: Context) => {
-  if (Deno.env.get('NETLIFY_DEV')) {
-    // Don't run in dev
-    return
-  }
+  // if (Deno.env.get('NETLIFY_DEV')) {
+  //   // Don't run in dev
+  //   return
+  // }
 
   const url = new URL(req.url)
 
@@ -82,7 +88,7 @@ const handler = async (req: Request, context: Context) => {
   const request: RequestData = {
     headers: Object.fromEntries(req.headers.entries()),
     geo,
-    url,
+    url: req.url,
     method: req.method,
     ip: context.ip,
     body: req.body ?? undefined,

package/src/templates/edge-shared/utils.ts

@@ -83,7 +83,10 @@ export const buildResponse = async ({
       const transformed = response.dataTransforms.reduce((prev, transform) => {
         return transform(prev)
       }, props)
-      return new Response(JSON.stringify(transformed), response)
+      const body = JSON.stringify(transformed)
+      const headers = new Headers(response.headers)
+      headers.set('content-length', String(body.length))
+      return new Response(body, { ...response, headers })
     }
     // This var will hold the contents of the script tag
     let buffer = ''