fhirsmith 0.9.6 → 0.9.7

package/tx/cs/cs-snomed.js

@@ -326,6 +326,20 @@ class SnomedServices {
     return 0;
   }
 
+  // Like getConceptRefSet, but distinguishes "this concept is not a reference
+  // set" (returns null) from "it is a reference set that happens to have no
+  // members" (returns a numeric membersByRef, which may be 0 or the
+  // MAGIC_NO_CHILDREN sentinel). Used by memberOf to reject non-refset operands.
+  _findRefSetMembersRef(conceptIndex) {
+    for (let i = 0; i < this.refSetIndex.count(); i++) {
+      const refSet = this.refSetIndex.getReferenceSet(i);
+      if (refSet.definition === conceptIndex) {
+        return refSet.membersByRef;
+      }
+    }
+    return null;
+  }
+
   // Filter support methods
   filterEquals(id) {
     const result = new SnomedFilterContext();
@@ -374,7 +388,7 @@ class SnomedServices {
   }
 
 
-  filterGeneralizes(id = true) {
+  filterGeneralizes(id = true, opContext = null) {
     const result = new SnomedFilterContext();
     const conceptResult = this.concepts.findConcept(id);
 
@@ -386,6 +400,7 @@ class SnomedServices {
     let parents = this.getConceptParents(conceptResult.index);
     let isNew = true;
     while (isNew) {
+      if (opContext) opContext.deadCheck('ecl:filterGeneralizes');
       isNew = false;
       let np = [];
       for (let parent of parents) {
@@ -485,7 +500,7 @@ class SnomedServices {
     }
     let result;
     try {
-      result = this._evalECLNode(ast);
+      result = this._evalECLNode(ast, opContext);
     } catch (err) {
       debugLog(err);
       throw new Issue('error', 'invalid', null, 'UNSUPPORTED_ECL', opContext.i18n.translate('UNSUPPORTED_ECL', opContext.langs, [eclExpression, err.message]), 'vs-invalid').handleAsOO(400);
@@ -495,7 +510,7 @@ class SnomedServices {
     // we actually need the full concept list, otherwise filterSize returns 0
     // and the iteration yields nothing. Materialise active concepts now.
     if (forIteration && result.eclWildcard && (!result.descendants || result.descendants.length === 0)) {
-      result.descendants = this._eclEnumerateActiveConcepts();
+      result.descendants = this._eclEnumerateActiveConcepts(opContext);
       delete result.eclWildcard;
     }
     return result;
@@ -506,10 +521,11 @@ class SnomedServices {
    * when the filter needs to be iterated over (e.g. $expand).
    * @returns {number[]}
    */
-  _eclEnumerateActiveConcepts = function () {
+  _eclEnumerateActiveConcepts = function (opContext) {
     const all = [];
     const n = this.concepts.count();
     for (let i = 0; i < n; i++) {
+      if (opContext) opContext.deadCheck('ecl:enumerateActiveConcepts');
       const concept = this.concepts.getConceptByCount(i);
       if ((concept.flags & 0x0F) === 0) { // active
         all.push(concept.index);
@@ -523,36 +539,37 @@ class SnomedServices {
    * @param {object} node
    * @returns {SnomedFilterContext}
    */
-  _evalECLNode = function (node) {
+  _evalECLNode = function (node, opContext) {
     if (!node) {
       throw new Error('ECL evaluation error: null AST node');
     }
+    if (opContext) opContext.deadCheck('ecl:evalNode');
 
     switch (node.type) {
 
       case ECLNodeType.SUB_EXPRESSION_CONSTRAINT:
-        return this._evalSubExpression(node);
+        return this._evalSubExpression(node, opContext);
 
       case ECLNodeType.COMPOUND_EXPRESSION_CONSTRAINT: {
-        const left = this._evalECLNode(node.left);
-        const right = this._evalECLNode(node.right);
+        const left = this._evalECLNode(node.left, opContext);
+        const right = this._evalECLNode(node.right, opContext);
         switch (node.operator) {
           case ECLNodeType.CONJUNCTION:
-            return this._eclIntersect(left, right);
+            return this._eclIntersect(left, right, opContext);
           case ECLNodeType.DISJUNCTION:
-            return this._eclUnion(left, right);
+            return this._eclUnion(left, right, opContext);
           case ECLNodeType.EXCLUSION:
-            return this._eclMinus(left, right);
+            return this._eclMinus(left, right, opContext);
           default:
             throw new Error(`Unsupported ECL compound operator: ${node.operator}`);
         }
       }
 
       case ECLNodeType.REFINED_EXPRESSION_CONSTRAINT:
-        return this._evalRefined(node);
+        return this._evalRefined(node, opContext);
 
       case ECLNodeType.DOTTED_EXPRESSION_CONSTRAINT:
-        return this._evalDotted(node);
+        return this._evalDotted(node, opContext);
 
       default:
         // Could be a bare concept reference or wildcard passed in directly
@@ -561,7 +578,7 @@ class SnomedServices {
             node.type === ECLNodeType.WILDCARD ||
             node.type === ECLNodeType.MEMBER_OF) {
           // Wrap it as if it came from a no-operator SubExpressionConstraint
-          return this._evalSubExpression({type: ECLNodeType.SUB_EXPRESSION_CONSTRAINT, operator: null, focus: node});
+          return this._evalSubExpression({type: ECLNodeType.SUB_EXPRESSION_CONSTRAINT, operator: null, focus: node}, opContext);
         }
         throw new Error(`Unsupported ECL node type: ${node.type}`);
     }
@@ -573,7 +590,7 @@ class SnomedServices {
    * @param {object} node
    * @returns {SnomedFilterContext}
    */
-  _evalSubExpression = function (node) {
+  _evalSubExpression = function (node, opContext) {
     const operator = node.operator; // an ECLTokenType string, or null
     const focus = node.focus;
 
@@ -590,16 +607,16 @@ class SnomedServices {
       if (operator) {
         throw new Error('ECL hierarchy operators combined with ^ (member-of) are not yet supported');
       }
-      return this._evalMemberOf(focus);
+      return this._evalMemberOf(focus, opContext);
     }
 
     // Plain concept reference
     if (focus.type === ECLNodeType.CONCEPT_REFERENCE) {
-      return this._evalConceptWithOperator(focus.conceptId, operator);
+      return this._evalConceptWithOperator(focus.conceptId, operator, opContext);
     }
 
     // Parenthesised sub-expression: focus is itself a full constraint node
-    return this._evalECLNode(focus);
+    return this._evalECLNode(focus, opContext);
   };
 
   /**
@@ -608,7 +625,7 @@ class SnomedServices {
    * @param {string|null} operator  ECLTokenType constant
    * @returns {SnomedFilterContext}
    */
-  _evalConceptWithOperator = function (conceptId, operator) {
+  _evalConceptWithOperator = function (conceptId, operator, opContext) {
     switch (operator) {
       case null:
       case undefined:
@@ -640,7 +657,7 @@ class SnomedServices {
 
         // ── Ancestors ──────────────────────────────────────────────────────────
       case ECLTokenType.ANCESTOR_OR_SELF_OF: {   // >>   self + all transitive ancestors
-        const result = this.filterGeneralizes(conceptId);
+        const result = this.filterGeneralizes(conceptId, opContext);
         const self = this.concepts.findConcept(conceptId);
         if (self.found && !result.descendants.includes(self.index)) {
           result.descendants.push(self.index);
@@ -649,7 +666,7 @@ class SnomedServices {
       }
 
       case ECLTokenType.ANCESTOR_OF: {           // >    all transitive ancestors, no self
-        return this.filterGeneralizes(conceptId);
+        return this.filterGeneralizes(conceptId, opContext);
       }
 
       case ECLTokenType.PARENT_OR_SELF_OF: {     // >>!  self + direct parents only
@@ -679,18 +696,54 @@ class SnomedServices {
   };
 
   /**
-   * Evaluate a MEMBER_OF node.  Only plain concept-reference refsets are
-   * supported; complex expressions inside ^ are not yet supported.
+   * Evaluate a MEMBER_OF (^) node. The operand may be any ECL expression: it is
+   * resolved to a set of candidate reference-set concepts, and the result is the
+   * union of their active concept members' referenced components.
+   *
+   * When the operand is a bare, explicitly-named concept that is not a reference
+   * set, this throws (the caller asked for an error in that case). When the
+   * operand is a computed expression (e.g. ^(<<900000000000455006)), concepts in
+   * the resolved set that are not reference sets are simply skipped — the closure
+   * of "Reference set" necessarily includes the non-refset parent itself.
+   *
    * @param {object} memberOfNode
+   * @param {OperationContext} [opContext]
    * @returns {SnomedFilterContext}
    */
-  _evalMemberOf = function (memberOfNode) {
-    const refSet = memberOfNode.refSet;
-    if (refSet.type !== ECLNodeType.CONCEPT_REFERENCE) {
-      throw new Error('ECL ^ (member-of) with a non-concept-reference refset is not yet supported');
+  _evalMemberOf = function (memberOfNode, opContext) {
+    const operandIsBareRef = memberOfNode.refSet.type === ECLNodeType.CONCEPT_REFERENCE;
+    const refsetConcepts = this._eclResolveSet(this._evalECLNode(memberOfNode.refSet, opContext), opContext);
+
+    const members = new Set();
+    for (const refsetIdx of refsetConcepts) {
+      if (opContext) opContext.deadCheck('ecl:memberOf');
+      const membersRef = this._findRefSetMembersRef(refsetIdx);
+      if (membersRef === null) {
+        if (operandIsBareRef) {
+          const code = this.concepts.getConceptId(refsetIdx).toString();
+          throw new Error(`The SNOMED CT Concept ${code} is not a reference set`);
+        }
+        continue; // computed operand: ignore concepts that aren't reference sets
+      }
+      if (membersRef === 0 || membersRef === 0xFFFFFFFF) {
+        continue; // a reference set with no members
+      }
+      const memberList = this.refSetMembers.getMembers(membersRef);
+      for (const m of memberList || []) {
+        // Concept referenced components only (kind 0). Description/other members
+        // are excluded, which also prevents the no-component sentinel (0xFFFFFFFF)
+        // from leaking in. The referenced concept may itself be INACTIVE and is
+        // still returned — "active" in the spec qualifies the membership row (and
+        // inactive rows are already dropped at import), not the referenced
+        // concept. The expansion marks/handles inactivity (e.g. activeOnly).
+        if (m.kind === 0) {
+          members.add(m.ref);
+        }
+      }
     }
-    // filterIn accepts a comma-separated string; a single ID works fine
-    return this.filterIn(refSet.conceptId);
+    const result = new SnomedFilterContext();
+    result.descendants = [...members];
+    return result;
   };
 
   /**
@@ -714,8 +767,8 @@ class SnomedServices {
    * @param {object} node
    * @returns {SnomedFilterContext}
    */
-  _evalDotted = function (node) {
-    let current = this._eclResolveSet(this._evalECLNode(node.base));
+  _evalDotted = function (node, opContext) {
+    let current = this._eclResolveSet(this._evalECLNode(node.base, opContext), opContext);
 
     for (const attr of node.attributes || []) {
       if (attr.type !== ECLNodeType.CONCEPT_REFERENCE) {
@@ -729,6 +782,7 @@ class SnomedServices {
 
       const next = new Set();
       for (const conceptIdx of current) {
+        if (opContext) opContext.deadCheck('ecl:dotted');
         const relIdxs = this.getConceptRelationships(conceptIdx);
         for (const relIdx of relIdxs) {
           const rel = this.relationships.getRelationship(relIdx);
@@ -758,11 +812,12 @@ class SnomedServices {
    * @param {object} node
    * @returns {SnomedFilterContext}
    */
-  _evalRefined = function (node) {
-    const baseSet = this._eclResolveSet(this._evalECLNode(node.base));
+  _evalRefined = function (node, opContext) {
+    const baseSet = this._eclResolveSet(this._evalECLNode(node.base, opContext), opContext);
     const matching = [];
     for (const conceptIdx of baseSet) {
-      if (this._refinementMatches(conceptIdx, node.refinement)) {
+      if (opContext) opContext.deadCheck('ecl:refined');
+      if (this._refinementMatches(conceptIdx, node.refinement, opContext)) {
         matching.push(conceptIdx);
       }
     }
@@ -778,17 +833,17 @@ class SnomedServices {
    * @param {object} refinement
    * @returns {boolean}
    */
-  _refinementMatches = function (conceptIdx, refinement) {
+  _refinementMatches = function (conceptIdx, refinement, opContext) {
     switch (refinement.type) {
       case ECLNodeType.ATTRIBUTE:
-        return this._attributeMatches(conceptIdx, refinement, null);
+        return this._attributeMatches(conceptIdx, refinement, null, opContext);
       case ECLNodeType.ATTRIBUTE_SET:
         for (const a of refinement.attributes) {
-          if (!this._refinementMatches(conceptIdx, a)) return false;
+          if (!this._refinementMatches(conceptIdx, a, opContext)) return false;
         }
         return true;
       case ECLNodeType.ATTRIBUTE_GROUP:
-        return this._attributeGroupMatches(conceptIdx, refinement);
+        return this._attributeGroupMatches(conceptIdx, refinement, opContext);
       default:
         throw new Error(`Unsupported refinement node type: ${refinement.type}`);
     }
@@ -804,7 +859,7 @@ class SnomedServices {
    * @param {number|null} groupFilter
    * @returns {boolean}
    */
-  _attributeMatches = function (conceptIdx, attr, groupFilter) {
+  _attributeMatches = function (conceptIdx, attr, groupFilter, opContext) {
     if (attr.reverse) {
       throw new Error('ECL reverse attributes (R) are not yet supported');
     }
@@ -821,7 +876,7 @@ class SnomedServices {
       throw new Error('ECL refinements only support plain concept-reference attribute names');
     }
 
-    const count = this._countAttributeMatches(conceptIdx, attr, groupFilter);
+    const count = this._countAttributeMatches(conceptIdx, attr, groupFilter, opContext);
 
     if (attr.cardinality) {
       return this._cardinalityAccepts(attr.cardinality, count);
@@ -838,25 +893,44 @@ class SnomedServices {
    * @param {number|null} groupFilter
    * @returns {number}
    */
-  _countAttributeMatches = function (conceptIdx, attr, groupFilter) {
-    const attrResult = this.concepts.findConcept(attr.name.conceptId);
-    if (!attrResult.found) {
-      throw new Error(`The SNOMED CT Concept ${attr.name.conceptId} is not known`);
+  _countAttributeMatches = function (conceptIdx, attr, groupFilter, opContext) {
+    // The attribute type and the value set depend only on the (static) AST node,
+    // not on the concept being tested, so resolve them once per refinement
+    // attribute and reuse across the whole base set. Without this memo the value
+    // expression is re-evaluated for every concept — and for a wildcard value
+    // (`= *`) the entire active-concept set is re-enumerated per concept —
+    // making refinement evaluation O(baseSet × valueExpr). The AST is parsed
+    // fresh per request, so memoising on the node is safe within a request.
+    let resolved = attr._eclResolved;
+    if (!resolved) {
+      const attrResult = this.concepts.findConcept(attr.name.conceptId);
+      if (!attrResult.found) {
+        throw new Error(`The SNOMED CT Concept ${attr.name.conceptId} is not known`);
+      }
+      resolved = {
+        attrTypeIdx: attrResult.index,
+        valueSet: new Set(this._eclResolveSet(this._evalECLNode(attr.comparison.value, opContext), opContext))
+      };
+      attr._eclResolved = resolved;
     }
-    const attrTypeIdx = attrResult.index;
-
-    const valueSet = new Set(this._eclResolveSet(this._evalECLNode(attr.comparison.value)));
+    const attrTypeIdx = resolved.attrTypeIdx;
+    const valueSet = resolved.valueSet;
 
     const relIdxs = this.getConceptRelationships(conceptIdx);
-    let count = 0;
+    // ECL cardinality counts non-redundant matching attributes — i.e. distinct
+    // matching values — not raw relationship rows. The same (type, value) can
+    // appear in multiple role groups; counting rows over-counts and makes e.g.
+    // [1..1] fail and [2..*] succeed for a concept with a single morphology.
+    const matchedTargets = new Set();
     for (const relIdx of relIdxs) {
+      if (opContext) opContext.deadCheck('ecl:countAttributeMatches');
       const rel = this.relationships.getRelationship(relIdx);
       if (!rel.active) continue;
       if (rel.relType !== attrTypeIdx) continue;
       if (groupFilter !== null && rel.group !== groupFilter) continue;
-      if (valueSet.has(rel.target)) count++;
+      if (valueSet.has(rel.target)) matchedTargets.add(rel.target);
     }
-    return count;
+    return matchedTargets.size;
   };
 
   /**
@@ -884,7 +958,7 @@ class SnomedServices {
    * @param {object} group
    * @returns {boolean}
    */
-  _attributeGroupMatches = function (conceptIdx, group) {
+  _attributeGroupMatches = function (conceptIdx, group, opContext) {
     const relIdxs = this.getConceptRelationships(conceptIdx);
     const groupNumbers = new Set();
     for (const relIdx of relIdxs) {
@@ -896,9 +970,10 @@ class SnomedServices {
 
     let matchingGroupCount = 0;
     for (const g of groupNumbers) {
+      if (opContext) opContext.deadCheck('ecl:attributeGroup');
       let allMatch = true;
       for (const attr of group.attributes) {
-        if (!this._attributeMatches(conceptIdx, attr, g)) {
+        if (!this._attributeMatches(conceptIdx, attr, g, opContext)) {
           allMatch = false;
           break;
         }
@@ -939,9 +1014,9 @@ class SnomedServices {
    * @param {SnomedFilterContext} ctx
    * @returns {number[]}
    */
-  _eclResolveSet = function (ctx) {
+  _eclResolveSet = function (ctx, opContext) {
     if (ctx.eclWildcard && (!ctx.descendants || ctx.descendants.length === 0)) {
-      return this._eclEnumerateActiveConcepts();
+      return this._eclEnumerateActiveConcepts(opContext);
     }
     return this._eclToIndexArray(ctx);
   };
@@ -949,20 +1024,24 @@ class SnomedServices {
   /**
    * AND: concepts present in both sets.
    */
-  _eclIntersect = function (left, right) {
+  _eclIntersect = function (left, right, opContext) {
     if (left.eclWildcard) return right;
     if (right.eclWildcard) return left;
     const leftSet = new Set(this._eclToIndexArray(left));
     const result = new SnomedFilterContext();
-    result.descendants = this._eclToIndexArray(right).filter(idx => leftSet.has(idx));
+    result.descendants = this._eclToIndexArray(right).filter(idx => {
+      if (opContext) opContext.deadCheck('ecl:intersect');
+      return leftSet.has(idx);
+    });
     return result;
   };
 
   /**
    * OR: concepts present in either set.
    */
-  _eclUnion = function (left, right) {
+  _eclUnion = function (left, right, opContext) {
     if (left.eclWildcard || right.eclWildcard) return this._eclWildcard();
+    if (opContext) opContext.deadCheck('ecl:union');
     const combined = new Set([
       ...this._eclToIndexArray(left),
       ...this._eclToIndexArray(right)
@@ -975,7 +1054,7 @@ class SnomedServices {
   /**
    * MINUS: concepts in left that are not in right.
    */
-  _eclMinus = function (left, right) {
+  _eclMinus = function (left, right, opContext) {
     const result = new SnomedFilterContext();
 
     if (right.eclWildcard) {
@@ -989,6 +1068,7 @@ class SnomedServices {
       // Enumerate all active concepts minus the right set
       const all = [];
       for (let i = 0; i < this.concepts.count(); i++) {
+        if (opContext) opContext.deadCheck('ecl:minus');
         const concept = this.concepts.getConceptByCount(i);
         if (this.isActive(concept.index) && !rightSet.has(concept.index)) {
           all.push(concept.index);
@@ -998,7 +1078,10 @@ class SnomedServices {
       return result;
     }
 
-    result.descendants = this._eclToIndexArray(left).filter(idx => !rightSet.has(idx));
+    result.descendants = this._eclToIndexArray(left).filter(idx => {
+      if (opContext) opContext.deadCheck('ecl:minus');
+      return !rightSet.has(idx);
+    });
     return result;
   };
 

package/tx/library/canonical-resource.js

@@ -129,8 +129,10 @@ class CanonicalResource {
           return this.dateIsMoreRecent(this.version, other.version);
         case 'integer':
           return parseInt(this.version, 10) > parseInt(other.version, 10);
-        case 'alpha': return this.version.localeCompare(other.version) > 0;
-        default: return this.version.localeCompare(other.version);
+        case 'alpha':
+        default:
+          // Return a boolean: true only when this.version sorts after other.version.
+          return this.version.localeCompare(other.version) > 0;
       }
     }
     if (this.date && other.date && this.date != other.date) {

package/tx/library/designations.js

@@ -46,7 +46,7 @@ class SearchFilterText {
     validateParameter(value, 'value', String);
     validateOptionalParameter(returnRating, 'returnRating', Boolean);
 
-    if (this.null) {
+    if (this.isNull) {
       return returnRating ? {passes: true, rating: 0} : true;
     }
 
@@ -610,35 +610,42 @@ class Designations {
 
       const matchTypes = [LangMatchType.FULL, LangMatchType.LANG_REGION, LangMatchType.LANG];
 
-      for (const matchType of matchTypes) {
-        for (const cd of this.designations) {
-          if (this._langMatches(lang, cd.language, matchType) && this.isDisplay(cd)) {
-            if (supplements && cd.source) {
-              supplements.add(cd.source);
+      for (const activeOnly of [true, false]) {
+        for (const matchType of matchTypes) {
+          for (const cd of this.designations) {
+            if (this._langMatches(lang, cd.language, matchType) && this.isDisplay(cd) && (!activeOnly || cd.isActive())) {
+              if (supplements && cd.source) {
+                supplements.add(cd.source);
+              }
+              return cd;
             }
-            return cd;
           }
-        }
-        for (const cd of this.designations) {
-          if (this._langMatches(lang, cd.language, matchType) && this._isPreferred(cd)) {
-            if (supplements && cd.source) {
-              supplements.add(cd.source);
+          for (const cd of this.designations) {
+            if (this._langMatches(lang, cd.language, matchType) && this._isPreferred(cd)&& (!activeOnly || cd.isActive())) {
+              if (supplements && cd.source) {
+                supplements.add(cd.source);
+              }
+              return cd;
             }
-            return cd;
           }
-        }
-        for (const cd of this.designations) {
-          if (this._langMatches(lang, cd.language, matchType)) {
-            if (supplements && cd.source) {
-              supplements.add(cd.source);
+          for (const cd of this.designations) {
+            if (this._langMatches(lang, cd.language, matchType) && (!activeOnly || cd.isActive())) {
+              if (supplements && cd.source) {
+                supplements.add(cd.source);
+              }
+              return cd;
             }
-            return cd;
           }
         }
       }
     }
     for (const cd of this.designations) {
-      if (!cd.language && this.isDisplay(cd)) {
+      if (!cd.language && this.isDisplay(cd) && cd.isActive()) {
+        if (supplements && cd.source) {
+          supplements.add(cd.source);
+        }
+        return cd;
+      } if (!cd.language && this.isDisplay(cd)) {
         if (supplements && cd.source) {
           supplements.add(cd.source);
         }