Skip to content

The open alternative to Salesforce, designed for AI.

6.4 KB
Raw Blame
import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
import { Args, Context, Int, Mutation, Query } from '@nestjs/graphql';

import { type Request } from 'express';
import { isDefined } from 'twenty-shared/utils';

import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filters/auth-graphql-api-exception.filter';
import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';
import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
import { UserSessionDTO } from 'src/engine/core-modules/user-session/dtos/user-session.dto';
import { UserSessionService } from 'src/engine/core-modules/user-session/services/user-session.service';
import { type UserSessionEntity } from 'src/engine/core-modules/user-session/user-session.entity';
import { UserSessionRevokedReason } from 'src/engine/core-modules/user-session/types/user-session-revoked-reason.type';
import { UserSessionCookieService } from 'src/engine/core-modules/user-session/services/user-session-cookie.service';
import { hashUserSessionToken } from 'src/engine/core-modules/user-session/utils/hash-user-session-token.util';
import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { AllowSuspendedWorkspace } from 'src/engine/decorators/auth/allow-suspended-workspace.decorator';
import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
import { AuthPrincipalGuard } from 'src/engine/guards/auth-principal.guard';

@UsePipes(ResolverValidationPipe)
@UseFilters(AuthGraphqlApiExceptionFilter)
@UseGuards(
  AuthPrincipalGuard({
    userSession: true,
    apiKey: false,
    oauthClient: false,
    application: false,
  }),
  NoPermissionGuard,
)
@MetadataResolver()
@AllowSuspendedWorkspace()
export class UserSessionResolver {
  constructor(
    private readonly userSessionService: UserSessionService,
    private readonly userSessionCookieService: UserSessionCookieService,
  ) {}

  @Query(() => [UserSessionDTO])
  async currentUserSessions(
    @AuthUser() user: AuthContextUser,
    @AuthWorkspace({ allowUndefined: true }) workspace:
      | WorkspaceEntity
      | undefined,
    @Context() context: { req: Request },
  ): Promise<UserSessionDTO[]> {
    // Workspace-agnostic sessions have no workspace to scope to: nothing is in scope rather than everything.
    if (!isDefined(workspace)) {
      return [];
    }

    const sessions =
      await this.userSessionService.findActiveSessionsForUserWorkspace({
        userId: user.id,
        workspaceId: workspace.id,
      });

    const presentedSessionToken =
      this.userSessionCookieService.extractSessionTokenFromRequest(context.req);
    const presentedTokenHash = isDefined(presentedSessionToken)
      ? hashUserSessionToken(presentedSessionToken)
      : undefined;

    return sessions.map((session) =>
      this.toUserSessionDTO(session, presentedTokenHash),
    );
  }

  @Mutation(() => Boolean)
  async revokeUserSession(
    @AuthUser() user: AuthContextUser,
    @AuthWorkspace({ allowUndefined: true }) workspace:
      | WorkspaceEntity
      | undefined,
    @Args('userSessionId', { type: () => UUIDScalarType })
    userSessionId: string,
    @Context() context: { req: Request },
  ): Promise<boolean> {
    if (!isDefined(workspace)) {
      return false;
    }

    // Before revoking: afterwards it is no longer active and would not be found.
    const currentSession = await this.resolveCurrentSession({
      request: context.req,
      user,
      workspace,
    });

    const revoked =
      await this.userSessionService.revokeSessionByIdForUserWorkspace({
        sessionId: userSessionId,
        userId: user.id,
        workspaceId: workspace.id,
        reason: UserSessionRevokedReason.UserRevoked,
      });

    if (
      revoked &&
      currentSession?.id === userSessionId &&
      isDefined(context.req.res)
    ) {
      this.userSessionCookieService.clearSessionCookie(context.req.res);
    }

    return revoked;
  }

  // A revoked or expired cookie must not decide which sessions survive.
  private async resolveCurrentSession({
    request,
    user,
    workspace,
  }: {
    request: Request;
    user: AuthContextUser;
    workspace: Pick<WorkspaceEntity, 'id'>;
  }): Promise<UserSessionEntity | undefined> {
    const presentedSessionToken =
      this.userSessionCookieService.extractSessionTokenFromRequest(request);

    if (!isDefined(presentedSessionToken)) {
      return undefined;
    }

    const activeSessions =
      await this.userSessionService.findActiveSessionsForUserWorkspace({
        userId: user.id,
        workspaceId: workspace.id,
      });
    const presentedTokenHash = hashUserSessionToken(presentedSessionToken);

    return activeSessions.find(
      (session) => session.tokenHash === presentedTokenHash,
    );
  }

  @Mutation(() => Int)
  async revokeAllOtherUserSessions(
    @AuthUser() user: AuthContextUser,
    @AuthWorkspace({ allowUndefined: true }) workspace:
      | WorkspaceEntity
      | undefined,
    @Context() context: { req: Request },
  ): Promise<number> {
    if (!isDefined(workspace)) {
      return 0;
    }

    const currentSession = await this.resolveCurrentSession({
      request: context.req,
      user,
      workspace,
    });

    return await this.userSessionService.revokeAllSessionsForUser({
      userId: user.id,
      workspaceId: workspace.id,
      reason: UserSessionRevokedReason.UserRevoked,
      exceptSessionId: currentSession?.id,
    });
  }

  private toUserSessionDTO(
    session: UserSessionEntity,
    presentedTokenHash: string | undefined,
  ): UserSessionDTO {
    return {
      id: session.id,
      workspaceId: session.workspaceId,
      authProvider: session.authProvider,
      isImpersonating: session.isImpersonating,
      userAgent: session.userAgent,
      ipAddress: session.ipAddress,
      country: session.country,
      region: session.region,
      city: session.city,
      createdAt: session.createdAt,
      lastActiveAt: session.lastActiveAt,
      expiresAt: session.expiresAt,
      isCurrent: session.tokenHash === presentedTokenHash,
    };
  }
}