dog-core 0.1.5

Core traits and utilities for the DogRS ecosystem - a modular Rust framework for building scalable applications
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171








# dog-core

[![Crates.io](https://img.shields.io/crates/v/dog-core.svg)](https://crates.io/crates/dog-core)
[![Documentation](https://docs.rs/dog-core/badge.svg)](https://docs.rs/dog-core)
[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg)](LICENSE)

**Core traits and utilities for the DogRS ecosystem - a modular Rust framework for building scalable applications**

dog-core provides the foundational abstractions that power the DogRS framework: services, hooks, tenant contexts, and storage contracts. It's designed to keep your core logic clean and portable across different adapters and environments.

## Features

- **Framework-agnostic core** - No coupling to specific web frameworks or databases
- **Multi-tenant services** - Built-in tenant context for SaaS applications
- **Service hooks** - Before/after/around/error pipelines for cross-cutting concerns
- **Storage contracts** - Pluggable storage backends without vendor lock-in
- **Async-first design** - Built for modern async Rust applications

## Quick Start

Add to your `Cargo.toml`:

```toml
[dependencies]
dog-core = "0.1.0"
```

### Basic Service Example

```rust
use dog_core::{DogService, TenantContext, Result};
use async_trait::async_trait;
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct CreateUserRequest {
    name: String,
    email: String,
}

#[derive(Serialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}

struct UserService;

#[async_trait]
impl DogService<CreateUserRequest, ()> for UserService {
    type Output = User;
    
    async fn create(&self, tenant: TenantContext, data: CreateUserRequest) -> Result<User> {
        // Your business logic here
        Ok(User {
            id: 1,
            name: data.name,
            email: data.email,
        })
    }
}
```

## Core Concepts

### Services
Services implement your business logic through the `DogService` trait:

```rust
#[async_trait]
pub trait DogService<TData, TQuery> {
    type Output;
    
    async fn create(&self, tenant: TenantContext, data: TData) -> Result<Self::Output>;
    async fn read(&self, tenant: TenantContext, query: TQuery) -> Result<Self::Output>;
    async fn update(&self, tenant: TenantContext, data: TData) -> Result<Self::Output>;
    async fn delete(&self, tenant: TenantContext, query: TQuery) -> Result<()>;
}
```

### Tenant Context
Multi-tenant applications get built-in tenant isolation:

```rust
let tenant = TenantContext::new("tenant-123")
    .with_actor("user-456")
    .with_trace_id("req-789");

let result = service.create(tenant, request_data).await?;
```

### Storage Adapters
Pluggable storage without vendor lock-in:

```rust
use dog_core::{StorageAdapter, StorageResult};

#[async_trait]
impl StorageAdapter for MyDatabase {
    async fn get(&self, tenant: &TenantContext, key: &str) -> StorageResult<Option<Vec<u8>>>;
    async fn put(&self, tenant: &TenantContext, key: &str, value: Vec<u8>) -> StorageResult<()>;
    async fn delete(&self, tenant: &TenantContext, key: &str) -> StorageResult<()>;
}
```

## Architecture

dog-core follows a clean separation of concerns:

```
┌─────────────────┐
│   Your App      │  ← Business logic
└─────────────────┘
         │
    ┌────┼────┐
    │    │    │
    ▼    │    ▼
┌─────────┐ ┌─────────────┐
│dog-axum │ │dog-typedb   │  ← Adapters
│(HTTP)   │ │(DB)         │
└─────────┘ └─────────────┘
         │
         ▼
┌─────────────────┐
│   dog-blob      │  ← Object storage
│   (Storage)     │
└─────────────────┘
         │
         ▼
┌─────────────────┐
│   dog-core      │  ← Core abstractions
└─────────────────┘
```

## Ecosystem

dog-core works with these adapters:

- **[dog-axum](https://crates.io/crates/dog-axum)** - Axum web framework integration
- **[dog-typedb](https://crates.io/crates/dog-typedb)** - TypeDB database adapter
- **[dog-blob](https://crates.io/crates/dog-blob)** - Blob storage infrastructure
- **[dog-schema](https://crates.io/crates/dog-schema)** - Schema validation utilities

## Examples

See the `dog-examples/` directory for complete applications:

- **music-blobs** - Media streaming service
- **blog-axum** - REST API with CRUD operations  
- **social-typedb** - Social network with TypeDB
- **fleet-queue** - Fleet management with background jobs

## License

MIT OR Apache-2.0

---

<div align="center">

**Made by [Jitpomi](https://github.com/Jitpomi)**

</div>