fhirsmith 0.4.2 → 0.5.0

package/tx/xversion/xv-terminologyCapabilities.js

@@ -0,0 +1,214 @@
+const {VersionUtilities} = require("../../library/version-utilities");
+
+/**
+ * Converts input TerminologyCapabilities to R5 format (modifies input object for performance)
+ * @param {Object} jsonObj - The input TerminologyCapabilities object
+ * @param {string} version - Source FHIR version
+ * @returns {Object} The same object, potentially modified to R5 format
+ * @private
+ */
+
+function terminologyCapabilitiesToR5(jsonObj, sourceVersion) {
+  if (VersionUtilities.isR5Ver(sourceVersion)) {
+    return jsonObj; // No conversion needed
+  }
+
+  if (VersionUtilities.isR4Ver(sourceVersion)) {
+    // R4 to R5: No major structural changes needed for TerminologyCapabilities
+    return jsonObj;
+  }
+
+  if (VersionUtilities.isR3Ver(sourceVersion)) {
+    // R3: TerminologyCapabilities doesn't exist - it's a Parameters resource
+    // Convert from Parameters format to TerminologyCapabilities
+    return convertParametersToR5(jsonObj);
+  }
+
+  return jsonObj;
+}
+
+
+/**
+ * Converts R3 Parameters format to R5 TerminologyCapabilities
+ * @param {Object} params - The Parameters resource
+ * @returns {Object} TerminologyCapabilities in R5 format
+ * @private
+ */
+function convertParametersToR5(params) {
+  if (params.resourceType !== 'Parameters') {
+    throw new Error('R3 TerminologyCapabilities must be a Parameters resource');
+  }
+
+  const result = {
+    resourceType: 'TerminologyCapabilities',
+    id: params.id,
+    status: 'active', // Default, as Parameters doesn't carry this
+    kind: 'instance', // Default for terminology server capabilities
+    codeSystem: []
+  };
+
+  const parameters = params.parameter || [];
+  let currentSystem = null;
+
+  for (const param of parameters) {
+    switch (param.name) {
+      case 'url':
+        result.url = param.valueUri;
+        break;
+      case 'version':
+        if (currentSystem) {
+          // This is a code system version
+          if (param.valueCode) {
+            currentSystem.version = currentSystem.version || [];
+            currentSystem.version.push({ code: param.valueCode });
+          }
+          // Empty version parameter means no specific version
+        } else {
+          // This is the TerminologyCapabilities version
+          result.version = param.valueCode || param.valueString;
+        }
+        break;
+      case 'date':
+        result.date = param.valueDateTime;
+        break;
+      case 'system':
+        // Start a new code system
+        currentSystem = { uri: param.valueUri };
+        result.codeSystem.push(currentSystem);
+        break;
+      case 'expansion.parameter':
+        result.expansion = result.expansion || { parameter: [] };
+        result.expansion.parameter.push({ name: param.valueCode });
+        break;
+    }
+  }
+
+  return result;
+}
+
+
+/**
+ * Converts R5 TerminologyCapabilities to target version format (clones object first)
+ * @param {Object} r5Obj - The R5 format TerminologyCapabilities object
+ * @param {string} targetVersion - Target FHIR version
+ * @returns {Object} New object in target version format
+ * @private
+ */
+function terminologyCapabilitiesFromR5(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 terminologyCapabilitiesR5ToR4(cloned);
+  } else if (VersionUtilities.isR3Ver(targetVersion)) {
+    return terminologyCapabilitiesR5ToR3(cloned);
+  }
+
+  throw new Error(`Unsupported target FHIR version: ${targetVersion}`);
+}
+
+/**
+ * Converts R5 TerminologyCapabilities to R4 format
+ * @param {Object} r5Obj - Cloned R5 TerminologyCapabilities object
+ * @returns {Object} R4 format TerminologyCapabilities
+ * @private
+ */
+function terminologyCapabilitiesR5ToR4(r5Obj) {
+
+  if (r5Obj.versionAlgorithmString) {
+    delete r5Obj.versionAlgorithmString;
+  }
+  if (r5Obj.versionAlgorithmCoding) {
+    delete r5Obj.versionAlgorithmCoding;
+  }
+
+  return r5Obj;
+}
+
+/**
+ * Converts R5 TerminologyCapabilities to R3 format
+ * @param {Object} r5Obj - Cloned R5 TerminologyCapabilities object
+ * @returns {Object} R3 format TerminologyCapabilities
+ * @private
+ */
+function terminologyCapabilitiesR5ToR3(r5Obj) {
+  // In R3, TerminologyCapabilities didn't exist - we represent it as a Parameters resource
+  const params = {
+    resourceType: 'Parameters',
+    id: r5Obj.id,
+    parameter: []
+  };
+
+  // Add url parameter
+  if (r5Obj.url) {
+    params.parameter.push({
+      name: 'url',
+      valueUri: r5Obj.url
+    });
+  }
+
+  // Add version parameter
+  if (r5Obj.version) {
+    params.parameter.push({
+      name: 'version',
+      valueCode: r5Obj.version
+    });
+  }
+
+  // Add date parameter
+  if (r5Obj.date) {
+    params.parameter.push({
+      name: 'date',
+      valueDateTime: r5Obj.date
+    });
+  }
+
+  // Add code systems with their versions
+  for (const codeSystem of r5Obj.codeSystem || []) {
+    // Add system parameter
+    params.parameter.push({
+      name: 'system',
+      valueUri: codeSystem.uri
+    });
+
+    // Add version parameter(s) for this code system
+    if (codeSystem.version && codeSystem.version.length > 0) {
+      for (const ver of codeSystem.version) {
+        if (ver.code) {
+          params.parameter.push({
+            name: 'version',
+            valueCode: ver.code
+          });
+        } else {
+          // Empty version parameter when no specific version
+          params.parameter.push({
+            name: 'version'
+          });
+        }
+      }
+    } else {
+      // No version specified for this code system
+      params.parameter.push({
+        name: 'version'
+      });
+    }
+  }
+
+  // Add expansion parameters
+  if (r5Obj.expansion && r5Obj.expansion.parameter) {
+    for (const expParam of r5Obj.expansion.parameter) {
+      params.parameter.push({
+        name: 'expansion.parameter',
+        valueCode: expParam.name
+      });
+    }
+  }
+
+  return params;
+}
+
+module.exports = { terminologyCapabilitiesToR5, terminologyCapabilitiesFromR5 };

package/tx/xversion/xv-valueset.js

@@ -0,0 +1,234 @@
+const {VersionUtilities} = require("../../library/version-utilities");
+const {getValueName} = require("../../library/utilities");
+
+/**
+ * Converts input ValueSet to R5 format (modifies input object for performance)
+ * @param {Object} jsonObj - The input ValueSet object
+ * @param {string} version - Source FHIR version
+ * @returns {Object} The same object, potentially modified to R5 format
+ * @private
+ */
+
+function valueSetToR5(jsonObj, sourceVersion) {
+  if (VersionUtilities.isR5Ver(sourceVersion)) {
+    return jsonObj; // No conversion needed
+  }
+  if (VersionUtilities.isR4Ver(sourceVersion)) {
+    return jsonObj; // No conversion needed
+  }
+  if (VersionUtilities.isR3Ver(sourceVersion)) {
+    // R3 to R5: Remove extensible field (we ignore it completely)
+    if (jsonObj.extensible !== undefined) {
+      delete jsonObj.extensible;
+    }
+    return jsonObj; // No conversion needed
+  }
+  throw new Error(`Unsupported FHIR version: ${sourceVersion}`);
+}
+
+/**
+ * Converts R5 ValueSet to target version format (clones object first)
+ * @param {Object} r5Obj - The R5 format ValueSet object
+ * @param {string} targetVersion - Target FHIR version
+ * @returns {Object} New object in target version format
+ * @private
+ */
+function valueSetFromR5(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 valueSetR5ToR4(cloned);
+  } else if (VersionUtilities.isR3Ver(targetVersion)) {
+    return valueSetR5ToR3(cloned);
+  }
+
+  throw new Error(`Unsupported target FHIR version: ${targetVersion}`);
+}
+
+/**
+ * Converts R5 ValueSet to R4 format
+ * @param {Object} r5Obj - Cloned R5 ValueSet object
+ * @returns {Object} R4 format ValueSet
+ * @private
+ */
+function valueSetR5ToR4(r5Obj) {
+  if (r5Obj.versionAlgorithmString) {
+    delete r5Obj.versionAlgorithmString;
+  }
+  if (r5Obj.versionAlgorithmCoding) {
+    delete r5Obj.versionAlgorithmCoding;
+  }
+
+  // Filter out R5-only filter operators in compose
+  if (r5Obj.compose && r5Obj.compose.include) {
+    r5Obj.compose.include = r5Obj.compose.include.map(include => {
+      if (include.filter && Array.isArray(include.filter)) {
+        include.filter = include.filter.map(filter => {
+          if (filter.op && isR5OnlyFilterOperator(filter.op)) {
+            // Remove R5-only operators
+            return null;
+          }
+          return filter;
+        }).filter(filter => filter !== null);
+      }
+      return include;
+    });
+  }
+
+  if (r5Obj.compose && r5Obj.compose.exclude) {
+    r5Obj.compose.exclude = r5Obj.compose.exclude.map(exclude => {
+      if (exclude.filter && Array.isArray(exclude.filter)) {
+        exclude.filter = exclude.filter.map(filter => {
+          if (filter.op && isR5OnlyFilterOperator(filter.op)) {
+            // Remove R5-only operators
+            return null;
+          }
+          return filter;
+        }).filter(filter => filter !== null);
+      }
+      return exclude;
+    });
+  }
+
+  if (r5Obj.expansion) {
+    let exp = r5Obj.expansion;
+
+    // Convert ValueSet.expansion.property to extensions
+    if (exp.property && exp.property.length > 0) {
+      exp.extension = exp.extension || [];
+      for (let prop of exp.property) {
+        exp.extension.push({
+          url: "http://hl7.org/fhir/5.0/StructureDefinition/extension-ValueSet.expansion.property",
+          extension: [
+            { url: "code", valueCode: prop.code },
+            { url: "uri", valueUri: prop.uri }
+          ]
+        });
+      }
+      delete exp.property;
+      convertContainsPropertyR5ToR4(exp.contains);
+
+    }
+  }
+
+  return r5Obj;
+}
+
+/**
+ * Converts R5 ValueSet to R3 format
+ * @param {Object} r5Obj - Cloned R5 ValueSet object
+ * @returns {Object} R3 format ValueSet
+ * @private
+ */
+function valueSetR5ToR3(r5Obj) {
+  // First apply R4 conversions
+  const r4Obj = valueSetR5ToR4(r5Obj);
+
+  // R3 has more limited filter operator support
+  if (r4Obj.compose && r4Obj.compose.include) {
+    r4Obj.compose.include = r4Obj.compose.include.map(include => {
+      if (include.filter && Array.isArray(include.filter)) {
+        include.filter = include.filter.map(filter => {
+          if (filter.op && !isR3CompatibleFilterOperator(filter.op)) {
+            // Remove non-R3-compatible operators
+            return null;
+          }
+          return filter;
+        }).filter(filter => filter !== null);
+      }
+      return include;
+    });
+  }
+
+  if (r4Obj.compose && r4Obj.compose.exclude) {
+    r4Obj.compose.exclude = r4Obj.compose.exclude.map(exclude => {
+      if (exclude.filter && Array.isArray(exclude.filter)) {
+        exclude.filter = exclude.filter.map(filter => {
+          if (filter.op && !isR3CompatibleFilterOperator(filter.op)) {
+            // Remove non-R3-compatible operators
+            return null;
+          }
+          return filter;
+        }).filter(filter => filter !== null);
+      }
+      return exclude;
+    });
+  }
+  return r4Obj;
+}
+
+
+
+// Recursive function to convert contains.property
+function convertContainsPropertyR5ToR4(containsList) {
+  if (!containsList) return;
+
+  for (let item of containsList) {
+    if (item.property && item.property.length > 0) {
+      item.extension = item.extension || [];
+      for (let prop of item.property) {
+        let ext = {
+          url: "http://hl7.org/fhir/5.0/StructureDefinition/extension-ValueSet.expansion.contains.property",
+          extension: [
+            { url: "code", valueCode: prop.code }
+          ]
+        };
+        let pn = getValueName(prop);
+        let subExt = { url: "value" };
+        subExt[pn] = prop[pn];
+        ext.extension.push(subExt);
+        item.extension.push(ext);
+      }
+      delete item.property;
+    }
+
+    // Recurse into nested contains
+    if (item.contains) {
+      convertContainsPropertyR5ToR4(item.contains);
+    }
+  }
+}
+
+
+/**
+ * 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 = { valueSetToR5, valueSetFromR5 };
+

package/utilities/dev-proxy-server.js

@@ -0,0 +1,126 @@
+import http from 'http';
+import https from 'https';
+import fs from 'fs';
+import crypto from 'crypto';
+
+const LISTEN_PORT = 3002;
+const PROD_HOST = '127.0.0.1';
+const PROD_PORT = 3001;
+const DEV_HOST = 'tx-dev.fhir.org';
+const DEV_PORT = 443;
+const DEV_HTTPS = true;
+const LOG_LOCATION = '/Users/grahamegrieve/temp/tx-comp-log/log.ndjson'; // 'T:\\logs\\comparison.ndjson';
+
+const logStream = fs.createWriteStream(LOG_LOCATION, { flags: 'a' });
+
+function collectBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', c => chunks.push(c));
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+function forward(method, url, headers, body, host, port, useHttps = false) {
+  return new Promise((resolve, reject) => {
+    const mod = useHttps ? https : http;
+    const req = mod.request({
+      hostname: host,
+      port,
+      path: url,
+      method,
+      headers: { ...headers, host: 'tx.fhir.org' },
+      timeout: 600000,
+    }, (res) => {
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => {
+        const body = Buffer.concat(chunks);
+        resolve({
+          status: res.statusCode,
+          headers: res.headers,
+          body,
+        });
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+    req.write(body);
+    req.end();
+  });
+}
+
+function isJsonRequest(req) {
+  const accept = (req.headers['accept'] || '').toLowerCase();
+  const ct = (req.headers['content-type'] || '').toLowerCase();
+  return accept.includes('json') || accept.includes('fhir') ||
+    ct.includes('json') || ct.includes('fhir');
+}
+
+function summarise(result) {
+  if (result.status === 'rejected') {
+    return { error: result.reason?.message || 'unknown' };
+  }
+  const r = result.value;
+  return {
+    status: r.status,
+    contentType: r.headers['content-type'] || '',
+    size: r.body.length,
+    hash: crypto.createHash('md5').update(r.body).digest('hex'),
+  };
+}
+
+http.createServer(async (req, res) => {
+  const body = await collectBody(req);
+
+  if (!isJsonRequest(req)) {
+    try {
+      const prod = await forward(req.method, req.url, req.headers, body, PROD_HOST, PROD_PORT);
+      res.writeHead(prod.status, prod.headers);
+      res.end(prod.body);
+    } catch (e) {
+      res.writeHead(502);
+      res.end('Bad Gateway');
+    }
+    return;
+  }
+
+  const [prodResult, devResult] = await Promise.allSettled([
+    forward(req.method, req.url, req.headers, body, PROD_HOST, PROD_PORT),
+    forward(req.method, req.url, req.headers, body, DEV_HOST, DEV_PORT, DEV_HTTPS),
+  ]);
+
+  const prodSummary = summarise(prodResult);
+  const devSummary = summarise(devResult);
+  const match = prodSummary.hash === devSummary.hash && prodSummary.status === devSummary.status;
+
+  const logEntry = {
+    ts: new Date().toISOString(),
+    id: crypto.randomUUID(),
+    method: req.method,
+    url: req.url,
+    match,
+    prod: prodSummary,
+    dev: devSummary,
+  };
+
+  if (!match) {
+    if (prodResult.status === 'fulfilled') logEntry.prodBody = prodResult.value.body.toString('utf8').substring(0, 50000);
+    if (devResult.status === 'fulfilled') logEntry.devBody = devResult.value.body.toString('utf8').substring(0, 50000);
+  }
+
+  logStream.write(JSON.stringify(logEntry) + '\n');
+
+  if (prodResult.status === 'fulfilled') {
+    const p = prodResult.value;
+    res.writeHead(p.status, p.headers);
+    res.end(p.body);
+  } else {
+    res.writeHead(502);
+    res.end('Bad Gateway');
+  }
+}).listen(LISTEN_PORT);
+
+console.log(`Comparison proxy listening on port ${LISTEN_PORT}`);
+console.log(`Production: ${PROD_HOST}:${PROD_PORT} | Dev: ${DEV_HOST}:${DEV_PORT}${DEV_HTTPS ? ' (HTTPS)' : ''}`);

package/utilities/explode-results.js

@@ -0,0 +1,58 @@
+import { readdirSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const dir = '/Users/grahamegrieve/temp/tx-comp/';
+
+function stripDiagnostics(jsonStr) {
+  let obj;
+  try { obj = JSON.parse(jsonStr); } catch { return null; }
+  if (obj.resourceType === 'Parameters' && Array.isArray(obj.parameter)) {
+    obj.parameter = obj.parameter.filter(p => p.name !== 'diagnostics');
+  }
+  return obj;
+}
+
+const files = readdirSync(dir).filter(f => f.startsWith('system-') && f.endsWith('.ndjson'));
+
+let totalWritten = 0;
+let totalSkipped = 0;
+
+for (const file of files) {
+  const subdir = join(dir, file.replace('.ndjson', ''));
+  let prodDirCreated = false;
+  let devDirCreated = false;
+  const prodDir = join(subdir, 'prod');
+  const devDir = join(subdir, 'dev');
+
+  const lines = readFileSync(join(dir, file), 'utf8').split('\n').filter(l => l.trim());
+  let written = 0;
+  let skipped = 0;
+  for (const line of lines) {
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+    const id = obj.id || `unknown-${written + skipped}`;
+
+    const prod = obj.prodBody ? stripDiagnostics(obj.prodBody) : null;
+    const dev = obj.devBody ? stripDiagnostics(obj.devBody) : null;
+
+    // Compare after stripping diagnostics
+    const prodStr = prod ? JSON.stringify(prod) : '';
+    const devStr = dev ? JSON.stringify(dev) : '';
+    if (prodStr === devStr) {
+      skipped++;
+      continue;
+    }
+
+    // They differ - write them out
+    if (!prodDirCreated) { mkdirSync(prodDir, { recursive: true }); prodDirCreated = true; }
+    if (!devDirCreated) { mkdirSync(devDir, { recursive: true }); devDirCreated = true; }
+
+    if (prod) writeFileSync(join(prodDir, `${id}.json`), JSON.stringify(prod, null, 2) + '\n');
+    if (dev) writeFileSync(join(devDir, `${id}.json`), JSON.stringify(dev, null, 2) + '\n');
+    written++;
+  }
+  totalWritten += written;
+  totalSkipped += skipped;
+  console.log(`${file}: ${written} differ, ${skipped} match (after removing diagnostics)`);
+}
+console.log(`\nDone. ${totalWritten} written, ${totalSkipped} skipped.`);