@platformatic/runtime 2.74.3 → 3.0.0-alpha.2

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export type HttpsSchemasPlatformaticDevPlatformaticRuntime2743Json = {
+export type PlatformaticRuntimeConfig = {
   [k: string]: unknown;
 } & {
   $schema?: string;

package/index.d.ts

@@ -1,29 +1,32 @@
-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 { Configuration, ConfigurationOptions, logFatalError, parseArgs } from '@platformatic/foundation'
+import { BaseGenerator } from '@platformatic/generators'
+import { JSONSchemaType } from 'ajv'
+import * as colorette from 'colorette'
+import { Logger } from 'pino'
+import { PlatformaticRuntimeConfig } from './config'
+
+export type RuntimeConfiguration = Promise<Configuration<PlatformaticRuntimeConfig>>
+
+export type ServiceCommandContext = {
+  colorette: typeof colorette
+  parseArgs: typeof parseArgs
+  logFatalError: typeof logFatalError
 }
 
-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 ServiceCommand = (
+  logger: Logger,
+  configuration: Configuration<unknown>,
+  args: string[],
+  context: ServiceCommandContext
+) => Promise<void>
+
+export interface ServicesCommands {
+  services: Record<string, Configuration<unknown>>
+  commands: Record<string, ServiceCommand>
+  help: Record<string, string | (() => string)>
 }
 
-/**
- * All the errors thrown by the plugin.
- */
 export module errors {
   export const RuntimeExitedError: () => FastifyError
   export const UnknownRuntimeAPICommandError: (command: string) => FastifyError
@@ -43,3 +46,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 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
+
+export declare function loadServicesCommands (): Promise<ServicesCommands>

package/index.js

@@ -1,30 +1,163 @@
 '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,
+  loadConfigurationModule,
+  abstractLogger,
+  findRuntimeConfigurationFile,
+  loadConfiguration: utilsLoadConfiguration,
+  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 { 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')
+
+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 loadServicesCommands () {
+  const services = {}
+  const commands = {}
+  const help = {}
+
+  let config
+  try {
+    const file = await findRuntimeConfigurationFile(abstractLogger, process.cwd(), null, false, false)
+
+    /* c8 ignore next 3 - Hard to test */
+    if (!file) {
+      throw new Error('No runtime configuration file found.')
+    }
+
+    config = await loadConfiguration(file)
+
+    /* c8 ignore next 3 - Hard to test */
+    if (!config) {
+      throw new Error('No runtime configuration file found.')
+    }
+  } catch {
+    return { services, commands, help }
+  }
+
+  for (const service of config.services) {
+    try {
+      const serviceConfig = await utilsLoadConfiguration(service.config)
+      const pkg = await loadConfigurationModule(service.path, serviceConfig)
+
+      if (pkg.createCommands) {
+        const definition = await pkg.createCommands(service.id)
+        for (const command of Object.keys(definition.commands)) {
+          services[command] = service
+        }
+
+        Object.assign(commands, definition.commands)
+        Object.assign(help, definition.help)
+      }
+      /* c8 ignore next 3 - Hard to test */
+    } catch {
+      // No-op, ignore the service
+    }
+  }
+
+  return { services, commands, help }
+}
+
+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' && err.code !== 'EACCES') || context?.skipPortInUseHandling) {
+          throw err
+        }
+
+        await runtime.close()
+
+        // 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
+module.exports.loadServicesCommands = loadServicesCommands