Changes as per review

LF-2985

Author: yuriy-sedinkin

README.md

@@ -75,13 +75,19 @@ where:
       fhirpath.resolveInternalTypes().
     * options.traceFn - An optional trace function to call when tracing.
     * options.userInvocationTable - a user invocation table used
-      to replace any existing or define new functions.
+      to replace any existing functions or define new ones.
     * options.async - defines how to support asynchronous functions:
-      false or similar to false, e.g. undefined, null, or 0 (default) - throw an exception,
-      true or similar to true - return Promise, only for asynchronous functions,
-      "always" - return Promise always.
+        * false or similar to false, e.g. undefined, null, or 0 (default) - throw
+          an exception,
+        * true or similar to true - return Promise, only for asynchronous functions,
+        * "always" - return Promise always.
     * options.terminologyUrl - a URL that points to a FHIR RESTful API that is
       used to create %terminologies that implements the Terminology Service API.
+    * options.terminologyUrl - a URL that points to a terminology server. This
+      URL is used to initialize %terminologies, as defined in the FHIR FHIRPath
+      [Terminology Service API](https://www.hl7.org/fhir/fhirpath.html#txapi).
+      See the [Implementation Status](#implementation-status) section for the
+      currently supported %terminologies APIs.
 
 Note:  The resource will be modified by this function to add type information.
 

src/additional.js

@@ -27,11 +27,14 @@ engine.memberOf = function (coll, valueset ) {
 
   if (typeof valueset === 'string' && /^https?:\/\/.*/.test(valueset)) {
     const terminologies = this.processedVars.terminologies;
+    if (!terminologies) {
+      throw new Error("Option \"termologyUrl\" is not specified.");
+    }
     return Terminologies.validateVS(
       [terminologies], valueset, util.valData(coll[0]), ''
     ).then(params => {
       return params.parameter.find((p) => p.name === "result").valueBoolean;
-    });
+    }, () => []);
   }
 
   // If the valueset cannot be resolved as an uri to a value set,

src/terminologies.js

@@ -63,15 +63,36 @@ class Terminologies {
         { method: "POST", headers: myHeaders, body: JSON.stringify(parameters) }
       );
     } else if (typeof coded === "string") {
-      const queryParams = new URLSearchParams({
+      const queryParams1 = new URLSearchParams({
         url: valueset,
-        code: coded,
-        inferSystem: true
       });
+      //  Workaround for the case where we don't have a system. See discussion here:
+      //  https://chat.fhir.org/#narrow/stream/179266-fhirpath/topic/Problem.20with.20the.20.22memberOf.22.20function.20and.20R4.20servers
       response = fetch(
-        `${requestUrl}?${queryParams.toString() + (params ? '&' + params : '')}`,
-        { headers: myHeaders }
-      );
+        `${self[0].terminologyUrl}/ValueSet?${queryParams1.toString() + (params ? '&' + params : '')}`,
+        {headers: myHeaders}
+      )
+        .then(r => r.json())
+        .then((bundle) => {
+          const system = bundle?.entry?.length === 1 && (
+            bundle.entry[0].resource.compose?.include?.length === 1
+            && bundle.entry[0].resource.compose.include[0].system
+            || bundle.entry[0].resource.expansion?.contains?.length === 1
+            && bundle.entry[0].resource.expansion?.contains[0].system);
+          if (system) {
+            const queryParams2 = new URLSearchParams({
+              url: valueset,
+              code: coded,
+              system
+            });
+            return fetch(
+              `${requestUrl}?${queryParams2.toString() + (params ? '&' + params : '')}`,
+              { headers: myHeaders }
+            );
+          } else {
+            throw new Error('The valueset does not have a single code system.');
+          }
+        });
     } else {
       if (coded.code) {
         const queryParams = new URLSearchParams({
@@ -91,17 +112,11 @@ class Terminologies {
     // to do the conversion.
     return Promise.resolve(response)
       .then(r => r.json())
-      .then(resultJson => {
-        if (response) {
-          let params = resultJson;
-          if (params && params.parameter) {
-            return params;
-          }
-          let outcomeResult = resultJson;
-          if (outcomeResult && outcomeResult.issue) {
-            throw outcomeResult;
-          }
+      .then(params => {
+        if (params?.parameter) {
+          return params;
         }
+        throw new Error(params);
       })
       .catch(() => {
         const key = createIndexKeyMemberOf(coded, valueset);

test/async-functions.test.js

@@ -54,26 +54,35 @@ describe('Async functions', () => {
       })
     });
 
-/*
-    // TODO: This unit test works only with the third-party server
-    //  (see the terminologyUrl option below). Also I posted a question here:
-    //  https://chat.fhir.org/#narrow/stream/179266-fhirpath/topic/Problem.20with.20the.20.22memberOf.22.20function.20and.20R4.20servers
     it('should work with Code when async functions are enabled', (done) => {
-
       let result = fhirpath.evaluate(
         resource,
         "Observation.code.coding.code[0].memberOf('http://hl7.org/fhir/ValueSet/observation-vitalsignresult')",
         {},
         model,
-        { async: true, terminologyUrl: "https://r4.ontoserver.csiro.au/fhir" }
+        { async: true, terminologyUrl: "https://lforms-fhir.nlm.nih.gov/baseR4" }
       );
       expect(result instanceof Promise).toBe(true);
       result.then((r) => {
         expect(r).toEqual([true]);
         done();
       })
     });
-*/
+
+    it('should return an empty result when the ValueSet cannot be resolved', (done) => {
+      let result = fhirpath.evaluate(
+        resource,
+        "Observation.code.coding.code[0].memberOf('http://unknown-valueset')",
+        {},
+        model,
+        { async: true, terminologyUrl: "https://lforms-fhir.nlm.nih.gov/baseR4" }
+      );
+      expect(result instanceof Promise).toBe(true);
+      result.then((r) => {
+        expect(r).toEqual([]);
+        done();
+      })
+    });
 
     it('should throw an exception when async functions are disabled', () => {