fhirsmith 0.4.2 → 0.5.1

package/tx/xversion/xv-codesystem.js

@@ -0,0 +1,169 @@
+const {VersionUtilities} = require("../../library/version-utilities");
+
+/**
+ * Converts input CodeSystem to R5 format (modifies input object for performance)
+ * @param {Object} jsonObj - The input CodeSystem object
+ * @param {string} version - Source FHIR version
+ * @returns {Object} The same object, potentially modified to R5 format
+ * @private
+ */
+
+function codeSystemToR5(jsonObj, version) {
+  if (version === 'R5') {
+    return jsonObj; // Already R5, no conversion needed
+  }
+
+  if (version === 'R3') {
+    // R3 to R5: Convert identifier from single object to array
+    if (jsonObj.identifier && !Array.isArray(jsonObj.identifier)) {
+      jsonObj.identifier = [jsonObj.identifier];
+    }
+    return jsonObj;
+  }
+
+  if (version === 'R4') {
+    // R4 to R5: identifier is already an array, no conversion needed
+    return jsonObj;
+  }
+
+  throw new Error(`Unsupported FHIR version: ${version}`);
+}
+
+/**
+ * Converts R5 CodeSystem to target version format (clones object first)
+ * @param {Object} r5Obj - The R5 format CodeSystem object
+ * @param {string} targetVersion - Target FHIR version
+ * @returns {Object} New object in target version format
+ * @private
+ */
+function codeSystemFromR5(r5Obj, targetVersion) {
+  if (VersionUtilities.isR5Ver(targetVersion)) {
+    return r5Obj; // No conversion needed
+  }
+
+  // Clone the object to avoid modifying the original
+  const cloned = JSON.parse(JSON.stringify(r5Obj));
+
+  if (VersionUtilities.isR4Ver(targetVersion)) {
+    return codeSystemR5ToR4(cloned);
+  } else if (VersionUtilities.isR3Ver(targetVersion)) {
+    return codeSystemR5ToR3(cloned);
+  }
+
+  throw new Error(`Unsupported target FHIR version: ${targetVersion}`);
+}
+
+/**
+ * Converts R5 CodeSystem to R4 format
+ * @param {Object} r5Obj - Cloned R5 CodeSystem object
+ * @returns {Object} R4 format CodeSystem
+ * @private
+ */
+function codeSystemR5ToR4(r5Obj) {
+  // Remove R5-specific elements that don't exist in R4
+  if (r5Obj.versionAlgorithmString) {
+    delete r5Obj.versionAlgorithmString;
+  }
+  if (r5Obj.versionAlgorithmCoding) {
+    delete r5Obj.versionAlgorithmCoding;
+  }
+
+  // Filter out R5-only filter operators
+  if (r5Obj.filter && Array.isArray(r5Obj.filter)) {
+    r5Obj.filter = r5Obj.filter.map(filter => {
+      if (filter.operator && Array.isArray(filter.operator)) {
+        // Remove R5-only operators like 'generalizes'
+        filter.operator = filter.operator.filter(op =>
+          !isR5OnlyFilterOperator(op)
+        );
+      }
+      return filter;
+    }).filter(filter =>
+      // Remove filters that have no valid operators left
+      !filter.operator || filter.operator.length > 0
+    );
+  }
+
+  return r5Obj;
+}
+
+/**
+ * Converts R5 CodeSystem to R3 format
+ * @param {Object} r5Obj - Cloned R5 CodeSystem object
+ * @returns {Object} R3 format CodeSystem
+ * @private
+ */
+function codeSystemR5ToR3(r5Obj) {
+  // First apply R4 conversions
+  const r4Obj = codeSystemR5ToR4(r5Obj);
+
+  // R5/R4 to R3: Convert identifier from array back to single object
+  if (r4Obj.identifier && Array.isArray(r4Obj.identifier)) {
+    if (r4Obj.identifier.length > 0) {
+      // Take the first identifier if multiple exist
+      r4Obj.identifier = r4Obj.identifier[0];
+    } else {
+      // Remove empty array
+      delete r4Obj.identifier;
+    }
+  }
+
+  // Remove additional R4-specific elements that don't exist in R3
+  if (r4Obj.supplements) {
+    delete r4Obj.supplements;
+  }
+
+  // R3 has more limited filter operator support
+  if (r4Obj.filter && Array.isArray(r4Obj.filter)) {
+    r4Obj.filter = r4Obj.filter.map(filter => {
+      if (filter.operator && Array.isArray(filter.operator)) {
+        // Keep only R3-compatible operators
+        filter.operator = filter.operator.filter(op =>
+          isR3CompatibleFilterOperator(op)
+        );
+      }
+      return filter;
+    }).filter(filter =>
+      // Remove filters that have no valid operators left
+      !filter.operator || filter.operator.length > 0
+    );
+  }
+
+  return r4Obj;
+}
+
+/**
+ * Checks if a filter operator is R5-only
+ * @param {string} operator - Filter operator code
+ * @returns {boolean} True if operator is R5-only
+ * @private
+ */
+function isR5OnlyFilterOperator(operator) {
+  const r5OnlyOperators = [
+    'generalizes',  // Added in R5
+    // Add other R5-only operators as they're identified
+  ];
+  return r5OnlyOperators.includes(operator);
+}
+
+/**
+ * Checks if a filter operator is compatible with R3
+ * @param {string} operator - Filter operator code
+ * @returns {boolean} True if operator is R3-compatible
+ * @private
+ */
+function isR3CompatibleFilterOperator(operator) {
+  const r3CompatibleOperators = [
+    '=',           // Equal
+    'is-a',        // Is-A relationship
+    'descendent-of', // Descendant of (note: R3 spelling)
+    'is-not-a',    // Is-Not-A relationship
+    'regex',       // Regular expression
+    'in',          // In set
+    'not-in',      // Not in set
+    'exists',      // Property exists
+  ];
+  return r3CompatibleOperators.includes(operator);
+}
+
+module.exports = { codeSystemToR5, codeSystemFromR5 };

package/tx/xversion/xv-conceptmap.js

@@ -0,0 +1,224 @@
+const {VersionUtilities} = require("../../library/version-utilities");
+
+/**
+ * Converts input ConceptMap to R5 format (modifies input object for performance)
+ * @param {Object} jsonObj - The input ConceptMap object
+ * @param {string} version - Source FHIR version
+ * @returns {Object} The same object, potentially modified to R5 format
+ * @private
+ */
+
+function conceptMapToR5(jsonObj, sourceVersion) {
+  if (VersionUtilities.isR5Ver(sourceVersion)) {
+    return jsonObj; // No conversion needed
+  }
+
+  if (VersionUtilities.isR3Ver(sourceVersion) || VersionUtilities.isR4Ver(sourceVersion)) {
+    // Convert identifier from single object to array
+    if (jsonObj.identifier && !Array.isArray(jsonObj.identifier)) {
+      jsonObj.identifier = [jsonObj.identifier];
+    }
+
+    // Convert source/target to sourceScope/targetScope
+    if (jsonObj.source !== undefined) {
+      // Combine source + sourceVersion if both exist
+      if (jsonObj.sourceVersion) {
+        jsonObj.sourceScope = `${jsonObj.source}|${jsonObj.sourceVersion}`;
+        delete jsonObj.sourceVersion;
+      } else {
+        jsonObj.sourceScope = jsonObj.source;
+      }
+      delete jsonObj.source;
+    }
+
+    if (jsonObj.target !== undefined) {
+      // Combine target + targetVersion if both exist
+      if (jsonObj.targetVersion) {
+        jsonObj.targetScope = `${jsonObj.target}|${jsonObj.targetVersion}`;
+        delete jsonObj.targetVersion;
+      } else {
+        jsonObj.targetScope = jsonObj.target;
+      }
+      delete jsonObj.target;
+    }
+
+    // Convert equivalence to relationship in group.element.target
+    if (jsonObj.group && Array.isArray(jsonObj.group)) {
+      jsonObj.group.forEach(group => {
+        if (group.element && Array.isArray(group.element)) {
+          group.element.forEach(element => {
+            if (element.target && Array.isArray(element.target)) {
+              element.target.forEach(target => {
+                if (target.equivalence && !target.relationship) {
+                  // Convert equivalence to relationship and keep both
+                  target.relationship = convertEquivalenceToRelationship(target.equivalence);
+                  // Keep equivalence for backward compatibility
+                }
+              });
+            }
+          });
+        }
+      });
+    }
+
+    return jsonObj;
+  }
+  throw new Error(`Unsupported FHIR version: ${sourceVersion}`);
+}
+
+/**
+ * Converts R5 ConceptMap to target version format (clones object first)
+ * @param {Object} r5Obj - The R5 format ConceptMap object
+ * @param {string} targetVersion - Target FHIR version
+ * @returns {Object} New object in target version format
+ * @private
+ */
+function conceptMapFromR5(r5Obj, targetVersion) {
+  if (VersionUtilities.isR5Ver(targetVersion)) {
+    return r5Obj; // No conversion needed
+  }
+
+  // Clone the object to avoid modifying the original
+  const cloned = JSON.parse(JSON.stringify(r5Obj));
+
+  if (VersionUtilities.isR4Ver(targetVersion)) {
+    return conceptMapR5ToR4(cloned);
+  } else if (VersionUtilities.isR3Ver(targetVersion)) {
+    return conceptMapR5ToR3(cloned);
+  }
+
+  throw new Error(`Unsupported target FHIR version: ${targetVersion}`);
+}
+
+/**
+ * Converts R5 ConceptMap to R4 format
+ * @param {Object} r5Obj - Cloned R5 ConceptMap object
+ * @returns {Object} R4 format ConceptMap
+ * @private
+ */
+function conceptMapR5ToR4(r5Obj) {
+  // Remove R5-specific elements
+  if (r5Obj.versionAlgorithmString) {
+    delete r5Obj.versionAlgorithmString;
+  }
+  if (r5Obj.versionAlgorithmCoding) {
+    delete r5Obj.versionAlgorithmCoding;
+  }
+  if (r5Obj.property) {
+    delete r5Obj.property;
+  }
+  if (r5Obj.additionalAttribute) {
+    delete r5Obj.additionalAttribute;
+  }
+
+  // Convert identifier array back to single object
+  if (r5Obj.identifier && Array.isArray(r5Obj.identifier)) {
+    if (r5Obj.identifier.length > 0) {
+      r5Obj.identifier = r5Obj.identifier[0]; // Take first identifier
+    } else {
+      delete r5Obj.identifier;
+    }
+  }
+
+  // Convert sourceScope/targetScope back to source/target + version
+  if (r5Obj.sourceScope) {
+    const parts = r5Obj.sourceScope.split('|');
+    r5Obj.source = parts[0];
+    if (parts.length > 1) {
+      r5Obj.sourceVersion = parts[1];
+    }
+    delete r5Obj.sourceScope;
+  }
+
+  if (r5Obj.targetScope) {
+    const parts = r5Obj.targetScope.split('|');
+    r5Obj.target = parts[0];
+    if (parts.length > 1) {
+      r5Obj.targetVersion = parts[1];
+    }
+    delete r5Obj.targetScope;
+  }
+
+  // Convert relationship back to equivalence in group.element.target
+  if (r5Obj.group && Array.isArray(r5Obj.group)) {
+    r5Obj.group.forEach(group => {
+      if (group.element && Array.isArray(group.element)) {
+        group.element.forEach(element => {
+          if (element.target && Array.isArray(element.target)) {
+            element.target.forEach(target => {
+              // If we have both equivalence and relationship, prefer equivalence for R4
+              if (target.relationship && !target.equivalence) {
+                target.equivalence = convertRelationshipToEquivalence(target.relationship);
+              }
+              // Remove R5-only relationship field
+              delete target.relationship;
+            });
+          }
+        });
+      }
+    });
+  }
+
+  return r5Obj;
+}
+
+/**
+ * Converts R5 ConceptMap to R3 format
+ * @param {Object} r5Obj - Cloned R5 ConceptMap object
+ * @returns {Object} R3 format ConceptMap
+ * @private
+ */
+function conceptMapR5ToR3(r5Obj) {
+  // First apply R4 conversions
+  const r4Obj = conceptMapR5ToR4(r5Obj);
+
+  return r4Obj;
+}
+
+
+/**
+ * Converts R3/R4 equivalence to R5 relationship
+ * @param {string} equivalence - R3/R4 equivalence value
+ * @returns {string} R5 relationship value
+ * @private
+ */
+function convertEquivalenceToRelationship(equivalence) {
+  const equivalenceToRelationship = {
+    'relatedto': 'related-to',
+    'equivalent': 'equivalent',
+    'equal': 'equivalent',
+    'wider': 'source-is-broader-than-target',
+    'subsumes': 'source-is-broader-than-target',
+    'narrower': 'source-is-narrower-than-target',
+    'specializes': 'source-is-narrower-than-target',
+    'inexact': 'not-related-to',
+    'unmatched': 'not-related-to',
+    'disjoint': 'not-related-to'
+  };
+  return equivalenceToRelationship[equivalence] || 'related-to';
+}
+
+/**
+ * Converts R5 relationship back to R3/R4 equivalence
+ * @param {string} relationship - R5 relationship value
+ * @returns {string} R3/R4 equivalence value
+ * @private
+ */
+function convertRelationshipToEquivalence(relationship) {
+  const relationshipToEquivalence = {
+    'related-to': 'relatedto',
+    'equivalent': 'equivalent',
+    'source-is-broader-than-target': 'wider',
+    'source-is-narrower-than-target': 'narrower',
+    'not-related-to': 'unmatched'
+  };
+  return relationshipToEquivalence[relationship] || 'relatedto';
+}
+
+
+
+module.exports = { conceptMapToR5, conceptMapFromR5 };
+
+
+
+

package/tx/xversion/xv-namingsystem.js

@@ -0,0 +1,88 @@
+const {VersionUtilities} = require("../../library/version-utilities");
+
+/**
+ * Converts input NamingSystem to R5 format (modifies input object for performance)
+ * @param {Object} jsonObj - The input NamingSystem object
+ * @param {string} version - Source FHIR version
+ * @returns {Object} The same object, potentially modified to R5 format
+ * @private
+ */
+
+function namingSystemToR5(jsonObj, sourceVersion) {
+  if (VersionUtilities.isR5Ver(sourceVersion)) {
+    return jsonObj; // No conversion needed
+  }
+  if (VersionUtilities.isR3Ver(sourceVersion)) {
+    // R3 to R5: Remove replacedBy field (we ignore it completely)
+    if (jsonObj.replacedBy !== undefined) {
+      delete jsonObj.replacedBy;
+    }
+    return jsonObj;
+  }
+
+  if (VersionUtilities.isR4Ver(sourceVersion)) {
+    // R4 to R5: No structural conversion needed
+    // R5 is backward compatible for the structural elements we care about
+    return jsonObj;
+  }
+  return jsonObj;
+}
+
+/**
+ * Converts R5 NamingSystem to target version format (clones object first)
+ * @param {Object} r5Obj - The R5 format NamingSystem object
+ * @param {string} targetVersion - Target FHIR version
+ * @returns {Object} New object in target version format
+ * @private
+ */
+function namingSystemFromR5(r5Obj, targetVersion) {
+  if (VersionUtilities.isR5Ver(targetVersion)) {
+    return r5Obj; // No conversion needed
+  }
+
+  // Clone the object to avoid modifying the original
+  const cloned = JSON.parse(JSON.stringify(r5Obj));
+
+  if (VersionUtilities.isR4Ver(targetVersion)) {
+    return namingSystemR5ToR4(cloned);
+  } else if (VersionUtilities.isR3Ver(targetVersion)) {
+    return namingSystemR5ToR3(cloned);
+  }
+
+  throw new Error(`Unsupported target FHIR version: ${targetVersion}`);
+}
+
+/**
+ * Converts R5 NamingSystem to R4 format
+ * @param {Object} r5Obj - Cloned R5 NamingSystem object
+ * @returns {Object} R4 format NamingSystem
+ * @private
+ */
+function namingSystemR5ToR4(r5Obj) {
+  if (r5Obj.versionAlgorithmString) {
+    delete r5Obj.versionAlgorithmString;
+  }
+  if (r5Obj.versionAlgorithmCoding) {
+    delete r5Obj.versionAlgorithmCoding;
+  }
+
+  return r5Obj;
+}
+
+/**
+ * Converts R5 NamingSystem to R3 format
+ * @param {Object} r5Obj - Cloned R5 NamingSystem object
+ * @returns {Object} R3 format NamingSystem
+ * @private
+ */
+function namingSystemR5ToR3(r5Obj) {
+  // First apply R4 conversions
+  const r4Obj = namingSystemR5ToR4(r5Obj);
+
+  // R3 doesn't have some R4/R5 fields, but we'll just let them through
+  // since most additions are backward compatible in JSON
+  return r4Obj;
+}
+
+module.exports = { namingSystemToR5, namingSystemFromR5 };
+

package/tx/xversion/xv-operationoutcome.js

@@ -0,0 +1,27 @@
+/**
+ * Converts input OperationOutcome to R5 format (modifies input object for performance)
+ * @param {Object} jsonObj - The input OperationOutcome object
+ * @param {string} version - Source FHIR version
+ * @returns {Object} The same object, potentially modified to R5 format
+ * @private
+ */
+
+// eslint-disable-next-line no-unused-vars
+function operationOutcomeToR5(jsonObj, sourceVersion) {
+  return jsonObj; // No conversion needed
+}
+
+/**
+ * Converts R5 OperationOutcome to target version format (clones object first)
+ * @param {Object} r5Obj - The R5 format OperationOutcome object
+ * @param {string} targetVersion - Target FHIR version
+ * @returns {Object} New object in target version format
+ * @private
+ */
+// eslint-disable-next-line no-unused-vars
+function operationOutcomeFromR5(r5Obj, targetVersion) {
+  return r5Obj; // No conversion needed
+}
+
+
+module.exports = { operationOutcomeToR5, operationOutcomeFromR5 };

package/tx/xversion/xv-parameters.js

@@ -0,0 +1,87 @@
+const {VersionUtilities} = require("../../library/version-utilities");
+
+/**
+ * Converts input Parameters to R5 format (modifies input object for performance)
+ * @param {Object} jsonObj - The input Parameters object
+ * @param {string} version - Source FHIR version
+ * @returns {Object} The same object, potentially modified to R5 format
+ * @private
+ */
+
+function parametersToR5(jsonObj, sourceVersion) {
+  if (VersionUtilities.isR5Ver(sourceVersion)) {
+    return jsonObj; // No conversion needed
+  }
+  throw new Error(`Unsupported FHIR version: ${sourceVersion}`);
+}
+
+/**
+ * Converts R5 Parameters to target version format (clones object first)
+ * @param {Object} r5Obj - The R5 format Parameters object
+ * @param {string} targetVersion - Target FHIR version
+ * @returns {Object} New object in target version format
+ * @private
+ */
+function parametersFromR5(r5Obj, targetVersion) {
+  if (VersionUtilities.isR5Ver(targetVersion)) {
+    return r5Obj; // No conversion needed
+  }
+
+  // Clone the object to avoid modifying the original
+  const cloned = JSON.parse(JSON.stringify(r5Obj));
+
+  if (VersionUtilities.isR4Ver(targetVersion)) {
+    return parametersR5ToR4(cloned);
+  } else if (VersionUtilities.isR3Ver(targetVersion)) {
+    return parametersR5ToR3(cloned);
+  }
+
+  throw new Error(`Unsupported target FHIR version: ${targetVersion}`);
+}
+
+/**
+ * Converts R5 Parameters to R4 format
+ * @param {Object} r5Obj - Cloned R5 Parameters object
+ * @returns {Object} R4 format Parameters
+ * @private
+ */
+function parametersR5ToR4(r5Obj) {
+  const {convertResourceFromR5} = require("./xv-resource");
+
+  for (let p of r5Obj.parameter) {
+    if (p.resource) {
+      p.resource = convertResourceFromR5(p.resource, "R4");
+    }
+  }
+  return r5Obj;
+}
+
+function convertParameterR5ToR3(p) {
+  if (p.valueCanonical) {
+    p.valueUri = p.valueCanonical;
+    delete p.valueCanonical;
+  }
+  for (const pp of p.part || []) {
+    convertParameterR5ToR3(pp)
+  }
+}
+
+/**
+ * Converts R5 Parameters to R3 format
+ * @param {Object} r5Obj - Cloned R5 Parameters object
+ * @returns {Object} R3 format Parameters
+ * @private
+ */
+function parametersR5ToR3(r5Obj) {
+  const {convertResourceFromR5} = require("./xv-resource");
+
+  for (let p of r5Obj.parameter) {
+    if (p.resource) {
+      p.resource = convertResourceFromR5(p.resource, "R3");
+    }
+    convertParameterR5ToR3(p);
+  }
+  return r5Obj;
+}
+
+module.exports = { parametersToR5, parametersFromR5 };

package/tx/xversion/xv-resource.js

@@ -0,0 +1,45 @@
+const {codeSystemFromR5} = require("./xv-codesystem");
+const {capabilityStatementFromR5} = require("./xv-capabiliityStatement");
+const {terminologyCapabilitiesFromR5} = require("./xv-terminologyCapabilities");
+const {valueSetFromR5} = require("./xv-valueset");
+const {conceptMapFromR5} = require("./xv-conceptmap");
+const {parametersFromR5} = require("./xv-parameters");
+const {operationOutcomeFromR5} = require("./xv-operationoutcome");
+const {bundleFromR5} = require("./xv-bundle");
+
+
+function convertResourceToR5(data, sourceVersion) {
+  if (sourceVersion == "5.0" || !data.resourceType) {
+    return data;
+  }
+  switch (data.resourceType) {
+    case "CodeSystem": return codeSystemFromR5(data, sourceVersion);
+    case "CapabilityStatement": return capabilityStatementFromR5(data, sourceVersion);
+    case "TerminologyCapabilities": return terminologyCapabilitiesFromR5(data, sourceVersion);
+    case "ValueSet": return valueSetFromR5(data, sourceVersion);
+    case "ConceptMap": return conceptMapFromR5(data, sourceVersion);
+    case "Parameters": return parametersFromR5(data, sourceVersion);
+    case "OperationOutcome": return operationOutcomeFromR5(data, sourceVersion);
+    case "Bundle": return bundleFromR5(data, sourceVersion);
+    default: return data;
+  }
+}
+
+function convertResourceFromR5(data, targetVersion) {
+  if (targetVersion == "5.0" || !data.resourceType) {
+    return data;
+  }
+  switch (data.resourceType) {
+    case "CodeSystem": return codeSystemFromR5(data, targetVersion);
+    case "CapabilityStatement": return capabilityStatementFromR5(data, targetVersion);
+    case "TerminologyCapabilities": return terminologyCapabilitiesFromR5(data, targetVersion);
+    case "ValueSet": return valueSetFromR5(data, targetVersion);
+    case "ConceptMap": return conceptMapFromR5(data, targetVersion);
+    case "Parameters": return parametersFromR5(data, targetVersion);
+    case "OperationOutcome": return operationOutcomeFromR5(data, targetVersion);
+    case "Bundle": return bundleFromR5(data, targetVersion);
+    default: return data;
+  }
+}
+
+module.exports = { convertResourceToR5, convertResourceFromR5 };