fhirsmith 0.13.3 → 0.14.0

package/tx/tx.js

@@ -49,10 +49,11 @@ const {capabilityStatementFromR5} = require("./xversion/xv-capabiliityStatement"
 const {bundleFromR5} = require("./xversion/xv-bundle");
 const {convertResourceToR5} = require("./xversion/xv-resource");
 const ClosureWorker = require("./workers/closure");
+const { ClosureStore } = require("./closure/closure-store");
 const {BundleXML} = require("./xml/bundle-xml");
 const ConceptUsageTracker = require("./usage-tracker");
 const ProblemFinder = require("./problems");
-const { buildOperationOutcome } = require('./library/operation-outcome');
+const { buildOperationOutcome, outcomeFromError } = require('./library/operation-outcome');
 // const {writeFileSync} = require("fs");
 
 class TXModule {
@@ -147,6 +148,13 @@ class TXModule {
 
     this.log.info('Initializing TX module');
 
+    // Optional instance code, prefixed onto every cache-id this server issues so a
+    // proxy in front of several instances can route by it (see nginx.md). Checked
+    // here so a bad value stops startup rather than surfacing per endpoint.
+    if (ResourceCache.checkInstanceCode(config.instanceCode)) {
+      this.log.info(`Cache-ids will be issued with instance code '${config.instanceCode}'`);
+    }
+
     // Load HTML template
     txHtml.loadTemplate();
 
@@ -176,8 +184,35 @@ class TXModule {
     await this.i18n.load();
     this.log.info('I18n support initialized');
 
+    // $closure keeps its tables on disk, across sessions and restarts, so it only exists
+    // when the administrator turns it on and says where they go. If it is turned on and
+    // the database can't be opened, that stops startup - silently running without it
+    // would be worse.
+    this.closureStore = null;
+    if (config.closure && config.closure.enabled) {
+      this.closureStore = new ClosureStore(config.closure, this.log);
+      this.closureStore.open();
+      this.log.info(`$closure enabled: tables in ${this.closureStore.path}`);
+      const days = config.closure.retentionDays;
+      if (days) {
+        const prune = async () => {
+          try {
+            const dropped = await this.closureStore.pruneUnused(days);
+            if (dropped.length > 0) {
+              this.log.info(`closure: dropped ${dropped.length} table(s) unused for ${days} days`);
+            }
+          } catch (error) {
+            this.log.error(`closure: pruning failed: ${error.message}`);
+          }
+        };
+        void prune(); // errors are logged inside
+        this.timers.push(setInterval(prune, 24 * 60 * 60 * 1000));
+      }
+    }
+
     // Initialize metadata handler with config
     this.metadataHandler = new MetadataHandler({
+      closure: this.closureStore != null,
       baseUrl: config.baseUrl,
       serverVersion: packageJson.version,
       txVersion: packageJson.txVersion,
@@ -259,6 +294,7 @@ class TXModule {
     // can report it and a client can size its keepalive interval to this server rather
     // than guessing at a number it has no way to see.
     endpointInfo.resourceCache.setIdleTimeout(cacheTimeoutMs);
+    endpointInfo.resourceCache.setInstanceCode(this.config.instanceCode);
     if (this.stats) {
       this.stats.addTask("Client Cache", "5 min");
     }
@@ -370,9 +406,15 @@ class TXModule {
           let result;
 
           if (isHtml) {
-            const title = txhtml.buildTitle(data, req);
+            // _format=html/fragment: the rendering only, with no page around it, for a
+            // page that runs an operation and puts the result inside itself (the ECL
+            // panel does this). The rendering is the same either way, so an error comes
+            // back as the rendered OperationOutcome rather than as something the caller
+            // has to handle separately.
             const content = await txhtml.render(data, req);
-            const html = await txhtml.renderPage(title, content, req.txEndpoint, req.txStartTime);
+            const fragment = (req.query._format || req.query.format) === 'html/fragment';
+            const html = fragment ? content
+              : await txhtml.renderPage(txhtml.buildTitle(data, req), content, req.txEndpoint, req.txStartTime);
             responseSize = Buffer.byteLength(html, 'utf8');
             res.setHeader('Content-Type', 'text/html');
             result = res.send(html);
@@ -710,20 +752,21 @@ class TXModule {
       }
     });
 
-    // ConceptMap/$closure (GET and POST)
-    router.get('/ConceptMap/\\$closure', async (req, res) => {
+    // $closure (GET and POST). System level: the OperationDefinition is
+    // ConceptMap-closure, but it is declared system=true, type=false (#100).
+    router.get('/\\$closure', async (req, res) => {
       const start = Date.now();
       try {
-        let worker = new ClosureWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        let worker = new ClosureWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n, this.closureStore, this.config.closure);
         await worker.handle(req, res, this.log);
       } finally {
         this.countRequest(endpointPath, '$closure', Date.now() - start);
       }
     });
-    router.post('/ConceptMap/\\$closure', async (req, res) => {
+    router.post('/\\$closure', async (req, res) => {
       const start = Date.now();
       try {
-        let worker = new ClosureWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        let worker = new ClosureWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n, this.closureStore, this.config.closure);
         await worker.handle(req, res, this.log);
       } finally {
         this.countRequest(endpointPath, '$closure', Date.now() - start);
@@ -921,9 +964,15 @@ class TXModule {
 
     // Unsupported methods
     for (const resourceType of resourceTypes) {
-      router.all(`/${resourceType}/:id`, (req, res) => {
+      router.all(`/${resourceType}/:id`, (req, res, next) => {
         const start = Date.now();
         try {
+          // /ConceptMap/$closure etc: an operation this server doesn't have at this
+          // level, not a resource that refuses the method
+          if (req.params.id.startsWith('$')) {
+            return res.status(404).json(this.operationOutcome('error', 'not-found',
+              `Unknown operation on this server: ${req.method} ${req.baseUrl}${req.path}`, 'not-found'));
+          }
           if (['PUT', 'POST', 'DELETE', 'PATCH'].includes(req.method)) {
             return res.status(405).json(this.operationOutcome(
               'error',
@@ -931,6 +980,8 @@ class TXModule {
               `Method ${req.method} is not supported`
             ));
           }
+          // anything else falls through to the not-found fallback rather than hanging
+          return next();
         } finally {
           this.countRequest(endpointPath, '$read', Date.now() - start);
         }
@@ -947,6 +998,22 @@ class TXModule {
       }
     });
 
+    // The ECL panel: an expression, an edition, and the expansion it produces. ECL is
+    // written by trial and error, so the page keeps the inputs and puts each result under
+    // them rather than navigating away from what you just typed.
+    router.get('/ecl', async (req, res) => {
+      const start = Date.now();
+      try {
+        let txhtml = new TxHtmlRenderer(new Renderer(req.txOpContext, req.txProvider), this.liquid, this.languages, this.i18n, req.txEndpoint.path);
+        const content = await txhtml.buildEclPage(req);
+        const html = await txhtml.renderPage('ECL', content, req.txEndpoint, req.txStartTime);
+        res.setHeader('Content-Type', 'text/html');
+        res.send(html);
+      } finally {
+        this.countRequest(endpointPath, 'ecl', Date.now() - start);
+      }
+    });
+
     router.get('/problems.html', async (req, res) => {
       const start = Date.now();
       try {
@@ -1066,6 +1133,35 @@ class TXModule {
     };
     router.get('/info/:id', infoHandler);
     router.post('/info/:id', infoHandler);
+
+    // ===== Fallbacks - keep these last =====
+
+    // Nothing above matched. Without this, Express answers with its own HTML
+    // "Cannot POST /r4/$foo" page; a FHIR server must answer with an
+    // OperationOutcome (#100). Goes through the wrapped res.json, so it is
+    // rendered as JSON, XML or HTML to suit the client like everything else.
+    router.use((req, res) => {
+      const start = Date.now();
+      try {
+        const what = req.path.includes('$') ? 'operation' : 'path';
+        res.status(404).json(this.operationOutcome('error', 'not-found',
+          `Unknown ${what} on this server: ${req.method} ${req.baseUrl}${req.path}`, 'not-found'));
+      } finally {
+        this.countRequest(endpointPath, 'unknown', Date.now() - start);
+      }
+    });
+
+    // A handler threw or rejected without answering. Express 5 forwards those here;
+    // its default handler would send an HTML error page.
+    // eslint-disable-next-line no-unused-vars
+    router.use((err, req, res, next) => {
+      this.log.error(err);
+      debugLog(err);
+      if (res.headersSent) {
+        return next(err);
+      }
+      res.status(err.statusCode || 500).json(outcomeFromError(err));
+    });
   }
 
   /**
@@ -1181,6 +1277,10 @@ class TXModule {
     this.timers = [];
     // Clean up any resources if needed
     await this.library.close();
+    if (this.closureStore) {
+      this.closureStore.close();
+      this.closureStore = null;
+    }
     this.log.info('TX module shut down');
   }
 
@@ -1271,6 +1371,14 @@ class TXModule {
     return count;
   }
 
+  // $closure usage for the home page: null when closure isn't turned on
+  closureStats() {
+    if (!this.closureStore) {
+      return null;
+    }
+    return { ...this.closureStore.totals(), retentionDays: this.config.closure.retentionDays || null };
+  }
+
   // High-water marks for the client cache, summed across endpoints.
   maxClientCacheCount() {
     let count = 0;

package/tx/workers/cache-control.js

@@ -13,7 +13,6 @@
 // unknown/expired cache later instead of failing obscurely deep inside a validation.
 //
 
-const crypto = require('crypto');
 const { TerminologyWorker, CACHE_ID_HEADER } = require('./worker');
 const { Parameters } = require('../library/parameters');
 const { Issue, buildOperationOutcome, outcomeFromError } = require('../library/operation-outcome');
@@ -135,7 +134,8 @@ class CacheControlWorker extends TerminologyWorker {
     // Flip this to default-true once all clients send an explicit value.
     const sealed = this.readSealed(params.jsonObj);
 
-    const cacheId = crypto.randomUUID();
+    // "<instanceCode>.<uuid>" when this server has an instance code, else a bare UUID
+    const cacheId = cache.newCacheId();
     cache.set(cacheId, resources, sealed);
 
     return res.status(200).json({