deeb 0.0.3

An ACID compliant JSON database built with Rust
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

# Deeb - JSON Database

Prounced `D-B`, Deeb is an Acid Compliant JSON based database for small 
websites and fast prototyping. 

Inspired by flexibility of Mongo and light weight of SqLite, Deeb is a tool 
that turns a set of JSON files into a database. 

Deeb's ability to turn groups JSON files into a database allows you to simply 
open a json file and edit as needed.

Check out the quick start below, or the [docs](https://docs.rs/deeb/latest/deeb/) 
to learn more.

## Quick Start

1. Add Deeb to your `Cargo.toml` file

```bash
cargo add deeb
```

2. Create a JSON file for your database.

```bash
echo '{"user": []}' > user.json
echo '{"comment": []}' > comment.json
```

3. Create a deed instance and perform operations

```rust
use deeb::*;
use serde_json::json;
use anyhow::Error;

#[tokio::main]
async fn main() -> Result<(), Error> {
     // Set up a new Deeb instance
    let db = Deeb::new();

    // Create a new entity
    let user = Entity::from("user");
    let comment = Entity::from("comment");

    db.add_instance("test", "./user.json", vec![user.clone()])
        .await?;
    db.add_instance("test2", "./comment.json", vec![comment.clone()])
        .await?;

    // Single Operations
    db.insert(&user, json!({"id": 1, "name": "Joey", "age": 10}), None).await?;
    db.find_one(&user, Query::eq("name", "Joey"), None).await?;

    // Perform a transaction
    let mut transaction = db.begin_transaction().await;

    // Insert data into the database
    db.insert(&user, json!({"id": 1, "name": "Steve", "age": 3}), Some(&mut transaction)).await?;
    db.insert(&user, json!({"id": 2, "name": "Johnny", "age": 3}), Some(&mut transaction)).await?;

    db.insert(&comment, json!({"user_id": 1, "comment": "Hello"}), Some(&mut transaction)).await?;
    db.insert(&comment, json!({"user_id": 1, "comment": "Hi"}), Some(&mut transaction)).await?;

    // Query the database
    let query = Query::like("name", "Steve");
    let result = db.find_one(&user, query, Some(&mut transaction)).await?;

    // Update the database
    let query = Query::ne("name", "Steve");
    let update = json!({"name": "Steve", "age": 3});
    db.update_one(&user, query, update, Some(&mut transaction)).await?;

    // Delete from the database
    let query = Query::eq("name", "Johnny");
    db.delete_one(&user, query, Some(&mut transaction)).await?;

    db.commit(&mut transaction).await?;

    Ok(())
}
```

## Features

- **ACID Compliant**: Deeb is an ACID compliant database
- **JSON Based**: Deeb uses JSON files as the database
- **Schemaless**: Deeb is schemaless
- **Transactions**: Deeb supports transactions
- **Querying**: Deeb supports querying, nested queries, and combination queries.

## Roadmap

- [x] Basic CRUD Operations
- [x] Transactions
- [ ] Indexing
- [x] Querying
- [ ] Migrations
- [x] Benchmarks
- [ ] Associations
- [x] Documentation
- [x] Tests
- [ ] Examples
- [ ] Logging
- [ ] Error Handling
- [ ] CI/CD