Writing your own plugin

use pylon_plugin::{Plugin, PluginError, PluginContext, PluginRoute, RequestMeta};
use pylon_auth::AuthContext;
use serde_json::Value;

pub trait Plugin: Send + Sync {
    /// Unique name for this plugin.
    fn name(&self) -> &str;

    /// Called once when the plugin is registered.
    fn on_init(&self, _ctx: &PluginContext) {}

    /// Custom API routes this plugin handles.
    fn routes(&self) -> Vec<PluginRoute> { vec![] }

    /// Before an entity insert. Mutate `data` in place; return Err to reject.
    fn before_insert(&self, _entity: &str, _data: &mut Value, _auth: &AuthContext)
        -> Result<(), PluginError> { Ok(()) }
    fn after_insert(&self, _entity: &str, _id: &str, _data: &Value, _auth: &AuthContext) {}

    /// Before an entity update. Mutate `data`; return Err to reject.
    fn before_update(&self, _entity: &str, _id: &str, _data: &mut Value, _auth: &AuthContext)
        -> Result<(), PluginError> { Ok(()) }
    fn after_update(&self, _entity: &str, _id: &str, _data: &Value, _auth: &AuthContext) {}

    /// Before an entity delete. Return Err to reject.
    fn before_delete(&self, _entity: &str, _id: &str, _auth: &AuthContext)
        -> Result<(), PluginError> { Ok(()) }
    fn after_delete(&self, _entity: &str, _id: &str, _auth: &AuthContext) {}

    /// On every incoming request (middleware). Return Err to short-circuit.
    fn on_request(&self, _method: &str, _path: &str, _auth: &AuthContext)
        -> Result<(), PluginError> { Ok(()) }

    /// Richer variant with per-request metadata (peer IP today).
    /// Defaults to delegating to `on_request`.
    fn on_request_with_meta(&self, method: &str, path: &str, auth: &AuthContext,
        _meta: &RequestMeta<'_>) -> Result<(), PluginError> {
        self.on_request(method, path, auth)
    }

    /// When a new session is created.
    fn on_session_create(&self, _user_id: &str, _token: &str) {}

    /// Additional manifest entities this plugin contributes.
    fn entities(&self) -> Vec<pylon_kernel::ManifestEntity> { vec![] }
}

return Err(PluginError {
    code: "BLOCKED".into(),
    message: "inserts to this entity are not allowed".into(),
    status: 403,
});

use pylon_plugin::{Plugin, PluginError};
use pylon_auth::AuthContext;
use serde_json::Value;

pub struct Timestamps;

impl Plugin for Timestamps {
    fn name(&self) -> &str { "timestamps" }

    fn before_insert(
        &self,
        _entity: &str,
        data: &mut Value,
        _auth: &AuthContext,
    ) -> Result<(), PluginError> {
        if let Some(obj) = data.as_object_mut() {
            let now = chrono::Utc::now().to_rfc3339();
            if !obj.contains_key("createdAt") {
                obj.insert("createdAt".into(), Value::String(now.clone()));
            }
            obj.insert("updatedAt".into(), Value::String(now));
        }
        Ok(())
    }
}

use pylon_plugin::{Plugin, PluginError, RequestMeta};
use pylon_auth::AuthContext;

impl Plugin for MyLimiter {
    fn name(&self) -> &str { "my_limiter" }

    fn on_request_with_meta(
        &self,
        _method: &str,
        _path: &str,
        auth: &AuthContext,
        meta: &RequestMeta<'_>,
    ) -> Result<(), PluginError> {
        let key = match auth.user_id.as_ref() {
            Some(uid) => format!("user:{uid}"),
            None => format!("ip:{}", meta.peer_ip),
        };
        self.check(&key) // Err(PluginError { status: 429, .. }) if over budget
    }
}

use pylon_plugin::{Plugin, PluginRoute};

impl Plugin for MyWebhookReceiver {
    fn name(&self) -> &str { "my_webhook" }

    fn routes(&self) -> Vec<PluginRoute> {
        vec![PluginRoute {
            method: "POST".into(),
            path: "/api/webhooks/my-service".into(),
            handler: Box::new(|body, _path, _auth| {
                // verify signature, parse, dispatch...
                (200, "{}".into())
            }),
        }]
    }
}

use std::sync::Arc;
use pylon_plugin::PluginRegistry;

let mut reg = PluginRegistry::new(runtime.manifest().clone());
reg.register(Arc::new(Timestamps));
// The default runtime also registers rate_limit, tenant_scope, owner_stamp here.

#[test]
fn timestamps_stamps_on_insert() {
    let plugin = Timestamps;
    let mut data = serde_json::json!({ "title": "x" });
    plugin
        .before_insert("Post", &mut data, &AuthContext::anonymous())
        .unwrap();
    assert!(data["createdAt"].is_string());
    assert!(data["updatedAt"].is_string());
}