Skip to main content

minco_plugin_ticketing/
store.rs

1use crate::{
2    CreateTicketInput, MAX_TICKET_LIST_FETCH_LIMIT, Ticket, TicketFromHandoffInput, TicketId,
3    TicketRequester, TicketStatus, TicketValidationError,
4};
5use async_trait::async_trait;
6use chrono::{DateTime, Utc};
7use minco_interaction::{
8    SupportHandoff, SupportHandoffDigest, SupportHandoffResult, SupportHandoffToken,
9};
10use serde::{Deserialize, Serialize};
11use sha2::{Digest, Sha256};
12use std::{
13    collections::{BTreeMap, BTreeSet},
14    fmt,
15    sync::Arc,
16};
17use subtle::ConstantTimeEq;
18use tokio::sync::Mutex;
19use uuid::Uuid;
20
21#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
22pub struct TicketActivityIntent {
23    pub id: Uuid,
24    pub project_id: String,
25    pub ticket_id: TicketId,
26    pub kind: String,
27    pub correlation_id: Uuid,
28    pub payload: serde_json::Value,
29    pub created_at: DateTime<Utc>,
30}
31
32impl TicketActivityIntent {
33    #[must_use]
34    pub fn new(
35        project_id: impl Into<String>,
36        ticket_id: TicketId,
37        kind: impl Into<String>,
38        correlation_id: Uuid,
39        payload: serde_json::Value,
40        created_at: DateTime<Utc>,
41    ) -> Self {
42        Self {
43            id: Uuid::now_v7(),
44            project_id: project_id.into(),
45            ticket_id,
46            kind: kind.into(),
47            correlation_id,
48            payload,
49            created_at,
50        }
51    }
52}
53
54#[derive(Debug, Clone, Default, PartialEq, Eq)]
55pub struct TicketListFilter {
56    pub project_id: String,
57    pub statuses: BTreeSet<TicketStatus>,
58    pub queue_id: Option<String>,
59    pub assignee_subject: Option<String>,
60    pub requester_subject: Option<String>,
61    pub after_updated_at: Option<DateTime<Utc>>,
62    pub after_id: Option<TicketId>,
63    pub limit: usize,
64}
65
66#[derive(Clone, PartialEq, Eq)]
67pub struct ConsumeHandoffRequest {
68    pub token: SupportHandoffToken,
69    pub project_id: String,
70    pub portal_origin: String,
71    pub input: TicketFromHandoffInput,
72    pub request_fingerprint: String,
73    pub now: DateTime<Utc>,
74}
75
76impl fmt::Debug for ConsumeHandoffRequest {
77    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
78        formatter
79            .debug_struct("ConsumeHandoffRequest")
80            .field("token", &self.token)
81            .field("project_id", &self.project_id)
82            .field("portal_origin", &self.portal_origin)
83            .field("input", &"[BOUNDED]")
84            .field("request_fingerprint", &"[REDACTED]")
85            .field("now", &self.now)
86            .finish()
87    }
88}
89
90impl ConsumeHandoffRequest {
91    pub fn new(
92        token: SupportHandoffToken,
93        project_id: impl Into<String>,
94        portal_origin: impl Into<String>,
95        input: TicketFromHandoffInput,
96        now: DateTime<Utc>,
97    ) -> Result<Self, TicketStoreError> {
98        let project_id = project_id.into();
99        let portal_origin = portal_origin.into();
100        let serialized = serde_json::to_vec(&serde_json::json!({
101            "project_id": project_id,
102            "portal_origin": portal_origin,
103            "subject": input.subject,
104            "description": input.description,
105            "channel": input.channel,
106            "priority": input.priority,
107        }))
108        .map_err(|error| TicketStoreError::Infrastructure(error.to_string()))?;
109        Ok(Self {
110            token,
111            project_id,
112            portal_origin,
113            input,
114            request_fingerprint: hex::encode(Sha256::digest(serialized)),
115            now,
116        })
117    }
118}
119
120#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
121pub struct ConsumedHandoff {
122    pub ticket: Ticket,
123    pub result: SupportHandoffResult,
124    pub repeated: bool,
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
128pub struct ExternalMessageIdentity {
129    pub project_id: String,
130    pub provider: String,
131    pub mailbox_scope: String,
132    pub external_id: String,
133    pub content_sha256: String,
134    pub raw_message_object_key: Option<String>,
135    pub internet_message_id: Option<String>,
136    pub in_reply_to: Option<String>,
137    pub references: Vec<String>,
138}
139
140#[derive(Debug, Clone, PartialEq, Eq)]
141pub struct IngestExternalMessageRequest {
142    pub identity: ExternalMessageIdentity,
143    pub ticket_id: TicketId,
144    pub body: String,
145    pub expected_revision: u64,
146    pub correlation_id: Uuid,
147    pub now: DateTime<Utc>,
148}
149
150#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
151pub struct ExternalMessageIngestResult {
152    pub ticket: Ticket,
153    pub repeated: bool,
154}
155
156#[async_trait]
157pub trait TicketingStore: Send + Sync + fmt::Debug {
158    async fn create(
159        &self,
160        ticket: Ticket,
161        intent: TicketActivityIntent,
162    ) -> Result<(), TicketStoreError>;
163
164    async fn get(&self, project_id: &str, id: TicketId)
165    -> Result<Option<Ticket>, TicketStoreError>;
166
167    async fn list(&self, filter: TicketListFilter) -> Result<Vec<Ticket>, TicketStoreError>;
168
169    async fn save(
170        &self,
171        ticket: Ticket,
172        expected_revision: u64,
173        intent: TicketActivityIntent,
174    ) -> Result<(), TicketStoreError>;
175
176    async fn insert_handoff(&self, handoff: SupportHandoff) -> Result<(), TicketStoreError>;
177
178    async fn consume_and_create_ticket(
179        &self,
180        request: ConsumeHandoffRequest,
181    ) -> Result<ConsumedHandoff, TicketStoreError>;
182
183    async fn ingest_external_message(
184        &self,
185        request: IngestExternalMessageRequest,
186    ) -> Result<ExternalMessageIngestResult, TicketStoreError>;
187
188    async fn ready(&self) -> Result<(), TicketStoreError> {
189        Ok(())
190    }
191}
192
193#[derive(Clone)]
194pub struct TicketingStoreService(pub Arc<dyn TicketingStore>);
195
196impl fmt::Debug for TicketingStoreService {
197    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
198        formatter.debug_tuple("TicketingStoreService").finish()
199    }
200}
201
202impl TicketingStoreService {
203    pub fn new(store: Arc<dyn TicketingStore>) -> Self {
204        Self(store)
205    }
206
207    pub async fn create(
208        &self,
209        ticket: Ticket,
210        intent: TicketActivityIntent,
211    ) -> Result<(), TicketStoreError> {
212        self.0.create(ticket, intent).await
213    }
214
215    pub async fn get(
216        &self,
217        project_id: &str,
218        id: TicketId,
219    ) -> Result<Option<Ticket>, TicketStoreError> {
220        self.0.get(project_id, id).await
221    }
222
223    pub async fn list(&self, filter: TicketListFilter) -> Result<Vec<Ticket>, TicketStoreError> {
224        self.0.list(filter).await
225    }
226
227    pub async fn save(
228        &self,
229        ticket: Ticket,
230        expected_revision: u64,
231        intent: TicketActivityIntent,
232    ) -> Result<(), TicketStoreError> {
233        self.0.save(ticket, expected_revision, intent).await
234    }
235
236    pub async fn insert_handoff(&self, handoff: SupportHandoff) -> Result<(), TicketStoreError> {
237        self.0.insert_handoff(handoff).await
238    }
239
240    pub async fn consume_and_create_ticket(
241        &self,
242        request: ConsumeHandoffRequest,
243    ) -> Result<ConsumedHandoff, TicketStoreError> {
244        self.0.consume_and_create_ticket(request).await
245    }
246
247    pub async fn ingest_external_message(
248        &self,
249        request: IngestExternalMessageRequest,
250    ) -> Result<ExternalMessageIngestResult, TicketStoreError> {
251        self.0.ingest_external_message(request).await
252    }
253
254    pub async fn ready(&self) -> Result<(), TicketStoreError> {
255        self.0.ready().await
256    }
257}
258
259#[derive(Debug, Clone)]
260struct MemoryHandoff {
261    handoff: SupportHandoff,
262    completed_fingerprint: Option<String>,
263}
264
265#[derive(Debug, Clone, Default)]
266struct MemoryState {
267    tickets: BTreeMap<(String, TicketId), Ticket>,
268    display_counters: BTreeMap<String, u64>,
269    handoffs: BTreeMap<SupportHandoffDigest, MemoryHandoff>,
270    external_messages:
271        BTreeMap<(String, String, String, String), (ExternalMessageIdentity, TicketId)>,
272    activity_intents: Vec<TicketActivityIntent>,
273    fail_next_handoff_commit: bool,
274}
275
276#[derive(Debug, Default)]
277pub struct MemoryTicketingStore {
278    state: Mutex<MemoryState>,
279}
280
281impl MemoryTicketingStore {
282    pub async fn activity_intents(&self) -> Vec<TicketActivityIntent> {
283        self.state.lock().await.activity_intents.clone()
284    }
285
286    pub async fn fail_next_handoff_commit(&self) {
287        self.state.lock().await.fail_next_handoff_commit = true;
288    }
289
290    pub async fn ticket_count(&self) -> usize {
291        self.state.lock().await.tickets.len()
292    }
293
294    pub async fn handoff_consumed(&self, digest: &SupportHandoffDigest) -> bool {
295        self.state
296            .lock()
297            .await
298            .handoffs
299            .get(digest)
300            .is_some_and(|entry| entry.handoff.consumed_result.is_some())
301    }
302}
303
304#[async_trait]
305impl TicketingStore for MemoryTicketingStore {
306    async fn create(
307        &self,
308        ticket: Ticket,
309        intent: TicketActivityIntent,
310    ) -> Result<(), TicketStoreError> {
311        let mut state = self.state.lock().await;
312        let key = (ticket.project_id.clone(), ticket.id);
313        if state.tickets.contains_key(&key) {
314            return Err(TicketStoreError::DuplicateTicket(ticket.id));
315        }
316        if state.tickets.values().any(|existing| {
317            existing.project_id == ticket.project_id
318                && existing.display_reference == ticket.display_reference
319        }) {
320            return Err(TicketStoreError::DuplicateDisplayReference);
321        }
322        state.tickets.insert(key, ticket);
323        state.activity_intents.push(intent);
324        drop(state);
325        Ok(())
326    }
327
328    async fn get(
329        &self,
330        project_id: &str,
331        id: TicketId,
332    ) -> Result<Option<Ticket>, TicketStoreError> {
333        Ok(self
334            .state
335            .lock()
336            .await
337            .tickets
338            .get(&(project_id.to_owned(), id))
339            .cloned())
340    }
341
342    async fn list(&self, filter: TicketListFilter) -> Result<Vec<Ticket>, TicketStoreError> {
343        if !(1..=MAX_TICKET_LIST_FETCH_LIMIT).contains(&filter.limit) {
344            return Err(TicketStoreError::InvalidListLimit);
345        }
346        if filter.after_updated_at.is_some() != filter.after_id.is_some() {
347            return Err(TicketStoreError::InvalidListCursor);
348        }
349        let mut values = self
350            .state
351            .lock()
352            .await
353            .tickets
354            .values()
355            .filter(|ticket| ticket.project_id == filter.project_id)
356            .filter(|ticket| filter.statuses.is_empty() || filter.statuses.contains(&ticket.status))
357            .filter(|ticket| {
358                filter
359                    .queue_id
360                    .as_ref()
361                    .is_none_or(|value| ticket.queue_id.as_ref() == Some(value))
362            })
363            .filter(|ticket| {
364                filter
365                    .assignee_subject
366                    .as_ref()
367                    .is_none_or(|value| ticket.assignee_subject.as_ref() == Some(value))
368            })
369            .filter(|ticket| {
370                filter
371                    .requester_subject
372                    .as_ref()
373                    .is_none_or(|value| &ticket.requester.subject == value)
374            })
375            .filter(|ticket| match (filter.after_updated_at, filter.after_id) {
376                (Some(updated), Some(id)) => (ticket.updated_at, ticket.id) > (updated, id),
377                _ => true,
378            })
379            .cloned()
380            .collect::<Vec<_>>();
381        values.sort_by_key(|ticket| (ticket.updated_at, ticket.id));
382        values.truncate(filter.limit);
383        Ok(values)
384    }
385
386    async fn save(
387        &self,
388        ticket: Ticket,
389        expected_revision: u64,
390        intent: TicketActivityIntent,
391    ) -> Result<(), TicketStoreError> {
392        let mut state = self.state.lock().await;
393        let key = (ticket.project_id.clone(), ticket.id);
394        let existing = state
395            .tickets
396            .get(&key)
397            .ok_or(TicketStoreError::NotFound(ticket.id))?;
398        if existing.revision != expected_revision || ticket.revision <= expected_revision {
399            return Err(TicketStoreError::StaleRevision {
400                expected: expected_revision,
401                actual: existing.revision,
402            });
403        }
404        state.tickets.insert(key, ticket);
405        state.activity_intents.push(intent);
406        drop(state);
407        Ok(())
408    }
409
410    async fn insert_handoff(&self, handoff: SupportHandoff) -> Result<(), TicketStoreError> {
411        let mut state = self.state.lock().await;
412        if state.handoffs.contains_key(&handoff.digest) {
413            return Err(TicketStoreError::DuplicateHandoff);
414        }
415        state.handoffs.insert(
416            handoff.digest.clone(),
417            MemoryHandoff {
418                handoff,
419                completed_fingerprint: None,
420            },
421        );
422        drop(state);
423        Ok(())
424    }
425
426    async fn consume_and_create_ticket(
427        &self,
428        request: ConsumeHandoffRequest,
429    ) -> Result<ConsumedHandoff, TicketStoreError> {
430        let mut state = self.state.lock().await;
431        let mut staged = state.clone();
432        let digest = request.token.digest();
433        let matched_digest = staged
434            .handoffs
435            .keys()
436            .find(|candidate| {
437                candidate
438                    .as_str()
439                    .as_bytes()
440                    .ct_eq(digest.as_str().as_bytes())
441                    .into()
442            })
443            .cloned()
444            .ok_or(TicketStoreError::UnknownHandoff)?;
445        let entry = staged
446            .handoffs
447            .get_mut(&matched_digest)
448            .expect("matched key exists");
449        if entry.handoff.project_id != request.project_id {
450            return Err(TicketStoreError::WrongHandoffProject);
451        }
452        if entry.handoff.portal_origin != request.portal_origin {
453            return Err(TicketStoreError::WrongHandoffPortal);
454        }
455        if let Some(result) = entry.handoff.consumed_result.clone() {
456            if entry.completed_fingerprint.as_deref() != Some(&request.request_fingerprint) {
457                return Err(TicketStoreError::HandoffAlreadyConsumed);
458            }
459            let ticket = staged
460                .tickets
461                .get(&(request.project_id.clone(), TicketId(result.ticket_id)))
462                .cloned()
463                .ok_or_else(|| {
464                    TicketStoreError::Infrastructure("completed handoff ticket is missing".into())
465                })?;
466            return Ok(ConsumedHandoff {
467                ticket,
468                result,
469                repeated: true,
470            });
471        }
472        if entry.handoff.expires_at <= request.now {
473            return Err(TicketStoreError::ExpiredHandoff);
474        }
475        let project_id = entry.handoff.project_id.clone();
476        let requester_subject = entry.handoff.requester_subject.clone();
477        let resources = entry.handoff.context.resource_references.clone();
478        let correlation_id = entry.handoff.correlation_id;
479        let counter = staged
480            .display_counters
481            .get(&project_id)
482            .copied()
483            .unwrap_or(0)
484            .saturating_add(1);
485        let ticket = Ticket::create(
486            CreateTicketInput {
487                project_id: project_id.clone(),
488                subject: request.input.subject,
489                description: request.input.description,
490                requester: TicketRequester {
491                    subject: requester_subject,
492                    display_name: None,
493                    email: None,
494                },
495                channel: request.input.channel,
496                priority: request.input.priority,
497                resource_references: resources,
498            },
499            format!("TKT-{counter:06}"),
500            request.now,
501        )?;
502        let result = SupportHandoffResult {
503            ticket_id: ticket.id.0,
504            requester_session_id: Uuid::now_v7(),
505        };
506        let intent = TicketActivityIntent::new(
507            project_id.clone(),
508            ticket.id,
509            "ticketing.created_from_handoff",
510            correlation_id,
511            serde_json::json!({ "ticket_id": ticket.id, "handoff_id": entry.handoff.id }),
512            request.now,
513        );
514        entry.handoff.consumed_result = Some(result.clone());
515        entry.completed_fingerprint = Some(request.request_fingerprint);
516        staged.display_counters.insert(project_id.clone(), counter);
517        staged
518            .tickets
519            .insert((project_id, ticket.id), ticket.clone());
520        staged.activity_intents.push(intent);
521        if staged.fail_next_handoff_commit {
522            state.fail_next_handoff_commit = false;
523            return Err(TicketStoreError::Infrastructure(
524                "injected handoff transaction failure".into(),
525            ));
526        }
527        *state = staged;
528        drop(state);
529        Ok(ConsumedHandoff {
530            ticket,
531            result,
532            repeated: false,
533        })
534    }
535
536    async fn ingest_external_message(
537        &self,
538        request: IngestExternalMessageRequest,
539    ) -> Result<ExternalMessageIngestResult, TicketStoreError> {
540        let mut state = self.state.lock().await;
541        let external_key = (
542            request.identity.project_id.clone(),
543            request.identity.provider.clone(),
544            request.identity.mailbox_scope.clone(),
545            request.identity.external_id.clone(),
546        );
547        if let Some((existing, ticket_id)) = state.external_messages.get(&external_key) {
548            return if existing.content_sha256 == request.identity.content_sha256 {
549                let ticket = state
550                    .tickets
551                    .get(&(existing.project_id.clone(), *ticket_id))
552                    .cloned()
553                    .ok_or_else(|| {
554                        TicketStoreError::Infrastructure(
555                            "external message authoritative ticket is missing".into(),
556                        )
557                    })?;
558                Ok(ExternalMessageIngestResult {
559                    ticket,
560                    repeated: true,
561                })
562            } else {
563                Err(TicketStoreError::ExternalIdentityConflict)
564            };
565        }
566        let key = (request.identity.project_id.clone(), request.ticket_id);
567        let mut ticket = state
568            .tickets
569            .get(&key)
570            .cloned()
571            .ok_or(TicketStoreError::NotFound(request.ticket_id))?;
572        if ticket.revision != request.expected_revision {
573            return Err(TicketStoreError::StaleRevision {
574                expected: request.expected_revision,
575                actual: ticket.revision,
576            });
577        }
578        ticket.reply_as_requester(request.body, request.now)?;
579        let intent = TicketActivityIntent::new(
580            ticket.project_id.clone(),
581            ticket.id,
582            "ticketing.external_message_ingested",
583            request.correlation_id,
584            serde_json::json!({ "ticket_id": ticket.id }),
585            request.now,
586        );
587        state
588            .external_messages
589            .insert(external_key, (request.identity, request.ticket_id));
590        state.tickets.insert(key, ticket.clone());
591        state.activity_intents.push(intent);
592        drop(state);
593        Ok(ExternalMessageIngestResult {
594            ticket,
595            repeated: false,
596        })
597    }
598}
599
600#[derive(Debug, thiserror::Error)]
601pub enum TicketStoreError {
602    #[error(transparent)]
603    Validation(#[from] TicketValidationError),
604    #[error("ticket was not found: {0}")]
605    NotFound(TicketId),
606    #[error("ticket already exists: {0}")]
607    DuplicateTicket(TicketId),
608    #[error("ticket display reference already exists in the project")]
609    DuplicateDisplayReference,
610    #[error("ticket revision is stale: expected {expected}, actual {actual}")]
611    StaleRevision { expected: u64, actual: u64 },
612    #[error("ticket list fetch limit must be between 1 and 201")]
613    InvalidListLimit,
614    #[error("ticket list cursor must contain both timestamp and ticket ID")]
615    InvalidListCursor,
616    #[error("support handoff already exists")]
617    DuplicateHandoff,
618    #[error("support handoff is unknown")]
619    UnknownHandoff,
620    #[error("support handoff expired")]
621    ExpiredHandoff,
622    #[error("support handoff belongs to a different project")]
623    WrongHandoffProject,
624    #[error("support handoff belongs to a different portal")]
625    WrongHandoffPortal,
626    #[error("support handoff was already consumed")]
627    HandoffAlreadyConsumed,
628    #[error("external provider identity was reused with different content")]
629    ExternalIdentityConflict,
630    #[error("ticketing storage failed: {0}")]
631    Infrastructure(String),
632}
633
634#[cfg(test)]
635mod tests {
636    use super::*;
637    use crate::{TicketChannel, TicketPriority};
638    use chrono::TimeDelta;
639    use minco_interaction::{
640        SupportContext, SupportLocationPolicy, SupportSurface, issue_support_handoff,
641    };
642
643    fn issue(now: DateTime<Utc>) -> (SupportHandoff, SupportHandoffToken) {
644        let policy = SupportLocationPolicy {
645            portal_origin: "https://support.example.test".into(),
646            allowed_return_paths: BTreeMap::from([(
647                "https://app.example.test".into(),
648                vec!["/orders".into()],
649            )]),
650        };
651        let (handoff, grant) = issue_support_handoff(
652            "project-a",
653            "user-1",
654            vec!["ticketing.create".into()],
655            SupportSurface::Widget,
656            SupportContext {
657                page_url: "https://app.example.test/orders/1".into(),
658                ..SupportContext::default()
659            },
660            "https://app.example.test/orders/1",
661            Uuid::now_v7(),
662            &policy,
663            now,
664            TimeDelta::minutes(5),
665        )
666        .unwrap();
667        (handoff, grant.token)
668    }
669
670    fn consume(token: SupportHandoffToken, now: DateTime<Utc>) -> ConsumeHandoffRequest {
671        ConsumeHandoffRequest::new(
672            token,
673            "project-a",
674            "https://support.example.test",
675            TicketFromHandoffInput {
676                subject: "Help".into(),
677                description: "Broken".into(),
678                channel: TicketChannel::Portal,
679                priority: TicketPriority::Normal,
680            },
681            now,
682        )
683        .unwrap()
684    }
685
686    fn ingress(
687        ticket_id: TicketId,
688        content_sha256: &str,
689        now: DateTime<Utc>,
690    ) -> IngestExternalMessageRequest {
691        IngestExternalMessageRequest {
692            identity: ExternalMessageIdentity {
693                project_id: "project-a".into(),
694                provider: "example-mail".into(),
695                mailbox_scope: "support@example.test".into(),
696                external_id: "message-1".into(),
697                content_sha256: content_sha256.into(),
698                raw_message_object_key: Some("mail/project-a/message-1".into()),
699                internet_message_id: Some("<message-1@example.test>".into()),
700                in_reply_to: None,
701                references: Vec::new(),
702            },
703            ticket_id,
704            body: "External reply".into(),
705            expected_revision: 0,
706            correlation_id: Uuid::now_v7(),
707            now,
708        }
709    }
710
711    #[tokio::test]
712    async fn handoff_is_atomic_idempotent_project_scoped_and_rolls_back() {
713        let store = Arc::new(MemoryTicketingStore::default());
714        let now = Utc::now();
715        let (handoff, token) = issue(now);
716        let digest = handoff.digest.clone();
717        store.insert_handoff(handoff).await.unwrap();
718        store.fail_next_handoff_commit().await;
719        assert!(matches!(
720            store
721                .consume_and_create_ticket(consume(token.clone(), now))
722                .await,
723            Err(TicketStoreError::Infrastructure(_))
724        ));
725        assert_eq!(store.ticket_count().await, 0);
726        assert!(!store.handoff_consumed(&digest).await);
727
728        let first = store
729            .consume_and_create_ticket(consume(token.clone(), now))
730            .await
731            .unwrap();
732        let repeated = store
733            .consume_and_create_ticket(consume(token, now + TimeDelta::minutes(10)))
734            .await
735            .unwrap();
736        assert!(!first.repeated);
737        assert!(repeated.repeated);
738        assert_eq!(first.result, repeated.result);
739        assert_eq!(store.ticket_count().await, 1);
740        assert_eq!(store.activity_intents().await.len(), 1);
741    }
742
743    #[tokio::test]
744    async fn concurrent_double_consume_creates_one_authoritative_ticket() {
745        let store = Arc::new(MemoryTicketingStore::default());
746        let now = Utc::now();
747        let (handoff, token) = issue(now);
748        store.insert_handoff(handoff).await.unwrap();
749        let left = {
750            let store = store.clone();
751            let token = token.clone();
752            tokio::spawn(async move { store.consume_and_create_ticket(consume(token, now)).await })
753        };
754        let right = {
755            let store = store.clone();
756            tokio::spawn(async move { store.consume_and_create_ticket(consume(token, now)).await })
757        };
758        let (left, right) = tokio::join!(left, right);
759        assert!(left.unwrap().is_ok());
760        assert!(right.unwrap().is_ok());
761        assert_eq!(store.ticket_count().await, 1);
762    }
763
764    #[tokio::test]
765    async fn invalid_handoffs_fail_closed_and_different_replay_is_rejected() {
766        let now = Utc::now();
767
768        let store = MemoryTicketingStore::default();
769        let (handoff, token) = issue(now);
770        store.insert_handoff(handoff).await.unwrap();
771        assert!(matches!(
772            store
773                .consume_and_create_ticket(consume(token, now + TimeDelta::minutes(6)))
774                .await,
775            Err(TicketStoreError::ExpiredHandoff)
776        ));
777
778        let store = MemoryTicketingStore::default();
779        let (handoff, token) = issue(now);
780        store.insert_handoff(handoff).await.unwrap();
781        let mut wrong_project = consume(token, now);
782        wrong_project.project_id = "project-b".into();
783        assert!(matches!(
784            store.consume_and_create_ticket(wrong_project).await,
785            Err(TicketStoreError::WrongHandoffProject)
786        ));
787
788        let store = MemoryTicketingStore::default();
789        let (handoff, token) = issue(now);
790        store.insert_handoff(handoff).await.unwrap();
791        let mut wrong_portal = consume(token, now);
792        wrong_portal.portal_origin = "https://other.example.test".into();
793        assert!(matches!(
794            store.consume_and_create_ticket(wrong_portal).await,
795            Err(TicketStoreError::WrongHandoffPortal)
796        ));
797
798        let store = MemoryTicketingStore::default();
799        assert!(matches!(
800            store
801                .consume_and_create_ticket(consume(SupportHandoffToken::generate(), now))
802                .await,
803            Err(TicketStoreError::UnknownHandoff)
804        ));
805
806        let store = MemoryTicketingStore::default();
807        let (handoff, token) = issue(now);
808        store.insert_handoff(handoff).await.unwrap();
809        store
810            .consume_and_create_ticket(consume(token.clone(), now))
811            .await
812            .unwrap();
813        let mut different = consume(token, now);
814        different.input.description = "A different request".into();
815        different.request_fingerprint = "different-fingerprint".into();
816        assert!(matches!(
817            store.consume_and_create_ticket(different).await,
818            Err(TicketStoreError::HandoffAlreadyConsumed)
819        ));
820    }
821
822    #[tokio::test]
823    async fn external_identity_replay_returns_authoritative_result_and_conflict_fails() {
824        let store = MemoryTicketingStore::default();
825        let now = Utc::now();
826        let ticket = Ticket::create(
827            CreateTicketInput {
828                project_id: "project-a".into(),
829                subject: "Help".into(),
830                description: "Broken".into(),
831                requester: TicketRequester {
832                    subject: "user".into(),
833                    display_name: None,
834                    email: None,
835                },
836                channel: TicketChannel::Api,
837                priority: TicketPriority::Normal,
838                resource_references: Vec::new(),
839            },
840            "TKT-EXTERNAL",
841            now,
842        )
843        .unwrap();
844        let created = TicketActivityIntent::new(
845            "project-a",
846            ticket.id,
847            "created",
848            Uuid::now_v7(),
849            serde_json::json!({}),
850            now,
851        );
852        store.create(ticket.clone(), created).await.unwrap();
853
854        let digest = "a".repeat(64);
855        let first = store
856            .ingest_external_message(ingress(ticket.id, &digest, now))
857            .await
858            .unwrap();
859        let repeated = store
860            .ingest_external_message(ingress(ticket.id, &digest, now))
861            .await
862            .unwrap();
863        assert!(!first.repeated);
864        assert!(repeated.repeated);
865        assert_eq!(first.ticket, repeated.ticket);
866        assert_eq!(first.ticket.revision, 1);
867        assert_eq!(store.activity_intents().await.len(), 2);
868
869        assert!(matches!(
870            store
871                .ingest_external_message(ingress(ticket.id, &"b".repeat(64), now))
872                .await,
873            Err(TicketStoreError::ExternalIdentityConflict)
874        ));
875        assert_eq!(
876            store.get("project-a", ticket.id).await.unwrap(),
877            Some(first.ticket)
878        );
879    }
880
881    #[tokio::test]
882    async fn stale_revision_and_project_isolation_fail_closed() {
883        let store = MemoryTicketingStore::default();
884        let now = Utc::now();
885        let ticket = Ticket::create(
886            CreateTicketInput {
887                project_id: "project-a".into(),
888                subject: "Help".into(),
889                description: "Broken".into(),
890                requester: TicketRequester {
891                    subject: "user".into(),
892                    display_name: None,
893                    email: None,
894                },
895                channel: TicketChannel::Api,
896                priority: TicketPriority::Normal,
897                resource_references: Vec::new(),
898            },
899            "TKT-1",
900            now,
901        )
902        .unwrap();
903        let intent = TicketActivityIntent::new(
904            "project-a",
905            ticket.id,
906            "created",
907            Uuid::now_v7(),
908            serde_json::json!({}),
909            now,
910        );
911        store.create(ticket.clone(), intent).await.unwrap();
912        assert!(store.get("project-b", ticket.id).await.unwrap().is_none());
913        let mut changed = ticket.clone();
914        changed.change_priority(TicketPriority::High, now);
915        let intent = TicketActivityIntent::new(
916            "project-a",
917            changed.id,
918            "changed",
919            Uuid::now_v7(),
920            serde_json::json!({}),
921            now,
922        );
923        assert!(matches!(
924            store.save(changed, 1, intent).await,
925            Err(TicketStoreError::StaleRevision { .. })
926        ));
927    }
928}