cloacina 0.6.0

A Rust library for resilient task execution and orchestration.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

/*
 *  Copyright 2025-2026 Colliery Software
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

//! Database models for workflow package metadata.
//!
//! This module defines domain structures for workflow package metadata.
//! These are API-level types; backend-specific models handle database storage.

use crate::database::universal_types::{UniversalTimestamp, UniversalUuid};
use serde::{Deserialize, Serialize};

/// Storage type for workflow binary data.
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum StorageType {
    /// Binary stored in workflow_registry database table
    Database,
    /// Binary stored on filesystem at {storage_dir}/{registry_id}.so
    Filesystem,
}

impl StorageType {
    pub fn as_str(&self) -> &'static str {
        match self {
            StorageType::Database => "database",
            StorageType::Filesystem => "filesystem",
        }
    }
}

impl std::str::FromStr for StorageType {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(match s.to_lowercase().as_str() {
            "filesystem" => StorageType::Filesystem,
            _ => StorageType::Database, // Default to database for backward compatibility
        })
    }
}

impl std::fmt::Display for StorageType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

/// Domain model for workflow package metadata.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkflowPackage {
    pub id: UniversalUuid,
    pub registry_id: UniversalUuid,
    pub package_name: String,
    pub version: String,
    pub description: Option<String>,
    pub author: Option<String>,
    pub metadata: String,
    pub storage_type: StorageType,
    pub created_at: UniversalTimestamp,
    pub updated_at: UniversalTimestamp,
    pub tenant_id: Option<String>,
    pub content_hash: String,
    pub superseded: bool,
    pub compiled_data: Option<Vec<u8>>,
    pub build_status: String,
    pub build_error: Option<String>,
    pub build_claimed_at: Option<UniversalTimestamp>,
    pub compiled_at: Option<UniversalTimestamp>,
}

/// Model for creating new workflow package metadata entries (domain type).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NewWorkflowPackage {
    pub registry_id: UniversalUuid,
    pub package_name: String,
    pub version: String,
    pub description: Option<String>,
    pub author: Option<String>,
    pub metadata: String,
    pub storage_type: StorageType,
}

impl NewWorkflowPackage {
    pub fn new(
        registry_id: UniversalUuid,
        package_name: String,
        version: String,
        description: Option<String>,
        author: Option<String>,
        metadata: String,
        storage_type: StorageType,
    ) -> Self {
        Self {
            registry_id,
            package_name,
            version,
            description,
            author,
            metadata,
            storage_type,
        }
    }
}