@epxing/utils 0.0.0-stage → 5.3.0-beta.1

package/src/chart-request-broker.js

@@ -0,0 +1,171 @@
+// A dashboard owns this broker. It never shares report results between dashboards or components.
+const stable = value => {
+  if (Array.isArray(value)) return value.map(stable)
+  if (value && typeof value === 'object') return Object.fromEntries(Object.keys(value).sort().map(key => [key, stable(value[key])]))
+  return value
+}
+const encode = value => JSON.stringify(stable(value))
+
+export function createChartRequestBroker ({ concurrency = 6, ttl = 30000, maxEntries = 64, maxBytes = 2 * 1024 * 1024, now = Date.now } = {}) {
+  const cache = new Map()
+  const jobs = new Set()
+  const inFlight = new Map()
+  const queue = []
+  const counters = { hits: 0, misses: 0, coalesced: 0, cancelled: 0, peakActive: 0 }
+  let active = 0
+  let bytes = 0
+  let context = null
+  let expiryTimer = null
+  let disposed = false
+
+  const remove = key => {
+    const entry = cache.get(key)
+    if (entry) bytes -= entry.bytes
+    cache.delete(key)
+  }
+  const expire = () => {
+    if (expiryTimer) clearTimeout(expiryTimer)
+    expiryTimer = null
+    for (const [key, entry] of cache) if (entry.expires <= now()) remove(key)
+    if (cache.size) {
+      const next = Math.min(...Array.from(cache.values(), entry => entry.expires))
+      expiryTimer = setTimeout(expire, Math.max(1, next - now()))
+    }
+  }
+  const clear = () => {
+    cache.clear()
+    bytes = 0
+    if (expiryTimer) clearTimeout(expiryTimer)
+    expiryTimer = null
+  }
+  const forget = job => {
+    jobs.delete(job)
+    if (inFlight.get(job.key) === job) inFlight.delete(job.key)
+  }
+  const cancel = job => {
+    if (job.cancelled) return
+    job.cancelled = true
+    job.invalidated = true
+    for (const consumer of job.consumers) consumer.resolve(null)
+    job.consumers.clear()
+    job.controller?.abort()
+    const index = queue.indexOf(job)
+    if (index !== -1) queue.splice(index, 1)
+    if (!job.started) forget(job)
+    counters.cancelled++
+  }
+  const syncContext = current => {
+    if (context && context.principal !== current.principal) {
+      clear()
+      for (const job of [...jobs]) cancel(job)
+    } else if (context && context.credential !== current.credential) {
+      // Token renewal invalidates responses, without cancelling authenticated work for the same principal.
+      clear()
+    }
+    context = current
+  }
+  const invalidate = reportId => {
+    for (const [key, entry] of cache) if (!reportId || entry.reportId === reportId) remove(key)
+    for (const job of jobs) if (!reportId || job.reportId === reportId) job.invalidated = true
+    expire()
+  }
+  const pump = () => {
+    if (disposed) return
+    while (active < concurrency && queue.length) {
+      const job = queue.shift()
+      syncContext(job.getContext())
+      if (job.cancelled || !job.consumers.size) { forget(job); continue }
+      job.started = true
+      job.credential = context.credential
+      job.version = job.getVersion()
+      job.cacheKey = encode([job.componentId, job.params, job.version])
+      job.controller = new AbortController()
+      active++
+      counters.peakActive = Math.max(counters.peakActive, active)
+      Promise.resolve().then(() => job.execute(job.controller.signal)).then(data => {
+        if (disposed || job.cancelled) return
+        const current = job.getContext()
+        syncContext(current)
+        if (job.cancelled) return
+        job.settled = true
+        const encoded = JSON.stringify(data)
+        // Include condition/version keys in the budget; complex filters can dwarf a small response.
+        const size = encoded ? (encoded.length + job.cacheKey.length) * 2 : 0
+        if (job.cacheable && !job.invalidated && current.credential === job.credential && job.getVersion() === job.version && encoded && size <= maxBytes / 2) {
+          remove(job.cacheKey)
+          cache.set(job.cacheKey, { encoded, bytes: size, expires: now() + ttl, reportId: job.reportId })
+          bytes += size
+          for (const cachedKey of cache.keys()) {
+            if (cache.size <= maxEntries && bytes <= maxBytes) break
+            remove(cachedKey)
+          }
+          expire()
+        }
+        for (const consumer of job.consumers) consumer.resolve(encoded === undefined ? data : JSON.parse(encoded))
+      }).catch(error => {
+        job.settled = true
+        if (!job.cancelled && !disposed) for (const consumer of job.consumers) consumer.reject(error)
+      }).finally(() => {
+        job.consumers.clear()
+        forget(job)
+        active--
+        pump()
+      })
+    }
+  }
+
+  return {
+    request ({ params, componentId = params.reportId, execute, getContext, getVersion = () => '', cacheable = false, force = false }) {
+      if (disposed) return { promise: Promise.resolve(null), cancel: () => {} }
+      const current = getContext()
+      syncContext(current)
+      expire()
+      const version = getVersion()
+      const key = encode([componentId, params, version])
+      const reportId = params.reportId
+      if (force) invalidate(reportId)
+      const entry = cache.get(key)
+      if (cacheable && current.credential && !force && entry) {
+        counters.hits++
+        cache.delete(key)
+        cache.set(key, entry)
+        return {
+          promise: Promise.resolve().then(() => {
+            const latest = getContext()
+            return latest.principal === current.principal && latest.credential === current.credential ? JSON.parse(entry.encoded) : null
+          }),
+          cancel: () => {}
+        }
+      }
+      let job = !force && inFlight.get(key)
+      if (job && !job.settled && !job.cancelled && !job.invalidated && job.credential === current.credential) counters.coalesced++
+      else {
+        counters.misses++
+        job = { key, componentId, params, reportId, execute, getContext, getVersion, version, credential: current.credential, cacheable: cacheable && !!current.credential, consumers: new Set() }
+        jobs.add(job)
+        inFlight.set(key, job)
+        queue.push(job)
+      }
+      const consumer = {}
+      const promise = new Promise((resolve, reject) => Object.assign(consumer, { resolve, reject }))
+      job.consumers.add(consumer)
+      pump()
+      return {
+        promise,
+        cancel: () => {
+          if (!job.consumers.delete(consumer)) return
+          consumer.resolve(null)
+          if (!job.consumers.size) cancel(job)
+        }
+      }
+    },
+    invalidate,
+    stats () { return { ...counters, active, queued: queue.length, entries: cache.size, bytes, disposed } },
+    dispose () {
+      disposed = true
+      clear()
+      for (const job of [...jobs]) cancel(job)
+      context = null
+    }
+  }
+}