@platformatic/runtime 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 type HttpsSchemasPlatformaticDevPlatformaticRuntime2720Json = {
+export type PlatformaticRuntimeConfig = {
   [k: string]: unknown;
 } & {
   $schema?: string;

package/index.d.ts

@@ -1,29 +1,11 @@
-import { InjectOptions, LightMyRequestResponse } from 'fastify'
 import { FastifyError } from '@fastify/error'
-import { BaseLogger } from 'pino'
-import { RuntimeGenerator } from './lib/generator/runtime-generator'
-export type pltRuntimeBuildServer = {
-  address: string
-  port: number
-  restart: () => Promise<void>
-  stop: () => Promise<void>
-  inject: (opts: InjectOptions | string) => Promise<LightMyRequestResponse>
-}
+import { BaseGenerator } from '@platformatic/generators'
+import { Configuration, ConfigurationOptions } from '@platformatic/utils'
+import { JSONSchemaType } from 'ajv'
+import { PlatformaticRuntimeConfig } from './config'
 
-declare module '@platformatic/runtime' {
-  export function buildServer (opts: object): Promise<pltRuntimeBuildServer>
-  export function start (args: object): Promise<object>
-  export function startCommand (args: object): Promise<void>
-  export function loadConfig (minimistConfig: object, args: object, store: object, overrides: object, replaceEnv: boolean): void
-  export function compile (argv: string[], logger: BaseLogger): void
-  export function platformaticRuntime (): Promise<void>
-  export function wrapConfigInRuntimeConfig (args: object): object
-  export const Generator: RuntimeGenerator.RuntimeGenerator
-}
+export type RuntimeConfiguration = Promise<Configuration<PlatformaticRuntimeConfig>>
 
-/**
- * All the errors thrown by the plugin.
- */
 export module errors {
   export const RuntimeExitedError: () => FastifyError
   export const UnknownRuntimeAPICommandError: (command: string) => FastifyError
@@ -43,3 +25,49 @@ export module errors {
   export const CannotMapSpecifierToAbsolutePathError: (specifier: string) => FastifyError
   export const NodeInspectorFlagsNotSupportedError: () => FastifyError
 }
+
+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 kWorkerId: unique symbol
+  export declare const kITC: unique symbol
+  export declare const kHealthCheckTimer: unique symbol
+  export declare const kLastELU: unique symbol
+  export declare const kWorkerStatus: unique symbol
+  export declare const kStderrMarker: string
+  export declare const kInterceptors: unique symbol
+  export declare const kWorkersBroadcast: unique symbol
+}
+
+export class Generator extends BaseGenerator.BaseGenerator {}
+
+export class WrappedGenerator extends BaseGenerator.BaseGenerator {}
+
+export declare function getRuntimeLogsDir (runtimeDir: string, runtimePID: number): string
+
+export declare const schema: JSONSchemaType<PlatformaticRuntimeConfig>
+
+export declare class Runtime {}
+
+export function wrapInRuntimeConfig (
+  config: Configuration<unknown>,
+  context?: ConfigurationOptions
+): Promise<RuntimeConfiguration>
+
+export declare const version: string
+
+export declare function loadConfiguration (
+  root: string | PlatformaticRuntimeConfig,
+  source?: string | PlatformaticRuntimeConfig,
+  context?: ConfigurationOptions
+): Promise<RuntimeConfiguration>
+
+export function create (
+  root: string,
+  source?: string | PlatformaticRuntimeConfig,
+  context?: ConfigurationOptions
+): Promise<Runtime>
+
+export declare function transform (config: RuntimeConfiguration): Promise<RuntimeConfiguration> | RuntimeConfiguration

package/index.js

@@ -1,30 +1,112 @@
 'use strict'
 
-const { buildServer } = require('./lib/build-server')
-const { compile } = require('./lib/compile')
-const errors = require('./lib/errors')
-const { platformaticRuntime, wrapConfigInRuntimeConfig } = require('./lib/config')
-const { RuntimeGenerator, WrappedGenerator } = require('./lib/generator/runtime-generator')
+const inspector = require('node:inspector')
+const { kMetadata } = require('@platformatic/utils')
+const { resolve, validationOptions } = require('@platformatic/basic')
+const {
+  loadConfiguration: utilsLoadConfiguration,
+  extractModuleFromSchemaUrl,
+  ensureLoggableError
+} = require('@platformatic/utils')
+const { NodeInspectorFlagsNotSupportedError } = require('./lib/errors')
+const { wrapInRuntimeConfig, transform } = require('./lib/config')
+const { RuntimeGenerator, WrappedGenerator } = require('./lib/generator')
 const { Runtime } = require('./lib/runtime')
-const { buildRuntime, start, startCommand } = require('./lib/start')
 const symbols = require('./lib/worker/symbols')
-const { loadConfig, getRuntimeLogsDir } = require('./lib/utils')
+const { schema } = require('./lib/schema')
+const { upgrade } = require('./lib/upgrade')
+const { getRuntimeLogsDir } = require('./lib/utils')
+
+async function restartRuntime (runtime) {
+  runtime.logger.info('Received SIGUSR2, restarting all services ...')
+
+  try {
+    await runtime.restart()
+  } catch (err) {
+    runtime.logger.error({ err: ensureLoggableError(err) }, 'Failed to restart services.')
+  }
+}
+
+function handleSignal (runtime) {
+  /* c8 ignore next 3 */
+  const restartListener = restartRuntime.bind(null, runtime)
+  process.on('SIGUSR2', restartListener)
+  runtime.on('closed', () => {
+    process.removeListener('SIGUSR2', restartListener)
+  })
+}
+
+async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'runtime')
+
+  // First of all, load the configuration without any validation
+  const config = await utilsLoadConfiguration(source)
+  const mod = extractModuleFromSchemaUrl(config)
+  if (mod?.module !== '@platformatic/runtime') {
+    return wrapInRuntimeConfig(config, context)
+  }
+
+  return utilsLoadConfiguration(source, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    upgrade,
+    replaceEnv: true,
+    root,
+    ...context
+  })
+}
+
+async function create (configOrRoot, sourceOrConfig, context) {
+  const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
+
+  if (inspector.url() && !config[kMetadata].env.VSCODE_INSPECTOR_OPTIONS) {
+    throw new NodeInspectorFlagsNotSupportedError()
+  }
+
+  let runtime = new Runtime(config, context)
+  handleSignal(runtime)
+
+  // Handle port handling
+  if (context?.start) {
+    let port = config.server?.port
+
+    while (true) {
+      try {
+        await runtime.start()
+        break
+      } catch (err) {
+        if (err.code !== 'EADDRINUSE' || context?.skipPortInUseHandling) {
+          throw err
+        }
+
+        // Get the actual port from the error message if original port was 0
+        if (!port) {
+          const mo = err.message.match(/ address already in use (.+)/)
+          const url = new URL(`http://${mo[1]}`)
+          port = Number(url.port)
+        }
+
+        config.server.port = ++port
+        runtime = new Runtime(config, context)
+        handleSignal(runtime)
+      }
+    }
+  }
+
+  return runtime
+}
 
 const platformaticVersion = require('./package.json').version
 
-module.exports.buildServer = buildServer
-module.exports.buildRuntime = buildRuntime
-module.exports.compile = compile
-module.exports.errors = errors
+module.exports.errors = require('./lib/errors')
 module.exports.Generator = RuntimeGenerator
 module.exports.WrappedGenerator = WrappedGenerator
 module.exports.getRuntimeLogsDir = getRuntimeLogsDir
-module.exports.loadConfig = loadConfig
-module.exports.platformaticRuntime = platformaticRuntime
-module.exports.schema = platformaticRuntime.schema
-module.exports.start = start
-module.exports.startCommand = startCommand
+module.exports.schema = schema
 module.exports.symbols = symbols
 module.exports.Runtime = Runtime
-module.exports.wrapConfigInRuntimeConfig = wrapConfigInRuntimeConfig
+module.exports.wrapInRuntimeConfig = wrapInRuntimeConfig
 module.exports.version = platformaticVersion
+module.exports.loadConfiguration = loadConfiguration
+module.exports.create = create
+module.exports.transform = transform

package/lib/config.js

@@ -1,35 +1,124 @@
 'use strict'
 
+const { join, resolve: resolvePath, isAbsolute } = require('node:path')
 const { readdir } = require('node:fs/promises')
 const { createRequire } = require('node:module')
-const { join, resolve: pathResolve, isAbsolute } = require('node:path')
+const { importStackableAndConfig, validationOptions } = require('@platformatic/basic')
 const {
-  loadModule,
+  kMetadata,
   omitProperties,
-  schemaComponents: { runtimeUnwrappablePropertiesList }
+  loadModule,
+  runtimeUnwrappablePropertiesList,
+  findConfigurationFile,
+  loadConfigurationModule,
+  loadConfiguration,
+  extractModuleFromSchemaUrl
 } = require('@platformatic/utils')
-const ConfigManager = require('@platformatic/config')
-const { Store } = require('@platformatic/config')
-
-const errors = require('./errors')
+const {
+  InspectAndInspectBrkError,
+  InvalidEntrypointError,
+  InvalidServicesWithWebError,
+  MissingEntrypointError,
+  InspectorPortError,
+  InspectorHostError
+} = require('./errors')
 const { schema } = require('./schema')
-const upgrade = require('./upgrade')
-const { parseArgs } = require('node:util')
+const { upgrade } = require('./upgrade')
+
+async function wrapInRuntimeConfig (config, context) {
+  let serviceId = 'main'
+  try {
+    const packageJson = join(config[kMetadata].root, 'package.json')
+    serviceId = require(packageJson).name || 'main'
+
+    if (serviceId.startsWith('@')) {
+      serviceId = serviceId.split('/')[1]
+    }
+  } catch (err) {
+    // on purpose, the package.json might be missing
+  }
 
-async function _transformConfig (configManager, args) {
-  const config = configManager.current
+  // If the service 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
+
+  // Important: do not change the order of the properties in this object
+  /* c8 ignore next */
+  const wrapped = {
+    $schema: schema.$id,
+    server,
+    watch: !production,
+    ...omitProperties(config.runtime ?? {}, runtimeUnwrappablePropertiesList),
+    entrypoint: serviceId,
+    services: [
+      {
+        id: serviceId,
+        path: config[kMetadata].root,
+        config: config[kMetadata].path
+      }
+    ]
+  }
 
-  const { values } = parseArgs({
-    args,
-    strict: false,
-    options: { production: { type: 'boolean', short: 'p', default: false } }
+  return loadConfiguration(wrapped, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    upgrade,
+    replaceEnv: true,
+    root: config[kMetadata].root,
+    ...context
   })
-  const production = values.production
+}
+
+function parseInspectorOptions (config, inspect, inspectBreak) {
+  const hasInspect = inspect != null
+  const hasInspectBrk = inspectBreak != null
+
+  if (hasInspect && hasInspectBrk) {
+    throw new InspectAndInspectBrkError()
+  }
+
+  const value = inspectBreak ?? inspect
+
+  if (!value) {
+    return
+  }
+
+  let host = '127.0.0.1'
+  let port = 9229
+
+  if (typeof value === 'string' && value.length > 0) {
+    const splitAt = value.lastIndexOf(':')
+
+    if (splitAt === -1) {
+      port = value
+    } else {
+      host = value.substring(0, splitAt)
+      port = value.substring(splitAt + 1)
+    }
+
+    port = Number.parseInt(port, 10)
+
+    if (!(port === 0 || (port >= 1024 && port <= 65535))) {
+      throw new InspectorPortError()
+    }
+
+    if (!host) {
+      throw new InspectorHostError()
+    }
+  }
+
+  config.inspectorOptions = { host, port, breakFirstLine: hasInspectBrk, watchDisabled: !!config.watch }
+  config.watch = false
+}
+
+async function transform (config, _, context) {
+  const production = context?.isProduction ?? context?.production
 
   let services
   if (config.web?.length) {
     if (config.services?.length) {
-      throw new errors.InvalidServicesWithWebError()
+      throw new InvalidServicesWithWebError()
     }
 
     services = config.web
@@ -48,12 +137,7 @@ async function _transformConfig (configManager, args) {
     const { exclude = [], mappings = {} } = config.autoload
     let { path } = config.autoload
 
-    // This is a hack, but it's the only way to not fix the paths for the autoloaded services
-    // while we are upgrading the config
-    if (configManager._fixPaths) {
-      path = pathResolve(configManager.dirname, path)
-    }
-
+    path = resolvePath(config[kMetadata].root, path)
     const entries = await readdir(path, { withFileTypes: true })
 
     for (let i = 0; i < entries.length; ++i) {
@@ -68,7 +152,7 @@ async function _transformConfig (configManager, args) {
       const entryPath = join(path, entry.name)
 
       let config
-      const configFilename = mapping.config ?? (await ConfigManager.findConfigFile(entryPath))
+      const configFilename = mapping.config ?? (await findConfigurationFile(entryPath))
 
       if (typeof configFilename === 'string') {
         config = join(entryPath, configFilename)
@@ -85,8 +169,9 @@ async function _transformConfig (configManager, args) {
     }
   }
 
-  configManager.current.serviceMap = new Map()
-  configManager.current.inspectorOptions = undefined
+  config.serviceMap = new Map()
+  config.inspectorOptions = undefined
+  parseInspectorOptions(config, context?.inspect, context?.inspectBreak)
 
   let hasValidEntrypoint = false
 
@@ -96,64 +181,44 @@ async function _transformConfig (configManager, args) {
     // 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 = pathResolve(configManager.dirname, service.path)
+      service.path = resolvePath(config[kMetadata].root, service.path)
     }
 
-    if (configManager._fixPaths && service.path && service.config) {
-      service.config = pathResolve(service.path, service.config)
+    if (service.path && service.config) {
+      service.config = resolvePath(service.path, service.config)
     }
 
-    if (service.config) {
-      try {
-        const store = new Store({ cwd: service.path })
-        const serviceConfig = await store.loadConfig(service)
-        service.isPLTService = !!serviceConfig.app.isPLTService
-        service.type = serviceConfig.app.configType
-        const _require = createRequire(service.path)
-        // 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
-        // TODO(mcollina): we should expose this inside every stackable configuration.
-        serviceConfig.app.modulesToLoad?.forEach(m => {
-          const toLoad = _require.resolve(m)
-          loadModule(_require, toLoad).catch(() => {})
-        })
-      } catch (err) {
-        // Fallback if for any reason a dependency is not found
-        try {
-          const manager = new ConfigManager({ source: pathResolve(service.path, service.config) })
-          await manager.parse()
-          const config = manager.current
-          const type = config.$schema ? ConfigManager.matchKnownSchema(config.$schema) : undefined
-          service.type = type
-          service.isPLTService = !!config.isPLTService
-        } 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'
-          service.isPLTService = false
-        }
+    try {
+      let pkg
+
+      if (service.config) {
+        const config = await loadConfiguration(service.config)
+        pkg = await loadConfigurationModule(service.path, config)
+
+        service.type = extractModuleFromSchemaUrl(config, true).module
+        service.skipTelemetryHooks = pkg.skipTelemetryHooks
+      } else {
+        const { moduleName, stackable } = await importStackableAndConfig(service.path)
+        pkg = stackable
+
+        service.type = moduleName
       }
-    } else {
-      // We need to identify the service type
-      const basic = await import('@platformatic/basic')
-      service.isPLTService = false
-      try {
-        const { stackable } = await basic.importStackableAndConfig(service.path)
-        service.type = stackable.default.configType
-        const _require = createRequire(service.path)
-        // 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
-        // TODO(mcollina): we should expose this inside every stackable configuration.
-        stackable.default.modulesToLoad?.forEach(m => {
-          const toLoad = _require.resolve(m)
-          loadModule(_require, toLoad).catch(() => {})
-        })
-      } catch {
-        // Nothing to do here
+
+      service.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)
+      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'
     }
 
     service.entrypoint = service.id === config.entrypoint
@@ -169,7 +234,7 @@ async function _transformConfig (configManager, args) {
       hasValidEntrypoint = true
     }
 
-    configManager.current.serviceMap.set(service.id, service)
+    config.serviceMap.set(service.id, service)
   }
 
   // If there is no entrypoint, autodetect one
@@ -188,7 +253,7 @@ async function _transformConfig (configManager, args) {
           continue
         }
 
-        if (service.type === 'composer') {
+        if (service.type === '@platformatic/composer') {
           composers.push(service.id)
         }
       }
@@ -201,162 +266,38 @@ async function _transformConfig (configManager, args) {
     }
   }
 
-  if (!hasValidEntrypoint) {
+  if (!hasValidEntrypoint && !context.allowMissingEntrypoint) {
     if (config.entrypoint) {
-      throw new errors.InvalidEntrypointError(config.entrypoint)
+      throw new InvalidEntrypointError(config.entrypoint)
     } else if (services.length >= 1) {
-      throw new errors.MissingEntrypointError()
+      throw new MissingEntrypointError()
     }
     // If there are no services, 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.
   }
 
-  configManager.current.services = services
-  configManager.current.web = undefined
+  config.services = services
+  config.web = undefined
+  config.logger ??= {}
 
   if (production) {
     // Any value below 10 is considered as "immediate restart" and won't be processed via setTimeout or similar
     // Important: do not use 2 otherwise ajv will convert to boolean `true`
-    configManager.current.restartOnError = 2
+    config.restartOnError = 2
   } else {
-    if (configManager.current.restartOnError === true) {
-      configManager.current.restartOnError = 5000
-    } else if (configManager.current.restartOnError < 0) {
-      configManager.current.restartOnError = 0
+    if (config.restartOnError === true) {
+      config.restartOnError = 5000
+    } else if (config.restartOnError < 0) {
+      config.restartOnError = 0
     }
   }
-}
-
-async function platformaticRuntime () {
-  // No-op. Here for consistency with other app types.
-}
-
-platformaticRuntime[Symbol.for('skip-override')] = true
-platformaticRuntime.schema = schema
-platformaticRuntime.configType = 'runtime'
-platformaticRuntime.configManagerConfig = {
-  version: require('../package.json').version,
-  schema,
-  allowToWatch: ['.env'],
-  schemaOptions: {
-    useDefaults: true,
-    coerceTypes: true,
-    allErrors: true,
-    strict: false
-  },
-  async transformConfig (args) {
-    await _transformConfig(this, args)
-  },
-  upgrade
-}
 
-async function wrapConfigInRuntimeConfig ({ configManager, args, opts }) {
-  let serviceId = 'main'
-  try {
-    const packageJson = join(configManager.dirname, 'package.json')
-    serviceId = require(packageJson).name || 'main'
-    if (serviceId.startsWith('@')) {
-      serviceId = serviceId.split('/')[1]
-    }
-  } catch (err) {
-    // on purpose, the package.json might be missing
-  }
-
-  // If the service supports its (so far, only @platformatic/service and descendants)
-  const { hostname, port, http2, https } = configManager.current.server ?? {}
-  const server = { hostname, port, http2, https }
-
-  // Important: do not change the order of the properties in this object
-  /* c8 ignore next */
-  const wrapperConfig = {
-    $schema: schema.$id,
-    server,
-    watch: !args?.production,
-    ...omitProperties(configManager.current.runtime ?? {}, runtimeUnwrappablePropertiesList),
-    entrypoint: serviceId,
-    services: [
-      {
-        id: serviceId,
-        path: configManager.dirname,
-        config: configManager.fullPath
-      }
-    ]
-  }
-
-  const cm = new ConfigManager({
-    source: wrapperConfig,
-    schema,
-    schemaOptions: {
-      useDefaults: true,
-      coerceTypes: true,
-      allErrors: true,
-      strict: false
-    },
-    transformConfig (args) {
-      return _transformConfig(this, args)
-    }
-  })
-
-  await cm.parseAndValidate(true, [], opts)
-
-  return cm
-}
-
-function parseInspectorOptions (configManager) {
-  const { current, args } = configManager
-  const hasInspect = 'inspect' in args
-  const hasInspectBrk = 'inspect-brk' in args
-  let inspectFlag
-
-  if (hasInspect) {
-    inspectFlag = args.inspect
-
-    if (hasInspectBrk) {
-      throw new errors.InspectAndInspectBrkError()
-    }
-  } else if (hasInspectBrk) {
-    inspectFlag = args['inspect-brk']
-  }
-
-  if (inspectFlag !== undefined) {
-    let host = '127.0.0.1'
-    let port = 9229
-
-    if (typeof inspectFlag === 'string' && inspectFlag.length > 0) {
-      const splitAt = inspectFlag.lastIndexOf(':')
-
-      if (splitAt === -1) {
-        port = inspectFlag
-      } else {
-        host = inspectFlag.substring(0, splitAt)
-        port = inspectFlag.substring(splitAt + 1)
-      }
-
-      port = Number.parseInt(port, 10)
-
-      if (!(port === 0 || (port >= 1024 && port <= 65535))) {
-        throw new errors.InspectorPortError()
-      }
-
-      if (!host) {
-        throw new errors.InspectorHostError()
-      }
-    }
-
-    current.inspectorOptions = {
-      host,
-      port,
-      breakFirstLine: hasInspectBrk,
-      watchDisabled: !!current.watch
-    }
-
-    current.watch = false
-  }
+  return config
 }
 
 module.exports = {
+  wrapInRuntimeConfig,
   parseInspectorOptions,
-  platformaticRuntime,
-  wrapConfigInRuntimeConfig
+  transform
 }