fhirsmith 0.5.2 → 0.5.3

package/tx/cs/cs-db.js

@@ -1,1308 +0,0 @@
-const sqlite3 = require('sqlite3').verbose();
-const assert = require('assert');
-const { CodeSystem } = require('../library/codesystem');
-const { Language, Languages} = require('../../library/languages');
-const { CodeSystemProvider, CodeSystemFactoryProvider} = require('./cs-api');
-const { validateOptionalParameter, validateArrayParameter} = require("../../library/utilities");
-
-class CachedDesignation {
-  constructor(display, language, use) {
-    this.display = display;
-    this.language = language;
-    this.use = use;
-  }
-}
-
-class CodeDBProviderContext {
-  constructor(key, code, display, definition, status) {
-    this.key = key;
-    this.code = code;
-    this.display = display;
-    this.definition = definition;
-    this.status = status;
-    this.designations = null; // Array of CachedDesignation
-    this.children = null; // Will be Set of keys if this has children
-  }
-
-  addChild(key) {
-    if (!this.children) {
-      this.children = new Set();
-    }
-    this.children.add(key);
-  }
-}
-
-
-class CodeDBIteratorContext {
-  constructor(context, keys) {
-    this.context = context;
-    this.keys = keys || [];
-    this.current = 0;
-    this.total = this.keys.length;
-  }
-
-  more() {
-    return this.current < this.total;
-  }
-
-  next() {
-    this.current++;
-  }
-}
-
-class CodeDBFilterHolder {
-  constructor() {
-    this.keys = [];
-    this.cursor = 0;
-    this.lsql = '';
-  }
-
-  hasKey(key) {
-    // Binary search since keys are sorted
-    let l = 0;
-    let r = this.keys.length - 1;
-    while (l <= r) {
-      const m = Math.floor((l + r) / 2);
-      if (this.keys[m] < key) {
-        l = m + 1;
-      } else if (this.keys[m] > key) {
-        r = m - 1;
-      } else {
-        return true;
-      }
-    }
-    return false;
-  }
-}
-
-class CodeDBPrep {
-  constructor() {
-    this.filters = [];
-  }
-}
-
-class CodeDBServices extends CodeSystemProvider {
-  constructor(opContext, supplements, db, sharedData) {
-    super(opContext, supplements);
-    this.db = db;
-
-    // Shared data from factory
-    this.langs = sharedData.langs;
-    this.codes = sharedData.codes;
-    this.codeList = sharedData.codeList;
-    this.codeSystem = sharedData.codeSystem;
-    this.root = sharedData.root;
-    this.firstCodeKey = sharedData.firstCodeKey;
-    this.relationships = sharedData.relationships;
-    this.propertyList = sharedData.propertyList;
-    this.statusKeys = sharedData.statusKeys;
-    this.statusCodes = sharedData.statusCodes;
-  }
-
-  close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-
-  // Metadata methods
-  system() {
-    return this.codeSystem.url;
-  }
-
-  version() {
-    return this.codeSystem.version;
-  }
-
-  name() {
-    return this.codeSystem.name;
-  }
-
-  description() {
-    return this.codeSystem.description;
-  }
-
-  async totalCount() {
-    return this.codes.size;
-  }
-
-  hasParents() {
-    return this.codeSystem.hierarchical;
-  }
-
-  hasAnyDisplays(languages) {
-    const langs = this._ensureLanguages(languages);
-
-    // Check supplements first
-    if (this._hasAnySupplementDisplays(langs)) {
-      return true;
-    }
-
-    // Check if any requested languages are available in code system data
-    for (const requestedLang of langs.languages) {
-      for (const [codeDBLangCode] of this.langs) {
-        const codeDBLang = new Language(codeDBLangCode);
-        if (codeDBLang.matchesForDisplay(requestedLang)) {
-          return true;
-        }
-      }
-    }
-
-    return super.hasAnyDisplays(langs);
-  }
-
-  // Core concept methods
-  async code(context) {
-    
-    const ctxt = await this.#ensureContext(context);
-    return ctxt ? ctxt.code : null;
-  }
-
-  async display(context) {
-    
-    const ctxt = await this.#ensureContext(context);
-    if (!ctxt) {
-      return null;
-    }
-
-    // Check supplements first
-    let disp = this._displayFromSupplements(ctxt.code);
-    if (disp) {
-      return disp;
-    }
-
-    // Use language-aware display logic
-    if (this.opContext.langs && !this.opContext.langs.isEnglishOrNothing()) {
-      await this.#loadDesignationsForContext(ctxt);
-
-      // Try to find exact language match
-      for (const lang of this.opContext.langs.langs) {
-        for (const display of ctxt.designations) {
-          if (lang.matches(display.language, true)) {
-            return display.value;
-          }
-        }
-      }
-
-      // Try partial language match
-      for (const lang of this.opContext.langs.langs) {
-        for (const display of ctxt.designations) {
-          if (lang.matches(display.language, false)) {
-            return display.value;
-          }
-        }
-      }
-    }
-
-    return ctxt.display || '';
-  }
-
-  async definition(context) {
-    const ctxt = await this.#ensureContext(context);
-    return ctxt.definition;
-  }
-
-  async isAbstract(context) {
-    const ctxt = await this.#ensureContext(context);
-    return ctxt.abstract;
-  }
-
-  async isInactive(context) {
-    const ctxt = await this.#ensureContext(context);
-    return ctxt.status == 'inactive';
-  }
-
-  async getStatus(context) {
-    const ctxt = await this.#ensureContext(context);
-    return ctxt.status;
-  }
-
-  async isDeprecated(context) {
-    const ctxt = await this.#ensureContext(context);
-    return ctxt.status == 'deprecated';
-  }
-
-  async designations(context, displays) {
-    const ctxt = await this.#ensureContext(context);
-    if (ctxt) {
-      await this.#loadDesignationsForContext(ctxt);
-      ctxt.designations
-      // Add main display
-      displays.addDesignation(true, 'active', this.codeSystem.language, CodeSystem.makeUseForDisplay(), ctxt.desc.trim());
-
-      // Add cached designations
-      if (ctxt.displays.length === 0) {
-        await this.#loadDesignationsForContext(ctxt);
-      }
-
-      for (const entry of ctxt.designations) {
-        let use = undefined;
-        if (entry.type) {
-          use = {
-            system: this.codeSystem.url,
-            code: entry.type
-          }
-        }
-        if (!use) {
-          use = entry.display ? CodeSystem.makeUseForDisplay() : null;
-        }
-        displays.addDesignation(false, 'active', entry.lang, use, entry.value.trim());
-      }
-
-      // Add supplement designations
-      this._listSupplementDesignations(ctxt.code, displays);
-    }
-
-  }
-
-  async extendLookup(ctxt, props, params) {
-    validateArrayParameter(props, 'props', String);
-    validateArrayParameter(params, 'params', Object);
-
-
-    if (typeof ctxt === 'string') {
-      const located = await this.locate(ctxt);
-      if (!located.context) {
-        throw new Error(located.message);
-      }
-      ctxt = located.context;
-    }
-
-    if (!(ctxt instanceof CodeDBProviderContext)) {
-      throw new Error('Invalid context for CodeDB lookup');
-    }
-
-    await this.#addConceptProperties(ctxt, params);
-    await this.#addStatusProperty(ctxt, params);
-  }
-
-  async #addConceptProperties(ctxt, params) {
-    return new Promise((resolve, reject) => {
-      const sql = `
-          SELECT PropertyTypes.Description, PropertyValues.Value
-          FROM Properties, PropertyTypes, PropertyValues
-          WHERE Properties.CodeKey = ?
-            AND Properties.PropertyTypeKey = PropertyTypes.PropertyTypeKey
-            AND Properties.PropertyValueKey = PropertyValues.PropertyValueKey
-      `;
-
-      this.db.all(sql, [ctxt.key], (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          for (const row of rows) {
-            this.#addStringProperty(params, 'property', row.Description, row.Value);
-          }
-          resolve();
-        }
-      });
-    });
-  }
-
-  async #addStatusProperty(ctxt, params) {
-    if (ctxt.status) {
-      this.#addStringProperty(params, 'property', 'STATUS', ctxt.status);
-    }
-  }
-
-  #addProperty(params, type, name, value, language = null) {
-
-    const property = {
-      name: type,
-      part: [
-        { name: 'code', valueCode: name },
-        { name: 'value', valueString: value }
-      ]
-    };
-
-    if (language) {
-      property.part.push({ name: 'language', valueCode: language });
-    }
-
-    params.push(property);
-  }
-
-  #addCodeProperty(params, type, name, value, language = null) {
-
-    const property = {
-      name: type,
-      part: [
-        { name: 'code', valueCode: name },
-        { name: 'value', valueCode: value }
-      ]
-    };
-
-    if (language) {
-      property.part.push({ name: 'language', valueCode: language });
-    }
-
-    params.push(property);
-  }
-
-  #addStringProperty(params, type, name, value, language = null) {
-
-    const property = {
-      name: type,
-      part: [
-        { name: 'code', valueCode: name },
-        { name: 'value', valueString: value }
-      ]
-    };
-
-    if (language) {
-      property.part.push({ name: 'language', valueCode: language });
-    }
-
-    params.push(property);
-  }
-
-  #addSupplementDisplays(displays, code) {
-    if (this.supplements) {
-      for (const supplement of this.supplements) {
-        const concept = supplement.getConceptByCode(code);
-        if (concept) {
-          if (concept.display) {
-            displays.push(new LoincDisplay(supplement.jsonObj.language || 'en', concept.display));
-          }
-          if (concept.designation) {
-            for (const designation of concept.designation) {
-              const lang = designation.language || supplement.jsonObj.language || 'en';
-              displays.push(new LoincDisplay(lang, designation.value));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  async #loadDesignationsForContext(ctxt) {
-    if (!ctxt.designations) {
-      ctxt.designations = [];
-      return new Promise((resolve, reject) => {
-        const sql = `
-            SELECT Languages.Code as Lang, DescriptionTypes.Description as DType, Descriptions.Value
-            FROM Descriptions,
-                 Languages,
-                 DescriptionTypes
-            WHERE Descriptions.CodeKey = ?
-              AND Descriptions.DescriptionTypeKey != 4
-            AND Descriptions.DescriptionTypeKey = DescriptionTypes.DescriptionTypeKey
-            AND Descriptions.LanguageKey = Languages.LanguageKey
-        `;
-
-        this.db.all(sql, [ctxt.key], (err, rows) => {
-          if (err) {
-            reject(err);
-          } else {
-            for (const row of rows) {
-              const isDisplay = row.DType === 'LONG_COMMON_NAME';
-              ctxt.designations.push(new CachedDesignation(row.Value, , row.Lang, row.DType));
-            }
-            resolve();
-          }
-        });
-      });
-    }
-  }
-
-  async #ensureContext(context) {
-    if (!context) {
-      return null;
-    }
-    if (typeof context === 'string') {
-      const ctxt = await this.locate(context);
-      if (!ctxt.context) {
-        throw new Error(ctxt.message);
-      } else {
-        return ctxt.context;
-      }
-    }
-    if (context instanceof CodeDBProviderContext) {
-      return context;
-    }
-    throw new Error("Unknown Type at #ensureContext: " + (typeof context));
-  }
-
-  // Lookup methods
-  async locate(code) {
-    
-    assert(!code || typeof code === 'string', 'code must be string');
-    if (!code) return { context: null, message: 'Empty code' };
-
-    const context = this.codes.get(code);
-    if (context) {
-      return { context: context, message: null };
-    }
-
-    return { context: null, message: undefined };
-  }
-
-  // Iterator methods
-  async iterator(context) {
-    
-
-    if (!context) {
-      // Iterate all codes starting from first code
-      const keys = Array.from({ length: this.codeList.length - this.firstCodeKey }, (_, i) => i + this.firstCodeKey);
-      return new LoincIteratorContext(null, keys);
-    } else {
-      const ctxt = await this.#ensureContext(context);
-      if (ctxt.kind === LoincProviderContextKind.PART && ctxt.children) {
-        return new LoincIteratorContext(ctxt, Array.from(ctxt.children));
-      } else {
-        return new LoincIteratorContext(ctxt, []);
-      }
-    }
-  }
-
-  async nextContext(iteratorContext) {
-    
-
-    if (!iteratorContext.more()) {
-      return null;
-    }
-
-    const key = iteratorContext.keys[iteratorContext.current];
-    iteratorContext.next();
-
-    return this.codeList[key];
-  }
-
-  // Filter support
-  async doesFilter(prop, op, value) {
-    // Relationship filters
-    if (this.relationships.has(prop) && ['=', 'in', 'exists', 'regex'].includes(op)) {
-      return true;
-    }
-
-    // Property filters
-    if (this.propertyList.has(prop) && ['=', 'in', 'exists', 'regex'].includes(op)) {
-      return true;
-    }
-
-    // Status filter
-    if (prop === 'STATUS' && op === '=' && this.statusKeys.has(value)) {
-      return true;
-    }
-
-    // LIST filter
-    if (prop === 'LIST' && op === '=' && this.codes.has(value)) {
-      return true;
-    }
-
-    // CLASSSTYPE filter
-    if (prop === 'CLASSTYPE' && op === '=' && ["1", "2", "3", "4"].includes(value)) {
-      return true;
-    }
-
-    // answers-for filter
-    if (prop === 'answers-for' && op === '=') {
-      return true;
-    }
-
-    // concept filters
-    if (prop === 'concept' && ['is-a', 'descendent-of', '=', 'in', 'not-in'].includes(op)) {
-      return true;
-    }
-
-    // code filters (VSAC workaround)
-    if (prop === 'code' && ['is-a', 'descendent-of', '='].includes(op)) {
-      return true;
-    }
-
-    // copyright filter
-    if (prop === 'copyright' && op === '=' && ['LOINC', '3rdParty'].includes(value)) {
-      return true;
-    }
-
-    return false;
-  }
-
-  async getPrepContext(iterate) {
-    return new LoincPrep(iterate);
-  }
-
-  async filter(filterContext, prop, op, value) {
-    
-
-    const filter = new LoincFilterHolder();
-    await this.#executeFilterQuery(prop, op, value, filter);
-    filterContext.filters.push(filter);
-  }
-
-  async #executeFilterQuery(prop, op, value, filter) {
-    let sql = '';
-    let lsql = '';
-
-    // LIST filter
-    if (prop === 'LIST' && op === '=' && this.codes.has(value)) {
-      sql = `SELECT TargetKey as Key FROM Relationships
-           WHERE RelationshipTypeKey = ${this.relationships.get('Answer')} 
-           AND SourceKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-           ORDER BY SourceKey ASC`;
-      lsql = `SELECT COUNT(TargetKey) FROM Relationships
-            WHERE RelationshipTypeKey = ${this.relationships.get('Answer')} 
-            AND SourceKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-            AND TargetKey = `;
-    }
-    // answers-for filter
-    else if (prop === 'answers-for' && op === '=') {
-      if (value.startsWith('LL')) {
-        sql = `SELECT TargetKey as Key FROM Relationships 
-             WHERE RelationshipTypeKey = ${this.relationships.get('Answer')} 
-             AND SourceKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}') 
-             ORDER BY SourceKey ASC`;
-        lsql = `SELECT COUNT(TargetKey) FROM Relationships 
-              WHERE RelationshipTypeKey = ${this.relationships.get('Answer')} 
-              AND SourceKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}') 
-              AND TargetKey = `;
-      } else {
-        sql = `SELECT TargetKey as Key FROM Relationships
-             WHERE RelationshipTypeKey = ${this.relationships.get('Answer')}
-             AND SourceKey IN (
-               SELECT SourceKey FROM Relationships
-               WHERE RelationshipTypeKey = ${this.relationships.get('answers-for')}
-               AND TargetKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-             )
-             ORDER BY SourceKey ASC`;
-        lsql = `SELECT COUNT(TargetKey) FROM Relationships 
-              WHERE RelationshipTypeKey = ${this.relationships.get('Answer')} 
-              AND SourceKey IN (SELECT SourceKey FROM Relationships 
-                WHERE RelationshipTypeKey = ${this.relationships.get('answers-for')} 
-                AND TargetKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')) 
-              AND TargetKey = `;
-      }
-    }
-    // Relationship equal filter
-    else if (this.relationships.has(prop) && op === '=') {
-      if (this.codes.has(value)) {
-        sql = `SELECT SourceKey as Key FROM Relationships
-             WHERE RelationshipTypeKey = ${this.relationships.get(prop)}
-             AND TargetKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-             ORDER BY SourceKey ASC`;
-        lsql = `SELECT COUNT(SourceKey) FROM Relationships 
-              WHERE RelationshipTypeKey = ${this.relationships.get(prop)} 
-              AND TargetKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}') 
-              AND SourceKey = `;
-      } else {
-        sql = `SELECT SourceKey as Key FROM Relationships
-             WHERE RelationshipTypeKey = ${this.relationships.get(prop)}
-             AND TargetKey IN (SELECT CodeKey FROM Codes WHERE Description = '${this.#sqlWrapString(value)}' COLLATE NOCASE)
-             ORDER BY SourceKey ASC`;
-        lsql = `SELECT COUNT(SourceKey) FROM Relationships 
-              WHERE RelationshipTypeKey = ${this.relationships.get(prop)} 
-              AND TargetKey IN (SELECT CodeKey FROM Codes WHERE Description = '${this.#sqlWrapString(value)}' COLLATE NOCASE) 
-              AND SourceKey = `;
-      }
-    }
-    // Relationship 'in' filter
-    else if (this.relationships.has(prop) && op === 'in') {
-      const codes = this.#commaListOfCodes(value);
-      sql = `SELECT SourceKey as Key FROM Relationships
-           WHERE RelationshipTypeKey = ${this.relationships.get(prop)}
-           AND TargetKey IN (SELECT CodeKey FROM Codes WHERE Code IN (${codes}))
-           ORDER BY SourceKey ASC`;
-      lsql = `SELECT COUNT(SourceKey) FROM Relationships 
-            WHERE RelationshipTypeKey = ${this.relationships.get(prop)} 
-            AND TargetKey IN (SELECT CodeKey FROM Codes WHERE Code IN (${codes})) 
-            AND SourceKey = `;
-    }
-    // Relationship 'exists' filter
-    else if (this.relationships.has(prop) && op === 'exists') {
-      if (this.codes.has(value)) {
-        sql = `SELECT SourceKey as Key FROM Relationships
-             WHERE RelationshipTypeKey = ${this.relationships.get(prop)}
-             AND EXISTS (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-             ORDER BY SourceKey ASC`;
-        lsql = `SELECT COUNT(SourceKey) FROM Relationships 
-              WHERE RelationshipTypeKey = ${this.relationships.get(prop)} 
-              AND EXISTS (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}') 
-              AND SourceKey = `;
-      } else {
-        sql = `SELECT SourceKey as Key FROM Relationships
-             WHERE RelationshipTypeKey = ${this.relationships.get(prop)}
-             AND EXISTS (SELECT CodeKey FROM Codes WHERE Description = '${this.#sqlWrapString(value)}' COLLATE NOCASE)
-             ORDER BY SourceKey ASC`;
-        lsql = `SELECT COUNT(SourceKey) FROM Relationships 
-              WHERE RelationshipTypeKey = ${this.relationships.get(prop)} 
-              AND EXISTS (SELECT CodeKey FROM Codes WHERE Description = '${this.#sqlWrapString(value)}' COLLATE NOCASE) 
-              AND SourceKey = `;
-      }
-    }
-    // Relationship regex filter
-    else if (this.relationships.has(prop) && op === 'regex') {
-      const matchingKeys = await this.#findRegexMatches(
-        `SELECT CodeKey as Key, Description FROM Codes 
-       WHERE CodeKey IN (SELECT TargetKey FROM Relationships WHERE RelationshipTypeKey = ${this.relationships.get(prop)})`,
-        value,
-        'Description'
-      );
-      if (matchingKeys.length > 0) {
-        sql = `SELECT SourceKey as Key FROM Relationships
-             WHERE RelationshipTypeKey = ${this.relationships.get(prop)}
-             AND TargetKey IN (${matchingKeys.join(',')})
-             ORDER BY SourceKey ASC`;
-        lsql = `SELECT COUNT(SourceKey) FROM Relationships 
-              WHERE RelationshipTypeKey = ${this.relationships.get(prop)} 
-              AND TargetKey IN (${matchingKeys.join(',')}) 
-              AND SourceKey = `;
-      }
-    }
-    // Property equal filter (with CLASSTYPE handling)
-    else if (this.propertyList.has(prop) && op === '=') {
-      let actualValue = value;
-      if (prop === 'CLASSTYPE' && ['1', '2', '3', '4'].includes(value)) {
-        const classTypes = {
-          '1': 'Laboratory class',
-          '2': 'Clinical class',
-          '3': 'Claims attachments',
-          '4': 'Surveys'
-        };
-        actualValue = classTypes[value];
-      }
-      sql = `SELECT CodeKey as Key FROM Properties, PropertyValues
-           WHERE Properties.PropertyTypeKey = ${this.propertyList.get(prop)}
-           AND Properties.PropertyValueKey = PropertyValues.PropertyValueKey
-           AND PropertyValues.Value = '${this.#sqlWrapString(actualValue)}' COLLATE NOCASE
-           ORDER BY CodeKey ASC`;
-      lsql = `SELECT COUNT(CodeKey) FROM Properties, PropertyValues 
-            WHERE Properties.PropertyTypeKey = ${this.propertyList.get(prop)} 
-            AND Properties.PropertyValueKey = PropertyValues.PropertyValueKey 
-            AND PropertyValues.Value = '${this.#sqlWrapString(actualValue)}' COLLATE NOCASE 
-            AND CodeKey = `;
-    }
-    // Property 'in' filter
-    else if (this.propertyList.has(prop) && op === 'in') {
-      const codes = this.#commaListOfCodes(value);
-      sql = `SELECT CodeKey as Key FROM Properties, PropertyValues
-           WHERE Properties.PropertyTypeKey = ${this.propertyList.get(prop)}
-           AND Properties.PropertyValueKey = PropertyValues.PropertyValueKey
-           AND PropertyValues.Value IN (${codes}) COLLATE NOCASE
-           ORDER BY CodeKey ASC`;
-      lsql = `SELECT COUNT(CodeKey) FROM Properties, PropertyValues 
-            WHERE Properties.PropertyTypeKey = ${this.propertyList.get(prop)} 
-            AND Properties.PropertyValueKey = PropertyValues.PropertyValueKey 
-            AND PropertyValues.Value IN (${codes}) COLLATE NOCASE 
-            AND CodeKey = `;
-    }
-    // Property 'exists' filter
-    else if (this.propertyList.has(prop) && op === 'exists') {
-      sql = `SELECT DISTINCT CodeKey as Key FROM Properties
-           WHERE Properties.PropertyTypeKey = ${this.propertyList.get(prop)}
-           ORDER BY CodeKey ASC`;
-      lsql = `SELECT COUNT(CodeKey) FROM Properties 
-            WHERE Properties.PropertyTypeKey = ${this.propertyList.get(prop)} 
-            AND CodeKey = `;
-    }
-    // Property regex filter
-    else if (this.propertyList.has(prop) && op === 'regex') {
-      const matchingKeys = await this.#findRegexMatches(
-        `SELECT PropertyValueKey, Value FROM PropertyValues 
-       WHERE PropertyValueKey IN (SELECT PropertyValueKey FROM Properties WHERE PropertyTypeKey = ${this.propertyList.get(prop)})`,
-        value,
-        'Value',
-        'PropertyValueKey'
-      );
-      if (matchingKeys.length > 0) {
-        sql = `SELECT CodeKey as Key FROM Properties
-             WHERE PropertyTypeKey = ${this.propertyList.get(prop)}
-             AND PropertyValueKey IN (${matchingKeys.join(',')})
-             ORDER BY CodeKey ASC`;
-        lsql = `SELECT COUNT(CodeKey) FROM Properties 
-              WHERE PropertyTypeKey = ${this.propertyList.get(prop)} 
-              AND PropertyValueKey IN (${matchingKeys.join(',')}) 
-              AND CodeKey = `;
-      }
-    }
-    // Status filter
-    else if (prop === 'STATUS' && op === '=' && this.statusKeys.has(value)) {
-      sql = `SELECT CodeKey as Key FROM Codes
-           WHERE StatusKey = ${this.statusKeys.get(value)}
-           ORDER BY CodeKey ASC`;
-      lsql = `SELECT COUNT(CodeKey) FROM Codes 
-            WHERE StatusKey = ${this.statusKeys.get(value)} 
-            AND CodeKey = `;
-    }
-    // Concept hierarchy filters (is-a, descendent-of)
-    else if (prop === 'concept' && ['is-a', 'descendent-of'].includes(op)) {
-      sql = `SELECT DescendentKey as Key FROM Closure
-           WHERE AncestorKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-           ORDER BY DescendentKey ASC`;
-      lsql = `SELECT COUNT(DescendentKey) FROM Closure 
-            WHERE AncestorKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}') 
-            AND DescendentKey = `;
-    }
-    // Concept equal filter (workaround for VSAC misuse)
-    else if (prop === 'concept' && op === '=') {
-      sql = `SELECT CodeKey as Key FROM Codes
-           WHERE Code = '${this.#sqlWrapString(value)}'
-           ORDER BY CodeKey ASC`;
-      lsql = `SELECT COUNT(CodeKey) FROM Codes 
-            WHERE Code = '${this.#sqlWrapString(value)}' 
-            AND CodeKey = `;
-    }
-    // Concept 'in' filter (workaround for VSAC misuse)
-    else if (prop === 'concept' && op === 'in') {
-      const codes = this.#commaListOfCodes(value);
-      sql = `SELECT CodeKey as Key FROM Codes
-           WHERE Code IN (${codes})
-           ORDER BY CodeKey ASC`;
-      lsql = `SELECT COUNT(CodeKey) FROM Codes 
-            WHERE Code IN (${codes}) 
-            AND CodeKey = `;
-    }
-    // Code property filters (workaround for VSAC misuse)
-    else if (prop === 'code' && ['is-a', 'descendent-of'].includes(op)) {
-      sql = `SELECT DescendentKey as Key FROM Closure
-           WHERE AncestorKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-           ORDER BY DescendentKey ASC`;
-      lsql = `SELECT COUNT(DescendentKey) FROM Closure 
-            WHERE AncestorKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}') 
-            AND DescendentKey = `;
-    }
-    else if (prop === 'code' && op === '=') {
-      sql = `SELECT CodeKey as Key FROM Codes
-           WHERE Code = '${this.#sqlWrapString(value)}'
-           ORDER BY CodeKey ASC`;
-      lsql = `SELECT COUNT(CodeKey) FROM Codes 
-            WHERE Code = '${this.#sqlWrapString(value)}' 
-            AND CodeKey = `;
-    }
-    // Copyright filters
-    else if (prop === 'copyright' && op === '=') {
-      if (value === 'LOINC') {
-        sql = `SELECT CodeKey as Key FROM Codes
-             WHERE NOT CodeKey IN (SELECT CodeKey FROM Properties WHERE PropertyTypeKey = 9)
-             ORDER BY CodeKey ASC`;
-        lsql = `SELECT COUNT(CodeKey) FROM Codes 
-              WHERE NOT CodeKey IN (SELECT CodeKey FROM Properties WHERE PropertyTypeKey = 9) 
-              AND CodeKey = `;
-      } else if (value === '3rdParty') {
-        sql = `SELECT CodeKey as Key FROM Codes
-             WHERE CodeKey IN (SELECT CodeKey FROM Properties WHERE PropertyTypeKey = 9)
-             ORDER BY CodeKey ASC`;
-        lsql = `SELECT COUNT(CodeKey) FROM Codes 
-              WHERE CodeKey IN (SELECT CodeKey FROM Properties WHERE PropertyTypeKey = 9) 
-              AND CodeKey = `;
-      }
-    }
-
-    if (sql) {
-      await this.#executeSQL(sql, filter);
-      filter.lsql = lsql;
-    } else {
-      throw new Error(`The filter "${prop} ${op} ${value}" is not supported for LOINC`);
-    }
-  }
-
-// Helper method for regex matching
-  async #findRegexMatches(sql, pattern, valueColumn, keyColumn = 'Key') {
-    return new Promise((resolve, reject) => {
-      const regex = new RegExp(pattern);
-      const matchingKeys = [];
-
-      this.db.all(sql, (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          for (const row of rows) {
-            if (regex.test(row[valueColumn])) {
-              matchingKeys.push(row[keyColumn]);
-            }
-          }
-          resolve(matchingKeys);
-        }
-      });
-    });
-  }
-
-// Helper method for comma-separated code lists
-  #commaListOfCodes(source) {
-    const codes = source.split(',')
-      .filter(s => this.codes.has(s.trim()))
-      .map(s => `'${this.#sqlWrapString(s.trim())}'`);
-    return codes.join(',');
-  }
-
-  async #executeSQL(sql, filter) {
-    return new Promise((resolve, reject) => {
-      this.db.all(sql, (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          filter.keys = rows.map(row => row.Key).filter(key => key !== 0);
-          resolve();
-        }
-      });
-    });
-  }
-
-  #sqlWrapString(str) {
-    return str.replace(/'/g, "''");
-  }
-
-  async executeFilters(filterContext) {
-    
-    return filterContext.filters;
-  }
-
-  async filterSize(filterContext, set) {
-    
-    return set.keys.length;
-  }
-
-  async filterMore(filterContext, set) {
-    
-    set.cursor = set.cursor || 0;
-    return set.cursor < set.keys.length;
-  }
-
-  async filterConcept(filterContext, set) {
-    
-
-    if (set.cursor >= set.keys.length) {
-      return null;
-    }
-
-    const key = set.keys[set.cursor];
-    set.cursor++;
-
-    return this.codeList[key];
-  }
-
-  async filterLocate(filterContext, set, code) {
-    const context = this.codes.get(code);
-    if (!context) {
-      return `Not a valid code: ${code}`;
-    }
-
-    if (!set.lsql) {
-      return 'Filter not understood';
-    }
-
-    // Check if this context's key is in the filter
-    if (set.hasKey(context.key)) {
-      return context;
-    } else {
-      return null; // `Code ${code} is not in the specified filter`;
-    }
-  }
-
-  async filterCheck(filterContext, set, concept) {
-    if (!(concept instanceof LoincProviderContext)) {
-      return false;
-    }
-
-    return set.hasKey(concept.key);
-  }
-
-  // Search filter - placeholder for text search
-  // eslint-disable-next-line no-unused-vars
-  async searchFilter(filterContext, filter, sort) {
-    
-    throw new Error('Text search not implemented yet');
-  }
-
-  // Subsumption testing
-  async subsumesTest(codeA, codeB) {
-    await this.#ensureContext(codeA);
-    await this.#ensureContext(codeB);
-
-    return 'not-subsumed'; // Not implemented yet
-  }
-
-  versionAlgorithm() {
-    return 'natural';
-  }
-
-  isDisplay(designation) {
-    return designation.use.code == "SHORTNAME" || designation.use.code == "LONG_COMMON_NAME" || designation.use.code == "LinguisticVariantDisplayName";
-  }
-}
-
-class LoincServicesFactory extends CodeSystemFactoryProvider {
-  constructor(i18n, dbPath) {
-    super(i18n);
-    this.dbPath = dbPath;
-    this.uses = 0;
-    this._loaded = false;
-    this._sharedData = null;
-  }
-
-  system() {
-    return 'http://loinc.org';
-  }
-
-  version() {
-    return this._sharedData._version;
-  }
-
-  name() {
-    return 'LOINC';
-  }
-
-  async #ensureLoaded() {
-    if (!this._loaded) {
-      await this.load();
-    }
-  }
-
-  async load() {
-    const db = new sqlite3.Database(this.dbPath);
-
-    // Enable performance optimizations
-    await this.#optimizeDatabase(db);
-
-    try {
-      this._sharedData = {
-        langs: new Map(),
-        codes: new Map(),
-        codeList: [null],
-        relationships: new Map(),
-        propertyList: new Map(),
-        statusKeys: new Map(),
-        statusCodes: new Map(),
-        _version: '',
-        root: '',
-        firstCodeKey: 0
-      };
-
-      // Load small lookup tables in parallel
-      // eslint-disable-next-line no-unused-vars
-      const [langs, statusCodes, relationships, propertyList, config] = await Promise.all([
-        this.#loadLanguages(db),
-        this.#loadStatusCodes(db),
-        this.#loadRelationshipTypes(db),
-        this.#loadPropertyTypes(db),
-        this.#loadConfig(db)
-      ]);
-
-      // Load codes (largest operation)
-      await this.#loadCodes(db);
-
-      // Load dependent data in parallel
-      await Promise.all([
-        // this.#loadDesignationsCache(db),
-        this.#loadHierarchy(db)
-      ]);
-
-    } finally {
-      db.close();
-    }
-    this._loaded = true;
-  }
-
-  async #optimizeDatabase(db) {
-    return new Promise((resolve) => {
-      db.serialize(() => {
-        db.run('PRAGMA journal_mode = WAL');
-        db.run('PRAGMA synchronous = NORMAL');
-        db.run('PRAGMA cache_size = 10000');
-        db.run('PRAGMA temp_store = MEMORY');
-        db.run('PRAGMA mmap_size = 268435456'); // 256MB
-        resolve();
-      });
-    });
-  }
-
-  async #loadLanguages(db) {
-    return new Promise((resolve, reject) => {
-      db.all('SELECT LanguageKey, Code FROM Languages', (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          for (const row of rows) {
-            this._sharedData.langs.set(row.Code, row.LanguageKey);
-          }
-          resolve();
-        }
-      });
-    });
-  }
-
-  async #loadStatusCodes(db) {
-    return new Promise((resolve, reject) => {
-      db.all('SELECT StatusKey, Description FROM StatusCodes', (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          for (const row of rows) {
-            this._sharedData.statusKeys.set(row.Description, row.StatusKey.toString());
-            this._sharedData.statusCodes.set(row.StatusKey.toString(), row.Description);
-          }
-          resolve();
-        }
-      });
-    });
-  }
-
-  async #loadRelationshipTypes(db) {
-    return new Promise((resolve, reject) => {
-      db.all('SELECT RelationshipTypeKey, Description FROM RelationshipTypes', (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          for (const row of rows) {
-            this._sharedData.relationships.set(row.Description, row.RelationshipTypeKey.toString());
-          }
-          resolve();
-        }
-      });
-    });
-  }
-
-  async #loadPropertyTypes(db) {
-    return new Promise((resolve, reject) => {
-      db.all('SELECT PropertyTypeKey, Description FROM PropertyTypes', (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          for (const row of rows) {
-            this._sharedData.propertyList.set(row.Description, row.PropertyTypeKey.toString());
-          }
-          resolve();
-        }
-      });
-    });
-  }
-
-  async #loadCodes(db) {
-    return new Promise((resolve, reject) => {
-      // First get the count to pre-allocate array
-      db.get('SELECT MAX(CodeKey) as maxKey FROM Codes', (err, row) => {
-        if (err) return reject(err);
-
-        // Pre-allocate the array to avoid repeated resizing
-        const maxKey = row.maxKey || 0;
-        this._sharedData.codeList = new Array(maxKey + 1).fill(null);
-
-        // Now load all codes
-        db.all('SELECT CodeKey, Code, Type, Codes.Description, StatusCodes.Description as Status FROM Codes, StatusCodes where StatusCodes.StatusKey = Codes.StatusKey order by CodeKey Asc', (err, rows) => {
-          if (err) return reject(err);
-
-          // Batch process rows
-          for (const row of rows) {
-            const context = new LoincProviderContext(
-              row.CodeKey,
-              row.Type - 1,
-              row.Code,
-              row.Description,
-              row.Status
-            );
-
-            this._sharedData.codes.set(row.Code, context);
-            this._sharedData.codeList[row.CodeKey] = context;
-
-            if (this._sharedData.firstCodeKey === 0 && context.kind === LoincProviderContextKind.CODE) {
-              this._sharedData.firstCodeKey = context.key;
-            }
-          }
-          resolve();
-        });
-      });
-    });
-  }
-
-  async #loadDesignationsCache(db) {
-    return new Promise((resolve, reject) => {
-      const sql = `
-          SELECT
-              d.CodeKey,
-              l.Code as Lang,
-              dt.Description as DType,
-              d.Value,
-              dt.Description = 'LONG_COMMON_NAME' as IsDisplay
-          FROM Descriptions d
-                   JOIN Languages l ON d.LanguageKey = l.LanguageKey
-                   JOIN DescriptionTypes dt ON d.DescriptionTypeKey = dt.DescriptionTypeKey
-          WHERE d.DescriptionTypeKey != 4
-          ORDER BY d.CodeKey
-      `;
-
-      db.all(sql, (err, rows) => {
-        if (err) return reject(err);
-
-        // Batch process by CodeKey to reduce lookups
-        let currentKey = null;
-        let currentContext = null;
-
-        for (const row of rows) {
-          if (row.CodeKey !== currentKey) {
-            currentKey = row.CodeKey;
-            currentContext = this._sharedData.codeList[currentKey];
-          }
-
-          if (currentContext) {
-            currentContext.displays.push(
-              new DescriptionCacheEntry(row.IsDisplay, row.Lang, row.Value, row.DType)
-            );
-          }
-        }
-        resolve();
-      });
-    });
-  }
-
-  async #loadHierarchy(db) {
-    const childRelKey = this._sharedData.relationships.get('child');
-    if (!childRelKey) {
-      return; // No child relationships defined
-    }
-
-    return new Promise((resolve, reject) => {
-      const sql = `
-          SELECT SourceKey, TargetKey FROM Relationships
-          WHERE RelationshipTypeKey = ${childRelKey}
-      `;
-
-      db.all(sql, (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          for (const row of rows) {
-            if (row.SourceKey !== 0 && row.TargetKey !== 0) {
-              const parentContext = this._sharedData.codeList[row.SourceKey];
-              if (parentContext) {
-                parentContext.addChild(row.TargetKey);
-              }
-            }
-          }
-          resolve();
-        }
-      });
-    });
-  }
-
-  async #loadConfig(db) {
-    return new Promise((resolve, reject) => {
-      db.all('SELECT ConfigKey, Value FROM Config WHERE ConfigKey IN (2, 3)', (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          for (const row of rows) {
-            if (row.ConfigKey === 2) {
-              this._sharedData._version = row.Value;
-            } else if (row.ConfigKey === 3) {
-              this._sharedData.root = row.Value;
-            }
-          }
-          resolve();
-        }
-      });
-    });
-  }
-
-  defaultVersion() {
-    return this._sharedData?._version || 'unknown';
-  }
-
-  async build(opContext, supplements) {
-    await this.#ensureLoaded();
-    this.recordUse();
-
-    // Create fresh database connection for this provider instance
-    const db = new sqlite3.Database(this.dbPath);
-
-    return new LoincServices(opContext, supplements, db, this._sharedData);
-  }
-
-  useCount() {
-    return this.uses;
-  }
-
-  recordUse() {
-    this.uses++;
-  }
-
-  async buildKnownValueSet(url, version) {
-
-    if (version && version != this.version()) {
-      return null;
-    }
-    if (!url.startsWith('http://loinc.org/vs')) {
-      return null;
-    }
-    if (url == 'http://loinc.org/vs') {
-      // All LOINC codes
-      return {
-        resourceType: 'ValueSet', url: 'http://loinc.org/vs', version: this.version(), status: 'active',
-        name: 'LOINC Value Set - all LOINC codes', description: 'All LOINC codes',
-        date: new Date().toISOString(), experimental: false,
-        compose: { include: [{ system: this.system() }] }
-      };
-    }
-
-    if (url.startsWith('http://loinc.org/vs/')) {
-      const code = url.substring(20);
-      const ci = this._sharedData.codes.get(code);
-      if (!ci) {
-        return null;
-      }
-
-      if (ci.kind === LoincProviderContextKind.PART) {
-        // Part-based value set with ancestor filter
-        return {
-          resourceType: 'ValueSet',  url: url, version: this.version(), status: 'active',
-          name: 'LOINCValueSetFor' + ci.code.replace(/-/g, '_'), description: 'LOINC value set for code ' + ci.code + ': ' + ci.desc,
-          date: new Date().toISOString(),  experimental: false,
-          compose: { include: [{ system: this.system(), filter: [{ property: 'ancestor', op: '=', value: code }] }]
-          }
-        };
-      }
-
-      if (ci.kind === LoincProviderContextKind.LIST) {
-        // Answer list - enumerate concepts from database
-        const concepts = await this.#getAnswerListConcepts(ci.key);
-        return {
-          resourceType: 'ValueSet', url: url, version: this.version(), status: 'active',
-          name: 'LOINCAnswerList' + ci.code.replace(/-/g, '_'),  description: 'LOINC Answer list for code ' + ci.code + ': ' + ci.desc,
-          date: new Date().toISOString(), experimental: false,
-          compose: { include: [{ system: this.system(), concept: concepts }] }
-        };
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Get answer list concepts from database
-   * @param {number} sourceKey - Key of the answer list
-   * @returns {Promise<Array>} Array of {code, display} objects
-   */
-  async #getAnswerListConcepts(sourceKey) {
-    return new Promise((resolve, reject) => {
-      let db = new sqlite3.Database(this.dbPath);
-      const sql = `
-      SELECT Code, Description 
-      FROM Relationships, Codes 
-      WHERE SourceKey = ? 
-        AND RelationshipTypeKey = 40 
-        AND Relationships.TargetKey = Codes.CodeKey
-    `;
-
-      db.all(sql, [sourceKey], (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          const concepts = rows.map(row => ({
-            code: row.Code
-          }));
-          resolve(concepts);
-        }
-      });
-    });
-  }
-
-  id() {
-    return "loinc"+this.version();
-  }
-}
-
-module.exports = {
-  LoincServices,
-  LoincServicesFactory,
-  LoincProviderContext,
-  LoincProviderContextKind
-};