fhirsmith 0.11.1 → 0.12.0

package/tx/params.js

@@ -61,6 +61,11 @@ class TxParameters {
     this.FValueSetVersionRules = null;
     this.FUid = '';
 
+    // names of single-valued parameters that have been set explicitly, so that
+    // parameters seen later with overwrite=false (i.e. from a ValueSet's
+    // embedded expansion parameters) don't clobber them. See seeParameter.
+    this.FSeen = new Set;
+
     this.FActiveOnly = false;
     this.FExcludeNested = false;
     this.FExcludeNotForUI = false;
@@ -104,173 +109,9 @@ class TxParameters {
     }
 
     for (let p of params.parameter) {
-      switch (p.name) {
-        // Version rules
-        case 'system-version': {
-          this.seeVersionRule(getValuePrimitive(p), false,'default');
-          break;
-        }
-        case 'check-system-version': {
-          this.seeVersionRule(getValuePrimitive(p), false, 'check');
-          break;
-        }
-        case 'force-system-version': {
-          this.seeVersionRule(getValuePrimitive(p), false, 'override');
-          break;
-        }
-        case 'default-valueset-version': {
-          this.seeVersionRule(getValuePrimitive(p), true, 'default');
-          break;
-        }
-        case 'force-valueset-version': {
-          this.seeVersionRule(getValuePrimitive(p), true, 'override');
-          break;
-        }
-        case 'check-valueset-version': {
-          this.seeVersionRule(getValuePrimitive(p), true, 'check');
-          break;
-        }
-
-        case 'displayLanguage': {
-          try {
-            const lang = getValuePrimitive(p);
-            this.DisplayLanguages = Languages.fromAcceptLanguage(lang, this.languageDefinitions, !this.validating);
-            if (lang) this.FHasDisplayLanguages = true;
-          } catch (error) {
-            throw new Issue("error", "processing", null, 'INVALID_DISPLAY_NAME', this.i18n.translate('INVALID_DISPLAY_NAME', this.HTTPLanguages, [getValuePrimitive(p)]), "invalid-display").handleAsOO(400);
-          }
-          break;
-        }
-        case 'designation': {
-          this.designations.push(getValuePrimitive(p));
-          break;
-        }
-        case 'property': {
-          this.properties.push(getValuePrimitive(p));
-          break;
-        }
-        case 'no-cache': {
-          // Write FUid (the field the cache key reads via hashSource); writing
-          // `this.uid` was a no-op so no-cache=true never busted the cache.
-          // Accept both the string ('true') and boolean (valueBoolean) forms.
-          if (strToBool(getValuePrimitive(p), false)) this.FUid = crypto.randomUUID();
-          break;
-        }
-        case '_incomplete':
-        case 'limitedExpansion': {
-          let value = getValuePrimitive(p);
-          this.limitedExpansion = strToBool(value, false);
-          break;
-        }
-        case 'includeDesignations': {
-          let value = getValuePrimitive(p);
-          this.includeDesignations = strToBool(value, false);
-          break;
-        }
-        case 'includeDefinition': {
-          let value = getValuePrimitive(p);
-          this.includeDefinition = strToBool(value, false);
-          break;
-        }
-        case 'activeOnly': {
-          let value = getValuePrimitive(p);
-          this.activeOnly = strToBool(value, false);
-          break;
-        }
-        case 'excludeNested': {
-          let value = getValuePrimitive(p);
-          this.excludeNested = strToBool(value, false);
-          break;
-        }
-        case 'excludeNotForUI': {
-          let value = getValuePrimitive(p);
-          this.excludeNotForUI = strToBool(value, false);
-          break;
-        }
-        case 'excludePostCoordinated': {
-          let value = getValuePrimitive(p);
-          this.excludePostCoordinated = strToBool(value, false);
-          break;
-        }
-        case 'default-to-latest-version': {
-          let value = getValuePrimitive(p);
-          this.defaultToLatestVersion = strToBool(value, false);
-          break;
-        }
-        case 'incomplete-ok': {
-          let value = getValuePrimitive(p);
-          this.incompleteOK = strToBool(value, false);
-          break;
-        }
-        case 'diagnostics': {
-          let value = getValuePrimitive(p);
-          this.diagnostics = strToBool(value, false);
-          break;
-        }
-        case 'lenient-display-validation': {
-          if (getValuePrimitive(p) == true) this.displayWarning = true;
-          break;
-        }
-        case 'valueset-membership-only': {
-          if (getValuePrimitive(p) == true) this.membershipOnly = true;
-          break;
-        }
-        case 'versionsMatch' : {
-          if (getValuePrimitive(p) == true) this.FVersionsMatch = true;
-          break;
-        }
-        case 'profile' : {
-          let value = p.resource;
-          if (value && (value.resourceType === 'Parameters' || value.resourceType === 'ExpansionProfile')) {
-            this.readParams(value);
-          }
-          break;
-        }
-        // eslint-disable-next-line no-fallthrough
-        case 'term': // jQuery support
-        case 'filter' : {
-          this.filter = getValuePrimitive(p);
-          break;
-        }
-        case 'count' : {
-          this.count = Utilities.parseIntOrDefault(getValuePrimitive(p), -1);
-          break;
-        }
-        case 'offset' : {
-          this.offset = Utilities.parseIntOrDefault(getValuePrimitive(p), -1);
-          break;
-        }
-
-        case 'limit' : {
-          this.limit = Utilities.parseIntOrDefault(getValuePrimitive(p), -1);
-          break;
-        }
-
-        case 'useSupplement' : {
-          this.supplements.add(getValuePrimitive(p));
-          break;
-        }
-
-        case 'abstract': {
-          if (getValuePrimitive(p) == true) {
-            this.abstractOk = true;
-          } else if (getValuePrimitive(p) == false) {
-            this.abstractOk = false;
-          }
-          break;
-        }
-        case 'inferSystem': {
-          if (getValuePrimitive(p) == true) this.inferSystem = true;
-          break;
-        }
-        case 'sort': {
-          this.sort = getValuePrimitive(p);
-          break;
-        }
-        case "exclude-system": {
-          throw new Issue('error', 'not-supported', null, null, "The parameter 'exclude-system' is not supported by this system", null, 400);
-        }
-      }
+      // parameters that come from the request itself always win over anything
+      // seen earlier (e.g. from a ValueSet's embedded expansion parameters)
+      this.seeParameter(p.name, p, true);
     }
 
   }
@@ -415,7 +256,7 @@ class TxParameters {
     this.FVersionsMatch = value;
     this.hasVersionsMatch = true;
   }
-e
+
   get versionRules() {
     return this.FVersionRules;
   }
@@ -432,19 +273,225 @@ e
     return new TxParameters(langDefs);
   }
 
+  /**
+   * Process a single parameter. This is the single place where parameter names
+   * are interpreted; both the request Parameters resource (see readParams) and
+   * the valueset-expansion-parameter extension route through here.
+   *
+   * @param {string} name - the parameter name
+   * @param {Object} value - any element getValuePrimitive() understands: a
+   *   Parameters.parameter entry, or the 'value' sub-extension of a
+   *   valueset-expansion-parameter extension
+   * @param {boolean} overwrite - true when the parameter comes from the request
+   *   (later values win); false when it comes from a ValueSet's embedded
+   *   expansion parameters, which must not clobber what the request set
+   *   explicitly. Parameters that accumulate (version rules, designations,
+   *   properties, supplements) are unaffected - they always add.
+   */
   seeParameter(name, value, overwrite) {
-    if (value) {
-      if (name === 'displayLanguage' && (!this.FDisplayLanguages || overwrite)) {
-        this.DisplayLanguages = Languages.fromAcceptLanguage(getValuePrimitive(value), this.languageDefinitions, !this.validating)
-        if (getValuePrimitive(value)) this.FHasDisplayLanguages = true;
+    if (!name || !value) {
+      return;
+    }
+
+    // returns false if this single-valued parameter has already been set
+    // explicitly and we're not allowed to overwrite it
+    const claim = (key) => {
+      if (!overwrite && this.FSeen.has(key)) {
+        return false;
+      }
+      this.FSeen.add(key);
+      return true;
+    };
+    // string ('true') and boolean (valueBoolean) forms are both accepted, since
+    // GET parameters always arrive as valueString
+    const asBool = () => strToBool(getValuePrimitive(value), false);
+
+    switch (name) {
+      // -- accumulating parameters: version rules --------------------------
+      case 'system-version': {
+        this.seeVersionRule(getValuePrimitive(value), false, 'default');
+        break;
+      }
+      case 'check-system-version': {
+        this.seeVersionRule(getValuePrimitive(value), false, 'check');
+        break;
+      }
+      case 'force-system-version': {
+        this.seeVersionRule(getValuePrimitive(value), false, 'override');
+        break;
+      }
+      case 'default-valueset-version': {
+        this.seeVersionRule(getValuePrimitive(value), true, 'default');
+        break;
+      }
+      case 'force-valueset-version': {
+        this.seeVersionRule(getValuePrimitive(value), true, 'override');
+        break;
+      }
+      case 'check-valueset-version': {
+        this.seeVersionRule(getValuePrimitive(value), true, 'check');
+        break;
       }
 
-      if (name === 'designation') {
+      // -- other accumulating parameters -----------------------------------
+      case 'designation': {
         this.designations.push(getValuePrimitive(value));
+        break;
+      }
+      case 'property': {
+        // properties can arrive from the request, from an expansion parameter
+        // extension, and (R6) from ValueSet.compose.property, so de-duplicate:
+        // a repeat would emit the property twice and change the cache key
+        const prop = getValuePrimitive(value);
+        if (prop && !this.properties.includes(prop)) {
+          this.properties.push(prop);
+        }
+        break;
+      }
+      case 'useSupplement': {
+        this.supplements.add(getValuePrimitive(value));
+        break;
       }
 
-      if (name === 'versionsMatch') {
-        this.versionsMatch = getValuePrimitive(value) === 'true';
+      // -- single valued parameters ----------------------------------------
+      case 'displayLanguage': {
+        if (claim('displayLanguage')) {
+          const lang = getValuePrimitive(value);
+          try {
+            this.DisplayLanguages = Languages.fromAcceptLanguage(lang, this.languageDefinitions, !this.validating);
+            if (lang) this.FHasDisplayLanguages = true;
+          } catch (error) {
+            throw new Issue("error", "processing", null, 'INVALID_DISPLAY_NAME', this.i18n.translate('INVALID_DISPLAY_NAME', this.HTTPLanguages, [lang]), "invalid-display").handleAsOO(400);
+          }
+        }
+        break;
+      }
+      case 'no-cache': {
+        // Write FUid (the field the cache key reads via hashSource); writing
+        // `this.uid` was a no-op so no-cache=true never busted the cache.
+        if (claim('no-cache') && asBool()) this.FUid = crypto.randomUUID();
+        break;
+      }
+      case '_incomplete':
+      case 'limitedExpansion': {
+        if (claim('limitedExpansion')) this.limitedExpansion = asBool();
+        break;
+      }
+      case 'includeDesignations': {
+        if (claim('includeDesignations')) this.includeDesignations = asBool();
+        break;
+      }
+      case 'includeDefinition': {
+        if (claim('includeDefinition')) this.includeDefinition = asBool();
+        break;
+      }
+      case 'activeOnly': {
+        if (claim('activeOnly')) this.activeOnly = asBool();
+        break;
+      }
+      case 'excludeNested': {
+        if (claim('excludeNested')) this.excludeNested = asBool();
+        break;
+      }
+      case 'excludeNotForUI': {
+        if (claim('excludeNotForUI')) this.excludeNotForUI = asBool();
+        break;
+      }
+      case 'excludePostCoordinated': {
+        if (claim('excludePostCoordinated')) this.excludePostCoordinated = asBool();
+        break;
+      }
+      case 'default-to-latest-version': {
+        if (claim('default-to-latest-version')) this.defaultToLatestVersion = asBool();
+        break;
+      }
+      case 'incomplete-ok': {
+        if (claim('incomplete-ok')) this.incompleteOK = asBool();
+        break;
+      }
+      case 'diagnostics': {
+        if (claim('diagnostics')) this.diagnostics = asBool();
+        break;
+      }
+      case 'lenient-display-validation': {
+        if (claim('lenient-display-validation')) this.displayWarning = asBool();
+        break;
+      }
+      case 'valueset-membership-only': {
+        if (claim('valueset-membership-only')) this.membershipOnly = asBool();
+        break;
+      }
+      case 'versionsMatch': {
+        if (claim('versionsMatch')) this.versionsMatch = asBool();
+        break;
+      }
+      case 'inferSystem': {
+        if (claim('inferSystem')) this.inferSystem = asBool();
+        break;
+      }
+      case 'abstract': {
+        // tri-state: only an explicit true/false changes the default (true)
+        const v = getValuePrimitive(value);
+        if (v === true || v === 'true') {
+          if (claim('abstract')) this.abstractOk = true;
+        } else if (v === false || v === 'false') {
+          if (claim('abstract')) this.abstractOk = false;
+        }
+        break;
+      }
+      case 'term': // jQuery support
+      case 'filter': {
+        if (claim('filter')) this.filter = getValuePrimitive(value);
+        break;
+      }
+      case 'count': {
+        if (claim('count')) this.count = Utilities.parseIntOrDefault(getValuePrimitive(value), -1);
+        break;
+      }
+      case 'offset': {
+        if (claim('offset')) this.offset = Utilities.parseIntOrDefault(getValuePrimitive(value), -1);
+        break;
+      }
+      case 'limit': {
+        if (claim('limit')) this.limit = Utilities.parseIntOrDefault(getValuePrimitive(value), -1);
+        break;
+      }
+      case 'sort': {
+        if (claim('sort')) this.sort = getValuePrimitive(value);
+        break;
+      }
+
+      // -- nested parameters -------------------------------------------------
+      case 'profile': {
+        // only meaningful from a Parameters.parameter, which can carry a resource
+        const res = value.resource;
+        if (res && (res.resourceType === 'Parameters' || res.resourceType === 'ExpansionProfile')) {
+          this.readParams(res);
+        }
+        break;
+      }
+
+      case 'exclude-system': {
+        throw new Issue('error', 'not-supported', null, null, "The parameter 'exclude-system' is not supported by this system", null, 400);
+      }
+    }
+  }
+
+  /**
+   * Read parameters a ValueSet declares on its own compose. Presently that's
+   * R6's ValueSet.compose.property (0..* code) - the properties to return in
+   * the expansion, named by the value set rather than by the request. We don't
+   * formally support R6, but the element is harmless in earlier versions and
+   * honouring it costs nothing.
+   *
+   * @param {Object} compose - ValueSet.compose (raw JSON)
+   */
+  seeCompose(compose) {
+    if (compose && Array.isArray(compose.property)) {
+      for (const prop of compose.property) {
+        if (typeof prop === 'string') {
+          this.seeParameter('property', {valueCode: prop}, false);
+        }
       }
     }
   }
@@ -639,6 +686,10 @@ e
     this.hasDisplayWarning = other.hasDisplayWarning;
     this.sort = other.sort;
 
+    if (other.FSeen) {
+      this.FSeen = new Set(other.FSeen);
+    }
+
     if (other.FProperties) {
       this.FProperties = [...other.FProperties];
     }