fhirsmith 0.18.0 → 0.18.2

package/registry/registry.js

@@ -20,6 +20,7 @@ const { RegistryAuth } = require('./auth');
 // parameters are ignored) because existing ecosystem clients rely on that.
 const DISCOVERY_PARAMS = ['registry', 'server', 'fhirVersion', 'url', 'authoritativeOnly', 'language'];
 const RESOLVE_PARAMS = ['fhirVersion', 'url', 'version', 'valueSet', 'authoritativeOnly', 'language', 'usage'];
+const CHOOSE_SERVER_PARAMS = ['fhirVersion', 'system', 'default', 'valueSet', 'usage', 'language'];
 
 // A link to a URL from a registry list or a crawled server: those are other people's
 // content, so only an http(s) URL is linked, and it is escaped
@@ -325,6 +326,8 @@ class RegistryModule {
     // Main registry page
     this.router.get('/', apiLimiter, apiGuard, session, this.handleMainPage.bind(this));
     this.router.get('/resolve', apiLimiter, apiGuard, session, this.handleResolveEndpoint.bind(this));
+    // JSON only - there's no page for a browser, so it's always guarded
+    this.router.get('/choose-server', apiLimiter, guard, this.handleChooseServerEndpoint.bind(this));
     this.router.get('/log', session, this.handleLogEndpoint.bind(this));
     this.router.get('/software', session, this.handleSoftwarePage.bind(this));
 
@@ -807,8 +810,15 @@ class RegistryModule {
       const lastRunDate = new Date(stats.lastRun);
       lastUpdatedText = `Last Updated: ${lastRunDate.toLocaleString()}`;
     }
-    html += `<p>${lastUpdatedText}. <a href="https://github.com/FHIR/ig-registry/blob/master/tx-registry-doco.md">Register your own server</a>`+
-      ` - see <a href="https://build.fhir.org/ig/HL7/fhir-tx-ecosystem-ig/ecosystem.html">Documentation</a></p>`;
+    // what goes here depends on the ecosystem, so it comes from the master registration file
+    html += `<p>${lastUpdatedText}.`;
+    if (data.registration) {
+      html += ` <a href="${safeHref(data.registration)}">Register your own server</a>`;
+    }
+    if (data.ecosystemDoco) {
+      html += `${data.registration ? ' -' : ''} see <a href="${safeHref(data.ecosystemDoco)}">Documentation</a>`;
+    }
+    html += '</p>';
 
     html += '<table class="grid">';
     html += '<thead><tr>';
@@ -1503,6 +1513,46 @@ class RegistryModule {
     }
   }
 
+  /**
+   * GET /choose-server: which one server to use for a request involving a set of code
+   * systems (see RegistryAPI.chooseServer). system repeats; the other parameters take their
+   * first value
+   */
+  handleChooseServerEndpoint(req, res) {
+    const start = Date.now();
+    try {
+      const params = this._normalizeQueryParams(req.query);
+      const {fhirVersion, valueSet, usage, language} = params;
+      const defaultServer = params.default;
+      const raw = req.query.system;
+      const systems = (raw == null ? [] : Array.isArray(raw) ? raw : [raw]).map(String).filter(s => s);
+
+      if (!fhirVersion) {
+        return res.status(400).json({error: 'A FHIR version is required'});
+      }
+      if (!defaultServer || !this._isValidUrl(defaultServer, ['http:', 'https:'])) {
+        return res.status(400).json({error: 'A default server (an http or https URL) is required'});
+      }
+      for (const system of systems) {
+        if (!this._isValidUrl(system.split('|')[0])) {
+          return res.status(400).json({error: 'Invalid code system URL format'});
+        }
+      }
+      if (valueSet && !this._isValidUrl(valueSet.split('|')[0])) {
+        return res.status(400).json({error: 'Invalid value set URL format'});
+      }
+
+      const result = this.api.chooseServer(fhirVersion, systems, defaultServer, valueSet, usage, language);
+      this.logger.info(`Chose ${result.server} for ${systems.join(', ') || '(no systems)'} (FHIR ${fhirVersion}, usage=${usage}, language=${language || 'none'})`);
+      res.json(result);
+    } catch (error) {
+      this.logger.error('Error in choose-server endpoint:', error);
+      res.status(400).json({error: error.message});
+    } finally {
+      this.stats.countRequest('choose-server', Date.now() - start);
+    }
+  }
+
   buildResolveResultContent(result, fhirVersion, resourceUrl, usage, language) {
     let html = '';
 
@@ -1833,6 +1883,7 @@ class RegistryModule {
 
 RegistryModule.DISCOVERY_PARAMS = DISCOVERY_PARAMS;
 RegistryModule.RESOLVE_PARAMS = RESOLVE_PARAMS;
+RegistryModule.CHOOSE_SERVER_PARAMS = CHOOSE_SERVER_PARAMS;
 
 module.exports = RegistryModule;
 module.exports.commonBaseUrl = commonBaseUrl;

package/translations/Messages.properties

@@ -1129,6 +1129,7 @@ CLOSURE_NAME_NOT_UUID = The closure table name ''{0}'' is not valid: this server
 CLOSURE_PARAM_UNKNOWN = The parameter ''{0}'' is not supported by $closure on this server
 CLOSURE_CONCEPT_AND_VERSION = A $closure request can add concepts or resynchronise from a version, but not both at once
 CLOSURE_RESET_AND_VERSION = A $closure request can reset the closure table or resynchronise from a version, but not both at once
+CLOSURE_DISPOSE_NOT_ALONE = A $closure request that disposes of the closure table can only name the table: it cannot also add concepts, resynchronise, reset or configure it
 CLOSURE_TABLE_EXISTS = The closure table ''{0}'' already exists. To discard its content and start again, include the parameter reset = true
 CLOSURE_TABLE_UNKNOWN = The closure table ''{0}'' does not exist on this server. Initialise it first, with a $closure request that names it and has no concepts
 CLOSURE_CONFIG_NOT_ALLOWED = The parameter ''{0}'' configures a closure table, so it can only be supplied when the table is initialised (or reset)

package/tx/README.md

@@ -312,6 +312,10 @@ THO's v3-ActCode code system is `CodeSystem/tho-v3-ActCode`. No resource is serv
 - `core` is the FHIR core package each endpoint loads for its FHIR version (`CodeSystem/core-administrative-gender`), and `x` is the code systems the server implements natively (`CodeSystem/x-...`); neither can be given as a prefix
 - Sources that only provide code systems natively (`internal`, `snomed`, `loinc` etc.) don't serve resources by id, so a prefix does nothing for them
 
+#### hl7.terminology and the FHIR core packages
+
+Much of the content of the FHIR core packages has moved to terminology.hl7.org (`hl7.terminology`), and its versions were reset when it moved (`coverage-selfpay` is 4.0.1 in `hl7.fhir.r4.core`, and 1.0.1 in `hl7.terminology`), so version order can't decide between the two. Where `hl7.terminology` provides a code system, value set or concept map with the same url as the endpoint's core package, THO's is always the one a reference with no version gets. The core package's versions are still available to a reference that names them (`http://hl7.org/fhir/concept-property-type|5.0.0`), unless THO provides that same version itself. Core value sets and concept maps that THO also provides are not read by id, found by search, or used for `$translate` unless asked for by version.
+
 ### Source Types
 
 #### `internal` - Built-in Code Systems

package/tx/closure/closure-store.js

@@ -286,6 +286,20 @@ class ClosureStore {
     return tx();
   }
 
+  /**
+   * Delete a table, and everything in it. The caller holds the table's lock.
+   * @param {string} name
+   * @returns {boolean} whether there was a table to delete
+   */
+  dropTable(name) {
+    const existing = this.stmt.getTable.get(name);
+    if (!existing) {
+      return false;
+    }
+    this.stmt.deleteTable.run(existing.id);
+    return true;
+  }
+
   /**
    * The parameters the table was initialised with, as Parameters.parameter entries.
    */

package/tx/cm/cm-package.js

@@ -8,6 +8,7 @@ const { VersionUtilities } = require('../../library/version-utilities');
 const {validateParameter} = require("../../library/utilities");
 const {ConceptMap} = require("../library/conceptmap");
 const { applyIdPrefix, stripIdPrefix } = require('../library/resource-ids');
+const { keepForPinnedReference } = require('../library/tho-precedence');
 
 /**
  * Package-based ConceptMap provider using shared database layer
@@ -169,7 +170,7 @@ class PackageConceptMapProvider extends AbstractConceptMapProvider {
 
         // Only process each ConceptMap once (use URL to deduplicate)
         const vsUrl = json.url;
-        if (seen.has(vsUrl)) {
+        if (seen.has(vsUrl) || this.#pinnedOnly.has(vs)) {
           continue;
         }
 
@@ -330,35 +331,39 @@ class PackageConceptMapProvider extends AbstractConceptMapProvider {
     return this.packageLoader.id();
   }
 
-  // the concept maps left out by excludeUrls, by their own (unprefixed) id
+  // the concept maps that keepPinnedOnly restricted, by their own (unprefixed) id, and themselves
   #excludedIds = new Set();
+  #pinnedOnly = new Set();
 
   /**
-   * Leave out the concept maps with any of these urls: they can't be fetched, they aren't
-   * found by search, and they aren't used for translation. The FHIR core package's concept
-   * maps are left out where hl7.terminology provides the same url (see
-   * Provider.applyTHOPrecedence). Must be called once the provider is initialized - the
-   * database is shared, so it isn't changed.
+   * The concept maps with these urls are hl7.terminology's to provide (see
+   * Provider.applyTHOPrecedence): from this (core) package they are only available to a
+   * reference that names their version, where THO doesn't provide that version itself. They
+   * aren't the default for their url, can't be read by id, aren't found by search, and aren't
+   * used for translation unless asked for. Must be called once the provider is initialized -
+   * the database is shared, so it isn't changed.
    *
-   * @param {Set<string>} urls
+   * @param {Map<string, Set<string>>} thoVersions - url -> the versions hl7.terminology provides
    */
-  excludeUrls(urls) {
-    const excluded = new Set();
+  keepPinnedOnly(thoVersions) {
+    const affected = new Set();
     for (const cm of this.conceptMapMap.values()) {
-      if (cm && urls.has(cm.url)) {
-        excluded.add(cm);
+      if (cm && thoVersions.has(cm.url)) {
+        affected.add(cm);
       }
     }
     for (const [key, cm] of [...this.conceptMapMap]) {
-      if (excluded.has(cm)) {
+      if (affected.has(cm) && !keepForPinnedReference(key, cm, thoVersions.get(cm.url))) {
         this.conceptMapMap.delete(key);
       }
     }
-    for (const cm of excluded) {
+    for (const cm of affected) {
+      this.#pinnedOnly.add(cm);
       this.#excludedIds.add(stripIdPrefix(cm.id, this.spaceId) ?? cm.id);
     }
   }
 
+
   prefixIds() {
     this.#applyIdPrefix();
   }
@@ -371,7 +376,8 @@ class PackageConceptMapProvider extends AbstractConceptMapProvider {
 
   async findConceptMapForTranslation(opContext, conceptMaps, sourceSystem, sourceScope, targetScope, targetSystem) {
     for (let cm of this.conceptMapMap.values()) {
-      if (cm.providesTranslation(sourceSystem, sourceScope, targetScope, targetSystem)) {
+      // a concept map that THO also provides is only used when it's asked for by version
+      if (!this.#pinnedOnly.has(cm) && cm.providesTranslation(sourceSystem, sourceScope, targetScope, targetSystem)) {
         conceptMaps.push(cm);
       }
     }

package/tx/cs/cs-api.js

@@ -1036,9 +1036,11 @@ class CodeSystemFactoryProvider {
    * @param source - the source system URI
    * @param sourceVersion - the version of the source coding (may be null)
    * @param dest - the target system URI, possibly with |version
+   * @param code - the code being translated, if known (under reverse, the target concept's
+   *   code), so a provider can leave out a map that has nothing to say about it
    */
   // eslint-disable-next-line no-unused-vars
-  async findImplicitConceptMaps(conceptMaps, source, sourceVersion, dest) {
+  async findImplicitConceptMaps(conceptMaps, source, sourceVersion, dest, code = null) {
     return null;
   }
 

package/tx/cs/cs-cs.js

@@ -19,6 +19,9 @@ const regexUtilities = require("../../library/regex-utilities");
 // filter results do not depend on forIteration, so one form is stored per version.
 const FILTER_ANALYSIS = Symbol('filterAnalysis');
 
+// The standard concept properties (http://hl7.org/fhir/concept-properties)
+const CONCEPT_PROPERTIES = 'http://hl7.org/fhir/concept-properties#';
+
 // The texts of each concept as a text filter compares them, by concept. Folding is
 // the costly part of a search over a large code system, so it is done once per
 // concept, and dropped with the code system.
@@ -315,6 +318,46 @@ class FhirCodeSystemProvider extends BaseCSServices {
     return this.codeSystem.jsonObj.property || null;
   }
 
+  /**
+   * The codes this code system uses for one of the standard concept properties
+   * (http://hl7.org/fhir/concept-properties#<name>). A property declared with the
+   * standard uri counts whatever local code it was given. A code that the code
+   * system declares with a different uri is a different property, and does not
+   * count. A code the code system doesn't declare (or declares with no uri) is
+   * recognised by the code alone - the standard code, and any legacy aliases
+   *
+   * @param {string} name - the standard property code (e.g. notSelectable)
+   * @param {string[]} aliases - legacy codes also recognised when not declared otherwise
+   * @returns {Set<string>} the local codes for the property
+   */
+  standardPropertyCodes(name, aliases = []) {
+    const uri = CONCEPT_PROPERTIES + name;
+    const defs = this.propertyDefinitions() || [];
+    const codes = new Set();
+    for (const d of defs) {
+      if (d.uri === uri) {
+        codes.add(d.code);
+      }
+    }
+    for (const c of [name, ...aliases]) {
+      if (!defs.some(d => d.code === c && d.uri && d.uri !== uri)) {
+        codes.add(c);
+      }
+    }
+    return codes;
+  }
+
+  /**
+   * Whether the code system declares the code of a standard concept property for a
+   * property of its own (with a different uri), so that the code is not the standard one
+   * @param {string} name - the standard property code
+   * @returns {boolean}
+   */
+  redefinesStandardProperty(name) {
+    const uri = CONCEPT_PROPERTIES + name;
+    return (this.propertyDefinitions() || []).some(d => d.code === name && d.uri && d.uri !== uri);
+  }
+
   /**
    * @param {Languages} languages - Language specification
    * @returns {boolean} Whether any displays are available for the languages
@@ -524,14 +567,10 @@ class FhirCodeSystemProvider extends BaseCSServices {
       return false;
     }
 
-    // Check for abstract property
+    // Check for the notSelectable property, by whatever code this code system gives it
     if (ctxt.concept.property && Array.isArray(ctxt.concept.property)) {
-      const abstractProp = ctxt.concept.property.find(p =>
-        p.code === 'abstract' ||
-        p.code === 'not-selectable' ||
-        p.code === 'notSelectable' ||
-        p.uri === 'http://hl7.org/fhir/concept-properties#notSelectable'
-      );
+      const codes = this.standardPropertyCodes('notSelectable', ['abstract', 'not-selectable']);
+      const abstractProp = ctxt.concept.property.find(p => codes.has(p.code));
       if (abstractProp && abstractProp.valueBoolean) {
         return true;
       }
@@ -1027,11 +1066,17 @@ class FhirCodeSystemProvider extends BaseCSServices {
       return;
     }
 
-    // Add properties if requested (or by default)
-    if (this._hasProp(props, 'property', true)) {
+    // Add the concept's properties: each one if it was asked for by its code (or '*', or nothing
+    // was asked for). 'property' asks for all of them - it used to be the only thing that did, so
+    // asking for a property by its own code returned nothing. A code the server doesn't know is
+    // simply not matched
+    {
       const properties = await this.properties(ctxt);
       if (properties) {
         for (const property of properties) {
+          if (!this._hasProp(props, property.code, true) && !this._hasProp(props, 'property', true)) {
+            continue;
+          }
           let parts = [];
           parts.push({ name: 'code', valueCode: property.code });
 
@@ -1393,9 +1438,10 @@ class FhirCodeSystemProvider extends BaseCSServices {
         }
       }
 
-      // Handle known special properties
+      // Handle known special properties - unless the code system uses the code for a
+      // property of its own, in which case the property filter above applies
       const knownProperties = ['notSelectable', 'status', 'inactive', 'deprecated'];
-      if (knownProperties.includes(prop)) {
+      if (knownProperties.includes(prop) && !this.redefinesStandardProperty(prop)) {
         results = await this._handleKnownPropertyFilter(filterContext, prop, op, value);
       }
 
@@ -1699,13 +1745,14 @@ class FhirCodeSystemProvider extends BaseCSServices {
   async _handleKnownPropertyFilter(filterContext, prop, op, value) {
     const results = new FhirCodeSystemProviderFilterContext();
     const allConcepts = this.codeSystem.getAllConcepts();
+    const nsCodes = this.standardPropertyCodes('notSelectable', ['abstract', 'not-selectable']);
 
     for (const concept of allConcepts) {
       this.opContext.deadCheck('cs:knownPropertyFilter');
       let matches = false;
 
       if (prop === 'notSelectable') {
-        const abstractProp = (concept.property || []).find(p => p.code === 'abstract' || p.code === 'notSelectable' || p.uri === 'http://hl7.org/fhir/concept-properties#notSelectable');
+        const abstractProp = (concept.property || []).find(p => nsCodes.has(p.code));
         let vv = abstractProp ? String(getValuePrimitive(abstractProp)) : null;
         if (op === '=') {
           matches = (vv === value);

package/tx/cs/cs-icf.js

@@ -12,10 +12,12 @@
  *   s  body structures            extent, nature, localization
  *   d  activities/participation   performance, capacity, then optionally capacity with
  *                                 assistance and performance without assistance
- *   e  environmental factors      not supported yet (barriers '.', facilitators '+')
+ *   e  environmental factors      one: a barrier after '.', or a facilitator after '+' (in
+ *                                 place of the '.') - e310.2, e310+3
  * Each digit must be a value of its position's scale, which the code system carries as the
- * concepts q1-n (extent of impairment), q2-n (nature), q3-n (localization) and q4-n (extent of
- * problem), under the group concepts q1..q4. A position cannot be omitted; 8 (not specified) is
+ * concepts q1-n (extent of impairment), q2-n (nature), q3-n (localization), q4-n (extent of
+ * problem), q5-n (barrier) and q6-n (facilitator, which has no 9), under the group concepts
+ * q1..q6. A position cannot be omitted; 8 (not specified) is
  * what fills it, and 8 says nothing in the display. Each position is reported by $lookup as the
  * property named in QUALIFIERS.
  *
@@ -37,32 +39,40 @@ const { Issue } = require('../library/operation-outcome');
 const { FhirCodeSystemProvider, FhirCodeSystemProviderContext, FhirCodeSystemProviderFilterContext } = require('./cs-cs');
 
 /**
- * The qualifier positions of each component: the property that reports the qualifier, the
- * scale (group concept) its values come from, and the label that introduces its value in the
- * display (none for b and s, whose qualifiers say what they are).
+ * The qualifier positions of each component, by the separator that introduces them: the
+ * property that reports the qualifier, the scale (group concept) its values come from, and the
+ * label that introduces its value in the display (none where the value says what it is).
+ * Only environmental factors take '+', which makes the qualifier a facilitator.
  */
 const QUALIFIERS = {
-  b: [
-    { property: 'extent', scale: 'q1' }
-  ],
-  s: [
-    { property: 'extent', scale: 'q1' },
-    { property: 'nature', scale: 'q2' },
-    { property: 'localization', scale: 'q3' }
-  ],
-  d: [
-    { property: 'performance', scale: 'q4', label: 'performance' },
-    { property: 'capacity', scale: 'q4', label: 'capacity' },
-    { property: 'capacity-with-assistance', scale: 'q4', label: 'capacity with assistance' },
-    { property: 'performance-without-assistance', scale: 'q4', label: 'performance without assistance' }
-  ],
-  e: null // barriers and facilitators: not supported yet
+  b: {
+    '.': [{ property: 'extent', scale: 'q1' }]
+  },
+  s: {
+    '.': [
+      { property: 'extent', scale: 'q1' },
+      { property: 'nature', scale: 'q2' },
+      { property: 'localization', scale: 'q3' }
+    ]
+  },
+  d: {
+    '.': [
+      { property: 'performance', scale: 'q4', label: 'performance' },
+      { property: 'capacity', scale: 'q4', label: 'capacity' },
+      { property: 'capacity-with-assistance', scale: 'q4', label: 'capacity with assistance' },
+      { property: 'performance-without-assistance', scale: 'q4', label: 'performance without assistance' }
+    ]
+  },
+  e: {
+    '.': [{ property: 'barrier', scale: 'q5' }],
+    '+': [{ property: 'facilitator', scale: 'q6' }]
+  }
 };
 
 const COMPONENT_NAMES = { b: 'body functions', s: 'body structures', d: 'activities and participation', e: 'environmental factors' };
-const COMPONENT_CODES = { b: 'a body functions (b) code', s: 'a body structures (s) code', d: 'an activities and participation (d) code' };
+const COMPONENT_CODES = { b: 'a body functions (b) code', s: 'a body structures (s) code', d: 'an activities and participation (d) code', e: 'an environmental factors (e) code' };
 
-const QUALIFIER_PROPERTIES = new Set(Object.values(QUALIFIERS).filter(q => q).flatMap(q => q.map(p => p.property)));
+const QUALIFIER_PROPERTIES = new Set(Object.values(QUALIFIERS).flatMap(c => Object.values(c)).flatMap(q => q.map(p => p.property)));
 
 /**
  * A category with qualifiers. code and concept are the category's, so whatever is inherited
@@ -110,21 +120,22 @@ class IcfCodeSystemProvider extends FhirCodeSystemProvider {
   // -- locating -------------------------------------------------------------------------
 
   /**
-   * A code in the code system, or a selectable category followed by '.' and one to three
-   * qualifier digits. An unknown category is a plain miss (no message); a known category
-   * with bad qualifiers says what is wrong with them.
+   * A code in the code system, or a selectable category followed by '.' (or, for an
+   * environmental factor, '+') and its qualifier digits. An unknown category is a plain miss
+   * (no message); a known category with bad qualifiers says what is wrong with them.
    */
   async locate(code) {
     const base = await super.locate(code);
     if (base.context || typeof code !== 'string') {
       return base;
     }
-    const dot = code.indexOf('.');
-    if (dot <= 0) {
+    const sep = code.search(/[.+]/);
+    if (sep <= 0) {
       return base;
     }
-    const stemCode = code.substring(0, dot);
-    const digits = code.substring(dot + 1);
+    const separator = code[sep];
+    const stemCode = code.substring(0, sep);
+    const digits = code.substring(sep + 1);
     const stem = this.codeSystem.getConceptByCode(stemCode);
     if (!stem) {
       return { context: null, message: undefined };
@@ -133,15 +144,17 @@ class IcfCodeSystemProvider extends FhirCodeSystemProvider {
       return { context: null, message: `The ICF code '${code}' is not valid: qualifiers can only follow a selectable ICF category, and '${stemCode}' is not one` };
     }
     const component = stemCode[0];
-    const positions = QUALIFIERS[component];
+    const positions = (QUALIFIERS[component] || {})[separator];
     if (!positions) {
-      return { context: null, message: `The ICF code '${code}' is not valid: qualifiers on ${COMPONENT_NAMES[component] || 'these'} codes are not supported` };
+      return { context: null, message: separator === '+'
+        ? `The ICF code '${code}' is not valid: only an environmental factor (e) can be a facilitator, written with '+'`
+        : `The ICF code '${code}' is not valid: qualifiers on ${COMPONENT_NAMES[component] || 'these'} codes are not supported` };
     }
     const names = positions.map(q => q.property).join(', ');
     if (!new RegExp(`^[0-9]{1,${positions.length}}$`).test(digits)) {
       return { context: null, message: positions.length === 1
-        ? `The ICF code '${code}' is not valid: ${COMPONENT_CODES[component]} takes one qualifier digit after the '.' (${names})`
-        : `The ICF code '${code}' is not valid: ${COMPONENT_CODES[component]} takes 1 to ${positions.length} qualifier digits after the '.' (${names})` };
+        ? `The ICF code '${code}' is not valid: ${COMPONENT_CODES[component]} takes one qualifier digit after the '${separator}' (${names})`
+        : `The ICF code '${code}' is not valid: ${COMPONENT_CODES[component]} takes 1 to ${positions.length} qualifier digits after the '${separator}' (${names})` };
     }
     const qualifiers = [];
     for (let i = 0; i < digits.length; i++) {