Skip to content

The open alternative to Salesforce, designed for AI.

34.9 KB
Raw Blame
import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
import { Args, Info, Int, Mutation, Query } from '@nestjs/graphql';
import { InjectRepository } from '@nestjs/typeorm';

import { type GraphQLResolveInfo } from 'graphql';
import GraphQLJSON from 'graphql-type-json';
import { AI_MODEL_TIERS } from 'twenty-shared/ai';
import { isDefined } from 'twenty-shared/utils';
import { In, type Repository } from 'typeorm';

import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
import { InstanceAndAllWorkspacesUpgradeStatusDTO } from 'src/engine/core-modules/upgrade/dtos/instance-and-all-workspaces-upgrade-status.dto';
import { WorkspaceUpgradeStatusDTO } from 'src/engine/core-modules/upgrade/dtos/workspace-upgrade-status.dto';
import { UpgradeStatusService } from 'src/engine/core-modules/upgrade/services/upgrade-status.service';

import { AdminResolver } from 'src/engine/api/graphql/graphql-config/decorators/admin-resolver.decorator';
import { AdminPanelHealthService } from 'src/engine/core-modules/admin-panel/admin-panel-health.service';
import { AdminPanelQueueService } from 'src/engine/core-modules/admin-panel/admin-panel-queue.service';
import { AdminChatThreadMessagesDTO } from 'src/engine/core-modules/admin-panel/dtos/admin-chat-thread-messages.dto';
import { AdminPanelRecentUserDTO } from 'src/engine/core-modules/admin-panel/dtos/admin-panel-recent-user.dto';
import { AdminPanelTopWorkspaceDTO } from 'src/engine/core-modules/admin-panel/dtos/admin-panel-top-workspace.dto';
import { AdminPanelWorkspaceBillingDTO } from 'src/engine/core-modules/admin-panel/dtos/admin-panel-workspace-billing.dto';
import { AdminPanelWorkspaceCreditGrantDTO } from 'src/engine/core-modules/admin-panel/dtos/admin-panel-workspace-credit-grant.dto';
import { GrantWorkspaceCreditsInput } from 'src/engine/core-modules/admin-panel/dtos/grant-workspace-credits.input';
import { RevokeWorkspaceCreditGrantInput } from 'src/engine/core-modules/admin-panel/dtos/revoke-workspace-credit-grant.input';
import { AdminWorkspaceChatThreadDTO } from 'src/engine/core-modules/admin-panel/dtos/admin-workspace-chat-thread.dto';
import { ConfigVariableDTO } from 'src/engine/core-modules/admin-panel/dtos/config-variable.dto';
import { ConfigVariablesDTO } from 'src/engine/core-modules/admin-panel/dtos/config-variables.dto';
import { DeleteJobsResponseDTO } from 'src/engine/core-modules/admin-panel/dtos/delete-jobs-response.dto';
import { QueueJobsResponseDTO } from 'src/engine/core-modules/admin-panel/dtos/queue-jobs-response.dto';
import { RetryJobsResponseDTO } from 'src/engine/core-modules/admin-panel/dtos/retry-jobs-response.dto';
import { RevokeSigningKeyInput } from 'src/engine/core-modules/admin-panel/dtos/revoke-signing-key.input';
import { ServerAdminDTO } from 'src/engine/core-modules/admin-panel/dtos/server-admin.dto';
import { SigningKeyDTO } from 'src/engine/core-modules/admin-panel/dtos/signing-key.dto';
import { SigningKeysAdminPanelDTO } from 'src/engine/core-modules/admin-panel/dtos/signing-keys-admin-panel.dto';
import { SystemHealthDTO } from 'src/engine/core-modules/admin-panel/dtos/system-health.dto';
import { GenerateTwoFactorAuthenticationRecoveryCodeAsServerAdminInput } from 'src/engine/core-modules/admin-panel/dtos/generate-two-factor-authentication-recovery-code-as-server-admin.input';
import { UpdateServerAdminAccessInput } from 'src/engine/core-modules/admin-panel/dtos/update-server-admin-access.input';
import { UpdateWorkspaceFeatureFlagInput } from 'src/engine/core-modules/admin-panel/dtos/update-workspace-feature-flag.input';
import { UserLookup } from 'src/engine/core-modules/admin-panel/dtos/user-lookup.dto';
import { UserLookupInput } from 'src/engine/core-modules/admin-panel/dtos/user-lookup.input';
import { VersionInfoDTO } from 'src/engine/core-modules/admin-panel/dtos/version-info.dto';
import { HealthIndicatorId } from 'src/engine/core-modules/admin-panel/enums/health-indicator-id.enum';
import { JobStateEnum } from 'src/engine/core-modules/message-queue/enums/job-state.enum';
import { QueueMetricsTimeRange } from 'src/engine/core-modules/admin-panel/enums/queue-metrics-time-range.enum';
import { MaintenanceModeService } from 'src/engine/core-modules/admin-panel/maintenance-mode.service';
import { AdminPanelBillingService } from 'src/engine/core-modules/admin-panel/services/admin-panel-billing.service';
import { AdminPanelChatService } from 'src/engine/core-modules/admin-panel/services/admin-panel-chat.service';
import { AdminPanelConfigService } from 'src/engine/core-modules/admin-panel/services/admin-panel-config.service';
import { AdminPanelSigningKeyService } from 'src/engine/core-modules/admin-panel/services/admin-panel-signing-key.service';
import { AdminPanelServerAdminService } from 'src/engine/core-modules/admin-panel/services/admin-panel-server-admin.service';
import { AdminPanelStatisticsService } from 'src/engine/core-modules/admin-panel/services/admin-panel-statistics.service';
import { AdminPanelUserLookupService } from 'src/engine/core-modules/admin-panel/services/admin-panel-user-lookup.service';
import { AdminPanelVersionService } from 'src/engine/core-modules/admin-panel/services/admin-panel-version.service';
import { ApplicationRegistrationVariableDTO } from 'src/engine/core-modules/application/application-registration-variable/dtos/application-registration-variable.dto';
import { ApplicationRegistrationVariableService } from 'src/engine/core-modules/application/application-registration-variable/application-registration-variable.service';
import { UpdateApplicationRegistrationVariableInput } from 'src/engine/core-modules/application/application-registration-variable/dtos/update-application-registration-variable.input';
import { ApplicationRegistrationClaimService } from 'src/engine/core-modules/application/application-registration/application-registration-claim.service';
import { ApplicationRegistrationEntity } from 'src/engine/core-modules/application/application-registration/application-registration.entity';
import { ApplicationRegistrationExceptionFilter } from 'src/engine/core-modules/application/application-registration/application-registration-exception-filter';
import { ApplicationRegistrationService } from 'src/engine/core-modules/application/application-registration/application-registration.service';
import { isCreditsUsedRequested } from 'src/engine/core-modules/application/application-registration/utils/is-credits-used-requested.util';
import { ApplicationRegistrationSourceType } from 'src/engine/core-modules/application/application-registration/enums/application-registration-source-type.enum';
import { AdminApplicationRegistrationClaimDTO } from 'src/engine/core-modules/application/application-registration/dtos/admin-application-registration-claim.dto';
import { AdminUpdateApplicationRegistrationInput } from 'src/engine/core-modules/application/application-registration/dtos/admin-update-application-registration.input';
import { ApplicationRegistrationInstalledWorkspacesDTO } from 'src/engine/core-modules/application/application-registration/dtos/application-registration-installed-workspaces.dto';
import { ApplicationRegistrationStatsDTO } from 'src/engine/core-modules/application/application-registration/dtos/application-registration-stats.dto';
import { FindApplicationRegistrationInstalledWorkspacesInput } from 'src/engine/core-modules/application/application-registration/dtos/find-application-registration-installed-workspaces.input';
import { PaginatedApplicationRegistrationsDTO } from 'src/engine/core-modules/application/application-registration/dtos/paginated-application-registrations.dto';
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 { AdminAiModelsDTO } from 'src/engine/core-modules/client-config/client-config.entity';
import { FeatureFlagException } from 'src/engine/core-modules/feature-flag/feature-flag.exception';
import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
import { UserInputError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
import { MarketplaceCatalogSyncCronJob } from 'src/engine/core-modules/application/application-marketplace/crons/marketplace-catalog-sync.cron.job';
import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';
import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
import { type ConfigVariables } from 'src/engine/core-modules/twenty-config/config-variables';
import { ConfigVariableGraphqlApiExceptionFilter } from 'src/engine/core-modules/twenty-config/filters/config-variable-graphql-api-exception.filter';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
import { ThrottlerGraphqlApiExceptionFilter } from 'src/engine/core-modules/throttler/filters/throttler-graphql-api-exception.filter';
import { TwoFactorAuthenticationExceptionFilter } from 'src/engine/core-modules/two-factor-authentication/two-factor-authentication-exception.filter';
import { TwoFactorAuthenticationRecoveryCodeDTO } from 'src/engine/core-modules/two-factor-authentication/dto/two-factor-authentication-recovery-code.dto';
import { TwoFactorAuthenticationRecoveryService } from 'src/engine/core-modules/two-factor-authentication/services/two-factor-authentication-recovery.service';
import { UsageBreakdownItemDTO } from 'src/engine/core-modules/usage/dtos/usage-breakdown-item.dto';
import { UsageAnalyticsService } from 'src/engine/core-modules/usage/services/usage-analytics.service';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { AdminPanelGuard } from 'src/engine/guards/admin-panel-guard';
import { AdminPanelOrImpersonateGuard } from 'src/engine/guards/admin-panel-or-impersonate.guard';
import { AuthPrincipalGuard } from 'src/engine/guards/auth-principal.guard';
import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
import { ServerLevelImpersonateGuard } from 'src/engine/guards/server-level-impersonate.guard';
import { MODEL_FAMILY_LABELS } from 'src/engine/metadata-modules/ai/ai-models/constants/model-family-labels.const';
import { AiModelRegistryService } from 'src/engine/metadata-modules/ai/ai-models/services/ai-model-registry.service';
import { AiModelTier } from 'src/engine/metadata-modules/ai/ai-models/types/ai-model-tier.enum';

import { AdminPanelHealthServiceDataDTO } from './dtos/admin-panel-health-service-data.dto';
import { MaintenanceModeDTO } from './dtos/maintenance-mode.dto';
import { QueueMetricsDataDTO } from './dtos/queue-metrics-data.dto';
import { SetMaintenanceModeInput } from './dtos/set-maintenance-mode.input';
import { getAvailableEfforts } from 'src/engine/metadata-modules/ai/ai-models/utils/get-available-efforts.util';

@UsePipes(ResolverValidationPipe)
@AdminResolver()
@UseFilters(
  AuthGraphqlApiExceptionFilter,
  TwoFactorAuthenticationExceptionFilter,
  ThrottlerGraphqlApiExceptionFilter,
  PreventNestToAutoLogGraphqlErrorsFilter,
  ConfigVariableGraphqlApiExceptionFilter,
)
@UseGuards(
  AuthPrincipalGuard({
    userSession: {
      standard: true,
      impersonated: true,
      playground: true,
      workspaceAgnostic: false,
    },
    apiKey: false,
    oauthClient: false,
    application: false,
  }),
  NoPermissionGuard,
)
export class AdminPanelResolver {
  constructor(
    private readonly adminUserLookupService: AdminPanelUserLookupService,
    private readonly adminServerAdminService: AdminPanelServerAdminService,
    private readonly twoFactorAuthenticationRecoveryService: TwoFactorAuthenticationRecoveryService,
    private readonly adminStatisticsService: AdminPanelStatisticsService,
    private readonly adminBillingService: AdminPanelBillingService,
    private readonly adminChatService: AdminPanelChatService,
    private readonly adminConfigService: AdminPanelConfigService,
    private readonly adminVersionService: AdminPanelVersionService,
    private readonly adminPanelHealthService: AdminPanelHealthService,
    private readonly adminPanelSigningKeyService: AdminPanelSigningKeyService,
    private readonly applicationRegistrationService: ApplicationRegistrationService,
    private readonly applicationRegistrationClaimService: ApplicationRegistrationClaimService,
    private readonly applicationRegistrationVariableService: ApplicationRegistrationVariableService,
    private adminPanelQueueService: AdminPanelQueueService,
    private featureFlagService: FeatureFlagService,
    private readonly twentyConfigService: TwentyConfigService,
    private readonly aiModelRegistryService: AiModelRegistryService,
    private readonly usageAnalyticsService: UsageAnalyticsService,
    private readonly maintenanceModeService: MaintenanceModeService,
    private readonly upgradeStatusService: UpgradeStatusService,
    @InjectRepository(WorkspaceEntity)
    private readonly workspaceRepository: Repository<WorkspaceEntity>,
    @InjectMessageQueue(MessageQueue.cronQueue)
    private readonly cronQueueService: MessageQueueService,
  ) {}

  @UseGuards(AdminPanelOrImpersonateGuard)
  @Query(() => UserLookup)
  async userLookupAdminPanel(
    @Args() userLookupInput: UserLookupInput,
  ): Promise<UserLookup> {
    return await this.adminUserLookupService.userLookup(
      userLookupInput.userIdentifier,
    );
  }

  @UseGuards(AdminPanelOrImpersonateGuard)
  @Query(() => [AdminPanelRecentUserDTO])
  async adminPanelRecentUsers(
    @Args('searchTerm', {
      type: () => String,
      nullable: true,
      defaultValue: '',
    })
    searchTerm: string,
  ): Promise<AdminPanelRecentUserDTO[]> {
    return this.adminStatisticsService.getRecentUsers(searchTerm);
  }

  @UseGuards(ServerLevelImpersonateGuard)
  @Query(() => [AdminPanelTopWorkspaceDTO])
  async adminPanelTopWorkspaces(
    @Args('searchTerm', {
      type: () => String,
      nullable: true,
      defaultValue: '',
    })
    searchTerm: string,
  ): Promise<AdminPanelTopWorkspaceDTO[]> {
    return this.adminStatisticsService.getTopWorkspaces(searchTerm);
  }

  @UseGuards(
    AuthPrincipalGuard({
      userSession: {
        standard: true,
        impersonated: false,
        playground: true,
        workspaceAgnostic: false,
      },
      apiKey: false,
      oauthClient: false,
      application: false,
    }),
    AdminPanelGuard,
  )
  @Query(() => [ServerAdminDTO])
  async getServerAdmins(): Promise<ServerAdminDTO[]> {
    return this.adminServerAdminService.getServerAdmins();
  }

  @UseGuards(
    AuthPrincipalGuard({
      userSession: {
        standard: true,
        impersonated: false,
        playground: true,
        workspaceAgnostic: false,
      },
      apiKey: false,
      oauthClient: false,
      application: false,
    }),
    AdminPanelGuard,
  )
  @Mutation(() => ServerAdminDTO)
  async updateServerAdminAccess(
    @Args() input: UpdateServerAdminAccessInput,
    @AuthUser() actor: AuthContextUser,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<ServerAdminDTO> {
    return this.adminServerAdminService.updateServerAdminAccess({
      actor,
      actorWorkspaceId: workspace.id,
      targetUserId: input.userId,
      canAccessFullAdminPanel: input.canAccessFullAdminPanel,
      canImpersonate: input.canImpersonate,
      otp: input.otp,
    });
  }

  @UseGuards(
    AuthPrincipalGuard({
      userSession: {
        standard: true,
        impersonated: false,
        playground: false,
        workspaceAgnostic: false,
      },
      apiKey: false,
      oauthClient: false,
      application: false,
    }),
    AdminPanelGuard,
  )
  @Mutation(() => TwoFactorAuthenticationRecoveryCodeDTO)
  async generateTwoFactorAuthenticationRecoveryCodeAsServerAdmin(
    @Args()
    input: GenerateTwoFactorAuthenticationRecoveryCodeAsServerAdminInput,
    @AuthUser() actor: AuthContextUser,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<TwoFactorAuthenticationRecoveryCodeDTO> {
    return this.twoFactorAuthenticationRecoveryService.generateRecoveryCode({
      actor,
      actorWorkspaceId: workspace.id,
      otp: input.otp,
      targetUserId: input.userId,
      targetWorkspaceId: input.workspaceId,
    });
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => Boolean)
  async updateWorkspaceFeatureFlag(
    @Args() updateFlagInput: UpdateWorkspaceFeatureFlagInput,
  ): Promise<boolean> {
    try {
      await this.featureFlagService.upsertWorkspaceFeatureFlag({
        workspaceId: updateFlagInput.workspaceId,
        featureFlag: updateFlagInput.featureFlag,
        value: updateFlagInput.value,
      });

      return true;
    } catch (error) {
      if (error instanceof FeatureFlagException) {
        throw new UserInputError(error.message);
      }

      throw error;
    }
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => ConfigVariablesDTO)
  async getConfigVariablesGrouped(): Promise<ConfigVariablesDTO> {
    return this.adminConfigService.getConfigVariablesGrouped();
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => SystemHealthDTO)
  async getSystemHealthStatus(): Promise<SystemHealthDTO> {
    return this.adminPanelHealthService.getSystemHealthStatus();
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => AdminPanelHealthServiceDataDTO)
  async getIndicatorHealthStatus(
    @Args('indicatorId', {
      type: () => HealthIndicatorId,
    })
    indicatorId: HealthIndicatorId,
  ): Promise<AdminPanelHealthServiceDataDTO> {
    return this.adminPanelHealthService.getIndicatorHealthStatus(indicatorId);
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => QueueMetricsDataDTO)
  async getQueueMetrics(
    @Args('queueName', { type: () => String })
    queueName: string,
    @Args('timeRange', {
      nullable: true,
      defaultValue: QueueMetricsTimeRange.OneHour,
      type: () => QueueMetricsTimeRange,
    })
    timeRange: QueueMetricsTimeRange = QueueMetricsTimeRange.OneHour,
  ): Promise<QueueMetricsDataDTO> {
    return await this.adminPanelHealthService.getQueueMetrics(
      queueName as MessageQueue,
      timeRange,
    );
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => VersionInfoDTO)
  async versionInfo(): Promise<VersionInfoDTO> {
    return this.adminVersionService.getVersionInfo();
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => AdminAiModelsDTO)
  async getAdminAiModels(): Promise<AdminAiModelsDTO> {
    const resolvedProviders =
      this.aiModelRegistryService.getResolvedProvidersForAdmin();

    const providerLabelOf = (providerName: string | undefined) =>
      isDefined(providerName)
        ? (resolvedProviders[providerName]?.label ?? providerName)
        : undefined;

    const languageModels = this.aiModelRegistryService
      .getAllModelsWithStatus()
      .map(
        ({ modelConfig, isAvailable, isAdminEnabled, providerName, name }) => ({
          modelId: modelConfig.modelId,
          label: modelConfig.label,
          kind: 'language' as const,
          modelFamily: modelConfig.modelFamily,
          modelFamilyLabel: modelConfig.modelFamily
            ? MODEL_FAMILY_LABELS[modelConfig.modelFamily]
            : undefined,
          sdkPackage: modelConfig.sdkPackage,
          isAvailable,
          isAdminEnabled,
          isDeprecated: modelConfig.isDeprecated ?? false,
          contextWindowTokens: modelConfig.contextWindowTokens,
          maxOutputTokens: modelConfig.maxOutputTokens,
          inputCostPerMillionTokens: modelConfig.inputCostPerMillionTokens,
          outputCostPerMillionTokens: modelConfig.outputCostPerMillionTokens,
          providerName,
          providerLabel: providerLabelOf(providerName),
          name,
          dataResidency: modelConfig.dataResidency,
          efforts: isDefined(modelConfig.effort)
            ? undefined
            : getAvailableEfforts(modelConfig),
        }),
      );

    const evaluationModels = this.aiModelRegistryService
      .getAllEvaluationModelsWithStatus()
      .map(({ modelConfig, isAvailable, isAdminEnabled }) => ({
        modelId: modelConfig.modelId,
        label: modelConfig.label,
        kind: 'evaluation' as const,
        sdkPackage: modelConfig.sdkPackage,
        isAvailable,
        isAdminEnabled,
        isDeprecated: modelConfig.isDeprecated ?? false,
        inputCostPerMillionTokens: modelConfig.inputCostPerMillionTokens,
        outputCostPerMillionTokens: modelConfig.outputCostPerMillionTokens,
        providerName: modelConfig.providerName,
        providerLabel: providerLabelOf(modelConfig.providerName),
        name: modelConfig.name,
        dataResidency: modelConfig.dataResidency,
      }));

    return {
      models: [...languageModels, ...evaluationModels],
      // Not the chain head: it can start with a provider this instance holds no key for
      defaultModelByTier: AI_MODEL_TIERS.map((tier) => ({
        tier,
        modelId:
          this.aiModelRegistryService.findDefaultModelForTier(tier)?.modelId,
      })),
    };
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => Boolean)
  async setAdminAiModelEnabled(
    @Args('modelId', { type: () => String }) modelId: string,
    @Args('enabled', { type: () => Boolean }) enabled: boolean,
  ): Promise<boolean> {
    await this.aiModelRegistryService.setModelAdminEnabled(modelId, enabled);

    return true;
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => Boolean)
  async setAdminAiModelsEnabled(
    @Args('modelIds', { type: () => [String] }) modelIds: string[],
    @Args('enabled', { type: () => Boolean }) enabled: boolean,
  ): Promise<boolean> {
    await this.aiModelRegistryService.setModelsAdminEnabled(modelIds, enabled);

    return true;
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => Boolean)
  async setAdminDefaultAiModel(
    @Args('tier', { type: () => AiModelTier }) tier: AiModelTier,
    @Args('modelId', { type: () => String }) modelId: string,
  ): Promise<boolean> {
    await this.aiModelRegistryService.setDefaultModel(tier, modelId);

    return true;
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => ConfigVariableDTO)
  async getDatabaseConfigVariable(
    @Args('key', { type: () => String }) key: keyof ConfigVariables,
  ): Promise<ConfigVariableDTO> {
    this.twentyConfigService.validateConfigVariableExists(key as string);

    return this.adminConfigService.getConfigVariable(key);
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => Boolean)
  async createDatabaseConfigVariable(
    @Args('key', { type: () => String }) key: keyof ConfigVariables,
    @Args('value', { type: () => GraphQLJSON })
    value: ConfigVariables[keyof ConfigVariables],
  ): Promise<boolean> {
    await this.twentyConfigService.set(key, value);

    return true;
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => Boolean)
  async updateDatabaseConfigVariable(
    @Args('key', { type: () => String }) key: keyof ConfigVariables,
    @Args('value', { type: () => GraphQLJSON })
    value: ConfigVariables[keyof ConfigVariables],
  ): Promise<boolean> {
    await this.twentyConfigService.update(key, value);

    return true;
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => Boolean)
  async deleteDatabaseConfigVariable(
    @Args('key', { type: () => String }) key: keyof ConfigVariables,
  ): Promise<boolean> {
    await this.twentyConfigService.delete(key);

    return true;
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => QueueJobsResponseDTO)
  async getQueueJobs(
    @Args('queueName', { type: () => String })
    queueName: string,
    @Args('state', { type: () => JobStateEnum })
    state: JobStateEnum,
    @Args('limit', { type: () => Int, nullable: true, defaultValue: 50 })
    limit?: number,
    @Args('offset', { type: () => Int, nullable: true, defaultValue: 0 })
    offset?: number,
  ): Promise<QueueJobsResponseDTO> {
    return await this.adminPanelQueueService.getQueueJobs(
      queueName as MessageQueue,
      state,
      limit,
      offset,
    );
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => RetryJobsResponseDTO)
  async retryJobs(
    @Args('queueName', { type: () => String })
    queueName: string,
    @Args('jobIds', { type: () => [String] })
    jobIds: string[],
  ): Promise<RetryJobsResponseDTO> {
    return await this.adminPanelQueueService.retryJobs(
      queueName as MessageQueue,
      jobIds,
    );
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => DeleteJobsResponseDTO)
  async deleteJobs(
    @Args('queueName', { type: () => String })
    queueName: string,
    @Args('jobIds', { type: () => [String] })
    jobIds: string[],
  ): Promise<DeleteJobsResponseDTO> {
    return await this.adminPanelQueueService.deleteJobs(
      queueName as MessageQueue,
      jobIds,
    );
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => PaginatedApplicationRegistrationsDTO)
  async findAllApplicationRegistrations(
    @Args('limit', { type: () => Int, nullable: true, defaultValue: 25 })
    limit: number,
    @Args('offset', { type: () => Int, nullable: true, defaultValue: 0 })
    offset: number,
    @Args('searchTerm', { type: () => String, nullable: true })
    searchTerm?: string,
    @Args('isPreInstalledOnly', { type: () => Boolean, nullable: true })
    isPreInstalledOnly?: boolean,
    @Args('sourceTypes', {
      type: () => [ApplicationRegistrationSourceType],
      nullable: true,
    })
    sourceTypes?: ApplicationRegistrationSourceType[],
    @Args('isListed', { type: () => Boolean, nullable: true })
    isListed?: boolean,
    @Args('isConfigured', { type: () => Boolean, nullable: true })
    isConfigured?: boolean,
  ): Promise<PaginatedApplicationRegistrationsDTO> {
    return this.applicationRegistrationService.findAll({
      limit,
      offset,
      searchTerm,
      isPreInstalledOnly,
      sourceTypes,
      isListed,
      isConfigured,
    });
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => Boolean)
  async syncMarketplaceCatalog(): Promise<boolean> {
    await this.cronQueueService.add(
      MarketplaceCatalogSyncCronJob.name,
      {},
      { id: 'marketplace-catalog-sync', isSystemJob: true }, // Avoids triggering multiple pending jobs
    );

    return true;
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => [AdminApplicationRegistrationClaimDTO])
  async findAdminApplicationRegistrationClaims(
    @Args('applicationRegistrationId') applicationRegistrationId: string,
  ): Promise<AdminApplicationRegistrationClaimDTO[]> {
    return this.applicationRegistrationClaimService.findClaimsForRegistration(
      applicationRegistrationId,
    );
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => ApplicationRegistrationEntity)
  async updateAdminApplicationRegistration(
    @Args('input') input: AdminUpdateApplicationRegistrationInput,
  ): Promise<ApplicationRegistrationEntity> {
    return this.applicationRegistrationService.updateGlobal(input);
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => [UsageBreakdownItemDTO])
  async getAdminAiUsageByWorkspace(
    @Args('periodStart', { type: () => Date, nullable: true })
    periodStart?: Date,
    @Args('periodEnd', { type: () => Date, nullable: true })
    periodEnd?: Date,
  ): Promise<UsageBreakdownItemDTO[]> {
    const defaultEnd = new Date();
    const defaultStart = new Date();

    defaultStart.setDate(defaultStart.getDate() - 30);

    const useDollarMode = !this.twentyConfigService.get('IS_BILLING_ENABLED');

    const items = await this.usageAnalyticsService.getAdminAiUsageByWorkspace({
      periodStart: periodStart ?? defaultStart,
      periodEnd: periodEnd ?? defaultEnd,
      useDollarMode,
    });

    if (items.length === 0) {
      return items;
    }

    const workspaceIds = items.map((item) => item.key);
    const workspaces = await this.workspaceRepository.find({
      where: { id: In(workspaceIds) },
      select: { id: true, displayName: true },
    });

    const nameMap = new Map(
      workspaces
        .filter((workspace) => isDefined(workspace.displayName))
        .map((workspace) => [workspace.id, workspace.displayName!]),
    );

    return items.map((item) => ({
      ...item,
      label: nameMap.get(item.key),
    }));
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => MaintenanceModeDTO, { nullable: true })
  async getMaintenanceMode(): Promise<MaintenanceModeDTO | null> {
    const value = await this.maintenanceModeService.getMaintenanceMode();

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

    return {
      startAt: new Date(value.startAt),
      endAt: new Date(value.endAt),
      link: value.link,
    };
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => Boolean)
  async setMaintenanceMode(
    @Args() { startAt, endAt, link }: SetMaintenanceModeInput,
  ): Promise<boolean> {
    await this.maintenanceModeService.setMaintenanceMode({
      startAt: startAt.toISOString(),
      endAt: endAt.toISOString(),
      link,
    });

    return true;
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => Boolean)
  async clearMaintenanceMode(): Promise<boolean> {
    await this.maintenanceModeService.clearMaintenanceMode();

    return true;
  }

  @UseGuards(ServerLevelImpersonateGuard)
  @Query(() => UserLookup)
  async workspaceLookupAdminPanel(
    @Args('workspaceId', { type: () => UUIDScalarType }) workspaceId: string,
  ): Promise<UserLookup> {
    return this.adminUserLookupService.workspaceLookup(workspaceId);
  }

  @UseGuards(ServerLevelImpersonateGuard)
  @Query(() => AdminPanelWorkspaceBillingDTO, { nullable: true })
  async workspaceBillingAdminPanel(
    @Args('workspaceId', { type: () => UUIDScalarType }) workspaceId: string,
  ): Promise<AdminPanelWorkspaceBillingDTO | null> {
    return this.adminBillingService.getWorkspaceBilling(workspaceId);
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => AdminPanelWorkspaceCreditGrantDTO)
  async grantWorkspaceCredits(
    @Args() input: GrantWorkspaceCreditsInput,
    @AuthUser() actor: AuthContextUser,
  ): Promise<AdminPanelWorkspaceCreditGrantDTO> {
    return this.adminBillingService.grantWorkspaceCredits({
      workspaceId: input.workspaceId,
      amount: input.amount,
      type: input.type,
      reason: input.reason,
      expiresInDays: input.expiresInDays,
      clientOperationId: input.clientOperationId,
      grantedByUserId: actor.id,
    });
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => AdminPanelWorkspaceCreditGrantDTO)
  async revokeWorkspaceCreditGrant(
    @Args() input: RevokeWorkspaceCreditGrantInput,
    @AuthUser() actor: AuthContextUser,
  ): Promise<AdminPanelWorkspaceCreditGrantDTO> {
    return this.adminBillingService.revokeWorkspaceCreditGrant({
      workspaceId: input.workspaceId,
      creditGrantId: input.creditGrantId,
      revokedByUserId: actor.id,
    });
  }

  @UseGuards(ServerLevelImpersonateGuard)
  @Query(() => [AdminWorkspaceChatThreadDTO])
  async getAdminWorkspaceChatThreads(
    @Args('workspaceId', { type: () => UUIDScalarType }) workspaceId: string,
  ): Promise<AdminWorkspaceChatThreadDTO[]> {
    return this.adminChatService.getWorkspaceChatThreads(workspaceId);
  }

  @UseGuards(ServerLevelImpersonateGuard)
  @Query(() => AdminChatThreadMessagesDTO)
  async getAdminChatThreadMessages(
    @Args('workspaceId', { type: () => UUIDScalarType }) workspaceId: string,
    @Args('threadId', { type: () => UUIDScalarType }) threadId: string,
  ): Promise<AdminChatThreadMessagesDTO> {
    return this.adminChatService.getChatThreadMessages({
      workspaceId,
      threadId,
    });
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => ApplicationRegistrationEntity)
  async findOneAdminApplicationRegistration(
    @Args('id') id: string,
  ): Promise<ApplicationRegistrationEntity> {
    return this.applicationRegistrationService.findOneByIdGlobal(id);
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => [ApplicationRegistrationVariableDTO])
  async findAdminApplicationRegistrationVariables(
    @Args('applicationRegistrationId') applicationRegistrationId: string,
  ): Promise<ApplicationRegistrationVariableDTO[]> {
    return this.applicationRegistrationVariableService.findVariablesWithObfuscatedValuesGlobal(
      applicationRegistrationId,
    );
  }

  @UseGuards(AdminPanelGuard)
  @UseFilters(ApplicationRegistrationExceptionFilter)
  @Query(() => ApplicationRegistrationStatsDTO)
  async findAdminApplicationRegistrationStats(
    @Args('id') id: string,
    @Info() info: GraphQLResolveInfo,
    @Args('periodStart', { type: () => Date, nullable: true })
    periodStart?: Date,
    @Args('periodEnd', { type: () => Date, nullable: true })
    periodEnd?: Date,
  ): Promise<ApplicationRegistrationStatsDTO> {
    return this.applicationRegistrationService.getStatsGlobal({
      applicationRegistrationId: id,
      includeCreditsUsed: isCreditsUsedRequested(info),
      periodStart,
      periodEnd,
    });
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => ApplicationRegistrationInstalledWorkspacesDTO)
  async findAdminApplicationRegistrationInstalledWorkspaces(
    @Args('input')
    {
      id,
      limit,
      offset,
      searchTerm,
    }: FindApplicationRegistrationInstalledWorkspacesInput,
  ): Promise<ApplicationRegistrationInstalledWorkspacesDTO> {
    return this.applicationRegistrationService.getInstalledWorkspacesGlobal(
      id,
      limit,
      offset,
      searchTerm,
    );
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => ApplicationRegistrationVariableDTO)
  async updateAdminApplicationRegistrationVariable(
    @Args('input') input: UpdateApplicationRegistrationVariableInput,
  ): Promise<ApplicationRegistrationVariableDTO> {
    return this.applicationRegistrationVariableService.updateVariableGlobal(
      input,
    );
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => InstanceAndAllWorkspacesUpgradeStatusDTO)
  async getInstanceAndAllWorkspacesUpgradeStatus(): Promise<InstanceAndAllWorkspacesUpgradeStatusDTO> {
    return this.upgradeStatusService.getInstanceAndAllWorkspacesStatus();
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => InstanceAndAllWorkspacesUpgradeStatusDTO)
  async refreshUpgradeStatus(): Promise<InstanceAndAllWorkspacesUpgradeStatusDTO> {
    return this.upgradeStatusService.refreshInstanceAndAllWorkspacesStatus();
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => [WorkspaceUpgradeStatusDTO])
  async getUpgradeStatus(
    @Args('workspaceIds', { type: () => [UUIDScalarType] })
    workspaceIds: string[],
  ): Promise<WorkspaceUpgradeStatusDTO[]> {
    if (workspaceIds.length === 0) {
      return [];
    }

    return this.upgradeStatusService.getWorkspaceStatuses(workspaceIds);
  }

  @UseGuards(AdminPanelGuard)
  @Query(() => SigningKeysAdminPanelDTO)
  async getSigningKeys(): Promise<SigningKeysAdminPanelDTO> {
    return this.adminPanelSigningKeyService.getSigningKeys();
  }

  @UseGuards(AdminPanelGuard)
  @Mutation(() => SigningKeyDTO)
  async revokeSigningKey(
    @Args() { id }: RevokeSigningKeyInput,
  ): Promise<SigningKeyDTO> {
    return this.adminPanelSigningKeyService.revokeSigningKey(id);
  }
}