Changes as per review

LF-2985

Author: yuriy-sedinkin

.eslintrc.yml

@@ -8,6 +8,9 @@ parserOptions:
   ecmaVersion: 2016
   requireConfigFile: false
   sourceType: module
+globals:
+  Headers: true
+  fetch: true
 rules:
   indent:
     - error

README.md

@@ -153,6 +153,8 @@ let tracefunction = function (x, label) {
 const res = fhirpath.evaluate(contextNode, path, environment, fhirpath_r4_model, { traceFn: tracefunction });
 ```
 
+### Asynchronous functions
+
 Some FHIRPath functions may be asynchronous. These functions throw exceptions by default.
 To enable these functions, we need to pass the `async` option to `evaluate` or `compile`.
 `async=true` enables return of a Promise only for expressions containing asynchronous functions.
@@ -163,15 +165,15 @@ For example, using the `memberOf` function might look like this:
 fhirpath.evaluate(
   resource,
   "Observation.code.coding.where(memberOf('http://hl7.org/fhir/ValueSet/observation-vitalsignresult'))",
-  { terminologies: { validateVS }},
+  {},
   model,
-  { async: true }
+  { async: true, serverUrl: 'https://lforms-fhir.nlm.nih.gov/baseR4' }
 )
 ```
 
-Please note that for the `memberOf` function to work we must define a general
-%terminologies object. See https://build.fhir.org/fhirpath.html#txapi and example
-in `test/async-functions.test.js`.
+Please note that for the `memberOf` function to work we must define a serverURL
+option that will be used by the %terminologies.validateVS function.
+(see https://build.fhir.org/fhirpath.html#txapi).
 
 ### User-defined functions
 

bin/fhirpath

@@ -45,7 +45,10 @@ else {
         throw new Error('FHIR model must be one of '+supportedVersions);
       model = require('../fhir-context/'+options.model);
     }
-    let res = fp.evaluate(resource, base ? {base, expression} : expression, context, model);
+    let res = fp.evaluate(
+      resource, base ? {base, expression} : expression, context, model,
+      { async: true }
+    );
 
     if (res instanceof Promise) {
       res.then((r) => printResult(expression, r))

index.d.ts

@@ -77,7 +77,8 @@ interface Options {
   resolveInternalTypes?: boolean
   traceFn?: (value: any, label: string) => void,
   userInvocationTable?: UserInvocationTable,
-  async: false|true|'always'
+  async: false|true|'always',
+  serverUrl: string
 }
 
 type Compile = (resource: any, context?: Context) => any[];

package-lock.json

@@ -6,25 +6,33 @@ let engine = {};
 
 /**
  * Returns true if the code is a member of the given valueset.
- * @param {(string | Coding | CodeableConcept)[]} coll - input collection
+ * @param {(string|Object)[]} coll - input collection with a single Coding,
+ *  CodeableConcept, or code element.
  * @param {string} valueset - value set URL
- * @return {Promise<{[p: string]: PromiseSettledResult<Awaited<*>>, [p: number]: PromiseSettledResult<Awaited<*>>, [p: symbol]: PromiseSettledResult<Awaited<*>>}>}
+ * @return {Promise<boolean>|[]} - promise of a boolean value indicating that
+ *  there is one element in the input collection whose code is a member of the
+ *  specified value set.
  */
 engine.memberOf = function (coll, valueset ) {
   if (!this.async) {
-    throw new Error('The asynchronous function "memberOf" is not allowed. To enable asynchronous functions, use the async=true or async="always" option.');
+    throw new Error('The asynchronous function "memberOf" is not allowed. ' +
+      'To enable asynchronous functions, use the async=true or async="always"' +
+      ' option.');
   }
   // If the input is empty or has more than one value, the return value is empty
   if (coll.length !== 1 || coll[0] == null) {
     return [];
   }
 
   if (typeof valueset === 'string' && /^https?:\/\/.*/.test(valueset)) {
-    const terminologies = this.vars.terminologies || this.processedVars.terminologies;
-    return terminologies.validateVS(valueset, util.valData(coll[0]), '');
+    return this.terminologies.validateVS(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, the return value is empty.
+  // If the valueset cannot be resolved as an uri to a value set,
+  // the return value is empty.
   return [];
 };
 

src/additional.js

@@ -27,18 +27,18 @@ engine.existsMacro  = function(coll, expr) {
 };
 
 engine.allMacro = function(coll, expr) {
-  const promisses = [];
+  const promises = [];
   for (let i=0, len=coll.length; i<len; ++i) {
     this.$index = i;
     const exprRes = expr(coll[i]);
     if (exprRes instanceof Promise) {
-      promisses.push(exprRes);
+      promises.push(exprRes);
     } else if(!util.isTrue(exprRes)){
       return [false];
     }
   }
-  if (promisses.length) {
-    return Promise.all(promisses).then(r => r.some(i => !util.isTrue(i)) ? [false] : [true]);
+  if (promises.length) {
+    return Promise.all(promises).then(r => r.some(i => !util.isTrue(i)) ? [false] : [true]);
   }
   return [true];
 };

src/existence.js

@@ -54,6 +54,7 @@ const {
   FP_Type, ResourceNode, TypeInfo
 } = types;
 let makeResNode = ResourceNode.makeResNode;
+const Terminologies = require('./terminologies');
 
 // * fn: handler
 // * arity: is index map with type signature
@@ -494,9 +495,7 @@ function doInvoke(ctx, fnName, data, rawParams){
     if(!invoc.arity){
       if(!rawParams){
         res = invoc.fn.call(ctx, data);
-        return res instanceof Promise
-          ? res.then(r => util.arraify(r))
-          : util.arraify(res);
+        return util.resolveAndArraify(res);
       } else {
         throw new Error(fnName + " expects no params");
       }
@@ -519,15 +518,11 @@ function doInvoke(ctx, fnName, data, rawParams){
         if (params.some(p => p instanceof Promise)) {
           return Promise.all(params).then(p => {
             res = invoc.fn.apply(ctx, p);
-            return res instanceof Promise
-              ? res.then(r => util.arraify(r))
-              : util.arraify(res);
+            return util.resolveAndArraify(res);
           });
         }
         res = invoc.fn.apply(ctx, params);
-        return res instanceof Promise
-          ? res.then(r => util.arraify(r))
-          : util.arraify(res);
+        return util.resolveAndArraify(res);
       } else {
         console.log(fnName + " wrong arity: got " + paramsNumber );
         return [];
@@ -702,9 +697,10 @@ function parse(path) {
  * @param {object} [options.userInvocationTable] - a user invocation table used
  *  to replace any existing or define new functions.
  * @param {boolean|string} [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,
+ *  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.
+ *  @param {string} [options.serverUrl] - a URL that points to a FHIR RESTful API.
  */
 function applyParsedPath(resource, parsedPath, context, model, options) {
   constants.reset();
@@ -728,6 +724,9 @@ function applyParsedPath(resource, parsedPath, context, model, options) {
   if (options.async) {
     ctx.async = options.async;
   }
+  if (options.serverUrl) {
+    ctx.terminologies = new Terminologies(options.serverUrl);
+  }
   const res = engine.doEval(ctx, dataRoot, parsedPath.children[0]);
   return res instanceof Promise
     ? res.then(r => prepareEvalResult(r, options))
@@ -822,6 +821,7 @@ function resolveInternalTypes(val) {
  *  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.
+ * @param {string} [options.serverUrl] - a URL that points to a FHIR RESTful API.
  */
 function evaluate(fhirData, path, context, model, options) {
   return compile(path, model, options)(fhirData, context);
@@ -849,6 +849,7 @@ function evaluate(fhirData, path, context, model, options) {
  *  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.
+ *  @param {string} [options.serverUrl] - a URL that points to a FHIR RESTful API.
  */
 function compile(path, model, options) {
   options = {

src/fhirpath.js

@@ -54,18 +54,26 @@ engine.repeatMacro = function(parentData, expr, res = [], unique = {}) {
     return Promise.all(newItems).then(items => {
       items = [].concat(...items);
       if (items.length) {
-        return engine.repeatMacro(getUniqItems(items, unique, res), expr, res, unique);
+        return engine.repeatMacro(getNewItems(items, unique, res), expr, res, unique);
       }
       return res;
     });
   } else if (newItems.length) {
-    return engine.repeatMacro(getUniqItems(newItems, unique, res), expr, res, unique);
+    return engine.repeatMacro(getNewItems(newItems, unique, res), expr, res, unique);
   } else {
     return res;
   }
 };
 
-function getUniqItems(items, unique, res) {
+/**
+ * Returns new items from the input array that are not in the hash of existing
+ * unique items and adds them to the result array.
+ * @param {Array<*>} items - inout array.
+ * @param {{[key: string]: *}} unique - hash of existing unique items
+ * @param {Array<*>} res - result array.
+ * @return {Array<*>}
+ */
+function getNewItems(items, unique, res) {
   const newItems = items.filter(item => {
     const key = hashObject(item);
     const isUnique = !unique[key];