feat(share): add chat

src/app/app.module.ts

@@ -54,6 +54,9 @@ import { FeedbackModule } from 'omniboxd/feedback/feedback.module';
 import { Feedback1757100000000 } from 'omniboxd/migrations/1757100000000-feedback';
 import { UserInterceptor } from 'omniboxd/interceptor/user.interceptor';
 import { WebSocketModule } from 'omniboxd/websocket/websocket.module';
+import { NullableUserId1757844448000 } from 'omniboxd/migrations/1757844448000-nullable-user-id';
+import { AddShareIdToConversations1757844449000 } from 'omniboxd/migrations/1757844449000-add-share-id-to-conversations';
+import { ShareUser1760171824000 } from 'omniboxd/migrations/1760171824000-share-user';
 
 @Module({})
 export class AppModule implements NestModule {
@@ -148,6 +151,9 @@ export class AppModule implements NestModule {
               SharesAllResources1754471311959,
               Applications1756914379375,
               Feedback1757100000000,
+              NullableUserId1757844448000,
+              AddShareIdToConversations1757844449000,
+              ShareUser1760171824000,
               ...extraMigrations,
             ],
             migrationsRun: true,

src/attachments/attachments.service.ts

@@ -15,6 +15,7 @@ import {
 } from './dto/upload-attachments-response.dto';
 import { SharesService } from 'omniboxd/shares/shares.service';
 import { SharedResourcesService } from 'omniboxd/shared-resources/shared-resources.service';
+import { Share } from 'omniboxd/shares/entities/share.entity';
 
 @Injectable()
 export class AttachmentsService {
@@ -181,18 +182,11 @@ export class AttachmentsService {
   }
 
   async downloadAttachmentViaShare(
-    shareId: string,
+    share: Share,
     resourceId: string,
     attachmentId: string,
-    password: string,
-    userId: string | undefined,
     httpResponse: Response,
   ) {
-    const share = await this.sharesService.getAndValidateShare(
-      shareId,
-      password,
-      userId,
-    );
     await this.sharedResourcesService.getAndValidateResource(share, resourceId);
     await this.resourceAttachmentsService.getResourceAttachmentOrFail(
       share.namespaceId,

src/attachments/share-attachments.controller.ts

@@ -1,30 +1,32 @@
-import { Controller, Get, Param, Res } from '@nestjs/common';
+import { Controller, Get, Param, Res, UseInterceptors } from '@nestjs/common';
 import { Response } from 'express';
 import { AttachmentsService } from './attachments.service';
-import { UserId } from 'omniboxd/decorators/user-id.decorator';
 import { CookieAuth } from 'omniboxd/auth/decorators';
-import { Cookies } from 'omniboxd/decorators/cookie.decorators';
+import {
+  ValidateShare,
+  ValidatedShare,
+} from 'omniboxd/decorators/validate-share.decorator';
+import { ValidateShareInterceptor } from 'omniboxd/interceptor/validate-share.interceptor';
+import { Share } from 'omniboxd/shares/entities/share.entity';
 
 @Controller('api/v1/shares/:shareId/resources/:resourceId/attachments')
+@UseInterceptors(ValidateShareInterceptor)
 export class ShareAttachmentsController {
   constructor(private readonly attachmentsService: AttachmentsService) {}
 
   @CookieAuth({ onAuthFail: 'continue' })
+  @ValidateShare()
   @Get(':attachmentId')
   async downloadAttachment(
-    @Param('shareId') shareId: string,
     @Param('resourceId') resourceId: string,
     @Param('attachmentId') attachmentId: string,
-    @Cookies('share-password') password: string,
+    @ValidatedShare() share: Share,
     @Res() res: Response,
-    @UserId({ optional: true }) userId?: string,
   ) {
     return await this.attachmentsService.downloadAttachmentViaShare(
-      shareId,
+      share,
       resourceId,
       attachmentId,
-      password,
-      userId,
       res,
     );
   }

src/auth/decorators/index.ts

@@ -1,4 +1,5 @@
 export * from './public.auth.decorator';
+export * from './ws-auth-options.decorator';
 export * from '../api-key/api-key.auth.decorator';
 export * from '../api-key/api-key.decorator';
 export * from '../cookie/cookie.auth.decorator';

src/auth/decorators/ws-auth-options.decorator.ts

@@ -0,0 +1,10 @@
+import { SetMetadata } from '@nestjs/common';
+
+export interface WsAuthConfig {
+  optional?: boolean;
+}
+
+export const WS_AUTH_CONFIG_KEY = 'wsAuthConfig';
+
+export const WsAuthOptions = (config: WsAuthConfig = {}) =>
+  SetMetadata(WS_AUTH_CONFIG_KEY, config);

src/conversations/conversations.controller.ts

@@ -58,7 +58,7 @@ export class ConversationsController {
     @Param('id') id: string,
     @Req() req,
   ): Promise<ConversationDetailDto> {
-    return await this.conversationsService.getDetail(id, req.user);
+    return await this.conversationsService.getConversationForUser(id, req.user);
   }
 
   @Post(':id/title')

src/conversations/conversations.module.ts

@@ -3,19 +3,22 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { Conversation } from 'omniboxd/conversations/entities/conversation.entity';
 import { ConversationsService } from 'omniboxd/conversations/conversations.service';
 import { ConversationsController } from 'omniboxd/conversations/conversations.controller';
+import { SharedConversationsController } from 'omniboxd/conversations/shared-conversations.controller';
 import { MessagesModule } from '../messages/messages.module';
 import { UserModule } from '../user/user.module';
 import { TasksModule } from 'omniboxd/tasks/tasks.module';
+import { SharesModule } from 'omniboxd/shares/shares.module';
 
 @Module({
   imports: [
     MessagesModule,
     UserModule,
     TasksModule,
+    SharesModule,
     TypeOrmModule.forFeature([Conversation]),
   ],
   providers: [ConversationsService],
-  controllers: [ConversationsController],
+  controllers: [ConversationsController, SharedConversationsController],
   exports: [ConversationsService],
 })
 export class ConversationsModule {}

src/conversations/conversations.service.ts

@@ -18,6 +18,7 @@ import {
 } from 'omniboxd/messages/entities/message.entity';
 import { WizardTaskService } from 'omniboxd/tasks/wizard-task.service';
 import { Task } from 'omniboxd/tasks/tasks.entity';
+import { Share } from 'omniboxd/shares/entities/share.entity';
 
 const TASK_PRIORITY = 5;
 
@@ -50,6 +51,16 @@ export class ConversationsService {
     return await this.conversationRepository.save(conversation);
   }
 
+  async createConversationForShare(share: Share) {
+    const conversation = this.conversationRepository.create({
+      namespaceId: share.namespaceId,
+      userId: null,
+      title: '',
+      shareId: share.id,
+    });
+    return await this.conversationRepository.save(conversation);
+  }
+
   async update(id: string, title: string) {
     const conversation = await this.findOne(id);
     conversation.title = title;
@@ -192,22 +203,17 @@ export class ConversationsService {
     };
   }
 
-  async getDetail(id: string, user: User): Promise<ConversationDetailDto> {
-    const conversation = await this.conversationRepository.findOneOrFail({
-      where: { id, userId: user.id },
-    });
-
+  private convertToConversationDetail(
+    conversation: Conversation,
+    messages: Message[],
+  ): ConversationDetailDto {
     const detail: ConversationDetailDto = {
       id: conversation.id,
       title: conversation.title,
       created_at: conversation.createdAt.toISOString(),
       updated_at: conversation.updatedAt?.toISOString(),
       mapping: {},
     };
-    const messages = await this.messagesService.findAll(
-      user.id,
-      conversation.id,
-    );
     if (messages.length === 0) {
       return detail;
     }
@@ -251,6 +257,34 @@ export class ConversationsService {
     return detail;
   }
 
+  async getConversationForUser(
+    conversationId: string,
+    user: User,
+  ): Promise<ConversationDetailDto> {
+    const conversation = await this.conversationRepository.findOneOrFail({
+      where: { id: conversationId, userId: user.id },
+    });
+    const messages = await this.messagesService.findAll(
+      user.id,
+      conversation.id,
+    );
+    return this.convertToConversationDetail(conversation, messages);
+  }
+
+  async getConversationForShare(
+    conversationId: string,
+    share: Share,
+  ): Promise<ConversationDetailDto> {
+    const conversation = await this.conversationRepository.findOneOrFail({
+      where: { id: conversationId, shareId: share.id },
+    });
+    const messages = await this.messagesService.findAll(
+      undefined,
+      conversation.id,
+    );
+    return this.convertToConversationDetail(conversation, messages);
+  }
+
   async findOne(id: string) {
     return await this.conversationRepository.findOneOrFail({
       where: { id },

src/conversations/entities/conversation.entity.ts

@@ -9,9 +9,12 @@ export class Conversation extends Base {
   @Column()
   namespaceId: string;
 
-  @Column()
-  userId: string;
+  @Column('varchar', { nullable: true })
+  userId: string | null;
 
   @Column()
   title: string;
+
+  @Column('varchar', { nullable: true })
+  shareId: string | null;
 }

src/conversations/shared-conversations.controller.ts

@@ -0,0 +1,35 @@
+import { Controller, Get, Param, Post, UseInterceptors } from '@nestjs/common';
+import { ConversationsService } from './conversations.service';
+import { CookieAuth } from 'omniboxd/auth/decorators';
+import {
+  ValidateShare,
+  ValidatedShare,
+} from 'omniboxd/decorators/validate-share.decorator';
+import { ValidateShareInterceptor } from 'omniboxd/interceptor/validate-share.interceptor';
+import { Share } from 'omniboxd/shares/entities/share.entity';
+
+@Controller('api/v1/shares/:shareId/conversations')
+@UseInterceptors(ValidateShareInterceptor)
+export class SharedConversationsController {
+  constructor(private readonly conversationsService: ConversationsService) {}
+
+  @CookieAuth({ onAuthFail: 'continue' })
+  @ValidateShare({ requireChat: true })
+  @Post()
+  async createConversationForShare(@ValidatedShare() share: Share) {
+    return await this.conversationsService.createConversationForShare(share);
+  }
+
+  @CookieAuth({ onAuthFail: 'continue' })
+  @ValidateShare({ requireChat: true })
+  @Get(':conversationId')
+  async getSharedConversation(
+    @Param('conversationId') conversationId: string,
+    @ValidatedShare() share: Share,
+  ) {
+    return await this.conversationsService.getConversationForShare(
+      conversationId,
+      share,
+    );
+  }
+}

src/decorators/validate-share.decorator.ts

@@ -0,0 +1,31 @@
+import {
+  createParamDecorator,
+  ExecutionContext,
+  SetMetadata,
+  applyDecorators,
+} from '@nestjs/common';
+import { Request } from 'express';
+
+export const VALIDATE_SHARE_KEY = 'validate-share';
+
+export interface ValidateShareOptions {
+  requireChat?: boolean;
+}
+
+/**
+ * Parameter decorator to inject the validated share into a method parameter
+ */
+export const ValidatedShare = createParamDecorator(
+  (data: unknown, ctx: ExecutionContext) => {
+    const request: Request = ctx.switchToHttp().getRequest();
+    return (request as any).validatedShare;
+  },
+);
+
+/**
+ * Method decorator to automatically validate share before method execution
+ * Extracts shareId from route params, password from cookies, and userId from request
+ */
+export function ValidateShare(options: ValidateShareOptions = {}) {
+  return applyDecorators(SetMetadata(VALIDATE_SHARE_KEY, options));
+}

src/interceptor/validate-share.interceptor.ts

@@ -0,0 +1,73 @@
+import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+  ForbiddenException,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { Request } from 'express';
+import { SharesService } from 'omniboxd/shares/shares.service';
+import {
+  VALIDATE_SHARE_KEY,
+  ValidateShareOptions,
+} from 'omniboxd/decorators/validate-share.decorator';
+import { ShareType } from 'omniboxd/shares/entities/share.entity';
+
+@Injectable()
+export class ValidateShareInterceptor implements NestInterceptor {
+  constructor(
+    private readonly reflector: Reflector,
+    private readonly sharesService: SharesService,
+  ) {}
+
+  async intercept(
+    context: ExecutionContext,
+    next: CallHandler,
+  ): Promise<Observable<any>> {
+    const validateOptions = this.reflector.get<ValidateShareOptions>(
+      VALIDATE_SHARE_KEY,
+      context.getHandler(),
+    );
+
+    if (!validateOptions) {
+      return next.handle();
+    }
+
+    const request: Request = context.switchToHttp().getRequest();
+
+    // Extract parameters using fixed parameter names
+    const shareId = request.params['shareId'];
+    const password = request.cookies?.['share-password'];
+    const userId = request.user?.id; // Assuming user is attached to request by auth middleware
+
+    if (!shareId) {
+      throw new Error(`Share ID parameter 'shareId' not found in request`);
+    }
+
+    // Validate the share
+    const validatedShare = await this.sharesService.getAndValidateShare(
+      shareId,
+      password,
+      userId,
+    );
+
+    // Additional chat validation if required
+    if (validateOptions.requireChat) {
+      if (
+        validatedShare.shareType !== ShareType.CHAT_ONLY &&
+        validatedShare.shareType !== ShareType.ALL
+      ) {
+        throw new ForbiddenException(
+          'This share does not allow chat functionality',
+        );
+      }
+    }
+
+    // Attach the validated share to the request for the @ValidatedShare decorator
+    (request as any).validatedShare = validatedShare;
+
+    return next.handle();
+  }
+}

src/messages/entities/message.entity.ts

@@ -44,8 +44,8 @@ export class Message extends Base {
   @PrimaryGeneratedColumn()
   id: string;
 
-  @Column()
-  userId: string;
+  @Column('varchar', { nullable: true })
+  userId: string | null;
 
   @Column()
   conversationId: string;