middleware simplification and unification with routing EF

Author: pieh

edge-runtime/lib/middleware.ts

@@ -1,43 +1,5 @@
-import type { Context } from '@netlify/edge-functions'
-
-import type { ElementHandlers } from '../vendor/deno.land/x/[email protected]/src/index.ts'
 import { getCookies } from '../vendor/deno.land/[email protected]/http/cookie.ts'
 
-type NextDataTransform = <T>(data: T) => T
-
-interface ResponseCookies {
-  // This is non-standard that Next.js adds.
-  // https://github.com/vercel/next.js/blob/de08f8b3d31ef45131dad97a7d0e95fa01001167/packages/next/src/compiled/@edge-runtime/cookies/index.js#L158
-  readonly _headers: Headers
-}
-
-interface MiddlewareResponse extends Response {
-  originResponse: Response
-  dataTransforms: NextDataTransform[]
-  elementHandlers: Array<[selector: string, handlers: ElementHandlers]>
-  get cookies(): ResponseCookies
-}
-
-interface MiddlewareRequest {
-  request: Request
-  context: Context
-  originalRequest: Request
-  next(): Promise<MiddlewareResponse>
-  rewrite(destination: string | URL, init?: ResponseInit): Response
-}
-
-export function isMiddlewareRequest(
-  response: Response | MiddlewareRequest,
-): response is MiddlewareRequest {
-  return 'originalRequest' in response
-}
-
-export function isMiddlewareResponse(
-  response: Response | MiddlewareResponse,
-): response is MiddlewareResponse {
-  return 'dataTransforms' in response
-}
-
 export const addMiddlewareHeaders = async (
   originResponse: Promise<Response> | Response,
   middlewareResponse: Response,

edge-runtime/lib/next-request.ts

@@ -1,132 +1,32 @@
 import type { Context } from '@netlify/edge-functions'
 
-import {
-  addBasePath,
-  addLocale,
-  addTrailingSlash,
-  normalizeDataUrl,
-  normalizeLocalePath,
-  removeBasePath,
-} from './util.ts'
+import type { RequestData } from './types'
 
-interface I18NConfig {
-  defaultLocale: string
-  localeDetection?: false
-  locales: string[]
-}
-
-export interface RequestData {
-  geo?: {
-    city?: string
-    country?: string
-    region?: string
-    latitude?: string
-    longitude?: string
-    timezone?: string
-  }
-  headers: Record<string, string>
-  ip?: string
-  method: string
-  nextConfig?: {
-    basePath?: string
-    i18n?: I18NConfig | null
-    trailingSlash?: boolean
-    skipMiddlewareUrlNormalize?: boolean
-  }
-  page?: {
-    name?: string
-    params?: { [key: string]: string }
-  }
-  url: string
-  body?: ReadableStream<Uint8Array>
-  detectedLocale?: string
-}
-
-const normalizeRequestURL = (
-  originalURL: string,
-  nextConfig?: RequestData['nextConfig'],
-): { url: string; detectedLocale?: string } => {
-  const url = new URL(originalURL)
-
-  let pathname = removeBasePath(url.pathname, nextConfig?.basePath)
-
-  // If it exists, remove the locale from the URL and store it
-  const { detectedLocale } = normalizeLocalePath(pathname, nextConfig?.i18n?.locales)
-
-  if (!nextConfig?.skipMiddlewareUrlNormalize) {
-    // We want to run middleware for data requests and expose the URL of the
-    // corresponding pages, so we have to normalize the URLs before running
-    // the handler.
-    pathname = normalizeDataUrl(pathname)
-
-    // Normalizing the trailing slash based on the `trailingSlash` configuration
-    // property from the Next.js config.
-    if (nextConfig?.trailingSlash) {
-      pathname = addTrailingSlash(pathname)
-    }
-  }
-
-  url.pathname = addBasePath(pathname, nextConfig?.basePath)
-
-  return {
-    url: url.toString(),
-    detectedLocale,
-  }
-}
-
-export const localizeRequest = (
-  url: URL,
-  nextConfig?: {
-    basePath?: string
-    i18n?: I18NConfig | null
-  },
-): { localizedUrl: URL; locale?: string } => {
-  const localizedUrl = new URL(url)
-  localizedUrl.pathname = removeBasePath(localizedUrl.pathname, nextConfig?.basePath)
-
-  // Detect the locale from the URL
-  const { detectedLocale } = normalizeLocalePath(localizedUrl.pathname, nextConfig?.i18n?.locales)
-
-  // Add the locale to the URL if not already present
-  localizedUrl.pathname = addLocale(
-    localizedUrl.pathname,
-    detectedLocale ?? nextConfig?.i18n?.defaultLocale,
-  )
-
-  localizedUrl.pathname = addBasePath(localizedUrl.pathname, nextConfig?.basePath)
-
-  return {
-    localizedUrl,
-    locale: detectedLocale,
-  }
-}
-
-export const buildNextRequest = (
-  request: Request,
-  context: Context,
-  nextConfig?: RequestData['nextConfig'],
-): RequestData => {
+export const buildNextRequest = (request: Request): RequestData => {
   const { url, method, body, headers } = request
-  const { country, subdivision, city, latitude, longitude, timezone } = context.geo
-  const geo: RequestData['geo'] = {
-    city,
-    country: country?.code,
-    region: subdivision?.code,
-    latitude: latitude?.toString(),
-    longitude: longitude?.toString(),
-    timezone,
-  }
 
-  const { detectedLocale, url: normalizedUrl } = normalizeRequestURL(url, nextConfig)
+  // we don't really use it but Next.js expects a signal
+  const abortController = new AbortController()
 
   return {
     headers: Object.fromEntries(headers.entries()),
-    geo,
-    url: normalizedUrl,
     method,
-    ip: context.ip,
+    // nextConfig?: {
+    //     basePath?: string;
+    //     i18n?: I18NConfig | null;
+    //     trailingSlash?: boolean;
+    //     experimental?: Pick<ExperimentalConfig, 'cacheLife' | 'authInterrupts' | 'clientParamParsingOrigins'>;
+    // };
+    // page?: {
+    //     name?: string;
+    //     params?: {
+    //         [key: string]: string | string[] | undefined;
+    //     };
+    // };
+    url,
     body: body ?? undefined,
-    nextConfig,
-    detectedLocale,
+    signal: abortController.signal,
+    /** passed in when running in edge runtime sandbox */
+    // waitUntil?: (promise: Promise<any>) => void;
   }
 }