fhirsmith 0.3.0 → 0.5.0

package/tx/cs/cs-omop.js

@@ -1,9 +1,10 @@
 const sqlite3 = require('sqlite3').verbose();
 const assert = require('assert');
 const { CodeSystem } = require('../library/codesystem');
-const { CodeSystemProvider, FilterExecutionContext, CodeSystemFactoryProvider } = require('./cs-api');
+const { FilterExecutionContext, CodeSystemFactoryProvider } = require('./cs-api');
 const {validateOptionalParameter, validateArrayParameter} = require("../../library/utilities");
 const {ConceptMap} = require("../library/conceptmap");
+const {BaseCSServices} = require("./cs-base");
 
 class OMOPConcept {
   constructor(code, display, domain, conceptClass, standard, vocabulary) {
@@ -126,7 +127,7 @@ function getLang(langConcept) {
   return 'en'; // default
 }
 
-class OMOPServices extends CodeSystemProvider {
+class OMOPServices extends BaseCSServices {
   constructor(opContext, supplements, db, sharedData) {
     super(opContext, supplements);
     this.db = db;
@@ -270,16 +271,16 @@ class OMOPServices extends CodeSystemProvider {
     }
 
     // Add basic properties
-    if (this.#hasProp(props, 'domain-id', true)) {
+    if (this._hasProp(props, 'domain-id', true)) {
       this.#addCodeProperty(params, 'property', 'domain-id', ctxt.domain);
     }
-    if (this.#hasProp(props, 'concept-class-id', true)) {
+    if (this._hasProp(props, 'concept-class-id', true)) {
       this.#addCodeProperty(params, 'property', 'concept-class-id', ctxt.conceptClass);
     }
-    if (this.#hasProp(props, 'standard-concept', true)) {
+    if (this._hasProp(props, 'standard-concept', true)) {
       this.#addCodeProperty(params, 'property', 'standard-concept', ctxt.standard);
     }
-    if (this.#hasProp(props, 'vocabulary-id', true)) {
+    if (this._hasProp(props, 'vocabulary-id', true)) {
       this.#addStringProperty(params, 'property', 'vocabulary-id', ctxt.vocabulary);
     }
 
@@ -304,26 +305,26 @@ class OMOPServices extends CodeSystemProvider {
         if (err) {
           reject(err);
         } else if (row) {
-          if (this.#hasProp(props, 'concept-class-concept-id', true)) {
+          if (this._hasProp(props, 'concept-class-concept-id', true)) {
             this.#addCodeProperty(params, 'property', 'concept-class-concept-id', row.concept_class_id);
           }
-          if (this.#hasProp(props, 'domain-concept-id', true)) {
+          if (this._hasProp(props, 'domain-concept-id', true)) {
             this.#addCodeProperty(params, 'property', 'domain-concept-id', row.domain_id);
           }
-          if (this.#hasProp(props, 'valid-start-date', true) && row.valid_start_date) {
+          if (this._hasProp(props, 'valid-start-date', true) && row.valid_start_date) {
             this.#addDateProperty(params, 'property', 'valid-start-date', row.valid_start_date);
           }
-          if (this.#hasProp(props, 'valid-end-date', true) && row.valid_end_date) {
+          if (this._hasProp(props, 'valid-end-date', true) && row.valid_end_date) {
             this.#addDateProperty(params, 'property', 'valid-end-date', row.valid_end_date);
           }
-          if (this.#hasProp(props, 'source-concept-code', true) && row.concept_code && getUri(row.vocabulary_id)) {
+          if (this._hasProp(props, 'source-concept-code', true) && row.concept_code && getUri(row.vocabulary_id)) {
             this.#addCodingProperty(params, 'property', 'source-concept-code',
               getUriOrError(row.vocabulary_id), row.concept_code);
           }
-          if (this.#hasProp(props, 'vocabulary-concept-id', true)) {
+          if (this._hasProp(props, 'vocabulary-concept-id', true)) {
             this.#addCodeProperty(params, 'property', 'vocabulary-concept-id', row.vocabulary_id);
           }
-          if (this.#hasProp(props, 'invalid-reason', true) && row.invalid_reason) {
+          if (this._hasProp(props, 'invalid-reason', true) && row.invalid_reason) {
             this.#addStringProperty(params, 'property', 'invalid-reason', row.invalid_reason);
           }
           resolve();
@@ -353,7 +354,7 @@ class OMOPServices extends CodeSystemProvider {
         } else {
           for (const row of rows) {
             seenConcepts.add(row.concept_id);
-            if (this.#hasProp(props, row.relationship_id, true)) {
+            if (this._hasProp(props, row.relationship_id, true)) {
               this.#addCodingProperty(params, 'property', row.relationship_id,
                 this.system(), row.concept_id, row.concept_name);
             }
@@ -379,7 +380,7 @@ class OMOPServices extends CodeSystemProvider {
         } else {
           for (const row of rows) {
             if (!seenConcepts.has(row.concept_id)) {
-              if (this.#hasProp(props, row.reverse_relationship_id, true)) {
+              if (this._hasProp(props, row.reverse_relationship_id, true)) {
                 this.#addCodingProperty(params, 'property', row.reverse_relationship_id,
                   this.system(), row.concept_id, row.concept_name);
               }

package/tx/cs/cs-rxnorm.js

@@ -140,6 +140,28 @@ class RxNormServices extends CodeSystemProvider {
     return false; // RxNorm codes are not abstract
   }
 
+  async getStatus(context) {
+
+    const ctxt = await this.#ensureContext(context);
+
+    if (ctxt && ctxt.archived) {
+      return 'archived';
+    }
+
+    // Check suppress flag
+    return new Promise((resolve, reject) => {
+      const sql = `SELECT suppress FROM rxnconso WHERE ${this.getCodeField()} = ? AND SAB = ? AND TTY <> 'SY'`;
+
+      this.db.get(sql, [ctxt.code, this.getSAB()], (err, row) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(row ? row.suppress === '1' ? 'suppressed' : null : null);
+        }
+      });
+    });
+  }
+
   async isInactive(context) {
     
     const ctxt = await this.#ensureContext(context);
@@ -527,7 +549,7 @@ class RxNormServices extends CodeSystemProvider {
         if (err) {
           reject(err);
         } else if (!row) {
-          resolve(`Code ${code} is not in the specified filter`);
+          resolve(null);
         } else {
           const concept = new RxNormConcept(row[this.getCodeField()], row.STR);
           resolve(concept);

package/tx/cs/cs-snomed.js

@@ -1,4 +1,4 @@
-const { CodeSystemProvider, CodeSystemContentMode, Designation, CodeSystemFactoryProvider} = require('./cs-api');
+const { CodeSystemContentMode, CodeSystemFactoryProvider} = require('./cs-api');
 const {
   SnomedStrings, SnomedWords, SnomedStems, SnomedReferences,
   SnomedDescriptions, SnomedDescriptionIndex, SnomedConceptList,
@@ -9,6 +9,8 @@ const {
   SnomedExpressionServices, SnomedExpression, SnomedConcept,
   SnomedExpressionParser, NO_REFERENCE, SnomedServicesRenderOption
 } = require('../sct/expressions');
+const {DesignationUse} = require("../library/designations");
+const {BaseCSServices} = require("./cs-base");
 
 // Context kinds matching Pascal enum
 const SnomedProviderContextKind = {
@@ -75,6 +77,13 @@ class SnomedFilterContext {
     this.matches = [];
     this.members = [];
     this.descendants = [];
+    this.expressions = undefined; // special use
+  }
+}
+
+class SnomedPrep {
+  constructor() {
+    this.filters = [];
   }
 }
 
@@ -289,6 +298,19 @@ class SnomedServices {
     }
   }
 
+  getConceptRelationships(reference) {
+    try {
+      const concept = this.concepts.getConcept(reference);
+      const relRef = concept.outbounds;
+
+      if (relRef === 0) return [];
+
+      return this.refs.getReferences(relRef) || [];
+    } catch (error) {
+      return [];
+    }
+  }
+
   getConceptRefSet(conceptIndex, byName = false) {
     for (let i = 0; i < this.refSetIndex.count(); i++) {
       const refSet = this.refSetIndex.getReferenceSet(i);
@@ -352,7 +374,7 @@ class SnomedServices {
     const result = new SnomedFilterContext();
 
     // Simplified search - in full implementation would use stemming and word indexes
-    const searchTerms = searchText.toLowerCase().split(/\s+/);
+    const searchTerms = searchText.filter.toLowerCase().split(/\s+/);
     const matches = [];
 
     // Search through all concepts
@@ -423,7 +445,7 @@ class SnomedServices {
 /**
  * SNOMED CT Code System Provider
  */
-class SnomedProvider extends CodeSystemProvider {
+class SnomedProvider extends BaseCSServices {
   constructor(opContext, supplements, snomedServices) {
     super(opContext, supplements);
     this.sct = snomedServices;
@@ -501,7 +523,7 @@ class SnomedProvider extends CodeSystemProvider {
     if (disp) return disp;
 
     if (ctxt.isComplex()) {
-      return this.sct.expressionServices.displayExpression(ctxt.expression);
+      return this.sct.expressionServices.renderExpression(ctxt.expression, SnomedServicesRenderOption.FillMissing);
     } else {
       return this.sct.getDisplayName(ctxt.getReference(), this.sct.defaultLanguage);
     }
@@ -552,7 +574,7 @@ class SnomedProvider extends CodeSystemProvider {
         // For complex expressions, just add the display
         const display = await this.display(context);
         if (display) {
-          displays.addDesignation(true, 'active', new Designation('en-US', null, display));
+          displays.addDesignation(true, 'active', 'en-US', DesignationUse.PREFERRED, display);
         }
       } else {
         // Get all designations for the concept
@@ -602,8 +624,6 @@ class SnomedProvider extends CodeSystemProvider {
 
   // Lookup methods
   async locate(code) {
-    
-
     if (!code) return { context: null, message: 'Empty code' };
 
     const conceptId = this.sct.stringToIdOrZero(code);
@@ -620,7 +640,7 @@ class SnomedProvider extends CodeSystemProvider {
       } catch (error) {
         return {
           context: null,
-          message: `Code ${code} is not a valid SNOMED CT Term, and could not be parsed as an expression (${error.message})`
+          message: Number.isInteger(code) ? undefined : `Not a valid expression: ${error.message}`
         };
       }
     } else {
@@ -639,6 +659,19 @@ class SnomedProvider extends CodeSystemProvider {
     }
   }
 
+  async incompleteValidationMessage(context) {
+
+    const ctxt = await this.#ensureContext(context);
+
+    if (!ctxt) return null;
+
+    if (ctxt.isComplex()) {
+      return "The expression is grammatically correct and the concepts are valid, but the expression has not been checked against the SNOMED CT concept model (MRCM)";
+    } else {
+      return null;
+    }
+  }
+
   async locateIsA(code, parent, disallowParent = false) {
     
 
@@ -699,8 +732,6 @@ class SnomedProvider extends CodeSystemProvider {
   }
 
   async nextContext(iteratorContext) {
-    
-
     if (iteratorContext.current >= iteratorContext.total) {
       return null;
     }
@@ -711,16 +742,74 @@ class SnomedProvider extends CodeSystemProvider {
     return SnomedExpressionContext.fromReference(key);
   }
 
-  // Filter support
-  async doesFilter(prop, op, value) {
-    
+  async extendLookup(context, props, params) {
+    const ctxt = await this.#ensureContext(context);
+    if (ctxt) {
+      if (!(ctxt instanceof SnomedExpressionContext) || ctxt.expression?.concepts.length == 1) {
+        const parents = this.sct.getConceptParents(ctxt.getReference());
+        for (let parentRef of parents) {
+          const code = this.sct.getConceptId(parentRef);
+          const description = this.sct.getDisplayName(parentRef);
+          this._addCodeProperty(params, 'property', 'parent', code, null, description);
+        }
 
+        const children = this.sct.getConceptChildren(ctxt.getReference());
+        for (let childRef of children) {
+          const code = this.sct.getConceptId(childRef);
+          const description = this.sct.getDisplayName(childRef);
+          this._addCodeProperty(params, 'property', 'child', code, null, description);
+        }
+
+        const relationships = this.sct.getConceptRelationships(ctxt.getReference());
+        let set = new Set();
+        for (let relationshipRef of relationships) {
+          const relationship = this.sct.relationships.getRelationship(relationshipRef);
+          const relType = this.sct.getConceptId(relationship.relType);
+          if (relType != '116680003') {
+            const relTypeD = this.sct.getDisplayName(relationship.relType);
+            const code = this.sct.getConceptId(relationship.target);
+            const description = this.sct.getDisplayName(relationship.target);
+            if (!set.has(relType + ":" + code)) {
+              set.add(relType + ":" + code);
+              let p = this._addCodeProperty(params, 'property', relType, code, null, description);
+              p.part.push({name: 'code-display', valueString: relTypeD});
+            }
+          }
+        }
+      }
+      if (ctxt instanceof SnomedExpressionContext) {
+        // ignore concepts for now, but list refinements and refinement groups
+        for (const refinement of ctxt.expression.refinements) {
+          const codeA = refinement.name.code;
+          const codeB = refinement.value.describe();
+          const description = await this.display(codeB);
+          let p = this._addCodeProperty(params, 'property', codeA, codeB, null, description);
+          p.part.push({name: 'code-display', valueString: await this.display(codeA)});
+        }
+        for (const refinementGroup of ctxt.expression.refinementGroups) {
+          for (const refinement of refinementGroup.refinements) {
+            const codeA = refinement.name.code;
+            const codeB = refinement.value.describe();
+            const description = await this.display(codeB);
+            let p = this._addCodeProperty(params, 'property', codeA, codeB, null, description);
+            p.part.push({name: 'code-display', valueString: await this.display(codeA)});
+          }
+        }
+      }
+    }
+  }
+
+    // Filter support
+  async doesFilter(prop, op, value) {
     if (prop === 'concept') {
       const id = this.sct.stringToIdOrZero(value);
       if (id !== 0n && ['=', 'is-a', 'descendent-of', 'in'].includes(op)) {
         return this.sct.conceptExists(value);
       }
     }
+    if (prop == 'expressions' && op == '=' && ['true', 'false'].includes(value)) {
+      return true;
+    }
 
     return false;
   }
@@ -728,11 +817,10 @@ class SnomedProvider extends CodeSystemProvider {
   // eslint-disable-next-line no-unused-vars
   async getPrepContext(iterate) {
     
-    return {}; // Simple filter context
+    return new SnomedPrep(); // Simple filter context
   }
 
   async filter(filterContext, prop, op, value) {
-    
 
     if (prop === 'concept') {
       const id = this.sct.stringToIdOrZero(value);
@@ -741,30 +829,52 @@ class SnomedProvider extends CodeSystemProvider {
       }
 
       switch (op) {
-        case '=':
-          return this.sct.filterEquals(id);
-        case 'is-a':
-          return this.sct.filterIsA(id, true);
-        case 'descendent-of':
-          return this.sct.filterIsA(id, false);
-        case 'in':
-          return this.sct.filterIn(id);
+        case '=': {
+          filterContext.filters.push(this.sct.filterEquals(id));
+          return null;
+        }
+        case 'is-a': {
+          filterContext.filters.push(this.sct.filterIsA(id, true));
+          return null;
+        }
+        case 'descendent-of': {
+          filterContext.filters.push(this.sct.filterIsA(id, false));
+          return null;
+        }
+        case 'in': {
+          filterContext.filters.push(this.sct.filterIn(id));
+          return null;
+        }
         default:
           throw new Error(`Unsupported filter operation: ${op}`);
       }
     }
 
+    if (prop == 'expressions' && op == '=') {
+      const filter = new SnomedFilterContext();
+      filter.expressions = value == 'true';
+      filterContext.filters.push(filter);
+      return null;
+    }
+
     throw new Error(`Unsupported filter property: ${prop}`);
   }
 
   async executeFilters(filterContext) {
-    
-    return [filterContext];
+    return filterContext.filters;
   }
 
-  async filterSize(filterContext, set) {
-    
+  // eslint-disable-next-line no-unused-vars
+  async filtersNotClosed(filterContext) {
+    for (let filter of filterContext.filters) {
+      if (filter.expressions != undefined && !filter.expressions) {
+        return false;
+      }
+    }
+    return true;
+  }
 
+  async filterSize(filterContext, set) {
     if (set.matches && set.matches.length > 0) {
       return set.matches.length;
     } else if (set.members && set.members.length > 0) {
@@ -777,7 +887,6 @@ class SnomedProvider extends CodeSystemProvider {
   }
 
   async filterMore(filterContext, set) {
-    
     set.cursor = set.cursor || 0;
 
     const size = await this.filterSize(filterContext, set);
@@ -785,8 +894,6 @@ class SnomedProvider extends CodeSystemProvider {
   }
 
   async filterConcept(filterContext, set) {
-    
-
     const size = await this.filterSize(filterContext, set);
     if (set.cursor >= size) {
       return null;
@@ -808,7 +915,6 @@ class SnomedProvider extends CodeSystemProvider {
   }
 
   async filterLocate(filterContext, set, code) {
-    
 
     const conceptResult = await this.locate(code);
     if (!conceptResult.context) {
@@ -816,9 +922,7 @@ class SnomedProvider extends CodeSystemProvider {
     }
 
     const ctxt = conceptResult.context;
-    if (ctxt.isComplex()) {
-      return 'Complex expressions not supported in filters';
-    }
+
 
     const reference = ctxt.getReference();
     let found = false;
@@ -834,19 +938,18 @@ class SnomedProvider extends CodeSystemProvider {
     if (found) {
       return ctxt;
     } else {
-      return `Code ${code} is not in the specified filter`;
+      return null;
     }
   }
 
   async filterCheck(filterContext, set, concept) {
-    
-
     if (!(concept instanceof SnomedExpressionContext)) {
       return false;
     }
 
-    if (concept.isComplex()) {
-      return false;
+    if (set.expressions != undefined) {
+      let b = set.expressions || !concept.isComplex();
+      return b;
     }
 
     const reference = concept.getReference();
@@ -972,8 +1075,148 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
       return null;
     }
   }
-  // eslint-disable-next-line no-unused-vars
+
+
+  /**
+   * Build an implicit SNOMED CT ValueSet from a URL.
+   *
+   * Handles the following URL patterns:
+   *   http://snomed.info/sct?fhir_vs                    – all of SNOMED CT
+   *   http://snomed.info/sct?fhir_vs=refset             – list of reference sets
+   *   http://snomed.info/sct?fhir_vs=refset/<id>        – members of a reference set
+   *   http://snomed.info/sct?fhir_vs=isa/<id>           – concept and descendants
+   *
+   * The URL may optionally include edition and/or version segments:
+   *   http://snomed.info/sct/<edition>?fhir_vs...
+   *   http://snomed.info/sct/<edition>/version/<ver>?fhir_vs...
+   *
+   * @param {string} url - The ValueSet URL to resolve
+   * @returns {object|null} A FHIR ValueSet JSON object, or null if the URL is not recognised
+   */
   async buildKnownValueSet(url, version) {
+    if (!url.startsWith("http://snomed.info/sct")) {
+      return null;
+    }
+    if (version != null && !this.version().startsWith(version)) {
+      return null;
+    }
+
+    const URI_SNOMED = 'http://snomed.info/sct';
+
+    // Extract the query portion (?fhir_vs...) if this is a recognised SNOMED implicit VS URL
+    let id = null;
+    const qIdx = url.indexOf('?');
+    if (qIdx === -1) {
+      return null;
+    }
+
+    if (url.startsWith('http://snomed.info/sct?fhir_vs') ||
+      url.startsWith(`http://snomed.info/sct/${this.edition}?fhir_vs`) ||
+      url.startsWith(`http://snomed.info/sct/${this.edition}/version/${this.version}?fhir_vs`)) {
+      id = url.substring(qIdx);
+    } else {
+      return null;
+    }
+
+    const now = new Date().toISOString();
+
+    if (id === '?fhir_vs=refset') {
+      // List of all reference sets
+      const concepts = [];
+      for (let i = 0; i < this.refSetIndex.count; i++) {
+        const code = this.refSetIndex.getReferenceSetCode(i);
+        concepts.push({code: this.getConceptId(code)});
+      }
+      return {
+        resourceType: 'ValueSet',
+        url,
+        status: 'active',
+        version: this.versionDate,
+        name: 'SNOMEDCTReferenceSetList',
+        title: 'SNOMED CT Reference Set List',
+        description: 'Reference Sets defined in this SNOMED-CT version',
+        date: now,
+        compose: {
+          include: [{
+            system: URI_SNOMED,
+            concept: concepts,
+          }],
+        },
+      };
+    }
+
+    if (id === '?fhir_vs') {
+      // All of SNOMED CT
+      return {
+        resourceType: 'ValueSet',
+        url,
+        status: 'active',
+        version: this.versionDate,
+        name: 'ALLSNOMEDCT',
+        title: 'SNOMED CT Reference Set (All of SNOMED CT)',
+        description: 'SNOMED CT Reference Set (All of SNOMED CT)',
+        date: now,
+        compose: {
+          include: [{
+            system: URI_SNOMED,
+          }],
+        },
+      };
+    }
+
+    if (id.startsWith('?fhir_vs=refset/')) {
+      const refsetId = id.substring(16);
+      if (!this.referenceSetExists(refsetId)) {
+        return null;
+      }
+      return {
+        resourceType: 'ValueSet',
+        url,
+        status: 'active',
+        version: this.versionDate,
+        name: 'SNOMEDCTRefSet' + refsetId,
+        title: 'SNOMED CT Reference Set ' + refsetId,
+        description: this.getDisplayName(refsetId, ''),
+        date: now,
+        compose: {
+          include: [{
+            system: URI_SNOMED,
+            filter: [{
+              property: 'concept',
+              op: 'in',
+              value: refsetId,
+            }],
+          }],
+        },
+      };
+    }
+
+    if (id.startsWith('?fhir_vs=isa/')) {
+      const conceptId = id.substring(13);
+      if (!this.conceptExists(conceptId)) {
+        return null;
+      }
+      return {
+        resourceType: 'ValueSet',
+        url,
+        status: 'active',
+        version: this.versionDate,
+        name: 'SNOMEDCTConcept' + conceptId,
+        title: 'SNOMED CT Concept ' + conceptId + ' and descendants',
+        description: 'All Snomed CT concepts for ' + this.getDisplayName(conceptId, ''),
+        date: now,
+        compose: {
+          include: [{
+            system: URI_SNOMED,
+            filter: [{
+              property: 'concept',
+              op: 'is-a',
+              value: conceptId,
+            }],
+          }],
+        },
+      };
+    }
     return null;
   }