camel-component-api 0.6.3

Component API trait and registry for rust-camel
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

# camel-component-api

> Component API traits and extension points for rust-camel components.

## Overview

`camel-component-api` defines the core `Component`, `Endpoint`, `Consumer`, and `Producer` contracts used by component crates.

It also re-exports common types from `camel-api` and URI helpers from `camel-endpoint`, so most component crates can depend on a single API crate.

## Features

- `Component` trait for scheme-based endpoint factories
- `Endpoint`, `Consumer`, and producer context contracts
- New extension traits: `ComponentContext`, `ComponentRegistrar`, `ComponentBundle`
- `NoOpComponentContext` helper for tests and examples
- Re-exports from `camel-api` (e.g. `CamelError`, `Exchange`, `BoxProcessor`)
- Re-exports from `camel-endpoint` (`UriConfig`, `UriComponents`, `parse_uri`)

## Installation

```toml
[dependencies]
camel-component-api = "0.5"
```

## Usage

### Implementing a Custom Component

```rust
use camel_component_api::{CamelError, Component, ComponentContext, Endpoint};

pub struct MyComponent;

impl Component for MyComponent {
    fn scheme(&self) -> &str {
        "my"
    }

    fn create_endpoint(
        &self,
        uri: &str,
        _ctx: &dyn ComponentContext,
    ) -> Result<Box<dyn Endpoint>, CamelError> {
        Ok(Box::new(MyEndpoint { uri: uri.to_string() }))
    }
}

struct MyEndpoint {
    uri: String,
}

impl Endpoint for MyEndpoint {
    fn uri(&self) -> &str {
        &self.uri
    }

    fn create_consumer(&self) -> Result<Box<dyn camel_component_api::Consumer>, CamelError> {
        Err(CamelError::NotImplemented("consumer not implemented".into()))
    }

    fn create_producer(
        &self,
        _ctx: &camel_component_api::ProducerContext,
    ) -> Result<camel_component_api::BoxProcessor, CamelError> {
        Err(CamelError::NotImplemented("producer not implemented".into()))
    }
}
```

## Core Types

| Type | Description |
|---|---|
| `Component` | Factory for scheme-specific endpoints |
| `Endpoint` | Consumer/producer endpoint contract |
| `Consumer` | Pulls/receives exchanges from a source |
| `ProducerContext` | Runtime context for producer creation |
| `ConsumerContext` | Runtime context passed to consumers |
| `ComponentContext` | Read-only access to components, languages, and metrics |
| `ComponentRegistrar` | Dynamic component registration interface (`Arc<dyn Component>`) |
| `ComponentBundle` | Multi-scheme registration + TOML config contract |
| `NoOpComponentContext` | Lightweight test context with no registry lookups |

## Extension Traits

```rust
use std::sync::Arc;
use camel_component_api::{CamelError, Component, ComponentContext, ComponentBundle, ComponentRegistrar, Endpoint, NoOpComponentContext};

// ComponentContext: provided to create_endpoint
impl Component for MyComponent {
    fn scheme(&self) -> &str { "my" }

    fn create_endpoint(&self, uri: &str, ctx: &dyn ComponentContext) -> Result<Box<dyn Endpoint>, CamelError> {
        let _maybe_other = ctx.resolve_component("other");
        Ok(Box::new(MyEndpoint { uri: uri.to_string() }))
    }
}

// ComponentBundle: register multiple schemes from one config
pub struct MyBundle;

impl ComponentBundle for MyBundle {
    fn config_key() -> &'static str { "my" }

    fn from_toml(raw: toml::Value) -> Result<Self, CamelError> {
        let _ = raw;
        Ok(Self)
    }

    fn register_all(self, registrar: &mut dyn ComponentRegistrar) {
        registrar.register_component_dyn(Arc::new(MyComponent));
    }
}

// NoOpComponentContext: convenient for tests
let ctx = NoOpComponentContext;
let _endpoint = MyComponent.create_endpoint("my:foo", &ctx)?;
```

## Documentation

- API: <https://docs.rs/camel-component-api>
- Repository: <https://github.com/kennycallado/rust-camel>

## License

Apache-2.0