Rust SDK

[package]
name = "omni-my-connector"
version = "0.1.0"
edition = "2024"

[dependencies]
omni-connector-sdk = { path = "../../sdk/rust" }
anyhow = "1"
async-trait = "0.1"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }

use anyhow::Result;
use omni_connector_sdk::serve;

use my_connector::MyConnector;

#[tokio::main]
async fn main() -> Result<()> {
    serve(MyConnector).await
}

use anyhow::{Context, Result};
use async_trait::async_trait;
use omni_connector_sdk::{
    Connector, ServiceCredential, Source, SourceType, SyncContext, SyncType,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Deserialize, Serialize)]
struct MyConfig {
    api_url: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
struct MyCredentials {
    api_key: String,
}

#[derive(Debug, Clone, Default, Deserialize, Serialize)]
struct MyCheckpoint {
    cursor: Option<String>,
}

struct MyConnector;

#[async_trait]
impl Connector for MyConnector {
    type Config = MyConfig;
    type Credentials = MyCredentials;
    type State = MyCheckpoint;

    fn name(&self) -> &'static str {
        "my_connector"
    }

    fn version(&self) -> &'static str {
        env!("CARGO_PKG_VERSION")
    }

    fn display_name(&self) -> String {
        "My Connector".to_string()
    }

    fn source_types(&self) -> Vec<SourceType> {
        vec![SourceType::Web]
    }

    fn sync_modes(&self) -> Vec<SyncType> {
        vec![SyncType::Full, SyncType::Incremental]
    }

    async fn sync(
        &self,
        source: Source,
        credentials: Option<ServiceCredential>,
        checkpoint: Option<Self::State>,
        ctx: SyncContext,
    ) -> Result<()> {
        let config: MyConfig = serde_json::from_value(source.config)
            .context("failed to decode source config")?;
        let creds = credentials.context("credentials are required")?;
        let creds: MyCredentials = serde_json::from_value(creds.credentials)
            .context("failed to decode credentials")?;

        run_sync(config, creds, checkpoint.unwrap_or_default(), ctx).await
    }
}

use anyhow::Result;
use omni_connector_sdk::{
    ConnectorEvent, DocumentMetadata, DocumentPermissions, SourceType, SyncContext,
};
use serde_json::json;

async fn emit_one(ctx: &SyncContext) -> Result<()> {
    let content_id = ctx.store_content("Hello from my data source").await?;
    let external_id = "item-123".to_string();

    ctx.emit_event(ConnectorEvent::DocumentCreated {
        sync_run_id: ctx.sync_run_id().to_string(),
        source_id: ctx.source_id().to_string(),
        document_id: external_id.clone(),
        content_id,
        metadata: DocumentMetadata {
            title: Some("Example item".to_string()),
            author: None,
            created_at: None,
            updated_at: None,
            content_type: Some("text/plain".to_string()),
            mime_type: Some("text/plain".to_string()),
            size: None,
            url: Some("https://example.com/items/123".to_string()),
            path: None,
            extra: None,
        },
        permissions: DocumentPermissions {
            public: true,
            users: vec![],
            groups: vec![],
        },
        attributes: Some([
            ("source_type".to_string(), json!(SourceType::Web)),
        ].into_iter().collect()),
    }).await?;

    ctx.increment_scanned(1).await?;
    ctx.increment_updated(1).await?;
    Ok(())
}

let checkpoint = serde_json::json!({ "cursor": next_cursor });
ctx.save_checkpoint(checkpoint).await?;

use anyhow::{anyhow, Result};
use axum::http::StatusCode;
use omni_connector_sdk::{ActionDefinition, ActionMode, ActionResponse, Connector, SourceType};
use serde_json::{json, Value as JsonValue};

fn actions(&self) -> Vec<ActionDefinition> {
    vec![ActionDefinition {
        name: "validate_connection".to_string(),
        description: "Validate connector credentials".to_string(),
        input_schema: json!({ "type": "object", "properties": {} }),
        mode: ActionMode::Read,
        source_types: vec![SourceType::Web],
        admin_only: false,
        hidden: true,
    }]
}

async fn execute_action(
    &self,
    action: &str,
    _params: JsonValue,
    _credentials: Option<omni_connector_sdk::ServiceCredential>,
) -> Result<axum::response::Response> {
    match action {
        "validate_connection" => Ok(ActionResponse::success(json!({ "ok": true })).into_response()),
        other => Ok(ActionResponse::not_supported(other)
            .into_response_with_status(StatusCode::NOT_FOUND)),
    }
}

use omni_connector_sdk::SearchOperator;

fn search_operators(&self) -> Vec<SearchOperator> {
    vec![SearchOperator {
        operator: "project".to_string(),
        attribute_key: "project_id".to_string(),
        value_type: "text".to_string(),
    }]
}