Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

feat(channels): add in viewonly channel access (#5064)

Will Hutchinson625335727018
diff --git a/.sqlx/query-1c03d1e837124187c0f4b940ee6863ec370be7dc1b87c38d1c53d898bfa6a235.json b/.sqlx/query-1c03d1e837124187c0f4b940ee6863ec370be7dc1b87c38d1c53d898bfa6a235.json
deleted file mode 100644
index 7bafd18b74..0000000000
--- a/.sqlx/query-1c03d1e837124187c0f4b940ee6863ec370be7dc1b87c38d1c53d898bfa6a235.json
+++ /dev/null
@@ -1,35 +0,0 @@
-{
- "db_name": "PostgreSQL",
- "query": "\n SELECT\n cp.role::text as \"role?\",\n c.channel_type::text as \"channel_type!\",\n c.org_id as \"org_id?\"\n FROM comms_channels c\n LEFT JOIN comms_channel_participants cp\n ON cp.channel_id = c.id AND cp.user_id = $2 AND cp.left_at IS NULL\n WHERE c.id = $1\n ",
- "describe": {
- "columns": [
- {
- "ordinal": 0,
- "name": "role?",
- "type_info": "Text"
- },
- {
- "ordinal": 1,
- "name": "channel_type!",
- "type_info": "Text"
- },
- {
- "ordinal": 2,
- "name": "org_id?",
- "type_info": "Int8"
- }
- ],
- "parameters": {
- "Left": [
- "Uuid",
- "Text"
- ]
- },
- "nullable": [
- null,
- null,
- true
- ]
- },
- "hash": "1c03d1e837124187c0f4b940ee6863ec370be7dc1b87c38d1c53d898bfa6a235"
-}
diff --git a/.sqlx/query-6f1e5783e442e0082571b5509505fe82f8b23f6f53c4bda18e9e656a6ca79c78.json b/.sqlx/query-6f1e5783e442e0082571b5509505fe82f8b23f6f53c4bda18e9e656a6ca79c78.json
new file mode 100644
index 0000000000..de099bf428
--- /dev/null
+++ b/.sqlx/query-6f1e5783e442e0082571b5509505fe82f8b23f6f53c4bda18e9e656a6ca79c78.json
@@ -0,0 +1,41 @@
+{
+ "db_name": "PostgreSQL",
+ "query": "\n SELECT\n cp.role::text as \"role?\",\n c.channel_type::text as \"channel_type!\",\n c.org_id as \"org_id?\",\n EXISTS (\n SELECT 1\n FROM team_user tu\n WHERE tu.user_id = $2 AND tu.team_id = c.team_id\n ) as \"is_team_member!\"\n FROM comms_channels c\n LEFT JOIN comms_channel_participants cp\n ON cp.channel_id = c.id AND cp.user_id = $2 AND cp.left_at IS NULL\n WHERE c.id = $1\n ",
+ "describe": {
+ "columns": [
+ {
+ "ordinal": 0,
+ "name": "role?",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 1,
+ "name": "channel_type!",
+ "type_info": "Text"
+ },
+ {
+ "ordinal": 2,
+ "name": "org_id?",
+ "type_info": "Int8"
+ },
+ {
+ "ordinal": 3,
+ "name": "is_team_member!",
+ "type_info": "Bool"
+ }
+ ],
+ "parameters": {
+ "Left": [
+ "Uuid",
+ "Text"
+ ]
+ },
+ "nullable": [
+ null,
+ null,
+ true,
+ null
+ ]
+ },
+ "hash": "6f1e5783e442e0082571b5509505fe82f8b23f6f53c4bda18e9e656a6ca79c78"
+}
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermission.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermission.ts
index 03f863e855..ce3834a3fd 100644
--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermission.ts
+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermission.ts
@@ -6,15 +6,17 @@
*/
import type { EntityPermissionOneOf } from './entityPermissionOneOf';
import type { EntityPermissionOneOfFive } from './entityPermissionOneOfFive';
+import type { EntityPermissionOneOfSeven } from './entityPermissionOneOfSeven';
import type { EntityPermissionOneOfThree } from './entityPermissionOneOfThree';
/**
* A user's permission for an entity, discriminated by entity kind.
Items (documents, chats, projects, threads) use access levels.
-Channels use participant roles.
+Channels use view-only permission or participant roles.
*/
export type EntityPermission =
| EntityPermissionOneOf
| EntityPermissionOneOfThree
- | EntityPermissionOneOfFive;
+ | EntityPermissionOneOfFive
+ | EntityPermissionOneOfSeven;
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfFive.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfFive.ts
index 1313527843..d503ffef16 100644
--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfFive.ts
+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfFive.ts
@@ -6,13 +6,13 @@
*/
import type { EntityPermissionOneOfFiveType } from './entityPermissionOneOfFiveType';
-import type { TeamRole } from './teamRole';
+import type { ParticipantRole } from './participantRole';
/**
- * Permission for team-based entities.
+ * Permission for channel-based entities with an active participant role.
*/
export type EntityPermissionOneOfFive = {
- /** The role the user has in the team. */
- role: TeamRole;
+ /** The role the user has in the channel. */
+ role: ParticipantRole;
type: EntityPermissionOneOfFiveType;
};
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfFiveType.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfFiveType.ts
index 025be0633b..c45de40c60 100644
--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfFiveType.ts
+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfFiveType.ts
@@ -10,5 +10,5 @@ export type EntityPermissionOneOfFiveType =
// eslint-disable-next-line @typescript-eslint/no-redeclare
export const EntityPermissionOneOfFiveType = {
- team_role: 'team_role',
+ channel_role: 'channel_role',
} as const;
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfSeven.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfSeven.ts
new file mode 100644
index 0000000000..1d7d9e84ef
--- /dev/null
+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfSeven.ts
@@ -0,0 +1,18 @@
+/**
+ * Generated by orval v7.21.0 🍺
+ * Do not edit manually.
+ * document_storage_service
+ * OpenAPI spec version: 0.1.0
+ */
+
+import type { EntityPermissionOneOfSevenType } from './entityPermissionOneOfSevenType';
+import type { TeamRole } from './teamRole';
+
+/**
+ * Permission for team-based entities.
+ */
+export type EntityPermissionOneOfSeven = {
+ /** The role the user has in the team. */
+ role: TeamRole;
+ type: EntityPermissionOneOfSevenType;
+};
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfSevenType.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfSevenType.ts
new file mode 100644
index 0000000000..e3b40ff1f6
--- /dev/null
+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfSevenType.ts
@@ -0,0 +1,14 @@
+/**
+ * Generated by orval v7.21.0 🍺
+ * Do not edit manually.
+ * document_storage_service
+ * OpenAPI spec version: 0.1.0
+ */
+
+export type EntityPermissionOneOfSevenType =
+ (typeof EntityPermissionOneOfSevenType)[keyof typeof EntityPermissionOneOfSevenType];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EntityPermissionOneOfSevenType = {
+ team_role: 'team_role',
+} as const;
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfThree.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfThree.ts
index 45011018eb..fb23294436 100644
--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfThree.ts
+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfThree.ts
@@ -4,15 +4,11 @@
* document_storage_service
* OpenAPI spec version: 0.1.0
*/
-
import type { EntityPermissionOneOfThreeType } from './entityPermissionOneOfThreeType';
-import type { ParticipantRole } from './participantRole';
/**
- * Permission for channel-based entities.
+ * View-only permission for a channel without an active participant role.
*/
export type EntityPermissionOneOfThree = {
- /** The role the user has in the channel. */
- role: ParticipantRole;
type: EntityPermissionOneOfThreeType;
};
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfThreeType.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfThreeType.ts
index 22a5d16d0d..68c0a67751 100644
--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfThreeType.ts
+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/entityPermissionOneOfThreeType.ts
@@ -10,5 +10,5 @@ export type EntityPermissionOneOfThreeType =
// eslint-disable-next-line @typescript-eslint/no-redeclare
export const EntityPermissionOneOfThreeType = {
- channel_role: 'channel_role',
+ channel_view_only: 'channel_view_only',
} as const;
diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.ts
index fa683e327a..c3e37a55b6 100644
--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.ts
+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.ts
@@ -495,6 +495,8 @@ export * from './entityPermission';
export * from './entityPermissionOneOf';
export * from './entityPermissionOneOfFive';
export * from './entityPermissionOneOfFiveType';
+export * from './entityPermissionOneOfSeven';
+export * from './entityPermissionOneOfSevenType';
export * from './entityPermissionOneOfThree';
export * from './entityPermissionOneOfThreeType';
export * from './entityPermissionOneOfType';
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.ts
index 71c03d49cd..75d93dee45 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
@@ -6525,6 +6525,13 @@ export const getEntityPermissionResponse = zod
.describe(
'Permission for item-based entities (document, chat, project, thread).'
),
+ zod
+ .object({
+ type: zod.enum(['channel_view_only']),
+ })
+ .describe(
+ 'View-only permission for a channel without an active participant role.'
+ ),
zod
.object({
role: zod
@@ -6532,7 +6539,9 @@ export const getEntityPermissionResponse = zod
.describe('The role a user has within a channel.'),
type: zod.enum(['channel_role']),
})
- .describe('Permission for channel-based entities.'),
+ .describe(
+ 'Permission for channel-based entities with an active participant role.'
+ ),
zod
.object({
role: zod
@@ -6545,7 +6554,7 @@ export const getEntityPermissionResponse = zod
.describe('Permission for team-based entities.'),
])
.describe(
- "A user's permission for an entity, discriminated by entity kind.\n\nItems (documents, chats, projects, threads) use access levels.\nChannels use participant roles."
+ "A user's permission for an entity, discriminated by entity kind.\n\nItems (documents, chats, projects, threads) use access levels.\nChannels use view-only permission or participant roles."
),
status: zod.enum(['access']),
}),
diff --git a/apps/web/src/lib/service-clients/service-storage/openapi.json b/apps/web/src/lib/service-clients/service-storage/openapi.json
index 104274dc19..3b32f5bf17 100644
--- a/apps/web/src/lib/service-clients/service-storage/openapi.json
+++ b/apps/web/src/lib/service-clients/service-storage/openapi.json
@@ -14677,7 +14677,18 @@
},
{
"type": "object",
- "description": "Permission for channel-based entities.",
+ "description": "View-only permission for a channel without an active participant role.",
+ "required": ["type"],
+ "properties": {
+ "type": {
+ "type": "string",
+ "enum": ["channel_view_only"]
+ }
+ }
+ },
+ {
+ "type": "object",
+ "description": "Permission for channel-based entities with an active participant role.",
"required": ["role", "type"],
"properties": {
"role": {
@@ -14706,7 +14717,7 @@
}
}
],
- "description": "A user's permission for an entity, discriminated by entity kind.\n\nItems (documents, chats, projects, threads) use access levels.\nChannels use participant roles."
+ "description": "A user's permission for an entity, discriminated by entity kind.\n\nItems (documents, chats, projects, threads) use access levels.\nChannels use view-only permission or participant roles."
},
"EntityPermissionResponse": {
"oneOf": [
diff --git a/crates/entity_access/src/domain/models.rs b/crates/entity_access/src/domain/models.rs
index 8f72494a60..5614892d25 100644
--- a/crates/entity_access/src/domain/models.rs
+++ b/crates/entity_access/src/domain/models.rs
@@ -87,6 +87,10 @@ pub struct AdminParticipantRole;
#[derive(Debug, Clone, Copy)]
pub struct MemberParticipantRole;
+/// Permission to view a channel without requiring an active participant role.
+#[derive(Debug, Clone, Copy)]
+pub struct ViewOnly;
+
/// Trait implemented by marker types that encode a permission requirement.
pub trait RequiredPermission: std::fmt::Debug + Send + Sync + 'static {
/// Returns whether the provided permission satisfies this requirement.
@@ -96,7 +100,7 @@ pub trait RequiredPermission: std::fmt::Debug + Send + Sync + 'static {
/// A user's permission for an entity, discriminated by entity kind.
///
/// Items (documents, chats, projects, threads) use access levels.
-/// Channels use participant roles.
+/// Channels use view-only permission or participant roles.
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
#[cfg_attr(feature = "schema", derive(utoipa::ToSchema))]
#[serde(tag = "type", rename_all = "snake_case")]
@@ -106,7 +110,9 @@ pub enum EntityPermission {
/// The access level the user has.
access_level: AccessLevel,
},
- /// Permission for channel-based entities.
+ /// View-only permission for a channel without an active participant role.
+ ChannelViewOnly,
+ /// Permission for channel-based entities with an active participant role.
ChannelRole {
/// The role the user has in the channel.
role: ParticipantRole,
@@ -188,6 +194,15 @@ impl RequiredPermission for OwnerAccessLevel {
}
}
+impl RequiredPermission for ViewOnly {
+ fn is_satisfied_by(permission: &EntityPermission) -> bool {
+ matches!(
+ permission,
+ EntityPermission::ChannelViewOnly | EntityPermission::ChannelRole { .. }
+ )
+ }
+}
+
impl RequiredPermission for OwnerParticipantRole {
fn is_satisfied_by(permission: &EntityPermission) -> bool {
permission.allows_participant_role(ParticipantRole::Owner)
@@ -235,12 +250,14 @@ pub struct UserTeamInfo {
/// Result of resolving a user's role in a channel.
///
-/// Distinguishes between "user has a role", "channel exists but user
-/// has no access", and "channel does not exist" — all from a single query.
+/// Distinguishes between an active participant role, view-only access,
+/// no access to an existing channel, and a channel that does not exist.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ChannelRoleResult {
/// User has a role in the channel.
Role(ParticipantRole),
+ /// User can view the channel without an active participant role.
+ ViewOnly,
/// Channel exists but user has no access.
NoAccess,
/// Channel does not exist.
diff --git a/crates/entity_access/src/domain/models/test.rs b/crates/entity_access/src/domain/models/test.rs
index aecc260bfa..7a4a5f02f9 100644
--- a/crates/entity_access/src/domain/models/test.rs
+++ b/crates/entity_access/src/domain/models/test.rs
@@ -75,3 +75,27 @@ fn dangerously_assert_bot_creates_owner_level_test_receipt() {
}
));
}
+
+#[test]
+fn channel_view_only_satisfies_only_view_only_requirement() {
+ let permission = EntityPermission::ChannelViewOnly;
+
+ assert!(permission.satisfies::<ViewOnly>());
+ assert!(!permission.satisfies::<MemberParticipantRole>());
+ assert!(!permission.satisfies::<AdminParticipantRole>());
+ assert!(!permission.satisfies::<OwnerParticipantRole>());
+ assert!(!permission.satisfies::<ViewAccessLevel>());
+}
+
+#[test]
+fn all_channel_participant_roles_satisfy_view_only_requirement() {
+ for role in [
+ ParticipantRole::Member,
+ ParticipantRole::Admin,
+ ParticipantRole::Owner,
+ ] {
+ let permission = EntityPermission::ChannelRole { role };
+
+ assert!(permission.satisfies::<ViewOnly>());
+ }
+}
diff --git a/crates/entity_access/src/domain/ports.rs b/crates/entity_access/src/domain/ports.rs
index c020dcb9e0..93d0c62aea 100644
--- a/crates/entity_access/src/domain/ports.rs
+++ b/crates/entity_access/src/domain/ports.rs
@@ -131,7 +131,8 @@ pub trait AccessRepository: Clone + Send + Sync + 'static {
/// Get the user's role in a channel.
///
/// Returns a [`ChannelRoleResult`] that distinguishes between:
- /// - User has a role (considering channel type rules)
+ /// - User has an active participant role (considering channel type rules)
+ /// - User has view-only access without an active participant role
/// - Channel exists but user has no access
/// - Channel does not exist
fn get_channel_role(
@@ -282,8 +283,9 @@ pub trait EntityAccessService: Clone + Send + Sync + 'static {
/// Get the user's permission for an entity.
///
- /// Returns `EntityPermission::AccessLevel` for items (documents, chats, projects, threads)
- /// and `EntityPermission::ChannelRole` for channels.
+ /// Returns `EntityPermission::AccessLevel` for items (documents, chats, projects, threads).
+ /// Channels return `EntityPermission::ChannelRole` for active participants or
+ /// `EntityPermission::ChannelViewOnly` for view-only access.
///
/// Returns `AccessError::Unauthorized` if the user has no access.
fn get_entity_permission(
diff --git a/crates/entity_access/src/domain/service.rs b/crates/entity_access/src/domain/service.rs
index a859cd5246..9f2059db31 100644
--- a/crates/entity_access/src/domain/service.rs
+++ b/crates/entity_access/src/domain/service.rs
@@ -509,6 +509,7 @@ fn channel_role_result_to_permission(
) -> Result<EntityPermission, AccessError> {
match result {
ChannelRoleResult::Role(role) => Ok(EntityPermission::ChannelRole { role }),
+ ChannelRoleResult::ViewOnly => Ok(EntityPermission::ChannelViewOnly),
ChannelRoleResult::NoAccess => Err(AccessError::Unauthorized),
ChannelRoleResult::NotFound => Err(AccessError::NotFound("Channel not found")),
}
diff --git a/crates/entity_access/src/domain/service/test.rs b/crates/entity_access/src/domain/service/test.rs
index dbab7baec5..cc2e56db2b 100644
--- a/crates/entity_access/src/domain/service/test.rs
+++ b/crates/entity_access/src/domain/service/test.rs
@@ -5,7 +5,7 @@ use super::*;
use crate::domain::models::{
AdminParticipantRole, BotId, CallChannelInfo, CommentAccessLevel, EditAccessLevel,
EntityAccessAuth, MemberParticipantRole, OwnerParticipantRole, ParticipantRole, UserTeamInfo,
- ViewAccessLevel,
+ ViewAccessLevel, ViewOnly,
};
use macro_user_id::user_id::MacroUserIdStr;
use models_permissions::share_permission::access_level::OwnerAccessLevel;
@@ -630,6 +630,25 @@ async fn test_get_entity_permission_channel_returns_role() {
));
}
+#[tokio::test]
+async fn test_get_entity_permission_channel_returns_view_only() {
+ let repo = MockRepo::new().with_channel_role(ChannelRoleResult::ViewOnly);
+ let service = EntityAccessServiceImpl::new(repo);
+ let user_id = test_user_id();
+
+ let result = service
+ .get_entity_permission(
+ Some(&user_id),
+ "11111111-1111-1111-1111-111111111111",
+ EntityType::Channel,
+ None,
+ )
+ .await
+ .unwrap();
+
+ assert!(matches!(result, EntityPermission::ChannelViewOnly));
+}
+
#[tokio::test]
async fn test_get_entity_permission_channel_no_access_returns_unauthorized() {
let repo = MockRepo::new().with_channel_role(ChannelRoleResult::NoAccess);
@@ -1250,6 +1269,46 @@ async fn test_generate_receipt_channel_with_role() {
));
}
+#[tokio::test]
+async fn test_generate_receipt_channel_view_only_satisfies_view_only_requirement() {
+ let repo = MockRepo::new().with_channel_role(ChannelRoleResult::ViewOnly);
+ let service = EntityAccessServiceImpl::new(repo);
+ let user_id = test_user_id();
+
+ let receipt = service
+ .generate_entity_access_receipt::<ViewOnly>(
+ &user_id,
+ None,
+ "11111111-1111-1111-1111-111111111111",
+ EntityType::Channel,
+ )
+ .await
+ .unwrap();
+
+ assert!(matches!(
+ receipt.entity_permission(),
+ EntityPermission::ChannelViewOnly
+ ));
+}
+
+#[tokio::test]
+async fn test_generate_receipt_channel_view_only_fails_member_requirement() {
+ let repo = MockRepo::new().with_channel_role(ChannelRoleResult::ViewOnly);
+ let service = EntityAccessServiceImpl::new(repo);
+ let user_id = test_user_id();
+
+ let result = service
+ .generate_entity_access_receipt::<MemberParticipantRole>(
+ &user_id,
+ None,
+ "11111111-1111-1111-1111-111111111111",
+ EntityType::Channel,
+ )
+ .await;
+
+ assert!(matches!(result, Err(AccessError::Unauthorized)));
+}
+
#[tokio::test]
async fn test_generate_receipt_channel_member_fails_edit_requirement() {
let repo = MockRepo::new().with_channel_role(ChannelRoleResult::Role(ParticipantRole::Member));
diff --git a/crates/entity_access/src/inbound/axum_extractors/channel/test.rs b/crates/entity_access/src/inbound/axum_extractors/channel/test.rs
index 308337b3da..b58de79d51 100644
--- a/crates/entity_access/src/inbound/axum_extractors/channel/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/channel/test.rs
@@ -23,7 +23,7 @@ use uuid::Uuid;
use super::*;
use crate::domain::models::{
AccessError, AccessLevel, AdminParticipantRole, BotId, CallChannelInfo, MemberParticipantRole,
- OwnerParticipantRole, UserTeamInfo,
+ OwnerParticipantRole, UserTeamInfo, ViewOnly,
};
const CHANNEL_ID: &str = "550e8400-e29b-41d4-a716-446655440000";
@@ -238,6 +238,8 @@ impl FromRef<TestState> for MacroAuthorizationState<FakeAuthorizationService> {
}
}
+type ViewOnlyExtractor =
+ ChannelAccessLevelExtractor<ViewOnly, FakeEntityAccessService, FakeAuthorizationService>;
type MemberExtractor = ChannelAccessLevelExtractor<
MemberParticipantRole,
FakeEntityAccessService,
@@ -305,6 +307,14 @@ fn assert_member_receipt(receipt: &EntityAccessReceipt<MemberParticipantRole>) {
));
}
+async fn view_only_handler(extractor: ViewOnlyExtractor) -> StatusCode {
+ assert_eq!(
+ extractor.entity_access_receipt.entity().entity_id,
+ CHANNEL_ID
+ );
+ StatusCode::OK
+}
+
async fn member_handler(extractor: MemberExtractor) -> StatusCode {
assert_member_receipt(&extractor.entity_access_receipt);
StatusCode::OK
@@ -370,6 +380,44 @@ async fn authenticated_access_forwards_organization_and_mints_receipt() {
);
}
+#[tokio::test]
+async fn view_only_permission_satisfies_view_only_extractor() {
+ let state = TestState::new(EntityPermission::ChannelViewOnly);
+ let response = app(state.clone(), view_only_handler)
+ .oneshot(request(Some("valid")))
+ .await
+ .expect("request should complete");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(state.entity_access.calls().len(), 1);
+}
+
+#[tokio::test]
+async fn member_permission_satisfies_view_only_extractor() {
+ let state = TestState::new(EntityPermission::ChannelRole {
+ role: ParticipantRole::Member,
+ });
+ let response = app(state.clone(), view_only_handler)
+ .oneshot(request(Some("valid")))
+ .await
+ .expect("request should complete");
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(state.entity_access.calls().len(), 1);
+}
+
+#[tokio::test]
+async fn view_only_permission_does_not_satisfy_member_extractor() {
+ let state = TestState::new(EntityPermission::ChannelViewOnly);
+ let response = app(state.clone(), member_handler)
+ .oneshot(request(Some("valid")))
+ .await
+ .expect("request should complete");
+
+ assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+ assert_eq!(state.entity_access.calls().len(), 1);
+}
+
#[tokio::test]
async fn insufficient_permission_is_rejected() {
let state = TestState::new(EntityPermission::ChannelRole {
diff --git a/crates/entity_access/src/outbound/pg_access_repo/queries/channel_role.rs b/crates/entity_access/src/outbound/pg_access_repo/queries/channel_role.rs
index 868b34db89..f00e6af5ae 100644
--- a/crates/entity_access/src/outbound/pg_access_repo/queries/channel_role.rs
+++ b/crates/entity_access/src/outbound/pg_access_repo/queries/channel_role.rs
@@ -13,6 +13,7 @@ struct ChannelRoleRow {
role: Option<String>,
channel_type: String,
org_id: Option<i64>,
+ is_team_member: bool,
}
/// Parse a participant role string from the database.
@@ -28,12 +29,14 @@ fn parse_role(s: &str) -> ParticipantRole {
///
/// Returns a [`ChannelRoleResult`] that distinguishes between:
/// - `Role(role)`: user has access with this role
+/// - `ViewOnly`: user belongs to the team that owns the team channel
/// - `NoAccess`: channel exists but user has no access
/// - `NotFound`: channel does not exist
///
/// Channel type rules:
/// - Public channels: non-participants default to Member
/// - Organization channels: default to Member only if user's org matches
+/// - Team channels: matching team members receive ViewOnly
/// - Private/DM: require explicit participation
#[tracing::instrument(err, skip(pool))]
#[allow(clippy::disallowed_methods, reason = "legacy code. fix later")]
@@ -49,7 +52,12 @@ pub async fn get_channel_role(
SELECT
cp.role::text as "role?",
c.channel_type::text as "channel_type!",
- c.org_id as "org_id?"
+ c.org_id as "org_id?",
+ EXISTS (
+ SELECT 1
+ FROM team_user tu
+ WHERE tu.user_id = $2 AND tu.team_id = c.team_id
+ ) as "is_team_member!"
FROM comms_channels c
LEFT JOIN comms_channel_participants cp
ON cp.channel_id = c.id AND cp.user_id = $2 AND cp.left_at IS NULL
@@ -89,10 +97,15 @@ pub async fn get_channel_role(
_ => row.role.as_deref().map(parse_role),
};
- Ok(match role {
- Some(role) => ChannelRoleResult::Role(role),
- None => ChannelRoleResult::NoAccess,
- })
+ if let Some(role) = role {
+ return Ok(ChannelRoleResult::Role(role));
+ }
+
+ if row.channel_type == "team" && row.is_team_member {
+ return Ok(ChannelRoleResult::ViewOnly);
+ }
+
+ Ok(ChannelRoleResult::NoAccess)
}
/// Get a bot's explicit role in a channel.
diff --git a/crates/entity_access/src/outbound/pg_access_repo/queries/channel_role/test.rs b/crates/entity_access/src/outbound/pg_access_repo/queries/channel_role/test.rs
index dd4d5f4be5..96e7ce90b3 100644
--- a/crates/entity_access/src/outbound/pg_access_repo/queries/channel_role/test.rs
+++ b/crates/entity_access/src/outbound/pg_access_repo/queries/channel_role/test.rs
@@ -3,6 +3,61 @@ use bot_id::{BotId, BotIdStr};
use macro_db_migrator::MACRO_DB_MIGRATIONS;
use sqlx::PgPool;
+const TEAM_ALPHA: Uuid = Uuid::from_u128(0x000000000000000000000000000ea001);
+
+async fn insert_channel(
+ pool: &PgPool,
+ channel_id: Uuid,
+ channel_type: &str,
+ team_id: Option<Uuid>,
+) -> anyhow::Result<()> {
+ sqlx::query!(
+ r#"
+ INSERT INTO comms_channels (id, name, channel_type, owner_id, team_id)
+ VALUES (
+ $1,
+ CASE WHEN $2 = 'direct_message' THEN NULL ELSE 'User Channel' END,
+ $2::text::comms_channel_type,
+ 'owner',
+ $3
+ )
+ "#,
+ channel_id,
+ channel_type,
+ team_id,
+ )
+ .execute(pool)
+ .await?;
+ Ok(())
+}
+
+async fn insert_user_participant(
+ pool: &PgPool,
+ channel_id: Uuid,
+ user_id: &str,
+ role: &str,
+ departed: bool,
+) -> anyhow::Result<()> {
+ sqlx::query!(
+ r#"
+ INSERT INTO comms_channel_participants (channel_id, role, user_id, left_at)
+ VALUES (
+ $1,
+ $2::text::comms_participant_role,
+ $3,
+ CASE WHEN $4 THEN now() ELSE NULL END
+ )
+ "#,
+ channel_id,
+ role,
+ user_id,
+ departed,
+ )
+ .execute(pool)
+ .await?;
+ Ok(())
+}
+
async fn insert_public_channel(pool: &PgPool, channel_id: Uuid) {
sqlx::query!(
r#"
@@ -55,6 +110,92 @@ async fn insert_bot_participant(
.unwrap();
}
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../../fixtures", scripts("user_team"))
+)]
+async fn matching_team_member_without_participant_is_view_only(pool: PgPool) -> anyhow::Result<()> {
+ let channel_id = Uuid::new_v4();
+ insert_channel(&pool, channel_id, "team", Some(TEAM_ALPHA)).await?;
+
+ let role = get_channel_role(&pool, &channel_id, "macro|[email protected]", None).await?;
+
+ assert_eq!(role, ChannelRoleResult::ViewOnly);
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../../fixtures", scripts("user_team"))
+)]
+async fn active_team_channel_participant_receives_stored_role(pool: PgPool) -> anyhow::Result<()> {
+ let channel_id = Uuid::new_v4();
+ let user_id = "macro|[email protected]";
+ insert_channel(&pool, channel_id, "team", Some(TEAM_ALPHA)).await?;
+ insert_user_participant(&pool, channel_id, user_id, "admin", false).await?;
+
+ let role = get_channel_role(&pool, &channel_id, user_id, None).await?;
+
+ assert_eq!(role, ChannelRoleResult::Role(ParticipantRole::Admin));
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../../fixtures", scripts("user_team"))
+)]
+async fn departed_participant_is_view_only_while_team_membership_remains(
+ pool: PgPool,
+) -> anyhow::Result<()> {
+ let channel_id = Uuid::new_v4();
+ let user_id = "macro|[email protected]";
+ insert_channel(&pool, channel_id, "team", Some(TEAM_ALPHA)).await?;
+ insert_user_participant(&pool, channel_id, user_id, "member", true).await?;
+
+ let role = get_channel_role(&pool, &channel_id, user_id, None).await?;
+ assert_eq!(role, ChannelRoleResult::ViewOnly);
+
+ sqlx::query!("DELETE FROM team_user WHERE user_id = $1", user_id)
+ .execute(&pool)
+ .await?;
+
+ let role = get_channel_role(&pool, &channel_id, user_id, None).await?;
+ assert_eq!(role, ChannelRoleResult::NoAccess);
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../../fixtures", scripts("user_team"))
+)]
+async fn unrelated_team_member_has_no_access(pool: PgPool) -> anyhow::Result<()> {
+ let channel_id = Uuid::new_v4();
+ insert_channel(&pool, channel_id, "team", Some(TEAM_ALPHA)).await?;
+
+ let role = get_channel_role(&pool, &channel_id, "macro|[email protected]", None).await?;
+
+ assert_eq!(role, ChannelRoleResult::NoAccess);
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../../fixtures", scripts("user_team"))
+)]
+async fn non_team_channels_do_not_grant_team_members_view_only(pool: PgPool) -> anyhow::Result<()> {
+ let user_id = "macro|[email protected]";
+
+ for channel_type in ["private", "direct_message"] {
+ let channel_id = Uuid::new_v4();
+ insert_channel(&pool, channel_id, channel_type, None).await?;
+
+ let role = get_channel_role(&pool, &channel_id, user_id, None).await?;
+
+ assert_eq!(role, ChannelRoleResult::NoAccess);
+ }
+ Ok(())
+}
+
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn bot_channel_role_active_participant_receives_stored_role(
pool: PgPool,