Masked email: upstream's x:MaskedEmail API (ME-2, ME-3, ME-6a, ME-7a, ME-12 to ME-19)

x:MaskedEmail is no longer refused as unbuilt. Creates generate the address
on an allowed domain and check the prefix, maxMaskedAddresses and the create
rate; updates keep server-set fields; enabled reads and writes map to the
shared state; query filters on enabled, forDomain and text; a tenant
administrator reaches its tenant's accounts' masks.

crates/jmap/src/registry/get.rs

@@ -196,6 +196,7 @@ impl RegistryGet for Server {
             | ObjectType::Domain => {
                 let is_singleton = (get.object_flags & OBJ_SINGLETON) != 0;
 
+                let ids_requested = get.ids.is_some();
                 let ids = if let Some(ids) = get.ids.take() {
                     ids
                 } else if object_type == ObjectType::Tenant
@@ -217,7 +218,7 @@ impl RegistryGet for Server {
                 get.response.list.reserve(ids.len());
 
                 for id in ids {
-                    let object = if let Some(object) = self
+                    let mut object = if let Some(object) = self
                         .registry()
                         .get(ObjectId::new(object_type, id))
                         .await
@@ -245,6 +246,16 @@ impl RegistryGet for Server {
                         continue;
                     };
 
+                    // inbuxa: ME-6a, ME-8
+                    if let ObjectInner::MaskedEmail(mask) = &mut object.inner
+                        && !crate::inbuxa::masked_email::read(self, id, mask).await?
+                    {
+                        if ids_requested {
+                            get.not_found(id);
+                        }
+                        continue;
+                    }
+
                     let mut extra_properties: VecMap<Property, _> = VecMap::new();
                     match &object.inner {
                         ObjectInner::DkimSignature(obj)

crates/jmap/src/registry/mod.rs

@@ -20,8 +20,7 @@ impl EnterpriseRegistry for Server {
     fn assert_enterprise_object(&self, object_type: ObjectType) -> trc::Result<()> {
         if !matches!(
             object_type,
-            ObjectType::MaskedEmail
-                | ObjectType::ArchivedItem
+            ObjectType::ArchivedItem
                 | ObjectType::Metric
                 | ObjectType::Trace
         ) {

crates/jmap/src/registry/query.rs

@@ -131,6 +131,16 @@ impl RegistryQuery for Server {
             .await
             .and_then(|response| response.build()),
 
+            // inbuxa: filters on enabled, forDomain and text (masked email)
+            ObjectType::MaskedEmail => crate::inbuxa::masked_email::query(RegistryQueryResponse {
+                server: self,
+                access_token,
+                object_type,
+                request,
+            })
+            .await
+            .and_then(|response| response.build()),
+
             ObjectType::Action => Err(trc::JmapEvent::InvalidArguments
                 .into_err()
                 .details("Actions cannot be queried")),

crates/jmap/src/registry/set.rs

@@ -500,6 +500,23 @@ impl RegistrySet for Server {
                             )
                             .await?
                         }
+                        // inbuxa: ME-12 to ME-17
+                        ObjectInner::MaskedEmail(mask) => {
+                            let old = match &modification {
+                                Modification::Update { object, .. } => match &object.inner {
+                                    ObjectInner::MaskedEmail(old) => Some(old),
+                                    _ => None,
+                                },
+                                Modification::Create { .. } => None,
+                            };
+                            crate::inbuxa::masked_email::validate(
+                                &set,
+                                mask,
+                                old,
+                                unpatched_properties,
+                            )
+                            .await?
+                        }
                         ObjectInner::AcmeProvider(provider) if is_create => {
                             validate_acme_provider(&set, provider, unpatched_properties).await?
                         }
@@ -629,6 +646,12 @@ impl RegistrySet for Server {
                             {
                                 cache_invalidator.process_update(id, &old, &new);
                             }
+                            // inbuxa: ME-1, ME-2
+                            if let (ObjectInner::MaskedEmail(old), ObjectInner::MaskedEmail(new)) =
+                                (&object.inner, &new_object.inner)
+                            {
+                                crate::inbuxa::masked_email::updated(self, id, old, new).await?;
+                            }
                             if let (
                                 ObjectInner::Application(previous),
                                 ObjectInner::Application(updated),
@@ -656,6 +679,10 @@ impl RegistrySet for Server {
                             RegistryWriteResult::Success(id),
                         ) => {
                             cache_invalidator.process_create(&new_object);
+                            // inbuxa: ME-7a
+                            if let ObjectInner::MaskedEmail(mask) = &new_object.inner {
+                                crate::inbuxa::masked_email::created(self, id, mask).await?;
+                            }
                             response.object.insert(Property::Id, RegistryValue::Id(id));
                             set.response
                                 .created
@@ -746,6 +773,10 @@ impl RegistrySet for Server {
                                     );
                                 }
 
+                                // inbuxa: ME-3
+                                if let ObjectInner::MaskedEmail(mask) = &object.inner {
+                                    crate::inbuxa::masked_email::destroyed(self, id, mask).await?;
+                                }
                                 cache_invalidator.process_delete(id, &object);
                                 set.response.destroyed.push(id);
                             }