fhirsmith 0.9.7 → 0.10.1

package/tx/workers/cache-control.js

@@ -0,0 +1,186 @@
+//
+// Cache Control Worker - Handles the $cache-control operation
+//
+// GET  /$cache-control?mode=start   - create a cache, return its (server-issued) id
+// POST /$cache-control?mode=start   - as above, optionally front-loading resources
+// GET  /$cache-control?mode=end     - tell the server it can release the cache now
+// POST /$cache-control?mode=end
+// (mode=check is reserved for later - report whether a cache is still valid + stats)
+//
+// This is the explicit replacement for the implicit `cache-id` parameter protocol:
+// the server owns the cache-id namespace, so it can authoritatively reject an
+// unknown/expired cache later instead of failing obscurely deep inside a validation.
+//
+// NOTE: this is scaffolding. start()/end() currently parse the request into a
+// Parameters resource (the same way validate.js does) but do not yet create or
+// release anything. The behaviour is filled in by later steps.
+//
+
+const crypto = require('crypto');
+const { TerminologyWorker, CACHE_ID_HEADER } = require('./worker');
+const { Parameters } = require('../library/parameters');
+const { debugLog } = require('../operation-context');
+
+class CacheControlWorker extends TerminologyWorker {
+  /**
+   * @param {OperationContext} opContext - Operation context
+   * @param {Logger} log - Logger instance
+   * @param {Provider} provider - Provider for code systems and resources
+   * @param {LanguageDefinitions} languages - Language definitions
+   * @param {I18nSupport} i18n - Internationalization support
+   */
+  constructor(opContext, log, provider, languages, i18n) {
+    super(opContext, log, provider, languages, i18n);
+  }
+
+  opName() {
+    return 'cache-control';
+  }
+
+  // Not a value-set operation; the base class requires this to be implemented.
+  vsHandle() {
+    return null;
+  }
+
+  /**
+   * Express entry point for /$cache-control (GET and POST).
+   * Dispatches on the `mode` query parameter.
+   * @param {express.Request} req - Express request
+   * @param {express.Response} res - Express response
+   */
+  async handle(req, res) {
+    try {
+      const mode = this.getMode(req);
+      // GET is accepted as well as POST, for consistency with the server's other
+      // operations (which are all browsable) and the convenience of poking
+      // $cache-control from a browser. The operation is declared affectsState=true
+      // in its OperationDefinition, so conformant clients POST; an accidental
+      // GET-created cache is an empty entry that self-expires.
+      switch (mode) {
+        case 'start':
+          return await this.start(req, res);
+        case 'end':
+          return await this.end(req, res);
+        default:
+          return res.status(400).json(this.operationOutcome('error', 'invalid',
+            `$cache-control requires a 'mode' of 'start' or 'end'` +
+            (mode ? ` (got '${mode}')` : ` (none supplied)`)));
+      }
+    } catch (error) {
+      this.log.error(error);
+      debugLog(error);
+      req.logInfo = this.usedSources.join('|') + ' - error' + (error.msgId ? ' ' + error.msgId : '');
+      const statusCode = error.statusCode || 500;
+      const issueCode = error.issueCode || 'exception';
+      return res.status(statusCode).json(this.operationOutcome('error', issueCode, error.message));
+    }
+  }
+
+  /**
+   * Determine the requested mode. The cache-control mode travels in the query
+   * string (?mode=start) so it survives even when a Parameters resource is POSTed
+   * as the body; a `mode` parameter in the body is accepted as a fallback.
+   * @param {express.Request} req
+   * @returns {string|null}
+   */
+  getMode(req) {
+    if (req.query && req.query.mode) {
+      return String(req.query.mode);
+    }
+    if (req.body && req.body.resourceType === 'Parameters') {
+      const p = this.findParameter(req.body, 'mode');
+      if (p) {
+        return this.getParameterValue(p);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * mode=start: mint a server-issued cache-id, create the (per-endpoint) cache,
+   * front-load any supplied resources into it, and return the id in the body.
+   *
+   * The id is returned in the body rather than a header to keep it readable by
+   * browser clients without CORS expose-header configuration; subsequent calls
+   * carry it back as the `${CACHE_ID_HEADER}` request header.
+   *
+   * The cache is created even when no resources are front-loaded: an explicitly
+   * empty cache must still *exist* so the server can later tell "cache I issued,
+   * currently empty" from "cache-id I never issued". That's why this uses
+   * ResourceCache.set (which always creates the entry) rather than add (which
+   * ignores empty resource lists).
+   *
+   * @param {express.Request} req
+   * @param {express.Response} res
+   */
+  async start(req, res) {
+    const cache = this.opContext.resourceCache;
+    if (!cache) {
+      return res.status(500).json(this.operationOutcome('error', 'exception',
+        'No resource cache is available on this endpoint'));
+    }
+
+    const params = new Parameters(this.buildParameters(req));
+    const { txResources, primaryResources } = this.collectSuppliedResources(params.jsonObj);
+    const resources = txResources.concat(primaryResources);
+
+    const cacheId = crypto.randomUUID();
+    cache.set(cacheId, resources);
+
+    return res.status(200).json({
+      resourceType: 'Parameters',
+      parameter: [
+        { name: 'cache-id', valueId: cacheId }
+      ]
+    });
+  }
+
+  /**
+   * mode=end: release the cache named by the `${CACHE_ID_HEADER}` header so the
+   * server can reclaim it now rather than waiting for the idle timeout.
+   *
+   * Releasing is idempotent: ending an id the server doesn't have is not an error
+   * here (the authoritative "unknown cache" signal belongs on the validation path,
+   * a later step). A missing header is a client error, though.
+   *
+   * @param {express.Request} req
+   * @param {express.Response} res
+   */
+  async end(req, res) {
+    const cache = this.opContext.resourceCache;
+    if (!cache) {
+      return res.status(500).json(this.operationOutcome('error', 'exception',
+        'No resource cache is available on this endpoint'));
+    }
+
+    const cacheId = req.headers[CACHE_ID_HEADER];
+    if (!cacheId) {
+      return res.status(400).json(this.operationOutcome('error', 'invalid',
+        `$cache-control mode=end requires the cache-id in the '${CACHE_ID_HEADER}' header`));
+    }
+
+    cache.clear(cacheId);
+
+    return res.status(200).json({ resourceType: 'Parameters', parameter: [] });
+  }
+
+  /**
+   * Build an OperationOutcome.
+   * @param {string} severity - error, warning, information
+   * @param {string} code - Issue code
+   * @param {string} message - Diagnostic message
+   * @returns {Object} OperationOutcome resource
+   */
+  operationOutcome(severity, code, message) {
+    return {
+      resourceType: 'OperationOutcome',
+      issue: [{
+        severity,
+        code,
+        details: { text: message }
+      }]
+    };
+  }
+}
+
+module.exports = { CacheControlWorker, CACHE_ID_HEADER };

package/tx/workers/{related.js → compare.js}

@@ -1,11 +1,11 @@
 //
-// Related Worker - Handles ValueSet $related operation
+// Compare Worker - Handles ValueSet $compare operation
 //
-// GET /ValueSet/{id}/$related
-// GET /ValueSet/$related?url=...&version=...
-// POST /ValueSet/$related (form body or Parameters with url)
-// POST /ValueSet/$related (body is ValueSet resource)
-// POST /ValueSet/$related (body is Parameters with valueSet parameter)
+// GET /ValueSet/{id}/$compare
+// GET /ValueSet/$compare?url=...&version=...
+// POST /ValueSet/$compare (form body or Parameters with url)
+// POST /ValueSet/$compare (body is ValueSet resource)
+// POST /ValueSet/$compare (body is Parameters with valueSet parameter)
 //
 
 const { TerminologyWorker } = require('./worker');
@@ -18,7 +18,7 @@ const {SearchFilterText} = require("../library/designations");
 const {ArrayMatcher} = require("../../library/utilities");
 const {debugLog} = require("../operation-context");
 
-class RelatedWorker extends TerminologyWorker {
+class CompareWorker extends TerminologyWorker {
   showLogic = false;
 
   /**
@@ -37,18 +37,18 @@ class RelatedWorker extends TerminologyWorker {
    * @returns {string}
    */
   opName() {
-    return 'related';
+    return 'compare';
   }
 
   /**
-   * Handle a type-level $related request
-   * GET/POST /ValueSet/$related
+   * Handle a type-level $compare request
+   * GET/POST /ValueSet/$compare
    * @param {express.Request} req - Express request
    * @param {express.Response} res - Express response
    */
   async handle(req, res) {
     try {
-      await this.handleTypeLevelRelated(req, res);
+      await this.handleTypeLevelCompare(req, res);
     } catch (error) {
       this.log.error(error);
       debugLog(error);
@@ -76,14 +76,14 @@ class RelatedWorker extends TerminologyWorker {
   }
 
   /**
-   * Handle an instance-level $related request
-   * GET/POST /ValueSet/{id}/$related
+   * Handle an instance-level $compare request
+   * GET/POST /ValueSet/{id}/$compare
    * @param {express.Request} req - Express request
    * @param {express.Response} res - Express response
    */
   async handleInstance(req, res) {
     try {
-      await this.handleInstanceLevelRelated(req, res);
+      await this.handleInstanceLevelCompare(req, res);
     } catch (error) {
       this.log.error(error);
       debugLog(error);
@@ -105,11 +105,11 @@ class RelatedWorker extends TerminologyWorker {
   }
 
   /**
-   * Handle type-level $related: /ValueSet/$related
+   * Handle type-level $compare: /ValueSet/$compare
    * ValueSet identified by url, or provided directly in body
    */
-  async handleTypeLevelRelated(req, res) {
-    this.deadCheck('related-type-level');
+  async handleTypeLevelCompare(req, res) {
+    this.deadCheck('compare-type-level');
 
     let params = req.body;
     this.addHttpParams(req, params);
@@ -121,16 +121,16 @@ class RelatedWorker extends TerminologyWorker {
     let thisVS = await this.readValueSet(res, "this", params, txp);
     let otherVS = await this.readValueSet(res, "other", params, txp);
 
-    const result = await this.doRelated(txp, thisVS, otherVS);
+    const result = await this.doCompare(txp, thisVS, otherVS);
     return res.json(result);
   }
   
   /**
-   * Handle instance-level related: /ValueSet/{id}/$related
+   * Handle instance-level compare: /ValueSet/{id}/$compare
    * ValueSet identified by resource ID
    */
-  async handleInstanceLevelRelated(req, res) {
-    this.deadCheck('related-instance-level');
+  async handleInstanceLevelCompare(req, res) {
+    this.deadCheck('compare-instance-level');
 
     let params = req.body;
     this.addHttpParams(req, params);
@@ -147,7 +147,7 @@ class RelatedWorker extends TerminologyWorker {
     }
     let otherVS = await this.readValueSet(res, "other", params, txp);
 
-    const result = await this.doRelated(txp, thisVS, otherVS);
+    const result = await this.doCompare(txp, thisVS, otherVS);
     return res.json(result);
   }
   
@@ -198,7 +198,7 @@ class RelatedWorker extends TerminologyWorker {
     }
   }
 
-  async doRelated(txp, thisVS, otherVS) {
+  async doCompare(txp, thisVS, otherVS) {
 
     // ok, we have to compare the composes. we don't care about anything else
     const thisC = thisVS.jsonObj.compose;
@@ -206,12 +206,12 @@ class RelatedWorker extends TerminologyWorker {
     if (!thisC) {
       return this.makeOutcome("indeterminate", `The ValueSet ${thisVS.vurl} has no compose`);
     }
-    Extensions.checkNoModifiers(thisC, 'RelatedWorker.doRelated', 'compose', thisVS.vurl)
+    Extensions.checkNoModifiers(thisC, 'CompareWorker.doCompare', 'compose', thisVS.vurl)
     this.checkNoLockedDate(thisVS.vurl, thisC);
     if (!otherC) {
       return this.makeOutcome("indeterminate", `The ValueSet ${otherVS.vurl} has no compose`);
     }
-    Extensions.checkNoModifiers(otherC, 'RelatedWorker.doRelated', 'compose', otherVS.vurl)
+    Extensions.checkNoModifiers(otherC, 'CompareWorker.doCompare', 'compose', otherVS.vurl)
     this.checkNoLockedDate(otherVS.vurl, otherC);
 
     let systems = new Map(); // tracks whether the comparison is version dependent or not
@@ -268,7 +268,7 @@ class RelatedWorker extends TerminologyWorker {
     } else if (status.left) {
       outcome = this.makeOutcome("superset", `The valueSet ${thisVS.vurl} is a super-set of the valueSet ${otherVS.vurl}`);
     } else {
-      outcome = this.makeOutcome("subset", `The valueSet ${thisVS.vurl} is a seb-set of the valueSet ${otherVS.vurl}`);
+      outcome = this.makeOutcome("subset", `The valueSet ${thisVS.vurl} is a sub-set of the valueSet ${otherVS.vurl}`);
     }
     if (txp.diagnostics) {
       outcome.parameter.push({name: 'performed-expansion', valueBoolean: exp ? true : false})
@@ -712,5 +712,5 @@ class RelatedWorker extends TerminologyWorker {
 }
 
 module.exports = {
-  RelatedWorker
+  CompareWorker
 };

package/tx/workers/metadata.js

@@ -233,7 +233,7 @@ class MetadataHandler {
               operation: [
                 { name: 'expand', definition: 'http://hl7.org/fhir/OperationDefinition/ValueSet-expand' },
                 { name: 'validate-code', definition: 'http://hl7.org/fhir/OperationDefinition/ValueSet-validate-code' },
-                { name: 'related', definition: 'https://raw.githubusercontent.com/HealthIntersections/FHIRsmith/refs/heads/main/tx/data/OperationDefinition-ValueSet-related.json' }
+                { name: 'compare', definition: 'http://hl7.org/fhir/tools/OperationDefinition/ValueSet-compare' }
               ]
             },
             {
@@ -266,7 +266,8 @@ class MetadataHandler {
             { name: 'validate-code', definition: 'http://hl7.org/fhir/OperationDefinition/Resource-validate-code' },
             { name: 'translate', definition: 'http://hl7.org/fhir/OperationDefinition/ConceptMap-translate' },
             { name: 'closure', definition: 'http://hl7.org/fhir/OperationDefinition/ConceptMap-closure' },
-            { name: 'related', definition: 'https://raw.githubusercontent.com/HealthIntersections/FHIRsmith/refs/heads/main/tx/data/OperationDefinition-ValueSet-related.json' },
+            { name: 'compare', definition: 'http://hl7.org/fhir/tools/OperationDefinition/ValueSet-compare' },
+            { name: 'cache-control', definition: 'http://hl7.org/fhir/tools/OperationDefinition/cache-control' },
             { name: 'versions', definition: 'http://hl7.org/fhir/OperationDefinition/fhir-versions' }
           ]
         }
@@ -395,10 +396,14 @@ class MetadataHandler {
   buildExpansionCapabilities() {
     return {
       parameter: [
-        {
-          name: 'cache-id',
-          documentation: 'This server supports caching terminology resources between calls. Clients only need to send value sets and codesystems once; thereafter they are automatically in scope for calls with the same cache-id. The cache is retained for 30 min from last call'
-        },
+        // NOTE: `cache-id` is deliberately not advertised as an expansion parameter.
+        // Caching is now discovered via the $cache-control operation in the
+        // CapabilityStatement, not by advertising a cache-id parameter here. The old
+        // advertisement implied the implicit "auto-create on first sight" protocol,
+        // which has been replaced: a cache must be created explicitly with
+        // $cache-control?mode=start before its cache-id can be used. Clients that
+        // only know the old mechanism will see no cache-id parameter and simply not
+        // cache (inlining each request), which is correct, just not optimised.
         {
           name: 'tx-resource',
           documentation: 'Additional valuesets needed for evaluation e.g. value sets referred to from the import statement of the value set being expanded'

package/tx/workers/worker.js

@@ -8,6 +8,12 @@ const {Languages} = require("../../library/languages");
 const {ConceptMap} = require("../library/conceptmap");
 const {Renderer} = require("../library/renderer");
 
+// The cache-id travels as an HTTP header (not an operation parameter) so proxies /
+// load-balancers can act on it and the server can reject it before parsing the body.
+// Defined here (the base worker) so both the worker and cache-control share one
+// source of truth without a circular require. Express lower-cases header names.
+const CACHE_ID_HEADER = 'x-cache-id';
+
 /**
  * Custom error for terminology setup issues
  */
@@ -121,7 +127,11 @@ class TerminologyWorker {
           latest = i;
         }
       }
-      return matches[latest];
+      const found = matches[latest];
+      if (this.additionalResourcesCacheId && this.log) {
+        this.log.info(`cache-id '${this.additionalResourcesCacheId}': using cached ${found.resourceType} ${found.url}${found.version ? '|' + found.version : ''} for lookup of ${url}${version ? '|' + version : ''}`);
+      }
+      return found;
     }
   }
 
@@ -487,50 +497,75 @@ class TerminologyWorker {
    * @returns {Object} Parameters resource
    */
   buildParameters(req) {
+    let params;
+
     // If POST with Parameters resource, use directly
     if (req.method === 'POST' && req.body && req.body.resourceType === 'Parameters') {
-      return req.body;
-    }
-    if (req.method === 'POST' && req.body && req.body.resourceType) {
+      params = req.body;
+    } else if (req.method === 'POST' && req.body && req.body.resourceType) {
       let langs = this.languages.parse(req.headers['accept-language']);
       throw new Issue('error', 'invalid', null, 'Wrong_type_for_resource_expected', this.i18n.translate('Wrong_type_for_resource_expected', langs, ["Parameters", req.body.resourceType])).handleAsOO(400);
-    }
-
-    // Convert query params or form body to Parameters
-    const source = req.method === 'POST' ? {...req.query, ...req.body} : req.query;
-    const params = {
-      resourceType: 'Parameters',
-      parameter: []
-    };
+    } else {
+      // Convert query params or form body to Parameters
+      const source = req.method === 'POST' ? {...req.query, ...req.body} : req.query;
+      params = {
+        resourceType: 'Parameters',
+        parameter: []
+      };
 
-    for (const [name, value] of Object.entries(source)) {
-      if (value === undefined || value === null) continue;
+      for (const [name, value] of Object.entries(source)) {
+        if (value === undefined || value === null) continue;
 
-      if (Array.isArray(value)) {
-        // Repeating parameter
-        for (const v of value) {
-          params.parameter.push({name, valueString: String(v)});
-        }
-      } else if (typeof value === 'object') {
-        // Could be a resource or complex type - check resourceType
-        if (value.resourceType) {
-          params.parameter.push({name, resource: value});
+        if (Array.isArray(value)) {
+          // Repeating parameter
+          for (const v of value) {
+            params.parameter.push({name, valueString: String(v)});
+          }
+        } else if (typeof value === 'object') {
+          // Could be a resource or complex type - check resourceType
+          if (value.resourceType) {
+            params.parameter.push({name, resource: value});
+          } else {
+            // Assume it's a complex type like Coding or CodeableConcept
+            params.parameter.push(this.buildComplexParameter(name, value));
+          }
+        } else if (value == 'true') {
+          params.parameter.push({name, valueBoolean: true});
+        } else if (value == 'false') {
+          params.parameter.push({name, valueBoolean: false});
         } else {
-          // Assume it's a complex type like Coding or CodeableConcept
-          params.parameter.push(this.buildComplexParameter(name, value));
+          params.parameter.push({name, valueString: String(value)});
         }
-      } else if (value == 'true') {
-        params.parameter.push({name, valueBoolean: true});
-      } else if (value == 'false') {
-        params.parameter.push({name, valueBoolean: false});
-      } else {
-        params.parameter.push({name, valueString: String(value)});
       }
     }
 
+    this.applyCacheIdHeader(req, params);
     return params;
   }
 
+  /**
+   * Normalise the cache-id from the `${CACHE_ID_HEADER}` header into a `cache-id`
+   * parameter, so all downstream code can read the cache-id the same way whether
+   * the client sent it as a header (the going-forward mechanism) or, for now, still
+   * as a parameter. If a cache-id parameter is already present it is left as-is, so
+   * an explicit parameter wins and there's no surprising override.
+   * @param {express.Request} req
+   * @param {Object} params - Parameters resource (mutated in place)
+   */
+  applyCacheIdHeader(req, params) {
+    const headerVal = req && req.headers ? req.headers[CACHE_ID_HEADER] : null;
+    if (!headerVal) {
+      return;
+    }
+    if (!params.parameter) {
+      params.parameter = [];
+    }
+    if (params.parameter.some(p => p.name === 'cache-id')) {
+      return;
+    }
+    params.parameter.push({ name: 'cache-id', valueId: String(headerVal) });
+  }
+
   /**
    * Build a parameter for complex types
    */
@@ -559,36 +594,87 @@ class TerminologyWorker {
   // ========== Additional Resources Handling ==========
 
   /**
-   * Set up additional resources from tx-resource parameters and cache
+   * Collect the resources supplied inline in a Parameters resource: the
+   * `tx-resource` parameters, and the primary `valueSet`/`codeSystem` parameters.
+   *
+   * The primary resource is collected separately because the cache-id protocol
+   * needs it retained too: fhir-core sends the main ValueSet as `valueSet` (not
+   * `tx-resource`), so if it isn't cached, a later by-reference call can't resolve
+   * it ("value set ... could not be found"). A primary resource is only usable by
+   * reference if it has a url to key on, so url-less ones are skipped.
+   *
    * @param {Object} params - Parameters resource
+   * @returns {{txResources: Array, primaryResources: Array}} wrapped resources
    */
-  setupAdditionalResources(params) {
-    if (!params || !params.parameter) return;
-
-    // Collect tx-resource parameters (resources provided inline)
+  collectSuppliedResources(params) {
     const txResources = [];
+    const primaryResources = [];
+    if (!params || !params.parameter) {
+      return { txResources, primaryResources };
+    }
     for (const param of params.parameter) {
-      this.deadCheck('setupAdditionalResources');
+      this.deadCheck('collectSuppliedResources');
       if (param.name === 'tx-resource' && param.resource) {
-        let res = this.wrapRawResource(param.resource);
+        const res = this.wrapRawResource(param.resource);
         if (res) {
           txResources.push(res);
         }
+      } else if ((param.name === 'valueSet' || param.name === 'codeSystem') && param.resource && param.resource.url) {
+        const res = this.wrapRawResource(param.resource);
+        if (res) {
+          primaryResources.push(res);
+        }
       }
     }
+    return { txResources, primaryResources };
+  }
 
-    // Check for cache-id
+  /**
+   * Set up additional resources from tx-resource parameters and cache
+   * @param {Object} params - Parameters resource
+   */
+  setupAdditionalResources(params) {
+    if (!params || !params.parameter) return;
+
+    // Collect the resources supplied inline on this request (tx-resource plus the
+    // primary valueSet/codeSystem). See collectSuppliedResources for why the
+    // primary resource is included.
+    const { txResources, primaryResources } = this.collectSuppliedResources(params);
+
+    // Check for cache-id. An explicit cache-id *parameter* wins; otherwise fall
+    // back to the cache-id the middleware lifted off the X-Cache-Id header onto
+    // the operation context. This fallback is what makes the header work on the
+    // op paths that don't route their Parameters through buildParameters
+    // (expand, related, batch-validate) or that hand setupAdditionalResources a
+    // raw req.body (lookup) - previously those silently ignored a front-loaded
+    // cache and failed to resolve by-reference resources.
     const cacheIdParam = this.findParameter(params, 'cache-id');
-    const cacheId = cacheIdParam ? this.getParameterValue(cacheIdParam) : null;
+    const cacheId = (cacheIdParam ? this.getParameterValue(cacheIdParam) : null)
+      || (this.opContext ? this.opContext.cacheId : null)
+      || null;
 
     if (cacheId && this.opContext.resourceCache) {
-      // Merge tx-resources with cached resources
-      if (txResources.length > 0) {
-        this.opContext.resourceCache.add(cacheId, txResources);
+      // The cache must already exist: caches are created explicitly via
+      // $cache-control?mode=start, which is the only thing that mints a cache-id.
+      // A cache-id the server doesn't know is an unambiguous, server-authoritative
+      // error condition (never created, or expired / released) - report it with a
+      // specific coded issue rather than silently auto-creating a fresh cache and
+      // then failing obscurely later when a by-reference resource can't be found.
+      if (!this.opContext.resourceCache.has(cacheId)) {
+        throw new Issue('error', 'not-found', null, 'CACHE_ID_UNKNOWN',
+          this.i18n.translate('CACHE_ID_UNKNOWN', this.opContext.langs, [cacheId]),
+          'cache-id-unknown', 404);
+      }
+
+      // The cache exists: merge any resources supplied on this request into it
+      // (incremental population is allowed), then expose the full cache contents.
+      const toCache = txResources.concat(primaryResources);
+      if (toCache.length > 0) {
+        this.opContext.resourceCache.add(cacheId, toCache);
       }
 
-      // Set additional resources to all resources for this cache-id
       this.additionalResources = this.opContext.resourceCache.get(cacheId);
+      this.additionalResourcesCacheId = cacheId;
     } else {
       // No cache-id, just use the tx-resources directly
       this.additionalResources = txResources;
@@ -708,7 +794,7 @@ class TerminologyWorker {
     // Check for various value types
     const valueTypes = [
       'valueString', 'valueCode', 'valueUri', 'valueCanonical', 'valueUrl',
-      'valueBoolean', 'valueInteger', 'valueDecimal',
+      'valueBoolean', 'valueInteger', 'valueDecimal', 'valueId',
       'valueDateTime', 'valueDate', 'valueTime',
       'valueCoding', 'valueCodeableConcept',
       'valueIdentifier', 'valueQuantity'
@@ -934,5 +1020,6 @@ class TerminologyWorker {
 
 module.exports = {
   TerminologyWorker,
-  TerminologySetupError
+  TerminologySetupError,
+  CACHE_ID_HEADER
 };