Lucas.Xu d842f228e8
feat: Integrate supabase (#2551)
* feat: integrate supabase auth service

* chore: ignore the sercet

* feat: separate and inject the auth service

* chore: integrate auth service into sign in/up page

* feat: integrate github and google sign in

* chore: update user trait

* feat: box any params in UserCloudService trait

* feat: add flowy-server crate

* refactor: user trait

* docs: doc ThirdPartyAuthPB

* feat: server provider

* feat: pass the uuid to rust side

* feat: pass supabase config to rust side

* feat: integrate env file

* feat: implement login as guest

* feat: impl postgrest

* test: use env

* chore: upper case key

* feat: optimize the file storage

* fix: don't call set auth when user login in local

* docs: add docs

* feat: create/update/get user using postgrest

* feat: optimize the login as guest

* feat: create user workspace

* feat: create user default workspace

* feat: redesign the setting path location page

* feat: use uuid as view id

* feat: send auth info to rust backend

* fix: sign up

* fix: skip to wrong page after login

* fix: integrate test error

* fix: indent command error

* feat: add discord login in type

* fix: flutter analyze

* ci: fix rust tests

* ci: fix tauri build

* ci: fix tauri build

---------

Co-authored-by: nathan <nathan@appflowy.io>
2023-05-21 18:53:59 +08:00

54 lines
995 B
Rust

use std::any::Any;
use anyhow::Result;
pub struct BoxAny(Box<dyn Any + Send + Sync + 'static>);
impl BoxAny {
pub fn new<T>(value: T) -> Self
where
T: Send + Sync + 'static,
{
Self(Box::new(value))
}
pub fn unbox_or_default<T>(self) -> T
where
T: Default + 'static,
{
match self.0.downcast::<T>() {
Ok(value) => *value,
Err(_) => T::default(),
}
}
pub fn unbox_or_error<T>(self) -> Result<T>
where
T: Default + 'static,
{
match self.0.downcast::<T>() {
Ok(value) => Ok(*value),
Err(e) => Err(anyhow::anyhow!(
"downcast error to {} failed: {:?}",
std::any::type_name::<T>(),
e
)),
}
}
pub fn unbox_or_none<T>(self) -> Option<T>
where
T: Default + 'static,
{
match self.0.downcast::<T>() {
Ok(value) => Some(*value),
Err(_) => None,
}
}
#[allow(dead_code)]
pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
self.0.downcast_ref()
}
}