Refactor schedule and user repositories into modular structure

- Moved schedule repository logic into separate modules for SQLite and PostgreSQL implementations.
- Created a mapping module for shared data structures and mapping functions in the schedule repository.
- Added new mapping module for user repository to handle user data transformations.
- Implemented PostgreSQL and SQLite user repository adapters with necessary CRUD operations.
- Added tests for user repository functionality, including saving, finding, and deleting users.

k-tv-backend/domain/src/services/channel.rs

@@ -0,0 +1,57 @@
+use std::sync::Arc;
+
+use crate::entities::Channel;
+use crate::errors::{DomainError, DomainResult};
+use crate::repositories::ChannelRepository;
+use crate::value_objects::{ChannelId, UserId};
+
+/// Service for managing channels (CRUD + ownership enforcement).
+pub struct ChannelService {
+    channel_repo: Arc<dyn ChannelRepository>,
+}
+
+impl ChannelService {
+    pub fn new(channel_repo: Arc<dyn ChannelRepository>) -> Self {
+        Self { channel_repo }
+    }
+
+    pub async fn create(
+        &self,
+        owner_id: UserId,
+        name: &str,
+        timezone: &str,
+    ) -> DomainResult<Channel> {
+        let channel = Channel::new(owner_id, name, timezone);
+        self.channel_repo.save(&channel).await?;
+        Ok(channel)
+    }
+
+    pub async fn find_by_id(&self, id: ChannelId) -> DomainResult<Channel> {
+        self.channel_repo
+            .find_by_id(id)
+            .await?
+            .ok_or(DomainError::ChannelNotFound(id))
+    }
+
+    pub async fn find_all(&self) -> DomainResult<Vec<Channel>> {
+        self.channel_repo.find_all().await
+    }
+
+    pub async fn find_by_owner(&self, owner_id: UserId) -> DomainResult<Vec<Channel>> {
+        self.channel_repo.find_by_owner(owner_id).await
+    }
+
+    pub async fn update(&self, channel: Channel) -> DomainResult<Channel> {
+        self.channel_repo.save(&channel).await?;
+        Ok(channel)
+    }
+
+    /// Delete a channel, enforcing that `requester_id` is the owner.
+    pub async fn delete(&self, id: ChannelId, requester_id: UserId) -> DomainResult<()> {
+        let channel = self.find_by_id(id).await?;
+        if channel.owner_id != requester_id {
+            return Err(DomainError::forbidden("You don't own this channel"));
+        }
+        self.channel_repo.delete(id).await
+    }
+}