@platformatic/runtime 0.28.1 → 0.30.0

package/lib/worker.js

@@ -1,36 +1,33 @@
 'use strict'
 
+const inspector = require('node:inspector')
+const { isatty } = require('node:tty')
 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({
-  dispatcher: globalAgent,
-  // setting the domain here allows for fail-fast scenarios
-  domain: '.plt.local'
-})
+const undici = require('undici')
 const pino = require('pino')
-const { isatty } = require('tty')
-
-const applications = new Map()
+const RuntimeApi = require('./api')
+const { MessagePortWritable } = require('./message-port-writable')
+const loaderPort = globalThis.LOADER_PORT // Added by loader.mjs.
 
+globalThis.fetch = undici.fetch
 delete globalThis.LOADER_PORT
-setGlobalDispatcher(globalDispatcher)
 
 let transport
+let destination
 
-/* c8 ignore next 5 */
-if (isatty(1)) {
+/* c8 ignore next 10 */
+if (workerData.config.loggingPort) {
+  destination = new MessagePortWritable({
+    metadata: workerData.config.loggingMetadata,
+    port: workerData.config.loggingPort
+  })
+} else if (isatty(1)) {
   transport = pino.transport({
     target: 'pino-pretty'
   })
 }
 
-const logger = pino(transport)
+const logger = pino(transport, destination)
 
 /* c8 ignore next 4 */
 process.once('uncaughtException', (err) => {
@@ -45,17 +42,19 @@ process.once('unhandledRejection', (err) => {
   throw err
 })
 
-async function main () {
-  const { services } = workerData.config
+function main () {
+  const { inspectorOptions } = workerData.config
 
-  for (let i = 0; i < services.length; ++i) {
-    const service = services[i]
-    const app = new PlatformaticApp(service, loaderPort, logger)
+  if (inspectorOptions) {
+    /* c8 ignore next 6 */
+    if (inspectorOptions.hotReloadDisabled) {
+      logger.info('debugging flags were detected. hot reloading has been disabled')
+    }
 
-    applications.set(service.id, app)
+    inspector.open(inspectorOptions.port, inspectorOptions.host, inspectorOptions.breakFirstLine)
   }
 
-  const runtime = new RuntimeApi(applications, globalDispatcher)
+  const runtime = new RuntimeApi(workerData.config, logger, loaderPort)
   runtime.startListening(parentPort)
 
   parentPort.postMessage('plt:init')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "0.28.1",
+  "version": "0.30.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -22,7 +22,10 @@
     "snazzy": "^9.0.0",
     "split2": "^4.2.0",
     "standard": "^17.1.0",
-    "tsd": "^0.28.1"
+    "tsd": "^0.28.1",
+    "typescript": "^5.1.6",
+    "@platformatic/sql-mapper": "0.30.0",
+    "@platformatic/sql-graphql": "0.30.0"
   },
   "dependencies": {
     "@hapi/topo": "^6.0.2",
@@ -37,15 +40,16 @@
     "pino": "^8.14.1",
     "pino-pretty": "^10.0.0",
     "undici": "^5.22.1",
-    "@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"
+    "@platformatic/composer": "0.30.0",
+    "@platformatic/config": "0.30.0",
+    "@platformatic/db": "0.30.0",
+    "@platformatic/service": "0.30.0",
+    "@platformatic/utils": "0.30.0"
   },
   "standard": {
     "ignore": [
-      "**/dist/*"
+      "**/dist/*",
+      "**/test/tmp"
     ]
   },
   "scripts": {

package/runtime.mjs

@@ -7,6 +7,7 @@ import isMain from 'es-main'
 import helpMe from 'help-me'
 import parseArgs from 'minimist'
 import { start } from './lib/start.js'
+import { compile } from './lib/compile.js'
 
 const help = helpMe({
   dir: join(import.meta.url, 'help'),
@@ -18,7 +19,9 @@ const program = commist({ maxDistance: 2 })
 
 program.register('help', help.toStdout)
 program.register('help start', help.toStdout.bind(null, ['start']))
+program.register('help compile', help.toStdout.bind(null, ['compile']))
 program.register('start', start)
+program.register('compile', compile)
 
 export async function run (argv) {
   const args = parseArgs(argv, {
@@ -32,6 +35,7 @@ export async function run (argv) {
     process.exit(0)
   }
 
+  /* c8 ignore next 4 */
   return {
     output: await program.parseAsync(argv),
     help

package/test/api.test.js

@@ -45,9 +45,10 @@ test('should get service config', async (t) => {
 
   const serviceConfig = await app.getServiceConfig('with-logger')
 
+  delete serviceConfig.$schema
+
   // 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,
@@ -274,6 +275,16 @@ test('should fail inject request is service is not started', async (t) => {
   }
 })
 
+test('does not wait forever if worker exits during api operation', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'service-throws-on-start.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await assert.rejects(async () => {
+    await app.start()
+  }, /The runtime exited before the operation completed/)
+})
+
 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)

package/test/app.test.js

@@ -268,7 +268,7 @@ test('supports configuration overrides', async (t) => {
   })
 })
 
-test('restarts on config change without overriding the configManager', { only: true }, async (t) => {
+test('restarts on config change without overriding the configManager', async (t) => {
   const { logger, stream } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')

package/test/cli/compile.test.mjs

@@ -0,0 +1,65 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { join } from 'desm'
+import path from 'node:path'
+import { cliPath } from './helper.mjs'
+import { execa } from 'execa'
+import { mkdtemp, rm, cp, mkdir } from 'node:fs/promises'
+import { setTimeout as sleep } from 'node:timers/promises'
+
+const base = join(import.meta.url, '..', 'tmp')
+
+try {
+  await mkdir(base, { recursive: true })
+} catch {
+}
+
+test('compile without tsconfigs', async () => {
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'monorepo.json')
+  await execa(cliPath, ['compile', '-c', config])
+})
+
+test('compile with tsconfig', async (t) => {
+  const tmpDir = await mkdtemp(path.join(base, 'test-runtime-compile-'))
+  const prev = process.cwd()
+  process.chdir(tmpDir)
+  t.after(() => {
+    process.chdir(prev)
+  })
+
+  t.after(async () => {
+    // We give up after 10s.
+    // This is because on Windows, it's very hard to delete files if the file
+    // system is not collaborating.
+    for (let i = 0; i < 10; i++) {
+      try {
+        await rm(tmpDir, { recursive: true, force: true })
+        break
+      } catch (err) {
+        if (err.code === 'EBUSY') {
+          await sleep(1000)
+          continue
+        }
+      }
+    }
+  })
+
+  const folder = join(import.meta.url, '..', '..', 'fixtures', 'typescript')
+  await cp(folder, tmpDir, { recursive: true })
+
+  const { stdout } = await execa(cliPath, ['compile'])
+
+  const lines = stdout.split('\n').map(JSON.parse)
+  const expected = [{
+    name: 'movies',
+    msg: 'Typescript compilation completed successfully.'
+  }, {
+    name: 'titles',
+    msg: 'Typescript compilation completed successfully.'
+  }]
+
+  for (let i = 0; i < expected.length; i++) {
+    assert.deepStrictEqual(lines[i].name, expected[i].name)
+    assert.deepStrictEqual(lines[i].msg, expected[i].msg)
+  }
+})

package/test/cli/start.test.mjs

@@ -59,3 +59,59 @@ test('exits on error', async () => {
   assert.strictEqual(res.statusCode, 200)
   assert.strictEqual(exitCode, 1)
 })
+
+test('does not start if node inspector flags are provided', async (t) => {
+  const { execa } = await import('execa')
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'monorepo.json')
+  const child = execa(process.execPath, [cliPath, 'start', '-c', config], {
+    env: { NODE_OPTIONS: '--inspect' },
+    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: The Node.js inspector flags are not supported/.test(stderr)) {
+        found = true
+        break
+      }
+    }
+
+    if (found) {
+      break
+    }
+  }
+
+  assert(found)
+})
+
+test('starts the inspector', async (t) => {
+  const { execa } = await import('execa')
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'monorepo.json')
+  const child = execa(process.execPath, [cliPath, 'start', '-c', config, '--inspect'], {
+    encoding: 'utf8'
+  })
+  let stderr = ''
+  let found = false
+
+  for await (const messages of on(child.stderr, 'data')) {
+    for (const message of messages) {
+      stderr += message
+
+      if (/Debugger listening on ws:\/\/127\.0\.0\.1:9229/.test(stderr)) {
+        found = true
+        break
+      }
+    }
+
+    if (found) {
+      break
+    }
+  }
+
+  assert(found)
+  child.kill('SIGINT')
+})

package/test/cli/validations.test.mjs

@@ -1,6 +1,7 @@
 import assert from 'node:assert'
 import { readFile } from 'node:fs/promises'
 import { test } from 'node:test'
+import { stripVTControlCharacters } from 'node:util'
 import { join } from 'desm'
 import { execa } from 'execa'
 import { cliPath } from './helper.mjs'
@@ -42,7 +43,7 @@ test('print validation errors', async () => {
 
   assert(error)
   assert.strictEqual(error.exitCode, 1)
-  assert.strictEqual(error.stdout, `
+  assert.strictEqual(stripVTControlCharacters(error.stdout), `
 ┌─────────┬─────────────┬─────────────────────────────────────────────────────────────────┐
 │ (index) │    path     │                             message                             │
 ├─────────┼─────────────┼─────────────────────────────────────────────────────────────────┤

package/test/cli/watch.test.mjs

@@ -1,14 +1,20 @@
 import assert from 'node:assert'
-import { cp, writeFile, mkdtemp } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
+import { cp, writeFile, mkdtemp, mkdir, rm } from 'node:fs/promises'
 import { join } from 'node:path'
 import { test } from 'node:test'
 import { setTimeout as sleep } from 'node:timers/promises'
 import desm from 'desm'
 import { request } from 'undici'
 import { start } from './helper.mjs'
+
 const fixturesDir = join(desm(import.meta.url), '..', '..', 'fixtures')
-const undiciPath = join(desm(import.meta.url), '..', '..', 'node_modules', 'undici')
+
+const base = join(desm(import.meta.url), '..', 'tmp')
+
+try {
+  await mkdir(base, { recursive: true })
+} catch {
+}
 
 function createCjsLoggingPlugin (text, reloaded) {
   return `\
@@ -42,7 +48,8 @@ function createEsmLoggingPlugin (text, reloaded) {
 }
 
 test('watches CommonJS files', async (t) => {
-  const tmpDir = await mkdtemp(join(tmpdir(), 'watch-'))
+  const tmpDir = await mkdtemp(join(base, 'watch-'))
+  t.after(() => rm(tmpDir, { recursive: true, force: true }))
   t.diagnostic(`using ${tmpDir}`)
   const configFileSrc = join(fixturesDir, 'configs', 'monorepo.json')
   const configFileDst = join(tmpDir, 'configs', 'monorepo.json')
@@ -55,8 +62,6 @@ test('watches CommonJS files', async (t) => {
     cp(appSrc, appDst, { recursive: true })
   ])
 
-  await cp(undiciPath, join(appDst, 'serviceApp', 'node_modules', 'undici'), { recursive: true })
-
   await writeFile(cjsPluginFilePath, createCjsLoggingPlugin('v1', false))
   const { child } = await start('-c', configFileDst)
   t.after(() => child.kill('SIGINT'))
@@ -73,7 +78,8 @@ test('watches CommonJS files', async (t) => {
 })
 
 test('watches ESM files', async (t) => {
-  const tmpDir = await mkdtemp(join(tmpdir(), 'watch-'))
+  const tmpDir = await mkdtemp(join(base, 'watch-'))
+  t.after(() => rm(tmpDir, { recursive: true, force: true }))
   t.diagnostic(`using ${tmpDir}`)
   const configFileSrc = join(fixturesDir, 'configs', 'monorepo.json')
   const configFileDst = join(tmpDir, 'configs', 'monorepo.json')
@@ -86,8 +92,6 @@ test('watches ESM files', async (t) => {
     cp(appSrc, appDst, { recursive: true })
   ])
 
-  await cp(undiciPath, join(appDst, 'serviceApp', 'node_modules', 'undici'), { recursive: true })
-
   await writeFile(esmPluginFilePath, createEsmLoggingPlugin('v1', false))
   const { child } = await start('-c', configFileDst)
   t.after(() => child.kill('SIGINT'))
@@ -103,7 +107,8 @@ test('watches ESM files', async (t) => {
 })
 
 test('should not hot reload files with `--hot-reload false', async (t) => {
-  const tmpDir = await mkdtemp(join(tmpdir(), 'watch-'))
+  const tmpDir = await mkdtemp(join(base, 'watch-'))
+  t.after(() => rm(tmpDir, { recursive: true, force: true }))
   t.diagnostic(`using ${tmpDir}`)
   const configFileSrc = join(fixturesDir, 'configs', 'monorepo.json')
   const configFileDst = join(tmpDir, 'configs', 'monorepo.json')
@@ -116,8 +121,6 @@ test('should not hot reload files with `--hot-reload false', async (t) => {
     cp(appSrc, appDst, { recursive: true })
   ])
 
-  await cp(undiciPath, join(appDst, 'serviceApp', 'node_modules', 'undici'), { recursive: true })
-
   await writeFile(cjsPluginFilePath, createCjsLoggingPlugin('v1', false))
   const { child, url } = await start('-c', configFileDst, '--hot-reload', 'false')
   t.after(() => child.kill('SIGINT'))

package/test/config.test.js

@@ -4,7 +4,7 @@ const assert = require('node:assert')
 const { join } = require('node:path')
 const { test } = require('node:test')
 const { loadConfig } = require('@platformatic/service')
-const { platformaticRuntime } = require('../lib/config')
+const { parseInspectorOptions, platformaticRuntime } = require('../lib/config')
 const fixturesDir = join(__dirname, '..', 'fixtures')
 
 test('throws if no entrypoint is found', async (t) => {
@@ -65,3 +65,139 @@ test('can resolve service id from client package.json if not provided', async ()
   assert.strictEqual(entry.dependencies.length, 1)
   assert.strictEqual(entry.dependencies[0].id, 'with-logger')
 })
+
+test('parseInspectorOptions()', async (t) => {
+  await t.test('throws if --inspect and --inspect-brk are both used', () => {
+    assert.throws(() => {
+      const cm = {
+        args: { inspect: '', 'inspect-brk': '' },
+        current: {}
+      }
+
+      parseInspectorOptions(cm)
+    }, /--inspect and --inspect-brk cannot be used together/)
+  })
+
+  await t.test('--inspect default settings', () => {
+    const cm = {
+      args: { inspect: '' },
+      current: {}
+    }
+
+    parseInspectorOptions(cm)
+    assert.deepStrictEqual(cm.current.inspectorOptions, {
+      host: '127.0.0.1',
+      port: 9229,
+      breakFirstLine: false,
+      hotReloadDisabled: false
+    })
+  })
+
+  await t.test('--inspect-brk default settings', () => {
+    const cm = {
+      args: { 'inspect-brk': '' },
+      current: {}
+    }
+
+    parseInspectorOptions(cm)
+    assert.deepStrictEqual(cm.current.inspectorOptions, {
+      host: '127.0.0.1',
+      port: 9229,
+      breakFirstLine: true,
+      hotReloadDisabled: false
+    })
+  })
+
+  await t.test('hot reloading is disabled if the inspector is used', () => {
+    const cm1 = {
+      args: { 'inspect-brk': '' },
+      current: { hotReload: true }
+    }
+
+    parseInspectorOptions(cm1)
+    assert.strictEqual(cm1.current.hotReload, false)
+
+    const cm2 = {
+      args: {},
+      current: { hotReload: true }
+    }
+
+    parseInspectorOptions(cm2)
+    assert.strictEqual(cm2.current.hotReload, true)
+  })
+
+  await t.test('sets port to a custom value', () => {
+    const cm = {
+      args: { inspect: '6666' },
+      current: {}
+    }
+
+    parseInspectorOptions(cm)
+    assert.deepStrictEqual(cm.current.inspectorOptions, {
+      host: '127.0.0.1',
+      port: 6666,
+      breakFirstLine: false,
+      hotReloadDisabled: false
+    })
+  })
+
+  await t.test('sets host and port to custom values', () => {
+    const cm = {
+      args: { inspect: '0.0.0.0:6666' },
+      current: {}
+    }
+
+    parseInspectorOptions(cm)
+    assert.deepStrictEqual(cm.current.inspectorOptions, {
+      host: '0.0.0.0',
+      port: 6666,
+      breakFirstLine: false,
+      hotReloadDisabled: false
+    })
+  })
+
+  await t.test('throws if the host is empty', () => {
+    assert.throws(() => {
+      const cm = {
+        args: { inspect: ':9229' },
+        current: {}
+      }
+
+      parseInspectorOptions(cm)
+    }, /inspector host cannot be empty/)
+  })
+
+  await t.test('differentiates valid and invalid ports', () => {
+    ['127.0.0.1:', 'foo', '1', '-1', '1023', '65536'].forEach((inspectFlag) => {
+      assert.throws(() => {
+        const cm = {
+          args: { inspect: inspectFlag },
+          current: {}
+        }
+
+        parseInspectorOptions(cm)
+      }, /inspector port must be 0 or in range 1024 to 65535/)
+    })
+
+    const cm = {
+      args: {},
+      current: {}
+    }
+
+    cm.args.inspect = '0'
+    parseInspectorOptions(cm)
+    assert.strictEqual(cm.current.inspectorOptions.port, 0)
+    cm.args.inspect = '1024'
+    parseInspectorOptions(cm)
+    assert.strictEqual(cm.current.inspectorOptions.port, 1024)
+    cm.args.inspect = '1025'
+    parseInspectorOptions(cm)
+    assert.strictEqual(cm.current.inspectorOptions.port, 1025)
+    cm.args.inspect = '65534'
+    parseInspectorOptions(cm)
+    assert.strictEqual(cm.current.inspectorOptions.port, 65534)
+    cm.args.inspect = '65535'
+    parseInspectorOptions(cm)
+    assert.strictEqual(cm.current.inspectorOptions.port, 65535)
+  })
+})

package/test/start.test.js

@@ -1,10 +1,14 @@
 'use strict'
 const assert = require('node:assert')
+const { spawn } = require('node:child_process')
+const { once } = require('node:events')
 const { join } = require('node:path')
 const { test } = require('node:test')
+const { MessageChannel } = require('node:worker_threads')
 const { request } = require('undici')
 const { loadConfig } = require('@platformatic/service')
 const { buildServer, platformaticRuntime } = require('..')
+const { startWithConfig } = require('../lib/start')
 const fixturesDir = join(__dirname, '..', 'fixtures')
 
 test('can start applications programmatically from object', async (t) => {
@@ -99,3 +103,56 @@ test('can restart the runtime apps', async (t) => {
     assert.deepStrictEqual(await res.body.json(), { hello: 'world' })
   }
 })
+
+test('supports logging via message port', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const { port1, port2 } = new MessageChannel()
+  config.configManager.current.loggingPort = port2
+  config.configManager.current.loggingMetadata = { foo: 1, bar: 2 }
+  const app = await buildServer(config.configManager.current)
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const [msg] = await once(port1, 'message')
+
+  assert.deepStrictEqual(msg.metadata, { foo: 1, bar: 2 })
+  assert(Array.isArray(msg.logs))
+  assert(msg.logs.length > 0)
+
+  for (let i = 0; i < msg.logs.length; ++i) {
+    // Verify that each log is valid JSON.
+    JSON.parse(msg.logs[i])
+  }
+})
+
+test('can start with a custom environment', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await startWithConfig(config.configManager, { A_CUSTOM_ENV_VAR: 'foobar' })
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const entryUrl = await app.start()
+  const res = await request(entryUrl + '/env')
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.deepStrictEqual(await res.body.json(), { A_CUSTOM_ENV_VAR: 'foobar' })
+})
+
+test('handles uncaught exceptions with db app', async (t) => {
+  // Test for https://github.com/platformatic/platformatic/issues/1193
+  const scriptFile = join(fixturesDir, 'start-command-in-runtime.js')
+  const configFile = join(fixturesDir, 'dbApp', 'platformatic.db.json')
+  const child = spawn(process.execPath, [scriptFile, configFile, '/async_crash'])
+  child.stdout.pipe(process.stdout)
+  child.stderr.pipe(process.stderr)
+  const [exitCode] = await once(child, 'exit')
+
+  assert.strictEqual(exitCode, 42)
+})