relay-knowledge 1.1.17

Graph-database-based knowledge graph project.
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

//! Owns registered repository lookup, status checkpoints, and status conversion.

use crate::{
    api::ApiError,
    domain::{
        CodeIndexCheckpoint, CodeIndexTaskRecord, CodeRepositoryRegistration, CodeRepositoryStatus,
    },
    storage::{CodeIndexPublicationStore, RepositoryCatalogStore},
};

use super::super::errors::storage_api_error;

pub(in crate::application::code_repository) async fn required_code_repository(
    store: &(impl RepositoryCatalogStore + ?Sized),
    repository: &str,
) -> Result<crate::domain::CodeRepositoryStatus, ApiError> {
    store
        .code_repository_status(repository.to_owned())
        .await
        .map_err(storage_api_error)?
        .ok_or_else(|| {
            ApiError::invalid_argument(format!("code repository '{repository}' is not registered"))
        })
}

pub(in crate::application::code_repository) async fn code_status_checkpoint(
    store: &(impl CodeIndexPublicationStore + ?Sized),
    status: &CodeRepositoryStatus,
    active_task: Option<&CodeIndexTaskRecord>,
) -> Result<Option<CodeIndexCheckpoint>, ApiError> {
    if let Some(task) = active_task {
        return store
            .code_index_checkpoint(task.source_scope.clone())
            .await
            .map_err(storage_api_error);
    }
    if status.state == "indexing"
        && let Some(checkpoint) = store
            .latest_code_index_checkpoint(status.repository_id.clone())
            .await
            .map_err(storage_api_error)?
    {
        return Ok(Some(checkpoint));
    }
    if let Some(scope) = status.last_indexed_scope_id.clone()
        && let Some(checkpoint) = store
            .code_index_checkpoint(scope)
            .await
            .map_err(storage_api_error)?
    {
        return Ok(Some(checkpoint));
    }

    Ok(None)
}

pub(in crate::application::code_repository) fn registration_from_status(
    status: &crate::domain::CodeRepositoryStatus,
) -> CodeRepositoryRegistration {
    CodeRepositoryRegistration {
        repository_id: status.repository_id.clone(),
        alias: status.alias.clone(),
        root_path: status.root_path.clone(),
        path_filters: status.path_filters.clone(),
        language_filters: status.language_filters.clone(),
    }
}