fhirsmith 0.10.1 → 0.11.0

package/tx/workers/expand.js

@@ -220,7 +220,7 @@ class ValueSetExpander {
   }
 
   async listDisplaysFromProvider(displays, cs, context) {
-    await cs.designations(context, displays);
+    await cs.designations(context, displays, true);
     displays.source = cs;
   }
 
@@ -661,15 +661,9 @@ class ValueSetExpander {
           if (cs.specialEnumeration()) {
             await this.checkCanExpandValueSet(cs.specialEnumeration(), '', null);
           } else if (filter.isNull) {
-            if (cs.isNotClosed()) {
-              if (cs.specialEnumeration()) {
-                Extensions.addBoolean(exp, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-                Extensions.addString(exp, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
-              } else {
-                throw new Issue("error", "too-costly", null, null, 'The code System "' + cs.system() + '" has a grammar, and cannot be enumerated directly', null, 422).withDiagnostics(this.worker.opContext.diagnostics());
-              }
-            }
-            if (!imp && this.limitCount > 0 && cs.totalCount > this.limitCount) {
+            // The unclosed marking for a grammar code system is added by
+            // processCodes (the actual expansion); checkSource only guards size.
+            if (!imp && this.count !== 0 && this.limitCount > 0 && cs.totalCount > this.limitCount) {
               throw new Issue("error", "too-costly", null, 'VALUESET_TOO_COSTLY', this.worker.i18n.translate('VALUESET_TOO_COSTLY', this.params.httpLanguages, [srcURL, '>' + this.limitCount]), null, 422).withDiagnostics(this.worker.opContext.diagnostics());
             }
           }
@@ -746,45 +740,64 @@ class ValueSetExpander {
             let vs = await this.worker.findValueSet(cs.specialEnumeration(), '', null);
             const base = await this.expandValueSet(cs.specialEnumeration(), '', vs, filter, notClosed);
             Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
             await this.importValueSet(base, expansion, valueSets, 0);
             notClosed.value = true;
+          } else if (!cs.canBeExpanded()) {
+            throw new Issue("error", "not-supported", null, 'CODESYSTEM_NOT_ENUMERABLE', this.worker.i18n.translate('CODESYSTEM_NOT_ENUMERABLE', this.params.httpLanguages, [cs.system()]), null, 422).withDiagnostics(this.worker.opContext.diagnostics());
           } else if (filter.isNull) {
             this.worker.opContext.log('add whole code system');
             if (cs.isNotClosed()) {
               if (cs.specialEnumeration()) {
                 Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
               } else {
-                throw new Issue("error", "too-costly", null, null, 'The code System "' + cs.system() + '" has a grammar, and cannot be enumerated directly', null, 422).withDiagnostics(this.worker.opContext.diagnostics());
+                // Grammar code system with no special enumeration (e.g. SNOMED CT):
+                // enumerate the precoordinated concepts we can, and mark the
+                // expansion incomplete rather than refusing it.
+                Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
+                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members");
               }
               notClosed.value = true;
             }
 
-            const iter = await cs.iterator(null);
-            if (valueSets.length === 0 && this.limitCount > 0 && (iter && iter.total > this.limitCount) && this.offset < 0) {
-              throw new Issue("error", "too-costly", null, 'VALUESET_TOO_COSTLY', this.worker.i18n.translate('VALUESET_TOO_COSTLY', this.params.httpLanguages, [vsSrc.vurl, '>' + this.limitCount]), null, 422).withDiagnostics(this.worker.opContext.diagnostics());
+            if (this.count === 0 && filters.length === 0 && valueSets.length === 0) {
+              // count=0 (count only) with a single whole-code-system include and no
+              // additional filters: report the code count directly rather than
+              // enumerating - which for a poly-hierarchy (e.g. SNOMED) is both
+              // expensive and pointless when no codes are being materialised.
+              this.addToTotal(await cs.countAllCodes(excludeInactive));
+            } else {
+              const iter = await cs.iterator(null);
+              if (valueSets.length === 0 && this.limitCount > 0 && (iter && iter.total > this.limitCount) && this.offset < 0) {
+                throw new Issue("error", "too-costly", null, 'VALUESET_TOO_COSTLY', this.worker.i18n.translate('VALUESET_TOO_COSTLY', this.params.httpLanguages, [vsSrc.vurl, '>' + this.limitCount]), null, 422).withDiagnostics(this.worker.opContext.diagnostics());
 
-            }
-            let tcount = 0;
-            let c = await cs.nextContext(iter);
-            while (c) {
-              this.worker.deadCheck('processCodes#3a');
-              if (await this.passesFilters(cs, c, prep, filters, 0)) {
-                tcount += await this.includeCodeAndDescendants(cs, c, expansion, valueSets, null, excludeInactive, vsSrc.vurl);
               }
-              c = await cs.nextContext(iter);
+              let tcount = 0;
+              let c = await cs.nextContext(iter);
+              while (c) {
+                this.worker.deadCheck('processCodes#3a');
+                if (await this.passesFilters(cs, c, prep, filters, 0)) {
+                  tcount += await this.includeCodeAndDescendants(cs, c, expansion, valueSets, null, excludeInactive, vsSrc.vurl);
+                }
+                c = await cs.nextContext(iter);
+              }
+              this.addToTotal(tcount);
             }
-            this.addToTotal(tcount);
           } else {
             this.worker.opContext.log('prepare filters');
-            this.noTotal();
             if (cs.isNotClosed(filter)) {
               notClosed.value = true;
             }
             const prep = await cs.getPrepContext(true);
             const ctxt = await cs.searchFilter(prep, filter, false);
             let set = await cs.executeFilters(prep);
+            if (this.count === 0 && valueSets.length === 0) {
+              // count=0 (count only): report the filtered size directly without
+              // materialising the codes.
+              this.addToTotal(await cs.filterSize(ctxt, set[0]));
+            } else {
+            this.noTotal();
             this.worker.opContext.log('iterate filters');
             while (await cs.filterMore(ctxt, set[0])) {
               this.worker.deadCheck('processCodes#4');
@@ -808,6 +821,7 @@ class ValueSetExpander {
               }
             }
             this.worker.opContext.log('iterate filters done');
+            }
           }
         }
 
@@ -856,7 +870,7 @@ class ValueSetExpander {
 
           if (cs.specialEnumeration()) {
             Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
             notClosed.value = true;
           }
 
@@ -867,7 +881,7 @@ class ValueSetExpander {
               throw new Issue('error', 'invalid', path + ".filter[" + i + "]", 'UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.worker.i18n.translate('UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.params.httpLanguages, [cs.system(), fc.property, fc.op]), 'vs-invalid', 400);
             }
             Extensions.checkNoModifiers(fc, 'ValueSetExpander.processCodes', 'filter', vsSrc.vurl);
-            await cs.filter(prep, i == 0, fc.property, fc.op, fc.value);
+            await cs.filter(prep, i == 0, fc.property, fc.op, fc.value, vsSrc.isCached ? fc : null);
           }
 
           const fset = await cs.executeFilters(prep);
@@ -1003,9 +1017,13 @@ class ValueSetExpander {
             if (cs.isNotClosed(filter)) {
               if (cs.specialEnumeration()) {
                 Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
               } else {
-                throw new Issue("error", "too-costly", null, null, 'The code System "' + cs.system() + '" has a grammar, and cannot be enumerated directly', null, 422).withDiagnostics(this.worker.opContext.diagnostics());
+                // Grammar code system with no special enumeration (e.g. SNOMED CT):
+                // enumerate the precoordinated concepts we can, and mark the
+                // expansion incomplete rather than refusing it.
+                Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
+                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members");
               }
             }
 
@@ -1053,14 +1071,14 @@ class ValueSetExpander {
           if (cs.specialEnumeration()) {
             await cs.specialFilter(prep, true);
             Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", "The code System '" + cs.system() + "' has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
           }
 
           let first = true;
           for (let fc of cset.filter) {
             this.worker.deadCheck('processCodes#4a');
             Extensions.checkNoModifiers(fc, 'ValueSetExpander.processCodes', 'filter', vsSrc.vurl);
-            await cs.filter(prep, first, fc.property, fc.op, fc.value);
+            await cs.filter(prep, first, fc.property, fc.op, fc.value, vsSrc.isCached ? fc : null);
             first = false;
           }
 

package/tx/workers/metadata.js

@@ -36,16 +36,37 @@ class MetadataHandler {
 
     if (mode === 'terminology') {
       this.logInfo = 'termcaps';
-      const tc = new TerminologyCapabilities(await this.buildTerminologyCapabilities(endpoint, provider));
+      const tc = new TerminologyCapabilities(await this.buildTerminologyCapabilities(endpoint, provider, req));
       return res.json(tc.jsonObj);
     }
     this.logInfo = 'metadata';
 
     // Default: return CapabilityStatement
-    const cs = new CapabilityStatement(this.buildCapabilityStatement(endpoint, provider));
+    const cs = new CapabilityStatement(this.buildCapabilityStatement(endpoint, provider, req));
     return res.json(cs.jsonObj);
   }
 
+  /**
+   * Resolve the public base URL for this request.
+   * Derived from what the client actually asked for (scheme + host) plus the
+   * endpoint path, so the server echoes the host the client used rather than a
+   * fixed, hardcoded value. Falls back to config/host only when no request is
+   * available (e.g. unit tests calling the build methods directly).
+   * @param {express.Request} [req] - Express request
+   * @param {Object} endpoint - Endpoint info {path, ...}
+   * @returns {string} Base URL, e.g. https://tx.fhir.org/r4
+   */
+  resolveBaseUrl(req, endpoint) {
+    if (!req) {
+      return this.config.baseUrl || `https://${this.host}${endpoint.path}`;
+    }
+    // Requires app.set('trust proxy', ...) and nginx forwarding X-Forwarded-Proto
+    // for the scheme to be correct behind the reverse proxy.
+    const proto = req.protocol || 'https';
+    const host = req.get('host') || this.host;
+    return `${proto}://${host}${endpoint.path}`;
+  }
+
   /**
    * Handle GET /$versions request
    * @param {express.Request} req - Express request (with txEndpoint attached)
@@ -106,11 +127,11 @@ class MetadataHandler {
    * @param {Object} provider - Provider for code systems and resources
    * @returns {Object} CapabilityStatement resource
    */
-  buildCapabilityStatement(endpoint) {
+  buildCapabilityStatement(endpoint, provider, req) {
 
     const now = new Date().toISOString();
     const fhirVersion = this.mapFhirVersion(endpoint.fhirVersion);
-    const baseUrl = this.config.baseUrl || `https://${this.host}${endpoint.path}`;
+    const baseUrl = this.resolveBaseUrl(req, endpoint);
     const serverVersion = this.config.serverVersion;
 
     return {
@@ -281,9 +302,9 @@ class MetadataHandler {
    * @param {Object} provider - Provider for code systems and resources
    * @returns {Object} TerminologyCapabilities resource
    */
-  async buildTerminologyCapabilities(endpoint, provider) {
+  async buildTerminologyCapabilities(endpoint, provider, req) {
     const now = new Date().toISOString();
-    const baseUrl = this.config.baseUrl || `https://${this.host}${endpoint.path}`;
+    const baseUrl = this.resolveBaseUrl(req, endpoint);
     const serverVersion = this.config.serverVersion || '1.0.0';
 
     const tc = {

package/tx/workers/search.js

@@ -8,6 +8,7 @@
 const { TerminologyWorker } = require('./worker');
 const {Utilities} = require("../../library/utilities");
 const {debugLog} = require("../operation-context");
+const {acceptsHtml} = require("../tx-html");
 
 class SearchWorker extends TerminologyWorker {
   /**
@@ -84,7 +85,12 @@ class SearchWorker extends TerminologyWorker {
           break;
       }
 
-      const count = summary === 'count' ? 0 : Math.min(elements ? 2000 : 200, params._count && Utilities.isInteger(params._count) ? parseInt(params._count) : 20);
+      // Default page size depends on the return format: browsers get small pages
+      // (20), while API clients (json/xml) get big ones (1000) - they just want
+      // the data, and small pages make crawlers (e.g. the tx registry) painfully
+      // slow. An explicit _count always wins, subject to the caps.
+      const defaultCount = acceptsHtml(req) ? 20 : 1000;
+      const count = summary === 'count' ? 0 : Math.min(elements ? 2000 : 200, params._count && Utilities.isInteger(params._count) ? parseInt(params._count) : defaultCount);
       const sort = params._sort || "id";
 
       // Get matching resources

package/tx/workers/validate.js

@@ -753,6 +753,7 @@ class ValueSetChecker {
               messages.push(msg);
             }
           } else {
+            this.worker.opContext.addNote(this.valueSet, 'Include for ' + this.worker.renderer.displayCoded(cc.system, cc.version) + ' not considered for "' + this.worker.renderer.displayCoded(system, version) + '"', this.indentCount);
             result = false;
           }
           for (let u of cc.valueSet || []) {
@@ -875,6 +876,7 @@ class ValueSetChecker {
           }
         }
       } else {
+        this.worker.opContext.addNote(this.valueSet, 'ValueSet has neither compose nor expansion - cannot determine membership', this.indentCount);
         result = false;
       }
     }
@@ -1126,17 +1128,23 @@ class ValueSetChecker {
         } else if (c.display && list.designations.length > 0) {
           await this.checkDisplays(list, defLang, c, msg, op, path);
         }
-        psys = c.system;
-        pcode = c.code;
-        if (ver.value) {
-          pver = ver.value;
-        }
-        let pd = list.preferredDisplay(this.params.workingLanguages());
-        if (pd) {
-          pdisp = pd;
-        }
-        if (!pdisp) {
-          pdisp = list.preferredDisplay(null);
+        // Report the FIRST matching coding, not the last: when a CodeableConcept
+        // has several valid codings, the code/system/version/display echoed back
+        // are those of the earliest coding that validated. Only capture once
+        // (pcode is undefined until the first match).
+        if (pcode === undefined) {
+          psys = c.system;
+          pcode = c.code;
+          if (ver.value) {
+            pver = ver.value;
+          }
+          let pd = list.preferredDisplay(this.params.workingLanguages());
+          if (pd) {
+            pdisp = pd;
+          }
+          if (!pdisp) {
+            pdisp = list.preferredDisplay(null);
+          }
         }
       } else if (!this.params.membershipOnly && ws) {
         if (!isAbsoluteUrl(ws)) {
@@ -1203,7 +1211,7 @@ class ValueSetChecker {
             }
           }
         } else {
-          this.checkCanonicalStatusCS(path, op, prov, this.valueSet);
+          await this.checkCanonicalStatusCS(path, op, prov, this.valueSet);
           let ctxt = await prov.locate(c.code);
           if (!ctxt.context) {
             // message can never be populated in pascal?
@@ -1280,7 +1288,10 @@ class ValueSetChecker {
       }
       i++;
     }
-    if (ok === false && !this.valueSet.jsonObj.internallyDefined) {
+    // for an internally defined value set (CodeSystem validation), the code-system-level
+    // message is preferred - but if nothing produced an error, this is the only
+    // explanation there will be, so it can't be suppressed
+    if (ok === false && (!this.valueSet.jsonObj.internallyDefined || !op.hasErrors())) {
       let mid, m, p;
       if (mode === 'codeableConcept') {
         mid = 'TX_GENERAL_CC_ERROR_MESSAGE';
@@ -1354,12 +1365,13 @@ class ValueSetChecker {
       if (!mpath) {
         mpath = 'code';
       }
+      let mid1 = "INACTIVE_CONCEPT_FOUND";
+      let mm1 = "";
       if (!['inactive', 'DISCOURAGED'].includes(vstatus.value)) {
-        let m = this.worker.i18n.translate('INACTIVE_CONCEPT_FOUND', this.params.HTTPLanguages, ['inactive', tcode]);
-        msg(m);
-        op.addIssue(new Issue('warning', 'business-rule', mpath, 'INACTIVE_CONCEPT_FOUND', m, 'code-comment'));
+        mid1 = 'INACTIVE_CONCEPT_FOUND_ADD';
+        mm1 = 'inactive';
       }
-      let m = this.worker.i18n.translate('INACTIVE_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, tcode]);
+      let m = this.worker.i18n.translate(mid1, this.params.HTTPLanguages, [vstatus.value, tcode, mm1]);
       msg(m);
       op.addIssue(new Issue('warning', 'business-rule', mpath, 'INACTIVE_CONCEPT_FOUND', m, 'code-comment'));
     } else if (vstatus.value && vstatus.value.toLowerCase() === 'deprecated') {
@@ -1688,7 +1700,7 @@ class ValueSetChecker {
         if (!fc.value) {
           throw new Issue('error', 'invalid', null, 'UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.worker.i18n.translate('UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.params.HTTPLanguages, [cs.system(), fc.property, fc.op]));
         }
-        await cs.filter(prep, false, fc.property, fc.op, fc.value);
+        await cs.filter(prep, false, fc.property, fc.op, fc.value, (vs && vs.isCached) ? fc : null);
         // if (f === null) {
         //   throw new Issue('error', 'not-supported', null, 'FILTER_NOT_UNDERSTOOD', this.worker.i18n.translate('FILTER_NOT_UNDERSTOOD', this.params.HTTPLanguages, [fc.property, fc.op, fc.value, vs.vurl, cs.system()]) + ' (2)', 'vs-invalid');
         // }

package/tx/workers/worker.js

@@ -661,19 +661,42 @@ class TerminologyWorker {
       // specific coded issue rather than silently auto-creating a fresh cache and
       // then failing obscurely later when a by-reference resource can't be found.
       if (!this.opContext.resourceCache.has(cacheId)) {
+        // A comma in the cache-id means the request carried multiple X-Cache-Id
+        // headers (Node joins duplicate headers with ", "): server-minted ids are
+        // single uuids. This happens when a client attaches a new cache-id header
+        // without clearing the old one (e.g. IG publisher builds where a second
+        // client context wrapped the same HTTP client) - report that specifically,
+        // because the generic "unknown cache" message sends people looking for an
+        // expiry problem that isn't there.
+        if (cacheId.includes(',')) {
+          throw new Issue('error', 'invalid', null, 'CACHE_ID_DUPLICATE',
+            `The request carried multiple ${CACHE_ID_HEADER} headers (combined value '${cacheId}'). ` +
+            'This is a client error: each request must carry exactly one cache-id. It usually means the client ' +
+            'started a second cache on a connection that already had one, without removing the first header.',
+            'cache-id-duplicate', 400);
+        }
         throw new Issue('error', 'not-found', null, 'CACHE_ID_UNKNOWN',
           this.i18n.translate('CACHE_ID_UNKNOWN', this.opContext.langs, [cacheId]),
           'cache-id-unknown', 404);
       }
 
-      // The cache exists: merge any resources supplied on this request into it
-      // (incremental population is allowed), then expose the full cache contents.
-      const toCache = txResources.concat(primaryResources);
-      if (toCache.length > 0) {
-        this.opContext.resourceCache.add(cacheId, toCache);
+      // The cache exists. If it is unsealed, merge any resources supplied on this
+      // request into it (incremental population). If it is sealed, the cache is
+      // fixed at what it was created with: resources supplied now are still used
+      // for this request (via additionalResources below) but are NOT added to the
+      // shared cache, so a sealed cache never grows.
+      if (!this.opContext.resourceCache.isSealed(cacheId)) {
+        const toCache = txResources.concat(primaryResources);
+        if (toCache.length > 0) {
+          this.opContext.resourceCache.add(cacheId, toCache);
+        }
+        this.additionalResources = this.opContext.resourceCache.get(cacheId);
+      } else {
+        // Sealed: expose the cache contents plus this request's own inline
+        // resources (used for this call only), without mutating the cache.
+        this.additionalResources = this.opContext.resourceCache.get(cacheId)
+          .concat(txResources, primaryResources);
       }
-
-      this.additionalResources = this.opContext.resourceCache.get(cacheId);
       this.additionalResourcesCacheId = cacheId;
     } else {
       // No cache-id, just use the tx-resources directly

package/tx/xversion/xv-valueset.js

@@ -131,9 +131,12 @@ function valueSetR5ToR4(r5Obj) {
         });
       }
       delete exp.property;
-      convertContainsPropertyR5ToR4(exp.contains);
-
     }
+
+    // ValueSet.expansion.contains.property is R5-only too, and must be converted
+    // whether or not the expansion declares expansion-level property definitions:
+    // a contained code can carry a property with no expansion.property present.
+    convertContainsPropertyR5ToR4(exp.contains);
   }
 
   return r5Obj;

package/xig/xig.js

@@ -977,7 +977,7 @@ async function fetchResourceRows(queryParams, offset = 0, limit = 200) {
 }
 
 function rowToObject(row, queryParams) {
-  const { ver, realm, auth, type, rt } = queryParams;
+  const { type } = queryParams;
   const packageObj = getPackage(row.PackageKey);
 
   const obj = {
@@ -3156,7 +3156,7 @@ async function initializeXigModule(stats, xigConfig) {
     if (!fs.existsSync(XIG_DB_PATH)) {
       xigLog.info('No existing XIG database found, triggering initial download');
       setTimeout(() => {
-        updateXigDatabase();
+        updateXigDatabase().catch((err) => xigLog.error('XIG database update failed: ' + err.message));
       }, 5000);
     }
 
@@ -3167,7 +3167,7 @@ async function initializeXigModule(stats, xigConfig) {
     // Note: This assumes we're called only when XIG is enabled
     if (xigConfig?.autoUpdate !== false) {
       cron.schedule('0 2 * * *', () => {
-        updateXigDatabase();
+        updateXigDatabase().catch((err) => xigLog.error('XIG database update failed: ' + err.message));
       });
     }