fhirsmith 0.3.0

package/tx/cs/cs-unii.js

@@ -0,0 +1,271 @@
+const sqlite3 = require('sqlite3').verbose();
+const assert = require('assert');
+const { CodeSystem } = require('../library/codesystem');
+const { CodeSystemProvider, CodeSystemFactoryProvider} = require('./cs-api');
+
+class UniiConcept {
+  constructor(code, display) {
+    this.code = code;
+    this.display = display;
+    this.others = []; // Array of other descriptions from UniiDesc table
+  }
+}
+
+class UniiServices extends CodeSystemProvider {
+  constructor(opContext, supplements, db, version) {
+    super(opContext, supplements);
+    this.db = db;
+    this._version = version;
+  }
+
+  // Clean up database connection when provider is destroyed
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+
+  // Metadata methods
+  system() {
+    return 'http://fdasis.nlm.nih.gov'; // UNII system URI
+  }
+
+  version() {
+    return this._version;
+  }
+
+  description() {
+    return 'UNII Codes';
+  }
+
+  name() {
+    return 'UNII Codes';
+  }
+
+  totalCount() {
+    return -1; // Database-driven, use count query if needed
+  }
+
+  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) {
+      // Add main display
+      if (ctxt.display) {
+        displays.addDesignation(true, 'active', 'en', CodeSystem.makeUseForDisplay(), ctxt.display.trim());
+      }
+      // Add other descriptions
+      ctxt.others.forEach(other => {
+        if (other && other.trim()) {
+          displays.addDesignation(false, 'active', 'en', CodeSystem.makeUseForDisplay(), other.trim());
+        }
+      });
+      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);
+      } else {
+        return ctxt.context;
+      }
+    }
+    if (code instanceof UniiConcept) {
+      return code;
+    }
+    throw new Error("Unknown Type at #ensureContext: " + (typeof code));
+  }
+
+  // Database helper methods
+  async #getVersion() {
+    return new Promise((resolve, reject) => {
+      this.db.get('SELECT Version FROM UniiVersion', (err, row) => {
+        if (err) reject(err);
+        else resolve(row ? row.Version : 'unknown');
+      });
+    });
+  }
+
+  async #getTotalCount() {
+    return new Promise((resolve, reject) => {
+      this.db.get('SELECT COUNT(*) as count FROM Unii', (err, row) => {
+        if (err) reject(err);
+        else resolve(row.count);
+      });
+    });
+  }
+
+  // Lookup methods
+  async locate(code) {
+    
+    assert(!code || typeof code === 'string', 'code must be string');
+    if (!code) return { context: null, message: 'Empty code' };
+
+    return new Promise((resolve, reject) => {
+      // First query: get main concept
+      this.db.get('SELECT UniiKey, Display FROM Unii WHERE Code = ?', [code], (err, row) => {
+        if (err) {
+          return reject(err);
+        }
+
+        if (!row) {
+          return resolve({ context: null, message: `UNII Code '${code}' not found` });
+        }
+
+        const concept = new UniiConcept(code, row.Display);
+        const uniiKey = row.UniiKey;
+
+        // Second query: get all descriptions
+        this.db.all('SELECT Display FROM UniiDesc WHERE UniiKey = ?', [uniiKey], (err, rows) => {
+          if (err) return reject(err);
+
+          // Add unique descriptions to others array
+          rows.forEach(descRow => {
+            const desc = descRow.Display;
+            if (desc && desc.trim() && !concept.others.includes(desc.trim())) {
+              concept.others.push(desc.trim());
+            }
+          });
+
+          resolve({ context: concept, message: undefined });
+        });
+      });
+    });
+  }
+
+  versionAlgorithm() {
+    return 'date';
+  }
+}
+
+class UniiServicesFactory extends CodeSystemFactoryProvider {
+  constructor(i18n, dbPath) {
+    super(i18n);
+    this.dbPath = dbPath;
+    this.uses = 0;
+    this._version = null;
+  }
+
+  async load() {
+    let db = new sqlite3.Database(this.dbPath);
+
+    return new Promise((resolve, reject) => {
+      db.get('SELECT Version FROM UniiVersion', (err, row) => {
+        if (err) {
+          reject(new Error(err));
+        } else {
+          this._version = row ? row.Version : 'unknown';
+          resolve(); // This resolves the Promise
+        }
+      });
+    });
+  }
+
+  defaultVersion() {
+    return 'unknown';
+  }
+
+  system() {
+    return 'http://fdasis.nlm.nih.gov'; // UNII system URI
+  }
+
+  version() {
+    return this._version;
+  }
+
+  build(opContext, supplements) {
+    this.uses++;
+
+    return new UniiServices(opContext, supplements, new sqlite3.Database(this.dbPath), this._version);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async buildKnownValueSet(url, version) {
+    return null;
+  }
+
+  useCount() {
+    return this.uses;
+  }
+
+  recordUse() {
+    this.uses++;
+  }
+  name() {
+    return 'UNII Codes';
+  }
+
+  id() {
+    return "unii";
+  }
+
+}
+
+module.exports = {
+  UniiServices,
+  UniiServicesFactory,
+  UniiConcept
+};

package/tx/cs/cs-uri.js

@@ -0,0 +1,218 @@
+const { CodeSystemProvider, CodeSystemFactoryProvider} = require('./cs-api');
+const assert = require('assert');
+
+/**
+ * Code system provider for URIs
+ * This is a simple provider that treats any URI as a valid code
+ * Uses strings directly as context since URIs have no additional metadata
+ * Enhanced to support supplements for display and definition lookup
+ */
+class UriServices extends CodeSystemProvider {
+  constructor(opContext, supplements) {
+    super(opContext, supplements);
+  }
+
+  // ============================================================================
+  // Metadata for the code system
+  // ============================================================================
+
+  system() {
+    return 'urn:ietf:rfc:3986'; // URI_URIs constant equivalent
+  }
+
+  version() {
+    return 'n/a';
+  }
+
+  description() {
+    return 'URIs';
+  }
+
+  totalCount() {
+    return -1; // Infinite/unknown count
+  }
+
+  name() {
+    return 'Internal URI services';
+  }
+
+  defLang() {
+    return 'en';
+  }
+
+  hasAnyDisplays(languages) {
+    const langs = this._ensureLanguages(languages);
+    if (this._hasAnySupplementDisplays(langs)) {
+      return true;
+    } else {
+      return false; // URIs don't have displays by default
+    }
+  }
+
+  hasParents() {
+    return false; // URIs don't have hierarchy
+  }
+
+  // ============================================================================
+  // Getting Information about concepts
+  // ============================================================================
+
+  async code(code) {
+    
+    await this.#ensureContext(code);
+    return code; // For URIs, the code is the context
+  }
+
+  async display(code) {
+    
+    const ctxt = await this.#ensureContext(code);
+    return this._displayFromSupplements(ctxt);
+  }
+
+  async definition(code) {
+    
+    await this.#ensureContext(code);
+    return null; // URIs don't have definitions by default
+  }
+
+  async isAbstract(code) {
+    
+    await this.#ensureContext(code);
+    return false; // URIs are not abstract
+  }
+
+  async isInactive(code) {
+    
+    await this.#ensureContext(code);
+    return false; // URIs are not inactive
+  }
+
+  async isDeprecated(code) {
+    
+    await this.#ensureContext(code);
+    return false; // URIs are not deprecated
+  }
+
+  async designations(code, displays) {
+    
+    const ctxt = await this.#ensureContext(code);
+    if (ctxt != null) {
+      this._listSupplementDesignations(ctxt, displays);
+    }
+  }
+
+  async properties(code) {
+    
+    const ctxt = await this.#ensureContext(code);
+    // Collect properties from all supplements
+    let allProperties = [];
+
+    if (this.supplements) {
+      for (const supplement of this.supplements) {
+        const concept = supplement.getConceptByCode(ctxt);  // ← Uses CodeSystem API
+        if (concept && concept.property) {
+          // Add all properties from this concept
+          allProperties = allProperties.concat(concept.property);
+        }
+      }
+    }
+
+    return allProperties;
+  }
+
+  async sameConcept(a, b) {
+    
+    await this.#ensureContext(a);
+    await this.#ensureContext(b);
+    return a === b; // For URIs, direct string comparison
+  }
+
+
+  async #ensureContext(code) {
+    if (!code || typeof code === 'string') {
+      return code;
+    }
+    throw new Error("Unknown Type at #ensureContext: "+ (typeof code));
+  }
+
+  // ============================================================================
+  // Finding concepts
+  // ============================================================================
+
+  async locate(code) {
+    
+    assert(!code || typeof code === 'string', 'code must be string');
+    if (!code) return { context: null, message: 'Empty code' };
+
+    // For URIs, any string is potentially valid
+    // But we can check if it exists in supplements for better validation
+    // but it doesn't make any difference...
+
+    return {
+      context: code, // Use the string directly as context
+      message: null
+    };
+  }
+
+  versionAlgorithm() {
+    return null;
+  }
+
+  isNotClosed() {
+    return true;
+  }
+
+  // ============================================================================
+  // Filtering (not supported for URIs)
+  // ============================================================================
+
+  // nothing to declare
+
+  // ============================================================================
+  // Translations and concept maps
+  // ============================================================================
+}
+
+/**
+ * Factory for creating URI code system providers
+ */
+class UriServicesFactory extends CodeSystemFactoryProvider {
+  constructor(i18n) {
+    super(i18n);
+  }
+
+  defaultVersion() {
+    return 'n/a';
+  }
+
+  system() {
+    return 'urn:ietf:rfc:3986'; // URI_URIs constant equivalent
+  }
+
+  version() {
+    return 'n/a';
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async buildKnownValueSet(url, version) {
+    return null;
+  }
+
+  async build(opContext, supplements) {
+    this.recordUse();
+    return new UriServices(opContext, supplements);
+  }
+  name() {
+    return 'URI services';
+  }
+
+
+  id() {
+    return "urls";
+  }
+}
+
+module.exports = {
+  UriServices,
+  UriServicesFactory
+};