@netlify/plugin-nextjs 4.41.3 → 5.0.0-beta.0

package/src/templates/edge/middleware-runtime.ts

@@ -1,62 +0,0 @@
-import type { Context } from 'https://edge.netlify.com'
-// Available at build time
-import matchers from './matchers.json' assert { type: 'json' }
-import edgeFunction from './bundle.js'
-import { buildNextRequest, buildResponse } from '../edge-shared/utils.ts'
-import { getMiddlewareRouteMatcher, MiddlewareRouteMatch, searchParamsToUrlQuery } from '../edge-shared/next-utils.ts'
-import nextConfig from '../edge-shared/nextConfig.json' assert { type: 'json' }
-
-const matchesMiddleware: MiddlewareRouteMatch = getMiddlewareRouteMatcher(matchers || [])
-
-export interface RequestContext {
-  request: Request
-  context: Context
-}
-
-declare global {
-  // deno-lint-ignore no-var
-  var NFRequestContextMap: Map<string, RequestContext>
-}
-
-globalThis.NFRequestContextMap ||= new Map()
-
-const handler = async (req: Request, context: Context) => {
-  if (Deno.env.get('NETLIFY_DEV')) {
-    // Don't run in dev
-    return
-  }
-
-  const url = new URL(req.url)
-
-  // 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.
-  if (!matchesMiddleware(url.pathname, req, searchParamsToUrlQuery(url.searchParams))) {
-    return
-  }
-
-  const requestId = req.headers.get('x-nf-request-id')
-  if (!requestId) {
-    console.error('Missing x-nf-request-id header')
-  } else {
-    globalThis.NFRequestContextMap.set(requestId, {
-      request: req,
-      context,
-    })
-  }
-
-  const request = buildNextRequest(req, context, nextConfig)
-
-  try {
-    const result = await edgeFunction({ request })
-    return buildResponse({ result, request: req, context })
-  } catch (error) {
-    console.error(error)
-    return new Response(error.message, { status: 500 })
-  } finally {
-    if (requestId) {
-      globalThis.NFRequestContextMap.delete(requestId)
-    }
-  }
-}
-
-export default handler

package/src/templates/edge/next-dev.js

@@ -1,104 +0,0 @@
-import { NextRequest } from '../vendor/esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/request.js'
-import { NextResponse } from '../vendor/esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/response.js'
-import { fromFileUrl } from '../vendor/deno.land/std@0.175.0/path/mod.ts'
-import { buildResponse, isFunction } from '../edge-shared/utils.ts'
-
-globalThis.NFRequestContextMap ||= new Map()
-globalThis.__dirname = fromFileUrl(new URL('./', import.meta.url)).slice(0, -1)
-globalThis.process ||= { env: Deno.env.toObject() }
-
-// Next.js uses this extension to the Headers API implemented by Cloudflare workerd
-if (!('getAll' in Headers.prototype)) {
-  Headers.prototype.getAll = function getAll(name) {
-    name = name.toLowerCase()
-    if (name !== 'set-cookie') {
-      throw new Error('Headers.getAll is only supported for Set-Cookie')
-    }
-    return [...this.entries()].filter(([key]) => key === name).map(([, value]) => value)
-  }
-}
-
-let idx = 0
-
-const handler = async (req, context) => {
-  if (!Deno.env.get('NETLIFY_DEV')) {
-    // Only run in dev
-    return
-  }
-
-  let middleware
-  // Dynamic imports and FS operations aren't allowed when deployed,
-  // but that's fine because this is only ever used locally.
-  // We don't want to just try importing and use that to test,
-  // because that would also throw if there's an error in the middleware,
-  // which we would want to surface not ignore.
-  try {
-    // We need to cache-bust the import because otherwise it will claim it
-    // doesn't exist if the user creates it after the server starts
-    const nextMiddleware = await import(`../../middleware.js#${++idx}`)
-
-    // The middleware file can export a named `middleware` export or a `default` export
-    middleware = isFunction(nextMiddleware.middleware)
-      ? nextMiddleware.middleware
-      : isFunction(nextMiddleware.default)
-      ? nextMiddleware.default
-      : undefined
-
-    if (!middleware) {
-      throw new Error('The middleware must export a `middleware` or a `default` function')
-    }
-  } catch (importError) {
-    if (importError.code === 'ERR_MODULE_NOT_FOUND' && importError.message.includes(`middleware.js`)) {
-      //  No middleware, so we silently return
-      return
-    }
-
-    throw importError
-  }
-
-  //  This is the format expected by Next.js along with the timezone which we support.
-  const geo = {
-    country: context.geo.country?.code,
-    region: context.geo.subdivision?.code,
-    city: context.geo.city,
-    latitude: context.geo.latitude?.toString(),
-    longitude: context.geo.longitude?.toString(),
-    timezone: context.geo.timezone,
-  }
-
-  // A default request id is fine locally
-  const requestId = req.headers.get('x-nf-request-id') || 'request-id'
-
-  globalThis.NFRequestContextMap.set(requestId, {
-    request: req,
-    context,
-  })
-
-  const request = {
-    headers: Object.fromEntries(req.headers.entries()),
-    geo,
-    method: req.method,
-    ip: context.ip,
-    body: req.body || undefined,
-  }
-
-  const nextRequest = new NextRequest(req, request)
-
-  try {
-    const response = await middleware(nextRequest)
-    return buildResponse({
-      result: { response: response || NextResponse.next(), waitUntil: Promise.resolve() },
-      request: req,
-      context,
-    })
-  } catch (error) {
-    console.error(error)
-    return new Response(error.message, { status: 500 })
-  } finally {
-    if (requestId) {
-      globalThis.NFRequestContextMap.delete(requestId)
-    }
-  }
-}
-
-export default handler

package/src/templates/edge/rsc-data.ts

@@ -1,5 +0,0 @@
-import prerenderManifest from '../edge-shared/prerender-manifest.json' assert { type: 'json' }
-import { getRscDataRouter, PrerenderManifest } from '../edge-shared/rsc-data.ts'
-
-const handler = getRscDataRouter(prerenderManifest as PrerenderManifest)
-export default handler

package/src/templates/edge/shims.js

@@ -1,77 +0,0 @@
-// @ts-check
-// deno-lint-ignore-file prefer-const no-unused-vars
-import { decode as _base64Decode } from '../vendor/deno.land/std@0.175.0/encoding/base64.ts'
-import BufferCompat from '../vendor/deno.land/std@0.175.0/node/buffer.ts'
-import EventsCompat from '../vendor/deno.land/std@0.175.0/node/events.ts'
-import AsyncHooksCompat from '../vendor/deno.land/std@0.175.0/node/async_hooks.ts'
-import AssertCompat from '../vendor/deno.land/std@0.175.0/node/assert.ts'
-import UtilCompat from '../vendor/deno.land/std@0.175.0/node/util.ts'
-
-/**
- * These are the shims, polyfills and other kludges to make Next.js work in standards-compliant runtime.
- * This file isn't imported, but is instead inlined along with other chunks into the edge bundle.
- */
-
-// Deno defines "window", but naughty libraries think this means it's a browser
-// @ts-ignore
-delete globalThis.window
-globalThis.process = {
-  env: { ...Deno.env.toObject(), NEXT_RUNTIME: 'edge', NEXT_PRIVATE_MINIMAL_MODE: '1' },
-}
-globalThis.EdgeRuntime = 'netlify-edge'
-let _ENTRIES = {}
-
-// Next.js expects this as a global
-globalThis.AsyncLocalStorage = AsyncHooksCompat.AsyncLocalStorage
-
-// Next.js uses this extension to the Headers API implemented by Cloudflare workerd
-if (!('getAll' in Headers.prototype)) {
-  // @ts-ignore
-  Headers.prototype.getAll = function getAll(name) {
-    name = name.toLowerCase()
-    if (name !== 'set-cookie') {
-      throw new Error('Headers.getAll is only supported for Set-Cookie')
-    }
-    return [...this.entries()].filter(([key]) => key === name).map(([, value]) => value)
-  }
-}
-//  Next uses blob: urls to refer to local assets, so we need to intercept these
-const _fetch = globalThis.fetch
-const fetch /* type {typeof globalThis.fetch} */ = async (url, init) => {
-  try {
-    if (url instanceof URL && 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
-  }
-}
-
-// Shim native modules that Vercel makes available
-if (typeof require === 'undefined') {
-  globalThis.require = (name) => {
-    switch (name.replace(/^node:/, '')) {
-      case 'buffer':
-        return BufferCompat
-      case 'events':
-        return EventsCompat
-      case 'async_hooks':
-        return AsyncHooksCompat
-      case 'assert':
-        return AssertCompat
-      case 'util':
-        return UtilCompat
-      default:
-        throw new ReferenceError(`Native module not found: ${name}`)
-    }
-  }
-}
-
-// Next edge runtime uses "self" as a function-scoped global-like object, but some of the older polyfills expect it to equal globalThis
-// See https://nextjs.org/docs/basic-features/supported-browsers-features#polyfills
-const self = { ...globalThis, fetch }

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

@@ -1,407 +0,0 @@
-/**
- * Various router utils ported to Deno from Next.js source
- * https://github.com/vercel/next.js/blob/7280c3ced186bb9a7ae3d7012613ef93f20b0fa9/packages/next/shared/lib/router/utils/
- * Licence: https://github.com/vercel/next.js/blob/7280c3ced186bb9a7ae3d7012613ef93f20b0fa9/license.md
- *
- * Some types have been re-implemented to be more compatible with Deno or avoid chains of dependent files
- */
-
-// Deno imports
-import type { Key } from '../vendor/deno.land/x/path_to_regexp@v6.2.1/index.ts'
-
-import { compile, pathToRegexp } from '../vendor/deno.land/x/path_to_regexp@v6.2.1/index.ts'
-import { getCookies } from '../vendor/deno.land/std@0.175.0/http/cookie.ts'
-
-// Inlined/re-implemented types
-
-export interface ParsedUrlQuery {
-  [key: string]: string | string[]
-}
-
-export interface Params {
-  // Yeah, best we get
-  // deno-lint-ignore no-explicit-any
-  [param: string]: any
-}
-
-export type RouteHas =
-  | {
-      type: 'header' | 'query' | 'cookie'
-      key: string
-      value?: string
-    }
-  | {
-      type: 'host'
-      key?: undefined
-      value: string
-    }
-
-export type Rewrite = {
-  source: string
-  destination: string
-  basePath?: false
-  locale?: false
-  has?: RouteHas[]
-  missing?: RouteHas[]
-  regex: string
-}
-
-export type Header = {
-  source: string
-  basePath?: false
-  locale?: false
-  headers: Array<{ key: string; value: string }>
-  has?: RouteHas[]
-  missing?: RouteHas[]
-  regex: string
-}
-export type Redirect = {
-  source: string
-  destination: string
-  basePath?: false
-  locale?: false
-  has?: RouteHas[]
-  missing?: RouteHas[]
-  statusCode?: number
-  permanent?: boolean
-  regex: string
-}
-
-export type DynamicRoute = {
-  page: string
-  regex: string
-  namedRegex?: string
-  routeKeys?: { [key: string]: string }
-}
-
-export type RoutesManifest = {
-  basePath: string
-  redirects: Redirect[]
-  headers: Header[]
-  rewrites: {
-    beforeFiles: Rewrite[]
-    afterFiles: Rewrite[]
-    fallback: Rewrite[]
-  }
-  dynamicRoutes: DynamicRoute[]
-}
-// escape-regexp.ts
-// regexp is based on https://github.com/sindresorhus/escape-string-regexp
-const reHasRegExp = /[|\\{}()[\]^$+*?.-]/
-const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g
-
-export function escapeStringRegexp(str: string) {
-  // see also: https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/escapeRegExp.js#L23
-  if (reHasRegExp.test(str)) {
-    return str.replace(reReplaceRegExp, '\\$&')
-  }
-  return str
-}
-
-// querystring.ts
-export function searchParamsToUrlQuery(searchParams: URLSearchParams): ParsedUrlQuery {
-  const query: ParsedUrlQuery = {}
-  searchParams.forEach((value, key) => {
-    if (typeof query[key] === 'undefined') {
-      query[key] = value
-    } else if (Array.isArray(query[key])) {
-      ;(query[key] as string[]).push(value)
-    } else {
-      query[key] = [query[key] as string, value]
-    }
-  })
-  return query
-}
-
-// parse-url.ts
-interface ParsedUrl {
-  hash: string
-  hostname?: string | null
-  href: string
-  pathname: string
-  port?: string | null
-  protocol?: string | null
-  query: ParsedUrlQuery
-  search: string
-}
-
-export function parseUrl(url: string): ParsedUrl {
-  const parsedURL = url.startsWith('/') ? new URL(url, 'http://n') : new URL(url)
-  return {
-    hash: parsedURL.hash,
-    hostname: parsedURL.hostname,
-    href: parsedURL.href,
-    pathname: parsedURL.pathname,
-    port: parsedURL.port,
-    protocol: parsedURL.protocol,
-    query: searchParamsToUrlQuery(parsedURL.searchParams),
-    search: parsedURL.search,
-  }
-}
-
-// prepare-destination.ts
-// Changed to use WHATWG Fetch Request instead of IncomingMessage
-export function matchHas(
-  req: Pick<Request, 'headers' | 'url'>,
-  query: Params,
-  has: RouteHas[] = [],
-  missing: RouteHas[] = [],
-): false | Params {
-  const params: Params = {}
-  const cookies = getCookies(req.headers)
-  const url = new URL(req.url)
-  const hasMatch = (hasItem: RouteHas) => {
-    let value: undefined | string | null
-    let key = hasItem.key
-
-    switch (hasItem.type) {
-      case 'header': {
-        key = hasItem.key.toLowerCase()
-        value = req.headers.get(key)
-        break
-      }
-      case 'cookie': {
-        value = cookies[hasItem.key]
-        break
-      }
-      case 'query': {
-        value = query[hasItem.key]
-        break
-      }
-      case 'host': {
-        value = url.hostname
-        break
-      }
-      default: {
-        break
-      }
-    }
-    if (!hasItem.value && value && key) {
-      params[getSafeParamName(key)] = value
-      return true
-    } else if (value) {
-      const matcher = new RegExp(`^${hasItem.value}$`)
-      const matches = Array.isArray(value) ? value.slice(-1)[0].match(matcher) : value.match(matcher)
-
-      if (matches) {
-        if (Array.isArray(matches)) {
-          if (matches.groups) {
-            Object.keys(matches.groups).forEach((groupKey) => {
-              params[groupKey] = matches.groups![groupKey]
-            })
-          } else if (hasItem.type === 'host' && matches[0]) {
-            params.host = matches[0]
-          }
-        }
-        return true
-      }
-    }
-    return false
-  }
-
-  const allMatch = has.every((item) => hasMatch(item)) && !missing.some((item) => hasMatch(item))
-
-  if (allMatch) {
-    return params
-  }
-  return false
-}
-
-export function compileNonPath(value: string, params: Params): string {
-  if (!value.includes(':')) {
-    return value
-  }
-
-  for (const key of Object.keys(params)) {
-    if (value.includes(`:${key}`)) {
-      value = value
-        .replace(new RegExp(`:${key}\\*`, 'g'), `:${key}--ESCAPED_PARAM_ASTERISKS`)
-        .replace(new RegExp(`:${key}\\?`, 'g'), `:${key}--ESCAPED_PARAM_QUESTION`)
-        .replace(new RegExp(`:${key}\\+`, 'g'), `:${key}--ESCAPED_PARAM_PLUS`)
-        .replace(new RegExp(`:${key}(?!\\w)`, 'g'), `--ESCAPED_PARAM_COLON${key}`)
-    }
-  }
-  value = value
-    .replace(/(:|\*|\?|\+|\(|\)|\{|\})/g, '\\$1')
-    .replace(/--ESCAPED_PARAM_PLUS/g, '+')
-    .replace(/--ESCAPED_PARAM_COLON/g, ':')
-    .replace(/--ESCAPED_PARAM_QUESTION/g, '?')
-    .replace(/--ESCAPED_PARAM_ASTERISKS/g, '*')
-  // the value needs to start with a forward-slash to be compiled
-  // correctly
-  return compile(`/${value}`, { validate: false })(params).slice(1)
-}
-
-export function prepareDestination(args: {
-  appendParamsToQuery: boolean
-  destination: string
-  params: Params
-  query: ParsedUrlQuery
-}) {
-  const query = Object.assign({}, args.query)
-  delete query.__nextLocale
-  delete query.__nextDefaultLocale
-  delete query.__nextDataReq
-
-  let escapedDestination = args.destination
-
-  for (const param of Object.keys({ ...args.params, ...query })) {
-    escapedDestination = escapeSegment(escapedDestination, param)
-  }
-
-  const parsedDestination: ParsedUrl = parseUrl(escapedDestination)
-  const destQuery = parsedDestination.query
-  const destPath = unescapeSegments(`${parsedDestination.pathname!}${parsedDestination.hash || ''}`)
-  const destHostname = unescapeSegments(parsedDestination.hostname || '')
-  const destPathParamKeys: Key[] = []
-  const destHostnameParamKeys: Key[] = []
-  pathToRegexp(destPath, destPathParamKeys)
-  pathToRegexp(destHostname, destHostnameParamKeys)
-
-  const destParams: (string | number)[] = []
-
-  destPathParamKeys.forEach((key) => destParams.push(key.name))
-  destHostnameParamKeys.forEach((key) => destParams.push(key.name))
-
-  const destPathCompiler = compile(
-    destPath,
-    // we don't validate while compiling the destination since we should
-    // have already validated before we got to this point and validating
-    // breaks compiling destinations with named pattern params from the source
-    // e.g. /something:hello(.*) -> /another/:hello is broken with validation
-    // since compile validation is meant for reversing and not for inserting
-    // params from a separate path-regex into another
-    { validate: false },
-  )
-
-  const destHostnameCompiler = compile(destHostname, { validate: false })
-
-  // update any params in query values
-  for (const [key, strOrArray] of Object.entries(destQuery)) {
-    // the value needs to start with a forward-slash to be compiled
-    // correctly
-    if (Array.isArray(strOrArray)) {
-      destQuery[key] = strOrArray.map((value) => compileNonPath(unescapeSegments(value), args.params))
-    } else {
-      destQuery[key] = compileNonPath(unescapeSegments(strOrArray), args.params)
-    }
-  }
-
-  // add path params to query if it's not a redirect and not
-  // already defined in destination query or path
-  const paramKeys = Object.keys(args.params).filter((name) => name !== 'nextInternalLocale')
-
-  if (args.appendParamsToQuery && !paramKeys.some((key) => destParams.includes(key))) {
-    for (const key of paramKeys) {
-      if (!(key in destQuery)) {
-        destQuery[key] = args.params[key]
-      }
-    }
-  }
-
-  let newUrl
-
-  try {
-    newUrl = destPathCompiler(args.params)
-
-    const [pathname, hash] = newUrl.split('#')
-    parsedDestination.hostname = destHostnameCompiler(args.params)
-    parsedDestination.pathname = pathname
-    parsedDestination.hash = `${hash ? '#' : ''}${hash || ''}`
-    delete (parsedDestination as any).search
-  } catch (err: any) {
-    if (err.message.match(/Expected .*? to not repeat, but got an array/)) {
-      throw new Error(
-        `To use a multi-match in the destination you must add \`*\` at the end of the param name to signify it should repeat. https://nextjs.org/docs/messages/invalid-multi-match`,
-      )
-    }
-    throw err
-  }
-
-  // Query merge order lowest priority to highest
-  // 1. initial URL query values
-  // 2. path segment values
-  // 3. destination specified query values
-  parsedDestination.query = {
-    ...query,
-    ...parsedDestination.query,
-  }
-
-  return {
-    newUrl,
-    destQuery,
-    parsedDestination,
-  }
-}
-
-/**
- * Ensure only a-zA-Z are used for param names for proper interpolating
- * with path-to-regexp
- */
-function getSafeParamName(paramName: string) {
-  let newParamName = ''
-
-  for (let i = 0; i < paramName.length; i++) {
-    const charCode = paramName.charCodeAt(i)
-
-    if (
-      (charCode > 64 && charCode < 91) || // A-Z
-      (charCode > 96 && charCode < 123) // a-z
-    ) {
-      newParamName += paramName[i]
-    }
-  }
-  return newParamName
-}
-
-function escapeSegment(str: string, segmentName: string) {
-  return str.replace(new RegExp(`:${escapeStringRegexp(segmentName)}`, 'g'), `__ESC_COLON_${segmentName}`)
-}
-
-function unescapeSegments(str: string) {
-  return str.replace(/__ESC_COLON_/gi, ':')
-}
-
-// is-dynamic.ts
-// Identify /[param]/ in route string
-const TEST_ROUTE = /\/\[[^/]+?\](?=\/|$)/
-
-export function isDynamicRoute(route: string): boolean {
-  return TEST_ROUTE.test(route)
-}
-
-// packages/next/shared/lib/router/utils/middleware-route-matcher.ts
-// 12.3 middleware route matcher
-
-export interface MiddlewareRouteMatch {
-  (pathname: string | null | undefined, request: Pick<Request, 'headers' | 'url'>, query: Params): boolean
-}
-
-export interface MiddlewareMatcher {
-  regexp: string
-  locale?: false
-  has?: RouteHas[]
-  missing?: RouteHas[]
-}
-
-export function getMiddlewareRouteMatcher(matchers: MiddlewareMatcher[]): MiddlewareRouteMatch {
-  return (pathname: string | null | undefined, req: Pick<Request, 'headers' | 'url'>, query: Params) => {
-    for (const matcher of matchers) {
-      const routeMatch = new RegExp(matcher.regexp).exec(pathname!)
-      if (!routeMatch) {
-        continue
-      }
-
-      if (matcher.has || matcher.missing) {
-        const hasParams = matchHas(req, query, matcher.has, matcher.missing)
-        if (!hasParams) {
-          continue
-        }
-      }
-
-      return true
-    }
-
-    return false
-  }
-}

package/src/templates/edge-shared/nextConfig.json

@@ -1,3 +0,0 @@
-{
-  "trailingSlash": true
-}

package/src/templates/edge-shared/prerender-manifest.json

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "routes": {},
-  "dynamicRoutes": {},
-  "notFoundRoutes": [],
-  "preview": {}
-}