evaldoc 1.0.0

package/functions/src/orgs.js

@@ -0,0 +1,127 @@
+/**
+ * Organizations & RBAC — pure logic core for multi-provider clinics.
+ *
+ * This module is intentionally side-effect-free so authorization decisions and
+ * seat math are exhaustively unit-testable. Firestore reads/writes live in the
+ * server endpoints; this file only answers "is this allowed?" and "how many
+ * seats?" questions.
+ *
+ * Roles (highest → lowest authority):
+ *   owner     — billing, delete org, manage everyone, full access
+ *   admin     — manage members (not owner), org settings, view all inboxes
+ *   clinician — own provider profile + own inbox, reply to patients
+ *   staff     — triage/reply in assigned inboxes only (no clinical settings)
+ */
+
+const ROLES = ['owner', 'admin', 'clinician', 'staff'];
+
+// Higher number = more authority. Used for "can actor manage target?" checks.
+const ROLE_RANK = {
+  owner: 4,
+  admin: 3,
+  clinician: 2,
+  staff: 1
+};
+
+// action -> roles allowed to perform it
+const PERMISSIONS = {
+  'billing.manage': ['owner'],
+  'org.delete': ['owner'],
+  'members.invite': ['owner', 'admin'],
+  'members.remove': ['owner', 'admin'],
+  'members.role': ['owner', 'admin'],
+  'inbox.viewAll': ['owner', 'admin'],
+  'settings.edit': ['owner', 'admin'],
+  'provider.own': ['owner', 'admin', 'clinician'],
+  'inbox.viewOwn': ['owner', 'admin', 'clinician', 'staff'],
+  'inbox.reply': ['owner', 'admin', 'clinician', 'staff']
+};
+
+// Seat caps per plan. null = unlimited.
+const SEAT_LIMITS = {
+  free: 1,
+  pro: 1,
+  clinic: 5,
+  enterprise: null
+};
+
+/** Is `role` allowed to perform `action`? */
+function can(role, action) {
+  const allowed = PERMISSIONS[action];
+  if (!allowed) return false;
+  return allowed.includes(role);
+}
+
+/** Is `role` a recognized role? */
+function isValidRole(role) {
+  return ROLES.includes(role);
+}
+
+/**
+ * Can an actor with `actorRole` manage (change role / remove) a member with
+ * `targetRole`? Only owner/admin can manage at all; an actor can never manage
+ * someone of equal-or-higher authority (so admins can't touch owners or each
+ * other, and owners can manage anyone below them).
+ */
+function canManageMember(actorRole, targetRole) {
+  if (!isValidRole(actorRole) || !isValidRole(targetRole)) return false;
+  if (actorRole !== 'owner' && actorRole !== 'admin') return false;
+  return ROLE_RANK[actorRole] > ROLE_RANK[targetRole];
+}
+
+/** Highest role an actor is allowed to assign when inviting/promoting. */
+function canAssignRole(actorRole, newRole) {
+  if (!isValidRole(actorRole) || !isValidRole(newRole)) return false;
+  if (actorRole !== 'owner' && actorRole !== 'admin') return false;
+  // Nobody can mint another owner via invite/role-change; ownership transfers
+  // are a separate, explicit flow. Admins can't create admins.
+  if (newRole === 'owner') return false;
+  if (actorRole === 'admin' && newRole === 'admin') return false;
+  return ROLE_RANK[actorRole] >= ROLE_RANK[newRole];
+}
+
+/** Seat cap for a plan (null = unlimited). */
+function seatLimitForPlan(plan) {
+  return Object.prototype.hasOwnProperty.call(SEAT_LIMITS, plan) ? SEAT_LIMITS[plan] : 1;
+}
+
+/** Remaining seats given a plan and current active member count. */
+function seatsRemaining(plan, activeMemberCount) {
+  const limit = seatLimitForPlan(plan);
+  if (limit === null) return Infinity;
+  return Math.max(0, limit - activeMemberCount);
+}
+
+/** Is there room for one more member? */
+function hasSeatAvailable(plan, activeMemberCount) {
+  return seatsRemaining(plan, activeMemberCount) > 0;
+}
+
+/** Default org shape for a brand-new personal org (one owner, free plan). */
+function personalOrgDefaults({ orgId, ownerUid, name }) {
+  return {
+    id: orgId,
+    ownerUid,
+    name: name || 'My Practice',
+    type: 'personal',
+    plan: 'free',
+    seats: 1,
+    createdAt: null, // stamped by caller with serverTimestamp
+    updatedAt: null
+  };
+}
+
+module.exports = {
+  ROLES,
+  ROLE_RANK,
+  PERMISSIONS,
+  SEAT_LIMITS,
+  can,
+  isValidRole,
+  canManageMember,
+  canAssignRole,
+  seatLimitForPlan,
+  seatsRemaining,
+  hasSeatAvailable,
+  personalOrgDefaults
+};

package/functions/src/patient-api.js

@@ -0,0 +1,545 @@
+const admin = require("firebase-admin");
+const { jsonResponse, readBody, nowTimestamp } = require("./utils");
+const { generateResponse } = require("./llm");
+const { analyzeInput, analyzeOutput, escalationMessage } = require("./safety");
+const { TOPICS, TOPIC_KEYS } = require("./topics");
+
+// Phase 2 imports
+const { classifyConversation } = require("./triage");
+const { generateDoctorDraft } = require("./drafts");
+const { notifyEscalation, notifyDraftReady } = require("./notifications");
+const { retrieveRelevantExamples } = require("./feedback");
+const { checkPaymentAccess } = require("./payment");
+
+/**
+ * Get or create patient profile
+ */
+async function getPatient(uid) {
+  const db = admin.firestore();
+  const patientDoc = await db.collection("patients").doc(uid).get();
+
+  if (!patientDoc.exists) {
+    return null;
+  }
+
+  return { id: patientDoc.id, ...patientDoc.data() };
+}
+
+/**
+ * Create patient profile
+ */
+async function createPatient(uid, data) {
+  const db = admin.firestore();
+  const patientRef = db.collection("patients").doc(uid);
+
+  const patientData = {
+    email: data.email,
+    displayName: data.displayName || null,
+    photoURL: data.photoURL || null,
+    doctorIds: [],
+    notificationsEnabled: true,
+    fcmToken: null,
+    createdAt: nowTimestamp(admin),
+    lastActiveAt: nowTimestamp(admin)
+  };
+
+  await patientRef.set(patientData);
+
+  return { id: uid, ...patientData };
+}
+
+/**
+ * Find doctor by handle
+ */
+async function findDoctorByHandle(handle) {
+  const db = admin.firestore();
+  const snapshot = await db
+    .collection("providers")
+    .where("handle", "==", handle)
+    .where("status", "==", "published")
+    .limit(1)
+    .get();
+
+  if (snapshot.empty) return null;
+  return { id: snapshot.docs[0].id, ...snapshot.docs[0].data() };
+}
+
+/**
+ * Get thread ID from patient and doctor IDs
+ */
+function getThreadId(patientId, doctorId) {
+  return `thread_${patientId}_${doctorId}`;
+}
+
+/**
+ * Get or create thread between patient and doctor
+ */
+async function getOrCreateThread(patientId, doctorId, patientData, doctorData) {
+  const db = admin.firestore();
+  const threadId = getThreadId(patientId, doctorId);
+  const threadRef = db.collection("threads").doc(threadId);
+  const threadDoc = await threadRef.get();
+
+  if (threadDoc.exists) {
+    return { id: threadDoc.id, ...threadDoc.data() };
+  }
+
+  // Create new thread with Phase 2 fields
+  const threadData = {
+    patientId,
+    patientEmail: patientData.email,
+    patientName: patientData.displayName || null,
+    patientPhoto: patientData.photoURL || null,
+    patientSource: "authenticated",
+
+    doctorId,
+    doctorName: doctorData.displayName,
+    doctorHandle: doctorData.handle,
+
+    status: "active",
+    isEscalated: false,
+    doctorOverride: false,
+
+    lastMessageAt: nowTimestamp(admin),
+    lastMessageText: null,
+    lastMessageRole: null,
+
+    unreadByPatient: 0,
+    unreadByDoctor: 0,
+    messageCount: 0,
+
+    currentTopic: null,
+
+    isPaid: false,
+    paymentId: null,
+
+    // Phase 2 fields
+    triageCategory: null,
+    triageConfidence: null,
+    triageReason: null,
+    triageUpdatedAt: null,
+
+    aiDraftResponse: null,
+    aiDraftGeneratedAt: null,
+    aiDraftStatus: null,
+
+    lastDoctorNotifiedAt: null,
+    doctorResponseFedBack: false,
+    feedbackProcessedAt: null,
+
+    createdAt: nowTimestamp(admin),
+    updatedAt: nowTimestamp(admin)
+  };
+
+  await threadRef.set(threadData);
+
+  // Add doctor to patient's doctorIds
+  await db.collection("patients").doc(patientId).update({
+    doctorIds: admin.firestore.FieldValue.arrayUnion(doctorId),
+    lastActiveAt: nowTimestamp(admin)
+  });
+
+  return { id: threadId, ...threadData };
+}
+
+/**
+ * Add message to thread
+ */
+async function addMessageToThread(threadId, role, message, metadata = {}) {
+  const db = admin.firestore();
+  const threadRef = db.collection("threads").doc(threadId);
+  const messagesRef = threadRef.collection("messages");
+
+  const messageData = {
+    threadId,
+    role, // patient, doctor, ai
+    message,
+    content: message, // dual-field for compatibility
+
+    isDoctorManual: metadata.isDoctorManual || false,
+    doctorUserId: metadata.doctorUserId || null,
+
+    readByPatient: role === "patient",
+    readByDoctor: false,
+
+    wasFiltered: metadata.wasFiltered || false,
+    isAiGenerated: metadata.isAiGenerated || false,
+
+    createdAt: nowTimestamp(admin)
+  };
+
+  const messageRef = await messagesRef.add(messageData);
+
+  // Update thread metadata
+  const updateData = {
+    lastMessageAt: nowTimestamp(admin),
+    lastMessageText: message.substring(0, 100),
+    lastMessageRole: role,
+    messageCount: admin.firestore.FieldValue.increment(1),
+    updatedAt: nowTimestamp(admin)
+  };
+
+  if (role === "patient") {
+    updateData.unreadByDoctor = admin.firestore.FieldValue.increment(1);
+  } else {
+    updateData.unreadByPatient = admin.firestore.FieldValue.increment(1);
+  }
+
+  await threadRef.update(updateData);
+
+  return { id: messageRef.id, ...messageData };
+}
+
+/**
+ * Get messages from thread
+ */
+async function getThreadMessages(threadId, limit = 50) {
+  const db = admin.firestore();
+  const messagesSnapshot = await db
+    .collection("threads")
+    .doc(threadId)
+    .collection("messages")
+    .orderBy("createdAt", "asc")
+    .limit(limit)
+    .get();
+
+  return messagesSnapshot.docs.map(doc => ({
+    id: doc.id,
+    ...doc.data()
+  }));
+}
+
+/**
+ * Mark messages as read
+ */
+async function markThreadAsRead(threadId, role) {
+  const db = admin.firestore();
+  const threadRef = db.collection("threads").doc(threadId);
+
+  if (role === "patient") {
+    await threadRef.update({
+      unreadByPatient: 0
+    });
+  } else if (role === "doctor") {
+    await threadRef.update({
+      unreadByDoctor: 0
+    });
+  }
+}
+
+/**
+ * Handle patient API routes
+ */
+async function handlePatientAPI(req, res, user) {
+  const db = admin.firestore();
+
+  // GET /api/patient/me - Get patient profile
+  if (req.method === "GET" && (req.path === "/patient/me" || req.path === "/me")) {
+    const patient = await getPatient(user.uid);
+    if (!patient) {
+      jsonResponse(res, 404, { error: "Patient not found" });
+      return;
+    }
+    jsonResponse(res, 200, patient);
+    return;
+  }
+
+  // POST /api/patient/create - Create patient profile
+  if (req.method === "POST" && req.path === "/patient/create") {
+    const body = readBody(req) || {};
+    const existing = await getPatient(user.uid);
+
+    if (existing) {
+      jsonResponse(res, 200, existing);
+      return;
+    }
+
+    const patient = await createPatient(user.uid, {
+      email: user.email || body.email,
+      displayName: body.displayName || user.name,
+      photoURL: body.photoURL
+    });
+
+    jsonResponse(res, 200, patient);
+    return;
+  }
+
+  // POST /api/patient/thread - Get or create thread with doctor
+  if (req.method === "POST" && req.path === "/patient/thread") {
+    const body = readBody(req) || {};
+    const doctorHandle = body.doctorHandle;
+
+    if (!doctorHandle) {
+      jsonResponse(res, 400, { error: "doctorHandle is required" });
+      return;
+    }
+
+    const patient = await getPatient(user.uid);
+    if (!patient) {
+      jsonResponse(res, 404, { error: "Patient profile not found" });
+      return;
+    }
+
+    const doctor = await findDoctorByHandle(doctorHandle);
+    if (!doctor) {
+      jsonResponse(res, 404, { error: "Doctor not found" });
+      return;
+    }
+
+    const thread = await getOrCreateThread(user.uid, doctor.id, patient, doctor);
+
+    jsonResponse(res, 200, { thread });
+    return;
+  }
+
+  // GET /api/patient/threads - Get all patient threads
+  if (req.method === "GET" && req.path === "/patient/threads") {
+    const threadsSnapshot = await db
+      .collection("threads")
+      .where("patientId", "==", user.uid)
+      .orderBy("lastMessageAt", "desc")
+      .limit(50)
+      .get();
+
+    const threads = threadsSnapshot.docs.map(doc => ({
+      id: doc.id,
+      ...doc.data()
+    }));
+
+    jsonResponse(res, 200, { threads });
+    return;
+  }
+
+  // GET /api/patient/thread/:threadId/messages - Get messages
+  if (req.method === "GET" && req.path.match(/^\/patient\/thread\/[^\/]+\/messages$/)) {
+    const threadId = req.path.split("/")[3];
+
+    // Verify patient owns this thread
+    const threadDoc = await db.collection("threads").doc(threadId).get();
+    if (!threadDoc.exists || threadDoc.data().patientId !== user.uid) {
+      jsonResponse(res, 404, { error: "Thread not found" });
+      return;
+    }
+
+    const messages = await getThreadMessages(threadId);
+    await markThreadAsRead(threadId, "patient");
+
+    jsonResponse(res, 200, { messages });
+    return;
+  }
+
+  // POST /api/patient/message - Send message to doctor
+  if (req.method === "POST" && req.path === "/patient/message") {
+    const body = readBody(req) || {};
+    const { threadId, message, topic } = body;
+
+    if (!threadId || !message) {
+      jsonResponse(res, 400, { error: "threadId and message are required" });
+      return;
+    }
+
+    // Verify patient owns this thread
+    const threadDoc = await db.collection("threads").doc(threadId).get();
+    if (!threadDoc.exists || threadDoc.data().patientId !== user.uid) {
+      jsonResponse(res, 404, { error: "Thread not found" });
+      return;
+    }
+
+    const thread = threadDoc.data();
+    const doctorDoc = await db.collection("providers").doc(thread.doctorId).get();
+    const doctor = doctorDoc.data();
+
+    // Payment access check
+    if (doctor.paymentEnabled && doctor.pricingModel !== 'free') {
+      const accessResult = await checkPaymentAccess({
+        providerId: thread.doctorId,
+        patientId: user.uid
+      });
+
+      if (!accessResult.hasAccess) {
+        jsonResponse(res, 402, {
+          error: "Payment required",
+          paymentRequired: true,
+          paymentConfig: {
+            pricingModel: doctor.pricingModel,
+            subscriptionPrice: doctor.subscriptionPrice || 0,
+            perChatPrice: doctor.perChatPrice || 0,
+            currency: doctor.currency || 'usd',
+            handle: doctor.handle,
+            stripePublishableKey: process.env.STRIPE_PUBLISHABLE_KEY
+          }
+        });
+        return;
+      }
+    }
+
+    // Safety check on input
+    const topicKey = topic || thread.currentTopic || "general_health_info";
+    const topicConfigForSafety = TOPICS[topicKey] || TOPICS[TOPIC_KEYS[0]];
+    const inputSafety = await analyzeInput(message, topicConfigForSafety);
+    if (inputSafety.blocked) {
+      jsonResponse(res, 400, { error: "Message blocked by safety filter" });
+      return;
+    }
+
+    // Save patient message
+    await addMessageToThread(threadId, "patient", message);
+
+    // Update thread topic if provided
+    if (topic) {
+      await threadDoc.ref.update({ currentTopic: topic });
+    }
+
+    // Generate AI response (unless doctor has override enabled)
+    let aiResponse = "Thank you for your message. The doctor will respond soon.";
+    let isEscalated = false;
+
+    if (!thread.doctorOverride) {
+      const threadMessages = await getThreadMessages(threadId, 10);
+      const conversationHistory = threadMessages.map(msg => ({
+        role: msg.role === "patient" ? "user" : "assistant",
+        content: msg.message
+      }));
+
+      const aiTopicKey = topic || thread.currentTopic || "general_health_info";
+      const topicConfig = TOPICS[aiTopicKey] || TOPICS[TOPIC_KEYS[0]];
+
+      // Retrieve doctor examples for personalized responses (Component 5)
+      let doctorExamples = [];
+      try {
+        doctorExamples = await retrieveRelevantExamples({
+          doctorId: thread.doctorId,
+          topic: topicKey,
+          limit: 3
+        });
+      } catch (err) {
+        console.error("[Patient API] Failed to retrieve doctor examples:", err.message);
+      }
+
+      aiResponse = await generateResponse({
+        topicConfig,
+        message,
+        provider: doctor,
+        conversationHistory,
+        doctorExamples
+      });
+
+      // Safety check on output
+      const outputSafety = analyzeOutput(aiResponse, topicConfig);
+      if (outputSafety.blocked) {
+        aiResponse = "I can't help with that. For medical advice, please contact a licensed clinician.";
+      }
+      if (inputSafety.escalated) {
+        isEscalated = true;
+        await threadDoc.ref.update({ isEscalated: true });
+      }
+    }
+
+    // Save AI response
+    await addMessageToThread(threadId, "ai", aiResponse, { isAiGenerated: true });
+
+    // Fire-and-forget: Triage classification + draft generation + notifications (Phase 2)
+    const allMessages = [
+      ...(await getThreadMessages(threadId, 10)).map(m => ({
+        role: m.role === "patient" ? "user" : "assistant",
+        content: m.message || m.content
+      }))
+    ];
+
+    classifyConversation({ messages: allMessages, isEscalated })
+      .then(async (triage) => {
+        console.log(`[Triage] Thread ${threadId}: ${triage.category} (${triage.confidence})`);
+        const triageUpdate = {
+          triageCategory: triage.category,
+          triageConfidence: triage.confidence,
+          triageReason: triage.reason,
+          triageUpdatedAt: admin.firestore.FieldValue.serverTimestamp()
+        };
+        await threadDoc.ref.update(triageUpdate);
+
+        // Generate draft for urgent/needs_review (Component 3)
+        if (triage.category === "urgent" || triage.category === "needs_review") {
+          try {
+            let draftExamples = [];
+            try {
+              draftExamples = await retrieveRelevantExamples({
+                doctorId: thread.doctorId,
+                topic: topic || thread.currentTopic,
+                limit: 3
+              });
+            } catch (e) { /* ignore */ }
+
+            const draftTopicKey = topic || thread.currentTopic || "general_health_info";
+            const draftResult = await generateDoctorDraft({
+              messages: allMessages,
+              provider: doctor,
+              topic: draftTopicKey,
+              triageCategory: triage.category,
+              doctorExamples: draftExamples
+            });
+
+            if (draftResult) {
+              await threadDoc.ref.update({
+                aiDraftResponse: draftResult.draft,
+                aiDraftGeneratedAt: admin.firestore.FieldValue.serverTimestamp(),
+                aiDraftStatus: "pending"
+              });
+
+              notifyDraftReady({
+                doctorId: thread.doctorId,
+                threadId,
+                patientName: thread.patientName
+              }).catch(err => console.error("[Notifications] Draft notify failed:", err.message));
+            }
+          } catch (draftErr) {
+            console.error("[Drafts] Generation failed:", draftErr.message);
+          }
+
+          // Notify escalation (Component 4)
+          if (triage.category === "urgent") {
+            notifyEscalation({
+              doctorId: thread.doctorId,
+              threadId,
+              patientName: thread.patientName,
+              reason: triage.reason
+            }).catch(err => console.error("[Notifications] Escalation notify failed:", err.message));
+          }
+        }
+      })
+      .catch(err => console.error("[Triage] Classification failed:", err.message));
+
+    jsonResponse(res, 200, {
+      response: aiResponse,
+      escalation: isEscalated
+    });
+    return;
+  }
+
+  // POST /api/patient/thread/:threadId/read - Mark as read
+  if (req.method === "POST" && req.path.match(/^\/patient\/thread\/[^\/]+\/read$/)) {
+    const threadId = req.path.split("/")[3];
+
+    // Verify patient owns this thread
+    const threadDoc = await db.collection("threads").doc(threadId).get();
+    if (!threadDoc.exists || threadDoc.data().patientId !== user.uid) {
+      jsonResponse(res, 404, { error: "Thread not found" });
+      return;
+    }
+
+    await markThreadAsRead(threadId, "patient");
+    jsonResponse(res, 200, { success: true });
+    return;
+  }
+
+  jsonResponse(res, 404, { error: "Not found" });
+}
+
+module.exports = {
+  handlePatientAPI,
+  getPatient,
+  createPatient,
+  getOrCreateThread,
+  addMessageToThread,
+  getThreadMessages,
+  markThreadAsRead
+};