chore: publish clean community baseline

2026-06-17 06:15:46 +00:00
commit a3a8a6c6a9
317 changed files with 73239 additions and 0 deletions
@@ -0,0 +1,321 @@
+use super::*;
+
+impl PostgresRegistry {
+    pub async fn list_platform_api_keys_for_agent(
+        &self,
+        workspace_id: &WorkspaceId,
+        agent_id: &AgentId,
+    ) -> Result<Vec<PlatformApiKeyRecord>, RegistryError> {
+        let rows = sqlx::query(
+            "select
+                id,
+                workspace_id,
+                agent_id,
+                name,
+                prefix,
+                scopes_json,
+                status,
+                created_at,
+                last_used_at
+             from platform_api_keys
+             where workspace_id = $1
+               and agent_id = $2
+             order by created_at desc",
+        )
+        .bind(workspace_id.as_str())
+        .bind(agent_id.as_str())
+        .fetch_all(&self.pool)
+        .await?;
+
+        rows.into_iter()
+            .map(|row| {
+                Ok(PlatformApiKeyRecord {
+                    api_key: PlatformApiKey {
+                        id: PlatformApiKeyId::new(row.get::<String, _>("id")),
+                        workspace_id: WorkspaceId::new(row.get::<String, _>("workspace_id")),
+                        agent_id: row.get::<Option<String>, _>("agent_id").map(AgentId::new),
+                        name: row.get("name"),
+                        prefix: row.get("prefix"),
+                        scopes: deserialize_json_value(row.get::<Value, _>("scopes_json"))?,
+                        status: deserialize_enum_text(&row.get::<String, _>("status"), "status")?,
+                        created_at: row.get("created_at"),
+                        last_used_at: row.get("last_used_at"),
+                    },
+                })
+            })
+            .collect()
+    }
+
+    pub async fn list_platform_api_keys(
+        &self,
+        workspace_id: &WorkspaceId,
+    ) -> Result<Vec<PlatformApiKeyRecord>, RegistryError> {
+        let rows = sqlx::query(
+            "select
+                id,
+                workspace_id,
+                agent_id,
+                name,
+                prefix,
+                scopes_json,
+                status,
+                created_at,
+                last_used_at
+             from platform_api_keys
+             where workspace_id = $1
+             order by created_at desc",
+        )
+        .bind(workspace_id.as_str())
+        .fetch_all(&self.pool)
+        .await?;
+
+        rows.into_iter()
+            .map(|row| {
+                Ok(PlatformApiKeyRecord {
+                    api_key: PlatformApiKey {
+                        id: PlatformApiKeyId::new(row.get::<String, _>("id")),
+                        workspace_id: WorkspaceId::new(row.get::<String, _>("workspace_id")),
+                        agent_id: row.get::<Option<String>, _>("agent_id").map(AgentId::new),
+                        name: row.get("name"),
+                        prefix: row.get("prefix"),
+                        scopes: deserialize_json_value(row.get::<Value, _>("scopes_json"))?,
+                        status: deserialize_enum_text(&row.get::<String, _>("status"), "status")?,
+                        created_at: row.get("created_at"),
+                        last_used_at: row.get("last_used_at"),
+                    },
+                })
+            })
+            .collect()
+    }
+
+    pub async fn get_platform_api_key_by_secret_for_agent_slug(
+        &self,
+        workspace_slug: &str,
+        agent_slug: &str,
+        secret_hash: &str,
+    ) -> Result<Option<PlatformApiKeyRecord>, RegistryError> {
+        let row = sqlx::query(
+            "select
+                k.id,
+                k.workspace_id,
+                k.agent_id,
+                k.name,
+                k.prefix,
+                k.scopes_json,
+                k.status,
+                k.created_at,
+                k.last_used_at
+             from platform_api_keys k
+             join workspaces w on w.id = k.workspace_id
+             join agents a on a.id = k.agent_id
+             where w.slug = $1
+               and a.slug = $2
+               and k.secret_hash = $3
+               and k.status = 'active'
+             limit 1",
+        )
+        .bind(workspace_slug)
+        .bind(agent_slug)
+        .bind(secret_hash)
+        .fetch_optional(&self.pool)
+        .await?;
+
+        row.map(|row| {
+            Ok(PlatformApiKeyRecord {
+                api_key: PlatformApiKey {
+                    id: PlatformApiKeyId::new(row.get::<String, _>("id")),
+                    workspace_id: WorkspaceId::new(row.get::<String, _>("workspace_id")),
+                    agent_id: row.get::<Option<String>, _>("agent_id").map(AgentId::new),
+                    name: row.get("name"),
+                    prefix: row.get("prefix"),
+                    scopes: deserialize_json_value(row.get::<Value, _>("scopes_json"))?,
+                    status: deserialize_enum_text(&row.get::<String, _>("status"), "status")?,
+                    created_at: row.get("created_at"),
+                    last_used_at: row.get("last_used_at"),
+                },
+            })
+        })
+        .transpose()
+    }
+
+    pub async fn create_platform_api_key(
+        &self,
+        request: CreatePlatformApiKeyRequest<'_>,
+    ) -> Result<(), RegistryError> {
+        let result = sqlx::query(
+            "insert into platform_api_keys (
+                id,
+                workspace_id,
+                agent_id,
+                name,
+                prefix,
+                secret_hash,
+                scopes_json,
+                status,
+                created_at,
+                last_used_at,
+                revoked_at
+             ) values (
+                $1, $2, $3, $4, $5, $6, $7, $8, $9::timestamptz, $10::timestamptz, $11::timestamptz
+             )",
+        )
+        .bind(request.api_key.id.as_str())
+        .bind(request.api_key.workspace_id.as_str())
+        .bind(request.api_key.agent_id.as_ref().map(AgentId::as_str))
+        .bind(&request.api_key.name)
+        .bind(&request.api_key.prefix)
+        .bind(request.secret_hash)
+        .bind(Json(serialize_json_value(&request.api_key.scopes)?))
+        .bind(serialize_enum_text(&request.api_key.status, "status")?)
+        .bind(request.api_key.created_at)
+        .bind(request.api_key.last_used_at)
+        .bind(Option::<&str>::None)
+        .execute(&self.pool)
+        .await;
+
+        match result {
+            Ok(_) => Ok(()),
+            Err(sqlx::Error::Database(error))
+                if error.constraint() == Some("platform_api_keys_workspace_name_idx") =>
+            {
+                Err(RegistryError::Storage(sqlx::Error::Database(error)))
+            }
+            Err(error) => Err(RegistryError::Storage(error)),
+        }
+    }
+
+    pub async fn revoke_platform_api_key(
+        &self,
+        workspace_id: &WorkspaceId,
+        key_id: &PlatformApiKeyId,
+        revoked_at: &time::OffsetDateTime,
+    ) -> Result<(), RegistryError> {
+        let result = sqlx::query(
+            "update platform_api_keys
+                set status = $1,
+                    revoked_at = $2::timestamptz
+              where workspace_id = $3 and id = $4",
+        )
+        .bind(serialize_enum_text(
+            &PlatformApiKeyStatus::Revoked,
+            "status",
+        )?)
+        .bind(revoked_at)
+        .bind(workspace_id.as_str())
+        .bind(key_id.as_str())
+        .execute(&self.pool)
+        .await?;
+
+        if result.rows_affected() == 0 {
+            return Err(RegistryError::PlatformApiKeyNotFound {
+                key_id: key_id.as_str().to_owned(),
+            });
+        }
+
+        Ok(())
+    }
+
+    pub async fn revoke_platform_api_key_for_agent(
+        &self,
+        workspace_id: &WorkspaceId,
+        agent_id: &AgentId,
+        key_id: &PlatformApiKeyId,
+        revoked_at: &time::OffsetDateTime,
+    ) -> Result<(), RegistryError> {
+        let result = sqlx::query(
+            "update platform_api_keys
+                set status = $1,
+                    revoked_at = $2::timestamptz
+              where workspace_id = $3 and agent_id = $4 and id = $5",
+        )
+        .bind(serialize_enum_text(
+            &PlatformApiKeyStatus::Revoked,
+            "status",
+        )?)
+        .bind(revoked_at)
+        .bind(workspace_id.as_str())
+        .bind(agent_id.as_str())
+        .bind(key_id.as_str())
+        .execute(&self.pool)
+        .await?;
+
+        if result.rows_affected() == 0 {
+            return Err(RegistryError::PlatformApiKeyNotFound {
+                key_id: key_id.as_str().to_owned(),
+            });
+        }
+
+        Ok(())
+    }
+
+    pub async fn delete_platform_api_key(
+        &self,
+        workspace_id: &WorkspaceId,
+        key_id: &PlatformApiKeyId,
+    ) -> Result<(), RegistryError> {
+        let result =
+            sqlx::query("delete from platform_api_keys where workspace_id = $1 and id = $2")
+                .bind(workspace_id.as_str())
+                .bind(key_id.as_str())
+                .execute(&self.pool)
+                .await?;
+
+        if result.rows_affected() == 0 {
+            return Err(RegistryError::PlatformApiKeyNotFound {
+                key_id: key_id.as_str().to_owned(),
+            });
+        }
+
+        Ok(())
+    }
+
+    pub async fn delete_platform_api_key_for_agent(
+        &self,
+        workspace_id: &WorkspaceId,
+        agent_id: &AgentId,
+        key_id: &PlatformApiKeyId,
+    ) -> Result<(), RegistryError> {
+        let result = sqlx::query(
+            "delete from platform_api_keys where workspace_id = $1 and agent_id = $2 and id = $3",
+        )
+        .bind(workspace_id.as_str())
+        .bind(agent_id.as_str())
+        .bind(key_id.as_str())
+        .execute(&self.pool)
+        .await?;
+
+        if result.rows_affected() == 0 {
+            return Err(RegistryError::PlatformApiKeyNotFound {
+                key_id: key_id.as_str().to_owned(),
+            });
+        }
+
+        Ok(())
+    }
+
+    pub async fn touch_platform_api_key(
+        &self,
+        workspace_id: &WorkspaceId,
+        key_id: &PlatformApiKeyId,
+        used_at: &time::OffsetDateTime,
+    ) -> Result<(), RegistryError> {
+        let result = sqlx::query(
+            "update platform_api_keys
+                set last_used_at = $3::timestamptz
+              where workspace_id = $1 and id = $2",
+        )
+        .bind(workspace_id.as_str())
+        .bind(key_id.as_str())
+        .bind(used_at)
+        .execute(&self.pool)
+        .await?;
+
+        if result.rows_affected() == 0 {
+            return Err(RegistryError::PlatformApiKeyNotFound {
+                key_id: key_id.as_str().to_owned(),
+            });
+        }
+
+        Ok(())
+    }
+}