@platformatic/runtime 2.18.0 → 2.19.0-alpha.10

package/config.d.ts

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

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')
@@ -66,6 +67,7 @@ class Runtime extends EventEmitter {
   #inspectorServer
   #workers
   #restartingWorkers
+  #sharedHttpCache
 
   constructor (configManager, runtimeLogsDir, env) {
     super()
@@ -85,6 +87,7 @@ class Runtime extends EventEmitter {
     })
     this.#status = undefined
     this.#restartingWorkers = new Map()
+    this.#sharedHttpCache = null
   }
 
   async init () {
@@ -139,6 +142,11 @@ class Runtime extends EventEmitter {
       throw e
     }
 
+    this.#sharedHttpCache = createSharedStore(
+      this.#configManager.dirname,
+      config.httpCache
+    )
+
     this.#updateStatus('init')
   }
 
@@ -267,6 +275,10 @@ class Runtime extends EventEmitter {
       this.#loggerDestination = null
     }
 
+    if (this.#sharedHttpCache?.close) {
+      await this.#sharedHttpCache.close()
+    }
+
     this.#updateStatus('closed')
   }
 
@@ -729,6 +741,23 @@ class Runtime extends EventEmitter {
     return createReadStream(filePath)
   }
 
+  async invalidateHttpCache (options = {}) {
+    const { keys, tags } = options
+
+    if (!this.#sharedHttpCache) return
+
+    const promises = []
+    if (keys && keys.length > 0) {
+      promises.push(this.#sharedHttpCache.deleteKeys(keys))
+    }
+
+    if (tags && tags.length > 0) {
+      promises.push(this.#sharedHttpCache.deleteTags(tags))
+    }
+
+    await Promise.all(promises)
+  }
+
   async sendCommandToService (id, name, message) {
     const service = await this.#getServiceById(id)
 
@@ -885,9 +914,18 @@ class Runtime extends EventEmitter {
       port: worker,
       handlers: {
         getServiceMeta: this.getServiceMeta.bind(this),
-        listServices: () => {
-          return this.#servicesIds
-        }
+        listServices: () => this.#servicesIds,
+        getServices: this.getServices.bind(this),
+        getHttpCacheValue: opts => this.#sharedHttpCache.getValue(opts.request),
+        setHttpCacheValue: opts => this.#sharedHttpCache.setValue(
+          opts.request,
+          opts.response,
+          opts.payload
+        ),
+        deleteHttpCacheValue: opts => this.#sharedHttpCache.delete(
+          opts.request
+        ),
+        invalidateHttpCache: opts => this.invalidateHttpCache(opts),
       }
     })
     worker[kITC].listen()

package/lib/schema.js

@@ -194,6 +194,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,39 @@
+'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 cachedValue = await this.get(req)
+      if (!cachedValue) return null
+
+      const { body, ...response } = cachedValue
+
+      let payload = ''
+      for await (const chunk of body) {
+        payload += chunk
+      }
+
+      return { response, payload }
+    }
+
+    setValue (req, opts, data) {
+      const writeStream = this.createWriteStream(req, opts)
+      writeStream.write(data)
+      writeStream.end()
+      return null
+    }
+  }
+
+  return new SharedCacheStore(storeConfig)
+}
+
+module.exports = { createSharedStore }

package/lib/worker/http-cache.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const { Readable, Writable } = require('node:stream')
+const { kITC } = require('./symbols')
+
+class RemoteCacheStore {
+  async get (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 {
+      ...cachedValue.response,
+      body: 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)
+
+    return new Writable({
+      write (chunk, encoding, callback) {
+        payload += chunk
+        callback()
+      },
+      final (callback) {
+        itc.send('setHttpCacheValue', { request, response, payload })
+          .then(() => callback())
+          .catch((err) => callback(err))
+      }
+    })
+  }
+
+  delete (request) {
+    const itc = globalThis[kITC]
+    if (!itc) throw new Error('Cannot delete from cache without an ITC instance')
+
+    request = this.#sanitizeRequest(request)
+    itc.send('deleteHttpCacheValue', { request })
+    // TODO: return a Promise
+  }
+
+  #sanitizeRequest (request) {
+    return {
+      origin: request.origin,
+      method: request.method,
+      path: request.path,
+      headers: request.headers
+    }
+  }
+}
+
+module.exports = RemoteCacheStore

package/lib/worker/main.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { EventEmitter } = require('node:events')
 const { createRequire } = require('node:module')
 const { hostname } = require('node:os')
 const { join } = require('node:path')
@@ -10,9 +11,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')
@@ -35,7 +38,10 @@ globalThis[kId] = threadId
 let app
 
 const config = workerData.config
-globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, { logger: createLogger() })
+globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, {
+  logger: createLogger(),
+  events: new EventEmitter()
+})
 
 function handleUnhandled (type, err) {
   const label =
@@ -92,17 +98,55 @@ 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)
 
   const { telemetry } = service
   const hooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
   // Setup mesh networker
-  const threadDispatcher = wire({ port: parentPort, useNetwork: service.useHttp, timeout: config.serviceTimeout, ...hooks })
+  const threadDispatcher = wire({
+    port: parentPort,
+    useNetwork: service.useHttp,
+    timeout: config.serviceTimeout,
+    ...hooks
+  })
+
+  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
@@ -150,7 +194,7 @@ async function main () {
 
   if (service.entrypoint && config.basePath) {
     const meta = await app.stackable.getMeta()
-    if (!meta.wantsAbsoluteUrls) {
+    if (!meta.composer.wantsAbsoluteUrls) {
       stripBasePath(config.basePath)
     }
   }
@@ -191,10 +235,7 @@ function stripBasePath (basePath) {
 
       if (headers) {
         for (const key in headers) {
-          if (
-            key.toLowerCase() === 'location' &&
-            !headers[key].startsWith(basePath)
-          ) {
+          if (key.toLowerCase() === 'location' && !headers[key].startsWith(basePath)) {
             headers[key] = basePath + headers[key]
           }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "2.18.0",
+  "version": "2.19.0-alpha.10",
   "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.18.0",
-    "@platformatic/node": "2.18.0",
-    "@platformatic/db": "2.18.0",
-    "@platformatic/service": "2.18.0",
-    "@platformatic/sql-graphql": "2.18.0",
-    "@platformatic/sql-mapper": "2.18.0"
+    "@platformatic/composer": "2.19.0-alpha.10",
+    "@platformatic/db": "2.19.0-alpha.10",
+    "@platformatic/node": "2.19.0-alpha.10",
+    "@platformatic/service": "2.19.0-alpha.10",
+    "@platformatic/sql-graphql": "2.19.0-alpha.10",
+    "@platformatic/sql-mapper": "2.19.0-alpha.10"
   },
   "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.8.1",
     "@watchable/unpromise": "^1.0.2",
     "boring-name-generator": "^1.0.3",
     "change-case-all": "^2.1.0",
@@ -67,16 +68,17 @@
     "prom-client": "^15.1.2",
     "semgrator": "^0.3.0",
     "tail-file-stream": "^0.2.0",
-    "undici": "^6.9.0",
-    "undici-thread-interceptor": "^0.9.0",
+    "thread-cpu-usage": "^0.2.0",
+    "undici": "^7.0.0",
+    "undici-thread-interceptor": "^0.10.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "2.18.0",
-    "@platformatic/config": "2.18.0",
-    "@platformatic/itc": "2.18.0",
-    "@platformatic/generators": "2.18.0",
-    "@platformatic/telemetry": "2.18.0",
-    "@platformatic/ts-compiler": "2.18.0",
-    "@platformatic/utils": "2.18.0"
+    "@platformatic/basic": "2.19.0-alpha.10",
+    "@platformatic/generators": "2.19.0-alpha.10",
+    "@platformatic/config": "2.19.0-alpha.10",
+    "@platformatic/ts-compiler": "2.19.0-alpha.10",
+    "@platformatic/itc": "2.19.0-alpha.10",
+    "@platformatic/utils": "2.19.0-alpha.10",
+    "@platformatic/telemetry": "2.19.0-alpha.10"
   },
   "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.18.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.19.0-alpha.10.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {
@@ -840,6 +840,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": [
         {