[macrouse] extern crate interfacerhttp;

use interfacerhttp::Result; use interfacer::http::contenttype;

[http_service]

trait MyServiceInterface { #[get("/api/user?limit={limit}&offset={offset}", contenttype::JSON)] #[except(200, contenttype::JSON)] fn getusersinfo(limit: u64, offset: u64) -> Result>;

#[put("/api/user/{uid}", content_type::JSON)]
#[expect(200)]
fn put_user_info(uid: u64, user: &User) -> Result<()>;

} ```

```rust // define service use interfacer_http::HttpService; use http::{Request, Response};

struct MyService { base_url: String, }

impl MyService { pub fn new(baseurl: Into) -> Self { Self {baseurl: base_url.into()} } }

impl HttpService for MyService { fn getbaseurl(&self) -> &str { &self.base_url } } ```

```rust // use them use crate::{MyServiceInterface, MyService}; use interfacer_http::Result;

fn main() -> Result<()> { let service = MyService::new("https://www.host.com"); let users = service.getusersinfo(0, 0)?; // async version // service.putuserinfo_async(users[0].uid, &users[0]).await? Ok(()) } ```

SQLService

```rust // define service interface

[macrouse] extern crate interfacersql;

use interfacer_sql::Result;

[sql_service]

trait MyServiceInterface { #[sql("SELECT * FROM user WHERE uid={uid}")] fn get_user(uid: u64) -> Result;

// parse by method name
#[sql]
fn get_user_by_uid(uid: u64) -> Result<User>;

} ```

```rust // define service use interfacer_sql::{SQLService, Result};

struct MyService { pool: ConnectionPool, }

impl MyService { pub fn connect(dburl: Into) -> Result { Ok(Self {pool: ConnectionPool::connect(baseurl.into())?}) } }

impl SQLService for MyService { fn get_pool(&self) -> &ConnectionPool { &self.pool } } ```

```rust // use them use crate::{MyServiceInterface, MyService}; use interfacer_sql::Result;

fn main() -> Result<()> { let service = MyService::connect("https://www.host.com")?; let users = service.getuser(0)?; // async version // service.getuser_async(0).await? Ok(()) } ```