fhirsmith 0.18.2 → 1.0.0

package/tx/closure/closure-store.js

@@ -26,6 +26,18 @@
 // here reads or writes an unbounded amount in one go: reads that can be large are paged
 // (entriesPage), and the size of what one call can write is capped by the worker.
 //
+// Shared (server.cluster.sharedClosure, cluster.md "Options"): several processes open this
+// file and any of them may answer $closure. The per-table lock is still taken, but it only
+// orders the calls within one process, so correctness across processes comes from the
+// writes themselves. A call computes against the table as it read it (its id and version),
+// and writes in one BEGIN IMMEDIATE transaction that first checks the table is still at
+// that id and version (recordAddChecked); if it isn't, nothing is written and the worker
+// computes again from what is there now. Creating a table checks for an existing one and
+// for the table limit in the same transaction as the insert (createTableChecked). A resync
+// reads only up to the version it reports (entriesPage's upTo), so a write by another
+// process between its pages can't put entries of a later version in it. Without shared,
+// none of these paths is taken.
+//
 
 const path = require('path');
 const fs = require('fs');
@@ -40,10 +52,13 @@ class ClosureStore {
   /**
    * @param {Object} config - modules.tx.closure
    * @param {Object} [log]
+   * @param {Object} [options]
+   * @param {boolean} [options.shared] - other processes use the file too (see above)
    */
-  constructor(config, log) {
+  constructor(config, log, options = {}) {
     this.config = config || {};
     this.log = log || console;
+    this.shared = !!options.shared;
     this.db = null;
     this.path = ClosureStore.resolvePath(this.config);
     this.locks = new Map(); // table name -> { tail: Promise, count: holder + waiters }
@@ -69,8 +84,22 @@ class ClosureStore {
       fs.mkdirSync(path.dirname(this.path), {recursive: true});
     }
     this.db = new Database(this.path);
+    if (this.shared) {
+      // first: switching to WAL and creating the tables need locks another process may hold
+      this.db.pragma('busy_timeout = 5000');
+    }
     this.db.pragma('journal_mode = WAL');
     this.db.pragma('foreign_keys = ON');
+    if (this.shared) {
+      // one process at a time creates the tables and brings an old database up to date
+      this.db.transaction(() => this.#createSchema()).immediate();
+    } else {
+      this.#createSchema();
+    }
+    this.#prepare();
+  }
+
+  #createSchema() {
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS closure_table (
         id        INTEGER PRIMARY KEY,
@@ -118,6 +147,25 @@ class ClosureStore {
           entry_count = (SELECT count(*) FROM closure_entry e WHERE e.table_id = closure_table.id);
       `);
     }
+    if (this.shared) {
+      // An INTEGER PRIMARY KEY can be reused after a reset/dispose. Shared calls keep
+      // the id across awaits, including in their retry memo and paged reads, so it
+      // must identify one incarnation forever. A durable counter also upgrades old
+      // databases without rebuilding the table and its foreign keys. This runs in
+      // the schema's IMMEDIATE transaction, before any shared writer can allocate.
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS closure_table_sequence (
+          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+          last_id INTEGER NOT NULL
+        );
+        INSERT OR IGNORE INTO closure_table_sequence VALUES (1, 0);
+        UPDATE closure_table_sequence SET last_id = max(last_id,
+          (SELECT coalesce(max(id), 0) FROM closure_table)) WHERE singleton = 1;
+      `);
+    }
+  }
+
+  #prepare() {
     this.stmt = {
       getTable: this.db.prepare('SELECT id, name, version, created, last_used FROM closure_table WHERE name = ?'),
       countTables: this.db.prepare('SELECT count(*) AS n FROM closure_table'),
@@ -156,6 +204,24 @@ class ClosureStore {
          WHERE e.table_id = ? AND e.added_version > ?`),
       staleTables: this.db.prepare('SELECT id, name FROM closure_table WHERE last_used < ?')
     };
+    if (this.shared) {
+      Object.assign(this.stmt, {
+        nextTableId: this.db.prepare('UPDATE closure_table_sequence SET last_id = last_id + 1 WHERE singleton = 1 RETURNING last_id AS id'),
+        insertSharedTable: this.db.prepare('INSERT INTO closure_table (id, name, version, created, last_used) VALUES (?, ?, 0, ?, ?)'),
+        entriesPageUpTo: this.db.prepare(`
+          SELECT e.rowid AS rowid,
+                 s.system AS source_system, s.code AS source_code, s.display AS source_display,
+                 t.system AS target_system, t.code AS target_code, t.display AS target_display,
+                 e.relationship
+            FROM closure_entry e
+            JOIN closure_concept s ON s.id = e.source_id
+            JOIN closure_concept t ON t.id = e.target_id
+           WHERE e.table_id = ? AND e.added_version > ? AND e.added_version <= ? AND e.rowid > ?
+           ORDER BY e.rowid
+           LIMIT ?`),
+        deleteStale: this.db.prepare('DELETE FROM closure_table WHERE id = ? AND last_used < ?')
+      });
+    }
   }
 
   close() {
@@ -260,7 +326,11 @@ class ClosureStore {
    * written. Page through with the last row's rowid as afterRowid (start with 0).
    * @returns {Array<{rowid, source_system, source_code, source_display, target_system, target_code, target_display, relationship}>}
    */
-  entriesPage(tableId, version, afterRowid, limit) {
+  entriesPage(tableId, version, afterRowid, limit, upTo) {
+    if (upTo !== undefined) {
+      // shared: only up to the version the caller read (see the header)
+      return this.stmt.entriesPageUpTo.all(tableId, version, upTo, afterRowid, limit);
+    }
     return this.stmt.entriesPage.all(tableId, version, afterRowid, limit);
   }
 
@@ -278,7 +348,9 @@ class ClosureStore {
       if (existing) {
         this.stmt.deleteTable.run(existing.id);
       }
-      const info = this.stmt.insertTable.run(name, now, now);
+      const info = this.shared
+        ? this.stmt.insertSharedTable.run(this.stmt.nextTableId.get().id, name, now, now)
+        : this.stmt.insertTable.run(name, now, now);
       const id = info.lastInsertRowid;
       params.forEach((p, i) => this.stmt.insertParam.run(id, i, p.name, JSON.stringify(p)));
       return this.stmt.getTable.get(name);
@@ -353,6 +425,50 @@ class ClosureStore {
     return version;
   }
 
+  /**
+   * Shared: create (or, with reset, replace) a table, checking in the same write
+   * transaction that there isn't one already (unless reset) and that the table limit
+   * isn't reached - so two processes creating at once can't both succeed, or go over it.
+   * @param {string} name
+   * @param {Array<Object>} params - as for createTable
+   * @param {Object} opts
+   * @param {boolean} opts.reset - replace a table of that name
+   * @param {number} opts.maxTables - Infinity for none
+   * @returns {{table: Object}|{refused: 'exists'|'limit'}}
+   */
+  createTableChecked(name, params, { reset, maxTables }) {
+    return this.db.transaction(() => {
+      const existing = this.stmt.getTable.get(name);
+      if (existing && !reset) {
+        return { refused: 'exists' };
+      }
+      if (!existing && this.stmt.countTables.get().n >= maxTables) {
+        return { refused: 'limit' };
+      }
+      return { table: this.createTable(name, params) };
+    }).immediate();
+  }
+
+  /**
+   * Shared: recordAdd, if the table is still the one the caller computed against - the
+   * same id (not reset or dropped since) and the same version (nothing added since). The
+   * check and the write are one BEGIN IMMEDIATE transaction, so no other process can
+   * write in between.
+   * @returns {number|null} the version after the add, or null if the table has changed
+   *   (nothing was written)
+   */
+  recordAddChecked(table, concepts, entries) {
+    // Even a duplicate-only add must check: a reset may have removed those concepts
+    // while this request was working, or an intervening add changed their version.
+    return this.db.transaction(() => {
+      const now = this.stmt.getTable.get(table.name);
+      if (!now || now.id !== table.id || now.version !== table.version) {
+        return null;
+      }
+      return this.recordAdd(table, concepts, entries);
+    }).immediate();
+  }
+
   /**
    * Every entry added after the given version.
    * @returns {Array<{source_system, source_code, source_display, target_system, target_code, target_display, relationship}>}
@@ -395,6 +511,13 @@ class ClosureStore {
     const dropped = [];
     for (const t of stale) {
       await this.withLock(t.name, async () => {
+        if (this.shared) {
+          // another process may use the table between a read and a delete: one statement
+          if (this.db && this.stmt.deleteStale.run(t.id, cutoff).changes > 0) {
+            dropped.push(t.name);
+          }
+          return;
+        }
         const now = this.db ? this.stmt.getTable.get(t.name) : null;
         if (now && now.id === t.id && now.last_used < cutoff) {
           this.stmt.deleteTable.run(t.id);

package/tx/cm/cm-database.js

@@ -2,6 +2,7 @@ const fs = require('fs').promises;
 const sqlite3 = require('sqlite3').verbose();
 const { VersionUtilities } = require('../../library/version-utilities');
 const { ConceptMap } = require('../library/conceptmap');
+const { guarded } = require('../library/sqlite-utilities');
 // Key of the row written once the cache has been fully populated (see isComplete)
 const CACHE_COMPLETE_KEY = 'cache-complete';
 
@@ -41,7 +42,7 @@ class ConceptMapDatabase {
    */
   async create() {
     return new Promise((resolve, reject) => {
-      const db = new sqlite3.Database(this.dbPath, (err) => {
+      const db = new sqlite3.Database(this.dbPath, guarded(reject, (err) => {
         if (err) {
           reject(new Error(`Failed to create database: ${err.message}`));
           return;
@@ -132,7 +133,7 @@ class ConceptMapDatabase {
             }
           });
         });
-      });
+      }));
     });
   }
 
@@ -144,16 +145,16 @@ class ConceptMapDatabase {
    * @returns {Promise<boolean>}
    */
   async isComplete() {
-    return new Promise((resolve) => {
-      const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, (err) => {
+    return new Promise((resolve, reject) => {
+      const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, guarded(reject, (err) => {
         if (err) {
           resolve(false);
           return;
         }
-        db.get('SELECT value FROM cache_status WHERE key = ?', [CACHE_COMPLETE_KEY], (err, row) => {
+        db.get('SELECT value FROM cache_status WHERE key = ?', [CACHE_COMPLETE_KEY], guarded(reject, (err, row) => {
           db.close(() => resolve(!err && row != null));
-        });
-      });
+        }));
+      }));
     });
   }
 
@@ -164,7 +165,7 @@ class ConceptMapDatabase {
    */
   async markComplete() {
     return new Promise((resolve, reject) => {
-      const db = new sqlite3.Database(this.dbPath, (err) => {
+      const db = new sqlite3.Database(this.dbPath, guarded(reject, (err) => {
         if (err) {
           reject(new Error(`Failed to open database: ${err.message}`));
           return;
@@ -173,17 +174,17 @@ class ConceptMapDatabase {
           db.run('CREATE TABLE IF NOT EXISTS cache_status (key TEXT PRIMARY KEY, value TEXT)');
           db.run(`INSERT INTO cache_status (key, value) VALUES (?, ?)
                     ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
-            [CACHE_COMPLETE_KEY, new Date().toISOString()], (err) => {
-              db.close((closeErr) => {
+            [CACHE_COMPLETE_KEY, new Date().toISOString()], guarded(reject, (err) => {
+              db.close(guarded(reject, (closeErr) => {
                 if (err || closeErr) {
                   reject(new Error(`Failed to mark cache complete: ${(err || closeErr).message}`));
                 } else {
                   resolve();
                 }
-              });
-            });
+              }));
+            }));
         });
-      });
+      }));
     });
   }
 
@@ -198,28 +199,28 @@ class ConceptMapDatabase {
     }
 
     return new Promise((resolve, reject) => {
-      const db = new sqlite3.Database(this.dbPath, (err) => {
+      const db = new sqlite3.Database(this.dbPath, guarded(reject, (err) => {
         if (err) {
           reject(new Error(`Failed to open database: ${err.message}`));
           return;
         }
 
         // Step 1: Delete existing related records
-        db.run('DELETE FROM conceptmap_identifiers WHERE conceptmap_id = ?', [conceptMap.id], (err) => {
+        db.run('DELETE FROM conceptmap_identifiers WHERE conceptmap_id = ?', [conceptMap.id], guarded(reject, (err) => {
           if (err) {
             db.close();
             reject(new Error(`Failed to delete identifiers: ${err.message}`));
             return;
           }
 
-          db.run('DELETE FROM conceptmap_jurisdictions WHERE conceptmap_id = ?', [conceptMap.id], (err) => {
+          db.run('DELETE FROM conceptmap_jurisdictions WHERE conceptmap_id = ?', [conceptMap.id], guarded(reject, (err) => {
             if (err) {
               db.close();
               reject(new Error(`Failed to delete jurisdictions: ${err.message}`));
               return;
             }
 
-            db.run('DELETE FROM conceptmap_systems WHERE conceptmap_id = ?', [conceptMap.id], (err) => {
+            db.run('DELETE FROM conceptmap_systems WHERE conceptmap_id = ?', [conceptMap.id], guarded(reject, (err) => {
               if (err) {
                 db.close();
                 reject(new Error(`Failed to delete systems: ${err.message}`));
@@ -250,7 +251,7 @@ class ConceptMapDatabase {
                 conceptMap.status || null,
                 conceptMap.title || null,
                 JSON.stringify(conceptMap)
-              ], (err) => {
+              ], guarded(reject, (err) => {
                 if (err) {
                   db.close();
                   reject(new Error(`Failed to insert main record: ${err.message}`));
@@ -259,11 +260,11 @@ class ConceptMapDatabase {
 
                 // Step 3: Insert related records
                 this._insertRelatedRecords(db, conceptMap, resolve, reject);
-              });
-            });
-          });
-        });
-      });
+              }));
+            }));
+          }));
+        }));
+      }));
     });
   }
 
@@ -393,13 +394,13 @@ class ConceptMapDatabase {
    */
   async loadAllConceptMaps() {
     return new Promise((resolve, reject) => {
-      const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, (err) => {
+      const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, guarded(reject, (err) => {
         if (err) {
           reject(new Error(`Failed to open database for loading: ${err.message}`));
           return;
         }
 
-        db.all('SELECT id, url, version, content FROM conceptmaps', [], (err, rows) => {
+        db.all('SELECT id, url, version, content FROM conceptmaps', [], guarded(reject, (err, rows) => {
           if (err) {
             db.close();
             reject(new Error(`Failed to load concept maps: ${err.message}`));
@@ -457,8 +458,8 @@ class ConceptMapDatabase {
             db.close();
             reject(new Error(`Failed to parse concept map content: ${error.message}`));
           }
-        });
-      });
+        }));
+      }));
     });
   }
 
@@ -473,13 +474,18 @@ class ConceptMapDatabase {
     const canOptimize = elements && elements.length > 0 &&
       elements.every(e => INDEXED_COLUMNS.includes(e));
 
-    // Always include 'id' in the columns to select when optimizing
-    const columnsToSelect = canOptimize
+    // Always include 'id' in the columns to select when optimizing (and the version, when the
+    // results are matched on it - see versionSearchMatches)
+    const versionAsked = searchParams.filter(p => p.name.toLowerCase() === 'version').map(p => p.value);
+    let columnsToSelect = canOptimize
       ? (elements.includes('id') ? elements : ['id', ...elements])
       : null;
+    if (columnsToSelect && versionAsked.length > 0 && !columnsToSelect.includes('version')) {
+      columnsToSelect = [...columnsToSelect, 'version'];
+    }
 
     return new Promise((resolve, reject) => {
-      const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, (err) => {
+      const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, guarded(reject, (err) => {
         if (err) {
           reject(new Error(`Failed to open database for search: ${err.message}`));
           return;
@@ -487,7 +493,7 @@ class ConceptMapDatabase {
 
         const { query, params } = this._buildSearchQuery(searchParams, columnsToSelect);
 
-        db.all(query, params, (err, rows) => {
+        db.all(query, params, guarded(reject, (err, rows) => {
           if (err) {
             db.close();
             reject(new Error(`Search query failed: ${err.message}`));
@@ -522,6 +528,9 @@ class ConceptMapDatabase {
                 return parsed;
               });
             }
+            for (const criteria of versionAsked) {
+              results = results.filter(r => VersionUtilities.versionSearchMatches(criteria, r.version, VersionUtilities.versionAlgorithmOf(r)));
+            }
 
             db.close((err) => {
               if (err) {
@@ -534,8 +543,8 @@ class ConceptMapDatabase {
             db.close();
             reject(new Error(`Failed to parse search results: ${error.message}`));
           }
-        });
-      });
+        }));
+      }));
     });
   }
 
@@ -546,14 +555,14 @@ class ConceptMapDatabase {
    */
   async deleteOldConceptMaps(cutoffTimestamp) {
     return new Promise((resolve, reject) => {
-      const db = new sqlite3.Database(this.dbPath, (err) => {
+      const db = new sqlite3.Database(this.dbPath, guarded(reject, (err) => {
         if (err) {
           reject(new Error(`Failed to open database for cleanup: ${err.message}`));
           return;
         }
 
         // Get URLs to delete first
-        db.all('SELECT url FROM conceptmaps WHERE last_seen < ?', [cutoffTimestamp], (err, rows) => {
+        db.all('SELECT url FROM conceptmaps WHERE last_seen < ?', [cutoffTimestamp], guarded(reject, (err, rows) => {
           if (err) {
             db.close();
             reject(new Error(`Failed to find old records: ${err.message}`));
@@ -575,7 +584,7 @@ class ConceptMapDatabase {
             pendingDeletes--;
             if (pendingDeletes === 0 && !hasError) {
               // Finally delete main records
-              db.run('DELETE FROM conceptmaps WHERE last_seen < ?', [cutoffTimestamp], function(err) {
+              db.run('DELETE FROM conceptmaps WHERE last_seen < ?', [cutoffTimestamp], guarded(reject, function(err) {
                 if (err) {
                   db.close();
                   reject(new Error(`Failed to delete old records: ${err.message}`));
@@ -584,7 +593,7 @@ class ConceptMapDatabase {
                   db.close();
                   resolve(deletedCount);
                 }
-              });
+              }));
             }
           };
 
@@ -601,22 +610,22 @@ class ConceptMapDatabase {
 
           pendingDeletes = 3; // identifiers, jurisdictions, systems
 
-          db.run(`DELETE FROM conceptmap_identifiers WHERE conceptmap_id IN (${placeholders})`, idsToDelete, (err) => {
+          db.run(`DELETE FROM conceptmap_identifiers WHERE conceptmap_id IN (${placeholders})`, idsToDelete, guarded(reject, (err) => {
             if (err) deleteError(new Error(`Failed to delete identifier records: ${err.message}`));
             else deleteComplete();
-          });
+          }));
 
-          db.run(`DELETE FROM conceptmap_jurisdictions WHERE conceptmap_id IN (${placeholders})`, idsToDelete, (err) => {
+          db.run(`DELETE FROM conceptmap_jurisdictions WHERE conceptmap_id IN (${placeholders})`, idsToDelete, guarded(reject, (err) => {
             if (err) deleteError(new Error(`Failed to delete jurisdiction records: ${err.message}`));
             else deleteComplete();
-          });
+          }));
 
-          db.run(`DELETE FROM conceptmap_systems WHERE conceptmap_id IN (${placeholders})`, idsToDelete, (err) => {
+          db.run(`DELETE FROM conceptmap_systems WHERE conceptmap_id IN (${placeholders})`, idsToDelete, guarded(reject, (err) => {
             if (err) deleteError(new Error(`Failed to delete system records: ${err.message}`));
             else deleteComplete();
-          });
-        });
-      });
+          }));
+        }));
+      }));
     });
   }
 
@@ -626,7 +635,7 @@ class ConceptMapDatabase {
    */
   async getStatistics() {
     return new Promise((resolve, reject) => {
-      const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, (err) => {
+      const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, guarded(reject, (err) => {
         if (err) {
           reject(new Error(`Failed to open database for statistics: ${err.message}`));
           return;
@@ -650,7 +659,7 @@ class ConceptMapDatabase {
         };
 
         // Total count
-        db.get(queries[0], [], (err, row) => {
+        db.get(queries[0], [], guarded(reject, (err, row) => {
           if (err) {
             db.close();
             reject(err);
@@ -658,10 +667,10 @@ class ConceptMapDatabase {
           }
           results.totalConceptMaps = row.total;
           checkComplete();
-        });
+        }));
 
         // Status breakdown
-        db.all(queries[1], [], (err, rows) => {
+        db.all(queries[1], [], guarded(reject, (err, rows) => {
           if (err) {
             db.close();
             reject(err);
@@ -672,10 +681,10 @@ class ConceptMapDatabase {
             results.byStatus[row.status || 'null'] = row.count;
           }
           checkComplete();
-        });
+        }));
 
         // System count
-        db.get(queries[2], [], (err, row) => {
+        db.get(queries[2], [], guarded(reject, (err, row) => {
           if (err) {
             db.close();
             reject(err);
@@ -683,8 +692,8 @@ class ConceptMapDatabase {
           }
           results.totalSystems = row.systems;
           checkComplete();
-        });
-      });
+        }));
+      }));
     });
   }
 
@@ -705,13 +714,16 @@ class ConceptMapDatabase {
 
       switch (name.toLowerCase()) {
         case 'url':
-          conditions.push('v.url LIKE ?');
-          params.push(`%${value}%`);
+          // a left match (case-sensitive): the url starts with the value
+          conditions.push('substr(v.url, 1, length(?)) = ?');
+          params.push(value, value);
           break;
 
         case 'version':
-          conditions.push('v.version LIKE ?');
-          params.push(`%${value}%`);
+          // version-aware matching (see VersionUtilities.versionSearchMatches): narrowed here to
+          // the versions that could match, and matched on the results (see search)
+          conditions.push("v.version LIKE ? ESCAPE '\\'");
+          params.push(VersionUtilities.versionSearchPrefix(value).replace(/[\\%_]/g, c => '\\' + c) + '%');
           break;
 
         case 'name':

package/tx/cm/cm-package.js

@@ -9,6 +9,7 @@ const {validateParameter} = require("../../library/utilities");
 const {ConceptMap} = require("../library/conceptmap");
 const { applyIdPrefix, stripIdPrefix } = require('../library/resource-ids');
 const { keepForPinnedReference } = require('../library/tho-precedence');
+const { waitForCache } = require('../library/wait-for-cache');
 
 /**
  * Package-based ConceptMap provider using shared database layer
@@ -18,14 +19,19 @@ class PackageConceptMapProvider extends AbstractConceptMapProvider {
 
   /**
    * @param {PackageContentLoader} packageLoader - Path to the extracted package folder
+   * @param {Object} [options]
+   * @param {boolean} [options.readOnly] - a tx-worker (cluster.md): the cache is the master's; it
+   *   is only read (ConceptMapDatabase reads with OPEN_READONLY), waited for until the master has
+   *   finished it, and never built or changed
    */
-  constructor(packageLoader) {
+  constructor(packageLoader, options = {}) {
     super();
     validateParameter(packageLoader, "packageLoader", PackageContentLoader);
     this.packageLoader = packageLoader;
     // -2: caches from before concept maps were checked for active content in their
     // narrative are rebuilt (see initialize)
     this.dbPath = path.join(packageLoader.packageFolder, '.conceptmaps-2.db');
+    this.readOnly = !!options.readOnly;
     this.database = new ConceptMapDatabase(this.dbPath);
     this.conceptMapMap = new Map();
     this.initialized = false;
@@ -41,6 +47,14 @@ class PackageConceptMapProvider extends AbstractConceptMapProvider {
       return;
     }
     await this.packageLoader.initialize();
+    if (this.readOnly) {
+      await waitForCache(async () => (await this.database.exists()) && (await this.database.isComplete()),
+        `Package ${this.packageLoader.pid ? this.packageLoader.pid() : ''}: concept map cache ${this.dbPath}`);
+      this.conceptMapMap = await this.database.loadAllConceptMaps();
+      this.#applyIdPrefix();
+      this.initialized = true;
+      return;
+    }
     await fs.rm(path.join(this.packageLoader.packageFolder, '.conceptmaps.db'), { force: true }); // the old cache
 
     // A cache is only used once its population finished. One that was cut short
@@ -194,6 +208,20 @@ class PackageConceptMapProvider extends AbstractConceptMapProvider {
               isMatch = false;
               break;
             }
+          } else if (param === 'url') {
+            // a left match, on the url as asked for (not lower cased)
+            const asked = searchParams.find(sp => sp.name === 'url').value;
+            if (!(json.url || '').startsWith(asked)) {
+              isMatch = false;
+              break;
+            }
+          } else if (param === 'version') {
+            // version-aware matching, on the version as asked for (not lower cased)
+            const asked = searchParams.find(sp => sp.name === 'version').value;
+            if (!VersionUtilities.versionSearchMatches(asked, json.version, VersionUtilities.versionAlgorithmOf(json))) {
+              isMatch = false;
+              break;
+            }
           } else if (param === 'jurisdiction') {
             // Special handling for jurisdiction - array of CodeableConcept
             if (!this._matchJurisdiction(json.jurisdiction, searchValue)) {