feat(openapi): complete upload preview and UI evidence

apps/admin-api/src/service/imports.rs

@@ -1,5 +1,6 @@
 use std::collections::{BTreeMap, BTreeSet};
 
+use crank_artifacts::{ArtifactError, MAX_ARTIFACT_BYTES};
 use crank_core::{
     ExecutionConfig, OperationSecurityLevel, Protocol, ToolQualityFinding, ToolQualitySeverity,
     WorkspaceId,
@@ -8,8 +9,10 @@ use crank_import::rest::{
     ImportFinding, ImportFindingSeverity, ImportOperationCandidate, operation_draft_from_candidate,
 };
 use crank_registry::{
-    ApplyImportJobRequest, CreateImportJobRequest, ImportConflictMode, ImportJobId, ImportJobKind,
-    ImportJobStatus, ImportOperationDraft,
+    ApplyImportJobRequest, ArtifactSourceId, ArtifactSourceSensitivity,
+    CreateArtifactSourceRequest, CreateImportJobRequest, DetachArtifactSourceRequest,
+    ImportConflictMode, ImportJobApplyResult, ImportJobId, ImportJobKind, ImportJobSourceEnvelope,
+    ImportJobStatus, ImportOperationDraft, RegistryError,
 };
 use serde_json::json;
 use sha2::{Digest, Sha256};
@@ -20,30 +23,83 @@ use crate::{
     error::ApiError,
     service::{
         AdminService, OpenApiImportCreatePayload, OpenApiImportCreateResponse,
-        OpenApiImportCreatedOperation, OpenApiImportPreviewPayload, OpenApiImportPreviewResponse,
-        OpenApiImportSkippedOperation, OperationPayload, new_prefixed_id,
+        OpenApiImportCreatedOperation, OpenApiImportPreviewResponse, OpenApiImportSkippedOperation,
+        OpenApiUpload, OpenApiUploadLocale, OperationPayload, new_prefixed_id,
     },
 };
 
 const IMPORT_JOB_TTL_HOURS: i64 = 24;
 
 impl AdminService {
-    #[instrument(skip(self, payload), fields(workspace_id = %workspace_id.as_str()))]
+    #[instrument(skip(self, upload), fields(workspace_id = %workspace_id.as_str()))]
     pub async fn preview_openapi_import(
         &self,
         workspace_id: &WorkspaceId,
-        payload: OpenApiImportPreviewPayload,
+        upload: OpenApiUpload,
     ) -> Result<OpenApiImportPreviewResponse, ApiError> {
         self.ensure_workspace_exists(workspace_id).await?;
-        let _ = self.registry.delete_expired_import_jobs().await;
+        self.registry.delete_expired_import_jobs().await?;
 
-        let preview = crank_import::rest::preview_document(&payload.document)
-            .map_err(|error| ApiError::validation(error.to_string()))?;
+        validate_openapi_upload(&upload)?;
+        let OpenApiUpload {
+            bytes,
+            mime_type,
+            locale,
+        } = upload;
+        let store = self.artifact_store.clone();
+        let artifact = tokio::task::spawn_blocking(move || store.put_registered(&bytes))
+            .await
+            .map_err(|_| ApiError::openapi_upload(locale, "storage_unavailable"))?
+            .map_err(|error| artifact_error(locale, error))?;
         let now = OffsetDateTime::now_utc();
         let expires_at = now + Duration::hours(IMPORT_JOB_TTL_HOURS);
         let job_id = ImportJobId::new(new_prefixed_id("imp"));
-        let preview_payload = serde_json::to_value(&preview)
+        let source_id = ArtifactSourceId::new(new_prefixed_id("src_openapi"));
+        let source = self
+            .registry
+            .create_artifact_source(CreateArtifactSourceRequest {
+                workspace_id,
+                source_id: &source_id,
+                artifact: &artifact,
+                mime_type: &mime_type,
+                sensitivity: ArtifactSourceSensitivity::Internal,
+                created_at: now,
+            })
+            .await?;
+        let mut detach_guard = SourceDetachGuard::new(
+            self.registry.clone(),
+            workspace_id.clone(),
+            source_id.clone(),
+            source.updated_at,
+        );
+        let verified = self
+            .registry
+            .read_artifact_source(&self.artifact_store, workspace_id, &source_id)
+            .await?;
+        if verified.source.blob.artifact_ref != *artifact.artifact_ref() {
+            return Err(ApiError::openapi_upload(locale, "source_integrity"));
+        }
+        let preview = parse_verified_preview(verified.bytes, locale).await?;
+        if preview
+            .groups
+            .iter()
+            .all(|group| group.operations.is_empty())
+        {
+            return Err(ApiError::openapi_upload(locale, "no_methods"));
+        }
+        let source_envelope = ImportJobSourceEnvelope {
+            source_id,
+            digest: artifact.artifact_ref().clone(),
+        };
+        let preview_value = serde_json::to_value(&preview)
             .map_err(|error| ApiError::internal(error.to_string()))?;
+        let preview_payload = json!({
+            "source": {
+                "source_id": source_envelope.source_id.as_str(),
+                "digest": source_envelope.digest.as_str(),
+            },
+            "preview": preview_value,
+        });
 
         self.registry
             .create_import_job(CreateImportJobRequest {
@@ -53,11 +109,13 @@ impl AdminService {
                 source_format: &preview.source.format,
                 source_version: preview.source.version.as_deref(),
                 status: ImportJobStatus::Pending,
+                source: &source_envelope,
                 preview_payload: &preview_payload,
                 created_at: &now,
                 expires_at: &expires_at,
             })
             .await?;
+        detach_guard.disarm();
 
         Ok(OpenApiImportPreviewResponse {
             job_id: job_id.as_str().to_owned(),
@@ -76,7 +134,7 @@ impl AdminService {
         payload: OpenApiImportCreatePayload,
     ) -> Result<OpenApiImportCreateResponse, ApiError> {
         self.ensure_workspace_exists(workspace_id).await?;
-        let _ = self.registry.delete_expired_import_jobs().await;
+        self.registry.delete_expired_import_jobs().await?;
 
         if !matches!(payload.conflict_mode.as_str(), "skip" | "rename") {
             return Err(ApiError::validation(
@@ -101,13 +159,6 @@ impl AdminService {
             return Err(ApiError::validation("import job kind is not openapi"));
         }
 
-        let stored_preview = job
-            .preview_payload
-            .get("preview")
-            .cloned()
-            .unwrap_or_else(|| job.preview_payload.clone());
-        let preview: crank_import::rest::ImportPreview = serde_json::from_value(stored_preview)
-            .map_err(|error| ApiError::internal(error.to_string()))?;
         let selected = payload
             .selected_operation_keys
             .iter()
@@ -118,7 +169,38 @@ impl AdminService {
                 "selected_operation_keys must contain at least one operation",
             ));
         }
+        let finished_at = OffsetDateTime::now_utc();
+        let application_key = openapi_application_key(&payload)?;
+        let conflict_mode = if payload.conflict_mode == "skip" {
+            ImportConflictMode::Skip
+        } else {
+            ImportConflictMode::Rename
+        };
+        if job.status == ImportJobStatus::Completed {
+            let applied = self
+                .registry
+                .apply_import_job(ApplyImportJobRequest {
+                    id: job_id,
+                    workspace_id,
+                    application_key: &application_key,
+                    conflict_mode,
+                    operations: &[],
+                    finished_at: &finished_at,
+                })
+                .await?;
+            return Ok(openapi_import_response(applied, Vec::new()));
+        }
 
+        let source = import_job_source(&job.preview_payload)?;
+        let verified = self
+            .registry
+            .read_artifact_source(&self.artifact_store, workspace_id, &source.source_id)
+            .await
+            .map_err(openapi_source_error)?;
+        if verified.source.blob.artifact_ref != source.digest {
+            return Err(ApiError::source_integrity());
+        }
+        let preview = parse_verified_preview(verified.bytes, OpenApiUploadLocale::En).await?;
         let mut candidates = BTreeMap::new();
         for group in &preview.groups {
             for operation in &group.operations {
@@ -171,13 +253,6 @@ impl AdminService {
             });
         }
 
-        let finished_at = OffsetDateTime::now_utc();
-        let application_key = openapi_application_key(&payload)?;
-        let conflict_mode = if payload.conflict_mode == "skip" {
-            ImportConflictMode::Skip
-        } else {
-            ImportConflictMode::Rename
-        };
         let applied = self
             .registry
             .apply_import_job(ApplyImportJobRequest {
@@ -190,20 +265,31 @@ impl AdminService {
             })
             .await?;
 
-        let created = applied
-            .created
-            .iter()
-            .map(|operation| OpenApiImportCreatedOperation {
-                operation_id: operation.operation_id.as_str().to_owned(),
-                name: operation.name.clone(),
-                version: operation.version,
-            })
-            .collect::<Vec<_>>();
-        let mut findings = applied
-            .created
-            .iter()
-            .filter_map(|operation| {
-                operation.renamed_from.as_ref().map(|previous_name| ImportFinding {
+        Ok(openapi_import_response(applied, skipped))
+    }
+}
+
+fn openapi_import_response(
+    applied: ImportJobApplyResult,
+    mut skipped: Vec<OpenApiImportSkippedOperation>,
+) -> OpenApiImportCreateResponse {
+    let created = applied
+        .created
+        .iter()
+        .map(|operation| OpenApiImportCreatedOperation {
+            operation_id: operation.operation_id.as_str().to_owned(),
+            name: operation.name.clone(),
+            version: operation.version,
+        })
+        .collect::<Vec<_>>();
+    let mut findings = applied
+        .created
+        .iter()
+        .filter_map(|operation| {
+            operation
+                .renamed_from
+                .as_ref()
+                .map(|previous_name| ImportFinding {
                     code: "operation_name_renamed".to_owned(),
                     severity: ImportFindingSeverity::Info,
                     message: format!(
@@ -212,36 +298,171 @@ impl AdminService {
                     ),
                     operation_key: Some(operation.operation_key.clone()),
                 })
-            })
-            .collect::<Vec<_>>();
-        for operation in applied.skipped {
-            skipped.push(OpenApiImportSkippedOperation {
-                operation_key: operation.operation_key.clone(),
-                name: operation.name.clone(),
-                reason: "operation with this name already exists".to_owned(),
-            });
-            findings.push(ImportFinding {
-                code: operation.reason,
-                severity: ImportFindingSeverity::Warning,
-                message: format!(
-                    "Операция {} уже существует и была пропущена.",
-                    operation.name
-                ),
-                operation_key: Some(operation.operation_key),
+        })
+        .collect::<Vec<_>>();
+    for operation in applied.skipped {
+        skipped.push(OpenApiImportSkippedOperation {
+            operation_key: operation.operation_key.clone(),
+            name: operation.name.clone(),
+            reason: "operation with this name already exists".to_owned(),
+        });
+        findings.push(ImportFinding {
+            code: operation.reason,
+            severity: ImportFindingSeverity::Warning,
+            message: format!(
+                "Операция {} уже существует и была пропущена.",
+                operation.name
+            ),
+            operation_key: Some(operation.operation_key),
+        });
+    }
+    info!(
+        name: "admin.openapi_import.completed",
+        created = created.len(),
+        skipped = skipped.len(),
+        "openapi import created drafts"
+    );
+    OpenApiImportCreateResponse {
+        created,
+        skipped,
+        findings,
+    }
+}
+
+fn validate_openapi_upload(upload: &OpenApiUpload) -> Result<(), ApiError> {
+    if upload.bytes.is_empty() {
+        return Err(ApiError::openapi_upload(upload.locale, "empty_file"));
+    }
+    if upload.bytes.len() > MAX_ARTIFACT_BYTES {
+        return Err(ApiError::openapi_upload(upload.locale, "file_too_large"));
+    }
+    if !matches!(
+        upload.mime_type.as_str(),
+        "application/yaml"
+            | "application/x-yaml"
+            | "text/yaml"
+            | "text/x-yaml"
+            | "application/json"
+            | "application/openapi+json"
+            | "application/octet-stream"
+    ) {
+        return Err(ApiError::openapi_upload(
+            upload.locale,
+            "invalid_media_type",
+        ));
+    }
+    if std::str::from_utf8(&upload.bytes).is_err() {
+        return Err(ApiError::openapi_upload(upload.locale, "invalid_utf8"));
+    }
+    Ok(())
+}
+
+async fn parse_verified_preview(
+    bytes: Vec<u8>,
+    locale: OpenApiUploadLocale,
+) -> Result<crank_import::rest::ImportPreview, ApiError> {
+    tokio::task::spawn_blocking(move || {
+        let document = std::str::from_utf8(&bytes)
+            .map_err(|_| ApiError::openapi_upload(locale, "invalid_utf8"))?;
+        crank_import::rest::preview_document(document)
+            .map_err(|_| ApiError::openapi_upload(locale, "invalid_document"))
+    })
+    .await
+    .map_err(|_| ApiError::openapi_upload(locale, "parser_unavailable"))?
+}
+
+fn artifact_error(locale: OpenApiUploadLocale, error: ArtifactError) -> ApiError {
+    match error {
+        ArtifactError::EmptySource => ApiError::openapi_upload(locale, "empty_file"),
+        ArtifactError::SourceTooLarge => ApiError::openapi_upload(locale, "file_too_large"),
+        ArtifactError::Integrity => ApiError::openapi_upload(locale, "source_integrity"),
+        ArtifactError::Storage
+        | ArtifactError::NotFound
+        | ArtifactError::InvalidReference
+        | ArtifactError::UnsafeRoot => ApiError::openapi_upload(locale, "storage_unavailable"),
+    }
+}
+
+fn openapi_source_error(error: RegistryError) -> ApiError {
+    match error {
+        RegistryError::SourceNotFound { .. } | RegistryError::SourceUnavailable => {
+            ApiError::source_unavailable()
+        }
+        RegistryError::SourceIntegrity => ApiError::source_integrity(),
+        other => ApiError::from(other),
+    }
+}
+
+fn import_job_source(payload: &serde_json::Value) -> Result<ImportJobSourceEnvelope, ApiError> {
+    let source = payload
+        .get("source")
+        .ok_or_else(ApiError::source_unavailable)?;
+    let source_id = source
+        .get("source_id")
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| value.len() <= 132)
+        .ok_or_else(ApiError::source_unavailable)?;
+    let digest = source
+        .get("digest")
+        .and_then(serde_json::Value::as_str)
+        .and_then(|value| value.parse().ok())
+        .ok_or_else(ApiError::source_integrity)?;
+    Ok(ImportJobSourceEnvelope {
+        source_id: ArtifactSourceId::new(source_id),
+        digest,
+    })
+}
+
+struct SourceDetachGuard {
+    registry: crank_registry::PostgresRegistry,
+    workspace_id: WorkspaceId,
+    source_id: ArtifactSourceId,
+    expected_updated_at: OffsetDateTime,
+    armed: bool,
+}
+
+impl SourceDetachGuard {
+    fn new(
+        registry: crank_registry::PostgresRegistry,
+        workspace_id: WorkspaceId,
+        source_id: ArtifactSourceId,
+        expected_updated_at: OffsetDateTime,
+    ) -> Self {
+        Self {
+            registry,
+            workspace_id,
+            source_id,
+            expected_updated_at,
+            armed: true,
+        }
+    }
+
+    fn disarm(&mut self) {
+        self.armed = false;
+    }
+}
+
+impl Drop for SourceDetachGuard {
+    fn drop(&mut self) {
+        if !self.armed {
+            return;
+        }
+        let registry = self.registry.clone();
+        let workspace_id = self.workspace_id.clone();
+        let source_id = self.source_id.clone();
+        let expected_updated_at = Some(self.expected_updated_at);
+        if let Ok(handle) = tokio::runtime::Handle::try_current() {
+            handle.spawn(async move {
+                let _ = registry
+                    .detach_artifact_source(DetachArtifactSourceRequest {
+                        workspace_id: &workspace_id,
+                        source_id: &source_id,
+                        expected_updated_at,
+                        detached_at: OffsetDateTime::now_utc(),
+                    })
+                    .await;
             });
         }
-        info!(
-            name: "admin.openapi_import.completed",
-            created = created.len(),
-            skipped = skipped.len(),
-            "openapi import created drafts"
-        );
-
-        Ok(OpenApiImportCreateResponse {
-            created,
-            skipped,
-            findings,
-        })
     }
 }