@gefyra/diffyr6-cli 1.1.4 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gefyra/diffyr6-cli",
-  "version": "1.1.4",
+  "version": "1.2.1",
   "description": "FHIR R4 to R6 migration pipeline runner with automated profile comparison and rule-based analysis",
   "main": "src/index.js",
   "type": "module",

package/src/compare-searchparameters.js

@@ -0,0 +1,328 @@
+import fsp from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function compareSearchParameters(resourcesDir, outputDir, options = {}) {
+  const { debug = false } = options;
+
+  if (debug) {
+    console.log('  Scanning CapabilityStatements for removed search parameters...');
+  }
+
+  const removedParams = await loadRemovedSearchParameters();
+  const capabilityStatements = await collectCapabilityStatements(resourcesDir);
+  const usedParams = extractUsedSearchParameters(capabilityStatements);
+  const matches = findRemovedMatches(usedParams, removedParams);
+
+  const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '').replace('T', '-');
+  const reportFilename = `searchparameter-report-${timestamp}.md`;
+  const reportPath = path.join(outputDir, reportFilename);
+  const jsonFilename = `searchparameter-report-${timestamp}.json`;
+  const jsonPath = path.join(outputDir, jsonFilename);
+
+  const markdown = generateSearchParameterReport(matches);
+  await fsp.writeFile(reportPath, markdown, 'utf8');
+
+  const affectedCapabilityStatements = new Set(
+    matches.map(match => match.capabilityStatement.id || match.capabilityStatement.url || match.capabilityStatement.sourceFile)
+  );
+  const jsonData = {
+    generated: new Date().toISOString(),
+    totalRemovedMatches: matches.length,
+    affectedCapabilityStatements: affectedCapabilityStatements.size,
+    matches,
+  };
+  await fsp.writeFile(jsonPath, JSON.stringify(jsonData, null, 2), 'utf8');
+
+  return {
+    path: reportPath,
+    filename: reportFilename,
+    jsonPath,
+    jsonFilename,
+    matchCount: matches.length,
+    affectedCpsCount: affectedCapabilityStatements.size,
+  };
+}
+
+async function loadRemovedSearchParameters() {
+  const configPath = path.resolve(__dirname, '..', 'config', 'searchparameters-r4-not-in-r6.json');
+  const content = await fsp.readFile(configPath, 'utf8');
+  const data = JSON.parse(content);
+  return data.searchParameters || [];
+}
+
+async function collectCapabilityStatements(resourcesDir) {
+  const files = await collectJsonFiles(resourcesDir);
+  const capabilityStatements = [];
+  const baseDir = path.resolve(resourcesDir);
+
+  for (const filePath of files) {
+    const raw = await fsp.readFile(filePath, 'utf8').catch(() => '');
+    if (!raw) {
+      continue;
+    }
+
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+
+    if (data?.resourceType !== 'CapabilityStatement') {
+      continue;
+    }
+
+    capabilityStatements.push({
+      id: data.id || '',
+      url: data.url || '',
+      name: data.name || data.title || data.id || path.basename(filePath, '.json'),
+      sourceFile: path.relative(baseDir, filePath) || path.basename(filePath),
+      data,
+    });
+  }
+
+  return capabilityStatements;
+}
+
+function extractUsedSearchParameters(capabilityStatements) {
+  const used = [];
+
+  for (const capabilityStatement of capabilityStatements) {
+    const restEntries = Array.isArray(capabilityStatement.data.rest) ? capabilityStatement.data.rest : [];
+
+    for (const rest of restEntries) {
+      const resources = Array.isArray(rest.resource) ? rest.resource : [];
+
+      for (const resource of resources) {
+        const resourceType = typeof resource.type === 'string' ? resource.type : '';
+        const searchParams = Array.isArray(resource.searchParam) ? resource.searchParam : [];
+
+        for (const searchParam of searchParams) {
+          const name = normalizeString(searchParam.name || searchParam.code);
+          const definition = normalizeString(searchParam.definition);
+
+          if (!name && !definition) {
+            continue;
+          }
+
+          used.push({
+            name,
+            definition,
+            resourceType,
+            capabilityStatementId: capabilityStatement.id,
+            capabilityStatementUrl: capabilityStatement.url,
+            capabilityStatementName: capabilityStatement.name,
+            sourceFile: capabilityStatement.sourceFile,
+          });
+        }
+      }
+    }
+  }
+
+  return used;
+}
+
+function findRemovedMatches(usedParams, removedParams) {
+  const removedByUrl = new Map();
+  const removedByBaseAndCode = new Map();
+
+  for (const removed of removedParams) {
+    const url = normalizeString(removed.url);
+    if (url) {
+      removedByUrl.set(url, removed);
+    }
+
+    const bases = Array.isArray(removed.base) ? removed.base : [];
+    for (const base of bases) {
+      const key = buildBaseCodeKey(base, removed.code || removed.name);
+      if (!key) {
+        continue;
+      }
+      if (!removedByBaseAndCode.has(key)) {
+        removedByBaseAndCode.set(key, []);
+      }
+      removedByBaseAndCode.get(key).push(removed);
+    }
+  }
+
+  const seen = new Set();
+  const matches = [];
+
+  for (const used of usedParams) {
+    let removed = null;
+    let matchedBy = '';
+
+    if (used.definition && removedByUrl.has(used.definition)) {
+      removed = removedByUrl.get(used.definition);
+      matchedBy = 'definition';
+    } else if (used.resourceType && used.name) {
+      const fallbackMatches = removedByBaseAndCode.get(buildBaseCodeKey(used.resourceType, used.name)) || [];
+      if (fallbackMatches.length > 0) {
+        removed = fallbackMatches[0];
+        matchedBy = 'name+base';
+      }
+    }
+
+    if (!removed) {
+      continue;
+    }
+
+    const matchKey = [
+      removed.url || removed.id || removed.code,
+      used.capabilityStatementId || used.capabilityStatementUrl || used.sourceFile,
+      used.resourceType,
+      used.name,
+      used.definition,
+    ].join('::').toLowerCase();
+
+    if (seen.has(matchKey)) {
+      continue;
+    }
+    seen.add(matchKey);
+
+    matches.push({
+      removedSearchParameter: {
+        id: removed.id || '',
+        name: removed.name || '',
+        code: removed.code || '',
+        url: removed.url || '',
+        base: Array.isArray(removed.base) ? removed.base : [],
+        type: removed.type || '',
+        description: removed.description || '',
+      },
+      capabilityStatement: {
+        id: used.capabilityStatementId || '',
+        url: used.capabilityStatementUrl || '',
+        name: used.capabilityStatementName || '',
+        sourceFile: used.sourceFile,
+      },
+      resourceType: used.resourceType,
+      searchParameter: {
+        name: used.name,
+        definition: used.definition,
+      },
+      matchedBy,
+    });
+  }
+
+  return matches.sort(compareMatches);
+}
+
+function generateSearchParameterReport(matches) {
+  const lines = [];
+  const generated = new Date().toISOString();
+  const affectedCapabilityStatements = new Set(
+    matches.map(match => match.capabilityStatement.id || match.capabilityStatement.url || match.capabilityStatement.sourceFile)
+  );
+
+  lines.push('# Search Parameter Report');
+  lines.push('');
+  lines.push(`**Generated:** ${generated}`);
+  lines.push(`**Removed search parameter matches:** ${matches.length}`);
+  lines.push(`**Affected CapabilityStatements:** ${affectedCapabilityStatements.size}`);
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  if (matches.length === 0) {
+    lines.push('No CapabilityStatements were found that reference search parameters removed in FHIR R6.');
+    lines.push('');
+    return lines.join('\n');
+  }
+
+  const grouped = new Map();
+  for (const match of matches) {
+    const key = match.removedSearchParameter.url || `${match.removedSearchParameter.code}::${match.resourceType}`;
+    if (!grouped.has(key)) {
+      grouped.set(key, []);
+    }
+    grouped.get(key).push(match);
+  }
+
+  for (const key of Array.from(grouped.keys()).sort()) {
+    const group = grouped.get(key);
+    const first = group[0];
+    const removed = first.removedSearchParameter;
+
+    lines.push(`## ${removed.code || removed.name || removed.id}`);
+    lines.push('');
+    lines.push(`**Resource Type:** ${(removed.base || []).join(', ') || first.resourceType || 'Unknown'}`);
+    lines.push(`**Definition:** ${removed.url || 'n/a'}`);
+    lines.push(`**Matches:** ${group.length}`);
+    if (removed.description) {
+      lines.push(`**Description:** ${removed.description}`);
+    }
+    lines.push('');
+    lines.push('Affected CapabilityStatements:');
+    lines.push('');
+
+    for (const match of group) {
+      const cpsLabel =
+        match.capabilityStatement.name ||
+        match.capabilityStatement.id ||
+        match.capabilityStatement.url ||
+        path.basename(match.capabilityStatement.sourceFile);
+      lines.push(`- **${cpsLabel}**`);
+      lines.push(`  Resource: ${match.resourceType || 'Unknown'}`);
+      lines.push(`  Parameter: ${match.searchParameter.name || 'n/a'}`);
+      lines.push(`  Match: ${match.matchedBy}`);
+      if (match.searchParameter.definition) {
+        lines.push(`  Definition: ${match.searchParameter.definition}`);
+      }
+      lines.push(`  Source: ${match.capabilityStatement.sourceFile}`);
+    }
+
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+async function collectJsonFiles(dir) {
+  const results = [];
+  const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
+
+  for (const entry of entries) {
+    const entryPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectJsonFiles(entryPath);
+      results.push(...nested);
+      continue;
+    }
+    if (entry.isFile() && entry.name.toLowerCase().endsWith('.json')) {
+      results.push(entryPath);
+    }
+  }
+
+  return results;
+}
+
+function buildBaseCodeKey(base, code) {
+  const normalizedBase = normalizeString(base);
+  const normalizedCode = normalizeString(code);
+  if (!normalizedBase || !normalizedCode) {
+    return '';
+  }
+  return `${normalizedBase}::${normalizedCode}`;
+}
+
+function normalizeString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function compareMatches(a, b) {
+  return (
+    compareStrings(a.removedSearchParameter.code, b.removedSearchParameter.code) ||
+    compareStrings(a.resourceType, b.resourceType) ||
+    compareStrings(a.capabilityStatement.name || a.capabilityStatement.id, b.capabilityStatement.name || b.capabilityStatement.id) ||
+    compareStrings(a.searchParameter.name, b.searchParameter.name)
+  );
+}
+
+function compareStrings(a, b) {
+  return (a || '').localeCompare(b || '');
+}

package/src/compare-terminology.js

@@ -54,10 +54,13 @@ export async function compareTerminology(resourcesDir, resourcesR6Dir, outputDir
   console.log(`  Found ${findings.length} profile(s) with binding differences`);
   
   // Identify common bindings across all profiles
-  const commonBindings = identifyCommonBindings(findings);
+  const commonBindings = sortFindings(identifyCommonBindings(findings));
   
   // Remove common bindings from individual profiles
-  const filteredFindings = removeCommonBindingsFromProfiles(findings, commonBindings);
+  const filteredFindings = removeCommonBindingsFromProfiles(findings, commonBindings).map(profile => ({
+    ...profile,
+    findings: sortFindings(profile.findings),
+  }));
   
   // Generate reports
   const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '').replace('T', '-');
@@ -280,6 +283,7 @@ async function compareProfileBindings(r4Profile, r6Profile, options = {}) {
       findings.push({
         type: 'new-binding',
         path,
+        isMustSupport: isMustSupportElement(r6Elem),
         r6Binding: r6Elem.binding,
       });
       continue;
@@ -297,6 +301,7 @@ async function compareProfileBindings(r4Profile, r6Profile, options = {}) {
       const finding = {
         type: 'strength-and-valueset-change',
         path,
+        isMustSupport: isMustSupportElement(r4Elem) || isMustSupportElement(r6Elem),
         r4Strength: r4Binding.strength,
         r6Strength: r6Binding.strength,
         r4ValueSet: r4Binding.valueSet,
@@ -328,6 +333,7 @@ async function compareProfileBindings(r4Profile, r6Profile, options = {}) {
         findings.push({
           type: 'strength-change',
           path,
+          isMustSupport: isMustSupportElement(r4Elem) || isMustSupportElement(r6Elem),
           r4Strength: r4Binding.strength,
           r6Strength: r6Binding.strength,
           r4ValueSet: r4Binding.valueSet,
@@ -341,6 +347,7 @@ async function compareProfileBindings(r4Profile, r6Profile, options = {}) {
       findings.push({
         type: 'strength-change',
         path,
+        isMustSupport: isMustSupportElement(r4Elem) || isMustSupportElement(r6Elem),
         r4Strength: r4Binding.strength,
         r6Strength: r6Binding.strength,
         r4ValueSet: r4Binding.valueSet,
@@ -351,6 +358,7 @@ async function compareProfileBindings(r4Profile, r6Profile, options = {}) {
       const finding = {
         type: 'valueset-change',
         path,
+        isMustSupport: isMustSupportElement(r4Elem) || isMustSupportElement(r6Elem),
         r4ValueSet: r4Binding.valueSet,
         r6ValueSet: r6Binding.valueSet,
         r4Strength: r4Binding.strength,
@@ -392,6 +400,7 @@ async function compareProfileBindings(r4Profile, r6Profile, options = {}) {
       findings.push({
         type: 'removed-binding',
         path,
+        isMustSupport: isMustSupportElement(r4Elem),
         r4Binding: r4Elem.binding,
       });
     }
@@ -400,6 +409,10 @@ async function compareProfileBindings(r4Profile, r6Profile, options = {}) {
   return findings;
 }
 
+function isMustSupportElement(element) {
+  return element?.mustSupport === true;
+}
+
 /**
  * Check if valueSet URL has a version (pipe notation)
  */
@@ -756,6 +769,38 @@ function groupFindingsByType(findings) {
   return byType;
 }
 
+function sortFindings(findings) {
+  return [...findings].sort((left, right) => {
+    if ((left.isMustSupport === true) !== (right.isMustSupport === true)) {
+      return left.isMustSupport === true ? -1 : 1;
+    }
+    const pathCompare = (left.path || '').localeCompare(right.path || '');
+    if (pathCompare !== 0) {
+      return pathCompare;
+    }
+    return (left.type || '').localeCompare(right.type || '');
+  });
+}
+
+function splitFindingsByMustSupport(findings) {
+  const mustSupport = [];
+  const others = [];
+
+  for (const finding of findings) {
+    if (finding.isMustSupport === true) {
+      mustSupport.push(finding);
+    } else {
+      others.push(finding);
+    }
+  }
+
+  return { mustSupport, others };
+}
+
+function appendFindingMetadata(lines, finding) {
+  lines.push(`- Must Support: ${finding.isMustSupport === true ? 'yes' : 'no'}`);
+}
+
 /**
  * Append findings to markdown lines
  */
@@ -767,6 +812,7 @@ function appendFindingsToMarkdown(lines, byType) {
     
     for (const f of byType['strength-and-valueset-change']) {
       lines.push(`**${f.path}**`);
+      appendFindingMetadata(lines, f);
       lines.push(`- Strength: \`${f.r4Strength}\` → \`${f.r6Strength}\``);
       lines.push(`- R4 ValueSet: ${f.r4ValueSet || 'none'}`);
       lines.push(`- R6 ValueSet: ${f.r6ValueSet || 'none'}`);
@@ -818,6 +864,7 @@ function appendFindingsToMarkdown(lines, byType) {
     
     for (const f of byType['strength-change']) {
       lines.push(`**${f.path}**`);
+      appendFindingMetadata(lines, f);
       lines.push(`- Strength: \`${f.r4Strength}\` → \`${f.r6Strength}\``);
       if (f.r4ValueSet) {
         lines.push(`- ValueSet (R4): ${f.r4ValueSet}`);
@@ -836,6 +883,7 @@ function appendFindingsToMarkdown(lines, byType) {
     
     for (const f of byType['valueset-change']) {
       lines.push(`**${f.path}**`);
+      appendFindingMetadata(lines, f);
       lines.push(`- R4 ValueSet: ${f.r4ValueSet || 'none'}`);
       lines.push(`- R6 ValueSet: ${f.r6ValueSet || 'none'}`);
       
@@ -890,6 +938,7 @@ function appendFindingsToMarkdown(lines, byType) {
     
     for (const f of byType['new-binding']) {
       lines.push(`**${f.path}**`);
+      appendFindingMetadata(lines, f);
       if (f.r6Binding?.valueSet) {
         lines.push(`- ValueSet: ${f.r6Binding.valueSet}`);
       }
@@ -907,6 +956,7 @@ function appendFindingsToMarkdown(lines, byType) {
     
     for (const f of byType['removed-binding']) {
       lines.push(`**${f.path}**`);
+      appendFindingMetadata(lines, f);
       if (f.r4Binding?.valueSet) {
         lines.push(`- ValueSet (R4): ${f.r4Binding.valueSet}`);
       }
@@ -923,11 +973,24 @@ function appendFindingsToMarkdown(lines, byType) {
  */
 function generateTerminologyReport(findings, commonBindings = []) {
   const lines = [];
+  const sortedProfiles = sortProfilesAlphabetically(findings);
+  const mustSupportProfiles = sortedProfiles
+    .map(profile => ({
+      ...profile,
+      findings: profile.findings.filter(finding => finding.isMustSupport === true),
+    }))
+    .filter(profile => profile.findings.length > 0);
+  const otherProfiles = sortedProfiles
+    .map(profile => ({
+      ...profile,
+      findings: profile.findings.filter(finding => finding.isMustSupport !== true),
+    }))
+    .filter(profile => profile.findings.length > 0);
   
   lines.push('# Terminology Binding Comparison Report');
   lines.push('');
   lines.push(`**Generated:** ${new Date().toISOString()}`);
-  lines.push(`**Profiles with Differences:** ${findings.length}`);
+  lines.push(`**Profiles with Differences:** ${sortedProfiles.length}`);
   if (commonBindings.length > 0) {
     lines.push(`**Common Bindings Across All Profiles:** ${commonBindings.length}`);
   }
@@ -943,34 +1006,75 @@ function generateTerminologyReport(findings, commonBindings = []) {
     lines.push('');
     lines.push('The following binding changes occur in **all** profiles:');
     lines.push('');
-    
-    const groupedCommon = groupFindingsByType(commonBindings);
-    appendFindingsToMarkdown(lines, groupedCommon);
+
+    appendMustSupportSections(lines, commonBindings);
     
     lines.push('---');
     lines.push('');
   }
   
-  if (findings.length === 0) {
+  if (sortedProfiles.length === 0) {
     lines.push('✅ **No profile-specific binding differences found.**');
     lines.push('');
     return lines.join('\n');
   }
-  
-  for (const profile of findings) {
-    lines.push(`## ${profile.profileName}`);
+
+  if (mustSupportProfiles.length > 0) {
+    lines.push('## Must Support');
     lines.push('');
-    lines.push(`- **R4 URL:** ${profile.r4Url}`);
-    lines.push(`- **R6 URL:** ${profile.r6Url}`);
-    lines.push(`- **Differences:** ${profile.findings.length}`);
+    lines.push('The following profiles contain binding differences on Must-Support elements:');
     lines.push('');
-    
-    const groupedFindings = groupFindingsByType(profile.findings);
-    appendFindingsToMarkdown(lines, groupedFindings);
-    
-    lines.push('---');
+
+    for (const profile of mustSupportProfiles) {
+      appendProfileSection(lines, profile);
+    }
+  }
+
+  if (otherProfiles.length > 0) {
+    lines.push('## Non Must Support');
+    lines.push('');
+    lines.push('The following profiles contain binding differences on elements without Must Support:');
     lines.push('');
+
+    for (const profile of otherProfiles) {
+      appendProfileSection(lines, profile);
+    }
   }
   
   return lines.join('\n');
 }
+
+function appendMustSupportSections(lines, findings) {
+  const sortedFindings = sortFindings(findings);
+  const { mustSupport, others } = splitFindingsByMustSupport(sortedFindings);
+
+  if (mustSupport.length > 0) {
+    lines.push('### Must Support Elements');
+    lines.push('');
+    appendFindingsToMarkdown(lines, groupFindingsByType(mustSupport));
+  }
+
+  if (others.length > 0) {
+    lines.push('### Other Elements');
+    lines.push('');
+    appendFindingsToMarkdown(lines, groupFindingsByType(others));
+  }
+}
+
+function appendProfileSection(lines, profile) {
+  lines.push(`### ${profile.profileName}`);
+  lines.push('');
+  lines.push(`- **R4 URL:** ${profile.r4Url}`);
+  lines.push(`- **R6 URL:** ${profile.r6Url}`);
+  lines.push(`- **Differences:** ${profile.findings.length}`);
+  lines.push('');
+  appendFindingsToMarkdown(lines, groupFindingsByType(sortFindings(profile.findings)));
+  lines.push('---');
+  lines.push('');
+}
+
+function sortProfilesAlphabetically(profiles) {
+  return [...profiles].sort((left, right) =>
+    (left.profileName || '').localeCompare(right.profileName || '')
+  );
+}

package/src/config.js

@@ -6,7 +6,7 @@ import { pathExists } from './utils/fs.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const CONFIG_VERSION = '1.0.2';
+export const CONFIG_VERSION = '1.0.3';
 
 /**
  * Default configuration values
@@ -26,6 +26,7 @@ export const DEFAULT_CONFIG = {
   compareMode: 'incremental',
   exportZip: true,
   skipTerminologyReport: false,
+  skipSearchParameterReport: false,
 };
 
 /**
@@ -68,17 +69,31 @@ function migrateConfig(config) {
     if (config.skipTerminologyReport === undefined) {
       config.skipTerminologyReport = false;
     }
+    if (config.skipSearchParameterReport === undefined) {
+      config.skipSearchParameterReport = false;
+    }
     return config;
   }
   
   const [major, minor, patch] = config.configVersion.split('.').map(Number);
   
-  // Migrate from 1.0.0 or 1.0.1 to 1.0.2
+  // Migrate from 1.0.0 or 1.0.1 to 1.0.2/1.0.3
   if (major === 1 && minor === 0 && (patch === 0 || patch === 1)) {
     console.log(`  Migrating config from ${config.configVersion} to ${CONFIG_VERSION}...`);
     if (config.skipTerminologyReport === undefined) {
       config.skipTerminologyReport = false;
     }
+    if (config.skipSearchParameterReport === undefined) {
+      config.skipSearchParameterReport = false;
+    }
+    config.configVersion = CONFIG_VERSION;
+  }
+
+  if (major === 1 && minor === 0 && patch === 2) {
+    console.log(`  Migrating config from ${config.configVersion} to ${CONFIG_VERSION}...`);
+    if (config.skipSearchParameterReport === undefined) {
+      config.skipSearchParameterReport = false;
+    }
     config.configVersion = CONFIG_VERSION;
   }
   
@@ -142,6 +157,10 @@ function validateConfig(config) {
   if (typeof config.skipTerminologyReport !== 'boolean') {
     errors.push('skipTerminologyReport must be a boolean');
   }
+
+  if (typeof config.skipSearchParameterReport !== 'boolean') {
+    errors.push('skipSearchParameterReport must be a boolean');
+  }
   
   if (errors.length > 0) {
     throw new Error(`Invalid configuration:\n${errors.map(e => `  - ${e}`).join('\n')}`);
@@ -166,7 +185,8 @@ export async function createExampleConfig(outputPath) {
     workdir: null,
     compareMode: 'incremental',
     exportZip: true,
-    skipTerminologyReport: false
+    skipTerminologyReport: false,
+    skipSearchParameterReport: false
   };
   
   await fsp.writeFile(