@platformatic/runtime 0.27.0 → 0.28.1

package/lib/loader.mjs

@@ -1,16 +1,17 @@
 import { createRequire, isBuiltin } from 'node:module'
 import { dirname, isAbsolute, resolve as pathResolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 const require = createRequire(import.meta.url)
-const thisFile = fileURLToPath(import.meta.url)
 const isWindows = process.platform === 'win32'
 let timestamp = process.hrtime.bigint()
 let port
 
+/* c8 ignore next 3 - c8 upgrade marked many existing things as uncovered */
 function bustEsmCache () {
   timestamp = process.hrtime.bigint()
 }
 
+/* c8 ignore next 11 - c8 upgrade marked many existing things as uncovered */
 function clearCjsCache () {
   // This evicts all of the modules from the require() cache.
   // Note: This does not clean up children references to the deleted module.
@@ -25,6 +26,7 @@ function clearCjsCache () {
 
 function isRelativePath (p) {
   // This function is extracted from Node core, so it should work.
+  /* c8 ignore next - c8 upgrade marked many existing things as uncovered */
   return p.charAt(0) === '.' &&
     /* c8 ignore next 9 */
     (
@@ -38,15 +40,15 @@ function isRelativePath (p) {
     )
 }
 
-function specifierToPath (specifier, referencingModuleId) {
-  // Convert the specifier into an absolute path if possible. If the specifier
-  // cannot be converted to a path (for example for a core module), then return
-  // null.
+function specifierToFileUrl (specifier, referencingModuleId) {
+  // Convert the specifier into an absolute path URL if possible. If the
+  // specifier cannot be converted to a path (for example for a core module),
+  // then return null.
   try {
     const url = new URL(specifier)
 
     if (url.protocol === 'file:') {
-      specifier = url.pathname
+      return url.href
     } else {
       return null
     }
@@ -54,12 +56,14 @@ function specifierToPath (specifier, referencingModuleId) {
     // Ignore error.
   }
 
+  /* c8 ignore next 3 - c8 upgrade marked many existing things as uncovered */
   if (isBuiltin(specifier)) {
     return null
   }
 
+  /* c8 ignore next 3 */
   if (isAbsolute(specifier)) {
-    return specifier
+    return pathToFileURL(specifier).href
   }
 
   /* c8 ignore next 3 */
@@ -67,31 +71,35 @@ function specifierToPath (specifier, referencingModuleId) {
     throw new Error(`cannot map '${specifier}' to an absolute path`)
   }
 
+  /* c8 ignore next 5 - c8 upgrade marked many existing things as uncovered */
   if (isRelativePath(specifier)) {
-    return pathResolve(dirname(fileURLToPath(referencingModuleId)), specifier)
+    return pathToFileURL(
+      pathResolve(dirname(fileURLToPath(referencingModuleId)), specifier)
+    ).href
   } else {
     // The specifier is something in node_modules/.
     const req = createRequire(referencingModuleId)
 
-    return req.resolve(specifier)
+    return pathToFileURL(req.resolve(specifier)).href
   }
 }
 
 export async function resolve (specifier, context, nextResolve) {
-  const path = specifierToPath(specifier, context.parentURL)
+  const url = specifierToFileUrl(specifier, context.parentURL)
 
   // If the specifier could not be mapped to a file, or the path is this file,
   // then don't do anything.
-  if (typeof path !== 'string' || path === thisFile) {
+  if (typeof url !== 'string' || url === import.meta.url) {
     return nextResolve(specifier, context)
   }
 
-  return nextResolve(`${path}?ts=${timestamp}`, context)
+  return nextResolve(`${url}?ts=${timestamp}`, context)
 }
 
 export function globalPreload (context) {
   port = context.port
   port.on('message', () => {
+    /* c8 ignore next 3 - c8 upgrade marked many existing things as uncovered */
     bustEsmCache()
     clearCjsCache()
     port.postMessage('plt:cache-cleared')

package/lib/start.js

@@ -1,11 +1,13 @@
 'use strict'
 const { once } = require('node:events')
 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 kLoaderFile = join(__dirname, 'loader.mjs')
+const { RuntimeApiClient } = require('./api.js')
+const kLoaderFile = pathToFileURL(join(__dirname, 'loader.mjs')).href
 const kWorkerFile = join(__dirname, 'worker.js')
 const kWorkerExecArgv = [
   '--no-warnings',
@@ -56,22 +58,8 @@ async function startWithConfig (configManager) {
 
   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
-    }
-  }
+  const runtimeApiClient = new RuntimeApiClient(worker)
+  return runtimeApiClient
 }
 
 module.exports = { start, startWithConfig }

package/lib/unified-api.js

@@ -18,9 +18,12 @@ const {
   platformaticComposer
 } = require('@platformatic/composer')
 const { buildServer: runtimeBuildServer } = require('./build-server')
-const { platformaticRuntime } = require('./config')
+const { platformaticRuntime, wrapConfigInRuntimeConfig } = require('./config')
 const { schema: runtimeSchema } = require('./schema')
-const { start: runtimeStart } = require('./start')
+const {
+  start: runtimeStart,
+  startWithConfig: runtimeStartWithConfig
+} = require('./start')
 
 const kSupportedAppTypes = new Set(['service', 'db', 'composer', 'runtime'])
 
@@ -149,15 +152,38 @@ async function startCommand (args) {
   try {
     await _start(args)
   } catch (err) {
-    delete err?.stack
-    console.error(err?.message)
+    logErrorAndExit(err)
+  }
+}
 
-    if (err?.cause) {
-      console.error(`${err.cause}`)
+async function startCommandInRuntime (args) {
+  try {
+    const configType = await getConfigType(args)
+    const config = await _loadConfig({}, args, configType)
+    let runtime
+
+    if (configType === 'runtime') {
+      runtime = await runtimeStartWithConfig(config.configManager)
+    } else {
+      const wrappedConfig = await wrapConfigInRuntimeConfig(config)
+      runtime = await runtimeStartWithConfig(wrappedConfig)
     }
 
-    process.exit(1)
+    return await runtime.start()
+  } catch (err) {
+    logErrorAndExit(err)
+  }
+}
+
+function logErrorAndExit (err) {
+  delete err?.stack
+  console.error(err?.message)
+
+  if (err?.cause) {
+    console.error(`${err.cause}`)
   }
+
+  process.exit(1)
 }
 
 module.exports = {
@@ -167,5 +193,6 @@ module.exports = {
   loadConfig: _loadConfig,
   start: _start,
   startCommand,
+  startCommandInRuntime,
   getApp
 }

package/lib/worker.js

@@ -1,8 +1,11 @@
 '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 { RuntimeApi } = require('./api')
+
 const loaderPort = globalThis.LOADER_PORT // Added by loader.mjs.
 const globalAgent = new Agent()
 const globalDispatcher = new FastifyUndiciDispatcher({
@@ -14,7 +17,6 @@ const pino = require('pino')
 const { isatty } = require('tty')
 
 const applications = new Map()
-let entrypoint
 
 delete globalThis.LOADER_PORT
 setGlobalDispatcher(globalDispatcher)
@@ -30,6 +32,7 @@ if (isatty(1)) {
 
 const logger = pino(transport)
 
+/* c8 ignore next 4 */
 process.once('uncaughtException', (err) => {
   logger.error({ err }, 'runtime error')
   throw err
@@ -42,38 +45,6 @@ process.once('unhandledRejection', (err) => {
   throw err
 })
 
-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
-      /* c8 ignore next 3 */
-    case undefined:
-      // Ignore
-      break
-    default:
-      throw new Error(`unknown message type: '${msg.msg}'`)
-  }
-})
-
 async function main () {
   const { services } = workerData.config
 
@@ -82,34 +53,12 @@ async function main () {
     const app = new PlatformaticApp(service, loaderPort, logger)
 
     applications.set(service.id, app)
-
-    if (service.entrypoint) {
-      entrypoint = app
-    }
   }
 
-  parentPort.postMessage('plt:init')
-}
-
-function configureDispatcher () {
-  const { services } = workerData.config
+  const runtime = new RuntimeApi(applications, globalDispatcher)
+  runtime.startListening(parentPort)
 
-  // 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)
-    }
-  }
+  parentPort.postMessage('plt:init')
 }
 
 main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "0.27.0",
+  "version": "0.28.1",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -37,11 +37,11 @@
     "pino": "^8.14.1",
     "pino-pretty": "^10.0.0",
     "undici": "^5.22.1",
-    "@platformatic/composer": "0.27.0",
-    "@platformatic/config": "0.27.0",
-    "@platformatic/db": "0.27.0",
-    "@platformatic/service": "0.27.0",
-    "@platformatic/utils": "0.27.0"
+    "@platformatic/composer": "0.28.1",
+    "@platformatic/config": "0.28.1",
+    "@platformatic/db": "0.28.1",
+    "@platformatic/service": "0.28.1",
+    "@platformatic/utils": "0.28.1"
   },
   "standard": {
     "ignore": [

package/test/api.test.js

@@ -0,0 +1,294 @@
+'use strict'
+
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { test } = require('node:test')
+
+const { loadConfig } = require('@platformatic/service')
+const { buildServer, platformaticRuntime } = require('..')
+const fixturesDir = join(__dirname, '..', 'fixtures')
+
+// Each test runtime app adds own process listeners
+process.setMaxListeners(100)
+
+test('should get service details', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const serviceDetails = await app.getServiceDetails('with-logger')
+  assert.deepStrictEqual(serviceDetails, {
+    id: 'with-logger',
+    status: 'started',
+    entrypoint: false,
+    localUrl: 'http://with-logger.plt.local',
+    dependencies: []
+  })
+})
+
+test('should get service config', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const serviceConfig = await app.getServiceConfig('with-logger')
+
+  // TODO: should return correct logger config
+  assert.deepStrictEqual(serviceConfig, {
+    $schema: 'https://platformatic.dev/schemas/v0.27.0/service',
+    server: {
+      hostname: '127.0.0.1',
+      port: 0,
+      logger: {},
+      keepAliveTimeout: 5000
+    },
+    service: { openapi: true },
+    plugins: {
+      paths: [
+        join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'plugin.js')
+      ]
+    },
+    watch: false
+  })
+})
+
+test('should fail to get service config if service is not started', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  try {
+    await app.getServiceConfig('with-logger')
+    assert.fail('should have thrown')
+  } catch (err) {
+    assert.strictEqual(err.message, 'Service with id \'with-logger\' is not started')
+  }
+})
+
+test('should get services topology', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const topology = await app.getServices()
+
+  assert.deepStrictEqual(topology, {
+    entrypoint: 'serviceApp',
+    services: [
+      {
+        id: 'serviceApp',
+        status: 'started',
+        entrypoint: true,
+        localUrl: 'http://serviceApp.plt.local',
+        dependencies: [
+          {
+            id: 'with-logger',
+            url: 'http://with-logger.plt.local',
+            local: true
+          }
+        ]
+      },
+      {
+        id: 'with-logger',
+        status: 'started',
+        entrypoint: false,
+        localUrl: 'http://with-logger.plt.local',
+        dependencies: []
+      },
+      {
+        id: 'multi-plugin-service',
+        status: 'started',
+        entrypoint: false,
+        localUrl: 'http://multi-plugin-service.plt.local',
+        dependencies: []
+      }
+    ]
+  })
+})
+
+test('should stop service by service id', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  {
+    const serviceDetails = await app.getServiceDetails('with-logger')
+    assert.strictEqual(serviceDetails.status, 'started')
+  }
+
+  await app.stopService('with-logger')
+
+  {
+    const serviceDetails = await app.getServiceDetails('with-logger')
+    assert.strictEqual(serviceDetails.status, 'stopped')
+  }
+})
+
+test('should fail to stop service with a wrong id', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  try {
+    await app.stopService('wrong-service-id')
+    assert.fail('should have thrown')
+  } catch (err) {
+    assert.strictEqual(err.message, 'Service with id \'wrong-service-id\' not found')
+  }
+})
+
+test('should start stopped service by service id', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  await app.stopService('with-logger')
+
+  {
+    const serviceDetails = await app.getServiceDetails('with-logger')
+    assert.strictEqual(serviceDetails.status, 'stopped')
+  }
+
+  await app.startService('with-logger')
+
+  {
+    const serviceDetails = await app.getServiceDetails('with-logger')
+    assert.strictEqual(serviceDetails.status, 'started')
+  }
+})
+
+test('should fail to start service with a wrong id', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  try {
+    await app.startService('wrong-service-id')
+    assert.fail('should have thrown')
+  } catch (err) {
+    assert.strictEqual(err.message, 'Service with id \'wrong-service-id\' not found')
+  }
+})
+
+test('should fail to start running service', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  try {
+    await app.startService('with-logger')
+    assert.fail('should have thrown')
+  } catch (err) {
+    assert.strictEqual(err.message, 'application is already started')
+  }
+})
+
+test('should inject request to service', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const res = await app.inject('with-logger', {
+    method: 'GET',
+    url: '/'
+  })
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.strictEqual(res.statusMessage, 'OK')
+
+  assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+  assert.strictEqual(res.headers['content-length'], '17')
+  assert.strictEqual(res.headers.connection, 'keep-alive')
+
+  assert.strictEqual(res.body, '{"hello":"world"}')
+  assert.strictEqual(res.payload, '{"hello":"world"}')
+})
+
+test('should fail inject request is service is not started', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  try {
+    await app.inject('with-logger', { method: 'GET', url: '/' })
+  } catch (err) {
+    assert.strictEqual(err.message, 'Service with id \'with-logger\' is not started')
+  }
+})
+
+test('should handle a lot of runtime api requests', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const promises = []
+  for (let i = 0; i < 100; i++) {
+    promises.push(app.getServiceDetails('with-logger'))
+  }
+
+  await Promise.all(promises)
+})

package/test/app.test.js

@@ -3,6 +3,7 @@
 const assert = require('node:assert')
 const { join } = require('node:path')
 const { test } = require('node:test')
+const { utimes } = require('node:fs/promises')
 const { PlatformaticApp } = require('../lib/app')
 const fixturesDir = join(__dirname, '..', 'fixtures')
 const pino = require('pino')
@@ -266,3 +267,42 @@ test('supports configuration overrides', async (t) => {
     assert.strictEqual(app.config.configManager.current.server.keepAliveTimeout, 1)
   })
 })
+
+test('restarts on config change without overriding the configManager', { only: true }, async (t) => {
+  const { logger, stream } = getLoggerAndStream()
+  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, logger)
+
+  t.after(async function () {
+    try {
+      await app.stop()
+    } catch (err) {
+      console.error(err)
+    }
+  })
+  await app.start()
+  const configManager = app.config.configManager
+  await utimes(configFile, new Date(), new Date())
+  let first = false
+  for await (const log of stream) {
+    // Wait for the server to restart, it will print a line containing "Server listening"
+    if (log.msg.includes('listening')) {
+      if (first) {
+        break
+      }
+      first = true
+    }
+  }
+  assert.strictEqual(configManager, app.server.platformatic.configManager)
+})

package/test/config.test.js

@@ -56,3 +56,12 @@ test('performs a topological sort on services depending on allowCycles', async (
     })
   })
 })
+
+test('can resolve service id from client package.json if not provided', async () => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo-client-without-id.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const entry = config.configManager.current.serviceMap.get('serviceApp')
+
+  assert.strictEqual(entry.dependencies.length, 1)
+  assert.strictEqual(entry.dependencies[0].id, 'with-logger')
+})