1use chrono::{DateTime, Utc};
5use sqlx_core::{from_row::FromRow, query::query, query_as::query_as, row::Row};
6use sqlx_postgres::PgRow;
7use stateknot_core::{
8 AuthorizationReceiptId, BoxFuture, InvocationId, RunId, TenantId, Timestamp,
9 ToolAuthorizationOperation, ToolAuthorizationReceipt, ToolAuthorizationReceiptSink,
10 ToolAuthorizationReceiptSinkError, ToolAuthorizationReceiptSinkFailure, ToolInvocationIntent,
11};
12use uuid::Uuid;
13
14use super::{
15 MAX_TOOL_INVOCATION_INTENT_BYTES, PostgresStore, StoreError, decode_digest, from_database_time,
16 has_database_constraint, to_database_time,
17};
18
19const MAX_RECEIPT_BYTES: usize = 65_536;
20
21const SELECT_RECEIPT: &str = r"
22SELECT
23 tenant_id,
24 receipt_id,
25 run_id,
26 thread_id,
27 invocation_id,
28 attempt_id,
29 origin_event_id,
30 operation,
31 descriptor_digest,
32 input_digest,
33 subject_digest,
34 policy_digest,
35 decision_digest,
36 authorization_window_id,
37 receipt_digest,
38 has_recovery_handle,
39 authorized_at,
40 recorded_at,
41 receipt_bytes,
42 receipt_bytes_digest
43FROM stateknot.tool_authorization_receipts
44WHERE tenant_id = $1 AND receipt_id = $2
45";
46
47const SELECT_INVOCATION_AUTHORIZATION_BOUNDARY: &str = r"
48SELECT
49 invocation.intent_bytes,
50 invocation.current_status,
51 invocation.current_attempt_id,
52 run.thread_id,
53 revision.journal_event_id
54FROM stateknot.tool_invocations AS invocation
55JOIN stateknot.runs AS run
56 ON run.tenant_id = invocation.tenant_id
57 AND run.run_id = invocation.run_id
58JOIN stateknot.tool_invocation_revisions AS revision
59 ON revision.tenant_id = invocation.tenant_id
60 AND revision.run_id = invocation.run_id
61 AND revision.invocation_id = invocation.invocation_id
62 AND revision.revision = invocation.current_revision
63 AND revision.record_digest = invocation.current_record_digest
64WHERE invocation.tenant_id = $1
65 AND invocation.run_id = $2
66 AND invocation.invocation_id = $3
67FOR UPDATE OF invocation
68";
69
70const SELECT_RECEIPT_PAGE: &str = r"
71SELECT
72 tenant_id,
73 receipt_id,
74 run_id,
75 thread_id,
76 invocation_id,
77 attempt_id,
78 origin_event_id,
79 operation,
80 descriptor_digest,
81 input_digest,
82 subject_digest,
83 policy_digest,
84 decision_digest,
85 authorization_window_id,
86 receipt_digest,
87 has_recovery_handle,
88 authorized_at,
89 recorded_at,
90 receipt_bytes,
91 receipt_bytes_digest
92FROM stateknot.tool_authorization_receipts
93WHERE tenant_id = $1
94 AND run_id = $2
95 AND invocation_id = $3
96 AND (recorded_at, receipt_id) > ($4, $5)
97ORDER BY recorded_at ASC, receipt_id ASC
98LIMIT $6
99";
100
101#[derive(Clone, Copy, Debug, Eq, PartialEq)]
103#[non_exhaustive]
104pub enum ToolAuthorizationReceiptOutcome {
105 Recorded,
107 Idempotent,
109}
110
111#[derive(Clone, Debug, Eq, PartialEq)]
113pub struct StoredToolAuthorizationReceipt {
114 receipt: ToolAuthorizationReceipt,
115 recorded_at: Timestamp,
116}
117
118impl StoredToolAuthorizationReceipt {
119 #[must_use]
121 pub const fn receipt(&self) -> &ToolAuthorizationReceipt {
122 &self.receipt
123 }
124
125 #[must_use]
127 pub const fn recorded_at(&self) -> Timestamp {
128 self.recorded_at
129 }
130}
131
132#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
134pub struct ToolAuthorizationReceiptPageSize(u8);
135
136impl ToolAuthorizationReceiptPageSize {
137 pub const MAX: u8 = 100;
139
140 pub const fn new(value: u8) -> Result<Self, StoreError> {
147 if value == 0 || value > Self::MAX {
148 return Err(StoreError::InvalidToolAuthorizationReceiptPageSize);
149 }
150 Ok(Self(value))
151 }
152
153 #[must_use]
155 pub const fn get(self) -> u8 {
156 self.0
157 }
158}
159
160#[derive(Clone, Debug)]
162pub struct ToolAuthorizationReceiptPage {
163 records: Vec<StoredToolAuthorizationReceipt>,
164 has_more: bool,
165}
166
167impl ToolAuthorizationReceiptPage {
168 #[must_use]
170 pub fn records(&self) -> &[StoredToolAuthorizationReceipt] {
171 &self.records
172 }
173
174 #[must_use]
176 pub const fn has_more(&self) -> bool {
177 self.has_more
178 }
179
180 #[must_use]
182 pub fn next_cursor(&self) -> Option<StoredToolAuthorizationReceipt> {
183 self.records.last().cloned()
184 }
185}
186
187impl PostgresStore {
188 #[allow(clippy::too_many_lines)]
200 pub async fn record_tool_authorization_receipt(
201 &self,
202 receipt: ToolAuthorizationReceipt,
203 ) -> Result<ToolAuthorizationReceiptOutcome, StoreError> {
204 let receipt_bytes = encode_receipt(&receipt)?;
205 let provenance = receipt.provenance();
206 let operation = operation_text(receipt.operation())
207 .ok_or(StoreError::InvalidToolAuthorizationReceipt)?;
208 let mut transaction = self.begin_mutation("Tool authorization receipt").await?;
209
210 if let Some(row) = query_as::<_, ToolAuthorizationReceiptRow>(SELECT_RECEIPT)
211 .bind(provenance.tenant_id().as_str())
212 .bind(*receipt.receipt_id().as_uuid())
213 .fetch_optional(&mut *transaction)
214 .await
215 .map_err(|source| StoreError::database("Tool authorization receipt retry", source))?
216 {
217 let stored = decode_receipt(&row)?;
218 if stored.receipt != receipt || encode_receipt(&stored.receipt)? != receipt_bytes {
219 return Err(StoreError::ToolAuthorizationReceiptConflict);
220 }
221 transaction.commit().await.map_err(|source| {
222 StoreError::database("Tool authorization receipt retry commit", source)
223 })?;
224 return Ok(ToolAuthorizationReceiptOutcome::Idempotent);
225 }
226
227 super::skill_activation_windows::validate_receipt_window(&mut transaction, &receipt)
228 .await?;
229 let boundary =
230 query_as::<_, ToolAuthorizationBoundaryRow>(SELECT_INVOCATION_AUTHORIZATION_BOUNDARY)
231 .bind(provenance.tenant_id().as_str())
232 .bind(*provenance.run_id().as_uuid())
233 .bind(*provenance.invocation_id().as_uuid())
234 .fetch_optional(&mut *transaction)
235 .await
236 .map_err(|source| StoreError::database("Tool authorization boundary", source))?
237 .ok_or(StoreError::ToolAuthorizationReceiptNotFound)?;
238 validate_boundary(&receipt, &boundary)?;
239
240 let inserted = query(
241 r"
242INSERT INTO stateknot.tool_authorization_receipts (
243 tenant_id,
244 receipt_id,
245 run_id,
246 thread_id,
247 invocation_id,
248 attempt_id,
249 origin_event_id,
250 operation,
251 descriptor_digest,
252 input_digest,
253 subject_digest,
254 policy_digest,
255 decision_digest,
256 authorization_window_id,
257 receipt_digest,
258 has_recovery_handle,
259 authorized_at,
260 receipt_bytes
261)
262VALUES (
263 $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18
264)
265ON CONFLICT (tenant_id, receipt_id) DO NOTHING
266",
267 )
268 .bind(provenance.tenant_id().as_str())
269 .bind(*receipt.receipt_id().as_uuid())
270 .bind(*provenance.run_id().as_uuid())
271 .bind(*provenance.thread_id().as_uuid())
272 .bind(*provenance.invocation_id().as_uuid())
273 .bind(*provenance.attempt_id().as_uuid())
274 .bind(*provenance.origin_event_id().as_uuid())
275 .bind(operation)
276 .bind(receipt.descriptor_digest().as_bytes())
277 .bind(receipt.input_digest().as_bytes())
278 .bind(receipt.subject_digest().as_bytes())
279 .bind(receipt.policy_digest().as_bytes())
280 .bind(receipt.decision_digest().as_bytes())
281 .bind(receipt.authorization_window_id().map(|id| *id.as_uuid()))
282 .bind(receipt.receipt_digest().as_bytes())
283 .bind(receipt.has_recovery_handle())
284 .bind(to_database_time(receipt.authorized_at())?)
285 .bind(receipt_bytes.clone())
286 .execute(&mut *transaction)
287 .await
288 .map_err(map_receipt_insert_error)?
289 .rows_affected();
290
291 let row = query_as::<_, ToolAuthorizationReceiptRow>(SELECT_RECEIPT)
292 .bind(provenance.tenant_id().as_str())
293 .bind(*receipt.receipt_id().as_uuid())
294 .fetch_optional(&mut *transaction)
295 .await
296 .map_err(|source| StoreError::database("Tool authorization receipt verify", source))?
297 .ok_or(StoreError::ToolAuthorizationReceiptConflict)?;
298 let stored = decode_receipt(&row)?;
299 if stored.receipt != receipt || encode_receipt(&stored.receipt)? != receipt_bytes {
300 return Err(StoreError::ToolAuthorizationReceiptConflict);
301 }
302 transaction
303 .commit()
304 .await
305 .map_err(|source| StoreError::database("Tool authorization receipt commit", source))?;
306 Ok(if inserted == 1 {
307 ToolAuthorizationReceiptOutcome::Recorded
308 } else {
309 ToolAuthorizationReceiptOutcome::Idempotent
310 })
311 }
312
313 pub async fn load_tool_authorization_receipt(
319 &self,
320 tenant_id: &TenantId,
321 receipt_id: AuthorizationReceiptId,
322 ) -> Result<StoredToolAuthorizationReceipt, StoreError> {
323 let mut transaction = self
324 .begin_repeatable_read("Tool authorization receipt load")
325 .await?;
326 let row = query_as::<_, ToolAuthorizationReceiptRow>(SELECT_RECEIPT)
327 .bind(tenant_id.as_str())
328 .bind(*receipt_id.as_uuid())
329 .fetch_optional(&mut *transaction)
330 .await
331 .map_err(|source| StoreError::database("Tool authorization receipt load", source))?
332 .ok_or(StoreError::ToolAuthorizationReceiptNotFound)?;
333 let stored = decode_receipt(&row)?;
334 if stored.receipt.provenance().tenant_id() != tenant_id
335 || stored.receipt.receipt_id() != receipt_id
336 {
337 return Err(StoreError::corrupt("Tool authorization receipt scope"));
338 }
339 transaction.commit().await.map_err(|source| {
340 StoreError::database("Tool authorization receipt load commit", source)
341 })?;
342 Ok(stored)
343 }
344
345 pub async fn load_tool_authorization_receipt_page(
353 &self,
354 tenant_id: &TenantId,
355 run_id: RunId,
356 invocation_id: InvocationId,
357 after: Option<&StoredToolAuthorizationReceipt>,
358 page_size: ToolAuthorizationReceiptPageSize,
359 ) -> Result<ToolAuthorizationReceiptPage, StoreError> {
360 if after.is_some_and(|cursor| {
361 let provenance = cursor.receipt.provenance();
362 provenance.tenant_id() != tenant_id
363 || provenance.run_id() != run_id
364 || provenance.invocation_id() != invocation_id
365 }) {
366 return Err(StoreError::InvalidToolAuthorizationReceiptCursor);
367 }
368 let mut transaction = self
369 .begin_repeatable_read("Tool authorization receipt page")
370 .await?;
371 if let Some(cursor) = after {
372 let row = query_as::<_, ToolAuthorizationReceiptRow>(SELECT_RECEIPT)
373 .bind(tenant_id.as_str())
374 .bind(*cursor.receipt.receipt_id().as_uuid())
375 .fetch_optional(&mut *transaction)
376 .await
377 .map_err(|source| {
378 StoreError::database("Tool authorization receipt cursor", source)
379 })?
380 .ok_or(StoreError::InvalidToolAuthorizationReceiptCursor)?;
381 if decode_receipt(&row)? != *cursor {
382 return Err(StoreError::InvalidToolAuthorizationReceiptCursor);
383 }
384 }
385 let (after_time, after_id) = after.map_or(
386 (
387 to_database_time(Timestamp::MIN)
388 .expect("minimum core timestamp fits qualified PostgreSQL"),
389 Uuid::nil(),
390 ),
391 |cursor| {
392 (
393 to_database_time(cursor.recorded_at)
394 .expect("validated stored receipt time remains representable"),
395 *cursor.receipt.receipt_id().as_uuid(),
396 )
397 },
398 );
399 let limit = i64::from(page_size.get()) + 1;
400 let rows = query_as::<_, ToolAuthorizationReceiptRow>(SELECT_RECEIPT_PAGE)
401 .bind(tenant_id.as_str())
402 .bind(*run_id.as_uuid())
403 .bind(*invocation_id.as_uuid())
404 .bind(after_time)
405 .bind(after_id)
406 .bind(limit)
407 .fetch_all(&mut *transaction)
408 .await
409 .map_err(|source| StoreError::database("Tool authorization receipt page", source))?;
410 let mut records = rows
411 .into_iter()
412 .map(|row| decode_receipt(&row))
413 .collect::<Result<Vec<_>, _>>()?;
414 let has_more = records.len() > usize::from(page_size.get());
415 if has_more {
416 records.pop();
417 }
418 transaction.commit().await.map_err(|source| {
419 StoreError::database("Tool authorization receipt page commit", source)
420 })?;
421 Ok(ToolAuthorizationReceiptPage { records, has_more })
422 }
423}
424
425impl ToolAuthorizationReceiptSink for PostgresStore {
426 fn record(
427 &self,
428 receipt: ToolAuthorizationReceipt,
429 ) -> BoxFuture<'_, Result<(), ToolAuthorizationReceiptSinkError>> {
430 Box::pin(async move {
431 self.record_tool_authorization_receipt(receipt)
432 .await
433 .map(|_| ())
434 .map_err(|source| {
435 let failure = receipt_sink_failure(&source);
436 ToolAuthorizationReceiptSinkError::new(failure, source)
437 })
438 })
439 }
440}
441
442fn receipt_sink_failure(error: &StoreError) -> ToolAuthorizationReceiptSinkFailure {
443 match error {
444 StoreError::Database { .. }
445 | StoreError::Migration { .. }
446 | StoreError::UnsupportedServerVersion
447 | StoreError::SchemaNotMigrated
448 | StoreError::IncompatibleSchema
449 | StoreError::IncompleteSchema => ToolAuthorizationReceiptSinkFailure::Unavailable,
450 _ => ToolAuthorizationReceiptSinkFailure::Rejected,
451 }
452}
453
454fn validate_boundary(
455 receipt: &ToolAuthorizationReceipt,
456 boundary: &ToolAuthorizationBoundaryRow,
457) -> Result<(), StoreError> {
458 if boundary.intent_bytes.is_empty()
459 || boundary.intent_bytes.len() > MAX_TOOL_INVOCATION_INTENT_BYTES
460 {
461 return Err(StoreError::corrupt(
462 "Tool authorization invocation intent size",
463 ));
464 }
465 let intent = serde_json::from_slice::<ToolInvocationIntent>(&boundary.intent_bytes)
466 .map_err(|_| StoreError::corrupt("Tool authorization invocation intent"))?;
467 let canonical = serde_json_canonicalizer::to_vec(&intent)
468 .map_err(|_| StoreError::corrupt("Tool authorization invocation canonicalization"))?;
469 if canonical != boundary.intent_bytes {
470 return Err(StoreError::corrupt(
471 "Tool authorization invocation canonical bytes",
472 ));
473 }
474 let provenance = receipt.provenance();
475 let thread_id = stateknot_core::ThreadId::from_uuid(boundary.thread_id)
476 .map_err(|_| StoreError::corrupt("Tool authorization thread identity"))?;
477 let attempt_id = boundary
478 .current_attempt_id
479 .map(stateknot_core::AttemptId::from_uuid)
480 .transpose()
481 .map_err(|_| StoreError::corrupt("Tool authorization attempt identity"))?;
482 let origin_event_id = stateknot_core::EventId::from_uuid(boundary.journal_event_id)
483 .map_err(|_| StoreError::corrupt("Tool authorization event identity"))?;
484 let expected_status = match receipt.operation() {
485 ToolAuthorizationOperation::Execute => "executing",
486 ToolAuthorizationOperation::Reconcile => "unknown",
487 _ => return Err(StoreError::InvalidToolAuthorizationReceipt),
488 };
489 let descriptor = intent.descriptor();
490 if intent.tenant_id() != provenance.tenant_id()
491 || intent.run_id() != provenance.run_id()
492 || intent.invocation_id() != provenance.invocation_id()
493 || thread_id != provenance.thread_id()
494 || attempt_id != Some(provenance.attempt_id())
495 || origin_event_id != provenance.origin_event_id()
496 || boundary.current_status != expected_status
497 || descriptor.metadata().identity() != receipt.tool()
498 || ToolAuthorizationReceipt::digest_descriptor(descriptor)
499 .map_err(|_| StoreError::InvalidToolAuthorizationReceipt)?
500 != receipt.descriptor_digest()
501 || ToolAuthorizationReceipt::digest_input(intent.input())
502 .map_err(|_| StoreError::InvalidToolAuthorizationReceipt)?
503 != receipt.input_digest()
504 {
505 return Err(StoreError::InvalidToolAuthorizationReceipt);
506 }
507 Ok(())
508}
509
510fn encode_receipt(receipt: &ToolAuthorizationReceipt) -> Result<Vec<u8>, StoreError> {
511 let bytes = serde_json_canonicalizer::to_vec(receipt)
512 .map_err(|_| StoreError::encoding("Tool authorization receipt"))?;
513 if bytes.is_empty() || bytes.len() > MAX_RECEIPT_BYTES {
514 return Err(StoreError::InvalidToolAuthorizationReceipt);
515 }
516 Ok(bytes)
517}
518
519fn decode_receipt(
520 row: &ToolAuthorizationReceiptRow,
521) -> Result<StoredToolAuthorizationReceipt, StoreError> {
522 if row.receipt_bytes.is_empty() || row.receipt_bytes.len() > MAX_RECEIPT_BYTES {
523 return Err(StoreError::corrupt("Tool authorization receipt size"));
524 }
525 let receipt = serde_json::from_slice::<ToolAuthorizationReceipt>(&row.receipt_bytes)
526 .map_err(|_| StoreError::corrupt("Tool authorization receipt value"))?;
527 let canonical = serde_json_canonicalizer::to_vec(&receipt)
528 .map_err(|_| StoreError::corrupt("Tool authorization receipt canonicalization"))?;
529 if canonical != row.receipt_bytes {
530 return Err(StoreError::corrupt(
531 "Tool authorization receipt canonical bytes",
532 ));
533 }
534 let provenance = receipt.provenance();
535 let tenant_id = TenantId::try_from(row.tenant_id.as_str())
536 .map_err(|_| StoreError::corrupt("Tool authorization receipt tenant"))?;
537 let receipt_id = AuthorizationReceiptId::from_uuid(row.receipt_id)
538 .map_err(|_| StoreError::corrupt("Tool authorization receipt identity"))?;
539 let run_id = RunId::from_uuid(row.run_id)
540 .map_err(|_| StoreError::corrupt("Tool authorization receipt run"))?;
541 let thread_id = stateknot_core::ThreadId::from_uuid(row.thread_id)
542 .map_err(|_| StoreError::corrupt("Tool authorization receipt thread"))?;
543 let invocation_id = InvocationId::from_uuid(row.invocation_id)
544 .map_err(|_| StoreError::corrupt("Tool authorization receipt invocation"))?;
545 let attempt_id = stateknot_core::AttemptId::from_uuid(row.attempt_id)
546 .map_err(|_| StoreError::corrupt("Tool authorization receipt attempt"))?;
547 let origin_event_id = stateknot_core::EventId::from_uuid(row.origin_event_id)
548 .map_err(|_| StoreError::corrupt("Tool authorization receipt event"))?;
549 let recorded_at = from_database_time(row.recorded_at)?;
550 if tenant_id != *provenance.tenant_id()
551 || receipt_id != receipt.receipt_id()
552 || run_id != provenance.run_id()
553 || thread_id != provenance.thread_id()
554 || invocation_id != provenance.invocation_id()
555 || attempt_id != provenance.attempt_id()
556 || origin_event_id != provenance.origin_event_id()
557 || Some(row.operation.as_str()) != operation_text(receipt.operation())
558 || decode_digest(
559 &row.descriptor_digest,
560 "Tool authorization descriptor digest",
561 )? != receipt.descriptor_digest()
562 || decode_digest(&row.input_digest, "Tool authorization input digest")?
563 != receipt.input_digest()
564 || decode_digest(&row.subject_digest, "Tool authorization subject digest")?
565 != receipt.subject_digest()
566 || decode_digest(&row.policy_digest, "Tool authorization policy digest")?
567 != receipt.policy_digest()
568 || decode_digest(&row.decision_digest, "Tool authorization decision digest")?
569 != receipt.decision_digest()
570 || row.authorization_window_id != receipt.authorization_window_id().map(|id| *id.as_uuid())
571 || decode_digest(&row.receipt_digest, "Tool authorization receipt digest")?
572 != receipt.receipt_digest()
573 || decode_digest(
574 &row.receipt_bytes_digest,
575 "Tool authorization receipt bytes digest",
576 )? != stateknot_core::Digest::sha256(&row.receipt_bytes)
577 || row.has_recovery_handle != receipt.has_recovery_handle()
578 || from_database_time(row.authorized_at)? != receipt.authorized_at()
579 || recorded_at < receipt.authorized_at()
580 {
581 return Err(StoreError::corrupt("Tool authorization receipt projection"));
582 }
583 Ok(StoredToolAuthorizationReceipt {
584 receipt,
585 recorded_at,
586 })
587}
588
589const fn operation_text(operation: ToolAuthorizationOperation) -> Option<&'static str> {
590 match operation {
591 ToolAuthorizationOperation::Execute => Some("execute"),
592 ToolAuthorizationOperation::Reconcile => Some("reconcile"),
593 _ => None,
594 }
595}
596
597fn map_receipt_insert_error(source: sqlx_core::Error) -> StoreError {
598 if has_database_constraint(&source, "tool_authorization_receipts_run_thread_fk")
599 || has_database_constraint(&source, "tool_authorization_receipts_attempt_event_fk")
600 || has_database_constraint(&source, "tool_authorization_receipts_window_fk")
601 {
602 StoreError::ToolAuthorizationReceiptNotFound
603 } else if has_database_constraint(&source, "tool_authorization_receipts_ids_are_uuid_v7")
604 || has_database_constraint(&source, "tool_authorization_receipts_operation_valid")
605 || has_database_constraint(&source, "tool_authorization_receipts_digest_lengths")
606 || has_database_constraint(&source, "tool_authorization_receipts_bytes_bounded")
607 || has_database_constraint(&source, "tool_authorization_receipts_clock_valid")
608 || has_database_constraint(&source, "tool_authorization_receipts_window_uuid_v7")
609 {
610 StoreError::InvalidToolAuthorizationReceipt
611 } else {
612 StoreError::database("Tool authorization receipt insert", source)
613 }
614}
615
616struct ToolAuthorizationBoundaryRow {
617 intent_bytes: Vec<u8>,
618 current_status: String,
619 current_attempt_id: Option<Uuid>,
620 thread_id: Uuid,
621 journal_event_id: Uuid,
622}
623
624impl<'row> FromRow<'row, PgRow> for ToolAuthorizationBoundaryRow {
625 fn from_row(row: &'row PgRow) -> Result<Self, sqlx_core::Error> {
626 Ok(Self {
627 intent_bytes: row.try_get("intent_bytes")?,
628 current_status: row.try_get("current_status")?,
629 current_attempt_id: row.try_get("current_attempt_id")?,
630 thread_id: row.try_get("thread_id")?,
631 journal_event_id: row.try_get("journal_event_id")?,
632 })
633 }
634}
635
636struct ToolAuthorizationReceiptRow {
637 tenant_id: String,
638 receipt_id: Uuid,
639 run_id: Uuid,
640 thread_id: Uuid,
641 invocation_id: Uuid,
642 attempt_id: Uuid,
643 origin_event_id: Uuid,
644 operation: String,
645 descriptor_digest: Vec<u8>,
646 input_digest: Vec<u8>,
647 subject_digest: Vec<u8>,
648 policy_digest: Vec<u8>,
649 decision_digest: Vec<u8>,
650 authorization_window_id: Option<Uuid>,
651 receipt_digest: Vec<u8>,
652 has_recovery_handle: bool,
653 authorized_at: DateTime<Utc>,
654 recorded_at: DateTime<Utc>,
655 receipt_bytes: Vec<u8>,
656 receipt_bytes_digest: Vec<u8>,
657}
658
659impl<'row> FromRow<'row, PgRow> for ToolAuthorizationReceiptRow {
660 fn from_row(row: &'row PgRow) -> Result<Self, sqlx_core::Error> {
661 Ok(Self {
662 tenant_id: row.try_get("tenant_id")?,
663 receipt_id: row.try_get("receipt_id")?,
664 run_id: row.try_get("run_id")?,
665 thread_id: row.try_get("thread_id")?,
666 invocation_id: row.try_get("invocation_id")?,
667 attempt_id: row.try_get("attempt_id")?,
668 origin_event_id: row.try_get("origin_event_id")?,
669 operation: row.try_get("operation")?,
670 descriptor_digest: row.try_get("descriptor_digest")?,
671 input_digest: row.try_get("input_digest")?,
672 subject_digest: row.try_get("subject_digest")?,
673 policy_digest: row.try_get("policy_digest")?,
674 decision_digest: row.try_get("decision_digest")?,
675 authorization_window_id: row.try_get("authorization_window_id")?,
676 receipt_digest: row.try_get("receipt_digest")?,
677 has_recovery_handle: row.try_get("has_recovery_handle")?,
678 authorized_at: row.try_get("authorized_at")?,
679 recorded_at: row.try_get("recorded_at")?,
680 receipt_bytes: row.try_get("receipt_bytes")?,
681 receipt_bytes_digest: row.try_get("receipt_bytes_digest")?,
682 })
683 }
684}