@platformatic/next 2.72.0 → 3.0.0-alpha.1

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export interface PlatformaticNextJsStackable {
+export interface PlatformaticNextJsConfig {
   $schema?: string;
   logger?: {
     level: (

package/index.js

@@ -1,361 +1,37 @@
-import {
-  BaseStackable,
-  transformConfig as basicTransformConfig,
-  ChildManager,
-  cleanBasePath,
-  createChildProcessListener,
-  createServerListener,
-  errors,
-  getServerUrl,
-  importFile,
-  resolvePackage,
-  schemaOptions
-} from '@platformatic/basic'
-import { ConfigManager } from '@platformatic/config'
-import { ChildProcess } from 'node:child_process'
-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 { parse, satisfies } from 'semver'
-import { packageJson, schema } from './lib/schema.js'
-
-const supportedVersions = ['^14.0.0', '^15.0.0']
-
-export * as cachingValkey from './lib/caching/valkey.js'
-
-export class NextStackable extends BaseStackable {
-  #basePath
-  #next
-  #nextVersion
-  #child
-  #server
-
-  constructor (options, root, configManager) {
-    super('next', packageJson.version, options, root, configManager)
-  }
-
-  async init () {
-    // This is needed to avoid Next.js to throw an error when the lockfile is not correct
-    // and the user is using npm but has pnpm in its $PATH.
-    //
-    // See: https://github.com/platformatic/composer-next-node-fastify/pull/3
-    //
-    // PS by Paolo: Sob.
-    process.env.NEXT_IGNORE_INCORRECT_LOCKFILE = 'true'
-
-    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)
-
-    if (this.#nextVersion.major < 15 || (this.#nextVersion.major <= 15 && this.#nextVersion.minor < 1)) {
-      await import('./lib/create-context-patch.js')
-    }
-
-    /* c8 ignore next 3 */
-    if (!supportedVersions.some(v => satisfies(nextPackage.version, v))) {
-      throw new errors.UnsupportedVersion('next', nextPackage.version, supportedVersions)
-    }
-  }
-
-  async start ({ listen }) {
-    // Make this idempotent
-    if (this.url) {
-      return this.url
-    }
-
-    this.on('config', config => {
-      this.#basePath = config.basePath
-    })
-
-    if (this.isProduction) {
-      await this.#startProduction(listen)
-    } else {
-      await this.#startDevelopment(listen)
-    }
-
-    await this._collectMetrics()
-  }
-
-  async stop () {
-    if (this.subprocess) {
-      return this.stopCommand()
-    }
-
-    globalThis.platformatic.events.emit('plt:next:close')
-
-    if (this.isProduction) {
-      await new Promise((resolve, reject) => {
-        this.#server.close(error => {
-          /* c8 ignore next 3 */
-          if (error) {
-            return reject(error)
-          }
-
-          resolve()
-        })
-      })
-
-      await this.childManager.close()
-    } else {
-      const exitPromise = once(this.#child, 'exit')
-      await this.childManager.close()
-      process.kill(this.#child.pid, 'SIGKILL')
-      await exitPromise
-    }
-  }
-
-  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) : ''
-
-    let command = config.application.commands.build
-
-    if (!command) {
-      await this.init()
-      command = ['node', pathResolve(this.#next, './dist/bin/next'), 'build', this.root]
-    }
-
-    return this.buildWithCommand(command, this.#basePath, { loader, scripts: this.#getChildManagerScripts() })
-  }
-
-  /* c8 ignore next 5 */
-  async getWatchConfig () {
-    return {
-      enabled: false,
-      path: this.root
-    }
-  }
-
-  getMeta () {
-    const composer = { prefix: this.basePath ?? this.#basePath, wantsAbsoluteUrls: true, needsRootTrailingSlash: false }
-
-    if (this.url) {
-      composer.tcp = true
-      composer.url = this.url
-    }
-
-    return { composer }
-  }
-
-  async #startDevelopment () {
-    const config = this.configManager.current
-    const loaderUrl = new URL('./lib/loader.js', import.meta.url)
-    const command = this.configManager.current.application.commands.development
-
-    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
-
-    if (command) {
-      return this.startWithCommand(command, loaderUrl, this.#getChildManagerScripts())
-    }
-
-    const { hostname, port } = this.serverConfig ?? {}
-    const serverOptions = {
-      host: hostname || '127.0.0.1',
-      port: port || 0
-    }
-
-    const context = await this.getChildManagerContext(this.#basePath)
-
-    this.childManager = new ChildManager({
-      loader: loaderUrl,
-      context: {
-        ...context,
-        port: false,
-        wantsAbsoluteUrls: true
-      },
-      scripts: this.#getChildManagerScripts()
-    })
-
-    const promise = once(this.childManager, 'url')
-    await this.#startDevelopmentNext(serverOptions)
-    const [url, clientWs] = await promise
-    this.url = url
-    this.clientWs = clientWs
-  }
-
-  async #startDevelopmentNext (serverOptions) {
-    const { nextDev } = await importFile(pathResolve(this.#next, './dist/cli/next-dev.js'))
-
-    try {
-      await this.childManager.inject()
-      const childPromise = createChildProcessListener()
-
-      this.#ensurePipeableStreamsInFork()
-
-      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
-      this.#child.stdout.setEncoding('utf8')
-      this.#child.stderr.setEncoding('utf8')
-
-      this.#child.stdout.pipe(process.stdout, { end: false })
-      this.#child.stderr.pipe(process.stderr, { end: false })
-    } finally {
-      await this.childManager.eject()
-    }
-  }
-
-  async #startProduction (listen) {
-    const config = this.configManager.current
-    const loaderUrl = new URL('./lib/loader.js', import.meta.url)
-    const command = this.configManager.current.application.commands.production
-
-    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
-
-    if (command) {
-      const childManagerScripts = this.#getChildManagerScripts()
-
-      if (this.#nextVersion.major < 15 || (this.#nextVersion.major <= 15 && this.#nextVersion.minor < 1)) {
-        childManagerScripts.push(new URL('./lib/create-context-patch.js', import.meta.url))
-      }
-      return this.startWithCommand(command, loaderUrl, childManagerScripts)
-    }
-
-    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
-        root: pathToFileURL(this.root).toString(),
-        basePath: this.#basePath,
-        logLevel: this.logger.level,
-        isEntrypoint: this.isEntrypoint,
-        runtimeBasePath: this.runtimeConfig.basePath,
-        wantsAbsoluteUrls: true,
-        telemetryConfig: this.telemetryConfig
-      },
-      scripts: this.#getChildManagerScripts()
-    })
-
-    this.verifyOutputDirectory(pathResolve(this.root, '.next'))
-    await this.#startProductionNext()
-  }
-
-  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'))
-
-      const { hostname, port } = this.serverConfig ?? {}
-      const serverOptions = {
-        hostname: hostname || '127.0.0.1',
-        port: port || 0
-      }
-
-      this.childManager.register()
-      const serverPromise = createServerListener(
-        (this.isEntrypoint ? serverOptions?.port : undefined) ?? true,
-        (this.isEntrypoint ? serverOptions?.hostname : undefined) ?? true
-      )
-
-      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)
-    } finally {
-      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
-  }
-
-  // In development mode, Next.js starts the dev server using child_process.fork with stdio set to 'inherit'.
-  // In order to capture the output, we need to ensure that the streams are pipeable and thus we perform a one-time
-  // monkey-patch of the ChildProcess.prototype.spawn method to override stdio[1] and stdio[2] to 'pipe'.
-  #ensurePipeableStreamsInFork () {
-    const originalSpawn = ChildProcess.prototype.spawn
-
-    // IMPORTANT: If Next.js code changes this might not work anymore. When this gives error, dig into Next.js code
-    // to evaluate the new path and/or if this is still necessary.
-    const startServerPath = pathResolve(this.#next, './dist/server/lib/start-server.js')
-
-    ChildProcess.prototype.spawn = function (options) {
-      if (options.args?.[1] === startServerPath) {
-        options.stdio[1] = 'pipe'
-        options.stdio[2] = 'pipe'
-
-        // Uninstall the patch
-        ChildProcess.prototype.spawn = originalSpawn
-      }
-
-      return originalSpawn.call(this, options)
-    }
-  }
-}
+import { transform as basicTransform, resolve, validationOptions } from '@platformatic/basic'
+import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/utils'
+import { schema } from './lib/schema.js'
+import { NextStackable } from './lib/stackable.js'
 
 /* c8 ignore next 9 */
-function transformConfig () {
-  if (this.current.watch === undefined) {
-    this.current.watch = { enabled: false }
-  }
+export async function transform (config, schema, options) {
+  config = await basicTransform(config, schema, options)
+  config.watch = { enabled: false }
 
-  if (typeof this.current.watch !== 'object') {
-    this.current.watch = { enabled: this.current.watch || false }
+  if (config.cache?.adapter === 'redis') {
+    config.cache.adapter = 'valkey'
   }
 
-  if (this.current.cache?.adapter === 'redis') {
-    this.current.cache.adapter = 'valkey'
-  }
-
-  return basicTransformConfig.call(this)
+  return config
 }
 
-export async function buildStackable (opts) {
-  const root = opts.context.directory
+export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'application')
 
-  const configManager = new ConfigManager({
-    schema,
-    source: opts.config ?? {},
-    schemaOptions,
-    transformConfig,
-    dirname: root,
-    context: opts.context
+  return utilsLoadConfiguration(source, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    replaceEnv: true,
+    root,
+    ...context
   })
-  await configManager.parseAndValidate()
-
-  return new NextStackable(opts, root, configManager)
 }
 
-export default {
-  configType: 'next',
-  configManagerConfig: {
-    schemaOptions,
-    transformConfig
-  },
-  buildStackable,
-  schema,
-  version: packageJson.version
+export async function create (configOrRoot, sourceOrConfig, context) {
+  const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
+  return new NextStackable(config[kMetadata].root, config, context)
 }
+
+export * as cachingValkey from './lib/caching/valkey.js'
+export { packageJson, schema, schemaComponents, version } from './lib/schema.js'
+export * from './lib/stackable.js'

package/lib/schema.js

@@ -1,8 +1,10 @@
-import { schemaComponents } from '@platformatic/basic'
+import { schemaComponents as basicSchemaComponents } from '@platformatic/basic'
 import { schemaComponents as utilsSchemaComponents } from '@platformatic/utils'
 import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 
-export const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'))
+export const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf8'))
+export const version = packageJson.version
 
 export const cache = {
   type: 'object',
@@ -46,10 +48,12 @@ const next = {
   additionalProperties: false
 }
 
+export const schemaComponents = { next }
+
 export const schema = {
   $id: `https://schemas.platformatic.dev/@platformatic/next/${packageJson.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'Platformatic Next.js Stackable',
+  title: 'Platformatic Next.js Config',
   type: 'object',
   properties: {
     $schema: {
@@ -57,8 +61,8 @@ export const schema = {
     },
     logger: utilsSchemaComponents.logger,
     server: utilsSchemaComponents.server,
-    watch: schemaComponents.watch,
-    application: schemaComponents.application,
+    watch: basicSchemaComponents.watch,
+    application: basicSchemaComponents.application,
     runtime: utilsSchemaComponents.wrappedRuntime,
     next,
     cache

package/lib/stackable.js

@@ -0,0 +1,329 @@
+import {
+  BaseStackable,
+  ChildManager,
+  cleanBasePath,
+  createChildProcessListener,
+  createServerListener,
+  errors,
+  getServerUrl,
+  importFile,
+  resolvePackage
+} from '@platformatic/basic'
+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']
+
+export class NextStackable extends BaseStackable {
+  #basePath
+  #next
+  #nextVersion
+  #child
+  #server
+
+  constructor (root, config, context) {
+    super('next', version, root, config, context)
+  }
+
+  async init () {
+    await super.init()
+
+    // This is needed to avoid Next.js to throw an error when the lockfile is not correct
+    // and the user is using npm but has pnpm in its $PATH.
+    //
+    // See: https://github.com/platformatic/composer-next-node-fastify/pull/3
+    //
+    // PS by Paolo: Sob.
+    process.env.NEXT_IGNORE_INCORRECT_LOCKFILE = 'true'
+
+    this.#next = resolvePath(dirname(resolvePackage(this.root, 'next')), '../..')
+    const nextPackage = JSON.parse(await readFile(resolvePath(this.#next, 'package.json'), 'utf-8'))
+    this.#nextVersion = parse(nextPackage.version)
+
+    if (this.#nextVersion.major < 15 || (this.#nextVersion.major <= 15 && this.#nextVersion.minor < 1)) {
+      await import('./create-context-patch.js')
+    }
+
+    /* c8 ignore next 3 */
+    if (!supportedVersions.some(v => satisfies(nextPackage.version, v))) {
+      throw new errors.UnsupportedVersion('next', nextPackage.version, supportedVersions)
+    }
+  }
+
+  async start ({ listen }) {
+    // Make this idempotent
+    if (this.url) {
+      return this.url
+    }
+
+    this.on('config', config => {
+      this.#basePath = config.basePath
+    })
+
+    if (this.isProduction) {
+      await this.#startProduction(listen)
+    } else {
+      await this.#startDevelopment(listen)
+    }
+
+    await this._collectMetrics()
+  }
+
+  async stop () {
+    if (this.subprocess) {
+      return this.stopCommand()
+    }
+
+    globalThis.platformatic.events.emit('plt:next:close')
+
+    if (this.isProduction) {
+      await new Promise((resolve, reject) => {
+        this.#server.close(error => {
+          /* c8 ignore next 3 */
+          if (error) {
+            return reject(error)
+          }
+
+          resolve()
+        })
+      })
+
+      await this.childManager.close()
+    } else {
+      const exitPromise = once(this.#child, 'exit')
+      await this.childManager.close()
+      process.kill(this.#child.pid, 'SIGKILL')
+      await exitPromise
+    }
+  }
+
+  async build () {
+    if (!this.#nextVersion) {
+      await this.init()
+    }
+
+    const config = this.config
+    const loader = new URL('./loader.js', import.meta.url)
+    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
+
+    let command = config.application.commands.build
+
+    if (!command) {
+      await this.init()
+      command = ['node', resolvePath(this.#next, './dist/bin/next'), 'build', this.root]
+    }
+
+    await this.buildWithCommand(command, this.#basePath, { loader, scripts: this.#getChildManagerScripts() })
+
+    // This is need to avoid Next.js 15.4+ to throw an error as process.cwd() is not the root of the Next.js application
+    if (
+      config.cache?.adapter &&
+      (this.#nextVersion.major > 15 || (this.#nextVersion.major === 15 && this.#nextVersion.minor >= 4))
+    ) {
+      const distDir = resolvePath(this.root, '.next')
+      const requiredServerFilesPath = resolvePath(distDir, 'required-server-files.json')
+      const requiredServerFiles = JSON.parse(await readFile(requiredServerFilesPath, 'utf-8'))
+
+      if (requiredServerFiles.config.cacheHandler) {
+        requiredServerFiles.config.cacheHandler = resolvePath(distDir, requiredServerFiles.config.cacheHandler)
+        await writeFile(requiredServerFilesPath, JSON.stringify(requiredServerFiles, null, 2))
+      }
+    }
+  }
+
+  /* c8 ignore next 5 */
+  async getWatchConfig () {
+    return {
+      enabled: false,
+      path: this.root
+    }
+  }
+
+  getMeta () {
+    const composer = { prefix: this.basePath ?? this.#basePath, wantsAbsoluteUrls: true, needsRootTrailingSlash: false }
+
+    if (this.url) {
+      composer.tcp = true
+      composer.url = this.url
+    }
+
+    return { composer }
+  }
+
+  async #startDevelopment () {
+    const config = this.config
+    const loaderUrl = new URL('./loader.js', import.meta.url)
+    const command = this.config.application.commands.development
+
+    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
+
+    if (command) {
+      return this.startWithCommand(command, loaderUrl, this.#getChildManagerScripts())
+    }
+
+    const { hostname, port } = this.serverConfig ?? {}
+    const serverOptions = {
+      host: hostname || '127.0.0.1',
+      port: port || 0
+    }
+
+    const context = await this.getChildManagerContext(this.#basePath)
+
+    this.childManager = new ChildManager({
+      loader: loaderUrl,
+      context: {
+        ...context,
+        port: false,
+        wantsAbsoluteUrls: true
+      },
+      scripts: this.#getChildManagerScripts()
+    })
+
+    const promise = once(this.childManager, 'url')
+    await this.#startDevelopmentNext(serverOptions)
+    const [url, clientWs] = await promise
+    this.url = url
+    this.clientWs = clientWs
+  }
+
+  async #startDevelopmentNext (serverOptions) {
+    const { nextDev } = await importFile(resolvePath(this.#next, './dist/cli/next-dev.js'))
+
+    try {
+      await this.childManager.inject()
+      const childPromise = createChildProcessListener()
+
+      this.#ensurePipeableStreamsInFork()
+
+      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
+      this.#child.stdout.setEncoding('utf8')
+      this.#child.stderr.setEncoding('utf8')
+
+      this.#child.stdout.pipe(process.stdout, { end: false })
+      this.#child.stderr.pipe(process.stderr, { end: false })
+    } finally {
+      await this.childManager.eject()
+    }
+  }
+
+  async #startProduction (listen) {
+    const config = this.config
+    const loaderUrl = new URL('./loader.js', import.meta.url)
+    const command = this.config.application.commands.production
+
+    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
+
+    if (command) {
+      const childManagerScripts = this.#getChildManagerScripts()
+
+      if (this.#nextVersion.major < 15 || (this.#nextVersion.major <= 15 && this.#nextVersion.minor < 1)) {
+        childManagerScripts.push(new URL('./create-context-patch.js', import.meta.url))
+      }
+      return this.startWithCommand(command, loaderUrl, childManagerScripts)
+    }
+
+    this.childManager = new ChildManager({
+      loader: loaderUrl,
+      context: {
+        config: this.config,
+        serviceId: this.serviceId,
+        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
+      },
+      scripts: this.#getChildManagerScripts()
+    })
+
+    this.verifyOutputDirectory(resolvePath(this.root, '.next'))
+    await this.#startProductionNext()
+  }
+
+  async #startProductionNext () {
+    try {
+      globalThis.platformatic.config = this.config
+      await this.childManager.inject()
+      const { nextStart } = await importFile(resolvePath(this.#next, './dist/cli/next-start.js'))
+
+      const { hostname, port } = this.serverConfig ?? {}
+      const serverOptions = {
+        hostname: hostname || '127.0.0.1',
+        port: port || 0
+      }
+
+      this.childManager.register()
+      const serverPromise = createServerListener(
+        (this.isEntrypoint ? serverOptions?.port : undefined) ?? true,
+        (this.isEntrypoint ? serverOptions?.hostname : undefined) ?? true
+      )
+
+      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)
+    } finally {
+      await this.childManager.eject()
+    }
+  }
+
+  #getChildManagerScripts () {
+    const scripts = []
+
+    if (this.#nextVersion.major === 15) {
+      scripts.push(new URL('./loader-next-15.cjs', import.meta.url))
+    }
+
+    return scripts
+  }
+
+  // In development mode, Next.js starts the dev server using child_process.fork with stdio set to 'inherit'.
+  // In order to capture the output, we need to ensure that the streams are pipeable and thus we perform a one-time
+  // monkey-patch of the ChildProcess.prototype.spawn method to override stdio[1] and stdio[2] to 'pipe'.
+  #ensurePipeableStreamsInFork () {
+    const originalSpawn = ChildProcess.prototype.spawn
+
+    // IMPORTANT: If Next.js code changes this might not work anymore. When this gives error, dig into Next.js code
+    // to evaluate the new path and/or if this is still necessary.
+    const startServerPath = resolvePath(this.#next, './dist/server/lib/start-server.js')
+
+    ChildProcess.prototype.spawn = function (options) {
+      if (options.args?.[1] === startServerPath) {
+        options.stdio[1] = 'pipe'
+        options.stdio[2] = 'pipe'
+
+        // Uninstall the patch
+        ChildProcess.prototype.spawn = originalSpawn
+      }
+
+      return originalSpawn.call(this, options)
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/next",
-  "version": "2.72.0",
+  "version": "3.0.0-alpha.1",
   "description": "Platformatic Next.js Stackable",
   "main": "index.js",
   "type": "module",
@@ -23,9 +23,8 @@
     "iovalkey": "^0.3.0",
     "msgpackr": "^1.11.2",
     "semver": "^7.6.3",
-    "@platformatic/basic": "2.72.0",
-    "@platformatic/config": "2.72.0",
-    "@platformatic/utils": "2.72.0"
+    "@platformatic/basic": "3.0.0-alpha.1",
+    "@platformatic/utils": "3.0.0-alpha.1"
   },
   "devDependencies": {
     "@fastify/reply-from": "^12.0.0",
@@ -39,12 +38,12 @@
     "next": "^15.0.0",
     "typescript": "^5.5.4",
     "ws": "^8.18.0",
-    "@platformatic/composer": "2.72.0",
-    "@platformatic/service": "2.72.0"
+    "@platformatic/composer": "3.0.0-alpha.1",
+    "@platformatic/service": "3.0.0-alpha.1"
   },
   "scripts": {
-    "test": "npm run lint && borp --concurrency=1 --no-timeout",
-    "coverage": "npm run lint && borp -C -X test -X test/fixtures --concurrency=1 --no-timeout",
+    "test": "npm run lint && borp --concurrency=1 --timeout 1200000",
+    "coverage": "npm run lint && borp -C -X test -X test/fixtures --concurrency=1 --timeout 1200000",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
     "build": "pnpm run gen-schema && pnpm run gen-types",

package/schema.json

@@ -1,7 +1,7 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/next/2.72.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/next/3.0.0-alpha.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "Platformatic Next.js Stackable",
+  "title": "Platformatic Next.js Config",
   "type": "object",
   "properties": {
     "$schema": {