Async Storage

Copyexport function getOrCreateGlobalAsyncLocalStorage<Store extends {}>(
  name: string
): AsyncLocalStorage<Store> {
  const key = Symbol.for(`@next/${name}@${process.env.__NEXT_VERSION}`)
 
  const globalStore = globalThis as typeof globalThis & {
    [key: symbol]: AsyncLocalStorage<Store> | undefined
  }
 
  return (globalStore[key] ??= createAsyncLocalStorage<Store>())
}

Copyclass FakeAsyncLocalStorage<Store extends {}>
  implements AsyncLocalStorage<Store>
{
  disable(): void {
    throw sharedAsyncLocalStorageNotAvailableError
  }
 
  getStore(): Store | undefined {
    // This fake implementation of AsyncLocalStorage always returns `undefined`.
    return undefined
  }
 
  run<R>(): R {
    throw sharedAsyncLocalStorageNotAvailableError
  }
 
  exit<R>(): R {
    throw sharedAsyncLocalStorageNotAvailableError
  }
 
  enterWith(): void {
    throw sharedAsyncLocalStorageNotAvailableError
  }
 
  static bind<T>(fn: T): T {
    return fn
  }
}

Copyexport function createAsyncLocalStorage<
  Store extends {},
>(): AsyncLocalStorage<Store> {
  if (maybeGlobalAsyncLocalStorage) {
    return new maybeGlobalAsyncLocalStorage()
  }
  return new FakeAsyncLocalStorage()
}

Copy// Browser variant of `./server-async-storage`. The server-only async-storage
// singletons don't exist in the browser, so these are `undefined`. Consumers
// guard usage behind `typeof window === 'undefined'`, so the stubs are never
// dereferenced.
export const actionAsyncStorage = undefined
export const workAsyncStorage = undefined
export const workUnitAsyncStorage = undefined

Copyconst store: WorkStore = {
  page,
  route: normalizeAppPath(page),
  incrementalCache:
    // we fallback to a global incremental cache for edge-runtime locally
    // so that it can access the fs cache without mocks
    renderOpts.incrementalCache || (globalThis as any).__incrementalCache,
  cacheLifeProfiles: renderOpts.cacheLifeProfiles,
  useCacheTimeout: renderOpts.experimental.useCacheTimeout,
  durableUseCacheEntries: renderOpts.experimental.durableUseCacheEntries,
  staticPageGenerationTimeout: renderOpts.staticPageGenerationTimeout,
  isBuildTimePrerendering: renderOpts.isBuildTimePrerendering,
  fetchCache: renderOpts.fetchCache,
  isOnDemandRevalidate: renderOpts.isOnDemandRevalidate,
  requestId: undefined,
  htmlRequestId: undefined,
 
  isDraftMode: renderOpts.isDraftMode,
 
  isPrefetchRequest,
  buildId,
  deploymentId,
  reactLoadableManifest: renderOpts?.reactLoadableManifest || {},
  assetPrefix: renderOpts?.assetPrefix || '',
  nonce,
 
  afterContext: createAfterContext(renderOpts),
  cacheComponentsEnabled: renderOpts.cacheComponents,
  validationLevel: renderOpts.validationLevel,
  previouslyRevalidatedTags,
  requestStartTime: performance.timeOrigin + performance.now(),
  refreshTagsByCacheKind: createRefreshTagsByCacheKind(),
  runInCleanSnapshot: createSnapshot(),
  shouldTrackFetchMetrics,
  clientComponentLoadTracker: undefined,
  reactServerErrorsByDigest: new Map(),
}

Copyfunction createAfterContext(renderOpts: RequestLifecycleOpts): AfterContext {
  const { waitUntil, onClose, onAfterTaskError } = renderOpts
  return new AfterContext({
    waitUntil,
    onClose,
    onTaskError: onAfterTaskError,
  })
}
 
/**
 * Creates a map with lazy results that refresh tags for the respective cache
 * kind when they're awaited for the first time.
 */
function createRefreshTagsByCacheKind(): Map<string, LazyResult<void>> {
  const refreshTagsByCacheKind = new Map<string, LazyResult<void>>()
  const cacheHandlers = getCacheHandlerEntries()
 
  if (cacheHandlers) {
    for (const [kind, cacheHandler] of cacheHandlers) {
      if ('refreshTags' in cacheHandler) {
        refreshTagsByCacheKind.set(
          kind,
          createLazyResult(async () => cacheHandler.refreshTags())
        )
      }
    }
  }
 
  return refreshTagsByCacheKind
}

CopyrefreshTagsByCacheKind: createRefreshTagsByCacheKind(),
runInCleanSnapshot: createSnapshot(),

Copyexport interface RequestStore extends CommonWorkUnitStore {
  readonly type: 'request'
 
  /**
   * The URL of the request. This only specifies the pathname and the search
   * part of the URL.
   */
  readonly url: {
    /**
     * The pathname of the requested URL.
     */
    readonly pathname: string
 
    /**
     * The search part of the requested URL. If the request did not provide a
     * search part, this will be an empty string.
     */
    readonly search: string
  }
 
  readonly headers: ReadonlyHeaders
  // This is mutable because we need to reassign it when transitioning from the action phase to the render phase.
  // The cookie object itself is deliberately read only and thus can't be updated.
  cookies: ReadonlyRequestCookies
  readonly mutableCookies: ResponseCookies
  readonly userspaceMutableCookies: ResponseCookies
  readonly draftMode: DraftModeProvider
  readonly isHmrRefresh?: boolean
  readonly serverComponentsHmrCache?: ServerComponentsHmrCache
  readonly hmrRefreshHash?: string
 
  readonly rootParams: Params
 
  /**
   * The resume data cache for this request. Either a mutable
   * `PrerenderResumeDataCache` (e.g. during a dev warmup that fills caches) or
   * an immutable `RenderResumeDataCache` (e.g. when resuming from a postponed
   * state). Narrow via `resumeDataCache.mutable` to tell them apart.
   */
  resumeDataCache: ResumeDataCache | null
 

Copyexport interface ActionStore {
  readonly isAction?: boolean
  readonly isAppRoute?: boolean
}

Copyexport interface DynamicAccessAsyncStore {
  readonly abortController: AbortController
  reason: DynamicAccessReason | null
}
 
export type DynamicAccessReason = 'fallback-params' | 'runtime'

Copyconst cache: {
  headers?: ReadonlyHeaders
  cookies?: ReadonlyRequestCookies
  mutableCookies?: ResponseCookies
  userspaceMutableCookies?: ResponseCookies
  draftMode?: DraftModeProvider
} = {}
 
return {
  type: 'request',
  phase,
  implicitTags,
  // Rather than just using the whole `url` here, we pull the parts we want
  // to ensure we don't use parts of the URL that we shouldn't. This also
  // lets us avoid requiring an empty string for `search` in the type.
  url: { pathname: url.pathname, search: url.search ?? '' },
  rootParams,
  get headers() {
    if (!cache.headers) {
      // Seal the headers object that'll freeze out any methods that could
      // mutate the underlying data.
      cache.headers = getHeaders(headers)
    }
 
    return cache.headers
  },
  get cookies() {
    if (!cache.cookies) {
      // if middleware is setting cookie(s), then include those in
      // the initial cached cookies so they can be read in render
      const requestCookies = new RequestCookies(HeadersAdapter.from(headers))
 
      mergeMiddlewareCookies(headers, requestCookies)
 
      // Seal the cookies object that'll freeze out any methods that could
      // mutate the underlying data.
      cache.cookies = RequestCookiesAdapter.seal(requestCookies)
    }
 
    return cache.cookies
  },
  set cookies(value: ReadonlyRequestCookies) {
    cache.cookies = value
  },
  get mutableCookies() {
    if (!cache.mutableCookies) {
      const mutableCookies = getMutableCookies(headers, onUpdateCookies)
 
      mergeMiddlewareCookies(headers, mutableCookies)
 
      cache.mutableCookies = mutableCookies
    }
    return cache.mutableCookies
  },
  get userspaceMutableCookies() {
    if (!cache.userspaceMutableCookies) {
      const userspaceMutableCookies =
        createCookiesWithMutableAccessCheck(this)
      cache.userspaceMutableCookies = userspaceMutableCookies
    }
    return cache.userspaceMutableCookies
  },
  get draftMode() {
    if (!cache.draftMode) {
      cache.draftMode = new DraftModeProvider(
        previewProps,
        headers,
        this.cookies,
        this.mutableCookies
      )
    }
 
    return cache.draftMode
  },

Copyget cookies() {
  if (!cache.cookies) {
    // if middleware is setting cookie(s), then include those in
    // the initial cached cookies so they can be read in render
    const requestCookies = new RequestCookies(HeadersAdapter.from(headers))
 
    mergeMiddlewareCookies(headers, requestCookies)
 
    // Seal the cookies object that'll freeze out any methods that could
    // mutate the underlying data.
    cache.cookies = RequestCookiesAdapter.seal(requestCookies)
  }
 
  return cache.cookies
},
set cookies(value: ReadonlyRequestCookies) {
  cache.cookies = value
},
get mutableCookies() {
  if (!cache.mutableCookies) {
    const mutableCookies = getMutableCookies(headers, onUpdateCookies)
 
    mergeMiddlewareCookies(headers, mutableCookies)
 
    cache.mutableCookies = mutableCookies
  }
  return cache.mutableCookies
},

Copyexport function synchronizeMutableCookies(store: RequestStore) {
  // TODO: does this need to update headers as well?
  store.cookies = RequestCookiesAdapter.seal(
    responseCookiesToRequestCookies(store.mutableCookies)
  )
}

Copyfunction createDraftModeWithDevWarnings(
  underlyingProvider: null | DraftModeProvider,
  route: undefined | string
): Promise<DraftMode> {
  const instance = new DraftMode(underlyingProvider)
  const promise = Promise.resolve(instance)
 
  const proxiedPromise = new Proxy(promise, {
    get(target, prop, receiver) {
      switch (prop) {
        case 'isEnabled':
          warnForSyncAccess(route, `\`draftMode().${prop}\``)
          break
        case 'enable':
        case 'disable': {
          warnForSyncAccess(route, `\`draftMode().${prop}()\``)
          break
        }
        default: {
          // We only warn for well-defined properties of the draftMode object.
        }
      }
 
      return ReflectAdapter.get(target, prop, receiver)
    },
  })
 
  return proxiedPromise
}

Copyexport interface TestReqInfo {
  url: string
  proxyPort: number
  testData: string
}

Copyfunction extractTestInfoFromRequest<R>(
  req: R,
  reader: TestRequestReader<R>
): TestReqInfo | undefined {
  const proxyPortHeader = reader.header(req, 'next-test-proxy-port')
  if (!proxyPortHeader) {
    return undefined
  }
  const url = reader.url(req)
  const proxyPort = Number(proxyPortHeader)
  const testData = reader.header(req, 'next-test-data') || ''
  return { url, proxyPort, testData }
}
 
export function withRequest<R, T>(
  req: R,
  reader: TestRequestReader<R>,
  fn: () => T
): T {
  const testReqInfo = extractTestInfoFromRequest(req, reader)
  if (!testReqInfo) {
    return fn()
  }
  return testStorage.run(testReqInfo, fn)
}

Copyexport function getTestReqInfo<R>(
  req?: R,
  reader?: TestRequestReader<R>
): TestReqInfo | undefined {
  const testReqInfo = testStorage.getStore()
  if (testReqInfo) {
    return testReqInfo
  }
  if (req && reader) {
    return extractTestInfoFromRequest(req, reader)
  }
  return undefined
}

Copyexport type RequestInsightsIdentity = {
  requestId: string
  kind?: RequestInsightKind
  htmlRequestId: string
  url: string | undefined
}

Copy// This storage covers the part of BaseServer request handling that runs before
// App Render creates workAsyncStorage. Once available, workStore remains the
// primary identity source for locally recorded spans.
function getRequestInsightsIdentityStorage(): AsyncLocalStorage<RequestInsightsIdentity> {
  return getOrCreateGlobalAsyncLocalStorage('request-insights-identity-storage')
}
 
export function runWithRequestInsightsIdentity<T>(
  identity: RequestInsightsIdentity,
  fn: () => T
): T {
  return getRequestInsightsIdentityStorage().run(identity, fn)
}
 
export function getRequestInsightsIdentity():
  | RequestInsightsIdentity
  | undefined {
  return getRequestInsightsIdentityStorage().getStore()
}

Copyexport function getBuiltinRequestContext():
  | BuiltinRequestContextValue
  | undefined {
  const _globalThis = globalThis as GlobalThisWithRequestContext
  const ctx = _globalThis[NEXT_REQUEST_CONTEXT_SYMBOL]
  return ctx?.get()
}
 
const NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for('@next/request-context')
 
type GlobalThisWithRequestContext = typeof globalThis & {
  [NEXT_REQUEST_CONTEXT_SYMBOL]?: BuiltinRequestContext
}
 
/** A request context provided by the platform. */
export type BuiltinRequestContext = {
  get(): BuiltinRequestContextValue | undefined
}
 
export type RunnableBuiltinRequestContext = BuiltinRequestContext & {
  run<T>(value: BuiltinRequestContextValue, callback: () => T): T
}
 
export type BuiltinRequestContextValue = {
  waitUntil?: WaitUntil
}
export type WaitUntil = (promise: Promise<any>) => void
 
/** "@next/request-context" has a different signature from AsyncLocalStorage,
 * matching [AsyncContext.Variable](https://github.com/tc39/proposal-async-context).
 * We don't need a full AsyncContext adapter here, just having `.get()` is enough
 */
export function createLocalRequestContext(): RunnableBuiltinRequestContext {
  const storage = createAsyncLocalStorage<BuiltinRequestContextValue>()
  return {
    get: () => storage.getStore(),
    run: (value, callback) => storage.run(value, callback),
  }
}