fhirsmith 0.12.0 → 0.13.0

package/tx/sct/expressions.js

@@ -6,7 +6,14 @@
  * Licensed under BSD-3-Clause
  */
 
+const { SnomedConceptList } = require('./structures');
+
 const MAX_TERM_LENGTH = 1024;
+// How deep concept-definition expansion may go while building a long normal form.
+// Attribute values are themselves expanded, so a chain of definitions can descend a
+// long way; in real data it is a handful of levels.
+const MAX_NORMALISATION_DEPTH = 50;
+
 const NO_REFERENCE = 0xFFFFFFFF;
 
 // MRCM (machine readable concept model) reference sets and metadata concepts.
@@ -593,6 +600,15 @@ class SnomedExpressionParser {
 
     this.ws();
     result.code = this.conceptId();
+    // Resolve the attribute name the same way concept() resolves a focus concept. Without this
+    // the name keeps NO_REFERENCE, and SnomedConcept.matches() then compares by reference on one
+    // side and by code on the other, which makes refinement matching (and so subsumption between
+    // two refined expressions) asymmetric.
+    if (this.conceptList) {
+      const found = this.conceptList.findConcept(result.code);
+      this.rule(found.found, 'Concept "' + result.code + '" not valid');
+      result.reference = found.index;
+    }
     this.ws();
 
     if (this.gchar('|')) {
@@ -1035,7 +1051,12 @@ class SnomedExpressionServices {
       }
 
       const result = new SnomedExpressionParser().parse(source);
-      this.checkExpression(result);
+      // Resolve concept ids to references, but do NOT run checkExpression: the MRCM rules it
+      // applies are the postcoordination ones, and this is a concept's own stored definition -
+      // precoordinated content, authored under MRCM content types that do not apply here. Running
+      // them rejects the normal form of any concept using an attribute that is precoordinated-only
+      // (e.g. 246075003 |Causative agent| on a disorder), which broke subsumption for expressions.
+      this.resolveExpressionReferences(result);
       return result;
     }
   }
@@ -1202,13 +1223,46 @@ class SnomedExpressionServices {
   /**
    * Normalize expression to normal form
    */
-  normaliseExpression(exp) {
+  /**
+   * Expand an expression to its long normal form, ready for structural comparison.
+   *
+   * A fully defined concept is replaced by its definition, because that definition is
+   * both necessary and sufficient. A primitive concept is NOT replaced - its definition
+   * is only necessary, and substituting it would make the expression look equivalent to
+   * things it merely subsumes. But the primitive's defining attributes are still
+   * entailed by it, so they are added alongside the concept rather than discarded:
+   * `4846001 |Anicteric viral hepatitis|` is primitive and carries an inferred
+   * `363698007 |Finding site| = 10200004 |Liver structure|`, so every instance of it
+   * really is a disease with that finding site, and `64572001:{363698007=10200004}`
+   * really does subsume it. Dropping those attributes - which is what this used to do -
+   * lost that answer and reported not-subsumed, which is simply wrong.
+   *
+   * Keeping the concept itself in the focus is what stops the addition being unsound in
+   * the other direction: the primitive stays as an atom that nothing else can match, so
+   * an expression carrying the same attributes is never reported as equivalent to it.
+   *
+   * @param {SnomedExpression} exp
+   * @param {number} [depth] - recursion guard, see MAX_NORMALISATION_DEPTH
+   * @returns {SnomedExpression}
+   */
+  normaliseExpression(exp, depth = 0) {
+    if (depth > MAX_NORMALISATION_DEPTH) {
+      // Expanding attribute values can descend a long way, and truncating silently is
+      // not safe in both directions: dropping conditions from the subsuming side makes
+      // it demand less and so subsume more, which would be a false positive. Fail
+      // instead, and let the caller report that it could not answer.
+      throw new Error(`Could not normalise the expression: it nests more than ${MAX_NORMALISATION_DEPTH}`
+        + ' levels deep once concept definitions are expanded');
+    }
     const work = new SnomedExpression();
 
     // Process concepts
     for (const concept of exp.concepts) {
-      if (concept.reference === NO_REFERENCE || this.isPrimitive(concept.reference)) {
+      if (concept.reference === NO_REFERENCE) {
+        work.concepts.push(concept);
+      } else if (this.isPrimitive(concept.reference)) {
         work.concepts.push(concept);
+        this.addDefiningAttributes(concept.reference, work, depth);
       } else {
         const ex = this.createNormalForm(concept.reference);
         work.merge(ex);
@@ -1220,7 +1274,7 @@ class SnomedExpressionServices {
       const refDst = new SnomedRefinement();
       work.refinements.push(refDst);
       refDst.name = refSrc.name;
-      refDst.value = this.normaliseExpression(refSrc.value);
+      refDst.value = this.normaliseExpression(refSrc.value, depth + 1);
     }
 
     // Process refinement groups
@@ -1232,7 +1286,7 @@ class SnomedExpressionServices {
         const refDst = new SnomedRefinement();
         grpDst.refinements.push(refDst);
         refDst.name = refSrc.name;
-        refDst.value = this.normaliseExpression(refSrc.value);
+        refDst.value = this.normaliseExpression(refSrc.value, depth + 1);
       }
     }
 
@@ -1241,6 +1295,56 @@ class SnomedExpressionServices {
     return work2.canonical();
   }
 
+  /**
+   * Add a concept's own defining (non is-a) relationships to an expression, as grouped
+   * and ungrouped refinements with their values normalised.
+   *
+   * Used for primitives, whose attributes are entailed but whose concept must stay in
+   * the focus - see normaliseExpression. The stored normal form cannot be used for this:
+   * it is built by createDefinedExpression, which stops at a primitive too, so the
+   * cached normal form of a primitive is just the concept itself. Reading the
+   * relationships here means existing caches keep working rather than needing a rebuild.
+   *
+   * @param {number} reference - the concept whose attributes to add
+   * @param {SnomedExpression} work - expression to add them to
+   * @param {number} depth - current normalisation depth
+   */
+  addDefiningAttributes(reference, work, depth) {
+    const groups = new Map();
+
+    for (const relIndex of this.getDefiningRelationships(reference)) {
+      const rel = this.relationships.getRelationship(relIndex);
+
+      const ref = new SnomedRefinement();
+      ref.name = new SnomedConcept(rel.relType);
+      ref.name.code = this.getConceptId(rel.relType);
+
+      const value = new SnomedExpression();
+      const target = new SnomedConcept(rel.target);
+      target.code = this.getConceptId(rel.target);
+      value.concepts.push(target);
+      ref.value = this.normaliseExpression(value, depth + 1);
+
+      if (rel.group === 0) {
+        if (!work.hasRefinement(ref)) {
+          work.refinements.push(ref);
+        }
+      } else {
+        const key = rel.group.toString();
+        if (!groups.has(key)) {
+          groups.set(key, new SnomedRefinementGroup());
+        }
+        groups.get(key).refinements.push(ref);
+      }
+    }
+
+    for (const grp of groups.values()) {
+      if (!work.hasRefinementGroup(grp)) {
+        work.refinementGroups.push(grp);
+      }
+    }
+  }
+
   /**
    * Check if expression a subsumes expression b
    */
@@ -1266,10 +1370,20 @@ class SnomedExpressionServices {
       }
     }
 
-    // Check refinement groups
+    // Check refinement groups. Every group in e1 has to be satisfied by SOME group in e2 - try
+    // them all rather than only the first one whose attribute names line up. Two normalisations
+    // of the same expression can put equivalent groups in a different order, and when several
+    // groups share the same attribute names (e.g. two morphology/site groups on one disorder)
+    // picking the first match and giving up made subsumption depend on that order.
     for (const r of e1.refinementGroups) {
-      const rt = this.findMatchingGroup(r, e2);
-      if (!rt || !this.subsumesGroup(r, rt)) {
+      let ok = false;
+      for (const rt of e2.refinementGroups) {
+        if (this.subsumesGroup(r, rt)) {
+          ok = true;
+          break;
+        }
+      }
+      if (!ok) {
         return false;
       }
     }
@@ -1454,6 +1568,28 @@ class SnomedExpressionServices {
     return null;
   }
 
+  /**
+   * Resolve every concept id in an expression to its internal reference, without applying any
+   * of the concept model rules. Used for expressions the server generated itself (normal forms),
+   * where the ids are known good and the MRCM postcoordination rules do not apply
+   * @param {SnomedExpression} expression
+   */
+  resolveExpressionReferences(expression) {
+    for (const concept of expression.concepts) {
+      this.checkConcept(concept);
+    }
+    for (const refinement of expression.refinements) {
+      this.checkConcept(refinement.name);
+      this.resolveExpressionReferences(refinement.value);
+    }
+    for (const group of expression.refinementGroups) {
+      for (const refinement of group.refinements) {
+        this.checkConcept(refinement.name);
+        this.resolveExpressionReferences(refinement.value);
+      }
+    }
+  }
+
   /**
    * Validate expression structure and concept references
    */
@@ -1467,6 +1603,7 @@ class SnomedExpressionServices {
         this.checkRefinement(refinement);
         this.checkRefinementDomain(expression, refinement);
         this.checkRefinementRange(refinement);
+        this.checkRefinementGrouped(refinement);
       }
     }
 
@@ -1493,7 +1630,8 @@ class SnomedExpressionServices {
    * applied to a structure that cannot be lateralized, so it is enforced.
    *
    * Attributes with no rule in this edition's MRCM are not checked, and neither
-   * are cardinality, grouping, or the range constraint (which needs ECL).
+   * is cardinality (checkExpressionCardinality), grouping (checkRefinementGrouped)
+   * or the range constraint (checkRefinementRange, which needs ECL).
    *
    * @param {SnomedExpression} expression - the expression the refinement is on
    * @param {SnomedRefinement} refinement
@@ -1543,12 +1681,51 @@ class SnomedExpressionServices {
     }
   }
 
+  /**
+   * Check that an attribute the MRCM marks as grouped is actually in a relationship
+   * group. This is only ever called for refinements that are NOT in a group.
+   *
+   * The MRCM attribute domain reference set carries a `grouped` flag per rule, and it
+   * is a real constraint rather than a stylistic preference: `363698007 |Finding site|`
+   * is grouped, so `40468003:363698007=10200004` is not a valid expression even though
+   * every part of it is - it has to be written `40468003:{363698007=10200004}`. The
+   * distinction matters because a group is what ties an attribute to the others that
+   * apply with it, and an expression that omits the braces has not said which.
+   *
+   * SNOMED's postcoordination guide calls the ungrouped form Close To User Form and
+   * defines a transformation ("Adding a Self-grouped Attribute") that converts it to
+   * the Classifiable Form. That transformation is not implemented here, so the
+   * ungrouped form is rejected rather than silently repaired: telling the caller their
+   * expression is not classifiable is honest, quietly guessing what they meant is not.
+   *
+   * As elsewhere in this check, an attribute with no rule in this edition's MRCM is
+   * left alone, and where several rules apply the strictest wins.
+   *
+   * @param {SnomedRefinement} refinement - a refinement outside any group
+   */
+  checkRefinementGrouped(refinement) {
+    const attribute = refinement.name ? refinement.name.reference : NO_REFERENCE;
+    if (attribute === undefined || attribute === null || attribute === NO_REFERENCE) {
+      return;
+    }
+    const rules = this.mrcmAttributeDomains().get(attribute);
+    if (!rules || rules.length === 0) {
+      return;
+    }
+    if (!rules.some(rule => rule.grouped)) {
+      return;
+    }
+    const attrDesc = this.describeConceptForMessage(attribute);
+    throw new Error(`The SNOMED CT concept model requires the attribute ${attrDesc} to be in a`
+      + ` relationship group, so it cannot be used ungrouped (write it as {${attrDesc} = ...})`);
+  }
+
   /**
    * The MRCM attribute domain reference set, indexed by attribute concept.
    * Built once per edition and cached; an edition with no MRCM yields an empty
    * map, which turns the domain check off rather than failing.
    *
-   * @returns {Map<number, Array<{domain: number, isRefset: boolean}>>}
+   * @returns {Map<number, Array<{domain: number, isRefset: boolean, grouped: boolean, max: number, maxInGroup: number}>>}
    */
   mrcmAttributeDomains() {
     if (this._mrcmAttributeDomains) {
@@ -1602,6 +1779,9 @@ class SnomedExpressionServices {
       list.push({
         domain: domain,
         isRefset: refSetConcepts.has(domain),
+        // The grouped column is a plain 0/1 (type 4), not a reference into the string
+        // table like the cardinalities beside it - reading it as one yields garbage.
+        grouped: values[2] === 1,
         // Only the maximums are enforced. A minimum ("1..1") says a concept in
         // this domain must have the attribute in its own definition; it does not
         // say a refinement of that concept has to restate it.
@@ -2160,9 +2340,7 @@ class SnomedExpressionServices {
     // In SNOMED CT, primitive concepts are not fully defined by their relationships
     try {
       const concept = this.concepts.getConcept(reference);
-      // Bit 0 typically indicates if concept is primitive (1) or defined (0)
-      // This may vary based on the specific implementation
-      return (concept.flags & 1) !== 0;
+      return (concept.flags & SnomedConceptList.MASK_CONCEPT_PRIMITIVE) !== 0;
     } catch (error) {
       // If we can't read the concept, assume it's primitive for safety
       this.log.warn(`Warning: Could not check primitive status for concept ${reference}: ${error.message}`);
@@ -2487,10 +2665,9 @@ class SnomedExpressionServicesExtended extends SnomedExpressionServices {
   isPrimitive(reference) {
     try {
       const concept = this.concepts.getConcept(reference);
-      // In SNOMED CT, primitive concepts have the primitive flag set
-      // The definitionStatusId in RF2 determines this:
-      // 900000000000074008 = primitive, 900000000000073002 = fully defined
-      return (concept.flags & 1) !== 0;
+      // definitionStatusId 900000000000074008 (primitive) is recorded at import time as
+      // MASK_CONCEPT_PRIMITIVE in the concept flags byte
+      return (concept.flags & SnomedConceptList.MASK_CONCEPT_PRIMITIVE) !== 0;
     } catch (error) {
       // If we can't read the concept, assume it's primitive for safety
       if (this.building) {

package/tx/tx.fhir.org.yml

@@ -26,7 +26,7 @@ sources:
   - snomed:sct_us_20230301.cache
   - snomed:sct_us_20240301.cache
   - snomed:sct_us_20250901.cache
-  - snomed:sct_test_20250909.cache
+  - snomed:sct_test_20250909b.cache
   - cpt:CodeSystem-cpt.db|cpt-2023-fragment-0.1.db
   - omop:omop_v20250227.db
   - npm:hl7.terminology
@@ -37,6 +37,7 @@ sources:
   - npm:us.cdc.phinvads
   - npm:hl7.fhir.uv.sdc
   - internal:vsac
+  - icd11:icd11-2026-01.db
 
 ignored:
   - urn:iso:std:iso:3166#20210120

package/tx/tx.js

@@ -51,6 +51,7 @@ const ClosureWorker = require("./workers/closure");
 const {BundleXML} = require("./xml/bundle-xml");
 const ConceptUsageTracker = require("./usage-tracker");
 const ProblemFinder = require("./problems");
+const { buildOperationOutcome } = require('./library/operation-outcome');
 // const {writeFileSync} = require("fs");
 
 class TXModule {
@@ -437,14 +438,7 @@ class TXModule {
             }
           } catch (e) {
             this.log.error(`JSON parse error: ${e.message}`);
-            return res.status(400).json({
-              resourceType: 'OperationOutcome',
-              issue: [{
-                severity: 'error',
-                code: 'invalid',
-                diagnostics: `Invalid JSON: ${e.message}`
-              }]
-            });
+            return res.status(400).json(buildOperationOutcome('error', 'invalid', `Invalid JSON: ${e.message}`));
           }
         }
 
@@ -465,25 +459,11 @@ class TXModule {
             req.body = this.convertXmlToResource(xmlStr);
           } catch (e) {
             this.log.error(`XML parse error: ${e.message}`);
-            return res.status(400).json({
-              resourceType: 'OperationOutcome',
-              issue: [{
-                severity: 'error',
-                code: 'invalid',
-                diagnostics: `Invalid XML: ${e.message}`
-              }]
-            });
+            return res.status(400).json(buildOperationOutcome('error', 'invalid', `Invalid XML: ${e.message}`));
           }
         }
       } else if (contentType != 'application/x-www-form-urlencoded') {
-        return res.status(415).json({
-          resourceType: 'OperationOutcome',
-          issue: [{
-            severity: 'error',
-            code: 'invalid',
-            diagnostics: `Unsupported Media Type: ${contentType}`
-          }]
-        });
+        return res.status(415).json(buildOperationOutcome('error', 'invalid', `Unsupported Media Type: ${contentType}`));
       }
 
       if (req.body) {
@@ -1010,14 +990,7 @@ class TXModule {
     router.get('/', async (req, res) => {
       const start = Date.now();
       try {
-        await res.json({
-          resourceType: 'OperationOutcome',
-          issue: [{
-            severity: 'information',
-            code: 'informational',
-            diagnostics: `FHIR Terminology Server - FHIR v${req.txEndpoint.fhirVersion}`
-          }]
-        });
+        await res.json(buildOperationOutcome('information', 'informational', `FHIR Terminology Server - FHIR v${req.txEndpoint.fhirVersion}`));
       } finally {
         this.countRequest(endpointPath, 'home', Date.now() - start);
       }
@@ -1125,17 +1098,17 @@ class TXModule {
   }
 
   /**
-   * Build an OperationOutcome for errors
+   * Build an OperationOutcome. Delegates to the shared builder so that every outcome this
+   * server emits has details.text and a tx-issue-type coding: diagnostics is stripped by
+   * the test harness, so nothing a caller needs may live there.
+   * @param {string} severity - error, warning, information
+   * @param {string} code - FHIR issue type
+   * @param {string} message - the human readable account of the problem
+   * @param {string} [txIssueType] - tx-issue-type; defaulted from code when not given
+   * @returns {Object} OperationOutcome resource
    */
-  operationOutcome(severity, code, message) {
-    return {
-      resourceType: 'OperationOutcome',
-      issue: [{
-        severity,
-        code,
-        diagnostics: message
-      }]
-    };
+  operationOutcome(severity, code, message, txIssueType = null) {
+    return buildOperationOutcome(severity, code, message, txIssueType);
   }
 
   /**

package/tx/workers/batch-validate.js

@@ -13,7 +13,7 @@
 //
 
 const { TerminologyWorker } = require('./worker');
-const {OperationOutcome, Issue} = require("../library/operation-outcome");
+const { OperationOutcome, Issue, buildOperationOutcome, outcomeFromError } = require('../library/operation-outcome');
 const {Parameters} = require("../library/parameters");
 const {ValidateWorker} = require("./validate");
 const {debugLog} = require("../operation-context");
@@ -137,7 +137,7 @@ class BatchValidateWorker extends TerminologyWorker {
               op.addIssue(error);
               output.push({name: "validation", resource : op.jsonObj});
             } else {
-              output.push({name: "validation", resource : this.operationOutcome('error', error.issueCode || 'exception', error.message) } );
+              output.push({name: "validation", resource : outcomeFromError(error) } );
             }
           }
         }
@@ -156,8 +156,7 @@ class BatchValidateWorker extends TerminologyWorker {
         oo.addIssue(error);
         return res.status(error.statusCode || 500).json(oo.jsonObj);
       }
-      return res.status(error.statusCode || 500).json(this.operationOutcome(
-        'error', error.issueCode || 'exception', error.message));
+      return res.status(error.statusCode || 500).json(outcomeFromError(error));
     }
   }
 
@@ -218,18 +217,9 @@ class BatchValidateWorker extends TerminologyWorker {
   /**
    * Build an OperationOutcome
    */
-  operationOutcome(severity, code, message) {
-    return {
-      resourceType: 'OperationOutcome',
-      issue: [{
-        severity,
-        code,
-        details: {
-          text: message
-        },
-        diagnostics: message
-      }]
-    };
+  operationOutcome(severity, code, message, txIssueType = null) {
+    // the shared builder, so that every outcome has details.text and a tx-issue-type coding
+    return buildOperationOutcome(severity, code, message, txIssueType);
   }
 
   hasValueSet(parameter) {

package/tx/workers/batch.js

@@ -5,7 +5,7 @@
 //
 
 const { TerminologyWorker } = require('./worker');
-const { Issue, OperationOutcome } = require('../library/operation-outcome');
+const { Issue, OperationOutcome, buildOperationOutcome, outcomeFromError } = require('../library/operation-outcome');
 const {debugLog} = require("../operation-context");
 
 class BatchWorker extends TerminologyWorker {
@@ -47,8 +47,7 @@ class BatchWorker extends TerminologyWorker {
         oo.addIssue(error);
         return res.status(error.statusCode || 500).json(oo.jsonObj);
       } else {
-        return res.status(error.statusCode || 500).json(this.operationOutcome(
-          'error', error.issueCode || 'exception', error.message));
+        return res.status(error.statusCode || 500).json(outcomeFromError(error));
       }
     }
   }
@@ -163,9 +162,8 @@ class BatchWorker extends TerminologyWorker {
       this.log.error(error);
       debugLog(error);
       const statusCode = error.statusCode || 500;
-      const issueCode = error.issueCode || 'exception';
-
-      return this.errorEntry(statusCode, issueCode, error.message);
+      // on a plain Error, issueCode is the FHIR issue type and txIssueType the tx-issue-type
+      return this.errorEntry(statusCode, error.issueCode || 'exception', error.message, error.txIssueType);
     }
   }
 
@@ -319,19 +317,13 @@ class BatchWorker extends TerminologyWorker {
   /**
    * Build an error response entry
    * @param {number} statusCode - HTTP status code
-   * @param {string} issueCode - FHIR issue code
+   * @param {string} issueCode - FHIR issue type
    * @param {string} message - Error message
+   * @param {string} [txIssueType] - tx-issue-type; defaulted from issueCode when not given
    * @returns {Object} Error entry
    */
-  errorEntry(statusCode, issueCode, message) {
-    const outcome = {
-      resourceType: 'OperationOutcome',
-      issue: [{
-        severity: 'error',
-        code: issueCode,
-        diagnostics: message
-      }]
-    };
+  errorEntry(statusCode, issueCode, message, txIssueType = null) {
+    const outcome = buildOperationOutcome('error', issueCode, message, txIssueType);
 
     return {
       resource: outcome,
@@ -343,21 +335,17 @@ class BatchWorker extends TerminologyWorker {
   }
 
   /**
-   * Build an OperationOutcome
+   * Build an OperationOutcome. Delegates to the shared builder so that every outcome this
+   * server emits has details.text and a tx-issue-type coding: diagnostics is stripped by
+   * the test harness, so nothing a caller needs may live there.
    * @param {string} severity - error, warning, information
-   * @param {string} code - Issue code
-   * @param {string} message - Diagnostic message
+   * @param {string} code - FHIR issue type
+   * @param {string} message - the human readable account of the problem
+   * @param {string} [txIssueType] - tx-issue-type; defaulted from code when not given
    * @returns {Object} OperationOutcome resource
    */
-  operationOutcome(severity, code, message) {
-    return {
-      resourceType: 'OperationOutcome',
-      issue: [{
-        severity,
-        code,
-        diagnostics: message
-      }]
-    };
+  operationOutcome(severity, code, message, txIssueType = null) {
+    return buildOperationOutcome(severity, code, message, txIssueType);
   }
 }
 

package/tx/workers/cache-control.js

@@ -16,7 +16,7 @@
 const crypto = require('crypto');
 const { TerminologyWorker, CACHE_ID_HEADER } = require('./worker');
 const { Parameters } = require('../library/parameters');
-const { Issue } = require('../library/operation-outcome');
+const { Issue, buildOperationOutcome, outcomeFromError } = require('../library/operation-outcome');
 const { debugLog } = require('../operation-context');
 
 class CacheControlWorker extends TerminologyWorker {
@@ -71,8 +71,8 @@ class CacheControlWorker extends TerminologyWorker {
       debugLog(error);
       req.logInfo = this.usedSources.join('|') + ' - error' + (error.msgId ? ' ' + error.msgId : '');
       const statusCode = error.statusCode || 500;
-      const issueCode = error.issueCode || 'exception';
-      return res.status(statusCode).json(this.operationOutcome('error', issueCode, error.message));
+      return res.status(statusCode).json(
+        outcomeFromError(error));
     }
   }
 
@@ -276,15 +276,9 @@ class CacheControlWorker extends TerminologyWorker {
    * @param {string} message - Diagnostic message
    * @returns {Object} OperationOutcome resource
    */
-  operationOutcome(severity, code, message) {
-    return {
-      resourceType: 'OperationOutcome',
-      issue: [{
-        severity,
-        code,
-        details: { text: message }
-      }]
-    };
+  operationOutcome(severity, code, message, txIssueType = null) {
+    // the shared builder, so that every outcome has details.text and a tx-issue-type coding
+    return buildOperationOutcome(severity, code, message, txIssueType);
   }
 }
 

package/tx/workers/closure.js

@@ -5,6 +5,8 @@
 // POST /ConceptMap/$closure
 //
 
+const { buildOperationOutcome } = require('../library/operation-outcome');
+
 class ClosureWorker {
   /**
    * Handle a $closure request
@@ -18,14 +20,7 @@ class ClosureWorker {
     this.log.debug('ConceptMap $closure with params:', params);
 
     // TODO: Implement closure logic using provider
-    res.status(501).json({
-      resourceType: 'OperationOutcome',
-      issue: [{
-        severity: 'error',
-        code: 'not-supported',
-        diagnostics: 'ConceptMap $closure operation not yet implemented'
-      }]
-    });
+    res.status(501).json(buildOperationOutcome('error', 'not-supported', 'ConceptMap $closure operation not yet implemented'));
   }
 }