fhirsmith 0.17.0 → 0.18.1

package/tx/cs/cs-api.js

@@ -67,19 +67,89 @@ class CodeSystemProvider {
    */
 
   /**
-   * The display name of the code system - what $lookup reports as its name parameter, and
-   * what a person reads. Every provider should override this; the fallback is the
-   * versioned uri, which is not a name, and a provider that forgets ends up reporting
+   * The name of the code system (CodeSystem.name, or the provider's equivalent). Every
+   * provider should override this; the fallback is the versioned uri, which is not a name,
+   * and a provider that forgets ends up reporting
    * "http://snomed.info/sct|http://snomed.info/sct/731000124108/version/20230301" where
    * the others report "LOINC".
+   * @returns {string} name of the code system
+   */
+  name() { return this.system() + (this.version() ? "|"+this.version() : "") }
+
+  /**
+   * What $lookup reports as its `name` parameter - "a display name for the code system".
+   * That is the title, translated into the request's language where the provider can,
+   * falling back to name(). Only $lookup uses this; everything else keeps using name().
+   * The default has no title to offer, so it is name().
+   * @param {Languages} [languages] - the request's working languages (displayLanguage, else
+   *   Accept-Language)
    * @returns {string} display name for the code system
    */
+  // eslint-disable-next-line no-unused-vars
+  lookupName(languages) { return this.name(); }
+
+  /**
+   * A second, shorter form of the code that some code systems also carry - ICD-11's short
+   * classification code (1A00) beside its code, the entity uri. $validate-code reports it as
+   * the classificationCode output parameter when the request used the code itself, and
+   * $expand always reports it as a contains property. Null (the default) when there is none.
+   * @param {CodeSystemProviderContext} context
+   * @returns {Promise<string|null>}
+   */
+  // eslint-disable-next-line no-unused-vars
+  async classificationCode(context) { return null; }
+
   /**
-   * @param {Languages} [languages] - the request's working languages, for a provider whose name
-   *   is translated; the default ignores them
+   * The classificationCode $validate-code reports for a code as it was given: by default the
+   * concept's classificationCode, whatever spelling was used.
+   * @param {CodeSystemProviderContext} context the concept the code located
+   * @param {string} code the code as given
+   * @returns {Promise<string|null>}
    */
   // eslint-disable-next-line no-unused-vars
-  name(languages) { return this.system() + (this.version() ? "|"+this.version() : "") }
+  async reportedClassificationCode(context, code) { return this.classificationCode(context); }
+
+  /**
+   * The code to put in an expansion for a concept the value set enumerated as `requested`.
+   * The default keeps the value set's own spelling; a code system whose normal form differs
+   * from what a value set may write (ICD-11: short code vs entity uri) returns code().
+   * @param {CodeSystemProviderContext} context
+   * @param {string} requested - the code as the value set wrote it
+   * @returns {Promise<string>}
+   */
+  // eslint-disable-next-line no-unused-vars
+  async expansionCode(context, requested) { return requested; }
+
+  /**
+   * Properties an expansion carries on every contains entry whatever the request asked
+   * for (each must also come back from properties()). None by default.
+   * @returns {string[]}
+   */
+  mandatoryExpansionProperties() { return []; }
+
+  /**
+   * Check the extensions on a Coding that this code system defines - ICD-11's
+   * classificationCode, say. Called by $validate-code once the coding's code has validated.
+   * Extensions the code system does not define are not its business, and are ignored.
+   *
+   * @param {Object} coding the Coding as given
+   * @param {CodeSystemProviderContext} context the concept the code located
+   * @returns {Promise<{index: number, msgId: string, params: string[]}[]>} one entry per problem,
+   *   naming the extension (its index in coding.extension) and the message; none by default
+   */
+  // eslint-disable-next-line no-unused-vars
+  async checkCodingExtensions(coding, context) { return []; }
+
+  /**
+   * Things $validate-code should say about a code that is valid - for a postcoordinated
+   * expression, say, a qualifier the grammar allows but a rule of the code system does not
+   * (ICD-11: two values on an axis that takes one).
+   *
+   * @param {CodeSystemProviderContext} context the concept the code located
+   * @returns {Promise<{severity: string, msgId: string, params: string[]}[]>} none by default
+   */
+  // eslint-disable-next-line no-unused-vars
+  async codeIssues(context) { return []; }
 
   /**
    * @returns {string} uri for the code system
@@ -540,9 +610,11 @@ class CodeSystemProvider {
    * @param {CodeSystemProviderContext} ctxt the context to add properties for
    * @param {string[]} props the properties requested
    * @param {Parameters} params the parameters response to add to
+   * @param {TxParameters} [txParams] the parsed request parameters, for providers whose output
+   *   depends on more than the property list (ICD-11's post-coordination-metadata)
    */
-
-  async extendLookup(ctxt, props, params) { }
+  // eslint-disable-next-line no-unused-vars
+  async extendLookup(ctxt, props, params, txParams) { }
 
   // procedure getCDSInfo(card : TCDSHookCard; langList : THTTPLanguageList; baseURL, code, display : String); virtual;
 
@@ -954,15 +1026,21 @@ class CodeSystemFactoryProvider {
   }
 
   /**
-   * build and return a known concept map from the URL, if there is one.
+   * Add any concept maps this code system implies for translating from source
+   * (a system URI, with the version of the source coding, which may be empty)
+   * to dest (a system URI, possibly with |version).
    *
-   * the conceptmap is never visible to a user; if it has an implicitSource, then
+   * The conceptmap is never visible to a user; if it has an internalSource, then
    * provider.getTranslations will be called when it's actually used
-   * @param url
-   * @param version
-   * @returns {ConceptMap}
+   * @param conceptMaps - the list to add to
+   * @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
    */
-  async findImplicitConceptMaps(conceptMaps, source, dest) {
+  // eslint-disable-next-line no-unused-vars
+  async findImplicitConceptMaps(conceptMaps, source, sourceVersion, dest, code = null) {
     return null;
   }
 

package/tx/cs/cs-cs.js

@@ -171,7 +171,35 @@ class FhirCodeSystemProviderFilterContext {
   }
 }
 
+// Code systems loaded as ordinary CodeSystem resources (from a package, or supplied by a
+// client) that need behaviour beyond the resource: a grammar, say. Keyed on the CodeSystem
+// url; the class extends FhirCodeSystemProvider, so the content still comes from the
+// resource. Required lazily, because the subclasses require this module.
+let specialisedProviders = null;
+
+function providerClassFor(url) {
+  if (specialisedProviders === null) {
+    specialisedProviders = new Map([
+      ['http://hl7.org/fhir/sid/icf', require('./cs-icf').IcfCodeSystemProvider]
+    ]);
+  }
+  return specialisedProviders.get(url) || FhirCodeSystemProvider;
+}
+
 class FhirCodeSystemProvider extends BaseCSServices {
+  /**
+   * The provider for a CodeSystem resource: a FhirCodeSystemProvider, or the subclass
+   * registered for its url. Always use this rather than the constructor.
+   * @param {OperationContext} opContext
+   * @param {CodeSystem} codeSystem
+   * @param {CodeSystem[]} supplements
+   * @returns {FhirCodeSystemProvider}
+   */
+  static create(opContext, codeSystem, supplements) {
+    const cls = providerClassFor(codeSystem.url);
+    return new cls(opContext, codeSystem, supplements);
+  }
+
   /**
    * @param {CodeSystem} codeSystem - The primary CodeSystem
    * @param {CodeSystem[]} supplements - Array of supplement CodeSystems
@@ -197,6 +225,33 @@ class FhirCodeSystemProvider extends BaseCSServices {
     return this.codeSystem.jsonObj.name || '';
   }
 
+  /**
+   * $lookup's display name: CodeSystem.title, translated where the resource carries a
+   * translation for one of the request's languages, else the title as written, else name.
+   * @param {Languages} [languages] - the request's working languages
+   * @returns {string}
+   */
+  lookupName(languages) {
+    const cs = this.codeSystem.jsonObj;
+    if (!cs.title) return this.name();
+    const base = (c) => String(c || '').toLowerCase().split('-')[0];
+    const translations = (cs._title?.extension || [])
+      .filter(e => e.url === 'http://hl7.org/fhir/StructureDefinition/translation')
+      .map(e => ({
+        lang: (e.extension || []).find(x => x.url === 'lang')?.valueCode,
+        content: (e.extension || []).find(x => x.url === 'content')?.valueString,
+      }))
+      .filter(t => t.lang && t.content);
+    for (const l of languages || []) {
+      const want = base(l.language || l.code);
+      if (!want) continue;
+      if (cs.language && base(cs.language) === want) return cs.title;
+      const t = translations.find(t => base(t.lang) === want);
+      if (t) return t.content;
+    }
+    return cs.title;
+  }
+
   /**
    * @returns {string} URI for the code system
    */
@@ -972,11 +1027,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 });
 
@@ -1747,7 +1808,7 @@ class FhirCodeSystemFactory extends CodeSystemFactoryProvider {
       });
     }
 
-    return new FhirCodeSystemProvider(opContext, codeSystem, supplements);
+    return FhirCodeSystemProvider.create(opContext, codeSystem, supplements);
   }
 
   // eslint-disable-next-line no-unused-vars