supporting repositories

[rsfunc]

Context:

Let

struct EntityTask {
    description: String,
}

#[cgp_component(GetEntityTasks)]
trait SupportsGetEntityTasks {
    async fn get_entity_tasks(&self) -> Vec<EntityTask>;
}

then I would like to define multiple tasks provider for this, and somehow have super component that could call all implementations and return all tasks...

I have the feeling it should be similar as in https://contextgeneric.dev/blog/extensible-datatypes-part-2/

Could you give some pointers if it is already doable with the current code?

[rsfunc]

Okay, I guess I need to study this one: https://github.com/contextgeneric/hypershell/blob/main/crates/hypershell-components/src/providers/string_arg.rs

[soareschen]

Hi @rsfunc, the way you implement a trait like GetEntityTasks depends on what kind of implementations you have, and how you want to use it in your application.

You could have multiple provider implementations with CGP, but if you only need one implementation for each concrete application context, then there is no need to use the extensible visitor pattern as highlighted in the blog post. For example, you could implement something like:

#[cgp_new_provider]
impl<Context> GetEntityTasks<Context> for GetEntityTasksFromApi
where
    Context: HasApiClient,
{ ... }

And then wire it up in your application:

#[cgp_context]
pub struct App {
    pub api_client: ApiClient,
}

delegate_components! {
    AppComponents {
        GetEntityTasksComponent: GetEntityTasksFromApi,
    }
}

Alternatively, if you do need to support multiple ways of getting the task at runtime through an enum of providers, there is now a #[cgp_dispatch] macro at the main branch that allows you to write something like follows:

#[cgp_dispatch]
#[async_trait]
trait SupportsGetEntityTasks {
    async fn get_entity_tasks(&self) -> Vec<EntityTask>;
}

impl SupportsGetEntityTasks for ApiClient { ... }
impl SupportsGetEntityTasks for InMemoryStore { ... }

#[derive(CgpVariant)]
pub enum EntityClient {
    ApiClient(ApiClient),
    InMemoryStore(InMemoryStore),
}

In the above example, the trait SupportsGetEntityTasks would automatically be implemented for EntityClient through a generated blanket implementation, since all variants in it implement the trait explicitly.

[rsfunc]

Indeed the idea is to have multiple, and I guessed it should be in the direction of the enums.
So, I will play/check your comments.
Ideally I would like to have or, that I can just define 'tasks' in multiple libraries (not knowing of each other) and run them one by one ( or parallel depending on the aggregator) and gather the results. Or at start define which check should be done via delegate_and_check_components.

[rsfunc]

I tried to use

cgp = { git = "https://github.com/contextgeneric/cgp.git", branch = "main", features = ["full"] }

in the toml of my crate ... but unfortunately the additional macros do not popup.

Anyway, if it would, so I would have something like

#[cgp_dispatch]
pub trait SupportsGetEmployerTasks {
    // generalize later, first lets try to implement via gcp
    fn get_employer_tasks(&self, employer: &Employer) -> impl Future<Output = anyhow::Result<Vec<AppTask>>> + Send;
}

#[derive(CgpVariant)]
pub enum EmployerChecksProviderEnum {
    CheckForIncompleteBillingInfoMissingContact(CheckForIncompleteBillingInfoMissingContact),
    CheckMissingContributionPaymentInfo(CheckMissingContributionPaymentInfo),
}

#[cgp_new_provider]
impl<C: Async> GetEmployerTasks<C> for CheckForIncompleteBillingInfoMissingContact
where
    C: SupportsEmployerAttributes,
{
    async fn get_employer_tasks(context: &C, employer: &Employer) -> anyhow::Result<Vec<AppTask>> {
        Ok(if !context.get_employer_attributes(employer.employer_id).await?.billing.is_complete() {
            vec![AppTask::IncompleteBillingInfoMissingContact(EmployerTaskParam::from(employer.clone()).into())]
        } else {
            vec![]
        })
    }
}

something similar for CheckMissingContributionPaymentInfo

So, somewhere I have an App

#[cgp_context]
#[derive(HasField, Clone)]
struct App {
 ...
}

let app=App { .. };

How to access the enum 'and call' get_employer_tasks

[rsfunc]

This works, at least, but, it bypasses all the magic... and I still need to know all the implementators

let employer = Example::example();
    let res = CheckMissingContributionPaymentInfo::get_employer_tasks(&app, &employer).await?;

[soareschen]

Thanks for sharing more about your example code! I now have a better idea of what you are trying to do. It looks like we don't really need extensible visitor in this case, and the same thing can be achieved with a different CGP pattern that I have yet to document.

At a high level, the implementation looks like follows:

use cgp::prelude::*;

pub struct Employer;

pub struct AppTask;

// A generic employer task querier that can perform queries based on a given `TaskSpec`.
#[cgp_component {
    provider: EmployerTaskQuerier,
    derive_delegate: UseDelegate<TaskSpec>, // Implement the `UseDelegate` dispatcher based on `TaskSpec`
}]
#[async_trait]
pub trait CanQueryEmployerTasks<TaskSpec: Async>: Async {
    async fn query_employer_tasks(
        &self,
        spec: &TaskSpec,
        employer: &Employer,
    ) -> Result<Vec<AppTask>, anyhow::Error>;
}

// A task spec for checking incomplete billing info with a missing contact.
pub struct CheckForIncompleteBillingInfoMissingContact;

// A task spec for checking missing contribution payment info.
pub struct CheckMissingContributionPaymentInfo;

// A combined task spec that allows multiple kinds of employer checks.
pub enum EmployerChecks {
    CheckForIncompleteBillingInfoMissingContact(CheckForIncompleteBillingInfoMissingContact),
    CheckMissingContributionPaymentInfo(CheckMissingContributionPaymentInfo),
}

// A default provider that implements `EmployerTaskQuerier`.
// We can also define separate providers to implement `EmployerTaskQuerier` for each task spec,
// but we will share the same provider in this example for simplicity.
pub struct DefaultEmployerTaskQuerier;

#[cgp_provider]
impl<App> EmployerTaskQuerier<App, CheckForIncompleteBillingInfoMissingContact>
    for DefaultEmployerTaskQuerier
where
    App: Async,
{
    async fn query_employer_tasks(
        app: &App,
        spec: &CheckForIncompleteBillingInfoMissingContact,
        employer: &Employer,
    ) -> Result<Vec<AppTask>, anyhow::Error> {
        todo!()
    }
}

#[cgp_provider]
impl<App> EmployerTaskQuerier<App, CheckMissingContributionPaymentInfo>
    for DefaultEmployerTaskQuerier
where
    App: Async,
{
    async fn query_employer_tasks(
        app: &App,
        spec: &CheckMissingContributionPaymentInfo,
        employer: &Employer,
    ) -> Result<Vec<AppTask>, anyhow::Error> {
        todo!()
    }
}

// Implements `EmployerTaskQuerier` for `EmployerChecks` by delegating it to other
// queriers
#[cgp_provider]
impl<App> EmployerTaskQuerier<App, EmployerChecks> for DefaultEmployerTaskQuerier
where
    // Use the context to look up for the implementation for sub tasks,
    // so that alternative providers may be wired with it.
    App: CanQueryEmployerTasks<CheckForIncompleteBillingInfoMissingContact>
        + CanQueryEmployerTasks<CheckMissingContributionPaymentInfo>,
{
    async fn query_employer_tasks(
        app: &App,
        spec: &EmployerChecks,
        employer: &Employer,
    ) -> Result<Vec<AppTask>, anyhow::Error> {
        // We can later use the extensible visitor pattern to handle the dispatching.
        // But it is better to start with an explicit match for clarity.
        match spec {
            EmployerChecks::CheckMissingContributionPaymentInfo(spec) => {
                app.query_employer_tasks(spec, employer).await
            }
            EmployerChecks::CheckForIncompleteBillingInfoMissingContact(spec) => {
                app.query_employer_tasks(spec, employer).await
            }
        }
    }
}

#[cgp_context]
pub struct App;

delegate_components! {
    AppComponents {
        // Use the default provider to implement `EmployerTaskQuerierComponent`
        EmployerTaskQuerierComponent: DefaultEmployerTaskQuerier,
    }
}

The main idea is that we would define a task querier component with a generic TaskSpec parameter as follows:

#[cgp_component(EmployerTaskQuerier)]
#[async_trait]
pub trait CanQueryEmployerTasks<TaskSpec: Async>: Async {
    async fn query_employer_tasks(
        &self,
        spec: &TaskSpec,
        employer: &Employer,
    ) -> Result<Vec<AppTask>, anyhow::Error>;
}

The generic parameter is there, because we want the context to be able to handle different sub tasks, i.e. EmployerChecks, CheckMissingContributionPaymentInfo, and CheckMissingContributionPaymentInfo. With the generic parameter, new task types can also be used with a context that supports them.

In the example, we define a default provider DefaultEmployerTaskQuerier that implements all instances of EmployerTaskQuerier, but they can also be implemented as separate providers for better extensibility. In particular, the EmployerTaskQuerier implementation for EmployerChecks makes use of the context to dispatch to the appropriate sub-task implementations.

Although it is possible to use extensible visitor here to automate the dispatching, it is better to start with explicit match statements first, and only consider refactoring it once you start seeing many repetitive matches with the same pattern. Furthermore, I have not yet implemented the fully generalized version of #[cgp_dispatch] to support dispatching on CGP traits. The current implementation of #[cgp_dispatch] specifically only support vanilla Rust traits, not CGP traits, to handle the use cases for Rust programmers who are only interested in dispatching vanilla Rust traits without adopting CGP.

In the example, I also use derive_delegate to derive the UseDelegate dispatcher that can perform static dispatch based on the TaskSpec generic parameter. With that, you gain the flexibility of to use custom providers to handle different task specs. For example:

delegate_components! {
    AppComponents {
        EmployerTaskQuerierComponent:
            UseDelegate<new EmployerTaskQuerierComponents {
                EmployerChecks:
                    DefaultEmployerTaskQuerier, // todo: replace with a different provider
                CheckMissingContributionPaymentInfo:
                    DefaultEmployerTaskQuerier, // todo: replace with a different provider
                CheckForIncompleteBillingInfoMissingContact:
                    DefaultEmployerTaskQuerier, // todo: replace with a different provider
                // todo: add new tasks here
            }>,
    }
}

I hope that the explanation is clear enough. This is one of the more advanced CGP patterns that I still haven't written any documentation or blog posts. Feel free to ask me to clarify anything, if it is still confusing to you.

[soareschen]

Btw, to use the main branch of cgp, you'd also need to add the following to the [patch.crates-io] section:

[patch.crates-io]
cgp                         = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-core                    = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-extra                   = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-async                   = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-async-macro             = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-component               = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-macro                   = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-macro-lib               = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-extra-macro             = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-extra-macro-lib         = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-type                    = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-field                   = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-error                   = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-error-extra             = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-run                     = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-runtime                 = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-sync                    = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-inner                   = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-handler                 = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-monad                   = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-dispatch                = { git = "https://github.com/contextgeneric/cgp.git" }
cgp-error-anyhow            = { git = "https://github.com/contextgeneric/cgp.git" }

The project uses lazy binding even for crate dependencies. It is currently a bit tedious due to breaking changes. But the idea is that once the project is fully stabilized, you will be able to override a specific sub-crate in CGP without having to fork the entire cgp project.

[rsfunc]

Thanks will try this weekend ! I have been a bit lazy ( newborn child here )... But I am very pleased with your fast and extensive help! I really think that cgp will really help in my projects. I currently use entrait crate... since it was easier to implement... but also I am already touching the boundaries of it... thats why came back to gcp and do a better reading... and.I see only more ways to use it ;) my compliments!

[soareschen]

Glad to hear that, and congrats for your newborn! Please feel free to ask for clarification, especially on cases that are not covered or explained properly by the current documentation. There are too many things to explain, and I haven't manage to find enough time to cover the basic documentation and tutorials.

[rsfunc]

Qua design it is indeed what I missed a bit.. calling cgp traits..

For now, I get the error,

delegate_and_check_components! {
    CanDoApp for App;
    AppComponents {
        // Use the default provider to implement `EmployerTaskQuerierComponent`
        EmployerTaskQuerierComponent: DefaultEmployerTaskQuerier,
        GdpComponent: GdpInlineProvider,
        ActuCompComponent: ActuCompRest,
        PensifyHrisComponent: PensifyHrisInlineProvider,
        SmsComponent : SmsTwillioProvider,
        QuestionnairesComponent: QuestionnairesDefaultProvider,
        QuestionnaireSectionsComponent: QuestionnaireSectionsDefaultProvider,
    }
}

I get

   --> apps/src/bin/apps.rs:281:9
    |
281 |         EmployerTaskQuerierComponent: DefaultEmployerTaskQuerier,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `cgp::prelude::IsProviderFor<EmployerTaskQuerierComponent, App>` is not implemented for `DefaultEmployerTaskQuerier`
    |
    = note: You need to add `#[cgp_provider(EmployerTaskQuerierComponent)]` on the impl block for CGP provider traits
    = help: the following other types implement trait `cgp::prelude::IsProviderFor<Component, Context, Params>`:
              `DefaultEmployerTaskQuerier` implements `cgp::prelude::IsProviderFor<EmployerTaskQuerierComponent, Context, EmployerChecks>`
              `DefaultEmployerTaskQuerier` implements `cgp::prelude::IsProviderFor<EmployerTaskQuerierComponent, Context, p_employer_forms::api::tasks::provider::CheckForIncompleteBillingInfoMissingContact>`
              `DefaultEmployerTaskQuerier` implements `cgp::prelude::IsProviderFor<EmployerTaskQuerierComponent, Context, p_employer_forms::api::tasks::provider::CheckMissingContributionPaymentInfo>`
note: required for `AppComponents` to implement `cgp::prelude::IsProviderFor<EmployerTaskQuerierComponent, App>`
   --> apps/src/bin/apps.rs:277:1

So, I see the expected implementations.
further it notes

note: required for `App` to implement `cgp::prelude::CanUseComponent<EmployerTaskQuerierComponent>`
note: required by a bound in `CanDoApp`

I guess unrelated, but for I call it via the following code,

/// lets try v2 using cgp
pub async fn check_tasks_by_employer_id_v2(
    deps: &(impl SupportsPensifyHris + CanQueryEmployerTasks<EmployerChecks>),
    claims: ClaimsWrapper,
    employer_id: Uuid,
) -> GetIssueResult<Vec<AppTask>> {
    let employer = deps.get_pensify_employer(claims.check_if_entity_id_is_in_scope(employer_id)?).await?;
    Ok(deps
        .query_employer_tasks(
            // just one check for now
            &EmployerChecks::CheckMissingContributionPaymentInfo(CheckMissingContributionPaymentInfo),
            &employer,
        )
        .await?)
}

Here, essentially your example, I tried to put all the related code in one mod

use cgp::prelude::*;
use p_domain_hris::Employer;
use p_domain_payments::IsComplete;
use p_domain_tasks::AppTask;
use p_domain_tasks::EmployerTaskParam;
use p_poem_pensify::providers::SupportsPensifyHris;

// A task spec for checking incomplete billing info with a missing contact.
pub struct CheckForIncompleteBillingInfoMissingContact;

// A task spec for checking missing contribution payment info.
pub struct CheckMissingContributionPaymentInfo;

// A combined task spec that allows multiple kinds of employer checks.
pub enum EmployerChecks {
    CheckForIncompleteBillingInfoMissingContact(CheckForIncompleteBillingInfoMissingContact),
    CheckMissingContributionPaymentInfo(CheckMissingContributionPaymentInfo),
}

// A default provider that implements `EmployerTaskQuerier`.
// We can also define separate providers to implement `EmployerTaskQuerier` for each task spec,
// but we will share the same provider in this example for simplicity.
pub struct DefaultEmployerTaskQuerier;

#[cgp_provider]
impl<Context> EmployerTaskQuerier<Context, CheckForIncompleteBillingInfoMissingContact> for DefaultEmployerTaskQuerier
where
    Context: SupportsPensifyHris + Async,
{
    async fn query_employer_tasks(
        context: &Context,
        spec: &CheckForIncompleteBillingInfoMissingContact,
        employer: &Employer,
    ) -> anyhow::Result<Vec<AppTask>> {
        Ok(if !context.get_employer_attributes(employer.employer_id).await?.billing.is_complete() {
            vec![AppTask::IncompleteBillingInfoMissingContact(EmployerTaskParam::from(employer.clone()).into())]
        } else {
            vec![]
        })
    }
}

#[cgp_provider]
impl<Context> EmployerTaskQuerier<Context, CheckMissingContributionPaymentInfo> for DefaultEmployerTaskQuerier
where
    Context: SupportsPensifyHris + Async,
{
    async fn query_employer_tasks(
        context: &Context,
        spec: &CheckMissingContributionPaymentInfo,
        employer: &Employer,
    ) -> Result<Vec<AppTask>, anyhow::Error> {
        Ok(if !context.get_employer_attributes(employer.employer_id).await?.contributions_payment_info.is_complete() {
            vec![AppTask::MissingContributionPaymentInfo(EmployerTaskParam::from(employer.clone()).into())]
        } else {
            vec![]
        })
    }
}

// Implements `EmployerTaskQuerier` for `EmployerChecks` by delegating it to other
// queriers
#[cgp_provider]
impl<Context> EmployerTaskQuerier<Context, EmployerChecks> for DefaultEmployerTaskQuerier
where
    // Use the context to look up for the implementation for subtasks,
    // so that alternative providers may be wired with it.
    Context: CanQueryEmployerTasks<CheckForIncompleteBillingInfoMissingContact>
        + CanQueryEmployerTasks<CheckMissingContributionPaymentInfo>,
{
    async fn query_employer_tasks(
        context: &Context,
        spec: &EmployerChecks,
        employer: &Employer,
    ) -> Result<Vec<AppTask>, anyhow::Error> {
        // We can later use the extensible visitor pattern to handle the dispatching.
        // But it is better to start with an explicit match for clarity.
        match spec {
            EmployerChecks::CheckMissingContributionPaymentInfo(spec) => {
                context.query_employer_tasks(spec, employer).await
            }
            EmployerChecks::CheckForIncompleteBillingInfoMissingContact(spec) => {
                context.query_employer_tasks(spec, employer).await
            }
        }
    }
}

// A generic employer task querier that can perform queries based on a given `TaskSpec`.
#[cgp_component {
    provider: EmployerTaskQuerier,
    derive_delegate: UseDelegate<TaskSpec>, // Implement the `UseDelegate` dispatcher based on `TaskSpec`
    }]
#[async_trait]
pub trait CanQueryEmployerTasks<TaskSpec: Async>: Async {
    async fn query_employer_tasks(&self, spec: &TaskSpec, employer: &Employer) -> anyhow::Result<Vec<AppTask>>;
}