Cloudflare Adapter

This adapter is for use with Cloudflare Workers. It is a simple adapter that parses the request body and passes it to the framework.

Usage

This sample is based off of npm init cloudflare project_name worker-rust template.

```rust use composure_cloudflare::CloudflareInteractionBot;

use worker::*;

mod utils;

[event(fetch)]

pub async fn main(req: Request, env: Env, ctx: worker::Context) -> Result { // Optionally, get more helpful error messages written to the console in the case of a panic. utils::setpanic_hook();

let command_handler = |interaction: ApplicationCommandInteraction| async move {
    match interaction.data.name.as_str() {
        "test" => test_handler(interaction),
        "subcommand" => {
            match interaction.data.first_option().ok_or_else(|| {
                Error::RustError("expected subcommand or subcommand group".into())
            })? {
                ApplicationCommandInteractionDataOption::Subcommand(command) => {
                    match command.name.as_str() {
                        "test" => test_handler(interaction),
                        _ => unknown_handler(interaction),
                    }
                }
                ApplicationCommandInteractionDataOption::SubcommandGroup(command) => {
                    match command.name.as_str() {
                        "group" => match command.subcommand.name.as_str() {
                            "test" => test_handler(&command, &interaction),
                            _ => unknown_handler(interaction),
                        },
                        _ => unknown_handler(interaction),
                    }
                }
                _ => Err(Error::RustError("expected subcommand group".into())),
            }
        }
        _ => unknown_handler(interaction),
    }
};

// The adapter will handle the request and return a response.
CloudflareInteractionBot::new(req, env)
    .with_command_handler(|interaction| Box::pin(command_handler(interaction)))
    .process()
    .await

}

fn testhandler(command: ApplicationCommandInteraction) -> Result { let username = match command.common.member { Some(member) => match member.nick { Some(nick) => nick, None => member.user.username, }, None => "unknown user".into(), }; let response = InteractionResponse::ChannelMessageWithSource(MessageCallbackData { content: Some(format!("Hello, {}!", username)), allowedmentions: None, embeds: None, flags: None, tts: None, attachments: None, components: None, });

Ok(response)

}

fn unknownhandler(command: ApplicationCommandInteraction) -> Result { Ok(InteractionResponse::respondwithembed( Embed::new() .withdescription("Unknown command!".into()) .withcolor(0xf04747), )) }

```

Todo