@platformatic/runtime 2.0.0-alpha.2 → 2.0.0-alpha.4

package/lib/worker/app.js

@@ -0,0 +1,250 @@
+'use strict'
+
+const { EventEmitter } = require('node:events')
+const { FileWatcher } = require('@platformatic/utils')
+const { getGlobalDispatcher, setGlobalDispatcher } = require('undici')
+const debounce = require('debounce')
+
+const errors = require('../errors')
+const defaultStackable = require('./default-stackable')
+const { getServiceUrl, loadConfig, loadEmptyConfig } = require('../utils')
+
+class PlatformaticApp extends EventEmitter {
+  #starting
+  #started
+  #listening
+  #watch
+  #fileWatcher
+  #debouncedRestart
+  #context
+
+  constructor (appConfig, telemetryConfig, serverConfig, hasManagementApi, watch, metricsConfig) {
+    super()
+    this.appConfig = appConfig
+    this.#watch = watch
+    this.#starting = false
+    this.#started = false
+    this.#listening = false
+    this.stackable = null
+    this.#fileWatcher = null
+
+    this.#context = {
+      serviceId: this.appConfig.id,
+      directory: this.appConfig.path,
+      isEntrypoint: this.appConfig.entrypoint,
+      isProduction: false,
+      telemetryConfig,
+      metricsConfig,
+      serverConfig,
+      hasManagementApi: !!hasManagementApi,
+      localServiceEnvVars: this.appConfig.localServiceEnvVars,
+    }
+  }
+
+  getStatus () {
+    if (this.#starting) return 'starting'
+    if (this.#started) return 'started'
+    return 'stopped'
+  }
+
+  async updateContext (context) {
+    this.#context = { ...this.#context, ...context }
+    if (this.stackable) {
+      this.stackable.updateContext(context)
+    }
+  }
+
+  async getBootstrapDependencies () {
+    return this.stackable.getBootstrapDependencies()
+  }
+
+  async init () {
+    try {
+      const appConfig = this.appConfig
+      let loadedConfig
+
+      if (!appConfig.config) {
+        loadedConfig = await loadEmptyConfig(
+          appConfig.path,
+          {
+            onMissingEnv: this.#fetchServiceUrl,
+            context: appConfig,
+          },
+          true
+        )
+      } else {
+        loadedConfig = await loadConfig(
+          {},
+          ['-c', appConfig.config],
+          {
+            onMissingEnv: this.#fetchServiceUrl,
+            context: appConfig,
+          },
+          true
+        )
+      }
+
+      const app = loadedConfig.app
+
+      const stackable = await app.buildStackable({
+        onMissingEnv: this.#fetchServiceUrl,
+        config: this.appConfig.config,
+        context: this.#context,
+      })
+      this.stackable = this.#wrapStackable(stackable)
+
+      this.#updateDispatcher()
+    } catch (err) {
+      this.#logAndExit(err)
+    }
+  }
+
+  async start () {
+    if (this.#starting || this.#started) {
+      throw new errors.ApplicationAlreadyStartedError()
+    }
+
+    this.#starting = true
+
+    try {
+      await this.stackable.init()
+    } catch (err) {
+      this.#logAndExit(err)
+    }
+
+    if (this.#watch) {
+      const watchConfig = await this.stackable.getWatchConfig()
+      if (watchConfig.enabled !== false) {
+        /* c8 ignore next 4 */
+        this.#debouncedRestart = debounce(() => {
+          this.stackable.log({ message: 'files changed', level: 'debug' })
+          this.emit('changed')
+        }, 100) // debounce restart for 100ms
+
+        this.#startFileWatching(watchConfig)
+      }
+    }
+
+    const listen = !!this.appConfig.useHttp
+    try {
+      await this.stackable.start({ listen })
+      this.#listening = listen
+      /* c8 ignore next 5 */
+    } catch (err) {
+      this.stackable.log({ message: err.message, level: 'debug' })
+      this.#starting = false
+      throw err
+    }
+
+    this.#started = true
+    this.#starting = false
+    this.emit('start')
+  }
+
+  async stop () {
+    if (!this.#started || this.#starting) {
+      throw new errors.ApplicationNotStartedError()
+    }
+
+    await this.#stopFileWatching()
+    await this.stackable.stop()
+
+    this.#started = false
+    this.#starting = false
+    this.#listening = false
+    this.emit('stop')
+  }
+
+  async listen () {
+    // This server is not an entrypoint or already listened in start. Behave as no-op.
+    if (!this.appConfig.entrypoint || this.appConfig.useHttp || this.#listening) {
+      return
+    }
+
+    await this.stackable.start({ listen: true })
+  }
+
+  #fetchServiceUrl (key, { parent, context: service }) {
+    if (service.localServiceEnvVars.has(key)) {
+      return service.localServiceEnvVars.get(key)
+    } else if (!key.endsWith('_URL') || !parent.serviceId) {
+      return null
+    }
+
+    return getServiceUrl(parent.serviceId)
+  }
+
+  #startFileWatching (watch) {
+    if (this.#fileWatcher) {
+      return
+    }
+
+    const fileWatcher = new FileWatcher({
+      path: watch.path,
+      /* c8 ignore next 2 */
+      allowToWatch: watch?.allow,
+      watchIgnore: watch?.ignore || [],
+    })
+
+    fileWatcher.on('update', this.#debouncedRestart)
+
+    fileWatcher.startWatching()
+    this.stackable.log({ message: 'start watching files', level: 'debug' })
+    this.#fileWatcher = fileWatcher
+  }
+
+  async #stopFileWatching () {
+    const watcher = this.#fileWatcher
+
+    if (watcher) {
+      this.stackable.log({ message: 'stop watching files', level: 'debug' })
+      await watcher.stopWatching()
+      this.#fileWatcher = null
+    }
+  }
+
+  #logAndExit (err) {
+    // Runtime logs here with console.error because stackable is not initialized
+    console.error(
+      JSON.stringify({
+        msg: err.message,
+        name: this.appConfig.id,
+      })
+    )
+    process.exit(1)
+  }
+
+  #wrapStackable (stackable) {
+    const newStackable = {}
+    for (const method of Object.keys(defaultStackable)) {
+      newStackable[method] = stackable[method]
+        ? stackable[method].bind(stackable)
+        : defaultStackable[method]
+    }
+    return newStackable
+  }
+
+  #updateDispatcher () {
+    const telemetryConfig = this.#context.telemetryConfig
+    const telemetryId = telemetryConfig?.serviceName
+
+    const interceptor = dispatch => {
+      return function InterceptedDispatch (opts, handler) {
+        if (telemetryId) {
+          opts.headers = {
+            ...opts.headers,
+            'x-plt-telemetry-id': telemetryId,
+          }
+        }
+        return dispatch(opts, handler)
+      }
+    }
+
+    const dispatcher = getGlobalDispatcher()
+      .compose(interceptor)
+
+    setGlobalDispatcher(dispatcher)
+  }
+}
+
+module.exports = { PlatformaticApp }

package/lib/worker/default-stackable.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const defaultStackable = {
+  init: () => {},
+  start: () => {
+    throw new Error('Stackable start not implemented')
+  },
+  stop: () => {},
+  getUrl: () => null,
+  updateContext: () => {},
+  getConfig: () => null,
+  getInfo: () => null,
+  getDispatchFunc: () => null,
+  getOpenapiSchema: () => null,
+  getGraphqlSchema: () => null,
+  getMetrics: () => null,
+  inject: () => {
+    throw new Error('Stackable inject not implemented')
+  },
+  log: ({ message }) => {
+    console.log(message)
+  },
+  getBootstrapDependencies: () => [],
+  getWatchConfig: () => ({ enabled: false }),
+}
+
+module.exports = defaultStackable

package/lib/worker/itc.js

@@ -0,0 +1,128 @@
+'use strict'
+
+const { once } = require('node:events')
+const { parentPort } = require('node:worker_threads')
+
+const { ITC } = require('@platformatic/itc')
+
+const errors = require('../errors')
+const { kITC, kId } = require('./symbols')
+
+async function sendViaITC (worker, name, message) {
+  try {
+    // Make sure to catch when the worker exits, otherwise we're stuck forever
+    const ac = new AbortController()
+    let exitCode
+
+    const response = await Promise.race([
+      worker[kITC].send(name, message),
+      once(worker, 'exit', { signal: ac.signal }).then(([code]) => {
+        exitCode = code
+      }),
+    ])
+
+    if (typeof exitCode === 'number') {
+      throw new errors.ServiceExitedError(worker[kId], exitCode)
+    } else {
+      ac.abort()
+    }
+
+    return response
+  } catch (error) {
+    if (!error.handlerError) {
+      throw error
+    }
+
+    if (error.handlerErrorCode && !error.handlerError.code) {
+      error.handlerError.code = error.handlerErrorCode
+    }
+
+    throw error.handlerError
+  }
+}
+
+function setupITC (app, service, dispatcher) {
+  const itc = new ITC({ port: parentPort })
+
+  itc.handle('start', async () => {
+    const status = app.getStatus()
+
+    if (status === 'starting') {
+      await once(app, 'start')
+    } else {
+      await app.start()
+    }
+
+    if (service.entrypoint) {
+      await app.listen()
+    }
+
+    const url = app.stackable.getUrl()
+
+    const dispatchFunc = await app.stackable.getDispatchFunc()
+    dispatcher.replaceServer(url ?? dispatchFunc)
+
+    return service.entrypoint ? url : null
+  })
+
+  itc.handle('stop', async () => {
+    const status = app.getStatus()
+
+    if (status === 'starting') {
+      await once(app, 'start')
+    }
+
+    if (status !== 'stopped') {
+      await app.stop()
+    }
+
+    dispatcher.interceptor.close()
+    itc.close()
+  })
+
+  itc.handle('getStatus', async () => {
+    return app.getStatus()
+  })
+
+  itc.handle('getServiceInfo', async () => {
+    return app.stackable.getInfo()
+  })
+
+  itc.handle('getServiceConfig', async () => {
+    const current = await app.stackable.getConfig()
+    // Remove all undefined keys from the config
+    return JSON.parse(JSON.stringify(current))
+  })
+
+  itc.handle('getServiceOpenAPISchema', async () => {
+    try {
+      return app.stackable.getOpenapiSchema()
+    } catch (err) {
+      throw new errors.FailedToRetrieveOpenAPISchemaError(service.id, err.message)
+    }
+  })
+
+  itc.handle('getServiceGraphQLSchema', async () => {
+    try {
+      return app.stackable.getGraphqlSchema()
+    } catch (err) {
+      throw new errors.FailedToRetrieveGraphQLSchemaError(service.id, err.message)
+    }
+  })
+
+  itc.handle('getMetrics', async format => {
+    return app.stackable.getMetrics({ format })
+  })
+
+  itc.handle('inject', async injectParams => {
+    return app.stackable.inject(injectParams)
+  })
+
+  app.on('changed', () => {
+    itc.notify('changed')
+  })
+
+  return itc
+}
+
+module.exports = { sendViaITC, setupITC }

package/lib/worker/main.js

@@ -0,0 +1,127 @@
+'use strict'
+
+const { createRequire } = require('node:module')
+const { join } = require('node:path')
+const { setTimeout: sleep } = require('node:timers/promises')
+const { parentPort, workerData, threadId } = require('node:worker_threads')
+const { pathToFileURL } = require('node:url')
+
+const pino = require('pino')
+const { fetch, setGlobalDispatcher, Agent } = require('undici')
+const { wire } = require('undici-thread-interceptor')
+
+const { PlatformaticApp } = require('./app')
+const { setupITC } = require('./itc')
+const loadInterceptors = require('./interceptors')
+const { MessagePortWritable, createPinoWritable } = require('@platformatic/utils')
+const { kId, kITC } = require('./symbols')
+
+process.on('uncaughtException', handleUnhandled.bind(null, 'uncaught exception'))
+process.on('unhandledRejection', handleUnhandled.bind(null, 'unhandled rejection'))
+
+globalThis.fetch = fetch
+globalThis[kId] = threadId
+
+let app
+const config = workerData.config
+const logger = createLogger()
+
+function handleUnhandled (type, err) {
+  logger.error({ err }, `application ${type}`)
+
+  Promise.race([app?.stop(), sleep(1000, 'timeout', { ref: false })])
+    .catch()
+    .finally(() => {
+      process.exit(1)
+    })
+}
+
+function createLogger () {
+  const destination = new MessagePortWritable({ port: workerData.loggingPort })
+  const loggerInstance = pino({ level: 'trace' }, destination)
+
+  Reflect.defineProperty(process, 'stdout', { value: createPinoWritable(loggerInstance, 'info') })
+  Reflect.defineProperty(process, 'stderr', { value: createPinoWritable(loggerInstance, 'error') })
+
+  return loggerInstance
+}
+
+async function main () {
+  if (config.preload) {
+    await import(pathToFileURL(config.preload))
+  }
+
+  const service = workerData.serviceConfig
+
+  // Setup undici
+  const interceptors = {}
+  const composedInterceptors = []
+
+  if (config.undici?.interceptors) {
+    const _require = createRequire(join(workerData.dirname, 'package.json'))
+    for (const key of ['Agent', 'Pool', 'Client']) {
+      if (config.undici.interceptors[key]) {
+        interceptors[key] = await loadInterceptors(_require, config.undici.interceptors[key])
+      }
+    }
+
+    if (Array.isArray(config.undici.interceptors)) {
+      composedInterceptors.push(...(await loadInterceptors(_require, config.undici.interceptors)))
+    }
+  }
+
+  const globalDispatcher = new Agent({
+    ...config.undici,
+    interceptors,
+  }).compose(composedInterceptors)
+
+  setGlobalDispatcher(globalDispatcher)
+
+  // Setup mesh networker
+  const threadDispatcher = wire({ port: parentPort, useNetwork: service.useHttp })
+
+  // If the service is an entrypoint and runtime server config is defined, use it.
+  let serverConfig = null
+  if (config.server && service.entrypoint) {
+    serverConfig = config.server
+  } else if (service.useHttp) {
+    serverConfig = {
+      port: 0,
+      hostname: '127.0.0.1',
+      keepAliveTimeout: 5000,
+    }
+  }
+
+  let telemetryConfig = config.telemetry
+  if (telemetryConfig) {
+    telemetryConfig = {
+      ...telemetryConfig,
+      serviceName: `${telemetryConfig.serviceName}-${service.id}`,
+    }
+  }
+
+  // Create the application
+  app = new PlatformaticApp(
+    service,
+    telemetryConfig,
+    serverConfig,
+    !!config.managementApi,
+    !!config.watch,
+    config.metrics
+  )
+
+  await app.init()
+
+  // Setup interaction with parent port
+  const itc = setupITC(app, service, threadDispatcher)
+
+  // Get the dependencies
+  const dependencies = config.autoload ? await app.getBootstrapDependencies() : []
+  itc.notify('init', { dependencies })
+  itc.listen()
+
+  globalThis[kITC] = itc
+}
+
+// No need to catch this because there is the unhadledRejection handler on top.
+main()

package/lib/worker/symbols.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const kConfig = Symbol.for('plt.runtime.config')
+const kId = Symbol.for('plt.runtime.id') // This is also used to detect if we are running in a Platformatic runtime thread
+const kITC = Symbol.for('plt.runtime.itc')
+
+module.exports = { kConfig, kId, kITC }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-alpha.4",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -19,26 +19,26 @@
   "devDependencies": {
     "@fastify/express": "^3.0.0",
     "@fastify/formbody": "^7.4.0",
-    "@matteo.collina/tspl": "^0.1.1",
-    "borp": "^0.16.0",
+    "borp": "^0.17.0",
     "c8": "^10.0.0",
+    "eslint": "9",
     "execa": "^8.0.1",
     "express": "^4.18.3",
     "fast-jwt": "^4.0.0",
     "get-port": "^7.1.0",
+    "json-schema-to-typescript": "^15.0.0",
+    "neostandard": "^0.11.1",
     "pino-abstract-transport": "^1.1.0",
-    "snazzy": "^9.0.0",
     "split2": "^4.2.0",
-    "standard": "^17.1.0",
     "tsd": "^0.31.0",
-    "typescript": "^5.4.2",
+    "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/sql-graphql": "2.0.0-alpha.2",
-    "@platformatic/sql-mapper": "2.0.0-alpha.2",
-    "@platformatic/composer": "2.0.0-alpha.2",
-    "@platformatic/service": "2.0.0-alpha.2",
-    "@platformatic/db": "2.0.0-alpha.2"
+    "@platformatic/composer": "2.0.0-alpha.4",
+    "@platformatic/db": "2.0.0-alpha.4",
+    "@platformatic/service": "2.0.0-alpha.4",
+    "@platformatic/sql-graphql": "2.0.0-alpha.4",
+    "@platformatic/sql-mapper": "2.0.0-alpha.4"
   },
   "dependencies": {
     "@fastify/error": "^3.4.1",
@@ -62,24 +62,24 @@
     "pino-pretty": "^11.0.0",
     "pino-roll": "^1.0.0",
     "semgrator": "^0.3.0",
-    "tail-file-stream": "^0.1.0",
+    "tail-file-stream": "^0.2.0",
     "undici": "^6.9.0",
+    "undici-thread-interceptor": "^0.5.0",
     "ws": "^8.16.0",
-    "@platformatic/config": "2.0.0-alpha.2",
-    "@platformatic/telemetry": "2.0.0-alpha.2",
-    "@platformatic/utils": "2.0.0-alpha.2",
-    "@platformatic/ts-compiler": "2.0.0-alpha.2",
-    "@platformatic/generators": "2.0.0-alpha.2"
-  },
-  "standard": {
-    "ignore": [
-      "**/dist/*",
-      "**/test/tmp"
-    ]
+    "@platformatic/config": "2.0.0-alpha.4",
+    "@platformatic/basic": "2.0.0-alpha.4",
+    "@platformatic/generators": "2.0.0-alpha.4",
+    "@platformatic/itc": "2.0.0-alpha.4",
+    "@platformatic/telemetry": "2.0.0-alpha.4",
+    "@platformatic/ts-compiler": "2.0.0-alpha.4",
+    "@platformatic/utils": "2.0.0-alpha.4"
   },
   "scripts": {
     "test": "npm run lint && borp --concurrency=1 --timeout=180000 && tsd",
-    "coverage": "npm run lint && borp -X=fixtures -X=test -C --concurrency=1 --timeout=120000 && tsd",
-    "lint": "standard | snazzy"
+    "coverage": "npm run lint && borp -X=fixtures -X=test -C --concurrency=1 --timeout=180000 && tsd",
+    "gen-schema": "node lib/schema.js > schema.json",
+    "gen-types": "json2ts > config.d.ts < schema.json",
+    "build": "pnpm run gen-schema && pnpm run gen-types",
+    "lint": "eslint"
   }
 }

package/runtime.mjs

@@ -14,7 +14,7 @@ export const compile = compileCmd
 const help = helpMe({
   dir: join(import.meta.url, 'help'),
   // the default
-  ext: '.txt'
+  ext: '.txt',
 })
 
 const program = commist({ maxDistance: 2 })
@@ -28,8 +28,8 @@ program.register('compile', compile)
 export async function run (argv) {
   const args = parseArgs(argv, {
     alias: {
-      v: 'version'
-    }
+      v: 'version',
+    },
   })
 
   if (args.version) {
@@ -40,7 +40,7 @@ export async function run (argv) {
   /* c8 ignore next 4 */
   return {
     output: await program.parseAsync(argv),
-    help
+    help,
   }
 }