fhirsmith 0.3.0

package/tx/workers/worker.js

@@ -0,0 +1,904 @@
+const { TerminologyError } = require('../operation-context');
+const { CodeSystem } = require('../library/codesystem');
+const ValueSet = require('../library/valueset');
+const {VersionUtilities} = require("../../library/version-utilities");
+const {getValuePrimitive} = require("../../library/utilities");
+const {Issue} = require("../library/operation-outcome");
+const {Languages} = require("../../library/languages");
+const {ConceptMap} = require("../library/conceptmap");
+const {Renderer} = require("../library/renderer");
+
+/**
+ * Custom error for terminology setup issues
+ */
+class TerminologySetupError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'TerminologySetupError';
+  }
+}
+
+/**
+ * Abstract base class for terminology operations
+ */
+class TerminologyWorker {
+  usedSources = [];
+  additionalResources = []; // Resources provided via tx-resource parameter or cache
+  foundParameters = [];
+  renderer;
+
+  /**
+   * @param {OperationContext} opContext - Operation context
+   * @param {Logger} log - Provider for code systems and resources
+   * @param {Provider} provider - Provider for code systems and resources
+   * @param {LanguageDefinitions} languages - Language definitions
+   * @param {I18nSupport} i18n - Internationalization support
+   */
+  constructor(opContext, log, provider, languages, i18n) {
+    this.opContext = opContext;
+    this.log = log;
+    this.provider = provider;
+    this.languages = languages;
+    this.i18n = i18n;
+    this.noCacheThisOne = false;
+    this.params = null; // Will be set by subclasses
+    this.renderer = new Renderer(i18n, languages, provider);
+  }
+
+  /**
+   * Abstract method to get operation name
+   * @returns {string} Operation name
+   */
+  opName() {
+    return '??';
+  }
+
+  /**
+   * Abstract method to get value set handle
+   * @returns {ValueSet} Value set being processed
+   */
+  vsHandle() {
+    throw new Error('vsHandle() must be implemented by subclass');
+  }
+
+  /**
+   * Check if operation should be terminated due to time/cost limits
+   * @param {string} place - Location identifier for debugging
+   */
+  deadCheck(place = 'unknown') {
+    this.opContext.deadCheck(place);
+  }
+
+  /**
+   * Add cost diagnostics to an error
+   * @param {TooCostlyError} e - The error to enhance
+   * @returns {TooCostlyError} Enhanced error
+   */
+  costDiags(e) {
+    e.diagnostics = this.opContext.diagnostics();
+    return e;
+  }
+
+  /**
+   * Find a resource in additional resources by URL and version
+   * @param {string} url - Resource URL
+   * @param {string} version - Resource version (optional)
+   * @param {string} resourceType - Expected resource type
+   * @param {boolean} error - Whether to throw error if type mismatch
+   * @returns {CodeSystem|ValueSet|null} Found resource or null
+   */
+  findInAdditionalResources(url, version = '', resourceType, error = true) {
+    if (!this.additionalResources || this.additionalResources.length === 0) {
+      return null;
+    }
+
+    const matches = [];
+
+    for (const resource of this.additionalResources) {
+      this.deadCheck('findInAdditionalResources');
+
+      if (url && ((resource.url === url) || (resource.vurl === url)) &&
+        (!version || VersionUtilities.versionMatchesByAlgorithm(version, resource.version, resource.versionAlgorithm()))) {
+
+        if (resource.resourceType !== resourceType) {
+          if (error) {
+            throw new Error(`Attempt to reference ${url} as a ${resourceType} when it's a ${resource.resourceType}`);
+          } else {
+            return null;
+          }
+        }
+        matches.push(resource);
+      }
+    }
+
+    if (matches.length === 0) {
+      return null;
+    } else {
+      // Find the latest version
+      let latest = 0;
+      for (let i = 1; i < matches.length; i++) {
+        if (VersionUtilities.isSemVer(matches[latest].version) && VersionUtilities.isSemVer(matches[i].version) &&  VersionUtilities.isThisOrLater(matches[latest].version, matches[i].version)) {
+          latest = i;
+        }
+      }
+      return matches[latest];
+    }
+  }
+
+  /**
+   * Find and load a code system provider
+   * @param {string} url - Code system URL
+   * @param {string} version - Code system version (optional)
+   * @param {TxParameters} params - Operation parameters
+   * @param {Array<string>} kinds - Allowed content modes
+   * @param {OperationOutcome} op - Op for errors
+   * * @param {boolean} nullOk - Whether null result is acceptable
+   * @returns {CodeSystemProvider|null} Code system provider or null
+   */
+  async findCodeSystem(url, version = '', params, kinds = ['complete'], op, nullOk = false, checkVer = false, noVParams = false) {
+    if (!url) {
+      return null;
+    }
+
+    if (!noVParams) {
+      version = this.determineVersionBase(url, version, params);
+    }
+    let codeSystemResource = null;
+    let provider = null;
+    const supplements = this.loadSupplements(url, version);
+
+    // First check additional resources
+    codeSystemResource = this.findInAdditionalResources(url, version, 'CodeSystem', !nullOk);
+
+    if (codeSystemResource) {
+      if (codeSystemResource.content === 'complete') {
+        // Create provider from complete code system
+        provider = await this.provider.createCodeSystemProvider(this.opContext, codeSystemResource, supplements);
+      }
+    }
+
+    // If no provider from additional resources, try main provider
+    if (!provider) {
+      provider = await this.provider.getCodeSystemProvider(this.opContext, url, version, supplements);
+    }
+
+    // If still no provider but we have a code system with allowed content mode
+    if (!provider && codeSystemResource && kinds.includes(codeSystemResource.content)) {
+      provider = await this.provider.createCodeSystemProvider(this.opContext, codeSystemResource, supplements);
+    }
+
+    if (!provider && !nullOk) {
+      if (!version) {
+        throw new Issue("error", "not-found", null, "UNKNOWN_CODESYSTEM_EXP", this.i18n.translate("UNKNOWN_CODESYSTEM_EXP", params.FHTTPLanguages, [url]), "not-found", 404);
+      } else {
+        const versions = await this.listVersions(url);
+        if (versions.length === 0) {
+          throw new Issue("error", "not-found", null, "UNKNOWN_CODESYSTEM_VERSION_EXP_NONE", this.i18n.translate("UNKNOWN_CODESYSTEM_VERSION_EXP_NONE", params.FHTTPLanguages, [url, version]), "not-found", 404);
+        } else {
+          throw new Issue("error", "not-found", null, "UNKNOWN_CODESYSTEM_VERSION_EXP", this.i18n.translate("UNKNOWN_CODESYSTEM_VERSION_EXP", params.FHTTPLanguages, [url, version, this.presentVersionList(versions)]), "not-found", 404);
+        }
+      }
+    }
+    if (provider) {
+      if (checkVer) {
+        this.checkVersion(url, provider.version(), params, provider.versionAlgorithm(), op);
+      }
+    }
+
+    return provider;
+  }
+
+  /**
+   * List available versions for a code system
+   * @param {string} url - Code system URL
+   * @returns {Array<string>} Available versions
+   */
+  async listVersions(url) {
+    const versions = new Set();
+
+    // Check additional resources
+    if (this.additionalResources) {
+      for (const resource of this.additionalResources) {
+        this.deadCheck('listVersions-additional');
+        if (resource.url === url && resource.version) {
+          versions.add(resource.version);
+        }
+      }
+    }
+
+    // Check main provider
+    const providerVersions = await this.provider.listCodeSystemVersions(url);
+    for (const version of providerVersions) {
+      this.deadCheck('listVersions-provider');
+      versions.add(version);
+    }
+
+    return Array.from(versions).sort();
+  }
+
+  async listDisplaysFromCodeSystem(displays, cs, c) {
+    // list all known language displays
+    await cs.designations(c, displays);
+    displays.source = cs;
+  }
+
+  listDisplaysFromConcept(displays, c) {
+    // list all known provided displays
+    // todo: supplements
+    for (let ccd of c.designations || []) {
+      displays.addDesignationFromConcept(ccd);
+    }
+  }
+
+  listDisplaysFromIncludeConcept(displays, c, vs) {
+    if (c.display) {
+      displays.baseLang = this.languages.parse(vs.language);
+      displays.addDesignation(true, "active", '', '', c.display.trim());
+    }
+    for (let cd of c.designations || []) {
+      // see https://chat.fhir.org/#narrow/stream/179202-terminology/topic/ValueSet.20designations.20and.20languages
+      displays.addDesignationFromConcept(cd);
+    }
+  }
+
+  /**
+   * Load supplements for a code system
+   * @param {string} url - Code system URL
+   * @param {string} version - Code system version
+   * @returns {Array<CodeSystem>} Supplement code systems
+   */
+  loadSupplements(url, version = '') {
+    const supplements = [];
+
+    if (!this.additionalResources) {
+      return supplements;
+    }
+
+    for (const resource of this.additionalResources) {
+      this.deadCheck('loadSupplements');
+      if (resource.resourceType === 'CodeSystem' && resource instanceof CodeSystem) {
+        const cs = resource;
+        // Check if this code system supplements the target URL
+        const supplementsUrl = cs.jsonObj.supplements;
+
+        if (!supplementsUrl) {
+          continue;
+        }
+
+        // Handle exact URL match (no version specified in supplements)
+        if (supplementsUrl === url) {
+          // If we're looking for a specific version, only include if no version in supplements URL
+          if (!version) {
+            supplements.push(cs);
+          }
+          continue;
+        }
+
+        // Handle versioned URL (format: url|version)
+        if (supplementsUrl.startsWith(`${url}|`)) {
+          if (!version) {
+            // No version specified in search, include all supplements for this URL
+            supplements.push(cs);
+          } else {
+            // Version specified, check if it matches the tail of supplements URL
+            const supplementsVersion = supplementsUrl.substring(`${url}|`.length);
+            if (supplementsVersion === version || VersionUtilities.versionMatches(supplementsVersion, version)) {
+              supplements.push(cs);
+            }
+          }
+        }
+      }
+    }
+
+    return supplements;
+  }
+
+  /**
+   * Check supplements for a code system provider
+   * @param {CodeSystemProvider} cs - Code system provider
+   * @param {Object} src - Source element (for extensions)
+   */
+  checkSupplements(cs, src, requiredSupplements) {
+    // Check for required supplements in extensions
+    if (src && src.getExtensions) {
+      const supplementExtensions = src.getExtensions('http://hl7.org/fhir/StructureDefinition/valueset-supplement');
+      for (const ext of supplementExtensions) {
+        const supplementUrl = ext.valueString || ext.valueUri;
+        if (supplementUrl && !cs.hasSupplement(this.opContext, supplementUrl)) {
+          throw new TerminologyError(`ValueSet depends on supplement '${supplementUrl}' on ${cs.systemUri} that is not known`);
+        }
+      }
+    }
+
+    // Remove required supplements that are satisfied
+    for (let i = requiredSupplements.length - 1; i >= 0; i--) {
+      if (cs.hasSupplement(requiredSupplements[i])) {
+        requiredSupplements.splice(i, 1);
+      }
+    }
+  }
+
+  /**
+   * Find a ValueSet by URL and optional version
+   * @param {string} url - ValueSet URL (may include |version)
+   * @param {string} version - ValueSet version (optional, overrides URL version)
+   * @returns {ValueSet|null} Found ValueSet or null
+   */
+  async findValueSet(url, version = '') {
+    if (!url) {
+      return null;
+    }
+
+    // Parse URL|version format
+    let effectiveUrl = url;
+    let effectiveVersion = version;
+
+    if (!effectiveVersion && url.includes('|')) {
+      const parts = url.split('|');
+      effectiveUrl = parts[0];
+      effectiveVersion = parts[1];
+    }
+
+    // First check additional resources
+    const fromAdditional = this.findInAdditionalResources(effectiveUrl, effectiveVersion, 'ValueSet', false);
+    if (fromAdditional) {
+      return fromAdditional;
+    }
+
+    // Then try the provider
+    if (this.provider && this.provider.findValueSet) {
+      const vs = await this.provider.findValueSet(this.opContext, effectiveUrl, effectiveVersion);
+      if (vs) {
+        return vs;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Apply version pinning rules from parameters
+   * @param {string} url - ValueSet URL
+   * @returns {string} Potentially versioned URL
+   */
+  pinValueSet(url) {
+    if (!url || !this.params) {
+      return url;
+    }
+
+    let baseUrl = url.includes("|") ? url.substring(0, url.indexOf("|")) : url;
+    let version = url.includes("|") ? url.substring(url.indexOf("|") + 1) : null;
+    version = this.determineVersionBase(url, version, this.params);
+    return version ? baseUrl+"|"+version : url;
+  }
+
+  /**
+   * Build a canonical URL from system and version
+   * @param {string} system - System URL
+   * @param {string} version - Version (optional)
+   * @returns {string} Canonical URL (system|version or just system)
+   */
+  canonical(system, version = '') {
+    if (!system) return '';
+    if (!version) return system;
+    return `${system}|${version}`;
+  }
+
+  /**
+   * Parse a canonical URL into system and version parts
+   * @param {string} canonical - Canonical URL (may include |version)
+   * @returns {{system: string, version: string}}
+   */
+  parseCanonical(canonical) {
+    if (!canonical) {
+      return { system: '', version: '' };
+    }
+
+    const pipeIndex = canonical.indexOf('|');
+    if (pipeIndex < 0) {
+      return { system: canonical, version: '' };
+    }
+
+    return {
+      system: canonical.substring(0, pipeIndex),
+      version: canonical.substring(pipeIndex + 1)
+    };
+  }
+
+  /**
+   * Process a ValueSet, recording context and extracting embedded expansion parameters
+   * @param {Object} vs - ValueSet resource (raw JSON)
+   * @param {Object} params - Parameters resource to add extracted params to
+   */
+  seeValueSet(vs, params) {
+    // Build canonical URL from url and version
+    const vurl = vs.url ? (vs.url + (vs.version ? '|' + vs.version : '')) : null;
+    if (vurl) {
+      this.opContext.seeContext(vurl);
+    }
+    // Check for expansion parameter extensions on compose
+    if (vs.jsonObj.compose && vs.jsonObj.compose.extension) {
+      for (const ext of vs.jsonObj.compose.extension) {
+        if (ext.url === 'http://hl7.org/fhir/StructureDefinition/valueset-expansion-parameter' ||
+          ext.url === 'http://hl7.org/fhir/tools/StructureDefinition/valueset-expansion-parameter') {
+          // Get name and value from nested extensions
+          const nameExt = ext.extension?.find(e => e.url === 'name');
+          const valueExt = ext.extension?.find(e => e.url === 'value');
+
+          if (nameExt && valueExt) {
+            const name = nameExt.valueString || nameExt.valueCode;
+            if (name) {
+              this.params.seeParameter(name, valueExt, false);
+            }
+          }
+        }
+      }
+    }
+    if (!params.FHTTPLanguages && vs.jsonObj.language) {
+      params.HTTPLanguages = Languages.fromAcceptLanguage(vs.jsonObj.language, this.languages, !this.isValidating());
+    }
+  }
+
+  isValidating() {
+    return false;
+  }
+
+  // ========== Parameter Handling ==========
+
+  /**
+   * Build a Parameters resource from the request
+   * Handles GET query params, POST form body, and POST Parameters resource
+   * @param {express.Request} req
+   * @returns {Object} Parameters resource
+   */
+  buildParameters(req) {
+    // If POST with Parameters resource, use directly
+    if (req.method === 'POST' && req.body && req.body.resourceType === 'Parameters') {
+      return req.body;
+    }
+
+    // Convert query params or form body to Parameters
+    const source = req.method === 'POST' ? {...req.query, ...req.body} : req.query;
+    const params = {
+      resourceType: 'Parameters',
+      parameter: []
+    };
+
+    for (const [name, value] of Object.entries(source)) {
+      if (value === undefined || value === null) continue;
+
+      if (Array.isArray(value)) {
+        // Repeating parameter
+        for (const v of value) {
+          params.parameter.push({name, valueString: String(v)});
+        }
+      } else if (typeof value === 'object') {
+        // Could be a resource or complex type - check resourceType
+        if (value.resourceType) {
+          params.parameter.push({name, resource: value});
+        } else {
+          // Assume it's a complex type like Coding or CodeableConcept
+          params.parameter.push(this.buildComplexParameter(name, value));
+        }
+      } else {
+        params.parameter.push({name, valueString: String(value)});
+      }
+    }
+
+    return params;
+  }
+
+  /**
+   * Build a parameter for complex types
+   */
+  buildComplexParameter(name, value) {
+    // Detect type based on structure
+    if (value.system !== undefined || value.code !== undefined || value.display !== undefined) {
+      return {name, valueCoding: value};
+    }
+    if (value.coding !== undefined || value.text !== undefined) {
+      return {name, valueCodeableConcept: value};
+    }
+    // Fallback - stringify
+    return {name, valueString: JSON.stringify(value)};
+  }
+
+
+  addHttpParams(req, params) {
+    if (req.headers && req.headers['accept-language']) {
+      params.parameter.push({name: '__Accept-Language', valueCode: req.headers['accept-language']});
+    }
+    if (req.headers && req.headers['content-language']) {
+      params.parameter.push({name: '__Content-Language', valueCode: req.headers['content-language']});
+    }
+  }
+
+  // ========== Additional Resources Handling ==========
+
+  /**
+   * Set up additional resources from tx-resource parameters and cache
+   * @param {Object} params - Parameters resource
+   */
+  setupAdditionalResources(params) {
+    if (!params || !params.parameter) return;
+
+    // Collect tx-resource parameters (resources provided inline)
+    const txResources = [];
+    for (const param of params.parameter) {
+      this.deadCheck('setupAdditionalResources');
+      if (param.name === 'tx-resource' && param.resource) {
+        let res = this.wrapRawResource(param.resource);
+        if (res) {
+          txResources.push(res);
+        }
+      }
+    }
+
+    // Check for cache-id
+    const cacheIdParam = this.findParameter(params, 'cache-id');
+    const cacheId = cacheIdParam ? this.getParameterValue(cacheIdParam) : null;
+
+    if (cacheId && this.opContext.resourceCache) {
+      // Merge tx-resources with cached resources
+      if (txResources.length > 0) {
+        this.opContext.resourceCache.add(cacheId, txResources);
+      }
+
+      // Set additional resources to all resources for this cache-id
+      this.additionalResources = this.opContext.resourceCache.get(cacheId);
+    } else {
+      // No cache-id, just use the tx-resources directly
+      this.additionalResources = txResources;
+    }
+  }
+
+  /**
+   * Wrap a raw resource in its appropriate class wrapper
+   * @param {Object} resource - Raw resource object
+   * @returns {CodeSystem|ValueSet|null} Wrapped resource or null
+   */
+  wrapRawResource(resource) {
+    if (resource.resourceType === 'CodeSystem') {
+      return new CodeSystem(resource, this.provider.getFhirVersion());
+    }
+    if (resource.resourceType === 'ValueSet') {
+      return new ValueSet(resource, this.provider.getFhirVersion());
+    }
+    if (resource.resourceType === 'ConceptMap') {
+      return new ConceptMap(resource, this.provider.getFhirVersion());
+    }
+    return null;
+  }
+
+  // ========== Parameters Handling ==========
+
+  /**
+   * Convert query parameters to a Parameters resource
+   * @param {Object} query - Query parameters
+   * @returns {Object} Parameters resource
+   */
+  queryToParameters(query) {
+    const params = {
+      resourceType: 'Parameters',
+      parameter: []
+    };
+
+    if (!query) return params;
+
+    for (const [name, value] of Object.entries(query)) {
+      if (Array.isArray(value)) {
+        // Repeating parameter
+        for (const v of value) {
+          params.parameter.push({ name, valueString: v });
+        }
+      } else {
+        params.parameter.push({ name, valueString: value });
+      }
+    }
+
+    return params;
+  }
+
+  /**
+   * Convert form body to a Parameters resource, merging with query params
+   * @param {Object} body - Form body
+   * @param {Object} query - Query parameters
+   * @returns {Object} Parameters resource
+   */
+  formToParameters(body, query) {
+    const params = {
+      resourceType: 'Parameters',
+      parameter: []
+    };
+
+    // Add query params first
+    if (query) {
+      for (const [name, value] of Object.entries(query)) {
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            params.parameter.push({ name, valueString: v });
+          }
+        } else {
+          params.parameter.push({ name, valueString: value });
+        }
+      }
+    }
+
+    // Add/override with body params
+    if (body) {
+      for (const [name, value] of Object.entries(body)) {
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            params.parameter.push({ name, valueString: v });
+          }
+        } else {
+          params.parameter.push({ name, valueString: value });
+        }
+      }
+    }
+
+    return params;
+  }
+
+  /**
+   * Find a parameter in a Parameters resource
+   * @param {Object} params - Parameters resource
+   * @param {string} name - Parameter name
+   * @returns {Object|null} Parameter object or null
+   */
+  findParameter(params, name) {
+    if (!params || !params.parameter) return null;
+    return params.parameter.find(p => p.name === name) || null;
+  }
+
+  /**
+   * Get the value from a parameter (handles various value types)
+   * @param {Object} param - Parameter object
+   * @returns {*} Parameter value
+   */
+  getParameterValue(param) {
+    if (!param) return null;
+
+    // Check for resource
+    if (param.resource) return param.resource;
+
+    // Check for various value types
+    const valueTypes = [
+      'valueString', 'valueCode', 'valueUri', 'valueCanonical', 'valueUrl',
+      'valueBoolean', 'valueInteger', 'valueDecimal',
+      'valueDateTime', 'valueDate', 'valueTime',
+      'valueCoding', 'valueCodeableConcept',
+      'valueIdentifier', 'valueQuantity'
+    ];
+
+    for (const vt of valueTypes) {
+      if (param[vt] !== undefined) {
+        return param[vt];
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get a string parameter value
+   * @param {Object} params - Parameters resource
+   * @param {string} name - Parameter name
+   * @returns {string|null} Parameter value or null
+   */
+  getStringParam(params, name) {
+    const p = this.findParameter(params, name);
+    if (!p) return null;
+    return getValuePrimitive(p);
+  }
+
+  /**
+   * Get a resource parameter value
+   * @param {Object} params - Parameters resource
+   * @param {string} name - Parameter name
+   * @returns {Object|null} Resource or null
+   */
+  getResourceParam(params, name) {
+    const p = this.findParameter(params, name);
+    return p?.resource || null;
+  }
+
+  /**
+   * Get a Coding parameter value
+   * @param {Object} params - Parameters resource
+   * @param {string} name - Parameter name
+   * @returns {Object|null} Coding or null
+   */
+  getCodingParam(params, name) {
+    const p = this.findParameter(params, name);
+    return p?.valueCoding || null;
+  }
+
+  /**
+   * Get a CodeableConcept parameter value
+   * @param {Object} params - Parameters resource
+   * @param {string} name - Parameter name
+   * @returns {Object|null} CodeableConcept or null
+   */
+  getCodeableConceptParam(params, name) {
+    const p = this.findParameter(params, name);
+    return p?.valueCodeableConcept || null;
+  }
+
+  /**
+   * Render a coded value as string for debugging/logging
+   * @param {string|Object} system - System URI or coding object
+   * @param {string} version - Version (optional)
+   * @param {string} code - Code (optional)
+   * @param {string} display - Display (optional)
+   * @returns {string} Rendered string
+   */
+  displayCoded(system, version = '', code = '', display = '') {
+    if (typeof system === 'object') {
+      // Handle coding or codeable concept objects
+      if (system.system !== undefined) {
+        // Coding object
+        return this.renderer.displayCoded(system.system, system.version, system.code, system.display);
+      } else if (system.codings) {
+        // Codeable concept object
+        const rendered = system.codings.map(c => this.displayCoded(c)).join(', ');
+        return `[${rendered}]`;
+      }
+    }
+
+    let result = system;
+    if (version) {
+      result += `|${version}`;
+    }
+    if (code) {
+      result += `#${code}`;
+    }
+    if (display) {
+      result += ` ("${display}")`;
+    }
+
+    return result;
+  }
+  determineVersionBase(url, version, params) {
+    if (params === null) {
+      return version;
+    }
+    let result = version;
+    let list = params.rulesForSystem(url);
+    let b = false;
+    for (let t of list) {
+      if (t.mode === 'override') {
+        if (!b) {
+          result = t.version;
+          this.foundParameters.push(t.asParam());
+          b = true;
+        } else if (result !== t.version) {
+          throw new Issue("error", "exception", null, 'SYSTEM_VERSION_MULTIPLE_OVERRIDE', this.FI18n.translate('SYSTEM_VERSION_MULTIPLE_OVERRIDE', params.FHTTPLanguages, [url, result, t.version]), 'version-error');
+        }
+      }
+    }
+    if (!result) {
+      b = false;
+      for (let t of list) {
+        if (t.mode === 'default') {
+          if (!b) {
+            result = t.version;
+            this.foundParameters.push(t.asParam());
+            b = true;
+          } else if (version !== t.version) {
+            throw new Issue("error", "exception", null, 'SYSTEM_VERSION_MULTIPLE_DEFAULT', this.FI18n.translate('SYSTEM_VERSION_MULTIPLE_DEFAULT', params.FHTTPLanguages, [url, result, t.version]), 'version-error');
+          }
+        }
+      }
+    }
+    for (let t of list) {
+      if (t.mode === 'check') {
+        if (!result) {
+          result = t.version;
+          this.foundParameters.push(t.asParam());
+        }
+        // if we decide to allow check to guide the selection.
+        // waiting for discussion
+        //else if (TFHIRVersions.isSubset(result, t.version)) {
+        //  result = t.version;
+        //}
+      }
+    }
+    return result;
+  }
+
+  checkVersion(url, version, params, versionAlgorithm, op) {
+    if (params) {
+      let list = params.rulesForSystem(url);
+      for (let t of list) {
+        if (t.mode === 'check') {
+          if (!VersionUtilities.versionMatchesByAlgorithm(t.version, version, versionAlgorithm)) {
+            let issue = new Issue("error", "exception", null, 'VALUESET_VERSION_CHECK', this.i18n.translate('VALUESET_VERSION_CHECK', params.FHTTPLanguages, [url, version, t.version]), 'version-error', 400);
+            if (op) {
+              op.addIssue(issue);
+            } else {
+              throw issue;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  makeVurl(resource) {
+    let result = resource.vurl;
+    if (!result && resource.url) {
+      if (resource.version) {
+        result =  resource.url+"|"+resource.version;
+      } else {
+        result =  resource.url;
+      }
+    }
+    return result;
+  }
+
+  // Note: findParameter, getStringParam, getResourceParam, getCodingParam,
+  // and getCodeableConceptParam are inherited from TerminologyWorker base class
+
+  fixForVersion(resource) {
+    if (this.provider.fhirVersion >= 5) {
+      return resource;
+    }
+    let rt = resource.resourceType;
+    switch (rt) {
+      case "ValueSet": {
+        let vs = new ValueSet(resource);
+        if (this.provider.fhirVersion == 4) {
+          return vs.convertFromR5(resource, "R4");
+        } else if (this.provider.fhirVersion == 3) {
+          return vs.convertFromR5(resource, "R3");
+        } else {
+          return resource;
+        }
+      }
+      default:
+        return resource;
+    }
+  }
+
+
+  seeSourceVS(vs, url) {
+    let s = url;
+    if (vs) {
+      if (vs.jsonObj) vs = vs.jsonObj;
+      s = vs.name || vs.title || vs.id || vs.url;
+    }
+    if (!this.usedSources.find(u => u == s)) {
+      this.usedSources.push(s);
+    }
+  }
+
+  seeSourceProvider(cs, url) {
+    let s = url;
+    if (cs) {
+      if (cs instanceof CodeSystem) {
+        cs = cs.jsonObj;
+        s = cs.name || cs.title || cs.id || cs.url;
+      } else {
+        s = cs.name() || cs.system();
+      }
+    }
+    if (!this.usedSources.find(u => u == s)) {
+      this.usedSources.push(s);
+    }
+  }
+
+  presentVersionList(items) {
+    if (items.length === 0) return '';
+    if (items.length === 1) return items[0];
+    if (items.length === 2) return `${items[0]} or ${items[1]}`;
+
+    const lastItem = items.pop();
+    return `${items.join(', ')} and ${lastItem}`;
+  }
+}
+
+module.exports = {
+  TerminologyWorker,
+  TerminologySetupError
+};