fhirsmith 0.10.0 → 0.11.0

package/tx/workers/batch-validate.js

@@ -1,14 +1,15 @@
 //
-// Validate Worker - Handles $validate-code operations
+// Batch Validate Worker - Handles $batch-validate-code operations
 //
-// GET /CodeSystem/$validate-code?{params}
-// POST /CodeSystem/$validate-code
-// GET /CodeSystem/{id}/$validate-code?{params}
-// POST /CodeSystem/{id}/$validate-code
-// GET /ValueSet/$validate-code?{params}
-// POST /ValueSet/$validate-code
-// GET /ValueSet/{id}/$validate-code?{params}
-// POST /ValueSet/{id}/$validate-code
+// GET/POST /ValueSet/$batch-validate-code    - batch of ValueSet  $validate-code
+// GET/POST /CodeSystem/$batch-validate-code  - batch of CodeSystem $validate-code
+//
+// A batch is a Parameters whose `validation` entries each carry a single
+// $validate-code request (as a nested Parameters). Shared inputs may be supplied
+// once at the top level ("globals") and are applied to every entry. Entries are
+// dispatched per-shape (a url/valueSet entry validates against a value set; a
+// system/codeSystem entry validates against a code system), so both batch routes
+// share one implementation and even a mixed batch is handled correctly.
 //
 
 const { TerminologyWorker } = require('./worker');
@@ -30,12 +31,20 @@ class BatchValidateWorker extends TerminologyWorker {
    */
   constructor(opContext, log, provider, languages, i18n) {
     super(opContext, log, provider, languages, i18n);
-    this.globalNames.add("tx-resource");
-    this.globalNames.add("url");
-    this.globalNames.add("valueSet");
-    this.globalNames.add("lenient-display-validation");
-    this.globalNames.add("__Accept-Language");
-    this.globalNames.add("__Content-Language");
+    // "Global" parameters may be supplied once at the top level and are applied to
+    // every entry that doesn't override them. tx-resource is always shared. The
+    // primary differs by operation: a ValueSet batch shares url/valueSet, a
+    // CodeSystem batch shares system/codeSystem.
+    this.valueSetGlobalNames = new Set([
+      "tx-resource", "url", "valueSet", "lenient-display-validation",
+      "__Accept-Language", "__Content-Language"
+    ]);
+    this.codeSystemGlobalNames = new Set([
+      "tx-resource", "system", "codeSystem", "lenient-display-validation",
+      "__Accept-Language", "__Content-Language"
+    ]);
+    // Back-compat: `globalNames` was the (ValueSet) set before CodeSystem batches.
+    this.globalNames = this.valueSetGlobalNames;
   }
 
   /**
@@ -46,18 +55,43 @@ class BatchValidateWorker extends TerminologyWorker {
     return 'batch-validate-code';
   }
 
+  /** ValueSet/$batch-validate-code: shared globals are url/valueSet. */
   async handleValueSet(req, res) {
+    return this.processBatch(req, res, this.valueSetGlobalNames);
+  }
+
+  /** CodeSystem/$batch-validate-code: shared globals are system/codeSystem. */
+  async handleCodeSystem(req, res) {
+    return this.processBatch(req, res, this.codeSystemGlobalNames);
+  }
+
+  /**
+   * Run a batch of $validate-code requests. Two passes: frontLoadBatch() pools all
+   * supplied resources into an unsealed cache first (see that method); then each
+   * `validation` entry is evaluated, inheriting the top-level globals it does not
+   * override and dispatched by shape to the ValueSet or CodeSystem validator.
+   *
+   * @param {express.Request} req
+   * @param {express.Response} res
+   * @param {Set<string>} globalNames - which top-level params are shared globals
+   */
+  async processBatch(req, res, globalNames) {
     try {
       let params = req.body;
       this.addHttpParams(req, params);
 
       let globalParams = [];
       for (const p of params.parameter) {
-        if (this.globalNames.has(p.name)) {
+        if (globalNames.has(p.name)) {
           globalParams.push(p);
         }
       }
 
+      // Pass 1: front-load every resource the batch supplies into the (unsealed)
+      // session cache before any entry is evaluated. When this happens, pass 2
+      // below drops per-entry tx-resource processing (they're already cached).
+      const frontLoaded = this.frontLoadBatch(params);
+
       let output = [];
 
       for (const p of params.parameter) {
@@ -65,12 +99,26 @@ class BatchValidateWorker extends TerminologyWorker {
           let op = new Parameters();
           op.jsonObj.parameter = [];
           for (const gp of globalParams) {
+            if (gp.name == 'tx-resource') {
+              // Pass 2: when the batch was front-loaded into an unsealed cache, the
+              // tx-resources are already in the cache and every entry resolves them
+              // by reference - don't re-inject or re-process them per entry. Without
+              // front-loading (no cache, or a sealed cache) keep the original
+              // behaviour: the global tx-resources apply to every entry.
+              if (!frontLoaded) {
+                op.jsonObj.parameter.push(gp);
+              }
+              continue;
+            }
             let exists = p.resource.parameter.find(pp => gp.name == pp.name);
-            if (gp.name == 'tx-resource' || !exists) {
+            if (!exists) {
               op.jsonObj.parameter.push(gp);
             }
           }
-          op.jsonObj.parameter.push(...p.resource.parameter);
+          const entryParams = frontLoaded
+            ? p.resource.parameter.filter(pp => pp.name !== 'tx-resource')
+            : p.resource.parameter;
+          op.jsonObj.parameter.push(...entryParams);
 
           let worker = new ValidateWorker(this.opContext.copy(), this.log, this.provider, this.languages, this.i18n);
           try {
@@ -100,11 +148,70 @@ class BatchValidateWorker extends TerminologyWorker {
     } catch (error) {
       this.log.error(error);
       debugLog(error);
+      // A batch-level failure (e.g. an unknown cache-id from pass 1) applies to the
+      // whole batch. Preserve a coded Issue (like cache-id-unknown) so the client
+      // gets the same coded OperationOutcome + status it would on a single op.
+      if (error instanceof Issue) {
+        const oo = new OperationOutcome();
+        oo.addIssue(error);
+        return res.status(error.statusCode || 500).json(oo.jsonObj);
+      }
       return res.status(error.statusCode || 500).json(this.operationOutcome(
         'error', error.issueCode || 'exception', error.message));
     }
   }
 
+  /**
+   * Pass 1 of batch processing: front-load every resource the batch supplies
+   * (each `tx-resource`, plus each entry's primary `valueSet`/`codeSystem`) into
+   * the session cache before any entry is evaluated. This makes the batch
+   * order-independent - an entry may refer by url to a resource another entry
+   * supplied - and means a failing entry does not withhold the resources it
+   * carried, because population happens up front and as one step.
+   *
+   * Front-loading is only relevant for an *unsealed* cache: that is what grows, so
+   * that is how one entry's resources become visible to the others. A sealed cache
+   * does not grow (each entry stays self-contained), and with no cache there is
+   * nowhere to pool; in both cases this returns false and pass 2 keeps the original
+   * per-entry tx-resource handling.
+   *
+   * The unknown-cache-id check is done here, once, for the whole batch.
+   *
+   * @param {Object} params - the batch Parameters (req.body)
+   * @returns {boolean} true if resources were front-loaded into an unsealed cache
+   */
+  frontLoadBatch(params) {
+    const cacheId = this.opContext ? this.opContext.cacheId : null;
+    const cache = this.opContext ? this.opContext.resourceCache : null;
+    if (!cacheId || !cache) {
+      return false;
+    }
+    if (!cache.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);
+    }
+    if (cache.isSealed(cacheId)) {
+      return false;
+    }
+    // Flatten the top-level params and every entry's params into one list, then let
+    // collectSuppliedResources pick out the tx-resource + primary valueSet/codeSystem.
+    const allParams = [];
+    for (const p of params.parameter) {
+      if (p.name === 'validation' && p.resource && Array.isArray(p.resource.parameter)) {
+        allParams.push(...p.resource.parameter);
+      } else {
+        allParams.push(p);
+      }
+    }
+    const { txResources, primaryResources } = this.collectSuppliedResources({ parameter: allParams });
+    const pool = txResources.concat(primaryResources);
+    if (pool.length > 0) {
+      cache.add(cacheId, pool);
+    }
+    return true;
+  }
+
   /**
    * Build an OperationOutcome
    */

package/tx/workers/cache-control.js

@@ -124,17 +124,46 @@ class CacheControlWorker extends TerminologyWorker {
     const { txResources, primaryResources } = this.collectSuppliedResources(params.jsonObj);
     const resources = txResources.concat(primaryResources);
 
+    // `sealed` controls whether the cache may grow after creation. When sealed,
+    // the cache holds only the resources front-loaded here; when unsealed, later
+    // operations accumulate every resource they see into it (see
+    // setupAdditionalResources).
+    //
+    // NOTE: the protocol default is `true`, but the server default here is
+    // deliberately `false` during the transition: existing clients that rely on
+    // incremental population and do not yet send `sealed` must keep working.
+    // Flip this to default-true once all clients send an explicit value.
+    const sealed = this.readSealed(params.jsonObj);
+
     const cacheId = crypto.randomUUID();
-    cache.set(cacheId, resources);
+    cache.set(cacheId, resources, sealed);
 
     return res.status(200).json({
       resourceType: 'Parameters',
       parameter: [
-        { name: 'cache-id', valueId: cacheId }
+        { name: 'cache-id', valueId: cacheId },
+        { name: 'sealed', valueBoolean: sealed }
       ]
     });
   }
 
+  /**
+   * Read the `sealed` boolean from the start request's Parameters.
+   *
+   * Server-side default is FALSE (transitional — see start()): a cache is only
+   * sealed if the client explicitly asks for it. Accepts a real JSON boolean or
+   * the string "true"/"false" for robustness across clients.
+   *
+   * @param {Object} params - Parameters resource (jsonObj)
+   * @returns {boolean}
+   */
+  readSealed(params) {
+    const p = this.findParameter(params, 'sealed');
+    if (!p) return false;
+    const v = this.getParameterValue(p);
+    return v === true || v === 'true';
+  }
+
   /**
    * 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.

package/tx/workers/expand.js

@@ -220,7 +220,7 @@ class ValueSetExpander {
   }
 
   async listDisplaysFromProvider(displays, cs, context) {
-    await cs.designations(context, displays);
+    await cs.designations(context, displays, true);
     displays.source = cs;
   }
 
@@ -661,15 +661,9 @@ class ValueSetExpander {
           if (cs.specialEnumeration()) {
             await this.checkCanExpandValueSet(cs.specialEnumeration(), '', null);
           } else if (filter.isNull) {
-            if (cs.isNotClosed()) {
-              if (cs.specialEnumeration()) {
-                Extensions.addBoolean(exp, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-                Extensions.addString(exp, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
-              } else {
-                throw new Issue("error", "too-costly", null, null, 'The code System "' + cs.system() + '" has a grammar, and cannot be enumerated directly', null, 422).withDiagnostics(this.worker.opContext.diagnostics());
-              }
-            }
-            if (!imp && this.limitCount > 0 && cs.totalCount > this.limitCount) {
+            // The unclosed marking for a grammar code system is added by
+            // processCodes (the actual expansion); checkSource only guards size.
+            if (!imp && this.count !== 0 && this.limitCount > 0 && cs.totalCount > this.limitCount) {
               throw new Issue("error", "too-costly", null, 'VALUESET_TOO_COSTLY', this.worker.i18n.translate('VALUESET_TOO_COSTLY', this.params.httpLanguages, [srcURL, '>' + this.limitCount]), null, 422).withDiagnostics(this.worker.opContext.diagnostics());
             }
           }
@@ -746,45 +740,64 @@ class ValueSetExpander {
             let vs = await this.worker.findValueSet(cs.specialEnumeration(), '', null);
             const base = await this.expandValueSet(cs.specialEnumeration(), '', vs, filter, notClosed);
             Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
             await this.importValueSet(base, expansion, valueSets, 0);
             notClosed.value = true;
+          } else if (!cs.canBeExpanded()) {
+            throw new Issue("error", "not-supported", null, 'CODESYSTEM_NOT_ENUMERABLE', this.worker.i18n.translate('CODESYSTEM_NOT_ENUMERABLE', this.params.httpLanguages, [cs.system()]), null, 422).withDiagnostics(this.worker.opContext.diagnostics());
           } else if (filter.isNull) {
             this.worker.opContext.log('add whole code system');
             if (cs.isNotClosed()) {
               if (cs.specialEnumeration()) {
                 Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
               } else {
-                throw new Issue("error", "too-costly", null, null, 'The code System "' + cs.system() + '" has a grammar, and cannot be enumerated directly', null, 422).withDiagnostics(this.worker.opContext.diagnostics());
+                // Grammar code system with no special enumeration (e.g. SNOMED CT):
+                // enumerate the precoordinated concepts we can, and mark the
+                // expansion incomplete rather than refusing it.
+                Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
+                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members");
               }
               notClosed.value = true;
             }
 
-            const iter = await cs.iterator(null);
-            if (valueSets.length === 0 && this.limitCount > 0 && (iter && iter.total > this.limitCount) && this.offset < 0) {
-              throw new Issue("error", "too-costly", null, 'VALUESET_TOO_COSTLY', this.worker.i18n.translate('VALUESET_TOO_COSTLY', this.params.httpLanguages, [vsSrc.vurl, '>' + this.limitCount]), null, 422).withDiagnostics(this.worker.opContext.diagnostics());
+            if (this.count === 0 && filters.length === 0 && valueSets.length === 0) {
+              // count=0 (count only) with a single whole-code-system include and no
+              // additional filters: report the code count directly rather than
+              // enumerating - which for a poly-hierarchy (e.g. SNOMED) is both
+              // expensive and pointless when no codes are being materialised.
+              this.addToTotal(await cs.countAllCodes(excludeInactive));
+            } else {
+              const iter = await cs.iterator(null);
+              if (valueSets.length === 0 && this.limitCount > 0 && (iter && iter.total > this.limitCount) && this.offset < 0) {
+                throw new Issue("error", "too-costly", null, 'VALUESET_TOO_COSTLY', this.worker.i18n.translate('VALUESET_TOO_COSTLY', this.params.httpLanguages, [vsSrc.vurl, '>' + this.limitCount]), null, 422).withDiagnostics(this.worker.opContext.diagnostics());
 
-            }
-            let tcount = 0;
-            let c = await cs.nextContext(iter);
-            while (c) {
-              this.worker.deadCheck('processCodes#3a');
-              if (await this.passesFilters(cs, c, prep, filters, 0)) {
-                tcount += await this.includeCodeAndDescendants(cs, c, expansion, valueSets, null, excludeInactive, vsSrc.vurl);
               }
-              c = await cs.nextContext(iter);
+              let tcount = 0;
+              let c = await cs.nextContext(iter);
+              while (c) {
+                this.worker.deadCheck('processCodes#3a');
+                if (await this.passesFilters(cs, c, prep, filters, 0)) {
+                  tcount += await this.includeCodeAndDescendants(cs, c, expansion, valueSets, null, excludeInactive, vsSrc.vurl);
+                }
+                c = await cs.nextContext(iter);
+              }
+              this.addToTotal(tcount);
             }
-            this.addToTotal(tcount);
           } else {
             this.worker.opContext.log('prepare filters');
-            this.noTotal();
             if (cs.isNotClosed(filter)) {
               notClosed.value = true;
             }
             const prep = await cs.getPrepContext(true);
             const ctxt = await cs.searchFilter(prep, filter, false);
             let set = await cs.executeFilters(prep);
+            if (this.count === 0 && valueSets.length === 0) {
+              // count=0 (count only): report the filtered size directly without
+              // materialising the codes.
+              this.addToTotal(await cs.filterSize(ctxt, set[0]));
+            } else {
+            this.noTotal();
             this.worker.opContext.log('iterate filters');
             while (await cs.filterMore(ctxt, set[0])) {
               this.worker.deadCheck('processCodes#4');
@@ -808,6 +821,7 @@ class ValueSetExpander {
               }
             }
             this.worker.opContext.log('iterate filters done');
+            }
           }
         }
 
@@ -856,7 +870,7 @@ class ValueSetExpander {
 
           if (cs.specialEnumeration()) {
             Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
             notClosed.value = true;
           }
 
@@ -867,7 +881,7 @@ class ValueSetExpander {
               throw new Issue('error', 'invalid', path + ".filter[" + i + "]", 'UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.worker.i18n.translate('UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.params.httpLanguages, [cs.system(), fc.property, fc.op]), 'vs-invalid', 400);
             }
             Extensions.checkNoModifiers(fc, 'ValueSetExpander.processCodes', 'filter', vsSrc.vurl);
-            await cs.filter(prep, i == 0, fc.property, fc.op, fc.value);
+            await cs.filter(prep, i == 0, fc.property, fc.op, fc.value, vsSrc.isCached ? fc : null);
           }
 
           const fset = await cs.executeFilters(prep);
@@ -1003,9 +1017,13 @@ class ValueSetExpander {
             if (cs.isNotClosed(filter)) {
               if (cs.specialEnumeration()) {
                 Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
               } else {
-                throw new Issue("error", "too-costly", null, null, 'The code System "' + cs.system() + '" has a grammar, and cannot be enumerated directly', null, 422).withDiagnostics(this.worker.opContext.diagnostics());
+                // Grammar code system with no special enumeration (e.g. SNOMED CT):
+                // enumerate the precoordinated concepts we can, and mark the
+                // expansion incomplete rather than refusing it.
+                Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
+                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members");
               }
             }
 
@@ -1053,14 +1071,14 @@ class ValueSetExpander {
           if (cs.specialEnumeration()) {
             await cs.specialFilter(prep, true);
             Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
           }
 
           let first = true;
           for (let fc of cset.filter) {
             this.worker.deadCheck('processCodes#4a');
             Extensions.checkNoModifiers(fc, 'ValueSetExpander.processCodes', 'filter', vsSrc.vurl);
-            await cs.filter(prep, first, fc.property, fc.op, fc.value);
+            await cs.filter(prep, first, fc.property, fc.op, fc.value, vsSrc.isCached ? fc : null);
             first = false;
           }
 

package/tx/workers/metadata.js

@@ -36,16 +36,37 @@ class MetadataHandler {
 
     if (mode === 'terminology') {
       this.logInfo = 'termcaps';
-      const tc = new TerminologyCapabilities(await this.buildTerminologyCapabilities(endpoint, provider));
+      const tc = new TerminologyCapabilities(await this.buildTerminologyCapabilities(endpoint, provider, req));
       return res.json(tc.jsonObj);
     }
     this.logInfo = 'metadata';
 
     // Default: return CapabilityStatement
-    const cs = new CapabilityStatement(this.buildCapabilityStatement(endpoint, provider));
+    const cs = new CapabilityStatement(this.buildCapabilityStatement(endpoint, provider, req));
     return res.json(cs.jsonObj);
   }
 
+  /**
+   * Resolve the public base URL for this request.
+   * Derived from what the client actually asked for (scheme + host) plus the
+   * endpoint path, so the server echoes the host the client used rather than a
+   * fixed, hardcoded value. Falls back to config/host only when no request is
+   * available (e.g. unit tests calling the build methods directly).
+   * @param {express.Request} [req] - Express request
+   * @param {Object} endpoint - Endpoint info {path, ...}
+   * @returns {string} Base URL, e.g. https://tx.fhir.org/r4
+   */
+  resolveBaseUrl(req, endpoint) {
+    if (!req) {
+      return this.config.baseUrl || `https://${this.host}${endpoint.path}`;
+    }
+    // Requires app.set('trust proxy', ...) and nginx forwarding X-Forwarded-Proto
+    // for the scheme to be correct behind the reverse proxy.
+    const proto = req.protocol || 'https';
+    const host = req.get('host') || this.host;
+    return `${proto}://${host}${endpoint.path}`;
+  }
+
   /**
    * Handle GET /$versions request
    * @param {express.Request} req - Express request (with txEndpoint attached)
@@ -106,11 +127,11 @@ class MetadataHandler {
    * @param {Object} provider - Provider for code systems and resources
    * @returns {Object} CapabilityStatement resource
    */
-  buildCapabilityStatement(endpoint) {
+  buildCapabilityStatement(endpoint, provider, req) {
 
     const now = new Date().toISOString();
     const fhirVersion = this.mapFhirVersion(endpoint.fhirVersion);
-    const baseUrl = this.config.baseUrl || `https://${this.host}${endpoint.path}`;
+    const baseUrl = this.resolveBaseUrl(req, endpoint);
     const serverVersion = this.config.serverVersion;
 
     return {
@@ -281,9 +302,9 @@ class MetadataHandler {
    * @param {Object} provider - Provider for code systems and resources
    * @returns {Object} TerminologyCapabilities resource
    */
-  async buildTerminologyCapabilities(endpoint, provider) {
+  async buildTerminologyCapabilities(endpoint, provider, req) {
     const now = new Date().toISOString();
-    const baseUrl = this.config.baseUrl || `https://${this.host}${endpoint.path}`;
+    const baseUrl = this.resolveBaseUrl(req, endpoint);
     const serverVersion = this.config.serverVersion || '1.0.0';
 
     const tc = {

package/tx/workers/search.js

@@ -8,6 +8,7 @@
 const { TerminologyWorker } = require('./worker');
 const {Utilities} = require("../../library/utilities");
 const {debugLog} = require("../operation-context");
+const {acceptsHtml} = require("../tx-html");
 
 class SearchWorker extends TerminologyWorker {
   /**
@@ -84,7 +85,12 @@ class SearchWorker extends TerminologyWorker {
           break;
       }
 
-      const count = summary === 'count' ? 0 : Math.min(elements ? 2000 : 200, params._count && Utilities.isInteger(params._count) ? parseInt(params._count) : 20);
+      // Default page size depends on the return format: browsers get small pages
+      // (20), while API clients (json/xml) get big ones (1000) - they just want
+      // the data, and small pages make crawlers (e.g. the tx registry) painfully
+      // slow. An explicit _count always wins, subject to the caps.
+      const defaultCount = acceptsHtml(req) ? 20 : 1000;
+      const count = summary === 'count' ? 0 : Math.min(elements ? 2000 : 200, params._count && Utilities.isInteger(params._count) ? parseInt(params._count) : defaultCount);
       const sort = params._sort || "id";
 
       // Get matching resources

package/tx/workers/validate.js

@@ -753,6 +753,7 @@ class ValueSetChecker {
               messages.push(msg);
             }
           } else {
+            this.worker.opContext.addNote(this.valueSet, 'Include for ' + this.worker.renderer.displayCoded(cc.system, cc.version) + ' not considered for "' + this.worker.renderer.displayCoded(system, version) + '"', this.indentCount);
             result = false;
           }
           for (let u of cc.valueSet || []) {
@@ -875,6 +876,7 @@ class ValueSetChecker {
           }
         }
       } else {
+        this.worker.opContext.addNote(this.valueSet, 'ValueSet has neither compose nor expansion - cannot determine membership', this.indentCount);
         result = false;
       }
     }
@@ -1126,17 +1128,23 @@ class ValueSetChecker {
         } else if (c.display && list.designations.length > 0) {
           await this.checkDisplays(list, defLang, c, msg, op, path);
         }
-        psys = c.system;
-        pcode = c.code;
-        if (ver.value) {
-          pver = ver.value;
-        }
-        let pd = list.preferredDisplay(this.params.workingLanguages());
-        if (pd) {
-          pdisp = pd;
-        }
-        if (!pdisp) {
-          pdisp = list.preferredDisplay(null);
+        // Report the FIRST matching coding, not the last: when a CodeableConcept
+        // has several valid codings, the code/system/version/display echoed back
+        // are those of the earliest coding that validated. Only capture once
+        // (pcode is undefined until the first match).
+        if (pcode === undefined) {
+          psys = c.system;
+          pcode = c.code;
+          if (ver.value) {
+            pver = ver.value;
+          }
+          let pd = list.preferredDisplay(this.params.workingLanguages());
+          if (pd) {
+            pdisp = pd;
+          }
+          if (!pdisp) {
+            pdisp = list.preferredDisplay(null);
+          }
         }
       } else if (!this.params.membershipOnly && ws) {
         if (!isAbsoluteUrl(ws)) {
@@ -1203,7 +1211,7 @@ class ValueSetChecker {
             }
           }
         } else {
-          this.checkCanonicalStatusCS(path, op, prov, this.valueSet);
+          await this.checkCanonicalStatusCS(path, op, prov, this.valueSet);
           let ctxt = await prov.locate(c.code);
           if (!ctxt.context) {
             // message can never be populated in pascal?
@@ -1280,7 +1288,10 @@ class ValueSetChecker {
       }
       i++;
     }
-    if (ok === false && !this.valueSet.jsonObj.internallyDefined) {
+    // for an internally defined value set (CodeSystem validation), the code-system-level
+    // message is preferred - but if nothing produced an error, this is the only
+    // explanation there will be, so it can't be suppressed
+    if (ok === false && (!this.valueSet.jsonObj.internallyDefined || !op.hasErrors())) {
       let mid, m, p;
       if (mode === 'codeableConcept') {
         mid = 'TX_GENERAL_CC_ERROR_MESSAGE';
@@ -1354,12 +1365,13 @@ class ValueSetChecker {
       if (!mpath) {
         mpath = 'code';
       }
+      let mid1 = "INACTIVE_CONCEPT_FOUND";
+      let mm1 = "";
       if (!['inactive', 'DISCOURAGED'].includes(vstatus.value)) {
-        let m = this.worker.i18n.translate('INACTIVE_CONCEPT_FOUND', this.params.HTTPLanguages, ['inactive', tcode]);
-        msg(m);
-        op.addIssue(new Issue('warning', 'business-rule', mpath, 'INACTIVE_CONCEPT_FOUND', m, 'code-comment'));
+        mid1 = 'INACTIVE_CONCEPT_FOUND_ADD';
+        mm1 = 'inactive';
       }
-      let m = this.worker.i18n.translate('INACTIVE_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, tcode]);
+      let m = this.worker.i18n.translate(mid1, this.params.HTTPLanguages, [vstatus.value, tcode, mm1]);
       msg(m);
       op.addIssue(new Issue('warning', 'business-rule', mpath, 'INACTIVE_CONCEPT_FOUND', m, 'code-comment'));
     } else if (vstatus.value && vstatus.value.toLowerCase() === 'deprecated') {
@@ -1688,7 +1700,7 @@ class ValueSetChecker {
         if (!fc.value) {
           throw new Issue('error', 'invalid', null, 'UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.worker.i18n.translate('UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.params.HTTPLanguages, [cs.system(), fc.property, fc.op]));
         }
-        await cs.filter(prep, false, fc.property, fc.op, fc.value);
+        await cs.filter(prep, false, fc.property, fc.op, fc.value, (vs && vs.isCached) ? fc : null);
         // if (f === null) {
         //   throw new Issue('error', 'not-supported', null, 'FILTER_NOT_UNDERSTOOD', this.worker.i18n.translate('FILTER_NOT_UNDERSTOOD', this.params.HTTPLanguages, [fc.property, fc.op, fc.value, vs.vurl, cs.system()]) + ' (2)', 'vs-invalid');
         // }