@platformatic/runtime 2.67.0-alpha.1 → 2.67.0-alpha.2

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export type HttpsSchemasPlatformaticDevPlatformaticRuntime2670Alpha1Json = {
+export type HttpsSchemasPlatformaticDevPlatformaticRuntime2670Alpha2Json = {
   [k: string]: unknown;
 } & {
   $schema?: string;

package/lib/config.js

@@ -251,7 +251,7 @@ platformaticRuntime.configManagerConfig = {
   upgrade
 }
 
-async function wrapConfigInRuntimeConfig ({ configManager, args }) {
+async function wrapConfigInRuntimeConfig ({ configManager, args, opts }) {
   let serviceId = 'main'
   try {
     const packageJson = join(configManager.dirname, 'package.json')
@@ -272,7 +272,7 @@ async function wrapConfigInRuntimeConfig ({ configManager, args }) {
   const wrapperConfig = {
     $schema: schema.$id,
     server,
-    watch: true,
+    watch: !args?.production,
     ...omitProperties(configManager.current.runtime ?? {}, runtimeUnwrappablePropertiesList),
     entrypoint: serviceId,
     services: [
@@ -298,7 +298,7 @@ async function wrapConfigInRuntimeConfig ({ configManager, args }) {
     }
   })
 
-  await cm.parseAndValidate()
+  await cm.parseAndValidate(true, [], opts)
 
   return cm
 }

package/lib/prom-server.js

@@ -93,6 +93,29 @@ async function startPrometheusServer (runtime, opts) {
     onRequestHook = promServer.basicAuth
   }
 
+  const readinessEndpoint = opts.readiness?.endpoint ?? DEFAULT_READINESS_ENDPOINT
+  const livenessEndpoint = opts.liveness?.endpoint ?? DEFAULT_LIVENESS_ENDPOINT
+
+  promServer.route({
+    url: '/',
+    method: 'GET',
+    logLevel: 'warn',
+    handler (req, reply) {
+      reply.type('text/plain')
+      let response = `Hello from Platformatic Prometheus Server!\nThe metrics are available at ${metricsEndpoint}.`
+
+      if (opts.readiness !== false) {
+        response += `\nThe readiness endpoint is available at ${readinessEndpoint}.`
+      }
+
+      if (opts.liveness !== false) {
+        response += `\nThe liveness endpoint is available at ${livenessEndpoint}.`
+      }
+
+      return response
+    }
+  })
+
   promServer.route({
     url: metricsEndpoint,
     method: 'GET',
@@ -112,7 +135,7 @@ async function startPrometheusServer (runtime, opts) {
     const failBody = opts.readiness?.fail?.body ?? DEFAULT_READINESS_FAIL_BODY
 
     promServer.route({
-      url: opts.readiness?.endpoint ?? DEFAULT_READINESS_ENDPOINT,
+      url: readinessEndpoint,
       method: 'GET',
       logLevel: 'warn',
       handler: async (req, reply) => {
@@ -151,7 +174,7 @@ async function startPrometheusServer (runtime, opts) {
     const failBody = opts.liveness?.fail?.body ?? DEFAULT_LIVENESS_FAIL_BODY
 
     promServer.route({
-      url: opts.liveness?.endpoint ?? DEFAULT_LIVENESS_ENDPOINT,
+      url: livenessEndpoint,
       method: 'GET',
       logLevel: 'warn',
       handler: async (req, reply) => {

package/lib/runtime.js

@@ -198,17 +198,7 @@ class Runtime extends EventEmitter {
       await this.closeAndThrow(e)
     }
 
-    const dispatcherOpts = { ...config.undici }
-    const interceptors = [this.#meshInterceptor]
-
-    if (config.httpCache) {
-      this.#sharedHttpCache = await createSharedStore(this.#configManager.dirname, config.httpCache)
-      interceptors.push(
-        undiciInterceptors.cache({ store: this.#sharedHttpCache, methods: config.httpCache.methods ?? ['GET', 'HEAD'] })
-      )
-    }
-
-    this.#dispatcher = new Agent(dispatcherOpts).compose(interceptors)
+    await this.#setDispatcher(config.undici)
 
     if (config.scheduler) {
       this.#scheduler = startScheduler(config.scheduler, this.#dispatcher, logger)
@@ -477,6 +467,22 @@ class Runtime extends EventEmitter {
     }
   }
 
+  async updateUndiciInterceptors (undiciConfig) {
+    this.#configManager.current.undici = undiciConfig
+
+    const promises = []
+    for (const worker of this.#workers.values()) {
+      promises.push(sendViaITC(worker, 'updateUndiciInterceptors', undiciConfig))
+    }
+
+    const results = await Promise.allSettled(promises)
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        throw result.reason
+      }
+    }
+  }
+
   startCollectingMetrics () {
     this.#metrics = []
     this.#metricsTimeout = setInterval(async () => {
@@ -1041,6 +1047,24 @@ class Runtime extends EventEmitter {
     return super.emit(event, payload)
   }
 
+  async #setDispatcher (undiciConfig) {
+    const config = this.#configManager.current
+
+    const dispatcherOpts = { ...undiciConfig }
+    const interceptors = [this.#meshInterceptor]
+
+    if (config.httpCache) {
+      this.#sharedHttpCache = await createSharedStore(this.#configManager.dirname, config.httpCache)
+      interceptors.push(
+        undiciInterceptors.cache({
+          store: this.#sharedHttpCache,
+          methods: config.httpCache.methods ?? ['GET', 'HEAD']
+        })
+      )
+    }
+    this.#dispatcher = new Agent(dispatcherOpts).compose(interceptors)
+  }
+
   #updateStatus (status, args) {
     this.#status = status
     this.emit(status, args)

package/lib/worker/interceptors.js

@@ -1,19 +1,208 @@
 'use strict'
 
+const { join } = require('node:path')
+const { workerData, parentPort } = require('node:worker_threads')
 const { pathToFileURL } = require('node:url')
+const { createRequire } = require('@platformatic/utils')
+const { setGlobalDispatcher, Client, Pool, Agent } = require('undici')
+const { wire } = require('undici-thread-interceptor')
+const { createTelemetryThreadInterceptorHooks } = require('@platformatic/telemetry')
+const { RemoteCacheStore, httpCacheInterceptor } = require('./http-cache')
+const { kInterceptors } = require('./symbols')
 
-async function loadInterceptor (_require, module, options) {
-  const url = pathToFileURL(_require.resolve(module))
-  const interceptor = (await import(url)).default
-  return interceptor(options)
+async function setDispatcher (runtimeConfig) {
+  const threadDispatcher = createThreadInterceptor(runtimeConfig)
+  const threadInterceptor = threadDispatcher.interceptor
+
+  let cacheInterceptor = null
+  if (runtimeConfig.httpCache) {
+    cacheInterceptor = createHttpCacheInterceptor(runtimeConfig)
+  }
+
+  let userInterceptors = []
+  if (Array.isArray(runtimeConfig.undici?.interceptors)) {
+    const _require = createRequire(join(workerData.dirname, 'package.json'))
+    userInterceptors = await loadInterceptors(_require, runtimeConfig.undici.interceptors)
+  }
+
+  const dispatcherOpts = await getDispatcherOpts(runtimeConfig.undici)
+
+  setGlobalDispatcher(
+    new Agent(dispatcherOpts).compose(
+      [
+        threadInterceptor,
+        ...userInterceptors,
+        cacheInterceptor
+      ].filter(Boolean)
+    )
+  )
+
+  return { threadDispatcher }
+}
+
+async function updateUndiciInterceptors (undiciConfig) {
+  const updatableInterceptors = globalThis[kInterceptors]
+  if (!updatableInterceptors) return
+
+  if (Array.isArray(undiciConfig?.interceptors)) {
+    for (const interceptorConfig of undiciConfig.interceptors) {
+      const { module, options } = interceptorConfig
+
+      const interceptorCtx = updatableInterceptors[module]
+      if (!interceptorCtx) continue
+
+      const { createInterceptor, updateInterceptor } = interceptorCtx
+      updateInterceptor(createInterceptor(options))
+    }
+  } else {
+    for (const key of ['Agent', 'Pool', 'Client']) {
+      const interceptorConfigs = undiciConfig.interceptors[key]
+      if (!interceptorConfigs) continue
+
+      for (const interceptorConfig of interceptorConfigs) {
+        const { module, options } = interceptorConfig
+
+        const interceptorCtx = updatableInterceptors[key][module]
+        if (!interceptorCtx) continue
+
+        const { createInterceptor, updateInterceptor } = interceptorCtx
+        updateInterceptor(createInterceptor(options))
+      }
+    }
+  }
 }
 
-function loadInterceptors (_require, interceptors) {
+function createUpdatableInterceptor (originInterceptor) {
+  let originalDispatcher = null
+  let originalDispatch = null
+
+  function updatableInterceptor (dispatch) {
+    originalDispatch = dispatch
+    originalDispatcher = originInterceptor(dispatch)
+
+    return function dispatcher (opts, handler) {
+      return originalDispatcher(opts, handler)
+    }
+  }
+
+  function updateInterceptor (newInterceptor) {
+    originalDispatcher = newInterceptor(originalDispatch)
+  }
+
+  return { updatableInterceptor, updateInterceptor }
+}
+
+async function loadInterceptors (_require, interceptorsConfigs, key) {
   return Promise.all(
-    interceptors.map(async ({ module, options }) => {
-      return loadInterceptor(_require, module, options)
+    interceptorsConfigs.map(async (interceptorConfig) => {
+      return loadInterceptor(_require, interceptorConfig, key)
     })
   )
 }
 
-module.exports = { loadInterceptors }
+async function loadInterceptor (_require, interceptorConfig, key) {
+  let updatableInterceptors = globalThis[kInterceptors]
+  if (!updatableInterceptors) {
+    updatableInterceptors = {}
+    globalThis[kInterceptors] = updatableInterceptors
+  }
+
+  const { module, options } = interceptorConfig
+
+  const url = pathToFileURL(_require.resolve(module))
+  const createInterceptor = (await import(url)).default
+  const interceptor = createInterceptor(options)
+
+  const {
+    updatableInterceptor,
+    updateInterceptor
+  } = createUpdatableInterceptor(interceptor)
+
+  const interceptorCtx = { createInterceptor, updateInterceptor }
+
+  if (key !== undefined) {
+    if (!updatableInterceptors[key]) {
+      updatableInterceptors[key] = {}
+    }
+    updatableInterceptors[key][module] = interceptorCtx
+  } else {
+    updatableInterceptors[module] = interceptorCtx
+  }
+
+  return updatableInterceptor
+}
+
+async function getDispatcherOpts (undiciConfig) {
+  const dispatcherOpts = { ...undiciConfig }
+
+  const interceptorsConfigs = undiciConfig?.interceptors
+  if (!interceptorsConfigs || Array.isArray(interceptorsConfigs)) {
+    return dispatcherOpts
+  }
+
+  const _require = createRequire(join(workerData.dirname, 'package.json'))
+
+  const clientInterceptors = []
+  const poolInterceptors = []
+
+  for (const key of ['Agent', 'Pool', 'Client']) {
+    const interceptorConfig = undiciConfig.interceptors[key]
+    if (!interceptorConfig) continue
+
+    const interceptors = await loadInterceptors(_require, interceptorConfig, key)
+    if (key === 'Agent') {
+      clientInterceptors.push(...interceptors)
+      poolInterceptors.push(...interceptors)
+    }
+    if (key === 'Pool') {
+      poolInterceptors.push(...interceptors)
+    }
+    if (key === 'Client') {
+      clientInterceptors.push(...interceptors)
+    }
+  }
+
+  dispatcherOpts.factory = (origin, opts) => {
+    return opts && opts.connections === 1
+      ? new Client(origin, opts).compose(clientInterceptors)
+      : new Pool(origin, opts).compose(poolInterceptors)
+  }
+
+  return dispatcherOpts
+}
+
+function createThreadInterceptor (runtimeConfig) {
+  const telemetry = runtimeConfig.telemetry
+  const hooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
+  const threadDispatcher = wire({
+    // Specifying the domain is critical to avoid flooding the DNS
+    // with requests for a domain that's never going to exist.
+    domain: '.plt.local',
+    port: parentPort,
+    timeout: runtimeConfig.serviceTimeout,
+    ...hooks
+  })
+  return threadDispatcher
+}
+
+function createHttpCacheInterceptor (runtimeConfig) {
+  const cacheInterceptor = httpCacheInterceptor({
+    store: new RemoteCacheStore({
+      onRequest: opts => {
+        globalThis.platformatic?.onHttpCacheRequest?.(opts)
+      },
+      onCacheHit: opts => {
+        globalThis.platformatic?.onHttpCacheHit?.(opts)
+      },
+      onCacheMiss: opts => {
+        globalThis.platformatic?.onHttpCacheMiss?.(opts)
+      },
+      logger: globalThis.platformatic.logger
+    }),
+    methods: runtimeConfig.httpCache.methods ?? ['GET', 'HEAD'],
+    logger: globalThis.platformatic.logger
+  })
+  return cacheInterceptor
+}
+
+module.exports = { setDispatcher, updateUndiciInterceptors }

package/lib/worker/itc.js

@@ -7,6 +7,7 @@ const { ITC } = require('@platformatic/itc')
 const { Unpromise } = require('@watchable/unpromise')
 
 const errors = require('../errors')
+const { updateUndiciInterceptors } = require('./interceptors')
 const { kITC, kId, kServiceId, kWorkerId } = require('./symbols')
 
 async function safeHandleInITC (worker, fn) {
@@ -109,6 +110,10 @@ function setupITC (app, service, dispatcher) {
         return app.stackable.inject(injectParams)
       },
 
+      async updateUndiciInterceptors (undiciConfig) {
+        await updateUndiciInterceptors(undiciConfig)
+      },
+
       getStatus () {
         return app.getStatus()
       },

package/lib/worker/main.js

@@ -2,16 +2,14 @@
 
 const { EventEmitter } = require('node:events')
 const { hostname } = require('node:os')
-const { join, resolve } = require('node:path')
-const { parentPort, workerData, threadId } = require('node:worker_threads')
+const { resolve } = require('node:path')
+const { workerData, threadId } = require('node:worker_threads')
 const { pathToFileURL } = require('node:url')
 const inspector = require('node:inspector')
 const diagnosticChannel = require('node:diagnostics_channel')
 const { ServerResponse } = require('node:http')
 
-const { createTelemetryThreadInterceptorHooks } = require('@platformatic/telemetry')
 const {
-  createRequire,
   disablePinoDirectWrite,
   ensureFlushedWorkerStdio,
   executeWithTimeout,
@@ -22,14 +20,11 @@ const {
 } = require('@platformatic/utils')
 const dotenv = require('dotenv')
 const pino = require('pino')
-const { fetch, setGlobalDispatcher, getGlobalDispatcher, Agent } = require('undici')
-const { wire } = require('undici-thread-interceptor')
-const undici = require('undici')
+const { fetch } = require('undici')
 
-const { RemoteCacheStore, httpCacheInterceptor } = require('./http-cache')
 const { PlatformaticApp } = require('./app')
 const { setupITC } = require('./itc')
-const { loadInterceptors } = require('./interceptors')
+const { setDispatcher } = require('./interceptors')
 const { kId, kITC, kStderrMarker } = require('./symbols')
 
 function handleUnhandled (app, type, err) {
@@ -138,85 +133,7 @@ async function main () {
     Object.assign(process.env, service.env)
   }
 
-  // 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 dispatcherOpts = { ...config.undici }
-
-  if (Object.keys(interceptors).length > 0) {
-    const clientInterceptors = []
-    const poolInterceptors = []
-
-    if (interceptors.Agent) {
-      clientInterceptors.push(...interceptors.Agent)
-      poolInterceptors.push(...interceptors.Agent)
-    }
-
-    if (interceptors.Pool) {
-      poolInterceptors.push(...interceptors.Pool)
-    }
-
-    if (interceptors.Client) {
-      clientInterceptors.push(...interceptors.Client)
-    }
-
-    dispatcherOpts.factory = (origin, opts) => {
-      return opts && opts.connections === 1
-        ? new undici.Client(origin, opts).compose(clientInterceptors)
-        : new undici.Pool(origin, opts).compose(poolInterceptors)
-    }
-  }
-
-  setGlobalDispatcher(new Agent(dispatcherOpts))
-
-  const { telemetry } = service
-  const hooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
-  // Setup mesh networker
-  const threadDispatcher = wire({
-    // Specifying the domain is critical to avoid flooding the DNS
-    // with requests for a domain that's never going to exist.
-    domain: '.plt.local',
-    port: parentPort,
-    timeout: config.serviceTimeout,
-    ...hooks
-  })
-
-  if (config.httpCache) {
-    const cacheInterceptor = httpCacheInterceptor({
-      store: new RemoteCacheStore({
-        onRequest: opts => {
-          globalThis.platformatic?.onHttpCacheRequest?.(opts)
-        },
-        onCacheHit: opts => {
-          globalThis.platformatic?.onHttpCacheHit?.(opts)
-        },
-        onCacheMiss: opts => {
-          globalThis.platformatic?.onHttpCacheMiss?.(opts)
-        },
-        logger: globalThis.platformatic.logger
-      }),
-      methods: config.httpCache.methods ?? ['GET', 'HEAD'],
-      logger: globalThis.platformatic.logger
-    })
-    composedInterceptors.push(cacheInterceptor)
-  }
-
-  const globalDispatcher = getGlobalDispatcher()
-  setGlobalDispatcher(globalDispatcher.compose(composedInterceptors))
+  const { threadDispatcher } = await setDispatcher(config)
 
   // If the service is an entrypoint and runtime server config is defined, use it.
   let serverConfig = null

package/lib/worker/symbols.js

@@ -8,6 +8,7 @@ const kWorkerId = Symbol.for('plt.runtime.worker.id')
 const kITC = Symbol.for('plt.runtime.itc')
 const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer')
 const kWorkerStatus = Symbol('plt.runtime.worker.status')
+const kInterceptors = Symbol.for('plt.runtime.worker.interceptors')
 
 // This string marker should be safe to use since it belongs to Unicode private area
 const kStderrMarker = '\ue002'
@@ -21,5 +22,6 @@ module.exports = {
   kITC,
   kHealthCheckTimer,
   kWorkerStatus,
-  kStderrMarker
+  kStderrMarker,
+  kInterceptors
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "2.67.0-alpha.1",
+  "version": "2.67.0-alpha.2",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -37,12 +37,12 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "2.67.0-alpha.1",
-    "@platformatic/db": "2.67.0-alpha.1",
-    "@platformatic/node": "2.67.0-alpha.1",
-    "@platformatic/service": "2.67.0-alpha.1",
-    "@platformatic/sql-graphql": "2.67.0-alpha.1",
-    "@platformatic/sql-mapper": "2.67.0-alpha.1"
+    "@platformatic/db": "2.67.0-alpha.2",
+    "@platformatic/node": "2.67.0-alpha.2",
+    "@platformatic/service": "2.67.0-alpha.2",
+    "@platformatic/sql-graphql": "2.67.0-alpha.2",
+    "@platformatic/composer": "2.67.0-alpha.2",
+    "@platformatic/sql-mapper": "2.67.0-alpha.2"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -77,13 +77,13 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.13.1",
     "ws": "^8.16.0",
-    "@platformatic/basic": "2.67.0-alpha.1",
-    "@platformatic/config": "2.67.0-alpha.1",
-    "@platformatic/generators": "2.67.0-alpha.1",
-    "@platformatic/itc": "2.67.0-alpha.1",
-    "@platformatic/telemetry": "2.67.0-alpha.1",
-    "@platformatic/ts-compiler": "2.67.0-alpha.1",
-    "@platformatic/utils": "2.67.0-alpha.1"
+    "@platformatic/basic": "2.67.0-alpha.2",
+    "@platformatic/config": "2.67.0-alpha.2",
+    "@platformatic/generators": "2.67.0-alpha.2",
+    "@platformatic/itc": "2.67.0-alpha.2",
+    "@platformatic/telemetry": "2.67.0-alpha.2",
+    "@platformatic/ts-compiler": "2.67.0-alpha.2",
+    "@platformatic/utils": "2.67.0-alpha.2"
   },
   "scripts": {
     "test": "pnpm run lint && borp --concurrency=1 --timeout=300000 && tsd",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.67.0-alpha.1.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.67.0-alpha.2.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {

package/undefined

@@ -1,5 +0,0 @@
-{"level":30,"time":1747909640025,"pid":84550,"hostname":"work","msg":"Starting the service \"service\"..."}
-{"level":30,"time":1747909640055,"pid":84550,"hostname":"work","msg":"Started the service \"service\"..."}
-{"level":30,"time":1747909640055,"pid":84550,"hostname":"work","msg":"Platformatic is now listening at http://127.0.0.1:41619"}
-{"level":30,"time":1747909640066,"pid":84550,"hostname":"work","msg":"Stopping the service \"service\"..."}
-{"level":30,"time":1747909640069,"pid":84550,"hostname":"work","msg":"Stopped the service \"service\"..."}