fhirsmith 0.3.0

package/tx/cs/cs-usstates.js

@@ -0,0 +1,305 @@
+const { CodeSystemProvider, CodeSystemFactoryProvider} = require('./cs-api');
+const assert = require('assert');
+const { CodeSystem } = require("../library/codesystem");
+
+class USStateConcept {
+  constructor(code, display) {
+    this.code = code;
+    this.display = display;
+  }
+}
+
+class USStateServices extends CodeSystemProvider {
+  constructor(opContext, supplements, codes, codeMap) {
+    super(opContext, supplements);
+    this.codes = codes || [];
+    this.codeMap = codeMap || new Map();
+  }
+
+  // Metadata methods
+  system() {
+    return 'https://www.usps.com/';
+  }
+
+  version() {
+    return null; // No version specified
+  }
+
+  description() {
+    return 'US State Codes';
+  }
+
+  name() {
+    return 'US State Codes';
+  }
+
+  totalCount() {
+    return this.codes.length;
+  }
+
+  hasParents() {
+    return false; // No hierarchical relationships
+  }
+
+  hasAnyDisplays(languages) {
+    const langs = this._ensureLanguages(languages);
+    if (this._hasAnySupplementDisplays(langs)) {
+      return true;
+    }
+    return super.hasAnyDisplays(langs);
+  }
+
+  // Core concept methods
+  async code(code) {
+    
+    const ctxt = await this.#ensureContext(code);
+    return ctxt ? ctxt.code : null;
+  }
+
+  async display(code) {
+    
+    const ctxt = await this.#ensureContext(code);
+    if (!ctxt) {
+      return null;
+    }
+    if (ctxt.display && this.opContext.langs.isEnglishOrNothing()) {
+      return ctxt.display.trim();
+    }
+    let disp = this._displayFromSupplements(ctxt.code);
+    if (disp) {
+      return disp;
+    }
+    return ctxt.display ? ctxt.display.trim() : '';
+  }
+
+  async definition(code) {
+    
+    await this.#ensureContext(code);
+    return null; // No definitions provided
+  }
+
+  async isAbstract(code) {
+    
+    await this.#ensureContext(code);
+    return false; // No abstract concepts
+  }
+
+  async isInactive(code) {
+    
+    await this.#ensureContext(code);
+    return false; // No inactive concepts
+  }
+
+  async isDeprecated(code) {
+    
+    await this.#ensureContext(code);
+    return false; // No deprecated concepts
+  }
+
+  async designations(code, displays) {
+    
+    const ctxt = await this.#ensureContext(code);
+    if (ctxt != null) {
+      displays.addDesignation(true, 'active', 'en', CodeSystem.makeUseForDisplay(), ctxt.display);
+      this._listSupplementDesignations(ctxt.code, displays);
+    }
+  }
+
+  async #ensureContext(code) {
+    if (!code) {
+      return code;
+    }
+    if (typeof code === 'string') {
+      const ctxt = await this.locate(code);
+      if (!ctxt.context) {
+        throw new Error(ctxt.message ? ctxt.message : `US State Code '${code}' not found`);
+      } else {
+        return ctxt.context;
+      }
+    }
+    if (code instanceof USStateConcept) {
+      return code;
+    }
+    throw new Error("Unknown Type at #ensureContext: " + (typeof code));
+  }
+
+  // Lookup methods
+  async locate(code) {
+    
+    assert(!code || typeof code === 'string', 'code must be string');
+    if (!code) return { context: null, message: 'Empty code' };
+
+    const concept = this.codeMap.get(code);
+    if (concept) {
+      return { context: concept, message: null };
+    }
+    return { context: null, message: undefined };
+  }
+
+  // Iterator methods
+  async iterator(code) {
+    
+    const ctxt = await this.#ensureContext(code);
+    if (!ctxt) {
+      return { index: 0, total: this.totalCount() };
+    }
+    return null; // No child iteration
+  }
+
+  async nextContext(iteratorContext) {
+    
+    assert(iteratorContext, 'iteratorContext must be provided');
+    if (iteratorContext && iteratorContext.index < iteratorContext.total) {
+      const concept = this.codes[iteratorContext.index];
+      iteratorContext.index++;
+      return concept;
+    }
+    return null;
+  }
+
+  // Subsumption
+  async subsumesTest(codeA, codeB) {
+    await this.#ensureContext(codeA);
+    await this.#ensureContext(codeB);
+    return 'not-subsumed'; // No subsumption relationships
+  }
+
+  versionAlgorithm() {
+    return null; // none
+  }
+}
+
+class USStateFactoryProvider extends CodeSystemFactoryProvider {
+  constructor(i18n) {
+    super(i18n);
+    this.uses = 0;
+    this.codes = null;
+    this.codeMap = null;
+  }
+
+  defaultVersion() {
+    return null; // No versioning for US states
+  }
+
+  build(opContext, supplements) {
+    this.uses++;
+    return new USStateServices(opContext, supplements, this.codes, this.codeMap);
+  }
+
+  useCount() {
+    return this.uses;
+  }
+
+  recordUse() {
+    this.uses++;
+  }
+
+
+  system() {
+    return 'https://www.usps.com/';
+  }
+
+  version() {
+    return null; // No version specified
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async buildKnownValueSet(url, version) {
+    return null;
+  }
+
+  async load() {
+    this.codes = [];
+    this.codeMap = new Map();
+
+    const data = [
+      ['AL', 'Alabama'],
+      ['AK', 'Alaska'],
+      ['AS', 'American Samoa'],
+      ['AZ', 'Arizona'],
+      ['AR', 'Arkansas'],
+      ['CA', 'California'],
+      ['CO', 'Colorado'],
+      ['CT', 'Connecticut'],
+      ['DE', 'Delaware'],
+      ['DC', 'District of Columbia'],
+      ['FM', 'Federated States of Micronesia'],
+      ['FL', 'Florida'],
+      ['GA', 'Georgia'],
+      ['GU', 'Guam'],
+      ['HI', 'Hawaii'],
+      ['ID', 'Idaho'],
+      ['IL', 'Illinois'],
+      ['IN', 'Indiana'],
+      ['IA', 'Iowa'],
+      ['KS', 'Kansas'],
+      ['KY', 'Kentucky'],
+      ['LA', 'Louisiana'],
+      ['ME', 'Maine'],
+      ['MH', 'Marshall Islands'],
+      ['MD', 'Maryland'],
+      ['MA', 'Massachusetts'],
+      ['MI', 'Michigan'],
+      ['MN', 'Minnesota'],
+      ['MS', 'Mississippi'],
+      ['MO', 'Missouri'],
+      ['MT', 'Montana'],
+      ['NE', 'Nebraska'],
+      ['NV', 'Nevada'],
+      ['NH', 'New Hampshire'],
+      ['NJ', 'New Jersey'],
+      ['NM', 'New Mexico'],
+      ['NY', 'New York'],
+      ['NC', 'North Carolina'],
+      ['ND', 'North Dakota'],
+      ['MP', 'Northern Mariana Islands'],
+      ['OH', 'Ohio'],
+      ['OK', 'Oklahoma'],
+      ['OR', 'Oregon'],
+      ['PW', 'Palau'],
+      ['PA', 'Pennsylvania'],
+      ['PR', 'Puerto Rico'],
+      ['RI', 'Rhode Island'],
+      ['SC', 'South Carolina'],
+      ['SD', 'South Dakota'],
+      ['TN', 'Tennessee'],
+      ['TX', 'Texas'],
+      ['UT', 'Utah'],
+      ['VT', 'Vermont'],
+      ['VI', 'Virgin Islands'],
+      ['VA', 'Virginia'],
+      ['WA', 'Washington'],
+      ['WV', 'West Virginia'],
+      ['WI', 'Wisconsin'],
+      ['WY', 'Wyoming'],
+      ['AE', 'Armed Forces Europe, the Middle East, and Canada'],
+      ['AP', 'Armed Forces Pacific'],
+      ['AA', 'Armed Forces Americas (except Canada)']
+    ];
+
+    // Load concepts into arrays and map
+    for (const [code, display] of data) {
+      const concept = new USStateConcept(code, display);
+      this.codes.push(concept);
+      this.codeMap.set(code, concept);
+    }
+  }
+
+  name() {
+    return 'US State Codes';
+  }
+
+  id() {
+    return "us-states";
+  }
+
+  iteratable() {
+    return true;
+  }
+}
+
+module.exports = {
+  USStateServices,
+  USStateFactoryProvider,
+  USStateConcept
+};

package/tx/dev.fhir.org.yml

@@ -0,0 +1,14 @@
+base:
+  url: https://storage.googleapis.com/tx-fhir-org
+
+sources:
+  - internal:lang
+  - internal:country
+  - internal:currency
+  - internal:areacode
+  - internal:mimetypes
+  - internal:usstates
+  - internal:hgvs
+  - ucum:tx/data/ucum-essence.xml
+  - npm:hl7.terminology
+  - npm:fhir.tx.support.r4

package/tx/fixtures/test-cases-setup.json

@@ -0,0 +1,18 @@
+{
+  "enabled": true,
+  "consoleErrors": false,
+  "host" : "local.host",
+  "librarySource": "tx/fixtures/test-cases.yml",
+  "endpoints": [
+    {
+      "path": "/r5",
+      "fhirVersion": "5.0",
+      "context": null
+    },
+    {
+      "path": "/r4",
+      "fhirVersion": "4.0",
+      "context": null
+    }
+  ]
+}

package/tx/fixtures/test-cases.yml

@@ -0,0 +1,16 @@
+base:
+  url: https://storage.googleapis.com/tx-fhir-org
+
+sources:
+  - internal:lang
+  - internal:country
+  - internal:currency
+  - internal:areacode
+  - internal:mimetypes
+  - internal:usstates
+  - ucum:tx/data/ucum-essence.xml
+  - loinc:loinc-2.81-b.db
+  - snomed!:sct_intl_20250201.cache
+  - snomed:sct_test_20250814.cache
+  - omop:omop_v20250227.db
+  - npm:hl7.terminology

package/tx/html/codesystem-operations.liquid

@@ -0,0 +1,25 @@
+<div class="operations" style="margin-top: 20px;">
+  <button type="button" class="btn btn-sm btn-outline-secondary" onclick="toggleOperations('{{ opsId }}')">Show Operations</button>
+  <div id="{{ opsId }}" style="display: none; margin-top: 10px;">
+
+    <div class="operation-form" style="margin-bottom: 15px;">
+      <strong>Lookup</strong>
+      <form method="get" action="$lookup" style="display: inline-block; margin-left: 10px;">
+        <input type="hidden" name="system" value="{{ url }}"/>
+        <input type="text" name="code" placeholder="Code" required size="20"/>
+        <button type="submit" class="btn btn-sm btn-primary">Lookup</button>
+      </form>
+    </div>
+
+    <div class="operation-form" style="margin-bottom: 15px;">
+      <strong>Subsumes</strong>
+      <form method="get" action="$subsumes" style="display: inline-block; margin-left: 10px;">
+        <input type="hidden" name="system" value="{{ url }}"/>
+        <input type="text" name="codeA" placeholder="Code A" required size="15"/>
+        <input type="text" name="codeB" placeholder="Code B" required size="15"/>
+        <button type="submit" class="btn btn-sm btn-primary">Subsumes</button>
+      </form>
+    </div>
+
+  </div>
+</div>

package/tx/html/home-metrics.liquid

@@ -0,0 +1,247 @@
+<div style="display: flex; gap: 20px; margin-bottom: 20px;">
+  <div style="flex: 1;">
+    <h6>Memory Usage (Heap Used)</h6>
+    <canvas id="memoryChart" height="200"></canvas>
+  </div>
+  <div style="flex: 1;">
+    <h6>Cache</h6>
+    <canvas id="cacheChart" height="200"></canvas>
+  </div>
+  <div style="flex: 1;">
+    <h6>Turnaround Time</h6>
+    <canvas id="tatChart" height="200"></canvas>
+  </div>
+</div>
+<div style="display: flex; gap: 20px; margin-bottom: 20px;">
+  <div style="flex: 1;">
+    <h6>Requests per Minute</h6>
+    <canvas id="requestChart" height="200"></canvas>
+  </div>
+  <div style="flex: 1;">
+    <h6>CPU Usage (%)</h6>
+    <canvas id="cpuChart" height="200"></canvas>
+  </div>
+  <div style="flex: 1;">
+    <h6>Node Blocking</h6>
+    <canvas id="blockChart" height="200"></canvas>
+  </div>
+</div>
+
+<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+<script>
+(function() {
+  const historyData = {{ historyJson }};
+  const startTime = {{ startTime }};
+
+  function formatTime(timestamp) {
+    const d = new Date(timestamp);
+    return d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+  }
+
+  function formatMB(bytes) {
+    return (bytes / 1024 / 1024).toFixed(1);
+  }
+
+  function formatDuration(ms) {
+    const hours = ms / 3600000;
+    if (hours < 1) {
+      return Math.round(ms / 60000) + 'm ago';
+    }
+    return hours.toFixed(1) + 'h ago';
+  }
+
+  const chartOptions = {
+    responsive: false,
+    maintainAspectRatio: false,
+    scales: {
+      x: {
+        ticks: {
+          maxTicksAuto: 6
+        }
+      },
+      y: {
+        beginAtZero: true
+      }
+    },
+    plugins: {
+      legend: {
+        display: false
+      }
+    }
+  };
+
+  // Memory chart
+  new Chart(document.getElementById('memoryChart'), {
+    type: 'line',
+    data: {
+      labels: historyData.map(d => formatTime(d.time)),
+      datasets: [{
+        data: historyData.map(d => parseFloat(formatMB(d.mem))),
+        borderColor: '#007bff',
+        backgroundColor: 'rgba(0, 123, 255, 0.1)',
+        fill: true,
+        tension: 0.3,
+        pointRadius: 2
+      }]
+    },
+    options: {
+      ...chartOptions,
+      scales: {
+        ...chartOptions.scales,
+        y: {
+          ...chartOptions.scales.y,
+          title: {
+            display: true,
+            text: 'MB (𝚫 from start)'
+          }
+        }
+      }
+    }
+  });
+
+  // Cache chart
+  new Chart(document.getElementById('cacheChart'), {
+    type: 'line',
+    data: {
+      labels: historyData.map(d => formatTime(d.time)),
+      datasets: [{
+        data: historyData.map(d => d.cache),
+        borderColor: '#7b7b7b',
+        backgroundColor: 'rgba(123, 123, 123, 0.1)',
+        fill: true,
+        tension: 0.3,
+        pointRadius: 2
+      }]
+    },
+    options: {
+      ...chartOptions,
+      scales: {
+        ...chartOptions.scales,
+        y: {
+          ...chartOptions.scales.y,
+          title: {
+            display: true,
+            text: '# cached items'
+          }
+        }
+      }
+    }
+  });
+
+
+  // Tat chart
+  new Chart(document.getElementById('tatChart'), {
+    type: 'line',
+    data: {
+      labels: historyData.map(d => formatTime(d.time)),
+      datasets: [{
+        data: historyData.map(d => d.tat),
+        borderColor: '#7b7b7b',
+        backgroundColor: 'rgba(123, 123, 123, 0.1)',
+        fill: true,
+        tension: 0.3,
+        pointRadius: 2
+      }]
+    },
+    options: {
+      ...chartOptions,
+      scales: {
+        ...chartOptions.scales,
+        y: {
+          ...chartOptions.scales.y,
+          title: {
+            display: true,
+            text: 'ms'
+          }
+        }
+      }
+    }
+  });
+
+  // CPU chart
+  new Chart(document.getElementById('cpuChart'), {
+    type: 'line',
+    data: {
+      labels: historyData.map(d => formatTime(d.time)),
+      datasets: [{
+        data: historyData.map(d => parseFloat(formatMB(d.cpu))),
+        borderColor: '#ff7b00',
+        backgroundColor: 'rgba(255, 123, 0, 0.1)',
+        fill: true,
+        tension: 0.3,
+        pointRadius: 2
+      }]
+    },
+    options: {
+      ...chartOptions,
+      scales: {
+        ...chartOptions.scales,
+        y: {
+          ...chartOptions.scales.y,
+          title: {
+            display: true,
+            text: '%'
+          }
+        }
+      }
+    }
+  });
+
+  // Requests chart
+  new Chart(document.getElementById('requestChart'), {
+    type: 'line',
+    data: {
+      labels: historyData.map(d => formatTime(d.time)),
+      datasets: [{
+        data: historyData.map(d => d.rpm.toFixed(2)),
+        borderColor: '#28a745',
+        backgroundColor: 'rgba(40, 167, 69, 0.1)',
+        fill: true,
+        tension: 0.3,
+        pointRadius: 2
+      }]
+    },
+    options: {
+      ...chartOptions,
+      scales: {
+        ...chartOptions.scales,
+        y: {
+          ...chartOptions.scales.y,
+          title: {
+            display: true,
+            text: 'req/min'
+          }
+        }
+      }
+    }
+  });
+  // Blocking chart
+  new Chart(document.getElementById('blockChart'), {
+    type: 'line',
+    data: {
+      labels: historyData.map(d => formatTime(d.time)),
+      datasets: [{
+        data: historyData.map(d => d.block),
+        borderColor: '#2845a7',
+        backgroundColor: 'rgba(40, 69, 167, 0.1)',
+        fill: true,
+        tension: 0.3,
+        pointRadius: 2
+      }]
+    },
+    options: {
+      ...chartOptions,
+      scales: {
+        ...chartOptions.scales,
+        y: {
+          ...chartOptions.scales.y,
+          title: {
+            display: true,
+            text: 'points'
+          }
+        }
+      }
+    }
+  });
+})();
+</script>