@platformatic/runtime 0.28.1 → 0.30.0

package/fixtures/typescript/services/titles/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "target": "es2019",
+    "sourceMap": true,
+    "pretty": true,
+    "noEmitOnError": true,
+    "outDir": "dist"
+  },
+  "watchOptions": {
+    "watchFile": "fixedPollingInterval",
+    "watchDirectory": "fixedPollingInterval",
+    "fallbackPolling": "dynamicPriority",
+    "synchronousWatchDirectory": true,
+    "excludeDirectories": [
+      "**/node_modules",
+      "dist"
+    ]
+  }
+}

package/help/compile.txt

@@ -0,0 +1,8 @@
+Compile all typescript plugins for all services.
+
+``` bash
+  $ platformatic runtime compile
+```
+
+This command will compile the TypeScript
+plugins for each services registered in the runtime.

package/index.js

@@ -3,11 +3,11 @@ const { buildServer } = require('./lib/build-server')
 const { platformaticRuntime } = require('./lib/config')
 const { start } = require('./lib/start')
 const unifiedApi = require('./lib/unified-api')
+const RuntimeApi = require('./lib/api')
 
-module.exports = {
-  buildServer,
-  platformaticRuntime,
-  schema: platformaticRuntime.schema,
-  start,
-  unifiedApi
-}
+module.exports.buildServer = buildServer
+module.exports.platformaticRuntime = platformaticRuntime
+module.exports.schema = platformaticRuntime.schema
+module.exports.RuntimeApi = RuntimeApi
+module.exports.start = start
+module.exports.unifiedApi = unifiedApi

package/lib/api-client.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const { once, EventEmitter } = require('node:events')
+const { randomUUID } = require('node:crypto')
+
+const MAX_LISTENERS_COUNT = 100
+
+class RuntimeApiClient extends EventEmitter {
+  #exitCode
+  #exitPromise
+
+  constructor (worker) {
+    super()
+    this.setMaxListeners(MAX_LISTENERS_COUNT)
+
+    this.worker = worker
+    this.#exitPromise = this.#exitHandler()
+    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 this.#exitPromise
+  }
+
+  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 Promise.race(
+      [once(this, operationId), this.#exitPromise]
+    )
+
+    if (this.#exitCode !== undefined) {
+      throw new Error('The runtime exited before the operation completed')
+    }
+
+    const { error, data } = message
+    if (error !== null) {
+      throw new Error(error)
+    }
+
+    return JSON.parse(data)
+  }
+
+  async #exitHandler () {
+    this.#exitCode = undefined
+    return once(this.worker, 'exit').then((msg) => {
+      this.#exitCode = msg[0]
+      return msg
+    })
+  }
+}
+
+module.exports = RuntimeApiClient

package/lib/api.js

@@ -1,84 +1,33 @@
 'use strict'
 
-const { once, EventEmitter } = require('node:events')
-const { randomUUID } = require('node:crypto')
+const FastifyUndiciDispatcher = require('fastify-undici-dispatcher')
+const { Agent, setGlobalDispatcher } = require('undici')
+const { PlatformaticApp } = require('./app')
 
-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 })
-  }
+class RuntimeApi {
+  #services
+  #dispatcher
+  #loaderPort
 
-  async #sendCommand (command, params = {}) {
-    const operationId = randomUUID()
+  constructor (config, logger, loaderPort) {
+    this.#services = new Map()
 
-    this.#worker.postMessage({ operationId, command, params })
-    const [message] = await once(this, operationId)
+    for (let i = 0; i < config.services.length; ++i) {
+      const service = config.services[i]
+      const app = new PlatformaticApp(service, loaderPort, logger)
 
-    const { error, data } = message
-    if (error !== null) {
-      throw new Error(error)
+      this.#services.set(service.id, app)
     }
 
-    return JSON.parse(data)
-  }
-}
-
-class RuntimeApi {
-  #services
-  #dispatcher
+    const globalAgent = new Agent()
+    const globalDispatcher = new FastifyUndiciDispatcher({
+      dispatcher: globalAgent,
+      // setting the domain here allows for fail-fast scenarios
+      domain: '.plt.local'
+    })
 
-  constructor (services, dispatcher) {
-    this.#services = services
-    this.#dispatcher = dispatcher
+    setGlobalDispatcher(globalDispatcher)
+    this.#dispatcher = globalDispatcher
   }
 
   async startListening (parentPort) {
@@ -116,9 +65,9 @@ class RuntimeApi {
   async #runCommandHandler (command, params) {
     switch (command) {
       case 'plt:start-services':
-        return this.#startServices(params)
+        return this.startServices(params)
       case 'plt:stop-services':
-        return this.#stopServices(params)
+        return this.stopServices(params)
       case 'plt:restart-services':
         return this.#restartServices(params)
       case 'plt:get-services':
@@ -139,7 +88,7 @@ class RuntimeApi {
     }
   }
 
-  async #startServices () {
+  async startServices () {
     let entrypointUrl = null
     for (const service of this.#services.values()) {
       await service.start()
@@ -154,7 +103,7 @@ class RuntimeApi {
     return entrypointUrl
   }
 
-  async #stopServices () {
+  async stopServices () {
     for (const service of this.#services.values()) {
       const serviceStatus = service.getStatus()
       if (serviceStatus === 'started') {
@@ -254,4 +203,4 @@ class RuntimeApi {
   }
 }
 
-module.exports = { RuntimeApi, RuntimeApiClient }
+module.exports = RuntimeApi

package/lib/app.js

@@ -118,6 +118,7 @@ class PlatformaticApp {
   }
 
   async handleProcessLevelEvent ({ signal, err }) {
+    /* c8 ignore next 3 */
     if (!this.server) {
       return false
     }
@@ -223,6 +224,7 @@ class PlatformaticApp {
       watchIgnore: [...(this.#originalWatch?.ignore || []), basename(configManager.fullPath)]
     })
 
+    /* c8 ignore next 4 */
     fileWatcher.on('update', async () => {
       this.server.log.debug('files changed')
       this.restart()
@@ -236,12 +238,14 @@ class PlatformaticApp {
 
   async #stopFileWatching () {
     const watcher = this.server.platformatic.fileWatcher
+    // The configManager automatically watches for the config file changes
+    // therefore we need to stop it all the times.
+    await this.config.configManager.stopWatching()
 
     if (watcher) {
-      await watcher.stopWatching()
       this.server.log.debug('stop watching files')
+      await watcher.stopWatching()
       this.server.platformatic.fileWatcher = undefined
-      this.server.platformatic.configManager.stopWatching()
     }
   }
 

package/lib/compile.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const { loadConfig, tsCompiler } = require('@platformatic/service')
+const { access } = require('node:fs/promises')
+const { join } = require('path')
+const pino = require('pino')
+const pretty = require('pino-pretty')
+const { isatty } = require('node:tty')
+
+const { platformaticRuntime } = require('./config')
+
+async function compile (argv) {
+  const { configManager } = await loadConfig({}, argv, platformaticRuntime, {
+    watch: false
+  })
+
+  let stream
+
+  /* c8 ignore next 6 */
+  if (isatty(process.stdout.fd)) {
+    stream = pretty({
+      translateTime: 'SYS:HH:MM:ss',
+      ignore: 'hostname,pid'
+    })
+  }
+
+  const logger = pino(stream)
+
+  for (const service of configManager.current.services) {
+    const tsconfig = join(service.path, 'tsconfig.json')
+
+    try {
+      await access(tsconfig)
+    } catch {
+      logger.trace(`No tsconfig.json found in ${service.path}, skipping...`)
+      continue
+    }
+
+    await tsCompiler.compile(service.path, {}, logger.child({ name: service.id }))
+  }
+}
+
+module.exports.compile = compile

package/lib/config.js

@@ -37,6 +37,7 @@ async function _transformConfig (configManager) {
 
   configManager.current.allowCycles = !!configManager.current.allowCycles
   configManager.current.serviceMap = new Map()
+  configManager.current.inspectorOptions = null
 
   let hasValidEntrypoint = false
 
@@ -121,22 +122,28 @@ async function parseClientsAndComposer (configManager) {
           let clientName = client.serviceId ?? ''
           let clientUrl
           let missingKey
-
-          try {
-            clientUrl = await cm.replaceEnv(client.url)
-            /* c8 ignore next 2 - unclear why c8 is unhappy here */
-          } catch (err) {
-            if (err.name !== 'MissingValueError') {
-              /* c8 ignore next 3 */
-              reject(err)
-              return
+          let isLocal = false
+
+          if (clientName === '' || client.url !== undefined) {
+            try {
+              clientUrl = await cm.replaceEnv(client.url)
+              /* c8 ignore next 2 - unclear why c8 is unhappy here */
+            } catch (err) {
+              if (err.name !== 'MissingValueError') {
+                /* c8 ignore next 3 */
+                reject(err)
+                return
+              }
+
+              missingKey = err.key
             }
-
-            missingKey = err.key
+            isLocal = missingKey && client.url === `{${missingKey}}`
+            /* c8 ignore next 3 */
+          } else {
+            /* c8 ignore next 2 */
+            isLocal = true
           }
 
-          const isLocal = missingKey && client.url === `{${missingKey}}`
-
           /* c8 ignore next 20 - unclear why c8 is unhappy for nearly 20 lines here */
           if (!clientName) {
             const clientAbsolutePath = pathResolve(service.path, client.path)
@@ -234,4 +241,60 @@ async function wrapConfigInRuntimeConfig ({ configManager, args }) {
   return cm
 }
 
-module.exports = { platformaticRuntime, wrapConfigInRuntimeConfig }
+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 Error('--inspect and --inspect-brk cannot be used together')
+    }
+  } 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 Error('inspector port must be 0 or in range 1024 to 65535')
+      }
+
+      if (!host) {
+        throw new Error('inspector host cannot be empty')
+      }
+    }
+
+    current.inspectorOptions = {
+      host,
+      port,
+      breakFirstLine: hasInspectBrk,
+      hotReloadDisabled: !!current.hotReload
+    }
+
+    current.hotReload = false
+  }
+}
+
+module.exports = {
+  parseInspectorOptions,
+  platformaticRuntime,
+  wrapConfigInRuntimeConfig
+}

package/lib/message-port-writable.js

@@ -0,0 +1,42 @@
+'use strict'
+const assert = require('node:assert')
+const { Writable } = require('node:stream')
+
+class MessagePortWritable extends Writable {
+  constructor (options) {
+    const opts = { ...options, objectMode: true }
+
+    super(opts)
+    this.port = opts.port
+    this.metadata = opts.metadata
+  }
+
+  _writev (chunks, callback) {
+    // Process the logs here before trying to send them across the thread
+    // boundary. Sometimes the chunks have an undocumented method on them
+    // which will prevent sending the chunk itself across threads.
+    const logs = chunks.map((chunk) => {
+      // pino should always produce a string here.
+      assert(typeof chunk.chunk === 'string')
+      return chunk.chunk.trim()
+    })
+
+    this.port.postMessage({
+      metadata: this.metadata,
+      logs
+    })
+    setImmediate(callback)
+  }
+
+  _final (callback) {
+    this.port.close()
+    callback()
+  }
+
+  _destroy (err, callback) {
+    this.port.close()
+    callback(err)
+  }
+}
+
+module.exports = { MessagePortWritable }

package/lib/start.js

@@ -1,12 +1,13 @@
 'use strict'
 const { once } = require('node:events')
+const inspector = require('node:inspector')
 const { join } = require('node:path')
 const { pathToFileURL } = require('node:url')
 const { Worker } = require('node:worker_threads')
 const closeWithGrace = require('close-with-grace')
 const { loadConfig } = require('@platformatic/service')
-const { platformaticRuntime } = require('./config')
-const { RuntimeApiClient } = require('./api.js')
+const { parseInspectorOptions, platformaticRuntime } = require('./config')
+const RuntimeApiClient = require('./api-client.js')
 const kLoaderFile = pathToFileURL(join(__dirname, 'loader.mjs')).href
 const kWorkerFile = join(__dirname, 'worker.js')
 const kWorkerExecArgv = [
@@ -16,21 +17,33 @@ const kWorkerExecArgv = [
 ]
 
 async function start (argv) {
-  const { configManager } = await loadConfig({}, argv, platformaticRuntime, {
+  const config = await loadConfig({}, argv, platformaticRuntime, {
     watch: true
   })
-  const app = await startWithConfig(configManager)
 
+  config.configManager.args = config.args
+  const app = await startWithConfig(config.configManager)
   await app.start()
   return app
 }
 
-async function startWithConfig (configManager) {
+async function startWithConfig (configManager, env = process.env) {
   const config = configManager.current
+
+  if (inspector.url()) {
+    throw new Error('The Node.js inspector flags are not supported. Please use \'platformatic start --inspect\' instead.')
+  }
+
+  if (configManager.args) {
+    parseInspectorOptions(configManager)
+  }
+
   const worker = new Worker(kWorkerFile, {
     /* c8 ignore next */
     execArgv: config.hotReload ? kWorkerExecArgv : [],
-    workerData: { config }
+    transferList: config.loggingPort ? [config.loggingPort] : [],
+    workerData: { config },
+    env
   })
 
   worker.on('exit', () => {
@@ -38,23 +51,29 @@ async function startWithConfig (configManager) {
   })
 
   worker.on('error', () => {
-    // the error is logged in the worker
-    process.exit(1)
+    // If this is the only 'error' handler, then exit the process as the default
+    // behavior. If anything else is listening for errors, then don't exit.
+    if (worker.listenerCount('error') === 1) {
+      // The error is logged in the worker.
+      process.exit(1)
+    }
   })
 
-  /* c8 ignore next 3 */
-  process.on('SIGUSR2', () => {
-    worker.postMessage({ signal: 'SIGUSR2' })
-  })
+  if (config.hotReload) {
+    /* c8 ignore next 3 */
+    process.on('SIGUSR2', () => {
+      worker.postMessage({ signal: 'SIGUSR2' })
+    })
 
-  closeWithGrace((event) => {
-    worker.postMessage(event)
-  })
+    closeWithGrace((event) => {
+      worker.postMessage(event)
+    })
 
-  /* c8 ignore next 3 */
-  configManager.on('update', () => {
-    // TODO(cjihrig): Need to clean up and restart the worker.
-  })
+    /* c8 ignore next 3 */
+    configManager.on('update', () => {
+      // TODO(cjihrig): Need to clean up and restart the worker.
+    })
+  }
 
   await once(worker, 'message') // plt:init
 

package/lib/unified-api.js

@@ -163,9 +163,11 @@ async function startCommandInRuntime (args) {
     let runtime
 
     if (configType === 'runtime') {
+      config.configManager.args = config.args
       runtime = await runtimeStartWithConfig(config.configManager)
     } else {
       const wrappedConfig = await wrapConfigInRuntimeConfig(config)
+      wrappedConfig.args = config.args
       runtime = await runtimeStartWithConfig(wrappedConfig)
     }