fhirsmith 0.3.0

package/tx/workers/search.js

@@ -0,0 +1,384 @@
+//
+// Search Worker - Handles resource search operations
+//
+// GET /{type}?{params}
+// POST /{type}/_search
+//
+
+const { TerminologyWorker } = require('./worker');
+
+class SearchWorker 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';
+  }
+
+
+  // Allowed search parameters
+  static ALLOWED_PARAMS = [
+    '_offset', '_count', '_elements', '_sort',
+    'url', 'version', 'content-mode', 'date', 'description',
+    'supplements', 'identifier', 'jurisdiction', 'name',
+    'publisher', 'status', 'system', 'title', 'text'
+  ];
+
+  // Sortable fields
+  static SORT_FIELDS = ['id', 'url', 'version', 'date', 'name', 'vurl'];
+
+  /**
+   * Handle a search 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 params = req.method === 'POST' ? req.body : req.query;
+
+    this.log.debug(`Search ${resourceType} with params:`, params);
+
+    try {
+      // Parse pagination parameters
+      const offset = Math.max(0, parseInt(params._offset) || 0);
+      const elements = params._elements ? decodeURIComponent(params._elements).split(',').map(e => e.trim()) : null;
+      const count = Math.min(elements ? 2000 : 200, Math.max(1, parseInt(params._count) || 20));
+      const sort = params._sort || "id";
+
+      // Get matching resources
+      let matches = [];
+      switch (resourceType) {
+        case 'CodeSystem':
+          matches = this.searchCodeSystems(params);
+          break;
+
+        case 'ValueSet':
+          matches = await this.searchValueSets(params, elements);
+          break;
+
+        case 'ConceptMap':
+          // Not implemented yet - return empty set
+          matches = [];
+          break;
+
+        default:
+          matches = [];
+      }
+
+      // Sort results
+      matches = this.sortResults(matches, sort);
+
+      // Build and return the bundle
+      const bundle = this.buildSearchBundle(
+        req, resourceType, matches, offset, count, elements
+      );
+      req.logInfo = `${bundle.entry.length} matches`;
+      return res.json(bundle);
+
+    } catch (error) {
+      req.logInfo = "error "+(error.msgId || error.className);
+      this.log.error(error);
+      return res.status(500).json({
+        resourceType: 'OperationOutcome',
+        issue: [{
+          severity: 'error',
+          code: 'exception',
+          diagnostics: error.message
+        }]
+      });
+    }
+  }
+
+  /**
+   * Search CodeSystems
+   */
+  searchCodeSystems(params) {
+    const matches = [];
+
+    // Extract search parameters (excluding special params)
+    const searchParams = {};
+    for (const [key, value] of Object.entries(params)) {
+      if (!key.startsWith('_') && value && SearchWorker.ALLOWED_PARAMS.includes(key)) {
+        searchParams[key] = value.toLowerCase();
+      }
+    }
+
+    // If no search params, return all
+    const hasSearchParams = Object.keys(searchParams).length > 0;
+
+    for (const [key, cs] of this.provider.codeSystems) {
+      this.deadCheck('searchCodeSystems');
+      if (key == cs.vurl) {
+        const json = cs.jsonObj;
+
+        if (!hasSearchParams) {
+          matches.push(json);
+          continue;
+        }
+
+        // Check each search parameter for partial match
+        let isMatch = true;
+        for (const [param, searchValue] of Object.entries(searchParams)) {
+          // 'system' doesn't do anything for CodeSystem search
+          if (param === 'system') {
+            continue;
+          }
+
+          // Map content-mode to content property
+          const jsonProp = param === 'content-mode' ? 'content' : param;
+
+          if (param === 'jurisdiction') {
+            // Special handling for jurisdiction - array of CodeableConcept
+            if (!this.matchJurisdiction(json.jurisdiction, searchValue)) {
+              isMatch = false;
+              break;
+            }
+          } else if (param === 'text') {
+            const propValue = json.title + json.description;
+            if (!this.matchValue(propValue, searchValue)) {
+              isMatch = false;
+              break;
+            }
+          } else {
+            // Standard partial text match
+            const propValue = json[jsonProp];
+            if (!this.matchValue(propValue, searchValue)) {
+              isMatch = false;
+              break;
+            }
+          }
+        }
+
+        if (isMatch) {
+          matches.push(json);
+        }
+      }
+    }
+
+    return matches;
+  }
+
+  /**
+   * Search ValueSets by delegating to providers
+   */
+  async searchValueSets(params, elements) {
+    const allMatches = [];
+
+    // Convert params object to array format expected by ValueSet providers
+    // Exclude control params (_offset, _count, _elements, _sort)
+    const searchParams = [];
+    for (const [key, value] of Object.entries(params)) {
+      if (!key.startsWith('_') && value && SearchWorker.ALLOWED_PARAMS.includes(key)) {
+        searchParams.push({ name: key, value: value });
+      }
+    }
+
+    for (const vsp of this.provider.valueSetProviders) {
+      this.deadCheck('searchValueSets-providers');
+      const results = await vsp.searchValueSets(searchParams, elements);
+      if (results && Array.isArray(results)) {
+        for (const vs of results) {
+          this.deadCheck('searchValueSets-results');
+          allMatches.push(vs.jsonObj || vs);
+        }
+      }
+    }
+
+    return allMatches;
+  }
+
+  /**
+   * Check if a value matches the search term (partial, case-insensitive)
+   */
+  matchValue(propValue, searchValue) {
+    if (propValue === undefined || propValue === null) {
+      return false;
+    }
+
+    const strValue = String(propValue).toLowerCase();
+    return strValue.includes(searchValue);
+  }
+
+  /**
+   * Check if jurisdiction matches - jurisdiction is an array of CodeableConcept
+   */
+  matchJurisdiction(jurisdictions, searchValue) {
+    if (!jurisdictions || !Array.isArray(jurisdictions)) {
+      return false;
+    }
+
+    for (const cc of jurisdictions) {
+      // Check coding array
+      if (cc.coding && Array.isArray(cc.coding)) {
+        for (const coding of cc.coding) {
+          if (coding.code && coding.code.toLowerCase().includes(searchValue)) {
+            return true;
+          }
+          if (coding.display && coding.display.toLowerCase().includes(searchValue)) {
+            return true;
+          }
+        }
+      }
+      // Check text
+      if (cc.text && cc.text.toLowerCase().includes(searchValue)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Sort results by the specified field
+   */
+  sortResults(results, sortField) {
+    if (!SearchWorker.SORT_FIELDS.includes(sortField)) {
+      return results;
+    }
+
+    return results.sort((a, b) => {
+      if (sortField === 'vurl') {
+        // Sort by url then version
+        const urlCompare = (a.url || '').localeCompare(b.url || '');
+        if (urlCompare !== 0) return urlCompare;
+        return (a.version || '').localeCompare(b.version || '');
+      }
+
+      const aVal = a[sortField] || '';
+      const bVal = b[sortField] || '';
+      return String(aVal).localeCompare(String(bVal));
+    });
+  }
+
+  /**
+   * Build a FHIR search Bundle with pagination
+   */
+  buildSearchBundle(req, resourceType, allMatches, offset, count, elements) {
+    const total = allMatches.length;
+
+    // Get the slice for this page
+    const pageResults = allMatches.slice(offset, offset + count);
+
+    // Build base URL for pagination links
+    const protocol = req.protocol;
+    const host = req.get('host');
+    const basePath = req.baseUrl + req.path;
+    const baseUrl = `${protocol}://${host}${basePath}`;
+
+    // Preserve search params for pagination links (excluding _offset)
+    const searchParams = new URLSearchParams();
+    const params = req.method === 'POST' ? req.body : req.query;
+    for (const [key, value] of Object.entries(params)) {
+      if (key !== '_offset' && value) {
+        searchParams.set(key, value);
+      }
+    }
+
+    // Build pagination links
+    const links = [];
+
+    // Self link
+    const selfParams = new URLSearchParams(searchParams);
+    selfParams.set('_offset', offset);
+    links.push({
+      relation: 'self',
+      url: `${baseUrl}?${selfParams.toString()}`
+    });
+
+    // First link
+    const firstParams = new URLSearchParams(searchParams);
+    firstParams.set('_offset', 0);
+    links.push({
+      relation: 'first',
+      url: `${baseUrl}?${firstParams.toString()}`
+    });
+
+    // Previous link (if not on first page)
+    if (offset > 0) {
+      const prevParams = new URLSearchParams(searchParams);
+      prevParams.set('_offset', Math.max(0, offset - count));
+      links.push({
+        relation: 'previous',
+        url: `${baseUrl}?${prevParams.toString()}`
+      });
+    }
+
+    // Next link (if more results)
+    if (offset + count < total) {
+      const nextParams = new URLSearchParams(searchParams);
+      nextParams.set('_offset', offset + count);
+      links.push({
+        relation: 'next',
+        url: `${baseUrl}?${nextParams.toString()}`
+      });
+    }
+
+    // Last link
+    const lastOffset = Math.max(0, Math.floor((total - 1) / count) * count);
+    const lastParams = new URLSearchParams(searchParams);
+    lastParams.set('_offset', lastOffset);
+    links.push({
+      relation: 'last',
+      url: `${baseUrl}?${lastParams.toString()}`
+    });
+
+    // Build entries
+    const entries = pageResults.map(resource => {
+      // Apply _elements filter if specified
+      let filteredResource = resource;
+      if (elements) {
+        filteredResource = this.filterElements(resource, elements);
+      }
+
+      return {
+        fullUrl: `${protocol}://${host}${req.baseUrl}/${resourceType}/${resource.id}`,
+        resource: filteredResource,
+        search: {
+          mode: 'match'
+        }
+      };
+    });
+
+    return {
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: total,
+      link: links,
+      entry: entries
+    };
+  }
+
+  /**
+   * Filter resource to only include specified elements
+   */
+  filterElements(resource, elements) {
+    // Always include resourceType and id
+    const filtered = {
+      resourceType: resource.resourceType,
+      id: resource.id
+    };
+
+    for (const element of elements) {
+      if (resource[element] !== undefined) {
+        filtered[element] = resource[element];
+      }
+    }
+
+    return filtered;
+  }
+}
+
+module.exports = SearchWorker;

package/tx/workers/subsumes.js

@@ -0,0 +1,334 @@
+//
+// Subsumes Worker - Handles CodeSystem $subsumes operation
+//
+// GET /CodeSystem/$subsumes?{params}
+// POST /CodeSystem/$subsumes
+// GET /CodeSystem/{id}/$subsumes?{params}
+// POST /CodeSystem/{id}/$subsumes
+//
+
+const { TerminologyWorker } = require('./worker');
+const { FhirCodeSystemProvider } = require('../cs/cs-cs');
+const {TxParameters} = require("../params");
+const {Parameters} = require("../library/parameters");
+const {Issue, OperationOutcome} = require("../library/operation-outcome");
+class SubsumesWorker 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 'subsumes';
+  }
+
+  /**
+   * Handle a type-level $subsumes request
+   * GET/POST /CodeSystem/$subsumes
+   * @param {express.Request} req - Express request
+   * @param {express.Response} res - Express response
+   */
+  async handle(req, res) {
+    try {
+      await this.handleTypeLevelSubsumes(req, res);
+    } catch (error) {
+      req.logInfo = "error "+(error.msgId || error.className);
+      this.log.error(error);
+      if (error instanceof Issue) {
+        let oo = new OperationOutcome();
+        oo.addIssue(error);
+        return res.status(error.statusCode || 500).json(oo.jsonObj);
+      } else {
+        return res.status(error.statusCode || 500).json(this.operationOutcome(
+          'error', error.issueCode || 'exception', error.message));
+      }
+    }
+  }
+
+  /**
+   * Handle an instance-level $subsumes request
+   * GET/POST /CodeSystem/{id}/$subsumes
+   * @param {express.Request} req - Express request
+   * @param {express.Response} res - Express response
+   */
+  async handleInstance(req, res) {
+    try {
+      await this.handleInstanceLevelSubsumes(req, res);
+    } catch (error) {
+      this.log.error(error);
+      if (error instanceof Issue) {
+        let oo = new OperationOutcome();
+        oo.addIssue(error);
+        return res.status(error.statusCode || 500).json(oo.jsonObj);
+      } else {
+        return res.status(error.statusCode || 500).json(this.operationOutcome(
+          'error', error.issueCode || 'exception', error.message));
+      }
+    }
+  }
+
+  /**
+   * Handle type-level subsumes: /CodeSystem/$subsumes
+   * CodeSystem identified by system+version params or from codingA/codingB
+   */
+  async handleTypeLevelSubsumes(req, res) {
+    this.deadCheck('subsumes-type-level');
+
+    // Handle tx-resource and cache-id parameters from Parameters resource
+    if (req.body && req.body.resourceType === 'Parameters') {
+      this.setupAdditionalResources(req.body);
+    }
+
+    // Parse parameters from request
+    const params = new Parameters(this.parseParameters(req));
+    const txp = new TxParameters(this.opContext.i18n.languageDefinitions, this.opContext.i18n);
+    txp.readParams(params.jsonObj);
+
+    // Get the codings and code system provider
+    let codingA, codingB;
+    let csProvider;
+
+    if (params.has('codingA') && params.has('codingB')) {
+      // Using codingA and codingB (only from Parameters resource)
+      codingA = params.get('codingA');
+      codingB = params.get('codingB');
+
+      // Codings must have the same system
+      if (codingA.system !== codingB.system) {
+        throw new Issue('error', 'not-found', null, null, 'codingA and codingB must have the same system', null, 400);
+      }
+      // Get the code system provider from the coding's system
+      csProvider = await this.findCodeSystem(codingA.system, codingA.version || '', txp, ['complete'], null, false);
+      this.seeSourceProvider(csProvider, codingA.system);
+    } else if (params.has('codeA') && params.has('codeB')) {
+      // Using codeA, codeB - system is required
+      if (!params.has('system')) {
+        throw new Issue('error', 'not-found', null, null, 'system parameter is required when using codeA and codeB', null, 404);
+      }
+
+      csProvider = await this.findCodeSystem(params.get('system'), params.get('version') || '', txp, ['complete'], null, false);
+      this.seeSourceProvider(csProvider, params.get('system'));
+      // Create codings from the codes
+      codingA = {
+        system: csProvider.system(),
+        version: csProvider.version(),
+        code: params.get('codeA')
+      };
+      codingB = {
+        system: csProvider.system(),
+        version: csProvider.version(),
+        code: params.get('codeB')
+      };
+
+    } else {
+      throw new Issue('error', 'invalid', null, null, 'Must provide either codingA and codingB, or codeA and codeB with system', null, 400);
+    }
+
+    // Perform the subsumes check
+    const result = await this.doSubsumes(csProvider, codingA, codingB);
+    req.logInfo = this.usedSources.join("|")+txp.logInfo();
+    return res.status(200).json(result);
+  }
+
+  /**
+   * Handle instance-level subsumes: /CodeSystem/{id}/$subsumes
+   * CodeSystem identified by resource ID
+   */
+  async handleInstanceLevelSubsumes(req, res) {
+    this.deadCheck('subsumes-instance-level');
+
+    const { id } = req.params;
+
+    // Find the CodeSystem by ID
+    const codeSystem = await this.provider.getCodeSystemById(this.opContext, id);
+
+    if (!codeSystem) {
+      throw new Issue('error', 'not found', null, null, `CodeSystem/${id} not found`, null, 404);
+    }
+
+    // Handle tx-resource and cache-id parameters from Parameters resource
+    if (req.body && req.body.resourceType === 'Parameters') {
+      this.setupAdditionalResources(req.body);
+    }
+
+    // Parse parameters from request
+    const params = new Parameters(this.parseParameters(req));
+    const txp = new TxParameters(this.opContext.i18n.languageDefinitions, this.opContext.i18n);
+    txp.readParams(params.jsonObj);
+
+    // Load any supplements
+    const supplements = this.loadSupplements(codeSystem.url, codeSystem.version);
+
+    // Create a FhirCodeSystemProvider for this CodeSystem
+    const csProvider = new FhirCodeSystemProvider(this.opContext, codeSystem, supplements);
+
+    // Get the codings
+    let codingA, codingB;
+
+    if (params.has('codingA') && params.has('codingB')) {
+      codingA = params.get('codingA');
+      codingB = params.get('codingB');
+    } else if (params.has('codeA') && params.has('codeB')) {
+      // Create codings from the codes using this CodeSystem
+      codingA = {
+        system: csProvider.system(),
+        version: csProvider.version(),
+        code: params.get('codeA')
+      };
+      codingB = {
+        system: csProvider.system(),
+        version: csProvider.version(),
+        code: params.get('codeB')
+      };
+    } else {
+      throw new Issue('error', 'invalid', null, null, 'Must provide either codingA and codingB, or codeA and codeB with system', null, 400);
+    }
+
+    // Perform the subsumes check
+    const result = await this.doSubsumes(csProvider, codingA, codingB);
+    req.logInfo = this.usedSources.join("|")+txp.logInfo();
+    return res.json(result);
+  }
+  /**
+   * Parse parameters from request (query params, form body, or Parameters resource)
+   * Returns a FHIR Parameters resource
+   * @param {express.Request} req - Express request
+   * @returns {Object} FHIR Parameters resource
+   */
+  parseParameters(req) {
+    // Check if body is a Parameters resource
+    if (req.body && req.body.resourceType === 'Parameters') {
+      return req.body;
+    }
+
+    // Parse from query params or form body and convert to Parameters resource
+    const params = req.method === 'POST' ? req.body : req.query;
+    return this.simpleParamsToParametersResource(params);
+  }
+
+  /**
+   * Convert simple parameters (query string or form body) to a FHIR Parameters resource
+   * @param {Object} params - Query params or form body
+   * @returns {Object} FHIR Parameters resource
+   */
+  simpleParamsToParametersResource(params) {
+    const result = {
+      resourceType: 'Parameters',
+      parameter: []
+    };
+
+    if (!params) {
+      return result;
+    }
+
+    for (const [name, value] of Object.entries(params)) {
+      if (value === undefined || value === null) {
+        continue;
+      }
+
+      // Handle arrays (e.g., repeated query params)
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          result.parameter.push({
+            name: name,
+            valueString: String(v)
+          });
+        }
+      } else {
+        result.parameter.push({
+          name: name,
+          valueString: String(value)
+        });
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Perform the actual subsumes check
+   * @param {CodeSystemProvider} csProvider - CodeSystem provider
+   * @param {Object} codingA - First coding
+   * @param {Object} codingB - Second coding
+   * @returns {Object} Parameters resource with subsumes result
+   */
+  async doSubsumes(csProvider, codingA, codingB) {
+    this.deadCheck('doSubsumes');
+
+    const csSystem = csProvider.system();
+
+    // Check system uri matches for both codings
+    if (csSystem !== codingA.system) {
+      const error = new Error(`System uri / code uri mismatch - not supported at this time (${csSystem}/${codingA.system})`);
+      error.statusCode = 400;
+      error.issueCode = 'not-supported';
+      throw error;
+    }
+    if (csSystem !== codingB.system) {
+      const error = new Error(`System uri / code uri mismatch - not supported at this time (${csSystem}/${codingB.system})`);
+      error.statusCode = 400;
+      error.issueCode = 'not-supported';
+      throw error;
+    }
+
+    // Validate both codes exist
+    const locateA = await csProvider.locate(codingA.code);
+    if (!locateA || !locateA.context) {
+      const error = new Error(`Invalid code: '${codingA.code}' not found in CodeSystem '${csSystem}'`);
+      error.statusCode = 404;
+      error.issueCode = 'not-found';
+      throw error;
+    }
+
+    const locateB = await csProvider.locate(codingB.code);
+    if (!locateB || !locateB.context) {
+      const error = new Error(`Invalid code: '${codingB.code}' not found in CodeSystem '${csSystem}'`);
+      error.statusCode = 404;
+      error.issueCode = 'not-found';
+      throw error;
+    }
+
+    // Determine the subsumption relationship
+    let outcome = await csProvider.subsumesTest(codingA.code, codingB.code);
+
+    return {
+      resourceType: 'Parameters',
+      parameter: [
+        {
+          name: 'outcome',
+          valueCode: outcome
+        }
+      ]
+    };
+  }
+
+  /**
+   * Build an OperationOutcome
+   * @param {string} severity - error, warning, information
+   * @param {string} code - Issue code
+   * @param {string} message - Diagnostic message
+   * @returns {Object} OperationOutcome resource
+   */
+  operationOutcome(severity, code, message) {
+    return {
+      resourceType: 'OperationOutcome',
+      issue: [{
+        severity,
+        code,
+        diagnostics: message
+      }]
+    };
+  }
+}
+
+module.exports = SubsumesWorker;