Skip to content

The open alternative to Salesforce, designed for AI.

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

import { isNonEmptyString } from '@sniptt/guards';
import { PermissionFlagType } from 'twenty-shared/constants';

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 { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
import { canCallerReachApplication } from 'src/engine/core-modules/application/utils/can-caller-reach-application.util';
import { type I18nContext } from 'src/engine/core-modules/i18n/types/i18n-context.type';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { type IDataloaders } from 'src/engine/dataloaders/dataloader.interface';
import { ApplicationTargetArg } from 'src/engine/decorators/auth/application-target-arg.decorator';
import { AuthApplication } from 'src/engine/decorators/auth/auth-application.decorator';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
import { ApplicationTranslationCatalogService } from 'src/engine/metadata-modules/application-translation-catalog/services/application-translation-catalog.service';
import { resolveEffectiveEntityProperty } from 'src/engine/metadata-modules/overrides/utils/resolve-effective-entity-property.util';
import { CreateSkillInput } from 'src/engine/metadata-modules/skill/dtos/create-skill.input';
import { SkillDTO } from 'src/engine/metadata-modules/skill/dtos/skill.dto';
import { UpdateSkillInput } from 'src/engine/metadata-modules/skill/dtos/update-skill.input';
import { IS_CUSTOM_DEPRECATION_REASON } from 'src/engine/metadata-modules/utils/constants/is-custom-deprecation-reason.constant';
import { SkillGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/skill/interceptors/skill-graphql-api-exception.interceptor';
import { SkillService } from 'src/engine/metadata-modules/skill/skill.service';
import { WorkspaceMigrationGraphqlApiExceptionInterceptor } from 'src/engine/workspace-manager/workspace-migration/interceptors/workspace-migration-graphql-api-exception.interceptor';
import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filters/auth-graphql-api-exception.filter';
import { ApplicationTargetGuard } from 'src/engine/guards/application-target.guard';
import { AccessPolicyGuard } from 'src/engine/guards/access-policy.guard';
import { type AccessPolicy } from 'src/engine/guards/types/access-policy.type';

// Reads only need the AI flag so the chat composer can list skills
const SKILL_READ_ACCESS_POLICY: AccessPolicy = {
  authPrincipals: {
    userSession: {
      standard: true,
      impersonated: true,
      playground: true,
      workspaceAgnostic: false,
    },
    apiKey: true,
    oauthClient: true,
    application: true,
  },
  requiredPermissionFlags: [PermissionFlagType.AI],
};

const SKILL_WRITE_ACCESS_POLICY: AccessPolicy = {
  authPrincipals: {
    userSession: {
      standard: true,
      impersonated: true,
      playground: true,
      workspaceAgnostic: false,
    },
    apiKey: true,
    oauthClient: true,
    application: true,
  },
  requiredPermissionFlags: [
    PermissionFlagType.AI,
    PermissionFlagType.AI_SETTINGS,
  ],
};

@UseInterceptors(
  WorkspaceMigrationGraphqlApiExceptionInterceptor,
  SkillGraphqlApiExceptionInterceptor,
)
@MetadataResolver(() => SkillDTO)
@UseFilters(ApplicationExceptionFilter, AuthGraphqlApiExceptionFilter)
export class SkillResolver {
  constructor(
    private readonly skillService: SkillService,
    private readonly applicationTranslationCatalogService: ApplicationTranslationCatalogService,
  ) {}

  @ResolveField(() => String)
  async label(
    @Parent() skill: SkillDTO,
    @Context() context: { loaders: IDataloaders } & I18nContext,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<string> {
    return this.resolveTranslatableProperty({
      skill,
      property: 'label',
      context,
      workspaceId: workspace.id,
    });
  }

  @ResolveField(() => String, { nullable: true })
  async description(
    @Parent() skill: SkillDTO,
    @Context() context: { loaders: IDataloaders } & I18nContext,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<string | undefined> {
    if (!isNonEmptyString(skill.description)) {
      return skill.description;
    }

    return this.resolveTranslatableProperty({
      skill,
      property: 'description',
      context,
      workspaceId: workspace.id,
    });
  }

  @ResolveField(() => Boolean, {
    deprecationReason: IS_CUSTOM_DEPRECATION_REASON,
  })
  isCustom(
    @Parent() skill: SkillDTO,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): boolean {
    return skill.applicationId === workspace.workspaceCustomApplicationId;
  }

  @Query(() => [SkillDTO])
  @UseGuards(AccessPolicyGuard(SKILL_READ_ACCESS_POLICY))
  async skills(
    @AuthWorkspace() workspace: WorkspaceEntity,
    @AuthApplication({ allowUndefined: true })
    callingApplication: FlatApplication | undefined,
  ): Promise<SkillDTO[]> {
    const skills = await this.skillService.findAll(workspace.id);

    return skills.filter((skill) =>
      canCallerReachApplication({
        callingApplication,
        applicationId: skill.applicationId,
        operation: 'read',
        workspaceCustomApplicationId: workspace.workspaceCustomApplicationId,
      }),
    );
  }

  @Query(() => SkillDTO, { nullable: true })
  @UseGuards(
    AccessPolicyGuard(SKILL_READ_ACCESS_POLICY),
    ApplicationTargetGuard,
  )
  async skill(
    @ApplicationTargetArg(
      'id',
      {
        kind: 'applicationOwnedEntity',
        metadataName: 'skill',
        requireApplicationRegistrationOwnership: false,
      },
      { type: () => UUIDScalarType },
    )
    id: string,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<SkillDTO | null> {
    return this.skillService.findById(id, workspace.id);
  }

  @Mutation(() => SkillDTO)
  @UseGuards(AccessPolicyGuard(SKILL_WRITE_ACCESS_POLICY))
  async createSkill(
    @Args('input') input: CreateSkillInput,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<SkillDTO> {
    return this.skillService.create(input, workspace.id);
  }

  @Mutation(() => SkillDTO)
  @UseGuards(
    AccessPolicyGuard(SKILL_WRITE_ACCESS_POLICY),
    ApplicationTargetGuard,
  )
  async updateSkill(
    @ApplicationTargetArg<UpdateSkillInput>('input', {
      kind: 'applicationOwnedEntity',
      metadataName: 'skill',
      idKey: 'id',
      requireApplicationRegistrationOwnership: false,
    })
    input: UpdateSkillInput,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<SkillDTO> {
    return this.skillService.update(input, workspace.id);
  }

  @Mutation(() => SkillDTO)
  @UseGuards(
    AccessPolicyGuard(SKILL_WRITE_ACCESS_POLICY),
    ApplicationTargetGuard,
  )
  async deleteSkill(
    @ApplicationTargetArg(
      'id',
      {
        kind: 'applicationOwnedEntity',
        metadataName: 'skill',
        requireApplicationRegistrationOwnership: false,
      },
      { type: () => UUIDScalarType },
    )
    id: string,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<SkillDTO> {
    return this.skillService.delete(id, workspace.id);
  }

  @Mutation(() => SkillDTO)
  @UseGuards(
    AccessPolicyGuard(SKILL_WRITE_ACCESS_POLICY),
    ApplicationTargetGuard,
  )
  async activateSkill(
    @ApplicationTargetArg(
      'id',
      {
        kind: 'applicationOwnedEntity',
        metadataName: 'skill',
        requireApplicationRegistrationOwnership: false,
      },
      { type: () => UUIDScalarType },
    )
    id: string,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<SkillDTO> {
    return this.skillService.activate(id, workspace.id);
  }

  @Mutation(() => SkillDTO)
  @UseGuards(
    AccessPolicyGuard(SKILL_WRITE_ACCESS_POLICY),
    ApplicationTargetGuard,
  )
  async deactivateSkill(
    @ApplicationTargetArg(
      'id',
      {
        kind: 'applicationOwnedEntity',
        metadataName: 'skill',
        requireApplicationRegistrationOwnership: false,
      },
      { type: () => UUIDScalarType },
    )
    id: string,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ): Promise<SkillDTO> {
    return this.skillService.deactivate(id, workspace.id);
  }

  private async resolveTranslatableProperty({
    skill,
    property,
    context,
    workspaceId,
  }: {
    skill: SkillDTO;
    property: 'label' | 'description';
    context: { loaders: IDataloaders } & I18nContext;
    workspaceId: string;
  }): Promise<string> {
    return resolveEffectiveEntityProperty({
      metadataName: 'skill',
      baseValue: skill[property],
      overrides: undefined,
      property,
      i18nContext:
        await this.applicationTranslationCatalogService.buildEffectiveEntityI18nContext(
          {
            applicationId: skill.applicationId,
            loaders: context.loaders,
            locale: context.req.locale,
            workspaceId,
          },
        ),
    });
  }
}