Support code caret rules in ValueSets

package.json

@@ -59,7 +59,7 @@
     "eslint": "^8.5.0",
     "eslint-config-prettier": "^6.10.1",
     "jest": "^28.1.3",
-    "jest-extended": "^1.2.0",
+    "jest-extended": "^3.0.2",
     "opener": "^1.5.1",
     "prettier": "^2.0.2",
     "ts-jest": "^28.0.7",

src/extractor/CaretValueRuleExtractor.ts

@@ -243,7 +243,8 @@ export class CaretValueRuleExtractor {
   static processConcept(
     input: fhirtypes.CodeSystemConcept,
     conceptHierarchy: string[],
-    codeSystemName: string,
+    entityName: string,
+    entityType: 'CodeSystem' | 'ValueSet',
     fisher: utils.Fishable
   ): ExportableCaretValueRule[] {
     const caretValueRules: ExportableCaretValueRule[] = [];
@@ -261,7 +262,7 @@ export class CaretValueRuleExtractor {
       caretValueRule.pathArray = conceptHierarchy;
       if (isFSHValueEmpty(caretValueRule.value)) {
         logger.error(
-          `Value in CodeSytem ${codeSystemName} at concept ${conceptHierarchy.join(
+          `Value in ${entityType} ${entityName} at concept ${conceptHierarchy.join(
             '.'
           )} for element ${caretValueRule.caretPath} is empty. No caret value rule will be created.`
         );

src/processor/CodeSystemProcessor.ts

@@ -56,6 +56,7 @@ export class CodeSystemProcessor {
         concept,
         [...newConceptRule.hierarchy, concept.code],
         codeSystemName,
+        'CodeSystem',
         fisher
       )
     );

src/processor/ValueSetProcessor.ts

@@ -13,8 +13,6 @@ const SUPPORTED_COMPONENT_PATHS = [
   'system',
   'version',
   'concept',
-  'concept.code',
-  'concept.display',
   'filter',
   'filter.property',
   'filter.op',
@@ -46,13 +44,35 @@ export class ValueSetProcessor {
       ...CaretValueRuleExtractor.processResource(input, fisher, input.resourceType, config)
     );
     if (input.compose) {
-      input.compose.include?.forEach((vsComponent: any) => {
+      input.compose.include?.forEach((vsComponent: fhirtypes.ValueSetComposeIncludeOrExclude) => {
         newRules.push(ValueSetFilterComponentRuleExtractor.process(vsComponent, input, true));
         newRules.push(ValueSetConceptComponentRuleExtractor.process(vsComponent, true));
+        vsComponent.concept?.forEach(includedConcept => {
+          newRules.push(
+            ...CaretValueRuleExtractor.processConcept(
+              includedConcept,
+              [includedConcept.code],
+              target.name,
+              'ValueSet',
+              fisher
+            )
+          );
+        });
       });
-      input.compose.exclude?.forEach((vsComponent: any) => {
+      input.compose.exclude?.forEach((vsComponent: fhirtypes.ValueSetComposeIncludeOrExclude) => {
         newRules.push(ValueSetFilterComponentRuleExtractor.process(vsComponent, input, false));
         newRules.push(ValueSetConceptComponentRuleExtractor.process(vsComponent, false));
+        vsComponent.concept?.forEach(excludedConcept => {
+          newRules.push(
+            ...CaretValueRuleExtractor.processConcept(
+              excludedConcept,
+              [excludedConcept.code],
+              target.name,
+              'ValueSet',
+              fisher
+            )
+          );
+        });
       });
     }
     target.rules = compact(newRules);
@@ -100,6 +120,8 @@ export class ValueSetProcessor {
         .filter(k => isNaN(parseInt(k)))
         .join('.');
     });
+    // any path that starts with "concept." is okay, since those can use code caret rules
+    flatPaths = flatPaths.filter(p => !p.startsWith('concept.'));
     // Check if there are any paths that are not a supported path
     return difference(flatPaths, SUPPORTED_COMPONENT_PATHS).length === 0;
   }

test/extractor/CaretValueRuleExtractor.test.ts

@@ -643,6 +643,7 @@ describe('CaretValueRuleExtractor', () => {
         testConcept,
         ['testConcept'],
         'testCS',
+        'CodeSystem',
         defs
       );
       expect(caretRules).toContainEqual(
@@ -683,6 +684,7 @@ describe('CaretValueRuleExtractor', () => {
         testConcept,
         ['testConcept'],
         'testCS',
+        'CodeSystem',
         defs
       );
 
@@ -693,7 +695,7 @@ describe('CaretValueRuleExtractor', () => {
         })
       );
       expect(loggerSpy.getLastMessage('error')).toMatch(
-        'Value in CodeSytem testCS at concept testConcept for element property[0] is empty. No caret value rule will be created.'
+        'Value in CodeSystem testCS at concept testConcept for element property[0] is empty. No caret value rule will be created.'
       );
     });
   });

test/optimizer/plugins/fixtures/unsupported-valueset.json

@@ -4,11 +4,19 @@
   "id": "unsupported.valueset",
   "url": "http://example.org/tests/ValueSet/unsupported.valueset",
   "title": "Unsupported ValueSet",
-  "description": "This value set is not supported by ValueSet FSH syntax because it has a concept designation.",
+  "description": "This value set is not supported by ValueSet FSH syntax because it has a version extension.",
   "compose": {
     "include": [
       {
         "system": "http://example.org/zoo",
+        "_version": {
+          "extension": [
+            {
+              "url": "http://example.org/SomeExtension",
+              "valueString": "version things"
+            }
+          ]
+        },
         "concept": [
           {
             "code": "BEAR",

test/processor/ValueSetProcessor.test.ts

@@ -66,26 +66,26 @@ describe('ValueSetProcessor', () => {
       );
     });
 
-    it('should not convert a ValueSet with an included concept designation', () => {
+    it('should convert a ValueSet with an included concept designation', () => {
       const input = JSON.parse(
         fs.readFileSync(path.join(__dirname, 'fixtures', 'composed-valueset.json'), 'utf-8')
       );
       input.compose.include[0].concept[0].designation = {
         value: 'ourse'
       };
       const result = ValueSetProcessor.process(input, defs, config);
-      expect(result).toBeUndefined();
+      expect(result).toBeDefined();
     });
 
-    it('should not convert a ValueSet with an excluded concept designation', () => {
+    it('should convert a ValueSet with an excluded concept designation', () => {
       const input = JSON.parse(
         fs.readFileSync(path.join(__dirname, 'fixtures', 'composed-valueset.json'), 'utf-8')
       );
       input.compose.exclude[0].concept[0].designation = {
         value: 'chatte'
       };
       const result = ValueSetProcessor.process(input, defs, config);
-      expect(result).toBeUndefined();
+      expect(result).toBeDefined();
     });
 
     it('should not convert a ValueSet with a compose.include id', () => {
@@ -235,5 +235,69 @@ describe('ValueSetProcessor', () => {
       expect(targetValueSet.rules).toHaveLength(4);
       expect(targetValueSet.rules).toContainEqual<ExportableCaretValueRule>(experimentalRule);
     });
+
+    it('should add concept caret rules to a ValueSet', () => {
+      const input = JSON.parse(
+        fs.readFileSync(path.join(__dirname, 'fixtures', 'composed-valueset.json'), 'utf-8')
+      );
+      // add some designations
+      input.compose.include[0].concept[0].designation = {
+        value: 'ourse',
+        language: 'fr'
+      };
+      input.compose.exclude[0].concept[0].designation = {
+        value: 'chatte',
+        language: 'fr'
+      };
+      const workingValueSet = new ExportableValueSet('ComposedValueSet');
+      ValueSetProcessor.extractRules(input, workingValueSet, defs, config);
+      const rules = workingValueSet.rules;
+
+      const expectedIncludeDesignationValue = new ExportableCaretValueRule('');
+      expectedIncludeDesignationValue.isCodeCaretRule = true;
+      expectedIncludeDesignationValue.pathArray = ['BEAR'];
+      expectedIncludeDesignationValue.caretPath = 'designation.value';
+      expectedIncludeDesignationValue.value = 'ourse';
+      expect(rules).toContainEqual<ExportableCaretValueRule>(expectedIncludeDesignationValue);
+
+      const expectedIncludeDesignationLanguage = new ExportableCaretValueRule('');
+      expectedIncludeDesignationLanguage.isCodeCaretRule = true;
+      expectedIncludeDesignationLanguage.pathArray = ['BEAR'];
+      expectedIncludeDesignationLanguage.caretPath = 'designation.language';
+      expectedIncludeDesignationLanguage.value = new FshCode('fr');
+      expect(rules).toContainEqual<ExportableCaretValueRule>(expectedIncludeDesignationLanguage);
+
+      const expectedExcludeDesignationValue = new ExportableCaretValueRule('');
+      expectedExcludeDesignationValue.isCodeCaretRule = true;
+      expectedExcludeDesignationValue.pathArray = ['CAT'];
+      expectedExcludeDesignationValue.caretPath = 'designation.value';
+      expectedExcludeDesignationValue.value = 'chatte';
+      expect(rules).toContainEqual<ExportableCaretValueRule>(expectedExcludeDesignationValue);
+
+      const expectedExcludeDesignationLanguage = new ExportableCaretValueRule('');
+      expectedExcludeDesignationLanguage.isCodeCaretRule = true;
+      expectedExcludeDesignationLanguage.pathArray = ['CAT'];
+      expectedExcludeDesignationLanguage.caretPath = 'designation.language';
+      expectedExcludeDesignationLanguage.value = new FshCode('fr');
+      expect(rules).toContainEqual<ExportableCaretValueRule>(expectedExcludeDesignationLanguage);
+    });
+
+    it('should log an error and not add a concept caret rule when the rule value is missing', () => {
+      const input = JSON.parse(
+        fs.readFileSync(path.join(__dirname, 'fixtures', 'composed-valueset.json'), 'utf-8')
+      );
+      // add an empty designation
+      input.compose.include[0].concept[0].designation = {};
+
+      const workingValueSet = new ExportableValueSet('ComposedValueSet');
+      ValueSetProcessor.extractRules(input, workingValueSet, defs, config);
+      const rules = workingValueSet.rules;
+
+      expect(rules).not.toContainEqual(expect.objectContaining({ pathArray: ['BEAR'] }));
+
+      expect(loggerSpy.getLastMessage('error')).toEqual(
+        'Value in ValueSet ComposedValueSet at concept BEAR for element designation is empty. No caret value rule will be created.'
+      );
+    });
   });
 });

test/processor/fixtures/unsupported-valueset-missing-id.json

@@ -2,11 +2,19 @@
   "resourceType": "ValueSet",
   "name": "UnsupportedValueSet",
   "title": "Unsupported ValueSet",
-  "description": "This value set is not supported by ValueSet FSH syntax because it has a concept designation.",
+  "description": "This value set is not supported by ValueSet FSH syntax because it has a version extension.",
   "compose": {
     "include": [
       {
         "system": "http://example.org/zoo",
+        "_version": {
+          "extension": [
+            {
+              "url": "http://example.org/SomeExtension",
+              "valueString": "version things"
+            }
+          ]
+        },
         "concept": [
           {
             "code": "BEAR",

test/processor/fixtures/unsupported-valueset.json

@@ -3,11 +3,19 @@
   "name": "UnsupportedValueSet",
   "id": "unsupported.valueset",
   "title": "Unsupported ValueSet",
-  "description": "This value set is not supported by ValueSet FSH syntax because it has a concept designation.",
+  "description": "This value set is not supported by ValueSet FSH syntax because it has a version extension.",
   "compose": {
     "include": [
       {
         "system": "http://example.org/zoo",
+        "_version": {
+          "extension": [
+            {
+              "url": "http://example.org/SomeExtension",
+              "valueString": "version things"
+            }
+          ]
+        },
         "concept": [
           {
             "code": "BEAR",