@platformatic/runtime 3.0.0-alpha.5 → 3.0.0-alpha.8

package/config.d.ts

@@ -32,18 +32,22 @@ export type PlatformaticRuntimeConfig = {
           maxYoungGeneration?: number | string;
         };
         preload?: string | string[];
+        dependencies?: string[];
         arguments?: string[];
         nodeOptions?: string;
       };
     };
   };
+  applications?: {
+    [k: string]: unknown;
+  }[];
   services?: {
     [k: string]: unknown;
   }[];
-  workers?: number | string;
   web?: {
     [k: string]: unknown;
   }[];
+  workers?: number | string;
   logger?: {
     level: (
       | ("fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent")
@@ -131,7 +135,7 @@ export type PlatformaticRuntimeConfig = {
   restartOnError?: boolean | number;
   gracefulShutdown?: {
     runtime: number | string;
-    service: number | string;
+    application: number | string;
   };
   health?: {
     enabled?: boolean | string;
@@ -250,11 +254,11 @@ export type PlatformaticRuntimeConfig = {
   telemetry?: {
     enabled?: boolean | string;
     /**
-     * The name of the service. Defaults to the folder name if not specified.
+     * The name of the application. Defaults to the folder name if not specified.
      */
-    serviceName: string;
+    applicationName: string;
     /**
-     * The version of the service (optional)
+     * The version of the application (optional)
      */
     version?: string;
     /**
@@ -330,9 +334,9 @@ export type PlatformaticRuntimeConfig = {
     watchDisabled?: boolean;
     [k: string]: unknown;
   };
-  serviceTimeout?: number | string;
+  applicationTimeout?: number | string;
   messagingTimeout?: number | string;
-  resolvedServicesBasePath?: string;
+  resolvedApplicationsBasePath?: string;
   env?: {
     [k: string]: string;
   };

package/eslint.config.js

@@ -1,8 +1,6 @@
-'use strict'
+import neostandard from 'neostandard'
 
-const neostandard = require('neostandard')
-
-module.exports = neostandard({
+export default neostandard({
   ts: true,
   ignores: [...neostandard.resolveIgnoresFromGitignore(), 'test/tmp/**/*', 'dist/**/*']
 })

package/index.d.ts

@@ -8,33 +8,33 @@ import { PlatformaticRuntimeConfig } from './config'
 
 export type RuntimeConfiguration = Promise<Configuration<PlatformaticRuntimeConfig>>
 
-export type ServiceCommandContext = {
+export type ApplicationCommandContext = {
   colorette: typeof colorette
   parseArgs: typeof parseArgs
   logFatalError: typeof logFatalError
 }
 
-export type ServiceCommand = (
+export type ApplicationCommand = (
   logger: Logger,
   configuration: Configuration<unknown>,
   args: string[],
-  context: ServiceCommandContext
+  context: ApplicationCommandContext
 ) => Promise<void>
 
-export interface ServicesCommands {
-  services: Record<string, Configuration<unknown>>
-  commands: Record<string, ServiceCommand>
+export interface ApplicationsCommands {
+  applications: Record<string, Configuration<unknown>>
+  commands: Record<string, ApplicationCommand>
   help: Record<string, string | (() => string)>
 }
 
 export module errors {
   export const RuntimeExitedError: () => FastifyError
   export const UnknownRuntimeAPICommandError: (command: string) => FastifyError
-  export const ServiceNotFoundError: (id: string) => FastifyError
-  export const ServiceNotStartedError: (id: string) => FastifyError
+  export const ApplicationNotFoundError: (id: string) => FastifyError
+  export const ApplicationNotStartedError: (id: string) => FastifyError
   export const FailedToRetrieveOpenAPISchemaError: (id: string, error: string) => FastifyError
   export const ApplicationAlreadyStartedError: () => FastifyError
-  export const ApplicationNotStartedError: () => FastifyError
+  export const RuntimeNotStartedError: () => FastifyError
   export const ConfigPathMustBeStringError: () => FastifyError
   export const NoConfigFileFoundError: (id: string) => FastifyError
   export const InvalidEntrypointError: (entrypoint: string) => FastifyError
@@ -51,7 +51,7 @@ export module symbols {
   export declare const kConfig: unique symbol
   export declare const kId: unique symbol
   export declare const kFullId: unique symbol
-  export declare const kServiceId: unique symbol
+  export declare const kApplicationId: unique symbol
   export declare const kWorkerId: unique symbol
   export declare const kITC: unique symbol
   export declare const kHealthCheckTimer: unique symbol
@@ -91,4 +91,4 @@ export function create (
 
 export declare function transform (config: RuntimeConfiguration): Promise<RuntimeConfiguration> | RuntimeConfiguration
 
-export declare function loadServicesCommands (): Promise<ServicesCommands>
+export declare function loadApplicationsCommands (): Promise<ApplicationsCommands>

package/index.js

@@ -1,31 +1,27 @@
-'use strict'
-
-const inspector = require('node:inspector')
-const {
-  kMetadata,
-  loadConfigurationModule,
+import { resolve, validationOptions } from '@platformatic/basic'
+import {
   abstractLogger,
-  findRuntimeConfigurationFile,
-  loadConfiguration: utilsLoadConfiguration,
+  ensureLoggableError,
   extractModuleFromSchemaUrl,
-  ensureLoggableError
-} = require('@platformatic/foundation')
-const { resolve, validationOptions } = require('@platformatic/basic')
-const { NodeInspectorFlagsNotSupportedError } = require('./lib/errors')
-const { wrapInRuntimeConfig, transform } = require('./lib/config')
-const { RuntimeGenerator, WrappedGenerator } = require('./lib/generator')
-const { Runtime } = require('./lib/runtime')
-const symbols = require('./lib/worker/symbols')
-const { schema } = require('./lib/schema')
-const { upgrade } = require('./lib/upgrade')
+  findRuntimeConfigurationFile,
+  kMetadata,
+  loadConfigurationModule,
+  loadConfiguration as utilsLoadConfiguration
+} from '@platformatic/foundation'
+import inspector from 'node:inspector'
+import { transform, wrapInRuntimeConfig } from './lib/config.js'
+import { NodeInspectorFlagsNotSupportedError } from './lib/errors.js'
+import { Runtime } from './lib/runtime.js'
+import { schema } from './lib/schema.js'
+import { upgrade } from './lib/upgrade.js'
 
 async function restartRuntime (runtime) {
-  runtime.logger.info('Received SIGUSR2, restarting all services ...')
+  runtime.logger.info('Received SIGUSR2, restarting all applications ...')
 
   try {
     await runtime.restart()
   } catch (err) {
-    runtime.logger.error({ err: ensureLoggableError(err) }, 'Failed to restart services.')
+    runtime.logger.error({ err: ensureLoggableError(err) }, 'Failed to restart applications.')
   }
 }
 
@@ -38,7 +34,7 @@ function handleSignal (runtime) {
   })
 }
 
-async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
   const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'runtime')
 
   // First of all, load the configuration without any validation
@@ -58,8 +54,8 @@ async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
   })
 }
 
-async function loadServicesCommands () {
-  const services = {}
+export async function loadApplicationsCommands () {
+  const applications = {}
   const commands = {}
   const help = {}
 
@@ -79,18 +75,18 @@ async function loadServicesCommands () {
       throw new Error('No runtime configuration file found.')
     }
   } catch {
-    return { services, commands, help }
+    return { applications, commands, help }
   }
 
-  for (const service of config.services) {
+  for (const application of config.applications) {
     try {
-      const serviceConfig = await utilsLoadConfiguration(service.config)
-      const pkg = await loadConfigurationModule(service.path, serviceConfig)
+      const applicationConfig = await utilsLoadConfiguration(application.config)
+      const pkg = await loadConfigurationModule(application.path, applicationConfig)
 
       if (pkg.createCommands) {
-        const definition = await pkg.createCommands(service.id)
+        const definition = await pkg.createCommands(application.id)
         for (const command of Object.keys(definition.commands)) {
-          services[command] = service
+          applications[command] = application
         }
 
         Object.assign(commands, definition.commands)
@@ -98,14 +94,14 @@ async function loadServicesCommands () {
       }
       /* c8 ignore next 3 - Hard to test */
     } catch {
-      // No-op, ignore the service
+      // No-op, ignore the application
     }
   }
 
-  return { services, commands, help }
+  return { applications, commands, help }
 }
 
-async function create (configOrRoot, sourceOrConfig, context) {
+export async function create (configOrRoot, sourceOrConfig, context) {
   const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
 
   if (inspector.url() && !config[kMetadata].env.VSCODE_INSPECTOR_OPTIONS) {
@@ -147,17 +143,10 @@ async function create (configOrRoot, sourceOrConfig, context) {
   return runtime
 }
 
-const platformaticVersion = require('./package.json').version
-
-module.exports.errors = require('./lib/errors')
-module.exports.Generator = RuntimeGenerator
-module.exports.WrappedGenerator = WrappedGenerator
-module.exports.schema = schema
-module.exports.symbols = symbols
-module.exports.Runtime = Runtime
-module.exports.wrapInRuntimeConfig = wrapInRuntimeConfig
-module.exports.version = platformaticVersion
-module.exports.loadConfiguration = loadConfiguration
-module.exports.create = create
-module.exports.transform = transform
-module.exports.loadServicesCommands = loadServicesCommands
+export { transform, wrapInRuntimeConfig } from './lib/config.js'
+export * as errors from './lib/errors.js'
+export { RuntimeGenerator as Generator, WrappedGenerator } from './lib/generator.js'
+export { Runtime } from './lib/runtime.js'
+export { schema } from './lib/schema.js'
+export * from './lib/version.js'
+export * as symbols from './lib/worker/symbols.js'

package/lib/config.js

@@ -1,44 +1,88 @@
-'use strict'
-
-const { join, resolve: resolvePath, isAbsolute } = require('node:path')
-const { readdir } = require('node:fs/promises')
-const { createRequire } = require('node:module')
-const { importStackableAndConfig, validationOptions } = require('@platformatic/basic')
-const {
-  kMetadata,
-  omitProperties,
-  loadModule,
-  runtimeUnwrappablePropertiesList,
+import { importCapabilityAndConfig, validationOptions } from '@platformatic/basic'
+import {
+  extractModuleFromSchemaUrl,
   findConfigurationFile,
-  loadConfigurationModule,
+  kMetadata,
   loadConfiguration,
-  extractModuleFromSchemaUrl
-} = require('@platformatic/foundation')
-const {
+  loadConfigurationModule,
+  loadModule,
+  omitProperties,
+  runtimeUnwrappablePropertiesList
+} from '@platformatic/foundation'
+import { readdir, readFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import { isAbsolute, join, resolve as resolvePath } from 'node:path'
+import {
   InspectAndInspectBrkError,
-  InvalidEntrypointError,
-  InvalidServicesWithWebError,
-  MissingEntrypointError,
+  InspectorHostError,
   InspectorPortError,
-  InspectorHostError
-} = require('./errors')
-const { schema } = require('./schema')
-const { upgrade } = require('./upgrade')
+  InvalidArgumentError,
+  InvalidEntrypointError,
+  MissingEntrypointError
+} from './errors.js'
+import { schema } from './schema.js'
+import { upgrade } from './upgrade.js'
+
+// Validate and coerce workers values early to avoid runtime hangs when invalid
+function coercePositiveInteger (value) {
+  if (typeof value === 'number') {
+    if (!Number.isInteger(value) || value < 1) return null
+    return value
+  }
+  if (typeof value === 'string') {
+    // Trim to handle accidental spaces
+    const trimmed = value.trim()
+    if (trimmed.length === 0) return null
+    const num = Number(trimmed)
+    if (!Number.isFinite(num) || !Number.isInteger(num) || num < 1) return null
+    return num
+  }
+  return null
+}
+
+function raiseInvalidWorkersError (location, received, hint) {
+  const extra = hint ? ` (${hint})` : ''
+  throw new InvalidArgumentError(`${location} workers must be a positive integer; received "${received}"${extra}`)
+}
+
+export function autoDetectPprofCapture (config) {
+  const require = createRequire(import.meta.url)
+
+  let pprofCapturePath
+  try {
+    pprofCapturePath = require.resolve('@platformatic/wattpm-pprof-capture')
+  } catch (err) {
+    // No-op
+  }
+
+  // Add to preload if not already present
+  if (!config.preload) {
+    config.preload = []
+  } else if (typeof config.preload === 'string') {
+    config.preload = [config.preload]
+  }
+
+  if (pprofCapturePath && !config.preload.includes(pprofCapturePath)) {
+    config.preload.push(pprofCapturePath)
+  }
+
+  return config
+}
 
-async function wrapInRuntimeConfig (config, context) {
-  let serviceId = 'main'
+export async function wrapInRuntimeConfig (config, context) {
+  let applicationId = 'main'
   try {
-    const packageJson = join(config[kMetadata].root, 'package.json')
-    serviceId = require(packageJson).name || 'main'
+    const packageJson = JSON.parse(await readFile(join(config[kMetadata].root, 'package.json'), 'utf-8'))
+    applicationId = packageJson?.name ?? 'main'
 
-    if (serviceId.startsWith('@')) {
-      serviceId = serviceId.split('/')[1]
+    if (applicationId.startsWith('@')) {
+      applicationId = applicationId.split('/')[1]
     }
   } catch (err) {
     // on purpose, the package.json might be missing
   }
 
-  // If the service supports its (so far, only @platformatic/service and descendants)
+  // If the application supports its (so far, only @platformatic/service and descendants)
   const { hostname, port, http2, https } = config.server ?? {}
   const server = { hostname, port, http2, https }
   const production = context?.isProduction ?? context?.production
@@ -50,10 +94,10 @@ async function wrapInRuntimeConfig (config, context) {
     server,
     watch: !production,
     ...omitProperties(config.runtime ?? {}, runtimeUnwrappablePropertiesList),
-    entrypoint: serviceId,
-    services: [
+    entrypoint: applicationId,
+    applications: [
       {
-        id: serviceId,
+        id: applicationId,
         path: config[kMetadata].root,
         config: config[kMetadata].path
       }
@@ -70,7 +114,7 @@ async function wrapInRuntimeConfig (config, context) {
   })
 }
 
-function parseInspectorOptions (config, inspect, inspectBreak) {
+export function parseInspectorOptions (config, inspect, inspectBreak) {
   const hasInspect = inspect != null
   const hasInspectBrk = inspectBreak != null
 
@@ -112,19 +156,9 @@ function parseInspectorOptions (config, inspect, inspectBreak) {
   config.watch = false
 }
 
-async function transform (config, _, context) {
+export async function transform (config, _, context) {
   const production = context?.isProduction ?? context?.production
-
-  let services
-  if (config.web?.length) {
-    if (config.services?.length) {
-      throw new InvalidServicesWithWebError()
-    }
-
-    services = config.web
-  } else {
-    services = config.services ?? []
-  }
+  const applications = [...(config.applications ?? []), ...(config.services ?? []), ...(config.web ?? [])]
 
   const watchType = typeof config.watch
   if (watchType === 'string') {
@@ -158,109 +192,134 @@ async function transform (config, _, context) {
         config = join(entryPath, configFilename)
       }
 
-      const service = { id, config, path: entryPath, useHttp: !!mapping.useHttp, health: mapping.health }
-      const existingServiceId = services.findIndex(service => service.id === id)
+      const application = {
+        id,
+        config,
+        path: entryPath,
+        useHttp: !!mapping.useHttp,
+        health: mapping.health,
+        dependencies: mapping.dependencies
+      }
+      const existingApplicationId = applications.findIndex(application => application.id === id)
 
-      if (existingServiceId !== -1) {
-        services[existingServiceId] = { ...service, ...services[existingServiceId] }
+      if (existingApplicationId !== -1) {
+        applications[existingApplicationId] = { ...application, ...applications[existingApplicationId] }
       } else {
-        services.push(service)
+        applications.push(application)
       }
     }
   }
 
-  config.serviceMap = new Map()
   config.inspectorOptions = undefined
   parseInspectorOptions(config, context?.inspect, context?.inspectBreak)
 
   let hasValidEntrypoint = false
 
-  for (let i = 0; i < services.length; ++i) {
-    const service = services[i]
+  // Root-level workers
+  if (typeof config.workers !== 'undefined') {
+    const coerced = coercePositiveInteger(config.workers)
+    if (coerced === null) {
+      const raw = config.workers
+      const hint = typeof raw === 'string' && /\{.*\}/.test(raw) ? 'check your environment variable' : ''
+      raiseInvalidWorkersError('Runtime', config.workers, hint)
+    }
+    config.workers = coerced
+  }
+
+  for (let i = 0; i < applications.length; ++i) {
+    const application = applications[i]
 
     // We need to have absolute paths here, ot the `loadConfig` will fail
     // Make sure we don't resolve if env var was not replaced
-    if (service.path && !isAbsolute(service.path) && !service.path.match(/^\{.*\}$/)) {
-      service.path = resolvePath(config[kMetadata].root, service.path)
+    if (application.path && !isAbsolute(application.path) && !application.path.match(/^\{.*\}$/)) {
+      application.path = resolvePath(config[kMetadata].root, application.path)
     }
 
-    if (service.path && service.config) {
-      service.config = resolvePath(service.path, service.config)
+    if (application.path && application.config) {
+      application.config = resolvePath(application.path, application.config)
     }
 
     try {
       let pkg
 
-      if (service.config) {
-        const config = await loadConfiguration(service.config)
-        pkg = await loadConfigurationModule(service.path, config)
+      if (application.config) {
+        const config = await loadConfiguration(application.config)
+        pkg = await loadConfigurationModule(application.path, config)
 
-        service.type = extractModuleFromSchemaUrl(config, true).module
-        service.skipTelemetryHooks = pkg.skipTelemetryHooks
+        application.type = extractModuleFromSchemaUrl(config, true).module
+        application.skipTelemetryHooks = pkg.skipTelemetryHooks
       } else {
-        const { moduleName, stackable } = await importStackableAndConfig(service.path)
-        pkg = stackable
+        const { moduleName, capability } = await importCapabilityAndConfig(application.path)
+        pkg = capability
 
-        service.type = moduleName
+        application.type = moduleName
       }
 
-      service.skipTelemetryHooks = pkg.skipTelemetryHooks
+      application.skipTelemetryHooks = pkg.skipTelemetryHooks
 
       // This is needed to work around Rust bug on dylibs:
       // https://github.com/rust-lang/rust/issues/91979
       // https://github.com/rollup/rollup/issues/5761
-      const _require = createRequire(service.path)
+      const _require = createRequire(application.path)
       for (const m of pkg.modulesToLoad ?? []) {
         const toLoad = _require.resolve(m)
         loadModule(_require, toLoad).catch(() => {})
       }
     } catch (err) {
       // This should not happen, it happens on running some unit tests if we prepare the runtime
-      // when not all the services configs are available. Given that we are running this only
-      // to ddetermine the type of the service, it's safe to ignore this error and default to unknown
-      service.type = 'unknown'
+      // when not all the applications configs are available. Given that we are running this only
+      // to ddetermine the type of the application, it's safe to ignore this error and default to unknown
+      application.type = 'unknown'
     }
 
-    service.entrypoint = service.id === config.entrypoint
-    service.dependencies = []
-    service.localServiceEnvVars = new Map()
-    service.localUrl = `http://${service.id}.plt.local`
+    // Validate and coerce per-service workers
+    if (typeof application.workers !== 'undefined') {
+      const coerced = coercePositiveInteger(application.workers)
+      if (coerced === null) {
+        const raw = config.application?.[i]?.workers
+        const hint = typeof raw === 'string' && /\{.*\}/.test(raw) ? 'check your environment variable' : ''
+        raiseInvalidWorkersError(`Service "${application.id}"`, application.workers, hint)
+      }
+      application.workers = coerced
+    }
 
-    if (typeof service.watch === 'undefined') {
-      service.watch = config.watch
+    application.entrypoint = application.id === config.entrypoint
+    application.dependencies ??= []
+    application.localUrl = `http://${application.id}.plt.local`
+
+    if (typeof application.watch === 'undefined') {
+      application.watch = config.watch
     }
 
-    if (service.entrypoint) {
+    if (application.entrypoint) {
       hasValidEntrypoint = true
     }
-
-    config.serviceMap.set(service.id, service)
   }
 
   // If there is no entrypoint, autodetect one
   if (!config.entrypoint) {
-    // If there is only one service, it becomes the entrypoint
-    if (services.length === 1) {
-      services[0].entrypoint = true
-      config.entrypoint = services[0].id
+    // If there is only one application, it becomes the entrypoint
+    if (applications.length === 1) {
+      applications[0].entrypoint = true
+      config.entrypoint = applications[0].id
       hasValidEntrypoint = true
     } else {
-      // Search if exactly service uses @platformatic/composer
-      const composers = []
+      // Search if exactly application uses @platformatic/gateway
+      const gateways = []
 
-      for (const service of services) {
-        if (!service.config) {
+      for (const application of applications) {
+        if (!application.config) {
           continue
         }
 
-        if (service.type === '@platformatic/composer') {
-          composers.push(service.id)
+        if (application.type === '@platformatic/gateway') {
+          gateways.push(application.id)
         }
       }
 
-      if (composers.length === 1) {
-        services.find(s => s.id === composers[0]).entrypoint = true
-        config.entrypoint = composers[0]
+      if (gateways.length === 1) {
+        applications.find(s => s.id === gateways[0]).entrypoint = true
+        config.entrypoint = gateways[0]
         hasValidEntrypoint = true
       }
     }
@@ -269,16 +328,17 @@ async function transform (config, _, context) {
   if (!hasValidEntrypoint && !context.allowMissingEntrypoint) {
     if (config.entrypoint) {
       throw new InvalidEntrypointError(config.entrypoint)
-    } else if (services.length >= 1) {
+    } else if (applications.length >= 1) {
       throw new MissingEntrypointError()
     }
-    // If there are no services, and no entrypoint it's an empty app.
+    // If there are no applications, and no entrypoint it's an empty app.
     // It won't start, but we should be able to parse and operate on it,
-    // like adding other services.
+    // like adding other applications.
   }
 
-  config.services = services
+  config.applications = applications
   config.web = undefined
+  config.services = undefined
   config.logger ??= {}
 
   if (production) {
@@ -293,11 +353,8 @@ async function transform (config, _, context) {
     }
   }
 
-  return config
-}
+  // Auto-detect and add pprof capture if available
+  autoDetectPprofCapture(config)
 
-module.exports = {
-  wrapInRuntimeConfig,
-  parseInspectorOptions,
-  transform
+  return config
 }