Move CLI object manipulation code upstream into microrm directly.

Cargo.lock

@@ -1242,9 +1242,10 @@ checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"
 
 [[package]]
 name = "microrm"
-version = "0.4.0"
+version = "0.4.0-rc.1"
 dependencies = [
  "base64 0.13.1",
+ "clap",
  "lazy_static",
  "libsqlite3-sys",
  "log",
@@ -1258,7 +1259,7 @@ dependencies = [
 
 [[package]]
 name = "microrm-macros"
-version = "0.4.0"
+version = "0.4.0-rc.1"
 dependencies = [
  "convert_case",
  "proc-macro2",

Cargo.toml

@@ -25,7 +25,7 @@ hmac = { version = "0.12" }
 toml = "0.8.2"
 
 # Data storage dependencies
-microrm = { version = "0.4.0", path="../microrm/microrm/" }
+microrm = { version = "0.4.0-rc.1", path="../microrm/microrm/", features = ["clap"] }
 serde_bytes = { version = "0.11.6" }
 
 # Public API/server dependencies

src/cli.rs

@@ -1,12 +1,12 @@
 use crate::{
     client_management, config, group_management,
     key::{self, KeyType},
-    object::ClapInterface,
     schema::{self, UIDCDatabase},
     scope_management, server, token_management, user_management, UIDCError,
 };
 use clap::{Parser, Subcommand};
 use microrm::prelude::*;
+use microrm::cli::ClapInterface;
 
 #[derive(Debug, Parser)]
 #[clap(author, version, about, long_about = None)]

src/object.rs

@@ -1,49 +1,10 @@
-use microrm::{schema::entity::Entity, prelude::{Queryable, Insertable}};
-
-mod clap_interface;
-
-pub use clap_interface::ClapInterface;
+use crate::UIDCError;
 
 mod role;
 mod user;
 
-pub trait Object: Sized + Entity + std::fmt::Debug {
-    type Error;
-    type CreateParameters: clap::Parser + std::fmt::Debug;
-    fn create_from_params(_: &Self::CreateParameters) -> Result<Self, Self::Error>;
-
-    type ExtraCommands: clap::Subcommand + std::fmt::Debug;
-    type ExtraCommandData;
-    fn run_extra_command(
-        data: &Self::ExtraCommandData,
-        extra: &Self::ExtraCommands,
-        query_ctx: impl Queryable<EntityOutput = Self>,
-        insert_ctx: &impl Insertable<Self>) -> Result<(), Self::Error> { unreachable!() }
-
-    fn shortname(&self) -> &str;
-}
-
-#[derive(Debug)]
-pub struct EmptyCommand;
-
-impl clap::FromArgMatches for EmptyCommand {
-    fn from_arg_matches(matches: &clap::ArgMatches) -> Result<Self, clap::Error> {
-        Ok(EmptyCommand)
+impl microrm::cli::CLIError for UIDCError {
+    fn no_such_entity(ename: &'static str, keys: String) -> Self {
+        UIDCError::AbortString(format!("no such {ename} matching {keys}"))
     }
-
-    fn update_from_arg_matches(&mut self, matches: &clap::ArgMatches) -> Result<(), clap::Error> {
-        Ok(())
-    }
-}
-
-impl clap::Subcommand for EmptyCommand {
-    fn augment_subcommands(cmd: clap::Command) -> clap::Command {
-        cmd
-    }
-
-    fn augment_subcommands_for_update(cmd: clap::Command) -> clap::Command {
-        cmd
-    }
-
-    fn has_subcommand(name: &str) -> bool { false }
 }

src/object/clap.rs

@@ -1,131 +0,0 @@
-use super::{Object,ObjectExt};
-
-#[derive(Debug)]
-pub struct ClapInterface<O: ObjectExt> {
-    verb: InterfaceVerb<O>,
-    _ghost: std::marker::PhantomData<O>,
-}
-
-impl<O: ObjectExt> ClapInterface<O> {
-    pub fn perform(
-        &self,
-        query_ctx: impl microrm::prelude::Queryable<EntityOutput = O>,
-        insert_ctx: &impl microrm::prelude::Insertable<O>,
-    ) -> Result<(), UIDCError> {
-        match &self.verb {
-            InterfaceVerb::Attach { relation, remote_keys } => {
-                todo!()
-            }
-            InterfaceVerb::Create(params) => {
-                O::create(insert_ctx, &params)?;
-            }
-            InterfaceVerb::Delete(keys) => {
-                O::delete(query_ctx, O::build_keys(keys))?;
-            }
-            InterfaceVerb::Detach => {
-                todo!()
-            }
-            InterfaceVerb::ListAll => {
-                O::list_all(query_ctx)?;
-            }
-            InterfaceVerb::Inspect(keys) => {
-                O::inspect(query_ctx, O::build_keys(keys))?;
-            }
-        }
-        Ok(())
-    }
-
-    /// iterate across the list of key parts (O::Uniques) and add args for each
-    fn add_keys(mut cmd: clap::Command) -> clap::Command {
-        struct UVisitor<'a>(&'a mut clap::Command);
-        impl<'a> EntityPartVisitor for UVisitor<'a> {
-            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
-                let arg = clap::Arg::new(EP::part_name())
-                    .required(true)
-                    .help(EP::desc());
-                *self.0 = self.0.clone().arg(arg);
-            }
-        }
-
-        <O::Uniques as EntityPartList>::accept_part_visitor(&mut UVisitor(&mut cmd));
-
-        cmd
-    }
-
-    fn make_relation_subcommands() -> impl Iterator<Item = clap::Command> {
-        let mut out = vec![];
-
-        struct PartVisitor<'l>(&'l mut Vec<clap::Command>);
-        impl<'l> EntityPartVisitor for PartVisitor<'l> {
-            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
-                struct Discriminator<'l>(&'l mut Vec<clap::Command>, &'static str);
-
-                impl<'l> DatumDiscriminator for Discriminator<'l> {
-                    fn visit_entity_id<E: Entity>(&mut self) {}
-                    fn visit_serialized<T: serde::Serialize + serde::de::DeserializeOwned>(
-                        &mut self,
-                    ) {
-                    }
-                    fn visit_bare_field<T: Datum>(&mut self) {}
-                    fn visit_assoc_map<E: Entity>(&mut self) {
-                        self.0.push(clap::Command::new(self.1));
-                    }
-                    fn visit_assoc_domain<R: microrm::schema::Relation>(&mut self) {
-                        self.0.push(clap::Command::new(self.1));
-                    }
-                    fn visit_assoc_range<R: microrm::schema::Relation>(&mut self) {
-                        self.0.push(clap::Command::new(self.1));
-                    }
-                }
-
-                <EP::Datum as Datum>::accept_discriminator(&mut Discriminator(
-                    self.0,
-                    EP::part_name(),
-                ));
-            }
-        }
-
-        O::accept_part_visitor(&mut PartVisitor(&mut out));
-
-        out.into_iter()
-    }
-}
-
-impl<O: ObjectExt> FromArgMatches for ClapInterface<O> {
-    fn from_arg_matches(matches: &clap::ArgMatches) -> Result<Self, clap::Error> {
-        let verb = InterfaceVerb::from_matches(matches);
-
-        Ok(Self {
-            verb: verb?,
-            _ghost: Default::default(),
-        })
-    }
-
-    fn update_from_arg_matches(&mut self, matches: &clap::ArgMatches) -> Result<(), clap::Error> {
-        todo!()
-    }
-}
-
-impl<O: ObjectExt> Subcommand for ClapInterface<O> {
-    fn has_subcommand(name: &str) -> bool {
-        todo!()
-    }
-
-    fn augment_subcommands(cmd: clap::Command) -> clap::Command {
-        cmd.subcommand(
-            Self::add_keys(clap::Command::new("attach"))
-                .subcommands(Self::make_relation_subcommands())
-                .subcommand_required(true),
-        )
-        .subcommand(<O::CreateParameters as clap::CommandFactory>::command().name("create"))
-        .subcommand(Self::add_keys(clap::Command::new("delete")))
-        .subcommand(Self::add_keys(clap::Command::new("inspect")))
-        .subcommand(clap::Command::new("list"))
-        .subcommands(O::extra_commands())
-    }
-
-    fn augment_subcommands_for_update(cmd: clap::Command) -> clap::Command {
-        todo!()
-    }
-}
-

src/object/clap_interface.rs

@@ -1,465 +0,0 @@
-use microrm::{
-    prelude::*,
-    schema::{
-        datum::{ConcreteDatumList, Datum, DatumDiscriminator, DatumDiscriminatorRef},
-        entity::{Entity, EntityID, EntityPartList, EntityPartVisitor, EntityVisitor},
-    },
-};
-
-use super::Object;
-use crate::UIDCError;
-use clap::{FromArgMatches, Subcommand};
-
-/// iterate across the list of key parts (E::Keys) and add args for each
-fn add_keys<E: Entity>(mut cmd: clap::Command) -> clap::Command {
-    struct UVisitor<'a>(&'a mut clap::Command);
-    impl<'a> EntityPartVisitor for UVisitor<'a> {
-        fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
-            let arg = clap::Arg::new(EP::part_name())
-                .required(true)
-                .help(EP::desc());
-            *self.0 = self.0.clone().arg(arg);
-        }
-    }
-
-    <E::Keys as EntityPartList>::accept_part_visitor(&mut UVisitor(&mut cmd));
-
-    cmd
-}
-
-fn collect_keys<E: Entity>(matches: &clap::ArgMatches) -> Vec<String> {
-    struct UVisitor<'a>(&'a clap::ArgMatches, &'a mut Vec<String>);
-    impl<'a> EntityPartVisitor for UVisitor<'a> {
-        fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
-            self.1.push(
-                self.0
-                    .get_one::<std::string::String>(EP::part_name())
-                    .unwrap()
-                    .clone(),
-            );
-        }
-    }
-
-    let mut key_values = vec![];
-    <E::Keys as EntityPartList>::accept_part_visitor(&mut UVisitor(matches, &mut key_values));
-    key_values
-}
-
-#[derive(Clone, Debug)]
-pub enum InterfaceVerb<O: Object> {
-    Attach {
-        local_keys: Vec<String>,
-        relation: String,
-        remote_keys: Vec<String>,
-    },
-    Create(O::CreateParameters),
-    Delete(Vec<String>),
-    Detach {
-        local_keys: Vec<String>,
-        relation: String,
-        remote_keys: Vec<String>,
-    },
-    ListAll,
-    Inspect(Vec<String>),
-    Extra(O::ExtraCommands),
-}
-
-// helper alias for later
-type UniqueList<E> = <<E as Entity>::Keys as EntityPartList>::DatumList;
-
-impl<O: Object> InterfaceVerb<O> {
-    fn parse_attachment(
-        matches: &clap::ArgMatches,
-    ) -> Result<(Vec<String>, String, Vec<String>), clap::Error> {
-        let local_keys = collect_keys::<O>(matches);
-
-        let (subcommand, submatches) = matches
-            .subcommand()
-            .ok_or(clap::Error::new(clap::error::ErrorKind::MissingSubcommand))?;
-
-        // find the relevant relation
-        struct RelationFinder<'l> {
-            subcommand: &'l str,
-            submatches: &'l clap::ArgMatches,
-            keys: &'l mut Vec<String>,
-        }
-        impl<'l> EntityPartVisitor for RelationFinder<'l> {
-            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
-                if EP::part_name() != self.subcommand {
-                    return;
-                }
-
-                println!(
-                    "RelationFinder found correct part for subcommand {}!",
-                    self.subcommand
-                );
-                println!("EP: {}", std::any::type_name::<EP>());
-                // println!("EP: {}", std::any::
-                EP::Datum::accept_entity_visitor(self);
-            }
-        }
-
-        impl<'l> EntityVisitor for RelationFinder<'l> {
-            fn visit<E: Entity>(&mut self) {
-                println!("\trelationfinder visiting entity {}", E::entity_name());
-                *self.keys = collect_keys::<E>(self.submatches);
-            }
-        }
-
-        let mut remote_keys = vec![];
-        O::accept_part_visitor(&mut RelationFinder {
-            subcommand,
-            submatches,
-            keys: &mut remote_keys,
-        });
-
-        Ok((local_keys, subcommand.into(), remote_keys))
-    }
-
-    fn from_matches(parent_matches: &clap::ArgMatches) -> Result<Self, clap::Error> {
-        let (subcommand, matches) = parent_matches
-            .subcommand()
-            .ok_or(clap::Error::new(clap::error::ErrorKind::MissingSubcommand))?;
-
-        Ok(match subcommand {
-            "attach" => {
-                let (local_keys, relation, remote_keys) = Self::parse_attachment(matches)?;
-                InterfaceVerb::Attach {
-                    local_keys,
-                    relation,
-                    remote_keys,
-                }
-            }
-            "create" => InterfaceVerb::Create(
-                <O::CreateParameters as clap::FromArgMatches>::from_arg_matches(matches)?,
-            ),
-            "delete" => InterfaceVerb::Delete(collect_keys::<O>(matches)),
-            "detach" => {
-                let (local_keys, relation, remote_keys) = Self::parse_attachment(matches)?;
-                InterfaceVerb::Detach {
-                    local_keys,
-                    relation,
-                    remote_keys,
-                }
-            }
-            "list" => InterfaceVerb::ListAll,
-            "inspect" => InterfaceVerb::Inspect(collect_keys::<O>(matches)),
-            cmd => {
-                if <O::ExtraCommands>::has_subcommand(cmd) {
-                    InterfaceVerb::Extra(<O::ExtraCommands>::from_arg_matches(parent_matches)?)
-                }
-                else {
-                    unreachable!()
-                }
-            },
-        })
-    }
-}
-
-/// helper type for attach and detach verbs
-struct Attacher<'l> {
-    do_attach: bool,
-    relation: &'l str,
-    remote_keys: &'l Vec<String>,
-    err: Option<UIDCError>,
-}
-
-impl<'l> Attacher<'l> {
-    fn do_operation<E: Entity>(&mut self, map: &impl AssocInterface<RemoteEntity = E>) {
-        match map
-            .query_all()
-            .keyed(
-                UniqueList::<E>::build_equivalent(self.remote_keys.iter().map(String::as_str))
-                    .unwrap(),
-            )
-            .get()
-        {
-            Ok(Some(obj)) => {
-                if self.do_attach {
-                    self.err = map.connect_to(obj.id()).err().map(Into::into);
-                } else {
-                    self.err = map.disconnect_from(obj.id()).err().map(Into::into);
-                }
-            }
-            Ok(None) => {
-                self.err = Some(UIDCError::Abort("No such entity to connect to"));
-            }
-            Err(e) => {
-                self.err = Some(e.into());
-            }
-        }
-    }
-}
-
-impl<'l> EntityPartVisitor for Attacher<'l> {
-    fn visit_datum<EP: microrm::schema::entity::EntityPart>(&mut self, datum: &EP::Datum) {
-        if EP::part_name() != self.relation {
-            return;
-        }
-
-        datum.accept_discriminator_ref(self);
-    }
-}
-
-impl<'l> DatumDiscriminatorRef for Attacher<'l> {
-    fn visit_entity_id<E: Entity>(&mut self, _: &E::ID) {
-        unreachable!()
-    }
-    fn visit_serialized<T: serde::Serialize + serde::de::DeserializeOwned>(&mut self, _: &T) {
-        unreachable!()
-    }
-    fn visit_bare_field<T: Datum>(&mut self, _: &T) {
-        unreachable!()
-    }
-
-    fn visit_assoc_map<E: Entity>(&mut self, map: &AssocMap<E>) {
-        self.do_operation(map);
-    }
-    fn visit_assoc_range<R: microrm::schema::Relation>(
-        &mut self,
-        map: &microrm::schema::AssocRange<R>,
-    ) {
-        self.do_operation(map);
-    }
-    fn visit_assoc_domain<R: microrm::schema::Relation>(
-        &mut self,
-        map: &microrm::schema::AssocDomain<R>,
-    ) {
-        self.do_operation(map);
-    }
-}
-
-#[derive(Debug)]
-pub struct ClapInterface<O: Object> {
-    verb: InterfaceVerb<O>,
-    _ghost: std::marker::PhantomData<O>,
-}
-
-impl<O: Object<Error = UIDCError>> ClapInterface<O> {
-    pub fn perform(
-        &self,
-        data: &O::ExtraCommandData,
-        query_ctx: impl microrm::prelude::Queryable<EntityOutput = O>,
-        insert_ctx: &impl microrm::prelude::Insertable<O>,
-    ) -> Result<(), UIDCError> {
-        match &self.verb {
-            InterfaceVerb::Attach {
-                local_keys,
-                relation,
-                remote_keys,
-            } => {
-                let outer_obj = query_ctx
-                    .keyed(
-                        UniqueList::<O>::build_equivalent(local_keys.iter().map(String::as_str))
-                            .unwrap(),
-                    )
-                    .get()?
-                    .ok_or(UIDCError::Abort("Could not find object to attach to"))?;
-
-                let mut attacher = Attacher {
-                    do_attach: true,
-                    relation,
-                    remote_keys,
-                    err: None,
-                };
-                outer_obj.accept_part_visitor_ref(&mut attacher);
-
-                if let Some(err) = attacher.err {
-                    return Err(err);
-                }
-            }
-            InterfaceVerb::Create(params) => {
-                insert_ctx.insert(O::create_from_params(params)?)?;
-            }
-            InterfaceVerb::Delete(keys) => {
-                query_ctx
-                    .keyed(
-                        UniqueList::<O>::build_equivalent(keys.iter().map(String::as_str))
-                            .unwrap(),
-                    )
-                    .delete()?;
-            }
-            InterfaceVerb::Detach {
-                local_keys,
-                relation,
-                remote_keys,
-            } => {
-                let outer_obj = query_ctx
-                    .keyed(
-                        UniqueList::<O>::build_equivalent(local_keys.iter().map(String::as_str))
-                            .unwrap(),
-                    )
-                    .get()?
-                    .ok_or(UIDCError::Abort("Could not find object to detach from"))?;
-
-                let mut attacher = Attacher {
-                    do_attach: false,
-                    relation,
-                    remote_keys,
-                    err: None,
-                };
-                outer_obj.accept_part_visitor_ref(&mut attacher);
-
-                if let Some(err) = attacher.err {
-                    return Err(err);
-                }
-            }
-            InterfaceVerb::ListAll => {
-                println!(
-                    "Listing all {}(s): ({})",
-                    O::entity_name(),
-                    query_ctx.clone().count()?
-                );
-                for obj in query_ctx.get()?.into_iter() {
-                    println!(" - {}", obj.shortname());
-                }
-            }
-            InterfaceVerb::Inspect(keys) => {
-                let obj = query_ctx
-                    .keyed(
-                        UniqueList::<O>::build_equivalent(keys.iter().map(String::as_str))
-                            .unwrap(),
-                    )
-                    .get()?
-                    .ok_or(UIDCError::Abort("no such element, cannot inspect"))?;
-                println!("{:#?}", obj.as_ref());
-
-                fn inspect_ai<AI: AssocInterface>(name: &'static str, ai: &AI) {
-                    println!("{}: ({})", name, ai.count().unwrap());
-                    for a in ai.get().expect("couldn't get object associations") {
-                        println!("[#{:3}]: {:?}", a.id().into_raw(), a.wrapped());
-                    }
-                }
-
-                struct AssocFieldWalker;
-                impl EntityPartVisitor for AssocFieldWalker {
-                    fn visit_datum<EP: microrm::schema::entity::EntityPart>(
-                        &mut self,
-                        datum: &EP::Datum,
-                    ) {
-                        struct Discriminator<'l, D: Datum>(&'l D, &'static str);
-
-                        impl<'l, D: Datum> DatumDiscriminatorRef for Discriminator<'l, D> {
-                            fn visit_serialized<
-                                T: serde::Serialize + serde::de::DeserializeOwned,
-                            >(
-                                &mut self,
-                                _: &T,
-                            ) {
-                            }
-                            fn visit_bare_field<T: Datum>(&mut self, _: &T) {}
-                            fn visit_entity_id<E: Entity>(&mut self, _: &E::ID) {}
-                            fn visit_assoc_map<E: Entity>(&mut self, amap: &AssocMap<E>) {
-                                inspect_ai(self.1, amap);
-                            }
-                            fn visit_assoc_domain<R: microrm::schema::Relation>(
-                                &mut self,
-                                adomain: &microrm::schema::AssocDomain<R>,
-                            ) {
-                                inspect_ai(self.1, adomain);
-                            }
-                            fn visit_assoc_range<R: microrm::schema::Relation>(
-                                &mut self,
-                                arange: &microrm::schema::AssocRange<R>,
-                            ) {
-                                inspect_ai(self.1, arange);
-                            }
-                        }
-
-                        datum.accept_discriminator_ref(&mut Discriminator(datum, EP::part_name()));
-                    }
-                }
-
-                obj.accept_part_visitor_ref(&mut AssocFieldWalker);
-            },
-            InterfaceVerb::Extra(extra) => {
-                O::run_extra_command(data, extra, query_ctx, insert_ctx)?;
-            },
-        }
-        Ok(())
-    }
-
-    fn make_relation_subcommands() -> impl Iterator<Item = clap::Command> {
-        let mut out = vec![];
-
-        struct PartVisitor<'l>(&'l mut Vec<clap::Command>);
-        impl<'l> EntityPartVisitor for PartVisitor<'l> {
-            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
-                struct Discriminator<'l>(&'l mut Vec<clap::Command>, &'static str);
-
-                impl<'l> DatumDiscriminator for Discriminator<'l> {
-                    fn visit_entity_id<E: Entity>(&mut self) {}
-                    fn visit_serialized<T: serde::Serialize + serde::de::DeserializeOwned>(
-                        &mut self,
-                    ) {
-                    }
-                    fn visit_bare_field<T: Datum>(&mut self) {}
-                    fn visit_assoc_map<E: Entity>(&mut self) {
-                        self.0.push(add_keys::<E>(clap::Command::new(self.1)));
-                    }
-                    fn visit_assoc_domain<R: microrm::schema::Relation>(&mut self) {
-                        self.0
-                            .push(add_keys::<R::Range>(clap::Command::new(self.1)));
-                    }
-                    fn visit_assoc_range<R: microrm::schema::Relation>(&mut self) {
-                        self.0
-                            .push(add_keys::<R::Domain>(clap::Command::new(self.1)));
-                    }
-                }
-
-                <EP::Datum as Datum>::accept_discriminator(&mut Discriminator(
-                    self.0,
-                    EP::part_name(),
-                ));
-            }
-        }
-
-        O::accept_part_visitor(&mut PartVisitor(&mut out));
-
-        out.into_iter()
-    }
-}
-
-impl<O: Object> FromArgMatches for ClapInterface<O> {
-    fn from_arg_matches(matches: &clap::ArgMatches) -> Result<Self, clap::Error> {
-        let verb = InterfaceVerb::from_matches(matches);
-
-        Ok(Self {
-            verb: verb?,
-            _ghost: Default::default(),
-        })
-    }
-
-    fn update_from_arg_matches(&mut self, matches: &clap::ArgMatches) -> Result<(), clap::Error> {
-        todo!()
-    }
-}
-
-impl<O: Object<Error = UIDCError>> Subcommand for ClapInterface<O> {
-    fn has_subcommand(name: &str) -> bool {
-        todo!()
-    }
-
-    fn augment_subcommands(cmd: clap::Command) -> clap::Command {
-        let cmd = cmd.subcommand(
-            add_keys::<O>(clap::Command::new("attach"))
-                .subcommands(Self::make_relation_subcommands())
-                .subcommand_required(true),
-        )
-        .subcommand(
-            add_keys::<O>(clap::Command::new("detach"))
-                .subcommands(Self::make_relation_subcommands())
-                .subcommand_required(true),
-        )
-        .subcommand(<O::CreateParameters as clap::CommandFactory>::command().name("create"))
-        .subcommand(add_keys::<O>(clap::Command::new("delete")))
-        .subcommand(add_keys::<O>(clap::Command::new("inspect")))
-        .subcommand(clap::Command::new("list"));
-
-        <O::ExtraCommands>::augment_subcommands(cmd)
-    }
-
-    fn augment_subcommands_for_update(cmd: clap::Command) -> clap::Command {
-        todo!()
-    }
-}

src/object/role.rs

@@ -1,12 +1,12 @@
-use super::Object;
 use crate::{schema, UIDCError};
+use microrm::cli::CLIObject;
 
 #[derive(clap::Parser, Debug)]
 pub struct CreateParameters {
     shortname: String,
 }
 
-impl Object for schema::Role {
+impl CLIObject for schema::Role {
     type Error = UIDCError;
     type CreateParameters = CreateParameters;
 
@@ -17,7 +17,7 @@ impl Object for schema::Role {
         })
     }
 
-    type ExtraCommands = super::EmptyCommand;
+    type ExtraCommands = microrm::cli::EmptyCommand;
     type ExtraCommandData = schema::Realm;
 
     fn shortname(&self) -> &str {

src/object/user.rs

@@ -1,5 +1,5 @@
-use super::Object;
 use crate::{schema, UIDCError, user_management};
+use microrm::cli::CLIObject;
 
 #[derive(clap::Parser, Debug)]
 pub struct CreateParameters {
@@ -17,7 +17,7 @@ pub enum UserCommands {
     }
 }
 
-impl Object for schema::User {
+impl CLIObject for schema::User {
     type Error = UIDCError;
     type CreateParameters = CreateParameters;