@primocaredentgroup/prescriptions-component 0.1.0

package/dist/convex/mutations/prescriptions.js

@@ -0,0 +1,1263 @@
+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 { assertDynamicRequiredComplete } from "../lib/dynamicFieldsStrict";
+import { normalizeClinicalDraftInput } from "../lib/clinicalNormalize";
+// ============================================
+// CALENDAR DATA VALIDATOR (per la mutation)
+// ============================================
+const calendarDataArgsValidator = v.object({
+    patientFirstName: v.string(),
+    patientLastName: v.string(),
+    clinicName: v.string(),
+    treatmentPlanId: v.string(),
+    treatmentPlanName: v.optional(v.string()),
+    treatmentId: v.string(),
+    treatmentName: v.string(),
+    phaseId: v.string(),
+    phaseName: v.string(),
+    application: v.string(),
+    toothNumber: v.optional(v.string()),
+    appointmentId: v.string(),
+    appointmentDate: v.number(),
+    operatorId: v.string(),
+    operatorName: v.string(),
+    // Prossimo appuntamento (opzionale)
+    nextAppointmentId: v.optional(v.string()),
+    nextAppointmentDate: v.optional(v.number()),
+    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",
+        });
+    }
+}
+// ============================================
+// PRESCRIPTION MUTATIONS
+// ============================================
+/**
+ * Crea una nuova bozza di prescrizione.
+ *
+ * VINCOLO CRITICO: Una sola prescrizione attiva per pdcItemId
+ */
+export const createDraft = 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 user = await requireAuthenticatedUserOrThrow(ctx);
+        // 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. 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
+        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`);
+        }
+        // 3b. Carica rulesetVersion attiva (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, // Will be backfilled
+            clinicId: args.clinicId,
+            doctorId: args.doctorId,
+            patientId: args.patientId,
+            pdcItemId: args.pdcItemId,
+            listinoId: args.listinoId,
+            flowKey: args.flowKey,
+            flowVersion: flow.version,
+            status: "DRAFT",
+            createdByUserId: user._id,
+            createdAt: now,
+            updatedAt: now,
+            coreRefs: {},
+            labRefs: {},
+            // Snapshot ruleset attivo al momento della creazione
+            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, // Will be backfilled
+            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, // Will be backfilled
+                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, // Will be backfilled
+            prescriptionRef: prescriptionId,
+        });
+        // 9. Audit
+        await ctx.db.insert("auditEvents", {
+            auditEventId: 0, // Will be backfilled
+            prescriptionRef: prescriptionId,
+            at: now,
+            actorUserId: user._id,
+            actorRole: user.role,
+            type: "PRESCRIPTION_CREATED",
+            payload: {
+                pdcItemId: args.pdcItemId,
+                flowKey: args.flowKey,
+                flowVersion: flow.version,
+            },
+        });
+        return { prescriptionId, revisionId };
+    },
+});
+/**
+ * Aggiorna i dati clinici (bozza).
+ * Solo se la revisione non è frozen.
+ */
+export const updateClinicalDraft = mutation({
+    args: {
+        prescriptionId: v.id("prescriptions"),
+        clinicalDataPatch: v.object({
+            prostheticService: v.optional(v.object({
+                serviceCode: v.optional(v.string()),
+                serviceLabel: v.optional(v.string()),
+            })),
+            application: v.optional(v.union(v.object({ type: v.literal("TOOTH"), toothNumber: v.number() }), v.object({ type: v.literal("MULTI_TOOTH"), teeth: v.array(v.number()) }), v.object({
+                type: v.literal("BRIDGE"),
+                teeth: v.array(v.object({
+                    toothNumber: v.number(),
+                    role: v.union(v.literal("abutment"), v.literal("pontic")),
+                })),
+            }), v.object({ type: v.literal("QUADRANT"), quadrant: v.number() }), v.object({ type: v.literal("SEXTANT"), sextant: v.number() }), v.object({
+                type: v.literal("ARCH"),
+                arch: v.union(v.literal("UPPER"), v.literal("LOWER")),
+            }), v.object({ type: v.literal("FULL_MOUTH") }), v.null())),
+            shade: v.optional(v.union(v.string(), v.null())),
+            notePreparazione: v.optional(v.union(v.string(), v.null())),
+            lineaMargine: v.optional(v.union(v.string(), v.null())),
+        }),
+    },
+    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 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
+        if (!prescription.latestClinicalRevisionId) {
+            throw new Error("Nessuna revisione clinica trovata");
+        }
+        const revision = await ctx.db.get(prescription.latestClinicalRevisionId);
+        if (!revision) {
+            throw new Error("Revisione clinica non trovata");
+        }
+        if (revision.frozen) {
+            throw new Error("La revisione è firmata e non può essere modificata");
+        }
+        // 5. Normalizza e applica patch ai dati clinici
+        const normalizedPatch = normalizeClinicalDraftInput(args.clinicalDataPatch);
+        const updatedClinicalData = {
+            ...revision.clinicalData,
+        };
+        if (normalizedPatch.prostheticService) {
+            updatedClinicalData.prostheticService = {
+                ...updatedClinicalData.prostheticService,
+                ...normalizedPatch.prostheticService,
+            };
+        }
+        if (normalizedPatch.application !== undefined) {
+            updatedClinicalData.application = normalizedPatch.application ?? undefined;
+        }
+        if (normalizedPatch.shade !== undefined) {
+            updatedClinicalData.shade = normalizedPatch.shade ?? undefined;
+        }
+        if (normalizedPatch.notePreparazione !== undefined) {
+            updatedClinicalData.notePreparazione = normalizedPatch.notePreparazione ?? undefined;
+        }
+        if (normalizedPatch.lineaMargine !== undefined) {
+            updatedClinicalData.lineaMargine = normalizedPatch.lineaMargine ?? undefined;
+        }
+        const flow = await ctx.db
+            .query("flows")
+            .withIndex("by_flowKey_version", (q) => q.eq("flowKey", prescription.flowKey).eq("version", prescription.flowVersion))
+            .first();
+        if (!flow) {
+            throw new Error("Flow non trovato");
+        }
+        // 6. Validazione clinica hard non-blocking in bozza
+        const clinicalValidationErrors = validateClinicalData(updatedClinicalData, flow.definition, false);
+        // 7. Ricalcola hash
+        const newHash = await computeClinicalHash(updatedClinicalData);
+        // 8. Aggiorna revisione
+        await ctx.db.patch(revision._id, {
+            clinicalData: updatedClinicalData,
+            clinicalHash: newHash,
+        });
+        // 9. Aggiorna timestamp prescrizione
+        await ctx.db.patch(args.prescriptionId, {
+            updatedAt: now,
+        });
+        const changedKeys = [];
+        if (normalizedPatch.prostheticService?.serviceCode !== undefined) {
+            changedKeys.push("prostheticService.serviceCode");
+        }
+        if (normalizedPatch.prostheticService?.serviceLabel !== undefined) {
+            changedKeys.push("prostheticService.serviceLabel");
+        }
+        if (normalizedPatch.application !== undefined) {
+            changedKeys.push("application");
+        }
+        if (normalizedPatch.shade !== undefined) {
+            changedKeys.push("shade");
+        }
+        if (normalizedPatch.notePreparazione !== undefined) {
+            changedKeys.push("notePreparazione");
+        }
+        if (normalizedPatch.lineaMargine !== undefined) {
+            changedKeys.push("lineaMargine");
+        }
+        // 10. 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",
+            payload: {
+                changes: normalizedPatch,
+                changedKeys,
+                clinicalValidationErrorsCount: clinicalValidationErrors.length,
+                newHash,
+            },
+        });
+        return { ok: true, success: true, clinicalHash: newHash, clinicalValidationErrors };
+    },
+});
+/**
+ * Invia prescrizione al medico.
+ * Cambia status da DRAFT a PENDING_DOCTOR.
+ */
+export const submitToDoctor = mutation({
+    args: {
+        prescriptionId: v.id("prescriptions"),
+    },
+    handler: async (ctx, args) => {
+        const now = Date.now();
+        const user = await requireAuthenticatedUserOrThrow(ctx);
+        // 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
+        const digitalErrors = validateDigitalRequirements(prescription.prescriptionType, prescription.digitalAssets);
+        if (digitalErrors.length > 0) {
+            throw new Error(digitalErrors.map(e => e.message).join("; "));
+        }
+        // 5. Aggiorna stato
+        await ctx.db.patch(args.prescriptionId, {
+            status: "PENDING_DOCTOR",
+            updatedAt: now,
+        });
+        // 6. Audit
+        await ctx.db.insert("auditEvents", {
+            auditEventId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            at: now,
+            actorUserId: user._id,
+            actorRole: user.role,
+            type: "SUBMITTED_TO_DOCTOR",
+            payload: {},
+        });
+        return { success: true };
+    },
+});
+/**
+ * Firma la prescrizione.
+ * Solo medico, solo in stato PENDING_DOCTOR.
+ */
+export const signPrescription = mutation({
+    args: {
+        prescriptionId: v.id("prescriptions"),
+        signaturePayload: v.string(), // Base64 della firma "debole"
+    },
+    handler: async (ctx, args) => {
+        const now = Date.now();
+        const user = await requireAuthenticatedUserOrThrow(ctx);
+        // 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
+        const flow = await ctx.db
+            .query("flows")
+            .withIndex("by_flowKey_version", (q) => q.eq("flowKey", prescription.flowKey).eq("version", prescription.flowVersion))
+            .first();
+        if (!flow) {
+            throw new Error("Flow non trovato");
+        }
+        if (!prescription.latestClinicalRevisionId) {
+            throw new Error("Nessuna revisione clinica trovata");
+        }
+        const revision = await ctx.db.get(prescription.latestClinicalRevisionId);
+        if (!revision) {
+            throw new Error("Revisione clinica non trovata");
+        }
+        // 5. Valida i dati clinici per la firma
+        const validationErrors = validateClinicalData(revision.clinicalData, flow.definition, true // forSignature
+        );
+        if (validationErrors.length > 0) {
+            throw new ConvexError({
+                code: "INVALID_CLINICAL_DATA",
+                message: `Validazione fallita: ${validationErrors.map((e) => e.message).join("; ")}`,
+            });
+        }
+        // 6. Strict dynamic required prima di side effects
+        await assertDynamicRequiredComplete(ctx, prescription);
+        // 7. Canonicalizza e calcola hash finale
+        const finalHash = await computeClinicalHash(revision.clinicalData);
+        // 7. Crea firma
+        const signature = {
+            signedAt: now,
+            signedByDoctorId: user.coreDoctorId ?? user._id,
+            signatureType: "weak-digital",
+            signaturePayload: args.signaturePayload,
+            clinicalHash: finalHash,
+        };
+        // 8. Aggiorna revisione con firma e freeze
+        await ctx.db.patch(revision._id, {
+            signature,
+            frozen: true,
+            clinicalHash: finalHash,
+        });
+        // 9. Crea sync jobs
+        const syncJobIds = [];
+        // Job per PrimoCore
+        const primoCoreJobId = await ctx.db.insert("syncJobs", {
+            syncJobId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            target: "PRIMOCORE",
+            kind: "POST_CLINICAL",
+            idempotencyKey: generateIdempotencyKey(args.prescriptionId, "PRIMOCORE", "POST_CLINICAL", String(revision.revisionNumber)),
+            requestPayload: {
+                clinicalData: revision.clinicalData,
+                signature,
+                prescriptionId: args.prescriptionId,
+            },
+            status: "PENDING",
+            attempts: 0,
+            nextRetryAt: now,
+            createdAt: now,
+            updatedAt: now,
+        });
+        syncJobIds.push(primoCoreJobId);
+        // Job per Lab
+        const labJobId = await ctx.db.insert("syncJobs", {
+            syncJobId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            target: "LAB",
+            kind: "LAB_REQUEST",
+            idempotencyKey: generateIdempotencyKey(args.prescriptionId, "LAB", "LAB_REQUEST", String(revision.revisionNumber)),
+            requestPayload: {
+                clinicalData: revision.clinicalData,
+                prescriptionId: args.prescriptionId,
+            },
+            status: "PENDING",
+            attempts: 0,
+            nextRetryAt: now,
+            createdAt: now,
+            updatedAt: now,
+        });
+        syncJobIds.push(labJobId);
+        // 10. Aggiorna stato prescrizione
+        await ctx.db.patch(args.prescriptionId, {
+            status: "SIGNED",
+            updatedAt: now,
+        });
+        // 11. Audit
+        await ctx.db.insert("auditEvents", {
+            auditEventId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            at: now,
+            actorUserId: user._id,
+            actorRole: "DOCTOR",
+            type: "PRESCRIPTION_SIGNED",
+            payload: {
+                clinicalHash: finalHash,
+                signedAt: now,
+                syncJobIds,
+            },
+        });
+        return {
+            success: true,
+            clinicalHash: finalHash,
+            syncJobIds,
+        };
+    },
+});
+/**
+ * Invia la prescrizione al laboratorio.
+ * Questa mutation semplifica il flusso: passa direttamente da DRAFT a SIGNED
+ * senza richiedere la firma del medico (auto-firma simulata).
+ */
+export const sendToLab = mutation({
+    args: {
+        prescriptionId: v.id("prescriptions"),
+    },
+    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 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
+        const flow = await ctx.db
+            .query("flows")
+            .withIndex("by_flowKey_version", (q) => q.eq("flowKey", prescription.flowKey).eq("version", prescription.flowVersion))
+            .first();
+        if (!flow) {
+            throw new Error("Flow non trovato");
+        }
+        if (!prescription.latestClinicalRevisionId) {
+            throw new Error("Nessuna revisione clinica trovata");
+        }
+        const revision = await ctx.db.get(prescription.latestClinicalRevisionId);
+        if (!revision) {
+            throw new Error("Revisione clinica non trovata");
+        }
+        // 5. Hard validation clinica (strict)
+        const validationErrors = validateClinicalData(revision.clinicalData, flow.definition, true);
+        if (validationErrors.length > 0) {
+            throw new ConvexError({
+                code: "INVALID_CLINICAL_DATA",
+                message: "Validazione clinica fallita",
+                errors: validationErrors.map((err) => `${err.field}: ${err.message}`),
+            });
+        }
+        // 6. Hard validation campi dinamici (strict required)
+        await assertDynamicRequiredComplete(ctx, prescription);
+        // 7. Calcola hash finale
+        const finalHash = await computeClinicalHash(revision.clinicalData);
+        // 8. Crea firma automatica (simulata)
+        const signature = {
+            signedAt: now,
+            signedByDoctorId: prescription.doctorId, // Usa il medico assegnato alla prescrizione
+            signatureType: "auto-lab", // Tipo di firma automatica per invio lab
+            signaturePayload: btoa(JSON.stringify({
+                autoSigned: true,
+                timestamp: now,
+                sentBy: user._id,
+                sentByRole: user.role,
+            })),
+            clinicalHash: finalHash,
+        };
+        // 9. Aggiorna revisione con firma e freeze
+        await ctx.db.patch(revision._id, {
+            signature,
+            frozen: true,
+            clinicalHash: finalHash,
+        });
+        // 10. Crea sync jobs
+        const syncJobIds = [];
+        // Job per PrimoCore
+        const primoCoreJobId = await ctx.db.insert("syncJobs", {
+            syncJobId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            target: "PRIMOCORE",
+            kind: "POST_CLINICAL",
+            idempotencyKey: generateIdempotencyKey(args.prescriptionId, "PRIMOCORE", "POST_CLINICAL", String(revision.revisionNumber)),
+            requestPayload: {
+                clinicalData: revision.clinicalData,
+                signature,
+                prescriptionId: args.prescriptionId,
+            },
+            status: "PENDING",
+            attempts: 0,
+            nextRetryAt: now,
+            createdAt: now,
+            updatedAt: now,
+        });
+        syncJobIds.push(primoCoreJobId);
+        // Job per Lab
+        const labJobId = await ctx.db.insert("syncJobs", {
+            syncJobId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            target: "LAB",
+            kind: "LAB_REQUEST",
+            idempotencyKey: generateIdempotencyKey(args.prescriptionId, "LAB", "LAB_REQUEST", String(revision.revisionNumber)),
+            requestPayload: {
+                clinicalData: revision.clinicalData,
+                prescriptionId: args.prescriptionId,
+            },
+            status: "PENDING",
+            attempts: 0,
+            nextRetryAt: now,
+            createdAt: now,
+            updatedAt: now,
+        });
+        syncJobIds.push(labJobId);
+        // 11. Aggiorna stato prescrizione a SIGNED (= in Lab)
+        await ctx.db.patch(args.prescriptionId, {
+            status: "SIGNED",
+            updatedAt: now,
+        });
+        // 12. Audit
+        await ctx.db.insert("auditEvents", {
+            auditEventId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            at: now,
+            actorUserId: user._id,
+            actorRole: user.role,
+            type: "SENT_TO_LAB",
+            payload: {
+                clinicalHash: finalHash,
+                sentAt: now,
+                syncJobIds,
+                autoSigned: true,
+            },
+        });
+        return {
+            success: true,
+            clinicalHash: finalHash,
+            syncJobIds,
+        };
+    },
+});
+/**
+ * Crea una nuova revisione dopo la firma.
+ * Permette di modificare una prescrizione già firmata.
+ */
+export const reviseAfterSignature = mutation({
+    args: {
+        prescriptionId: v.id("prescriptions"),
+        reason: v.string(),
+    },
+    handler: async (ctx, args) => {
+        const now = Date.now();
+        const user = await requireAuthenticatedUserOrThrow(ctx);
+        // 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
+        if (!prescription.latestClinicalRevisionId) {
+            throw new Error("Nessuna revisione clinica trovata");
+        }
+        const currentRevision = await ctx.db.get(prescription.latestClinicalRevisionId);
+        if (!currentRevision) {
+            throw new Error("Revisione clinica non trovata");
+        }
+        // 5. Crea nuova revisione (copia dei dati, senza firma)
+        const newRevisionNumber = currentRevision.revisionNumber + 1;
+        const newHash = await computeClinicalHash(currentRevision.clinicalData);
+        const newRevisionId = await ctx.db.insert("clinicalRevisions", {
+            clinicalRevisionId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            revisionNumber: newRevisionNumber,
+            clinicalData: currentRevision.clinicalData,
+            clinicalHash: newHash,
+            signature: null,
+            frozen: false,
+            createdAt: now,
+        });
+        // 6. Aggiorna prescrizione
+        await ctx.db.patch(args.prescriptionId, {
+            status: "PENDING_DOCTOR",
+            latestClinicalRevisionId: newRevisionId,
+            updatedAt: now,
+        });
+        // 7. Audit
+        await ctx.db.insert("auditEvents", {
+            auditEventId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            at: now,
+            actorUserId: user._id,
+            actorRole: "DOCTOR",
+            type: "REVISION_CREATED",
+            payload: {
+                previousRevisionNumber: currentRevision.revisionNumber,
+                newRevisionNumber,
+                previousHash: currentRevision.clinicalHash,
+                reason: args.reason,
+            },
+        });
+        return {
+            success: true,
+            newRevisionId,
+            newRevisionNumber,
+        };
+    },
+});
+/**
+ * Annulla una prescrizione.
+ */
+export const cancelPrescription = mutation({
+    args: {
+        prescriptionId: v.id("prescriptions"),
+        reason: v.string(),
+    },
+    handler: async (ctx, args) => {
+        const now = Date.now();
+        const user = await requireAuthenticatedUserOrThrow(ctx);
+        // 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");
+        }
+        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
+        await ctx.db.patch(args.prescriptionId, {
+            status: "CANCELLED",
+            updatedAt: now,
+        });
+        // 5. Audit
+        await ctx.db.insert("auditEvents", {
+            auditEventId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            at: now,
+            actorUserId: user._id,
+            actorRole: user.role,
+            type: "PRESCRIPTION_CANCELLED",
+            payload: { reason: args.reason },
+        });
+        return { success: true };
+    },
+});
+/**
+ * Marca una prescrizione come spedita al laboratorio.
+ * Per prescrizioni analogiche: traccia quando l'impronta fisica viene spedita.
+ */
+export const markAsShipped = mutation({
+    args: {
+        prescriptionId: v.id("prescriptions"),
+        trackingNumber: v.optional(v.string()), // Numero tracking corriere (opzionale)
+    },
+    handler: async (ctx, args) => {
+        const now = Date.now();
+        const user = await requireAuthenticatedUserOrThrow(ctx);
+        // 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)) {
+            throw new Error(`Non è possibile marcare come spedita una prescrizione in stato ${prescription.status}`);
+        }
+        // 3. Verifica se già spedita
+        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
+        await ctx.db.patch(args.prescriptionId, {
+            shippedAt: now,
+            shippedBy: user._id,
+            trackingNumber: args.trackingNumber,
+            updatedAt: now,
+        });
+        // 6. Audit
+        await ctx.db.insert("auditEvents", {
+            auditEventId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            at: now,
+            actorUserId: user._id,
+            actorRole: user.role,
+            type: "PRESCRIPTION_SHIPPED",
+            payload: {
+                trackingNumber: args.trackingNumber,
+                shippedAt: now,
+            },
+        });
+        return { success: true, shippedAt: now };
+    },
+});
+/**
+ * Rimuove il flag di spedizione (annulla spedizione).
+ */
+export const unmarkAsShipped = mutation({
+    args: {
+        prescriptionId: v.id("prescriptions"),
+    },
+    handler: async (ctx, args) => {
+        const now = Date.now();
+        const user = await requireAuthenticatedUserOrThrow(ctx);
+        // 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
+        await ctx.db.patch(args.prescriptionId, {
+            shippedAt: undefined,
+            shippedBy: undefined,
+            trackingNumber: undefined,
+            updatedAt: now,
+        });
+        // 5. Audit
+        await ctx.db.insert("auditEvents", {
+            auditEventId: 0, // Will be backfilled
+            prescriptionRef: args.prescriptionId,
+            at: now,
+            actorUserId: user._id,
+            actorRole: user.role,
+            type: "PRESCRIPTION_SHIPMENT_CANCELLED",
+            payload: {},
+        });
+        return { success: true };
+    },
+});
+// ============================================
+// CREATE FROM CALENDAR - Creazione automatica dal Calendario
+// ============================================
+/**
+ * Crea una prescrizione automaticamente quando il Calendario crea un appuntamento.
+ *
+ * CARATTERISTICHE:
+ * - Usa idempotencyKey per evitare duplicati (se la chiamata viene ritentata)
+ * - Salva uno snapshot dei dati dal Calendario (calendarData)
+ * - Pre-compila i dati clinici con le info disponibili
+ * - Ritorna la prescrizione esistente se idempotencyKey già usata
+ *
+ * @param idempotencyKey - Chiave univoca (es: "cal-{appointmentId}")
+ * @param calendarData - Snapshot dei dati dal Calendario
+ * @param clinicId, patientId, etc. - ID per i riferimenti
+ */
+export const createFromCalendar = mutation({
+    args: {
+        // Chiave per idempotenza - OBBLIGATORIA
+        idempotencyKey: v.string(),
+        // ID principali (riferimenti alle entità)
+        clinicId: v.string(),
+        doctorId: v.string(),
+        patientId: v.string(),
+        pdcItemId: v.string(),
+        listinoId: v.string(),
+        // Flow da usare (default: prosthetics-standard)
+        flowKey: v.optional(v.string()),
+        // Snapshot completo dal Calendario
+        calendarData: calendarDataArgsValidator,
+    },
+    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",
+            });
+        }
+        // =============================================
+        // 1. CONTROLLO IDEMPOTENZA
+        // Se esiste già una prescrizione con questa idempotencyKey,
+        // la ritorniamo invece di crearne una nuova
+        // =============================================
+        const existingByIdempotency = await ctx.db
+            .query("prescriptions")
+            .withIndex("by_idempotencyKey", (q) => q.eq("idempotencyKey", args.idempotencyKey))
+            .first();
+        if (existingByIdempotency) {
+            // Già creata in precedenza, ritorna quella esistente
+            console.log(`[createFromCalendar] Prescrizione già esistente per idempotencyKey: ${args.idempotencyKey}`);
+            return {
+                success: true,
+                prescriptionId: existingByIdempotency._id,
+                alreadyExisted: true,
+                message: "Prescrizione già esistente per questo appuntamento",
+            };
+        }
+        // =============================================
+        // 2. VINCOLO: Una sola prescrizione attiva per 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) {
+            // C'è già una prescrizione attiva per questo PDC Item
+            // NON è un errore, ma informiamo il chiamante
+            console.log(`[createFromCalendar] Prescrizione già attiva per pdcItemId: ${args.pdcItemId}`);
+            return {
+                success: false,
+                prescriptionId: activePrescription._id,
+                alreadyExisted: true,
+                message: `Esiste già una prescrizione attiva per questa prestazione (ID: ${activePrescription._id})`,
+            };
+        }
+        // =============================================
+        // 3. CARICA FLOW ATTIVO (con fallback)
+        // =============================================
+        const DEFAULT_FLOW_KEY = "prosthetics-standard";
+        let flow = await ctx.db
+            .query("flows")
+            .withIndex("by_flowKey_status", (q) => q.eq("flowKey", flowKey).eq("status", "ACTIVE"))
+            .first();
+        // Se il flow richiesto non esiste, usa il default
+        let actualFlowKey = flowKey;
+        if (!flow) {
+            console.log(`[createFromCalendar] Flow "${flowKey}" non trovato, uso default "${DEFAULT_FLOW_KEY}"`);
+            flow = await ctx.db
+                .query("flows")
+                .withIndex("by_flowKey_status", (q) => q.eq("flowKey", DEFAULT_FLOW_KEY).eq("status", "ACTIVE"))
+                .first();
+            if (!flow) {
+                throw new Error(`Flow default "${DEFAULT_FLOW_KEY}" non trovato. Eseguire il seed del database.`);
+            }
+            actualFlowKey = DEFAULT_FLOW_KEY;
+        }
+        // =============================================
+        // 4. DETERMINA APPLICAZIONE DAI DATI CALENDARIO
+        // Converte 'mouth', 'tooth', 'upper_arch', 'lower_arch' 
+        // nel formato interno
+        // =============================================
+        let application = undefined;
+        switch (args.calendarData.application) {
+            case "tooth":
+                if (args.calendarData.toothNumber) {
+                    // Supporta formato multi-dente: "11,12,13" oppure singolo "11"
+                    const toothStr = args.calendarData.toothNumber.trim();
+                    if (toothStr.includes(",")) {
+                        // Multi-dente: "11,12,13"
+                        const teeth = toothStr
+                            .split(",")
+                            .map((s) => parseInt(s.trim(), 10))
+                            .filter((n) => !isNaN(n) && n >= 11 && n <= 48);
+                        if (teeth.length > 1) {
+                            application = { type: "MULTI_TOOTH", teeth };
+                        }
+                        else if (teeth.length === 1) {
+                            application = { type: "TOOTH", toothNumber: teeth[0] };
+                        }
+                    }
+                    else {
+                        // Singolo dente
+                        const num = parseInt(toothStr, 10);
+                        if (!isNaN(num)) {
+                            application = { type: "TOOTH", toothNumber: num };
+                        }
+                    }
+                }
+                break;
+            case "upper_arch":
+                application = { type: "ARCH", arch: "UPPER" };
+                break;
+            case "lower_arch":
+                application = { type: "ARCH", arch: "LOWER" };
+                break;
+            case "mouth":
+                application = { type: "FULL_MOUTH" };
+                break;
+            // Altri casi possono essere aggiunti
+        }
+        // =============================================
+        // 4b. CARICA RULESET ATTIVO (snapshot)
+        // =============================================
+        const activeRulesetCal = await ctx.db
+            .query("activeRulesets")
+            .withIndex("by_key", (q) => q.eq("key", "global"))
+            .first();
+        // =============================================
+        // 5. CREA PRESCRIZIONE
+        // =============================================
+        const prescriptionId = await ctx.db.insert("prescriptions", {
+            prescriptionId: 0, // Will be backfilled
+            clinicId: args.clinicId,
+            doctorId: args.doctorId,
+            patientId: args.patientId,
+            pdcItemId: args.pdcItemId,
+            listinoId: args.listinoId,
+            flowKey: actualFlowKey, // Usa il flow effettivo (potrebbe essere il default)
+            flowVersion: flow.version,
+            status: "DRAFT",
+            createdByUserId: user._id, // Derivato dall'identità autenticata
+            createdAt: now,
+            updatedAt: now,
+            coreRefs: {
+                coreAppointmentIds: args.calendarData.nextAppointmentId
+                    ? [args.calendarData.appointmentId, args.calendarData.nextAppointmentId]
+                    : [args.calendarData.appointmentId],
+            },
+            labRefs: {},
+            // Nuovi campi
+            idempotencyKey: args.idempotencyKey,
+            calendarData: args.calendarData,
+            // Snapshot ruleset attivo al momento della creazione
+            rulesetVersionId: activeRulesetCal?.versionId,
+            valuesByFieldId: "{}",
+        });
+        // =============================================
+        // 6. CREA REVISIONE CLINICA INIZIALE
+        // Pre-compilata con i dati dal Calendario
+        // =============================================
+        const initialClinicalData = {
+            patient: { corePatientId: args.patientId },
+            clinic: { coreClinicId: args.clinicId },
+            doctor: { coreDoctorId: args.doctorId },
+            prostheticService: {
+                pdcItemId: args.pdcItemId,
+                listinoId: args.listinoId,
+                // Pre-compila con i dati dal Calendario
+                serviceCode: args.calendarData.treatmentId,
+                serviceLabel: args.calendarData.treatmentName,
+            },
+            // Applicazione determinata sopra
+            application: application,
+        };
+        const clinicalHash = await computeClinicalHash(initialClinicalData);
+        const revisionId = await ctx.db.insert("clinicalRevisions", {
+            clinicalRevisionId: 0, // Will be backfilled
+            prescriptionRef: prescriptionId,
+            revisionNumber: 1,
+            clinicalData: initialClinicalData,
+            clinicalHash,
+            signature: null,
+            frozen: false,
+            createdAt: now,
+        });
+        // =============================================
+        // 7. AGGIORNA PRESCRIZIONE CON RIFERIMENTO ALLA REVISIONE
+        // =============================================
+        await ctx.db.patch(prescriptionId, {
+            latestClinicalRevisionId: revisionId,
+        });
+        // =============================================
+        // 8. INIZIALIZZA PHASE INSTANCES
+        // =============================================
+        // Raccogli gli ID degli appuntamenti per il coreRefs
+        const appointmentIds = [args.calendarData.appointmentId];
+        if (args.calendarData.nextAppointmentId) {
+            appointmentIds.push(args.calendarData.nextAppointmentId);
+        }
+        for (let i = 0; i < flow.definition.phases.length; i++) {
+            const phase = flow.definition.phases[i];
+            // Se questa fase corrisponde a quella dell'appuntamento corrente
+            const isCurrentPhase = phase.phaseTypeKey === args.calendarData.phaseId ||
+                phase.label.toLowerCase() === args.calendarData.phaseName.toLowerCase();
+            // Se questa fase corrisponde al prossimo appuntamento (se presente)
+            const isNextPhase = args.calendarData.nextAppointmentId && (phase.phaseTypeKey === args.calendarData.nextAppointmentPhaseId ||
+                (args.calendarData.nextAppointmentPhaseName &&
+                    phase.label.toLowerCase() === args.calendarData.nextAppointmentPhaseName.toLowerCase()));
+            // Determina lo status e i dati appuntamento
+            let phaseStatus = "NOT_STARTED";
+            let appointmentData = undefined;
+            if (isCurrentPhase) {
+                phaseStatus = "SCHEDULED";
+                appointmentData = {
+                    coreAppointmentId: args.calendarData.appointmentId,
+                    startAt: args.calendarData.appointmentDate,
+                    doctorId: args.doctorId,
+                };
+            }
+            else if (isNextPhase && args.calendarData.nextAppointmentDate) {
+                phaseStatus = "SCHEDULED";
+                appointmentData = {
+                    coreAppointmentId: args.calendarData.nextAppointmentId,
+                    startAt: args.calendarData.nextAppointmentDate,
+                    doctorId: args.doctorId,
+                };
+            }
+            await ctx.db.insert("phaseInstances", {
+                phaseInstanceId: 0, // Will be backfilled
+                prescriptionRef: prescriptionId,
+                phaseTypeKey: phase.phaseTypeKey,
+                ordinal: i,
+                iteration: 1,
+                status: phaseStatus,
+                appointment: appointmentData,
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+        // =============================================
+        // 9. CREA OPERATIONAL DATA
+        // =============================================
+        await ctx.db.insert("operationalData", {
+            operationalDataId: 0, // Will be backfilled
+            prescriptionRef: prescriptionId,
+        });
+        // =============================================
+        // 10. AUDIT LOG
+        // =============================================
+        await ctx.db.insert("auditEvents", {
+            auditEventId: 0, // Will be backfilled
+            prescriptionRef: prescriptionId,
+            at: now,
+            actorUserId: user._id,
+            actorRole: "SYSTEM", // Creato automaticamente dal sistema
+            type: "PRESCRIPTION_CREATED_FROM_CALENDAR",
+            payload: {
+                idempotencyKey: args.idempotencyKey,
+                calendarAppointmentId: args.calendarData.appointmentId,
+                pdcItemId: args.pdcItemId,
+                flowKey: actualFlowKey,
+                flowKeyRequested: flowKey !== actualFlowKey ? flowKey : undefined, // Log se era diverso
+                flowVersion: flow.version,
+                patientName: `${args.calendarData.patientFirstName} ${args.calendarData.patientLastName}`,
+                treatmentName: args.calendarData.treatmentName,
+                phaseName: args.calendarData.phaseName,
+            },
+        });
+        // =============================================
+        // 11. RITORNA RISULTATO
+        // =============================================
+        console.log(`[createFromCalendar] Nuova prescrizione creata: ${prescriptionId}`);
+        return {
+            success: true,
+            prescriptionId,
+            revisionId,
+            alreadyExisted: false,
+            message: "Prescrizione creata con successo",
+        };
+    },
+});
+//# sourceMappingURL=prescriptions.js.map