@platformatic/runtime 3.68.0 → 4.0.0-new-config.1

package/lib/schema.js

@@ -1,6 +1,6 @@
 #! /usr/bin/env node
 
-import { schemaComponents } from '@platformatic/foundation'
+import { schemaComponents } from '@platformatic/foundation/lib/schema.js'
 import { version } from './version.js'
 
 const runtimeLogger = {

package/lib/upgrade.js

@@ -1,13 +1,28 @@
 import { abstractLogger } from '@platformatic/foundation'
 import { join } from 'node:path'
+import { lt } from 'semver'
 import { semgrator } from 'semgrator'
 
 export async function upgrade (logger, config, version) {
+  const runtimeLogger = logger?.child({ name: '@platformatic/runtime' }) ?? abstractLogger
+
+  const schema = config.$schema
+  const isRuntimeSchema =
+    !schema ||
+    /(?:^|\/)(?:@platformatic\/)?runtime(?:\/|$)/.test(schema) ||
+    /(?:^|\/)wattpm(?:\/|$)/.test(schema)
+
+  if (isRuntimeSchema && config.server && lt(version, '4.0.0')) {
+    runtimeLogger.warn(
+      'Runtime v4 no longer supports a root server configuration. Move it into the configuration of the capability that owns the listener.'
+    )
+  }
+
   const iterator = semgrator({
     version,
     path: join(import.meta.dirname, 'versions'),
     input: config,
-    logger: logger?.child({ name: '@platformatic/runtime' }) ?? abstractLogger
+    logger: runtimeLogger
   })
 
   let result

package/lib/versions/v4.0.0.js

@@ -0,0 +1,31 @@
+export default {
+  version: '3.99.0',
+  up (config) {
+    const schema = config.$schema
+    const isRuntimeSchema =
+      !schema ||
+      /(?:^|\/)(?:@platformatic\/)?runtime(?:\/|$)/.test(schema) ||
+      /(?:^|\/)wattpm(?:\/|$)/.test(schema)
+
+    // Standalone application configurations are wrapped by Runtime and pass
+    // through this upgrade chain. Their capability-owned server must survive.
+    if (!isRuntimeSchema) {
+      return config
+    }
+
+    for (const section of ['applications', 'services', 'web']) {
+      for (const application of config[section] ?? []) {
+        delete application.server
+      }
+    }
+
+    for (const application of Object.values(config.autoload?.mappings ?? {})) {
+      delete application.server
+    }
+
+    delete config.entrypoint
+    delete config.server
+
+    return config
+  }
+}

package/lib/worker/controller.js

@@ -17,6 +17,7 @@ import {
   getOnHttpStatsRunning,
   getOnHttpStatsSize
 } from '@platformatic/globals'
+import { importCapabilityPackage } from '@platformatic/basic'
 import debounce from 'debounce'
 import { EventEmitter } from 'node:events'
 import { existsSync } from 'node:fs'
@@ -59,13 +60,12 @@ function handleUnhandled (app, event, listeners, timeout, err, ...args) {
 export class Controller extends EventEmitter {
   #starting
   #started
-  #listening
   #watch
   #fileWatcher
   #debouncedRestart
   #context
 
-  constructor (runtimeConfig, applicationConfig, workerId, serverConfig, metricsConfig) {
+  constructor (runtimeConfig, applicationConfig, workerId, metricsConfig) {
     super()
     this.runtimeConfig = runtimeConfig
     this.applicationConfig = applicationConfig
@@ -74,7 +74,6 @@ export class Controller extends EventEmitter {
     this.#watch = !!runtimeConfig.watch
     this.#starting = false
     this.#started = false
-    this.#listening = false
     this.capability = null
     this.#fileWatcher = null
 
@@ -86,12 +85,10 @@ export class Controller extends EventEmitter {
       workerId: this.workerId,
       directory: this.applicationConfig.path,
       dependencies: this.applicationConfig.dependencies,
-      isEntrypoint: this.applicationConfig.entrypoint,
       isProduction: this.applicationConfig.isProduction,
       telemetryConfig: this.applicationConfig.telemetry,
       loggerConfig: runtimeConfig.logger,
       metricsConfig,
-      serverConfig,
       worker: workerData?.worker,
       resourceLimits: workerData?.resourceLimits,
       hasManagementApi: !!runtimeConfig.managementApi,
@@ -129,32 +126,52 @@ export class Controller extends EventEmitter {
         process.env.NODE_ENV = 'production'
       }
 
-      // Before returning the base application, check if there is any file we recognize
-      // and the user just forgot to specify in the configuration.
-      if (!appConfig.config) {
-        const candidate = listRecognizedConfigurationFiles().find(f => existsSync(resolve(appConfig.path, f)))
+      /*
+        v4: the configuration was evaluated exactly once, main-side, and this worker receives the
+        validated capability payload as data. There is no file to re-read and no schema to
+        rediscover — which is the whole point, since re-parsing per worker meant an application
+        with workers: 4 evaluated user code five times and could reach five different answers.
+
+        The capability is imported through the canonical resolution order, application-scoped first,
+        so the copy that runs here is the copy whose schema validated the payload main-side.
+      */
+      /*
+        v4: the configuration was evaluated exactly once, main-side, and this worker receives the
+        validated capability payload as data. There is no file to re-read and no schema to
+        rediscover — which is the point, since re-parsing per worker meant an application with
+        workers: 4 evaluated user code five times and could reach five different answers.
+
+        The capability is imported through the canonical resolution order, application-scoped
+        first, so the copy that runs here is the copy whose schema validated the payload.
+      */
+      if (appConfig.resolvedConfig) {
+        const pkg = await importCapabilityPackage(appConfig.path, appConfig.module)
+
+        this.capability = await pkg.create(appConfig.path, appConfig.resolvedConfig, this.#context)
+      } else {
+        // Before returning the base application, check if there is any file we recognize
+        // and the user just forgot to specify in the configuration.
+        if (!appConfig.config) {
+          const candidate = listRecognizedConfigurationFiles().find(f => existsSync(resolve(appConfig.path, f)))
 
-        if (candidate) {
-          appConfig.config = resolve(appConfig.path, candidate)
+          if (candidate) {
+            appConfig.config = resolve(appConfig.path, candidate)
+          }
         }
-      }
 
-      if (appConfig.config) {
-        // Parse the configuration file the first time to obtain the schema. This load is thrown away:
-        // the capability loads the configuration again below and that is the configuration the
-        // application actually runs on. This one only has to yield $schema and module, so it must not
-        // diverge from the second load in any way the user can observe: it deliberately applies no
-        // onMissingEnv fallback and emits no strictEnv report, both of which are left to the load the
-        // application is built from.
-        const unvalidatedConfig = await loadConfiguration(appConfig.config, null, {
-          strictEnv: false
-        })
-        const pkg = await loadConfigurationModule(appConfig.path, unvalidatedConfig)
-        this.capability = await pkg.create(appConfig.path, appConfig.config, this.#context)
-        // We could not find a configuration file, we use the bundle @platformatic/basic with the runtime to load it
-      } else {
-        const pkg = await loadConfigurationModule(resolve(import.meta.dirname, '../..'), {}, '@platformatic/basic')
-        this.capability = await pkg.create(appConfig.path, {}, this.#context)
+        if (appConfig.config) {
+          // Parse the configuration file the first time to obtain the schema
+          const unvalidatedConfig = await loadConfiguration(appConfig.config, null, {
+            onMissingEnv: this.#context.fetchApplicationUrl,
+            strictEnv: this.#context.strictEnv
+          })
+          const pkg = await loadConfigurationModule(appConfig.path, unvalidatedConfig)
+          this.capability = await pkg.create(appConfig.path, appConfig.config, this.#context)
+          // We could not find a configuration file, we use the bundle @platformatic/basic with the runtime to load it
+        } else {
+          const pkg = await loadConfigurationModule(resolve(import.meta.dirname, '../..'), {}, '@platformatic/basic')
+          this.capability = await pkg.create(appConfig.path, {}, this.#context)
+        }
       }
 
       this.#updateDispatcher()
@@ -193,6 +210,7 @@ export class Controller extends EventEmitter {
 
     try {
       await this.capability.init?.()
+
       this.emit('init')
     } catch (err) {
       this.#logAndThrow(err)
@@ -202,7 +220,6 @@ export class Controller extends EventEmitter {
       return
     }
 
-    this.#updateCapabilityStatus('starting')
     this.emit('starting')
 
     if (this.#watch) {
@@ -219,17 +236,13 @@ export class Controller extends EventEmitter {
       }
     }
 
-    const listen = !!(this.applicationConfig.useHttp || this.applicationConfig.websocket)
-
     try {
-      await this.capability.start({ listen })
+      await this.capability.start()
       if (refreshGlobalDispatcher()) {
         this.#updateDispatcher()
       }
-      this.#listening = listen
       /* c8 ignore next 5 */
     } catch (err) {
-      this.#updateCapabilityStatus('start:error')
       this.emit('start:error', err)
 
       this.capability.log({ message: err.message, level: 'debug' })
@@ -240,19 +253,19 @@ export class Controller extends EventEmitter {
     this.#started = true
     this.#starting = false
 
-    this.#updateCapabilityStatus('started')
     this.emit('started')
   }
 
+  getUrl () {
+    return this.capability.getUrl()
+  }
+
   async stop (force = false, dependents = []) {
     if (!force && (!this.#started || this.#starting)) {
       throw new RuntimeNotStartedError()
     }
 
     this.emit('stopping')
-    // Do not update status of the capability to "stopping" here otherwise
-    // if stop is called before start is finished, the capability will not
-    // be able to wait for start to finish and it will create a race condition.
 
     await this.#stopFileWatching()
     await this.capability.waitForDependentsStop(dependents)
@@ -260,26 +273,10 @@ export class Controller extends EventEmitter {
 
     this.#started = false
     this.#starting = false
-    this.#listening = false
 
-    this.#updateCapabilityStatus('stopped')
     this.emit('stopped')
   }
 
-  async listen () {
-    // This server is not an entrypoint or already listened in start. Behave as no-op.
-    if (
-      !this.applicationConfig.entrypoint ||
-      this.applicationConfig.useHttp ||
-      this.applicationConfig.websocket ||
-      this.#listening
-    ) {
-      return
-    }
-
-    await this.capability.start({ listen: true })
-  }
-
   async getMetrics ({ format }) {
     const dispatcher = getGlobalDispatcher()
     const onHttpStatsFree = getOnHttpStatsFree({ throwOnMissing: false })
@@ -405,14 +402,4 @@ export class Controller extends EventEmitter {
       }
     })
   }
-
-  #updateCapabilityStatus (status) {
-    if (typeof this.capability.updateStatus === 'function') {
-      this.capability.updateStatus(status)
-    } else {
-      // This is horrible but needed for backward compatibility
-      this.capability.status = status
-      this.capability.emit(status)
-    }
-  }
 }

package/lib/worker/itc.js

@@ -201,14 +201,13 @@ export async function setupITC (controller, application, dispatcher, sharedConte
               })
             })
 
-            throw ensureLoggableError(e)
+            // Errors are structured cloned when sent to the runtime, which drops all their custom properties (like the
+            // port and the address of listen errors): send a plain object instead so that the runtime can inspect them.
+            // eslint-disable-next-line no-throw-literal
+            throw { name: e.name, ...ensureLoggableError(e) }
           }
         }
 
-        if (application.entrypoint) {
-          await controller.listen()
-        }
-
         dispatcher.replaceServer(await controller.capability.getDispatchTarget())
 
         const scheduledTasks =
@@ -217,7 +216,7 @@ export async function setupITC (controller, application, dispatcher, sharedConte
             : []
 
         return {
-          url: application.entrypoint ? controller.capability.getUrl() : null,
+          url: controller.getUrl(),
           scheduledTasks
         }
       },

package/lib/worker/main.js

@@ -270,18 +270,6 @@ async function main () {
 
   const { threadDispatcher } = await setDispatcher(runtimeConfig)
 
-  // If the application is an entrypoint and runtime server config is defined, use it.
-  let serverConfig = null
-  if (runtimeConfig.server && applicationConfig.entrypoint) {
-    serverConfig = runtimeConfig.server
-  } else if (applicationConfig.useHttp || applicationConfig.websocket) {
-    serverConfig = {
-      port: 0,
-      hostname: '127.0.0.1',
-      keepAliveTimeout: 5000
-    }
-  }
-
   const inspectorOptions = workerData.inspectorOptions
 
   if (inspectorOptions) {
@@ -313,15 +301,14 @@ async function main () {
     runtimeConfig,
     applicationConfig,
     workerData.worker.index,
-    serverConfig,
     metricsConfig
   )
 
   await controller.init(cleanup)
 
-  if (applicationConfig.entrypoint && runtimeConfig.basePath) {
+  if (runtimeConfig.basePath) {
     const meta = await controller.capability.getMeta()
-    if (!meta.gateway.wantsAbsoluteUrls) {
+    if (!meta.gateway?.wantsAbsoluteUrls) {
       stripBasePath(runtimeConfig.basePath)
     }
   }
@@ -425,10 +412,8 @@ function stripBasePath (basePath) {
   }
 
   ServerResponse.prototype.setHeader = function (name, value) {
-    if (this[kBasePath]) {
-      if (name.toLowerCase() === 'location') {
-        value = prependBasePath(value)
-      }
+    if (this[kBasePath] && name.toLowerCase() === 'location') {
+      value = prependBasePath(value)
     }
     originSetHeader.call(this, name, value)
   }

package/lib/worker/management.js

@@ -74,10 +74,6 @@ export class ManagementClient {
     return this.#send('getSchedulerJobs')
   }
 
-  getScheduler () {
-    return this.getSchedulerJobs()
-  }
-
   pauseSchedulerJob (name) {
     return this.#send('pauseSchedulerJob', { name })
   }

package/lib/worker/symbols.js

@@ -8,6 +8,8 @@ export const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer
 export const kWorkerStatus = Symbol('plt.runtime.worker.status')
 export const kWorkerHealthSignals = Symbol.for('plt.runtime.worker.healthSignals')
 export const kWorkerStartTime = Symbol.for('plt.runtime.worker.startTime')
+export const kWorkerUrl = Symbol.for('plt.runtime.worker.url')
+export const kWorkerPortOffset = Symbol.for('plt.runtime.worker.portOffset')
 export const kLastHealthCheckELU = Symbol.for('plt.runtime.worker.lastHealthCheckELU')
 export const kLastWorkerScalerELU = Symbol.for('plt.runtime.worker.lastWorkerScalerELU')
 export const kInterceptorReadyPromise = Symbol.for('plt.runtime.worker.interceptorReadyPromise')

package/lib/worker-scaler.js

@@ -1,8 +1,13 @@
-import { features } from '@platformatic/foundation'
 import { availableParallelism } from 'node:os'
 import { getMemoryInfo } from './metrics.js'
 import { ScalingAlgorithm } from './scaling-algorithm.js'
-import { kApplicationId, kId, kLastWorkerScalerELU, kWorkerStartTime, kWorkerStatus } from './worker/symbols.js'
+import {
+  kApplicationId,
+  kId,
+  kLastWorkerScalerELU,
+  kWorkerStartTime,
+  kWorkerStatus
+} from './worker/symbols.js'
 
 const healthCheckInterval = 1000
 export const kOriginalWorkers = Symbol('plt.runtime.application.dynamicWorkersScalerOriginalWorkers')
@@ -93,14 +98,7 @@ export class DynamicWorkersScaler {
   async add (application) {
     const config = {}
 
-    if (application.entrypoint && !features.node.reusePort) {
-      this.#runtime.logger.warn(
-        `The "${application.id}" application cannot be scaled because it is an entrypoint and the "reusePort" feature is not available in your OS.`
-      )
-
-      config.minWorkers = 1
-      config.maxWorkers = 1
-    } else if (application.workers.dynamic === false) {
+    if (application.workers.dynamic === false) {
       this.#runtime.logger.warn(
         `The "${application.id}" application cannot be scaled because it has a fixed number of workers (${application.workers.static}).`
       )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.68.0",
+  "version": "4.0.0-new-config.1",
   "description": "Platformatic runtime",
   "main": "index.js",
   "type": "module",
@@ -39,14 +39,14 @@
     "typescript": "~6.0.3",
     "undici-oidc-interceptor": "^0.9.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "3.68.0",
-    "@platformatic/db": "3.68.0",
-    "@platformatic/gateway": "3.68.0",
-    "@platformatic/node": "3.68.0",
-    "@platformatic/service": "3.68.0",
-    "@platformatic/sql-graphql": "3.68.0",
-    "@platformatic/sql-mapper": "3.68.0",
-    "@platformatic/wattpm-pprof-capture": "3.68.0"
+    "@platformatic/composer": "4.0.0-new-config.1",
+    "@platformatic/node": "4.0.0-new-config.1",
+    "@platformatic/gateway": "4.0.0-new-config.1",
+    "@platformatic/service": "4.0.0-new-config.1",
+    "@platformatic/sql-graphql": "4.0.0-new-config.1",
+    "@platformatic/db": "4.0.0-new-config.1",
+    "@platformatic/wattpm-pprof-capture": "4.0.0-new-config.1",
+    "@platformatic/sql-mapper": "4.0.0-new-config.1"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -72,18 +72,19 @@
     "pino-opentelemetry-transport": "^4.0.2",
     "pino-pretty": "^13.0.0",
     "semgrator": "^0.3.0",
+    "semver": "^7.6.3",
     "sonic-boom": "^4.2.0",
     "systeminformation": "^5.27.11",
     "undici": "^7.27.2",
     "undici-thread-interceptor": "^1.3.1",
     "ws": "^8.16.0",
-    "@platformatic/generators": "3.68.0",
-    "@platformatic/globals": "3.68.0",
-    "@platformatic/itc": "3.68.0",
-    "@platformatic/metrics": "3.68.0",
-    "@platformatic/telemetry": "3.68.0",
-    "@platformatic/basic": "3.68.0",
-    "@platformatic/foundation": "3.68.0"
+    "@platformatic/basic": "4.0.0-new-config.1",
+    "@platformatic/globals": "4.0.0-new-config.1",
+    "@platformatic/itc": "4.0.0-new-config.1",
+    "@platformatic/metrics": "4.0.0-new-config.1",
+    "@platformatic/foundation": "4.0.0-new-config.1",
+    "@platformatic/generators": "4.0.0-new-config.1",
+    "@platformatic/telemetry": "4.0.0-new-config.1"
   },
   "engines": {
     "node": ">=22.19.0"