The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
import { UseFilters, UseGuards, UseInterceptors } from '@nestjs/common';
import { Args, Mutation, Parent, Query, ResolveField } from '@nestjs/graphql';
import { type QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
import { PermissionFlagType } from 'twenty-shared/constants';
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
import { ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entity';
import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filters/auth-graphql-api-exception.filter';
import { CreateApiKeyInput } from 'src/engine/core-modules/api-key/dtos/create-api-key.input';
import { GetApiKeyInput } from 'src/engine/core-modules/api-key/dtos/get-api-key.input';
import { RevokeApiKeyInput } from 'src/engine/core-modules/api-key/dtos/revoke-api-key.input';
import { UpdateApiKeyInput } from 'src/engine/core-modules/api-key/dtos/update-api-key.input';
import { apiKeyGraphqlApiExceptionHandler } from 'src/engine/core-modules/api-key/utils/api-key-graphql-api-exception-handler.util';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { AuthPrincipalGuard } from 'src/engine/guards/auth-principal.guard';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/permissions/utils/permissions-graphql-api-exception.filter';
import { RoleDTO } from 'src/engine/metadata-modules/role/dtos/role.dto';
import { WorkspaceMigrationGraphqlApiExceptionInterceptor } from 'src/engine/workspace-manager/workspace-migration/interceptors/workspace-migration-graphql-api-exception.interceptor';
import { ApiKeyRoleService } from './services/api-key-role.service';
import { ApiKeyService } from './services/api-key.service';
@MetadataResolver(() => ApiKeyEntity)
@UseInterceptors(WorkspaceMigrationGraphqlApiExceptionInterceptor)
@UseFilters(AuthGraphqlApiExceptionFilter, PermissionsGraphqlApiExceptionFilter)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: true,
}),
SettingsPermissionGuard(PermissionFlagType.API_KEYS_AND_WEBHOOKS),
)
export class ApiKeyResolver {
constructor(
private readonly apiKeyService: ApiKeyService,
private readonly apiKeyRoleService: ApiKeyRoleService,
) {}
@Query(() => [ApiKeyEntity])
async apiKeys(
@AuthWorkspace() workspace: WorkspaceEntity,
): Promise<ApiKeyEntity[]> {
return this.apiKeyService.findActiveByWorkspaceId(workspace.id);
}
@Query(() => [RoleDTO])
async getApiKeyRoles(
@AuthWorkspace() workspace: WorkspaceEntity,
): Promise<RoleDTO[]> {
return this.apiKeyRoleService.getApiKeyAssignableRoles(workspace.id);
}
@Query(() => ApiKeyEntity, { nullable: true })
async apiKey(
@Args('input') input: GetApiKeyInput,
@AuthWorkspace() workspace: WorkspaceEntity,
): Promise<ApiKeyEntity | null> {
try {
const apiKey = await this.apiKeyService.findById(input.id, workspace.id);
if (!apiKey) {
return null;
}
return apiKey;
} catch (error) {
apiKeyGraphqlApiExceptionHandler(error);
throw error;
}
}
// Creating a key assigns it a role, so it also requires ROLES to prevent
// binding a role above the caller's own. Refusing playground sessions blocks
// minting from derived PLAYGROUND tokens.
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: false,
workspaceAgnostic: false,
},
apiKey: false,
oauthClient: false,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.ROLES),
)
@Mutation(() => ApiKeyEntity)
async createApiKey(
@AuthWorkspace() workspace: WorkspaceEntity,
@Args('input') input: CreateApiKeyInput,
): Promise<ApiKeyEntity> {
return this.apiKeyService.create({
name: input.name,
expiresAt: new Date(input.expiresAt),
revokedAt: input.revokedAt ? new Date(input.revokedAt) : undefined,
workspaceId: workspace.id,
roleId: input.roleId,
});
}
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: false,
workspaceAgnostic: false,
},
apiKey: false,
oauthClient: false,
application: false,
}),
)
@Mutation(() => ApiKeyEntity, { nullable: true })
async updateApiKey(
@AuthWorkspace() workspace: WorkspaceEntity,
@Args('input') input: UpdateApiKeyInput,
): Promise<ApiKeyEntity | null> {
const updateData: QueryDeepPartialEntity<ApiKeyEntity> = {};
if (input.name !== undefined) updateData.name = input.name;
if (input.expiresAt !== undefined)
updateData.expiresAt = new Date(input.expiresAt);
if (input.revokedAt !== undefined) {
updateData.revokedAt = input.revokedAt ? new Date(input.revokedAt) : null;
}
try {
return await this.apiKeyService.update(
input.id,
workspace.id,
updateData,
);
} catch (error) {
apiKeyGraphqlApiExceptionHandler(error);
throw error;
}
}
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: false,
workspaceAgnostic: false,
},
apiKey: false,
oauthClient: false,
application: false,
}),
)
@Mutation(() => ApiKeyEntity, { nullable: true })
async revokeApiKey(
@AuthWorkspace() workspace: WorkspaceEntity,
@Args('input') input: RevokeApiKeyInput,
): Promise<ApiKeyEntity | null> {
return this.apiKeyService.revoke(input.id, workspace.id);
}
// Binding a role to an API key requires ROLES to prevent privilege escalation.
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: false,
workspaceAgnostic: false,
},
apiKey: false,
oauthClient: false,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.ROLES),
)
@Mutation(() => Boolean)
async assignRoleToApiKey(
@AuthWorkspace() workspace: WorkspaceEntity,
@Args('apiKeyId', { type: () => UUIDScalarType }) apiKeyId: string,
@Args('roleId', { type: () => UUIDScalarType }) roleId: string,
): Promise<boolean> {
try {
await this.apiKeyRoleService.assignRoleToApiKey({
apiKeyId,
roleId,
workspaceId: workspace.id,
});
return true;
} catch (error) {
apiKeyGraphqlApiExceptionHandler(error);
throw error;
}
}
@ResolveField(() => RoleDTO)
async role(
@Parent() apiKey: ApiKeyEntity,
@AuthWorkspace() workspace: WorkspaceEntity,
): Promise<RoleDTO> {
return this.apiKeyRoleService.getRoleDtoByApiKeyId({
apiKeyId: apiKey.id,
workspaceId: workspace.id,
});
}
}