uidc/src/schema.rs

pub use microrm::prelude::{Entity, Database};
use microrm::schema::{IDMap, AssocMap, Serialized, Relation, AssocDomain, AssocRange};
use serde::{Deserialize, Serialize};

use crate::key::KeyType;

// ----------------------------------------------------------------------
// uidc internal types
// ----------------------------------------------------------------------

/// Simple key-value store for persistent configuration
#[derive(Entity)]
pub struct PersistentConfig {
    #[unique]
    pub key: String,
    pub value: String,
}

// ----------------------------------------------------------------------
// Session types
// ----------------------------------------------------------------------

#[derive(Entity)]
pub struct Session {
    #[unique]
    pub session_id: String,
    pub auth: AssocMap<SessionAuth>,
    pub expiry: time::OffsetDateTime,
}

#[derive(Entity)]
pub struct SessionAuth {
    pub realm: RealmID,

    pub user: Option<UserID>,

    pub pending_user: Option<UserID>,
    pub pending_challenges: Serialized<Vec<AuthChallengeType>>,
}

#[derive(Clone, Copy, PartialEq, PartialOrd, Serialize, Deserialize, Debug)]
pub enum AuthChallengeType {
    Username,
    Password,
    TOTP,
    Grid,
    WebAuthn,
}

#[derive(Entity)]
pub struct AuthChallenge {
    #[unique]
    pub challenge_type: Serialized<AuthChallengeType>,
    pub public: Vec<u8>,
    pub secret: Vec<u8>,
    pub enabled: bool,
}

// ----------------------------------------------------------------------
// OIDC types
// ----------------------------------------------------------------------

pub struct UserGroupRelation;
impl Relation for UserGroupRelation {
    type Domain = User;
    type Range = Group;
    const NAME: &'static str = "UserGroup";
}

pub struct GroupRoleRelation;
impl Relation for GroupRoleRelation {
    type Domain = Group;
    type Range = Role;
    const NAME: &'static str = "GroupRole";
}

#[derive(Clone, Default, Entity)]
pub struct Realm {
    #[unique]
    pub shortname: String,

    pub clients: AssocMap<Client>,
    pub groups: AssocMap<Group>,
    pub keys: AssocMap<Key>,
    pub roles: AssocMap<Role>,
    pub scopes: AssocMap<Scope>,
    pub users: AssocMap<User>,
}

#[derive(Entity)]
pub struct Key {
    #[unique]
    pub key_id: String,
    pub key_type: Serialized<KeyType>,
    pub public_data: Vec<u8>,
    pub secret_data: Vec<u8>,
    pub expiry: time::OffsetDateTime,
}

#[derive(Entity)]
pub struct User {
    #[unique]
    pub username: String,
    pub auth: AssocMap<AuthChallenge>,
    pub groups: AssocDomain<UserGroupRelation>,
}

#[derive(Entity)]
pub struct Group {
    #[unique]
    pub shortname: String,
    pub users: AssocRange<UserGroupRelation>,
    pub roles: AssocDomain<GroupRoleRelation>,
}

#[derive(Entity)]
pub struct Role {
    #[unique]
    pub shortname: String,
    pub groups: AssocRange<GroupRoleRelation>,
}

/// OAuth2 client representation
#[derive(Entity)]
pub struct Client {
    #[unique]
    pub shortname: String,
    pub secret: String,
    pub key_type: Serialized<KeyType>,
    pub redirects: AssocMap<ClientRedirect>,
    pub scopes: AssocMap<Scope>,
}

#[derive(Entity)]
pub struct ClientRedirect {
    pub redirect: String,
}

/// Requested group of permissions
#[derive(Entity)]
pub struct Scope {
    #[unique]
    pub shortname: String,
    pub roles: AssocMap<Role>,
}

#[derive(Database)]
pub struct UIDCDatabase {
    pub persistent_config: IDMap<PersistentConfig>,

    pub realms: IDMap<Realm>,

    pub sessions: IDMap<Session>,
}