fhirsmith 0.9.5 → 0.9.7

package/tx/cs/cs-cs.js

@@ -1140,6 +1140,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     const allConcepts = this.codeSystem.getAllConcepts();
 
     for (const concept of allConcepts) {
+      this.opContext.deadCheck('cs:searchFilter');
       const rating = this._calculateSearchRating(concept, searchTerm);
       if (rating > 0) {
         results.add(concept, rating);
@@ -1285,6 +1286,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
 
       const allCodes = this.codeSystem.getAllCodes();
       for (const code of allCodes) {
+        this.opContext.deadCheck('cs:conceptFilter:is-not-a');
         if (!excludeSet.has(code)) {
           const concept = this.codeSystem.getConceptByCode(code);
           if (concept) {
@@ -1316,6 +1318,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
         const regex = regexUtilities.compile('^' + value + '$');
         const allCodes = this.codeSystem.getAllCodes();
         for (const code of allCodes) {
+          this.opContext.deadCheck('cs:conceptFilter:regex');
           if (regex.test(code)) {
             const concept = this.codeSystem.getConceptByCode(code);
             if (concept) {
@@ -1349,6 +1352,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
       }
       const descendants = this.codeSystem.getDescendants(ancestorCode);
       for (const code of descendants) {
+        this.opContext.deadCheck('cs:addDescendants');
         if (code !== ancestorCode) {
           const concept = this.codeSystem.getConceptByCode(code);
           if (concept) {
@@ -1370,6 +1374,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     if (concept) {
       const descendants = this.codeSystem.getChildren(parentCode);
       for (const code of descendants) {
+        this.opContext.deadCheck('cs:addChildren');
         if (code !== parentCode) { // should not be
           const concept = this.codeSystem.getConceptByCode(code);
           if (concept) {
@@ -1393,6 +1398,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
 
     const allCodes = this.codeSystem.getAllCodes();
     for (const code of allCodes) {
+      this.opContext.deadCheck('cs:childExistsFilter');
       const hasChildren = this.codeSystem.getChildren(code).length > 0;
       if (hasChildren === wantChildren) {
         const concept = this.codeSystem.getConceptByCode(code);
@@ -1419,6 +1425,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     const allConcepts = this.codeSystem.getAllConcepts();
 
     for (const concept of allConcepts) {
+      this.opContext.deadCheck('cs:propertyFilter');
       if (this._conceptMatchesPropertyFilter(concept, propertyDef, op, value)) {
         results.add(concept, 0);
       }
@@ -1498,6 +1505,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     const allConcepts = this.codeSystem.getAllConcepts();
 
     for (const concept of allConcepts) {
+      this.opContext.deadCheck('cs:knownPropertyFilter');
       let matches = false;
 
       if (prop === 'notSelectable') {

package/tx/cs/cs-loinc.js

@@ -947,6 +947,7 @@ class LoincServices extends BaseCSServices {
           reject(err);
         } else {
           for (const row of rows) {
+            if (this.opContext) this.opContext.deadCheck('loinc:findRegexMatches');
             if (regex.test(row[valueColumn])) {
               matchingKeys.push(row[keyColumn]);
             }
@@ -1429,8 +1430,8 @@ class LoincServicesFactory extends CodeSystemFactoryProvider {
    * @returns {Promise<Array>} Array of {code, display} objects
    */
   async #getAnswerListConcepts(sourceKey) {
-    return new Promise((resolve, reject) => {
-      let db = new sqlite3.Database(this.dbPath);
+    const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY);
+    try {
       const sql = `
           SELECT Code, Description
           FROM Relationships, Codes
@@ -1439,17 +1440,17 @@ class LoincServicesFactory extends CodeSystemFactoryProvider {
             AND Relationships.TargetKey = Codes.CodeKey
       `;
 
-      db.all(sql, [sourceKey], (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          const concepts = rows.map(row => ({
-            code: row.Code
-          }));
-          resolve(concepts);
-        }
+      const rows = await new Promise((resolve, reject) => {
+        db.all(sql, [sourceKey], (err, result) => {
+          if (err) reject(err);
+          else resolve(result);
+        });
       });
-    });
+
+      return rows.map(row => ({ code: row.Code }));
+    } finally {
+      await new Promise((resolve) => db.close(() => resolve()));
+    }
   }
 
   id() {

package/tx/cs/cs-omop.js

@@ -906,41 +906,42 @@ class OMOPServicesFactory extends CodeSystemFactoryProvider {
     return new OMOPServices(opContext, supplements, db, this._sharedData);
   }
 
-  static checkDB(dbPath) {
+  static async checkDB(dbPath) {
+    const fs = require('fs');
     try {
-      const fs = require('fs');
-
-      // Check if file exists
       if (!fs.existsSync(dbPath)) {
         return 'Database file not found';
       }
-
-      // Check file size
       const stats = fs.statSync(dbPath);
       if (stats.size < 1024) {
         return 'Database file too small';
       }
+    } catch (e) {
+      return `Database error: ${e.message}`;
+    }
 
-      // Try to open database and check for required tables
-      const db = new sqlite3.Database(dbPath);
-
-      try {
-        // Simple count query to verify database integrity
-        db.get('SELECT COUNT(*) as count FROM Concepts', (err) => {
-          if (err) {
-            db.close();
-            return 'Missing Tables - needs re-importing (by java)';
-          }
-        });
-
-        db.close();
-        return 'OK (check via provider for count)';
-      } catch (e) {
-        return 'Missing Tables - needs re-importing (by java)';
-      }
+    let db;
+    try {
+      db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY);
     } catch (e) {
       return `Database error: ${e.message}`;
     }
+
+    try {
+      // Simple count query to verify database integrity. If the Concepts
+      // table is missing, db.get rejects and we fall through to the catch.
+      const row = await new Promise((resolve, reject) => {
+        db.get('SELECT COUNT(*) as count FROM Concepts', (err, result) => {
+          if (err) reject(err);
+          else resolve(result);
+        });
+      });
+      return `OK (${row && row.count != null ? row.count : 0} Concepts)`;
+    } catch (_e) {
+      return 'Missing Tables - needs re-importing (by java)';
+    } finally {
+      await new Promise((resolve) => db.close(() => resolve()));
+    }
   }
 
 

package/tx/cs/cs-provider-list.js

@@ -5,7 +5,8 @@ const { AbstractCodeSystemProvider } = require('./cs-provider-api');
  */
 class ListCodeSystemProvider extends AbstractCodeSystemProvider {
   /**
-   * {Map<String, CodeSystem>} A list of code system factories that contains all the preloaded native code systems
+   * {CodeSystem[]} The preloaded FHIR code systems in this list. This is an
+   * array — append with .push(), not Map-style .set().
    */
   codeSystems = [];
 

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/cs/cs-unii.js

@@ -210,18 +210,18 @@ class UniiServicesFactory extends CodeSystemFactoryProvider {
   }
 
   async load() {
-    let db = new sqlite3.Database(this.dbPath);
-
-    return new Promise((resolve, reject) => {
-      db.get('SELECT Version FROM UniiVersion', (err, row) => {
-        if (err) {
-          reject(new Error(err));
-        } else {
-          this._version = row ? row.Version : 'unknown';
-          resolve(); // This resolves the Promise
-        }
+    const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY);
+    try {
+      const row = await new Promise((resolve, reject) => {
+        db.get('SELECT Version FROM UniiVersion', (err, result) => {
+          if (err) reject(new Error(err));
+          else resolve(result);
+        });
       });
-    });
+      this._version = row ? row.Version : 'unknown';
+    } finally {
+      await new Promise((resolve) => db.close(() => resolve()));
+    }
   }
 
   defaultVersion() {