Skip to content

The open alternative to Salesforce, designed for AI.

11.8 KB
Raw Blame
import { UseFilters, UseGuards } from '@nestjs/common';
import { Context, Parent, Query, ResolveField } from '@nestjs/graphql';

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 { ApplicationExceptionFilter } from 'src/engine/core-modules/application/application-exception-filter';
import { ApplicationStopService } from 'src/engine/core-modules/application/application-stop/application-stop.service';
import { ApplicationVariableEntityDTO } from 'src/engine/core-modules/application/application-variable/dtos/application-variable.dto';
import {
  ApplicationException,
  ApplicationExceptionCode,
} from 'src/engine/core-modules/application/application.exception';
import { ApplicationService } from 'src/engine/core-modules/application/application.service';
import { type ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
import { ApplicationDTO } from 'src/engine/core-modules/application/dtos/application.dto';
import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
import { buildPublicAssetLogoUrl } from 'src/engine/core-modules/application/utils/build-public-asset-logo-url.util';
import { canCallerReachApplication } from 'src/engine/core-modules/application/utils/can-caller-reach-application.util';
import { ForbiddenError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
import { SdkClientChecksumsDTO } from 'src/engine/core-modules/sdk-client/dtos/sdk-client-checksums.dto';
import { getInstalledSdkMetadataModule } from 'src/engine/core-modules/sdk-client/utils/get-installed-sdk-metadata-module.util';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { type IDataloaders } from 'src/engine/dataloaders/dataloader.interface';
import { AgentDTO } from 'src/engine/metadata-modules/ai/ai-agent/dtos/agent.dto';
import { CommandMenuItemDTO } from 'src/engine/metadata-modules/command-menu-item/dtos/command-menu-item.dto';
import { FrontComponentDTO } from 'src/engine/metadata-modules/front-component/dtos/front-component.dto';
import { LogicFunctionDTO } from 'src/engine/metadata-modules/logic-function/dtos/logic-function.dto';
import { ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
import { SettingsMenuItemDTO } from 'src/engine/metadata-modules/settings-menu-item/dtos/settings-menu-item.dto';
import { AuthApplication } from 'src/engine/decorators/auth/auth-application.decorator';
import { ApplicationTargetArg } from 'src/engine/decorators/auth/application-target-arg.decorator';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
import { AuthPrincipalGuard } from 'src/engine/guards/auth-principal.guard';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
import { ApplicationTargetGuard } from 'src/engine/guards/application-target.guard';

@UseGuards(
  AuthPrincipalGuard({
    userSession: {
      standard: true,
      impersonated: true,
      playground: true,
      workspaceAgnostic: false,
    },
    apiKey: true,
    oauthClient: true,
    application: true,
  }),
  NoPermissionGuard,
)
@MetadataResolver(() => ApplicationDTO)
@UseFilters(ApplicationExceptionFilter)
export class ApplicationResolver {
  constructor(
    private readonly twentyConfigService: TwentyConfigService,
    private readonly workspaceCacheService: WorkspaceCacheService,
    private readonly applicationStopService: ApplicationStopService,
    private readonly applicationService: ApplicationService,
  ) {}

  @Query(() => SdkClientChecksumsDTO, { nullable: true })
  @UseGuards(ApplicationTargetGuard)
  async applicationSdkClientChecksums(
    @ApplicationTargetArg(
      'applicationId',
      { kind: 'applicationId', requireApplicationRegistrationOwnership: false },
      { type: () => UUIDScalarType },
    )
    applicationId: string,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<SdkClientChecksumsDTO | null> {
    const { flatApplicationMaps } =
      await this.workspaceCacheService.getOrRecompute(workspace.id, [
        'flatApplicationMaps',
      ]);

    const application = flatApplicationMaps.byId[applicationId];

    if (!isDefined(application)) {
      return null;
    }

    return {
      core: application.sdkClientCoreChecksum,
      metadata: (await getInstalledSdkMetadataModule()).checksum,
    };
  }

  // Surfaces the kill switch so clients can warn users that the app is
  // temporarily stopped and behaving in a degraded way. Kept as a dedicated
  // query so listing applications does not trigger one Redis read per app.
  @Query(() => Boolean)
  @UseGuards(ApplicationTargetGuard)
  async isApplicationStopped(
    @ApplicationTargetArg('applicationUniversalIdentifier', {
      kind: 'applicationUniversalIdentifier',
      requireApplicationRegistrationOwnership: false,
    })
    applicationUniversalIdentifier: string,
  ): Promise<boolean> {
    return this.applicationStopService.isApplicationStopped(
      applicationUniversalIdentifier,
    );
  }

  // Resolves the display url of the logo bundled in the installed
  // application's public assets, so clients never build file urls themselves.
  @ResolveField(() => String, { nullable: true })
  logoUrl(
    @Parent() application: Pick<ApplicationDTO, 'id' | 'logo'>,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): string | null {
    return buildPublicAssetLogoUrl({
      logo: application.logo,
      serverUrl: this.twentyConfigService.get('SERVER_URL'),
      workspaceId: workspace.id,
      applicationId: application.id,
    });
  }

  @ResolveField(() => Boolean)
  runOnUserPreferences(
    @Parent()
    application: Partial<
      Pick<ApplicationEntity, 'isUserHealthCheckEnabled'> &
        Pick<ApplicationDTO, 'runOnUserPreferences'>
    >,
  ): boolean {
    return (
      application.runOnUserPreferences ??
      application.isUserHealthCheckEnabled ??
      false
    );
  }

  @ResolveField(() => Boolean)
  isUninstallBlockedByOtherWorkspaceInstallations(
    @Parent()
    application: Pick<ApplicationDTO, 'id' | 'applicationRegistrationId'>,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<boolean> {
    return this.applicationService.isUninstallBlockedByOtherWorkspaceInstallations(
      {
        applicationId: application.id,
        applicationRegistrationId: application.applicationRegistrationId,
        workspaceId: workspace.id,
      },
    );
  }

  @ResolveField(() => [AgentDTO])
  agents(
    @Parent() application: Pick<ApplicationDTO, 'id'>,
    @AuthWorkspace()
    { id: workspaceId, workspaceCustomApplicationId }: WorkspaceEntity,
    @Context() context: { loaders: IDataloaders },
    @AuthApplication({ allowUndefined: true })
    callingApplication: FlatApplication | undefined,
  ) {
    if (
      !canCallerReachApplication({
        callingApplication,
        applicationId: application.id,
        operation: 'read',
        workspaceCustomApplicationId,
      })
    ) {
      return [];
    }

    return context.loaders.agentsByApplicationIdLoader.load({
      workspaceId,
      applicationId: application.id,
    });
  }

  @ResolveField(() => [FrontComponentDTO])
  frontComponents(
    @Parent() application: Pick<ApplicationDTO, 'id'>,
    @AuthWorkspace()
    { id: workspaceId, workspaceCustomApplicationId }: WorkspaceEntity,
    @Context() context: { loaders: IDataloaders },
    @AuthApplication({ allowUndefined: true })
    callingApplication: FlatApplication | undefined,
  ) {
    if (
      !canCallerReachApplication({
        callingApplication,
        applicationId: application.id,
        operation: 'read',
        workspaceCustomApplicationId,
      })
    ) {
      return [];
    }

    return context.loaders.frontComponentsByApplicationIdLoader.load({
      workspaceId,
      applicationId: application.id,
    });
  }

  @ResolveField(() => [CommandMenuItemDTO])
  commandMenuItems(
    @Parent() application: Pick<ApplicationDTO, 'id'>,
    @AuthWorkspace()
    { id: workspaceId, workspaceCustomApplicationId }: WorkspaceEntity,
    @Context() context: { loaders: IDataloaders },
    @AuthApplication({ allowUndefined: true })
    callingApplication: FlatApplication | undefined,
  ) {
    if (
      !canCallerReachApplication({
        callingApplication,
        applicationId: application.id,
        operation: 'read',
        workspaceCustomApplicationId,
      })
    ) {
      return [];
    }

    return context.loaders.commandMenuItemsByApplicationIdLoader.load({
      workspaceId,
      applicationId: application.id,
    });
  }

  @ResolveField(() => [SettingsMenuItemDTO], { nullable: true })
  settingsMenuItems(
    @Parent() application: Pick<ApplicationDTO, 'id'>,
    @AuthWorkspace()
    { id: workspaceId, workspaceCustomApplicationId }: WorkspaceEntity,
    @Context() context: { loaders: IDataloaders },
    @AuthApplication({ allowUndefined: true })
    callingApplication: FlatApplication | undefined,
  ) {
    if (
      !canCallerReachApplication({
        callingApplication,
        applicationId: application.id,
        operation: 'read',
        workspaceCustomApplicationId,
      })
    ) {
      return [];
    }

    return context.loaders.settingsMenuItemsByApplicationIdLoader.load({
      workspaceId,
      applicationId: application.id,
    });
  }

  @ResolveField(() => [LogicFunctionDTO])
  logicFunctions(
    @Parent() application: Pick<ApplicationDTO, 'id'>,
    @AuthWorkspace()
    { id: workspaceId, workspaceCustomApplicationId }: WorkspaceEntity,
    @Context() context: { loaders: IDataloaders },
    @AuthApplication({ allowUndefined: true })
    callingApplication: FlatApplication | undefined,
  ) {
    if (
      !canCallerReachApplication({
        callingApplication,
        applicationId: application.id,
        operation: 'read',
        workspaceCustomApplicationId,
      })
    ) {
      return [];
    }

    return context.loaders.logicFunctionsByApplicationIdLoader.load({
      workspaceId,
      applicationId: application.id,
    });
  }

  @ResolveField(() => [ObjectMetadataDTO])
  objects(
    @Parent() application: Pick<ApplicationDTO, 'id'>,
    @AuthWorkspace()
    { id: workspaceId, workspaceCustomApplicationId }: WorkspaceEntity,
    @Context() context: { loaders: IDataloaders },
    @AuthApplication({ allowUndefined: true })
    callingApplication: FlatApplication | undefined,
  ) {
    if (
      !canCallerReachApplication({
        callingApplication,
        applicationId: application.id,
        operation: 'read',
        workspaceCustomApplicationId,
      })
    ) {
      return [];
    }

    return context.loaders.objectMetadataByApplicationIdLoader.load({
      workspaceId,
      applicationId: application.id,
    });
  }

  @ResolveField(() => [ApplicationVariableEntityDTO])
  applicationVariables(
    @Parent() application: Pick<ApplicationDTO, 'id'>,
    @AuthWorkspace() workspace: WorkspaceEntity,
    @Context() context: { loaders: IDataloaders },
    @AuthApplication({ allowUndefined: true })
    callingApplication: FlatApplication | undefined,
  ) {
    if (
      !canCallerReachApplication({
        callingApplication,
        applicationId: application.id,
        operation: 'manage',
      })
    ) {
      throw new ForbiddenError(
        new ApplicationException(
          'An application token can only read its own application variables',
          ApplicationExceptionCode.FORBIDDEN,
        ),
      );
    }

    return context.loaders.applicationVariablesByApplicationIdLoader.load({
      workspaceId: workspace.id,
      applicationId: application.id,
    });
  }
}