arminius_lib_model/

filter.rs

// SPDX-FileCopyrightText: 2025 BWI GmbH
//
// SPDX-License-Identifier: Apache-2.0

//! Data models related to Filters

use std::ops::Not as _;

use arminius_lib_db::{DatabaseError, ResultExt as _};
use ruma::{
	OwnedDeviceId, RoomId, UInt, UserId,
	api::client::filter::{
		EventFormat, Filter, FilterDefinition, LazyLoadOptions, RoomEventFilter, RoomFilter,
		UrlFilter,
	},
};
use sqlx::{Type, prelude::FromRow};

use crate::types::DbUlid;

/// Filters applied to the room events, based on which events these are
/// used. See [`DbRoomFilter`] for more.
#[derive(Debug, Type)]
#[sqlx(type_name = "room_event_filter")]
pub struct DbRoomEventFilter {
	/// The maximum number of events returned.
	/// It should always be more than 0 and and have a reasonable maximum.
	///
	/// NOTE: this field should never return `None`, but since the type
	/// checking by sqlx does not allow for overwrite or constraint on the
	/// types, we will handle it at the application level.
	limit: Option<i32>,
	/// The rooms to exclude.
	not_rooms: Option<Vec<String>>,
	/// The senders to exclude.
	not_senders: Option<Vec<String>>,
	/// The event types to exclude.
	not_types: Option<Vec<String>>,
	/// The rooms to include.
	rooms: Option<Vec<String>>,
	/// The senders to include.
	senders: Option<Vec<String>>,
	/// The types to include.
	types: Option<Vec<String>>,
	/// If it `Some`, it means that something events will be excluded.
	/// If it is `true` the events without URL will be excluded.
	/// If it is `false` the events with URL will be excluded.
	contains_url: Option<bool>,
	/// If `true`, sends all membership events for all events, even if they
	/// have already been sent to the client. Does not apply unless
	/// `lazy_load_members` is `true`.
	include_redundant_members: Option<bool>,
	/// Lazily Load the membership events.
	lazy_load_members: Option<bool>,
	/// Enables Per thread notification counts. Only applies to the `/sync`
	/// endpoint.
	unread_thread_notifications: Option<bool>,
}

/// Filters that apply to the room events.
#[derive(Debug, Type)]
#[sqlx(type_name = "room_filter")]
pub struct DbRoomFilter {
	/// The per user account data to include for rooms.
	pub account_data: Option<DbRoomEventFilter>,
	/// Ephemeral events to include for rooms. appear in the ephemeral
	/// property in the `/sync` end-point.
	pub ephemeral: Option<DbRoomEventFilter>,
	/// The state events to include for the rooms.
	pub state: Option<DbRoomEventFilter>,
	/// The message and state update events to include for rooms.
	pub timeline: Option<DbRoomEventFilter>,
	/// Include rooms that the user has left in the sync.
	pub include_leave: Option<bool>,
	/// Events from these rooms should be excluded.
	pub not_rooms: Option<Vec<String>>,
	/// Events from these rooms should be included.
	pub rooms: Option<Vec<String>>,
}

/// General Event filters.
#[derive(Debug, Type)]
#[sqlx(type_name = "event_filter")]
pub struct DbEventFilter {
	/// The Limit of events returned.
	/// It should always be more than 0 and and have a reasonable maximum.
	///
	/// NOTE: this field should never return `None`, but since the type
	/// checking by sqlx does not allow for overwrite or constraint on the
	/// types, we will handle it at the application level.
	pub limit: Option<i32>,
	/// Events from these senders should be excluded.
	pub not_senders: Option<Vec<String>>,
	/// Events with these types should be excluded.
	pub not_types: Option<Vec<String>>,
	/// Events from these senders should be included.
	pub senders: Option<Vec<String>>,
	/// Events with these types should be included.
	pub types: Option<Vec<String>>,
}

/// Format of the event that is requested by the client in the filters.
/// This is defaulted to client.
#[derive(Debug, Type)]
#[sqlx(type_name = "event_format_enum", rename_all = "lowercase")]
pub enum DbEventFormat {
	/// The events should be send using formats appropriate for the clients.
	Client,
	/// The events should be send in raw format, as received by the
	/// homeserver.
	Federation,
}

impl TryFrom<DbRoomEventFilter> for Filter {
	type Error = DatabaseError;

	fn try_from(filter: DbRoomEventFilter) -> Result<Self, Self::Error> {
		let mut ruma_filter = Self::empty();
		ruma_filter.not_types = filter.not_types.unwrap_or_default();
		ruma_filter.limit = filter
			.limit
			.map(|limit| {
				UInt::try_from(limit).invalid_data(&format!(
					"the limit number of '{limit}' is greater than the maximum number that can fit into a non negative f64"
				))
			})
			.transpose()?;
		if let Some(senders) = filter.senders {
			ruma_filter.senders = Some(
				senders
					.into_iter()
					.map(|raw_user_id| {
						UserId::parse(&raw_user_id).invalid_data(&format!(
							"the user_id retrieved from the database for '{raw_user_id}' is not a valid user ID"
						))
					})
					.collect::<Result<Vec<_>, _>>()?,
			);
		}
		ruma_filter.not_senders = filter
			.not_senders
			.unwrap_or_default()
			.into_iter()
			.map(|raw_user_id| {
				UserId::parse(&raw_user_id).invalid_data(&format!(
					"the user_id retrieved from the database for '{raw_user_id}' is not a valid user ID"
				))
			})
			.collect::<Result<Vec<_>, _>>()?;

		ruma_filter.types = filter.types;
		Ok(ruma_filter)
	}
}

impl From<DbEventFormat> for EventFormat {
	fn from(event_format: DbEventFormat) -> Self {
		match event_format {
			DbEventFormat::Client => EventFormat::Client,
			DbEventFormat::Federation => EventFormat::Federation,
		}
	}
}

impl TryFrom<DbRoomEventFilter> for RoomEventFilter {
	type Error = DatabaseError;

	fn try_from(room_event_filter: DbRoomEventFilter) -> Result<Self, Self::Error> {
		let mut ruma_room_event_filter = Self::empty();
		ruma_room_event_filter.types = room_event_filter.types;
		ruma_room_event_filter.not_types = room_event_filter.not_types.unwrap_or_default();
		ruma_room_event_filter.not_rooms = room_event_filter
			.not_rooms
			.unwrap_or_default()
			.into_iter()
			.map(|raw_room_id| {
				RoomId::parse(&raw_room_id).invalid_data(&format!(
					"the room id from database '{raw_room_id}' is not a valid room id"
				))
			})
			.collect::<Result<Vec<_>, _>>()?;
		ruma_room_event_filter.rooms = room_event_filter
			.rooms
			.map(|rooms| {
				rooms
					.into_iter()
					.map(|raw_room_id| {
						RoomId::parse(&raw_room_id).invalid_data(&format!(
							"the room id from database '{raw_room_id}' is not a valid room id"
						))
					})
					.collect::<Result<Vec<_>, _>>()
			})
			.transpose()?;

		ruma_room_event_filter.not_senders = room_event_filter
			.not_senders
			.unwrap_or_default()
			.into_iter()
			.map(|raw_user_id| {
				UserId::parse(&raw_user_id).invalid_data(&format!(
					"the user id from database '{raw_user_id}' is not a valid user id"
				))
			})
			.collect::<Result<Vec<_>, _>>()?;

		ruma_room_event_filter.senders = room_event_filter
			.senders
			.map(|senders| {
				senders
					.into_iter()
					.map(|raw_user_id| {
						UserId::parse(&raw_user_id).invalid_data(&format!(
							"the user id from database '{raw_user_id}' is not a valid user id"
						))
					})
					.collect::<Result<Vec<_>, _>>()
			})
			.transpose()?;
		ruma_room_event_filter.limit =
			room_event_filter.limit
			.map(|limit| {
				UInt::try_from(limit).invalid_data(&format!(
					"the limit number of '{limit}' is greater than the maximum number that can fit into a non negative f64"
				))
			}).transpose()?;
		ruma_room_event_filter.url_filter = room_event_filter.contains_url.map(|contains_url| {
			if contains_url { UrlFilter::EventsWithUrl } else { UrlFilter::EventsWithoutUrl }
		});
		ruma_room_event_filter.lazy_load_options =
			if room_event_filter.lazy_load_members.is_some_and(|lazy_load| lazy_load) {
				LazyLoadOptions::Enabled {
					include_redundant_members: room_event_filter
						.include_redundant_members
						.unwrap_or_default(),
				}
			} else {
				LazyLoadOptions::Disabled
			};

		if let Some(unread_thread_notifications) = room_event_filter.unread_thread_notifications {
			ruma_room_event_filter.unread_thread_notifications = unread_thread_notifications;
		}
		Ok(ruma_room_event_filter)
	}
}

impl TryFrom<DbRoomFilter> for RoomFilter {
	type Error = DatabaseError;

	fn try_from(room_filter: DbRoomFilter) -> Result<Self, Self::Error> {
		let mut ruma_room_filter = Self::empty();
		ruma_room_filter.include_leave = room_filter.include_leave.unwrap_or_default();

		if let Some(account_data) = room_filter.account_data {
			ruma_room_filter.account_data = account_data.try_into()?;
		}
		if let Some(ephemeral) = room_filter.ephemeral {
			ruma_room_filter.ephemeral = ephemeral.try_into()?;
		}
		if let Some(state) = room_filter.state {
			ruma_room_filter.state = state.try_into()?;
		}
		if let Some(timeline) = room_filter.timeline {
			ruma_room_filter.timeline = timeline.try_into()?;
		}
		ruma_room_filter.rooms = room_filter
			.rooms
			.map(|rooms| {
				rooms
					.into_iter()
					.map(|raw_room_id| {
						RoomId::parse(&raw_room_id).invalid_data(&format!(
							"the room id from database '{raw_room_id}' is not a valid room id"
						))
					})
					.collect::<Result<Vec<_>, _>>()
			})
			.transpose()?;
		ruma_room_filter.not_rooms = room_filter
			.not_rooms
			.unwrap_or_default()
			.into_iter()
			.map(|raw_room_id| {
				RoomId::parse(&raw_room_id).invalid_data(&format!(
					"the room id from database '{raw_room_id}' is not a valid room id"
				))
			})
			.collect::<Result<Vec<_>, _>>()?;
		Ok(ruma_room_filter)
	}
}

impl From<EventFormat> for DbEventFormat {
	fn from(format: EventFormat) -> Self {
		match format {
			EventFormat::Federation => DbEventFormat::Federation,
			_ => DbEventFormat::Client, // Catch-all for forward compatibility
		}
	}
}

impl From<Filter> for DbEventFilter {
	fn from(filter: Filter) -> Self {
		Self {
			limit: filter.limit.map(|limit| limit.try_into().unwrap_or(i32::MAX)),
			not_senders: filter
				.not_senders
				.is_empty()
				.not()
				.then(|| filter.not_senders.into_iter().map(|sender| sender.to_string()).collect()),
			not_types: filter.not_types.is_empty().not().then_some(filter.not_types),
			senders: filter
				.senders
				.map(|sender| sender.into_iter().map(|id| id.to_string()).collect()),
			types: filter.types,
		}
	}
}

impl From<RoomEventFilter> for DbRoomEventFilter {
	fn from(filter: RoomEventFilter) -> Self {
		let (lazy_load_members, include_redundant_members) = match filter.lazy_load_options {
			LazyLoadOptions::Enabled { include_redundant_members } => {
				(Some(true), Some(include_redundant_members))
			}
			LazyLoadOptions::Disabled => (Some(false), Some(false)),
		};

		Self {
			limit: filter.limit.map(|limit| limit.try_into().unwrap_or(i32::MAX)),
			not_rooms: filter
				.not_rooms
				.is_empty()
				.not()
				.then(|| filter.not_rooms.into_iter().map(|id| id.to_string()).collect()),
			not_senders: filter
				.not_senders
				.is_empty()
				.not()
				.then(|| filter.not_senders.into_iter().map(|id| id.to_string()).collect()),
			not_types: filter.not_types.is_empty().not().then_some(filter.not_types),
			rooms: filter.rooms.map(|room| room.into_iter().map(|id| id.to_string()).collect()),
			senders: filter
				.senders
				.map(|sender| sender.into_iter().map(|id| id.to_string()).collect()),
			types: filter.types,
			contains_url: match filter.url_filter {
				Some(UrlFilter::EventsWithUrl) => Some(true),
				Some(UrlFilter::EventsWithoutUrl) => Some(false),
				None => None,
			},
			include_redundant_members,
			lazy_load_members,
			unread_thread_notifications: Some(filter.unread_thread_notifications),
		}
	}
}

impl From<RoomFilter> for DbRoomFilter {
	fn from(filter: RoomFilter) -> Self {
		Self {
			account_data: filter.account_data.is_empty().not().then(|| filter.account_data.into()),
			ephemeral: filter.ephemeral.is_empty().not().then(|| filter.ephemeral.into()),
			state: filter.state.is_empty().not().then(|| filter.state.into()),
			timeline: filter.timeline.is_empty().not().then(|| filter.timeline.into()),
			include_leave: Some(filter.include_leave),
			not_rooms: filter
				.not_rooms
				.is_empty()
				.not()
				.then(|| filter.not_rooms.into_iter().map(|id| id.to_string()).collect()),
			rooms: filter.rooms.map(|room| room.into_iter().map(|id| id.to_string()).collect()),
		}
	}
}

/// A struct that does the job of receiving the filter.
#[derive(Debug, FromRow)]
pub struct FilterRow {
	/// The ID assigned by the database for this record. Later used
	/// for recovering the data.
	pub id: DbUlid,
	/// UserId of the creator of the filter. Only this user should have
	/// access to this field.
	pub user_id: String,
	/// DeviceId of the device that requested this filter. The lifetime of
	/// the filter depends on the lifetime of the device in the database.
	pub device_id: OwnedDeviceId,
	/// Filters that apply to the room events.
	pub room: Option<DbRoomFilter>,
	/// Filters that apply to the account data.
	pub account_data: Option<DbEventFilter>,
	/// Filters that apply to the presence data.
	pub presence: Option<DbEventFilter>,
	/// Format of the events returned.
	pub event_format: DbEventFormat,
	/// fields of the the events to return.
	pub event_fields: Option<Vec<String>>,
}

impl TryFrom<DbEventFilter> for Filter {
	type Error = DatabaseError;

	fn try_from(filter: DbEventFilter) -> Result<Self, Self::Error> {
		let mut ruma_filter = Self::empty();
		ruma_filter.not_types = filter.not_types.unwrap_or_default();
		ruma_filter.limit = filter
			.limit
			.map(|limit| {
				UInt::try_from(limit).invalid_data(&format!(
					"the limit number of '{limit}' is greater than the maximum number that can fit into a non negative f64"
				))
			})
			.transpose()?;
		if let Some(senders) = filter.senders {
			ruma_filter.senders = Some(
				senders
					.into_iter()
					.map(|raw_user_id| {
						UserId::parse(&raw_user_id).invalid_data(&format!(
							"the user_id retrieved from the database for '{raw_user_id}' is not a valid user ID"
						))
					})
					.collect::<Result<Vec<_>, _>>()?,
			);
		}
		ruma_filter.not_senders = filter
			.not_senders
			.unwrap_or_default()
			.into_iter()
			.map(|raw_user_id| {
				UserId::parse(&raw_user_id).invalid_data(&format!(
					"the user_id retrieved from the database for '{raw_user_id}' is not a valid user ID"
				))
			})
			.collect::<Result<Vec<_>, _>>()?;

		ruma_filter.types = filter.types;
		Ok(ruma_filter)
	}
}

impl TryFrom<FilterRow> for FilterDefinition {
	type Error = DatabaseError;

	fn try_from(row: FilterRow) -> Result<Self, Self::Error> {
		let mut filter_definition = FilterDefinition::empty();

		filter_definition.event_fields = row.event_fields;
		filter_definition.event_format = row.event_format.into();
		if let Some(presence) = row.presence {
			filter_definition.presence = presence.try_into()?;
		}
		if let Some(account_data) = row.account_data {
			filter_definition.account_data = account_data.try_into()?;
		}
		if let Some(room) = row.room {
			filter_definition.room = room.try_into()?;
		}

		Ok(filter_definition)
	}
}