@netlify/plugin-nextjs 5.0.0-beta.2 → 5.0.0-beta.4

package/edge-runtime/lib/util.test.ts

@@ -0,0 +1,39 @@
+import { assertEquals } from 'https://deno.land/std@0.175.0/testing/asserts.ts'
+import { rewriteDataPath } from './util.ts'
+
+Deno.test('rewriteDataPath', async (t) => {
+  await t.step('should rewrite a data url', async () => {
+    const dataUrl = '/_next/data/build-id/rewrite-me.json'
+    const newRoute = '/target'
+    const result = rewriteDataPath({ dataUrl, newRoute })
+    assertEquals(result, '/_next/data/build-id/target.json')
+  })
+
+  await t.step('should rewrite a data url with a base path', async () => {
+    const dataUrl = '/baseDir/_next/data/build-id/rewrite-me.json'
+    const newRoute = '/target'
+    const result = rewriteDataPath({ dataUrl, newRoute, basePath: '/baseDir' })
+    assertEquals(result, '/baseDir/_next/data/build-id/target.json')
+  })
+
+  await t.step('should rewrite from an index data url', async () => {
+    const dataUrl = '/_next/data/build-id/index.json'
+    const newRoute = '/target'
+    const result = rewriteDataPath({ dataUrl, newRoute })
+    assertEquals(result, '/_next/data/build-id/target.json')
+  })
+
+  await t.step('should rewrite to an index data url', async () => {
+    const dataUrl = '/_next/data/build-id/rewrite-me.json'
+    const newRoute = '/'
+    const result = rewriteDataPath({ dataUrl, newRoute })
+    assertEquals(result, '/_next/data/build-id/index.json')
+  })
+
+  await t.step('should rewrite to a route with a trailing slash', async () => {
+    const dataUrl = '/_next/data/build-id/rewrite-me.json'
+    const newRoute = '/target/'
+    const result = rewriteDataPath({ dataUrl, newRoute })
+    assertEquals(result, '/_next/data/build-id/target.json')
+  })
+})

package/edge-runtime/lib/util.ts

@@ -1,16 +1,63 @@
-// If the redirect is a data URL, we need to normalize it.
-// https://github.com/vercel/next.js/blob/25e0988e7c9033cb1503cbe0c62ba5de2e97849c/packages/next/src/shared/lib/router/utils/get-next-pathname-info.ts#L69-L76
-export function normalizeDataUrl(redirect: string) {
-  if (redirect.startsWith('/_next/data/') && redirect.includes('.json')) {
-    const paths = redirect
+import type { RequestData } from './next-request.ts'
+
+/**
+ * Normalize a data URL into a route path.
+ * @see https://github.com/vercel/next.js/blob/25e0988e7c9033cb1503cbe0c62ba5de2e97849c/packages/next/src/shared/lib/router/utils/get-next-pathname-info.ts#L69-L76
+ */
+export function normalizeDataUrl(urlPath: string) {
+  if (urlPath.startsWith('/_next/data/') && urlPath.includes('.json')) {
+    const paths = urlPath
       .replace(/^\/_next\/data\//, '')
       .replace(/\.json/, '')
       .split('/')
 
-    redirect = paths[1] !== 'index' ? `/${paths.slice(1).join('/')}` : '/'
+    urlPath = paths[1] !== 'index' ? `/${paths.slice(1).join('/')}` : '/'
   }
 
-  return redirect
+  return urlPath
+}
+
+export const removeBasePath = (path: string, basePath?: string) => {
+  if (basePath && path.startsWith(basePath)) {
+    return path.replace(basePath, '')
+  }
+  return path
+}
+
+// https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/i18n/normalize-locale-path.ts
+
+export interface PathLocale {
+  detectedLocale?: string
+  pathname: string
+}
+
+/**
+ * For a pathname that may include a locale from a list of locales, it
+ * removes the locale from the pathname returning it alongside with the
+ * detected locale.
+ *
+ * @param pathname A pathname that may include a locale.
+ * @param locales A list of locales.
+ * @returns The detected locale and pathname without locale
+ */
+export function normalizeLocalePath(pathname: string, locales?: string[]): PathLocale {
+  let detectedLocale: string | undefined
+  // first item will be empty string from splitting at first char
+  const pathnameParts = pathname.split('/')
+
+  ;(locales || []).some((locale) => {
+    if (pathnameParts[1] && pathnameParts[1].toLowerCase() === locale.toLowerCase()) {
+      detectedLocale = locale
+      pathnameParts.splice(1, 1)
+      pathname = pathnameParts.join('/') || '/'
+      return true
+    }
+    return false
+  })
+  return {
+    pathname,
+    detectedLocale,
+  }
 }
 
 /**
@@ -24,3 +71,28 @@ export function relativizeURL(url: string | string, base: string | URL) {
     ? relative.toString().replace(origin, '')
     : relative.toString()
 }
+
+export const normalizeIndex = (path: string) => (path === '/' ? '/index' : path)
+
+const stripTrailingSlash = (path: string) =>
+  path !== '/' && path.endsWith('/') ? path.slice(0, -1) : path
+
+/**
+ * Modify a data url to point to a new page route.
+ */
+export function rewriteDataPath({
+  dataUrl,
+  newRoute,
+  basePath,
+}: {
+  dataUrl: string
+  newRoute: string
+  basePath?: string
+}) {
+  const normalizedDataUrl = normalizeDataUrl(removeBasePath(dataUrl, basePath))
+
+  return dataUrl.replace(
+    normalizeIndex(normalizedDataUrl),
+    stripTrailingSlash(normalizeIndex(newRoute)),
+  )
+}

package/edge-runtime/middleware.ts

@@ -1,7 +1,10 @@
 import type { Context } from '@netlify/edge-functions'
 
 import matchers from './matchers.json' assert { type: 'json' }
+import nextConfig from './next.config.json' assert { type: 'json' }
 
+import { InternalHeaders } from './lib/headers.ts'
+import { logger, LogLevel } from './lib/logging.ts'
 import { buildNextRequest, RequestData } from './lib/next-request.ts'
 import { buildResponse } from './lib/response.ts'
 import { FetchEventResult } from './lib/response.ts'
@@ -29,20 +32,34 @@ export async function handleMiddleware(
   context: Context,
   nextHandler: NextHandler,
 ) {
-  const nextRequest = buildNextRequest(request, context)
+  const nextRequest = buildNextRequest(request, context, nextConfig)
   const url = new URL(request.url)
+  const reqLogger = logger
+    .withLogLevel(
+      request.headers.has(InternalHeaders.NFDebugLogging) ? LogLevel.Debug : LogLevel.Log,
+    )
+    .withFields({ url_path: url.pathname })
+    .withRequestID(request.headers.get(InternalHeaders.NFRequestID))
 
   // While we have already checked the path when mapping to the edge function,
   // Next.js supports extra rules that we need to check here too, because we
   // might be running an edge function for a path we should not. If we find
   // that's the case, short-circuit the execution.
   if (!matchesMiddleware(url.pathname, request, searchParamsToUrlQuery(url.searchParams))) {
+    reqLogger.debug('Aborting middleware due to runtime rules')
+
     return
   }
 
   try {
     const result = await nextHandler({ request: nextRequest })
-    const response = await buildResponse({ result, request: request, context })
+    const response = await buildResponse({
+      context,
+      logger: reqLogger,
+      request,
+      result,
+      requestLocale: nextRequest.detectedLocale,
+    })
 
     return response
   } catch (error) {

package/edge-runtime/next.config.json

@@ -0,0 +1 @@
+{}

package/edge-runtime/vendor/import_map.json

@@ -3,7 +3,8 @@
     "https://ghuc.cc/worker-tools/resolvable-promise/index.ts": "./raw.githubusercontent.com/worker-tools/resolvable-promise/master/index.ts",
     "https://deno.land/": "./deno.land/",
     "https://esm.sh/": "./esm.sh/",
-    "https://raw.githubusercontent.com/": "./raw.githubusercontent.com/"
+    "https://raw.githubusercontent.com/": "./raw.githubusercontent.com/",
+    "https://v1-7-0--edge-utils.netlify.app/": "./v1-7-0--edge-utils.netlify.app/"
   },
   "scopes": {
     "./esm.sh/": {

package/edge-runtime/vendor/v1-7-0--edge-utils.netlify.app/logger/logger.ts

@@ -0,0 +1,164 @@
+type Logger = (...data: unknown[]) => void;
+
+export enum LogLevel {
+  Debug = 1,
+  Log,
+  Error,
+}
+
+const serializeError = (error: Error): Record<string, unknown> => {
+  const cause = error?.cause instanceof Error
+    ? serializeError(error.cause)
+    : error.cause;
+
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack,
+  };
+};
+
+export class StructuredLogger {
+  private fields: Record<string, unknown>;
+  private logLevel: LogLevel;
+  private message: string;
+  private rawLogger?: Logger;
+  private requestID?: string;
+  __netlifyStructuredLogger: number;
+
+  constructor(
+    message?: string,
+    fields?: Record<string, unknown>,
+    requestID?: string,
+    rawLogger?: Logger,
+    logLevel?: LogLevel,
+  ) {
+    this.fields = fields ?? {};
+    this.logLevel = logLevel ?? LogLevel.Log;
+    this.message = message ?? "";
+    this.rawLogger = rawLogger;
+    this.requestID = requestID;
+
+    // Value should be equal to the major version
+    this.__netlifyStructuredLogger = 1;
+  }
+
+  debug(message: string) {
+    if (this.logLevel > LogLevel.Debug) {
+      return;
+    }
+
+    const logger = this.rawLogger ?? globalThis.console.log;
+
+    logger(
+      new StructuredLogger(
+        message,
+        this.fields,
+        this.requestID,
+        this.rawLogger,
+        this.logLevel,
+      ),
+    );
+  }
+
+  error(message: string) {
+    if (this.logLevel > LogLevel.Error) {
+      return;
+    }
+
+    const logger = this.rawLogger ?? globalThis.console.log;
+
+    logger(
+      new StructuredLogger(
+        message,
+        this.fields,
+        this.requestID,
+        this.rawLogger,
+        this.logLevel,
+      ),
+    );
+  }
+
+  log(message: string) {
+    if (this.logLevel > LogLevel.Log) {
+      return;
+    }
+
+    const logger = this.rawLogger ?? globalThis.console.log;
+
+    logger(
+      new StructuredLogger(
+        message,
+        this.fields,
+        this.requestID,
+        this.rawLogger,
+        this.logLevel,
+      ),
+    );
+  }
+
+  serialize() {
+    const log = {
+      fields: this.fields,
+      message: this.message,
+      requestID: this.requestID,
+    };
+
+    return log;
+  }
+
+  withError(error: unknown) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+
+    return this.withFields(fields);
+  }
+
+  withFields(fields: Record<string, unknown>) {
+    return new StructuredLogger(
+      this.message,
+      {
+        ...this.fields,
+        ...fields,
+      },
+      this.requestID,
+      this.rawLogger,
+      this.logLevel,
+    );
+  }
+
+  withLogLevel(logLevel: LogLevel) {
+    return new StructuredLogger(
+      this.message,
+      this.fields,
+      this.requestID,
+      this.rawLogger,
+      logLevel,
+    );
+  }
+
+  withRawLogger(logger: Logger) {
+    return new StructuredLogger(
+      this.message,
+      this.fields,
+      this.requestID,
+      logger,
+      this.logLevel,
+    );
+  }
+
+  withRequestID(requestID: string | null) {
+    if (requestID === null) {
+      return this;
+    }
+
+    return new StructuredLogger(
+      this.message,
+      this.fields,
+      requestID,
+      this.rawLogger,
+      this.logLevel,
+    );
+  }
+}
+
+export const logger = new StructuredLogger();

package/edge-runtime/vendor/v1-7-0--edge-utils.netlify.app/logger/mod.ts

@@ -0,0 +1 @@
+export * from "./logger.ts";

package/edge-runtime/vendor.ts

@@ -16,3 +16,5 @@ import 'https://deno.land/x/html_rewriter@v0.1.0-pre.17/index.ts'
 
 import 'https://esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/request.js'
 import 'https://esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/response.js'
+
+import 'https://v1-7-0--edge-utils.netlify.app/logger/mod.ts'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "5.0.0-beta.2",
+  "version": "5.0.0-beta.4",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "./dist/index.js",
   "type": "module",

package/dist/esm-chunks/chunk-R4NHZWGU.js

@@ -1,32 +0,0 @@
-
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  PLUGIN_DIR
-} from "./chunk-4AJYXTWN.js";
-
-// src/run/config.ts
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-var getRunConfig = async () => {
-  return JSON.parse(await readFile(resolve(".next/required-server-files.json"), "utf-8")).config;
-};
-var setRunConfig = (config) => {
-  config.experimental = {
-    ...config.experimental,
-    incrementalCacheHandlerPath: `${PLUGIN_DIR}/dist/run/handlers/cache.cjs`
-  };
-  process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
-};
-var getTagsManifest = async () => {
-  return JSON.parse(await readFile(resolve(".netlify/tags-manifest.json"), "utf-8"));
-};
-
-export {
-  getRunConfig,
-  setRunConfig,
-  getTagsManifest
-};

package/dist/esm-chunks/chunk-YZXA5QBC.js

@@ -1,60 +0,0 @@
-
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-
-// src/run/systemlog.ts
-var systemLogTag = "__nfSystemLog";
-var serializeError = (error) => {
-  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
-  return {
-    error: error.message,
-    error_cause: cause,
-    error_stack: error.stack
-  };
-};
-var StructuredLogger = class _StructuredLogger {
-  fields;
-  message;
-  constructor(message, fields) {
-    this.fields = fields ?? {};
-    this.message = message ?? "";
-  }
-  // TODO: add sampling
-  doLog(logger2, message) {
-    logger2(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
-  }
-  log(message) {
-    this.doLog(console.log, message);
-  }
-  info(message) {
-    this.doLog(console.info, message);
-  }
-  debug(message) {
-    this.doLog(console.debug, message);
-  }
-  warn(message) {
-    this.doLog(console.warn, message);
-  }
-  error(message) {
-    this.doLog(console.error, message);
-  }
-  withError(error) {
-    const fields = error instanceof Error ? serializeError(error) : { error };
-    return this.withFields(fields);
-  }
-  withFields(fields) {
-    return new _StructuredLogger(this.message, {
-      ...this.fields,
-      ...fields
-    });
-  }
-};
-var logger = new StructuredLogger();
-
-export {
-  StructuredLogger,
-  logger
-};