@platformatic/next 2.19.0-alpha.6 → 2.19.0-alpha.8

package/config.d.ts

@@ -93,10 +93,4 @@ export interface PlatformaticNextJsStackable {
       production?: string;
     };
   };
-  cache?: {
-    adapter: "redis" | "valkey";
-    url: string;
-    prefix?: string;
-    maxTTL?: number | string;
-  };
 }

package/index.js

@@ -16,14 +16,15 @@ import { once } from 'node:events'
 import { readFile } from 'node:fs/promises'
 import { dirname, resolve as pathResolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
-import { satisfies } from 'semver'
+import { parse, satisfies } from 'semver'
 import { packageJson, schema } from './lib/schema.js'
 
-const supportedVersions = '^14.0.0'
+const supportedVersions = ['^14.0.0', '^15.0.0']
 
 export class NextStackable extends BaseStackable {
   #basePath
   #next
+  #nextVersion
   #child
   #server
 
@@ -34,9 +35,10 @@ export class NextStackable extends BaseStackable {
   async init () {
     this.#next = pathResolve(dirname(resolvePackage(this.root, 'next')), '../..')
     const nextPackage = JSON.parse(await readFile(pathResolve(this.#next, 'package.json'), 'utf-8'))
+    this.#nextVersion = parse(nextPackage.version)
 
     /* c8 ignore next 3 */
-    if (!satisfies(nextPackage.version, supportedVersions)) {
+    if (!supportedVersions.some(v => satisfies(nextPackage.version, v))) {
       throw new errors.UnsupportedVersion('next', nextPackage.version, supportedVersions)
     }
   }
@@ -59,10 +61,8 @@ export class NextStackable extends BaseStackable {
       return this.stopCommand()
     }
 
-    globalThis.platformatic.events.emit('plt:next:close')
-
     if (this.isProduction) {
-      await new Promise((resolve, reject) => {
+      return new Promise((resolve, reject) => {
         this.#server.close(error => {
           /* c8 ignore next 3 */
           if (error) {
@@ -72,8 +72,6 @@ export class NextStackable extends BaseStackable {
           resolve()
         })
       })
-
-      await this.childManager.close()
     } else {
       const exitPromise = once(this.#child, 'exit')
       await this.childManager.close()
@@ -83,6 +81,10 @@ export class NextStackable extends BaseStackable {
   }
 
   async build () {
+    if (!this.#nextVersion) {
+      await this.init()
+    }
+
     const config = this.configManager.current
     const loader = new URL('./lib/loader.js', import.meta.url)
     this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
@@ -94,14 +96,13 @@ export class NextStackable extends BaseStackable {
       command = ['node', pathResolve(this.#next, './dist/bin/next'), 'build', this.root]
     }
 
-    return this.buildWithCommand(command, this.#basePath, loader)
+    return this.buildWithCommand(command, this.#basePath, loader, this.#getChildManagerScripts())
   }
 
   /* c8 ignore next 5 */
   async getWatchConfig () {
     return {
-      enabled: false,
-      path: this.root
+      enabled: false
     }
   }
 
@@ -124,7 +125,7 @@ export class NextStackable extends BaseStackable {
     this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
 
     if (command) {
-      return this.startWithCommand(command, loaderUrl)
+      return this.startWithCommand(command, loaderUrl, this.#getChildManagerScripts())
     }
 
     const { hostname, port } = this.serverConfig ?? {}
@@ -136,7 +137,6 @@ export class NextStackable extends BaseStackable {
     this.childManager = new ChildManager({
       loader: loaderUrl,
       context: {
-        config: this.configManager.current,
         serviceId: this.serviceId,
         workerId: this.workerId,
         // Always use URL to avoid serialization problem in Windows
@@ -148,7 +148,8 @@ export class NextStackable extends BaseStackable {
         runtimeBasePath: this.runtimeConfig.basePath,
         wantsAbsoluteUrls: true,
         telemetryConfig: this.telemetryConfig
-      }
+      },
+      scripts: this.#getChildManagerScripts()
     })
 
     const promise = once(this.childManager, 'url')
@@ -168,7 +169,17 @@ export class NextStackable extends BaseStackable {
     try {
       await this.childManager.inject()
       const childPromise = createChildProcessListener()
-      await nextDev(serverOptions, 'default', this.root)
+
+      if (this.#nextVersion.major === 14 && this.#nextVersion.minor < 2) {
+        await nextDev({
+          '--hostname': serverOptions.host,
+          '--port': serverOptions.port,
+          _: [this.root]
+        })
+      } else {
+        await nextDev(serverOptions, 'default', this.root)
+      }
+
       this.#child = await childPromise
     } finally {
       await this.childManager.eject()
@@ -183,13 +194,12 @@ export class NextStackable extends BaseStackable {
     this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
 
     if (command) {
-      return this.startWithCommand(command, loaderUrl)
+      return this.startWithCommand(command, loaderUrl, this.#getChildManagerScripts())
     }
 
     this.childManager = new ChildManager({
       loader: loaderUrl,
       context: {
-        config: this.configManager.current,
         serviceId: this.serviceId,
         workerId: this.workerId,
         // Always use URL to avoid serialization problem in Windows
@@ -200,7 +210,8 @@ export class NextStackable extends BaseStackable {
         runtimeBasePath: this.runtimeConfig.basePath,
         wantsAbsoluteUrls: true,
         telemetryConfig: this.telemetryConfig
-      }
+      },
+      scripts: this.#getChildManagerScripts()
     })
 
     this.verifyOutputDirectory(pathResolve(this.root, '.next'))
@@ -209,7 +220,6 @@ export class NextStackable extends BaseStackable {
 
   async #startProductionNext () {
     try {
-      globalThis.platformatic.config = this.configManager.current
       await this.childManager.inject()
       const { nextStart } = await importFile(pathResolve(this.#next, './dist/cli/next-start.js'))
 
@@ -230,7 +240,15 @@ export class NextStackable extends BaseStackable {
         (this.isEntrypoint ? serverOptions?.hostname : undefined) ?? true
       )
 
-      await nextStart(serverOptions, this.root)
+      if (this.#nextVersion.major === 14 && this.#nextVersion.minor < 2) {
+        await nextStart({
+          '--hostname': serverOptions.host,
+          '--port': serverOptions.port,
+          _: [this.root]
+        })
+      } else {
+        await nextStart(serverOptions, this.root)
+      }
 
       this.#server = await serverPromise
       this.url = getServerUrl(this.#server)
@@ -238,6 +256,16 @@ export class NextStackable extends BaseStackable {
       await this.childManager.eject()
     }
   }
+
+  #getChildManagerScripts () {
+    const scripts = []
+
+    if (this.#nextVersion.major === 15) {
+      scripts.push(new URL('./lib/loader-next-15.cjs', import.meta.url))
+    }
+
+    return scripts
+  }
 }
 
 /* c8 ignore next 9 */
@@ -250,10 +278,6 @@ function transformConfig () {
     this.current.watch = { enabled: this.current.watch || false }
   }
 
-  if (this.current.cache?.adapter === 'redis') {
-    this.current.cache.adapter = 'valkey'
-  }
-
   basicTransformConfig.call(this)
 }
 

package/lib/loader-next-15.cjs

@@ -0,0 +1,52 @@
+const { resolve } = require('node:path')
+const { fileURLToPath } = require('node:url')
+const fsPromises = require('node:fs').promises
+const { transformSync } = require('amaro')
+const { parse } = require('@babel/parser')
+const traverse = require('@babel/traverse')
+
+const originalReadFile = fsPromises.readFile
+const targetFile = resolve(fileURLToPath(globalThis.platformatic.root), 'next.config.ts')
+
+function detectFormat (code) {
+  let format = 'esm'
+
+  const ast = parse(code, { sourceType: 'module' })
+
+  // Manipulate the AST
+  traverse.default(ast, {
+    AssignmentExpression (path) {
+      const { left } = path.node
+
+      // module.exports = $EXPRESSION
+      if (left.object.name === 'module' && left.property.name === 'exports') {
+        format = 'cjs'
+        path.stop()
+      }
+    }
+  })
+
+  return format
+}
+
+fsPromises.readFile = async function WTF (url, options) {
+  if (url.startsWith('file://')) {
+    url = fileURLToPath(url)
+  }
+
+  const contents = await originalReadFile(url, options)
+
+  if (url !== targetFile) {
+    return contents
+  }
+
+  const { code } = transformSync(contents.toString('utf-8'), { mode: 'strip-only' })
+
+  const { transformESM, transformCJS } = await import('./loader.js')
+  const transformer = detectFormat(code) === 'esm' ? transformESM : transformCJS
+  const transformed = transformer(code)
+
+  // Restore the original method
+  fsPromises.readFile = originalReadFile
+  return transformed
+}

package/lib/loader.js

@@ -11,14 +11,12 @@ 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
+let basePath = ''
 
 function parseSingleExpression (expr) {
   return parse(expr, { allowAwaitOutsideFunction: true }).program.body[0]
@@ -37,11 +35,6 @@ function parseSingleExpression (expr) {
       __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 (development)
     globalThis[Symbol.for('plt.children.itc')]?.notify('config', __pltOriginalNextConfig)
 
@@ -52,41 +45,27 @@ function parseSingleExpression (expr) {
   }
 */
 function createEvaluatorWrapperFunction (original) {
-  const cacheHandler = config?.cache
-    ? fileURLToPath(new URL(`./caching/${config.cache.adapter ?? 'foo'}.js`, import.meta.url)).replaceAll(sep, '/')
-    : undefined
-
   return functionDeclaration(
     null,
     [restElement(identifier('args'))],
-    blockStatement(
-      [
-        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,
-        parseSingleExpression(`globalThis[Symbol.for('plt.children.itc')]?.notify('config', ${originalId})`),
-        parseSingleExpression(`process.emit('plt:next:config', ${originalId})`),
-        returnStatement(identifier(originalId))
-      ].filter(e => e)
-    ),
+    blockStatement([
+      variableDeclaration('let', [variableDeclarator(identifier(originalId), original)]),
+      parseSingleExpression(
+        `if (typeof ${originalId} === 'function') { ${originalId} = await ${originalId}(...args) }`
+      ),
+      parseSingleExpression(
+        `if (typeof ${originalId}.basePath === 'undefined') { ${originalId}.basePath = "${basePath}" }`
+      ),
+      parseSingleExpression(`globalThis[Symbol.for('plt.children.itc')]?.notify('config', ${originalId})`),
+      parseSingleExpression(`process.emit('plt:next:config', ${originalId})`),
+      returnStatement(identifier(originalId))
+    ]),
     false,
     true
   )
 }
 
-function transformCJS (source) {
+export function transformCJS (source) {
   const ast = parse(source.toString(), { sourceType: 'module' })
 
   // Manipulate the AST
@@ -105,7 +84,7 @@ function transformCJS (source) {
   return generate.default(ast).code
 }
 
-function transformESM (source) {
+export function transformESM (source) {
   const ast = parse(source.toString(), { sourceType: 'module' })
 
   // Manipulate the AST
@@ -146,7 +125,6 @@ export async function initialize (data) {
   // 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
 }
 
 export async function load (url, context, nextLoad) {

package/lib/schema.js

@@ -4,36 +4,6 @@ import { readFileSync } from 'node:fs'
 
 export const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'))
 
-export const cache = {
-  type: 'object',
-  properties: {
-    adapter: {
-      type: 'string',
-      enum: ['redis', 'valkey']
-    },
-    url: {
-      type: 'string'
-    },
-    prefix: {
-      type: 'string'
-    },
-    maxTTL: {
-      default: 86400 * 7, // One week
-      anyOf: [
-        {
-          type: 'number',
-          minimum: 0
-        },
-        {
-          type: 'string'
-        }
-      ]
-    }
-  },
-  required: ['adapter', 'url'],
-  additionalProperties: false
-}
-
 export const schema = {
   $id: `https://schemas.platformatic.dev/@platformatic/next/${packageJson.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
@@ -46,8 +16,7 @@ export const schema = {
     logger: utilsSchemaComponents.logger,
     server: utilsSchemaComponents.server,
     watch: schemaComponents.watch,
-    application: schemaComponents.application,
-    cache
+    application: schemaComponents.application
   },
   additionalProperties: false
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/next",
-  "version": "2.19.0-alpha.6",
+  "version": "2.19.0-alpha.8",
   "description": "Platformatic Next.js Stackable",
   "main": "index.js",
   "type": "module",
@@ -19,27 +19,28 @@
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
     "@babel/types": "^7.25.2",
-    "iovalkey": "^0.2.1",
-    "msgpackr": "^1.11.2",
+    "amaro": "^0.2.0",
     "semver": "^7.6.3",
-    "@platformatic/basic": "2.19.0-alpha.6",
-    "@platformatic/utils": "2.19.0-alpha.6",
-    "@platformatic/config": "2.19.0-alpha.6"
+    "@platformatic/basic": "2.19.0-alpha.8",
+    "@platformatic/config": "2.19.0-alpha.8",
+    "@platformatic/utils": "2.19.0-alpha.8"
   },
   "devDependencies": {
     "@fastify/reply-from": "^11.0.0",
+    "@types/node": "^22.5.0",
     "borp": "^0.19.0",
     "eslint": "9",
+    "execa": "^9.5.1",
     "fastify": "^5.0.0",
     "json-schema-to-typescript": "^15.0.1",
     "neostandard": "^0.11.1",
-    "next": "^14.2.5",
+    "next": "^15.0.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "typescript": "^5.5.4",
     "ws": "^8.18.0",
-    "@platformatic/composer": "2.19.0-alpha.6",
-    "@platformatic/service": "2.19.0-alpha.6"
+    "@platformatic/composer": "2.19.0-alpha.8",
+    "@platformatic/service": "2.19.0-alpha.8"
   },
   "scripts": {
     "test": "npm run lint && borp --concurrency=1 --no-timeout",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/next/2.19.0-alpha.6.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/next/2.19.0-alpha.8.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Next.js Stackable",
   "type": "object",
@@ -296,41 +296,6 @@
       },
       "additionalProperties": false,
       "default": {}
-    },
-    "cache": {
-      "type": "object",
-      "properties": {
-        "adapter": {
-          "type": "string",
-          "enum": [
-            "redis",
-            "valkey"
-          ]
-        },
-        "url": {
-          "type": "string"
-        },
-        "prefix": {
-          "type": "string"
-        },
-        "maxTTL": {
-          "default": 604800,
-          "anyOf": [
-            {
-              "type": "number",
-              "minimum": 0
-            },
-            {
-              "type": "string"
-            }
-          ]
-        }
-      },
-      "required": [
-        "adapter",
-        "url"
-      ],
-      "additionalProperties": false
     }
   },
   "additionalProperties": false

package/lib/caching/valkey.js

@@ -1,229 +0,0 @@
-import { ensureLoggableError } from '@platformatic/utils'
-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'
-
-export const MAX_BATCH_SIZE = 100
-
-const sections = {
-  values: 'values',
-  tags: 'tags'
-}
-
-const clients = new Map()
-
-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 {
-  #config
-  #logger
-  #store
-  #subprefix
-  #maxTTL
-
-  constructor () {
-    this.#logger = this.#createLogger()
-    this.#config = globalThis.platformatic.config.cache
-    this.#store = getConnection(this.#config.url)
-    this.#maxTTL = this.#config.maxTTL
-    this.#subprefix = this.#getSubprefix()
-  }
-
-  async get (cacheKey) {
-    this.#logger.trace({ key: cacheKey }, 'get')
-
-    const key = this.#keyFor(cacheKey, sections.values)
-
-    let rawValue
-    try {
-      rawValue = await this.#store.get(key)
-
-      if (!rawValue) {
-        return
-      }
-    } catch (e) {
-      this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot read cache value from Valkey')
-      throw new Error('Cannot read cache value from Valkey', { cause: e })
-    }
-
-    let value
-    try {
-      value = this.#deserialize(rawValue)
-    } catch (e) {
-      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)
-
-      throw new Error('Cannot deserialize cache value from Valkey', { cause: e })
-    }
-
-    if (this.#maxTTL < value.revalidate) {
-      try {
-        await this.#refreshKey(key, value)
-      } catch (e) {
-        this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot refresh cache key expiration in Valkey')
-
-        // We don't throw here since we want to use the cached value anyway
-      }
-    }
-
-    return value
-  }
-
-  async set (cacheKey, value, { tags, revalidate }) {
-    this.#logger.trace({ key: cacheKey, value, tags, revalidate }, 'set')
-
-    try {
-      // Compute the parameters to save
-      const key = this.#keyFor(cacheKey, sections.values)
-      const data = this.#serialize({ value, tags, lastModified: Date.now(), revalidate, maxTTL: this.#maxTTL })
-      const expire = Math.min(revalidate, this.#maxTTL)
-
-      if (expire < 1) {
-        return
-      }
-
-      // Enqueue all the operations to perform in Valkey
-
-      const promises = []
-      promises.push(this.#store.set(key, data, '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 revalidateTag (tags) {
-    this.#logger.trace({ tags }, 'revalidateTag')
-
-    if (typeof tags === 'string') {
-      tags = [tags]
-    }
-
-    try {
-      let promises = []
-
-      for (const tag of tags) {
-        const tagsKey = this.#keyFor(tag, sections.tags)
-
-        // For each key in the tag set, expire the key
-        for await (const keys of this.#store.sscanStream(tagsKey)) {
-          for (const key of keys) {
-            promises.push(this.#store.del(key))
-
-            // Batch full, execute it
-            if (promises.length >= MAX_BATCH_SIZE) {
-              await Promise.all(promises)
-              promises = []
-            }
-          }
-        }
-
-        // Delete the set, this will also take care of executing pending operation for a non full batch
-        promises.push(this.#store.del(tagsKey))
-        await Promise.all(promises)
-        promises = []
-      }
-    } catch (e) {
-      this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot expire cache tags in Valkey')
-      throw new Error('Cannot expire cache tags in Valkey', { cause: e })
-    }
-  }
-
-  async #refreshKey (key, value) {
-    const life = Math.round((Date.now() - value.lastModified) / 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)
-  }
-
-  #createLogger () {
-    const pinoOptions = {
-      level: globalThis.platformatic?.logLevel ?? 'info'
-    }
-
-    if (this.serviceId) {
-      pinoOptions.name = `cache:${this.serviceId}`
-    }
-
-    if (typeof globalThis.platformatic.workerId !== 'undefined') {
-      pinoOptions.base = { pid: process.pid, hostname: hostname(), worker: this.workerId }
-    }
-
-    return pino(pinoOptions)
-  }
-
-  #getSubprefix () {
-    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'
-  }
-
-  #keyFor (key, section) {
-    return keyFor(this.#config.prefix, this.#subprefix, section, key)
-  }
-
-  #serialize (data) {
-    return pack(data).toString('base64url')
-  }
-
-  #deserialize (data) {
-    return unpack(Buffer.from(data, 'base64url'))
-  }
-}
-
-export default CacheHandler