@platformatic/runtime 1.22.0 → 1.24.0

package/fixtures/configs/monorepo-hotreload.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.20.0/runtime",
+  "entrypoint": "serviceApp",
+  "allowCycles": true,
+  "hotReload": true,
+  "autoload": {
+    "path": "../monorepo",
+    "exclude": [
+      "docs",
+      "composerApp"
+    ],
+    "mappings": {
+      "serviceAppWithLogger": {
+        "id": "with-logger",
+        "config": "platformatic.service.json"
+      },
+      "serviceAppWithMultiplePlugins": {
+        "id": "multi-plugin-service",
+        "config": "platformatic.service.json"
+      },
+      "dbApp": {
+        "id": "db-app",
+        "config": "platformatic.db.json"
+      }
+    }
+  }
+}

package/fixtures/configs/monorepo-with-management-api.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v1.21.0/runtime",
+  "entrypoint": "serviceApp",
+  "allowCycles": true,
+  "hotReload": false,
+  "autoload": {
+    "path": "../monorepo",
+    "exclude": ["docs", "composerApp"],
+    "mappings": {
+      "serviceAppWithLogger": {
+        "id": "with-logger",
+        "config": "platformatic.service.json"
+      },
+      "serviceAppWithMultiplePlugins": {
+        "id": "multi-plugin-service",
+        "config": "platformatic.service.json"
+      }
+    }
+  },
+  "managementApi": {}
+}

package/fixtures/management-api/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "test-runtime-package",
+  "version": "1.0.42"
+}

package/fixtures/management-api/platformatic.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v1.22.0/runtime",
+  "entrypoint": "service-1",
+  "allowCycles": true,
+  "hotReload": false,
+  "autoload": {
+    "path": "./services"
+  },
+  "managementApi": true
+}

package/fixtures/management-api/services/service-1/platformatic.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v1.22.0/service",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0,
+    "logger": {
+      "name": "service-with-logger",
+      "level": "trace"
+    }
+  },
+  "service": {
+    "openapi": true
+  },
+  "plugins": {
+    "paths": ["plugin.js"]
+  },
+  "watch": true,
+  "metrics": {
+    "server": "parent"
+  }
+}

package/fixtures/management-api/services/service-1/plugin.js

@@ -0,0 +1,8 @@
+'use strict'
+
+/** @param {import('fastify').FastifyInstance} app */
+module.exports = async function (app) {
+  app.get('/hello', async () => {
+    return { service: 'service-2' }
+  })
+}

package/fixtures/management-api/services/service-2/platformatic.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v1.22.0/service",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0
+  },
+  "service": {
+    "openapi": true
+  },
+  "plugins": {
+    "paths": ["plugin.js"]
+  }
+}

package/fixtures/management-api/services/service-2/plugin.js

@@ -0,0 +1,8 @@
+'use strict'
+
+/** @param {import('fastify').FastifyInstance} app */
+module.exports = async function (app, options) {
+  app.get('/hello', async () => {
+    return { service: 'service-2' }
+  })
+}

package/fixtures/monorepo/serviceAppWithLogger/platformatic.service.json

@@ -16,5 +16,8 @@
       "plugin.js"
     ]
   },
-  "watch": true
+  "watch": true,
+  "metrics": {
+    "server": "parent"
+  }
 }

package/lib/api-client.js

@@ -3,6 +3,7 @@
 const { once, EventEmitter } = require('node:events')
 const { randomUUID } = require('node:crypto')
 const errors = require('./errors')
+const { setTimeout: sleep } = require('node:timers/promises')
 
 const MAX_LISTENERS_COUNT = 100
 
@@ -29,13 +30,34 @@ class RuntimeApiClient extends EventEmitter {
 
   async close () {
     await this.#sendCommand('plt:stop-services')
-    await this.#exitPromise
+
+    this.worker.postMessage({ command: 'plt:close' })
+    const res = await Promise.race([
+      this.#exitPromise,
+      // We must kill the worker if it doesn't exit in 10 seconds
+      // because it may be stuck in an infinite loop.
+      // This is a workaround for
+      // https://github.com/nodejs/node/issues/47748
+      // https://github.com/nodejs/node/issues/49344
+      // Remove once https://github.com/nodejs/node/pull/51290 is released
+      // on all lines.
+      // Likely to be removed when we drop support for Node.js 18.
+      sleep(10000, 'timeout', { ref: false })
+    ])
+
+    if (res === 'timeout') {
+      this.worker.unref()
+    }
   }
 
   async restart () {
     return this.#sendCommand('plt:restart-services')
   }
 
+  async getEntrypointDetails () {
+    return this.#sendCommand('plt:get-entrypoint-details')
+  }
+
   async getServices () {
     return this.#sendCommand('plt:get-services')
   }

package/lib/api.js

@@ -9,9 +9,11 @@ const { printSchema } = require('graphql')
 class RuntimeApi {
   #services
   #dispatcher
+  #logger
 
   constructor (config, logger, loaderPort) {
     this.#services = new Map()
+    this.#logger = logger
     const telemetryConfig = config.telemetry
 
     for (let i = 0; i < config.services.length; ++i) {
@@ -47,12 +49,26 @@ class RuntimeApi {
     parentPort.on('message', async (message) => {
       const command = message?.command
       if (command) {
+        if (command === 'plt:close') {
+          // We close everything because they might be using
+          // a FinalizationRegistry and it may stuck us in an infinite loop.
+          // This is a workaround for
+          // https://github.com/nodejs/node/issues/47748
+          // https://github.com/nodejs/node/issues/49344
+          // Remove once https://github.com/nodejs/node/pull/51290 is released
+          // on all lines.
+          // Likely to be removed when we drop support for Node.js 18.
+          if (this.#dispatcher) {
+            await this.#dispatcher.close()
+          }
+          await this.stopServices()
+
+          setImmediate(process.exit) // Exit the worker thread.
+          return
+        }
+
         const res = await this.#executeCommand(message)
         parentPort.postMessage(res)
-
-        if (command === 'plt:stop-services') {
-          process.exit() // Exit the worker thread.
-        }
         return
       }
       await this.#handleProcessLevelEvent(message)
@@ -96,6 +112,8 @@ class RuntimeApi {
         return this.stopServices(params)
       case 'plt:restart-services':
         return this.#restartServices(params)
+      case 'plt:get-entrypoint-details':
+        return this.#getEntrypointDetails(params)
       case 'plt:get-services':
         return this.#getServices(params)
       case 'plt:get-service-details':
@@ -134,7 +152,7 @@ class RuntimeApi {
   }
 
   async stopServices () {
-    const stopServiceReqs = [this.#dispatcher.close()]
+    const stopServiceReqs = []
     for (const service of this.#services.values()) {
       const serviceStatus = service.getStatus()
       if (serviceStatus === 'started') {
@@ -161,6 +179,15 @@ class RuntimeApi {
     return entrypointUrl
   }
 
+  #getEntrypointDetails () {
+    for (const service of this.#services.values()) {
+      if (service.appConfig.entrypoint) {
+        return this.#getServiceDetails({ id: service.appConfig.id })
+      }
+    }
+    return null
+  }
+
   #getServices () {
     const services = { services: [] }
 
@@ -190,8 +217,15 @@ class RuntimeApi {
     const service = this.#getServiceById(id)
     const status = service.getStatus()
 
+    const type = service.config.configType
     const { entrypoint, dependencies, localUrl } = service.appConfig
-    return { id, status, localUrl, entrypoint, dependencies }
+    const serviceDetails = { id, type, status, localUrl, entrypoint, dependencies }
+
+    if (entrypoint) {
+      serviceDetails.url = status === 'started' ? service.server.url : null
+    }
+
+    return serviceDetails
   }
 
   #getServiceConfig ({ id }) {
@@ -269,8 +303,7 @@ class RuntimeApi {
       statusCode: res.statusCode,
       statusMessage: res.statusMessage,
       headers: res.headers,
-      body: res.body,
-      payload: res.payload
+      body: res.body
     }
   }
 }

package/lib/app.js

@@ -73,7 +73,10 @@ class PlatformaticApp {
       this.#setuplogger(this.config.configManager)
       await this.server.restart()
     } catch (err) {
-      this.#logAndExit(err)
+      // The restart failed. Log the error and
+      // wait for another event.
+      // The old app is still available
+      this.#logger.error({ err })
     }
 
     this.#restarting = false
@@ -103,6 +106,16 @@ class PlatformaticApp {
       })
     }
 
+    if (!this.appConfig.entrypoint) {
+      configManager.update({
+        ...configManager.current,
+        server: {
+          ...(configManager.current.server || {}),
+          trustProxy: true
+        }
+      })
+    }
+
     const config = configManager.current
 
     this.#setuplogger(configManager)

package/lib/errors.js

@@ -21,5 +21,6 @@ module.exports = {
   InspectorPortError: createError(`${ERROR_PREFIX}_INSPECTOR_PORT`, 'Inspector port must be 0 or in range 1024 to 65535'),
   InspectorHostError: createError(`${ERROR_PREFIX}_INSPECTOR_HOST`, 'Inspector host cannot be empty'),
   CannotMapSpecifierToAbsolutePathError: createError(`${ERROR_PREFIX}_CANNOT_MAP_SPECIFIER_TO_ABSOLUTE_PATH`, 'Cannot map "%s" to an absolute path'),
-  NodeInspectorFlagsNotSupportedError: createError(`${ERROR_PREFIX}_NODE_INSPECTOR_FLAGS_NOT_SUPPORTED`, 'The Node.js inspector flags are not supported. Please use \'platformatic start --inspect\' instead.')
+  NodeInspectorFlagsNotSupportedError: createError(`${ERROR_PREFIX}_NODE_INSPECTOR_FLAGS_NOT_SUPPORTED`, 'The Node.js inspector flags are not supported. Please use \'platformatic start --inspect\' instead.'),
+  FailedToUnlinkManagementApiSocket: createError(`${ERROR_PREFIX}_FAILED_TO_UNLINK_MANAGEMENT_API_SOCKET`, 'Failed to unlink management API socket "%s"')
 }

package/lib/generator/runtime-generator.js

@@ -84,7 +84,7 @@ class RuntimeGenerator extends BaseGenerator {
       PLT_SERVER_HOSTNAME: '0.0.0.0',
       PORT: this.config.port || 3042,
       PLT_SERVER_LOGGER_LEVEL: this.config.logLevel || 'info'
-    })
+    }, { overwrite: false })
   }
 
   addServicesDependencies () {

package/lib/management-api.js

@@ -0,0 +1,211 @@
+'use strict'
+
+const { tmpdir, platform } = require('node:os')
+const { join } = require('node:path')
+const { readFile, mkdir, unlink } = require('node:fs/promises')
+const fastify = require('fastify')
+const { prettyFactory } = require('pino-pretty')
+const errors = require('./errors')
+const platformaticVersion = require('../package.json').version
+
+const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'pids')
+
+const pinoLogLevels = {
+  fatal: 60,
+  error: 50,
+  warn: 40,
+  info: 30,
+  debug: 20,
+  trace: 10
+}
+
+async function createManagementApi (configManager, runtimeApiClient, loggingPort) {
+  let apiConfig = configManager.current.managementApi
+  if (!apiConfig || apiConfig === true) {
+    apiConfig = {}
+  }
+
+  const app = fastify(apiConfig)
+  app.log.warn(
+    'Runtime Management API is in the experimental stage. ' +
+    'The feature is not subject to semantic versioning rules. ' +
+    'Non-backward compatible changes or removal may occur in any future release. ' +
+    'Use of the feature is not recommended in production environments.'
+  )
+
+  async function getRuntimePackageJson (cwd) {
+    const packageJsonPath = join(cwd, 'package.json')
+    const packageJsonFile = await readFile(packageJsonPath, 'utf8')
+    const packageJson = JSON.parse(packageJsonFile)
+    return packageJson
+  }
+
+  app.register(require('@fastify/websocket'))
+
+  app.register(async (app) => {
+    app.get('/metadata', async () => {
+      const packageJson = await getRuntimePackageJson(configManager.dirname).catch(() => ({}))
+      const entrypointDetails = await runtimeApiClient.getEntrypointDetails().catch(() => null)
+
+      return {
+        pid: process.pid,
+        cwd: process.cwd(),
+        argv: process.argv,
+        uptimeSeconds: Math.floor(process.uptime()),
+        execPath: process.execPath,
+        nodeVersion: process.version,
+        projectDir: configManager.dirname,
+        packageName: packageJson.name ?? null,
+        packageVersion: packageJson.version ?? null,
+        url: entrypointDetails?.url ?? null,
+        platformaticVersion
+      }
+    })
+
+    app.get('/config', async () => {
+      return configManager.current
+    })
+
+    app.get('/env', async () => {
+      return process.env
+    })
+
+    app.post('/stop', async () => {
+      app.log.debug('stop services')
+      await runtimeApiClient.close()
+    })
+
+    app.post('/reload', async () => {
+      app.log.debug('reload services')
+      await runtimeApiClient.restart()
+    })
+
+    app.get('/services', async () => {
+      return runtimeApiClient.getServices()
+    })
+
+    app.get('/services/:id', async (request) => {
+      const { id } = request.params
+      app.log.debug('get service details', { id })
+      return runtimeApiClient.getServiceDetails(id)
+    })
+
+    app.get('/services/:id/config', async (request) => {
+      const { id } = request.params
+      app.log.debug('get service config', { id })
+      return runtimeApiClient.getServiceConfig(id)
+    })
+
+    app.post('/services/:id/start', async (request) => {
+      const { id } = request.params
+      app.log.debug('start service', { id })
+      await runtimeApiClient.startService(id)
+    })
+
+    app.post('/services/:id/stop', async (request) => {
+      const { id } = request.params
+      app.log.debug('stop service', { id })
+      await runtimeApiClient.stopService(id)
+    })
+
+    app.all('/services/:id/proxy/*', async (request, reply) => {
+      const { id, '*': requestUrl } = request.params
+      app.log.debug('proxy request', { id, requestUrl })
+
+      const injectParams = {
+        method: request.method,
+        url: requestUrl || '/',
+        headers: request.headers,
+        query: request.query,
+        body: request.body
+      }
+
+      const res = await runtimeApiClient.inject(id, injectParams)
+
+      reply
+        .code(res.statusCode)
+        .headers(res.headers)
+        .send(res.body)
+    })
+
+    app.get('/logs', { websocket: true }, async (connection, req) => {
+      const logLevel = req.query.level || 'info'
+      const pretty = req.query.pretty !== 'false'
+      const serviceId = req.query.serviceId || null
+
+      const logLevelNumber = pinoLogLevels[logLevel]
+      const prettify = prettyFactory()
+
+      const handler = (message) => {
+        for (let log of message.logs) {
+          try {
+            const parsedLog = JSON.parse(log)
+            if (parsedLog.level < logLevelNumber) continue
+            if (serviceId && parsedLog.name !== serviceId) continue
+            if (pretty) {
+              log = prettify(parsedLog)
+            }
+            connection.socket.send(log)
+          } catch (err) {
+            console.error('Failed to parse log message: ', log, err)
+          }
+        }
+      }
+
+      loggingPort.on('message', handler)
+      connection.socket.on('close', () => {
+        loggingPort.off('message', handler)
+      })
+      connection.socket.on('error', () => {
+        loggingPort.off('message', handler)
+      })
+      connection.socket.on('end', () => {
+        loggingPort.off('message', handler)
+      })
+    })
+  }, { prefix: '/api' })
+
+  return app
+}
+
+async function startManagementApi (configManager, runtimeApiClient, loggingPort) {
+  const runtimePID = process.pid
+
+  let socketPath = null
+  if (platform() === 'win32') {
+    socketPath = '\\\\.\\pipe\\platformatic-' + runtimePID
+  } else {
+    await mkdir(PLATFORMATIC_TMP_DIR, { recursive: true })
+    socketPath = join(PLATFORMATIC_TMP_DIR, `${runtimePID}.sock`)
+  }
+
+  try {
+    await mkdir(PLATFORMATIC_TMP_DIR, { recursive: true })
+    await unlink(socketPath).catch((err) => {
+      if (err.code !== 'ENOENT') {
+        throw new errors.FailedToUnlinkManagementApiSocket(err.message)
+      }
+    })
+
+    const managementApi = await createManagementApi(
+      configManager,
+      runtimeApiClient,
+      loggingPort
+    )
+
+    if (platform() !== 'win32') {
+      managementApi.addHook('onClose', async () => {
+        await unlink(socketPath).catch(() => {})
+      })
+    }
+
+    await managementApi.listen({ path: socketPath })
+    return managementApi
+  /* c8 ignore next 4 */
+  } catch (err) {
+    console.error(err)
+    process.exit(1)
+  }
+}
+
+module.exports = { startManagementApi, createManagementApi }

package/lib/schema.js

@@ -129,6 +129,15 @@ const platformaticRuntimeSchema = {
     },
     $schema: {
       type: 'string'
+    },
+    managementApi: {
+      anyOf: [
+        { type: 'boolean' },
+        {
+          type: 'object',
+          properties: {}
+        }
+      ]
     }
   },
   anyOf: [

package/lib/start.js

@@ -1,16 +1,18 @@
 'use strict'
+
 const { once } = require('node:events')
 const inspector = require('node:inspector')
 const { join, resolve, dirname } = require('node:path')
-const fs = require('node:fs/promises')
+const { writeFile } = require('node:fs/promises')
 const { pathToFileURL } = require('node:url')
 const { Worker } = require('node:worker_threads')
-const closeWithGrace = require('close-with-grace')
 const { start: serviceStart } = require('@platformatic/service')
+const { printConfigValidationErrors } = require('@platformatic/config')
+const closeWithGrace = require('close-with-grace')
 const { loadConfig } = require('./load-config')
+const { startManagementApi } = require('./management-api')
 const { parseInspectorOptions, wrapConfigInRuntimeConfig } = require('./config')
 const RuntimeApiClient = require('./api-client.js')
-const { printConfigValidationErrors } = require('@platformatic/config')
 const errors = require('./errors')
 const pkg = require('../package.json')
 
@@ -42,14 +44,27 @@ async function startWithConfig (configManager, env = process.env) {
   // The configManager cannot be transferred to the worker, so remove it.
   delete config.configManager
 
+  let mainLoggingPort = null
+  let childLoggingPort = config.loggingPort
+
+  if (!childLoggingPort && config.managementApi) {
+    const { port1, port2 } = new MessageChannel()
+    mainLoggingPort = port1
+    childLoggingPort = port2
+
+    config.loggingPort = childLoggingPort
+  }
+
   const worker = new Worker(kWorkerFile, {
     /* c8 ignore next */
     execArgv: config.hotReload ? kWorkerExecArgv : [],
-    transferList: config.loggingPort ? [config.loggingPort] : [],
+    transferList: childLoggingPort ? [childLoggingPort] : [],
     workerData: { config, dirname },
     env
   })
 
+  let managementApi = null
+
   let exited = null
   let isWorkerAlive = true
   worker.on('exit', (code) => {
@@ -57,6 +72,7 @@ async function startWithConfig (configManager, env = process.env) {
     process.exitCode = code
     isWorkerAlive = false
     configManager.fileWatcher?.stopWatching()
+    managementApi?.close()
     if (typeof exited === 'function') {
       exited()
     }
@@ -96,6 +112,16 @@ async function startWithConfig (configManager, env = process.env) {
   await once(worker, 'message') // plt:init
 
   const runtimeApiClient = new RuntimeApiClient(worker)
+
+  if (config.managementApi) {
+    managementApi = await startManagementApi(
+      configManager,
+      runtimeApiClient,
+      mainLoggingPort
+    )
+    runtimeApiClient.managementApi = managementApi
+  }
+
   return runtimeApiClient
 }
 
@@ -148,7 +174,7 @@ async function startCommand (args) {
       }
       const toWrite = join(dirname(resolve(args[0])), 'platformatic.service.json')
       console.log(`No config file found, creating ${join(dirname(args[0]), 'platformatic.service.json')}`)
-      await fs.writeFile(toWrite, JSON.stringify(config, null, 2))
+      await writeFile(toWrite, JSON.stringify(config, null, 2))
       return startCommand(['--config', toWrite])
     }
     logErrorAndExit(err)

package/lib/worker.js

@@ -12,6 +12,7 @@ const {
 } = require('node:worker_threads')
 const undici = require('undici')
 const pino = require('pino')
+const pretty = require('pino-pretty')
 const { setGlobalDispatcher, Agent } = require('undici')
 const RuntimeApi = require('./api')
 const { MessagePortWritable } = require('./message-port-writable')
@@ -34,7 +35,6 @@ globalThis.fetch = undici.fetch
 const config = workerData.config
 
 let loggerConfig = config.server?.logger
-let destination
 
 if (loggerConfig) {
   loggerConfig = { ...loggerConfig }
@@ -42,21 +42,23 @@ if (loggerConfig) {
   loggerConfig = {}
 }
 
-/* c8 ignore next 10 */
+const cliStream = isatty(1) ? pretty() : pino.destination(1)
+
+let logger = null
 if (config.loggingPort) {
-  destination = new MessagePortWritable({
+  const portStream = new MessagePortWritable({
     metadata: config.loggingMetadata,
     port: config.loggingPort
   })
-  delete loggerConfig.transport
-} else if (!loggerConfig.transport && isatty(1)) {
-  loggerConfig.transport = {
-    target: 'pino-pretty'
-  }
+  const multiStream = pino.multistream([
+    { stream: portStream, level: 'trace' },
+    { stream: cliStream, level: loggerConfig.level || 'info' }
+  ])
+  logger = pino({ level: 'trace' }, multiStream)
+} else {
+  logger = pino(loggerConfig, cliStream)
 }
 
-const logger = pino(loggerConfig, destination)
-
 if (config.server) {
   config.server.logger = logger
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "1.22.0",
+  "version": "1.24.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -18,6 +18,7 @@
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
     "@fastify/express": "^2.3.0",
+    "@matteo.collina/tspl": "^0.1.1",
     "borp": "^0.9.0",
     "c8": "^9.1.0",
     "execa": "^8.0.1",
@@ -30,11 +31,13 @@
     "tsd": "^0.30.4",
     "typescript": "^5.3.3",
     "undici-oauth-interceptor": "^0.4.2",
-    "@platformatic/sql-graphql": "1.22.0",
-    "@platformatic/sql-mapper": "1.22.0"
+    "ws": "^8.16.0",
+    "@platformatic/sql-graphql": "1.24.0",
+    "@platformatic/sql-mapper": "1.24.0"
   },
   "dependencies": {
     "@fastify/error": "^3.4.1",
+    "@fastify/websocket": "^9.0.0",
     "@hapi/topo": "^6.0.2",
     "boring-name-generator": "^1.0.3",
     "close-with-grace": "^1.2.0",
@@ -52,13 +55,13 @@
     "pino-pretty": "^10.3.1",
     "undici": "^6.6.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "1.22.0",
-    "@platformatic/db": "1.22.0",
-    "@platformatic/config": "1.22.0",
-    "@platformatic/generators": "1.22.0",
-    "@platformatic/service": "1.22.0",
-    "@platformatic/telemetry": "1.22.0",
-    "@platformatic/utils": "1.22.0"
+    "@platformatic/composer": "1.24.0",
+    "@platformatic/config": "1.24.0",
+    "@platformatic/db": "1.24.0",
+    "@platformatic/generators": "1.24.0",
+    "@platformatic/service": "1.24.0",
+    "@platformatic/telemetry": "1.24.0",
+    "@platformatic/utils": "1.24.0"
   },
   "standard": {
     "ignore": [

package/runtime.mjs

@@ -45,5 +45,5 @@ export async function run (argv) {
 }
 
 if (isMain(import.meta)) {
-  await run(process.argv.splice(2))
+  await run(process.argv.slice(2))
 }