feature: request join policy

client/src/data/rooms.ts

@@ -9,9 +9,15 @@ export type Room = {
   joinPolicy: string
 }
 
+export type Membership = {
+  roomId: string
+  status: string
+}
+
 export type RoomResponse = {
   room: Room
   roles: string[]
+  membership?: Membership
 }
 
 const getRoom = async (roomId?: string): Promise<RoomResponse> => {

client/src/features/room/organisms/ChatBox.tsx

@@ -2,15 +2,21 @@ import { Button, Icon, Textarea, Spinner, VStack, Alert, AlertIcon, Spacer } fro
 import React, { useState, KeyboardEventHandler, useRef, useEffect, ReactElement } from 'react'
 import { AiOutlineArrowRight } from 'react-icons/ai'
 import { usePostMessage } from '../../../data/messages'
-import { useJoinRoom } from '../../../data/rooms'
+import { RoomResponse, useJoinRoom } from '../../../data/rooms'
 import { useUserDetails } from '../../../data/users'
+import { can } from '../../../data/lib'
 
 export type ChatBoxProps = {
-  roomId: string
-  canJoin: boolean
+  roomResponse: RoomResponse
 }
 
-const JoinAlert = ({ roomId, canJoin }: ChatBoxProps) => {
+const JoinAlert = ({ roomResponse }: ChatBoxProps): ReactElement => {
+  const roomId = roomResponse.room.id
+
+  const canJoin = can('join', roomResponse)
+  const requiresApproval = roomResponse.room.joinPolicy === 'request'
+  const awaitingApproval = roomResponse.membership?.status === 'PendingApproval'
+
   const { mutate: joinRoom, isLoading, isSuccess: isJoined } = useJoinRoom(roomId)
 
   useEffect(() => {
@@ -20,13 +26,22 @@ const JoinAlert = ({ roomId, canJoin }: ChatBoxProps) => {
   }, [isJoined])
 
   if (canJoin) {
+    if (awaitingApproval) {
+      return (
+        <Alert status='info' variant='top-accent'>
+          <AlertIcon />
+          Awaiting approval from owner.
+          <Spacer />
+        </Alert>
+      )
+    }
     return (
       <Alert status='info' variant='top-accent'>
         <AlertIcon />
         Join this room to chat.
         <Spacer />
         <Button rightIcon={isLoading ? <Spinner /> : undefined} onClick={() => joinRoom()}>
-          Join
+          {requiresApproval ? 'Request to Join' : 'Join'}
         </Button>
       </Alert>
     )
@@ -40,7 +55,9 @@ const JoinAlert = ({ roomId, canJoin }: ChatBoxProps) => {
   )
 }
 
-export const ChatBox: React.FC<ChatBoxProps> = ({ roomId, canJoin }: ChatBoxProps): ReactElement => {
+export const ChatBox: React.FC<ChatBoxProps> = ({ roomResponse }: ChatBoxProps): ReactElement => {
+  const roomId = roomResponse.room.id
+
   const [content, setContent] = useState<string>('')
   const { data: user, isLoading } = useUserDetails()
   const joined = user?.rooms.some((room) => room.id === roomId)
@@ -67,7 +84,7 @@ export const ChatBox: React.FC<ChatBoxProps> = ({ roomId, canJoin }: ChatBoxProp
   }
 
   if (!isLoading && !joined) {
-    return <JoinAlert roomId={roomId} canJoin={canJoin} />
+    return <JoinAlert roomResponse={roomResponse} />
   }
 
   return (

client/src/features/room/pages/Room.tsx

@@ -17,7 +17,6 @@ export const RoomPage = () => {
   const { data: roomResponse } = useRoom(roomId)
 
   const canRead = can('read', roomResponse)
-  const canJoin = can('join', roomResponse)
 
   const { data: messages, isLoading: isLoadingMessages } = useMessages(roomId, { enabled: canRead })
   useMessagesSubscription(roomId, { enabled: canRead })
@@ -27,7 +26,7 @@ export const RoomPage = () => {
   return (
     <Box display='flex' flexFlow='column' height='100%' flex='1'>
       {<MessagesList messages={messages ?? [restrictedMessage(roomId)]} />}
-      <ChatBox roomId={roomId} canJoin={canJoin} />
+      <ChatBox roomResponse={roomResponse} />
     </Box>
   )
 }

services/api/src/app/auth/permissions/roles.ts

@@ -40,7 +40,7 @@ export const defineRolesForUser = (user: User, memberships: Membership[]) => {
   });
 
   can(Role.Join, 'Room', {
-    joinPolicy: JoinPolicy.Anyone,
+    joinPolicy: { $in: [JoinPolicy.Anyone, JoinPolicy.Request] },
   });
   can(Role.Join, 'Room', {
     id: { $in: pendingInviteRoomIds },

services/api/src/app/messages/command.service.ts

@@ -12,6 +12,7 @@ import { P, match } from 'ts-pattern';
 import { InviteUseCase } from '@usecases/rooms/invite';
 import { LeaveRoomUseCase } from '@usecases/rooms/leave';
 import { AboutRoomUseCase } from '@usecases/rooms/about-room';
+import { ApproveRequestUseCase } from '@usecases/rooms/approve-request';
 
 @Injectable()
 export class CommandService {
@@ -22,6 +23,7 @@ export class CommandService {
     private readonly help: HelpCommandUseCase,
     private readonly leave: LeaveRoomUseCase,
     private readonly parse: ParseCommandUseCase,
+    private readonly approveRequest: ApproveRequestUseCase,
     private readonly changeRoomJoinPolicy: ChangeRoomJoinPolicyUseCase,
     private readonly aboutRoom: AboutRoomUseCase,
     private readonly invite: InviteUseCase,
@@ -57,6 +59,13 @@ export class CommandService {
           authenticatedUser,
         }),
       )
+      .with({ tag: 'approveRequest', params: P.select() }, (params) =>
+        this.approveRequest.exec({
+          ...params,
+          roomId,
+          authenticatedUser,
+        }),
+      )
       .with({ tag: 'aboutRoom' }, () =>
         this.aboutRoom.exec({
           roomId,

services/api/src/app/messages/messages.module.ts

@@ -16,6 +16,7 @@ import { ChangeRoomJoinPolicyUseCase } from '@usecases/rooms/change-room-join-po
 import { InviteUseCase } from '@usecases/rooms/invite';
 import { LeaveRoomUseCase } from '@usecases/rooms/leave';
 import { AboutRoomUseCase } from '@usecases/rooms/about-room';
+import { ApproveRequestUseCase } from '@usecases/rooms/approve-request';
 
 @Module({
   imports: [AuthModule, DispatcherModule],
@@ -37,6 +38,7 @@ import { AboutRoomUseCase } from '@usecases/rooms/about-room';
     LeaveRoomUseCase,
     LoremCommandUseCase,
     AboutRoomUseCase,
+    ApproveRequestUseCase,
     HelpCommandUseCase,
   ],
   exports: [MessagesService],

services/api/src/domain/entities/membership.entity.ts

@@ -82,8 +82,18 @@ export const isPendingInvite = allPass([
   withStatus(MembershipStatus.PendingInvite),
 ]);
 
+export const isPendingApproval = allPass([
+  isCurrent,
+  withStatus(MembershipStatus.PendingApproval),
+]);
+
 export const isMemberOf = (roomId: string, memberships: Membership[]) =>
   memberships.some(allPass([isActive, forRoom(roomId)]));
 
-export const hasInviteTo = (roomId: string, memberships: Membership[]) =>
+export const hasPendingInviteTo = (roomId: string, memberships: Membership[]) =>
   memberships.some(allPass([isPendingInvite, forRoom(roomId)]));
+
+export const hasPendingRequestTo = (
+  roomId: string,
+  memberships: Membership[],
+) => memberships.some(allPass([isPendingApproval, forRoom(roomId)]));

services/api/src/domain/usecases/commands/parse/command.parser.ts

@@ -9,6 +9,7 @@ export type ParsedCommand =
   | { tag: 'renameRoom'; params: { newName: string } }
   | { tag: 'renameUser'; params: { newName: string } }
   | { tag: 'inviteUser'; params: { email: string } }
+  | { tag: 'approveRequest'; params: { email: string } }
   | { tag: 'leave'; params: null }
   | { tag: 'aboutRoom'; params: null }
   | { tag: 'changeRoomJoinPolicy'; params: { newJoinPolicy: JoinPolicy } }

services/api/src/domain/usecases/commands/parse/parsers/approve-request-parser.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { CommandParser, ParsedCommand } from '../command.parser';
+
+const schema = z
+  .tuple([z.literal('approve'), z.literal('request'), z.string().email()])
+  .transform<ParsedCommand>(([, , email]) => ({
+    tag: 'approveRequest',
+    params: { email },
+  }));
+
+export const approveRequestParser = new CommandParser({
+  matchTokens: ['approve', 'request'],
+  schema,
+  signature: `/approve request {email}`,
+  summary: 'approve pending request to join the room',
+});

services/api/src/domain/usecases/commands/parse/parsers/change-room-join-policy-parser.ts

@@ -8,7 +8,7 @@ const schema = z
     z.literal('room'),
     z.literal('join'),
     z.literal('policy'),
-    z.enum([JoinPolicy.Anyone, JoinPolicy.Invite]),
+    z.enum([JoinPolicy.Anyone, JoinPolicy.Invite, JoinPolicy.Request]),
   ])
   .rest(z.string())
   .transform<ParsedCommand>(([, , , , joinPolicy]) => ({

services/api/src/domain/usecases/commands/parse/parsers/index.ts

@@ -1,5 +1,6 @@
 import { CommandParser } from '../command.parser';
 import { aboutRoomParser } from './about-room-parser';
+import { approveRequestParser } from './approve-request-parser';
 import { changeRoomJoinPolicyParser } from './change-room-join-policy-parser';
 import { helpParser } from './help.parser';
 import { inviteParser } from './invite-parser';
@@ -17,4 +18,5 @@ export const parsers: CommandParser[] = [
   changeRoomJoinPolicyParser,
   aboutRoomParser,
   inviteParser,
+  approveRequestParser,
 ];

services/api/src/domain/usecases/rooms/approve-request.ts

@@ -0,0 +1,95 @@
+import {
+  MembershipStatus,
+  hasPendingRequestTo,
+  isMemberOf,
+} from '@entities/membership.entity';
+import { MembershipsRepository } from '@entities/memberships.repository';
+import { Dispatcher, DraftMessage } from '@entities/messages';
+import { RoomsRepository } from '@entities/rooms.repository';
+import { User, UsersRepository } from '@entities/users';
+import { Injectable } from '@nestjs/common';
+import { AuthService, Role } from '@usecases/auth.service';
+
+export type ApproveRequestParams = {
+  authenticatedUser: User;
+  roomId: string;
+  email: string;
+};
+
+@Injectable()
+export class ApproveRequestUseCase {
+  constructor(
+    private readonly rooms: RoomsRepository,
+    private readonly users: UsersRepository,
+    private readonly memberships: MembershipsRepository,
+    private readonly auth: AuthService,
+    private readonly dispatcher: Dispatcher,
+  ) {}
+
+  async exec({
+    authenticatedUser,
+    roomId,
+    email,
+  }: ApproveRequestParams): Promise<void> {
+    const room = await this.rooms.getRoom(roomId);
+
+    await this.auth.authorize({
+      user: authenticatedUser,
+      subject: room,
+      action: Role.Manage,
+    });
+
+    const invitedUser = await this.users.findUser(email);
+
+    if (!invitedUser) {
+      const message: DraftMessage = {
+        content: `No user exists with email ${email}`,
+        roomId: room.id,
+        authorId: 'system',
+        recipientId: authenticatedUser.id,
+      };
+
+      await this.dispatcher.send(message);
+      return;
+    }
+
+    const existingMemberships = await this.memberships.getMemberships(
+      invitedUser.id,
+    );
+    if (isMemberOf(roomId, existingMemberships)) {
+      const message: DraftMessage = {
+        content: `${invitedUser.name} is already a member of this room`,
+        roomId: room.id,
+        authorId: 'system',
+        recipientId: authenticatedUser.id,
+      };
+
+      await this.dispatcher.send(message);
+      return;
+    } else if (!hasPendingRequestTo(roomId, existingMemberships)) {
+      const message: DraftMessage = {
+        content: `${invitedUser.name} does not have a pending request to join this room`,
+        roomId: room.id,
+        authorId: 'system',
+        recipientId: authenticatedUser.id,
+      };
+
+      await this.dispatcher.send(message);
+      return;
+    }
+
+    await this.memberships.createMembership({
+      userId: invitedUser.id,
+      roomId,
+      status: MembershipStatus.Joined,
+    });
+
+    const message: DraftMessage = {
+      content: `${authenticatedUser.name} approved ${invitedUser.name} to join the room`,
+      roomId: room.id,
+      authorId: 'system',
+    };
+
+    await this.dispatcher.send(message);
+  }
+}

services/api/src/domain/usecases/rooms/get.ts

@@ -3,25 +3,36 @@ import { Room } from '@entities/room.entity';
 import { RoomsRepository } from '@entities/rooms.repository';
 import { User } from '@entities/users';
 import { Injectable } from '@nestjs/common';
+import { MembershipsRepository } from '@entities/memberships.repository';
+import { Membership, forRoom, isCurrent } from '@entities/membership.entity';
 
 export type RoomDetails = {
   room: Room;
   roles: Role[];
+  membership?: Membership;
 };
 
 @Injectable()
 export class GetRoomUseCase {
   constructor(
     private readonly rooms: RoomsRepository,
+    private readonly memberships: MembershipsRepository,
     private readonly authService: AuthService,
   ) {}
 
   async exec(roomId: string, user: User): Promise<RoomDetails> {
     const room = await this.rooms.getRoom(roomId);
+
     const roles = await this.authService.authorizedRoles({
       user,
       subject: room,
     });
-    return { room, roles };
+
+    const memberships = await this.memberships.getMemberships(user.id);
+    const [currentMembership] = memberships
+      .filter(forRoom(roomId))
+      .filter(isCurrent);
+
+    return { room, roles, membership: currentMembership };
   }
 }

services/api/src/domain/usecases/rooms/invite.ts

@@ -1,7 +1,7 @@
 import { AuthService, Role } from '@usecases/auth.service';
 import {
   MembershipStatus,
-  hasInviteTo,
+  hasPendingInviteTo,
   isMemberOf,
 } from '@entities/membership.entity';
 import { MembershipsRepository } from '@entities/memberships.repository';
@@ -66,7 +66,7 @@ export class InviteUseCase {
 
       await this.dispatcher.send(message);
       return;
-    } else if (hasInviteTo(roomId, existingMemberships)) {
+    } else if (hasPendingInviteTo(roomId, existingMemberships)) {
       const message: DraftMessage = {
         content: `${invitedUser.name} already has an invite to this room`,
         roomId: room.id,