Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
feat(teams): add auto join team channel support (#5061)
Will Hutchinsona9daa0891800
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.jsonindex f8360c9b4c..06e0b5ff58 100644--- a/.github/workspace-dep-closures.json+++ b/.github/workspace-dep-closures.json@@ -5159,6 +5159,9 @@"crates/authentication_service_client","crates/bot_id","crates/channel_sender",+ "crates/channels",+ "crates/connection_gateway_client",+ "crates/connection_gateway_models","crates/contacts","crates/cowlike","crates/crm",@@ -5205,6 +5208,7 @@"crates/remote_env_var","crates/roles_and_permissions","crates/s3_key",+ "crates/share_permission_db_utils","crates/sqs_client","crates/sqs_worker","crates/system_properties",diff --git a/.sqlx/query-119ee7577e9cfcdeb2877c94bfdc67d099d58199ee9a1ba994bae7906c9cf515.json b/.sqlx/query-119ee7577e9cfcdeb2877c94bfdc67d099d58199ee9a1ba994bae7906c9cf515.jsonnew file mode 100644index 0000000000..a1a5ac1d59--- /dev/null+++ b/.sqlx/query-119ee7577e9cfcdeb2877c94bfdc67d099d58199ee9a1ba994bae7906c9cf515.json@@ -0,0 +1,15 @@+{+ "db_name": "PostgreSQL",+ "query": "\n UPDATE comms_channel_participants\n SET left_at = NULL\n WHERE user_id = $1\n AND channel_id = ANY($2)\n AND left_at IS NOT NULL\n ",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Text",+ "UuidArray"+ ]+ },+ "nullable": []+ },+ "hash": "119ee7577e9cfcdeb2877c94bfdc67d099d58199ee9a1ba994bae7906c9cf515"+}diff --git a/.sqlx/query-63b8a0bc87e00d95ca046f0602a14ef73e9c8ebffb19a40ed7e059004d9bdb9a.json b/.sqlx/query-63b8a0bc87e00d95ca046f0602a14ef73e9c8ebffb19a40ed7e059004d9bdb9a.jsondeleted file mode 100644index 2e97e18d29..0000000000--- a/.sqlx/query-63b8a0bc87e00d95ca046f0602a14ef73e9c8ebffb19a40ed7e059004d9bdb9a.json+++ /dev/null@@ -1,15 +0,0 @@-{- "db_name": "PostgreSQL",- "query": "\n DELETE FROM comms_channel_participants\n WHERE user_id = $2\n AND channel_id IN (\n SELECT id FROM comms_channels WHERE team_id = $1\n )\n ",- "describe": {- "columns": [],- "parameters": {- "Left": [- "Uuid",- "Text"- ]- },- "nullable": []- },- "hash": "63b8a0bc87e00d95ca046f0602a14ef73e9c8ebffb19a40ed7e059004d9bdb9a"-}diff --git a/.sqlx/query-7d4385b8207bd320c290edc420c68c86028ac0ecb586a78fe55438f5e13b9106.json b/.sqlx/query-7d4385b8207bd320c290edc420c68c86028ac0ecb586a78fe55438f5e13b9106.jsondeleted file mode 100644index a63d6d21d2..0000000000--- a/.sqlx/query-7d4385b8207bd320c290edc420c68c86028ac0ecb586a78fe55438f5e13b9106.json+++ /dev/null@@ -1,15 +0,0 @@-{- "db_name": "PostgreSQL",- "query": "\n INSERT INTO comms_channel_participants (channel_id, user_id, role, joined_at)\n SELECT cc.id, $2, 'member'::comms_participant_role, NOW()\n FROM comms_channels cc\n WHERE cc.team_id = $1\n ON CONFLICT (channel_id, user_id) DO NOTHING\n ",- "describe": {- "columns": [],- "parameters": {- "Left": [- "Uuid",- "Text"- ]- },- "nullable": []- },- "hash": "7d4385b8207bd320c290edc420c68c86028ac0ecb586a78fe55438f5e13b9106"-}diff --git a/.sqlx/query-10843b4044bca618301e755b0b6b5aeca5fd398adc48ed9f755490fa25e7f3f9.json b/.sqlx/query-9ec1d6dd12e88a48cd61d4b2a7cb0eeee510769fab9a0b41ac1a6d7384e0eeea.jsonsimilarity index 60%rename from .sqlx/query-10843b4044bca618301e755b0b6b5aeca5fd398adc48ed9f755490fa25e7f3f9.jsonrename to .sqlx/query-9ec1d6dd12e88a48cd61d4b2a7cb0eeee510769fab9a0b41ac1a6d7384e0eeea.jsonindex 2c80a4edcb..7bad1abc3d 100644--- a/.sqlx/query-10843b4044bca618301e755b0b6b5aeca5fd398adc48ed9f755490fa25e7f3f9.json+++ b/.sqlx/query-9ec1d6dd12e88a48cd61d4b2a7cb0eeee510769fab9a0b41ac1a6d7384e0eeea.json@@ -1,6 +1,6 @@{"db_name": "PostgreSQL",- "query": "\n INSERT INTO comms_channels (id, name, owner_id, org_id, team_id, channel_type)\n VALUES ($1, $2, $3, $4, $5, $6)\n ",+ "query": "\n INSERT INTO comms_channels (\n id, name, owner_id, org_id, team_id, channel_type, auto_join_team\n )\n VALUES ($1, $2, $3, $4, $5, $6, $7)\n ","describe": {"columns": [],"parameters": {@@ -22,10 +22,11 @@]}}- }+ },+ "Bool"]},"nullable": []},- "hash": "10843b4044bca618301e755b0b6b5aeca5fd398adc48ed9f755490fa25e7f3f9"+ "hash": "9ec1d6dd12e88a48cd61d4b2a7cb0eeee510769fab9a0b41ac1a6d7384e0eeea"}diff --git a/.sqlx/query-d132c249dc280d43197902289d97f1a87d1519b4de21096e079b36c18cf95c52.json b/.sqlx/query-d132c249dc280d43197902289d97f1a87d1519b4de21096e079b36c18cf95c52.jsonnew file mode 100644index 0000000000..1caccbb5e1--- /dev/null+++ b/.sqlx/query-d132c249dc280d43197902289d97f1a87d1519b4de21096e079b36c18cf95c52.json@@ -0,0 +1,23 @@+{+ "db_name": "PostgreSQL",+ "query": "\n UPDATE comms_channel_participants AS cp\n SET left_at = NOW()\n FROM comms_channels AS cc\n WHERE cp.channel_id = cc.id\n AND cc.team_id = $1\n AND cp.user_id = $2\n AND cp.left_at IS NULL\n RETURNING cp.channel_id\n ",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "channel_id",+ "type_info": "Uuid"+ }+ ],+ "parameters": {+ "Left": [+ "Uuid",+ "Text"+ ]+ },+ "nullable": [+ false+ ]+ },+ "hash": "d132c249dc280d43197902289d97f1a87d1519b4de21096e079b36c18cf95c52"+}diff --git a/.sqlx/query-ee4b1b82e0153531885a2070a1c43f3a496e9016fd0505562134626ef76356c2.json b/.sqlx/query-ee4b1b82e0153531885a2070a1c43f3a496e9016fd0505562134626ef76356c2.jsonnew file mode 100644index 0000000000..829ac0a77d--- /dev/null+++ b/.sqlx/query-ee4b1b82e0153531885a2070a1c43f3a496e9016fd0505562134626ef76356c2.json@@ -0,0 +1,15 @@+{+ "db_name": "PostgreSQL",+ "query": "\n INSERT INTO comms_channel_participants (channel_id, user_id, role)\n SELECT id, $2, 'member'::comms_participant_role\n FROM comms_channels\n WHERE team_id = $1 AND auto_join_team = TRUE\n ON CONFLICT (channel_id, user_id) DO UPDATE\n SET role = EXCLUDED.role,\n joined_at = NOW(),\n left_at = NULL\n WHERE comms_channel_participants.left_at IS NOT NULL\n ",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Uuid",+ "Text"+ ]+ },+ "nullable": []+ },+ "hash": "ee4b1b82e0153531885a2070a1c43f3a496e9016fd0505562134626ef76356c2"+}diff --git a/.sqlx/query-fab9a824cda630cab30894236104bd723c6473db79f05ce7fd94ccd1f02fcbc3.json b/.sqlx/query-fab9a824cda630cab30894236104bd723c6473db79f05ce7fd94ccd1f02fcbc3.jsonindex 52288cbc23..fbde75d1cf 100644--- a/.sqlx/query-fab9a824cda630cab30894236104bd723c6473db79f05ce7fd94ccd1f02fcbc3.json+++ b/.sqlx/query-fab9a824cda630cab30894236104bd723c6473db79f05ce7fd94ccd1f02fcbc3.json@@ -26,8 +26,8 @@]},"nullable": [- true,false,+ true,null]},diff --git a/Cargo.lock b/Cargo.lockindex 4b79f96a2d..b559feb54d 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -964,6 +964,7 @@ dependencies = ["aws-sdk-sqs","axum","base64 0.22.1",+ "channels","chrono","comms_db_client","contacts",@@ -14077,6 +14078,7 @@ dependencies = ["async-stripe","async-trait","axum",+ "channels","chrono","contacts","entity_access",@@ -14091,6 +14093,7 @@ dependencies = ["model_notifications","model_user","models_email",+ "models_pagination","non_empty","notification","roles_and_permissions",diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/createChannelRequest.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/createChannelRequest.tsindex a8e3c64187..8d803c42d2 100644--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/createChannelRequest.ts+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/createChannelRequest.ts@@ -12,6 +12,8 @@ import type { CreateChannelRequestTeamId } from './createChannelRequestTeamId';* Request to create a channel.*/export interface CreateChannelRequest {+ /** Whether team members automatically join this channel. Defaults to false. */+ auto_join_team?: boolean;/** Channel type. */channel_type: ChannelType;/** Optional channel name. */diff --git a/apps/web/src/lib/service-clients/service-storage/generated/zod.ts b/apps/web/src/lib/service-clients/service-storage/generated/zod.tsindex 691e510001..71c03d49cd 100644--- a/apps/web/src/lib/service-clients/service-storage/generated/zod.ts+++ b/apps/web/src/lib/service-clients/service-storage/generated/zod.ts@@ -1332,8 +1332,16 @@ export const ingestTranscriptBody = zod/*** @summary Handler for `POST /channels`.*/+export const createChannelBodyAutoJoinTeamDefault = false;+export const createChannelBody = zod.object({+ auto_join_team: zod+ .boolean()+ .optional()+ .describe(+ 'Whether team members automatically join this channel. Defaults to false.'+ ),channel_type: zod.enum(['public', 'private', 'direct_message', 'team']).describe('Type of channel.'),diff --git a/apps/web/src/lib/service-clients/service-storage/openapi.json b/apps/web/src/lib/service-clients/service-storage/openapi.jsonindex 2152428732..104274dc19 100644--- a/apps/web/src/lib/service-clients/service-storage/openapi.json+++ b/apps/web/src/lib/service-clients/service-storage/openapi.json@@ -12393,6 +12393,11 @@"description": "Request to create a channel.","required": ["channel_type", "participants"],"properties": {+ "auto_join_team": {+ "type": "boolean",+ "description": "Whether team members automatically join this channel. Defaults to false.",+ "default": false+ },"channel_type": {"$ref": "#/components/schemas/ChannelType","description": "Channel type."diff --git a/crates/channels/fixtures/channels_repo.sql b/crates/channels/fixtures/channels_repo.sqlindex cec0916772..f58febd987 100644--- a/crates/channels/fixtures/channels_repo.sql+++ b/crates/channels/fixtures/channels_repo.sql@@ -12,6 +12,45 @@-- Channel: ch2 (separate channel for isolation tests)-- Participants: owner, admin, member (active), left_user (left)+-- Team channels for bulk membership tests.+INSERT INTO macro_user (id, username, email, stripe_customer_id) VALUES+ ('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'team-owner-a', '[email protected]', 'cus_team_a'),+ ('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', 'team-owner-b', '[email protected]', 'cus_team_b');++INSERT INTO "User" (id, email, macro_user_id) VALUES+ ('macro|[email protected]', '[email protected]', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'),+ ('macro|[email protected]', '[email protected]', 'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb');++INSERT INTO team (id, name, owner_id) VALUES+ ('11111111-1111-1111-1111-111111111111', 'Team A', 'macro|[email protected]'),+ ('22222222-2222-2222-2222-222222222222', 'Team B', 'macro|[email protected]');++INSERT INTO comms_channels (+ id, name, channel_type, org_id, owner_id, team_id, auto_join_team, created_at, updated_at+) VALUES+ ('00000000-0000-0000-0000-000000000c11', 'team-a-auto-active', 'team', NULL,+ 'macro|[email protected]', '11111111-1111-1111-1111-111111111111', TRUE,+ '2024-01-01 00:00:00+00', '2024-01-01 00:00:00+00'),+ ('00000000-0000-0000-0000-000000000c12', 'team-a-auto-left', 'team', NULL,+ 'macro|[email protected]', '11111111-1111-1111-1111-111111111111', TRUE,+ '2024-01-01 00:00:00+00', '2024-01-01 00:00:00+00'),+ ('00000000-0000-0000-0000-000000000c13', 'team-a-manual', 'team', NULL,+ 'macro|[email protected]', '11111111-1111-1111-1111-111111111111', FALSE,+ '2024-01-01 00:00:00+00', '2024-01-01 00:00:00+00'),+ ('00000000-0000-0000-0000-000000000c21', 'team-b-auto', 'team', NULL,+ 'macro|[email protected]', '22222222-2222-2222-2222-222222222222', TRUE,+ '2024-01-01 00:00:00+00', '2024-01-01 00:00:00+00');++INSERT INTO comms_channel_participants (channel_id, user_id, role, joined_at, left_at) VALUES+ ('00000000-0000-0000-0000-000000000c11', 'macro|[email protected]', 'admin',+ '2024-01-01 00:00:00+00', NULL),+ ('00000000-0000-0000-0000-000000000c12', 'macro|[email protected]', 'admin',+ '2024-01-01 00:01:00+00', '2024-01-05 00:00:00+00'),+ ('00000000-0000-0000-0000-000000000c13', 'macro|[email protected]', 'owner',+ '2024-01-01 00:02:00+00', NULL),+ ('00000000-0000-0000-0000-000000000c21', 'macro|[email protected]', 'member',+ '2024-01-01 00:03:00+00', NULL);+-- channelsINSERT INTO comms_channels (id, name, channel_type, org_id, owner_id, created_at, updated_at) VALUES('00000000-0000-0000-0000-000000000c01', 'test-channel', 'public', NULL, 'macro|[email protected]',diff --git a/crates/channels/src/domain/models.rs b/crates/channels/src/domain/models.rsindex eec6725fa2..c7489c72f0 100644--- a/crates/channels/src/domain/models.rs+++ b/crates/channels/src/domain/models.rs@@ -700,6 +700,10 @@ pub struct CreateChannelRequest {pub channel_type: ChannelType,/// Team id for team channels.pub team_id: Option<Uuid>,+ /// Whether team members automatically join this channel. Defaults to false.+ #[serde(default)]+ #[cfg_attr(feature = "inbound", schema(default = false))]+ pub auto_join_team: bool,/// Participants to add, excluding the owner.#[cfg_attr(feature = "inbound", schema(value_type = HashSet<String>))]pub participants: HashSet<MacroUserIdStr<'static>>,diff --git a/crates/channels/src/domain/ports.rs b/crates/channels/src/domain/ports.rsindex a0a3296351..58cbed8f83 100644--- a/crates/channels/src/domain/ports.rs+++ b/crates/channels/src/domain/ports.rs@@ -274,6 +274,29 @@ pub trait ChannelRepo: Send + Sync + 'static {req: CreateChannelRequest,) -> impl Future<Output = Result<Uuid, Self::Err>> + Send;+ /// Add or reactivate a user in every auto-join channel for a team.+ fn auto_join_by_team_id<'a>(+ &self,+ team_id: &Uuid,+ user_id: &MacroUserIdStr<'a>,+ ) -> impl Future<Output = Result<(), Self::Err>> + Send;++ /// Soft-leave a user from every active channel membership for a team.+ ///+ /// Returns the channel ids whose memberships changed.+ fn leave_by_team_id<'a>(+ &self,+ team_id: &Uuid,+ user_id: &MacroUserIdStr<'a>,+ ) -> impl Future<Output = Result<Vec<Uuid>, Self::Err>> + Send;++ /// Roll back a team leave by restoring a user's memberships in the exact channels provided.+ fn restore_by_channel_ids<'a>(+ &self,+ user_id: &MacroUserIdStr<'a>,+ channel_ids: &[Uuid],+ ) -> impl Future<Output = Result<(), Self::Err>> + Send;+/// Fetch an existing direct message channel.fn maybe_get_dm<'a>(&self,@@ -631,6 +654,47 @@ pub trait ChannelService: Send + Sync + 'static {}}+ /// Add or reactivate a user in every auto-join channel for a team.+ fn auto_join_by_team_id(+ &self,+ _team_id: &Uuid,+ _user_id: &MacroUserIdStr<'_>,+ ) -> impl Future<Output = Result<(), ChannelMutationErr>> + Send {+ async move {+ Err(ChannelMutationErr::NotFound(+ "team channel mutations are not configured".to_string(),+ ))+ }+ }++ /// Soft-leave a user from every active channel membership for a team.+ ///+ /// Returns the channel ids whose memberships changed.+ fn leave_by_team_id(+ &self,+ _team_id: &Uuid,+ _user_id: &MacroUserIdStr<'_>,+ ) -> impl Future<Output = Result<Vec<Uuid>, ChannelMutationErr>> + Send {+ async move {+ Err(ChannelMutationErr::NotFound(+ "team channel mutations are not configured".to_string(),+ ))+ }+ }++ /// Roll back a team leave by restoring a user's memberships in the exact channels provided.+ fn restore_by_channel_ids(+ &self,+ _user_id: &MacroUserIdStr<'_>,+ _channel_ids: &[Uuid],+ ) -> impl Future<Output = Result<(), ChannelMutationErr>> + Send {+ async move {+ Err(ChannelMutationErr::NotFound(+ "team channel mutations are not configured".to_string(),+ ))+ }+ }+/// Get or create a direct message channel.fn get_or_create_dm(&self,diff --git a/crates/channels/src/domain/service.rs b/crates/channels/src/domain/service.rsindex 1b0e427207..648ec86e3c 100644--- a/crates/channels/src/domain/service.rs+++ b/crates/channels/src/domain/service.rs@@ -342,6 +342,11 @@ wherereq: crate::domain::models::CreateChannelRequest,) -> Result<crate::domain::models::CreateChannelResponse, ChannelMutationErr> {let actor = require_user_actor(&actor)?;+ if req.auto_join_team && req.channel_type != ChannelType::Team {+ return Err(ChannelMutationErr::BadRequest(+ "auto-join is only available for team channels".to_string(),+ ));+ }if req.channel_type == ChannelType::Team {let team_id = req.team_id.ok_or_else(|| {ChannelMutationErr::BadRequest("team id missing for team channel type".to_string())@@ -422,6 +427,7 @@ wherename: None,channel_type: ChannelType::DirectMessage,team_id: None,+ auto_join_team: false,participants: HashSet::from([actor, recipient_id.clone()]),},)@@ -457,6 +463,7 @@ wherename: None,channel_type: ChannelType::Private,team_id: None,+ auto_join_team: false,participants: req.recipients,},)@@ -1714,6 +1721,42 @@ whereChannelServiceImpl::create_channel(self, actor, None, req).await}+ #[tracing::instrument(err, skip(self, user_id))]+ async fn auto_join_by_team_id(+ &self,+ team_id: &Uuid,+ user_id: &MacroUserIdStr<'_>,+ ) -> Result<(), ChannelMutationErr> {+ self.repo+ .auto_join_by_team_id(team_id, user_id)+ .await+ .map_err(|e| ChannelMutationErr::Repo(e.into()))+ }++ #[tracing::instrument(err, skip(self, user_id))]+ async fn leave_by_team_id(+ &self,+ team_id: &Uuid,+ user_id: &MacroUserIdStr<'_>,+ ) -> Result<Vec<Uuid>, ChannelMutationErr> {+ self.repo+ .leave_by_team_id(team_id, user_id)+ .await+ .map_err(|e| ChannelMutationErr::Repo(e.into()))+ }++ #[tracing::instrument(err, skip(self, user_id, channel_ids))]+ async fn restore_by_channel_ids(+ &self,+ user_id: &MacroUserIdStr<'_>,+ channel_ids: &[Uuid],+ ) -> Result<(), ChannelMutationErr> {+ self.repo+ .restore_by_channel_ids(user_id, channel_ids)+ .await+ .map_err(|e| ChannelMutationErr::Repo(e.into()))+ }+async fn get_or_create_dm(&self,actor: Sender,diff --git a/crates/channels/src/domain/service/test.rs b/crates/channels/src/domain/service/test.rsindex e731c06841..02334331fd 100644--- a/crates/channels/src/domain/service/test.rs+++ b/crates/channels/src/domain/service/test.rs@@ -4,12 +4,13 @@ use crate::domain::{models::{Activity, ActivityType, BotId, BotSenderProfile, ChannelAttachment, ChannelAttachmentType,ChannelContextMessage, ChannelInfo, ChannelMessageFilters, ChannelMetadata,- ChannelParticipant, ChannelType, CountedReaction, CreateEntityMentionOptions,- DeleteMessageQuery, EntityMention, MessageAttachment, MessagePageDirection,- MutatedAttachment, MutatedMessage, NewChannelAttachment, ParticipantRole,- PatchChannelRequest, PatchMessageRequest, PostMessageRequest, PostReactionRequest,- ReactionAction, ReferencedShareItem, ReferencedShareItemType, ResolvedChannelMessage,- Sender, SimpleMention, ThreadData, ThreadReplyRow, TopLevelMessageRow,+ ChannelParticipant, ChannelType, CountedReaction, CreateChannelRequest,+ CreateEntityMentionOptions, DeleteMessageQuery, EntityMention, MessageAttachment,+ MessagePageDirection, MutatedAttachment, MutatedMessage, NewChannelAttachment,+ ParticipantRole, PatchChannelRequest, PatchMessageRequest, PostMessageRequest,+ PostReactionRequest, ReactionAction, ReferencedShareItem, ReferencedShareItemType,+ ResolvedChannelMessage, Sender, SimpleMention, ThreadData, ThreadReplyRow,+ TopLevelMessageRow,},ports::{ChannelEventDispatcher, ChannelMentionExtractor, ChannelReferenceSharePermissions,@@ -529,6 +530,30 @@ impl ChannelRepo for FakeMutationRepo {Ok(self.state.lock().unwrap().channel_id)}+ async fn auto_join_by_team_id(+ &self,+ _team_id: &Uuid,+ _user_id: &MacroUserIdStr<'_>,+ ) -> Result<(), Self::Err> {+ Ok(())+ }++ async fn leave_by_team_id(+ &self,+ _team_id: &Uuid,+ _user_id: &MacroUserIdStr<'_>,+ ) -> Result<Vec<Uuid>, Self::Err> {+ Ok(Vec::new())+ }++ async fn restore_by_channel_ids(+ &self,+ _user_id: &MacroUserIdStr<'_>,+ _channel_ids: &[Uuid],+ ) -> Result<(), Self::Err> {+ Ok(())+ }+async fn maybe_get_dm(&self,_user_id: MacroUserIdStr<'_>,@@ -1867,6 +1892,7 @@ async fn create_channel_event_carries_channel_name() {name: Some("general".to_string()),channel_type: ChannelType::Private,team_id: None,+ auto_join_team: false,participants: HashSet::from([macro_id("macro|[email protected]")]),},)@@ -1894,6 +1920,7 @@ async fn create_private_channel_allows_no_invited_participants() {name: Some("private notes".to_string()),channel_type: ChannelType::Private,team_id: None,+ auto_join_team: false,participants: HashSet::new(),},)@@ -1908,6 +1935,126 @@ async fn create_private_channel_allows_no_invited_participants() {));}+#[test]+fn create_channel_request_defaults_auto_join_team_to_false() {+ let request: CreateChannelRequest = serde_json::from_value(serde_json::json!({+ "name": "general",+ "channel_type": "team",+ "team_id": Uuid::new_v4(),+ "participants": []+ }))+ .unwrap();++ assert!(!request.auto_join_team);+}++#[tokio::test]+async fn create_channel_rejects_auto_join_for_non_team_channel() {+ let channel_id = Uuid::new_v4();+ let repo = FakeMutationRepo::new(channel_id, "macro|[email protected]");+ let svc = mutation_service(repo, FakeEvents::default(), FakeReferenceSharing::default());++ let err = svc+ .create_channel(+ sender("macro|[email protected]"),+ None,+ CreateChannelRequest {+ name: Some("private notes".to_string()),+ channel_type: ChannelType::Private,+ team_id: None,+ auto_join_team: true,+ participants: HashSet::new(),+ },+ )+ .await+ .unwrap_err();++ assert!(matches!(err, ChannelMutationErr::BadRequest(_)));+}++#[tokio::test]+async fn team_membership_operations_delegate_to_repo() {+ let team_id = Uuid::new_v4();+ let channel_ids = vec![Uuid::new_v4(), Uuid::new_v4()];+ let user_id = macro_id("macro|[email protected]");+ let mut repo = MockChannelRepo::new();+ repo.expect_auto_join_by_team_id()+ .withf({+ let user_id = user_id.clone();+ move |actual_team_id, actual_user_id| {+ actual_team_id == &team_id && actual_user_id == &user_id+ }+ })+ .once()+ .returning(|_, _| Box::pin(async { Ok(()) }));+ repo.expect_leave_by_team_id()+ .withf({+ let user_id = user_id.clone();+ move |actual_team_id, actual_user_id| {+ actual_team_id == &team_id && actual_user_id == &user_id+ }+ })+ .once()+ .returning({+ let channel_ids = channel_ids.clone();+ move |_, _| {+ let channel_ids = channel_ids.clone();+ Box::pin(async move { Ok(channel_ids) })+ }+ });+ repo.expect_restore_by_channel_ids()+ .withf({+ let user_id = user_id.clone();+ let channel_ids = channel_ids.clone();+ move |actual_user_id, actual_channel_ids| {+ actual_user_id == &user_id && actual_channel_ids == channel_ids+ }+ })+ .once()+ .returning(|_, _| Box::pin(async { Ok(()) }));+ let svc = ChannelServiceImpl::new(repo);++ svc.auto_join_by_team_id(&team_id, &user_id).await.unwrap();+ assert_eq!(+ svc.leave_by_team_id(&team_id, &user_id).await.unwrap(),+ channel_ids+ );+ svc.restore_by_channel_ids(&user_id, &channel_ids)+ .await+ .unwrap();+}++#[tokio::test]+async fn team_membership_operations_delegate_repo_errors() {+ let team_id = Uuid::new_v4();+ let user_id = macro_id("macro|[email protected]");+ let mut repo = MockChannelRepo::new();+ repo.expect_auto_join_by_team_id()+ .once()+ .returning(|_, _| Box::pin(async { Err(anyhow::anyhow!("join failed")) }));+ repo.expect_leave_by_team_id()+ .once()+ .returning(|_, _| Box::pin(async { Err(anyhow::anyhow!("leave failed")) }));+ repo.expect_restore_by_channel_ids()+ .once()+ .returning(|_, _| Box::pin(async { Err(anyhow::anyhow!("restore failed")) }));+ let svc = ChannelServiceImpl::new(repo);++ let join_err = svc+ .auto_join_by_team_id(&team_id, &user_id)+ .await+ .unwrap_err();+ let leave_err = svc.leave_by_team_id(&team_id, &user_id).await.unwrap_err();+ let restore_err = svc+ .restore_by_channel_ids(&user_id, &[Uuid::new_v4()])+ .await+ .unwrap_err();++ assert!(matches!(join_err, ChannelMutationErr::Repo(_)));+ assert!(matches!(leave_err, ChannelMutationErr::Repo(_)));+ assert!(matches!(restore_err, ChannelMutationErr::Repo(_)));+}+#[tokio::test]async fn patch_channel_dispatches_channel_updated() {let channel_id = Uuid::new_v4();diff --git a/crates/channels/src/outbound/pg_channels_repo.rs b/crates/channels/src/outbound/pg_channels_repo.rsindex 3b38955383..b5c551def6 100644--- a/crates/channels/src/outbound/pg_channels_repo.rs+++ b/crates/channels/src/outbound/pg_channels_repo.rs@@ -2673,8 +2673,10 @@ impl ChannelRepo for PgChannelsRepo {let mut transaction = self.pool.begin().await?;sqlx::query!(r#"- INSERT INTO comms_channels (id, name, owner_id, org_id, team_id, channel_type)- VALUES ($1, $2, $3, $4, $5, $6)+ INSERT INTO comms_channels (+ id, name, owner_id, org_id, team_id, channel_type, auto_join_team+ )+ VALUES ($1, $2, $3, $4, $5, $6, $7)"#,channel_id,req.name.as_deref(),@@ -2682,6 +2684,7 @@ impl ChannelRepo for PgChannelsRepo {None::<i64>,req.team_id,req.channel_type as ChannelType,+ req.auto_join_team,).execute(&mut *transaction).await@@ -2729,6 +2732,78 @@ impl ChannelRepo for PgChannelsRepo {Ok(channel_id)}+ async fn auto_join_by_team_id(+ &self,+ team_id: &Uuid,+ user_id: &MacroUserIdStr<'_>,+ ) -> Result<(), Self::Err> {+ sqlx::query!(+ r#"+ INSERT INTO comms_channel_participants (channel_id, user_id, role)+ SELECT id, $2, 'member'::comms_participant_role+ FROM comms_channels+ WHERE team_id = $1 AND auto_join_team = TRUE+ ON CONFLICT (channel_id, user_id) DO UPDATE+ SET role = EXCLUDED.role,+ joined_at = NOW(),+ left_at = NULL+ WHERE comms_channel_participants.left_at IS NOT NULL+ "#,+ team_id,+ user_id.as_ref(),+ )+ .execute(&self.pool)+ .await+ .context("unable to auto-join team channels")?;+ Ok(())+ }++ async fn leave_by_team_id(+ &self,+ team_id: &Uuid,+ user_id: &MacroUserIdStr<'_>,+ ) -> Result<Vec<Uuid>, Self::Err> {+ sqlx::query_scalar!(+ r#"+ UPDATE comms_channel_participants AS cp+ SET left_at = NOW()+ FROM comms_channels AS cc+ WHERE cp.channel_id = cc.id+ AND cc.team_id = $1+ AND cp.user_id = $2+ AND cp.left_at IS NULL+ RETURNING cp.channel_id+ "#,+ team_id,+ user_id.as_ref(),+ )+ .fetch_all(&self.pool)+ .await+ .context("unable to leave team channels")+ }++ async fn restore_by_channel_ids(+ &self,+ user_id: &MacroUserIdStr<'_>,+ channel_ids: &[Uuid],+ ) -> Result<(), Self::Err> {+ sqlx::query!(+ r#"+ UPDATE comms_channel_participants+ SET left_at = NULL+ WHERE user_id = $1+ AND channel_id = ANY($2)+ AND left_at IS NOT NULL+ "#,+ user_id.as_ref(),+ channel_ids,+ )+ .execute(&self.pool)+ .await+ .context("unable to restore channel memberships")?;+ Ok(())+ }+async fn maybe_get_dm(&self,user_id: MacroUserIdStr<'_>,diff --git a/crates/channels/src/outbound/pg_channels_repo/tests.rs b/crates/channels/src/outbound/pg_channels_repo/tests.rsindex 612b45a6ad..9e1dac183f 100644--- a/crates/channels/src/outbound/pg_channels_repo/tests.rs+++ b/crates/channels/src/outbound/pg_channels_repo/tests.rs@@ -1,7 +1,7 @@use crate::domain::models::{- AttachmentEntityReference, BotId, BotSenderProfile, ChannelMessageFilters,- CreateEntityMentionOptions, GetThreadReplyRowsRequest, MessagePageDirection,- NotificationFilters, ParticipantRole,+ AttachmentEntityReference, BotId, BotSenderProfile, ChannelMessageFilters, ChannelType,+ CreateChannelRequest, CreateEntityMentionOptions, GetThreadReplyRowsRequest,+ MessagePageDirection, NotificationFilters, ParticipantRole,};use crate::domain::ports::{ChannelListRepo, ChannelRepo};use crate::outbound::pg_channels_repo::PgChannelsRepo;@@ -11,7 +11,7 @@ use macro_db_migrator::MACRO_DB_MIGRATIONS;use macro_user_id::user_id::MacroUserIdStr;use models_pagination::{CreatedAt, Cursor, CursorVal, Query, SimpleSortMethod};use sqlx::{Pool, Postgres};-use std::sync::Arc;+use std::{collections::HashSet, sync::Arc};use uuid::Uuid;const NO_FILTERS: ChannelMessageFilters = ChannelMessageFilters {@@ -28,6 +28,11 @@ const NO_FILTERS: ChannelMessageFilters = ChannelMessageFilters {const CH1: Uuid = Uuid::from_u128(0x00000000_0000_0000_0000_000000000c01);const CH2: Uuid = Uuid::from_u128(0x00000000_0000_0000_0000_000000000c02);+const TEAM_A: Uuid = Uuid::from_u128(0x11111111_1111_1111_1111_111111111111);+const TEAM_A_AUTO_ACTIVE: Uuid = Uuid::from_u128(0x00000000_0000_0000_0000_000000000c11);+const TEAM_A_AUTO_LEFT: Uuid = Uuid::from_u128(0x00000000_0000_0000_0000_000000000c12);+const TEAM_A_MANUAL: Uuid = Uuid::from_u128(0x00000000_0000_0000_0000_000000000c13);+const TEAM_B_AUTO: Uuid = Uuid::from_u128(0x00000000_0000_0000_0000_000000000c21);const MSG1: Uuid = Uuid::from_u128(0x00000000_0000_0000_0000_000000000001);const MSG2: Uuid = Uuid::from_u128(0x00000000_0000_0000_0000_000000000002);const MSG3: Uuid = Uuid::from_u128(0x00000000_0000_0000_0000_000000000003);@@ -78,6 +83,296 @@ fn report_err(e: rootcause::Report) -> anyhow::Error {anyhow::anyhow!("{e:?}")}+#[sqlx::test(+ fixtures(path = "../../../fixtures", scripts("channels_repo")),+ migrator = "MACRO_DB_MIGRATIONS"+)]+async fn create_channel_persists_auto_join_team(pool: Pool<Postgres>) {+ let repo = repo(pool.clone());++ let enabled_channel_id = repo+ .create_channel(+ macro_user_id(USER_A),+ None,+ CreateChannelRequest {+ name: Some("enabled".to_string()),+ channel_type: ChannelType::Team,+ team_id: Some(TEAM_A),+ auto_join_team: true,+ participants: HashSet::new(),+ },+ )+ .await+ .unwrap();+ let disabled_channel_id = repo+ .create_channel(+ macro_user_id(USER_A),+ None,+ CreateChannelRequest {+ name: Some("disabled".to_string()),+ channel_type: ChannelType::Team,+ team_id: Some(TEAM_A),+ auto_join_team: false,+ participants: HashSet::new(),+ },+ )+ .await+ .unwrap();++ let enabled = sqlx::query_scalar!(+ "SELECT auto_join_team FROM comms_channels WHERE id = $1",+ enabled_channel_id,+ )+ .fetch_one(&pool)+ .await+ .unwrap();+ let disabled = sqlx::query_scalar!(+ "SELECT auto_join_team FROM comms_channels WHERE id = $1",+ disabled_channel_id,+ )+ .fetch_one(&pool)+ .await+ .unwrap();++ assert!(enabled);+ assert!(!disabled);+}++#[sqlx::test(+ fixtures(path = "../../../fixtures", scripts("channels_repo")),+ migrator = "MACRO_DB_MIGRATIONS"+)]+async fn auto_join_is_enabled_team_scoped_and_idempotent(pool: Pool<Postgres>) {+ let repo = repo(pool.clone());+ let user_id = macro_user_id(NON_MEMBER);++ repo.auto_join_by_team_id(&TEAM_A, &user_id).await.unwrap();+ repo.auto_join_by_team_id(&TEAM_A, &user_id).await.unwrap();++ let channel_ids = sqlx::query_scalar!(+ r#"+ SELECT channel_id+ FROM comms_channel_participants+ WHERE user_id = $1+ ORDER BY channel_id+ "#,+ user_id.as_ref(),+ )+ .fetch_all(&pool)+ .await+ .unwrap();++ assert_eq!(channel_ids, vec![TEAM_A_AUTO_ACTIVE, TEAM_A_AUTO_LEFT]);+ assert!(!channel_ids.contains(&TEAM_A_MANUAL));+ assert!(!channel_ids.contains(&TEAM_B_AUTO));+}++#[sqlx::test(+ fixtures(path = "../../../fixtures", scripts("channels_repo")),+ migrator = "MACRO_DB_MIGRATIONS"+)]+async fn auto_join_reactivates_left_members_without_changing_active_memberships(+ pool: Pool<Postgres>,+) {+ let repo = repo(pool.clone());+ let user_id = macro_user_id(LEFT_USER);+ let active_before = sqlx::query!(+ r#"+ SELECT role AS "role: ParticipantRole", joined_at+ FROM comms_channel_participants+ WHERE channel_id = $1 AND user_id = $2+ "#,+ TEAM_A_AUTO_ACTIVE,+ user_id.as_ref(),+ )+ .fetch_one(&pool)+ .await+ .unwrap();+ let left_before = sqlx::query!(+ r#"+ SELECT joined_at+ FROM comms_channel_participants+ WHERE channel_id = $1 AND user_id = $2+ "#,+ TEAM_A_AUTO_LEFT,+ user_id.as_ref(),+ )+ .fetch_one(&pool)+ .await+ .unwrap();++ repo.auto_join_by_team_id(&TEAM_A, &user_id).await.unwrap();++ let active_after = sqlx::query!(+ r#"+ SELECT role AS "role: ParticipantRole", joined_at, left_at::timestamptz AS "left_at?"+ FROM comms_channel_participants+ WHERE channel_id = $1 AND user_id = $2+ "#,+ TEAM_A_AUTO_ACTIVE,+ user_id.as_ref(),+ )+ .fetch_one(&pool)+ .await+ .unwrap();+ let reactivated = sqlx::query!(+ r#"+ SELECT role AS "role: ParticipantRole", joined_at, left_at::timestamptz AS "left_at?"+ FROM comms_channel_participants+ WHERE channel_id = $1 AND user_id = $2+ "#,+ TEAM_A_AUTO_LEFT,+ user_id.as_ref(),+ )+ .fetch_one(&pool)+ .await+ .unwrap();++ assert_eq!(active_after.role, active_before.role);+ assert_eq!(active_after.joined_at, active_before.joined_at);+ assert!(active_after.left_at.is_none());+ assert_eq!(reactivated.role, ParticipantRole::Member);+ assert!(reactivated.joined_at > left_before.joined_at);+ assert!(reactivated.left_at.is_none());+}++#[sqlx::test(+ fixtures(path = "../../../fixtures", scripts("channels_repo")),+ migrator = "MACRO_DB_MIGRATIONS"+)]+async fn leave_soft_leaves_all_team_channels_and_returns_only_changes(pool: Pool<Postgres>) {+ let repo = repo(pool.clone());+ let user_id = macro_user_id(LEFT_USER);+ let original_left_at = sqlx::query_scalar!(+ r#"+ SELECT left_at::timestamptz+ FROM comms_channel_participants+ WHERE channel_id = $1 AND user_id = $2+ "#,+ TEAM_A_AUTO_LEFT,+ user_id.as_ref(),+ )+ .fetch_one(&pool)+ .await+ .unwrap();++ let mut changed = repo.leave_by_team_id(&TEAM_A, &user_id).await.unwrap();+ changed.sort_unstable();++ assert_eq!(changed, vec![TEAM_A_AUTO_ACTIVE, TEAM_A_MANUAL]);+ assert!(+ repo.leave_by_team_id(&TEAM_A, &user_id)+ .await+ .unwrap()+ .is_empty()+ );++ let team_a_active_count = sqlx::query_scalar!(+ r#"+ SELECT COUNT(*) AS "count!"+ FROM comms_channel_participants cp+ JOIN comms_channels cc ON cc.id = cp.channel_id+ WHERE cc.team_id = $1 AND cp.user_id = $2 AND cp.left_at IS NULL+ "#,+ TEAM_A,+ user_id.as_ref(),+ )+ .fetch_one(&pool)+ .await+ .unwrap();+ let unchanged_left_at = sqlx::query_scalar!(+ r#"+ SELECT left_at::timestamptz+ FROM comms_channel_participants+ WHERE channel_id = $1 AND user_id = $2+ "#,+ TEAM_A_AUTO_LEFT,+ user_id.as_ref(),+ )+ .fetch_one(&pool)+ .await+ .unwrap();+ let other_team_left_at = sqlx::query_scalar!(+ r#"+ SELECT left_at::timestamptz+ FROM comms_channel_participants+ WHERE channel_id = $1 AND user_id = $2+ "#,+ TEAM_B_AUTO,+ user_id.as_ref(),+ )+ .fetch_one(&pool)+ .await+ .unwrap();++ assert_eq!(team_a_active_count, 0);+ assert_eq!(unchanged_left_at, original_left_at);+ assert!(other_team_left_at.is_none());+}++#[sqlx::test(+ fixtures(path = "../../../fixtures", scripts("channels_repo")),+ migrator = "MACRO_DB_MIGRATIONS"+)]+async fn rollback_restores_exact_channels_without_changing_role_or_joined_at(pool: Pool<Postgres>) {+ let repo = repo(pool.clone());+ let user_id = macro_user_id(LEFT_USER);+ let before = sqlx::query!(+ r#"+ SELECT channel_id, role AS "role: ParticipantRole", joined_at+ FROM comms_channel_participants+ WHERE user_id = $1 AND channel_id = ANY($2)+ ORDER BY channel_id+ "#,+ user_id.as_ref(),+ &[TEAM_A_AUTO_ACTIVE, TEAM_A_MANUAL],+ )+ .fetch_all(&pool)+ .await+ .unwrap();+ let changed = repo.leave_by_team_id(&TEAM_A, &user_id).await.unwrap();++ repo.restore_by_channel_ids(&user_id, &changed)+ .await+ .unwrap();++ let restored = sqlx::query!(+ r#"+ SELECT channel_id, role AS "role: ParticipantRole", joined_at,+ left_at::timestamptz AS "left_at?"+ FROM comms_channel_participants+ WHERE user_id = $1 AND channel_id = ANY($2)+ ORDER BY channel_id+ "#,+ user_id.as_ref(),+ &[TEAM_A_AUTO_ACTIVE, TEAM_A_MANUAL],+ )+ .fetch_all(&pool)+ .await+ .unwrap();+ let previously_left = sqlx::query_scalar!(+ r#"+ SELECT left_at::timestamptz+ FROM comms_channel_participants+ WHERE channel_id = $1 AND user_id = $2+ "#,+ TEAM_A_AUTO_LEFT,+ user_id.as_ref(),+ )+ .fetch_one(&pool)+ .await+ .unwrap();++ assert_eq!(restored.len(), before.len());+ for (restored, before) in restored.iter().zip(before) {+ assert_eq!(restored.channel_id, before.channel_id);+ assert_eq!(restored.role, before.role);+ assert_eq!(restored.joined_at, before.joined_at);+ assert!(restored.left_at.is_none());+ }+ assert!(previously_left.is_some());+}+#[sqlx::test(fixtures(path = "../../../fixtures", scripts("channels_repo")),migrator = "MACRO_DB_MIGRATIONS"diff --git a/crates/macro_db_client/migrations/20260721174603_add_auto_join_team_to_comms_channels.sql b/crates/macro_db_client/migrations/20260721174603_add_auto_join_team_to_comms_channels.sqlnew file mode 100644index 0000000000..9f32718ca4--- /dev/null+++ b/crates/macro_db_client/migrations/20260721174603_add_auto_join_team_to_comms_channels.sql@@ -0,0 +1,2 @@+ALTER TABLE public.comms_channels+ ADD COLUMN auto_join_team BOOLEAN NOT NULL DEFAULT FALSE;diff --git a/crates/teams/Cargo.toml b/crates/teams/Cargo.tomlindex 42b8923556..8f45d130fb 100644--- a/crates/teams/Cargo.toml+++ b/crates/teams/Cargo.toml@@ -52,6 +52,7 @@ async-stripe = { workspace = true, default-features = false, features = [] }async-trait = { workspace = true, optional = true }chrono = { workspace = true }+channels = { path = "../channels", default-features = false, features = ["ports"] }contacts = { path = "../contacts", default-features = false, optional = true }macro_authorization = { path = "../macro_authorization", optional = true, default-features = false, features = ["axum",@@ -98,6 +99,7 @@ workspace-hack = { version = "0.1", path = "../workspace-hack" }[dev-dependencies]macro_db_migrator = { path = "../macro_db_migrator" }+models_pagination = { path = "../models_pagination" }rootcause = { workspace = true }serde_json = { workspace = true }tokio = { workspace = true }diff --git a/crates/teams/fixtures/team_channels.sql b/crates/teams/fixtures/team_channels.sqldeleted file mode 100644index 1c3e961315..0000000000--- a/crates/teams/fixtures/team_channels.sql+++ /dev/null@@ -1,29 +0,0 @@-INSERT INTO "macro_user" (id, username, email, stripe_customer_id)-VALUES- ('a1111111-1111-1111-1111-111111111111', '[email protected]', '[email protected]', 'cus_1234'),- ('a2222222-2222-2222-2222-222222222222', '[email protected]', '[email protected]', 'stripe_user2'),- ('a3333333-3333-3333-3333-333333333333', '[email protected]', '[email protected]', 'stripe_user3');--INSERT INTO "User" ("id", "email", "name", "stripeCustomerId", "macro_user_id") VALUES-('macro|[email protected]', '[email protected]', 'User', 'cus_1234', 'a1111111-1111-1111-1111-111111111111'),-('macro|[email protected]', '[email protected]', 'User2', NULL, 'a2222222-2222-2222-2222-222222222222'),-('macro|[email protected]', '[email protected]', 'User3', NULL, 'a3333333-3333-3333-3333-333333333333');--INSERT INTO team(id, name, owner_id, subscription_id, seat_count)-VALUES ('11111111-1111-1111-1111-111111111111', 'team1', 'macro|[email protected]', 'sub_1', 2);--INSERT INTO team_user (team_id, user_id, team_role)-VALUES ('11111111-1111-1111-1111-111111111111', 'macro|[email protected]', 'owner'),- ('11111111-1111-1111-1111-111111111111', 'macro|[email protected]', 'member');---- Team channels for team1-INSERT INTO comms_channels (id, name, channel_type, team_id, owner_id, created_at, updated_at)-VALUES ('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'General', 'team', '11111111-1111-1111-1111-111111111111', 'macro|[email protected]', NOW(), NOW()),- ('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', 'Random', 'team', '11111111-1111-1111-1111-111111111111', 'macro|[email protected]', NOW(), NOW());---- Owner is participant in both channels-INSERT INTO comms_channel_participants (channel_id, user_id, role, joined_at)-VALUES ('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'macro|[email protected]', 'owner', NOW()),- ('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', 'macro|[email protected]', 'owner', NOW()),- ('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'macro|[email protected]', 'member', NOW()),- ('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', 'macro|[email protected]', 'member', NOW());diff --git a/crates/teams/src/domain/team_repo.rs b/crates/teams/src/domain/team_repo.rsindex 841d5ea484..1ae53580f3 100644--- a/crates/teams/src/domain/team_repo.rs+++ b/crates/teams/src/domain/team_repo.rs@@ -15,23 +15,6 @@ use crate::domain::model::{ToggleAutoJoinDomainError, TryJoinTeamByDomainError,};-/// The TeamChannelsRepository defines a set of actions related to team channels-pub trait TeamChannelsRepository: Clone + Send + Sync + 'static {- /// Adds a team member to all team channels- fn add_team_member_to_channels(- &self,- team_id: &uuid::Uuid,- user_id: &MacroUserIdStr<'_>,- ) -> impl Future<Output = Result<(), TeamError>> + Send;-- /// Removes a team member from all team channels- fn remove_team_member_from_channels(- &self,- team_id: &uuid::Uuid,- user_id: &MacroUserIdStr<'_>,- ) -> impl Future<Output = Result<(), TeamError>> + Send;-}-/// The TeamRepository defines a set of actions to perform on teams datapub trait TeamRepository: Clone + Send + Sync + 'static {/// Gets the stripe customer id for a userdiff --git a/crates/teams/src/domain/team_service.rs b/crates/teams/src/domain/team_service.rsindex 69e9f705e6..69e496805b 100644--- a/crates/teams/src/domain/team_service.rs+++ b/crates/teams/src/domain/team_service.rs@@ -5,6 +5,7 @@ mod test;use std::{collections::HashSet, sync::Arc};+use channels::domain::ports::{ChannelMutationErr, ChannelService};use entity_access::domain::models::{AdminTeamRole, EntityAccessReceipt, MemberTeamRole, OwnerTeamRole,};@@ -44,7 +45,7 @@ use crate::domain::{},team_analytics::{NoOpTeamAnalytics, TeamAnalytics, TeamAnalyticsEvent},team_crm_settings_repo::TeamCrmSettingsRepository,- team_repo::{TeamChannelsRepository, TeamMembersService, TeamRepository, TeamService},+ team_repo::{TeamMembersService, TeamRepository, TeamService},};/// Implementation of the TeamService using a TeamRepository@@ -52,7 +53,7 @@ use crate::domain::{pub struct TeamServiceImpl<TR,CR,- TCR,+ CS,URPS,NI,CE,@@ -63,7 +64,7 @@ pub struct TeamServiceImpl<> whereTR: TeamRepository,CR: CustomerRepository,- TCR: TeamChannelsRepository,+ CS: ChannelService + Clone,URPS: UserRolesAndPermissionsService,NI: NotificationIngress,CE: CrmEnqueuer,@@ -76,8 +77,8 @@ pub struct TeamServiceImpl<team_repository: TR,/// The underlying customer repositorycustomer_repository: CR,- /// The team channels repository- team_channels_repository: TCR,+ /// The channel service+ channel_service: CS,/// The underlying user roles and permissions serviceuser_roles_and_permissions_service: URPS,/// The notification ingress service@@ -97,12 +98,16 @@ pub struct TeamServiceImpl<event_broker: EB,}-impl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA, CNE, EB> Clone- for TeamServiceImpl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA, CNE, EB>+fn channel_error_to_team_error(error: ChannelMutationErr) -> TeamError {+ TeamError::StorageLayerError(error.into())+}++impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB> Clone+ for TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB>whereTR: TeamRepository,CR: CustomerRepository,- TCR: TeamChannelsRepository,+ CS: ChannelService + Clone,URPS: UserRolesAndPermissionsService,NI: NotificationIngress,CE: CrmEnqueuer,@@ -115,7 +120,7 @@ whereSelf {team_repository: self.team_repository.clone(),customer_repository: self.customer_repository.clone(),- team_channels_repository: self.team_channels_repository.clone(),+ channel_service: self.channel_service.clone(),user_roles_and_permissions_service: self.user_roles_and_permissions_service.clone(),notification_ingress: self.notification_ingress.clone(),crm_enqueuer: self.crm_enqueuer.clone(),@@ -127,11 +132,11 @@ where}}-impl<TR, CR, TCR, URPS, NI, CE, TCRMS>+impl<TR, CR, CS, URPS, NI, CE, TCRMS>TeamServiceImpl<TR,CR,- TCR,+ CS,URPS,NI,CE,@@ -143,7 +148,7 @@ impl<TR, CR, TCR, URPS, NI, CE, TCRMS>whereTR: TeamRepository,CR: CustomerRepository,- TCR: TeamChannelsRepository,+ CS: ChannelService + Clone,URPS: UserRolesAndPermissionsService,NI: NotificationIngress,CE: CrmEnqueuer,@@ -153,7 +158,7 @@ wherepub fn new(team_repository: TR,customer_repository: CR,- team_channels_repository: TCR,+ channel_service: CS,user_roles_and_permissions_service: URPS,notification_ingress: Arc<NI>,crm_enqueuer: CE,@@ -162,7 +167,7 @@ whereSelf::new_with_analytics(team_repository,customer_repository,- team_channels_repository,+ channel_service,user_roles_and_permissions_service,notification_ingress,crm_enqueuer,@@ -172,23 +177,12 @@ where}}-impl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA>- TeamServiceImpl<- TR,- CR,- TCR,- URPS,- NI,- CE,- TCRMS,- TA,- NoOpContactsEnqueuer,- NoopMacroEventBroker,- >+impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA>+ TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, NoOpContactsEnqueuer, NoopMacroEventBroker>whereTR: TeamRepository,CR: CustomerRepository,- TCR: TeamChannelsRepository,+ CS: ChannelService + Clone,URPS: UserRolesAndPermissionsService,NI: NotificationIngress,CE: CrmEnqueuer,@@ -203,7 +197,7 @@ wherepub fn new_with_analytics(team_repository: TR,customer_repository: CR,- team_channels_repository: TCR,+ channel_service: CS,user_roles_and_permissions_service: URPS,notification_ingress: Arc<NI>,crm_enqueuer: CE,@@ -213,7 +207,7 @@ whereSelf {team_repository,customer_repository,- team_channels_repository,+ channel_service,user_roles_and_permissions_service,notification_ingress,crm_enqueuer,@@ -225,12 +219,12 @@ where}}-impl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA, CNE, EB>- TeamServiceImpl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA, CNE, EB>+impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB>+ TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB>whereTR: TeamRepository,CR: CustomerRepository,- TCR: TeamChannelsRepository,+ CS: ChannelService + Clone,URPS: UserRolesAndPermissionsService,NI: NotificationIngress,CE: CrmEnqueuer,@@ -243,14 +237,14 @@ wherepub fn with_contacts_enqueuer<CNE2>(self,contacts_enqueuer: CNE2,- ) -> TeamServiceImpl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA, CNE2, EB>+ ) -> TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE2, EB>whereCNE2: ContactsEnqueuer,{TeamServiceImpl {team_repository: self.team_repository,customer_repository: self.customer_repository,- team_channels_repository: self.team_channels_repository,+ channel_service: self.channel_service,user_roles_and_permissions_service: self.user_roles_and_permissions_service,notification_ingress: self.notification_ingress,crm_enqueuer: self.crm_enqueuer,@@ -265,14 +259,14 @@ wherepub fn with_event_broker<EB2>(self,event_broker: EB2,- ) -> TeamServiceImpl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA, CNE, EB2>+ ) -> TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB2>whereEB2: MacroEventBroker,{TeamServiceImpl {team_repository: self.team_repository,customer_repository: self.customer_repository,- team_channels_repository: self.team_channels_repository,+ channel_service: self.channel_service,user_roles_and_permissions_service: self.user_roles_and_permissions_service,notification_ingress: self.notification_ingress,crm_enqueuer: self.crm_enqueuer,@@ -504,12 +498,12 @@ impl GetTeamSubscriptionError {}}-impl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA, CNE, EB> TeamMembersService- for TeamServiceImpl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA, CNE, EB>+impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB> TeamMembersService+ for TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB>whereTR: TeamRepository,CR: CustomerRepository,- TCR: TeamChannelsRepository,+ CS: ChannelService + Clone,URPS: UserRolesAndPermissionsService,NI: NotificationIngress,CE: CrmEnqueuer,@@ -533,12 +527,12 @@ where}}-impl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA, CNE, EB> TeamService- for TeamServiceImpl<TR, CR, TCR, URPS, NI, CE, TCRMS, TA, CNE, EB>+impl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB> TeamService+ for TeamServiceImpl<TR, CR, CS, URPS, NI, CE, TCRMS, TA, CNE, EB>whereTR: TeamRepository,CR: CustomerRepository,- TCR: TeamChannelsRepository,+ CS: ChannelService + Clone,URPS: UserRolesAndPermissionsService,NI: NotificationIngress,CE: CrmEnqueuer,@@ -860,35 +854,40 @@ wherereturn Err(RemoveUserFromTeamError::CustomerError(e));}- if let Err(e) = self- .team_channels_repository- .remove_team_member_from_channels(&team_id, user_id)+ let left_channel_ids = match self+ .channel_service+ .leave_by_team_id(&team_id, user_id).await{- if let Some(subscription_id) = subscription_id.as_ref() {- self.customer_repository- .increment_seat_count(subscription_id, 1)+ Ok(channel_ids) => channel_ids,+ Err(error) => {+ if let Some(subscription_id) = subscription_id.as_ref() {+ self.customer_repository+ .increment_seat_count(subscription_id, 1)+ .await+ .inspect_err(|rollback_err| {+ tracing::error!(+ error=?rollback_err,+ "unable to rollback customer seat count after removing team member from channels failed"+ );+ })+ .ok();+ }+ self.team_repository+ .rollback_remove_user_from_team(&removed_member).await.inspect_err(|rollback_err| {tracing::error!(error=?rollback_err,- "unable to rollback customer seat count after removing team member from channels failed"+ "unable to rollback removed team member after removing team member from channels failed");}).ok();+ return Err(RemoveUserFromTeamError::TeamError(+ channel_error_to_team_error(error),+ ));}- self.team_repository- .rollback_remove_user_from_team(&removed_member)- .await- .inspect_err(|rollback_err| {- tracing::error!(- error=?rollback_err,- "unable to rollback removed team member after removing team member from channels failed"- );- })- .ok();- return Err(RemoveUserFromTeamError::TeamError(e));- }+ };let roles_to_remove = vec![RoleId::TeamSubscriber, RoleId::SubOpus];let roles = non_empty::NonEmpty::new(roles_to_remove.as_slice()).unwrap();@@ -898,8 +897,8 @@ where.dangerous_remove_roles_from_user(user_id, &roles).await{- self.team_channels_repository- .add_team_member_to_channels(&team_id, user_id)+ self.channel_service+ .restore_by_channel_ids(user_id, &left_channel_ids).await.inspect_err(|rollback_err| {tracing::error!(@@ -1338,8 +1337,8 @@ where}if let Err(e) = self- .team_channels_repository- .add_team_member_to_channels(&team_member.team_id, user_id)+ .channel_service+ .auto_join_by_team_id(&team_member.team_id, user_id).await{if grants_premium {@@ -1377,7 +1376,7 @@ where);}).ok();- return Err(JoinTeamError::TeamError(e));+ return Err(JoinTeamError::TeamError(channel_error_to_team_error(e)));}// Best-effort: ask the email service to seed CRM tables from this@@ -1924,8 +1923,8 @@ where}if let Err(e) = self- .team_channels_repository- .add_team_member_to_channels(&team_id, user_id)+ .channel_service+ .auto_join_by_team_id(&team_id, user_id).await{if grants_premium {@@ -1955,7 +1954,7 @@ where}self.rollback_add_user_to_team(&team_id, user_id, "adding team member to channels").await;- return Err(JoinTeamError::TeamError(e).into());+ return Err(JoinTeamError::TeamError(channel_error_to_team_error(e)).into());}// Best-effort: ask the email service to seed CRM tables from thisdiff --git a/crates/teams/src/domain/team_service/test.rs b/crates/teams/src/domain/team_service/test.rsindex 1b77dbaa09..d6d7d6260c 100644--- a/crates/teams/src/domain/team_service/test.rs+++ b/crates/teams/src/domain/team_service/test.rs@@ -7,12 +7,23 @@ use std::{},};+use channels::domain::{+ models::{+ AttachmentEntityReference, ChannelAttachmentType, ChannelMessageFilters,+ ChannelParticipant, MessagePageDirection, ThreadReply,+ },+ ports::{+ ChannelAttachmentsPage, ChannelMessagesErr, ChannelMessagesQueryResult, ChannelMutationErr,+ ChannelService,+ },+};use entity_access::domain::models::{AdminTeamRole, EntityAccessReceipt, EntityType, MemberTeamRole, OwnerTeamRole,RequiredPermission,};use macro_event_broker::{EventBrokerError, MacroEvent, MacroEventBroker, Topic as _};use macro_user_id::{email::Email, lowercased::Lowercase, user_id::MacroUserIdStr};+use models_pagination::{CreatedAt, Query};use notification::domain::{models::{Notification, NotificationResult, request::SendNotificationRequest},service::{NotificationIngress, SendNotificationError},@@ -50,7 +61,7 @@ use crate::domain::{TeamInviteDetails, TeamInviteSnapshot, TeamMember, TeamPlan, TeamRole, TeamWithMembers,ToggleAutoJoinDomainError, TryJoinTeamByDomainError,},- team_repo::{TeamChannelsRepository, TeamRepository},+ team_repo::TeamRepository,};// -- Mock TeamRepository --@@ -833,31 +844,90 @@ impl CustomerRepository for MockCustomerRepository {}}-// -- Mock TeamChannelsRepository --+// -- Recording ChannelService --#[derive(Clone, Default)]-struct MockTeamChannelsRepository {- add_calls: Arc<Mutex<Vec<(uuid::Uuid, String)>>>,- remove_calls: Arc<Mutex<Vec<(uuid::Uuid, String)>>>,- fail_add: bool,- fail_remove: bool,-}+struct RecordingChannelService {+ auto_join_calls: Arc<Mutex<Vec<(uuid::Uuid, String)>>>,+ leave_calls: Arc<Mutex<Vec<(uuid::Uuid, String)>>>,+ restore_calls: Arc<Mutex<Vec<(String, Vec<uuid::Uuid>)>>>,+ leave_channel_ids: Vec<uuid::Uuid>,+ fail_auto_join: bool,+ fail_leave: bool,+ fail_restore: bool,+}++impl ChannelService for RecordingChannelService {+ fn get_channel_messages(+ &self,+ _channel_id: uuid::Uuid,+ _query: Query<uuid::Uuid, CreatedAt, ()>,+ _direction: MessagePageDirection,+ _limit: u16,+ _filters: &ChannelMessageFilters,+ _notification_user_id: Option<MacroUserIdStr<'static>>,+ ) -> impl Future<Output = Result<ChannelMessagesQueryResult, ChannelMessagesErr>> + Send {+ async move { unimplemented!("not needed for team service tests") }+ }++ fn get_channel_attachments(+ &self,+ _channel_id: uuid::Uuid,+ _query: Query<uuid::Uuid, CreatedAt, ()>,+ _limit: u16,+ _attachment_type: Option<ChannelAttachmentType>,+ ) -> impl Future<Output = Result<ChannelAttachmentsPage, ChannelMessagesErr>> + Send {+ async move { unimplemented!("not needed for team service tests") }+ }++ fn get_channel_participants(+ &self,+ _channel_id: uuid::Uuid,+ ) -> impl Future<Output = Result<Vec<ChannelParticipant>, ChannelMessagesErr>> + Send {+ async move { unimplemented!("not needed for team service tests") }+ }++ fn get_attachment_references(+ &self,+ _entity_type: String,+ _entity_id: String,+ _user_id: String,+ ) -> impl Future<Output = Result<Vec<AttachmentEntityReference>, ChannelMessagesErr>> + Send+ {+ async move { unimplemented!("not needed for team service tests") }+ }++ fn get_channel_messages_around(+ &self,+ _channel_id: uuid::Uuid,+ _message_id: uuid::Uuid,+ _limit: u16,+ ) -> impl Future<Output = Result<ChannelMessagesQueryResult, ChannelMessagesErr>> + Send {+ async move { unimplemented!("not needed for team service tests") }+ }++ fn get_thread_replies(+ &self,+ _channel_id: uuid::Uuid,+ _message_id: uuid::Uuid,+ ) -> impl Future<Output = Result<Vec<ThreadReply>, ChannelMessagesErr>> + Send {+ async move { unimplemented!("not needed for team service tests") }+ }-impl TeamChannelsRepository for MockTeamChannelsRepository {- fn add_team_member_to_channels(+ fn auto_join_by_team_id(&self,team_id: &uuid::Uuid,user_id: &MacroUserIdStr<'_>,- ) -> impl Future<Output = Result<(), TeamError>> + Send {- self.add_calls+ ) -> impl Future<Output = Result<(), ChannelMutationErr>> + Send {+ self.auto_join_calls.lock().unwrap().push((*team_id, user_id.as_ref().to_string()));- let fail = self.fail_add;+ let fail = self.fail_auto_join;async move {if fail {- Err(TeamError::StorageLayerError(anyhow::anyhow!(- "add channels failed"+ Err(ChannelMutationErr::Repo(anyhow::anyhow!(+ "auto-join channels failed")))} else {Ok(())@@ -865,20 +935,42 @@ impl TeamChannelsRepository for MockTeamChannelsRepository {}}- fn remove_team_member_from_channels(+ fn leave_by_team_id(&self,team_id: &uuid::Uuid,user_id: &MacroUserIdStr<'_>,- ) -> impl Future<Output = Result<(), TeamError>> + Send {- self.remove_calls+ ) -> impl Future<Output = Result<Vec<uuid::Uuid>, ChannelMutationErr>> + Send {+ self.leave_calls.lock().unwrap().push((*team_id, user_id.as_ref().to_string()));- let fail = self.fail_remove;+ let channel_ids = self.leave_channel_ids.clone();+ let fail = self.fail_leave;async move {if fail {- Err(TeamError::StorageLayerError(anyhow::anyhow!(- "remove channels failed"+ Err(ChannelMutationErr::Repo(anyhow::anyhow!(+ "leave channels failed"+ )))+ } else {+ Ok(channel_ids)+ }+ }+ }++ fn restore_by_channel_ids(+ &self,+ user_id: &MacroUserIdStr<'_>,+ channel_ids: &[uuid::Uuid],+ ) -> impl Future<Output = Result<(), ChannelMutationErr>> + Send {+ self.restore_calls+ .lock()+ .unwrap()+ .push((user_id.as_ref().to_string(), channel_ids.to_vec()));+ let fail = self.fail_restore;+ async move {+ if fail {+ Err(ChannelMutationErr::Repo(anyhow::anyhow!(+ "restore channels failed")))} else {Ok(())@@ -1342,7 +1434,7 @@ fn build_service(let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),notification_ingress.clone(),NoOpCrmEnqueuer,@@ -1358,7 +1450,7 @@ fn build_service_with_event_broker(TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -1370,7 +1462,7 @@ fn build_service_with_event_broker(fn build_service_with_analytics(team_repo: MockTeamRepository,customer_repo: MockCustomerRepository,- channels_repo: MockTeamChannelsRepository,+ channels_repo: RecordingChannelService,roles_service: MockUserRolesAndPermissionsService,team_analytics: MockTeamAnalytics,) -> impl TeamService {@@ -1406,7 +1498,7 @@ async fn event_broker_can_be_replaced_and_is_preserved_by_service_reconstructionlet default_service = TeamServiceImpl::new(MockTeamRepository::new(Vec::new(), "Event Team", mark_sent_calls),MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -1438,7 +1530,7 @@ async fn event_broker_can_be_replaced_and_is_preserved_by_service_reconstructionlet analytics_service = TeamServiceImpl::new_with_analytics(MockTeamRepository::new(Vec::new(), "Event Team", Arc::new(Mutex::new(Vec::new()))),MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -1722,7 +1814,7 @@ async fn team_payment_revoke_removes_exact_premium_roles_from_members() {let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),roles_service,Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -1762,7 +1854,7 @@ async fn team_payment_restore_adds_exact_premium_roles_to_members() {let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),roles_service,Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -1795,7 +1887,7 @@ async fn team_payment_patch_payment_status_delegates_to_repository() {let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -1836,7 +1928,7 @@ async fn test_create_team_moves_github_installation_to_created_team() {let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -1875,7 +1967,7 @@ async fn test_create_team_propagates_github_installation_move_failure() {let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -1915,7 +2007,7 @@ async fn team_analytics_create_team_emits_created_event_with_team_id() {let service = build_service_with_analytics(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),MockTeamAnalytics::new(events.clone()),);@@ -1965,7 +2057,7 @@ async fn team_analytics_failure_is_swallowed_by_create_team() {let service = build_service_with_analytics(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),MockTeamAnalytics::failing(events.clone()),);@@ -2002,7 +2094,7 @@ async fn team_analytics_create_team_does_not_emit_when_side_effect_fails() {let service = build_service_with_analytics(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),MockTeamAnalytics::new(events.clone()),);@@ -2034,7 +2126,7 @@ fn build_service_for_premium_check(no_active_subscription,..Default::default()},- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -2103,7 +2195,7 @@ async fn invite_users_to_team_enterprise_bypasses_billing_and_preserves_side_efflet service = TeamServiceImpl::new_with_analytics(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),notification_ingress.clone(),NoOpCrmEnqueuer,@@ -2180,7 +2272,7 @@ async fn invite_users_to_team_blocked_for_member_when_non_admin_invites_disabledlet service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -2228,7 +2320,7 @@ async fn invite_users_to_team_allowed_for_admin_when_non_admin_invites_disabled(let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -2264,7 +2356,7 @@ async fn toggle_allow_non_admin_invites_delegates_to_repository() {let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -2308,7 +2400,7 @@ async fn invite_users_to_team_enterprise_enforces_team_plan_seat_cap() {let service = TeamServiceImpl::new_with_analytics(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),notification_ingress.clone(),NoOpCrmEnqueuer,@@ -2357,7 +2449,7 @@ async fn invite_users_to_team_enterprise_status_lookup_failure_precedes_persistelet service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -2534,7 +2626,7 @@ async fn team_analytics_invite_users_emits_invited_events_with_team_id() {let service = build_service_with_analytics(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),MockTeamAnalytics::new(events.clone()),);@@ -2591,7 +2683,7 @@ async fn team_analytics_invite_users_does_not_emit_when_invite_creation_fails()let service = build_service_with_analytics(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),MockTeamAnalytics::new(events.clone()),);@@ -2638,7 +2730,7 @@ async fn test_get_team_reports_crm_enabled() {let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),notification_ingress,NoOpCrmEnqueuer,@@ -2723,7 +2815,7 @@ fn build_crm_enable_service(let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),notification_ingress,enqueuer,@@ -2792,7 +2884,7 @@ fn build_service_with_repo_and_broker(TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -2817,7 +2909,7 @@ fn build_service_with_team(let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),notification_ingress,NoOpCrmEnqueuer,@@ -3294,7 +3386,7 @@ async fn test_invite_users_to_team_backfills_legacy_team_subscription() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),notification_ingress,NoOpCrmEnqueuer,@@ -3336,7 +3428,7 @@ async fn join_team_enterprise_bypasses_billing_and_preserves_membership_side_efflet user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();let team_repository = make_enterprise_join_team_repository(team_id, invite_id, &user_id);let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository::default();+ let channels_repository = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService::default();let crm_enqueuer = RecordingCrmEnqueuer::default();let events = Arc::new(Mutex::new(Vec::new()));@@ -3374,10 +3466,10 @@ async fn join_team_enterprise_bypasses_billing_and_preserves_membership_side_eff);assert!(roles_service.remove_calls.lock().unwrap().is_empty());assert_eq!(- *channels_repository.add_calls.lock().unwrap(),+ *channels_repository.auto_join_calls.lock().unwrap(),vec![(team_id, user_id.as_ref().to_string())]);- assert!(channels_repository.remove_calls.lock().unwrap().is_empty());+ assert!(channels_repository.leave_calls.lock().unwrap().is_empty());assert_eq!(*crm_enqueuer.populated.lock().unwrap(),vec![user_id.as_ref().to_string()]@@ -3400,7 +3492,7 @@ async fn join_team_enterprise_rolls_back_accepted_invite_when_role_assignment_falet user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();let team_repository = make_enterprise_join_team_repository(team_id, invite_id, &user_id);let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository::default();+ let channels_repository = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService {fail_upsert: true,..Default::default()@@ -3433,7 +3525,13 @@ async fn join_team_enterprise_rolls_back_accepted_invite_when_role_assignment_faassert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);assert_eq!(roles_service.upsert_calls.lock().unwrap().len(), 1);assert!(roles_service.remove_calls.lock().unwrap().is_empty());- assert!(channels_repository.add_calls.lock().unwrap().is_empty());+ assert!(+ channels_repository+ .auto_join_calls+ .lock()+ .unwrap()+ .is_empty()+ );assert!(crm_enqueuer.populated.lock().unwrap().is_empty());assert!(events.lock().unwrap().is_empty());}@@ -3445,8 +3543,8 @@ async fn join_team_enterprise_rolls_back_roles_and_invite_when_channel_add_failslet user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();let team_repository = make_enterprise_join_team_repository(team_id, invite_id, &user_id);let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository {- fail_add: true,+ let channels_repository = RecordingChannelService {+ fail_auto_join: true,..Default::default()};let roles_service = MockUserRolesAndPermissionsService::default();@@ -3479,7 +3577,7 @@ async fn join_team_enterprise_rolls_back_roles_and_invite_when_channel_add_failsassert_eq!(roles_service.upsert_calls.lock().unwrap().len(), 1);assert_eq!(roles_service.remove_calls.lock().unwrap().len(), 1);assert_eq!(- *channels_repository.add_calls.lock().unwrap(),+ *channels_repository.auto_join_calls.lock().unwrap(),vec![(team_id, user_id.as_ref().to_string())]);assert!(crm_enqueuer.populated.lock().unwrap().is_empty());@@ -3494,7 +3592,7 @@ async fn join_team_enterprise_rolls_back_accepted_invite_when_status_read_fails(let mut team_repository = make_enterprise_join_team_repository(team_id, invite_id, &user_id);team_repository.fail_enterprise_status_lookup = true;let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository::default();+ let channels_repository = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService::default();let crm_enqueuer = RecordingCrmEnqueuer::default();let events = Arc::new(Mutex::new(Vec::new()));@@ -3524,7 +3622,13 @@ async fn join_team_enterprise_rolls_back_accepted_invite_when_status_read_fails(assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);assert!(roles_service.upsert_calls.lock().unwrap().is_empty());assert!(roles_service.remove_calls.lock().unwrap().is_empty());- assert!(channels_repository.add_calls.lock().unwrap().is_empty());+ assert!(+ channels_repository+ .auto_join_calls+ .lock()+ .unwrap()+ .is_empty()+ );assert!(crm_enqueuer.populated.lock().unwrap().is_empty());assert!(events.lock().unwrap().is_empty());}@@ -3547,7 +3651,7 @@ async fn join_team_rolls_back_accepted_invite_when_billing_lookup_fails() {let service = TeamServiceImpl::new(team_repository.clone(),MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -3613,7 +3717,7 @@ async fn test_join_team_backfills_legacy_team_subscription() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -3661,7 +3765,7 @@ async fn test_join_team_rolls_back_accept_when_backfill_fails() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -3711,7 +3815,7 @@ async fn test_join_team_owner_without_subscription_joins_as_free_team() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),roles_service.clone(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -3746,8 +3850,8 @@ async fn test_join_team_increments_customer_seat_count() {let increment_calls = customer_repo.increment_calls.clone();let decrement_calls = customer_repo.decrement_calls.clone();- let channels_repo = MockTeamChannelsRepository::default();- let add_channel_calls = channels_repo.add_calls.clone();+ let channels_repo = RecordingChannelService::default();+ let add_channel_calls = channels_repo.auto_join_calls.clone();let roles_service = MockUserRolesAndPermissionsService::default();let upsert_role_calls = roles_service.upsert_calls.clone();@@ -3795,7 +3899,7 @@ async fn team_analytics_join_team_emits_joined_event_with_team_id() {let service = build_service_with_analytics(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),MockTeamAnalytics::new(events.clone()),);@@ -3830,7 +3934,7 @@ async fn team_event_invite_join_uses_accepted_invite_snapshot() {let service = TeamServiceImpl::new(team_repository,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),RecordingCrmEnqueuer::failing(),@@ -3877,8 +3981,8 @@ async fn test_join_team_rolls_back_accept_when_customer_increment_fails() {..Default::default()};let increment_calls = customer_repo.increment_calls.clone();- let channels_repo = MockTeamChannelsRepository::default();- let add_channel_calls = channels_repo.add_calls.clone();+ let channels_repo = RecordingChannelService::default();+ let add_channel_calls = channels_repo.auto_join_calls.clone();let roles_service = MockUserRolesAndPermissionsService::default();let upsert_role_calls = roles_service.upsert_calls.clone();@@ -3931,8 +4035,8 @@ async fn test_remove_user_from_team_decrements_customer_seat_count() {let increment_calls = customer_repo.increment_calls.clone();let decrement_calls = customer_repo.decrement_calls.clone();- let channels_repo = MockTeamChannelsRepository::default();- let remove_channel_calls = channels_repo.remove_calls.clone();+ let channels_repo = RecordingChannelService::default();+ let remove_channel_calls = channels_repo.leave_calls.clone();let roles_service = MockUserRolesAndPermissionsService::default();let remove_role_calls = roles_service.remove_calls.clone();@@ -3990,7 +4094,7 @@ async fn team_analytics_remove_user_from_team_emits_left_event_with_team_id() {let service = build_service_with_analytics(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),MockTeamAnalytics::new(events.clone()),);@@ -4031,7 +4135,7 @@ async fn team_event_self_service_removal_uses_member_as_actor_and_previous_role(let service = TeamServiceImpl::new(team_repository,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),RecordingCrmEnqueuer::failing(),@@ -4080,8 +4184,8 @@ async fn test_remove_user_from_team_rolls_back_remove_when_customer_decrement_fa..Default::default()};let decrement_calls = customer_repo.decrement_calls.clone();- let channels_repo = MockTeamChannelsRepository::default();- let remove_channel_calls = channels_repo.remove_calls.clone();+ let channels_repo = RecordingChannelService::default();+ let remove_channel_calls = channels_repo.leave_calls.clone();let roles_service = MockUserRolesAndPermissionsService::default();let remove_role_calls = roles_service.remove_calls.clone();@@ -4133,8 +4237,8 @@ async fn test_join_team_rolls_back_customer_roles_and_accept_when_channel_add_fa};let increment_calls = customer_repo.increment_calls.clone();let decrement_calls = customer_repo.decrement_calls.clone();- let channels_repo = MockTeamChannelsRepository {- fail_add: true,+ let channels_repo = RecordingChannelService {+ fail_auto_join: true,..Default::default()};let roles_service = MockUserRolesAndPermissionsService::default();@@ -4182,8 +4286,8 @@ async fn team_analytics_join_team_does_not_emit_when_join_is_rolled_back() {subscription_id,..Default::default()};- let channels_repo = MockTeamChannelsRepository {- fail_add: true,+ let channels_repo = RecordingChannelService {+ fail_auto_join: true,..Default::default()};let events = Arc::new(Mutex::new(Vec::new()));@@ -4224,8 +4328,8 @@ async fn test_remove_user_from_team_rolls_back_customer_and_remove_when_channel_};let increment_calls = customer_repo.increment_calls.clone();let decrement_calls = customer_repo.decrement_calls.clone();- let channels_repo = MockTeamChannelsRepository {- fail_remove: true,+ let channels_repo = RecordingChannelService {+ fail_leave: true,..Default::default()};let roles_service = MockUserRolesAndPermissionsService::default();@@ -4282,8 +4386,8 @@ async fn team_analytics_remove_user_from_team_does_not_emit_when_remove_is_rollesubscription_id,..Default::default()};- let channels_repo = MockTeamChannelsRepository {- fail_remove: true,+ let channels_repo = RecordingChannelService {+ fail_leave: true,..Default::default()};let events = Arc::new(Mutex::new(Vec::new()));@@ -4321,7 +4425,7 @@ async fn test_try_join_team_by_domain_no_matching_team_returns_none() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -4358,8 +4462,8 @@ async fn test_try_join_team_by_domain_adds_member_directly() {let increment_calls = customer_repo.increment_calls.clone();let decrement_calls = customer_repo.decrement_calls.clone();- let channels_repo = MockTeamChannelsRepository::default();- let add_channel_calls = channels_repo.add_calls.clone();+ let channels_repo = RecordingChannelService::default();+ let add_channel_calls = channels_repo.auto_join_calls.clone();let roles_service = MockUserRolesAndPermissionsService::default();let upsert_role_calls = roles_service.upsert_calls.clone();@@ -4413,7 +4517,7 @@ async fn test_try_join_team_by_domain_returns_none_when_already_member() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -4453,7 +4557,7 @@ async fn test_try_join_team_by_domain_skips_team_at_seat_cap() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -4500,7 +4604,7 @@ async fn test_try_join_team_by_domain_rolls_back_membership_when_roles_fail() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),roles_service,Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -4548,7 +4652,7 @@ async fn try_join_team_by_domain_rolls_back_membership_when_billing_lookup_failslet service = TeamServiceImpl::new(team_repository.clone(),MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -4586,7 +4690,7 @@ async fn try_join_team_by_domain_enterprise_bypasses_billing_and_preserves_side_let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();let team_repository = make_enterprise_domain_join_team_repository(team_id, &user_id);let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository::default();+ let channels_repository = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService::default();let crm_enqueuer = RecordingCrmEnqueuer::default();let events = Arc::new(Mutex::new(Vec::new()));@@ -4632,10 +4736,10 @@ async fn try_join_team_by_domain_enterprise_bypasses_billing_and_preserves_side_);assert!(roles_service.remove_calls.lock().unwrap().is_empty());assert_eq!(- *channels_repository.add_calls.lock().unwrap(),+ *channels_repository.auto_join_calls.lock().unwrap(),vec![(team_id, user_id.as_ref().to_string())]);- assert!(channels_repository.remove_calls.lock().unwrap().is_empty());+ assert!(channels_repository.leave_calls.lock().unwrap().is_empty());assert_eq!(*crm_enqueuer.populated.lock().unwrap(),vec![user_id.as_ref().to_string()]@@ -4662,7 +4766,7 @@ async fn try_join_team_by_domain_enterprise_still_enforces_local_seat_cap() {team_repository.team_plan = Some(TeamPlan::Idea);team_repository.seat_count = TeamPlan::Idea.seat_cap();let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository::default();+ let channels_repository = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService::default();let crm_enqueuer = RecordingCrmEnqueuer::default();let events = Arc::new(Mutex::new(Vec::new()));@@ -4692,7 +4796,13 @@ async fn try_join_team_by_domain_enterprise_still_enforces_local_seat_cap() {assert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 0);assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);assert!(roles_service.upsert_calls.lock().unwrap().is_empty());- assert!(channels_repository.add_calls.lock().unwrap().is_empty());+ assert!(+ channels_repository+ .auto_join_calls+ .lock()+ .unwrap()+ .is_empty()+ );assert!(crm_enqueuer.populated.lock().unwrap().is_empty());assert!(events.lock().unwrap().is_empty());}@@ -4703,7 +4813,7 @@ async fn try_join_team_by_domain_enterprise_rolls_back_membership_when_roles_failet user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();let team_repository = make_enterprise_domain_join_team_repository(team_id, &user_id);let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository::default();+ let channels_repository = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService {fail_upsert: true,..Default::default()@@ -4733,7 +4843,13 @@ async fn try_join_team_by_domain_enterprise_rolls_back_membership_when_roles_faiassert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);assert_eq!(roles_service.upsert_calls.lock().unwrap().len(), 1);assert!(roles_service.remove_calls.lock().unwrap().is_empty());- assert!(channels_repository.add_calls.lock().unwrap().is_empty());+ assert!(+ channels_repository+ .auto_join_calls+ .lock()+ .unwrap()+ .is_empty()+ );assert!(crm_enqueuer.populated.lock().unwrap().is_empty());assert!(events.lock().unwrap().is_empty());}@@ -4744,8 +4860,8 @@ async fn try_join_team_by_domain_enterprise_rolls_back_roles_when_channels_fail(let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();let team_repository = make_enterprise_domain_join_team_repository(team_id, &user_id);let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository {- fail_add: true,+ let channels_repository = RecordingChannelService {+ fail_auto_join: true,..Default::default()};let roles_service = MockUserRolesAndPermissionsService::default();@@ -4775,7 +4891,7 @@ async fn try_join_team_by_domain_enterprise_rolls_back_roles_when_channels_fail(assert_eq!(roles_service.upsert_calls.lock().unwrap().len(), 1);assert_eq!(roles_service.remove_calls.lock().unwrap().len(), 1);assert_eq!(- *channels_repository.add_calls.lock().unwrap(),+ *channels_repository.auto_join_calls.lock().unwrap(),vec![(team_id, user_id.as_ref().to_string())]);assert!(crm_enqueuer.populated.lock().unwrap().is_empty());@@ -4790,7 +4906,7 @@ async fn remove_user_from_team_enterprise_bypasses_billing_and_preserves_side_eflet team_repository =make_enterprise_remove_user_repository(team_id, &member_id, TeamRole::Admin);let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository::default();+ let channels_repository = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService::default();let crm_enqueuer = RecordingCrmEnqueuer::default();let events = Arc::new(Mutex::new(Vec::new()));@@ -4827,10 +4943,16 @@ async fn remove_user_from_team_enterprise_bypasses_billing_and_preserves_side_efassert_eq!(*team_repository.rollback_remove_calls.lock().unwrap(), 0);assert_no_enterprise_remove_user_billing_calls(&team_repository, &customer_repository);assert_eq!(- *channels_repository.remove_calls.lock().unwrap(),+ *channels_repository.leave_calls.lock().unwrap(),vec![(team_id, member_id.as_ref().to_string())]);- assert!(channels_repository.add_calls.lock().unwrap().is_empty());+ assert!(+ channels_repository+ .auto_join_calls+ .lock()+ .unwrap()+ .is_empty()+ );assert_eq!(*roles_service.remove_calls.lock().unwrap(),vec![(@@ -4871,8 +4993,8 @@ async fn remove_user_from_team_enterprise_rolls_back_membership_when_channel_remlet team_repository =make_enterprise_remove_user_repository(team_id, &member_id, TeamRole::Member);let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository {- fail_remove: true,+ let channels_repository = RecordingChannelService {+ fail_leave: true,..Default::default()};let roles_service = MockUserRolesAndPermissionsService::default();@@ -4906,10 +5028,16 @@ async fn remove_user_from_team_enterprise_rolls_back_membership_when_channel_remassert_eq!(*team_repository.rollback_remove_calls.lock().unwrap(), 1);assert_no_enterprise_remove_user_billing_calls(&team_repository, &customer_repository);assert_eq!(- *channels_repository.remove_calls.lock().unwrap(),+ *channels_repository.leave_calls.lock().unwrap(),vec![(team_id, member_id.as_ref().to_string())]);- assert!(channels_repository.add_calls.lock().unwrap().is_empty());+ assert!(+ channels_repository+ .auto_join_calls+ .lock()+ .unwrap()+ .is_empty()+ );assert!(roles_service.remove_calls.lock().unwrap().is_empty());assert!(crm_enqueuer.depopulated.lock().unwrap().is_empty());assert!(events.lock().unwrap().is_empty());@@ -4924,7 +5052,12 @@ async fn remove_user_from_team_enterprise_rolls_back_membership_and_channels_whelet team_repository =make_enterprise_remove_user_repository(team_id, &member_id, TeamRole::Member);let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository::default();+ let left_channel_ids = vec![uuid::Uuid::from_u128(9301), uuid::Uuid::from_u128(9302)];+ let channels_repository = RecordingChannelService {+ leave_channel_ids: left_channel_ids.clone(),+ fail_restore: true,+ ..Default::default()+ };let roles_service = MockUserRolesAndPermissionsService {fail_remove: true,..Default::default()@@ -4959,12 +5092,19 @@ async fn remove_user_from_team_enterprise_rolls_back_membership_and_channels_wheassert_eq!(*team_repository.rollback_remove_calls.lock().unwrap(), 1);assert_no_enterprise_remove_user_billing_calls(&team_repository, &customer_repository);assert_eq!(- *channels_repository.remove_calls.lock().unwrap(),+ *channels_repository.leave_calls.lock().unwrap(),vec![(team_id, member_id.as_ref().to_string())]);+ assert!(+ channels_repository+ .auto_join_calls+ .lock()+ .unwrap()+ .is_empty()+ );assert_eq!(- *channels_repository.add_calls.lock().unwrap(),- vec![(team_id, member_id.as_ref().to_string())]+ *channels_repository.restore_calls.lock().unwrap(),+ vec![(member_id.as_ref().to_string(), left_channel_ids)]);assert_eq!(roles_service.remove_calls.lock().unwrap().len(), 1);assert!(crm_enqueuer.depopulated.lock().unwrap().is_empty());@@ -4980,7 +5120,7 @@ async fn remove_user_from_team_enterprise_status_read_precedes_membership_removamake_enterprise_remove_user_repository(team_id, &member_id, TeamRole::Member);team_repository.fail_enterprise_status_lookup = true;let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository::default();+ let channels_repository = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService::default();let crm_enqueuer = RecordingCrmEnqueuer::default();let events = Arc::new(Mutex::new(Vec::new()));@@ -5018,8 +5158,14 @@ async fn remove_user_from_team_enterprise_status_read_precedes_membership_removaassert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 0);assert_eq!(*team_repository.rollback_remove_calls.lock().unwrap(), 0);assert_no_enterprise_remove_user_billing_calls(&team_repository, &customer_repository);- assert!(channels_repository.remove_calls.lock().unwrap().is_empty());- assert!(channels_repository.add_calls.lock().unwrap().is_empty());+ assert!(channels_repository.leave_calls.lock().unwrap().is_empty());+ assert!(+ channels_repository+ .auto_join_calls+ .lock()+ .unwrap()+ .is_empty()+ );assert!(roles_service.remove_calls.lock().unwrap().is_empty());assert!(crm_enqueuer.depopulated.lock().unwrap().is_empty());assert!(events.lock().unwrap().is_empty());@@ -5055,7 +5201,7 @@ async fn team_contacts_invite_join_enqueues_distinct_owner_and_member_edges() {let service = TeamServiceImpl::new(team_repository,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5098,7 +5244,7 @@ async fn team_contacts_invite_join_swallows_enqueue_failure_without_rollback() {let service = TeamServiceImpl::new(team_repository.clone(),MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5123,7 +5269,7 @@ async fn team_contacts_invite_join_swallows_roster_failure() {let service = TeamServiceImpl::new(team_repository.clone(),MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5158,7 +5304,7 @@ async fn team_contacts_invite_join_skips_empty_connection_batch() {let service = TeamServiceImpl::new(team_repository,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5191,8 +5337,8 @@ async fn team_contacts_invite_join_does_not_enqueue_when_channel_work_rolls_backlet service = TeamServiceImpl::new(team_repository.clone(),MockCustomerRepository::default(),- MockTeamChannelsRepository {- fail_add: true,+ RecordingChannelService {+ fail_auto_join: true,..Default::default()},MockUserRolesAndPermissionsService::default(),@@ -5235,7 +5381,7 @@ async fn team_contacts_domain_join_enqueues_distinct_owner_and_member_edges() {let service = TeamServiceImpl::new(team_repository,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5273,7 +5419,7 @@ async fn team_contacts_domain_join_does_not_enqueue_without_matching_team() {let service = TeamServiceImpl::new(team_repository.clone(),MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5303,7 +5449,7 @@ async fn team_contacts_domain_join_does_not_enqueue_for_existing_member() {let service = TeamServiceImpl::new(team_repository.clone(),MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5339,7 +5485,7 @@ async fn team_contacts_domain_join_does_not_enqueue_at_seat_cap() {let service = TeamServiceImpl::new(team_repository.clone(),MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5362,7 +5508,7 @@ async fn try_join_team_by_domain_enterprise_status_read_precedes_membership_mutalet mut team_repository = make_enterprise_domain_join_team_repository(team_id, &user_id);team_repository.fail_enterprise_status_lookup = true;let customer_repository = MockCustomerRepository::default();- let channels_repository = MockTeamChannelsRepository::default();+ let channels_repository = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService::default();let crm_enqueuer = RecordingCrmEnqueuer::default();let events = Arc::new(Mutex::new(Vec::new()));@@ -5395,7 +5541,13 @@ async fn try_join_team_by_domain_enterprise_status_read_precedes_membership_mutaassert_eq!(*team_repository.remove_user_calls.lock().unwrap(), 0);assert_no_enterprise_join_team_billing_calls(&team_repository, &customer_repository);assert!(roles_service.upsert_calls.lock().unwrap().is_empty());- assert!(channels_repository.add_calls.lock().unwrap().is_empty());+ assert!(+ channels_repository+ .auto_join_calls+ .lock()+ .unwrap()+ .is_empty()+ );assert!(crm_enqueuer.populated.lock().unwrap().is_empty());assert!(events.lock().unwrap().is_empty());}@@ -5414,7 +5566,7 @@ async fn create_team_without_subscription_skips_convert_and_defaults_auto_join()let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5449,7 +5601,7 @@ async fn create_team_with_subscription_converts_and_defaults_auto_join() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5479,7 +5631,7 @@ async fn create_team_generic_domain_does_not_default_auto_join() {let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5520,7 +5672,7 @@ async fn invite_users_to_team_free_team_under_cap_skips_billing() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),notification_ingress.clone(),NoOpCrmEnqueuer,@@ -5567,7 +5719,7 @@ async fn invite_users_to_team_free_team_enforces_member_cap() {let service = TeamServiceImpl::new(team_repo,MockCustomerRepository::default(),- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),MockUserRolesAndPermissionsService::default(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,@@ -5607,7 +5759,7 @@ async fn join_team_free_team_skips_billing_and_premium_roles() {let customer_repo = MockCustomerRepository::default();let increment_calls = customer_repo.increment_calls.clone();- let channels_repo = MockTeamChannelsRepository::default();+ let channels_repo = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService::default();let events = Arc::new(Mutex::new(Vec::new()));@@ -5630,7 +5782,7 @@ async fn join_team_free_team_skips_billing_and_premium_roles() {// Free teams do not grant premium roles.assert!(roles_service.upsert_calls.lock().unwrap().is_empty());assert_eq!(- *channels_repo.add_calls.lock().unwrap(),+ *channels_repo.auto_join_calls.lock().unwrap(),vec![(team_id, user_id.as_ref().to_string())]);assert_eq!(events.lock().unwrap().len(), 1);@@ -5651,7 +5803,7 @@ async fn join_team_free_team_over_cap_rolls_back() {let customer_repo = MockCustomerRepository::default();let increment_calls = customer_repo.increment_calls.clone();- let channels_repo = MockTeamChannelsRepository::default();+ let channels_repo = RecordingChannelService::default();let roles_service = MockUserRolesAndPermissionsService::default();let service = TeamServiceImpl::new(@@ -5670,7 +5822,7 @@ async fn join_team_free_team_over_cap_rolls_back() {assert_eq!(*rollback_accept_calls.lock().unwrap(), 1);assert!(increment_calls.lock().unwrap().is_empty());assert!(roles_service.upsert_calls.lock().unwrap().is_empty());- assert!(channels_repo.add_calls.lock().unwrap().is_empty());+ assert!(channels_repo.auto_join_calls.lock().unwrap().is_empty());}#[tokio::test]@@ -5700,7 +5852,7 @@ async fn try_join_team_by_domain_free_team_at_cap_skips() {let service = TeamServiceImpl::new(team_repo,customer_repo,- MockTeamChannelsRepository::default(),+ RecordingChannelService::default(),roles_service.clone(),Arc::new(MockNotificationIngress::new(HashSet::new())),NoOpCrmEnqueuer,diff --git a/crates/teams/src/outbound.rs b/crates/teams/src/outbound.rsindex 9ad53cd5cd..4563134c10 100644--- a/crates/teams/src/outbound.rs+++ b/crates/teams/src/outbound.rs@@ -2,6 +2,5 @@ pub mod contacts_enqueuer;pub mod crm_enqueuer;pub mod customer_repo;pub mod team_analytics;-pub mod team_channels_repo;pub mod team_crm_settings_repo;pub mod team_repo;diff --git a/crates/teams/src/outbound/team_channels_repo.rs b/crates/teams/src/outbound/team_channels_repo.rsdeleted file mode 100644index 1ae36c1b1b..0000000000--- a/crates/teams/src/outbound/team_channels_repo.rs+++ /dev/null@@ -1,71 +0,0 @@-//! Implementation for TeamChannelsRepository using MacroDB.-use crate::domain::{model::TeamError, team_repo::TeamChannelsRepository};-use macro_user_id::user_id::MacroUserIdStr;-use sqlx::PgPool;--#[cfg(test)]-mod test;--/// The TeamChannelsRepositoryImpl struct is a wrapper around sqlx::PgPool connected to macrodb.-#[derive(Clone)]-pub struct TeamChannelsRepositoryImpl {- /// The underlying sqlx::PgPool connected to macrodb.- pool: PgPool,-}--impl TeamChannelsRepositoryImpl {- /// Creates a new instance of TeamChannelsRepositoryImpl- pub fn new(pool: PgPool) -> Self {- Self { pool }- }-}--impl TeamChannelsRepository for TeamChannelsRepositoryImpl {- #[tracing::instrument(skip(self), err)]- async fn add_team_member_to_channels(- &self,- team_id: &uuid::Uuid,- user_id: &MacroUserIdStr<'_>,- ) -> Result<(), TeamError> {- sqlx::query!(- r#"- INSERT INTO comms_channel_participants (channel_id, user_id, role, joined_at)- SELECT cc.id, $2, 'member'::comms_participant_role, NOW()- FROM comms_channels cc- WHERE cc.team_id = $1- ON CONFLICT (channel_id, user_id) DO NOTHING- "#,- team_id,- user_id.as_ref(),- )- .execute(&self.pool)- .await- .map_err(|e| TeamError::StorageLayerError(e.into()))?;-- Ok(())- }-- #[tracing::instrument(skip(self), err)]- async fn remove_team_member_from_channels(- &self,- team_id: &uuid::Uuid,- user_id: &MacroUserIdStr<'_>,- ) -> Result<(), TeamError> {- sqlx::query!(- r#"- DELETE FROM comms_channel_participants- WHERE user_id = $2- AND channel_id IN (- SELECT id FROM comms_channels WHERE team_id = $1- )- "#,- team_id,- user_id.as_ref(),- )- .execute(&self.pool)- .await- .map_err(|e| TeamError::StorageLayerError(e.into()))?;-- Ok(())- }-}diff --git a/crates/teams/src/outbound/team_channels_repo/test.rs b/crates/teams/src/outbound/team_channels_repo/test.rsdeleted file mode 100644index e69fbc862f..0000000000--- a/crates/teams/src/outbound/team_channels_repo/test.rs+++ /dev/null@@ -1,130 +0,0 @@-use macro_db_migrator::MACRO_DB_MIGRATIONS;-use macro_user_id::user_id::MacroUserIdStr;-use sqlx::{Pool, Postgres};--use super::*;--#[sqlx::test(- migrator = "MACRO_DB_MIGRATIONS",- fixtures(path = "../../../fixtures", scripts("team_channels"))-)]-async fn test_add_team_member_to_channels(pool: Pool<Postgres>) -> anyhow::Result<()> {- let repo = TeamChannelsRepositoryImpl::new(pool.clone());-- let team_id = macro_uuid::string_to_uuid("11111111-1111-1111-1111-111111111111")?;- let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]")?;-- repo.add_team_member_to_channels(&team_id, &user_id).await?;-- // Verify user3 was added to both team channels- let count = sqlx::query_scalar!(- r#"- SELECT COUNT(*) as "count!"- FROM comms_channel_participants- WHERE user_id = $1- AND role = 'member'::comms_participant_role- "#,- user_id.as_ref(),- )- .fetch_one(&pool)- .await?;-- assert_eq!(count, 2);-- // Calling again should be idempotent (ON CONFLICT DO NOTHING)- repo.add_team_member_to_channels(&team_id, &user_id).await?;-- let count = sqlx::query_scalar!(- r#"- SELECT COUNT(*) as "count!"- FROM comms_channel_participants- WHERE user_id = $1- AND role = 'member'::comms_participant_role- "#,- user_id.as_ref(),- )- .fetch_one(&pool)- .await?;-- assert_eq!(count, 2);-- Ok(())-}--#[sqlx::test(- migrator = "MACRO_DB_MIGRATIONS",- fixtures(path = "../../../fixtures", scripts("team_channels"))-)]-async fn test_remove_team_member_from_channels(pool: Pool<Postgres>) -> anyhow::Result<()> {- let repo = TeamChannelsRepositoryImpl::new(pool.clone());-- let team_id = macro_uuid::string_to_uuid("11111111-1111-1111-1111-111111111111")?;- let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]")?;-- // Verify user2 is in both channels before removal- let count = sqlx::query_scalar!(- r#"- SELECT COUNT(*) as "count!"- FROM comms_channel_participants- WHERE user_id = $1- "#,- user_id.as_ref(),- )- .fetch_one(&pool)- .await?;-- assert_eq!(count, 2);-- repo.remove_team_member_from_channels(&team_id, &user_id)- .await?;-- // Verify user2 was removed from both team channels- let count = sqlx::query_scalar!(- r#"- SELECT COUNT(*) as "count!"- FROM comms_channel_participants- WHERE user_id = $1- "#,- user_id.as_ref(),- )- .fetch_one(&pool)- .await?;-- assert_eq!(count, 0);-- // Removing again should be a no-op- repo.remove_team_member_from_channels(&team_id, &user_id)- .await?;-- Ok(())-}--#[sqlx::test(- migrator = "MACRO_DB_MIGRATIONS",- fixtures(path = "../../../fixtures", scripts("team_channels"))-)]-async fn test_add_member_to_team_with_no_channels(pool: Pool<Postgres>) -> anyhow::Result<()> {- let repo = TeamChannelsRepositoryImpl::new(pool.clone());-- // Use a team_id that has no channels- let team_id = macro_uuid::string_to_uuid("99999999-9999-9999-9999-999999999999")?;- let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]")?;-- // Should succeed without inserting anything- repo.add_team_member_to_channels(&team_id, &user_id).await?;-- let count = sqlx::query_scalar!(- r#"- SELECT COUNT(*) as "count!"- FROM comms_channel_participants- WHERE user_id = $1- "#,- user_id.as_ref(),- )- .fetch_one(&pool)- .await?;-- assert_eq!(count, 0);-- Ok(())-}diff --git a/services/authentication_service/Cargo.toml b/services/authentication_service/Cargo.tomlindex 232e09d1c3..b1c3abc845 100644--- a/services/authentication_service/Cargo.toml+++ b/services/authentication_service/Cargo.toml@@ -41,6 +41,9 @@ aws-sdk-sesv2 = { workspace = true }aws-sdk-sqs = { workspace = true }axum = { workspace = true, features = ["macros"] }base64 = { workspace = true }+channels = { path = "../../crates/channels", default-features = false, features = [+ "outbound",+] }chrono = { workspace = true }comms_db_client = { path = "../../crates/comms_db_client" }contacts = { path = "../../crates/contacts", default-features = false, features = [diff --git a/services/authentication_service/src/api/context.rs b/services/authentication_service/src/api/context.rsindex e8e9c6db90..324c0fdd7f 100644--- a/services/authentication_service/src/api/context.rs+++ b/services/authentication_service/src/api/context.rs@@ -41,7 +41,9 @@ pub(crate) type NotificationIngressType = SqsNotificationIngress<SqsQueue>;pub(crate) type TeamsServiceType = teams::domain::team_service::TeamServiceImpl<teams::outbound::team_repo::TeamRepositoryImpl,teams::outbound::customer_repo::CustomerRepositoryImpl,- teams::outbound::team_channels_repo::TeamChannelsRepositoryImpl,+ channels::domain::service::ChannelServiceImpl<+ channels::outbound::pg_channels_repo::PgChannelsRepo,+ >,UserRolesAndPermissionsServiceImpl<MacroDB, MacroDB>,NotificationIngressType,teams::outbound::crm_enqueuer::SqsCrmEnqueuer,diff --git a/services/authentication_service/src/main.rs b/services/authentication_service/src/main.rsindex 1a8208fe68..b7c3aab060 100644--- a/services/authentication_service/src/main.rs+++ b/services/authentication_service/src/main.rs@@ -3,6 +3,7 @@ use analytics_client::{AnalyticsClient, AnalyticsClientConfig, GoogleAnalyticsConfig, MetaConfig, PostHogConfig,};use anyhow::{Context, anyhow};+use channels::{domain::service::ChannelServiceImpl, outbound::pg_channels_repo::PgChannelsRepo};use config::{Config, Environment};use contacts::{domain::service::SqsContactsIngress, outbound::ingress::SqsContactsQueue};use document_storage_service_client::DocumentStorageServiceClient;@@ -44,8 +45,7 @@ use teams::{domain::team_service::TeamServiceImpl,outbound::{contacts_enqueuer::ContactsIngressEnqueuer, customer_repo::CustomerRepositoryImpl,- team_analytics::AnalyticsClientTeamAnalytics,- team_channels_repo::TeamChannelsRepositoryImpl, team_repo::TeamRepositoryImpl,+ team_analytics::AnalyticsClientTeamAnalytics, team_repo::TeamRepositoryImpl,},};@@ -283,7 +283,7 @@ async fn main() -> anyhow::Result<()> {stripe_client.clone(),config.stripe_price_id.to_string().clone(),);- let team_channels_repo_impl = TeamChannelsRepositoryImpl::new(db.clone());+ let channel_service = ChannelServiceImpl::new(PgChannelsRepo::new(db.clone()));let team_crm_settings_repo_impl =teams::outbound::team_crm_settings_repo::TeamCrmSettingsRepositoryImpl::new(db.clone());@@ -306,7 +306,7 @@ async fn main() -> anyhow::Result<()> {let teams_service_impl = TeamServiceImpl::new_with_analytics(teams_repo_impl,customer_repo_impl,- team_channels_repo_impl,+ channel_service,user_roles_and_permissions_service.clone(),notification_ingress_service.clone(),crm_enqueuer,