story 2-13-importplan-re-import: implemented and reviewed via bmad-loop
This commit is contained in:
1 parent
c562d5368d
commit
f69c36fa65
66 files changed
+11366
-686
No files matched your search
@@ -27,7 +27,10 @@ use crate::{
|
||||
},
|
||||
auth_profiles::{create_auth_profile, get_auth_profile, list_auth_profiles},
|
||||
capabilities::get_capabilities,
|
||||
imports::{create_openapi_import, preview_openapi_import},
|
||||
imports::{
|
||||
apply_openapi_import_plan, create_openapi_import, create_openapi_import_plan,
|
||||
preview_openapi_import,
|
||||
},
|
||||
observability::{
|
||||
approve_approval, deny_approval, export_logs_csv, export_usage_csv, get_agent_usage,
|
||||
get_approval, get_log, get_operation_usage, get_usage, list_approvals, list_logs,
|
||||
@@ -58,6 +61,14 @@ pub fn build_app(state: AppState) -> Router {
|
||||
"/imports/openapi/{job_id}/create",
|
||||
post(create_openapi_import),
|
||||
)
|
||||
.route(
|
||||
"/imports/openapi/{job_id}/plans",
|
||||
post(create_openapi_import_plan),
|
||||
)
|
||||
.route(
|
||||
"/imports/openapi/{plan_id}/apply",
|
||||
post(apply_openapi_import_plan).layer(DefaultBodyLimit::max(16 * 1024)),
|
||||
)
|
||||
.route(
|
||||
"/operations/analyze-quality",
|
||||
post(analyze_operation_quality),
|
||||
|
||||
@@ -575,6 +575,73 @@ pub struct OpenApiImportSkippedOperation {
|
||||
pub reason: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct OpenApiImportPlanCreatePayload {
|
||||
#[serde(default = "default_openapi_plan_selection_mode")]
|
||||
pub selection_mode: String,
|
||||
#[serde(default)]
|
||||
pub selected_operation_keys: Vec<String>,
|
||||
#[serde(default)]
|
||||
pub server_url: Option<String>,
|
||||
#[serde(default)]
|
||||
pub decisions: Vec<OpenApiImportPlanDecision>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct OpenApiImportPlanApplyPayload {
|
||||
pub plan_digest: String,
|
||||
pub idempotency_key: String,
|
||||
}
|
||||
|
||||
fn default_openapi_plan_selection_mode() -> String {
|
||||
"full".to_owned()
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct OpenApiImportPlanDecision {
|
||||
pub operation_key: String,
|
||||
pub action: String,
|
||||
#[serde(default)]
|
||||
pub target_operation_id: Option<String>,
|
||||
#[serde(default)]
|
||||
pub confirmed_name: Option<String>,
|
||||
#[serde(default)]
|
||||
pub auth_profile_id: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
|
||||
pub struct OpenApiImportPlanCounts {
|
||||
pub selected: usize,
|
||||
pub excluded: usize,
|
||||
pub actionable: usize,
|
||||
pub blocked: usize,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize)]
|
||||
pub struct OpenApiImportPlanCandidateView {
|
||||
pub key: String,
|
||||
pub name: String,
|
||||
pub state: String,
|
||||
pub action: Option<String>,
|
||||
pub target_operation_id: Option<String>,
|
||||
pub confirmed_name: Option<String>,
|
||||
pub auth_profile_id: Option<String>,
|
||||
pub reason: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
pub struct OpenApiImportPlanCreateResponse {
|
||||
pub plan_reference: String,
|
||||
pub plan_digest: String,
|
||||
pub expires_at: String,
|
||||
pub selection_mode: String,
|
||||
pub counts: OpenApiImportPlanCounts,
|
||||
pub candidates: Vec<OpenApiImportPlanCandidateView>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
pub struct CreatedOperationResponse {
|
||||
pub operation_id: String,
|
||||
|
||||
@@ -687,6 +687,94 @@ impl From<RegistryError> for ApiError {
|
||||
format!("import job {job_id} was already applied with different parameters"),
|
||||
json!({ "job_id": job_id }),
|
||||
),
|
||||
RegistryError::InvalidImportPlan { field } => Self::validation_with_context(
|
||||
format!("invalid import plan input for field {field}"),
|
||||
json!({
|
||||
"field": field,
|
||||
"error_code": "import_plan_invalid_input"
|
||||
}),
|
||||
),
|
||||
RegistryError::ImportPlanConflict { plan_id } => Self::conflict_with_context(
|
||||
format!("import plan {plan_id} already exists with different material"),
|
||||
json!({
|
||||
"plan_id": plan_id,
|
||||
"error_code": "import_plan_conflict",
|
||||
"recovery": "repreview_required"
|
||||
}),
|
||||
),
|
||||
RegistryError::ImportPlanJobUnavailable { job_id } => Self::not_found_with_context(
|
||||
format!("import job {job_id} is unavailable for planning"),
|
||||
json!({ "job_id": job_id, "error_code": "import_plan_job_unavailable" }),
|
||||
),
|
||||
RegistryError::ImportPlanJobTerminal { job_id }
|
||||
| RegistryError::ImportPlanJobExpired { job_id } => Self::conflict_with_context(
|
||||
format!("import job {job_id} is not in planning state"),
|
||||
json!({
|
||||
"job_id": job_id,
|
||||
"error_code": "import_plan_job_terminal",
|
||||
"recovery": "repreview_required",
|
||||
"repreview_required": true
|
||||
}),
|
||||
),
|
||||
RegistryError::ImportPlanNotFound { .. } => Self::not_found_with_context(
|
||||
"import plan was not found in this workspace",
|
||||
json!({ "error_code": "import_plan_not_found" }),
|
||||
),
|
||||
RegistryError::ImportPlanExpired { .. } => Self::conflict_with_context(
|
||||
"import plan has expired; create a fresh preview",
|
||||
json!({
|
||||
"error_code": "import_plan_expired",
|
||||
"recovery": "repreview_required",
|
||||
"repreview_required": true
|
||||
}),
|
||||
),
|
||||
RegistryError::ImportPlanPayloadCorrupt { .. } => Self::conflict_with_context(
|
||||
"import plan is invalid; create a fresh preview",
|
||||
json!({
|
||||
"error_code": "import_plan_payload_invalid",
|
||||
"recovery": "repreview_required",
|
||||
"repreview_required": true
|
||||
}),
|
||||
),
|
||||
RegistryError::ImportPlanFingerprintStale { .. } => Self::conflict_with_context(
|
||||
"import plan no longer matches the verified preview; create a fresh preview",
|
||||
json!({
|
||||
"error_code": "import_plan_fingerprint_stale",
|
||||
"recovery": "repreview_required",
|
||||
"repreview_required": true
|
||||
}),
|
||||
),
|
||||
RegistryError::ImportPlanKeyDigestConflict { .. } => Self::conflict_with_context(
|
||||
"idempotency key was already committed for different plan material",
|
||||
json!({
|
||||
"error_code": "import_plan_key_digest_conflict",
|
||||
"recovery": "repreview_required",
|
||||
"repreview_required": true
|
||||
}),
|
||||
),
|
||||
RegistryError::ImportPlanNameConflict { .. } => Self::conflict_with_context(
|
||||
"an operation name changed after the plan was created",
|
||||
json!({
|
||||
"error_code": "import_plan_name_conflict",
|
||||
"recovery": "confirm_skip_rename_or_new_version"
|
||||
}),
|
||||
),
|
||||
RegistryError::ImportPlanTargetStale { .. } => Self::conflict_with_context(
|
||||
"an operation changed after the plan was created; create a fresh preview",
|
||||
json!({
|
||||
"error_code": "import_plan_target_stale",
|
||||
"recovery": "repreview_required",
|
||||
"repreview_required": true
|
||||
}),
|
||||
),
|
||||
RegistryError::ImportPlanAuthUnavailable { .. } => Self::conflict_with_context(
|
||||
"an authentication profile is unavailable; create a fresh preview",
|
||||
json!({
|
||||
"error_code": "import_plan_auth_unavailable",
|
||||
"recovery": "repreview_required",
|
||||
"repreview_required": true
|
||||
}),
|
||||
),
|
||||
RegistryError::SourceNotFound { .. } => Self::not_found_with_context(
|
||||
"artifact source was not found",
|
||||
json!({
|
||||
|
||||
@@ -10,7 +10,10 @@ use serde_json::{Value, json};
|
||||
|
||||
use crate::{
|
||||
error::ApiError,
|
||||
service::{OpenApiImportCreatePayload, OpenApiUpload, OpenApiUploadLocale},
|
||||
service::{
|
||||
OpenApiImportCreatePayload, OpenApiImportPlanApplyPayload, OpenApiImportPlanCreatePayload,
|
||||
OpenApiUpload, OpenApiUploadLocale,
|
||||
},
|
||||
state::AppState,
|
||||
};
|
||||
|
||||
@@ -25,6 +28,12 @@ pub struct WorkspaceImportPath {
|
||||
pub job_id: String,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub struct WorkspacePlanPath {
|
||||
pub workspace_id: String,
|
||||
pub plan_id: String,
|
||||
}
|
||||
|
||||
pub async fn preview_openapi_import(
|
||||
Path(path): Path<WorkspacePath>,
|
||||
State(state): State<AppState>,
|
||||
@@ -198,6 +207,49 @@ pub async fn create_openapi_import(
|
||||
Ok(Json(json!(imported)))
|
||||
}
|
||||
|
||||
pub async fn create_openapi_import_plan(
|
||||
Path(path): Path<WorkspaceImportPath>,
|
||||
State(state): State<AppState>,
|
||||
Json(payload): Json<OpenApiImportPlanCreatePayload>,
|
||||
) -> Result<Json<Value>, ApiError> {
|
||||
let plan = state
|
||||
.service
|
||||
.create_openapi_import_plan(
|
||||
&path.workspace_id.as_str().into(),
|
||||
&path.job_id.as_str().into(),
|
||||
payload,
|
||||
)
|
||||
.await?;
|
||||
Ok(Json(json!(plan)))
|
||||
}
|
||||
|
||||
pub async fn apply_openapi_import_plan(
|
||||
Path(path): Path<WorkspacePlanPath>,
|
||||
State(state): State<AppState>,
|
||||
Json(payload): Json<OpenApiImportPlanApplyPayload>,
|
||||
) -> Result<impl IntoResponse, ApiError> {
|
||||
let report = state
|
||||
.service
|
||||
.apply_openapi_import_plan(
|
||||
&path.workspace_id.as_str().into(),
|
||||
&path.plan_id.as_str().into(),
|
||||
payload,
|
||||
)
|
||||
.await?;
|
||||
let status = if report.status == crank_registry::ImportPlanApplyStatus::Rejected {
|
||||
axum::http::StatusCode::CONFLICT
|
||||
} else {
|
||||
axum::http::StatusCode::OK
|
||||
};
|
||||
Ok((
|
||||
status,
|
||||
Json(
|
||||
serde_json::to_value(report)
|
||||
.map_err(|_| ApiError::internal("could not serialize import plan report"))?,
|
||||
),
|
||||
))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use axum::http::{HeaderMap, HeaderValue};
|
||||
|
||||
@@ -2,8 +2,8 @@ use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
use crank_artifacts::{ArtifactError, MAX_ARTIFACT_BYTES};
|
||||
use crank_core::{
|
||||
ExecutionConfig, OperationSecurityLevel, Protocol, ToolQualityFinding, ToolQualitySeverity,
|
||||
WorkspaceId,
|
||||
AuthProfileId, ExecutionConfig, OperationId, OperationSecurityLevel, OperationStatus, Protocol,
|
||||
ToolQualityFinding, ToolQualitySeverity, WorkspaceId,
|
||||
};
|
||||
use crank_import::rest::{
|
||||
ImportFinding, ImportFindingSeverity, ImportOperationCandidate, NORMALIZER_VERSION,
|
||||
@@ -11,11 +11,12 @@ use crank_import::rest::{
|
||||
};
|
||||
use crank_registry::{
|
||||
ApplyImportJobRequest, ArtifactSourceId, ArtifactSourceSensitivity,
|
||||
CreateArtifactSourceRequest, CreateImportJobRequest, FinishImportJobRequest,
|
||||
ImportConflictMode, ImportJobApplyResult, ImportJobId, ImportJobKind, ImportJobSourceEnvelope,
|
||||
ImportJobStatus, ImportOperationDraft, RegistryError,
|
||||
CreateArtifactSourceRequest, CreateImportJobRequest, CreateImportPlanRequest,
|
||||
FinishImportJobRequest, ImportConflictMode, ImportJob, ImportJobApplyResult, ImportJobId,
|
||||
ImportJobKind, ImportJobSourceEnvelope, ImportJobStatus, ImportOperationDraft, ImportPlanId,
|
||||
RegistryError, RegistryOperation,
|
||||
};
|
||||
use serde_json::json;
|
||||
use serde_json::{Value, json};
|
||||
use sha2::{Digest, Sha256};
|
||||
use time::{Duration, OffsetDateTime, format_description::well_known::Rfc3339};
|
||||
use tracing::{info, instrument};
|
||||
@@ -24,21 +25,38 @@ use crate::{
|
||||
error::ApiError,
|
||||
service::{
|
||||
AdminService, OpenApiImportCreatePayload, OpenApiImportCreateResponse,
|
||||
OpenApiImportCreatedOperation, OpenApiImportPreviewResponse, OpenApiImportSkippedOperation,
|
||||
OpenApiUpload, OpenApiUploadLocale, OperationPayload, new_prefixed_id,
|
||||
OpenApiImportCreatedOperation, OpenApiImportPlanApplyPayload,
|
||||
OpenApiImportPlanCandidateView, OpenApiImportPlanCounts, OpenApiImportPlanCreatePayload,
|
||||
OpenApiImportPlanCreateResponse, OpenApiImportPlanDecision, OpenApiImportPreviewResponse,
|
||||
OpenApiImportSkippedOperation, OpenApiUpload, OpenApiUploadLocale, OperationPayload,
|
||||
new_prefixed_id,
|
||||
},
|
||||
};
|
||||
|
||||
mod external_references;
|
||||
mod import_plan;
|
||||
mod job_contract;
|
||||
mod plan_apply;
|
||||
mod verified_preview;
|
||||
|
||||
use external_references::ImportReplayContext;
|
||||
use import_plan::import_plan_repreview_error;
|
||||
use job_contract::{
|
||||
SourceDetachGuard, import_job_dependencies, import_job_normalization_config, import_job_source,
|
||||
};
|
||||
use verified_preview::{
|
||||
ImportPreviewResolution, artifact_error, openapi_source_error, parse_verified_preview,
|
||||
preview_digest, preview_has_blocker,
|
||||
};
|
||||
|
||||
const IMPORT_JOB_TTL_HOURS: i64 = 24;
|
||||
const OPENAPI_PARSE_DEADLINE: std::time::Duration = std::time::Duration::from_secs(30);
|
||||
const OPENAPI_PARSE_CONCURRENCY: usize = 4;
|
||||
const MAX_IMPORT_PLAN_KEYS: usize = 512;
|
||||
const MAX_IMPORT_PLAN_KEY_BYTES: usize = 4_096;
|
||||
const MAX_IMPORT_PLAN_SERVER_URL_BYTES: usize = 8_192;
|
||||
const MAX_IMPORT_PLAN_NAME_BYTES: usize = 256;
|
||||
const MAX_IMPORT_PLAN_ID_REF_BYTES: usize = 128;
|
||||
static OPENAPI_PARSE_SLOTS: tokio::sync::Semaphore =
|
||||
tokio::sync::Semaphore::const_new(OPENAPI_PARSE_CONCURRENCY);
|
||||
|
||||
@@ -276,141 +294,20 @@ impl AdminService {
|
||||
return Ok(openapi_import_response(applied));
|
||||
}
|
||||
|
||||
let source = match import_job_source(&job.preview_payload, locale) {
|
||||
Ok(source) => source,
|
||||
Err(error) => {
|
||||
return self
|
||||
.fail_openapi_import_or_replay(
|
||||
&replay_context,
|
||||
"import_source_verification_failed",
|
||||
error,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
};
|
||||
let verified = match self
|
||||
.registry
|
||||
.read_artifact_source(
|
||||
std::sync::Arc::clone(&self.artifact_store),
|
||||
workspace_id,
|
||||
&source.source_id,
|
||||
)
|
||||
let resolved_preview = match self
|
||||
.resolve_verified_openapi_preview(workspace_id, &job, locale)
|
||||
.await
|
||||
{
|
||||
Ok(verified) => verified,
|
||||
Err(
|
||||
error @ (RegistryError::SourceNotFound { .. } | RegistryError::SourceUnavailable),
|
||||
) => {
|
||||
Ok(resolved) => resolved,
|
||||
Err(ImportPreviewResolution::Fatal(error_code, error)) => {
|
||||
return self
|
||||
.fail_openapi_import_or_replay(
|
||||
&replay_context,
|
||||
"import_source_verification_failed",
|
||||
openapi_source_error(locale, error),
|
||||
)
|
||||
.fail_openapi_import_or_replay(&replay_context, error_code, error)
|
||||
.await;
|
||||
}
|
||||
Err(error @ RegistryError::SourceIntegrity) => {
|
||||
return self
|
||||
.fail_openapi_import_or_replay(
|
||||
&replay_context,
|
||||
"import_source_verification_failed",
|
||||
openapi_source_error(locale, error),
|
||||
)
|
||||
.await;
|
||||
}
|
||||
Err(error) => return Err(openapi_source_error(locale, error)),
|
||||
Err(ImportPreviewResolution::NonFatal(error)) => return Err(error),
|
||||
};
|
||||
if verified.source.blob.artifact_ref != source.digest {
|
||||
return self
|
||||
.fail_openapi_import_or_replay(
|
||||
&replay_context,
|
||||
"import_source_verification_failed",
|
||||
ApiError::openapi_upload(locale, "source_integrity"),
|
||||
)
|
||||
.await;
|
||||
}
|
||||
let replay_contract = match import_replay_contract(&job.preview_payload, locale) {
|
||||
Ok(contract) => contract,
|
||||
Err(error) => {
|
||||
return self
|
||||
.fail_openapi_import_or_replay(
|
||||
&replay_context,
|
||||
"import_replay_verification_failed",
|
||||
error,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
};
|
||||
let parsed = match replay_contract {
|
||||
ImportReplayContract::PersistedV2(parsed) => parsed,
|
||||
ImportReplayContract::LegacyV1 | ImportReplayContract::Current => {
|
||||
let legacy_v1 = matches!(replay_contract, ImportReplayContract::LegacyV1);
|
||||
let dependency_snapshots = match self
|
||||
.read_import_job_dependencies(workspace_id, &job.preview_payload, locale)
|
||||
.await
|
||||
{
|
||||
Ok(snapshots) => snapshots,
|
||||
Err(error) => {
|
||||
return self
|
||||
.fail_openapi_import_or_replay(
|
||||
&replay_context,
|
||||
"import_dependency_verification_failed",
|
||||
error,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
};
|
||||
let normalization_config = match import_job_normalization_config(
|
||||
&job.preview_payload,
|
||||
&self.external_reference_normalization,
|
||||
legacy_v1,
|
||||
locale,
|
||||
) {
|
||||
Ok(config) => config,
|
||||
Err(error) => {
|
||||
return self
|
||||
.fail_openapi_import_or_replay(
|
||||
&replay_context,
|
||||
"import_replay_verification_failed",
|
||||
error,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
};
|
||||
let parsed = match parse_verified_preview(
|
||||
verified.bytes,
|
||||
source.digest.digest_hex().to_owned(),
|
||||
dependency_snapshots,
|
||||
normalization_config,
|
||||
locale,
|
||||
legacy_v1,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(parsed) => parsed,
|
||||
Err(error) => {
|
||||
return self
|
||||
.fail_openapi_import_or_replay(
|
||||
&replay_context,
|
||||
"import_replay_verification_failed",
|
||||
error,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
};
|
||||
if let Err(error) = verify_preview_contract(&job.preview_payload, &parsed, locale) {
|
||||
return self
|
||||
.fail_openapi_import_or_replay(
|
||||
&replay_context,
|
||||
"import_replay_verification_failed",
|
||||
error,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
parsed
|
||||
}
|
||||
};
|
||||
if preview_has_blocker(&parsed.preview, &selected) {
|
||||
let preview = resolved_preview.preview;
|
||||
if preview_has_blocker(&preview, &selected) {
|
||||
return self
|
||||
.fail_openapi_import_or_replay(
|
||||
&replay_context,
|
||||
@@ -420,7 +317,7 @@ impl AdminService {
|
||||
.await;
|
||||
}
|
||||
let mut candidates = BTreeMap::new();
|
||||
for group in &parsed.preview.groups {
|
||||
for group in &preview.groups {
|
||||
for operation in &group.operations {
|
||||
candidates.insert(operation.key.clone(), operation);
|
||||
}
|
||||
@@ -599,227 +496,6 @@ fn validate_openapi_upload(upload: &OpenApiUpload) -> Result<(), ApiError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
struct ParsedOpenApiPreview {
|
||||
preview: crank_import::rest::ImportPreview,
|
||||
ir_fingerprint: String,
|
||||
}
|
||||
|
||||
enum ImportReplayContract {
|
||||
LegacyV1,
|
||||
PersistedV2(ParsedOpenApiPreview),
|
||||
Current,
|
||||
}
|
||||
|
||||
fn import_replay_contract(
|
||||
payload: &serde_json::Value,
|
||||
locale: OpenApiUploadLocale,
|
||||
) -> Result<ImportReplayContract, ApiError> {
|
||||
let Some(normalization) = payload.get("normalization") else {
|
||||
return Ok(ImportReplayContract::LegacyV1);
|
||||
};
|
||||
let normalizer = normalization
|
||||
.get("normalizer_version")
|
||||
.and_then(serde_json::Value::as_str)
|
||||
.ok_or_else(|| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
let projection = normalization
|
||||
.get("projection_version")
|
||||
.and_then(serde_json::Value::as_str)
|
||||
.ok_or_else(|| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
let ir_fingerprint = normalization
|
||||
.get("ir_fingerprint")
|
||||
.and_then(serde_json::Value::as_str)
|
||||
.filter(|value| is_lower_sha256(value))
|
||||
.ok_or_else(|| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
let expected_preview_digest = payload
|
||||
.get("preview_digest")
|
||||
.and_then(serde_json::Value::as_str)
|
||||
.filter(|value| is_lower_sha256(value))
|
||||
.ok_or_else(|| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
|
||||
if normalizer == NORMALIZER_VERSION && projection == PROJECTION_VERSION {
|
||||
return Ok(ImportReplayContract::Current);
|
||||
}
|
||||
// Historical preview payloads are replayed as their persisted projection.
|
||||
// They must never be parsed again with the current v4 semantics.
|
||||
if !matches!(
|
||||
(normalizer, projection),
|
||||
("normalized-ir-v2", "preview-v2") | ("normalized-ir-v3", "preview-v3")
|
||||
) {
|
||||
return Err(ApiError::openapi_upload(locale, "source_integrity"));
|
||||
}
|
||||
|
||||
let preview_value = payload
|
||||
.get("preview")
|
||||
.cloned()
|
||||
.ok_or_else(|| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
if preview_digest(&preview_value)? != expected_preview_digest {
|
||||
return Err(ApiError::openapi_upload(locale, "source_integrity"));
|
||||
}
|
||||
let preview = serde_json::from_value(preview_value)
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
Ok(ImportReplayContract::PersistedV2(ParsedOpenApiPreview {
|
||||
preview,
|
||||
ir_fingerprint: ir_fingerprint.to_owned(),
|
||||
}))
|
||||
}
|
||||
|
||||
fn is_lower_sha256(value: &str) -> bool {
|
||||
value.len() == 64
|
||||
&& value
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
|
||||
}
|
||||
|
||||
async fn parse_verified_preview(
|
||||
bytes: Vec<u8>,
|
||||
digest: String,
|
||||
snapshots: Vec<crank_import::rest::ExternalDocumentSnapshot>,
|
||||
normalization_config: crank_import::rest::NormalizationConfig,
|
||||
locale: OpenApiUploadLocale,
|
||||
legacy_v1: bool,
|
||||
) -> Result<ParsedOpenApiPreview, ApiError> {
|
||||
let started = tokio::time::Instant::now();
|
||||
let permit = tokio::time::timeout(OPENAPI_PARSE_DEADLINE, OPENAPI_PARSE_SLOTS.acquire())
|
||||
.await
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "parser_unavailable"))?
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "parser_unavailable"))?;
|
||||
let parsing = tokio::task::spawn_blocking(move || {
|
||||
// Keep the permit inside the blocking task. Timing out the caller
|
||||
// cannot cancel CPU work already running, but abandoned parsers remain
|
||||
// globally bounded and release capacity when they actually finish.
|
||||
let _permit = permit;
|
||||
let document = std::str::from_utf8(&bytes)
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "invalid_utf8"))?;
|
||||
if legacy_v1 {
|
||||
return crank_import::rest::preview_document_legacy_v1(document)
|
||||
.map(|preview| ParsedOpenApiPreview {
|
||||
preview,
|
||||
ir_fingerprint: String::new(),
|
||||
})
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "invalid_document"));
|
||||
}
|
||||
let digest = crank_import::rest::SourceDigest::parse(digest)
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
let ir = crank_import::rest::normalize_verified_bundle(
|
||||
document,
|
||||
digest,
|
||||
&snapshots,
|
||||
&normalization_config,
|
||||
)
|
||||
.map_err(|error| match error {
|
||||
crank_import::rest::ImportParseError::NoMethods => {
|
||||
ApiError::openapi_upload(locale, "no_methods")
|
||||
}
|
||||
_ => ApiError::openapi_upload(locale, "invalid_document"),
|
||||
})?;
|
||||
let ir_fingerprint = preview_digest(
|
||||
&serde_json::to_value(&ir)
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "invalid_document"))?,
|
||||
)?;
|
||||
Ok::<_, ApiError>(ParsedOpenApiPreview {
|
||||
preview: crank_import::rest::preview_from_ir(&ir),
|
||||
ir_fingerprint,
|
||||
})
|
||||
});
|
||||
let remaining = OPENAPI_PARSE_DEADLINE
|
||||
.checked_sub(started.elapsed())
|
||||
.unwrap_or(std::time::Duration::ZERO);
|
||||
tokio::time::timeout(remaining, parsing)
|
||||
.await
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "parser_unavailable"))?
|
||||
.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(locale: OpenApiUploadLocale, error: RegistryError) -> ApiError {
|
||||
match error {
|
||||
RegistryError::SourceNotFound { .. } | RegistryError::SourceUnavailable => {
|
||||
ApiError::openapi_upload(locale, "source_unavailable")
|
||||
}
|
||||
RegistryError::SourceIntegrity => ApiError::openapi_upload(locale, "source_integrity"),
|
||||
other => ApiError::from(other),
|
||||
}
|
||||
}
|
||||
|
||||
fn preview_digest(preview: &serde_json::Value) -> Result<String, ApiError> {
|
||||
let canonical =
|
||||
serde_json::to_vec(preview).map_err(|error| ApiError::internal(error.to_string()))?;
|
||||
Ok(format!("{:x}", Sha256::digest(canonical)))
|
||||
}
|
||||
|
||||
fn verify_preview_contract(
|
||||
payload: &serde_json::Value,
|
||||
parsed: &ParsedOpenApiPreview,
|
||||
locale: OpenApiUploadLocale,
|
||||
) -> Result<(), ApiError> {
|
||||
// Pre-fingerprint jobs are legacy rolling-upgrade records. They retain the
|
||||
// old reparse behavior; new jobs fail closed if parser output drifts or a
|
||||
// persisted preview has been changed.
|
||||
let expected = payload
|
||||
.get("preview_digest")
|
||||
.and_then(serde_json::Value::as_str);
|
||||
if payload.get("normalization").is_some() && expected.is_none() {
|
||||
return Err(ApiError::openapi_upload(locale, "source_integrity"));
|
||||
}
|
||||
let Some(expected) = expected else {
|
||||
return Ok(());
|
||||
};
|
||||
let actual = preview_digest(
|
||||
&serde_json::to_value(&parsed.preview)
|
||||
.map_err(|error| ApiError::internal(error.to_string()))?,
|
||||
)?;
|
||||
if actual == expected {
|
||||
if let Some(normalization) = payload.get("normalization") {
|
||||
let normalizer = normalization
|
||||
.get("normalizer_version")
|
||||
.and_then(serde_json::Value::as_str);
|
||||
let projection = normalization
|
||||
.get("projection_version")
|
||||
.and_then(serde_json::Value::as_str);
|
||||
let fingerprint = normalization
|
||||
.get("ir_fingerprint")
|
||||
.and_then(serde_json::Value::as_str);
|
||||
if normalizer != Some(NORMALIZER_VERSION)
|
||||
|| projection != Some(PROJECTION_VERSION)
|
||||
|| fingerprint != Some(parsed.ir_fingerprint.as_str())
|
||||
{
|
||||
return Err(ApiError::openapi_upload(locale, "source_integrity"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
} else {
|
||||
Err(ApiError::openapi_upload(locale, "source_integrity"))
|
||||
}
|
||||
}
|
||||
|
||||
fn preview_has_blocker(
|
||||
preview: &crank_import::rest::ImportPreview,
|
||||
selected_operation_keys: &BTreeSet<String>,
|
||||
) -> bool {
|
||||
preview
|
||||
.findings
|
||||
.iter()
|
||||
.any(|finding| finding.severity == ImportFindingSeverity::Error)
|
||||
|| preview
|
||||
.groups
|
||||
.iter()
|
||||
.flat_map(|group| group.operations.iter())
|
||||
.filter(|operation| selected_operation_keys.contains(&operation.key))
|
||||
.flat_map(|operation| operation.findings.iter())
|
||||
.any(|finding| finding.severity == ImportFindingSeverity::Error)
|
||||
}
|
||||
|
||||
fn openapi_application_key(payload: &OpenApiImportCreatePayload) -> Result<String, ApiError> {
|
||||
let selected_operation_keys = payload
|
||||
.selected_operation_keys
|
||||
|
||||
@@ -0,0 +1,777 @@
|
||||
use super::*;
|
||||
|
||||
impl AdminService {
|
||||
#[instrument(skip(self, payload), fields(workspace_id = %workspace_id.as_str(), job_id = %job_id.as_str()))]
|
||||
pub async fn create_openapi_import_plan(
|
||||
&self,
|
||||
workspace_id: &WorkspaceId,
|
||||
job_id: &ImportJobId,
|
||||
payload: OpenApiImportPlanCreatePayload,
|
||||
) -> Result<OpenApiImportPlanCreateResponse, ApiError> {
|
||||
self.ensure_workspace_exists(workspace_id).await?;
|
||||
|
||||
let now = OffsetDateTime::now_utc();
|
||||
let job = self
|
||||
.registry
|
||||
.get_import_job(workspace_id, job_id)
|
||||
.await?
|
||||
.ok_or_else(|| {
|
||||
ApiError::not_found_with_context(
|
||||
"import job was not found",
|
||||
json!({ "job_id": job_id.as_str() }),
|
||||
)
|
||||
})?;
|
||||
if job.kind != ImportJobKind::OpenApi {
|
||||
return Err(ApiError::validation("import job kind is not openapi"));
|
||||
}
|
||||
if job.expires_at <= now {
|
||||
return Err(ApiError::validation("import preview has expired"));
|
||||
}
|
||||
if job.status != ImportJobStatus::Pending {
|
||||
return Err(import_plan_repreview_error("import_plan_job_terminal"));
|
||||
}
|
||||
|
||||
if payload.decisions.len() > MAX_IMPORT_PLAN_KEYS {
|
||||
return Err(ApiError::validation(
|
||||
"too many decision blocks for this import plan",
|
||||
));
|
||||
}
|
||||
if payload.server_url.as_deref().is_some_and(|server_url| {
|
||||
server_url.is_empty() || server_url.len() > MAX_IMPORT_PLAN_SERVER_URL_BYTES
|
||||
}) {
|
||||
return Err(ApiError::validation_with_context(
|
||||
"server_url is empty or too long",
|
||||
json!({ "error_code": "import_plan_invalid_input" }),
|
||||
));
|
||||
}
|
||||
|
||||
// The plan is anchored to the verified job snapshots. A stale or
|
||||
// corrupt preview is reported as bounded re-preview guidance and
|
||||
// never mutates the job: other stored plans may still reference the
|
||||
// same job and its replay must remain readable.
|
||||
let resolved = self
|
||||
.resolve_verified_openapi_preview(workspace_id, &job, OpenApiUploadLocale::En)
|
||||
.await
|
||||
.map_err(|resolution| match resolution {
|
||||
ImportPreviewResolution::Fatal(error_code, _) => {
|
||||
import_plan_repreview_error(error_code)
|
||||
}
|
||||
ImportPreviewResolution::NonFatal(error) => error,
|
||||
})?;
|
||||
let preview = &resolved.preview;
|
||||
|
||||
// Stored external dependency snapshots are re-verified for every
|
||||
// replay variant (including historically persisted ones) without a
|
||||
// network fetch: detached or altered snapshots are re-preview
|
||||
// material and no plan is created.
|
||||
self.read_import_job_dependencies(
|
||||
workspace_id,
|
||||
&job.preview_payload,
|
||||
OpenApiUploadLocale::En,
|
||||
)
|
||||
.await
|
||||
.map_err(|_| import_plan_repreview_error("import_dependency_verification_failed"))?;
|
||||
|
||||
let candidates: BTreeMap<String, &ImportOperationCandidate> = preview
|
||||
.groups
|
||||
.iter()
|
||||
.flat_map(|group| group.operations.iter())
|
||||
.map(|operation| (operation.key.clone(), operation))
|
||||
.collect();
|
||||
let all_set: BTreeSet<String> = candidates.keys().cloned().collect();
|
||||
let selected = resolve_plan_selection(
|
||||
&payload.selection_mode,
|
||||
&payload.selected_operation_keys,
|
||||
&all_set,
|
||||
)?;
|
||||
if selected.len() > MAX_IMPORT_PLAN_KEYS
|
||||
|| all_set.len() - selected.len() > MAX_IMPORT_PLAN_KEYS
|
||||
{
|
||||
return Err(ApiError::validation_with_context(
|
||||
"too many candidates for an import plan",
|
||||
json!({ "error_code": "import_plan_invalid_input" }),
|
||||
));
|
||||
}
|
||||
let selected_keys: Vec<String> = selected.iter().cloned().collect();
|
||||
let excluded: Vec<String> = all_set
|
||||
.iter()
|
||||
.filter(|key| !selected.contains(*key))
|
||||
.cloned()
|
||||
.collect();
|
||||
let decisions = validate_plan_decisions(&payload.decisions, &selected)?;
|
||||
|
||||
let global_blocker = preview
|
||||
.findings
|
||||
.iter()
|
||||
.find(|finding| finding.severity == ImportFindingSeverity::Error)
|
||||
.map(|finding| finding.code.clone());
|
||||
|
||||
let mut planned = Vec::with_capacity(selected_keys.len());
|
||||
for key in &selected_keys {
|
||||
let Some(candidate) = candidates.get(key) else {
|
||||
unreachable!("selection is validated against the candidate set");
|
||||
};
|
||||
let blocker = global_blocker.clone().or_else(|| {
|
||||
candidate
|
||||
.findings
|
||||
.iter()
|
||||
.find(|finding| finding.severity == ImportFindingSeverity::Error)
|
||||
.map(|finding| finding.code.clone())
|
||||
});
|
||||
let candidate_plan = self
|
||||
.plan_import_candidate(
|
||||
workspace_id,
|
||||
payload.server_url.as_deref(),
|
||||
key,
|
||||
candidate,
|
||||
decisions.get(key).copied(),
|
||||
blocker,
|
||||
)
|
||||
.await?;
|
||||
planned.push(candidate_plan);
|
||||
}
|
||||
|
||||
let counts = OpenApiImportPlanCounts {
|
||||
selected: planned.len(),
|
||||
excluded: excluded.len(),
|
||||
actionable: planned
|
||||
.iter()
|
||||
.filter(|candidate| !candidate.blocked)
|
||||
.count(),
|
||||
blocked: planned.iter().filter(|candidate| candidate.blocked).count(),
|
||||
};
|
||||
|
||||
// Server-authored immutable plan. Client-supplied candidate material,
|
||||
// digests or payload fields are not read: every value below derives
|
||||
// from the verified job preview and the revalidated decisions.
|
||||
let all_keys: Vec<String> = all_set.iter().cloned().collect();
|
||||
let plan_counts_value = json!({
|
||||
"selected": counts.selected,
|
||||
"excluded": counts.excluded,
|
||||
"actionable": counts.actionable,
|
||||
"blocked": counts.blocked,
|
||||
});
|
||||
let plan_reference = new_prefixed_id("plan");
|
||||
let plan_payload = json!({
|
||||
"schema_version": "import-plan-v1",
|
||||
"plan_reference": plan_reference,
|
||||
"job_id": job_id.as_str(),
|
||||
"server_url": payload.server_url,
|
||||
"source": {
|
||||
"source_id": resolved.source.source_id.as_str(),
|
||||
"digest": resolved.source.digest.as_str(),
|
||||
},
|
||||
"dependencies": job.preview_payload.get("dependencies").cloned().unwrap_or(json!([])),
|
||||
"fingerprint": resolved.fingerprint,
|
||||
"selection": {
|
||||
"mode": payload.selection_mode,
|
||||
"all": all_keys,
|
||||
"selected": selected_keys,
|
||||
"excluded": excluded,
|
||||
},
|
||||
"counts": plan_counts_value,
|
||||
"candidates": planned.iter().map(plan_candidate_payload).collect::<Result<Vec<_>, _>>()?,
|
||||
});
|
||||
|
||||
let plan_reference_id = ImportPlanId::new(&plan_reference);
|
||||
let created = self
|
||||
.registry
|
||||
.create_import_plan(CreateImportPlanRequest {
|
||||
id: &plan_reference_id,
|
||||
workspace_id,
|
||||
job_id,
|
||||
payload: &plan_payload,
|
||||
created_at: &now,
|
||||
expires_at: &job.expires_at,
|
||||
})
|
||||
.await
|
||||
.map_err(ApiError::from)?;
|
||||
|
||||
let mut candidate_views: Vec<OpenApiImportPlanCandidateView> = planned
|
||||
.iter()
|
||||
.map(|candidate| OpenApiImportPlanCandidateView {
|
||||
key: candidate.key.clone(),
|
||||
name: candidate.name.clone(),
|
||||
state: if candidate.blocked {
|
||||
"blocked"
|
||||
} else {
|
||||
"actionable"
|
||||
}
|
||||
.to_owned(),
|
||||
action: Some(candidate.action.clone()),
|
||||
target_operation_id: candidate.target_operation_id.clone(),
|
||||
confirmed_name: candidate.confirmed_name.clone(),
|
||||
auth_profile_id: candidate.auth_profile_id.clone(),
|
||||
reason: candidate.reason.clone(),
|
||||
})
|
||||
.collect();
|
||||
candidate_views.extend(excluded.iter().map(|key| {
|
||||
let name = candidates
|
||||
.get(key)
|
||||
.map(|candidate| candidate.draft.name.clone())
|
||||
.unwrap_or_default();
|
||||
OpenApiImportPlanCandidateView {
|
||||
key: key.clone(),
|
||||
name,
|
||||
state: "excluded".to_owned(),
|
||||
action: None,
|
||||
target_operation_id: None,
|
||||
confirmed_name: None,
|
||||
auth_profile_id: None,
|
||||
reason: Some("not_selected".to_owned()),
|
||||
}
|
||||
}));
|
||||
|
||||
Ok(OpenApiImportPlanCreateResponse {
|
||||
plan_reference: created.id.as_str().to_owned(),
|
||||
plan_digest: created.digest,
|
||||
expires_at: created
|
||||
.expires_at
|
||||
.format(&Rfc3339)
|
||||
.map_err(|error| ApiError::internal(error.to_string()))?,
|
||||
selection_mode: payload.selection_mode,
|
||||
counts,
|
||||
candidates: candidate_views,
|
||||
})
|
||||
}
|
||||
|
||||
/// Materializes one selected candidate of the plan: the confirmed
|
||||
/// decision, the exact authorized target with its expected state and the
|
||||
/// full Draft snapshot (create/rename/new_version) or the bounded
|
||||
/// redacted rejection reason (blocked).
|
||||
async fn plan_import_candidate(
|
||||
&self,
|
||||
workspace_id: &WorkspaceId,
|
||||
server_url: Option<&str>,
|
||||
key: &str,
|
||||
candidate: &ImportOperationCandidate,
|
||||
decision: Option<&OpenApiImportPlanDecision>,
|
||||
blocker_reason: Option<String>,
|
||||
) -> Result<PlannedCandidate, ApiError> {
|
||||
let action = decision
|
||||
.map(|decision| decision.action.as_str())
|
||||
.unwrap_or("create");
|
||||
let target_operation_id =
|
||||
decision.and_then(|decision| decision.target_operation_id.clone());
|
||||
let confirmed_name = decision.and_then(|decision| decision.confirmed_name.clone());
|
||||
let auth_profile_id = decision.and_then(|decision| decision.auth_profile_id.clone());
|
||||
let candidate_name = candidate.draft.name.clone();
|
||||
|
||||
let blocked = blocker_reason.is_some();
|
||||
|
||||
// Explicit skip/new_version targets are always resolved in the
|
||||
// workspace: an unknown target, a name mismatch, or an incompatible
|
||||
// protocol is a request error even when the candidate is already
|
||||
// blocked.
|
||||
let mut target = None;
|
||||
let mut target_summary = None;
|
||||
let mut next_version: Option<u32> = None;
|
||||
if matches!(action, "skip" | "new_version") {
|
||||
let target_id = target_operation_id
|
||||
.as_ref()
|
||||
.expect("target_operation_id is validated for skip/new_version")
|
||||
.clone();
|
||||
let target_operation = OperationId::new(target_id.clone());
|
||||
let summary = self
|
||||
.registry
|
||||
.get_operation_summary(workspace_id, &target_operation)
|
||||
.await?
|
||||
.ok_or_else(|| {
|
||||
ApiError::validation_with_context(
|
||||
"decision target operation was not found in this workspace",
|
||||
json!({
|
||||
"target_operation_id": target_id,
|
||||
"error_code": "import_plan_target_invalid"
|
||||
}),
|
||||
)
|
||||
})?;
|
||||
if summary.name != candidate_name {
|
||||
return Err(ApiError::validation_with_context(
|
||||
"decision target does not match the candidate name in this workspace",
|
||||
json!({
|
||||
"target_operation_id": target_id,
|
||||
"error_code": "import_plan_target_invalid"
|
||||
}),
|
||||
));
|
||||
}
|
||||
if action == "new_version"
|
||||
&& (summary.protocol != Protocol::Rest
|
||||
|| summary.status == OperationStatus::Archived)
|
||||
{
|
||||
return Err(ApiError::validation_with_context(
|
||||
"new_version target must be an active REST operation",
|
||||
json!({
|
||||
"target_operation_id": target_id,
|
||||
"error_code": "import_plan_target_invalid"
|
||||
}),
|
||||
));
|
||||
}
|
||||
target = Some(json!({
|
||||
"operation_id": target_id,
|
||||
"name": summary.name,
|
||||
"expected_state": {
|
||||
"status": serde_json::to_value(summary.status)
|
||||
.map_err(|error| ApiError::internal(error.to_string()))?,
|
||||
"current_draft_version": summary.current_draft_version,
|
||||
"latest_published_version": summary.latest_published_version,
|
||||
},
|
||||
}));
|
||||
if action == "new_version" {
|
||||
let version = summary
|
||||
.current_draft_version
|
||||
.checked_add(1)
|
||||
.filter(|value| i32::try_from(*value).is_ok())
|
||||
.ok_or_else(|| {
|
||||
ApiError::conflict_with_context(
|
||||
"operation revision limit reached",
|
||||
json!({ "error_code": "operation_revision_exhausted" }),
|
||||
)
|
||||
})?;
|
||||
next_version = Some(version);
|
||||
}
|
||||
target_summary = Some(summary);
|
||||
}
|
||||
|
||||
// create/rename must land on a name that is free now; the server
|
||||
// never auto-selects a replacement when the confirmed name is taken.
|
||||
if !blocked && matches!(action, "create" | "rename") {
|
||||
let final_name = confirmed_name.as_deref().unwrap_or(candidate_name.as_str());
|
||||
if self
|
||||
.find_operation_by_name(workspace_id, final_name)
|
||||
.await?
|
||||
.is_some()
|
||||
{
|
||||
if action == "create" && decision.is_none() {
|
||||
return Ok(PlannedCandidate {
|
||||
key: key.to_owned(),
|
||||
name: candidate_name,
|
||||
blocked: true,
|
||||
reason: Some("operation_name_conflict".to_owned()),
|
||||
action: action.to_owned(),
|
||||
target_operation_id,
|
||||
confirmed_name,
|
||||
auth_profile_id,
|
||||
auth_snapshot: None,
|
||||
target: None,
|
||||
operation: None,
|
||||
});
|
||||
}
|
||||
return Err(ApiError::conflict_with_context(
|
||||
format!("operation with name {final_name} already exists"),
|
||||
json!({
|
||||
"name": final_name,
|
||||
"error_code": "import_plan_name_conflict",
|
||||
"recovery": "confirm_skip_rename_or_new_version"
|
||||
}),
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
// The final server-authored auth profile reference: the explicit
|
||||
// decision, or the target's reference inherited for an actionable
|
||||
// new_version. Only the reference (never a secret value) is stored.
|
||||
let mut auth_profile_ref = auth_profile_id
|
||||
.as_deref()
|
||||
.map(|id| AuthProfileId::new(id.to_owned()));
|
||||
if let Some(summary) = target_summary.as_ref()
|
||||
&& !blocked
|
||||
&& action == "new_version"
|
||||
&& auth_profile_ref.is_none()
|
||||
{
|
||||
let record = self
|
||||
.registry
|
||||
.get_operation_version(workspace_id, &summary.id, summary.current_draft_version)
|
||||
.await?
|
||||
.ok_or_else(|| ApiError::internal("current operation version is unavailable"))?;
|
||||
auth_profile_ref = record.snapshot.execution_config.auth_profile_ref;
|
||||
}
|
||||
let auth_profile_id = auth_profile_ref.as_ref().map(|id| id.as_str().to_owned());
|
||||
|
||||
if blocked {
|
||||
return Ok(PlannedCandidate {
|
||||
key: key.to_owned(),
|
||||
name: candidate_name,
|
||||
blocked: true,
|
||||
reason: blocker_reason,
|
||||
action: action.to_owned(),
|
||||
target_operation_id,
|
||||
confirmed_name,
|
||||
auth_profile_id,
|
||||
auth_snapshot: None,
|
||||
target,
|
||||
operation: None,
|
||||
});
|
||||
}
|
||||
|
||||
if action == "skip" {
|
||||
return Ok(PlannedCandidate {
|
||||
key: key.to_owned(),
|
||||
name: candidate_name,
|
||||
blocked: false,
|
||||
reason: None,
|
||||
action: action.to_owned(),
|
||||
target_operation_id,
|
||||
confirmed_name,
|
||||
auth_profile_id,
|
||||
auth_snapshot: None,
|
||||
target,
|
||||
operation: None,
|
||||
});
|
||||
}
|
||||
|
||||
let mut draft = operation_draft_from_candidate(candidate, server_url);
|
||||
if action == "rename" {
|
||||
draft.name = confirmed_name
|
||||
.clone()
|
||||
.expect("rename decisions carry the exact confirmed_name");
|
||||
}
|
||||
attach_import_findings(&mut draft, candidate);
|
||||
let operation = self.new_operation_snapshot(OperationPayload {
|
||||
name: draft.name.clone(),
|
||||
display_name: draft.display_name.clone(),
|
||||
category: draft.category,
|
||||
protocol: Protocol::Rest,
|
||||
security_level: OperationSecurityLevel::Standard,
|
||||
target: crank_core::Target::Rest(draft.target),
|
||||
input_schema: draft.input_schema,
|
||||
output_schema: draft.output_schema,
|
||||
input_mapping: draft.input_mapping,
|
||||
output_mapping: draft.output_mapping,
|
||||
execution_config: ExecutionConfig {
|
||||
timeout_ms: 10_000,
|
||||
retry_policy: None,
|
||||
response_cache: None,
|
||||
idempotency: None,
|
||||
safety: None,
|
||||
approval_policy: None,
|
||||
auth_profile_ref,
|
||||
headers: BTreeMap::new(),
|
||||
},
|
||||
tool_description: draft.tool_description,
|
||||
wizard_state: draft.wizard_state,
|
||||
})?;
|
||||
// The same workspace/auth secret validator the operation creation
|
||||
// path uses: the referenced profile and its active secret refs must
|
||||
// resolve in this workspace before the plan is accepted.
|
||||
self.validate_registry_operation_in_workspace(workspace_id, &operation)
|
||||
.await?;
|
||||
let mut operation = operation;
|
||||
if action == "new_version" {
|
||||
let target_id = target_operation_id
|
||||
.clone()
|
||||
.expect("new_version decisions carry target_operation_id");
|
||||
operation.id = OperationId::new(target_id);
|
||||
operation.version = next_version.expect("new_version computes the next Draft version");
|
||||
}
|
||||
let auth_snapshot = match operation.execution_config.auth_profile_ref.as_ref() {
|
||||
Some(profile_id) => Some(self.import_auth_snapshot(workspace_id, profile_id).await?),
|
||||
None => None,
|
||||
};
|
||||
|
||||
Ok(PlannedCandidate {
|
||||
key: key.to_owned(),
|
||||
name: draft.name,
|
||||
blocked: false,
|
||||
reason: None,
|
||||
action: action.to_owned(),
|
||||
target_operation_id,
|
||||
confirmed_name,
|
||||
auth_profile_id,
|
||||
auth_snapshot,
|
||||
target,
|
||||
operation: Some(operation),
|
||||
})
|
||||
}
|
||||
|
||||
/// Captures only profile configuration and secret metadata. Credential
|
||||
/// values never enter the plan; Apply compares this snapshot under locks.
|
||||
async fn import_auth_snapshot(
|
||||
&self,
|
||||
workspace_id: &WorkspaceId,
|
||||
profile_id: &AuthProfileId,
|
||||
) -> Result<Value, ApiError> {
|
||||
let unavailable = || import_plan_repreview_error("import_plan_auth_unavailable");
|
||||
let profile = self
|
||||
.registry
|
||||
.get_auth_profile(workspace_id, profile_id)
|
||||
.await?
|
||||
.ok_or_else(unavailable)?;
|
||||
let mut secret_ids: Vec<String> = profile
|
||||
.config
|
||||
.secret_ids()
|
||||
.into_iter()
|
||||
.map(|id| id.as_str().to_owned())
|
||||
.collect();
|
||||
secret_ids.sort();
|
||||
secret_ids.dedup();
|
||||
let mut secrets = Vec::with_capacity(secret_ids.len());
|
||||
for id in secret_ids {
|
||||
let secret = self
|
||||
.registry
|
||||
.get_secret(workspace_id, &crank_core::SecretId::new(id.clone()))
|
||||
.await?
|
||||
.ok_or_else(unavailable)?
|
||||
.secret;
|
||||
secrets.push(json!({
|
||||
"id": id,
|
||||
"status": secret.status,
|
||||
"current_version": secret.current_version,
|
||||
"updated_at": secret.updated_at.format(&Rfc3339)
|
||||
.map_err(|error| ApiError::internal(error.to_string()))?,
|
||||
}));
|
||||
}
|
||||
Ok(json!({
|
||||
"profile_id": profile_id.as_str(),
|
||||
"name": profile.name,
|
||||
"kind": profile.kind,
|
||||
"config": profile.config,
|
||||
"updated_at": profile.updated_at.format(&Rfc3339)
|
||||
.map_err(|error| ApiError::internal(error.to_string()))?,
|
||||
"secrets": secrets,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
struct PlannedCandidate {
|
||||
key: String,
|
||||
name: String,
|
||||
blocked: bool,
|
||||
reason: Option<String>,
|
||||
action: String,
|
||||
target_operation_id: Option<String>,
|
||||
confirmed_name: Option<String>,
|
||||
auth_profile_id: Option<String>,
|
||||
auth_snapshot: Option<Value>,
|
||||
target: Option<Value>,
|
||||
operation: Option<RegistryOperation>,
|
||||
}
|
||||
|
||||
pub(super) fn import_plan_repreview_error(error_code: &'static str) -> ApiError {
|
||||
ApiError::conflict_with_context(
|
||||
"import plan revalidation failed; create a fresh preview",
|
||||
json!({
|
||||
"error_code": error_code,
|
||||
"recovery": "repreview_required",
|
||||
"repreview_required": true
|
||||
}),
|
||||
)
|
||||
}
|
||||
|
||||
/// Closes the selection against the current preview: `full` keeps every
|
||||
/// candidate (an explicit list must equal the whole candidate set), `partial`
|
||||
/// requires a non-empty exact subset. Unknown or duplicate keys are rejected
|
||||
/// before any plan material exists.
|
||||
fn resolve_plan_selection(
|
||||
selection_mode: &str,
|
||||
requested: &[String],
|
||||
all: &BTreeSet<String>,
|
||||
) -> Result<BTreeSet<String>, ApiError> {
|
||||
if !matches!(selection_mode, "full" | "partial") {
|
||||
return Err(ApiError::validation_with_context(
|
||||
"selection_mode must be full or partial",
|
||||
json!({ "error_code": "import_plan_invalid_input" }),
|
||||
));
|
||||
}
|
||||
if requested.len() > MAX_IMPORT_PLAN_KEYS {
|
||||
return Err(ApiError::validation_with_context(
|
||||
"too many selected_operation_keys for this import plan",
|
||||
json!({ "error_code": "import_plan_invalid_input" }),
|
||||
));
|
||||
}
|
||||
for key in requested {
|
||||
if key.is_empty() || key.len() > MAX_IMPORT_PLAN_KEY_BYTES {
|
||||
return Err(ApiError::validation_with_context(
|
||||
"selected_operation_keys entries are empty or too long",
|
||||
json!({ "error_code": "import_plan_invalid_input" }),
|
||||
));
|
||||
}
|
||||
}
|
||||
let requested_set: BTreeSet<&String> = requested.iter().collect();
|
||||
if requested_set.len() != requested.len() {
|
||||
return Err(ApiError::validation_with_context(
|
||||
"selected_operation_keys contains duplicates",
|
||||
json!({ "error_code": "import_plan_invalid_input" }),
|
||||
));
|
||||
}
|
||||
let all_set: BTreeSet<&String> = all.iter().collect();
|
||||
match selection_mode {
|
||||
"full" => {
|
||||
if !requested_set.is_empty() && requested_set != all_set {
|
||||
return Err(ApiError::validation_with_context(
|
||||
"full selection covers the entire candidate set; selected_operation_keys does not match the preview",
|
||||
json!({ "error_code": "import_plan_selection_mismatch" }),
|
||||
));
|
||||
}
|
||||
Ok(all.clone())
|
||||
}
|
||||
_ => {
|
||||
if requested_set.is_empty() {
|
||||
return Err(ApiError::validation_with_context(
|
||||
"partial selection requires at least one selected_operation_key",
|
||||
json!({ "error_code": "import_plan_invalid_input" }),
|
||||
));
|
||||
}
|
||||
if !requested_set.is_subset(&all_set) {
|
||||
return Err(ApiError::validation_with_context(
|
||||
"selected_operation_keys reference operations absent from the preview",
|
||||
json!({ "error_code": "import_plan_unknown_operation_key" }),
|
||||
));
|
||||
}
|
||||
Ok(requested.iter().cloned().collect())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Binds decisions to selected candidates with action-specific field rules:
|
||||
/// unknown/duplicate keys, foreign fields and oversized references are
|
||||
/// rejected before the plan is materialized.
|
||||
fn validate_plan_decisions<'input>(
|
||||
decisions: &'input [OpenApiImportPlanDecision],
|
||||
selected: &BTreeSet<String>,
|
||||
) -> Result<BTreeMap<String, &'input OpenApiImportPlanDecision>, ApiError> {
|
||||
let invalid = |context: Value| {
|
||||
Err(ApiError::validation_with_context(
|
||||
"import plan decision is invalid",
|
||||
context,
|
||||
))
|
||||
};
|
||||
let mut mapping = BTreeMap::new();
|
||||
for decision in decisions {
|
||||
if decision.operation_key.is_empty()
|
||||
|| decision.operation_key.len() > MAX_IMPORT_PLAN_KEY_BYTES
|
||||
{
|
||||
return invalid(json!({
|
||||
"operation_key": decision.operation_key,
|
||||
"error_code": "import_plan_invalid_input"
|
||||
}));
|
||||
}
|
||||
if !matches!(
|
||||
decision.action.as_str(),
|
||||
"create" | "skip" | "rename" | "new_version"
|
||||
) {
|
||||
return invalid(json!({
|
||||
"operation_key": decision.operation_key,
|
||||
"error_code": "import_plan_invalid_input"
|
||||
}));
|
||||
}
|
||||
validate_decision_fields(decision)?;
|
||||
if !selected.contains(&decision.operation_key) {
|
||||
return invalid(json!({
|
||||
"operation_key": decision.operation_key,
|
||||
"error_code": "import_plan_decision_unselected"
|
||||
}));
|
||||
}
|
||||
if mapping
|
||||
.insert(decision.operation_key.clone(), decision)
|
||||
.is_some()
|
||||
{
|
||||
return invalid(json!({
|
||||
"operation_key": decision.operation_key,
|
||||
"error_code": "import_plan_invalid_input"
|
||||
}));
|
||||
}
|
||||
}
|
||||
Ok(mapping)
|
||||
}
|
||||
|
||||
fn validate_decision_fields(decision: &OpenApiImportPlanDecision) -> Result<(), ApiError> {
|
||||
let context = json!({
|
||||
"operation_key": decision.operation_key,
|
||||
"error_code": "import_plan_invalid_input"
|
||||
});
|
||||
let invalid = |message: &str| -> Result<(), ApiError> {
|
||||
Err(ApiError::validation_with_context(message, context.clone()))
|
||||
};
|
||||
if decision
|
||||
.target_operation_id
|
||||
.as_deref()
|
||||
.is_some_and(|value| value.is_empty() || value.len() > MAX_IMPORT_PLAN_ID_REF_BYTES)
|
||||
{
|
||||
return invalid("decision target_operation_id is empty or too long");
|
||||
}
|
||||
if decision
|
||||
.confirmed_name
|
||||
.as_deref()
|
||||
.is_some_and(|value| value.is_empty() || value.len() > MAX_IMPORT_PLAN_NAME_BYTES)
|
||||
{
|
||||
return invalid("decision confirmed_name is empty or too long");
|
||||
}
|
||||
if decision
|
||||
.auth_profile_id
|
||||
.as_deref()
|
||||
.is_some_and(|value| value.is_empty() || value.len() > MAX_IMPORT_PLAN_ID_REF_BYTES)
|
||||
{
|
||||
return invalid("decision auth_profile_id is empty or too long");
|
||||
}
|
||||
match decision.action.as_str() {
|
||||
"create" => {
|
||||
if decision.target_operation_id.is_some() || decision.confirmed_name.is_some() {
|
||||
return invalid(
|
||||
"target_operation_id and confirmed_name are not allowed for action create",
|
||||
);
|
||||
}
|
||||
}
|
||||
"skip" => {
|
||||
if decision.auth_profile_id.is_some() {
|
||||
return invalid("auth_profile_id is not allowed for action skip");
|
||||
}
|
||||
if decision.target_operation_id.is_none() {
|
||||
return invalid("action skip requires the exact target_operation_id");
|
||||
}
|
||||
if decision.confirmed_name.is_some() {
|
||||
return invalid("confirmed_name is not allowed for action skip");
|
||||
}
|
||||
}
|
||||
"rename" => {
|
||||
if decision.target_operation_id.is_some() {
|
||||
return invalid("target_operation_id is not allowed for action rename");
|
||||
}
|
||||
if decision.confirmed_name.is_none() {
|
||||
return invalid("action rename requires the exact confirmed_name");
|
||||
}
|
||||
}
|
||||
"new_version" => {
|
||||
if decision.target_operation_id.is_none() {
|
||||
return invalid("action new_version requires the exact target_operation_id");
|
||||
}
|
||||
if decision.confirmed_name.is_some() {
|
||||
return invalid("confirmed_name is not allowed for action new_version");
|
||||
}
|
||||
}
|
||||
_ => unreachable!("decision action is validated before the field rules"),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Serializes one planned candidate into the versioned plan payload: the
|
||||
/// redacted decision, the bounded rejection reason (if any), the exact
|
||||
/// authorized target with expected state and, for mutating actions, the full
|
||||
/// server-authored Draft snapshot.
|
||||
fn plan_candidate_payload(candidate: &PlannedCandidate) -> Result<Value, ApiError> {
|
||||
let mut object = json!({
|
||||
"key": candidate.key,
|
||||
"name": candidate.name,
|
||||
"state": if candidate.blocked { "blocked" } else { "actionable" },
|
||||
"decision": {
|
||||
"action": candidate.action,
|
||||
"target_operation_id": candidate.target_operation_id,
|
||||
"confirmed_name": candidate.confirmed_name,
|
||||
"auth_profile_id": candidate.auth_profile_id,
|
||||
},
|
||||
});
|
||||
if let Some(reason) = &candidate.reason {
|
||||
object["reason"] = json!(reason);
|
||||
}
|
||||
if let Some(target) = &candidate.target {
|
||||
object["target"] = target.clone();
|
||||
}
|
||||
if let Some(auth_snapshot) = &candidate.auth_snapshot {
|
||||
object["auth_snapshot"] = auth_snapshot.clone();
|
||||
}
|
||||
if let Some(operation) = &candidate.operation {
|
||||
let value = serde_json::to_value(operation)
|
||||
.map_err(|error| ApiError::internal(error.to_string()))?;
|
||||
object["operation"] = value;
|
||||
}
|
||||
Ok(object)
|
||||
}
|
||||
@@ -0,0 +1,185 @@
|
||||
use super::*;
|
||||
use crank_registry::{ApplyImportPlanRequest, ImportPlanApplyReport};
|
||||
|
||||
const MAX_IMPORT_PLAN_IDEMPOTENCY_KEY_BYTES: usize = 128;
|
||||
|
||||
impl AdminService {
|
||||
#[instrument(skip(self, payload), fields(workspace_id = %workspace_id.as_str(), plan_id = %plan_id.as_str()))]
|
||||
pub async fn apply_openapi_import_plan(
|
||||
&self,
|
||||
workspace_id: &WorkspaceId,
|
||||
plan_id: &ImportPlanId,
|
||||
payload: OpenApiImportPlanApplyPayload,
|
||||
) -> Result<ImportPlanApplyReport, ApiError> {
|
||||
self.ensure_workspace_exists(workspace_id).await?;
|
||||
validate_apply_payload(&payload)?;
|
||||
|
||||
// The replay row is deliberately checked before the plan or job.
|
||||
// Its report remains authoritative after normal TTL cleanup removes
|
||||
// those source rows.
|
||||
if let Some(application) = self
|
||||
.registry
|
||||
.get_import_plan_application(workspace_id, &payload.idempotency_key)
|
||||
.await?
|
||||
{
|
||||
if application.plan_digest != payload.plan_digest {
|
||||
return Err(key_digest_conflict());
|
||||
}
|
||||
return Ok(application.result.report);
|
||||
}
|
||||
|
||||
let plan = self
|
||||
.registry
|
||||
.get_import_plan(workspace_id, plan_id)
|
||||
.await?
|
||||
.ok_or_else(|| {
|
||||
ApiError::not_found_with_context(
|
||||
"import plan was not found in this workspace",
|
||||
json!({ "error_code": "import_plan_not_found" }),
|
||||
)
|
||||
})?;
|
||||
|
||||
if plan.digest != payload.plan_digest {
|
||||
return Err(import_plan_repreview_error("import_plan_digest_mismatch"));
|
||||
}
|
||||
let now = OffsetDateTime::now_utc();
|
||||
if plan.expires_at <= now {
|
||||
return Err(import_plan_repreview_error("import_plan_expired"));
|
||||
}
|
||||
|
||||
let job = self
|
||||
.registry
|
||||
.get_import_job(workspace_id, &plan.job_id)
|
||||
.await?
|
||||
.ok_or_else(|| import_plan_repreview_error("import_plan_job_unavailable"))?;
|
||||
if job.kind != ImportJobKind::OpenApi {
|
||||
return Err(import_plan_repreview_error("import_plan_job_kind_mismatch"));
|
||||
}
|
||||
if job.status != ImportJobStatus::Pending || job.expires_at <= now {
|
||||
return Err(import_plan_repreview_error("import_plan_job_terminal"));
|
||||
}
|
||||
|
||||
let resolved = self
|
||||
.resolve_verified_openapi_preview(workspace_id, &job, OpenApiUploadLocale::En)
|
||||
.await
|
||||
.map_err(|resolution| match resolution {
|
||||
ImportPreviewResolution::Fatal(error_code, _) => {
|
||||
import_plan_repreview_error(error_code)
|
||||
}
|
||||
ImportPreviewResolution::NonFatal(_) => {
|
||||
import_plan_repreview_error("import_preview_revalidation_failed")
|
||||
}
|
||||
})?;
|
||||
|
||||
// Applying a new plan requires the current normalizer/projection
|
||||
// contract. Historic jobs remain available to the legacy replay path,
|
||||
// but a plan created from a historic projection must be previewed
|
||||
// again before it can authorize mutations.
|
||||
if resolved
|
||||
.fingerprint
|
||||
.get("normalizer_version")
|
||||
.and_then(Value::as_str)
|
||||
!= Some(NORMALIZER_VERSION)
|
||||
|| resolved
|
||||
.fingerprint
|
||||
.get("projection_version")
|
||||
.and_then(Value::as_str)
|
||||
!= Some(PROJECTION_VERSION)
|
||||
{
|
||||
return Err(import_plan_repreview_error("importer_version_changed"));
|
||||
}
|
||||
|
||||
// Verify every persisted external snapshot again without making a
|
||||
// network request. The registry repeats source/dependency checks
|
||||
// under its transaction before it mutates operations.
|
||||
self.read_import_job_dependencies(
|
||||
workspace_id,
|
||||
&job.preview_payload,
|
||||
OpenApiUploadLocale::En,
|
||||
)
|
||||
.await
|
||||
.map_err(|_| import_plan_repreview_error("import_dependency_verification_failed"))?;
|
||||
|
||||
let result = self
|
||||
.registry
|
||||
.apply_import_plan(&ApplyImportPlanRequest {
|
||||
workspace_id,
|
||||
plan_id,
|
||||
plan_digest: &payload.plan_digest,
|
||||
idempotency_key: &payload.idempotency_key,
|
||||
verified_fingerprint: &resolved.fingerprint,
|
||||
applied_at: &now,
|
||||
})
|
||||
.await
|
||||
.map_err(map_apply_registry_error)?;
|
||||
Ok(result.report)
|
||||
}
|
||||
}
|
||||
|
||||
fn validate_apply_payload(payload: &OpenApiImportPlanApplyPayload) -> Result<(), ApiError> {
|
||||
let digest_valid = payload.plan_digest.len() == 64
|
||||
&& payload
|
||||
.plan_digest
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte));
|
||||
if !digest_valid {
|
||||
return Err(ApiError::validation_with_context(
|
||||
"plan_digest must be 64 lowercase hexadecimal characters",
|
||||
json!({ "error_code": "import_plan_invalid_input" }),
|
||||
));
|
||||
}
|
||||
if !(1..=MAX_IMPORT_PLAN_IDEMPOTENCY_KEY_BYTES).contains(&payload.idempotency_key.len())
|
||||
|| payload.idempotency_key.trim() != payload.idempotency_key
|
||||
|| payload.idempotency_key.chars().any(char::is_control)
|
||||
{
|
||||
return Err(ApiError::validation_with_context(
|
||||
"idempotency_key must be a non-empty bounded printable value",
|
||||
json!({ "error_code": "import_plan_invalid_input" }),
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn map_apply_registry_error(error: RegistryError) -> ApiError {
|
||||
match error {
|
||||
RegistryError::ImportPlanNotFound { .. } => ApiError::not_found_with_context(
|
||||
"import plan was not found in this workspace",
|
||||
json!({ "error_code": "import_plan_not_found" }),
|
||||
),
|
||||
RegistryError::ImportPlanExpired { .. } => {
|
||||
import_plan_repreview_error("import_plan_expired")
|
||||
}
|
||||
RegistryError::ImportPlanPayloadCorrupt { .. } => {
|
||||
import_plan_repreview_error("import_plan_payload_invalid")
|
||||
}
|
||||
RegistryError::ImportPlanFingerprintStale { .. } => {
|
||||
import_plan_repreview_error("import_plan_fingerprint_stale")
|
||||
}
|
||||
RegistryError::ImportPlanKeyDigestConflict { .. } => key_digest_conflict(),
|
||||
RegistryError::ImportPlanNameConflict { .. } => ApiError::conflict_with_context(
|
||||
"an operation name changed after the plan was created",
|
||||
json!({
|
||||
"error_code": "import_plan_name_conflict",
|
||||
"recovery": "confirm_skip_rename_or_new_version"
|
||||
}),
|
||||
),
|
||||
RegistryError::ImportPlanTargetStale { .. } => {
|
||||
import_plan_repreview_error("import_plan_target_stale")
|
||||
}
|
||||
RegistryError::ImportPlanAuthUnavailable { .. } => {
|
||||
import_plan_repreview_error("import_plan_auth_unavailable")
|
||||
}
|
||||
other => ApiError::from(other),
|
||||
}
|
||||
}
|
||||
|
||||
fn key_digest_conflict() -> ApiError {
|
||||
ApiError::conflict_with_context(
|
||||
"idempotency key was already committed for different plan material",
|
||||
json!({
|
||||
"error_code": "import_plan_key_digest_conflict",
|
||||
"recovery": "repreview_required",
|
||||
"repreview_required": true
|
||||
}),
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,390 @@
|
||||
use super::*;
|
||||
|
||||
/// Revalidates the verified source/dependency snapshots and the persisted
|
||||
/// replay contract of a stored job without mutating the job. Both the
|
||||
/// legacy Apply and the ImportPlan creation derive from this result, so
|
||||
/// the legacy failure-text code travels with the outcome.
|
||||
impl AdminService {
|
||||
pub(super) async fn resolve_verified_openapi_preview(
|
||||
&self,
|
||||
workspace_id: &WorkspaceId,
|
||||
job: &ImportJob,
|
||||
locale: OpenApiUploadLocale,
|
||||
) -> Result<ResolvedOpenApiPreview, ImportPreviewResolution> {
|
||||
let source = match import_job_source(&job.preview_payload, locale) {
|
||||
Ok(source) => source,
|
||||
Err(error) => {
|
||||
return Err(ImportPreviewResolution::Fatal(
|
||||
"import_source_verification_failed",
|
||||
error,
|
||||
));
|
||||
}
|
||||
};
|
||||
let verified = match self
|
||||
.registry
|
||||
.read_artifact_source(
|
||||
std::sync::Arc::clone(&self.artifact_store),
|
||||
workspace_id,
|
||||
&source.source_id,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(verified) => verified,
|
||||
Err(
|
||||
error @ (RegistryError::SourceNotFound { .. } | RegistryError::SourceUnavailable),
|
||||
) => {
|
||||
return Err(ImportPreviewResolution::Fatal(
|
||||
"import_source_verification_failed",
|
||||
openapi_source_error(locale, error),
|
||||
));
|
||||
}
|
||||
Err(error @ RegistryError::SourceIntegrity) => {
|
||||
return Err(ImportPreviewResolution::Fatal(
|
||||
"import_source_verification_failed",
|
||||
openapi_source_error(locale, error),
|
||||
));
|
||||
}
|
||||
Err(error) => {
|
||||
return Err(ImportPreviewResolution::NonFatal(openapi_source_error(
|
||||
locale, error,
|
||||
)));
|
||||
}
|
||||
};
|
||||
if verified.source.blob.artifact_ref != source.digest {
|
||||
return Err(ImportPreviewResolution::Fatal(
|
||||
"import_source_verification_failed",
|
||||
ApiError::openapi_upload(locale, "source_integrity"),
|
||||
));
|
||||
}
|
||||
let replay_contract = match import_replay_contract(&job.preview_payload, locale) {
|
||||
Ok(contract) => contract,
|
||||
Err(error) => {
|
||||
return Err(ImportPreviewResolution::Fatal(
|
||||
"import_replay_verification_failed",
|
||||
error,
|
||||
));
|
||||
}
|
||||
};
|
||||
let (preview, normalizer_version, projection_version, ir_fingerprint) =
|
||||
match replay_contract {
|
||||
ImportReplayContract::PersistedV2(replay) => (
|
||||
replay.preview.preview,
|
||||
replay.normalizer_version,
|
||||
replay.projection_version,
|
||||
replay.preview.ir_fingerprint,
|
||||
),
|
||||
ImportReplayContract::LegacyV1 | ImportReplayContract::Current => {
|
||||
let legacy_v1 = matches!(replay_contract, ImportReplayContract::LegacyV1);
|
||||
let dependency_snapshots = self
|
||||
.read_import_job_dependencies(workspace_id, &job.preview_payload, locale)
|
||||
.await
|
||||
.map_err(|error| {
|
||||
ImportPreviewResolution::Fatal(
|
||||
"import_dependency_verification_failed",
|
||||
error,
|
||||
)
|
||||
})?;
|
||||
let normalization_config = import_job_normalization_config(
|
||||
&job.preview_payload,
|
||||
&self.external_reference_normalization,
|
||||
legacy_v1,
|
||||
locale,
|
||||
)
|
||||
.map_err(|error| {
|
||||
ImportPreviewResolution::Fatal("import_replay_verification_failed", error)
|
||||
})?;
|
||||
let parsed = parse_verified_preview(
|
||||
verified.bytes,
|
||||
source.digest.digest_hex().to_owned(),
|
||||
dependency_snapshots,
|
||||
normalization_config,
|
||||
locale,
|
||||
legacy_v1,
|
||||
)
|
||||
.await
|
||||
.map_err(|error| {
|
||||
ImportPreviewResolution::Fatal("import_replay_verification_failed", error)
|
||||
})?;
|
||||
if let Err(error) =
|
||||
verify_preview_contract(&job.preview_payload, &parsed, locale)
|
||||
{
|
||||
return Err(ImportPreviewResolution::Fatal(
|
||||
"import_replay_verification_failed",
|
||||
error,
|
||||
));
|
||||
}
|
||||
if legacy_v1 {
|
||||
(parsed.preview, String::new(), String::new(), String::new())
|
||||
} else {
|
||||
(
|
||||
parsed.preview,
|
||||
NORMALIZER_VERSION.to_owned(),
|
||||
PROJECTION_VERSION.to_owned(),
|
||||
parsed.ir_fingerprint,
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
Ok(ResolvedOpenApiPreview {
|
||||
source,
|
||||
preview,
|
||||
fingerprint: json!({
|
||||
"normalizer_version": if normalizer_version.is_empty() { Value::Null } else { Value::String(normalizer_version) },
|
||||
"projection_version": if projection_version.is_empty() { Value::Null } else { Value::String(projection_version) },
|
||||
"ir_fingerprint": if ir_fingerprint.is_empty() { Value::Null } else { Value::String(ir_fingerprint) },
|
||||
"preview_digest": job.preview_payload.get("preview_digest").and_then(Value::as_str).map(|digest| Value::String(digest.to_owned())).unwrap_or(Value::Null),
|
||||
}),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) struct ParsedOpenApiPreview {
|
||||
pub(super) preview: crank_import::rest::ImportPreview,
|
||||
pub(super) ir_fingerprint: String,
|
||||
}
|
||||
|
||||
/// Verified job preview material shared by the legacy Apply path and the
|
||||
/// ImportPlan creation: the replay contract has held, no job mutation
|
||||
/// happened.
|
||||
pub(super) struct ResolvedOpenApiPreview {
|
||||
pub(super) source: ImportJobSourceEnvelope,
|
||||
pub(super) preview: crank_import::rest::ImportPreview,
|
||||
pub(super) fingerprint: Value,
|
||||
}
|
||||
|
||||
/// Outcome of a failed preview revalidation. `Fatal` codes are the same
|
||||
/// stable failure texts the legacy path records on a failed job; the plan
|
||||
/// path must surface the same material as a bounded re-preview conflict
|
||||
/// without touching the job, because other stored plans may anchor to it.
|
||||
pub(super) enum ImportPreviewResolution {
|
||||
Fatal(&'static str, ApiError),
|
||||
NonFatal(ApiError),
|
||||
}
|
||||
|
||||
struct PersistedOpenApiReplay {
|
||||
preview: ParsedOpenApiPreview,
|
||||
normalizer_version: String,
|
||||
projection_version: String,
|
||||
}
|
||||
|
||||
enum ImportReplayContract {
|
||||
LegacyV1,
|
||||
PersistedV2(Box<PersistedOpenApiReplay>),
|
||||
Current,
|
||||
}
|
||||
|
||||
fn import_replay_contract(
|
||||
payload: &serde_json::Value,
|
||||
locale: OpenApiUploadLocale,
|
||||
) -> Result<ImportReplayContract, ApiError> {
|
||||
let Some(normalization) = payload.get("normalization") else {
|
||||
return Ok(ImportReplayContract::LegacyV1);
|
||||
};
|
||||
let normalizer = normalization
|
||||
.get("normalizer_version")
|
||||
.and_then(serde_json::Value::as_str)
|
||||
.ok_or_else(|| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
let projection = normalization
|
||||
.get("projection_version")
|
||||
.and_then(serde_json::Value::as_str)
|
||||
.ok_or_else(|| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
let ir_fingerprint = normalization
|
||||
.get("ir_fingerprint")
|
||||
.and_then(serde_json::Value::as_str)
|
||||
.filter(|value| is_lower_sha256(value))
|
||||
.ok_or_else(|| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
let expected_preview_digest = payload
|
||||
.get("preview_digest")
|
||||
.and_then(serde_json::Value::as_str)
|
||||
.filter(|value| is_lower_sha256(value))
|
||||
.ok_or_else(|| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
|
||||
if normalizer == NORMALIZER_VERSION && projection == PROJECTION_VERSION {
|
||||
return Ok(ImportReplayContract::Current);
|
||||
}
|
||||
// Historical preview payloads are replayed as their persisted projection.
|
||||
// They must never be parsed again with the current v4 semantics.
|
||||
if !matches!(
|
||||
(normalizer, projection),
|
||||
("normalized-ir-v2", "preview-v2") | ("normalized-ir-v3", "preview-v3")
|
||||
) {
|
||||
return Err(ApiError::openapi_upload(locale, "source_integrity"));
|
||||
}
|
||||
|
||||
let preview_value = payload
|
||||
.get("preview")
|
||||
.cloned()
|
||||
.ok_or_else(|| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
if preview_digest(&preview_value)? != expected_preview_digest {
|
||||
return Err(ApiError::openapi_upload(locale, "source_integrity"));
|
||||
}
|
||||
let preview = serde_json::from_value(preview_value)
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
Ok(ImportReplayContract::PersistedV2(Box::new(
|
||||
PersistedOpenApiReplay {
|
||||
preview: ParsedOpenApiPreview {
|
||||
preview,
|
||||
ir_fingerprint: ir_fingerprint.to_owned(),
|
||||
},
|
||||
normalizer_version: normalizer.to_owned(),
|
||||
projection_version: projection.to_owned(),
|
||||
},
|
||||
)))
|
||||
}
|
||||
|
||||
fn is_lower_sha256(value: &str) -> bool {
|
||||
value.len() == 64
|
||||
&& value
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
|
||||
}
|
||||
|
||||
pub(super) async fn parse_verified_preview(
|
||||
bytes: Vec<u8>,
|
||||
digest: String,
|
||||
snapshots: Vec<crank_import::rest::ExternalDocumentSnapshot>,
|
||||
normalization_config: crank_import::rest::NormalizationConfig,
|
||||
locale: OpenApiUploadLocale,
|
||||
legacy_v1: bool,
|
||||
) -> Result<ParsedOpenApiPreview, ApiError> {
|
||||
let started = tokio::time::Instant::now();
|
||||
let permit = tokio::time::timeout(OPENAPI_PARSE_DEADLINE, OPENAPI_PARSE_SLOTS.acquire())
|
||||
.await
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "parser_unavailable"))?
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "parser_unavailable"))?;
|
||||
let parsing = tokio::task::spawn_blocking(move || {
|
||||
// Keep the permit inside the blocking task. Timing out the caller
|
||||
// cannot cancel CPU work already running, but abandoned parsers remain
|
||||
// globally bounded and release capacity when they actually finish.
|
||||
let _permit = permit;
|
||||
let document = std::str::from_utf8(&bytes)
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "invalid_utf8"))?;
|
||||
if legacy_v1 {
|
||||
return crank_import::rest::preview_document_legacy_v1(document)
|
||||
.map(|preview| ParsedOpenApiPreview {
|
||||
preview,
|
||||
ir_fingerprint: String::new(),
|
||||
})
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "invalid_document"));
|
||||
}
|
||||
let digest = crank_import::rest::SourceDigest::parse(digest)
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "source_integrity"))?;
|
||||
let ir = crank_import::rest::normalize_verified_bundle(
|
||||
document,
|
||||
digest,
|
||||
&snapshots,
|
||||
&normalization_config,
|
||||
)
|
||||
.map_err(|error| match error {
|
||||
crank_import::rest::ImportParseError::NoMethods => {
|
||||
ApiError::openapi_upload(locale, "no_methods")
|
||||
}
|
||||
_ => ApiError::openapi_upload(locale, "invalid_document"),
|
||||
})?;
|
||||
let ir_fingerprint = preview_digest(
|
||||
&serde_json::to_value(&ir)
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "invalid_document"))?,
|
||||
)?;
|
||||
Ok::<_, ApiError>(ParsedOpenApiPreview {
|
||||
preview: crank_import::rest::preview_from_ir(&ir),
|
||||
ir_fingerprint,
|
||||
})
|
||||
});
|
||||
let remaining = OPENAPI_PARSE_DEADLINE
|
||||
.checked_sub(started.elapsed())
|
||||
.unwrap_or(std::time::Duration::ZERO);
|
||||
tokio::time::timeout(remaining, parsing)
|
||||
.await
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "parser_unavailable"))?
|
||||
.map_err(|_| ApiError::openapi_upload(locale, "parser_unavailable"))?
|
||||
}
|
||||
|
||||
pub(super) 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"),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn openapi_source_error(locale: OpenApiUploadLocale, error: RegistryError) -> ApiError {
|
||||
match error {
|
||||
RegistryError::SourceNotFound { .. } | RegistryError::SourceUnavailable => {
|
||||
ApiError::openapi_upload(locale, "source_unavailable")
|
||||
}
|
||||
RegistryError::SourceIntegrity => ApiError::openapi_upload(locale, "source_integrity"),
|
||||
other => ApiError::from(other),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn preview_digest(preview: &serde_json::Value) -> Result<String, ApiError> {
|
||||
let canonical =
|
||||
serde_json::to_vec(preview).map_err(|error| ApiError::internal(error.to_string()))?;
|
||||
Ok(format!("{:x}", Sha256::digest(canonical)))
|
||||
}
|
||||
|
||||
fn verify_preview_contract(
|
||||
payload: &serde_json::Value,
|
||||
parsed: &ParsedOpenApiPreview,
|
||||
locale: OpenApiUploadLocale,
|
||||
) -> Result<(), ApiError> {
|
||||
// Pre-fingerprint jobs are legacy rolling-upgrade records. They retain the
|
||||
// old reparse behavior; new jobs fail closed if parser output drifts or a
|
||||
// persisted preview has been changed.
|
||||
let expected = payload
|
||||
.get("preview_digest")
|
||||
.and_then(serde_json::Value::as_str);
|
||||
if payload.get("normalization").is_some() && expected.is_none() {
|
||||
return Err(ApiError::openapi_upload(locale, "source_integrity"));
|
||||
}
|
||||
let Some(expected) = expected else {
|
||||
return Ok(());
|
||||
};
|
||||
let actual = preview_digest(
|
||||
&serde_json::to_value(&parsed.preview)
|
||||
.map_err(|error| ApiError::internal(error.to_string()))?,
|
||||
)?;
|
||||
if actual == expected {
|
||||
if let Some(normalization) = payload.get("normalization") {
|
||||
let normalizer = normalization
|
||||
.get("normalizer_version")
|
||||
.and_then(serde_json::Value::as_str);
|
||||
let projection = normalization
|
||||
.get("projection_version")
|
||||
.and_then(serde_json::Value::as_str);
|
||||
let fingerprint = normalization
|
||||
.get("ir_fingerprint")
|
||||
.and_then(serde_json::Value::as_str);
|
||||
if normalizer != Some(NORMALIZER_VERSION)
|
||||
|| projection != Some(PROJECTION_VERSION)
|
||||
|| fingerprint != Some(parsed.ir_fingerprint.as_str())
|
||||
{
|
||||
return Err(ApiError::openapi_upload(locale, "source_integrity"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
} else {
|
||||
Err(ApiError::openapi_upload(locale, "source_integrity"))
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn preview_has_blocker(
|
||||
preview: &crank_import::rest::ImportPreview,
|
||||
selected_operation_keys: &BTreeSet<String>,
|
||||
) -> bool {
|
||||
preview
|
||||
.findings
|
||||
.iter()
|
||||
.any(|finding| finding.severity == ImportFindingSeverity::Error)
|
||||
|| preview
|
||||
.groups
|
||||
.iter()
|
||||
.flat_map(|group| group.operations.iter())
|
||||
.filter(|operation| selected_operation_keys.contains(&operation.key))
|
||||
.flat_map(|operation| operation.findings.iter())
|
||||
.any(|finding| finding.severity == ImportFindingSeverity::Error)
|
||||
}
|
||||
@@ -111,7 +111,7 @@ async fn real_admin_startup_runs_immediate_import_maintenance() {
|
||||
.fetch_one(&pool)
|
||||
.await
|
||||
.unwrap(),
|
||||
Some(13),
|
||||
Some(14),
|
||||
"migration binary must install the current canonical ledger",
|
||||
);
|
||||
sqlx::query(
|
||||
|
||||
@@ -11,6 +11,8 @@ use super::common::{
|
||||
|
||||
mod external_references;
|
||||
mod http_contract;
|
||||
mod import_plan_apply;
|
||||
mod import_plan_create;
|
||||
|
||||
const OPENAPI3: &str = r#"
|
||||
openapi: 3.0.3
|
||||
|
||||
@@ -0,0 +1,664 @@
|
||||
use serde_json::{Value, json};
|
||||
use serial_test::serial;
|
||||
|
||||
use super::super::common::*;
|
||||
|
||||
const OPENAPI_SINGLE: &str = r#"
|
||||
openapi: 3.0.3
|
||||
info: { title: Apply test }
|
||||
servers: [{ url: https://api.example.test }]
|
||||
paths:
|
||||
/alpha:
|
||||
get:
|
||||
operationId: alpha
|
||||
responses: { '200': { description: ok } }
|
||||
"#;
|
||||
|
||||
const OPENAPI_TWO_OPERATIONS: &str = r#"
|
||||
openapi: 3.0.3
|
||||
info: { title: Partial Apply test }
|
||||
servers: [{ url: https://api.example.test }]
|
||||
paths:
|
||||
/alpha:
|
||||
get:
|
||||
operationId: alpha
|
||||
responses: { '200': { description: ok } }
|
||||
/beta:
|
||||
get:
|
||||
operationId: beta
|
||||
responses: { '200': { description: ok } }
|
||||
"#;
|
||||
|
||||
const OPENAPI_WITH_BLOCKER: &str = r#"
|
||||
openapi: 3.0.3
|
||||
info: { title: Blocked full Apply test }
|
||||
servers: [{ url: https://api.example.test }]
|
||||
paths:
|
||||
/actionable:
|
||||
get:
|
||||
operationId: actionable
|
||||
responses: { '200': { description: ok } }
|
||||
/blocked:
|
||||
post:
|
||||
operationId: blocked
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/xml:
|
||||
schema: { type: string }
|
||||
responses: { '200': { description: ok } }
|
||||
"#;
|
||||
|
||||
struct CreatedPlan {
|
||||
reference: String,
|
||||
digest: String,
|
||||
body: Value,
|
||||
}
|
||||
|
||||
async fn create_plan(
|
||||
client: &reqwest::Client,
|
||||
base_url: impl AsRef<str>,
|
||||
document: &str,
|
||||
plan_payload: Value,
|
||||
) -> CreatedPlan {
|
||||
let base_url = base_url.as_ref();
|
||||
let upload = reqwest::multipart::Part::bytes(document.as_bytes().to_vec())
|
||||
.file_name("import.yaml")
|
||||
.mime_str("application/yaml")
|
||||
.unwrap();
|
||||
let preview_response = client
|
||||
.post(format!("{base_url}/imports/openapi/preview"))
|
||||
.multipart(reqwest::multipart::Form::new().part("file", upload))
|
||||
.send()
|
||||
.await
|
||||
.expect("OpenAPI preview request should reach the Admin API");
|
||||
assert_eq!(
|
||||
preview_response.status(),
|
||||
reqwest::StatusCode::OK,
|
||||
"preview failed: {}",
|
||||
preview_response.text().await.unwrap_or_default()
|
||||
);
|
||||
let preview: Value = preview_response.json().await.unwrap();
|
||||
let job_id = preview["job_id"]
|
||||
.as_str()
|
||||
.expect("preview response must include the persisted job ID");
|
||||
|
||||
let plan_response = client
|
||||
.post(format!("{base_url}/imports/openapi/{job_id}/plans"))
|
||||
.json(&plan_payload)
|
||||
.send()
|
||||
.await
|
||||
.expect("ImportPlan request should reach the Admin API");
|
||||
let status = plan_response.status();
|
||||
let body: Value = plan_response.json().await.unwrap_or(Value::Null);
|
||||
assert_eq!(
|
||||
status,
|
||||
reqwest::StatusCode::OK,
|
||||
"plan creation failed: {body}"
|
||||
);
|
||||
let reference = body["plan_reference"]
|
||||
.as_str()
|
||||
.expect("CreatePlan must return its server-issued reference")
|
||||
.to_owned();
|
||||
let digest = body["plan_digest"]
|
||||
.as_str()
|
||||
.expect("CreatePlan must return its server-derived digest")
|
||||
.to_owned();
|
||||
assert!(reference.starts_with("plan_"));
|
||||
assert_eq!(digest.len(), 64);
|
||||
assert!(digest.bytes().all(|byte| byte.is_ascii_hexdigit()));
|
||||
CreatedPlan {
|
||||
reference,
|
||||
digest,
|
||||
body,
|
||||
}
|
||||
}
|
||||
|
||||
async fn apply_plan(
|
||||
client: &reqwest::Client,
|
||||
base_url: impl AsRef<str>,
|
||||
plan: &CreatedPlan,
|
||||
idempotency_key: &str,
|
||||
) -> (reqwest::StatusCode, Value) {
|
||||
let base_url = base_url.as_ref();
|
||||
let response = client
|
||||
.post(format!(
|
||||
"{base_url}/imports/openapi/{}/apply",
|
||||
plan.reference
|
||||
))
|
||||
.json(&json!({
|
||||
"plan_digest": plan.digest,
|
||||
"idempotency_key": idempotency_key
|
||||
}))
|
||||
.send()
|
||||
.await
|
||||
.expect("Apply request should reach the Admin API");
|
||||
let status = response.status();
|
||||
let body = response.json::<Value>().await.unwrap_or(Value::Null);
|
||||
(status, body)
|
||||
}
|
||||
|
||||
async fn operation_list(client: &reqwest::Client, base_url: impl AsRef<str>) -> Value {
|
||||
let base_url = base_url.as_ref();
|
||||
let response = client
|
||||
.get(format!("{base_url}/operations"))
|
||||
.send()
|
||||
.await
|
||||
.expect("operation list request should reach the Admin API");
|
||||
assert_eq!(response.status(), reqwest::StatusCode::OK);
|
||||
response.json().await.unwrap()
|
||||
}
|
||||
|
||||
fn full_plan() -> Value {
|
||||
json!({ "selection_mode": "full", "selected_operation_keys": [] })
|
||||
}
|
||||
|
||||
fn report_has_outcome_status(report: &Value, expected: &str) -> bool {
|
||||
report["outcomes"].as_array().is_some_and(|outcomes| {
|
||||
outcomes
|
||||
.iter()
|
||||
.any(|outcome| outcome["status"] == expected || outcome["outcome"] == expected)
|
||||
})
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn apply_creates_one_draft_from_a_server_created_plan() {
|
||||
let registry = test_registry().await;
|
||||
let base_url = spawn_admin_api(build_test_app(
|
||||
registry,
|
||||
test_storage_root("import_plan_apply_new_draft"),
|
||||
))
|
||||
.await;
|
||||
let client = authorized_client(&base_url).await;
|
||||
let plan = create_plan(&client, &base_url, OPENAPI_SINGLE, full_plan()).await;
|
||||
assert_eq!(plan.body["counts"]["actionable"], 1);
|
||||
|
||||
let (status, report) = apply_plan(&client, &base_url, &plan, "apply-new-draft").await;
|
||||
|
||||
assert_eq!(status, reqwest::StatusCode::OK, "Apply failed: {report}");
|
||||
assert_eq!(report["plan_digest"], plan.digest);
|
||||
assert_eq!(report["outcomes"].as_array().unwrap().len(), 1);
|
||||
assert!(report_has_outcome_status(&report, "created"));
|
||||
assert!(report["outcomes"].to_string().contains("GET /alpha"));
|
||||
let operations = operation_list(&client, &base_url).await;
|
||||
assert_eq!(operations["total"], 1);
|
||||
assert_eq!(operations["items"][0]["status"], "draft");
|
||||
assert_eq!(operations["items"][0]["current_draft_version"], 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn full_apply_with_a_blocked_candidate_is_atomic_and_reports_the_failure() {
|
||||
let registry = test_registry().await;
|
||||
let base_url = spawn_admin_api(build_test_app(
|
||||
registry,
|
||||
test_storage_root("import_plan_apply_full_blocked"),
|
||||
))
|
||||
.await;
|
||||
let client = authorized_client(&base_url).await;
|
||||
let plan = create_plan(&client, &base_url, OPENAPI_WITH_BLOCKER, full_plan()).await;
|
||||
assert_eq!(plan.body["counts"]["blocked"], 1);
|
||||
let before = operation_list(&client, &base_url).await;
|
||||
|
||||
let (status, report) = apply_plan(&client, &base_url, &plan, "apply-full-blocked").await;
|
||||
|
||||
assert_eq!(
|
||||
status,
|
||||
reqwest::StatusCode::CONFLICT,
|
||||
"unexpected report: {report}"
|
||||
);
|
||||
assert_eq!(operation_list(&client, &base_url).await, before);
|
||||
assert!(
|
||||
report["outcomes"].is_array(),
|
||||
"blocked Apply must return outcomes: {report}"
|
||||
);
|
||||
assert!(report_has_outcome_status(&report, "rejected"));
|
||||
assert!(report["outcomes"].to_string().contains("POST /blocked"));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn explicit_partial_plan_applies_only_selected_candidates_and_explains_exclusions() {
|
||||
let registry = test_registry().await;
|
||||
let base_url = spawn_admin_api(build_test_app(
|
||||
registry,
|
||||
test_storage_root("import_plan_apply_partial"),
|
||||
))
|
||||
.await;
|
||||
let client = authorized_client(&base_url).await;
|
||||
let plan = create_plan(
|
||||
&client,
|
||||
&base_url,
|
||||
OPENAPI_TWO_OPERATIONS,
|
||||
json!({
|
||||
"selection_mode": "partial",
|
||||
"selected_operation_keys": ["GET /alpha"]
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(plan.body["counts"]["selected"], 1);
|
||||
assert_eq!(plan.body["counts"]["excluded"], 1);
|
||||
|
||||
let (status, report) = apply_plan(&client, &base_url, &plan, "apply-partial").await;
|
||||
|
||||
assert_eq!(status, reqwest::StatusCode::OK, "Apply failed: {report}");
|
||||
assert!(report["outcomes"].is_array());
|
||||
assert!(report_has_outcome_status(&report, "created"));
|
||||
let report_text = report.to_string();
|
||||
assert!(report_text.contains("GET /alpha"));
|
||||
assert!(report_text.contains("GET /beta"));
|
||||
assert!(report_text.contains("excluded"));
|
||||
let operations = operation_list(&client, &base_url).await;
|
||||
assert_eq!(operations["total"], 1);
|
||||
assert_eq!(operations["items"][0]["name"], "alpha");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn same_key_and_digest_replay_report_without_extra_draft_and_changed_digest_conflicts() {
|
||||
let registry = test_registry().await;
|
||||
let base_url = spawn_admin_api(build_test_app(
|
||||
registry,
|
||||
test_storage_root("import_plan_apply_idempotency"),
|
||||
))
|
||||
.await;
|
||||
let client = authorized_client(&base_url).await;
|
||||
let plan = create_plan(&client, &base_url, OPENAPI_SINGLE, full_plan()).await;
|
||||
let (first_status, first_report) =
|
||||
apply_plan(&client, &base_url, &plan, "stable-apply-key").await;
|
||||
assert_eq!(
|
||||
first_status,
|
||||
reqwest::StatusCode::OK,
|
||||
"Apply failed: {first_report}"
|
||||
);
|
||||
let operations_after_first = operation_list(&client, &base_url).await;
|
||||
|
||||
let (replay_status, replay_report) =
|
||||
apply_plan(&client, &base_url, &plan, "stable-apply-key").await;
|
||||
assert_eq!(replay_status, reqwest::StatusCode::OK);
|
||||
assert_eq!(replay_report, first_report);
|
||||
assert_eq!(
|
||||
operation_list(&client, &base_url).await,
|
||||
operations_after_first
|
||||
);
|
||||
|
||||
let changed = CreatedPlan {
|
||||
reference: plan.reference.clone(),
|
||||
digest: "0".repeat(64),
|
||||
body: plan.body.clone(),
|
||||
};
|
||||
let (changed_status, _) = apply_plan(&client, &base_url, &changed, "stable-apply-key").await;
|
||||
assert_eq!(changed_status, reqwest::StatusCode::CONFLICT);
|
||||
assert_eq!(
|
||||
operation_list(&client, &base_url).await,
|
||||
operations_after_first
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn concurrent_same_key_apply_converges_on_one_persisted_report() {
|
||||
let registry = test_registry().await;
|
||||
let base_url = spawn_admin_api(build_test_app(
|
||||
registry,
|
||||
test_storage_root("import_plan_apply_concurrent_replay"),
|
||||
))
|
||||
.await;
|
||||
let client = authorized_client(&base_url).await;
|
||||
let plan = create_plan(&client, &base_url, OPENAPI_SINGLE, full_plan()).await;
|
||||
|
||||
let (left, right) = tokio::join!(
|
||||
apply_plan(&client, &base_url, &plan, "concurrent-apply-key"),
|
||||
apply_plan(&client, &base_url, &plan, "concurrent-apply-key"),
|
||||
);
|
||||
|
||||
assert_eq!(left.0, reqwest::StatusCode::OK, "left: {}", left.1);
|
||||
assert_eq!(right.0, reqwest::StatusCode::OK, "right: {}", right.1);
|
||||
assert_eq!(left.1, right.1);
|
||||
assert_eq!(operation_list(&client, &base_url).await["total"], 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn apply_rejects_client_candidate_fields_and_malformed_digest() {
|
||||
let registry = test_registry().await;
|
||||
let base_url = spawn_admin_api(build_test_app(
|
||||
registry,
|
||||
test_storage_root("import_plan_apply_input_validation"),
|
||||
))
|
||||
.await;
|
||||
let client = authorized_client(&base_url).await;
|
||||
let plan = create_plan(&client, &base_url, OPENAPI_SINGLE, full_plan()).await;
|
||||
let url = format!("{base_url}/imports/openapi/{}/apply", plan.reference);
|
||||
|
||||
let extra_fields = client
|
||||
.post(&url)
|
||||
.json(&json!({
|
||||
"plan_digest": plan.digest,
|
||||
"idempotency_key": "validation-key",
|
||||
"operations": [{ "operation_id": "attacker-chosen" }]
|
||||
}))
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
extra_fields.status(),
|
||||
reqwest::StatusCode::UNPROCESSABLE_ENTITY
|
||||
);
|
||||
|
||||
let malformed_digest = client
|
||||
.post(url)
|
||||
.json(&json!({
|
||||
"plan_digest": "not-a-digest",
|
||||
"idempotency_key": "validation-key"
|
||||
}))
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(malformed_digest.status(), reqwest::StatusCode::BAD_REQUEST);
|
||||
assert_eq!(operation_list(&client, &base_url).await["total"], 0);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn exact_skip_and_rename_decisions_affect_only_the_confirmed_operations() {
|
||||
let registry = test_registry().await;
|
||||
let base_url = spawn_admin_api(build_test_app(
|
||||
registry,
|
||||
test_storage_root("import_plan_apply_skip_rename"),
|
||||
))
|
||||
.await;
|
||||
let client = authorized_client(&base_url).await;
|
||||
|
||||
let initial = create_plan(&client, &base_url, OPENAPI_SINGLE, full_plan()).await;
|
||||
let (initial_status, initial_report) =
|
||||
apply_plan(&client, &base_url, &initial, "skip-rename-seed").await;
|
||||
assert_eq!(initial_status, reqwest::StatusCode::OK, "{initial_report}");
|
||||
let before_skip = operation_list(&client, &base_url).await;
|
||||
let operation_id = before_skip["items"][0]["id"]
|
||||
.as_str()
|
||||
.expect("operation list includes the workspace operation ID");
|
||||
|
||||
let skip = create_plan(
|
||||
&client,
|
||||
&base_url,
|
||||
OPENAPI_SINGLE,
|
||||
json!({
|
||||
"selection_mode": "full",
|
||||
"selected_operation_keys": [],
|
||||
"decisions": [{
|
||||
"operation_key": "GET /alpha",
|
||||
"action": "skip",
|
||||
"target_operation_id": operation_id
|
||||
}]
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
let (skip_status, skip_report) =
|
||||
apply_plan(&client, &base_url, &skip, "skip-exact-target").await;
|
||||
assert_eq!(skip_status, reqwest::StatusCode::OK, "{skip_report}");
|
||||
assert!(report_has_outcome_status(&skip_report, "skipped"));
|
||||
assert_eq!(skip_report["outcomes"][0]["operation_id"], operation_id);
|
||||
assert_eq!(operation_list(&client, &base_url).await, before_skip);
|
||||
|
||||
let rename = create_plan(
|
||||
&client,
|
||||
&base_url,
|
||||
OPENAPI_SINGLE,
|
||||
json!({
|
||||
"selection_mode": "full",
|
||||
"selected_operation_keys": [],
|
||||
"decisions": [{
|
||||
"operation_key": "GET /alpha",
|
||||
"action": "rename",
|
||||
"confirmed_name": "alpha_imported"
|
||||
}]
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
let (rename_status, rename_report) =
|
||||
apply_plan(&client, &base_url, &rename, "rename-confirmed-name").await;
|
||||
assert_eq!(rename_status, reqwest::StatusCode::OK, "{rename_report}");
|
||||
assert!(report_has_outcome_status(&rename_report, "renamed"));
|
||||
let after_rename = operation_list(&client, &base_url).await;
|
||||
assert_eq!(after_rename["total"], 2);
|
||||
assert!(
|
||||
after_rename["items"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.any(|item| { item["name"] == "alpha_imported" && item["status"] == "draft" })
|
||||
);
|
||||
assert!(
|
||||
after_rename["items"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.any(|item| { item["id"] == operation_id && item["name"] == "alpha" })
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn new_version_preserves_published_version_and_prior_version() {
|
||||
let registry = test_registry().await;
|
||||
let base_url = spawn_admin_api(build_test_app(
|
||||
registry,
|
||||
test_storage_root("import_plan_apply_new_version_published"),
|
||||
))
|
||||
.await;
|
||||
let client = authorized_client(&base_url).await;
|
||||
let seed = create_plan(&client, &base_url, OPENAPI_SINGLE, full_plan()).await;
|
||||
let (seed_status, seed_report) =
|
||||
apply_plan(&client, &base_url, &seed, "new-version-seed").await;
|
||||
assert_eq!(seed_status, reqwest::StatusCode::OK, "{seed_report}");
|
||||
let seeded = operation_list(&client, &base_url).await;
|
||||
let operation_id = seeded["items"][0]["id"].as_str().unwrap().to_owned();
|
||||
|
||||
let publish = client
|
||||
.post(format!("{base_url}/operations/{operation_id}/publish"))
|
||||
.header(
|
||||
reqwest::header::IF_MATCH,
|
||||
operation_etag(&client, &base_url, &operation_id).await,
|
||||
)
|
||||
.json(&json!({ "version": 1 }))
|
||||
.send()
|
||||
.await
|
||||
.expect("publish request should reach the Admin API");
|
||||
assert_eq!(publish.status(), reqwest::StatusCode::OK);
|
||||
let published: Value = publish.json().await.unwrap();
|
||||
assert_eq!(published["published_version"], 1);
|
||||
let prior_version_before: Value = client
|
||||
.get(format!("{base_url}/operations/{operation_id}/versions/1"))
|
||||
.send()
|
||||
.await
|
||||
.unwrap()
|
||||
.json()
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let plan = create_plan(
|
||||
&client,
|
||||
&base_url,
|
||||
OPENAPI_SINGLE,
|
||||
json!({
|
||||
"selection_mode": "full",
|
||||
"selected_operation_keys": [],
|
||||
"decisions": [{
|
||||
"operation_key": "GET /alpha",
|
||||
"action": "new_version",
|
||||
"target_operation_id": operation_id
|
||||
}]
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
let (status, report) = apply_plan(&client, &base_url, &plan, "new-version-exact-target").await;
|
||||
assert_eq!(status, reqwest::StatusCode::OK, "{report}");
|
||||
assert!(report_has_outcome_status(&report, "versioned"));
|
||||
assert_eq!(report["outcomes"][0]["operation_id"], operation_id);
|
||||
assert_eq!(report["outcomes"][0]["version"], 2);
|
||||
|
||||
let after = operation_list(&client, &base_url).await;
|
||||
assert_eq!(after["total"], 1);
|
||||
assert_eq!(after["items"][0]["id"], operation_id);
|
||||
assert_eq!(after["items"][0]["latest_published_version"], 1);
|
||||
assert_eq!(after["items"][0]["current_draft_version"], 2);
|
||||
let published_again: Value = client
|
||||
.get(format!("{base_url}/operations/{operation_id}/versions/1"))
|
||||
.send()
|
||||
.await
|
||||
.unwrap()
|
||||
.json()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(published_again, prior_version_before);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn disabled_auth_secret_rejects_apply_without_leaking_credentials() {
|
||||
let registry = test_registry().await;
|
||||
let base_url = spawn_admin_api(build_test_app(
|
||||
registry.clone(),
|
||||
test_storage_root("import_plan_apply_revoked_auth"),
|
||||
))
|
||||
.await;
|
||||
let client = authorized_client(&base_url).await;
|
||||
let secret_canary = "import-plan-auth-canary-must-not-leak";
|
||||
let secret_response = client
|
||||
.post(format!("{base_url}/secrets"))
|
||||
.json(&json!({
|
||||
"name": "import-plan-auth-token",
|
||||
"kind": "token",
|
||||
"value": { "token": secret_canary }
|
||||
}))
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(secret_response.status(), reqwest::StatusCode::OK);
|
||||
let secret: Value = secret_response.json().await.unwrap();
|
||||
let secret_id = secret["id"].as_str().unwrap();
|
||||
let profile_response = client
|
||||
.post(format!("{base_url}/auth-profiles"))
|
||||
.json(&json!({
|
||||
"name": "import-plan-auth-profile",
|
||||
"kind": "api_key_header",
|
||||
"config": {
|
||||
"api_key_header": {
|
||||
"header_name": "X-Api-Key",
|
||||
"secret_id": secret_id
|
||||
}
|
||||
}
|
||||
}))
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(profile_response.status(), reqwest::StatusCode::OK);
|
||||
let profile: Value = profile_response.json().await.unwrap();
|
||||
let auth_profile_id = profile["id"].as_str().unwrap();
|
||||
|
||||
let redacted_plan = create_plan(
|
||||
&client,
|
||||
&base_url,
|
||||
OPENAPI_TWO_OPERATIONS,
|
||||
json!({
|
||||
"selection_mode": "partial",
|
||||
"selected_operation_keys": ["GET /beta"],
|
||||
"decisions": [{
|
||||
"operation_key": "GET /beta",
|
||||
"action": "create",
|
||||
"auth_profile_id": auth_profile_id
|
||||
}]
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
let (redacted_status, redacted_report) =
|
||||
apply_plan(&client, &base_url, &redacted_plan, "redacted-auth-report").await;
|
||||
assert_eq!(
|
||||
redacted_status,
|
||||
reqwest::StatusCode::OK,
|
||||
"{redacted_report}"
|
||||
);
|
||||
assert!(redacted_report["source_digest"].is_string());
|
||||
assert!(!redacted_report.to_string().contains(secret_canary));
|
||||
assert!(!redacted_report.to_string().contains("ciphertext"));
|
||||
|
||||
let plan = create_plan(
|
||||
&client,
|
||||
&base_url,
|
||||
OPENAPI_SINGLE,
|
||||
json!({
|
||||
"selection_mode": "full",
|
||||
"selected_operation_keys": [],
|
||||
"decisions": [{
|
||||
"operation_key": "GET /alpha",
|
||||
"action": "create",
|
||||
"auth_profile_id": auth_profile_id
|
||||
}]
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
|
||||
// A profile can remain active while its credential mapping changes.
|
||||
// The confirmed plan must not silently adopt the new configuration.
|
||||
sqlx::query(
|
||||
"update auth_profiles
|
||||
set config_json = jsonb_set(config_json, '{api_key_header,header_name}', '\"X-Changed-Key\"'),
|
||||
updated_at = now()
|
||||
where workspace_id = $1 and id = $2",
|
||||
)
|
||||
.bind("ws_default")
|
||||
.bind(auth_profile_id)
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
let (drift_status, drift_error) =
|
||||
apply_plan(&client, &base_url, &plan, "changed-auth-config-apply").await;
|
||||
assert_eq!(drift_status, reqwest::StatusCode::CONFLICT, "{drift_error}");
|
||||
assert_eq!(
|
||||
drift_error["error"]["context"]["error_code"],
|
||||
"import_plan_auth_unavailable"
|
||||
);
|
||||
assert_eq!(operation_list(&client, &base_url).await["total"], 1);
|
||||
|
||||
let plan = create_plan(
|
||||
&client,
|
||||
&base_url,
|
||||
OPENAPI_SINGLE,
|
||||
json!({
|
||||
"selection_mode": "full",
|
||||
"selected_operation_keys": [],
|
||||
"decisions": [{
|
||||
"operation_key": "GET /alpha",
|
||||
"action": "create",
|
||||
"auth_profile_id": auth_profile_id
|
||||
}]
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
|
||||
// There is no profile revoke endpoint; disabling its backing credential
|
||||
// models revocation between confirmation and apply.
|
||||
sqlx::query(
|
||||
"update secrets set status = 'disabled', updated_at = now() where workspace_id = $1 and id = $2",
|
||||
)
|
||||
.bind("ws_default")
|
||||
.bind(secret_id)
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let (status, error) = apply_plan(&client, &base_url, &plan, "revoked-auth-apply").await;
|
||||
assert_eq!(status, reqwest::StatusCode::CONFLICT, "{error}");
|
||||
assert_eq!(
|
||||
error["error"]["context"]["error_code"],
|
||||
"import_plan_auth_unavailable"
|
||||
);
|
||||
let response_text = error.to_string();
|
||||
assert!(!response_text.contains(secret_canary));
|
||||
assert!(!response_text.contains("ciphertext"));
|
||||
let after = operation_list(&client, &base_url).await;
|
||||
assert_eq!(after["total"], 1);
|
||||
assert_eq!(after["items"][0]["name"], "beta");
|
||||
}
|
||||
@@ -0,0 +1,952 @@
|
||||
use super::*;
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn full_plan_is_server_authored_with_bounded_confirmation_and_no_mutation() {
|
||||
let registry = test_registry().await;
|
||||
let service = test_service(
|
||||
registry.clone(),
|
||||
test_storage_root("openapi_import_plan_full"),
|
||||
test_auth_settings(),
|
||||
test_secret_crypto(),
|
||||
);
|
||||
let workspace_id = WorkspaceId::new("ws_default");
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let job = registry
|
||||
.get_import_job(&workspace_id, &job_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
|
||||
let plan = service
|
||||
.create_openapi_import_plan(&workspace_id, &job_id, plan_payload("full", vec![], vec![]))
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert!(plan.plan_reference.starts_with("plan_"));
|
||||
assert!(
|
||||
plan.plan_digest.len() == 64
|
||||
&& plan
|
||||
.plan_digest
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_hexdigit())
|
||||
);
|
||||
assert_eq!(plan.selection_mode, "full");
|
||||
assert_eq!(plan.counts.selected, 1);
|
||||
assert_eq!(plan.counts.excluded, 0);
|
||||
assert_eq!(plan.counts.actionable, 1);
|
||||
assert_eq!(plan.counts.blocked, 0);
|
||||
let candidate = &plan.candidates[0];
|
||||
assert_eq!(candidate.key, "GET /v2/latest");
|
||||
assert_eq!(candidate.name, "latest_rates");
|
||||
assert_eq!(candidate.state, "actionable");
|
||||
assert_eq!(candidate.action.as_deref(), Some("create"));
|
||||
assert_eq!(candidate.reason, None);
|
||||
|
||||
let expires_at = OffsetDateTime::parse(
|
||||
&plan.expires_at,
|
||||
&time::format_description::well_known::Rfc3339,
|
||||
)
|
||||
.unwrap();
|
||||
assert!(expires_at > OffsetDateTime::now_utc());
|
||||
assert!(expires_at <= job.expires_at);
|
||||
|
||||
let stored = registry
|
||||
.get_import_plan(&workspace_id, &plan.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.expect("the created plan must be readable in its workspace");
|
||||
assert_eq!(stored.digest, plan.plan_digest);
|
||||
assert_eq!(stored.expires_at, expires_at);
|
||||
assert_eq!(
|
||||
stored.payload["selection"]["selected"],
|
||||
json!(["GET /v2/latest"])
|
||||
);
|
||||
assert_eq!(stored.payload["selection"]["excluded"], json!([]));
|
||||
assert_eq!(stored.payload["counts"]["actionable"], json!(1));
|
||||
let candidate = &stored.payload["candidates"][0];
|
||||
assert_eq!(candidate["decision"]["action"], "create");
|
||||
assert!(
|
||||
candidate["operation"]["id"]
|
||||
.as_str()
|
||||
.unwrap()
|
||||
.starts_with("op_")
|
||||
);
|
||||
assert_eq!(candidate["operation"]["status"], "draft");
|
||||
assert_eq!(
|
||||
stored.payload["source"]["digest"],
|
||||
job.preview_payload["source"]["digest"]
|
||||
);
|
||||
assert!(stored.payload["fingerprint"]["ir_fingerprint"].is_string());
|
||||
// Planning is non-mutating: no operation exists and the job stays pending.
|
||||
assert!(
|
||||
service
|
||||
.list_operations(&workspace_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.is_empty()
|
||||
);
|
||||
let job = registry
|
||||
.get_import_job(&workspace_id, &job_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(job.status, ImportJobStatus::Pending);
|
||||
assert_eq!(job.error_text, None);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn partial_plan_counts_selection_and_rejects_invalid_request_material() {
|
||||
let registry = test_registry().await;
|
||||
let service = test_service(
|
||||
registry.clone(),
|
||||
test_storage_root("openapi_import_plan_partial"),
|
||||
test_auth_settings(),
|
||||
test_secret_crypto(),
|
||||
);
|
||||
let workspace_id = WorkspaceId::new("ws_default");
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_TWO_OPS))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let keys = preview_operation_keys(&preview);
|
||||
assert_eq!(keys.len(), 2);
|
||||
let (first, second) = (keys[0].clone(), keys[1].clone());
|
||||
|
||||
let plan = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload("partial", vec![first.clone()], vec![]),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(plan.counts.selected, 1);
|
||||
assert_eq!(plan.counts.excluded, 1);
|
||||
assert_eq!(plan.counts.actionable, 1);
|
||||
assert_eq!(plan.counts.blocked, 0);
|
||||
let excluded = plan
|
||||
.candidates
|
||||
.iter()
|
||||
.find(|candidate| candidate.key == second)
|
||||
.expect("the excluded candidate is listed for confirmation");
|
||||
assert_eq!(excluded.state, "excluded");
|
||||
assert_eq!(excluded.reason.as_deref(), Some("not_selected"));
|
||||
|
||||
let stored = registry
|
||||
.get_import_plan(&workspace_id, &plan.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let expected_all = json!([first, second]);
|
||||
assert_eq!(stored.payload["selection"]["all"], expected_all);
|
||||
// `excluded` candidates never receive a decision, target or draft material.
|
||||
let listed = stored.payload["candidates"].as_array().unwrap();
|
||||
assert_eq!(listed.len(), 1);
|
||||
assert_eq!(listed[0]["key"], first);
|
||||
assert!(listed[0].get("target").is_none());
|
||||
|
||||
let cases: Vec<(OpenApiImportPlanCreatePayload, &'static str)> = vec![
|
||||
(
|
||||
plan_payload("full", vec![first.clone()], vec![]),
|
||||
"import_plan_selection_mismatch",
|
||||
),
|
||||
(
|
||||
plan_payload("partial", vec!["GET /unknown".to_owned()], vec![]),
|
||||
"import_plan_unknown_operation_key",
|
||||
),
|
||||
(
|
||||
plan_payload("partial", vec![], vec![]),
|
||||
"import_plan_invalid_input",
|
||||
),
|
||||
(
|
||||
plan_payload("partial", vec![first.clone(), first.clone()], vec![]),
|
||||
"import_plan_invalid_input",
|
||||
),
|
||||
(
|
||||
plan_payload("bogus", vec![first.clone()], vec![]),
|
||||
"import_plan_invalid_input",
|
||||
),
|
||||
(
|
||||
plan_payload(
|
||||
"partial",
|
||||
vec![first.clone()],
|
||||
vec![decision("GET /other", "create", None, None, None)],
|
||||
),
|
||||
"import_plan_decision_unselected",
|
||||
),
|
||||
(
|
||||
plan_payload(
|
||||
"partial",
|
||||
vec![first.clone(), second.clone()],
|
||||
vec![
|
||||
decision(&first, "create", None, None, None),
|
||||
decision(&first, "skip", Some("op_other"), None, None),
|
||||
],
|
||||
),
|
||||
"import_plan_invalid_input",
|
||||
),
|
||||
(
|
||||
plan_payload(
|
||||
"partial",
|
||||
vec![first.clone()],
|
||||
vec![decision(&first, "skip", None, None, None)],
|
||||
),
|
||||
"import_plan_invalid_input",
|
||||
),
|
||||
(
|
||||
plan_payload(
|
||||
"partial",
|
||||
vec![first.clone()],
|
||||
vec![decision(
|
||||
&first,
|
||||
"skip",
|
||||
Some("op_other"),
|
||||
Some("other_name"),
|
||||
None,
|
||||
)],
|
||||
),
|
||||
"import_plan_invalid_input",
|
||||
),
|
||||
(
|
||||
plan_payload(
|
||||
"partial",
|
||||
vec![first.clone(), second.clone()],
|
||||
vec![decision(
|
||||
&first,
|
||||
"skip",
|
||||
Some("op_other"),
|
||||
None,
|
||||
Some("auth_profile_any"),
|
||||
)],
|
||||
),
|
||||
"import_plan_invalid_input",
|
||||
),
|
||||
(
|
||||
plan_payload(
|
||||
"partial",
|
||||
vec![first.clone(), second.clone()],
|
||||
vec![
|
||||
decision(&first, "create", None, Some("renamed"), None),
|
||||
decision(&second, "rename", Some("op_other"), None, None),
|
||||
],
|
||||
),
|
||||
"import_plan_invalid_input",
|
||||
),
|
||||
(
|
||||
plan_payload(
|
||||
"partial",
|
||||
vec![first.clone()],
|
||||
vec![decision(&first, "rename", None, None, None)],
|
||||
),
|
||||
"import_plan_invalid_input",
|
||||
),
|
||||
(
|
||||
plan_payload(
|
||||
"partial",
|
||||
vec![first.clone()],
|
||||
vec![decision(&first, "new_version", None, None, None)],
|
||||
),
|
||||
"import_plan_invalid_input",
|
||||
),
|
||||
];
|
||||
for (payload, expected_code) in cases {
|
||||
let error = service
|
||||
.create_openapi_import_plan(&workspace_id, &job_id, payload)
|
||||
.await
|
||||
.expect_err("invalid plan material must be rejected");
|
||||
assert_error_code(&error, expected_code);
|
||||
assert_http_status(error, axum::http::StatusCode::BAD_REQUEST);
|
||||
}
|
||||
// The successful plan above still exists untouched.
|
||||
let readable = registry
|
||||
.get_import_plan(&workspace_id, &plan.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(readable.is_some());
|
||||
assert!(
|
||||
service
|
||||
.list_operations(&workspace_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.is_empty()
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn client_supplied_candidate_material_has_no_authority() {
|
||||
let registry = test_registry().await;
|
||||
let service = test_service(
|
||||
registry.clone(),
|
||||
test_storage_root("openapi_import_plan_client_authority"),
|
||||
test_auth_settings(),
|
||||
test_secret_crypto(),
|
||||
);
|
||||
let workspace_id = WorkspaceId::new("ws_default");
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
|
||||
// Client-supplied digests, payloads or candidate arrays are not part of
|
||||
// the request contract and must not influence the server-authored plan.
|
||||
let request = json!({
|
||||
"selection_mode": "full",
|
||||
"selected_operation_keys": [],
|
||||
"plan_digest": format!("sha256:{}", "ab".repeat(32)),
|
||||
"plan_payload": {
|
||||
"schema_version": "import-plan-client-v999",
|
||||
"candidates": [{ "key": "GET /forged", "name": "forged" }],
|
||||
},
|
||||
"candidates": [{ "key": "GET /forged" }],
|
||||
});
|
||||
assert!(
|
||||
serde_json::from_value::<OpenApiImportPlanCreatePayload>(request).is_err(),
|
||||
"client-supplied candidate material must be rejected at the request boundary"
|
||||
);
|
||||
let payload: OpenApiImportPlanCreatePayload = serde_json::from_value(json!({
|
||||
"selection_mode": "full",
|
||||
"selected_operation_keys": []
|
||||
}))
|
||||
.unwrap();
|
||||
let plan = service
|
||||
.create_openapi_import_plan(&workspace_id, &job_id, payload)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let stored = registry
|
||||
.get_import_plan(&workspace_id, &plan.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let material = stored.payload.to_string();
|
||||
assert!(!material.contains("import-plan-client-v999"));
|
||||
assert!(!material.contains("GET /forged"));
|
||||
assert!(!material.contains("abababab"));
|
||||
assert_eq!(
|
||||
stored.payload["selection"]["all"],
|
||||
json!(["GET /v2/latest"])
|
||||
);
|
||||
assert_eq!(stored.payload["schema_version"], "import-plan-v1");
|
||||
assert!(stored.digest.len() == 64 && stored.digest.bytes().all(|b| b.is_ascii_hexdigit()));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn plan_creation_is_workspace_scoped() {
|
||||
let registry = test_registry().await;
|
||||
let service = test_service(
|
||||
registry.clone(),
|
||||
test_storage_root("openapi_import_plan_scope"),
|
||||
test_auth_settings(),
|
||||
test_secret_crypto(),
|
||||
);
|
||||
let primary = WorkspaceId::new("ws_default");
|
||||
let secondary = WorkspaceId::new("ws_plan_scope_secondary");
|
||||
let created_at = OffsetDateTime::now_utc();
|
||||
registry
|
||||
.create_workspace(CreateWorkspaceRequest {
|
||||
workspace: &Workspace {
|
||||
id: secondary.clone(),
|
||||
slug: "ws-plan-scope-secondary".to_owned(),
|
||||
display_name: "Plan scope secondary".to_owned(),
|
||||
status: WorkspaceStatus::Active,
|
||||
settings: json!({}),
|
||||
created_at,
|
||||
updated_at: created_at,
|
||||
},
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let preview = service
|
||||
.preview_openapi_import(&primary, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let plan = service
|
||||
.create_openapi_import_plan(&primary, &job_id, plan_payload("full", vec![], vec![]))
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let cross_scope_error = service
|
||||
.create_openapi_import_plan(&secondary, &job_id, plan_payload("full", vec![], vec![]))
|
||||
.await
|
||||
.expect_err("a foreign job must be invisible, not planned");
|
||||
assert_http_status(cross_scope_error, axum::http::StatusCode::NOT_FOUND);
|
||||
let stored = registry
|
||||
.get_import_plan(&secondary, &plan.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(stored.is_none(), "a foreign plan id must be invisible");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn exact_skip_rename_and_new_version_decisions_are_saved_verbatim() {
|
||||
let registry = test_registry().await;
|
||||
let upstream_base_url = spawn_upstream_server().await;
|
||||
let service = test_service(
|
||||
registry.clone(),
|
||||
test_storage_root("openapi_import_plan_decisions"),
|
||||
test_auth_settings(),
|
||||
test_secret_crypto(),
|
||||
);
|
||||
let workspace_id = WorkspaceId::new("ws_default");
|
||||
|
||||
// A conflicting existing operation so `create` is no longer safe by default.
|
||||
let existing = service
|
||||
.create_operation(
|
||||
&workspace_id,
|
||||
test_operation_payload(&upstream_base_url, "latest_rates"),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let operation_id = existing.operation_id;
|
||||
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let plan = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload(
|
||||
"full",
|
||||
vec![],
|
||||
vec![decision(
|
||||
"GET /v2/latest",
|
||||
"skip",
|
||||
Some(operation_id.as_str()),
|
||||
None,
|
||||
None,
|
||||
)],
|
||||
),
|
||||
)
|
||||
.await
|
||||
.expect("skip must target the exact existing operation");
|
||||
let stored = registry
|
||||
.get_import_plan(&workspace_id, &plan.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let candidate = &stored.payload["candidates"][0];
|
||||
assert_eq!(plan.counts.actionable, 1);
|
||||
assert_eq!(candidate["decision"]["action"], "skip");
|
||||
assert_eq!(candidate["target"]["operation_id"], json!(operation_id));
|
||||
assert_eq!(
|
||||
candidate["target"]["expected_state"],
|
||||
json!({
|
||||
"status": "draft",
|
||||
"current_draft_version": 1,
|
||||
"latest_published_version": null
|
||||
})
|
||||
);
|
||||
assert!(
|
||||
candidate.get("operation").is_none(),
|
||||
"skip must not create draft material"
|
||||
);
|
||||
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let renamed = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload(
|
||||
"full",
|
||||
vec![],
|
||||
vec![decision(
|
||||
"GET /v2/latest",
|
||||
"rename",
|
||||
None,
|
||||
Some("latest_rates_confirmed"),
|
||||
None,
|
||||
)],
|
||||
),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let stored = registry
|
||||
.get_import_plan(&workspace_id, &renamed.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
stored.payload["candidates"][0]["decision"]["confirmed_name"],
|
||||
"latest_rates_confirmed"
|
||||
);
|
||||
assert_eq!(
|
||||
stored.payload["candidates"][0]["operation"]["name"],
|
||||
"latest_rates_confirmed"
|
||||
);
|
||||
assert!(
|
||||
stored.payload["candidates"][0]["operation"]["id"]
|
||||
.as_str()
|
||||
.unwrap()
|
||||
.starts_with("op_")
|
||||
);
|
||||
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let versioned = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload(
|
||||
"full",
|
||||
vec![],
|
||||
vec![decision(
|
||||
"GET /v2/latest",
|
||||
"new_version",
|
||||
Some(operation_id.as_str()),
|
||||
None,
|
||||
None,
|
||||
)],
|
||||
),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let stored = registry
|
||||
.get_import_plan(&workspace_id, &versioned.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let candidate = &stored.payload["candidates"][0];
|
||||
assert_eq!(
|
||||
candidate["operation"]["id"], operation_id,
|
||||
"new_version snapshot must bind the exact target operation"
|
||||
);
|
||||
assert_eq!(candidate["operation"]["version"], 2);
|
||||
assert_eq!(
|
||||
candidate["target"]["expected_state"],
|
||||
json!({
|
||||
"status": "draft",
|
||||
"current_draft_version": 1,
|
||||
"latest_published_version": null
|
||||
})
|
||||
);
|
||||
|
||||
// Planning never mutates: only the original Draft Version exists.
|
||||
let operations = service.list_operations(&workspace_id).await.unwrap();
|
||||
assert_eq!(operations.len(), 1);
|
||||
assert_eq!(operations[0].name, "latest_rates");
|
||||
assert_eq!(operations[0].current_draft_version, 1);
|
||||
|
||||
// A mismatched target is rejected with the stable target code.
|
||||
let other = service
|
||||
.create_operation(
|
||||
&workspace_id,
|
||||
test_operation_payload(&upstream_base_url, "other_operation"),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
for mismatched in [
|
||||
vec![decision(
|
||||
"GET /v2/latest",
|
||||
"skip",
|
||||
Some(other.operation_id.as_str()),
|
||||
None,
|
||||
None,
|
||||
)],
|
||||
vec![decision(
|
||||
"GET /v2/latest",
|
||||
"new_version",
|
||||
Some(other.operation_id.as_str()),
|
||||
None,
|
||||
None,
|
||||
)],
|
||||
] {
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let error = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload("full", vec![], mismatched),
|
||||
)
|
||||
.await
|
||||
.expect_err("a mismatched target must be rejected");
|
||||
assert_error_code(&error, "import_plan_target_invalid");
|
||||
assert_http_status(error, axum::http::StatusCode::BAD_REQUEST);
|
||||
}
|
||||
|
||||
// An explicit `create` against a taken name conflicts; the server never
|
||||
// auto-selects a replacement name.
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let error = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload(
|
||||
"full",
|
||||
vec![],
|
||||
vec![decision("GET /v2/latest", "create", None, None, None)],
|
||||
),
|
||||
)
|
||||
.await
|
||||
.expect_err("create with a taken name must conflict");
|
||||
assert_error_code(&error, "import_plan_name_conflict");
|
||||
assert_http_status(error, axum::http::StatusCode::CONFLICT);
|
||||
|
||||
// Without an explicit decision the same collision stays a bounded,
|
||||
// redacted blocked candidate inside the immutable plan.
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let plan = service
|
||||
.create_openapi_import_plan(&workspace_id, &job_id, plan_payload("full", vec![], vec![]))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(plan.counts.actionable, 0);
|
||||
assert_eq!(plan.counts.blocked, 1);
|
||||
let stored = registry
|
||||
.get_import_plan(&workspace_id, &plan.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let candidate = &stored.payload["candidates"][0];
|
||||
assert_eq!(candidate["state"], "blocked");
|
||||
assert_eq!(candidate["reason"], "operation_name_conflict");
|
||||
assert!(candidate.get("operation").is_none());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn auth_profile_references_are_validated_stored_and_inherited() {
|
||||
let registry = test_registry().await;
|
||||
let upstream_base_url = spawn_upstream_server().await;
|
||||
let service = test_service(
|
||||
registry.clone(),
|
||||
test_storage_root("openapi_import_plan_auth"),
|
||||
test_auth_settings(),
|
||||
test_secret_crypto(),
|
||||
);
|
||||
let workspace_id = WorkspaceId::new("ws_default");
|
||||
|
||||
let secret_token = "plan-secret-canary-2-13";
|
||||
let secret = service
|
||||
.create_secret(
|
||||
&workspace_id,
|
||||
None,
|
||||
SecretPayload {
|
||||
name: "plan-auth-token".to_owned(),
|
||||
kind: SecretKind::Token,
|
||||
value: json!({ "token": secret_token }),
|
||||
},
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let auth_profile = service
|
||||
.create_auth_profile(
|
||||
&workspace_id,
|
||||
AuthProfilePayload {
|
||||
name: "plan-auth-profile".to_owned(),
|
||||
kind: AuthKind::ApiKeyHeader,
|
||||
config: AuthConfig::ApiKeyHeader(ApiKeyHeaderAuthConfig {
|
||||
header_name: "X-Api-Key".to_owned(),
|
||||
secret_id: SecretId::new(secret.id.as_str()),
|
||||
}),
|
||||
},
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let plan = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload(
|
||||
"full",
|
||||
vec![],
|
||||
vec![decision(
|
||||
"GET /v2/latest",
|
||||
"create",
|
||||
None,
|
||||
None,
|
||||
Some(auth_profile.id.as_str()),
|
||||
)],
|
||||
),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let stored = registry
|
||||
.get_import_plan(&workspace_id, &plan.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
stored.payload["candidates"][0]["operation"]["execution_config"]["auth_profile_ref"],
|
||||
auth_profile.id.as_str()
|
||||
);
|
||||
// Only the reference survives: no secret material anywhere in the plan.
|
||||
assert!(!stored.payload.to_string().contains(secret_token));
|
||||
assert_eq!(
|
||||
plan.candidates.first().unwrap().auth_profile_id.as_deref(),
|
||||
Some(auth_profile.id.as_str())
|
||||
);
|
||||
|
||||
// An unknown profile reference fails closed in the workspace scope check.
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let error = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload(
|
||||
"full",
|
||||
vec![],
|
||||
vec![decision(
|
||||
"GET /v2/latest",
|
||||
"create",
|
||||
None,
|
||||
None,
|
||||
Some("auth_missing_profile"),
|
||||
)],
|
||||
),
|
||||
)
|
||||
.await
|
||||
.expect_err("an unknown auth profile reference must be rejected");
|
||||
assert_error_code(&error, "operation_auth_profile_invalid");
|
||||
assert_http_status(error, axum::http::StatusCode::UNPROCESSABLE_ENTITY);
|
||||
|
||||
// `new_version` without an explicit choice inherits the target's ref.
|
||||
let existing = service
|
||||
.create_operation(&workspace_id, {
|
||||
let mut payload = test_operation_payload(&upstream_base_url, "latest_rates");
|
||||
payload.execution_config.auth_profile_ref =
|
||||
Some(AuthProfileId::new(auth_profile.id.as_str()));
|
||||
payload
|
||||
})
|
||||
.await
|
||||
.expect("an existing operation with the candidate name");
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let plan = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload(
|
||||
"full",
|
||||
vec![],
|
||||
vec![decision(
|
||||
"GET /v2/latest",
|
||||
"new_version",
|
||||
Some(existing.operation_id.as_str()),
|
||||
None,
|
||||
None,
|
||||
)],
|
||||
),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let stored = registry
|
||||
.get_import_plan(&workspace_id, &plan.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let candidate = &stored.payload["candidates"][0];
|
||||
assert_eq!(
|
||||
candidate["decision"]["auth_profile_id"],
|
||||
auth_profile.id.as_str(),
|
||||
"the inherited target reference is reflected in the candidate summary"
|
||||
);
|
||||
assert_eq!(
|
||||
candidate["operation"]["execution_config"]["auth_profile_ref"],
|
||||
auth_profile.id.as_str(),
|
||||
"the inherited target reference must be retained in the snapshot"
|
||||
);
|
||||
assert!(!stored.payload.to_string().contains(secret_token));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn stale_or_terminal_jobs_preview_again_without_mutating_the_job() {
|
||||
let registry = test_registry().await;
|
||||
let service = test_service(
|
||||
registry.clone(),
|
||||
test_storage_root("openapi_import_plan_stale"),
|
||||
test_auth_settings(),
|
||||
test_secret_crypto(),
|
||||
);
|
||||
let workspace_id = WorkspaceId::new("ws_default");
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
sqlx::query(
|
||||
"update import_jobs
|
||||
set preview_payload = jsonb_set(preview_payload, '{preview_digest}', to_jsonb($1::text))
|
||||
where id = $2",
|
||||
)
|
||||
.bind("0".repeat(64))
|
||||
.bind(job_id.as_str())
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let error = service
|
||||
.create_openapi_import_plan(&workspace_id, &job_id, plan_payload("full", vec![], vec![]))
|
||||
.await
|
||||
.expect_err("a stale preview contract must be rejected");
|
||||
assert_error_code(&error, "import_replay_verification_failed");
|
||||
let context = public_error_context(&error).cloned().unwrap();
|
||||
assert_eq!(context["repreview_required"], json!(true));
|
||||
assert_eq!(
|
||||
context.get("recovery").and_then(Value::as_str),
|
||||
Some("repreview_required")
|
||||
);
|
||||
assert_http_status(error, axum::http::StatusCode::CONFLICT);
|
||||
|
||||
// Unlike the legacy path the job itself is untouched: other stored
|
||||
// plans anchored to it must remain readable.
|
||||
let job = registry
|
||||
.get_import_job(&workspace_id, &job_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(job.status, ImportJobStatus::Pending);
|
||||
assert_eq!(job.error_text, None);
|
||||
assert!(job.finished_at.is_none());
|
||||
assert!(
|
||||
service
|
||||
.list_operations(&workspace_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.is_empty()
|
||||
);
|
||||
|
||||
let completed_at = OffsetDateTime::now_utc();
|
||||
registry
|
||||
.finish_import_job(FinishImportJobRequest {
|
||||
id: &job_id,
|
||||
status: ImportJobStatus::Failed,
|
||||
created_operation_ids: &json!([]),
|
||||
error_text: Some("test_finalized"),
|
||||
finished_at: &completed_at,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let error = service
|
||||
.create_openapi_import_plan(&workspace_id, &job_id, plan_payload("full", vec![], vec![]))
|
||||
.await
|
||||
.expect_err("a terminal job cannot be planned");
|
||||
assert_error_code(&error, "import_plan_job_terminal");
|
||||
assert_http_status(error, axum::http::StatusCode::CONFLICT);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn public_plan_route_returns_bounded_confirmation_and_requires_a_session() {
|
||||
let registry = test_registry().await;
|
||||
let storage_root = test_storage_root("openapi_import_plan_http");
|
||||
let service = test_service(
|
||||
registry.clone(),
|
||||
storage_root.clone(),
|
||||
test_auth_settings(),
|
||||
test_secret_crypto(),
|
||||
);
|
||||
let app = build_test_app(registry.clone(), storage_root);
|
||||
let workspace_id = WorkspaceId::new("ws_default");
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id = preview.job_id.clone();
|
||||
|
||||
let server = spawn_admin_api(app).await;
|
||||
let client = authorized_client(&server).await;
|
||||
let url = format!("{}/imports/openapi/{}/plans", server.as_ref(), job_id);
|
||||
|
||||
// Without a session (and thus without a workspace owner context) the
|
||||
// public contract refuses and no plan is created.
|
||||
let anonymous = reqwest::Client::new();
|
||||
let denied = anonymous
|
||||
.post(&url)
|
||||
.json(&json!({ "selection_mode": "full", "selected_operation_keys": [] }))
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(denied.status(), reqwest::StatusCode::UNAUTHORIZED);
|
||||
|
||||
let accepted = client
|
||||
.post(&url)
|
||||
.json(&json!({ "selection_mode": "full", "selected_operation_keys": [] }))
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(accepted.status(), reqwest::StatusCode::OK);
|
||||
let body: Value = accepted.json().await.unwrap();
|
||||
let plan_reference = body["plan_reference"].as_str().unwrap_or_default();
|
||||
assert!(
|
||||
plan_reference.starts_with("plan_"),
|
||||
"plan reference must be server-issued: {body:?}"
|
||||
);
|
||||
let plan_digest = body["plan_digest"].as_str().unwrap_or_default();
|
||||
assert!(
|
||||
plan_digest.len() == 64 && plan_digest.bytes().all(|b| b.is_ascii_hexdigit()),
|
||||
"plan digest must be the registry-derived SHA-256: {body:?}"
|
||||
);
|
||||
assert_eq!(body["selection_mode"], "full");
|
||||
assert_eq!(
|
||||
body["counts"],
|
||||
json!({ "selected": 1, "excluded": 0, "actionable": 1, "blocked": 0 })
|
||||
);
|
||||
assert_eq!(body["candidates"].as_array().unwrap().len(), 1);
|
||||
assert_eq!(body["candidates"][0]["key"], "GET /v2/latest");
|
||||
assert_eq!(body["candidates"][0]["state"], "actionable");
|
||||
assert_eq!(body["candidates"][0]["action"], "create");
|
||||
assert!(body["expires_at"].is_string());
|
||||
// The HTTP response is the bounded confirmation only: no draft snapshot,
|
||||
// no raw preview material, no secret material.
|
||||
assert!(body["candidates"][0].get("operation").is_none());
|
||||
assert!(!body.to_string().to_lowercase().contains("password"));
|
||||
|
||||
// The plan is readable in the same workspace right after the 200.
|
||||
let plan_id = crank_registry::ImportPlanId::new(plan_reference);
|
||||
let readable = registry
|
||||
.get_import_plan(&workspace_id, &plan_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.expect("the HTTP-created plan must be persisted");
|
||||
assert_eq!(readable.digest, plan_digest);
|
||||
}
|
||||
@@ -0,0 +1,163 @@
|
||||
use admin_api::{
|
||||
error::ApiError,
|
||||
service::{
|
||||
AuthProfilePayload, OpenApiImportPlanCreatePayload, OpenApiImportPlanDecision,
|
||||
OpenApiUpload, OpenApiUploadLocale, SecretPayload,
|
||||
},
|
||||
};
|
||||
use axum::response::IntoResponse;
|
||||
use crank_core::{
|
||||
ApiKeyHeaderAuthConfig, AuthConfig, AuthKind, AuthProfileId, OperationId, SecretId, SecretKind,
|
||||
Workspace, WorkspaceId, WorkspaceStatus,
|
||||
};
|
||||
use crank_registry::{
|
||||
CreateWorkspaceRequest, FinishImportJobRequest, ImportJobId, ImportJobStatus,
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
use serial_test::serial;
|
||||
use time::OffsetDateTime;
|
||||
|
||||
use super::super::common::*;
|
||||
const OPENAPI_SINGLE: &str = r#"
|
||||
openapi: 3.0.3
|
||||
info:
|
||||
title: Frankfurter API
|
||||
servers:
|
||||
- url: https://api.frankfurter.dev
|
||||
paths:
|
||||
/v2/latest:
|
||||
get:
|
||||
operationId: latestRates
|
||||
summary: Получить последние курсы валют
|
||||
tags: [currency]
|
||||
parameters:
|
||||
- name: base
|
||||
in: query
|
||||
required: true
|
||||
schema: { type: string }
|
||||
responses:
|
||||
'200':
|
||||
description: OK
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
type: object
|
||||
properties:
|
||||
base: { type: string }
|
||||
rates:
|
||||
type: object
|
||||
"#;
|
||||
|
||||
const OPENAPI_TWO_OPS: &str = r#"
|
||||
openapi: 3.0.3
|
||||
info: { title: Two Operations }
|
||||
servers: [{ url: https://api.example.test }]
|
||||
paths:
|
||||
/alpha:
|
||||
get:
|
||||
operationId: alpha
|
||||
responses: { '200': { description: ok } }
|
||||
/beta:
|
||||
get:
|
||||
operationId: betaOp
|
||||
responses: { '200': { description: ok } }
|
||||
"#;
|
||||
|
||||
const OPENAPI_GLOBAL_BLOCKER: &str = r#"
|
||||
openapi: 3.0.3
|
||||
info: { title: Global blocker }
|
||||
servers: [{ url: https://api.example.test }]
|
||||
paths:
|
||||
/valid:
|
||||
get:
|
||||
responses: { '200': { description: ok } }
|
||||
/broken: not-a-path-item
|
||||
"#;
|
||||
|
||||
fn upload(document: &str) -> OpenApiUpload {
|
||||
OpenApiUpload {
|
||||
bytes: document.as_bytes().to_vec(),
|
||||
mime_type: "application/yaml".to_owned(),
|
||||
locale: OpenApiUploadLocale::En,
|
||||
}
|
||||
}
|
||||
|
||||
fn preview_operation_keys(
|
||||
preview: &admin_api::service::OpenApiImportPreviewResponse,
|
||||
) -> Vec<String> {
|
||||
let mut keys = preview
|
||||
.preview
|
||||
.groups
|
||||
.iter()
|
||||
.flat_map(|group| &group.operations)
|
||||
.map(|operation| operation.key.clone())
|
||||
.collect::<Vec<_>>();
|
||||
keys.sort();
|
||||
keys
|
||||
}
|
||||
|
||||
fn decision(
|
||||
key: &str,
|
||||
action: &str,
|
||||
target: Option<&str>,
|
||||
name: Option<&str>,
|
||||
auth: Option<&str>,
|
||||
) -> OpenApiImportPlanDecision {
|
||||
OpenApiImportPlanDecision {
|
||||
operation_key: key.to_owned(),
|
||||
action: action.to_owned(),
|
||||
target_operation_id: target.map(ToOwned::to_owned),
|
||||
confirmed_name: name.map(ToOwned::to_owned),
|
||||
auth_profile_id: auth.map(ToOwned::to_owned),
|
||||
}
|
||||
}
|
||||
|
||||
fn plan_payload(
|
||||
selection_mode: &str,
|
||||
selected: Vec<String>,
|
||||
decisions: Vec<OpenApiImportPlanDecision>,
|
||||
) -> OpenApiImportPlanCreatePayload {
|
||||
OpenApiImportPlanCreatePayload {
|
||||
selection_mode: selection_mode.to_owned(),
|
||||
selected_operation_keys: selected,
|
||||
server_url: None,
|
||||
decisions,
|
||||
}
|
||||
}
|
||||
|
||||
fn public_error_context(error: &ApiError) -> Option<&Value> {
|
||||
match error {
|
||||
ApiError::Unauthorized { context, .. }
|
||||
| ApiError::Forbidden { context, .. }
|
||||
| ApiError::Validation { context, .. }
|
||||
| ApiError::Unprocessable { context, .. }
|
||||
| ApiError::NotFound { context, .. }
|
||||
| ApiError::Conflict { context, .. }
|
||||
| ApiError::PayloadTooLarge { context, .. }
|
||||
| ApiError::PreconditionRequired { context, .. }
|
||||
| ApiError::RateLimited { context, .. }
|
||||
| ApiError::Internal { context, .. } => context.as_ref(),
|
||||
}
|
||||
}
|
||||
|
||||
fn assert_error_code(error: &ApiError, expected_code: &str) {
|
||||
assert_eq!(
|
||||
public_error_context(error)
|
||||
.and_then(|context| context.get("error_code"))
|
||||
.and_then(Value::as_str),
|
||||
Some(expected_code),
|
||||
"unexpected API error: {error:?}"
|
||||
);
|
||||
}
|
||||
|
||||
/// Asserts the rendered HTTP status of a rejection without private accessors.
|
||||
fn assert_http_status(error: ApiError, expected: axum::http::StatusCode) {
|
||||
assert_eq!(
|
||||
error.into_response().status(),
|
||||
expected,
|
||||
"the rendered status must match the public contract"
|
||||
);
|
||||
}
|
||||
|
||||
mod creation;
|
||||
mod validation;
|
||||
@@ -0,0 +1,275 @@
|
||||
use super::*;
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn explicit_targets_are_checked_even_when_the_candidate_is_blocked() {
|
||||
let registry = test_registry().await;
|
||||
let upstream_base_url = spawn_upstream_server().await;
|
||||
let service = test_service(
|
||||
registry.clone(),
|
||||
test_storage_root("openapi_import_plan_blocked_target"),
|
||||
test_auth_settings(),
|
||||
test_secret_crypto(),
|
||||
);
|
||||
let workspace_id = WorkspaceId::new("ws_default");
|
||||
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_GLOBAL_BLOCKER))
|
||||
.await
|
||||
.unwrap();
|
||||
let blocker_code = preview
|
||||
.preview
|
||||
.findings
|
||||
.iter()
|
||||
.find(|finding| finding.severity == crank_import::rest::ImportFindingSeverity::Error)
|
||||
.map(|finding| finding.code.clone())
|
||||
.expect("the fixture produces a global error finding");
|
||||
let candidate = &preview.preview.groups[0].operations[0];
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
|
||||
// A mismatched/unknown explicit target is a request error even though
|
||||
// the candidate is already blocked by the preview.
|
||||
let error = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload(
|
||||
"full",
|
||||
vec![],
|
||||
vec![decision(
|
||||
&candidate.key,
|
||||
"skip",
|
||||
Some("op_does_not_exist"),
|
||||
None,
|
||||
None,
|
||||
)],
|
||||
),
|
||||
)
|
||||
.await
|
||||
.expect_err("an unknown target is a request error even for a blocked candidate");
|
||||
assert_error_code(&error, "import_plan_target_invalid");
|
||||
assert_http_status(error, axum::http::StatusCode::BAD_REQUEST);
|
||||
|
||||
// A resolvable exact target is recorded while the candidate stays
|
||||
// blocked with its bounded redacted reason.
|
||||
let existing = service
|
||||
.create_operation(
|
||||
&workspace_id,
|
||||
test_operation_payload(&upstream_base_url, &candidate.draft.name),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_GLOBAL_BLOCKER))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let plan = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload(
|
||||
"full",
|
||||
vec![],
|
||||
vec![decision(
|
||||
&candidate.key,
|
||||
"skip",
|
||||
Some(existing.operation_id.as_str()),
|
||||
None,
|
||||
None,
|
||||
)],
|
||||
),
|
||||
)
|
||||
.await
|
||||
.expect("a valid explicit target is accepted for a blocked candidate");
|
||||
let stored = registry
|
||||
.get_import_plan(&workspace_id, &plan.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let candidate = &stored.payload["candidates"][0];
|
||||
assert_eq!(candidate["state"], "blocked");
|
||||
assert_eq!(candidate["reason"], blocker_code);
|
||||
assert_eq!(
|
||||
candidate["target"]["operation_id"],
|
||||
json!(existing.operation_id)
|
||||
);
|
||||
assert!(
|
||||
candidate.get("operation").is_none(),
|
||||
"a blocked candidate never stores draft material"
|
||||
);
|
||||
assert!(service.list_operations(&workspace_id).await.unwrap().len() <= 1);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn archived_rest_target_cannot_be_planned_for_new_version() {
|
||||
let registry = test_registry().await;
|
||||
let upstream_base_url = spawn_upstream_server().await;
|
||||
let service = test_service(
|
||||
registry.clone(),
|
||||
test_storage_root("openapi_import_plan_archived_target"),
|
||||
test_auth_settings(),
|
||||
test_secret_crypto(),
|
||||
);
|
||||
let workspace_id = WorkspaceId::new("ws_default");
|
||||
let existing = service
|
||||
.create_operation(
|
||||
&workspace_id,
|
||||
test_operation_payload(&upstream_base_url, "latest_rates"),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
registry
|
||||
.archive_operation(
|
||||
&workspace_id,
|
||||
&OperationId::new(existing.operation_id.clone()),
|
||||
&time::OffsetDateTime::now_utc(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload(OPENAPI_SINGLE))
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let error = service
|
||||
.create_openapi_import_plan(
|
||||
&workspace_id,
|
||||
&job_id,
|
||||
plan_payload(
|
||||
"full",
|
||||
vec![],
|
||||
vec![decision(
|
||||
"GET /v2/latest",
|
||||
"new_version",
|
||||
Some(existing.operation_id.as_str()),
|
||||
None,
|
||||
None,
|
||||
)],
|
||||
),
|
||||
)
|
||||
.await
|
||||
.expect_err("archived target cannot accept a new Draft Version");
|
||||
assert_error_code(&error, "import_plan_target_invalid");
|
||||
assert_http_status(error, axum::http::StatusCode::BAD_REQUEST);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[serial]
|
||||
async fn detached_dependency_snapshot_repreview_requires_without_a_plan() {
|
||||
let app = axum::Router::new().route(
|
||||
"/schema.yaml",
|
||||
axum::routing::get(|| async {
|
||||
"Result: { type: object, properties: { id: { type: string } } }"
|
||||
}),
|
||||
);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
|
||||
let origin = format!("http://{address}");
|
||||
|
||||
let registry = test_registry().await;
|
||||
let service = test_service_with_external_references(
|
||||
registry.clone(),
|
||||
test_storage_root("openapi_import_plan_dependency_stale"),
|
||||
vec![format!("{origin}/")],
|
||||
);
|
||||
let workspace_id = WorkspaceId::new("ws_default");
|
||||
let upload = OpenApiUpload {
|
||||
bytes: format!(
|
||||
r#"
|
||||
openapi: 3.1.0
|
||||
info: {{ title: External dependency }}
|
||||
servers: [{{ url: https://api.example.test }}]
|
||||
paths:
|
||||
/items:
|
||||
get:
|
||||
operationId: listItems
|
||||
responses:
|
||||
'200':
|
||||
description: ok
|
||||
content:
|
||||
application/json:
|
||||
schema: {{ $ref: '{origin}/schema.yaml#/Result' }}
|
||||
"#
|
||||
)
|
||||
.into_bytes(),
|
||||
mime_type: "application/yaml".to_owned(),
|
||||
locale: OpenApiUploadLocale::En,
|
||||
};
|
||||
let preview = service
|
||||
.preview_openapi_import(&workspace_id, upload)
|
||||
.await
|
||||
.unwrap();
|
||||
let job_id: ImportJobId = preview.job_id.as_str().into();
|
||||
let job = registry
|
||||
.get_import_job(&workspace_id, &job_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let dependency_sources = job.preview_payload["dependencies"]
|
||||
.as_array()
|
||||
.cloned()
|
||||
.unwrap();
|
||||
assert!(
|
||||
!dependency_sources.is_empty(),
|
||||
"fixture must create a dependency"
|
||||
);
|
||||
|
||||
// The plan is creatable while the stored snapshot is still active.
|
||||
let fresh = service
|
||||
.create_openapi_import_plan(&workspace_id, &job_id, plan_payload("full", vec![], vec![]))
|
||||
.await
|
||||
.expect("an active dependency snapshot must not block planning");
|
||||
assert_eq!(
|
||||
registry
|
||||
.get_import_plan(&workspace_id, &fresh.plan_reference.as_str().into())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap()
|
||||
.payload["dependencies"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.len(),
|
||||
dependency_sources.len()
|
||||
);
|
||||
|
||||
// Detach one stored snapshot: the same job now requires re-preview and
|
||||
// no plan is created; the legacy job itself stays untouched.
|
||||
let victim = &dependency_sources[0];
|
||||
sqlx::query(
|
||||
"update artifact_sources
|
||||
set lifecycle = 'detached', updated_at = now(), detached_at = now()
|
||||
where workspace_id = $1 and source_id = $2",
|
||||
)
|
||||
.bind(workspace_id.as_str())
|
||||
.bind(victim["source_id"].as_str().unwrap())
|
||||
.execute(registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
let error = service
|
||||
.create_openapi_import_plan(&workspace_id, &job_id, plan_payload("full", vec![], vec![]))
|
||||
.await
|
||||
.expect_err("a detached dependency snapshot is re-preview material");
|
||||
assert_error_code(&error, "import_dependency_verification_failed");
|
||||
let context = public_error_context(&error).cloned().unwrap();
|
||||
assert_eq!(context["repreview_required"], json!(true));
|
||||
assert_http_status(error, axum::http::StatusCode::CONFLICT);
|
||||
let job = registry
|
||||
.get_import_job(&workspace_id, &job_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(job.status, ImportJobStatus::Pending);
|
||||
assert_eq!(job.error_text, None);
|
||||
assert!(job.finished_at.is_none());
|
||||
assert!(
|
||||
service
|
||||
.list_operations(&workspace_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.is_empty()
|
||||
);
|
||||
}
|
||||
@@ -40,7 +40,7 @@ fn plan_is_deterministic_and_committed_contract_is_current() {
|
||||
);
|
||||
assert_eq!(first.stdout, second.stdout);
|
||||
let plan: serde_json::Value = serde_json::from_slice(&first.stdout).unwrap();
|
||||
assert_eq!(plan["sequence"].as_array().unwrap().len(), 13);
|
||||
assert_eq!(plan["sequence"].as_array().unwrap().len(), 14);
|
||||
|
||||
let checked = command(&["plan", "--check"], None);
|
||||
assert!(
|
||||
@@ -82,7 +82,7 @@ async fn database_only_config_can_apply_and_preflight_a_fresh_schema() {
|
||||
);
|
||||
let result: serde_json::Value = serde_json::from_slice(&preflight.stdout).unwrap();
|
||||
assert_eq!(result["status"], "current");
|
||||
assert_eq!(result["version"], 13);
|
||||
assert_eq!(result["version"], 14);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
Reference in new issue
Block a user