Initial must supports added to data requirement

src/helpers/elm/ELMHelpers.ts

@@ -36,9 +36,28 @@
       }
     }
     return null;
-  } else if (expression.localId == localId) {
+  } else if (expression.localId === localId) {
     return expression as ELMExpression;
   } else {
     return findClauseInExpression(Object.values(expression), localId);
   }
 }
+
+/**
+ * Recursively search an ELM tree for all expression (clause) with a given name
+ *
+ * @param expression The expression tree to search for the clause in.
+ * @param name The name to look for.
+ * @returns The expression if found or null.
+ */
+export function findNamedClausesInExpression(expression: any, name: string): ELMExpression[] {
+  if (typeof expression === 'string' || typeof expression === 'number' || typeof expression === 'boolean') {
+    return [];
+  } else if (Array.isArray(expression)) {
+    return expression.flatMap(elem => findNamedClausesInExpression(elem, name));
+  } else if (expression.name === name) {
+    return [expression as ELMExpression];
+  } else {
+    return findNamedClausesInExpression(Object.values(expression), name);
+  }
+}

src/helpers/elm/QueryFilterParser.ts

@@ -233,7 +233,7 @@
  */
 function parseSources(query: ELMQuery): SourceInfo[] {
   const sources: SourceInfo[] = [];
-  const querySources = [...query.source, ...query.relationship];
+  const querySources = [...query.source, ...(query.relationship || [])];
 
   querySources.forEach(source => {
     if (source.expression.type == 'Retrieve') {

src/helpers/elm/RetrievesHelper.ts

@@ -209,6 +209,13 @@ export function findRetrieves(
     }
 
     query.relationship?.forEach(relationshipClause => {
+      if (relationshipClause.localId) {
+        recursiveOpts.expressionStack.push({
+          libraryName: elm.library.identifier.id,
+          localId: relationshipClause.localId,
+          type: relationshipClause.type
+        });
+      }
       recurse(results, relationshipClause.expression, recursiveOpts);
       recurse(results, relationshipClause.suchThat, recursiveOpts);
     });

src/types/Calculator.ts

@@ -297,6 +297,8 @@ export interface DataTypeQuery {
   queryInfo?: QueryInfo;
   /** specifies an optional template/profile for the objects that the retrieve returns to conform to */
   templateId?: string;
+  /** array of fields that must be supported in association with this retrieve */
+  mustSupport?: string[];
 }
 
 export interface GapsDataTypeQuery extends DataTypeQuery {

src/types/ELMTypes.ts

@@ -234,7 +234,7 @@ export interface ELMQuery extends ELMExpression {
   type: 'Query';
   source: ELMAliasedQuerySource[];
   let?: ELMLetClause[];
-  relationship: ELMRelationshipClause[];
+  relationship?: ELMRelationshipClause[];
   where?: AnyELMExpression;
   return?: ELMReturnClause;
   sort?: any;
@@ -253,6 +253,7 @@ export interface ELMAliasedQuerySource {
 
 export interface ELMRelationshipClause extends ELMAliasedQuerySource {
   suchThat: AnyELMExpression;
+  type: string;
 }
 
 export interface ELMLetClause {

test/unit/DataRequirementHelpers.test.ts

@@ -4,6 +4,7 @@ import { CalculationOptions, DataTypeQuery } from '../../src/types/Calculator';
 import { DataRequirement } from 'fhir/r4';
 import { DateTime, Interval } from 'cql-execution';
 import moment from 'moment';
+import { ELM, ELMAliasedQuerySource, ELMQuery } from '../../src';
 
 describe('DataRequirementHelpers', () => {
   describe('generateDataRequirement', () => {
@@ -308,4 +309,239 @@ describe('DataRequirementHelpers', () => {
       );
     });
   });
+  describe('findPropertyExpressions', () => {
+    test('find properties in array', () => {
+      const expression = {
+        type: 'anyType',
+        localId: '0',
+        anyField: [
+          {
+            localId: '1',
+            type: 'Property'
+          },
+          {
+            localId: '2',
+            type: 'Other'
+          },
+          {
+            localId: '3',
+            type: 'Property'
+          }
+        ]
+      };
+      const elm: ELM = {
+        library: {
+          identifier: {
+            id: 'libraryId',
+            version: 'libraryVersion'
+          },
+          schemaIdentifier: {
+            id: 'schemaId',
+            version: 'schemaVersion'
+          },
+          usings: {},
+          statements: {
+            def: [
+              {
+                name: 'testStatement',
+                context: 'Patient',
+                expression: expression
+              }
+            ]
+          }
+        }
+      };
+      const propertyExpressions = DataRequirementHelpers.findPropertyExpressions(expression, [], elm, [elm]);
+      const expectedPropertyExpressions = [
+        {
+          property: {
+            localId: '1',
+            type: 'Property'
+          },
+          stack: [
+            {
+              type: 'anyType',
+              localId: '0',
+              libraryName: 'libraryId'
+            }
+          ]
+        },
+        {
+          property: {
+            localId: '3',
+            type: 'Property'
+          },
+          stack: [
+            {
+              type: 'anyType',
+              localId: '0',
+              libraryName: 'libraryId'
+            }
+          ]
+        }
+      ];
+
+      expect(propertyExpressions).toEqual(expectedPropertyExpressions);
+    });
+
+    test('find properties in object', () => {
+      const expression = {
+        type: 'anyType',
+        localId: '0',
+        anyField1: {
+          localId: '1',
+          type: 'Property'
+        },
+        anyField2: {
+          localId: '2',
+          type: 'Other'
+        },
+        anyField3: {
+          localId: '3',
+          type: 'Property'
+        }
+      };
+      const elm: ELM = {
+        library: {
+          identifier: {
+            id: 'libraryId',
+            version: 'libraryVersion'
+          },
+          schemaIdentifier: {
+            id: 'schemaId',
+            version: 'schemaVersion'
+          },
+          usings: {},
+          statements: {
+            def: [
+              {
+                name: 'testStatement',
+                context: 'Patient',
+                expression: expression
+              }
+            ]
+          }
+        }
+      };
+      const propertyExpressions = DataRequirementHelpers.findPropertyExpressions(expression, [], elm, [elm]);
+      const expectedPropertyExpressions = [
+        {
+          property: {
+            localId: '1',
+            type: 'Property'
+          },
+          stack: [
+            {
+              type: 'anyType',
+              localId: '0',
+              libraryName: 'libraryId'
+            }
+          ]
+        },
+        {
+          property: {
+            localId: '3',
+            type: 'Property'
+          },
+          stack: [
+            {
+              type: 'anyType',
+              localId: '0',
+              libraryName: 'libraryId'
+            }
+          ]
+        }
+      ];
+
+      expect(propertyExpressions).toEqual(expectedPropertyExpressions);
+    });
+  });
+
+  describe('findRetrieveMatches', () => {
+    test('simple retrieve match', () => {
+      const stack = [
+        {
+          type: 'Query',
+          localId: '0',
+          libraryName: 'libraryId'
+        }
+      ];
+      const retrieve: DataTypeQuery = {
+        dataType: 'fhir_type',
+        path: 'status',
+        templateId: 'http://hl7.org/fhir/StructureDefinition/fhir_type',
+        expressionStack: stack,
+        retrieveLocalId: '1'
+      };
+      const property: DataRequirementHelpers.PropertyTracker = {
+        property: {
+          localId: '2',
+          type: 'Property',
+          path: 'status',
+          scope: 'TestScope'
+        },
+        stack: stack
+      };
+      const expression: ELMQuery = {
+        type: 'Query',
+        localId: '0',
+        source: [
+          {
+            alias: 'TestScope',
+            expression: {
+              type: 'Retrieve',
+              localId: '1'
+            }
+          }
+        ],
+        relationship: [],
+        where: property.property
+      };
+      const elm: ELM = {
+        library: {
+          identifier: {
+            id: 'libraryId',
+            version: 'libraryVersion'
+          },
+          schemaIdentifier: {
+            id: 'schemaId',
+            version: 'schemaVersion'
+          },
+          usings: {},
+          statements: {
+            def: [
+              {
+                name: 'testStatement',
+                context: 'Patient',
+                expression: expression
+              }
+            ]
+          }
+        }
+      };
+      const expectedRetrieveMatches = [retrieve];
+      const retrieveMatches = DataRequirementHelpers.findRetrieveMatches(property, [retrieve], [elm]);
+      expect(retrieveMatches).toEqual(expectedRetrieveMatches);
+    });
+  });
+
+  describe('findSourceWithScope', () => {
+    test('simple source', () => {
+      const source: ELMAliasedQuerySource = {
+        expression: {
+          type: 'AnyType',
+          localId: '1'
+        },
+        alias: 'testScope'
+      };
+      const expression: ELMQuery = {
+        type: 'Query',
+        localId: '0',
+        relationship: [],
+        source: [source]
+      };
+
+      expect(DataRequirementHelpers.findSourcewithScope(expression, 'testScope')).toEqual(source);
+    });
+  });
 });