PhantomData<State> with query_as macro

[woile]

Hi everyone, I'm trying to use the "type state pattern" with query_as!, but I cannot make it work. Has anyone had any success?

My end goal would be to have the create method only for new users, and later I'd like to add update for an existing.

use std::marker::PhantomData;

use crate::UserCreate;
use serde::{Deserialize, Serialize};

use sqlx::{ Database, Decode, SqlitePool};

#[derive(Debug, Clone)]
pub struct Existing;

#[derive(Debug, Clone)]
pub struct New;

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct User<State = New> {
    pub username: String,
    #[serde(skip_serializing)]
    state: PhantomData<State>,
}

impl User<New> {
    fn create(pool: &SqlitePool) -> Result<User<Existing>, sqlx::Error> {
        let username = String::from("foo");
        let user: User<Existing> = sqlx::query_as!(
            User,
            r#"
            INSERT INTO users__users (username)
            VALUES ($1)
            RETURNING username, 'new' as "state: PhantomData<Existing>"
            "#,
            username,
        )
        .fetch_one(pool)
        .await?;
        Ok(user)
    }
}

I get:

the trait bound `PhantomData<_>: sqlx::Decode<'_, Sqlite>` is not satisfied
the following other types implement trait `sqlx::Decode<'r, DB>`:

And I think I cannot implement PhantomData for sqlx::Decode because it's a foreign type 🤔

[wvffle]

I am also struggling with that, have you resolved it @woile?

[woile]

I did not find a way, I realized in the end an existing user may not be the same as a new user. So it's better to have different structs.
I've started using a similar approach to Django's managers.

[woile]

Here's a raw implementation.

The idea is that you can implement QueryManager for any type you want to use with the Manager

use serde::{Deserialize, Serialize};
use sqlx::SqlitePool;

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct User {
    pub id: String,
    pub username: String,
}

pub struct NewUser(pub User);
pub struct ExistingUser(pub User);
pub struct QueryUser(pub User);

pub trait QueryManager {}

impl QueryManager for NewUser {}
impl QueryManager for ExistingUser {}
impl QueryManager for QueryUser {}

/// A user Manager.
///
/// User creation and updating
///
/// ```
/// let new_user = User {id: "123", username: "new_user".to_string()};
/// let user = Manager<NewUser>::new(pool.clone(), NewUser(new_user));
/// let mut user = user.save();
///
/// user.inner.0.username = "new_username".to_string();
/// user.save()
///
/// let mut user = Manager<ExistingUser>::get_by_id(pool, "id");
/// user.inner.0.username = "new_username2".to_string();
/// user.save()  // here you could pass a parameter
/// ```
///
/// Single from user id
///
/// ```
/// let user = Manager<ExistingUser>::get_by_id(pool, "id");
/// ```
///
/// Multiple results
///
/// ```
/// let users = Manager<QueryUser>::get_many(pool);
/// ```
pub struct Manager<Q: QueryManager> {
    pool: SqlitePool,
    inner: Q,
}

/// You can implement any method for NewUser
impl<'a> Manager<NewUser> {
    pub fn new(pool: SqlitePool, extra: NewUser) -> Manager<NewUser> {
        Manager { pool, inner: extra }
    }

    pub fn save(self) -> Manager<ExistingUser> {
        // Write to database!
        Manager {
            pool: self.pool,
            inner: ExistingUser(User {
                id: self.inner.0.id,
                username: self.inner.0.username,
            }),
        }
    }
}

/// You can implement any method for ExistingUser
impl<'a> Manager<ExistingUser> {
    pub fn get_by_id(pool: SqlitePool, id: impl AsRef<str>) -> Manager<ExistingUser> {
        // Get from database!
        todo!();
    }

    pub fn save(&self) {
        // Update the database!
        todo!();
    }
}

/// You can implement any method for QueryUser
impl<'a> Manager<QueryUser> {
    pub fn get_many(pool: SqlitePool) -> Vec<Manager<ExistingUser>> {
        // Get all from database!
        todo!();
    }
}

User creation and updating

let new_user = User {id: "123", username: "new_user".to_string()};
let user = Manager<NewUser>::new(&pool, NewUser(new_user));
let mut user = user.save();  // here we use the `save` from NewUser

user.inner.0.username = "new_username".to_string();
user.save()  // here we use the `save` from ExistingUser

let mut user = Manager<ExistingUser>::get_by_id(&pool, "id");
user.inner.0.username = "new_username2".to_string();
user.save()  // here you could pass a parameter

Single from user id

let user = Manager<ExistingUser>::get_by_id(&pool, "id");

Multiple results

let users = Manager<QueryUser>::get_many(&pool);

You may have to tweak it at will, and I think it can be further improved using Deref and Into.

Also, it may be worth exploring the replacement of QueryUser(pub User) with QueryUsers(pub Vec<User>), but I kind of like returning a vec of ExistingUsers. But I'm not sure it makes sense. You'll have to explore a bit