The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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);
}
}