Merge pull request #54 from mcode/communication-forwarding

plarocque4 · web-flow · commit f3f56d514363 · 2026-03-10T15:54:40.000-04:00
add forwarding communincation resources to ehr
diff --git a/src/hooks/hookResources.ts b/src/hooks/hookResources.ts
@@ -11,6 +11,8 @@ import axios from 'axios';
 import { ServicePrefetch } from '../rems-cds-hooks/resources/CdsService';
 import { hydrate } from '../rems-cds-hooks/prefetch/PrefetchHydrator';
 import { getServiceConnection } from './hookProxy';
+import { HookSession } from '../lib/schemas/HookSession';
+import * as env from 'env-var';
 
 export interface CardRule {
   links: Link[];
@@ -96,19 +98,48 @@ export async function handleHook(
   if (contextRequest && contextRequest.resourceType === 'MedicationRequest') {
 
     const forwardData = async (hook: Hook, url: string) => {
-      // remove the auth token before any forwarding occurs
-      delete hook.fhirAuthorization;
-      const options = {
-        method: 'POST',
-        data: hook,
-        timeout: 5000,
-      };
+      // Store original EHR details before modifying the hook
+      const originalFhirServer = hook.fhirServer?.toString();
       
       try {
+        // Create and save HookSession to MongoDB
+        const session = await HookSession.createFromHook(hook);
+        
+        console.log(`\n Created HookSession in MongoDB:`);
+        console.log(`   Session ID: ${session._id}`);
+        console.log(`   Patient: ${session.patientId}`);
+        console.log(`   Hook Instance: ${session.hookInstance}`);
+        console.log(`   EHR FHIR Server: ${session.ehrFhirServer}`);
+        console.log(`   Authorization stored: ${session.ehrAuthorization?.access_token ? 'Yes' : 'No'}`);
+
+        // Get intermediary's FHIR base URL from environment
+        const intermediaryFhirUrl = env.get('INTERMEDIARY_FHIR_URL').asString() || 
+                                    config.server.backendApiBase || 
+                                    `http://localhost:${config.server.port}`;
+        
+        // Override the fhirServer URL to point to intermediary
+        hook.fhirServer = new URL(intermediaryFhirUrl);
+        
+        // Remove authorization before forwarding to REMS Admin
+        delete hook.fhirAuthorization;
+        
+        console.log(`\n Forwarding CDS Hook to REMS Admin:`);
+        console.log(`   Original EHR: ${originalFhirServer}`);
+        console.log(`   Overridden to: ${hook.fhirServer}`);
+        console.log(`   REMS Admin will POST Communications to: ${hook.fhirServer}Communication\n`);
+        
+        const options = {
+          method: 'POST',
+          data: hook,
+          timeout: 5000,
+        };
+        
         const response = await axios(url, options);
         res.json(response.data);
-      } catch (err) {
-        console.log(err);
+        
+      } catch (err: any) {
+        console.error(' Error in forwardData:', err.message);
+        console.error(err.stack);
         res.json({ cards: [] }); // Return fallback response
       }
     };
@@ -126,7 +157,7 @@ export async function handleHook(
           let serviceConnection = await getServiceConnection(drugCode, hook.fhirServer?.toString());
           if (serviceConnection) {
             const url = serviceConnection.to + hook.hook;
-            console.log('rems-admin hook url: ' + url);
+            console.log('REMS Admin hook URL: ' + url);
             if (hook.fhirAuthorization && hook.fhirServer && hook.fhirAuthorization.access_token) {
               hydrate(getFhirResource, hookPrefetch, hook).then(async hydratedPrefetch => {
                 if (hydratedPrefetch) {
@@ -227,15 +258,36 @@ export async function handleHook(
               return;
             }
             uniqueUrls.forEach(async (url: string) => {
-              // remove the auth token before any forwarding occurs
-              delete hook.fhirAuthorization;
-              
-              const options = {
-                method: 'POST',
-                data: hook
-              };
+              // Store original before modification
+              const originalFhirServer = hook.fhirServer?.toString();
               
               try {
+                // Create and save HookSession to MongoDB
+                const session = await HookSession.createFromHook(hook);
+                
+                console.log(`\n Created HookSession in MongoDB (${hookType}):`);
+                console.log(`   Session ID: ${session._id}`);
+                console.log(`   Patient: ${session.patientId}`);
+
+                // Get intermediary's FHIR base URL
+                const intermediaryFhirUrl = env.get('INTERMEDIARY_FHIR_URL').asString() || 
+                                            config.server.backendApiBase || 
+                                            `http://localhost:${config.server.port}`;
+                
+                // Override fhirServer to point to intermediary
+                hook.fhirServer = new URL(intermediaryFhirUrl);
+                
+                // Remove authorization
+                delete hook.fhirAuthorization;
+                
+                console.log(`   Original EHR: ${originalFhirServer}`);
+                console.log(`   Overridden to: ${hook.fhirServer}\n`);
+                
+                const options = {
+                  method: 'POST',
+                  data: hook
+                };
+                
                 const response = await axios(url, options);
                 cards = [...cards, ...response.data.cards];
 
@@ -244,8 +296,8 @@ export async function handleHook(
                   // return the final list of cards
                   res.json({ cards });
                 }
-              } catch (error) {
-                console.error('Error calling REMS Admin:', error);
+              } catch (error: any) {
+                console.error(' Error in processMedications:', error.message);
                 urlCount--;
                 if (urlCount <= 0) {
                   res.json({ cards });
diff --git a/src/lib/schemas/HookSession.ts b/src/lib/schemas/HookSession.ts
@@ -0,0 +1,197 @@
+import mongoose, { Document, Model } from 'mongoose';
+const { Schema } = mongoose;
+
+// Interface for the document
+export interface IHookSession extends Document {
+  hookInstance: string;
+  hookType: 'order-sign' | 'order-select' | 'patient-view' | 'encounter-start';
+  ehrFhirServer: string;
+  ehrAuthorization?: {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    scope: string;
+    subject: string;
+  };
+  patientId: string;
+  encounterId?: string;
+  userId?: string;
+  createdAt: Date;
+  lastAccessedAt: Date;
+  communicationsSent: number;
+  
+  // Instance methods
+  incrementCommunications(): Promise<void>;
+}
+
+// Interface for the model (static methods)
+export interface IHookSessionModel extends Model<IHookSession> {
+  createFromHook(hook: any, ttlHours?: number): Promise<IHookSession>;
+  findActiveSession(patientId: string): Promise<IHookSession | null>;
+  cleanupExpired(): Promise<number>;
+}
+
+const HookSessionSchema = new Schema({
+  // Hook identification
+  hookInstance: {
+    type: String,
+    required: true,
+    index: true,
+    description: 'UUID from the CDS Hook hookInstance field'
+  },
+  
+  hookType: {
+    type: String,
+    required: true,
+    enum: ['order-sign', 'order-select', 'patient-view', 'encounter-start'],
+    description: 'Type of CDS Hook that was called'
+  },
+  
+  // EHR information  
+  ehrFhirServer: {
+    type: String,
+    required: true,
+    description: 'Original EHR FHIR base URL (e.g., https://ehr.example.com/fhir/r4)'
+  },
+  
+  ehrAuthorization: {
+    access_token: {
+      type: String,
+      required: false,
+      description: 'OAuth access token for the EHR'
+    },
+    token_type: {
+      type: String,
+      required: false,
+      default: 'Bearer',
+      description: 'Token type (typically Bearer)'
+    },
+    expires_in: {
+      type: Number,
+      required: false,
+      description: 'Token expiration in seconds'
+    },
+    scope: {
+      type: String,
+      required: false,
+      description: 'OAuth scopes granted'
+    },
+    subject: {
+      type: String,
+      required: false,
+      description: 'Subject/client ID for the token'
+    }
+  },
+  
+  // Patient context
+  patientId: {
+    type: String,
+    required: true,
+    index: true,
+    description: 'Patient ID from hook context'
+  },
+  
+  // Optional encounter context  
+  encounterId: {
+    type: String,
+    required: false,
+    index: true,
+    description: 'Encounter ID from hook context if present'
+  },
+  
+  // Practitioner context
+  userId: {
+    type: String,
+    required: false,
+    description: 'User/Practitioner ID from hook context'
+  },
+  
+  // Timestamps
+  createdAt: {
+    type: Date,
+    default: Date.now,
+    index: true,
+    description: 'When this session was created'
+  },
+  
+  // Tracking
+  lastAccessedAt: {
+    type: Date,
+    default: Date.now,
+    description: 'Last time this session was accessed'
+  },
+  
+  communicationsSent: {
+    type: Number,
+    default: 0,
+    description: 'Number of Communication resources proxied using this session'
+  }
+});
+
+// Index for efficient lookups
+HookSessionSchema.index({ patientId: 1, hookInstance: 1 });
+
+// Static method to create a session from a CDS Hook
+HookSessionSchema.statics.createFromHook = async function(
+  hook: any,
+): Promise<IHookSession> {
+  const now = new Date();
+
+  let ehrFhirServer = hook.fhirServer?.toString();
+  
+  const dockerEhrName = process.env.DOCKERED_EHR_CONTAINER_NAME;
+  console.log('docker ehr env:' + dockerEhrName)
+  if (dockerEhrName) {
+    ehrFhirServer = ehrFhirServer
+      .replace(/localhost/g, dockerEhrName)
+      .replace(/127\.0\.0\.1/g, dockerEhrName);
+  }
+  
+  const session = new this({
+    hookInstance: hook.hookInstance,
+    hookType: hook.hook,
+    ehrFhirServer: ehrFhirServer,
+    ehrAuthorization: hook.fhirAuthorization,
+    patientId: hook.context.patientId,
+    encounterId: hook.context.encounterId,
+    userId: hook.context.userId,
+    createdAt: now,
+    lastAccessedAt: now
+  });
+  
+  await session.save();
+  console.log(` Created HookSession: ${session._id} for patient ${session.patientId}`);
+  return session;
+};
+
+// Static method to find an active session for a patient
+HookSessionSchema.statics.findActiveSession = async function(
+  patientId: string
+): Promise<IHookSession | null> {
+  const now = new Date();
+  
+  // Find the most recent non-expired session for this patient
+  const session = await this.findOne({
+    patientId: patientId,
+  }).sort({ createdAt: -1 }); // Most recent first
+  
+  if (session) {
+    // Update last accessed time
+    session.lastAccessedAt = now;
+    await session.save();
+  }
+  
+  return session;
+};
+
+// Instance method to increment communication counter
+HookSessionSchema.methods.incrementCommunications = async function(): Promise<void> {
+  this.communicationsSent += 1;
+  this.lastAccessedAt = new Date();
+  await this.save();
+};
+
+export const HookSession = mongoose.model<IHookSession, IHookSessionModel>(
+  'HookSession',
+  HookSessionSchema
+);
diff --git a/src/server.ts b/src/server.ts
