Experimental data model

src/api_v1/mod.rs

@@ -1,6 +1,6 @@
 mod user;
 
-use crate::api_v1::user::handle_user_info;
+use crate::api_v1::user::{handle_user_info, handle_user_info_self};
 use crate::service::MagnetarService;
 use crate::web::auth;
 use crate::web::auth::AuthState;
@@ -11,7 +11,8 @@ use std::sync::Arc;
 
 pub fn create_api_router(service: Arc<MagnetarService>) -> Router {
     Router::new()
-        .route("/user/@self", get(handle_user_info))
+        .route("/users/@self", get(handle_user_info_self))
+        .route("/users/:id", get(handle_user_info))
         .layer(from_fn_with_state(
             AuthState::new(service.clone()),
             auth::auth,

src/api_v1/user.rs

@@ -1,18 +1,36 @@
 use crate::service::MagnetarService;
-use crate::web::auth::AuthenticatedUser;
+use crate::web::auth::{AuthenticatedUser, MaybeUser};
 use crate::web::ApiError;
-use axum::extract::State;
+use axum::extract::{Path, Query, State};
-use axum::response::IntoResponse;
 use axum::Json;
+use magnetar_sdk::endpoints::user::{GetUserById, GetUserSelf, UserByIdReq, UserSelfReq};
+use magnetar_sdk::endpoints::{Req, Res};
 use std::sync::Arc;
 
-// TODO: Not a real endpoint
+pub async fn handle_user_info_self(
-pub async fn handle_user_info(
+    Query(UserSelfReq {
-    State(service): State<Arc<MagnetarService>>,
+        detail: _,
-    AuthenticatedUser(user): AuthenticatedUser,
+        pins: _,
-) -> Result<impl IntoResponse, ApiError> {
+        profile: _,
-    let db = service.db.clone();
+        secrets: _,
-    let user = db.get_user_by_id(&user.id).await?;
+    }): Query<Req<GetUserSelf>>,
-
+    State(_service): State<Arc<MagnetarService>>,
-    Ok(Json(user))
+    AuthenticatedUser(_user): AuthenticatedUser,
+) -> Result<Json<Res<GetUserSelf>>, ApiError> {
+    todo!()
+}
+
+pub async fn handle_user_info(
+    Path(_id): Path<String>,
+    Query(UserByIdReq {
+        detail: _,
+        pins: _,
+        profile: _,
+        relation: _,
+        auth: _,
+    }): Query<Req<GetUserById>>,
+    State(_service): State<Arc<MagnetarService>>,
+    MaybeUser(_user): MaybeUser,
+) -> Result<Json<Res<GetUserById>>, ApiError> {
+    todo!()
 }

src/main.rs

@@ -1,4 +1,5 @@
 mod api_v1;
+pub mod model;
 pub mod nodeinfo;
 pub mod service;
 pub mod util;

src/model/data/drive.rs

@@ -0,0 +1,27 @@
+use magnetar_calckey_model::ck;
+use magnetar_sdk::types::drive::DriveFileBase;
+
+use crate::model::{PackBase, PackExtract, PackType, PackingContext};
+
+impl PackType for PackExtract<DriveFileBase> {
+    type Input = PackBase<ck::drive_file::Model>;
+
+    fn extract(context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackBase(file) = data;
+
+        PackExtract(DriveFileBase {
+            name: file.name,
+            created_at: file.created_at.into(),
+            size: file.size as u64,
+            sha256: todo!(),
+            mime_type: file.r#type,
+            image_meta: todo!(),
+            url: Some(file.url),
+            thumbnail_url: file.thumbnail_url,
+            sensitive: file.is_sensitive,
+            comment: file.comment,
+            folder_id: file.folder_id,
+            user_id: file.user_id,
+        })
+    }
+}

src/model/data/emoji.rs

@@ -0,0 +1,19 @@
+use crate::model::{PackBase, PackExtract, PackType, PackingContext};
+use magnetar_calckey_model::ck;
+use magnetar_sdk::types::emoji::EmojiBase;
+
+impl PackType for PackExtract<EmojiBase> {
+    type Input = PackBase<ck::emoji::Model>;
+
+    fn extract(_context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackBase(model) = data;
+
+        PackExtract(EmojiBase {
+            shortcode: model.name.clone(),
+            category: model.category.clone(),
+            url: model.public_url.clone(),
+            width: model.width,
+            height: model.height,
+        })
+    }
+}

src/model/data/id.rs

@@ -0,0 +1,19 @@
+use magnetar_calckey_model::ck;
+
+pub trait BaseId: 'static {
+    fn get_id(&self) -> &str;
+}
+
+macro_rules! impl_id {
+    ($id:ty) => {
+        impl BaseId for $id {
+            fn get_id(&self) -> &str {
+                &self.id
+            }
+        }
+    };
+}
+
+impl_id!(ck::emoji::Model);
+impl_id!(ck::user::Model);
+impl_id!(ck::note::Model);

src/model/data/mod.rs

@@ -0,0 +1,5 @@
+pub mod drive;
+pub mod emoji;
+pub mod id;
+pub mod note;
+pub mod user;

src/model/data/note.rs

@@ -0,0 +1,87 @@
+use magnetar_calckey_model::ck;
+use magnetar_sdk::types::{
+    drive::PackDriveFileBase,
+    emoji::EmojiContext,
+    note::{NoteAttachmentExt, NoteBase, NoteVisibility, PackReactionBase, ReactionBase},
+    user::UserBase,
+};
+
+use crate::model::{
+    LinkAuto, PackAggregate, PackBase, PackChild, PackExtract, PackMulti, PackPacked, PackType,
+    PackingContext,
+};
+
+impl PackType for PackExtract<ReactionBase> {
+    type Input = PackBase<ck::note_reaction::Model>;
+
+    fn extract(_context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackBase(reaction) = data;
+
+        PackExtract(ReactionBase {
+            created_at: reaction.created_at.into(),
+            user_id: reaction.user_id,
+        })
+    }
+}
+
+impl PackType for PackExtract<NoteBase> {
+    type Input = PackMulti<(
+        PackBase<ck::note::Model>,
+        PackAggregate<PackChild<PackPacked<PackReactionBase>, LinkAuto>>,
+        PackChild<PackExtract<EmojiContext>, LinkAuto>,
+        PackChild<PackExtract<UserBase>, LinkAuto>,
+    )>;
+
+    fn extract(_context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackMulti((
+            PackBase(note),
+            PackAggregate(reactions, ..),
+            PackChild(PackExtract(emojis), ..),
+            PackChild(PackExtract(user), ..),
+        )) = data;
+
+        let reactions = reactions
+            .into_iter()
+            .map(|PackChild(PackPacked(t, ..), ..)| t)
+            .collect::<Vec<_>>();
+
+        use ck::sea_orm_active_enums::NoteVisibilityEnum as NVE;
+        PackExtract(NoteBase {
+            created_at: note.created_at.into(),
+            cw: note.cw,
+            uri: note.uri,
+            url: note.url,
+            text: note.text.unwrap_or_default(),
+            visibility: match note.visibility {
+                NVE::Followers => NoteVisibility::Followers,
+                NVE::Hidden => NoteVisibility::Direct,
+                NVE::Public => NoteVisibility::Public,
+                NVE::Home => NoteVisibility::Home,
+                NVE::Specified => NoteVisibility::Direct,
+            },
+            user: Box::new(user),
+            parent_note_id: note.reply_id,
+            renoted_note_id: note.renote_id,
+            reply_count: note.replies_count as u64,
+            renote_count: note.renote_count as u64,
+            hashtags: note.tags,
+            reactions,
+            emojis,
+            local_only: note.local_only,
+        })
+    }
+}
+
+impl PackType for PackExtract<NoteAttachmentExt> {
+    type Input = PackMulti<(
+        PackBase<ck::note::Model>,
+        PackAggregate<PackChild<PackPacked<PackDriveFileBase>, LinkAuto>>,
+    )>;
+
+    fn extract(_context: &PackingContext<Self>, data: Self::Input) -> Self {
+        PackExtract(NoteAttachmentExt {
+            attachments: todo!(),
+            poll: todo!(),
+        })
+    }
+}

src/model/data/user.rs

@@ -0,0 +1,260 @@
+use magnetar_calckey_model::ck;
+use magnetar_calckey_model::ck::sea_orm_active_enums::UserProfileFfvisibilityEnum;
+use magnetar_sdk::types::emoji::{EmojiContext, PackEmojiBase};
+use magnetar_sdk::types::note::PackNoteWithAttachments;
+use magnetar_sdk::types::user::{
+    AvatarDecoration, PackSecurityKeyBase, SecurityKeyBase, SpeechTransform, UserBase,
+    UserDetailExt, UserProfileExt, UserProfilePinsEx, UserRelationExt, UserSecretsExt,
+};
+
+use crate::model::{
+    LinkAuto, LinkIdent, PackAggregate, PackBase, PackChild, PackExtract, PackMaybe, PackMulti,
+    PackPacked, PackType, PackingContext,
+};
+
+impl PackType for PackExtract<EmojiContext> {
+    type Input = PackMulti<(
+        PackBase<ck::user::Model>,
+        PackChild<PackAggregate<PackPacked<PackEmojiBase>>, LinkAuto>,
+    )>;
+
+    fn extract(_context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackMulti((PackBase(_), PackChild(PackAggregate(emojis), ..))) = data;
+
+        PackExtract(EmojiContext(
+            emojis
+                .into_iter()
+                .map(|PackPacked(t, ..)| t)
+                .collect::<Vec<_>>(),
+        ))
+    }
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+pub struct UserAvatarLink;
+impl From<UserAvatarLink> for LinkIdent {
+    fn from(_: UserAvatarLink) -> Self {
+        LinkIdent::Named("avatar".to_string())
+    }
+}
+
+impl PackType for PackExtract<UserBase> {
+    type Input = PackMulti<(
+        PackBase<ck::user::Model>,
+        PackChild<PackMaybe<PackBase<ck::drive_file::Model>>, UserAvatarLink>,
+        PackChild<PackExtract<EmojiContext>, LinkAuto>,
+    )>;
+
+    fn extract(_context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackMulti((
+            PackBase(ref user),
+            PackChild(PackMaybe(ref avatar), _),
+            PackChild(PackExtract(ref emoji_context), _),
+        )) = data;
+
+        let avatar = avatar.as_ref().map(|PackBase(v)| v);
+
+        PackExtract(UserBase {
+            acct: user
+                .host
+                .as_ref()
+                .map(|host| format!("@{}@{}", user.username, host))
+                .unwrap_or_else(|| format!("@{}", user.username)),
+            username: user.username.clone(),
+            display_name: user.name.clone().unwrap_or_else(|| user.username.clone()),
+            host: user.host.clone(),
+            speech_transform: if user.is_cat && user.speak_as_cat {
+                SpeechTransform::Cat
+            } else {
+                SpeechTransform::None
+            },
+            created_at: user.created_at.into(),
+            avatar_url: avatar.map(|v| v.url.clone()),
+            avatar_blurhash: avatar.and_then(|v| v.blurhash.clone()),
+            avatar_color: None,
+            avatar_decoration: if user.is_cat {
+                AvatarDecoration::CatEars
+            } else {
+                AvatarDecoration::None
+            },
+            is_admin: user.is_admin,
+            is_moderator: user.is_moderator,
+            is_bot: user.is_bot,
+            emojis: emoji_context.clone(),
+        })
+    }
+}
+
+impl PackType for PackExtract<UserProfileExt> {
+    type Input = PackMulti<(
+        PackBase<ck::user::Model>,
+        PackChild<PackBase<ck::user_profile::Model>, LinkAuto>,
+        PackMaybe<PackExtract<UserRelationExt>>,
+    )>;
+
+    fn extract(context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackMulti((
+            PackBase(ref user),
+            PackChild(PackBase(ref profile), ..),
+            PackMaybe(ref relation),
+        )) = data;
+
+        let relation = relation.as_ref().map(|PackExtract(v)| v);
+
+        let follow_visibility = match profile.ff_visibility {
+            UserProfileFfvisibilityEnum::Public => true,
+            UserProfileFfvisibilityEnum::Followers => {
+                relation.as_ref().is_some_and(|r| r.follows_you)
+            }
+            UserProfileFfvisibilityEnum::Private => false,
+        } || context.is_self(user);
+
+        PackExtract(UserProfileExt {
+            is_locked: user.is_locked,
+            is_silenced: user.is_silenced,
+            is_suspended: user.is_suspended,
+            description: profile.description.clone(),
+            location: profile.location.clone(),
+            birthday: profile
+                .birthday
+                .clone()
+                .and_then(|b| b.parse().map_or_else(|_| None, Some)),
+            fields: serde_json::from_value(profile.fields.clone()).unwrap_or_else(|_| Vec::new()),
+            follower_count: follow_visibility.then_some(user.followers_count as u64),
+            following_count: follow_visibility.then_some(user.following_count as u64),
+            note_count: Some(user.notes_count as u64),
+            url: profile.url.clone(),
+            moved_to_uri: user.moved_to_uri.clone(),
+            also_known_as: user.also_known_as.clone(),
+            banner_url: None,
+            banner_color: None,
+            banner_blurhash: None,
+            has_public_reactions: profile.public_reactions,
+        })
+    }
+}
+
+impl PackType for PackExtract<UserDetailExt> {
+    type Input = PackBase<ck::user::Model>;
+
+    fn extract(_context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackBase(model) = data;
+
+        PackExtract(UserDetailExt {
+            last_fetched_at: model.last_fetched_at.map(Into::into),
+            uri: model.uri.clone(),
+            updated_at: model.updated_at.map(Into::into),
+        })
+    }
+}
+
+impl PackType for PackExtract<UserRelationExt> {
+    type Input = PackMulti<(
+        PackChild<PackBase<ck::following::Model>, LinkAuto>,
+        PackChild<PackBase<ck::blocking::Model>, LinkAuto>,
+        PackChild<PackBase<ck::muting::Model>, LinkAuto>,
+        PackChild<PackBase<ck::renote_muting::Model>, LinkAuto>,
+    )>;
+
+    fn extract(context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackMulti((
+            PackChild(PackBase(ref follow), ..),
+            PackChild(PackBase(ref block), ..),
+            PackChild(PackBase(ref mute), ..),
+            PackChild(PackBase(ref renote_mute), ..),
+        )) = data;
+
+        let self_user = context.self_user();
+
+        PackExtract(UserRelationExt {
+            follows_you: self_user.is_some_and(|self_user| {
+                self_user.id == follow.followee_id && self_user.id != follow.follower_id
+            }),
+            you_follow: self_user.is_some_and(|self_user| {
+                self_user.id == follow.follower_id && self_user.id != follow.followee_id
+            }),
+            blocks_you: self_user.is_some_and(|self_user| {
+                self_user.id == block.blockee_id && self_user.id != block.blocker_id
+            }),
+            you_block: self_user.is_some_and(|self_user| {
+                self_user.id == block.blocker_id && self_user.id != block.blockee_id
+            }),
+            mute: self_user.is_some_and(|self_user| {
+                self_user.id == mute.muter_id && self_user.id != mute.mutee_id
+            }),
+            mute_renotes: self_user.is_some_and(|self_user| {
+                self_user.id == renote_mute.muter_id && self_user.id != renote_mute.mutee_id
+            }),
+        })
+    }
+}
+
+impl PackType for PackExtract<UserProfilePinsEx> {
+    type Input = PackMulti<(
+        PackBase<ck::user::Model>,
+        PackChild<
+            PackAggregate<
+                PackMulti<(
+                    PackBase<ck::user_note_pining::Model>,
+                    PackChild<PackPacked<PackNoteWithAttachments>, LinkAuto>,
+                )>,
+            >,
+            LinkAuto,
+        >,
+    )>;
+
+    fn extract(_context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackMulti((PackBase(_), PackChild(PackAggregate(pins), ..))) = data;
+
+        PackExtract(UserProfilePinsEx {
+            pinned_notes: pins
+                .into_iter()
+                .map(|PackMulti((_, PackChild(PackPacked(note, ..), ..)))| note)
+                .collect(),
+        })
+    }
+}
+
+impl PackType for PackExtract<SecurityKeyBase> {
+    type Input = PackBase<ck::user_security_key::Model>;
+
+    fn extract(_context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackBase(model) = data;
+
+        PackExtract(SecurityKeyBase {
+            name: model.name.clone(),
+            last_used_at: Some(model.last_used.into()),
+        })
+    }
+}
+
+impl PackType for PackExtract<UserSecretsExt> {
+    type Input = PackMulti<(
+        PackBase<ck::user::Model>,
+        PackChild<
+            PackMulti<(
+                PackBase<ck::user_profile::Model>,
+                PackChild<PackAggregate<PackPacked<PackSecurityKeyBase>>, LinkAuto>,
+            )>,
+            LinkAuto,
+        >,
+    )>;
+
+    fn extract(_context: &PackingContext<Self>, data: Self::Input) -> Self {
+        let PackMulti((
+            _,
+            PackChild(PackMulti((PackBase(ref profile), PackChild(PackAggregate(keys), ..))), ..),
+        )) = data;
+
+        let keys = keys
+            .into_iter()
+            .map(|PackPacked(t, ..)| t)
+            .collect::<Vec<_>>();
+
+        PackExtract(UserSecretsExt {
+            email: profile.email.clone(),
+            email_verified: profile.email_verified,
+            security_keys: keys.clone(),
+        })
+    }
+}

src/model/map_type.rs

@@ -0,0 +1,163 @@
+use crate::model::LinkIdent;
+use std::any::TypeId;
+use std::fmt::Debug;
+use std::sync::Arc;
+
+type PMT = PackMapType;
+
+#[derive(Clone, Debug)]
+pub struct Multi(Vec<Arc<PMT>>);
+
+impl Multi {
+    pub fn get_base(&self) -> Option<&PMT> {
+        for pmt in &self.0 {
+            match pmt.as_ref() {
+                PackMapType::FromType(CommandPackFromType { base: true, .. }) => return Some(pmt),
+                PackMapType::Maybe(CommandPackMaybe { inner }) => {
+                    if let PackMapType::FromType(..) = inner.as_ref() {
+                        return Some(pmt);
+                    }
+                }
+                PackMapType::Multi(CommandPackMulti { inner }) => {
+                    if let Some(pmt) = inner.get_base() {
+                        return Some(pmt);
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        None
+    }
+}
+
+impl From<Vec<PMT>> for Multi {
+    fn from(v: Vec<PMT>) -> Self {
+        Multi(v.into_iter().map(Arc::new).collect())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum PackMapType {
+    FromType(CommandPackFromType),
+    Maybe(CommandPackMaybe),
+    Child(CommandPackChild),
+    Aggregate(CommandPackAggregate),
+    Multi(CommandPackMulti),
+}
+
+trait PackCommand {}
+
+#[derive(Clone, Debug)]
+pub struct CommandPackFromType {
+    pub name: String,
+    pub id: TypeId,
+    pub base: bool,
+}
+
+impl PackCommand for CommandPackFromType {}
+
+#[derive(Clone, Debug)]
+pub struct CommandPackMaybe {
+    pub inner: Arc<PackMapType>,
+}
+
+impl PackCommand for CommandPackMaybe {}
+
+#[derive(Clone, Debug)]
+pub struct CommandPackChild {
+    pub inner: Arc<PackMapType>,
+    pub link: LinkIdent,
+}
+
+impl PackCommand for CommandPackChild {}
+
+#[derive(Clone, Debug)]
+pub struct CommandPackAggregate {
+    pub inner: Arc<PackMapType>,
+}
+
+impl PackCommand for CommandPackAggregate {}
+
+#[derive(Clone, Debug)]
+pub struct CommandPackMulti {
+    pub inner: Multi,
+}
+
+impl PackCommand for CommandPackMulti {}
+
+impl PackMapType {
+    pub fn from_type<T: Sized + 'static>(base: bool) -> Self {
+        PackMapType::FromType(CommandPackFromType {
+            name: std::any::type_name::<T>().to_string(),
+            id: TypeId::of::<T>(),
+            base,
+        })
+    }
+
+    pub fn get_base_type(&self) -> TypeId {
+        let id = match self {
+            PackMapType::FromType(CommandPackFromType { base: true, .. }) => Some(self),
+            PackMapType::Multi(CommandPackMulti { inner }) => inner.get_base(),
+            _ => None,
+        };
+
+        let PackMapType::FromType(CommandPackFromType { id, .. }) = id.expect("no base type") else {
+            panic!("base type is not FromType")
+        };
+
+        *id
+    }
+
+    pub fn as_edges(
+        &self,
+        base_parent: &Option<(usize, String)>,
+        parent: &Option<(usize, String)>,
+        level: usize,
+    ) -> Vec<(Option<String>, String)> {
+        match self {
+            PackMapType::FromType(CommandPackFromType {
+                name, base: true, ..
+            }) => {
+                vec![(base_parent.clone().map(|(_, s)| s), name.clone())]
+            }
+            PackMapType::FromType(CommandPackFromType {
+                name, base: false, ..
+            }) => {
+                vec![(parent.clone().map(|(_, s)| s), name.clone())]
+            }
+            PackMapType::Maybe(CommandPackMaybe { inner }) => {
+                inner.as_edges(base_parent, parent, level)
+            }
+            PackMapType::Aggregate(CommandPackAggregate { inner }) => {
+                inner.as_edges(base_parent, parent, level)
+            }
+            PackMapType::Child(CommandPackChild { inner, .. }) => {
+                inner.as_edges(parent, &None, level + 1)
+            }
+            PackMapType::Multi(CommandPackMulti { inner }) => {
+                let new_parent = if let Some(PackMapType::FromType(CommandPackFromType {
+                    name,
+                    base: true,
+                    ..
+                })) = inner.get_base()
+                {
+                    if parent.clone().is_some_and(|(l, _)| l == level) {
+                        parent.clone()
+                    } else {
+                        Some((level, name.clone()))
+                    }
+                } else {
+                    parent.clone()
+                };
+
+                let mut edges = Vec::new();
+                for t in &inner.0 {
+                    edges.extend(t.as_edges(base_parent, &new_parent, level));
+                }
+
+                edges
+            }
+        }
+    }
+}

src/model/mod.rs

@@ -0,0 +1,394 @@
+use crate::model::map_type::{
+    CommandPackAggregate, CommandPackChild, CommandPackMaybe, CommandPackMulti, PackMapType,
+};
+use magnetar_calckey_model::ck;
+use magnetar_sdk::types::Id;
+use magnetar_sdk::{Packed, Required};
+use std::marker::PhantomData;
+use std::sync::Arc;
+
+use self::data::id::BaseId;
+
+pub mod data;
+pub mod db_pack;
+pub mod map_type;
+
+#[derive(Clone, Debug)]
+struct InternalContext {
+    self_user: Option<Arc<ck::user::Model>>,
+}
+
+#[derive(Clone, Debug)]
+pub struct PackingContext<T: ?Sized> {
+    context: Arc<InternalContext>,
+    data: Arc<PackMapType>,
+    _type: PhantomData<T>,
+}
+
+impl<T: ?Sized> PackingContext<T> {
+    fn cloned<S>(&self) -> PackingContext<S> {
+        PackingContext {
+            context: self.context.clone(),
+            data: self.data.clone(),
+            _type: PhantomData,
+        }
+    }
+}
+
+pub trait ReportType: 'static {
+    type Input: 'static;
+
+    fn report_type() -> PackMapType;
+}
+
+pub trait PackType: 'static {
+    type Input: 'static;
+
+    fn extract(context: &PackingContext<Self>, data: Self::Input) -> Self;
+
+    fn is_base_type() -> bool {
+        false
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct PackExtract<T>(T);
+
+impl<Out> ReportType for PackExtract<Out>
+where
+    Self: PackType,
+    <Self as PackType>::Input: ReportType + PackType,
+{
+    type Input = <Self as PackType>::Input;
+
+    fn report_type() -> PackMapType {
+        <Self as PackType>::Input::report_type()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum LinkIdent {
+    Auto,
+    Named(String),
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+pub struct LinkAuto;
+
+impl From<LinkAuto> for LinkIdent {
+    fn from(_: LinkAuto) -> Self {
+        LinkIdent::Auto
+    }
+}
+
+// Raw input type children
+#[derive(Clone, Debug)]
+pub struct PackBase<T: 'static>(T);
+
+impl<In: 'static> ReportType for PackBase<In> {
+    type Input = In;
+
+    fn report_type() -> PackMapType {
+        PackMapType::from_type::<In>(true)
+    }
+}
+
+impl<In: 'static> PackType for PackBase<In> {
+    type Input = In;
+
+    fn extract(_context: &PackingContext<Self>, data: <Self as PackType>::Input) -> Self {
+        PackBase(data)
+    }
+
+    fn is_base_type() -> bool {
+        true
+    }
+}
+
+// Raw input type children, non-base
+#[derive(Clone, Debug)]
+pub struct PackExt<T: 'static>(T);
+
+impl<In: 'static> ReportType for PackExt<In> {
+    type Input = In;
+
+    fn report_type() -> PackMapType {
+        PackMapType::from_type::<In>(false)
+    }
+}
+
+impl<In: 'static> PackType for PackExt<In> {
+    type Input = In;
+
+    fn extract(_context: &PackingContext<Self>, data: <Self as PackType>::Input) -> Self {
+        PackExt(data)
+    }
+}
+
+// Tree children
+#[derive(Clone, Debug)]
+pub struct PackChild<T: ReportType + PackType, L: Into<LinkIdent> + Default + 'static>(
+    T,
+    PhantomData<fn() -> L>,
+);
+
+impl<In: ReportType + PackType, L: Into<LinkIdent> + Default + 'static> ReportType
+    for PackChild<In, L>
+{
+    type Input = In;
+
+    fn report_type() -> PackMapType {
+        PackMapType::Child(CommandPackChild {
+            inner: Arc::new(In::report_type()),
+            link: L::into(L::default()),
+        })
+    }
+}
+
+impl<In: ReportType + PackType, L: Into<LinkIdent> + Default + 'static> PackType
+    for PackChild<In, L>
+{
+    type Input = In;
+
+    fn extract(_context: &PackingContext<Self>, data: <Self as PackType>::Input) -> Self {
+        PackChild(data, PhantomData)
+    }
+}
+
+// Aggregate multiple entries 1:N
+#[derive(Clone, Debug)]
+pub struct PackAggregate<T: ReportType + PackType>(Vec<T>);
+
+impl<In: ReportType + PackType> ReportType for PackAggregate<In> {
+    type Input = In;
+
+    fn report_type() -> PackMapType {
+        PackMapType::Aggregate(CommandPackAggregate {
+            inner: Arc::new(In::report_type()),
+        })
+    }
+}
+
+impl<In: ReportType + PackType> PackType for PackAggregate<In> {
+    type Input = Vec<In>;
+
+    fn extract(_context: &PackingContext<Self>, data: <Self as PackType>::Input) -> Self {
+        PackAggregate(data)
+    }
+}
+
+// An item that may or may not be present
+#[derive(Clone, Debug)]
+pub struct PackMaybe<T: ReportType + PackType>(Option<T>);
+
+impl<In: ReportType + PackType> ReportType for PackMaybe<In> {
+    type Input = In;
+
+    fn report_type() -> PackMapType {
+        In::report_type()
+    }
+}
+
+impl<In: ReportType + PackType> PackType for PackMaybe<In> {
+    type Input = Option<In>;
+
+    fn extract(_context: &PackingContext<Self>, data: <Self as PackType>::Input) -> Self {
+        PackMaybe(data)
+    }
+}
+
+// Multiple adjacent values
+#[derive(Clone, Debug)]
+pub struct PackMulti<T>(T);
+
+macro_rules! impl_pack_multi {
+    ($($a:ident as $b:ident),*) => {
+        impl<$($a,)*> ReportType for PackMulti<($($a,)*)>
+        where $($a: ReportType + PackType,)* {
+            type Input = ($(<$a as ReportType>::Input,)*);
+
+            fn report_type() -> PackMapType {
+                PackMapType::Multi(CommandPackMulti {
+                    inner: vec![$(
+                        $a::report_type(),
+                    )*].into(),
+                })
+            }
+        }
+
+        impl<$($a,)*> PackType for PackMulti<($($a,)*)>
+        where $($a: ReportType + PackType,)* {
+            type Input = ($(<$a as PackType>::Input,)*);
+
+            fn extract(context: &PackingContext<Self>, ($($b,)*): <Self as PackType>::Input) -> Self {
+                PackMulti(($(
+                    <$a as PackType>::extract(&context.cloned(), $b),
+                )*))
+            }
+        }
+    };
+}
+
+impl_pack_multi!();
+impl_pack_multi!(A as a);
+impl_pack_multi!(A as a, B as b);
+impl_pack_multi!(A as a, B as b, C as c);
+impl_pack_multi!(A as a, B as b, C as c, D as d);
+impl_pack_multi!(A as a, B as b, C as c, D as d, E as e);
+impl_pack_multi!(A as a, B as b, C as c, D as d, E as e, F as f);
+impl_pack_multi!(A as a, B as b, C as c, D as d, E as e, F as f, G as g);
+impl_pack_multi!(A as a, B as b, C as c, D as d, E as e, F as f, G as g, H as h);
+
+// API packed types
+
+pub struct PackPacked<T: Packed, In = <T as Packed>::Input>(T, PhantomData<In>);
+
+macro_rules! impl_pack_raw_tuple {
+    ($($a:ident),*) => {
+        impl<$($a,)* P: Packed> ReportType for PackPacked<P, ($($a,)*)>
+        where $(PackWrapper<$a>: ReportType + PackType),* {
+            type Input = ($($a,)*);
+
+            fn report_type() -> PackMapType {
+                PackMapType::Multi(CommandPackMulti {
+                    inner: vec![
+                        $(
+                        PackWrapper::<$a>::report_type()
+                        ),*
+                    ].into()
+                })
+            }
+        }
+
+        impl<$($a,)* P: Packed<Input = ($($a,)*)>> PackType for PackPacked<P, ($($a,)*)>
+        where $(PackWrapper<$a>: ReportType + PackType),* {
+            type Input = ($($a,)*);
+
+            fn extract(_context: &PackingContext<Self>, data: <Self as PackType>::Input) -> Self {
+                PackPacked(P::pack_from(data), PhantomData)
+            }
+        }
+    };
+}
+
+impl_pack_raw_tuple!(A);
+impl_pack_raw_tuple!(A, B);
+impl_pack_raw_tuple!(A, B, C);
+impl_pack_raw_tuple!(A, B, C, D);
+impl_pack_raw_tuple!(A, B, C, D, E);
+impl_pack_raw_tuple!(A, B, C, D, E, F);
+impl_pack_raw_tuple!(A, B, C, D, E, F, G);
+impl_pack_raw_tuple!(A, B, C, D, E, F, G, H);
+
+// Helper wrapper for Multi components
+#[derive(Clone, Debug)]
+pub struct PackWrapper<T>(T);
+
+impl<In: 'static> ReportType for PackWrapper<Required<In>>
+where
+    PackExtract<In>: ReportType + PackType,
+{
+    type Input = <PackExtract<In> as ReportType>::Input;
+
+    fn report_type() -> PackMapType {
+        PackExtract::<In>::report_type()
+    }
+}
+
+impl<In: 'static> PackType for PackWrapper<Required<In>>
+where
+    PackExtract<In>: ReportType + PackType,
+{
+    type Input = <PackExtract<In> as PackType>::Input;
+
+    fn extract(context: &PackingContext<Self>, data: Self::Input) -> Self {
+        PackWrapper(Required(
+            PackExtract::<In>::extract(&context.cloned(), data).0,
+        ))
+    }
+}
+
+impl<In: 'static> ReportType for PackWrapper<Option<In>>
+where
+    PackExtract<In>: ReportType + PackType,
+{
+    type Input = In;
+
+    fn report_type() -> PackMapType {
+        PackMapType::Maybe(CommandPackMaybe {
+            inner: Arc::new(PackExtract::<In>::report_type()),
+        })
+    }
+}
+
+impl<In: 'static> PackType for PackWrapper<Option<In>>
+where
+    PackExtract<In>: ReportType + PackType,
+{
+    type Input = Option<In>;
+
+    fn extract(context: &PackingContext<Self>, data: Self::Input) -> Self {
+        PackWrapper(
+            PackMaybe::<PackExtract<In>>::extract(&context.cloned(), data.map(PackExtract))
+                .0
+                .map(|PackExtract(x)| x),
+        )
+    }
+}
+
+// Concrete extractable types
+impl PackType for PackExtract<Id> {
+    type Input = PackExt<Box<dyn BaseId>>;
+
+    fn extract(_context: &PackingContext<Self>, PackExt(data): <Self as PackType>::Input) -> Self {
+        PackExtract(Id {
+            id: data.get_id().to_owned(),
+        })
+    }
+}
+
+// Packing context that gets passed in
+impl<T> PackingContext<T> {
+    fn self_user(&self) -> Option<&ck::user::Model> {
+        self.context.self_user.as_deref()
+    }
+
+    fn is_self(&self, user: &ck::user::Model) -> bool {
+        self.self_user()
+            .is_some_and(|self_user| self_user.id == user.id)
+    }
+}
+
+pub struct Packer<T> {
+    context: PackingContext<T>,
+}
+
+pub fn pack_from_db<T: PackType + ReportType>(
+    self_user: Option<Arc<ck::user::Model>>,
+) -> Packer<T> {
+    let types = T::report_type();
+    let context = PackingContext {
+        context: Arc::new(InternalContext { self_user }),
+        data: Arc::new(types),
+        _type: PhantomData,
+    };
+
+    Packer { context }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use magnetar_sdk::types::user::PackUserSelfMaybeAll;
+
+    #[test]
+    fn test_pack_type() {
+        let types = <PackPacked<PackUserSelfMaybeAll> as ReportType>::report_type();
+        println!("{:?}", types);
+
+        let edges = types.as_edges(&None, &None, 0);
+        for (from, to) in edges {
+            println!("{:?} --> {:?}", from, to);
+        }
+    }
+}