Trait TaskSource 

pub trait TaskSource: Send + Sync {
    // Required methods
    fn kind(&self) -> &'static str;
    fn capabilities(&self) -> Capabilities;
    fn health<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Health, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_task<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 NativeId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Task>, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_project<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 NativeId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Project>, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn query_tasks<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        query: &'life1 TaskQuery,
        page: &'life2 PageRequest,
    ) -> Pin<Box<dyn Future<Output = Result<Page<Task>, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn query_projects<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        query: &'life1 ProjectQuery,
        page: &'life2 PageRequest,
    ) -> Pin<Box<dyn Future<Output = Result<Page<Project>, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn labels<'life0, 'life1, 'async_trait>(
        &'life0 self,
        page: &'life1 PageRequest,
    ) -> Pin<Box<dyn Future<Output = Result<Page<Label>, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn task_dependencies<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        id: &'life1 NativeId,
        direction: Direction,
        page: &'life2 PageRequest,
    ) -> Pin<Box<dyn Future<Output = Result<Page<DependencyEdge>, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn project_dependencies<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        id: &'life1 NativeId,
        direction: Direction,
        page: &'life2 PageRequest,
    ) -> Pin<Box<dyn Future<Output = Result<Page<DependencyEdge>, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;

    // Provided methods
    fn writes(&self) -> WriteSupport { ... }
    fn write_task<'life0, 'life1, 'async_trait>(
        &'life0 self,
        write: &'life1 ItemWrite<Task>,
    ) -> Pin<Box<dyn Future<Output = Result<NativeId, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn write_project<'life0, 'life1, 'async_trait>(
        &'life0 self,
        write: &'life1 ItemWrite<Project>,
    ) -> Pin<Box<dyn Future<Output = Result<NativeId, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn delete_task<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 NativeId,
    ) -> Pin<Box<dyn Future<Output = Result<(), SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn delete_project<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 NativeId,
    ) -> Pin<Box<dyn Future<Output = Result<(), SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_document<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 NativeId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Document>, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn query_documents<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        query: &'life1 DocumentQuery,
        page: &'life2 PageRequest,
    ) -> Pin<Box<dyn Future<Output = Result<Page<Document>, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn write_document<'life0, 'life1, 'async_trait>(
        &'life0 self,
        write: &'life1 ItemWrite<Document>,
    ) -> Pin<Box<dyn Future<Output = Result<NativeId, SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn delete_document<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 NativeId,
    ) -> Pin<Box<dyn Future<Output = Result<(), SourceError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
}

One configured source, as the engine drives it.

Dyn-compatible through async_trait because the engine holds Vec<Box<dyn TaskSource>> over heterogeneous plugins.

Three rules bind every implementation, and the engine’s compensation is only correct while all three hold:

1. Apply every predicate you declare Support::Native.
2. Ignore every Support-typed predicate you declare Unsupported — return the wider result set, never a narrower one. Silently dropping rows for a predicate you did not declare is the one failure no test above the plugin can catch.
3. Never return a silently empty dependency read. Rule 2 reaches the Support-typed predicates alone; a dependency read is always real, and so is a document read — Capabilities::documents says whether this source has documents at all, and a source that says it has none is never asked for one rather than answering an empty page.

Required Methods

fn kind(&self) -> &'static str

The plugin kind that built this source, for display and for plan output.

fn capabilities(&self) -> Capabilities

What this source applies itself. Read once per query by the engine.

fn health<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Health, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Whether the source is answering right now.

Errors

Returns a SourceError when the check itself could not be made.

fn get_task<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NativeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Task>, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch one task by its native id, or None when there is no such task.

Errors

Returns a SourceError when the source could not answer.

fn get_project<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NativeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Project>, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch one project by its native id, or None when there is no such project.

Errors

Returns a SourceError when the source could not answer.

fn query_tasks<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, query: &'life1 TaskQuery, page: &'life2 PageRequest, ) -> Pin<Box<dyn Future<Output = Result<Page<Task>, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

One page of the tasks matching query.

Errors

Returns a SourceError when the source could not answer.

fn query_projects<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, query: &'life1 ProjectQuery, page: &'life2 PageRequest, ) -> Pin<Box<dyn Future<Output = Result<Page<Project>, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

One page of the projects matching query.

Errors

Returns a SourceError when the source could not answer.

fn labels<'life0, 'life1, 'async_trait>( &'life0 self, page: &'life1 PageRequest, ) -> Pin<Box<dyn Future<Output = Result<Page<Label>, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

One page of every label this source knows.

Errors

Returns a SourceError when the source could not answer.

fn task_dependencies<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 NativeId, direction: Direction, page: &'life2 PageRequest, ) -> Pin<Box<dyn Future<Output = Result<Page<DependencyEdge>, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

One page of the task dependency edges at id, in direction.

Errors

Returns a SourceError when the source could not answer.

fn project_dependencies<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 NativeId, direction: Direction, page: &'life2 PageRequest, ) -> Pin<Box<dyn Future<Output = Result<Page<DependencyEdge>, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

One page of the project dependency edges at id, in direction.

Errors

Returns a SourceError when the source could not answer.

Provided Methods

fn writes(&self) -> WriteSupport

Whether this source can be written through at all.

Defaulted to WriteSupport::Unsupported, which is what keeps this a read interface for every source that has nothing to write into: one that cannot be written needs no edit and keeps working. Read before a write is attempted, so a copy naming such a source as its destination is refused before anything is read.

fn write_task<'life0, 'life1, 'async_trait>( &'life0 self, write: &'life1 ItemWrite<Task>, ) -> Pin<Box<dyn Future<Output = Result<NativeId, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create or update one task, answering with the native id the destination holds it under.

A source declaring WriteSupport::Supported owes three things here. It refuses, naming the field, anything it cannot represent rather than dropping it — including a metadata key it cannot carry, which it names. It writes every other field it was given. And it never creates when ItemWrite::target names an item it does not hold.

Errors

Returns SourceError::Refused when this source has no write side, when a field or a metadata key cannot be represented, or when target names nothing here; and whatever else the source could not do the write for.

fn write_project<'life0, 'life1, 'async_trait>( &'life0 self, write: &'life1 ItemWrite<Project>, ) -> Pin<Box<dyn Future<Output = Result<NativeId, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create or update one project, on exactly the terms of write_task.

Errors

As write_task.

fn delete_task<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NativeId, ) -> Pin<Box<dyn Future<Output = Result<(), SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove one task this destination holds, so a copy that could not finish can put the destination back the way it found it.

This is not a verb of the product: nothing a user types deletes anything, and a copy never deletes an item it did not itself create in the run that is failing. It exists because a copy is either complete or it never happened — a half-written project has to be run again, and the re-run is the mutation burst that trips a hosted destination’s rate limiter. Undoing this run’s own creates is what removes that retry at source.

A source declaring WriteSupport::Supported owes a real implementation, for the reason it owes write_task one: the engine will create items there, so it has to be able to remove the ones it created. An id naming nothing is not an error — the item is already gone, which is the state this asks for.

Errors

Returns SourceError::Refused when this source has no write side, and whatever else the source could not remove the item for.

fn delete_project<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NativeId, ) -> Pin<Box<dyn Future<Output = Result<(), SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove one project this destination holds, on exactly the terms of delete_task.

Errors

As delete_task.

fn get_document<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NativeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Document>, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch one document by its native id, or None when there is no such document.

Defaulted to documentless, which is what keeps documents an addition rather than a break: a source with none needs no edit, keeps working, and says so in the same words every other document-free source does. A source that has documents declares Support::Native for Capabilities::documents and owes a real implementation here, because that declaration is what makes the engine ask.

Errors

Returns SourceError::Refused when this source has no documents, and whatever else the source could not answer for.

fn query_documents<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, query: &'life1 DocumentQuery, page: &'life2 PageRequest, ) -> Pin<Box<dyn Future<Output = Result<Page<Document>, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

One page of the documents matching query.

Defaulted on exactly the terms of get_document. A source with no documents refuses rather than answering an empty page: an empty page reads as a source that has documents and holds none matching, which is the one wrong answer this method can give.

Errors

As get_document.

fn write_document<'life0, 'life1, 'async_trait>( &'life0 self, write: &'life1 ItemWrite<Document>, ) -> Pin<Box<dyn Future<Output = Result<NativeId, SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create or update one document, on exactly the terms of write_task.

Errors

As write_task.

fn delete_document<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NativeId, ) -> Pin<Box<dyn Future<Output = Result<(), SourceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove one document this destination holds, on exactly the terms of delete_task.

Errors

As delete_task.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors