@primocaredentgroup/prescriptions-component 0.1.5 → 0.1.7

package/dist/convex/mutations/prescriptions.js

@@ -1,8 +1,8 @@
 import { mutation } from "../_generated/server";
 import { ConvexError, v } from "convex/values";
 import { computeClinicalHash, generateIdempotencyKey } from "../lib/utils";
-import { validateClinicalData, canUserPerformAction, validateDigitalRequirements } from "../lib/validation";
-import { requireIdentityUser, assertPrescriptionAccess } from "../lib/auth";
+import { validateClinicalData, validateDigitalRequirements } from "../lib/validation";
+import { requireIdentityOrThrow } from "../lib/auth";
 import { assertDynamicRequiredComplete } from "../lib/dynamicFieldsStrict";
 import { normalizeClinicalDraftInput } from "../lib/clinicalNormalize";
 // ============================================
@@ -30,30 +30,11 @@ const calendarDataArgsValidator = v.object({
     nextAppointmentPhaseId: v.optional(v.string()),
     nextAppointmentPhaseName: v.optional(v.string()),
 });
-async function requireAuthenticatedUserOrThrow(ctx) {
-    try {
-        return await requireIdentityUser(ctx);
-    }
-    catch (error) {
-        if (error instanceof ConvexError) {
-            throw error;
-        }
-        throw new ConvexError({
-            code: "UNAUTHORIZED",
-            message: "Accesso non autorizzato",
-        });
-    }
-}
-function assertPrescriptionAccessOrThrow(user, prescription) {
-    try {
-        assertPrescriptionAccess(user, prescription);
-    }
-    catch (error) {
-        throw new ConvexError({
-            code: "FORBIDDEN",
-            message: error instanceof Error ? error.message : "Forbidden",
-        });
-    }
+function getActorFromIdentity(identity) {
+    return {
+        actorUserId: identity.subject,
+        actorRole: "HOST",
+    };
 }
 // ============================================
 // PRESCRIPTION MUTATIONS
@@ -74,7 +55,8 @@ export const createDraft = mutation({
     },
     handler: async (ctx, args) => {
         const now = Date.now();
-        const user = await requireAuthenticatedUserOrThrow(ctx);
+        const identity = await requireIdentityOrThrow(ctx);
+        const actor = getActorFromIdentity(identity);
         // 1. VINCOLO: Verifica unicità pdcItemId
         const existingPrescriptions = await ctx.db
             .query("prescriptions")
@@ -85,23 +67,7 @@ export const createDraft = mutation({
         if (activePrescription) {
             throw new Error(`Esiste già una prescrizione attiva per questo PDC Item (ID: ${activePrescription._id})`);
         }
-        // 2. Verifica ruolo + ownership clinic
-        const canCreate = user.role === "SECRETARY" ||
-            user.adminRole === "admin" ||
-            user.adminRole === "superadmin";
-        if (!canCreate) {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: "Utente non autorizzato a creare prescrizioni",
-            });
-        }
-        if (user.clinicId !== args.clinicId && user.adminRole !== "admin" && user.adminRole !== "superadmin") {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: "Clinic non autorizzata per l'utente autenticato",
-            });
-        }
-        // 3. Carica flow attivo
+        // 2. Carica flow attivo
         const flow = await ctx.db
             .query("flows")
             .withIndex("by_flowKey_status", (q) => q.eq("flowKey", args.flowKey).eq("status", "ACTIVE"))
@@ -125,7 +91,7 @@ export const createDraft = mutation({
             flowKey: args.flowKey,
             flowVersion: flow.version,
             status: "DRAFT",
-            createdByUserId: user._id,
+            createdByUserId: actor.actorUserId,
             createdAt: now,
             updatedAt: now,
             coreRefs: {},
@@ -180,18 +146,142 @@ export const createDraft = mutation({
             operationalDataId: 0, // Will be backfilled
             prescriptionRef: prescriptionId,
         });
-        // 9. Audit
+        // 8. Audit
         await ctx.db.insert("auditEvents", {
             auditEventId: 0, // Will be backfilled
             prescriptionRef: prescriptionId,
             at: now,
-            actorUserId: user._id,
-            actorRole: user.role,
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
             type: "PRESCRIPTION_CREATED",
             payload: {
                 pdcItemId: args.pdcItemId,
                 flowKey: args.flowKey,
                 flowVersion: flow.version,
+                actorEmail: identity.email,
+            },
+        });
+        return { prescriptionId, revisionId };
+    },
+});
+/**
+ * Crea una bozza di prescrizione quando chiamata dal backend (es. da appointments dell'host).
+ * NON richiede identity: ctx.runMutation da un'altra mutation non propaga il token utente.
+ * Usa actor HOST_BACKEND per audit.
+ */
+export const createDraftFromBackend = mutation({
+    args: {
+        clinicId: v.string(),
+        doctorId: v.string(),
+        patientId: v.string(),
+        pdcItemId: v.string(),
+        listinoId: v.string(),
+        flowKey: v.string(),
+    },
+    handler: async (ctx, args) => {
+        const now = Date.now();
+        const actor = { actorUserId: "HOST_BACKEND", actorRole: "HOST" };
+        // 1. VINCOLO: Verifica unicità pdcItemId
+        const existingPrescriptions = await ctx.db
+            .query("prescriptions")
+            .withIndex("by_pdcItemId", (q) => q.eq("pdcItemId", args.pdcItemId))
+            .collect();
+        const activeStatuses = ["DRAFT", "PENDING_DOCTOR", "SIGNED", "SYNCED", "ERROR"];
+        const activePrescription = existingPrescriptions.find((p) => activeStatuses.includes(p.status));
+        if (activePrescription) {
+            throw new Error(`Esiste già una prescrizione attiva per questo PDC Item (ID: ${activePrescription._id})`);
+        }
+        // 2. Carica flow attivo
+        const flow = await ctx.db
+            .query("flows")
+            .withIndex("by_flowKey_status", (q) => q.eq("flowKey", args.flowKey).eq("status", "ACTIVE"))
+            .first();
+        if (!flow) {
+            throw new Error(`Flow "${args.flowKey}" non trovato o non attivo`);
+        }
+        // 3. Carica ruleset attivo (se presente)
+        const activeRuleset = await ctx.db
+            .query("activeRulesets")
+            .withIndex("by_key", (q) => q.eq("key", "global"))
+            .first();
+        // 4. Crea prescrizione
+        const prescriptionId = await ctx.db.insert("prescriptions", {
+            prescriptionId: 0,
+            clinicId: args.clinicId,
+            doctorId: args.doctorId,
+            patientId: args.patientId,
+            pdcItemId: args.pdcItemId,
+            listinoId: args.listinoId,
+            flowKey: args.flowKey,
+            flowVersion: flow.version,
+            status: "DRAFT",
+            createdByUserId: actor.actorUserId,
+            createdAt: now,
+            updatedAt: now,
+            coreRefs: {},
+            labRefs: {},
+            rulesetVersionId: activeRuleset?.versionId,
+            valuesByFieldId: "{}",
+        });
+        // 5. Crea revisione clinica iniziale (vuota)
+        const initialClinicalData = {
+            patient: { corePatientId: args.patientId },
+            clinic: { coreClinicId: args.clinicId },
+            doctor: { coreDoctorId: args.doctorId },
+            prostheticService: {
+                pdcItemId: args.pdcItemId,
+                listinoId: args.listinoId,
+                serviceCode: "",
+                serviceLabel: "",
+            },
+        };
+        const clinicalHash = await computeClinicalHash(initialClinicalData);
+        const revisionId = await ctx.db.insert("clinicalRevisions", {
+            clinicalRevisionId: 0,
+            prescriptionRef: prescriptionId,
+            revisionNumber: 1,
+            clinicalData: initialClinicalData,
+            clinicalHash,
+            signature: null,
+            frozen: false,
+            createdAt: now,
+        });
+        // 6. Aggiorna prescrizione con riferimento alla revisione
+        await ctx.db.patch(prescriptionId, {
+            latestClinicalRevisionId: revisionId,
+        });
+        // 7. Inizializza phase instances
+        for (let i = 0; i < flow.definition.phases.length; i++) {
+            const phase = flow.definition.phases[i];
+            await ctx.db.insert("phaseInstances", {
+                phaseInstanceId: 0,
+                prescriptionRef: prescriptionId,
+                phaseTypeKey: phase.phaseTypeKey,
+                ordinal: i,
+                iteration: 1,
+                status: "NOT_STARTED",
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+        // 8. Crea operational data
+        await ctx.db.insert("operationalData", {
+            operationalDataId: 0,
+            prescriptionRef: prescriptionId,
+        });
+        // 9. Audit
+        await ctx.db.insert("auditEvents", {
+            auditEventId: 0,
+            prescriptionRef: prescriptionId,
+            at: now,
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
+            type: "PRESCRIPTION_CREATED",
+            payload: {
+                pdcItemId: args.pdcItemId,
+                flowKey: args.flowKey,
+                flowVersion: flow.version,
+                source: "createDraftFromBackend",
             },
         });
         return { prescriptionId, revisionId };
@@ -226,43 +316,17 @@ export const updateClinicalDraft = mutation({
     },
     handler: async (ctx, args) => {
         const now = Date.now();
-        // 1. Auth identity + prescrizione
-        let user;
-        try {
-            user = await requireIdentityUser(ctx);
-        }
-        catch (error) {
-            if (error instanceof ConvexError) {
-                throw error;
-            }
-            throw new ConvexError({
-                code: "UNAUTHORIZED",
-                message: "Accesso non autorizzato",
-            });
-        }
+        const identity = await requireIdentityOrThrow(ctx);
+        const actor = getActorFromIdentity(identity);
         const prescription = await ctx.db.get(args.prescriptionId);
         if (!prescription) {
             throw new Error("Prescrizione non trovata");
         }
-        try {
-            assertPrescriptionAccess(user, prescription);
-        }
-        catch (error) {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: error instanceof Error ? error.message : "Forbidden",
-            });
-        }
         // 2. Verifica stato
         if (!["DRAFT", "PENDING_DOCTOR"].includes(prescription.status)) {
             throw new Error(`Non è possibile modificare una prescrizione in stato ${prescription.status}`);
         }
-        // 3. Verifica permessi azione
-        const permission = canUserPerformAction(user.role, "updateDraft", prescription.status);
-        if (!permission.allowed) {
-            throw new Error(permission.reason);
-        }
-        // 4. Carica revisione corrente
+        // 3. Carica revisione corrente
         if (!prescription.latestClinicalRevisionId) {
             throw new Error("Nessuna revisione clinica trovata");
         }
@@ -335,19 +399,20 @@ export const updateClinicalDraft = mutation({
         if (normalizedPatch.lineaMargine !== undefined) {
             changedKeys.push("lineaMargine");
         }
-        // 10. Audit
+        // 9. Audit
         await ctx.db.insert("auditEvents", {
             auditEventId: 0, // Will be backfilled
             prescriptionRef: args.prescriptionId,
             at: now,
-            actorUserId: user._id,
-            actorRole: user.role,
-            type: user.role === "DOCTOR" ? "DOCTOR_UPDATED_DRAFT" : "CLINICAL_DRAFT_UPDATED",
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
+            type: "CLINICAL_DRAFT_UPDATED",
             payload: {
                 changes: normalizedPatch,
                 changedKeys,
                 clinicalValidationErrorsCount: clinicalValidationErrors.length,
                 newHash,
+                actorEmail: identity.email,
             },
         });
         return { ok: true, success: true, clinicalHash: newHash, clinicalValidationErrors };
@@ -363,22 +428,18 @@ export const submitToDoctor = mutation({
     },
     handler: async (ctx, args) => {
         const now = Date.now();
-        const user = await requireAuthenticatedUserOrThrow(ctx);
+        const identity = await requireIdentityOrThrow(ctx);
+        const actor = getActorFromIdentity(identity);
         // 1. Carica prescrizione
         const prescription = await ctx.db.get(args.prescriptionId);
         if (!prescription) {
             throw new Error("Prescrizione non trovata");
         }
-        assertPrescriptionAccessOrThrow(user, prescription);
         // 2. Verifica stato
         if (prescription.status !== "DRAFT") {
             throw new Error(`Non è possibile inviare una prescrizione in stato ${prescription.status}`);
         }
-        const permission = canUserPerformAction(user.role, "submit", prescription.status);
-        if (!permission.allowed) {
-            throw new Error(permission.reason);
-        }
-        // 4. Valida requisiti per prescrizioni digitali
+        // 3. Valida requisiti per prescrizioni digitali
         const digitalErrors = validateDigitalRequirements(prescription.prescriptionType, prescription.digitalAssets);
         if (digitalErrors.length > 0) {
             throw new Error(digitalErrors.map(e => e.message).join("; "));
@@ -388,15 +449,15 @@ export const submitToDoctor = mutation({
             status: "PENDING_DOCTOR",
             updatedAt: now,
         });
-        // 6. Audit
+        // 5. Audit
         await ctx.db.insert("auditEvents", {
             auditEventId: 0, // Will be backfilled
             prescriptionRef: args.prescriptionId,
             at: now,
-            actorUserId: user._id,
-            actorRole: user.role,
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
             type: "SUBMITTED_TO_DOCTOR",
-            payload: {},
+            payload: { actorEmail: identity.email },
         });
         return { success: true };
     },
@@ -412,24 +473,18 @@ export const signPrescription = mutation({
     },
     handler: async (ctx, args) => {
         const now = Date.now();
-        const user = await requireAuthenticatedUserOrThrow(ctx);
+        const identity = await requireIdentityOrThrow(ctx);
+        const actor = getActorFromIdentity(identity);
         // 1. Carica prescrizione
         const prescription = await ctx.db.get(args.prescriptionId);
         if (!prescription) {
             throw new Error("Prescrizione non trovata");
         }
-        assertPrescriptionAccessOrThrow(user, prescription);
         // 2. Verifica stato
         if (prescription.status !== "PENDING_DOCTOR") {
             throw new Error(`Non è possibile firmare una prescrizione in stato ${prescription.status}`);
         }
-        if (user.role !== "DOCTOR") {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: "Solo i medici possono firmare le prescrizioni",
-            });
-        }
-        // 4. Carica flow e revisione
+        // 3. Carica flow e revisione
         const flow = await ctx.db
             .query("flows")
             .withIndex("by_flowKey_version", (q) => q.eq("flowKey", prescription.flowKey).eq("version", prescription.flowVersion))
@@ -460,7 +515,7 @@ export const signPrescription = mutation({
         // 7. Crea firma
         const signature = {
             signedAt: now,
-            signedByDoctorId: user.coreDoctorId ?? user._id,
+            signedByDoctorId: prescription.doctorId,
             signatureType: "weak-digital",
             signaturePayload: args.signaturePayload,
             clinicalHash: finalHash,
@@ -515,18 +570,19 @@ export const signPrescription = mutation({
             status: "SIGNED",
             updatedAt: now,
         });
-        // 11. Audit
+        // 10. Audit
         await ctx.db.insert("auditEvents", {
             auditEventId: 0, // Will be backfilled
             prescriptionRef: args.prescriptionId,
             at: now,
-            actorUserId: user._id,
-            actorRole: "DOCTOR",
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
             type: "PRESCRIPTION_SIGNED",
             payload: {
                 clinicalHash: finalHash,
                 signedAt: now,
                 syncJobIds,
+                actorEmail: identity.email,
             },
         });
         return {
@@ -547,57 +603,17 @@ export const sendToLab = mutation({
     },
     handler: async (ctx, args) => {
         const now = Date.now();
-        // 1. Auth identity + prescrizione
-        let user;
-        try {
-            user = await requireIdentityUser(ctx);
-        }
-        catch (error) {
-            if (error instanceof ConvexError) {
-                throw error;
-            }
-            throw new ConvexError({
-                code: "UNAUTHORIZED",
-                message: "Accesso non autorizzato",
-            });
-        }
+        const identity = await requireIdentityOrThrow(ctx);
+        const actor = getActorFromIdentity(identity);
         const prescription = await ctx.db.get(args.prescriptionId);
         if (!prescription) {
             throw new Error("Prescrizione non trovata");
         }
-        try {
-            assertPrescriptionAccess(user, prescription);
-        }
-        catch (error) {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: error instanceof Error ? error.message : "Forbidden",
-            });
-        }
         // 2. Verifica stato (deve essere DRAFT o PENDING_DOCTOR)
         if (prescription.status !== "DRAFT" && prescription.status !== "PENDING_DOCTOR") {
             throw new Error(`Non è possibile inviare al lab una prescrizione in stato ${prescription.status}`);
         }
-        // 3. Policy invio vs policy auto-firma:
-        // - invio consentito a ruoli autorizzati dal flusso corrente (submit/sign)
-        // - auto-firma consentita solo al DOCTOR
-        const canSubmit = canUserPerformAction(user.role, "submit", prescription.status).allowed;
-        const canSign = canUserPerformAction(user.role, "sign", prescription.status).allowed;
-        const canSendToLab = canSubmit || canSign;
-        if (!canSendToLab) {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: `Il ruolo ${user.role} non può inviare al laboratorio in stato ${prescription.status}`,
-            });
-        }
-        const canAutoSign = user.role === "DOCTOR";
-        if (!canAutoSign) {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: "Invio al laboratorio non consentito: auto-firma disponibile solo per DOCTOR",
-            });
-        }
-        // 4. Carica flow e revisione
+        // 3. Carica flow e revisione
         const flow = await ctx.db
             .query("flows")
             .withIndex("by_flowKey_version", (q) => q.eq("flowKey", prescription.flowKey).eq("version", prescription.flowVersion))
@@ -633,8 +649,8 @@ export const sendToLab = mutation({
             signaturePayload: btoa(JSON.stringify({
                 autoSigned: true,
                 timestamp: now,
-                sentBy: user._id,
-                sentByRole: user.role,
+                sentBy: actor.actorUserId,
+                sentByRole: actor.actorRole,
             })),
             clinicalHash: finalHash,
         };
@@ -693,14 +709,15 @@ export const sendToLab = mutation({
             auditEventId: 0, // Will be backfilled
             prescriptionRef: args.prescriptionId,
             at: now,
-            actorUserId: user._id,
-            actorRole: user.role,
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
             type: "SENT_TO_LAB",
             payload: {
                 clinicalHash: finalHash,
                 sentAt: now,
                 syncJobIds,
                 autoSigned: true,
+                actorEmail: identity.email,
             },
         });
         return {
@@ -721,24 +738,18 @@ export const reviseAfterSignature = mutation({
     },
     handler: async (ctx, args) => {
         const now = Date.now();
-        const user = await requireAuthenticatedUserOrThrow(ctx);
+        const identity = await requireIdentityOrThrow(ctx);
+        const actor = getActorFromIdentity(identity);
         // 1. Carica prescrizione
         const prescription = await ctx.db.get(args.prescriptionId);
         if (!prescription) {
             throw new Error("Prescrizione non trovata");
         }
-        assertPrescriptionAccessOrThrow(user, prescription);
         // 2. Verifica stato
         if (!["SIGNED", "ERROR"].includes(prescription.status)) {
             throw new Error(`Non è possibile revisionare una prescrizione in stato ${prescription.status}`);
         }
-        if (user.role !== "DOCTOR") {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: "Solo i medici possono creare revisioni",
-            });
-        }
-        // 4. Carica revisione corrente
+        // 3. Carica revisione corrente
         if (!prescription.latestClinicalRevisionId) {
             throw new Error("Nessuna revisione clinica trovata");
         }
@@ -770,14 +781,15 @@ export const reviseAfterSignature = mutation({
             auditEventId: 0, // Will be backfilled
             prescriptionRef: args.prescriptionId,
             at: now,
-            actorUserId: user._id,
-            actorRole: "DOCTOR",
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
             type: "REVISION_CREATED",
             payload: {
                 previousRevisionNumber: currentRevision.revisionNumber,
                 newRevisionNumber,
                 previousHash: currentRevision.clinicalHash,
                 reason: args.reason,
+                actorEmail: identity.email,
             },
         });
         return {
@@ -797,13 +809,13 @@ export const cancelPrescription = mutation({
     },
     handler: async (ctx, args) => {
         const now = Date.now();
-        const user = await requireAuthenticatedUserOrThrow(ctx);
+        const identity = await requireIdentityOrThrow(ctx);
+        const actor = getActorFromIdentity(identity);
         // 1. Carica prescrizione
         const prescription = await ctx.db.get(args.prescriptionId);
         if (!prescription) {
             throw new Error("Prescrizione non trovata");
         }
-        assertPrescriptionAccessOrThrow(user, prescription);
         // 2. Verifica stato (non può annullare se già SYNCED)
         if (prescription.status === "SYNCED") {
             throw new Error("Non è possibile annullare una prescrizione già sincronizzata");
@@ -811,24 +823,20 @@ export const cancelPrescription = mutation({
         if (prescription.status === "CANCELLED") {
             throw new Error("La prescrizione è già annullata");
         }
-        const permission = canUserPerformAction(user.role, "cancel", prescription.status);
-        if (!permission.allowed) {
-            throw new Error(permission.reason);
-        }
-        // 4. Aggiorna stato
+        // 3. Aggiorna stato
         await ctx.db.patch(args.prescriptionId, {
             status: "CANCELLED",
             updatedAt: now,
         });
-        // 5. Audit
+        // 4. Audit
         await ctx.db.insert("auditEvents", {
             auditEventId: 0, // Will be backfilled
             prescriptionRef: args.prescriptionId,
             at: now,
-            actorUserId: user._id,
-            actorRole: user.role,
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
             type: "PRESCRIPTION_CANCELLED",
-            payload: { reason: args.reason },
+            payload: { reason: args.reason, actorEmail: identity.email },
         });
         return { success: true };
     },
@@ -844,13 +852,13 @@ export const markAsShipped = mutation({
     },
     handler: async (ctx, args) => {
         const now = Date.now();
-        const user = await requireAuthenticatedUserOrThrow(ctx);
+        const identity = await requireIdentityOrThrow(ctx);
+        const actor = getActorFromIdentity(identity);
         // 1. Carica prescrizione
         const prescription = await ctx.db.get(args.prescriptionId);
         if (!prescription) {
             throw new Error("Prescrizione non trovata");
         }
-        assertPrescriptionAccessOrThrow(user, prescription);
         // 2. Verifica stato (deve essere SIGNED o superiore, non CANCELLED)
         const validStatuses = ["SIGNED", "SYNCED", "ERROR"];
         if (!validStatuses.includes(prescription.status)) {
@@ -860,35 +868,25 @@ export const markAsShipped = mutation({
         if (prescription.shippedAt) {
             throw new Error("Questa prescrizione è già stata marcata come spedita");
         }
-        // 4. Policy ruolo: segreteria/medico e admin builder possono marcare spedito
-        const canManageShipment = user.role === "SECRETARY" ||
-            user.role === "DOCTOR" ||
-            user.adminRole === "admin" ||
-            user.adminRole === "superadmin";
-        if (!canManageShipment) {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: "Ruolo non autorizzato alla gestione spedizione",
-            });
-        }
-        // 5. Aggiorna prescrizione
+        // 3. Aggiorna prescrizione
         await ctx.db.patch(args.prescriptionId, {
             shippedAt: now,
-            shippedBy: user._id,
+            shippedBy: actor.actorUserId,
             trackingNumber: args.trackingNumber,
             updatedAt: now,
         });
-        // 6. Audit
+        // 4. Audit
         await ctx.db.insert("auditEvents", {
             auditEventId: 0, // Will be backfilled
             prescriptionRef: args.prescriptionId,
             at: now,
-            actorUserId: user._id,
-            actorRole: user.role,
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
             type: "PRESCRIPTION_SHIPPED",
             payload: {
                 trackingNumber: args.trackingNumber,
                 shippedAt: now,
+                actorEmail: identity.email,
             },
         });
         return { success: true, shippedAt: now };
@@ -903,44 +901,33 @@ export const unmarkAsShipped = mutation({
     },
     handler: async (ctx, args) => {
         const now = Date.now();
-        const user = await requireAuthenticatedUserOrThrow(ctx);
+        const identity = await requireIdentityOrThrow(ctx);
+        const actor = getActorFromIdentity(identity);
         // 1. Carica prescrizione
         const prescription = await ctx.db.get(args.prescriptionId);
         if (!prescription) {
             throw new Error("Prescrizione non trovata");
         }
-        assertPrescriptionAccessOrThrow(user, prescription);
         // 2. Verifica se è spedita
         if (!prescription.shippedAt) {
             throw new Error("Questa prescrizione non è marcata come spedita");
         }
-        // 3. Policy ruolo: segreteria/medico e admin builder possono annullare spedizione
-        const canManageShipment = user.role === "SECRETARY" ||
-            user.role === "DOCTOR" ||
-            user.adminRole === "admin" ||
-            user.adminRole === "superadmin";
-        if (!canManageShipment) {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: "Ruolo non autorizzato alla gestione spedizione",
-            });
-        }
-        // 4. Aggiorna prescrizione
+        // 3. Aggiorna prescrizione
         await ctx.db.patch(args.prescriptionId, {
             shippedAt: undefined,
             shippedBy: undefined,
             trackingNumber: undefined,
             updatedAt: now,
         });
-        // 5. Audit
+        // 4. Audit
         await ctx.db.insert("auditEvents", {
             auditEventId: 0, // Will be backfilled
             prescriptionRef: args.prescriptionId,
             at: now,
-            actorUserId: user._id,
-            actorRole: user.role,
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
             type: "PRESCRIPTION_SHIPMENT_CANCELLED",
-            payload: {},
+            payload: { actorEmail: identity.email },
         });
         return { success: true };
     },
@@ -979,22 +966,8 @@ export const createFromCalendar = mutation({
     handler: async (ctx, args) => {
         const now = Date.now();
         const flowKey = args.flowKey ?? "prosthetics-standard";
-        const user = await requireAuthenticatedUserOrThrow(ctx);
-        const canCreate = user.role === "SECRETARY" ||
-            user.adminRole === "admin" ||
-            user.adminRole === "superadmin";
-        if (!canCreate) {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: "Utente non autorizzato a creare prescrizioni",
-            });
-        }
-        if (user.clinicId !== args.clinicId && user.adminRole !== "admin" && user.adminRole !== "superadmin") {
-            throw new ConvexError({
-                code: "FORBIDDEN",
-                message: "Clinic non autorizzata per l'utente autenticato",
-            });
-        }
+        const identity = await requireIdentityOrThrow(ctx);
+        const actor = getActorFromIdentity(identity);
         // =============================================
         // 1. CONTROLLO IDEMPOTENZA
         // Se esiste già una prescrizione con questa idempotencyKey,
@@ -1119,7 +1092,7 @@ export const createFromCalendar = mutation({
             flowKey: actualFlowKey, // Usa il flow effettivo (potrebbe essere il default)
             flowVersion: flow.version,
             status: "DRAFT",
-            createdByUserId: user._id, // Derivato dall'identità autenticata
+            createdByUserId: actor.actorUserId, // Derivato dall'identità autenticata
             createdAt: now,
             updatedAt: now,
             coreRefs: {
@@ -1232,8 +1205,8 @@ export const createFromCalendar = mutation({
             auditEventId: 0, // Will be backfilled
             prescriptionRef: prescriptionId,
             at: now,
-            actorUserId: user._id,
-            actorRole: "SYSTEM", // Creato automaticamente dal sistema
+            actorUserId: actor.actorUserId,
+            actorRole: actor.actorRole,
             type: "PRESCRIPTION_CREATED_FROM_CALENDAR",
             payload: {
                 idempotencyKey: args.idempotencyKey,
@@ -1245,6 +1218,7 @@ export const createFromCalendar = mutation({
                 patientName: `${args.calendarData.patientFirstName} ${args.calendarData.patientLastName}`,
                 treatmentName: args.calendarData.treatmentName,
                 phaseName: args.calendarData.phaseName,
+                actorEmail: identity.email,
             },
         });
         // =============================================