fhirsmith 0.3.0

package/tx/tx.js

@@ -0,0 +1,927 @@
+//
+// TX Module - FHIR Terminology Server
+//
+// This module provides FHIR terminology services (CodeSystem, ValueSet, ConceptMap)
+// with support for multiple endpoints at different FHIR versions.
+//
+
+const express = require('express');
+const path = require('path');
+const Logger = require('../library/logger');
+const { Library } = require('./library');
+const { OperationContext, ResourceCache, ExpansionCache } = require('./operation-context');
+const { LanguageDefinitions } = require('../library/languages');
+const { I18nSupport } = require('../library/i18nsupport');
+const { CodeSystemXML } = require('./xml/codesystem-xml');
+const txHtml = require('./tx-html');
+const { Liquid } = require('liquidjs');
+const packageJson = require("../package.json");
+
+// Import workers
+const ReadWorker = require('./workers/read');
+const SearchWorker = require('./workers/search');
+const { ExpandWorker } = require('./workers/expand');
+const { ValidateWorker } = require('./workers/validate');
+const TranslateWorker = require('./workers/translate');
+const LookupWorker = require('./workers/lookup');
+const SubsumesWorker = require('./workers/subsumes');
+const { MetadataHandler } = require('./workers/metadata');
+const { BatchValidateWorker } = require('./workers/batch-validate');
+const {CapabilityStatementXML} = require("./xml/capabilitystatement-xml");
+const {TerminologyCapabilitiesXML} = require("./xml/terminologycapabilities-xml");
+const {ParametersXML} = require("./xml/parameters-xml");
+const {OperationOutcomeXML} = require("./xml/operationoutcome-xml");
+const {ValueSetXML} = require("./xml/valueset-xml");
+const {ConceptMapXML} = require("./xml/conceptmap-xml");
+const {TxHtmlRenderer} = require("./tx-html");
+const {Renderer} = require("./library/renderer");
+const {OperationsWorker} = require("./workers/operations");
+
+class TXModule {
+  timers = [];
+
+  constructor(stats) {
+    this.config = null;
+    this.library = null;
+    this.endpoints = [];
+    this.routers = new Map(); // path -> router
+    this.requestIdCounter = 0; // Thread-safe request ID counter
+    this.languages = null; // LanguageDefinitions
+    this.i18n = null; // I18nSupport
+    this.metadataHandler = null; // MetadataHandler
+    this.liquid = new Liquid({
+      root: path.join(__dirname, 'html'),  // optional: where to look for templates
+      extname: '.liquid'    // optional: default extension
+    });
+    this.stats = stats;
+    if (stats) {
+      stats.cachingModules.push(this);
+    }
+  }
+
+  /**
+   * Generate a unique request ID
+   * @returns {string} Unique request ID
+   */
+  generateRequestId() {
+    this.requestIdCounter++;
+    return `tx-${this.requestIdCounter}`;
+  }
+
+  acceptsXml(req) {
+    const accept = req.headers.accept || '';
+    return accept.includes('application/fhir+xml') || accept.includes('application/xml+fhir');
+  }
+
+
+  /**
+   * Initialize the TX module
+   * @param {Object} config - Module configuration
+   * @param {express.Application} app - Express application for registering endpoints
+   */
+  async initialize(config, app) {
+    this.config = config;
+    // Initialize logger with config settings
+    this.log = Logger.getInstance().child({
+      module: 'tx',
+      consoleErrors: config.consoleErrors,
+      telnetErrors: config.telnetErrors
+    });
+
+    this.log.info('Initializing TX module');
+
+    // Load HTML template
+    txHtml.loadTemplate();
+
+    // Validate config
+    if (!config.librarySource) {
+      throw new Error('TX module requires librarySource configuration');
+    }
+
+    if (!config.endpoints || !Array.isArray(config.endpoints) || config.endpoints.length === 0) {
+      throw new Error('TX module requires at least one endpoint configuration');
+    }
+
+    // Load language definitions
+    const langPath = path.join(__dirname, 'data', 'lang.dat');
+    this.log.info(`Loading language definitions from: ${langPath}`);
+    this.languages = await LanguageDefinitions.fromFile(langPath);
+    this.log.info('Language definitions loaded');
+
+    // Initialize i18n support
+    const translationsPath = path.join(__dirname, '..', 'translations');
+    this.log.info(`Loading translations from: ${translationsPath}`);
+    this.i18n = new I18nSupport(translationsPath, this.languages);
+    await this.i18n.load();
+    this.log.info('I18n support initialized');
+
+    // Initialize metadata handler with config
+    this.metadataHandler = new MetadataHandler({
+      baseUrl: config.baseUrl,
+      serverVersion: packageJson.version,
+      softwareName: config.softwareName || 'FHIRsmith',
+      name: config.name || 'FHIRTerminologyServer',
+      title: config.title || 'FHIR Terminology Server',
+      description: config.description || 'FHIR Terminology Server',
+      contactUrl: config.contactUrl,
+      contact: config.contact,
+      releaseDate: config.releaseDate,
+      host: config.host ? config.host : "localhost"
+    });
+
+    // Load the library from YAML
+    this.log.info(`Loading library from: ${config.librarySource}`);
+    this.library = new Library(config.librarySource, this.log);
+    this.log.info(`Load...`);
+    await this.library.load();
+    this.log.info('Library loaded successfully');
+
+    // Set up each endpoint
+    for (const endpoint of config.endpoints) {
+      await this.setupEndpoint(endpoint, app);
+    }
+
+    this.log.info(`TX module initialized with ${config.endpoints.length} endpoint(s)`);
+  }
+
+  /**
+   * Set up a single endpoint
+   * @param {Object} endpoint - Endpoint configuration {path, fhirVersion, context}
+   * @param {express.Application} app - Express application
+   */
+  async setupEndpoint(endpoint, app) {
+    const { path: endpointPath, context } = endpoint;
+    const fhirVersion = String(endpoint.fhirVersion);
+
+    if (!endpointPath) {
+      throw new Error('Endpoint requires a path');
+    }
+
+    if (!fhirVersion) {
+      throw new Error(`Endpoint ${endpointPath} requires a fhirVersion`);
+    }
+
+    // Check for path conflicts
+    if (this.routers.has(endpointPath)) {
+      throw new Error(`Duplicate endpoint path: ${endpointPath}`);
+    }
+
+    this.log.info(`Setting up endpoint: ${endpointPath} (FHIR v${fhirVersion}, context: ${context || 'none'})`);
+
+    const router = express.Router();
+
+    // Get cache configuration
+    const cacheTimeoutMinutes = this.config.cacheTimeout || 30;
+    const expansionCacheSize = this.config.expansionCacheSize || 1000;
+    const expansionCacheMemoryThreshold = this.config.expansionCacheMemoryThreshold || 0;
+
+    // Store endpoint info for provider creation
+    const endpointInfo = {
+      path: endpointPath,
+      fhirVersion,
+      context: context || null,
+      resourceCache: new ResourceCache(),
+      expansionCache: new ExpansionCache(expansionCacheSize, expansionCacheMemoryThreshold)
+    };
+    // Create the provider once for this endpoint
+    endpointInfo.provider = await this.library.cloneWithFhirVersion(fhirVersion, context, endpointPath);
+
+    // Set up periodic pruning of the resource cache
+    // cacheTimeout is in minutes, default to 30 minutes
+    const cacheTimeoutMs = cacheTimeoutMinutes * 60 * 1000;
+    const pruneIntervalMs = 5 * 60 * 1000; // Run every 5 minutes
+    this.timers.push(setInterval(() => {
+      endpointInfo.resourceCache.prune(cacheTimeoutMs);
+    }, pruneIntervalMs));
+    this.log.info(`Resource cache pruning enabled for ${endpointPath}: timeout ${cacheTimeoutMinutes} minutes, check interval 5 minutes`);
+
+    // Set up periodic memory pressure check for expansion cache (if threshold configured)
+    if (expansionCacheMemoryThreshold > 0) {
+      this.timers.push(setInterval(() => {
+        if (endpointInfo.expansionCache.checkMemoryPressure()) {
+          this.log.info(`Expansion cache memory pressure detected for ${endpointPath}, evicted oldest half`);
+        }
+      }, pruneIntervalMs));
+      this.log.info(`Expansion cache for ${endpointPath}: max ${expansionCacheSize} entries, memory threshold ${expansionCacheMemoryThreshold}MB`);
+    } else {
+      this.log.info(`Expansion cache for ${endpointPath}: max ${expansionCacheSize} entries, no memory threshold`);
+    }
+
+    // Middleware to attach provider, context, and timing to request, and wrap res.json for HTML
+    router.use((req, res, next) => {
+      // Increment request count
+      endpointInfo.provider.requestCount++;
+
+      // Generate unique request ID
+      const requestId = this.generateRequestId();
+
+      // Get Accept-Language header for language preferences
+      const acceptLanguage = req.get('Accept-Language') || 'en';
+
+      // Create operation context with language, ID, time limit, and caches
+      const opContext = new OperationContext(
+        acceptLanguage, this.i18n, requestId, 30,
+        endpointInfo.resourceCache, endpointInfo.expansionCache
+      );
+
+      // Attach everything to request
+      req.txProvider = endpointInfo.provider;
+      req.txEndpoint = endpointInfo;
+      req.txStartTime = Date.now();
+      req.txOpContext = opContext;
+      req.txLanguages = this.languages;
+      req.txI18n = this.i18n;
+      req.txLog = this.log;
+
+      // Add X-Request-Id header to response
+      res.setHeader('X-Request-Id', requestId);
+
+      // Wrap res.json to intercept and convert to HTML if browser requests it, and log the request
+      const originalJson = res.json.bind(res);
+
+      let txhtml = new TxHtmlRenderer(new Renderer(opContext, endpointInfo.provider), this.liquid);
+      res.json = async (data) => {
+        try {
+          const duration = Date.now() - req.txStartTime;
+          const isHtml = txhtml.acceptsHtml(req);
+          const isXml = this.acceptsXml(req);
+
+          let responseSize;
+          let result;
+
+          if (isHtml) {
+            const title = txhtml.buildTitle(data, req);
+            const content = await txhtml.render(data, req);
+            const html = await txhtml.renderPage(title, content, req.txEndpoint, req.txStartTime);
+            responseSize = Buffer.byteLength(html, 'utf8');
+            res.setHeader('Content-Type', 'text/html');
+            result = res.send(html);
+          } else if (isXml) {
+            try {
+              const xml = this.convertResourceToXml(data);
+              responseSize = Buffer.byteLength(xml, 'utf8');
+              res.setHeader('Content-Type', 'application/fhir+xml');
+              result = res.send(xml);
+            } catch (err) {
+              console.error(err);
+              // Fall back to JSON if XML conversion not supported
+              this.log.warn(`XML conversion failed for ${data.resourceType}: ${err.message}, falling back to JSON`);
+              const jsonStr = JSON.stringify(data);
+              responseSize = Buffer.byteLength(jsonStr, 'utf8');
+              result = originalJson(data);
+            }
+          } else {
+            const jsonStr = JSON.stringify(data);
+            responseSize = Buffer.byteLength(jsonStr, 'utf8');
+            result = originalJson(data);
+          }
+
+          // Log the request with request ID
+          const format = isHtml ? 'html' : (isXml ? 'xml' : 'json');
+          let li = req.logInfo ? "(" + req.logInfo + ")" : "";
+          this.log.info(`[${requestId}] ${req.method} ${format} ${res.statusCode} ${duration}ms ${responseSize}: ${req.originalUrl} ${li})`);
+
+          return result;
+        } catch (err) {
+          this.log.error(`Error rendering response: ${err.message}`);
+          console.error(err);
+          res.status(500).send('Internal Server Error');
+        }
+      };
+
+      next();
+    });
+
+    // CORS headers
+    router.use((req, res, next) => {
+      res.header('Access-Control-Allow-Origin', '*');
+      res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+      res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+      if (req.method === 'OPTIONS') {
+        return res.sendStatus(200);
+      }
+      next();
+    });
+
+    // JSON body parsing - accept both application/json and application/fhir+json
+    // Handle body that may already be read as a Buffer by app-level middleware
+    router.use((req, res, next) => {
+      const contentType = req.get('Content-Type') || '';
+
+      // Only process POST/PUT
+      if (req.method !== 'POST' && req.method !== 'PUT') {
+        return next();
+      }
+
+      if (contentType.includes('application/json') ||
+          contentType.includes('application/fhir+json') ||
+          contentType.includes('application/json+fhir')) {
+
+        // If body is a Buffer, parse it
+        if (Buffer.isBuffer(req.body)) {
+          try {
+            const bodyStr = req.body.toString('utf8');
+            if (bodyStr) {
+              req.body = JSON.parse(bodyStr);
+            }
+          } catch (e) {
+            this.log.error(`JSON parse error: ${e.message}`);
+            return res.status(400).json({
+              resourceType: 'OperationOutcome',
+              issue: [{
+                severity: 'error',
+                code: 'invalid',
+                diagnostics: `Invalid JSON: ${e.message}`
+              }]
+            });
+          }
+        }
+
+      } else if (contentType.includes('application/xml') ||
+        // Handle XML
+        contentType.includes('application/fhir+xml') ||
+        contentType.includes('application/xml+fhir')) {
+
+        let xmlStr;
+        if (Buffer.isBuffer(req.body)) {
+          xmlStr = req.body.toString('utf8');
+        } else if (typeof req.body === 'string') {
+          xmlStr = req.body;
+        }
+
+        if (xmlStr) {
+          try {
+            req.body = this.convertXmlToResource(xmlStr);
+          } catch (e) {
+            this.log.error(`XML parse error: ${e.message}`);
+            return res.status(400).json({
+              resourceType: 'OperationOutcome',
+              issue: [{
+                severity: 'error',
+                code: 'invalid',
+                diagnostics: `Invalid XML: ${e.message}`
+              }]
+            });
+          }
+        }
+      }
+
+      next();
+    });
+
+
+    // Set up routes
+    this.setupRoutes(router);
+
+    // Register the router with the app
+    app.use(endpointPath, router);
+    this.routers.set(endpointPath, router);
+    this.endpoints.push(endpointInfo);
+
+    this.log.info(`Endpoint ${endpointPath} registered`);
+  }
+
+  /**
+   * Set up routes for an endpoint
+   * @param {express.Router} router - Express router
+   */
+  setupRoutes(router) {
+    const resourceTypes = ['CodeSystem', 'ValueSet', 'ConceptMap'];
+
+    // ===== Operations =====
+
+
+    // CodeSystem/$lookup (GET and POST)
+    router.get('/CodeSystem/\\$lookup', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new LookupWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res);
+      } finally {
+        this.countRequest('$lookup', Date.now() - start);
+      }
+    });
+    router.post('/CodeSystem/\\$lookup', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new LookupWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res);
+      } finally {
+        this.countRequest('$lookup', Date.now() - start);
+      }
+    });
+
+    // CodeSystem/$subsumes (GET and POST)
+    router.get('/CodeSystem/\\$subsumes', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new SubsumesWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res);
+      } finally {
+        this.countRequest('$subsumes', Date.now() - start);
+      }
+    });
+    router.post('/CodeSystem/\\$subsumes', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new SubsumesWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res);
+      } finally {
+        this.countRequest('$subsumes', Date.now() - start);
+      }
+    });
+
+    // CodeSystem/$validate-code (GET and POST)
+    router.get('/CodeSystem/\\$validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleCodeSystem(req, res);
+      } finally {
+        this.countRequest('$validate', Date.now() - start);
+      }
+    });
+    router.post('/CodeSystem/\\$validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleCodeSystem(req, res);
+      } finally {
+        this.countRequest('$validate', Date.now() - start);
+      }
+    });
+
+    // CodeSystem/$batch-validate-code (GET and POST)
+    router.get('/CodeSystem/\\$batch-validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new BatchValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleCodeSystem(req, res);
+      } finally {
+        this.countRequest('$batch', Date.now() - start);
+      }
+    });
+    router.post('/CodeSystem/\\$batch-validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new BatchValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleCodeSystem(req, res);
+      } finally {
+        this.countRequest('$batch', Date.now() - start);
+      }
+    });
+    // ValueSet/$validate-code (GET and POST)
+    router.get('/ValueSet/\\$validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleValueSet(req, res);
+      } finally {
+        this.countRequest('$validate', Date.now() - start);
+      }
+    });
+    router.post('/ValueSet/\\$validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleValueSet(req, res);
+      } finally {
+        this.countRequest('$validate', Date.now() - start);
+      }
+    });
+
+    // ValueSet/$batch-validate-code (GET and POST)
+    router.get('/ValueSet/\\$batch-validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new BatchValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleValueSet(req, res);
+      } finally {
+        this.countRequest('$batch', Date.now() - start);
+      }
+    });
+    router.post('/ValueSet/\\$batch-validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new BatchValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleValueSet(req, res);
+      } finally {
+        this.countRequest('validate', Date.now() - start);
+      }
+    });
+
+    // ValueSet/$expand (GET and POST)
+    router.get('/ValueSet/\\$expand', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res, this.log);
+      } finally {
+        this.countRequest('$expand', Date.now() - start);
+      }
+    });
+    router.post('/ValueSet/\\$expand', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res, this.log);
+      } finally {
+        this.countRequest('$expand', Date.now() - start);
+      }
+    });
+
+    // ConceptMap/$translate (GET and POST)
+    router.get('/ConceptMap/\\$translate', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new TranslateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res, this.log);
+      } finally {
+        this.countRequest('$translate', Date.now() - start);
+      }
+    });
+    router.post('/ConceptMap/\\$translate', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new TranslateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res, this.log);
+      } finally {
+        this.countRequest('$translate', Date.now() - start);
+      }
+    });
+
+    // ConceptMap/$closure (GET and POST)
+    router.get('/ConceptMap/\\$closure', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new TranslateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res, this.log);
+      } finally {
+        this.countRequest('$closure', Date.now() - start);
+      }
+    });
+    router.post('/ConceptMap/\\$closure', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new TranslateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res, this.log);
+      } finally {
+        this.countRequest('$closure', Date.now() - start);
+      }
+    });
+
+    // ===== Instance operations =====
+
+    // CodeSystem/[id]/$lookup
+    router.get('/CodeSystem/:id/\\$lookup', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new LookupWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleInstance(req, res);
+      } finally {
+        this.countRequest('$lookup', Date.now() - start);
+      }
+    });
+    router.post('/CodeSystem/:id/\\$lookup', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new LookupWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleInstance(req, res);
+      } finally {
+        this.countRequest('$lookup', Date.now() - start);
+      }
+    });
+
+    // CodeSystem/[id]/$subsumes
+    router.get('/CodeSystem/:id/\\$subsumes', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new SubsumesWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleInstance(req, res);
+      } finally {
+        this.countRequest('$subsumes', Date.now() - start);
+      }
+    });
+    router.post('/CodeSystem/:id/\\$subsumes', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new SubsumesWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleInstance(req, res);
+      } finally {
+        this.countRequest('$subsumes', Date.now() - start);
+      }
+    });
+
+    // CodeSystem/[id]/$validate-code
+    router.get('/CodeSystem/:id/\\$validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+      let worker = new ValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleCodeSystemInstance(req, res, this.log);
+    } finally {
+      this.countRequest('$validate', Date.now() - start);
+    }
+    });
+    router.post('/CodeSystem/:id/\\$validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleCodeSystemInstance(req, res, this.log);
+      } finally {
+        this.countRequest('$validate', Date.now() - start);
+      }
+      
+    });
+
+    // ValueSet/[id]/$validate-code
+    router.get('/ValueSet/:id/\\$validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleValueSetInstance(req, res, this.log);
+      } finally {
+        this.countRequest('$validate', Date.now() - start);
+      }
+    });
+    router.post('/ValueSet/:id/\\$validate-code', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ValidateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleValueSetInstance(req, res, this.log);
+      } finally {
+        this.countRequest('$validate', Date.now() - start);
+      }
+    });
+
+    // ValueSet/[id]/$expand
+    router.get('/ValueSet/:id/\\$expand', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleInstance(req, res, this.log);
+      } finally {
+        this.countRequest('$expand', Date.now() - start);
+      }
+    });
+    router.post('/ValueSet/:id/\\$expand', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleInstance(req, res, this.log);
+      } finally {
+        this.countRequest('$expand', Date.now() - start);
+      }
+    });
+
+    // ConceptMap/[id]/$translate
+    router.get('/ConceptMap/:id/\\$translate', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new TranslateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleInstance(req, res, this.log);
+      } finally {
+        this.countRequest('$translate', Date.now() - start);
+      }
+    });
+    router.post('/ConceptMap/:id/\\$translate', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new TranslateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleInstance(req, res, this.log);
+      } finally {
+        this.countRequest('$translate', Date.now() - start);
+      }
+    });
+
+    // ===== Read and Search =====
+
+    // Read: GET /[type]/[id]
+    for (const resourceType of resourceTypes) {
+      router.get(`/${resourceType}/:id`, async (req, res) => {
+        const start = Date.now();
+        try {
+          // Skip if id starts with $ (it's an operation)
+          if (req.params.id.startsWith('$')) {
+            return res.status(404).json(this.operationOutcome(
+              'error',
+              'not-found',
+              `Unknown operation: ${req.params.id}`
+            ));
+          }
+          let worker = new ReadWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+          await worker.handle(req, res, resourceType);
+        } finally {
+          this.countRequest('read', Date.now() - start);
+        }
+      });
+    }
+
+    // Search: GET /[type]
+    for (const resourceType of resourceTypes) {
+      router.get(`/${resourceType}`, async (req, res) => {
+        const start = Date.now();
+        try {
+          let worker = new SearchWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+          await worker.handle(req, res, resourceType);
+        } finally {
+          this.countRequest('search', Date.now() - start);
+        }
+      });
+      router.post(`/${resourceType}/_search`, async (req, res) => {
+        const start = Date.now();
+        try {
+          let worker = new SearchWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+          await worker.handle(req, res, resourceType);
+        } finally {
+          this.countRequest('search', Date.now() - start);
+        }
+      });
+    }
+
+    // Unsupported methods
+    for (const resourceType of resourceTypes) {
+      router.all(`/${resourceType}/:id`, (req, res) => {
+        const start = Date.now();
+        try {
+          if (['PUT', 'POST', 'DELETE', 'PATCH'].includes(req.method)) {
+            return res.status(405).json(this.operationOutcome(
+              'error',
+              'not-supported',
+              `Method ${req.method} is not supported`
+            ));
+          }
+        } finally {
+          this.countRequest('$read', Date.now() - start);
+        }
+      });
+    }
+
+    router.get('/op.html',  async(req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new OperationsWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res);
+      } finally {
+        this.countRequest('$op', Date.now() - start);
+      }
+    });
+
+    // Metadata / CapabilityStatement
+    router.get('/metadata', async (req, res) => {
+      const start = Date.now();
+      try {
+        try {
+          await this.metadataHandler.handle(req, res);
+        } catch (error) {
+          this.log.error(`Error in /metadata: ${error.message}`);
+          res.status(500).json(this.operationOutcome('error', 'exception', error.message));
+        }
+      } finally {
+        this.countRequest('metadata', Date.now() - start);
+      }
+    });
+
+    // $versions operation
+    router.get('/\\$versions', async (req, res) => {
+      const start = Date.now();
+      try {
+        try {
+          await this.metadataHandler.handleVersions(req, res);
+        } catch (error) {
+          this.log.error(`Error in $versions: ${error.message}`);
+          res.status(500).json(this.operationOutcome('error', 'exception', error.message));
+        }
+      } finally {
+        this.countRequest('$versions', Date.now() - start);
+      }
+    });
+
+    // Root endpoint info
+    router.get('/', async (req, res) => {
+      const start = Date.now();
+      try {
+        await res.json({
+          resourceType: 'OperationOutcome',
+          issue: [{
+            severity: 'information',
+            code: 'informational',
+            diagnostics: `FHIR Terminology Server - FHIR v${req.txEndpoint.fhirVersion}`
+          }]
+        });
+      } finally {
+        this.countRequest('home', Date.now() - start);
+      }
+    });
+  }
+
+  /**
+   * Build an OperationOutcome for errors
+   */
+  operationOutcome(severity, code, message) {
+    return {
+      resourceType: 'OperationOutcome',
+      issue: [{
+        severity,
+        code,
+        diagnostics: message
+      }]
+    };
+  }
+
+  /**
+   * Get module status for health check
+   */
+  getStatus() {
+    return {
+      enabled: true,
+      status: this.library ? 'Running' : 'Not initialized',
+      endpoints: this.endpoints.map(e => ({
+        path: e.path,
+        fhirVersion: e.fhirVersion,
+        context: e.context
+      }))
+    };
+  }
+
+  /**
+   * Shutdown the module
+   */
+  async shutdown() {
+    this.log.info('Shutting down TX module');
+    for (const timer of this.timers) {
+      clearInterval(timer);
+    }
+    this.timers = [];
+    // Clean up any resources if needed
+    await this.library.close();
+    this.log.info('TX module shut down');
+  }
+
+  trimParameters(params) {
+    if (!params || !params.parameter) {
+      return params;
+    }
+
+    params.parameter = params.parameter.filter(p => p.name !== 'tx-resource');
+
+    return params;
+  }
+
+  convertResourceToXml(res) {
+    switch (res.resourceType) {
+      case "CodeSystem" : return CodeSystemXML._jsonToXml(res);
+      case "ValueSet" : return ValueSetXML.toXml(res);
+      case "CapabilityStatement" : return CapabilityStatementXML.toXml(res, "R5");
+      case "TerminologyCapabilities" : return TerminologyCapabilitiesXML.toXml(res, "R5");
+      case "Parameters": return ParametersXML.toXml(res, this.fhirVersion);
+      case "OperationOutcome": return OperationOutcomeXML.toXml(res, this.fhirVersion);
+    }
+    throw new Error(`Resource type ${res.resourceType} not supported in XML`);
+  }
+
+  convertXmlToResource(xml) {
+    // Detect resource type from root element
+    const rootMatch = xml.match(/<([A-Za-z]+)\s/);
+    if (!rootMatch) {
+      throw new Error('Could not detect resource type from XML');
+    }
+
+    const resourceType = rootMatch[1];
+
+    let data;
+    switch (resourceType) {
+      case "Parameters":
+        data = ParametersXML.fromXml(xml);
+        break;
+      case "CodeSystem":
+        data = CodeSystemXML.fromXml(xml);
+        break;
+      case "ValueSet":
+        data = ValueSetXML.fromXml(xml);
+        break;
+      case "ConceptMap":
+        data = ConceptMapXML.fromXml(xml);
+        break;
+      default:
+        throw new Error(`Resource type ${resourceType} not supported for XML input`);
+    }
+
+    return data;
+  }
+
+  countRequest(name, tat) {
+    if (this.stats) {
+      this.stats.countRequest(name, tat);
+    }
+  }
+
+  cacheCount() {
+    let count = 0;
+    for (let ep of this.endpoints) {
+      count = count + ep.resourceCache.size() + ep.expansionCache.size();
+    }
+    return count;
+  }
+}
+
+module.exports = TXModule;