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);
+ });
+ });
 });