fhirsmith 0.9.7 → 0.10.0

package/registry/crawler.js

@@ -2,15 +2,34 @@
 // Crawler for gathering server information from terminology servers
 
 const axios = require('axios');
-const { 
-  ServerRegistries, 
-  ServerRegistry, 
-  ServerInformation, 
+const dns = require('dns');
+const http = require('http');
+const https = require('https');
+const ipaddr = require('ipaddr.js');
+const {
+  ServerRegistries,
+  ServerRegistry,
+  ServerInformation,
   ServerVersionInformation,
 } = require('./model');
 const {Extensions} = require("../tx/library/extensions");
 const {debugLog} = require("../tx/operation-context");
 
+// True if an IP literal is anything other than a normal public (unicast) address:
+// loopback, private, link-local (incl. 169.254.169.254 cloud metadata), unique-local,
+// CGNAT, multicast, reserved, etc. IPv4-mapped IPv6 addresses are unwrapped first.
+function isNonPublicAddress(ip) {
+  try {
+    let addr = ipaddr.parse(ip);
+    if (addr.kind() === 'ipv6' && addr.isIPv4MappedAddress()) {
+      addr = addr.toIPv4Address();
+    }
+    return addr.range() !== 'unicast';
+  } catch (e) {
+    return true; // unparseable - treat as unsafe
+  }
+}
+
 const MASTER_URL = 'https://fhir.github.io/ig-registry/tx-servers.json';
 
 class RegistryCrawler {
@@ -22,7 +41,8 @@ class RegistryCrawler {
       masterUrl: config.masterUrl || MASTER_URL,
       userAgent: config.userAgent || 'HealthIntersections/FhirServer',
       crawlInterval: config.crawlInterval || 5 * 60 * 1000, // 5 minutes default
-      apiKeys: config.apiKeys || {} // Map of server URL or code to API key
+      apiKeys: config.apiKeys || {}, // Map of server URL or code to API key
+      allowPrivateAddresses: config.allowPrivateAddresses || false // SSRF opt-out for local test servers
     };
     this.stats = stats;
 
@@ -39,6 +59,63 @@ class RegistryCrawler {
     this.log = logv;
   }
 
+  // A DNS lookup wrapper that rejects any host resolving to a non-public address.
+  // Enforced at connection time (so it also covers redirect targets and defeats
+  // DNS-rebinding), this is the SSRF guard for outbound fetches. The registry is
+  // crawled from server-supplied "next" links, so the target host is not trusted.
+  // Set config.allowPrivateAddresses = true to disable (e.g. for local test servers).
+  ssrfLookup() {
+    const allowPrivate = !!(this.config && this.config.allowPrivateAddresses);
+    return (hostname, options, callback) => {
+      if (typeof options === 'function') {
+        callback = options;
+        options = {};
+      }
+      const wantAll = !!(options && options.all);
+      dns.lookup(hostname, Object.assign({}, options, { all: true }), (err, addresses) => {
+        if (err) {
+          callback(err);
+          return;
+        }
+        if (!allowPrivate) {
+          for (const a of addresses) {
+            if (isNonPublicAddress(a.address)) {
+              callback(new Error('Blocked request to non-public address ' + a.address + ' (host ' + hostname + ')'));
+              return;
+            }
+          }
+        }
+        if (wantAll) {
+          callback(null, addresses);
+        } else {
+          callback(null, addresses[0].address, addresses[0].family);
+        }
+      });
+    };
+  }
+
+  // http/https agents that route every connection through the SSRF lookup.
+  guardedAgents() {
+    if (!this._guardedAgents) {
+      const lookup = this.ssrfLookup();
+      class GuardedHttpAgent extends http.Agent {
+        createConnection(options, cb) {
+          return super.createConnection(Object.assign({}, options, { lookup }), cb);
+        }
+      }
+      class GuardedHttpsAgent extends https.Agent {
+        createConnection(options, cb) {
+          return super.createConnection(Object.assign({}, options, { lookup }), cb);
+        }
+      }
+      this._guardedAgents = {
+        httpAgent: new GuardedHttpAgent({ keepAlive: true }),
+        httpsAgent: new GuardedHttpsAgent({ keepAlive: true })
+      };
+    }
+    return this._guardedAgents;
+  }
+
 
   /**
    * Main entry point - crawl the registry starting from the master URL
@@ -455,7 +532,9 @@ class RegistryCrawler {
         timeout: this.config.timeout,
         headers: headers,
         signal: this.abortController?.signal,
-        validateStatus: (status) => status < 500 // Don't throw on 4xx
+        validateStatus: (status) => status < 500, // Don't throw on 4xx
+        httpAgent: this.guardedAgents().httpAgent,
+        httpsAgent: this.guardedAgents().httpsAgent
       });
       
       if (response.status >= 400) {

package/registry/registry.js

@@ -976,7 +976,15 @@ class RegistryModule {
 
       try {
         const params = this._normalizeQueryParams(req.query);
-        const {fhirVersion, url, valueSet, usage} = params;
+        const {fhirVersion, valueSet, usage, version} = params;
+        let {url} = params;
+
+        // If a version was supplied separately, fold it into the code system
+        // URL using the canonical url|version syntax that the resolver expects.
+        // Don't double up if the caller already encoded a version in the url.
+        if (version && url && !url.includes('|')) {
+          url = `${url}|${version}`;
+        }
 
         // Convert authoritativeOnly to boolean
         const authoritativeOnly = params.authoritativeOnly === 'true';
@@ -1219,6 +1227,7 @@ class RegistryModule {
   buildResolveFormContent(queryParams = {}) {
     const fhirVersion = queryParams.fhirVersion || '';
     const url = queryParams.url || '';
+    const version = queryParams.version || '';
     const valueSet = queryParams.valueSet || '';
     const authoritativeOnly = queryParams.authoritativeOnly === 'true';
 
@@ -1246,6 +1255,14 @@ class RegistryModule {
     html += '</p>';
     html += '<p class="text-muted small">Example: http://loinc.org</p>';
 
+    // Code System Version field (optional)
+    html += '<p>';
+    html += '<label for="version" class="form-label fw-bold">Code System Version</label>';
+    html += `<input type="text" class="form-control" id="version" name="version"
+           value="${escape(version)}">`;
+    html += '</p>';
+    html += '<p class="text-muted small">Optional. Example: 2.74 (combined with the Code System URL as url|version)</p>';
+
     // ValueSet URL field - now vertical
     html += '<p>';
     html += '<label for="valueSet" class="form-label fw-bold">Value Set URL</label>';

package/server.js

@@ -430,6 +430,11 @@ async function buildRootPageContent() {
   content += `<td style="background-color:${pctColor(processPCT)}"><strong>Process Memory:</strong> ${rssMB} MB of ${memLimitMB} MB (${processPCT.toFixed(0)}%)</td>`;
   content += `<td style="background-color:${pctColor(sysMemPCT)}"><strong>System Memory:</strong> ${usedMemMB} MB of ${totalMemMB} MB (${sysMemPCT.toFixed(0)}%)</td>`;
   content += '</tr>';
+  content += '<tr>';
+  content += `<td><strong>Expansion Cache:</strong> ${stats.expansionItems()} items</td>`;
+  content += `<td><strong>Client Cache:</strong> ${stats.clientCaches()} caches / ${stats.clientConcepts()} concepts</td>`;
+  content += `<td><strong>Max Client Cache:</strong> ${stats.maxClientCaches()} caches / ${stats.maxClientConcepts()} concepts</td>`;
+  content += '</tr>';
   content += getLogStats();
   content += '</table>';
 

package/stats.js

@@ -36,24 +36,26 @@ class ServerStats {
         : (now - this.startTime) / 60000;
       const requestsPerMin = minutesSinceStart > 0 ? requestsDelta / minutesSinceStart : 0;
 
-      const currentCpu = this.readSystemCpu();
-      const idleDelta = currentCpu.idle - this.lastUsage.idle;
-      const totalDelta = currentCpu.total - this.lastUsage.total;
-      const percent = totalDelta > 0 ? 100 * (1 - idleDelta / totalDelta) : 0;
-
       const loopDelay = this.eventLoopMonitor.mean / 1e6;
-      let cacheCount = 0;
+      // Two distinct caches: the expansion cache (count entries) and the client
+      // (resource) cache (count concepts held - a sense of how much it's carrying).
+      let expansionItems = 0;
+      let clientConcepts = 0;
       for (let m of this.cachingModules) {
-        cacheCount = cacheCount + m.cacheCount();
+        if (typeof m.expansionItemCount === 'function') {
+          expansionItems = expansionItems + m.expansionItemCount();
+        }
+        if (typeof m.clientConceptCount === 'function') {
+          clientConcepts = clientConcepts + m.clientConceptCount();
+        }
       }
 
-      this.history.push({time: now, mem: currentMem - this.startMem, rpm: requestsPerMin, tat: requestsTat, cpu: percent, block: loopDelay, cache : cacheCount});
+      this.history.push({time: now, mem: currentMem - this.startMem, rpm: requestsPerMin, tat: requestsTat, block: loopDelay, expansion: expansionItems, clientConcepts: clientConcepts});
 
       this.eventLoopMonitor.reset();
       this.requestCountSnapshot = combinedCount;
       this.requestTime = 0;
       this.lastTime = now;
-      this.lastUsage = currentCpu;
 
       // Prune old data (keep 24 hours)
       const cutoff = now - (24 * 60 * 60 * 1000); // 24 hours ago
@@ -65,7 +67,6 @@ class ServerStats {
     this.started = true;
     this.startMem = process.memoryUsage().heapUsed;
     this.startTime = Date.now();
-    this.lastUsage = this.readSystemCpu();
     this.lastTime = this.startTime;
     this.eventLoopMonitor = monitorEventLoopDelay({ resolution: 20 });
     this.eventLoopMonitor.enable();
@@ -141,17 +142,24 @@ class ServerStats {
     clearInterval(this.timer);
   }
 
-  readSystemCpu() {
-    const os = require('os');
-    const cpus = os.cpus();
-    let idle = 0, total = 0;
-    for (const cpu of cpus) {
-      idle += cpu.times.idle;
-      total += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq;
+  // Live cache aggregates across all registered caching modules (defensive: a
+  // module that doesn't expose a given metric contributes 0).
+  _sumCachingModules(method) {
+    let total = 0;
+    for (let m of this.cachingModules) {
+      if (typeof m[method] === 'function') {
+        total = total + m[method]();
+      }
     }
-    return { idle, total };
+    return total;
   }
 
+  expansionItems() { return this._sumCachingModules('expansionItemCount'); }
+  clientCaches() { return this._sumCachingModules('clientCacheCount'); }
+  clientConcepts() { return this._sumCachingModules('clientConceptCount'); }
+  maxClientCaches() { return this._sumCachingModules('maxClientCacheCount'); }
+  maxClientConcepts() { return this._sumCachingModules('maxClientConceptCount'); }
+
   getTaskColor(status) {
     switch (status) {
       case "started": return "LightGrey";

package/translations/Messages.properties

@@ -1100,6 +1100,7 @@ Unable_to_resolve_system__value_set_has_multiple_matches = The System URI could
 Unable_to_resolve_system__value_set_has_no_includes_or_expansion = The System URI could not be determined for the code ''{0}'' in the ValueSet ''{1}'': value set has no includes or expansion
 UNABLE_TO_RESOLVE_SYSTEM_SYSTEM_IS_INDETERMINATE = The code system {1} referred to from value set {0} has a grammar, and the code might be valid in it
 Unable_to_resolve_value_Set_ = A definition for the value Set ''{0}'' could not be found
+CACHE_ID_UNKNOWN = The cache ''{0}'' is not known to this server. Caches are created with $cache-control?mode=start; this one was never created, or has expired or been released
 Unable_to_validate_code_without_using_server = Unable to validate code without using server because: {0}
 Undefined_attribute__on__for_type__properties__ = Undefined attribute ''@{0}'' on {1} for type {2}
 Undefined_element_ = Undefined element ''{0}'' at {1}

package/tx/html/home-metrics.liquid

@@ -4,7 +4,7 @@
     <canvas id="memoryChart" height="200"></canvas>
   </div>
   <div style="flex: 1;">
-    <h6>Cache</h6>
+    <h6>Expansion Cache</h6>
     <canvas id="cacheChart" height="200"></canvas>
   </div>
   <div style="flex: 1;">
@@ -18,8 +18,8 @@
     <canvas id="requestChart" height="200"></canvas>
   </div>
   <div style="flex: 1;">
-    <h6>CPU Usage (%)</h6>
-    <canvas id="cpuChart" height="200"></canvas>
+    <h6>Client Cache</h6>
+    <canvas id="clientCacheChart" height="200"></canvas>
   </div>
   <div style="flex: 1;">
     <h6>Node Blocking</h6>
@@ -99,13 +99,13 @@
     }
   });
 
-  // Cache chart
+  // Expansion cache chart
   new Chart(document.getElementById('cacheChart'), {
     type: 'line',
     data: {
       labels: historyData.map(d => formatTime(d.time)),
       datasets: [{
-        data: historyData.map(d => d.cache),
+        data: historyData.map(d => d.expansion),
         borderColor: '#7b7b7b',
         backgroundColor: 'rgba(123, 123, 123, 0.1)',
         fill: true,
@@ -121,7 +121,7 @@
           ...chartOptions.scales.y,
           title: {
             display: true,
-            text: '# cached items'
+            text: 'Expansion cache # items'
           }
         }
       }
@@ -158,13 +158,13 @@
     }
   });
 
-  // CPU chart
-  new Chart(document.getElementById('cpuChart'), {
+  // Client cache concepts chart
+  new Chart(document.getElementById('clientCacheChart'), {
     type: 'line',
     data: {
       labels: historyData.map(d => formatTime(d.time)),
       datasets: [{
-        data: historyData.map(d => parseFloat(formatMB(d.cpu))),
+        data: historyData.map(d => d.clientConcepts),
         borderColor: '#ff7b00',
         backgroundColor: 'rgba(255, 123, 0, 0.1)',
         fill: true,
@@ -180,7 +180,7 @@
           ...chartOptions.scales.y,
           title: {
             display: true,
-            text: '%'
+            text: 'Client Cache # concepts'
           }
         }
       }

package/tx/library/codesystem.js

@@ -42,6 +42,37 @@ class CodeSystem extends CanonicalResource {
       }
       this.buildMaps();
     }
+    // Precalculated at construction so callers (e.g. the resource cache) have a
+    // cheap O(1) sense of how large this resource is.
+    this._conceptCount = CodeSystem._countConcepts(this.jsonObj.concept);
+  }
+
+  /**
+   * Number of concepts defined in this CodeSystem, counted recursively (nested
+   * concepts included). Precalculated at construction time.
+   * @returns {number}
+   */
+  conceptCount() {
+    return this._conceptCount;
+  }
+
+  /**
+   * Recursively count concepts (including nested `concept` children).
+   * @param {Array} concepts
+   * @returns {number}
+   */
+  static _countConcepts(concepts) {
+    if (!Array.isArray(concepts)) {
+      return 0;
+    }
+    let n = 0;
+    for (const c of concepts) {
+      n++;
+      if (c && c.concept) {
+        n += CodeSystem._countConcepts(c.concept);
+      }
+    }
+    return n;
   }
 
   /**

package/tx/library/conceptmap.js

@@ -20,6 +20,30 @@ class ConceptMap extends CanonicalResource {
     this.jsonObj = conceptMapToR5(jsonObj, fhirVersion);
     this.validate();
     this.id = this.jsonObj.id;
+    // Precalculated at construction so callers (e.g. the resource cache) have a
+    // cheap O(1) sense of how large this resource is.
+    this._conceptCount = ConceptMap._countConcepts(this.jsonObj);
+  }
+
+  /**
+   * Number of concept nodes this ConceptMap carries: every source `element` plus
+   * every `target` across all groups (each is a coded node, so this approximates
+   * the resource's size). Precalculated at construction time.
+   * @returns {number}
+   */
+  conceptCount() {
+    return this._conceptCount;
+  }
+
+  static _countConcepts(jsonObj) {
+    let n = 0;
+    for (const g of ((jsonObj && jsonObj.group) || [])) {
+      for (const e of (g.element || [])) {
+        n++;
+        n += Array.isArray(e.target) ? e.target.length : 0;
+      }
+    }
+    return n;
   }
 
   /**

package/tx/library/valueset.js

@@ -25,6 +25,52 @@ class ValueSet extends CanonicalResource {
     this.jsonObj = valueSetToR5(jsonObj, fhirVersion);
     this.validate();
     this.buildMaps();
+    // Precalculated at construction so callers (e.g. the resource cache) have a
+    // cheap O(1) sense of how large this resource is.
+    this._conceptCount = ValueSet._countConcepts(this.jsonObj);
+  }
+
+  /**
+   * Number of concepts this ValueSet carries: the enumerated concepts in its
+   * compose (include + exclude `concept` lists) plus any concepts in an inline
+   * expansion (`expansion.contains`, counted recursively). Note this counts the
+   * concepts *present in the resource*, not the (possibly unbounded) size of the
+   * value set's full expansion. Precalculated at construction time.
+   * @returns {number}
+   */
+  conceptCount() {
+    return this._conceptCount;
+  }
+
+  static _countConcepts(jsonObj) {
+    let n = 0;
+    const compose = jsonObj && jsonObj.compose;
+    if (compose) {
+      for (const inc of (compose.include || [])) {
+        n += Array.isArray(inc.concept) ? inc.concept.length : 0;
+      }
+      for (const exc of (compose.exclude || [])) {
+        n += Array.isArray(exc.concept) ? exc.concept.length : 0;
+      }
+    }
+    if (jsonObj && jsonObj.expansion) {
+      n += ValueSet._countContains(jsonObj.expansion.contains);
+    }
+    return n;
+  }
+
+  static _countContains(items) {
+    if (!Array.isArray(items)) {
+      return 0;
+    }
+    let n = 0;
+    for (const it of items) {
+      n++;
+      if (it && it.contains) {
+        n += ValueSet._countContains(it.contains);
+      }
+    }
+    return n;
   }
 
   /**

package/tx/operation-context.js

@@ -3,6 +3,7 @@ const inspector = require("inspector");
 const crypto = require("crypto");
 const {Languages} = require("../library/languages");
 const {Issue} = require("./library/operation-outcome");
+const Logger = require("../library/logger");
 
 /**
  * Check if running under a debugger
@@ -59,6 +60,37 @@ class ResourceCache {
     this.stats = stats;
     this.cache = new Map();
     this.locks = new Map(); // For thread-safety with async operations
+    this.log = Logger.getInstance().child({module: 'tx-cache'});
+    // Running total of concepts across every resource in every entry, maintained
+    // incrementally on each mutation so cache sizing/limits are O(1) to consult.
+    // Each entry also carries its own `concepts` subtotal so removal/replacement
+    // can adjust the total without rescanning.
+    this.totalConcepts = 0;
+    // High-water marks (never decremented) - the most caches and the most concepts
+    // this cache has held at once, for capacity reporting.
+    this.maxConcepts = 0;
+    this.maxSizeValue = 0;
+  }
+
+  /**
+   * Update the high-water marks after a mutation that may have grown the cache.
+   */
+  _trackMax() {
+    if (this.totalConcepts > this.maxConcepts) {
+      this.maxConcepts = this.totalConcepts;
+    }
+    if (this.cache.size > this.maxSizeValue) {
+      this.maxSizeValue = this.cache.size;
+    }
+  }
+
+  /**
+   * Concept count of a single cached resource, or 0 if it doesn't expose one.
+   * @param {Object} resource
+   * @returns {number}
+   */
+  _conceptsOf(resource) {
+    return resource && typeof resource.conceptCount === 'function' ? resource.conceptCount() : 0;
   }
 
   /**
@@ -70,8 +102,10 @@ class ResourceCache {
     const entry = this.cache.get(cacheId);
     if (entry) {
       entry.lastUsed = Date.now();
+      this.log.info(`cache-id '${cacheId}': hit, returning ${entry.resources.length} resource(s): ${entry.resources.map(r => this._resourceKey(r)).join(', ')}`);
       return [...entry.resources]; // Return a copy
     }
+    this.log.info(`cache-id '${cacheId}': miss (no entry)`);
     return [];
   }
 
@@ -92,22 +126,32 @@ class ResourceCache {
   add(cacheId, resources) {
     if (!resources || resources.length === 0) return;
 
-    const entry = this.cache.get(cacheId) || { resources: [], lastUsed: Date.now() };
+    const entry = this.cache.get(cacheId) || { resources: [], lastUsed: Date.now(), concepts: 0 };
 
-    // Merge resources, avoiding duplicates by url+version
+    // Merge resources, avoiding duplicates by url+version. Keep the entry's concept
+    // subtotal and the cache-wide total in step with each insertion/replacement.
     for (const resource of resources) {
       const key = this._resourceKey(resource);
+      const newConcepts = this._conceptsOf(resource);
       const existingIndex = entry.resources.findIndex(r => this._resourceKey(r) === key);
       if (existingIndex >= 0) {
-        // Replace existing
+        // Replace existing: adjust by the difference
+        const delta = newConcepts - this._conceptsOf(entry.resources[existingIndex]);
         entry.resources[existingIndex] = resource;
+        entry.concepts += delta;
+        this.totalConcepts += delta;
+        this.log.info(`cache-id '${cacheId}': replaced ${key}`);
       } else {
         entry.resources.push(resource);
+        entry.concepts += newConcepts;
+        this.totalConcepts += newConcepts;
+        this.log.info(`cache-id '${cacheId}': added ${key}`);
       }
     }
 
     entry.lastUsed = Date.now();
     this.cache.set(cacheId, entry);
+    this._trackMax();
   }
 
   /**
@@ -116,10 +160,23 @@ class ResourceCache {
    * @param {Array} resources - Resources to set
    */
   set(cacheId, resources) {
+    this.log.info(`cache-id '${cacheId}': set (replace all) with ${resources.length} resource(s): ${resources.map(r => this._resourceKey(r)).join(', ')}`);
+    // Drop the old entry's contribution, then count the replacement.
+    const existing = this.cache.get(cacheId);
+    if (existing) {
+      this.totalConcepts -= existing.concepts || 0;
+    }
+    let concepts = 0;
+    for (const resource of resources) {
+      concepts += this._conceptsOf(resource);
+    }
+    this.totalConcepts += concepts;
     this.cache.set(cacheId, {
       resources: [...resources],
-      lastUsed: Date.now()
+      lastUsed: Date.now(),
+      concepts
     });
+    this._trackMax();
   }
 
   /**
@@ -127,6 +184,10 @@ class ResourceCache {
    * @param {string} cacheId - The cache identifier
    */
   clear(cacheId) {
+    const entry = this.cache.get(cacheId);
+    if (entry) {
+      this.totalConcepts -= entry.concepts || 0;
+    }
     this.cache.delete(cacheId);
   }
 
@@ -135,6 +196,7 @@ class ResourceCache {
    */
   clearAll() {
     this.cache.clear();
+    this.totalConcepts = 0;
   }
 
   /**
@@ -150,6 +212,7 @@ class ResourceCache {
     for (const [cacheId, entry] of this.cache.entries()) {
       if (now - entry.lastUsed > maxAge) {
         i++;
+        this.totalConcepts -= entry.concepts || 0;
         this.cache.delete(cacheId);
       }
     }
@@ -166,6 +229,41 @@ class ResourceCache {
     return this.cache.size;
   }
 
+  /**
+   * Total number of concepts held across every entry in the cache. Maintained
+   * incrementally, so this is O(1).
+   * @returns {number}
+   */
+  conceptCount() {
+    return this.totalConcepts;
+  }
+
+  /**
+   * Highest number of concepts this cache has held at once (high-water mark).
+   * @returns {number}
+   */
+  maxConceptCount() {
+    return this.maxConcepts;
+  }
+
+  /**
+   * Highest number of caches (cache-ids) this cache has held at once.
+   * @returns {number}
+   */
+  maxSize() {
+    return this.maxSizeValue;
+  }
+
+  /**
+   * Number of concepts held under a single cache-id (0 if unknown).
+   * @param {string} cacheId
+   * @returns {number}
+   */
+  conceptCountFor(cacheId) {
+    const entry = this.cache.get(cacheId);
+    return entry ? (entry.concepts || 0) : 0;
+  }
+
   /**
    * Generate a key for a resource based on url and version
    * @param {Object} resource - The resource
@@ -437,6 +535,12 @@ class OperationContext {
     this.logEntries = [];
     this.resourceCache = resourceCache;
     this.expansionCache = expansionCache;
+    // Server-issued cache-id carried on the request (X-Cache-Id header). Set once
+    // per request from the header so every worker can consult it uniformly via
+    // setupAdditionalResources, regardless of how that worker assembles its
+    // Parameters (buildParameters, raw req.body, query/form). An explicit
+    // cache-id *parameter* still takes precedence over this.
+    this.cacheId = null;
     this.debugging = isDebugging();
     // Providers opened during this operation that need their underlying
     // resources (sqlite connections, etc.) released when the operation ends.
@@ -470,6 +574,7 @@ class OperationContext {
     newContext.timeTracker = this.timeTracker.link();
     newContext.logEntries = [...this.logEntries];
     newContext.debugging = this.debugging;
+    newContext.cacheId = this.cacheId;
     newContext.usageTracker = this.usageTracker;
     // Share the same provider-cleanup list so providers opened by the copy
     // are released when the parent operation ends.