Prima Client Rust

An ergonomic and autogenerated database client that utilises Prisma schemas.

Installation

1. Create a prisma schema and migrate your database

2. Install the prisma-client-rust CLI

cargo install prisma-client-rust

1. Install prisma-client-rust

   • If you have cargo-edit installed, run cargo add prisma-client-rust
   • If not, add prisma-client-rust = "1.0.0' as a dependency in Cargo.toml

2. Add prisma-client-rust as a generator to your Prisma Schema

generator client { provider = "prisma-client-rust" // The folder that files should be generated to, relative to your schema output = "./db" }

1. Generate rust module with prisma-client-rust generate
2. Include the generated module in your code and connect a new Prisma client

```rs // Name of the module will be the folder specified in the generator's 'output' pub mod db;

use db::{PrismaClient}

// Any async runtime can be used, tokio is just an example

[tokio::main]

async fn main() { let client = PrismaClient::new();

await client.engine.connect();

} ```

Queries

The following examples use this schema:

```prisma datasource db { provider = "postgresql" url = env("DATABASE_URL") }

generator client { provider = "prisma-client-rust" binaryTargets = ["native"] output = "../src/db" }

model User { username String @id displayName String

posts           Post[]
comments        Comment[]

}

model Post { id String @id content String

comments Comment[] @relation()

User         User?   @relation(fields: [userUsername], references: [username])
userUsername String?

}

model Comment { id String @id

postId String
post   Post   @relation(fields: [postId], references: [id])

User         User?   @relation(fields: [userUsername], references: [username])
userUsername String?

} ```

Find

```rust pub mod db::{Post};

[tokio::main]

async fn main() { let mut client = PrismaClient::new();

client.engine.connect();

// Find a single record using a unique field
let unique_user = client
    .user()
    .find_unique(User::username().equals("some user".to_string()))
    .exec()
    .await;

// Find the first record that matches some parameters
let first_user = client
    .user()
    .find_first(vec![User::username().contains("user".to_string())])
    .exec()
    .await;

// Find all records that match some parameters
let many_users = client
    .user()
    .find_many(vec![
        // Querying on relations is also supported
        User::posts().some(vec![Post::content().contains("content".to_string())]),
    ])
    .exec()
    .await;

} ```

Create

```rust pub mod db::{PrismaClient, User, Post};

[tokio::main]

async fn main() { let mut client = PrismaClient::new();

client.engine.connect();

// Required values are passed in as separate arguments
let user = client
    .user()
    .create_one(
        User::username().set("user0".to_string()),
        User::display_name().set("User 0".to_string()),
        // Optional arguments can be added in a vector as the last parameter
        vec![],
    )
    .exec()
    .await;

let post = client
    .post()
    .create_one(
        Post::id().set("0".to_string()),
        Post::content().set("Some post content".to_string()),
        // Relations can be linked by specifying a where query
        Post::user().link(User::username().equals(user.username.to_string())),
        vec![],
    )
    .exec()
    .await;

} ```

Delete

```rust pub mod db::{PrismaClient, User, Post};

[tokio::main]

async fn main() { let mut client = PrismaClient::new();

client.engine.connect();

// Delete a single record matching a given condition (also works with find_unique)
client
    .post()
    .find_unique(Post::id().equals("0".to_string()))
    .delete()
    .exec()
    .await;

// Delete many records matching given conditions (In this case, deletes every user)
client.user().find_many(vec![]).delete().exec().await;

} ```