Skip to content

The open alternative to Salesforce, designed for AI.

3.7 KB
Raw Blame
import { UseGuards, UseInterceptors, UseFilters } from '@nestjs/common';
import { Args, Mutation, Query } from '@nestjs/graphql';

import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-workspace-id.decorator';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { MessageFolderDTO } from 'src/engine/metadata-modules/message-folder/dtos/message-folder.dto';
import {
  UpdateMessageFolderInput,
  UpdateMessageFoldersInput,
} from 'src/engine/metadata-modules/message-folder/dtos/update-message-folder.input';
import { MessageFolderGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/message-folder/interceptors/message-folder-graphql-api-exception.interceptor';
import { MessageFolderMetadataService } from 'src/engine/metadata-modules/message-folder/message-folder-metadata.service';
import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filters/auth-graphql-api-exception.filter';
import { AccessPolicyGuard } from 'src/engine/guards/access-policy.guard';

@UseGuards(
  AccessPolicyGuard({
    authPrincipals: {
      userSession: {
        standard: true,
        impersonated: true,
        playground: true,
        workspaceAgnostic: false,
      },
      apiKey: true,
      oauthClient: true,
      application: true,
    },
    requiredPermissionFlags: [],
  }),
)
@UseInterceptors(MessageFolderGraphqlApiExceptionInterceptor)
@MetadataResolver(() => MessageFolderDTO)
@UseFilters(AuthGraphqlApiExceptionFilter)
export class MessageFolderResolver {
  constructor(
    private readonly messageFolderMetadataService: MessageFolderMetadataService,
  ) {}

  @Query(() => [MessageFolderDTO])
  async myMessageFolders(
    @AuthWorkspace() workspace: WorkspaceEntity,
    @AuthUserWorkspaceId() userWorkspaceId: string,
    @Args('messageChannelId', {
      type: () => UUIDScalarType,
      nullable: true,
    })
    messageChannelId?: string,
  ): Promise<MessageFolderDTO[]> {
    if (messageChannelId) {
      return this.messageFolderMetadataService.findByMessageChannelIdForUser({
        messageChannelId,
        userWorkspaceId,
        workspaceId: workspace.id,
      });
    }

    return this.messageFolderMetadataService.findByUserWorkspaceId({
      userWorkspaceId,
      workspaceId: workspace.id,
    });
  }

  @Mutation(() => MessageFolderDTO)
  async updateMessageFolder(
    @Args('input') input: UpdateMessageFolderInput,
    @AuthWorkspace() workspace: WorkspaceEntity,
    @AuthUserWorkspaceId() userWorkspaceId: string,
  ): Promise<MessageFolderDTO> {
    await this.messageFolderMetadataService.verifyAdministrableByCaller({
      id: input.id,
      userWorkspaceId,
      workspaceId: workspace.id,
    });

    return this.messageFolderMetadataService.update({
      id: input.id,
      workspaceId: workspace.id,
      data: input.update,
    });
  }

  @Mutation(() => [MessageFolderDTO])
  async updateMessageFolders(
    @Args('input') input: UpdateMessageFoldersInput,
    @AuthWorkspace() workspace: WorkspaceEntity,
    @AuthUserWorkspaceId() userWorkspaceId: string,
  ): Promise<MessageFolderDTO[]> {
    await Promise.all(
      input.ids.map((id) =>
        this.messageFolderMetadataService.verifyAdministrableByCaller({
          id,
          userWorkspaceId,
          workspaceId: workspace.id,
        }),
      ),
    );

    return this.messageFolderMetadataService.setSyncStatus({
      ids: input.ids,
      workspaceId: workspace.id,
      data: input.update,
    });
  }
}