@platformatic/runtime 0.26.0

package/lib/schema.js

@@ -0,0 +1,89 @@
+#! /usr/bin/env node
+'use strict'
+
+const pkg = require('../package.json')
+const version = 'v' + pkg.version
+const platformaticRuntimeSchema = {
+  $id: `https://platformatic.dev/schemas/${version}/runtime`,
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  type: 'object',
+  properties: {
+    autoload: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['path'],
+      properties: {
+        path: {
+          type: 'string',
+          resolvePath: true
+        },
+        exclude: {
+          type: 'array',
+          default: [],
+          items: {
+            type: 'string'
+          }
+        },
+        mappings: {
+          type: 'object',
+          additionalProperties: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['id', 'config'],
+            properties: {
+              id: {
+                type: 'string'
+              },
+              config: {
+                type: 'string'
+              }
+            }
+          }
+        }
+      }
+    },
+    services: {
+      type: 'array',
+      default: [],
+      minItems: 1,
+      items: {
+        type: 'object',
+        required: ['id', 'path', 'config'],
+        properties: {
+          id: {
+            type: 'string'
+          },
+          path: {
+            type: 'string',
+            resolvePath: true
+          },
+          config: {
+            type: 'string'
+          }
+        }
+      }
+    },
+    entrypoint: {
+      type: 'string'
+    },
+    hotReload: {
+      type: 'boolean'
+    },
+    allowCycles: {
+      type: 'boolean'
+    },
+    $schema: {
+      type: 'string'
+    }
+  },
+  anyOf: [
+    { required: ['autoload', 'entrypoint'] },
+    { required: ['services', 'entrypoint'] }
+  ]
+}
+
+module.exports.schema = platformaticRuntimeSchema
+
+if (require.main === module) {
+  console.log(JSON.stringify(platformaticRuntimeSchema, null, 2))
+}

package/lib/start.js

@@ -0,0 +1,77 @@
+'use strict'
+const { once } = require('node:events')
+const { join } = require('node:path')
+const { Worker } = require('node:worker_threads')
+const closeWithGrace = require('close-with-grace')
+const { loadConfig } = require('@platformatic/service')
+const { platformaticRuntime } = require('./config')
+const kLoaderFile = join(__dirname, 'loader.mjs')
+const kWorkerFile = join(__dirname, 'worker.js')
+const kWorkerExecArgv = [
+  '--no-warnings',
+  '--experimental-loader',
+  kLoaderFile
+]
+
+async function start (argv) {
+  const { configManager } = await loadConfig({}, argv, platformaticRuntime, {
+    watch: true
+  })
+  const app = await startWithConfig(configManager)
+
+  await app.start()
+  return app
+}
+
+async function startWithConfig (configManager) {
+  const config = configManager.current
+  const worker = new Worker(kWorkerFile, {
+    /* c8 ignore next */
+    execArgv: config.hotReload ? kWorkerExecArgv : [],
+    workerData: { config }
+  })
+
+  worker.on('exit', () => {
+    configManager.fileWatcher?.stopWatching()
+  })
+
+  worker.on('error', (err) => {
+    console.error(err)
+    process.exit(1)
+  })
+
+  /* c8 ignore next 3 */
+  process.on('SIGUSR2', () => {
+    worker.postMessage({ signal: 'SIGUSR2' })
+  })
+
+  closeWithGrace((event) => {
+    worker.postMessage(event)
+  })
+
+  /* c8 ignore next 3 */
+  configManager.on('update', () => {
+    // TODO(cjihrig): Need to clean up and restart the worker.
+  })
+
+  await once(worker, 'message') // plt:init
+
+  return {
+    async start () {
+      worker.postMessage({ msg: 'plt:start' })
+      const [msg] = await once(worker, 'message') // plt:started
+
+      return msg.url
+    },
+    async close () {
+      worker.postMessage({ msg: 'plt:stop' })
+      await once(worker, 'exit')
+    },
+    async restart () {
+      worker.postMessage({ msg: 'plt:restart' })
+      await once(worker, 'message') // plt:restarted
+    }
+  }
+}
+
+module.exports = { start, startWithConfig }

package/lib/worker.js

@@ -0,0 +1,88 @@
+'use strict'
+const { parentPort, workerData } = require('node:worker_threads')
+const FastifyUndiciDispatcher = require('fastify-undici-dispatcher')
+const { Agent, setGlobalDispatcher } = require('undici')
+const { PlatformaticApp } = require('./app')
+const loaderPort = globalThis.LOADER_PORT // Added by loader.mjs.
+const globalAgent = new Agent()
+const globalDispatcher = new FastifyUndiciDispatcher({
+  dispatcher: globalAgent,
+  // setting the domain here allows for fail-fast scenarios
+  domain: '.plt.local'
+})
+const applications = new Map()
+let entrypoint
+
+delete globalThis.LOADER_PORT
+setGlobalDispatcher(globalDispatcher)
+
+parentPort.on('message', async (msg) => {
+  for (const app of applications.values()) {
+    await app.handleProcessLevelEvent(msg)
+
+    if (msg?.msg === 'plt:start' || msg?.msg === 'plt:restart') {
+      const serviceUrl = new URL(app.appConfig.localUrl)
+
+      globalDispatcher.route(serviceUrl.host, app.server)
+    }
+  }
+
+  switch (msg?.msg) {
+    case 'plt:start':
+      configureDispatcher()
+      parentPort.postMessage({ msg: 'plt:started', url: entrypoint.server.url })
+      break
+    case 'plt:restart':
+      configureDispatcher()
+      parentPort.postMessage({ msg: 'plt:restarted', url: entrypoint.server.url })
+      break
+    case 'plt:stop':
+      process.exit() // Exit the worker thread.
+      break
+    case undefined:
+      // Ignore
+      break
+    default:
+      throw new Error(`unknown message type: '${msg.msg}'`)
+  }
+})
+
+async function main () {
+  const { services } = workerData.config
+
+  for (let i = 0; i < services.length; ++i) {
+    const service = services[i]
+    const app = new PlatformaticApp(service, loaderPort)
+
+    applications.set(service.id, app)
+
+    if (service.entrypoint) {
+      entrypoint = app
+    }
+  }
+
+  parentPort.postMessage('plt:init')
+}
+
+function configureDispatcher () {
+  const { services } = workerData.config
+
+  // Setup the local services in the global dispatcher.
+  for (let i = 0; i < services.length; ++i) {
+    const service = services[i]
+    const serviceApp = applications.get(service.id)
+    const serviceUrl = new URL(service.localUrl)
+
+    globalDispatcher.route(serviceUrl.host, serviceApp.server)
+
+    for (let j = 0; j < service.dependencies.length; ++j) {
+      const depConfig = service.dependencies[j]
+      const depApp = applications.get(depConfig.id)
+      const depUrl = new URL(depConfig.url)
+
+      globalDispatcher.route(depUrl.host, depApp.server)
+    }
+  }
+}
+
+main()

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@platformatic/runtime",
+  "version": "0.26.0",
+  "description": "",
+  "main": "index.js",
+  "bin": {
+    "plt-runtime": "./runtime.mjs"
+  },
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/platformatic/platformatic.git"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/platformatic/platformatic/issues"
+  },
+  "homepage": "https://github.com/platformatic/platformatic#readme",
+  "devDependencies": {
+    "c8": "^7.13.0",
+    "execa": "^7.0.0",
+    "snazzy": "^9.0.0",
+    "split2": "^4.1.0",
+    "standard": "^17.0.0",
+    "tsd": "^0.28.0"
+  },
+  "dependencies": {
+    "@hapi/topo": "^6.0.2",
+    "close-with-grace": "^1.2.0",
+    "commist": "^3.2.0",
+    "desm": "^1.3.0",
+    "es-main": "^1.2.0",
+    "fastify": "^4.17.0",
+    "fastify-undici-dispatcher": "^0.4.0",
+    "help-me": "^4.2.0",
+    "minimist": "^1.2.8",
+    "undici": "^5.20.0",
+    "@platformatic/config": "0.26.0",
+    "@platformatic/service": "0.26.0",
+    "@platformatic/start": "0.26.0",
+    "@platformatic/utils": "0.26.0"
+  },
+  "standard": {
+    "ignore": [
+      "**/dist/*"
+    ]
+  },
+  "scripts": {
+    "test": "npm run lint && c8 -x fixtures -x test node --test && tsd",
+    "lint": "standard | snazzy"
+  }
+}

package/runtime.mjs

@@ -0,0 +1,43 @@
+#! /usr/bin/env node
+
+import { readFile } from 'node:fs/promises'
+import commist from 'commist'
+import { join } from 'desm'
+import isMain from 'es-main'
+import helpMe from 'help-me'
+import parseArgs from 'minimist'
+import { start } from './lib/start.js'
+
+const help = helpMe({
+  dir: join(import.meta.url, 'help'),
+  // the default
+  ext: '.txt'
+})
+
+const program = commist({ maxDistance: 2 })
+
+program.register('help', help.toStdout)
+program.register('help start', help.toStdout.bind(null, ['start']))
+program.register('start', start)
+
+export async function run (argv) {
+  const args = parseArgs(argv, {
+    alias: {
+      v: 'version'
+    }
+  })
+
+  if (args.version) {
+    console.log('v' + JSON.parse(await readFile(join(import.meta.url, 'package.json'))).version)
+    process.exit(0)
+  }
+
+  return {
+    output: await program.parseAsync(argv),
+    help
+  }
+}
+
+if (isMain(import.meta)) {
+  await run(process.argv.splice(2))
+}

package/test/app.test.js

@@ -0,0 +1,245 @@
+'use strict'
+
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { test } = require('node:test')
+const { PlatformaticApp } = require('../lib/app')
+const fixturesDir = join(__dirname, '..', 'fixtures')
+
+test('logs errors during startup', async (t) => {
+  const appPath = join(fixturesDir, 'serviceAppThrowsOnStart')
+  const configFile = join(appPath, 'platformatic.service.json')
+  const config = {
+    id: 'serviceAppThrowsOnStart',
+    config: configFile,
+    path: appPath,
+    entrypoint: true,
+    hotReload: true
+  }
+  const app = new PlatformaticApp(config, null)
+
+  t.mock.method(console, 'error', () => {})
+  t.mock.method(process, 'exit', () => { throw new Error('exited') })
+
+  await assert.rejects(async () => {
+    await app.start()
+  }, /exited/)
+  assert.strictEqual(process.exit.mock.calls.length, 1)
+  assert.strictEqual(process.exit.mock.calls[0].arguments[0], 1)
+  assert.strictEqual(console.error.mock.calls.length, 1)
+  assert.strictEqual(console.error.mock.calls[0].arguments[0].message, 'boom')
+})
+
+test('errors when starting an already started application', async (t) => {
+  const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
+  const configFile = join(appPath, 'platformatic.service.json')
+  const config = {
+    id: 'serviceApp',
+    config: configFile,
+    path: appPath,
+    entrypoint: true,
+    hotReload: true,
+    dependencies: [],
+    dependents: [],
+    localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
+  }
+  const app = new PlatformaticApp(config, null)
+
+  t.after(app.stop.bind(app))
+  await app.start()
+  await assert.rejects(async () => {
+    await app.start()
+  }, /application is already started/)
+})
+
+test('errors when stopping an already stopped application', async (t) => {
+  const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
+  const configFile = join(appPath, 'platformatic.service.json')
+  const config = {
+    id: 'serviceApp',
+    config: configFile,
+    path: appPath,
+    entrypoint: true,
+    hotReload: true,
+    dependencies: [],
+    dependents: [],
+    localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
+  }
+  const app = new PlatformaticApp(config, null)
+
+  await assert.rejects(async () => {
+    await app.stop()
+  }, /application has not been started/)
+})
+
+test('does not restart while restarting', async (t) => {
+  const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
+  const configFile = join(appPath, 'platformatic.service.json')
+  const config = {
+    id: 'serviceApp',
+    config: configFile,
+    path: appPath,
+    entrypoint: true,
+    hotReload: true,
+    dependencies: [],
+    dependents: [],
+    localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
+  }
+  const app = new PlatformaticApp(config, null)
+
+  t.after(app.stop.bind(app))
+  await app.start()
+  t.mock.method(app, 'stop')
+  await Promise.all([
+    app.restart(),
+    app.restart(),
+    app.restart()
+  ])
+
+  // stop() should have only been called once despite three restart() calls.
+  assert.strictEqual(app.stop.mock.calls.length, 1)
+})
+
+test('restarts on SIGUSR2', async (t) => {
+  const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
+  const configFile = join(appPath, 'platformatic.service.json')
+  const config = {
+    id: 'serviceApp',
+    config: configFile,
+    path: appPath,
+    entrypoint: true,
+    hotReload: true,
+    dependencies: [],
+    dependents: [],
+    localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
+  }
+  const app = new PlatformaticApp(config, null)
+
+  t.after(app.stop.bind(app))
+  await app.start()
+  t.mock.method(app, 'restart')
+  await app.handleProcessLevelEvent({ signal: 'SIGUSR2' })
+  assert(app.restart.mock.calls.length)
+})
+
+test('stops on signals other than SIGUSR2', async (t) => {
+  const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
+  const configFile = join(appPath, 'platformatic.service.json')
+  const config = {
+    id: 'serviceApp',
+    config: configFile,
+    path: appPath,
+    entrypoint: true,
+    hotReload: true,
+    dependencies: [],
+    dependents: [],
+    localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
+  }
+  const app = new PlatformaticApp(config, null)
+
+  t.after(async () => {
+    try {
+      await app.stop()
+    } catch {
+      // Ignore. The server should be stopped if nothing went wrong.
+    }
+  })
+  await app.start()
+  t.mock.method(app, 'stop')
+  await app.handleProcessLevelEvent({ signal: 'SIGINT' })
+  assert.strictEqual(app.stop.mock.calls.length, 1)
+})
+
+test('stops on uncaught exceptions', async (t) => {
+  const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
+  const configFile = join(appPath, 'platformatic.service.json')
+  const config = {
+    id: 'serviceApp',
+    config: configFile,
+    path: appPath,
+    entrypoint: true,
+    hotReload: true,
+    dependencies: [],
+    dependents: [],
+    localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
+  }
+  const app = new PlatformaticApp(config, null)
+
+  t.after(async () => {
+    try {
+      await app.stop()
+    } catch {
+      // Ignore. The server should be stopped if nothing went wrong.
+    }
+  })
+  await app.start()
+  t.mock.method(app, 'stop')
+  await app.handleProcessLevelEvent({ err: new Error('boom') })
+  assert.strictEqual(app.stop.mock.calls.length, 1)
+})
+
+test('supports configuration overrides', async (t) => {
+  const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
+  const configFile = join(appPath, 'platformatic.service.json')
+  const config = {
+    id: 'serviceApp',
+    config: configFile,
+    path: appPath,
+    entrypoint: true,
+    hotReload: true,
+    dependencies: [],
+    dependents: [],
+    localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
+  }
+
+  await t.test('throws on non-string config paths', async (t) => {
+    config._configOverrides = new Map([[null, 5]])
+    const app = new PlatformaticApp(config, null)
+
+    t.after(async () => {
+      try {
+        await app.stop()
+      } catch {
+        // Ignore. The server should be stopped if nothing went wrong.
+      }
+    })
+
+    await assert.rejects(async () => {
+      await app.start()
+    }, /config path must be a string/)
+  })
+
+  await t.test('ignores invalid config paths', async (t) => {
+    config._configOverrides = new Map([['foo.bar.baz', 5]])
+    const app = new PlatformaticApp(config, null)
+
+    t.after(async () => {
+      try {
+        await app.stop()
+      } catch {
+        // Ignore. The server should be stopped if nothing went wrong.
+      }
+    })
+
+    await app.start()
+  })
+
+  await t.test('sets valid config paths', async (t) => {
+    config._configOverrides = new Map([
+      ['server.keepAliveTimeout', 1],
+      ['server.port', 0]
+    ])
+    const app = new PlatformaticApp(config, null)
+
+    t.after(async () => {
+      try {
+        await app.stop()
+      } catch {
+        // Ignore. The server should be stopped if nothing went wrong.
+      }
+    })
+
+    await app.start()
+    assert.strictEqual(app.config.configManager.current.server.keepAliveTimeout, 1)
+  })
+})

package/test/cli/helper.mjs

@@ -0,0 +1,46 @@
+import { on } from 'node:events'
+import { Agent, setGlobalDispatcher } from 'undici'
+import { execa } from 'execa'
+import split from 'split2'
+import { join } from 'desm'
+
+setGlobalDispatcher(new Agent({
+  keepAliveTimeout: 10,
+  keepAliveMaxTimeout: 10,
+  tls: {
+    rejectUnauthorized: false
+  }
+}))
+
+export const cliPath = join(import.meta.url, '..', '..', 'runtime.mjs')
+
+export async function start (...args) {
+  const child = execa(process.execPath, [cliPath, 'start', ...args])
+  child.stderr.pipe(process.stdout)
+
+  const output = child.stdout.pipe(split(function (line) {
+    try {
+      const obj = JSON.parse(line)
+      return obj
+    } catch (err) {
+      console.log(line)
+    }
+  }))
+  child.ndj = output
+
+  const errorTimeout = setTimeout(() => {
+    throw new Error('Couldn\'t start server')
+  }, 30000)
+
+  for await (const messages of on(output, 'data')) {
+    for (const message of messages) {
+      const url = message.url ??
+        message.msg.match(/server listening at (.+)/i)?.[1]
+
+      if (url !== undefined) {
+        clearTimeout(errorTimeout)
+        return { child, url, output }
+      }
+    }
+  }
+}

package/test/cli/start.test.mjs

@@ -0,0 +1,61 @@
+import assert from 'node:assert'
+import { on, once } from 'node:events'
+import { test } from 'node:test'
+import { join } from 'desm'
+import { request } from 'undici'
+import { cliPath, start } from './helper.mjs'
+
+test('autostart', async () => {
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'monorepo.json')
+  const { child, url } = await start('-c', config)
+  const res = await request(url)
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.deepStrictEqual(await res.body.json(), { hello: 'hello123' })
+  child.kill('SIGINT')
+})
+
+test('start command', async () => {
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'monorepo.json')
+  const { child, url } = await start('start', '-c', config)
+  const res = await request(url)
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.deepStrictEqual(await res.body.json(), { hello: 'hello123' })
+  child.kill('SIGINT')
+})
+
+test('handles startup errors', async (t) => {
+  const { execa } = await import('execa')
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'service-throws-on-start.json')
+  const child = execa(process.execPath, [cliPath, 'start', '-c', config], { encoding: 'utf8' })
+  let stderr = ''
+  let found = false
+
+  for await (const messages of on(child.stderr, 'data')) {
+    for (const message of messages) {
+      stderr += message
+
+      if (/Error: boom/.test(stderr)) {
+        found = true
+        break
+      }
+    }
+
+    if (found) {
+      break
+    }
+  }
+
+  assert(found)
+})
+
+test('exits on error', async () => {
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'monorepo.json')
+  const { child, url } = await start('start', '-c', config)
+  const res = await request(url + '/crash')
+  const [exitCode] = await once(child, 'exit')
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.strictEqual(exitCode, 1)
+})