barbacane-control 0.7.0

Barbacane control plane — spec compilation and management CLI
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Artifacts repository for CRUD operations.

use sqlx::PgPool;
use uuid::Uuid;

use super::models::Artifact;

/// Repository for artifact operations.
#[derive(Clone)]
pub struct ArtifactsRepository {
    pool: PgPool,
}

impl ArtifactsRepository {
    /// Create a new artifacts repository.
    pub fn new(pool: PgPool) -> Self {
        Self { pool }
    }

    /// Store a new artifact.
    pub async fn create(
        &self,
        project_id: Option<Uuid>,
        manifest: serde_json::Value,
        data: Vec<u8>,
        sha256: &str,
        compiler_version: &str,
    ) -> Result<Artifact, sqlx::Error> {
        let size_bytes = data.len() as i64;
        sqlx::query_as::<_, Artifact>(
            r#"
            INSERT INTO artifacts (project_id, manifest, data, sha256, size_bytes, compiler_version)
            VALUES ($1, $2, $3, $4, $5, $6)
            RETURNING *
            "#,
        )
        .bind(project_id)
        .bind(&manifest)
        .bind(&data)
        .bind(sha256)
        .bind(size_bytes)
        .bind(compiler_version)
        .fetch_one(&self.pool)
        .await
    }

    /// List all artifacts.
    pub async fn list(&self) -> Result<Vec<Artifact>, sqlx::Error> {
        sqlx::query_as::<_, Artifact>("SELECT * FROM artifacts ORDER BY compiled_at DESC")
            .fetch_all(&self.pool)
            .await
    }

    /// List artifacts for a project.
    pub async fn list_for_project(&self, project_id: Uuid) -> Result<Vec<Artifact>, sqlx::Error> {
        sqlx::query_as::<_, Artifact>(
            "SELECT * FROM artifacts WHERE project_id = $1 ORDER BY compiled_at DESC",
        )
        .bind(project_id)
        .fetch_all(&self.pool)
        .await
    }

    /// Get an artifact by ID (metadata only).
    pub async fn get(&self, id: Uuid) -> Result<Option<Artifact>, sqlx::Error> {
        sqlx::query_as::<_, Artifact>("SELECT * FROM artifacts WHERE id = $1")
            .bind(id)
            .fetch_optional(&self.pool)
            .await
    }

    /// Get the binary data of an artifact for download.
    pub async fn get_data(&self, id: Uuid) -> Result<Option<Vec<u8>>, sqlx::Error> {
        let row: Option<(Vec<u8>,)> = sqlx::query_as("SELECT data FROM artifacts WHERE id = $1")
            .bind(id)
            .fetch_optional(&self.pool)
            .await?;
        Ok(row.map(|(data,)| data))
    }

    /// Check if any artifact's manifest references a given plugin name+version.
    pub async fn plugin_is_referenced(
        &self,
        name: &str,
        version: &str,
    ) -> Result<bool, sqlx::Error> {
        // The artifact manifest is JSONB with a `plugins` array of objects
        // containing `name` and `version` fields. Use the @> containment operator.
        let exists: bool = sqlx::query_scalar(
            r#"
            SELECT EXISTS(
                SELECT 1 FROM artifacts
                WHERE manifest->'plugins' @> jsonb_build_array(
                    jsonb_build_object('name', $1::text, 'version', $2::text)
                )
            )
            "#,
        )
        .bind(name)
        .bind(version)
        .fetch_one(&self.pool)
        .await?;
        Ok(exists)
    }

    /// Delete an artifact.
    pub async fn delete(&self, id: Uuid) -> Result<bool, sqlx::Error> {
        let result = sqlx::query("DELETE FROM artifacts WHERE id = $1")
            .bind(id)
            .execute(&self.pool)
            .await?;
        Ok(result.rows_affected() > 0)
    }

    /// Link an artifact to a spec revision.
    pub async fn link_to_spec(
        &self,
        artifact_id: Uuid,
        spec_id: Uuid,
        spec_revision: i32,
    ) -> Result<(), sqlx::Error> {
        sqlx::query(
            r#"
            INSERT INTO artifact_specs (artifact_id, spec_id, spec_revision)
            VALUES ($1, $2, $3)
            ON CONFLICT (artifact_id, spec_id) DO NOTHING
            "#,
        )
        .bind(artifact_id)
        .bind(spec_id)
        .bind(spec_revision)
        .execute(&self.pool)
        .await?;
        Ok(())
    }
}