fhirsmith 0.3.0

package/tx/workers/metadata.js

@@ -0,0 +1,467 @@
+//
+// Metadata Handler - Handles /metadata endpoint and $versions operation
+//
+// GET /metadata - Returns CapabilityStatement
+// GET /metadata?mode=terminology - Returns TerminologyCapabilities
+// GET /$versions - Returns supported FHIR versions
+//
+
+const {CapabilityStatement} = require("../library/capabilitystatement");
+const {TerminologyCapabilities} = require("../library/terminologycapabilities");
+
+/**
+ * Metadata handler for FHIR terminology server
+ * Used by TXModule to handle /metadata requests
+ */
+class MetadataHandler {
+  host;
+
+  /**
+   * @param {Object} config - Server configuration
+   */
+  constructor(config = {}) {
+    this.config = config;
+    this.host = config.host;
+  }
+
+  /**
+   * Handle GET /metadata request
+   * @param {express.Request} req - Express request (with txEndpoint and txProvider attached)
+   * @param {express.Response} res - Express response
+   */
+  async handle(req, res) {
+    const mode = req.query.mode;
+    const endpoint = req.txEndpoint;
+    const provider = req.txProvider;
+
+    if (mode === 'terminology') {
+      this.logInfo = 'termcaps';
+      const tc = new TerminologyCapabilities(await this.buildTerminologyCapabilities(endpoint, provider));
+      return res.json(tc.toJSON(endpoint.fhirVersion));
+    }
+    this.logInfo = 'metadata';
+
+    // Default: return CapabilityStatement
+    const cs = new CapabilityStatement(this.buildCapabilityStatement(endpoint, provider));
+    return res.json(cs.toJSON(endpoint.fhirVersion));
+  }
+
+  /**
+   * Handle GET /$versions request
+   * @param {express.Request} req - Express request (with txEndpoint attached)
+   * @param {express.Response} res - Express response
+   */
+  handleVersions(req, res) {
+    const endpoint = req.txEndpoint;
+    const fhirVersion = this.getShortFhirVersion(endpoint.fhirVersion);
+
+    // Check Accept header to determine response format
+    const accept = req.get('Accept') || '';
+    const isFhirJson = accept.includes('application/fhir+json') ||
+      accept.includes('application/fhir+xml');
+
+    if (isFhirJson) {
+      // Return FHIR Parameters resource
+      return res.json({
+        resourceType: 'Parameters',
+        parameter: [
+          {
+            name: 'version',
+            valueCode: fhirVersion
+          },
+          {
+            name: 'default',
+            valueCode: fhirVersion
+          }
+        ]
+      });
+    } else {
+      // Return simple JSON
+      return res.json({
+        versions: [fhirVersion],
+        default: fhirVersion
+      });
+    }
+  }
+
+  /**
+   * Get short FHIR version (e.g., "4.0" from "4.0.1" or "4.0")
+   * @param {string} version - FHIR version string
+   * @returns {string} Short version (X.0 format)
+   */
+  getShortFhirVersion(version) {
+    if (!version) return '4.0';
+
+    // If already short format (e.g., "4.0"), return as-is
+    const parts = String(version).split('.');
+    if (parts.length >= 2) {
+      return `${parts[0]}.${parts[1]}`;
+    }
+    return version;
+  }
+
+  /**
+   * Build CapabilityStatement for an endpoint
+   * @param {Object} endpoint - Endpoint info {path, fhirVersion, context}
+   * @param {Object} provider - Provider for code systems and resources
+   * @returns {Object} CapabilityStatement resource
+   */
+  buildCapabilityStatement(endpoint) {
+    const now = new Date().toISOString();
+    const fhirVersion = this.mapFhirVersion(endpoint.fhirVersion);
+    const baseUrl = this.config.baseUrl || `https://${this.host}${endpoint.path}`;
+    const serverVersion = this.config.serverVersion || '1.0.0';
+
+    return {
+      resourceType: 'CapabilityStatement',
+      id: this.config.id || 'FhirServer',
+      'extension' : [
+        {
+          'extension' : [
+            {
+              'url' : 'definition',
+              'valueCanonical' : 'http://hl7.org/fhir/uv/tx-tests/FeatureDefinition/test-version'
+            },
+            {
+              'url' : 'value',
+              'valueCode' : '1.8.0'
+            },
+            {
+              'extension' : [
+                {
+                  'url' : 'name',
+                  'valueCode' : 'mode'
+                },
+                {
+                  'url' : 'value',
+                  'valueCode' : 'tx.fhir.org'
+                }
+              ],
+              'url' : 'qualifier'
+            }
+          ],
+          'url' : 'http://hl7.org/fhir/uv/application-feature/StructureDefinition/feature'
+        },
+        {
+          'extension' : [
+            {
+              'url' : 'definition',
+              'valueCanonical' : 'http://hl7.org/fhir/uv/tx-ecosystem/FeatureDefinition/CodeSystemAsParameter'
+            },
+            {
+              'url' : 'value',
+              'valueBoolean' : true
+            }
+          ],
+          'url' : 'http://hl7.org/fhir/uv/application-feature/StructureDefinition/feature'
+        }
+      ],
+      url: `${baseUrl}/CapabilityStatement/tx`,
+      version: `${fhirVersion}-${serverVersion}`,
+      name: this.config.name || 'FHIRTerminologyServer',
+      title: this.config.title || 'FHIR Terminology Server Conformance Statement',
+      status: 'active',
+      date: now,
+      contact: this.config.contact || [
+        {
+          telecom: [
+            {
+              system: 'other',
+              value: this.config.contactUrl || 'http://example.org/'
+            }
+          ]
+        }
+      ],
+      description: this.config.description || 'FHIR Terminology Server',
+      kind: 'instance',
+      instantiates: [
+        'http://hl7.org/fhir/CapabilityStatement/terminology-server'
+      ],
+      software: {
+        name: this.config.softwareName || 'FHIR Terminology Server',
+        version: serverVersion,
+        releaseDate: this.config.releaseDate || now
+      },
+      implementation: {
+        description: `FHIR Server running at ${baseUrl}`,
+        url: baseUrl
+      },
+      fhirVersion: fhirVersion,
+      format: ['application/fhir+xml', 'application/fhir+json'],
+      rest: [
+        {
+          mode: 'server',
+          security: {
+            cors: true
+          },
+          resource: [
+            {
+              type: 'CodeSystem',
+              interaction: [
+                { code: 'read', documentation: 'Read a code system' },
+                { code: 'search-type', documentation: 'Search the code systems' }
+              ],
+              searchParam: [
+                { name: 'url', type: 'uri' },
+                { name: 'version', type: 'token' },
+                { name: 'name', type: 'string' },
+                { name: 'title', type: 'string' },
+                { name: 'status', type: 'token' },
+                { name: '_id', type: 'token' }
+              ],
+              operation: [
+                { name: 'lookup', definition: 'http://hl7.org/fhir/OperationDefinition/CodeSystem-lookup' },
+                { name: 'validate-code', definition: 'http://hl7.org/fhir/OperationDefinition/CodeSystem-validate-code' },
+                { name: 'subsumes', definition: 'http://hl7.org/fhir/OperationDefinition/CodeSystem-subsumes' }
+              ]
+            },
+            {
+              type: 'ValueSet',
+              interaction: [
+                { code: 'read', documentation: 'Read a ValueSet' },
+                { code: 'search-type', documentation: 'Search the value sets' }
+              ],
+              searchParam: [
+                { name: 'url', type: 'uri' },
+                { name: 'version', type: 'token' },
+                { name: 'name', type: 'string' },
+                { name: 'title', type: 'string' },
+                { name: 'status', type: 'token' },
+                { name: '_id', type: 'token' }
+              ],
+              operation: [
+                { name: 'expand', definition: 'http://hl7.org/fhir/OperationDefinition/ValueSet-expand' },
+                { name: 'validate-code', definition: 'http://hl7.org/fhir/OperationDefinition/ValueSet-validate-code' }
+              ]
+            },
+            {
+              type: 'ConceptMap',
+              interaction: [
+                { code: 'read', documentation: 'Read a ConceptMap' },
+                { code: 'search-type', documentation: 'Search the concept maps' }
+              ],
+              searchParam: [
+                { name: 'url', type: 'uri' },
+                { name: 'version', type: 'token' },
+                { name: 'name', type: 'string' },
+                { name: 'title', type: 'string' },
+                { name: 'status', type: 'token' },
+                { name: '_id', type: 'token' }
+              ],
+              operation: [
+                { name: 'translate', definition: 'http://hl7.org/fhir/OperationDefinition/ConceptMap-translate' },
+                { name: 'closure', definition: 'http://hl7.org/fhir/OperationDefinition/ConceptMap-closure' }
+              ]
+            }
+          ],
+          interaction: [
+            { code: 'transaction' }
+          ],
+          operation: [
+            { name: 'expand', definition: 'http://hl7.org/fhir/OperationDefinition/ValueSet-expand' },
+            { name: 'lookup', definition: 'http://hl7.org/fhir/OperationDefinition/CodeSystem-lookup' },
+            { name: 'subsumes', definition: 'http://hl7.org/fhir/OperationDefinition/CodeSystem-subsumes' },
+            { name: 'validate-code', definition: 'http://hl7.org/fhir/OperationDefinition/Resource-validate-code' },
+            { name: 'translate', definition: 'http://hl7.org/fhir/OperationDefinition/ConceptMap-translate' },
+            { name: 'closure', definition: 'http://hl7.org/fhir/OperationDefinition/ConceptMap-closure' },
+            { name: 'versions', definition: 'http://hl7.org/fhir/OperationDefinition/fhir-versions' }
+          ]
+        }
+      ]
+    };
+  }
+
+  /**
+   * Build TerminologyCapabilities resource
+   * @param {Object} endpoint - Endpoint info
+   * @param {Object} provider - Provider for code systems and resources
+   * @returns {Object} TerminologyCapabilities resource
+   */
+  async buildTerminologyCapabilities(endpoint, provider) {
+    const now = new Date().toISOString();
+    const baseUrl = this.config.baseUrl || `https://${this.host}${endpoint.path}`;
+    const serverVersion = this.config.serverVersion || '1.0.0';
+
+    const tc = {
+      resourceType: 'TerminologyCapabilities',
+      id: this.config.id || 'FhirServer',
+      url: `${baseUrl}/TerminologyCapabilities/tx`,
+      version: serverVersion,
+      name: this.config.name || 'FHIRTerminologyServerCapabilities',
+      title: this.config.title || 'FHIR Terminology Server Capability Statement',
+      status: 'active',
+      date: now,
+      contact: this.config.contact || [
+        {
+          telecom: [
+            {
+              system: 'other',
+              value: this.config.contactUrl || 'http://example.org/'
+            }
+          ]
+        }
+      ],
+      description: this.config.description || 'Terminology Capability Statement for FHIR Terminology Server',
+      kind: 'instance',
+      codeSystem: await this.buildCodeSystemEntries(provider),
+      expansion: this.buildExpansionCapabilities(),
+      validateCode: this.buildValidateCodeCapabilities(),
+      translation: this.buildTranslationCapabilities()
+    };
+
+    return tc;
+  }
+
+  /**
+   * Build codeSystem entries from provider
+   * @param {Object} provider - Provider with codeSystems and codeSystemFactories
+   * @returns {Object[]} Array of codeSystem entries
+   */
+  async buildCodeSystemEntries(provider) {
+    const seenSystems = new Map(); // url -> entry for deduplication
+
+    // Process provider.codeSystems (direct CodeSystem resources)
+    if (provider && provider.codeSystems) {
+      for (const cs of provider.codeSystems.values()) {
+        const url = cs.url || (cs.jsonObj && cs.jsonObj.url);
+        const version = cs.version || (cs.jsonObj && cs.jsonObj.version);
+
+        if (url) {
+          this.addCodeSystemEntry(seenSystems, url, version);
+        }
+      }
+    }
+
+    // Process provider.codeSystemFactories (factory providers)
+    if (provider && provider.codeSystemFactories) {
+      for (const factory of provider.codeSystemFactories.values()) {
+        const url = factory.system();
+        const version = factory.version();
+
+        if (url) {
+          this.addCodeSystemEntry(seenSystems, url, version);
+        }
+      }
+    }
+
+    // Convert map to array and sort by URI
+    const entries = Array.from(seenSystems.values());
+    entries.sort((a, b) => (a.uri || '').localeCompare(b.uri || ''));
+
+    return entries.length > 0 ? entries : undefined;
+  }
+
+  /**
+   * Add or update a code system entry
+   * @param {Map} seenSystems - Map of URL to entry
+   * @param {string} url - Code system URL
+   * @param {string} version - Code system version (may be null)
+   */
+  addCodeSystemEntry(seenSystems, url, version) {
+    if (!seenSystems.has(url)) {
+      // Create new entry
+      const entry = { uri: url };
+      if (version) {
+        entry.version = [{ code: version }];
+      }
+      seenSystems.set(url, entry);
+    } else if (version) {
+      // Add version to existing entry
+      const entry = seenSystems.get(url);
+      if (!entry.version) {
+        entry.version = [];
+      }
+      // Check if version already exists
+      if (!entry.version.some(v => v.code === version)) {
+        entry.version.push({ code: version });
+      }
+    }
+  }
+
+  /**
+   * Build expansion capabilities
+   * @returns {Object} Expansion capabilities object
+   */
+  buildExpansionCapabilities() {
+    return {
+      parameter: [
+        {
+          name: 'cache-id',
+          documentation: 'This server supports caching terminology resources between calls. Clients only need to send value sets and codesystems once; thereafter they are automatically in scope for calls with the same cache-id. The cache is retained for 30 min from last call'
+        },
+        {
+          name: 'tx-resource',
+          documentation: 'Additional valuesets needed for evaluation e.g. value sets referred to from the import statement of the value set being expanded'
+        },
+        { name: '_incomplete' },
+        { name: 'abstract' },
+        { name: 'activeOnly' },
+        { name: 'check-system-version' },
+        { name: 'count' },
+        { name: 'default-to-latest-version' },
+        { name: 'displayLanguage' },
+        { name: 'excludeNested' },
+        { name: 'excludeNotForUI' },
+        { name: 'excludePostCoordinated' },
+        { name: 'force-system-version' },
+        { name: 'inactive' },
+        { name: 'includeAlternateCodes' },
+        { name: 'includeDefinition' },
+        { name: 'includeDesignations' },
+        { name: 'incomplete-ok' },
+        { name: 'limitedExpansion' },
+        {
+          name: 'mode',
+          documentation: '=lenient-display-validation'
+        },
+        { name: 'no-cache' },
+        { name: 'offset' },
+        { name: 'profile' },
+        { name: 'property' },
+        { name: 'system-version' },
+        {
+          name: 'valueSetMode',
+          documentation: '= CHECK_MEMBERSHIP_ONLY | NO_MEMBERSHIP_CHECK'
+        }
+      ]
+    };
+  }
+
+  /**
+   * Build validateCode capabilities
+   * @returns {Object} ValidateCode capabilities object
+   */
+  buildValidateCodeCapabilities() {
+    return {
+      "translations" : true
+    };
+  }
+
+  /**
+   * Build translation capabilities
+   * @returns {Object} Translation capabilities object
+   */
+  buildTranslationCapabilities() {
+    return {
+      needsMap : false
+    };
+  }
+
+  /**
+   * Map short FHIR version to full version string
+   * @param {string} version - Short version (e.g., '4.0')
+   * @returns {string} Full version (e.g., '4.0.1')
+   */
+  mapFhirVersion(version) {
+    const versionMap = {
+      '3.0': '3.0.2',
+      '4.0': '4.0.1',
+      '4.3': '4.3.0',
+      '5.0': '5.0.0',
+      '6.0': '6.0.0'
+    };
+    return versionMap[version] || version || '4.0.1';
+  }
+}
+
+module.exports = { MetadataHandler };

package/tx/workers/operations.js

@@ -0,0 +1,34 @@
+
+const {TerminologyWorker} = require("./worker");
+
+/**
+ * this handles assembling the information for the operations form
+ */
+class OperationsWorker extends TerminologyWorker {
+  /**
+   * @param {OperationContext} opContext - Operation context
+   * @param {Logger} log - Logger instance
+   * @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) {
+    super(opContext, log, provider, languages, i18n);
+  }
+
+  /**
+   * Get operation name
+   * @returns {string}
+   */
+  opName() {
+    return 'search';
+  }
+
+  async handle(req, res) {
+    const formData = { resourceType : "Operations" };
+    formData.valueSets = await this.provider.listAllValueSets();
+    return res.json(formData);
+  }
+}
+
+module.exports = { OperationsWorker };

package/tx/workers/read.js

@@ -0,0 +1,164 @@
+//
+// Read Worker - Handles resource read operations
+//
+// GET /{type}/{id}
+//
+
+const { TerminologyWorker } = require('./worker');
+
+class ReadWorker extends TerminologyWorker {
+  /**
+   * @param {OperationContext} opContext - Operation context
+   * @param {Logger} log - Logger instance
+   * @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) {
+    super(opContext, log, provider, languages, i18n);
+  }
+
+  /**
+   * Get operation name
+   * @returns {string}
+   */
+  opName() {
+    return 'read';
+  }
+  /**
+   * Handle a read request
+   * @param {express.Request} req - Express request (with txProvider attached)
+   * @param {express.Response} res - Express response
+   * @param {string} resourceType - The resource type (CodeSystem, ValueSet, ConceptMap)
+   * @param {Object} log - Logger instance
+   */
+  async handle(req, res, resourceType) {
+    const { id } = req.params;
+
+    this.log.debug(`Read ${resourceType}/${id}`);
+
+    try {
+      switch (resourceType) {
+        case 'CodeSystem':
+          return await this.handleCodeSystem(req, res, id);
+
+        case 'ValueSet':
+          return await this.handleValueSet(req, res, id);
+
+        case 'ConceptMap':
+          return res.status(501).json({
+            resourceType: 'OperationOutcome',
+            issue: [{
+              severity: 'error',
+              code: 'not-supported',
+              diagnostics: 'ConceptMap read not yet implemented'
+            }]
+          });
+
+        default:
+          return res.status(404).json({
+            resourceType: 'OperationOutcome',
+            issue: [{
+              severity: 'error',
+              code: 'not-found',
+              diagnostics: `Unknown resource type: ${resourceType}`
+            }]
+          });
+      }
+    } catch (error) {
+      req.logInfo = this.usedSources.join("|")+" - error"+(error.msgId  ? " "+error.msgId : "");
+      this.log.error(error);
+      return res.status(500).json({
+        resourceType: 'OperationOutcome',
+        issue: [{
+          severity: 'error',
+          code: 'exception',
+          diagnostics: error.message
+        }]
+      });
+    }
+  }
+
+  /**
+   * Handle CodeSystem read
+   */
+  async handleCodeSystem(req, res, id) {
+    let cs = this.provider.getCodeSystemById(this.opContext, id);
+    if (cs != null) {
+      return res.json(cs.jsonObj);
+    }
+
+    if (id.startsWith("x-")) {
+      cs = this.provider.getCodeSystemFactoryById(this.opContext, id.substring(2));
+      if (cs != null) {
+        let json = {
+          resourceType: "CodeSystem",
+          id: "x-" + cs.id(),
+          url: cs.system(),
+          name: cs.name(),
+          status: "active",
+          description: "This is a place holder for the code system which is fully supported through internal means (not by this code system)",
+          content: "not-present"
+        }
+        if (cs.version()) {
+          json.version = cs.version();
+        }
+        if (cs.iteratable()) {
+          json.content =  "conplete",
+          json.concept = [];
+          let csp = cs.build(this.opContext, []);
+          let iter = await csp.iteratorAll();
+          let c = await csp.nextContext(iter);
+          while (c) {
+            let cc = {
+              code: await csp.code(c),
+              display: await csp.display(c)
+            }
+            let def = await csp.definition(c);
+            if (def) {
+              cc.definition = def;
+            }
+            json.concept.push(cc);
+            c = await csp.nextContext(iter);
+          }
+
+        }
+        return res.json(json);
+      }
+    }
+
+    return res.status(404).json({
+      resourceType: 'OperationOutcome',
+      issue: [{
+        severity: 'error',
+        code: 'not-found',
+        diagnostics: `CodeSystem/${id} not found`
+      }]
+    });
+  }
+
+  /**
+   * Handle ValueSet read
+   */
+  async handleValueSet(req, res, id) {
+    // Iterate through valueSetProviders in order
+    for (const vsp of this.provider.valueSetProviders) {
+      this.deadCheck('handleValueSet-loop');
+      const vs = await vsp.fetchValueSetById(id);
+      if (vs) {
+        return res.json(vs.jsonObj);
+      }
+    }
+
+    return res.status(404).json({
+      resourceType: 'OperationOutcome',
+      issue: [{
+        severity: 'error',
+        code: 'not-found',
+        diagnostics: `ValueSet/${id} not found`
+      }]
+    });
+  }
+}
+
+module.exports = ReadWorker;