fhirsmith 0.9.6 → 0.10.0

package/tx/library.js

@@ -1,7 +1,9 @@
 const fs = require('fs').promises;
 const path = require('path');
+const crypto = require('crypto');
 const yaml = require('yaml'); // npm install yaml
 const { PackageManager, PackageContentLoader } = require('../library/package-manager');
+const { FolderContentLoader } = require('../library/folder-content-loader');
 const { CodeSystem } = require("./library/codesystem");
 const {CountryCodeFactoryProvider} = require("./cs/cs-country");
 const {Iso4217FactoryProvider} = require("./cs/cs-currency");
@@ -295,6 +297,10 @@ class Library {
         await this.loadOcl(details, isDefault, mode);
         break;
 
+      case 'folder':
+        await this.loadFolder(details, isDefault, mode);
+        break;
+
       default:
         throw new Error(`Unknown source type: ${type}`);
     }
@@ -598,6 +604,23 @@ class Library {
       version = parts[1];
     }
     const packagePath = await packageManager.fetch(packageId, version);
+    await this.#loadPackageFromPath(packagePath, mode, csOnly);
+  }
+
+  async loadUrl(packageManager, url, isDefault, mode, csOnly) {
+    const packagePath = await packageManager.fetchUrl(url);
+    await this.#loadPackageFromPath(packagePath, mode, csOnly);
+  }
+
+  /**
+   * Shared loader for npm- and url-sourced packages. Given a fetched package
+   * path, loads its CodeSystems (and, unless csOnly, its ValueSets and
+   * ConceptMaps) into this library. Factored out of loadNpm/loadUrl so the two
+   * cannot drift apart (a past divergence here used Map-style .set() on the
+   * array-backed codeSystems list, breaking url sources).
+   * @private
+   */
+  async #loadPackageFromPath(packagePath, mode, csOnly) {
     if (mode === "fetch" || mode === "cs") {
       return;
     }
@@ -634,43 +657,64 @@ class Library {
     this.#logPackage(contentLoader.id(), contentLoader.version(), csc, vs ? vs.valueSetMap.size : 0);
   }
 
-  async loadUrl(packageManager, url, isDefault, mode, csOnly) {
-    const packagePath = await packageManager.fetchUrl(url);
+  /**
+   * Loads CodeSystem / ValueSet / ConceptMap resources from any *.json file in a folder.
+   * The folder is scanned (top level only); each JSON file is read and routed to the
+   * appropriate provider based on its resourceType. Files that fail to parse or whose
+   * resourceType isn't one of the three terminology types are silently skipped.
+   *
+   * Relative paths are resolved against the project root (same convention as loadUcum etc.).
+   *
+   * @param {string} details - The folder to scan
+   * @param {boolean} isDefault - Unused; folder sources don't register factories
+   * @param {string} mode - One of "fetch", "cs", "npm"
+   */
+  // eslint-disable-next-line no-unused-vars
+  async loadFolder(details, isDefault, mode) {
     if (mode === "fetch" || mode === "cs") {
       return;
     }
-    const fullPackagePath = path.join(this.cacheFolder, packagePath);
-    const contentLoader = new PackageContentLoader(fullPackagePath);
+
+    const folderPath = path.isAbsolute(details)
+      ? details
+      : path.resolve(path.join(__dirname, '..', details));
+
+    // Park the Package*Provider SQLite caches under the terminology cache rather
+    // than polluting the user's source folder, and wipe between runs so edits to
+    // the source folder are reliably picked up.
+    const hash = crypto.createHash('sha1').update(folderPath).digest('hex').substring(0, 16);
+    const cacheSubdir = path.join(this.cacheFolder, 'folder-source-' + hash);
+    await fs.rm(cacheSubdir, { recursive: true, force: true });
+    await fs.mkdir(cacheSubdir, { recursive: true });
+
+    const contentLoader = new FolderContentLoader(folderPath, cacheSubdir);
     await contentLoader.initialize();
 
-    this.packageSources.push(contentLoader.id()+"#"+contentLoader.version());
+    this.packageSources.push(contentLoader.id() + "#" + contentLoader.version());
 
-    let cp = new ListCodeSystemProvider();
-    const resources = await contentLoader.getResourcesByType("CodeSystem");
+    const cp = new ListCodeSystemProvider();
+    const csEntries = await contentLoader.getResourcesByType("CodeSystem");
     let csc = 0;
-    for (const resource of resources) {
-      const cs = new CodeSystem(await contentLoader.loadFile(resource, contentLoader.fhirVersion()));
+    for (const entry of csEntries) {
+      const cs = new CodeSystem(await contentLoader.loadFile(entry, contentLoader.fhirVersion()));
       if (this.#isIgnored(cs.url, cs.version)) {
         this.log.info(`Ignoring CodeSystem ${cs.url}${cs.version ? '#' + cs.version : ''} (excluded by config)`);
         continue;
       }
       cs.sourcePackage = contentLoader.pid();
-      cp.codeSystems.set(cs.url, cs);
-      cp.codeSystems.set(cs.vurl, cs);
+      cp.codeSystems.push(cs);
       csc++;
     }
     this.codeSystemProviders.push(cp);
-    let vs = null;
-    if (!csOnly) {
-      vs = new PackageValueSetProvider(contentLoader);
-      await vs.initialize();
-      this.valueSetProviders.push(vs);
-      const cm = new PackageConceptMapProvider(contentLoader);
-      await cm.initialize();
-      this.conceptMapProviders.push(cm);
-    }
 
-    this.#logPackage(contentLoader.id(), contentLoader.version(), csc, vs ? vs.valueSetMap.size : 0);
+    const vs = new PackageValueSetProvider(contentLoader);
+    await vs.initialize();
+    this.valueSetProviders.push(vs);
+    const cm = new PackageConceptMapProvider(contentLoader);
+    await cm.initialize();
+    this.conceptMapProviders.push(cm);
+
+    this.#logPackage(contentLoader.id(), contentLoader.version(), csc, vs.valueSetMap.size);
   }
 
   /**

package/tx/operation-context.js

@@ -3,6 +3,7 @@ const inspector = require("inspector");
 const crypto = require("crypto");
 const {Languages} = require("../library/languages");
 const {Issue} = require("./library/operation-outcome");
+const Logger = require("../library/logger");
 
 /**
  * Check if running under a debugger
@@ -59,6 +60,37 @@ class ResourceCache {
     this.stats = stats;
     this.cache = new Map();
     this.locks = new Map(); // For thread-safety with async operations
+    this.log = Logger.getInstance().child({module: 'tx-cache'});
+    // Running total of concepts across every resource in every entry, maintained
+    // incrementally on each mutation so cache sizing/limits are O(1) to consult.
+    // Each entry also carries its own `concepts` subtotal so removal/replacement
+    // can adjust the total without rescanning.
+    this.totalConcepts = 0;
+    // High-water marks (never decremented) - the most caches and the most concepts
+    // this cache has held at once, for capacity reporting.
+    this.maxConcepts = 0;
+    this.maxSizeValue = 0;
+  }
+
+  /**
+   * Update the high-water marks after a mutation that may have grown the cache.
+   */
+  _trackMax() {
+    if (this.totalConcepts > this.maxConcepts) {
+      this.maxConcepts = this.totalConcepts;
+    }
+    if (this.cache.size > this.maxSizeValue) {
+      this.maxSizeValue = this.cache.size;
+    }
+  }
+
+  /**
+   * Concept count of a single cached resource, or 0 if it doesn't expose one.
+   * @param {Object} resource
+   * @returns {number}
+   */
+  _conceptsOf(resource) {
+    return resource && typeof resource.conceptCount === 'function' ? resource.conceptCount() : 0;
   }
 
   /**
@@ -70,8 +102,10 @@ class ResourceCache {
     const entry = this.cache.get(cacheId);
     if (entry) {
       entry.lastUsed = Date.now();
+      this.log.info(`cache-id '${cacheId}': hit, returning ${entry.resources.length} resource(s): ${entry.resources.map(r => this._resourceKey(r)).join(', ')}`);
       return [...entry.resources]; // Return a copy
     }
+    this.log.info(`cache-id '${cacheId}': miss (no entry)`);
     return [];
   }
 
@@ -92,22 +126,32 @@ class ResourceCache {
   add(cacheId, resources) {
     if (!resources || resources.length === 0) return;
 
-    const entry = this.cache.get(cacheId) || { resources: [], lastUsed: Date.now() };
+    const entry = this.cache.get(cacheId) || { resources: [], lastUsed: Date.now(), concepts: 0 };
 
-    // Merge resources, avoiding duplicates by url+version
+    // Merge resources, avoiding duplicates by url+version. Keep the entry's concept
+    // subtotal and the cache-wide total in step with each insertion/replacement.
     for (const resource of resources) {
       const key = this._resourceKey(resource);
+      const newConcepts = this._conceptsOf(resource);
       const existingIndex = entry.resources.findIndex(r => this._resourceKey(r) === key);
       if (existingIndex >= 0) {
-        // Replace existing
+        // Replace existing: adjust by the difference
+        const delta = newConcepts - this._conceptsOf(entry.resources[existingIndex]);
         entry.resources[existingIndex] = resource;
+        entry.concepts += delta;
+        this.totalConcepts += delta;
+        this.log.info(`cache-id '${cacheId}': replaced ${key}`);
       } else {
         entry.resources.push(resource);
+        entry.concepts += newConcepts;
+        this.totalConcepts += newConcepts;
+        this.log.info(`cache-id '${cacheId}': added ${key}`);
       }
     }
 
     entry.lastUsed = Date.now();
     this.cache.set(cacheId, entry);
+    this._trackMax();
   }
 
   /**
@@ -116,10 +160,23 @@ class ResourceCache {
    * @param {Array} resources - Resources to set
    */
   set(cacheId, resources) {
+    this.log.info(`cache-id '${cacheId}': set (replace all) with ${resources.length} resource(s): ${resources.map(r => this._resourceKey(r)).join(', ')}`);
+    // Drop the old entry's contribution, then count the replacement.
+    const existing = this.cache.get(cacheId);
+    if (existing) {
+      this.totalConcepts -= existing.concepts || 0;
+    }
+    let concepts = 0;
+    for (const resource of resources) {
+      concepts += this._conceptsOf(resource);
+    }
+    this.totalConcepts += concepts;
     this.cache.set(cacheId, {
       resources: [...resources],
-      lastUsed: Date.now()
+      lastUsed: Date.now(),
+      concepts
     });
+    this._trackMax();
   }
 
   /**
@@ -127,6 +184,10 @@ class ResourceCache {
    * @param {string} cacheId - The cache identifier
    */
   clear(cacheId) {
+    const entry = this.cache.get(cacheId);
+    if (entry) {
+      this.totalConcepts -= entry.concepts || 0;
+    }
     this.cache.delete(cacheId);
   }
 
@@ -135,6 +196,7 @@ class ResourceCache {
    */
   clearAll() {
     this.cache.clear();
+    this.totalConcepts = 0;
   }
 
   /**
@@ -150,6 +212,7 @@ class ResourceCache {
     for (const [cacheId, entry] of this.cache.entries()) {
       if (now - entry.lastUsed > maxAge) {
         i++;
+        this.totalConcepts -= entry.concepts || 0;
         this.cache.delete(cacheId);
       }
     }
@@ -166,6 +229,41 @@ class ResourceCache {
     return this.cache.size;
   }
 
+  /**
+   * Total number of concepts held across every entry in the cache. Maintained
+   * incrementally, so this is O(1).
+   * @returns {number}
+   */
+  conceptCount() {
+    return this.totalConcepts;
+  }
+
+  /**
+   * Highest number of concepts this cache has held at once (high-water mark).
+   * @returns {number}
+   */
+  maxConceptCount() {
+    return this.maxConcepts;
+  }
+
+  /**
+   * Highest number of caches (cache-ids) this cache has held at once.
+   * @returns {number}
+   */
+  maxSize() {
+    return this.maxSizeValue;
+  }
+
+  /**
+   * Number of concepts held under a single cache-id (0 if unknown).
+   * @param {string} cacheId
+   * @returns {number}
+   */
+  conceptCountFor(cacheId) {
+    const entry = this.cache.get(cacheId);
+    return entry ? (entry.concepts || 0) : 0;
+  }
+
   /**
    * Generate a key for a resource based on url and version
    * @param {Object} resource - The resource
@@ -204,6 +302,10 @@ class ExpansionCache {
     this.cache = new Map();
     this.maxSize = maxSize;
     this.memoryThresholdBytes = memoryThresholdMB * 1024 * 1024;
+    // When true, every expansion is cached regardless of how long it took
+    // (bypasses MIN_CACHE_TIME_MS). Used by the test runner to force the cache
+    // path so cache correctness (e.g. language in the key) is exercised.
+    this.forceCaching = false;
   }
 
   /**
@@ -284,8 +386,9 @@ class ExpansionCache {
    * @returns {boolean} True if cached, false if duration too short
    */
   set(key, expansion, durationMs) {
-    // Only cache if expansion took significant time
-    if (durationMs < ExpansionCache.MIN_CACHE_TIME_MS) {
+    // Only cache if expansion took significant time, unless forceCaching is on
+    // (in which case everything is cached regardless of duration).
+    if (!this.forceCaching && durationMs < ExpansionCache.MIN_CACHE_TIME_MS) {
       return false;
     }
 
@@ -357,21 +460,6 @@ class ExpansionCache {
     return false;
   }
 
-  /**
-   * Force-store an expansion regardless of duration (for testing)
-   * @param {string} key - Hash key
-   * @param {Object} expansion - The expanded ValueSet
-   */
-  forceSet(key, expansion) {
-    this.cache.set(key, {
-      expansion: expansion,
-      createdAt: Date.now(),
-      lastUsed: Date.now(),
-      durationMs: 0,
-      hitCount: 0
-    });
-  }
-
   /**
    * Clear a specific entry
    * @param {string} key - Hash key
@@ -388,22 +476,22 @@ class ExpansionCache {
   }
 
   /**
-   * Get cache statistics
+   * Get cache statistics.
+   * NB: named getStats(), not stats() — the `stats` field (the ServerStats
+   * passed to the constructor) would shadow a method called `stats`, making it
+   * unreachable.
    * @returns {Object} Stats object
    */
-  stats() {
+  getStats() {
     let totalHits = 0;
-    let totalDuration = 0;
     for (const entry of this.cache.values()) {
       totalHits += entry.hitCount;
-      totalDuration += entry.durationMs;
     }
     return {
       size: this.cache.size,
       maxSize: this.maxSize,
       memoryThresholdMB: this.memoryThresholdBytes > 0 ? this.memoryThresholdBytes / (1024 * 1024) : 0,
-      totalHits,
-      totalDurationSaved: totalHits > 0 ? totalDuration * totalHits : 0
+      totalHits
     };
   }
 
@@ -447,6 +535,12 @@ class OperationContext {
     this.logEntries = [];
     this.resourceCache = resourceCache;
     this.expansionCache = expansionCache;
+    // Server-issued cache-id carried on the request (X-Cache-Id header). Set once
+    // per request from the header so every worker can consult it uniformly via
+    // setupAdditionalResources, regardless of how that worker assembles its
+    // Parameters (buildParameters, raw req.body, query/form). An explicit
+    // cache-id *parameter* still takes precedence over this.
+    this.cacheId = null;
     this.debugging = isDebugging();
     // Providers opened during this operation that need their underlying
     // resources (sqlite connections, etc.) released when the operation ends.
@@ -480,6 +574,7 @@ class OperationContext {
     newContext.timeTracker = this.timeTracker.link();
     newContext.logEntries = [...this.logEntries];
     newContext.debugging = this.debugging;
+    newContext.cacheId = this.cacheId;
     newContext.usageTracker = this.usageTracker;
     // Share the same provider-cleanup list so providers opened by the copy
     // are released when the parent operation ends.

package/tx/params.js

@@ -53,6 +53,11 @@ class TxParameters {
 
     this.FHTTPLanguages = null;
     this.FDisplayLanguages = null;
+    // Whether languages were explicitly supplied by the request (vs a
+    // synthesised default). Consumed by hasHTTPLanguages/hasDisplayLanguages so
+    // the requested language folds into the expansion cache key.
+    this.FHasHTTPLanguages = false;
+    this.FHasDisplayLanguages = false;
     this.FValueSetVersionRules = null;
     this.FUid = '';
 
@@ -87,11 +92,15 @@ class TxParameters {
     if (!params.parameter) {
       return;
     }
-    if (!this.hasHTTPLanguages && this.hasParam(params, "__Content-Language")) {
-      this.HTTPLanguages = Languages.fromAcceptLanguage(this.paramstr(params, "__Content-Language"), this.languageDefinitions, !this.validating);
+    if (this.hasParam(params, "__Content-Language")) {
+      const lang = this.paramstr(params, "__Content-Language");
+      this.HTTPLanguages = Languages.fromAcceptLanguage(lang, this.languageDefinitions, !this.validating);
+      if (lang) this.FHasHTTPLanguages = true;
     }
-    if (!this.hasHTTPLanguages && this.hasParam(params, "__Accept-Language")) {
-      this.HTTPLanguages = Languages.fromAcceptLanguage(this.paramstr(params, "__Accept-Language"), this.languageDefinitions, !this.validating);
+    if (this.hasParam(params, "__Accept-Language")) {
+      const lang = this.paramstr(params, "__Accept-Language");
+      this.HTTPLanguages = Languages.fromAcceptLanguage(lang, this.languageDefinitions, !this.validating);
+      if (lang) this.FHasHTTPLanguages = true;
     }
 
     for (let p of params.parameter) {
@@ -124,7 +133,9 @@ class TxParameters {
 
         case 'displayLanguage': {
           try {
-            this.DisplayLanguages = Languages.fromAcceptLanguage(getValuePrimitive(p), this.languageDefinitions, !this.validating);
+            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);
           }
@@ -139,7 +150,10 @@ class TxParameters {
           break;
         }
         case 'no-cache': {
-          if (getValuePrimitive(p) === 'true') this.uid = crypto.randomUUID();
+          // 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':
@@ -292,11 +306,11 @@ class TxParameters {
   }
 
   get hasHTTPLanguages() {
-    return this.FHTTPLanguages && this.FHTTPLanguages.source;
+    return this.FHasHTTPLanguages;
   }
 
   get hasDisplayLanguages() {
-    return this.FDisplayLanguages && this.FDisplayLanguages.source;
+    return this.FHasDisplayLanguages;
   }
 
   get hasDesignations() {
@@ -422,6 +436,7 @@ e
     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 === 'designation') {
@@ -561,6 +576,17 @@ e
     if (this.hasDesignations) {
       s = s + this.FDesignations.join(',') + '|';
     }
+    if (this.supplements && this.supplements.size > 0) {
+      // useSupplement changes the expansion result (and a bad supplement must
+      // error), so it must be part of the cache key. Sort for determinism.
+      s = s + '$' + [...this.supplements].sort().join(',') + '|';
+    }
+    // Further result-affecting parameters that were previously omitted from the
+    // key: the text filter (changes which codes expand), limited/incomplete
+    // expansion handling, whether abstract codes are included, and diagnostics.
+    // filter is free text, so JSON.stringify it to avoid delimiter collisions.
+    s = s + 'f:' + JSON.stringify(this.filter || '') + '|' +
+      b(this.limitedExpansion) + b(this.incompleteOK) + b(this.abstractOk) + b(this.diagnostics);
     for (let t of this.FVersionRules) {
       s = s + t.asString() + '|';
     }
@@ -623,9 +649,11 @@ e
 
     if (other.FHTTPLanguages) {
       this.FHTTPLanguages = other.FHTTPLanguages;
+      this.FHasHTTPLanguages = this.FHasHTTPLanguages || other.FHasHTTPLanguages;
     }
     if (other.FDisplayLanguages) {
       this.FDisplayLanguages = other.FDisplayLanguages;
+      this.FHasDisplayLanguages = this.FHasDisplayLanguages || other.FHasDisplayLanguages;
     }
   }
 

package/tx/provider.js

@@ -1,7 +1,8 @@
 const { CodeSystem } = require("./library/codesystem");
 const {VersionUtilities} = require("../library/version-utilities");
 const { FhirCodeSystemProvider} = require("./cs/cs-cs");
-const {OperationContext, TerminologyError} = require("./operation-context");
+const {OperationContext} = require("./operation-context");
+const {TerminologyError} = require("./library/errors");
 const {validateParameter, validateOptionalParameter, validateArrayParameter} = require("../library/utilities");
 const path = require("path");
 const {PackageContentLoader} = require("../library/package-manager");
@@ -498,14 +499,16 @@ class Provider {
   deleteCodeSystem(cs) {
     this.codeSystems.delete(cs.vurl);
     this.codeSystems.delete(cs.url);
+    // If other versions of the SAME url survive, re-point the unversioned [url]
+    // entry at the most-recent surviving version. Otherwise leave it deleted.
     let existing = null;
     for (let t of this.codeSystems.values()) {
-      if (!existing || t.isMoreRecent(existing)) {
+      if (t.url === cs.url && (!existing || t.isMoreRecent(existing))) {
         existing = t;
       }
     }
     if (existing) {
-      this.codeSystems.set(cs.url, cs);
+      this.codeSystems.set(existing.url, existing);
     }
   }
 

package/tx/tx-html.js

@@ -19,6 +19,7 @@ const {TerminologyCapabilitiesXML} = require("./xml/terminologycapabilities-xml"
 const {ParametersXML} = require("./xml/parameters-xml");
 const {OperationOutcomeXML} = require("./xml/operationoutcome-xml");
 const {debugLog} = require("./operation-context");
+const {InvalidError} = require("./library/errors");
 
 const txHtmlLog = Logger.getInstance().child({ module: 'tx-html' });
 
@@ -311,6 +312,12 @@ class TxHtmlRenderer {
       return await this.buildHomePage(req);
     } else {
       try {
+        if (json === null || json === undefined || typeof json !== 'object' || Array.isArray(json)) {
+          throw new InvalidError(`Cannot render: expected a FHIR resource object but got ${json === null ? 'null' : (Array.isArray(json) ? 'an array' : typeof json)}`);
+        }
+        if (json.resourceType === undefined || json.resourceType === null || typeof json.resourceType !== 'string' || json.resourceType === '') {
+          throw new InvalidError(`Cannot render: resource has no resourceType (got ${json.resourceType === undefined ? 'undefined' : JSON.stringify(json.resourceType)})`);
+        }
         const _fmt = req?.query?._format || req?.query?.format || req?.body?._format;
         const op = req ? req.path.includes("$") : false;
         const resourceType = json.resourceType;
@@ -464,6 +471,33 @@ class TxHtmlRenderer {
     if (param.valueCode !== undefined) {
       return `<code>${escape(param.valueCode)}</code>`;
     }
+    if (param.valueId !== undefined) {
+      return escape(String(param.valueId));
+    }
+    if (param.valueOid !== undefined) {
+      return escape(String(param.valueOid));
+    }
+    if (param.valueUuid !== undefined) {
+      return escape(String(param.valueUuid));
+    }
+    if (param.valueMarkdown !== undefined) {
+      // Render markdown to HTML the same way the rest of the server does, using
+      // commonmark in safe mode (raw HTML in the markdown is escaped, so this is
+      // XSS-safe).
+      const commonmark = require('commonmark');
+      const reader = new commonmark.Parser();
+      const writer = new commonmark.HtmlRenderer({ safe: true });
+      return writer.render(reader.parse(String(param.valueMarkdown)));
+    }
+    if (param.valueInteger64 !== undefined) {
+      return escape(String(param.valueInteger64));
+    }
+    if (param.valuePositiveInt !== undefined) {
+      return escape(String(param.valuePositiveInt));
+    }
+    if (param.valueUnsignedInt !== undefined) {
+      return escape(String(param.valueUnsignedInt));
+    }
     if (param.valueDate !== undefined) {
       return escape(param.valueDate);
     }