pocketbase-rs 0.1.0

A simple wrapper around PocketBase's Rest API. Uses the Builder Pattern.
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

# pocketbase-rs

A *still in development* Rust API Wrapper to interact with the [PocketBase Web API](https://pocketbase.io/). 

## Note

This project is still under development, the different API methods are added when they are needed for an external project.   
Pull Requests are welcome, whether it's about adding missing methods, adding and fixing documentation, and more.   

This crate was last tested on `PocketBase` version `0.23.7`.

## Installation

Simply add this line in your `cargo.toml` file:

## Usage

The different methods are generally named the same as the official JavaScript SDK. Usage of this Rust crate is usually similiar to it.

```rust
use std::Error;

use pocketbase_rs::PocketBase;
use serde::{Deserialize, Serialize};

#[derive(Default, Serialize, Deserialize, Clone, Debug)]
pub struct Article {
  name: String,
  content: String,
}

#[tokio::main]
 async fn main() -> Result<(), Error> {
  let mut pb = PocketBase::new("http://localhost:8081");

  // Authenticate the new client

  let auth_data = pb
      .collection("_superusers")
      .auth_with_password("user@domain.com", "secure-password")
      .await?;

  // Create record

  let new_record = pb
      .collection("articles")
      .create::<Article>(Article {
          name: "Vulpes Vulpes".to_string(),
          content: "The red fox (Vulpes vulpes) is the largest of the true foxes and one of the most widely distributed members. [source: Wikipedia, the free encyclopedia]".to_string(),
      })
      .await?;

  println!("Created article: {:?}", record);

  // Get records list

  let records = pb
      .collection("articles")
      .get_list::<Article>()
      .sort("-created,id")
      .call()
      .await?;

  for record in records.items {
    println!("{record:?}");
  }

  Ok(())
}
```

## Licence

This project is free and open source. All code in this repository is dual-licensed under either:

* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
  <http://www.apache.org/licenses/LICENSE-2.0>)
* MIT license ([LICENSE-MIT](LICENSE-MIT) or
  <http://opensource.org/licenses/MIT>)

at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in Rust by Example by you, as defined in the Apache-2.0 license, shall be dually licensed as above, without any additional terms or conditions.