@platformatic/runtime 0.26.1 → 0.28.1

package/fixtures/composerApp/api1.json

@@ -0,0 +1,65 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "version": "8.3.1",
+    "title": "@fastify/swagger"
+  },
+  "components": {
+    "schemas": {}
+  },
+  "paths": {
+    "/users": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      },
+      "post": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      },
+      "put": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      }
+    },
+    "/users/{id}": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      },
+      "post": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      },
+      "put": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      },
+      "delete": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      }
+    }
+  }
+}

package/fixtures/composerApp/platformatic.composer.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.23.2/composer",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0,
+    "logger": {
+      "level": "info"
+    }
+  },
+  "composer": {
+    "services": [
+      {
+        "id": "api1",
+        "origin": "http://127.0.0.1",
+        "openapi": {
+          "file": "./api1.json"
+        }
+      }
+    ],
+    "refreshTimeout": 1000
+  },
+  "watch": false
+}

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

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.22.0/trickortreat",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0,
+    "logger": {
+      "level": "info",
+      "name": "hello server"
+    }
+  },
+  "plugins": {
+    "paths": ["./plugin.js"]
+  },
+  "service": {
+    "openapi": true
+  },
+  "metrics": false,
+  "watch": false
+}

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

@@ -0,0 +1,18 @@
+{
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0,
+    "logger": {
+      "level": "info",
+      "name": "hello server"
+    }
+  },
+  "plugins": {
+    "paths": ["./plugin.js"]
+  },
+  "service": {
+    "openapi": true
+  },
+  "metrics": false,
+  "watch": false
+}

package/fixtures/dbApp/platformatic.db.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.22.0/db",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0
+  },
+  "migrations": {
+    "dir": "migrations",
+    "table": "versions"
+  },
+  "types": {
+    "autogenerate": false
+  },
+  "db": {
+    "connectionString": "sqlite://db.sqlite",
+    "graphql": true,
+    "ignore": {
+      "versions": true
+    },
+    "events": false
+  }
+}

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/fixtures/start-command.js

@@ -0,0 +1,9 @@
+'use strict'
+const { startCommand } = require('../lib/unified-api')
+
+async function main () {
+  await startCommand(['-c', process.argv[2]])
+  process.exit(42)
+}
+
+main()

package/fixtures/starter.js

@@ -0,0 +1,9 @@
+'use strict'
+const { start } = require('../lib/unified-api')
+
+async function main () {
+  await start(['-c', process.argv[2]])
+  process.exit(42)
+}
+
+main()

package/index.js

@@ -1,33 +1,13 @@
 'use strict'
-const ConfigManager = require('@platformatic/config')
+const { buildServer } = require('./lib/build-server')
 const { platformaticRuntime } = require('./lib/config')
-const { start, startWithConfig } = require('./lib/start')
-
-async function buildServer (options = {}) {
-  if (!options.configManager) {
-    // Instantiate a new config manager from the current options.
-    const cm = new ConfigManager({
-      ...platformaticRuntime.configManagerConfig,
-      source: options
-    })
-    await cm.parseAndValidate()
-
-    if (typeof options === 'string') {
-      options = { configManager: cm }
-    } else {
-      options.configManager = cm
-    }
-  }
-
-  // The transformConfig() function can't be sent between threads.
-  delete options.configManager._transformConfig
-
-  return startWithConfig(options.configManager)
-}
+const { start } = require('./lib/start')
+const unifiedApi = require('./lib/unified-api')
 
 module.exports = {
   buildServer,
   platformaticRuntime,
   schema: platformaticRuntime.schema,
-  start
+  start,
+  unifiedApi
 }

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 }