@platformatic/runtime 0.27.0 → 0.28.1

package/fixtures/configs/invalid-schema-type.config.json

@@ -9,8 +9,7 @@
     }
   },
   "plugins": {
-    "paths": ["./plugin.js"],
-    "hotReload": false
+    "paths": ["./plugin.js"]
   },
   "service": {
     "openapi": true

package/fixtures/configs/monorepo-client-without-id.json

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

package/fixtures/configs/no-schema.config.json

@@ -8,8 +8,7 @@
     }
   },
   "plugins": {
-    "paths": ["./plugin.js"],
-    "hotReload": false
+    "paths": ["./plugin.js"]
   },
   "service": {
     "openapi": true

package/fixtures/monorepo/serviceApp/platformatic.service-client-without-id.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.20.0/service",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0
+  },
+  "service": {
+    "openapi": true
+  },
+  "plugins": {
+    "paths": [
+      "plugin.js"
+    ]
+  },
+  "clients": [
+    {
+      "path": "./with-logger",
+      "url": "{PLT_WITH_LOGGER_URL}"
+    }
+  ]
+}

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

@@ -8,13 +8,13 @@
     "openapi": true
   },
   "plugins": {
-    "hotReload": true,
     "paths": [
       "plugin.js"
     ]
   },
   "clients": [
     {
+      "serviceId": "with-logger",
       "path": "./with-logger",
       "url": "{PLT_WITH_LOGGER_URL}"
     }

package/fixtures/serviceAppThrowsOnStart/platformatic.service.json

@@ -5,7 +5,6 @@
     "port": 0
   },
   "plugins": {
-    "hotReload": true,
     "paths": [
       "plugin.js"
     ]

package/fixtures/start-command-in-runtime.js

@@ -0,0 +1,14 @@
+'use strict'
+const assert = require('node:assert')
+const { request } = require('undici')
+const { startCommandInRuntime } = require('../lib/unified-api')
+
+async function main () {
+  const entrypoint = await startCommandInRuntime(['-c', process.argv[2]])
+  const res = await request(entrypoint)
+
+  assert.strictEqual(res.statusCode, 200)
+  process.exit(42)
+}
+
+main()

package/lib/api.js

@@ -0,0 +1,257 @@
+'use strict'
+
+const { once, EventEmitter } = require('node:events')
+const { randomUUID } = require('node:crypto')
+
+const MAX_LISTENERS_COUNT = 100
+
+class RuntimeApiClient extends EventEmitter {
+  #worker
+
+  constructor (worker) {
+    super()
+    this.setMaxListeners(MAX_LISTENERS_COUNT)
+
+    this.#worker = worker
+    this.#worker.on('message', (message) => {
+      if (message.operationId) {
+        this.emit(message.operationId, message)
+      }
+    })
+  }
+
+  async start () {
+    return this.#sendCommand('plt:start-services')
+  }
+
+  async close () {
+    await this.#sendCommand('plt:stop-services')
+    await once(this.#worker, 'exit')
+  }
+
+  async restart () {
+    return this.#sendCommand('plt:restart-services')
+  }
+
+  async getServices () {
+    return this.#sendCommand('plt:get-services')
+  }
+
+  async getServiceDetails (id) {
+    return this.#sendCommand('plt:get-service-details', { id })
+  }
+
+  async getServiceConfig (id) {
+    return this.#sendCommand('plt:get-service-config', { id })
+  }
+
+  async startService (id) {
+    return this.#sendCommand('plt:start-service', { id })
+  }
+
+  async stopService (id) {
+    return this.#sendCommand('plt:stop-service', { id })
+  }
+
+  async inject (id, injectParams) {
+    return this.#sendCommand('plt:inject', { id, injectParams })
+  }
+
+  async #sendCommand (command, params = {}) {
+    const operationId = randomUUID()
+
+    this.#worker.postMessage({ operationId, command, params })
+    const [message] = await once(this, operationId)
+
+    const { error, data } = message
+    if (error !== null) {
+      throw new Error(error)
+    }
+
+    return JSON.parse(data)
+  }
+}
+
+class RuntimeApi {
+  #services
+  #dispatcher
+
+  constructor (services, dispatcher) {
+    this.#services = services
+    this.#dispatcher = dispatcher
+  }
+
+  async startListening (parentPort) {
+    parentPort.on('message', async (message) => {
+      const command = message?.command
+      if (command) {
+        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)
+    })
+  }
+
+  async #handleProcessLevelEvent (message) {
+    for (const service of this.#services.values()) {
+      await service.handleProcessLevelEvent(message)
+    }
+  }
+
+  async #executeCommand (message) {
+    const { operationId, command, params } = message
+    try {
+      const res = await this.#runCommandHandler(command, params)
+      return { operationId, error: null, data: JSON.stringify(res || null) }
+    } catch (err) {
+      return { operationId, error: err.message }
+    }
+  }
+
+  async #runCommandHandler (command, params) {
+    switch (command) {
+      case 'plt:start-services':
+        return this.#startServices(params)
+      case 'plt:stop-services':
+        return this.#stopServices(params)
+      case 'plt:restart-services':
+        return this.#restartServices(params)
+      case 'plt:get-services':
+        return this.#getServices(params)
+      case 'plt:get-service-details':
+        return this.#getServiceDetails(params)
+      case 'plt:get-service-config':
+        return this.#getServiceConfig(params)
+      case 'plt:start-service':
+        return this.#startService(params)
+      case 'plt:stop-service':
+        return this.#stopService(params)
+      case 'plt:inject':
+        return this.#inject(params)
+      /* c8 ignore next 2 */
+      default:
+        throw new Error(`Unknown Runtime API command: '${command}'`)
+    }
+  }
+
+  async #startServices () {
+    let entrypointUrl = null
+    for (const service of this.#services.values()) {
+      await service.start()
+
+      if (service.appConfig.entrypoint) {
+        entrypointUrl = service.server.url
+      }
+
+      const serviceUrl = new URL(service.appConfig.localUrl)
+      this.#dispatcher.route(serviceUrl.host, service.server)
+    }
+    return entrypointUrl
+  }
+
+  async #stopServices () {
+    for (const service of this.#services.values()) {
+      const serviceStatus = service.getStatus()
+      if (serviceStatus === 'started') {
+        await service.stop()
+      }
+    }
+  }
+
+  async #restartServices () {
+    let entrypointUrl = null
+    for (const service of this.#services.values()) {
+      if (service.server) {
+        await service.restart(true)
+      }
+
+      if (service.appConfig.entrypoint) {
+        entrypointUrl = service.server.url
+      }
+
+      const serviceUrl = new URL(service.appConfig.localUrl)
+      this.#dispatcher.route(serviceUrl.host, service.server)
+    }
+    return entrypointUrl
+  }
+
+  #getServices () {
+    const services = { services: [] }
+
+    for (const service of this.#services.values()) {
+      const serviceId = service.appConfig.id
+      const serviceDetails = this.#getServiceDetails({ id: serviceId })
+      if (serviceDetails.entrypoint) {
+        services.entrypoint = serviceId
+      }
+      services.services.push(serviceDetails)
+    }
+
+    return services
+  }
+
+  #getServiceById (id) {
+    const service = this.#services.get(id)
+
+    if (!service) {
+      throw new Error(`Service with id '${id}' not found`)
+    }
+
+    return service
+  }
+
+  #getServiceDetails ({ id }) {
+    const service = this.#getServiceById(id)
+    const status = service.getStatus()
+
+    const { entrypoint, dependencies, localUrl } = service.appConfig
+    return { id, status, localUrl, entrypoint, dependencies }
+  }
+
+  #getServiceConfig ({ id }) {
+    const service = this.#getServiceById(id)
+
+    const { config } = service
+    if (!config) {
+      throw new Error(`Service with id '${id}' is not started`)
+    }
+
+    return config.configManager.current
+  }
+
+  async #startService ({ id }) {
+    const service = this.#getServiceById(id)
+    await service.start()
+  }
+
+  async #stopService ({ id }) {
+    const service = this.#getServiceById(id)
+    await service.stop()
+  }
+
+  async #inject ({ id, injectParams }) {
+    const service = this.#getServiceById(id)
+
+    const serviceStatus = service.getStatus()
+    if (serviceStatus !== 'started') {
+      throw new Error(`Service with id '${id}' is not started`)
+    }
+
+    const res = await service.server.inject(injectParams)
+    // Return only serializable properties.
+    return {
+      statusCode: res.statusCode,
+      statusMessage: res.statusMessage,
+      headers: res.headers,
+      body: res.body,
+      payload: res.payload
+    }
+  }
+}
+
+module.exports = { RuntimeApi, RuntimeApiClient }

package/lib/app.js

@@ -1,6 +1,6 @@
 'use strict'
 const { once } = require('node:events')
-const { dirname } = require('node:path')
+const { dirname, basename } = require('node:path')
 const { FileWatcher } = require('@platformatic/utils')
 const {
   buildServer,
@@ -27,6 +27,14 @@ class PlatformaticApp {
     this.#logger = logger
   }
 
+  getStatus () {
+    if (this.#started) {
+      return 'started'
+    } else {
+      return 'stopped'
+    }
+  }
+
   async restart (force) {
     if (this.#restarting) {
       return
@@ -54,7 +62,9 @@ class PlatformaticApp {
       throw new Error('application is already started')
     }
 
-    await this.#initializeConfig()
+    if (!this.#restarting) {
+      await this.#initializeConfig()
+    }
     const { configManager } = this.config
     const config = configManager.current
 
@@ -77,9 +87,6 @@ class PlatformaticApp {
       this.#logAndExit(err)
     }
 
-    this.server.platformatic.configManager = configManager
-    this.server.platformatic.config = config
-
     if (config.plugins !== undefined && this.#originalWatch !== false) {
       this.#startFileWatching()
     }
@@ -110,26 +117,11 @@ class PlatformaticApp {
     this.#started = false
   }
 
-  async handleProcessLevelEvent ({ msg, signal, err }) {
-    if (msg === 'plt:start') {
-      await this.start()
-      return
-    }
-
+  async handleProcessLevelEvent ({ signal, err }) {
     if (!this.server) {
       return false
     }
 
-    if (msg === 'plt:restart') {
-      await this.restart(true)
-      return
-    }
-
-    if (msg === 'plt:stop') {
-      await this.stop()
-      return
-    }
-
     if (signal === 'SIGUSR2') {
       this.server.log.info('reloading configuration')
       await this.restart()
@@ -161,49 +153,43 @@ class PlatformaticApp {
         return appConfig.localServiceEnvVars.get(key)
       }
     })
-    const { args, configManager } = this.config
+    const { configManager } = this.config
 
-    if (appConfig._configOverrides instanceof Map) {
-      try {
-        appConfig._configOverrides.forEach((value, key) => {
-          if (typeof key !== 'string') {
-            throw new Error('config path must be a string.')
-          }
-
-          const parts = key.split('.')
-          let next = configManager.current
-          let obj
-
-          for (let i = 0; next !== undefined && i < parts.length; ++i) {
-            obj = next
-            next = obj[parts[i]]
-          }
-
-          if (next !== undefined) {
-            obj[parts.at(-1)] = value
-          }
-        })
-      } catch (err) {
-        configManager.stopWatching()
-        throw err
+    function applyOverrides () {
+      if (appConfig._configOverrides instanceof Map) {
+        try {
+          appConfig._configOverrides.forEach((value, key) => {
+            if (typeof key !== 'string') {
+              throw new Error('config path must be a string.')
+            }
+
+            const parts = key.split('.')
+            let next = configManager.current
+            let obj
+
+            for (let i = 0; next !== undefined && i < parts.length; ++i) {
+              obj = next
+              next = obj[parts[i]]
+            }
+
+            if (next !== undefined) {
+              obj[parts.at(-1)] = value
+            }
+          })
+        } catch (err) {
+          configManager.stopWatching()
+          throw err
+        }
       }
     }
 
-    this.#setuplogger(configManager)
-
-    this.#hotReload = args.hotReload && this.appConfig.hotReload
+    applyOverrides()
 
-    if (configManager.current.plugins) {
-      if (this.#hotReload) {
-        this.#hotReload = configManager.current.plugins.hotReload
-      }
-
-      configManager.current.plugins.hotReload = false
-    }
+    this.#hotReload = this.appConfig.hotReload
 
     configManager.on('update', async (newConfig) => {
-      /* c8 ignore next 4 */
       this.server.platformatic.config = newConfig
+      applyOverrides()
       this.server.log.debug('config changed')
       this.server.log.trace({ newConfig }, 'new config')
       await this.restart()
@@ -228,11 +214,13 @@ class PlatformaticApp {
   #startFileWatching () {
     const server = this.server
     const { configManager } = server.platformatic
+    // TODO FileWatcher and ConfigManager both watch the configuration file
+    // we should remove the watching from the ConfigManager
     const fileWatcher = new FileWatcher({
       path: dirname(configManager.fullPath),
       /* c8 ignore next 2 */
       allowToWatch: this.#originalWatch?.allow,
-      watchIgnore: this.#originalWatch?.ignore
+      watchIgnore: [...(this.#originalWatch?.ignore || []), basename(configManager.fullPath)]
     })
 
     fileWatcher.on('update', async () => {

package/lib/config.js

@@ -1,6 +1,6 @@
 'use strict'
 const { readFile, readdir } = require('node:fs/promises')
-const { join, resolve: pathResolve } = require('node:path')
+const { basename, join, resolve: pathResolve } = require('node:path')
 const Topo = require('@hapi/topo')
 const ConfigManager = require('@platformatic/config')
 const { schema } = require('./schema')
@@ -101,7 +101,7 @@ async function parseClientsAndComposer (configManager) {
             }
 
             if (dep.origin === `{${err.key}}`) {
-              service.localServiceEnvVars.set(err.key, `${clientName}.plt.local`)
+              service.localServiceEnvVars.set(err.key, `http://${clientName}.plt.local`)
             }
           }
         }
@@ -118,6 +118,7 @@ async function parseClientsAndComposer (configManager) {
       const promises = parsed.clients.map((client) => {
         // eslint-disable-next-line no-async-promise-executor
         return new Promise(async (resolve, reject) => {
+          let clientName = client.serviceId ?? ''
           let clientUrl
           let missingKey
 
@@ -135,11 +136,15 @@ async function parseClientsAndComposer (configManager) {
           }
 
           const isLocal = missingKey && client.url === `{${missingKey}}`
-          const clientAbsolutePath = pathResolve(service.path, client.path)
-          const clientPackageJson = join(clientAbsolutePath, 'package.json')
-          const clientMetadata = JSON.parse(await readFile(clientPackageJson, 'utf8'))
+
           /* c8 ignore next 20 - unclear why c8 is unhappy for nearly 20 lines here */
-          const clientName = clientMetadata.name ?? ''
+          if (!clientName) {
+            const clientAbsolutePath = pathResolve(service.path, client.path)
+            const clientPackageJson = join(clientAbsolutePath, 'package.json')
+            const clientMetadata = JSON.parse(await readFile(clientPackageJson, 'utf8'))
+
+            clientName = clientMetadata.name ?? ''
+          }
 
           if (clientUrl === undefined) {
             // Combine the service name with the client name to avoid collisions
@@ -156,8 +161,8 @@ async function parseClientsAndComposer (configManager) {
 
           const dependency = configManager.current.serviceMap.get(clientName)
 
+          /* c8 ignore next 4 */
           if (dependency === undefined) {
-            /* c8 ignore next 3 */
             reject(new Error(`service '${service.id}' has unknown dependency: '${clientName}'`))
             return
           }
@@ -206,4 +211,27 @@ platformaticRuntime.configManagerConfig = {
   }
 }
 
-module.exports = { platformaticRuntime }
+async function wrapConfigInRuntimeConfig ({ configManager, args }) {
+  /* c8 ignore next */
+  const id = basename(configManager.dirname) || 'main'
+  const wrapperConfig = {
+    $schema: schema.$id,
+    entrypoint: id,
+    allowCycles: false,
+    hotReload: true,
+    services: [
+      {
+        id,
+        path: configManager.dirname,
+        config: configManager.fullPath
+      }
+    ]
+  }
+  const cm = new ConfigManager({ source: wrapperConfig, schema })
+
+  await _transformConfig(cm)
+  await cm.parseAndValidate()
+  return cm
+}
+
+module.exports = { platformaticRuntime, wrapConfigInRuntimeConfig }