feat: connect settings live flow to auth api

crates/crank-registry/src/error.rs

@@ -10,6 +10,10 @@ pub enum RegistryError {
     WorkspaceNotFound { workspace_id: String },
     #[error("workspace with slug {slug} already exists")]
     WorkspaceSlugAlreadyExists { slug: String },
+    #[error("user {user_id} was not found")]
+    UserNotFound { user_id: String },
+    #[error("user with email {email} already exists")]
+    UserEmailAlreadyExists { email: String },
     #[error("invitation {invitation_id} was not found")]
     InvitationNotFound { invitation_id: String },
     #[error("platform api key {key_id} was not found")]

crates/crank-registry/src/postgres.rs

@@ -178,6 +178,81 @@ impl PostgresRegistry {
         row.as_ref().map(map_auth_user_record).transpose()
     }
 
+    pub async fn get_auth_user_by_id(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Option<AuthUserRecord>, RegistryError> {
+        let row = sqlx::query(
+            "select
+                id,
+                email,
+                display_name,
+                password_hash,
+                status,
+                to_char(created_at at time zone 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS\"Z\"') as created_at
+             from users
+             where id = $1
+             limit 1",
+        )
+        .bind(user_id.as_str())
+        .fetch_optional(&self.pool)
+        .await?;
+
+        row.as_ref().map(map_auth_user_record).transpose()
+    }
+
+    pub async fn update_user_profile(
+        &self,
+        user_id: &UserId,
+        email: &str,
+        display_name: &str,
+    ) -> Result<User, RegistryError> {
+        let row = sqlx::query(
+            "update users
+             set email = $2,
+                 display_name = $3
+             where id = $1
+             returning
+                id,
+                email,
+                display_name,
+                status,
+                to_char(created_at at time zone 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS\"Z\"') as created_at",
+        )
+        .bind(user_id.as_str())
+        .bind(email)
+        .bind(display_name)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|error| map_user_update_error(error, user_id, email))?;
+
+        map_user(&row)
+    }
+
+    pub async fn update_user_password(
+        &self,
+        user_id: &UserId,
+        password_hash: &str,
+    ) -> Result<(), RegistryError> {
+        let result = sqlx::query(
+            "update users
+             set password_hash = $2
+             where id = $1",
+        )
+        .bind(user_id.as_str())
+        .bind(password_hash)
+        .execute(&self.pool)
+        .await?;
+
+        if result.rows_affected() == 0 {
+            return Err(RegistryError::UserNotFound {
+                user_id: user_id.as_str().to_owned(),
+            });
+        }
+
+        Ok(())
+    }
+
     pub async fn create_user_session(
         &self,
         session_id: &UserSessionId,
@@ -2686,17 +2761,37 @@ fn map_membership_record(row: &PgRow) -> Result<MembershipRecord, RegistryError>
 
 fn map_auth_user_record(row: &PgRow) -> Result<AuthUserRecord, RegistryError> {
     Ok(AuthUserRecord {
-        user: User {
-            id: UserId::new(row.try_get::<String, _>("id")?),
-            email: row.try_get("email")?,
-            display_name: row.try_get("display_name")?,
-            status: deserialize_enum_text(&row.try_get::<String, _>("status")?, "status")?,
-            created_at: row.try_get("created_at")?,
-        },
+        user: map_user(row)?,
         password_hash: row.try_get("password_hash")?,
     })
 }
 
+fn map_user(row: &PgRow) -> Result<User, RegistryError> {
+    Ok(User {
+        id: UserId::new(row.try_get::<String, _>("id")?),
+        email: row.try_get("email")?,
+        display_name: row.try_get("display_name")?,
+        status: deserialize_enum_text(&row.try_get::<String, _>("status")?, "status")?,
+        created_at: row.try_get("created_at")?,
+    })
+}
+
+fn map_user_update_error(error: sqlx::Error, user_id: &UserId, email: &str) -> RegistryError {
+    match error {
+        sqlx::Error::RowNotFound => RegistryError::UserNotFound {
+            user_id: user_id.as_str().to_owned(),
+        },
+        sqlx::Error::Database(database_error)
+            if database_error.code().as_deref() == Some("23505") =>
+        {
+            RegistryError::UserEmailAlreadyExists {
+                email: email.to_owned(),
+            }
+        }
+        other => RegistryError::Storage(other),
+    }
+}
+
 fn map_invitation_record(row: &PgRow) -> Result<InvitationRecord, RegistryError> {
     Ok(InvitationRecord {
         invitation: InvitationToken {