omena-query 0.3.0

Omena query boundary over CME producer query fragments
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use crate::{
    OmenaError, OmenaErrorClassV0, OmenaErrorContextV0, OmenaErrorRecoverabilityV0,
    OmenaErrorSeverityV0, OmenaSdkDiagnosticsDebugReportV0, OmenaSdkDiagnosticsRequestV0,
    OmenaSdkDiagnosticsResponseV0, OmenaSdkDiagnosticsSummaryV0, OmenaSdkResponsePartitionV0,
    OmenaWorkspaceSnapshotIdV0, summarize_omena_query_consumer_check_style_source,
};

pub fn execute_omena_sdk_diagnostics_workflow(
    request: OmenaSdkDiagnosticsRequestV0,
    read_snapshot_id: OmenaWorkspaceSnapshotIdV0,
) -> Result<OmenaSdkDiagnosticsResponseV0, OmenaError> {
    if request.snapshot_id != read_snapshot_id {
        return Err(OmenaError::new(
            OmenaErrorClassV0::Workspace,
            "diagnostics request does not match the current workspace snapshot",
            OmenaErrorContextV0 {
                code: "workspace.snapshot-mismatch".to_string(),
                severity: OmenaErrorSeverityV0::Error,
                recoverability: OmenaErrorRecoverabilityV0::Retry,
                evidence: Vec::new(),
            },
        ));
    }

    let summary = summarize_omena_query_consumer_check_style_source(
        &request.style_path,
        &request.style_source,
    );
    Ok(OmenaSdkDiagnosticsResponseV0 {
        snapshot_id: read_snapshot_id,
        partition: OmenaSdkResponsePartitionV0::Public,
        summary: OmenaSdkDiagnosticsSummaryV0 {
            schema_version: summary.schema_version.to_string(),
            product: summary.product.to_string(),
            style_path: summary.style_path,
            dialect: summary.dialect.to_string(),
            token_count: count_to_u64(summary.token_count)?,
            parser_error_count: count_to_u64(summary.parser_error_count)?,
            class_selector_count: count_to_u64(summary.class_selector_count)?,
            custom_property_count: count_to_u64(summary.custom_property_count)?,
            keyframe_count: count_to_u64(summary.keyframe_count)?,
            ready_surfaces: summary
                .ready_surfaces
                .into_iter()
                .map(str::to_string)
                .collect(),
        },
    })
}

pub fn execute_omena_sdk_diagnostics_debug_workflow(
    request: OmenaSdkDiagnosticsRequestV0,
    read_snapshot_id: OmenaWorkspaceSnapshotIdV0,
) -> Result<OmenaSdkDiagnosticsDebugReportV0, OmenaError> {
    let response = execute_omena_sdk_diagnostics_workflow(request, read_snapshot_id)?;
    let analysis = serde_json::json!({
        "parserErrorCount": response.summary.parser_error_count,
        "readySurfaces": response.summary.ready_surfaces,
    });
    Ok(OmenaSdkDiagnosticsDebugReportV0 {
        snapshot_id: response.snapshot_id,
        partition: OmenaSdkResponsePartitionV0::Debug,
        public_response: response,
        analysis,
    })
}

fn count_to_u64(value: usize) -> Result<u64, OmenaError> {
    u64::try_from(value).map_err(|_| {
        OmenaError::new(
            OmenaErrorClassV0::Internal,
            "diagnostics count exceeds the workflow contract range",
            OmenaErrorContextV0 {
                code: "diagnostics.count-range".to_string(),
                severity: OmenaErrorSeverityV0::Error,
                recoverability: OmenaErrorRecoverabilityV0::NotRecoverable,
                evidence: Vec::new(),
            },
        )
    })
}