Skip to content

The open alternative to Salesforce, designed for AI.

7.6 KB
Raw Blame
/* @license Enterprise */

import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
import { Args, Query } from '@nestjs/graphql';
import { InjectRepository } from '@nestjs/typeorm';

import { PermissionFlagType } from 'twenty-shared/constants';
import { isDefined } from 'twenty-shared/utils';
import { In, type Repository } from 'typeorm';

import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
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 { UsageAnalyticsInput } from 'src/engine/core-modules/usage/dtos/inputs/usage-analytics.input';
import { UsageAnalyticsDTO } from 'src/engine/core-modules/usage/dtos/usage-analytics.dto';
import {
  UsageAnalyticsService,
  type UsageBreakdownItem,
} from 'src/engine/core-modules/usage/services/usage-analytics.service';
import { consolidateUsageByApplication } from 'src/engine/core-modules/usage/utils/consolidate-usage-by-application.util';
import { listDeclaredBillingChargeNames } from 'src/engine/core-modules/usage/utils/list-declared-billing-charge-names.util';
import { fromUsageBreakdownItemToUsageBreakdownItemDTO } from 'src/engine/core-modules/usage/utils/from-usage-breakdown-item-to-usage-breakdown-item-dto.util';
import { toDisplayCredits } from 'src/engine/core-modules/usage/utils/to-display-credits.util';
import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
import { AuthPrincipalGuard } from 'src/engine/guards/auth-principal.guard';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';

@MetadataResolver()
@UseFilters(PreventNestToAutoLogGraphqlErrorsFilter)
@UsePipes(ResolverValidationPipe)
export class UsageResolver {
  constructor(
    private readonly usageAnalyticsService: UsageAnalyticsService,
    @InjectRepository(UserWorkspaceEntity)
    private readonly userWorkspaceRepository: Repository<UserWorkspaceEntity>,
    private readonly workspaceCacheService: WorkspaceCacheService,
  ) {}

  @Query(() => UsageAnalyticsDTO)
  @UseGuards(
    AuthPrincipalGuard({
      userSession: {
        standard: true,
        impersonated: true,
        playground: true,
        workspaceAgnostic: false,
      },
      apiKey: true,
      oauthClient: true,
      application: true,
    }),
    SettingsPermissionGuard(PermissionFlagType.WORKSPACE),
  )
  async getUsageAnalytics(
    @AuthWorkspace() workspace: WorkspaceEntity,
    @Args('input', { nullable: true }) input?: UsageAnalyticsInput,
  ): Promise<UsageAnalyticsDTO> {
    const defaultPeriodEnd = new Date();
    const defaultPeriodStart = new Date();

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

    const periodStart = input?.periodStart ?? defaultPeriodStart;
    const periodEnd = input?.periodEnd ?? defaultPeriodEnd;

    const periodParams = {
      workspaceId: workspace.id,
      periodStart,
      periodEnd,
      operationTypes: input?.operationTypes ?? undefined,
    };

    const { flatApplicationMaps } =
      await this.workspaceCacheService.getOrRecompute(workspace.id, [
        'flatApplicationMaps',
      ]);

    // Per application: two apps may declare the same operation name.
    const declaredOperationsByApplicationId = Object.fromEntries(
      Object.entries(flatApplicationMaps.byId).map(
        ([applicationId, application]) => [
          applicationId,
          listDeclaredBillingChargeNames({ billing: application?.billing }),
        ],
      ),
    );

    const [
      usageByUser,
      usageByOperationType,
      usageByApplication,
      usageByModel,
      timeSeries,
    ] = await Promise.all([
      this.usageAnalyticsService.getUsageByUser(periodParams),
      this.usageAnalyticsService.getUsageByOperationType({
        ...periodParams,
        userWorkspaceId: input?.userWorkspaceId ?? undefined,
      }),
      this.usageAnalyticsService.getUsageByApplication({
        ...periodParams,
        userWorkspaceId: input?.userWorkspaceId ?? undefined,
        declaredOperationsByApplicationId,
      }),
      this.usageAnalyticsService.getUsageByModel(periodParams),
      this.usageAnalyticsService.getUsageTimeSeries(periodParams),
    ]);

    const resolvedUsageByUser = await this.resolveBreakdownKeys(
      usageByUser,
      (ids) => this.resolveUserNames(ids, workspace.id),
    );

    const resolvedUsageByApplication = consolidateUsageByApplication({
      items: usageByApplication,
      flatApplicationMaps,
    });

    const result: UsageAnalyticsDTO = {
      usageByUser: resolvedUsageByUser.map(
        fromUsageBreakdownItemToUsageBreakdownItemDTO,
      ),
      usageByOperationType: usageByOperationType.map(
        fromUsageBreakdownItemToUsageBreakdownItemDTO,
      ),
      usageByApplication: resolvedUsageByApplication.map(
        fromUsageBreakdownItemToUsageBreakdownItemDTO,
      ),
      usageByModel: usageByModel.map(
        fromUsageBreakdownItemToUsageBreakdownItemDTO,
      ),
      timeSeries: timeSeries.map((point) => ({
        ...point,
        creditsUsed: toDisplayCredits(point.creditsUsed),
        workspaceCreditsUsed: toDisplayCredits(point.workspaceCreditsUsed),
      })),
      periodStart,
      periodEnd,
    };

    if (input?.userWorkspaceId) {
      const userWorkspace = await this.userWorkspaceRepository.findOne({
        where: { id: input.userWorkspaceId, workspaceId: workspace.id },
        select: { id: true },
      });

      if (isDefined(userWorkspace)) {
        const dailyUsage =
          await this.usageAnalyticsService.getUsageByUserTimeSeries({
            ...periodParams,
            userWorkspaceId: input.userWorkspaceId,
          });

        result.userDailyUsage = {
          userWorkspaceId: input.userWorkspaceId,
          dailyUsage: dailyUsage.map((point) => ({
            ...point,
            creditsUsed: toDisplayCredits(point.creditsUsed),
            workspaceCreditsUsed: toDisplayCredits(point.workspaceCreditsUsed),
          })),
        };
      }
    }

    return result;
  }

  private async resolveBreakdownKeys(
    items: UsageBreakdownItem[],
    resolveNames: (ids: string[]) => Promise<Map<string, string>>,
  ): Promise<UsageBreakdownItem[]> {
    if (items.length === 0) {
      return items;
    }

    const ids = items.map((item) => item.key);
    const nameMap = await resolveNames(ids);

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

  private async resolveUserNames(
    userWorkspaceIds: string[],
    workspaceId: string,
  ): Promise<Map<string, string>> {
    const nameMap = new Map<string, string>();

    if (userWorkspaceIds.length === 0) {
      return nameMap;
    }

    const userWorkspaces = await this.userWorkspaceRepository.find({
      where: { id: In(userWorkspaceIds), workspaceId },
      relations: ['user'],
      select: {
        id: true,
        user: { firstName: true, lastName: true, email: true },
      },
    });

    for (const userWorkspace of userWorkspaces) {
      if (!isDefined(userWorkspace.user)) {
        continue;
      }

      const { firstName, lastName, email } = userWorkspace.user;
      const fullName = `${firstName} ${lastName}`.trim();

      nameMap.set(userWorkspace.id, fullName || email);
    }

    return nameMap;
  }
}