fhirsmith 0.14.2 → 0.15.1

package/tx/cs/cs-icd11.js

@@ -113,8 +113,11 @@ class ICD11Services extends BaseCSServices {
   /**
    * The default is system|version, but $lookup's `name` is meant to be a display name for
    * the code system. OMOP overrides it the same way; WHO returns the linearization title.
+   * It follows the request's languages like any other display, falling back to the primary
+   * title. $lookup passes its working languages (displayLanguage, else Accept-Language),
+   * since displayLanguage never reaches opContext.langs; other callers pass nothing.
    */
-  name() { return this.shared.title; }
+  name(languages) { return this.shared.titles?.[this.#displayLang(languages)] || this.shared.title; }
   description() { return this.shared.title; }
   totalCount() { return this.shared.count; }
   defLang() { return 'en'; }
@@ -191,12 +194,13 @@ class ICD11Services extends BaseCSServices {
     return row ? new ICD11Concept(row) : null;
   }
 
-  /** The three things the expression parser needs from the database. */
+  /** What the expression parser needs: the database, and the request's translations. */
   #expressionContext() {
     return {
       get: (sql, params) => this.#get(sql, params),
       all: (sql, params) => this.#all(sql, params),
       resolve: (text) => this.#resolve(text),
+      translate: (msgId, params) => this.opContext.i18n.translate(msgId, this.opContext.langs, params),
     };
   }
 
@@ -309,8 +313,8 @@ class ICD11Services extends BaseCSServices {
    * iterable of Language, in quality order; the database holds translations keyed on the
    * primary subtag, so that is what is matched.
    */
-  #displayLang() {
-    const langs = this.opContext?.langs;
+  #displayLang(languages) {
+    const langs = languages || this.opContext?.langs;
     if (langs) {
       for (const l of langs) {
         const base = l.language || String(l.code || '').split('-')[0];
@@ -615,8 +619,9 @@ class ICD11Services extends BaseCSServices {
     if (!target) {
       // a value set that names a code that is not there is broken, and saying so is more
       // use than quietly expanding to nothing
-      throw new Issue('error', 'code-invalid', null, null,
-        `The filter value '${value}' is not a code in ${this.system()}`, 'invalid-code', 422);
+      throw new Issue('error', 'code-invalid', null, 'FILTER_VALUE_UNKNOWN_CODE',
+        this.opContext.i18n.translate('FILTER_VALUE_UNKNOWN_CODE', this.opContext.langs, [value, this.system()]),
+        'invalid-code', 422);
     }
     filterContext.filters.push(new ICD11FilterSet('isa', {
       ancestorId: target.id, minDepth: op === 'is-a' ? 0 : 1, value,
@@ -749,12 +754,24 @@ class ICD11ServicesFactory extends CodeSystemFactoryProvider {
       }
       const count = await get('SELECT COUNT(*) n FROM concept WHERE system = ?', [sys.id]);
       const langs = await get("SELECT value FROM meta WHERE key = 'languages'", []);
+      // per-language titles; a database built before system_title existed has none
+      const all = (sql, p) => new Promise((res, rej) =>
+        db.all(sql, p, (e, r) => e ? rej(e) : res(r || [])));
+      const titles = {};
+      const hasTitles = await get(
+        "SELECT 1 x FROM sqlite_master WHERE type = 'table' AND name = 'system_title'", []);
+      if (hasTitles) {
+        for (const r of await all('SELECT lang, title FROM system_title WHERE system = ?', [sys.id])) {
+          titles[r.lang] = r.title;
+        }
+      }
       this._shared = {
         systemCode: sys.code,
         systemId: sys.id,
         url: sys.url,
         version: sys.version,
         title: sys.title,
+        titles,
         isTree: !!sys.is_tree,
         count: count.n,
         languages: (langs?.value || 'en').split(','),

package/tx/cs/cs-provider-api.js

@@ -1,22 +1,37 @@
+const { assignIdSpace } = require('../library/resource-ids');
+
 /**
  * Abstract base class for value set providers
  * Defines the interface that all value set providers must implement
  */
 class AbstractCodeSystemProvider {
   /**
-   * {int} Unique number assigned to this provider
+   * {string} The prefix of this provider's id space (set by assignIds) - given for its source in the library
+   * YAML, or autonumbered. Every code system this provider provides has an id that starts
+   * with spaceId + '-' (see tx/library/resource-ids.js)
    */
   spaceId;
 
   /**
-   * ensure that the ids on the code systems are unique, if they are
-   * in the global namespace
+   * Put this provider in an id space: set spaceId, and prefix the ids of the code systems it
+   * provides with spaceId + '-'. A provider is put in one id space, once - asking for a
+   * different one later is an error (see assignIdSpace)
    *
-   * @param {Set<String>} ids
+   * @param {string} spaceId
    */
-  // eslint-disable-next-line no-unused-vars
-  assignIds(ids) {
-    throw new Error('assignIds must be implemented by subclass');
+  assignIds(spaceId) {
+    if (assignIdSpace(this, spaceId)) {
+      this.prefixIds();
+    }
+  }
+
+  /**
+   * Prefix the ids of the code systems this provider provides with spaceId + '-', once spaceId
+   * is set (by assignIds). Code systems the provider provides later (see
+   * getCodeSystemChanges) must be given ids in the same space.
+   */
+  prefixIds() {
+    throw new Error('prefixIds must be implemented by subclass');
   }
 
   /**

package/tx/cs/cs-provider-list.js

@@ -1,4 +1,5 @@
 const { AbstractCodeSystemProvider } = require('./cs-provider-api');
+const { applyIdPrefix } = require('../library/resource-ids');
 
 /**
  * Package-based ValueSet provider using shared database layer
@@ -11,18 +12,18 @@ class ListCodeSystemProvider extends AbstractCodeSystemProvider {
   codeSystems = [];
 
   /**
-   * ensure that the ids on the code systems are unique, if they are
-   * in the global namespace
-   *
-   * @param {Set<String>} ids
+   * prefix the ids of the code systems with this provider's spaceId. A code system without
+   * an id gets its position in the list
    */
-  // eslint-disable-next-line no-unused-vars
-  assignIds(ids) {
+  prefixIds() {
+    let i = 0;
     for (const cs of this.codeSystems) {
-      if (!cs.id || ids.has("CodeSystem/"+cs.id)) {
-        cs.id = ""+ids.size;
+      i++;
+      const json = cs.jsonObj || cs;
+      if (!json.id) {
+        json.id = String(i);
       }
-      ids.add("CodeSystem/"+cs.id);
+      applyIdPrefix(cs, this.spaceId);
     }
   }
 

package/tx/cs/icd11-expressions.js

@@ -232,12 +232,11 @@ async function parseExpression(ctx, text) {
  */
 function notOnAnyAxis(ctx, stem, token) {
   const axes = stem.axes.map(a => a.axis_name).join(', ');
-  const msg = axes
-    ? `'${token.text}' is not a permitted value on any postcoordination axis of `
-      + `'${stem.stem.text}'. That stem declares: ${axes}`
-    : `'${token.text}' cannot be postcoordinated onto '${stem.stem.text}': that concept `
-      + `declares no postcoordination axes`;
-  return new Issue('error', 'code-invalid', null, null, msg, 'invalid-code', 400).handleAsOO(400);
+  const [msgId, params] = axes
+    ? ['ICD11_PC_VALUE_NOT_ON_AXIS', [token.text, stem.stem.text, axes]]
+    : ['ICD11_PC_NO_AXES', [token.text, stem.stem.text]];
+  return new Issue('error', 'code-invalid', null, msgId, ctx.translate(msgId, params),
+    'invalid-code', 400).handleAsOO(400);
 }
 
 module.exports = { ICD11Expression, ExpressionToken, parseExpression, tokenize, SCHEMA_NS };

package/tx/importers/icd11-schema.md

@@ -42,6 +42,7 @@ text lives in `designation`. The untouched native JSON for each concept is kept
 |---|---|
 | `meta` | key/value: release, languages, endpoints, tool version, request count |
 | `system` | one row per code system — `mms`, `icf`, `foundation` — with its canonical url, release and `is_tree` |
+| `system_title` | the code system's title per language (`system.title` is the primary one); only titles WHO actually translated |
 | `concept` | one row per entity |
 | `concept_parent` | parent/child edges, `seq` preserving the API's order |
 | `concept_closure` | transitive closure including the reflexive row, so is-a never needs recursion |

package/tx/importers/import-icd11.js

@@ -55,6 +55,15 @@ CREATE TABLE IF NOT EXISTS system (
   uri_stem  TEXT NOT NULL           -- versioned uri prefix used by the native API
 );
 
+-- the code system's own title, per language crawled (system.title is the primary language).
+-- Only a title WHO actually translated is recorded -- an English fallback is not a French title.
+CREATE TABLE IF NOT EXISTS system_title (
+  system  INTEGER NOT NULL REFERENCES system(id),
+  lang    TEXT NOT NULL,
+  title   TEXT NOT NULL,
+  PRIMARY KEY (system, lang)
+);
+
 -- one row per concept
 CREATE TABLE IF NOT EXISTS concept (
   id           INTEGER PRIMARY KEY,
@@ -374,6 +383,8 @@ class Icd11Importer {
       setMeta: db.prepare(`INSERT INTO meta(key,value) VALUES (?,?)
                            ON CONFLICT(key) DO UPDATE SET value=excluded.value`),
       getMeta: db.prepare(`SELECT value FROM meta WHERE key=?`),
+      insSystemTitle: db.prepare(`INSERT INTO system_title(system,lang,title) VALUES (?,?,?)
+                                  ON CONFLICT(system,lang) DO UPDATE SET title=excluded.title`),
       insSystem: db.prepare(`INSERT INTO system(code,url,version,title,is_tree,api_root,uri_stem)
                              VALUES (@code,@url,@version,@title,@is_tree,@api_root,@uri_stem)
                              ON CONFLICT(code) DO UPDATE SET
@@ -566,6 +577,8 @@ class Icd11Importer {
 
     for (const lang of languages) {
       const isPrimary = lang === primaryLang;
+      // before the resume check: a language whose concepts are all done still needs its title
+      await this.storeSystemTitle(systemId, def, lang, isPrimary ? root : null);
       const done = new Set(this.stmt.doneLangs.all(systemId, lang).map(r => r.uri));
       const todo = uris.filter(u => !done.has(unversion(u)));
       if (!todo.length) { this.log(`  [${lang}] already complete`); continue; }
@@ -609,6 +622,32 @@ class Icd11Importer {
     return systemId;
   }
 
+  /**
+   * Record the linearization root's title in one language. `root` is the document already
+   * fetched for the primary language; other languages cost one extra call each. The root's
+   * title carries the language WHO actually answered in, so an untranslated title (WHO falls
+   * back to English) is skipped rather than stored under the requested language.
+   */
+  async storeSystemTitle(systemId, def, lang, root) {
+    if (!root) {
+      const r = await this.getEntity(WHO + def.apiRoot, lang);
+      if (!r.ok) {
+        this.problem('title-failed', r.error, { system: def.code, lang, uri: def.apiRoot });
+        this.warn(`  ! could not read the ${lang} title of ${def.apiRoot}: ${r.error}`);
+        return;
+      }
+      root = r.body;
+    }
+    const title = textOf(root.title);
+    if (!title) return;
+    const got = langOf(root.title, lang);
+    if (got.split('-')[0] !== lang.split('-')[0]) {
+      this.log(`  [${lang}] no translated title (WHO answered in ${got})`);
+      return;
+    }
+    this.stmt.insSystemTitle.run(systemId, lang, title);
+  }
+
   /**
    * Turn the parent and scale-entity uris collected during the crawl into real ids.
    * `rootUri` is the linearization root, which the top-level concepts name as their

package/tx/library/resource-ids.js

@@ -0,0 +1,107 @@
+//
+// Resource ids in the server's id spaces
+//
+// Every CodeSystem, ValueSet and ConceptMap the server serves by id lives in the id space of
+// the provider that loaded it, and its id is the provider's prefix, a '-', then the id the
+// resource had in its source: "tho-v3-ActCode", "core-v3-MaritalStatus". The prefix is the
+// provider's spaceId: given in the library YAML (npm:hl7.terminology=tho), autonumbered by
+// the library when the YAML doesn't give one, and "core" for the FHIR core package each
+// endpoint loads for itself.
+//
+// No resource is served under its original id. Two sources can carry resources with the same
+// id (hl7.terminology and hl7.fhir.r4.core both have a CodeSystem v3-MaritalStatus), so an
+// unprefixed id can't say which one it means - and anything that looks a resource up by its
+// raw id must fail, rather than find whichever one happens to come first.
+//
+
+// resources whose id has been prefixed - so prefixing is idempotent, and a raw id that
+// happens to start with the prefix still gets one
+const prefixed = new WeakSet();
+
+/**
+ * Prefix a resource's id with spaceId. The resource is either a wrapper with a jsonObj
+ * (CodeSystem, ValueSet, ConceptMap) or a plain json object. Does nothing to a resource
+ * that has already been prefixed, or that has no id.
+ *
+ * @param {Object} resource
+ * @param {string} spaceId
+ */
+function applyIdPrefix(resource, spaceId) {
+  if (!resource || !spaceId || prefixed.has(resource)) {
+    return;
+  }
+  const json = resource.jsonObj || resource;
+  if (!json.id) {
+    return;
+  }
+  const id = `${spaceId}-${json.id}`;
+  json.id = id;
+  if (resource.jsonObj && Object.prototype.hasOwnProperty.call(resource, 'id')) {
+    resource.id = id;
+  }
+  prefixed.add(resource);
+}
+
+/**
+ * The id a resource had in its source, for an id served in spaceId - or null, if the id
+ * isn't in that space (including when it's a raw id, or there's no spaceId).
+ *
+ * @param {string} id
+ * @param {string} spaceId
+ * @returns {string|null}
+ */
+function stripIdPrefix(id, spaceId) {
+  if (!spaceId || typeof id !== 'string') {
+    return null;
+  }
+  const prefix = `${spaceId}-`;
+  return id.startsWith(prefix) && id.length > prefix.length ? id.substring(prefix.length) : null;
+}
+
+/**
+ * Whether a prefix given in the library YAML is acceptable. It's the start of an id, so it
+ * may only use id characters, and no '-', so that the prefix of any id is unambiguous.
+ * 'core' is the endpoints' own core package, and 'x' is the code system factories
+ * (CodeSystem/x-...), so neither is available.
+ *
+ * @param {string} prefix
+ * @returns {string|null} why the prefix isn't acceptable, or null if it is
+ */
+function checkIdPrefix(prefix) {
+  if (!/^[A-Za-z0-9.]{1,32}$/.test(prefix)) {
+    return `an id prefix may only contain letters, digits and '.' (up to 32 characters)`;
+  }
+  if (prefix === CORE_PREFIX || prefix === 'x') {
+    return `the id prefix '${prefix}' is reserved`;
+  }
+  return null;
+}
+
+/**
+ * Put a provider in an id space - the shared part of the providers' assignIds(spaceId).
+ * A provider is put in one id space, once: its resources are prefixed when it is, so
+ * moving it to another would leave them in the old one. Asking again for the same space
+ * does nothing.
+ *
+ * @param {Object} provider - a code system, value set or concept map provider
+ * @param {string} spaceId
+ * @returns {boolean} true if the provider has just been put in the space, and must now
+ *   prefix its resources' ids
+ */
+function assignIdSpace(provider, spaceId) {
+  if (!spaceId) {
+    throw new Error(`${provider.constructor.name}: no id space given`);
+  }
+  if (provider.spaceId) {
+    if (provider.spaceId === spaceId) {
+      return false;
+    }
+    throw new Error(`${provider.constructor.name} is already in the id space '${provider.spaceId}', so it can't be put in '${spaceId}'`);
+  }
+  provider.spaceId = spaceId;
+  return true;
+}
+
+const CORE_PREFIX = 'core';
+
+module.exports = { applyIdPrefix, stripIdPrefix, checkIdPrefix, assignIdSpace, CORE_PREFIX };

package/tx/library.js

@@ -39,6 +39,7 @@ const { OCLValueSetProvider } = require('./ocl/vs-ocl');
 const { OCLConceptMapProvider } = require('./ocl/cm-ocl');
 const {UriServicesFactory} = require("./cs/cs-uri");
 const {debugLog} = require("./operation-context");
+const { checkIdPrefix } = require("./library/resource-ids");
 
 /**
  * This class holds all the loaded content ready for processing
@@ -72,6 +73,17 @@ class Library {
   packageSources = [];
   externalSources = [];
 
+  /**
+   * {Map<Object, string>} the id prefix the library YAML gives for the source a provider was
+   * loaded from (npm:hl7.terminology=tho), by provider
+   */
+  #sourcePrefixes = new Map();
+
+  /**
+   * {Set<string>} every id prefix the library YAML gives - autonumbered prefixes skip them
+   */
+  #givenPrefixes = new Set();
+
   baseUrl = null;
   cacheFolder = null;
   startTime = Date.now();
@@ -171,6 +183,8 @@ class Library {
 
     this.log.info('Fetching Data from '+this.baseUrl);
 
+    this.#checkSourcePrefixes(config.sources);
+
     for (const source of config.sources) {
       try {
         await this.processSource(source, this.packageManager, "fetch");
@@ -223,15 +237,20 @@ class Library {
     this.assignIds();
   }
 
-  async processSource(source, packageManager, mode) {
-    // Parse the source string
+  /**
+   * Parse a source entry from the library YAML: type[!]:details[=prefix]
+   *
+   * @param {string} source
+   * @returns {{type: string, details: string, isDefault: boolean, prefix: string|null}}
+   */
+  #parseSource(source) {
     const colonIndex = source.indexOf(':');
     if (colonIndex === -1) {
       throw new Error(`Invalid source format: ${source}`);
     }
 
     let type = source.substring(0, colonIndex);
-    const details = source.substring(colonIndex + 1);
+    let details = source.substring(colonIndex + 1);
 
     // Handle special markers (like ! for default)
     let isDefault = false;
@@ -240,6 +259,59 @@ class Library {
       isDefault = true;
     }
 
+    // the id prefix for the resources the source provides: everything after the last '='
+    let prefix = null;
+    const eqIndex = details.lastIndexOf('=');
+    if (eqIndex > -1) {
+      prefix = details.substring(eqIndex + 1);
+      details = details.substring(0, eqIndex);
+      const problem = checkIdPrefix(prefix);
+      if (problem) {
+        throw new Error(`Invalid source '${source}': ${problem}`);
+      }
+    }
+    return { type, details, isDefault, prefix };
+  }
+
+  /**
+   * Check the id prefixes the library YAML gives before anything is loaded - each id space
+   * must belong to one source
+   *
+   * @param {string[]} sources
+   */
+  #checkSourcePrefixes(sources) {
+    const seen = new Map();
+    for (const source of sources) {
+      const { prefix } = this.#parseSource(source);
+      if (prefix) {
+        if (seen.has(prefix)) {
+          throw new Error(`The id prefix '${prefix}' is given for both '${seen.get(prefix)}' and '${source}'`);
+        }
+        seen.set(prefix, source);
+      }
+    }
+  }
+
+  async processSource(source, packageManager, mode) {
+    const { type, details, isDefault, prefix } = this.#parseSource(source);
+
+    // the providers this source adds, so they can be given its id prefix
+    const csCount = this.codeSystemProviders.length;
+    const vsCount = this.valueSetProviders.length;
+    const cmCount = this.conceptMapProviders.length;
+
+    await this.#loadSource(type, details, isDefault, mode, packageManager);
+
+    if (prefix) {
+      this.#givenPrefixes.add(prefix);
+      for (const provider of [...this.codeSystemProviders.slice(csCount),
+        ...this.valueSetProviders.slice(vsCount), ...this.conceptMapProviders.slice(cmCount)]) {
+        this.#sourcePrefixes.set(provider, prefix);
+      }
+    }
+  }
+
+  async #loadSource(type, details, isDefault, mode, packageManager) {
     // Switch statement for different source types
     switch (type) {
       case 'internal':
@@ -1000,6 +1072,7 @@ class Library {
     // Now add the existing value set providers after the FHIR core packages
     provider.valueSetProviders.push(...this.valueSetProviders);
     provider.conceptMapProviders.push(...this.conceptMapProviders);
+    provider.applyTHOPrecedence();
 
     // bind UCUM common value set
     let ucum = provider.codeSystemFactories.get("http://unitsofmeasure.org");
@@ -1030,30 +1103,29 @@ class Library {
   }
 
   /**
-   * all the loaded resources must have unique IDs for the get operation
-   * they must be assigned by the library on loading. providers can either assign
-   * ids from the global space at start up, or, if they can provide new resources
-   * later in an ongoing fashion, allocate them in their own space
+   * Every loaded resource is served in the id space of the provider that loaded it: its id is
+   * the provider's spaceId, '-', and the id it had in its source (see
+   * tx/library/resource-ids.js). The spaceId is the prefix the library YAML gives for the
+   * provider's source, or, if it gives none, a number - the next one, counting providers of
+   * the same kind, that the YAML doesn't use as a prefix. Numbers depend on the order of the
+   * sources, so a source whose ids should stay the same when the YAML changes needs a prefix.
+   *
+   * (Code system factories don't have ids - they are not available directly.)
    */
   assignIds() {
-    let ids = new Set();
-    // these don't have ids - not available directly for (const cs of this.codeSystemFactories) { .. }
-    let i = 0;
-    for (const cp of this.codeSystemProviders) {
-      cp.spaceId = String(++i);
-      cp.assignIds(ids);
-    }
-    i = 0;
-    for (const vp of this.valueSetProviders) {
-      vp.spaceId = String(++i);
-      vp.assignIds(ids);
-    }
-    i = 0;
-    for (const cmp of this.conceptMapProviders) {
-      cmp.spaceId = String(++i);
-      cmp.assignIds(ids);
+    for (const providers of [this.codeSystemProviders, this.valueSetProviders, this.conceptMapProviders]) {
+      let n = 0;
+      for (const provider of providers) {
+        let spaceId = this.#sourcePrefixes.get(provider);
+        if (!spaceId) {
+          do {
+            n++;
+          } while (this.#givenPrefixes.has(String(n)));
+          spaceId = String(n);
+        }
+        provider.assignIds(spaceId);
+      }
     }
-
   }
 
   async close() {

package/tx/ocl/cm-ocl.cjs

@@ -3,6 +3,7 @@ const { ConceptMap } = require('../library/conceptmap');
 const { PAGE_SIZE } = require('./shared/constants');
 const { createOclHttpClient } = require('./http/client');
 const { fetchAllPages, extractItemsAndNext } = require('./http/pagination');
+const { stripIdPrefix } = require('../library/resource-ids');
 
 const DEFAULT_MAX_SEARCH_PAGES = 10;
 
@@ -24,7 +25,7 @@ class OCLConceptMapProvider extends AbstractConceptMapProvider {
     this._canonicalBySourceUrl = new Map();
   }
 
-  assignIds(ids) {
+  prefixIds() {
     if (!this.spaceId) {
       return;
     }
@@ -33,13 +34,18 @@ class OCLConceptMapProvider extends AbstractConceptMapProvider {
     this._idMap.clear();
 
     for (const cm of unique) {
-      if (!cm.id.startsWith(`${this.spaceId}-`)) {
-        const nextId = `${this.spaceId}-${cm.id}`;
-        cm.id = nextId;
-        cm.jsonObj.id = nextId;
-      }
+      this.#prefixId(cm);
       this._idMap.set(cm.id, cm);
-      ids.add(`ConceptMap/${cm.id}`);
+    }
+  }
+
+  // concept maps are served in this provider's id space - including the ones that arrive
+  // after the spaceId is assigned
+  #prefixId(cm) {
+    if (this.spaceId && cm.id && !cm.id.startsWith(`${this.spaceId}-`)) {
+      const nextId = `${this.spaceId}-${cm.id}`;
+      cm.id = nextId;
+      cm.jsonObj.id = nextId;
     }
   }
 
@@ -56,7 +62,7 @@ class OCLConceptMapProvider extends AbstractConceptMapProvider {
 
     const mappingId = this.#extractMappingId(url);
     if (mappingId) {
-      return await this.fetchConceptMapById(mappingId);
+      return await this.#fetchMappingById(mappingId);
     }
 
     try {
@@ -81,14 +87,15 @@ class OCLConceptMapProvider extends AbstractConceptMapProvider {
     if (this._idMap.has(id)) {
       return this._idMap.get(id);
     }
+    // only ids in this provider's space - the rest is the OCL mapping id
+    const rawId = stripIdPrefix(id, this.spaceId);
+    return rawId ? await this.#fetchMappingById(rawId) : null;
+  }
 
-    let rawId = id;
-    if (this.spaceId && id.startsWith(`${this.spaceId}-`)) {
-      rawId = id.substring(this.spaceId.length + 1);
-    }
-
-    if (this._idMap.has(rawId)) {
-      return this._idMap.get(rawId);
+  async #fetchMappingById(rawId) {
+    const id = this.spaceId ? `${this.spaceId}-${rawId}` : rawId;
+    if (this._idMap.has(id)) {
+      return this._idMap.get(id);
     }
 
     try {
@@ -378,6 +385,7 @@ class OCLConceptMapProvider extends AbstractConceptMapProvider {
   }
 
   #indexConceptMap(cm) {
+    this.#prefixId(cm);
     this.conceptMapMap.set(cm.url, cm);
     if (cm.version) {
       this.conceptMapMap.set(`${cm.url}|${cm.version}`, cm);

package/tx/ocl/cs-ocl.cjs

@@ -92,15 +92,12 @@ class OCLCodeSystemProvider extends AbstractCodeSystemProvider {
     }
   }
 
-  assignIds(ids) {
+  prefixIds() {
+    const codeSystems = [...new Set(this._idToCodeSystem.values())];
     this._usedIds.clear();
-    for (const cs of this._idToCodeSystem.values()) {
-      if (!cs.id || ids.has(`CodeSystem/${cs.id}`)) {
-        cs.id = String(ids.size);
-        cs.jsonObj.id = cs.id;
-      }
-      ids.add(`CodeSystem/${cs.id}`);
-      this._usedIds.add(cs.id);
+    this._idToCodeSystem.clear();
+    for (const cs of codeSystems) {
+      this.#trackCodeSystemId(cs);
       this._idToCodeSystem.set(cs.id, cs);
     }
   }
@@ -358,9 +355,11 @@ class OCLCodeSystemProvider extends AbstractCodeSystemProvider {
       return;
     }
 
-    if (!cs.id || this._usedIds.has(cs.id)) {
+    // code systems are served in this provider's id space
+    const prefix = this.spaceId ? `${this.spaceId}-` : '';
+    if (!cs.id || !cs.id.startsWith(prefix) || this._usedIds.has(cs.id)) {
       const raw = cs.id || cs.name || cs.url || 'ocl-cs';
-      const base = this.spaceId ? `${this.spaceId}-${raw}` : String(raw);
+      const base = raw.startsWith(prefix) ? String(raw) : `${prefix}${raw}`;
       let candidate = base;
       let index = 1;
       while (this._usedIds.has(candidate)) {