fhirsmith 0.18.1 → 1.0.0

package/tx/cs/cs-country.js

@@ -73,6 +73,14 @@ class CountryCodeServices extends CodeSystemProvider {
     if (!ctxt) {
       return null;
     }
+    // a user-assigned code's display is a placeholder ('User-assigned'): an extension-codes
+    // supplement's display for it comes first
+    if (ctxt.userDefined) {
+      const ext = this._extensionCodeDisplay(ctxt.code);
+      if (ext) {
+        return ext;
+      }
+    }
     if (ctxt.display && this.opContext.langs.isEnglishOrNothing()) {
       return ctxt.display;
     }
@@ -116,11 +124,15 @@ class CountryCodeServices extends CodeSystemProvider {
     const ctxt = await this.#ensureContext(code);
     if (ctxt != null) {
       displays.userDefined = ctxt.userDefined;
-      displays.addDesignation( true, 'active', 'en', CodeSystem.makeUseForDisplay(), ctxt.display);
+      // when an extension-codes supplement gives a user-assigned code a display, the placeholder
+      // ('User-assigned') isn't one of its displays
+      if (!(ctxt.userDefined && this._extensionCodeDisplay(ctxt.code))) {
+        displays.addDesignation( true, 'active', 'en', CodeSystem.makeUseForDisplay(), ctxt.display);
+      }
       if (ctxt.french) {
         displays.addDesignation(true, 'active', 'fr', CodeSystem.makeUseForDisplay(), ctxt.french);
       }
-      this._listSupplementDesignations(ctxt.code, displays);
+      this._listSupplementDesignations(ctxt.code, displays, ctxt.userDefined);
     }
   }
 
@@ -199,8 +211,8 @@ class CountryCodeServices extends CodeSystemProvider {
       const result = new CountryCodeConceptFilter();
 
       try {
-        // Create regex with anchors to match the Pascal implementation (^value$)
-        const regex = regexUtilities.compile('^' + value + '$');
+        // anchored to the whole code
+        const regex = regexUtilities.compile('^(?:' + value + ')$'); // the whole value: a|b is ^(?:a|b)$, not ^a|b$
 
         for (const concept of this.codes) {
           if (regex.test(concept.code)) {
@@ -266,7 +278,7 @@ class CountryCodeServices extends CodeSystemProvider {
     if (concept && set.list.includes(concept)) {
       return concept;
     }
-    return `Code '${code}' not found in filter set`;
+    return null;
   }
 
   async filterCheck(filterContext, set, concept) {

package/tx/cs/cs-cpt.js

@@ -4,6 +4,7 @@ const { CodeSystem } = require('../library/codesystem');
 const { FilterExecutionContext, CodeSystemFactoryProvider } = require('./cs-api');
 const {validateArrayParameter} = require("../../library/utilities");
 const {BaseCSServices} = require("./cs-base");
+const { guarded } = require('../library/sqlite-utilities');
 
 class CPTConceptDesignation {
   constructor(kind, value) {
@@ -123,10 +124,7 @@ class CPTServices extends BaseCSServices {
   }
 
   close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
+    this.closeDb();
   }
 
   // Metadata methods
@@ -228,6 +226,15 @@ class CPTServices extends BaseCSServices {
   isNotClosed() {
     return true;
   }
+  /**
+   * The concept's properties for $expand: built by extendLookup, so that an expansion reports
+   * the same properties $lookup does (see CodeSystemProvider._propertiesFromLookup). Not the
+   * copyright, which extendLookup always adds: it is about the code system, not the concept
+   */
+  async properties(context, names) {
+    return (await this._propertiesFromLookup(context, names)).filter(p => p.code !== 'copyright');
+  }
+
   async extendLookup(ctxt, props, params) {
     validateArrayParameter(props, 'props', String);
     validateArrayParameter(params, 'params', Object);
@@ -571,7 +578,8 @@ class CPTServices extends BaseCSServices {
 
 
 
-  // Subsumption testing - not implemented
+  // Subsumption: CPT codes have no subsumption relationships, so two codes that both exist are
+  // not-subsumed (the caller deals with equal codes: equivalent)
   async subsumesTest(codeA, codeB) {
     await this.#ensureContext(codeA);
     await this.#ensureContext(codeB);
@@ -585,9 +593,14 @@ class CPTServices extends BaseCSServices {
 }
 
 class CPTServicesFactory extends CodeSystemFactoryProvider {
-  constructor(i18n, dbPath) {
+  /**
+   * @param {Object} [options] - {readOnly: true} in a tx-worker (cluster.md): the file is
+   *   the master's; this process opens it read-only
+   */
+  constructor(i18n, dbPath, options = {}) {
     super(i18n);
     this.dbPath = dbPath;
+    this.readOnly = !!options.readOnly;
     this.uses = 0;
     this._loaded = false;
     this._sharedData = null;
@@ -613,8 +626,12 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
     }
   }
 
+  #open() {
+    return this.readOnly ? new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY) : new sqlite3.Database(this.dbPath);
+  }
+
   async load() {
-    const db = new sqlite3.Database(this.dbPath);
+    const db = this.#open();
 
     try {
       this._sharedData = {
@@ -645,7 +662,7 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
 
   async #loadVersion(db) {
     return new Promise((resolve, reject) => {
-      db.all('SELECT * FROM Information', (err, rows) => {
+      db.all('SELECT * FROM Information', guarded(reject, (err, rows) => {
         if (err) {
           reject(err);
         } else {
@@ -656,13 +673,13 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
           }
           resolve();
         }
-      });
+      }));
     });
   }
 
   async #loadConcepts(db) {
     return new Promise((resolve, reject) => {
-      db.all('SELECT * FROM Concepts', (err, rows) => {
+      db.all('SELECT * FROM Concepts', guarded(reject, (err, rows) => {
         if (err) {
           reject(err);
         } else {
@@ -680,13 +697,13 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
           }
           resolve();
         }
-      });
+      }));
     });
   }
 
   async #loadProperties(db) {
     return new Promise((resolve, reject) => {
-      db.all('SELECT * FROM Properties', (err, rows) => {
+      db.all('SELECT * FROM Properties', guarded(reject, (err, rows) => {
         if (err) {
           reject(err);
         } else {
@@ -698,13 +715,13 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
           }
           resolve();
         }
-      });
+      }));
     });
   }
 
   async #loadDesignations(db) {
     return new Promise((resolve, reject) => {
-      db.all('SELECT * FROM Designations', (err, rows) => {
+      db.all('SELECT * FROM Designations', guarded(reject, (err, rows) => {
         if (err) {
           reject(err);
         } else {
@@ -716,7 +733,7 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
           }
           resolve();
         }
-      });
+      }));
     });
   }
 
@@ -729,7 +746,7 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
     this.recordUse();
 
     // Create fresh database connection for this provider instance
-    const db = new sqlite3.Database(this.dbPath);
+    const db = this.#open();
 
     return new CPTServices(opContext, supplements, db, this._sharedData);
   }

package/tx/cs/cs-cs.js

@@ -1,5 +1,5 @@
 const { CodeSystem}  = require("../library/codesystem");
-const { CodeSystemFactoryProvider, FilterExecutionContext }  = require( "./cs-api");
+const { CodeSystemFactoryProvider, FilterExecutionContext, CodeSystemProvider }  = require( "./cs-api");
 const { VersionUtilities }  = require("../../library/version-utilities");
 const { Language }  = require ("../../library/languages");
 const { validateOptionalParameter, getValuePrimitive, validateArrayParameter} = require("../../library/utilities");
@@ -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.
@@ -53,7 +56,8 @@ function conceptSearchTexts(concept) {
       display: concept.display ? searchText(concept.display) : null,
       definition: concept.definition ? foldSearchText(concept.definition) : null,
       designations: Array.isArray(concept.designation)
-        ? concept.designation.filter(designation => designation.value).map(designation => searchText(designation.value))
+        ? concept.designation.filter(designation => designation.value)
+          .map(designation => ({ ...searchText(designation.value), language: designation.language || null }))
         : []
     };
     SEARCH_TEXTS.set(concept, texts);
@@ -80,9 +84,16 @@ function wordsRatio(words, text) {
  * Context class for FHIR CodeSystem provider concepts
  */
 class FhirCodeSystemProviderContext {
-  constructor(code, concept) {
+  /**
+   * @param {string} code - the code
+   * @param {Object} concept - its definition in the code system
+   * @param {boolean} reserved - true if the code system doesn't define the code, but it is in its
+   *   reserved code space (so the concept is just the code, and supplements may define it)
+   */
+  constructor(code, concept, reserved = false) {
     this.code = code;
     this.concept = concept;
+    this.reserved = reserved;
   }
 }
 
@@ -187,6 +198,16 @@ function providerClassFor(url) {
 }
 
 class FhirCodeSystemProvider extends BaseCSServices {
+  /**
+   * A code system that reserves code spaces for users (codesystem-reservedCodeSpace) has codes that
+   * aren't listed in an expansion of all of it
+   * @returns {string|null}
+   */
+  openCodeSpaceReason() {
+    return this.codeSystem.reservedCodeSpaces().length > 0 ?
+      "The code system '" + this.system() + "' reserves code spaces for users to define their own codes, and those codes are not in the expansion" : null;
+  }
+
   /**
    * The provider for a CodeSystem resource: a FhirCodeSystemProvider, or the subclass
    * registered for its url. Always use this rather than the constructor.
@@ -315,6 +336,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
@@ -421,6 +482,16 @@ class FhirCodeSystemProvider extends BaseCSServices {
       };
     }
 
+    // a code the code system doesn't define, in a code space it reserves for users to define their own
+    // codes, is a valid code. An extension-codes supplement in scope may define it (display etc); if
+    // none does, it has no display
+    if (this.codeSystem.isInReservedCodeSpace(code)) {
+      return {
+        context: new FhirCodeSystemProviderContext(code, { code: code }, true),
+        message: null
+      };
+    }
+
     return {
       context: null,
       message: undefined
@@ -468,6 +539,11 @@ class FhirCodeSystemProvider extends BaseCSServices {
     if (supplementDisplay) {
       return supplementDisplay;
     }
+    // a code in the reserved code space has the display an extension-codes supplement gives it,
+    // whatever languages were asked for - or, if none does, the code space's default display
+    if (ctxt.reserved) {
+      return this._extensionCodeDisplay(ctxt.code) || this.codeSystem.reservedCodeSpaceFor(ctxt.code).defaultDisplay;
+    }
 
     // Use language-aware display logic
     if (this.opContext.langs && !this.opContext.langs.isEnglishOrNothing()) {
@@ -524,14 +600,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;
       }
@@ -735,8 +807,17 @@ class FhirCodeSystemProvider extends BaseCSServices {
       }
     }
 
+    // a code in the reserved code space that no extension-codes supplement in scope gives a display has
+    // its code space's default display ('User-assigned'). It is a placeholder, so (as for ISO 3166's
+    // user-assigned codes) another display is not wrong - see validate.js checkDisplays
+    if (ctxt.reserved && !this._extensionCodeDisplay(ctxt.code)) {
+      displays.userDefined = true;
+      const displayLang = this.defaultLanguage ? this.defaultLanguage.toString() : null;
+      displays.addDesignation(true, 'active', displayLang, CodeSystem.makeUseForDisplay(), this.codeSystem.reservedCodeSpaceFor(ctxt.code).defaultDisplay);
+    }
+
     // Add supplement designations
-    this._listSupplementDesignations(ctxt.code, displays);
+    this._listSupplementDesignations(ctxt.code, displays, ctxt.reserved);
   }
 
   /**
@@ -1093,9 +1174,10 @@ class FhirCodeSystemProvider extends BaseCSServices {
    * @param {boolean} iterate - True if results will be iterated
    * @returns {FilterExecutionContext} Filter context
    */
-  async getPrepContext(iterate) {
-    
-    return new FilterExecutionContext(iterate);
+  async getPrepContext(iterate, languages = null) {
+    const result = new FilterExecutionContext(iterate);
+    result.languages = languages; // what the request asked for (a text filter searches one language)
+    return result;
   }
 
   /**
@@ -1122,7 +1204,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     }
     // Supported hierarchy filters
     if ((prop === 'concept' || prop === 'code') &&
-      ['is-a', 'descendent-of', 'is-not-a', 'child-of', 'in', '=', 'regex'].includes(op)) {
+      ['is-a', 'descendent-of', 'descendent-leaf', 'is-not-a', 'child-of', 'in', 'not-in', '=', 'regex'].includes(op)) {
       return true;
     }
 
@@ -1265,13 +1347,16 @@ class FhirCodeSystemProvider extends BaseCSServices {
     const results = new FhirCodeSystemProviderFilterContext();
     const searchTerm = foldSearchText(filter.filter);
     const searchWords = searchTerm.split(/[^\p{L}\p{N}]+/u).filter(word => word !== '');
+    // the display, definition and designations in one language only (see searchLanguage),
+    // with the designations that supplements in use give in that language
+    const lang = this.searchLanguage(filterContext.languages);
 
     // Search through all concepts
     const allConcepts = this.codeSystem.getAllConcepts();
 
     for (const concept of allConcepts) {
       this.opContext.deadCheck('cs:searchFilter');
-      const rating = this._calculateSearchRating(concept, searchTerm, searchWords);
+      const rating = this._calculateSearchRating(concept, searchTerm, searchWords, lang);
       if (rating > 0) {
         results.add(concept, rating);
       }
@@ -1298,8 +1383,20 @@ class FhirCodeSystemProvider extends BaseCSServices {
    * @returns {number} Rating (0 = no match, higher = better match)
    * @private
    */
-  _calculateSearchRating(concept, searchTerm, searchWords) {
-    const texts = conceptSearchTexts(concept);
+  _calculateSearchRating(concept, searchTerm, searchWords, lang = null) {
+    const all = conceptSearchTexts(concept);
+    let texts = all;
+    if (lang) {
+      const csLang = this.defLang();
+      const inLang = CodeSystemProvider.inSearchLanguage(csLang, lang);
+      texts = {
+        code: all.code,
+        display: inLang ? all.display : null,
+        definition: inLang ? all.definition : null,
+        designations: all.designations.filter(d => CodeSystemProvider.inSearchLanguage(d.language, lang, csLang))
+          .concat(this.#supplementSearchTexts(concept.code, lang))
+      };
+    }
     const display = texts.display;
     let rating = 0;
 
@@ -1350,6 +1447,55 @@ class FhirCodeSystemProvider extends BaseCSServices {
     return rating;
   }
 
+  /**
+   * As for any code system (CodeSystemProvider.searchLanguage), but whether there is text in
+   * a language is decided by what the code system actually has: its own language, a designation
+   * in it, or a supplement's (hasAnyDisplays says yes to English whatever the code system's
+   * language is)
+   */
+  searchLanguage(languages) {
+    for (const lang of (languages && languages.languages) || []) {
+      if (lang && lang.language && lang.code !== '*' && this.#hasSearchText(lang)) {
+        return lang;
+      }
+    }
+    return new Language(this.defLang());
+  }
+
+  #hasSearchText(lang) {
+    const csLang = this.defLang();
+    if (CodeSystemProvider.inSearchLanguage(csLang, lang)) {
+      return true;
+    }
+    for (const concept of this.codeSystem.getAllConcepts()) {
+      if ((concept.designation || []).some(d => d.value && CodeSystemProvider.inSearchLanguage(d.language, lang, csLang))) {
+        return true;
+      }
+    }
+    return this._hasSupplementText(lang);
+  }
+
+  // the displays and designations that supplements in use give a code, in the search language
+  #supplementSearchTexts(code, lang) {
+    const result = [];
+    for (const supplement of this.supplements || []) {
+      const concept = supplement.getConceptByCode(code);
+      if (!concept) {
+        continue;
+      }
+      const suppLang = supplement.jsonObj.language || this.defLang();
+      if (concept.display && CodeSystemProvider.inSearchLanguage(suppLang, lang)) {
+        result.push(searchText(concept.display));
+      }
+      for (const d of concept.designation || []) {
+        if (d.value && CodeSystemProvider.inSearchLanguage(d.language, lang, suppLang)) {
+          result.push(searchText(d.value));
+        }
+      }
+    }
+    return result;
+  }
+
   /**
    * Execute a value set filter
    * @param {FilterExecutionContext} filterContext - Filter context
@@ -1399,9 +1545,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);
       }
 
@@ -1439,7 +1586,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
    */
   _isCacheableFilter(prop, op) {
     if (prop === 'concept' || prop === 'code') {
-      return op === 'is-a' || op === 'descendent-of' || op === 'is-not-a' || op === 'regex';
+      return op === 'is-a' || op === 'descendent-of' || op === 'descendent-leaf' || op === 'is-not-a' || op === 'regex';
     }
     if (prop === 'child' && op === 'exists') {
       return true;
@@ -1478,6 +1625,19 @@ class FhirCodeSystemProvider extends BaseCSServices {
       // Find all descendants of the specified code
       const includeRoot = (op === 'is-a');
       await this._addDescendants(results, value, includeRoot);
+    } else if (op === 'descendent-leaf') {
+      // R5: the descendants that have no children of their own
+      if (this.codeSystem.getConceptByCode(value)) {
+        for (const code of this.codeSystem.getDescendants(value)) {
+          this.opContext.deadCheck('cs:conceptFilter:descendent-leaf');
+          if (code !== value && this.codeSystem.getChildren(code).length === 0) {
+            const concept = this.codeSystem.getConceptByCode(code);
+            if (concept) {
+              results.add(concept, 0);
+            }
+          }
+        }
+      }
     } else if (op === 'child-of') {
       // Find all descendants of the specified code
       await this._addChildren(results, value);
@@ -1507,6 +1667,20 @@ class FhirCodeSystemProvider extends BaseCSServices {
         }
       }
     }
+    else if (op === 'not-in') {
+      // Every code except the listed ones (comma separated) - their descendants are not excluded
+      const excludeSet = new Set(value.split(',').map(c => c.trim()));
+      const allCodes = this.codeSystem.getAllCodes();
+      for (const code of allCodes) {
+        this.opContext.deadCheck('cs:conceptFilter:not-in');
+        if (!excludeSet.has(code)) {
+          const concept = this.codeSystem.getConceptByCode(code);
+          if (concept) {
+            results.add(concept, 0);
+          }
+        }
+      }
+    }
     else if (op === '=') {
       // Exact match
       const concept = this.codeSystem.getConceptByCode(value);
@@ -1517,7 +1691,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     else if (op === 'regex') {
       // Regular expression match
       try {
-        const regex = regexUtilities.compile('^' + value + '$');
+        const regex = regexUtilities.compile('^(?:' + value + ')$'); // the whole value: a|b is ^(?:a|b)$, not ^a|b$
         const allCodes = this.codeSystem.getAllCodes();
         for (const code of allCodes) {
           this.opContext.deadCheck('cs:conceptFilter:regex');
@@ -1665,7 +1839,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     }
     else if (op === 'regex') {
       try {
-        const regex = regexUtilities.compile('^' + value + '$');
+        const regex = regexUtilities.compile('^(?:' + value + ')$'); // the whole value: a|b is ^(?:a|b)$, not ^a|b$
         return properties.some(p => regex.test(this._getPropertyValue(p)));
       } catch (error) {
         return false;
@@ -1705,13 +1879,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-currency.js

@@ -245,7 +245,7 @@ class Iso4217Services extends CodeSystemProvider {
         return concept;
       }
     }
-    return `Code '${code}' not found in filter set`;
+    return null;
   }
 
   async filterCheck(filterContext, set, concept) {