[do not merge] exploring adapters API

.github/workflows/run-tests.yml

@@ -45,7 +45,7 @@ jobs:
           elif [ "${{ steps.check-labels.outputs.result }}" = "latest-and-canary" ]; then
             echo "matrix=[\"latest\", \"canary\"]" >> $GITHUB_OUTPUT
           else
-            echo "matrix=[\"latest\"]" >> $GITHUB_OUTPUT
+            echo "matrix=[\"canary\"]" >> $GITHUB_OUTPUT
           fi
 
   e2e:
@@ -133,6 +133,8 @@ jobs:
 
   test:
     needs: setup
+    # integration tests are completely broken in adapters branch for now, so no point in running them currently
+    if: false
     strategy:
       fail-fast: false
       matrix:

.gitignore

@@ -22,3 +22,6 @@ tests/**/package-lock.json
 tests/**/pnpm-lock.yaml
 tests/**/yarn.lock
 tests/**/out/
+
+# Local Vercel folder
+.vercel

adapters-feedback.md

@@ -0,0 +1,53 @@
+## Feedback
+
+- Files from `public` directory not listed in `outputs.staticFiles`. Should they be?
+- `routes.headers` does not contain immutable cache-control headers for `_next/static`. Should those
+  be included?
+- In `onBuildComplete` - `config.images.remotePatterns` type is `(RemotePattern | URL)[]` but in
+  reality `URL` inputs are converted to `RemotePattern` so type should be just `RemotePattern[]` in
+  `onBuildComplete` (this would require different config type for `modifyConfig` (allow inputs
+  here?) and `onBuildComplete` (final, normalized config shape)?)
+- `outputs.middleware.config.matchers` can be undefined per types - can that ever happen? Can we
+  just have empty array instead to simplify handling (possibly similar as above point where type is
+  for the input, while "output" will have a default matcher if not defined by user).
+- `outputs.middleware` does not contain `env` that exist in `middleware-manifest.json` (i.e.
+  `NEXT_SERVER_ACTIONS_ENCRYPTION_KEY`, `NEXT_PREVIEW_MODE_ID`, `NEXT_PREVIEW_MODE_SIGNING_KEY` etc)
+  or `wasm` (tho wasm files are included in assets, so I think I have a way to support those as-is,
+  but need to to make some assumption about using extension-less file name of wasm file as
+  identifier)
+- `outputs.staticFiles` (i18n enabled) custom fully static (no `getStaticProps`) `/pages/*`
+  `filePath` point to not existing file - see repro at https://github.com/pieh/i18n-adapters
+- `outputs.staticFiles` (i18n enabled) custom `/pages/*` with `getStaticProps` result in fatal
+  `Error: Invariant: failed to find source route /en(/*) for prerender /en(/*)` directly from
+  Next.js:
+
+  ```
+  ⨯ Failed to run onBuildComplete from Netlify
+
+    > Build error occurred
+    Error: Invariant: failed to find source route /en/404 for prerender /en/404
+  ```
+
+  (additionally - invariant is reported as failing to run `onBuildComplete` from adapter, but it
+  happens before adapter's `onBuildComplete` runs, would be good to clear this up a bit so users
+  could report issues in correct place in such cases. Not that important for nearest future / not
+  blocking).
+
+  See repro at https://github.com/pieh/i18n-adapters (it's same as for point above, need to
+  uncomment `getStaticProps` in one of the pages in repro to see this case)
+
+- `output: 'export'` case seems to produce outputs as if it was not export mode (for example having
+  non-empty `outputs.appPages` or `outputs.prerenders`). To not have special handling for that in
+  adapters, only non-empty outputs should be `staticFiles` pointing to what's being written to `out`
+  (or custom `distDir`) directory?
+- `output.staticFiles` entries for fully static pages router pages don't have `trailingSlash: true`
+  option applied to `pathname`. For example:
+  ```json
+  {
+    "id": "/link/rewrite-target-fullystatic",
+    "//": "Should pathname below have trailing slash, if `trailingSlash: true` is set in next.config.js?",
+    "pathname": "/link/rewrite-target-fullystatic",
+    "type": "STATIC_FILE",
+    "filePath": "/Users/misiek/dev/next-runtime-adapter/tests/fixtures/middleware-pages/.next/server/pages/link/rewrite-target-fullystatic.html"
+  }
+  ```

adapters-running-notes.md

@@ -0,0 +1,32 @@
+## Plan
+
+1. There are some operations that are easier to do in a build plugin context due to helpers, so some
+   handling will remain in build plugin (cache save/restore, moving static assets dirs for
+   publishing them etc).
+
+2. We will use adapters API where it's most helpful:
+
+- adjusting next config:
+  - [done] set standalone mode instead of using "private" env var (for now at least we will continue
+    with standalone mode as using outputs other than middleware require bigger changes which will be
+    explored in later phases)
+  - [done] set image loader (url generator) to use Netlify Image CDN directly (no need for
+    \_next/image rewrite then)
+  - (maybe/explore) set build time cache handler to avoid having to read output of default cache
+    handler and convert those files into blobs to upload later
+- [done] use middleware output to generate middleware edge function
+- [done] don't glob for static files and use `outputs.staticFiles` instead
+- [checked, did not apply changes yet, due to question about this in feedback section] check
+  `output: 'export'` case
+- note any remaining manual manifest files reading in build plugin once everything that could be
+  adjusted was handled
+
+## To figure out
+
+- Can we export build time otel spans from adapter similarly how we do that now in a build plugin?
+- Expose some constants from build plugin to adapter - what's best way to do that? (things like
+  packagePath, publishDir etc)
+- Looking forward - Platform change to accept a list of files to upload to cdn (avoids file system
+  operations such as `cp`)
+- Looking forward - allow using regexes for static headers matcher (needed to apply next.config.js
+  defined headers to apply to static assets)

e2e-report/.gitignore

@@ -28,9 +28,6 @@ yarn-error.log*
 # local env files
 .env*.local
 
-# vercel
-.vercel
-
 # typescript
 *.tsbuildinfo
 next-env.d.ts

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,30 @@
 import type { Context } from '@netlify/edge-functions'
 
-import {
-  addBasePath,
-  addLocale,
-  addTrailingSlash,
-  normalizeDataUrl,
-  normalizeLocalePath,
-  removeBasePath,
-} from './util.ts'
-
-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,
-  }
-}
+import type { RequestData } from './types'
 
 export const buildNextRequest = (
   request: Request,
-  context: Context,
-  nextConfig?: RequestData['nextConfig'],
+  nextConfig: RequestData['nextConfig'],
 ): 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,
-    body: body ?? undefined,
     nextConfig,
-    detectedLocale,
+    // page?: {
+    //     name?: string;
+    //     params?: {
+    //         [key: string]: string | string[] | undefined;
+    //     };
+    // };
+    url,
+    body: body ?? undefined,
+    signal: abortController.signal,
+    /** passed in when running in edge runtime sandbox */
+    // waitUntil?: (promise: Promise<any>) => void;
   }
 }