@platformatic/runtime 2.8.0 → 2.8.2-alpha.1

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export type HttpsSchemasPlatformaticDevPlatformaticRuntime280Json = {
+export type HttpsSchemasPlatformaticDevPlatformaticRuntime282Alpha1Json = {
   [k: string]: unknown;
 } & {
   $schema?: string;
@@ -115,6 +115,17 @@ export type HttpsSchemasPlatformaticDevPlatformaticRuntime280Json = {
         };
     [k: string]: unknown;
   };
+  httpCache?:
+    | boolean
+    | {
+        store?: string;
+        /**
+         * @minItems 1
+         */
+        methods?: [string, ...string[]];
+        cacheTagsHeader?: string;
+        [k: string]: unknown;
+      };
   watch?: boolean | string;
   managementApi?:
     | boolean

package/lib/config.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const { readdir } = require('node:fs/promises')
-const { join, resolve: pathResolve } = require('node:path')
+const { join, resolve: pathResolve, isAbsolute } = require('node:path')
 
 const ConfigManager = require('@platformatic/config')
+const { Store } = require('@platformatic/config')
 
 const errors = require('./errors')
 const { schema } = require('./schema')
@@ -86,9 +87,40 @@ async function _transformConfig (configManager, args) {
   for (let i = 0; i < services.length; ++i) {
     const service = services[i]
 
+    // We need to have absolut paths here, ot the `loadConfig` will fail
+    if (!isAbsolute(service.path)) {
+      service.path = pathResolve(configManager.dirname, service.path)
+    }
+
     if (configManager._fixPaths && service.config) {
       service.config = pathResolve(service.path, service.config)
     }
+
+    if (service.config) {
+      try {
+        const store = new Store({ cwd: service.path })
+        const serviceConfig = await store.loadConfig(service)
+        service.isPLTService = !!serviceConfig.app.isPLTService
+        service.type = serviceConfig.app.configType
+      } catch (err) {
+        // Fallback if for any reason a dependency is not found
+        try {
+          const manager = new ConfigManager({ source: pathResolve(service.path, service.config) })
+          await manager.parse()
+          const config = manager.current
+          const type = config.$schema ? ConfigManager.matchKnownSchema(config.$schema) : undefined
+          service.type = type
+          service.isPLTService = !!config.isPLTService
+        } catch (err) {
+          // This should not happen, it happens on running some unit tests if we prepare the runtime
+          // when not all the services configs are available. Given that we are running this only
+          // to ddetermine the type of the service, it's safe to ignore this error and default to unknown
+          service.type = 'unknown'
+          service.isPLTService = false
+        }
+      }
+    }
+
     service.entrypoint = service.id === config.entrypoint
     service.dependencies = []
     service.localServiceEnvVars = new Map()
@@ -121,12 +153,7 @@ async function _transformConfig (configManager, args) {
           continue
         }
 
-        const manager = new ConfigManager({ source: pathResolve(service.path, service.config) })
-        await manager.parse()
-        const config = manager.current
-        const type = config.$schema ? ConfigManager.matchKnownSchema(config.$schema) : undefined
-
-        if (type === 'composer') {
+        if (service.type === 'composer') {
           composers.push(service.id)
         }
       }

package/lib/management-api.js

@@ -193,6 +193,15 @@ async function managementApiPlugin (app, opts) {
     const logFileStream = await runtime.getLogFileStream(logId, runtimePID)
     return logFileStream
   })
+
+  app.get('/http-cache/requests', async () => {
+    return runtime.getCachedHttpRequests()
+  })
+
+  app.post('/http-cache/invalidate', async (req) => {
+    const { origin, routes, tags } = req.body
+    await runtime.invalidateHttpCache({ origin, routes, tags })
+  })
 }
 
 async function startManagementApi (runtime, configManager) {

package/lib/runtime.js

@@ -16,6 +16,7 @@ const errors = require('./errors')
 const { createLogger } = require('./logger')
 const { startManagementApi } = require('./management-api')
 const { startPrometheusServer } = require('./prom-server')
+const { createSharedStore } = require('./shared-http-cache')
 const { getRuntimeTmpDir } = require('./utils')
 const { sendViaITC, waitEventFromITC } = require('./worker/itc')
 const { RoundRobinMap } = require('./worker/round-robin-map.js')
@@ -43,6 +44,9 @@ const COLLECT_METRICS_TIMEOUT = 1000
 
 const MAX_BOOTSTRAP_ATTEMPTS = 5
 
+const telemetryPath = require.resolve('@platformatic/telemetry')
+const openTelemetrySetupPath = join(telemetryPath, '..', 'lib', 'node-http-telemetry.js')
+
 class Runtime extends EventEmitter {
   #configManager
   #isProduction
@@ -62,6 +66,7 @@ class Runtime extends EventEmitter {
   #inspectorServer
   #workers
   #restartingWorkers
+  #sharedHttpCache
 
   constructor (configManager, runtimeLogsDir, env) {
     super()
@@ -78,6 +83,7 @@ class Runtime extends EventEmitter {
     this.#interceptor = createThreadInterceptor({ domain: '.plt.local', timeout: true })
     this.#status = undefined
     this.#restartingWorkers = new Map()
+    this.#sharedHttpCache = null
   }
 
   async init () {
@@ -124,6 +130,16 @@ class Runtime extends EventEmitter {
       throw e
     }
 
+    this.#sharedHttpCache = createSharedStore(
+      this.#configManager.dirname,
+      {
+        ...config.httpCache,
+        errorCallback: (err) => {
+          this.logger.error(err, 'Error in shared HTTP cache store')
+        }
+      }
+    )
+
     this.#updateStatus('init')
   }
 
@@ -252,6 +268,10 @@ class Runtime extends EventEmitter {
       this.#loggerDestination = null
     }
 
+    if (this.#sharedHttpCache?.close) {
+      await this.#sharedHttpCache.close()
+    }
+
     this.#updateStatus('closed')
   }
 
@@ -714,6 +734,24 @@ class Runtime extends EventEmitter {
     return createReadStream(filePath)
   }
 
+  async getCachedHttpRequests () {
+    return this.#sharedHttpCache.getRoutes()
+  }
+
+  async invalidateHttpCache (options = {}) {
+    const { origin, routes, tags } = options
+
+    if (!this.#sharedHttpCache) return
+
+    if (routes && routes.length > 0) {
+      await this.#sharedHttpCache.deleteRoutes(routes)
+    }
+
+    if (tags && tags.length > 0) {
+      await this.#sharedHttpCache.deleteByCacheTags(origin, tags)
+    }
+  }
+
   #updateStatus (status) {
     this.#status = status
     this.emit(status)
@@ -753,6 +791,13 @@ class Runtime extends EventEmitter {
       inspectorOptions.port = inspectorOptions.port + this.#workers.size + 1
     }
 
+    if (config.telemetry) {
+      serviceConfig.telemetry = {
+        ...config.telemetry,
+        serviceName: `${config.telemetry.serviceName}-${serviceConfig.id}`
+      }
+    }
+
     const worker = new Worker(kWorkerFile, {
       workerData: {
         config,
@@ -770,7 +815,7 @@ class Runtime extends EventEmitter {
         runtimeLogsDir: this.#runtimeLogsDir,
         loggingPort
       },
-      execArgv: [], // Avoid side effects
+      execArgv: serviceConfig.isPLTService ? [] : ['--require', openTelemetrySetupPath],
       env: this.#env,
       transferList: [loggingPort],
       /*
@@ -845,9 +890,19 @@ class Runtime extends EventEmitter {
       port: worker,
       handlers: {
         getServiceMeta: this.getServiceMeta.bind(this),
-        listServices: () => {
-          return this.#servicesIds
-        }
+        listServices: () => this.#servicesIds,
+        getServices: this.getServices.bind(this),
+        isHttpCacheFull: () => this.#sharedHttpCache.isFull(),
+        getHttpCacheValue: opts => this.#sharedHttpCache.getValue(opts.request),
+        setHttpCacheValue: opts => this.#sharedHttpCache.setValue(
+          opts.request,
+          opts.response,
+          opts.payload
+        ),
+        deleteHttpCacheValue: opts => this.#sharedHttpCache.deleteByOrigin(
+          opts.origin
+        ),
+        invalidateHttpCache: opts => this.invalidateHttpCache(opts),
       }
     })
     worker[kITC].listen()

package/lib/schema.js

@@ -185,6 +185,32 @@ const platformaticRuntimeSchema = {
         }
       }
     },
+    httpCache: {
+      oneOf: [
+        {
+          type: 'boolean'
+        },
+        {
+          type: 'object',
+          properties: {
+            store: {
+              type: 'string'
+            },
+            methods: {
+              type: 'array',
+              items: {
+                type: 'string'
+              },
+              default: ['GET', 'HEAD'],
+              minItems: 1
+            },
+            cacheTagsHeader: {
+              type: 'string'
+            }
+          }
+        }
+      ]
+    },
     watch: {
       anyOf: [
         {

package/lib/shared-http-cache.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const { join } = require('node:path')
+const { createRequire } = require('node:module')
+const MemoryCacheStore = require('@platformatic/undici-cache-memory')
+
+function createSharedStore (projectDir, httpCacheConfig = {}) {
+  const runtimeRequire = createRequire(join(projectDir, 'file'))
+
+  const { store, ...storeConfig } = httpCacheConfig
+  const CacheStore = store ? runtimeRequire(store) : MemoryCacheStore
+
+  class SharedCacheStore extends CacheStore {
+    async getValue (req) {
+      const readStream = await this.createReadStream(req)
+      if (!readStream) return null
+
+      let payload = ''
+      for await (const chunk of readStream) {
+        payload += chunk
+      }
+
+      const response = this.#sanitizeResponse(readStream.value)
+      return { response, payload }
+    }
+
+    setValue (req, opts, data) {
+      const writeStream = this.createWriteStream(req, opts)
+      writeStream.write(data)
+      writeStream.end()
+      return null
+    }
+
+    #sanitizeResponse (response) {
+      return {
+        ...response,
+        rawHeaders: response.rawHeaders.map(header => header.toString())
+      }
+    }
+  }
+
+  return new SharedCacheStore(storeConfig)
+}
+
+module.exports = { createSharedStore }

package/lib/worker/http-cache.js

@@ -0,0 +1,83 @@
+'use strict'
+
+const { Readable, Writable } = require('node:stream')
+const { kITC } = require('./symbols')
+
+class RemoteCacheStore {
+  get isFull () {
+    // TODO: make an itc call to the shared cache when interceptor supports
+    // an async isFull method
+    return false
+  }
+
+  async createReadStream (request) {
+    const itc = globalThis[kITC]
+    if (!itc) return
+
+    const cachedValue = await itc.send('getHttpCacheValue', {
+      request: this.#sanitizeRequest(request)
+    })
+    if (!cachedValue) return
+
+    const readable = new Readable({
+      read () {}
+    })
+
+    Object.defineProperty(readable, 'value', {
+      get () { return cachedValue.response }
+    })
+
+    readable.push(cachedValue.payload)
+    readable.push(null)
+
+    return readable
+  }
+
+  createWriteStream (request, response) {
+    const itc = globalThis[kITC]
+    if (!itc) throw new Error('Cannot write to cache without an ITC instance')
+
+    let payload = ''
+
+    request = this.#sanitizeRequest(request)
+    response = this.#sanitizeResponse(response)
+
+    return new Writable({
+      write (chunk, encoding, callback) {
+        payload += chunk
+        callback()
+      },
+      final (callback) {
+        itc.send('setHttpCacheValue', { request, response, payload })
+          .then(() => callback())
+          .catch((err) => callback(err))
+      }
+    })
+  }
+
+  deleteByOrigin (origin) {
+    const itc = globalThis[kITC]
+    if (!itc) throw new Error('Cannot delete from cache without an ITC instance')
+
+    itc.send('deleteHttpCacheValue', { origin })
+    // TODO: return a Promise
+  }
+
+  #sanitizeRequest (request) {
+    return {
+      origin: request.origin,
+      method: request.method,
+      path: request.path,
+      headers: request.headers
+    }
+  }
+
+  #sanitizeResponse (response) {
+    return {
+      ...response,
+      rawHeaders: response.rawHeaders.map(header => header.toString())
+    }
+  }
+}
+
+module.exports = RemoteCacheStore

package/lib/worker/main.js

@@ -10,9 +10,11 @@ const diagnosticChannel = require('node:diagnostics_channel')
 const { ServerResponse } = require('node:http')
 
 const pino = require('pino')
-const { fetch, setGlobalDispatcher, Agent } = require('undici')
+const { fetch, setGlobalDispatcher, getGlobalDispatcher, Agent } = require('undici')
 const { wire } = require('undici-thread-interceptor')
+const undici = require('undici')
 
+const RemoteCacheStore = require('./http-cache')
 const { PlatformaticApp } = require('./app')
 const { setupITC } = require('./itc')
 const loadInterceptors = require('./interceptors')
@@ -90,10 +92,34 @@ async function main () {
     }
   }
 
-  const globalDispatcher = new Agent({
-    ...config.undici,
-    interceptors
-  }).compose(composedInterceptors)
+  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)
+    }
+  }
+
+  const globalDispatcher = new Agent(dispatcherOpts)
+    .compose(composedInterceptors)
 
   setGlobalDispatcher(globalDispatcher)
 
@@ -102,6 +128,15 @@ async function main () {
   // TODO: make this configurable
   const threadDispatcher = wire({ port: parentPort, useNetwork: service.useHttp, timeout: 5 * 60 * 1000 })
 
+  if (config.httpCache) {
+    setGlobalDispatcher(
+      getGlobalDispatcher().compose(undici.interceptors.cache({
+        store: new RemoteCacheStore(),
+        methods: config.httpCache.methods ?? ['GET', 'HEAD']
+      }))
+    )
+  }
+
   // If the service is an entrypoint and runtime server config is defined, use it.
   let serverConfig = null
   if (config.server && service.entrypoint) {
@@ -114,14 +149,6 @@ async function main () {
     }
   }
 
-  let telemetryConfig = config.telemetry
-  if (telemetryConfig) {
-    telemetryConfig = {
-      ...telemetryConfig,
-      serviceName: `${telemetryConfig.serviceName}-${service.id}`
-    }
-  }
-
   const inspectorOptions = workerData.inspectorOptions
 
   if (inspectorOptions) {
@@ -144,7 +171,7 @@ async function main () {
   app = new PlatformaticApp(
     service,
     workerData.worker.count > 1 ? workerData.worker.index : undefined,
-    telemetryConfig,
+    service.telemetry,
     config.logger,
     serverConfig,
     config.metrics,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "2.8.0",
+  "version": "2.8.2-alpha.1",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -35,18 +35,19 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "2.8.0",
-    "@platformatic/db": "2.8.0",
-    "@platformatic/node": "2.8.0",
-    "@platformatic/service": "2.8.0",
-    "@platformatic/sql-graphql": "2.8.0",
-    "@platformatic/sql-mapper": "2.8.0"
+    "@platformatic/composer": "2.8.2-alpha.1",
+    "@platformatic/db": "2.8.2-alpha.1",
+    "@platformatic/service": "2.8.2-alpha.1",
+    "@platformatic/node": "2.8.2-alpha.1",
+    "@platformatic/sql-graphql": "2.8.2-alpha.1",
+    "@platformatic/sql-mapper": "2.8.2-alpha.1"
   },
   "dependencies": {
     "@fastify/error": "^4.0.0",
     "@fastify/websocket": "^11.0.0",
     "@hapi/topo": "^6.0.2",
     "@platformatic/http-metrics": "^0.2.1",
+    "@platformatic/undici-cache-memory": "^0.3.0",
     "@watchable/unpromise": "^1.0.2",
     "boring-name-generator": "^1.0.3",
     "change-case-all": "^2.1.0",
@@ -68,16 +69,16 @@
     "semgrator": "^0.3.0",
     "tail-file-stream": "^0.2.0",
     "thread-cpu-usage": "^0.2.0",
-    "undici": "^6.9.0",
+    "undici": "7.0.0-alpha.3",
     "undici-thread-interceptor": "^0.7.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "2.8.0",
-    "@platformatic/generators": "2.8.0",
-    "@platformatic/config": "2.8.0",
-    "@platformatic/itc": "2.8.0",
-    "@platformatic/telemetry": "2.8.0",
-    "@platformatic/ts-compiler": "2.8.0",
-    "@platformatic/utils": "2.8.0"
+    "@platformatic/basic": "2.8.2-alpha.1",
+    "@platformatic/config": "2.8.2-alpha.1",
+    "@platformatic/itc": "2.8.2-alpha.1",
+    "@platformatic/generators": "2.8.2-alpha.1",
+    "@platformatic/telemetry": "2.8.2-alpha.1",
+    "@platformatic/utils": "2.8.2-alpha.1",
+    "@platformatic/ts-compiler": "2.8.2-alpha.1"
   },
   "scripts": {
     "test": "npm run lint && borp --concurrency=1 --timeout=300000 && tsd",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.8.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.8.2-alpha.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {
@@ -451,6 +451,35 @@
         }
       }
     },
+    "httpCache": {
+      "oneOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "store": {
+              "type": "string"
+            },
+            "methods": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "default": [
+                "GET",
+                "HEAD"
+              ],
+              "minItems": 1
+            },
+            "cacheTagsHeader": {
+              "type": "string"
+            }
+          }
+        }
+      ]
+    },
     "watch": {
       "anyOf": [
         {