{"version":3,"sources":["../../../../src/server/use-cache/handlers.ts"],"sourcesContent":["import { createDefaultCacheHandler } from '../lib/cache-handlers/default'\nimport type { CacheHandler } from '../lib/cache-handlers/types'\nimport {\n  createTieredCacheHandler,\n  type CacheReadWriteHandler,\n} from './tiered-cache-handler'\n\nconst debug = process.env.NEXT_PRIVATE_DEBUG_CACHE\n  ? (message: string, ...args: any[]) => {\n      console.log(`use-cache: ${message}`, ...args)\n    }\n  : undefined\n\nconst handlersSymbol = Symbol.for('@next/cache-handlers')\nconst handlersMapSymbol = Symbol.for('@next/cache-handlers-map')\nconst handlersSetSymbol = Symbol.for('@next/cache-handlers-set')\nconst privateHandlerSymbol = Symbol.for('@next/cache-handlers-private')\nconst builtInHandlersSymbol = Symbol.for('@next/cache-handlers-built-in')\nconst devFrontHandlersSymbol = Symbol.for('@next/cache-handlers-dev-fronts')\nconst devTieredHandlersSymbol = Symbol.for('@next/cache-handlers-dev-tiered')\nconst memoryCacheDisabledSymbol = Symbol.for(\n  '@next/cache-handlers-memory-disabled'\n)\n\n/**\n * The in-memory size used for the dev-only built-in handlers (the private\n * handler, the size-0 replacement, and the per-kind front handlers for custom\n * kinds). Mirrors the framework default so `cacheMaxMemorySize: 0` does not\n * disable caching in development.\n */\nconst DEV_MEMORY_CACHE_SIZE = 50 * 1024 * 1024\n\n/**\n * The reference to the cache handlers. We store the cache handlers on the\n * global object so that we can access the same instance across different\n * boundaries (such as different copies of the same module).\n */\nconst reference: typeof globalThis & {\n  [handlersSymbol]?: {\n    RemoteCache?: CacheHandler\n    DefaultCache?: CacheHandler\n  }\n  [handlersMapSymbol]?: Map<string, CacheHandler>\n  [handlersSetSymbol]?: Set<CacheHandler>\n  [builtInHandlersSymbol]?: Set<CacheHandler>\n  // DEV-only\n  [privateHandlerSymbol]?: CacheHandler\n  [devFrontHandlersSymbol]?: Map<string, CacheHandler>\n  [devTieredHandlersSymbol]?: Map<string, CacheReadWriteHandler>\n  [memoryCacheDisabledSymbol]?: boolean\n} = globalThis\n\n/**\n * Initialize the cache handlers.\n * @param cacheMaxMemorySize - The maximum memory size of the cache in bytes, if\n *  not provided, the default memory size will be used.\n * @returns `true` if the cache handlers were initialized, `false` if they were already initialized.\n */\nexport function initializeCacheHandlers(cacheMaxMemorySize: number): boolean {\n  // If the cache handlers have already been initialized, don't do it again.\n  if (reference[handlersMapSymbol]) {\n    debug?.('cache handlers already initialized')\n    return false\n  }\n\n  debug?.('initializing cache handlers')\n  const handlersMap = new Map<string, CacheHandler>()\n  reference[handlersMapSymbol] = handlersMap\n  const builtInHandlers = new Set<CacheHandler>()\n  reference[builtInHandlersSymbol] = builtInHandlers\n\n  // In development, `cacheMaxMemorySize: 0` would make the built-in default\n  // handler a no-op, so every reload would miss. Use a real in-memory size\n  // instead so dev stays fast; the \"use cache\" wrapper forces a dynamic cache\n  // life for this case so it still behaves close to \"no cache\" (serve stale,\n  // regenerate in the background). Production keeps the no-op handler.\n  const builtInSize =\n    process.env.__NEXT_DEV_SERVER && cacheMaxMemorySize === 0\n      ? DEV_MEMORY_CACHE_SIZE\n      : cacheMaxMemorySize\n\n  // Initialize the cache from the symbol contents first.\n  if (reference[handlersSymbol]) {\n    let fallback: CacheHandler\n    if (reference[handlersSymbol].DefaultCache) {\n      debug?.('setting \"default\" cache handler from symbol')\n      fallback = reference[handlersSymbol].DefaultCache\n    } else {\n      debug?.('setting \"default\" cache handler from default')\n      fallback = createDefaultCacheHandler(builtInSize)\n      builtInHandlers.add(fallback)\n    }\n\n    handlersMap.set('default', fallback)\n\n    if (reference[handlersSymbol].RemoteCache) {\n      debug?.('setting \"remote\" cache handler from symbol')\n      handlersMap.set('remote', reference[handlersSymbol].RemoteCache)\n    } else {\n      debug?.('setting \"remote\" cache handler from default')\n      handlersMap.set('remote', fallback)\n    }\n  } else {\n    const handler = createDefaultCacheHandler(builtInSize)\n    builtInHandlers.add(handler)\n\n    debug?.('setting \"default\" cache handler from default')\n    handlersMap.set('default', handler)\n    debug?.('setting \"remote\" cache handler from default')\n    handlersMap.set('remote', handler)\n  }\n\n  // Create a set of the cache handlers.\n  reference[handlersSetSymbol] = new Set(handlersMap.values())\n\n  // In development we add dedicated built-in in-memory handlers so that reloads\n  // are fast. These are always built-in handlers, never a user-configured one,\n  // and are gated on the dev server so production behaves exactly as\n  // configured.\n  if (process.env.__NEXT_DEV_SERVER) {\n    reference[memoryCacheDisabledSymbol] = cacheMaxMemorySize === 0\n\n    // Private caches are persisted here so reloads are fast. Private entries\n    // can hold data specific to the incoming request (for example, derived from\n    // its cookies or headers), so this is never the user-configured `default`\n    // alias. Sized so it still caches under `cacheMaxMemorySize: 0` (otherwise\n    // it would become the no-op stub and private reloads would miss).\n    reference[privateHandlerSymbol] = createDefaultCacheHandler(\n      DEV_MEMORY_CACHE_SIZE\n    )\n\n    // Built-in front handlers, one per custom kind, and the tiered handlers\n    // that place a front in front of a (possibly slow or remote) backing\n    // handler so cache hits resolve in a microtask, are both created per kind\n    // in `setCacheHandler`.\n    reference[devFrontHandlersSymbol] = new Map()\n    reference[devTieredHandlersSymbol] = new Map()\n  }\n\n  return true\n}\n\n/**\n * Get a cache handler by kind.\n * @param kind - The kind of cache handler to get.\n * @returns The cache handler, or `undefined` if it does not exist.\n * @throws If the cache handlers are not initialized.\n */\nexport function getCacheHandler(kind: string): CacheHandler | undefined {\n  // This should never be called before initializeCacheHandlers.\n  if (!reference[handlersMapSymbol]) {\n    throw new Error('Cache handlers not initialized')\n  }\n\n  return reference[handlersMapSymbol].get(kind)\n}\n\n/**\n * Get the dedicated in-memory cache handler that persists private caches in\n * development. Returns `undefined` outside the dev server, where private caches\n * must not be persisted. This is intentionally not part of the kind-keyed\n * handlers map so that it can never be replaced by a user-configured handler.\n */\nexport function getPrivateCacheHandler(): CacheHandler | undefined {\n  // This should never be called before initializeCacheHandlers.\n  if (!reference[handlersMapSymbol]) {\n    throw new Error('Cache handlers not initialized')\n  }\n\n  return reference[privateHandlerSymbol]\n}\n\n/**\n * Whether the in-memory cache is disabled (`cacheMaxMemorySize: 0`). Dev-only\n * signal used to force a dynamic cache life so that the size-0 case still\n * serves stale and regenerates in the background. Always `false` in production.\n */\nexport function isMemoryCacheDisabled(): boolean {\n  return reference[memoryCacheDisabledSymbol] ?? false\n}\n\n/**\n * Whether `kind` is backed by a real user-configured handler rather than the\n * built-in in-memory default. Such a handler may be slow or remote, so in\n * development a built-in front handler is placed in front of it (see\n * `getDevTieredCacheHandler`) to keep cache hits microtask-fast. The presence\n * of a dev front handler is the signal, since front handlers are created\n * exactly for user-registered kinds. Always `false` in production.\n */\nexport function isCustomCacheHandler(kind: string): boolean {\n  if (!process.env.__NEXT_DEV_SERVER) {\n    return false\n  }\n\n  return reference[devFrontHandlersSymbol]?.has(kind) ?? false\n}\n\n/**\n * Whether `kind` resolves to one of the in-memory handlers that\n * `initializeCacheHandlers` constructs itself, rather than one supplied by the\n * platform through the `@next/cache-handlers` global or by `cacheHandlers`\n * config. Reads from a built-in handler are map lookups, so repeating one\n * within a request costs nothing; reads from a supplied handler may be a\n * network round trip. Unlike `isCustomCacheHandler`, this holds in production.\n *\n * Tracking the instances rather than the kinds is what keeps aliasing correct:\n * self-hosted, `remote` resolves to the same handler as `default` and so\n * reports as built-in, while a platform-supplied `remote` does not.\n */\nexport function isBuiltInCacheHandler(kind: string): boolean {\n  const handler = reference[handlersMapSymbol]?.get(kind)\n\n  return (\n    handler !== undefined &&\n    Boolean(reference[builtInHandlersSymbol]?.has(handler))\n  )\n}\n\n/**\n * Get the dev-only tiered cache handler for a custom `kind`: a fast built-in\n * in-memory front handler in front of the user-configured backing handler, so\n * cache hits resolve in a microtask. Returns `undefined` if there is none (a\n * built-in kind, or production).\n */\nexport function getDevTieredCacheHandler(\n  kind: string\n): CacheReadWriteHandler | undefined {\n  if (!process.env.__NEXT_DEV_SERVER) {\n    return undefined\n  }\n\n  return reference[devTieredHandlersSymbol]?.get(kind)\n}\n\n/**\n * Get an iterator over the cache handlers.\n * @returns An iterator over the cache handlers, or `undefined` if they are not\n * initialized.\n */\nexport function getCacheHandlers(): IterableIterator<CacheHandler> | undefined {\n  const handlersSet = reference[handlersSetSymbol]\n  if (!handlersSet) {\n    return undefined\n  }\n\n  if (process.env.__NEXT_DEV_SERVER) {\n    return iterateCacheHandlersWithDevBuiltIns(handlersSet)\n  }\n\n  return handlersSet.values()\n}\n\n/**\n * Yields the registered handlers plus the dev-only built-in handlers (the\n * private handler and the per-kind front handlers). The built-in handlers are\n * not part of the registered set, but tag operations must still reach them:\n * their `updateTags` writes the shared tags manifest that their `get` consults,\n * so `revalidateTag` can invalidate their entries.\n */\nfunction* iterateCacheHandlersWithDevBuiltIns(\n  handlersSet: Set<CacheHandler>\n): IterableIterator<CacheHandler> {\n  yield* handlersSet\n\n  const privateHandler = reference[privateHandlerSymbol]\n  if (privateHandler) {\n    yield privateHandler\n  }\n\n  const devFrontHandlers = reference[devFrontHandlersSymbol]\n  if (devFrontHandlers) {\n    yield* devFrontHandlers.values()\n  }\n}\n\n/**\n * Get a map iterator over the cache handlers (keyed by kind).\n * @returns An iterator over the cache handler entries, or `undefined` if they\n * are not initialized.\n * @throws If the cache handlers are not initialized.\n */\nexport function getCacheHandlerEntries():\n  | IterableIterator<[string, CacheHandler]>\n  | undefined {\n  const handlersMap = reference[handlersMapSymbol]\n  if (!handlersMap) {\n    return undefined\n  }\n\n  if (process.env.__NEXT_DEV_SERVER) {\n    return iterateCacheHandlerEntriesWithDevBuiltIns(handlersMap)\n  }\n\n  return handlersMap.entries()\n}\n\n/**\n * Yields the registered entries plus the dev-only private handler under its\n * kind, so that per-kind tag operations (`refreshTags` / `getExpiration` for\n * implicit tags) apply to private entries. Custom-kind front handlers are\n * intentionally omitted: the backing handler (already in the map) is\n * authoritative for that kind's `getExpiration`, and a front entry is discarded\n * via that same value.\n */\nfunction* iterateCacheHandlerEntriesWithDevBuiltIns(\n  handlersMap: Map<string, CacheHandler>\n): IterableIterator<[string, CacheHandler]> {\n  yield* handlersMap.entries()\n\n  const privateHandler = reference[privateHandlerSymbol]\n  if (privateHandler) {\n    const privateEntry: [string, CacheHandler] = ['private', privateHandler]\n    yield privateEntry\n  }\n}\n\n/**\n * Set a cache handler by kind.\n * @param kind - The kind of cache handler to set.\n * @param cacheHandler - The cache handler to set.\n */\nexport function setCacheHandler(\n  kind: string,\n  cacheHandler: CacheHandler\n): void {\n  // This should never be called before initializeCacheHandlers.\n  if (!reference[handlersMapSymbol] || !reference[handlersSetSymbol]) {\n    throw new Error('Cache handlers not initialized')\n  }\n\n  debug?.('setting cache handler for \"%s\"', kind)\n  reference[handlersMapSymbol].set(kind, cacheHandler)\n  reference[handlersSetSymbol].add(cacheHandler)\n\n  // A user-configured handler may be slow or remote. In development, give it a\n  // dedicated built-in in-memory front handler so cache hits resolve in a\n  // microtask, and pair the two into a tiered handler the wrapper reads\n  // through. Both are created alongside registration so their lifecycle matches\n  // the backing handler's, and the front handler's presence is the signal that\n  // this kind is backed by a real handler (see `isCustomCacheHandler`). Being a\n  // built-in default handler, the front inherits the dev minimum retention, so\n  // a short-`expire` value still hits the front instead of falling through to\n  // the slow backing on every read.\n  if (process.env.__NEXT_DEV_SERVER) {\n    const frontHandler = createDefaultCacheHandler(DEV_MEMORY_CACHE_SIZE)\n    reference[devFrontHandlersSymbol]?.set(kind, frontHandler)\n    reference[devTieredHandlersSymbol]?.set(\n      kind,\n      createTieredCacheHandler(frontHandler, cacheHandler)\n    )\n  }\n}\n"],"names":["createDefaultCacheHandler","createTieredCacheHandler","debug","process","env","NEXT_PRIVATE_DEBUG_CACHE","message","args","console","log","undefined","handlersSymbol","Symbol","for","handlersMapSymbol","handlersSetSymbol","privateHandlerSymbol","builtInHandlersSymbol","devFrontHandlersSymbol","devTieredHandlersSymbol","memoryCacheDisabledSymbol","DEV_MEMORY_CACHE_SIZE","reference","globalThis","initializeCacheHandlers","cacheMaxMemorySize","handlersMap","Map","builtInHandlers","Set","builtInSize","__NEXT_DEV_SERVER","fallback","DefaultCache","add","set","RemoteCache","handler","values","getCacheHandler","kind","Error","get","getPrivateCacheHandler","isMemoryCacheDisabled","isCustomCacheHandler","has","isBuiltInCacheHandler","Boolean","getDevTieredCacheHandler","getCacheHandlers","handlersSet","iterateCacheHandlersWithDevBuiltIns","privateHandler","devFrontHandlers","getCacheHandlerEntries","iterateCacheHandlerEntriesWithDevBuiltIns","entries","privateEntry","setCacheHandler","cacheHandler","frontHandler"],"mappings":"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","ignoreList":[0]}