@platformatic/next 3.16.0 → 3.18.0

package/config.d.ts

@@ -523,6 +523,7 @@ export interface PlatformaticNextJsConfig {
     adapter: "redis" | "valkey";
     url: string;
     prefix?: string;
+    cacheComponents?: boolean;
     maxTTL?: number | string;
   };
 }

package/index.js

@@ -1,8 +1,14 @@
 import { transform as basicTransform, resolve, validationOptions } from '@platformatic/basic'
 import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/foundation'
+import { sep } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { NextCapability } from './lib/capability.js'
 import { schema } from './lib/schema.js'
 
+function getCacheHandlerPath (name) {
+  return fileURLToPath(new URL(`./lib/caching/${name}.js`, import.meta.url)).replaceAll(sep, '/')
+}
+
 /* c8 ignore next 9 */
 export async function transform (config, schema, options) {
   config = await basicTransform(config, schema, options)
@@ -15,6 +21,40 @@ export async function transform (config, schema, options) {
   return config
 }
 
+export async function enhanceNextConfig (nextConfig, ...args) {
+  // This is to avoid https://github.com/vercel/next.js/issues/76981
+  Headers.prototype[Symbol.for('nodejs.util.inspect.custom')] = undefined
+
+  if (typeof nextConfig === 'function') {
+    nextConfig = await nextConfig(...args)
+  }
+
+  const { basePath, config, nextVersion } = globalThis.platformatic
+
+  if (typeof nextConfig.basePath === 'undefined') {
+    nextConfig.basePath = basePath
+  }
+
+  if (config.cache?.adapter) {
+    if (nextVersion.major > 15 && config.cache?.cacheComponents && typeof nextConfig.cacheComponents === 'undefined') {
+      nextConfig.cacheComponents = true
+      nextConfig.cacheHandler = getCacheHandlerPath('null-isr')
+      nextConfig.cacheHandlers = { default: getCacheHandlerPath(`${config.cache.adapter}-components`) }
+      nextConfig.cacheMaxMemorySize = 0
+    } else if (typeof nextConfig.cacheHandler === 'undefined') {
+      nextConfig.cacheHandler = getCacheHandlerPath(`${config.cache.adapter}-isr`)
+      nextConfig.cacheMaxMemorySize = 0
+    }
+  }
+
+  if (config.next?.trailingSlash && typeof nextConfig.trailingSlash === 'undefined') {
+    nextConfig.trailingSlash = true
+  }
+
+  globalThis.platformatic.notifyConfig(nextConfig)
+  return nextConfig
+}
+
 export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
   const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'application')
 
@@ -32,6 +72,6 @@ export async function create (configOrRoot, sourceOrConfig, context) {
   return new NextCapability(config[kMetadata].root, config, context)
 }
 
-export * as cachingValkey from './lib/caching/valkey.js'
+export * as cachingValkey from './lib/caching/valkey-isr.js'
 export * from './lib/capability.js'
 export { packageJson, schema, schemaComponents, version } from './lib/schema.js'

package/lib/caching/null-isr.js

@@ -0,0 +1,12 @@
+// This is provided to allow users to only rely on Cache Components and not the ISR cache
+export class CacheHandler {
+  async get () {}
+
+  async set () {}
+
+  async remove () {}
+
+  async revalidateTag () {}
+}
+
+export default CacheHandler

package/lib/caching/valkey-common.js

@@ -0,0 +1,101 @@
+import { buildPinoFormatters, buildPinoTimestamp } from '@platformatic/foundation'
+import { Redis } from 'iovalkey'
+import { pack, unpack } from 'msgpackr'
+import { existsSync, readFileSync } from 'node:fs'
+import { hostname } from 'node:os'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { pino } from 'pino'
+
+globalThis.platformatic ??= {}
+globalThis.platformatic.valkeyClients = new Map()
+
+export function keyFor (prefix, subprefix, section, key) {
+  let result = prefix?.length ? prefix + ':' : ''
+
+  result += 'cache:next'
+
+  if (subprefix?.length) {
+    result += ':' + subprefix
+  }
+
+  if (section?.length) {
+    result += ':' + section
+  }
+
+  if (key?.length) {
+    result += Buffer.from(key).toString('base64url')
+  }
+
+  return result
+}
+
+export function getConnection (url) {
+  let client = globalThis.platformatic.valkeyClients.get(url)
+
+  if (!client) {
+    client = new Redis(url, { enableAutoPipelining: true })
+    globalThis.platformatic.valkeyClients.set(url, client)
+
+    globalThis.platformatic.events.on('plt:next:close', () => {
+      client.disconnect(false)
+    })
+  }
+
+  return client
+}
+
+export function createPlatformaticLogger () {
+  const loggerConfig = globalThis.platformatic?.config?.logger
+
+  const pinoOptions = {
+    ...loggerConfig,
+    level: globalThis.platformatic?.logLevel ?? loggerConfig?.level ?? 'info'
+  }
+  if (pinoOptions.formatters) {
+    pinoOptions.formatters = buildPinoFormatters(pinoOptions.formatters)
+  }
+  if (pinoOptions.timestamp) {
+    pinoOptions.timestamp = buildPinoTimestamp(pinoOptions.timestamp)
+  }
+
+  if (globalThis.platformatic?.applicationId) {
+    pinoOptions.name = `cache:${globalThis.platformatic.applicationId}`
+  }
+
+  if (pinoOptions.base !== null) {
+    pinoOptions.base = {
+      ...(pinoOptions.base ?? {}),
+      pid: process.pid,
+      hostname: hostname(),
+      worker: globalThis.platformatic?.workerId
+    }
+  } else if (pinoOptions.base === null) {
+    pinoOptions.base = undefined
+  }
+
+  return pino(pinoOptions)
+}
+
+export function getPlatformaticSubprefix () {
+  const root = fileURLToPath(globalThis.platformatic.root)
+
+  return existsSync(resolve(root, '.next/BUILD_ID'))
+    ? readFileSync(resolve(root, '.next/BUILD_ID'), 'utf-8').trim()
+    : 'development'
+}
+
+export function getPlatformaticMeta () {
+  return {
+    applicationId: globalThis.platformatic.applicationId,
+    workerId: globalThis.platformatic.workerId
+  }
+}
+
+export function serialize (data) {
+  return pack(data).toString('base64url')
+}
+
+export function deserialize (data) {
+  return unpack(Buffer.from(data, 'base64url'))
+}

package/lib/caching/valkey-components.js

@@ -0,0 +1,231 @@
+import { ensureLoggableError } from '@platformatic/foundation'
+import { ReadableStream } from 'node:stream/web'
+import {
+  createPlatformaticLogger,
+  deserialize,
+  getConnection,
+  getPlatformaticMeta,
+  getPlatformaticSubprefix,
+  keyFor,
+  serialize
+} from './valkey-common.js'
+
+export const CACHE_HIT_METRIC = {
+  name: 'next_components_cache_valkey_hit_count',
+  help: 'Next.js Components Cache (Valkey) Hit Count'
+}
+export const CACHE_MISS_METRIC = {
+  name: 'next_components_cache_valkey_miss_count',
+  help: 'Next.js Components Cache (Valkey) Miss Count'
+}
+export const MAX_BATCH_SIZE = 100
+
+export const sections = {
+  values: 'components:values',
+  tags: 'components:tags'
+}
+
+export class CacheHandler {
+  #config
+  #logger
+  #store
+  #prefix
+  #subprefix
+  #meta
+  #maxTTL
+  #cacheHitMetric
+  #cacheMissMetric
+
+  constructor () {
+    this.#config ??= globalThis.platformatic.config.cache
+    this.#logger ??= createPlatformaticLogger()
+    this.#store ??= getConnection(this.#config.url)
+    this.#maxTTL ??= this.#config.maxTTL
+    this.#prefix ??= this.#config.prefix
+    this.#subprefix ??= getPlatformaticSubprefix()
+    this.#meta ??= getPlatformaticMeta()
+
+    if (!this.#config) {
+      throw new Error('Please provide a the "config" option.')
+    }
+
+    if (!this.#logger) {
+      throw new Error('Please provide a the "logger" option.')
+    }
+
+    if (!this.#store) {
+      throw new Error('Please provide a the "store" option.')
+    }
+
+    if (globalThis.platformatic) {
+      this.#registerMetrics()
+    }
+  }
+
+  async get (cacheKey, _, isRedisKey) {
+    this.#logger.trace({ key: cacheKey }, 'cache get')
+
+    const key = isRedisKey ? cacheKey : this.#keyFor(cacheKey, sections.values)
+
+    let rawValue
+    try {
+      rawValue = await this.#store.get(key)
+
+      if (!rawValue) {
+        this.#cacheMissMetric?.inc()
+        return
+      }
+    } catch (e) {
+      this.#cacheMissMetric?.inc()
+      this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot read cache value from Valkey')
+
+      return
+    }
+
+    let raw
+    try {
+      raw = deserialize(rawValue)
+    } catch (e) {
+      this.#cacheMissMetric?.inc()
+      this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot deserialize cache value from Valkey')
+
+      // Avoid useless reads the next time
+      // Note that since the value was unserializable, we don't know its tags and thus
+      // we cannot remove it from the tags sets. TTL will take care of them.
+      await this.#store.del(key)
+
+      return
+    }
+
+    const { maxTTL: _maxTTL, meta: _meta, ...value } = raw
+
+    if (this.#maxTTL < raw.revalidate) {
+      try {
+        await this.#refreshKey(key, value)
+      } catch (e) {
+        this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot refresh cache key expiration in Valkey')
+      }
+    }
+
+    // Convert the value back to a web ReadableStream. Sob.
+    const buffer = value.value
+    value.value = new ReadableStream({
+      start (controller) {
+        controller.enqueue(buffer)
+        controller.close()
+      }
+    })
+
+    this.#cacheHitMetric?.inc()
+    return value
+  }
+
+  async set (cacheKey, dataPromise, isRedisKey) {
+    const { value, ...data } = await dataPromise
+    const { expire: expireSec, tags, revalidate } = data
+
+    this.#logger.trace({ key: cacheKey, value, tags, revalidate }, 'cache set')
+
+    const key = isRedisKey ? cacheKey : this.#keyFor(cacheKey, sections.values)
+
+    try {
+      // Gather the value
+      const chunks = []
+      for await (const chunk of value) {
+        chunks.push(chunk)
+      }
+
+      // Compute the parameters to save
+      const toSerialize = serialize({
+        maxTTL: this.#maxTTL,
+        meta: this.#meta,
+        value: Buffer.concat(chunks),
+        ...data
+      })
+      const expire = Math.min(revalidate, expireSec, this.#maxTTL)
+
+      if (expire < 1) {
+        return
+      }
+
+      // Enqueue all the operations to perform in Valkey
+      const promises = []
+      promises.push(this.#store.set(key, toSerialize, 'EX', expire))
+
+      // As Next.js limits tags to 64, we don't need to manage batches here
+      if (Array.isArray(tags)) {
+        for (const tag of tags) {
+          const tagsKey = this.#keyFor(tag, sections.tags)
+          promises.push(this.#store.sadd(tagsKey, key))
+          promises.push(this.#store.expire(tagsKey, expire))
+        }
+      }
+
+      // Execute all the operations
+      await Promise.all(promises)
+    } catch (e) {
+      this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot write cache value in Valkey')
+      throw new Error('Cannot write cache value in Valkey', { cause: e })
+    }
+  }
+
+  async refreshTags () {
+    // this.#logger.trace('refreshTags - Not implemented')
+  }
+
+  getExpiration (_tags) {
+    // this.#logger.trace({ tags: _tags }, 'getExpiration - Not implemented')
+    return Number.POSITIVE_INFINITY
+  }
+
+  updateTags (_tags) {
+    // this.#logger.trace({ tags: _tags }, 'updateTags - Not implemented')
+  }
+
+  async #refreshKey (key, value) {
+    const life = Math.round((Date.now() - value.timestamp) / 1000)
+    const expire = Math.min(value.revalidate - life, this.#maxTTL)
+
+    if (expire < 1) {
+      return
+    }
+
+    const promises = []
+    promises.push(this.#store.expire(key, expire, 'gt'))
+
+    if (Array.isArray(value.tags)) {
+      for (const tag of value.tags) {
+        const tagsKey = this.#keyFor(tag, sections.tags)
+        promises.push(this.#store.expire(tagsKey, expire, 'gt'))
+      }
+    }
+
+    await Promise.all(promises)
+  }
+
+  #keyFor (key, section) {
+    return keyFor(this.#prefix, this.#subprefix, section, key)
+  }
+
+  #registerMetrics () {
+    const { client, registry } = globalThis.platformatic.prometheus
+
+    this.#cacheHitMetric =
+      registry.getSingleMetric(CACHE_HIT_METRIC.name) ??
+      new client.Counter({
+        name: CACHE_HIT_METRIC.name,
+        help: CACHE_HIT_METRIC.help,
+        registers: [registry]
+      })
+
+    this.#cacheMissMetric =
+      registry.getSingleMetric(CACHE_MISS_METRIC.name) ??
+      new client.Counter({
+        name: CACHE_MISS_METRIC.name,
+        help: CACHE_MISS_METRIC.help,
+        registers: [registry]
+      })
+  }
+}
+
+export default new CacheHandler()

package/lib/caching/{valkey.js → valkey-isr.js}

@@ -1,17 +1,16 @@
-import { buildPinoFormatters, buildPinoTimestamp, ensureLoggableError } from '@platformatic/foundation'
-import { Redis } from 'iovalkey'
-import { pack, unpack } from 'msgpackr'
-import { existsSync, readFileSync } from 'node:fs'
-import { hostname } from 'node:os'
-import { resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { pino } from 'pino'
-
-const CACHE_HIT_METRIC = { name: 'next_cache_valkey_hit_count', help: 'Next.js Cache (Valkey) Hit Count' }
-const CACHE_MISS_METRIC = { name: 'next_cache_valkey_miss_count', help: 'Next.js Cache (Valkey) Miss Count' }
-
-const clients = new Map()
-
+import { ensureLoggableError } from '@platformatic/foundation'
+import {
+  createPlatformaticLogger,
+  deserialize,
+  getConnection,
+  getPlatformaticMeta,
+  getPlatformaticSubprefix,
+  keyFor,
+  serialize
+} from './valkey-common.js'
+
+export const CACHE_HIT_METRIC = { name: 'next_cache_valkey_hit_count', help: 'Next.js Cache (Valkey) Hit Count' }
+export const CACHE_MISS_METRIC = { name: 'next_cache_valkey_miss_count', help: 'Next.js Cache (Valkey) Miss Count' }
 export const MAX_BATCH_SIZE = 100
 
 export const sections = {
@@ -19,27 +18,6 @@ export const sections = {
   tags: 'tags'
 }
 
-export function keyFor (prefix, subprefix, section, key) {
-  return [prefix, 'cache:next', subprefix, section, key ? Buffer.from(key).toString('base64url') : undefined]
-    .filter(c => c)
-    .join(':')
-}
-
-export function getConnection (url) {
-  let client = clients.get(url)
-
-  if (!client) {
-    client = new Redis(url, { enableAutoPipelining: true })
-    clients.set(url, client)
-
-    globalThis.platformatic.events.on('plt:next:close', () => {
-      client.disconnect(false)
-    })
-  }
-
-  return client
-}
-
 export class CacheHandler {
   #standalone
   #config
@@ -64,14 +42,14 @@ export class CacheHandler {
     this.#subprefix = options.subprefix
     this.#meta = options.meta
 
-    if (!this.#standalone && globalThis.platformatic) {
+    if (!this.#standalone && globalThis.platformatic?.config) {
       this.#config ??= globalThis.platformatic.config.cache
-      this.#logger ??= this.#createPlatformaticLogger()
+      this.#logger ??= createPlatformaticLogger()
       this.#store ??= getConnection(this.#config.url)
       this.#maxTTL ??= this.#config.maxTTL
       this.#prefix ??= this.#config.prefix
-      this.#subprefix ??= this.#getPlatformaticSubprefix()
-      this.#meta ??= this.#getPlatformaticMeta()
+      this.#subprefix ??= getPlatformaticSubprefix()
+      this.#meta ??= getPlatformaticMeta()
     } else {
       this.#config ??= {}
       this.#maxTTL ??= 86_400
@@ -92,7 +70,7 @@ export class CacheHandler {
       throw new Error('Please provide a the "store" option.')
     }
 
-    if (globalThis.platformatic) {
+    if (globalThis.platformatic?.prometheus) {
       this.#registerMetrics()
     }
   }
@@ -118,7 +96,7 @@ export class CacheHandler {
 
     let value
     try {
-      value = this.#deserialize(rawValue)
+      value = deserialize(rawValue)
     } catch (e) {
       this.#cacheMissMetric?.inc()
       this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot deserialize cache value from Valkey')
@@ -155,7 +133,7 @@ export class CacheHandler {
 
     try {
       // Compute the parameters to save
-      const data = this.#serialize({
+      const data = serialize({
         value,
         tags,
         lastModified: Date.now(),
@@ -170,7 +148,6 @@ export class CacheHandler {
       }
 
       // Enqueue all the operations to perform in Valkey
-
       const promises = []
       promises.push(this.#store.set(key, data, 'EX', expire))
 
@@ -210,7 +187,7 @@ export class CacheHandler {
 
     let value
     try {
-      value = this.#deserialize(rawValue)
+      value = deserialize(rawValue)
     } catch (e) {
       this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot deserialize cache value from Valkey')
 
@@ -299,65 +276,10 @@ export class CacheHandler {
     await Promise.all(promises)
   }
 
-  #createPlatformaticLogger () {
-    const loggerConfig = globalThis.platformatic?.config?.logger
-
-    const pinoOptions = {
-      ...loggerConfig,
-      level: globalThis.platformatic?.logLevel ?? loggerConfig?.level ?? 'info'
-    }
-    if (pinoOptions.formatters) {
-      pinoOptions.formatters = buildPinoFormatters(pinoOptions.formatters)
-    }
-    if (pinoOptions.timestamp) {
-      pinoOptions.timestamp = buildPinoTimestamp(pinoOptions.timestamp)
-    }
-
-    if (this.applicationId) {
-      pinoOptions.name = `cache:${this.applicationId}`
-    }
-
-    if (pinoOptions.base !== null) {
-      pinoOptions.base = {
-        ...(pinoOptions.base ?? {}),
-        pid: process.pid,
-        hostname: hostname(),
-        worker: this.workerId
-      }
-    } else if (pinoOptions.base === null) {
-      pinoOptions.base = undefined
-    }
-
-    return pino(pinoOptions)
-  }
-
-  #getPlatformaticSubprefix () {
-    const root = fileURLToPath(globalThis.platformatic.root)
-
-    return existsSync(resolve(root, '.next/BUILD_ID'))
-      ? (this.#subprefix = readFileSync(resolve(root, '.next/BUILD_ID'), 'utf-8').trim())
-      : 'development'
-  }
-
-  #getPlatformaticMeta () {
-    return {
-      applicationId: globalThis.platformatic.applicationId,
-      workerId: globalThis.platformatic.workerId
-    }
-  }
-
   #keyFor (key, section) {
     return keyFor(this.#prefix, this.#subprefix, section, key)
   }
 
-  #serialize (data) {
-    return pack(data).toString('base64url')
-  }
-
-  #deserialize (data) {
-    return unpack(Buffer.from(data, 'base64url'))
-  }
-
   #registerMetrics () {
     const { client, registry } = globalThis.platformatic.prometheus
 

package/lib/capability.js

@@ -13,11 +13,10 @@ import { ChildProcess } from 'node:child_process'
 import { once } from 'node:events'
 import { readFile, writeFile } from 'node:fs/promises'
 import { dirname, resolve as resolvePath } from 'node:path'
-import { pathToFileURL } from 'node:url'
 import { parse, satisfies } from 'semver'
 import { version } from './schema.js'
 
-const supportedVersions = ['^14.0.0', '^15.0.0']
+const supportedVersions = ['^14.0.0', '^15.0.0', '^16.0.0']
 
 export class NextCapability extends BaseCapability {
   #basePath
@@ -164,7 +163,10 @@ export class NextCapability extends BaseCapability {
   async getChildManagerContext (basePath) {
     const context = await super.getChildManagerContext(basePath)
 
+    const { major, minor } = this.#nextVersion
     context.exitOnUnhandledErrors = false
+    context.wantsAbsoluteUrls = true
+    context.nextVersion = { major, minor }
 
     return context
   }
@@ -190,16 +192,13 @@ export class NextCapability extends BaseCapability {
 
     this.childManager = new ChildManager({
       loader: loaderUrl,
-      context: {
-        ...context,
-        port: false,
-        wantsAbsoluteUrls: true
-      },
+      context: { ...context, port: false },
       scripts: this.#getChildManagerScripts()
     })
 
     const promise = once(this.childManager, 'url')
     await this.#startDevelopmentNext(serverOptions)
+
     const [url, clientWs] = await promise
     this.url = url
     this.clientWs = clientWs
@@ -235,7 +234,7 @@ export class NextCapability extends BaseCapability {
     }
   }
 
-  async #startProduction (listen) {
+  async #startProduction () {
     const config = this.config
     const loaderUrl = new URL('./loader.js', import.meta.url)
     const command = this.config.application.commands.production
@@ -253,19 +252,7 @@ export class NextCapability extends BaseCapability {
 
     this.childManager = new ChildManager({
       loader: loaderUrl,
-      context: {
-        config: this.config,
-        applicationId: this.applicationId,
-        workerId: this.workerId,
-        // Always use URL to avoid serialization problem in Windows
-        root: pathToFileURL(this.root).toString(),
-        basePath: this.#basePath,
-        logLevel: this.logger.level,
-        isEntrypoint: this.isEntrypoint,
-        runtimeBasePath: this.runtimeConfig.basePath,
-        wantsAbsoluteUrls: true,
-        telemetryConfig: this.telemetryConfig
-      },
+      context: await this.getChildManagerContext(this.#basePath),
       scripts: this.#getChildManagerScripts()
     })
 
@@ -312,7 +299,7 @@ export class NextCapability extends BaseCapability {
   #getChildManagerScripts () {
     const scripts = []
 
-    if (this.#nextVersion.major === 15) {
+    if (this.#nextVersion.major >= 15) {
       scripts.push(new URL('./loader-next-15.cjs', import.meta.url))
     }
 

package/lib/loader-next-15.cjs

@@ -42,8 +42,7 @@ fsPromises.readFile = async function readAndPatchNextConfigTS (url, options) {
 
   const { code } = transformSync(contents.toString('utf-8'), { mode: 'strip-only' })
 
-  const { transformESM, transformCJS, setLoaderData } = await import('./loader.js')
-  setLoaderData({ basePath: globalThis.platformatic.basePath, config: globalThis.platformatic.config })
+  const { transformESM, transformCJS } = await import('./loader.js')
   const transformer = detectFormat(code) === 'esm' ? transformESM : transformCJS
   const transformed = transformer(code)
 

package/lib/loader.js

@@ -11,83 +11,26 @@ import {
   variableDeclarator
 } from '@babel/types'
 import { readFile, realpath } from 'node:fs/promises'
-import { sep } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
-const originalId = '__pltOriginalNextConfig'
-
-let config
-let candidates
-let basePath = ''
+const originalId = '__pltEnhanceNextConfig'
+// Keep in sync with https://github.com/vercel/next.js/blob/main/packages/next/src/shared/lib/constants.ts
+let candidates = ['next.config.js', 'next.config.mjs']
 
 function parseSingleExpression (expr) {
   return parse(expr, { allowAwaitOutsideFunction: true }).program.body[0]
 }
 
-/*
-  Generates:
-  async function (...args) {
-    let __pltOriginalNextConfig = $ORIGINAL;
-
-    if (typeof __pltOriginalNextConfig === 'function') {
-      __pltOriginalNextConfig = await __pltOriginalNextConfig(...args);
-    }
-
-    if(typeof __pltOriginalNextConfig.basePath === 'undefined') {
-      __pltOriginalNextConfig.basePath = basePath
-    }
-
-    if(typeof __pltOriginalNextConfig.cacheHandler === 'undefined') {
-      __pltOriginalNextConfig.cacheHandler = $PATH
-      __pltOriginalNextConfig.cacheMaxMemorySize = 0
-    }
-
-    // This is to send the configuraion when Next is executed in a child process
-    globalThis.platformatic.notifyConfig(__pltOriginalNextConfig)
-
-    return __pltOriginalNextConfig;
-  }
-*/
 function createEvaluatorWrapperFunction (original) {
-  const cacheHandler = config?.cache?.adapter
-    ? fileURLToPath(new URL(`./caching/${config.cache.adapter}.js`, import.meta.url)).replaceAll(sep, '/')
-    : undefined
-
-  const trailingSlash = config?.next?.trailingSlash
-
   return functionDeclaration(
-    null,
+    identifier(originalId),
     [restElement(identifier('args'))],
-    blockStatement(
-      [
-        // This is to avoid https://github.com/vercel/next.js/issues/76981
-        parseSingleExpression("Headers.prototype[Symbol.for('nodejs.util.inspect.custom')] = undefined"),
-        variableDeclaration('let', [variableDeclarator(identifier(originalId), original)]),
-        parseSingleExpression(
-          `if (typeof ${originalId} === 'function') { ${originalId} = await ${originalId}(...args) }`
-        ),
-        parseSingleExpression(
-          `if (typeof ${originalId}.basePath === 'undefined') { ${originalId}.basePath = "${basePath}" }`
-        ),
-        cacheHandler
-          ? parseSingleExpression(`
-              if (typeof ${originalId}.cacheHandler === 'undefined') {
-                ${originalId}.cacheHandler = '${cacheHandler}'
-                ${originalId}.cacheMaxMemorySize = 0
-              }  
-            `)
-          : undefined,
-        trailingSlash
-          ? parseSingleExpression(`
-              if (typeof ${originalId}.trailingSlash === 'undefined') { 
-                ${originalId}.trailingSlash = true
-              }
-            `)
-          : undefined,
-        parseSingleExpression(`globalThis.platformatic.notifyConfig(${originalId})`),
-        returnStatement(identifier(originalId))
-      ].filter(e => e)
-    ),
+    blockStatement([
+      parseSingleExpression("const { enhanceNextConfig } = await import('@platformatic/next')"),
+      variableDeclaration('const', [variableDeclarator(identifier('original'), original)]),
+      parseSingleExpression('const enhanced = await enhanceNextConfig(original, ...args)'),
+      returnStatement(identifier('enhanced'))
+    ]),
     false,
     true
   )
@@ -143,12 +86,6 @@ export function transformESM (source) {
   return generate.default(ast).code
 }
 
-export function setLoaderData (data) {
-  candidates = data.candidates
-  basePath = data.basePath ?? ''
-  config = data.config
-}
-
 export async function initialize (data) {
   const realRoot = pathToFileURL(await realpath(fileURLToPath(data.root)))
 
@@ -156,12 +93,7 @@ export async function initialize (data) {
     realRoot.pathname += '/'
   }
 
-  setLoaderData({
-    // Keep in sync with https://github.com/vercel/next.js/blob/main/packages/next/src/shared/lib/constants.ts
-    candidates: ['next.config.js', 'next.config.mjs'].map(c => new URL(c, realRoot).toString()),
-    basePath: data.basePath ?? '',
-    config: data.config
-  })
+  candidates = candidates.map(c => new URL(c, realRoot).toString())
 }
 
 export async function load (url, context, nextLoad) {

package/lib/schema.js

@@ -19,6 +19,9 @@ export const cache = {
     prefix: {
       type: 'string'
     },
+    cacheComponents: {
+      type: 'boolean'
+    },
     maxTTL: {
       default: 86400 * 7, // One week
       anyOf: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/next",
-  "version": "3.16.0",
+  "version": "3.18.0",
   "description": "Platformatic Next.js Capability",
   "main": "index.js",
   "type": "module",
@@ -23,8 +23,8 @@
     "iovalkey": "^0.3.0",
     "msgpackr": "^1.11.2",
     "semver": "^7.6.3",
-    "@platformatic/basic": "3.16.0",
-    "@platformatic/foundation": "3.16.0"
+    "@platformatic/basic": "3.18.0",
+    "@platformatic/foundation": "3.18.0"
   },
   "devDependencies": {
     "@fastify/reply-from": "^12.0.0",
@@ -37,17 +37,21 @@
     "fastify": "^5.0.0",
     "json-schema-to-typescript": "^15.0.1",
     "neostandard": "^0.12.0",
-    "next": "^15.0.0",
+    "next": "^16.0.0",
     "typescript": "^5.5.4",
     "ws": "^8.18.0",
-    "@platformatic/gateway": "3.16.0",
-    "@platformatic/service": "3.16.0"
+    "@platformatic/service": "3.18.0",
+    "@platformatic/gateway": "3.18.0"
   },
   "engines": {
     "node": ">=22.19.0"
   },
   "scripts": {
-    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
+    "test": "npm run test:main && npm run test:caching && npm run test:compatibility && npm run test:integration",
+    "test:main": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js",
+    "test:caching": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/caching/*.test.js",
+    "test:compatibility": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/compatibility/*.test.js",
+    "test:integration": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/integration/*.test.js",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
     "build": "npm run gen-schema && npm run gen-types",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/next/3.16.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/next/3.18.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Next.js Config",
   "type": "object",
@@ -1142,8 +1142,7 @@
                 {
                   "type": "string"
                 }
-              ],
-              "default": 4294967296
+              ]
             },
             "maxYoungGeneration": {
               "anyOf": [
@@ -1915,6 +1914,9 @@
         "prefix": {
           "type": "string"
         },
+        "cacheComponents": {
+          "type": "boolean"
+        },
         "maxTTL": {
           "default": 604800,
           "anyOf": [