Adding `awto` library as a dependency

Run this command in a terminal, in your project's directory:

cargo add awto

To add it manually, edit your project's Cargo.toml file and add to the [dependencies] section:

awto = "0.1.2"

The awto library will be automatically available globally. Read the awto library documentation.

Back to the crate overview.

Readme

awto

Awtomate your 🦀 microservices with awto

What is awto?

Awto treats your rust project as the source of truth for microservices, and generates database tables and protobufs based on your schema and service.

Database Generation

Database tables are generated from your Rust structs
Changes to your structs are detected and will modify the table schema accordingly

Protobuf Generation

Generate protobuf schemas from your models
Compile a protobuf server from your app's service

Concepts

With awto, you create a Cargo workspace for each microservice. Under your workspace, you create two libs: schema and service

Schema

The schema lib's purpose is to define your microservice models which will be used to generate database tables.

// schema/src/lib.rs
use awto::prelude::*;

schema! {
    #[database_table]
    #[protobuf_message]
    pub struct Product {
        pub id: Uuid,
        pub created_at: DateTime<FixedOffset>,
        pub updated_at: DateTime<FixedOffset>,
        pub name: String,
        #[awto(max_len = 120)]
        pub description: Option<String>,
        #[awto(default = 0)]
        pub price: i64,
    }
}

See example schema in examples/ecom.

Service

The service lib is where you write your business logic. This business logic can later be used to create a protobuf API (and in the future a graphql API).

// service/src/lib.rs

register_services!(ProductService);

pub struct ProductService {
    pub conn: DatabaseConnection,
}

#[protobuf_service]
impl ProductService {
    pub async fn find_by_id(&self, request: ProductId) -> Result<Product, Status> {
        let product = product::Entity::find_by_id(request.id)
            .one(&self.conn)
            .await
            .map_err(|err| Status::internal(err.to_string()))?
            .ok_or_else(|| Status::not_found("product not found"))?;

        Ok(product.into())
    }
}

See example service in examples/ecom.

Cargo workspace

Your schema and service libs should be under a cargo workspace.

# root Cargo.toml
[workspace]
members = ["schema", "service"]

See example project in examples/ecom.

Awto CLI

Awto provides a cli for generating additional libraries with the awto compile <lib> command. Currently the available libraries are:

database - based on SeaORM, provides a database library for use in your service
protobuf - based on tonic, provides a protobuf server library

Install

The cli can be installed with:

cargo install awto-cli

This will provide a binary called awto.

Check installation with awto --help.

Compile library

To compile a library, you can run:

awto compile <output>

The available outputs currently are:

database - syncs your database with your schema and generates a lib for performing operations with the database via SeaORM.
protobuf - generates a protobuf file and lib which can be used as a protobuf server & client via tonic.

Roadmap

Awto is still in alpha stages and is made mostly as an experiment at this point. If it gets some attention, serious effort will be put into it to make it a meaningful tool for the Rust community.

Contributing

Whether you want to share ideas, bugs, suggestions, or other, your contributions to this project are welcomed 🤌

License

By contributing, you agree that your contributions will be licensed under this repository's MIT or Apache-2.0 License.

Adding awto library as a dependency

Adding `awto` library as a dependency