The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
/* @license Enterprise */
import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
import { Args, Mutation, Query } from '@nestjs/graphql';
import {
INTERNAL_CREDITS_PER_DISPLAY_CREDIT,
PermissionFlagType,
} from 'twenty-shared/constants';
import { WorkspaceActivationStatus } from 'twenty-shared/workspace';
import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
import { type ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entity';
import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';
import { BillingEndTrialPeriodDTO } from 'src/engine/core-modules/billing/dtos/billing-end-trial-period.dto';
import { BillingResourceCreditUsageDTO } from 'src/engine/core-modules/billing/dtos/billing-resource-credit-usage.dto';
import { BillingPlanDTO } from 'src/engine/core-modules/billing/dtos/billing-plan.dto';
import { BillingPaymentIntentDTO } from 'src/engine/core-modules/billing/dtos/billing-payment-intent.dto';
import { BillingSessionDTO } from 'src/engine/core-modules/billing/dtos/billing-session.dto';
import { BillingUpdateDTO } from 'src/engine/core-modules/billing/dtos/billing-update.dto';
import { BillingCheckoutSessionInput } from 'src/engine/core-modules/billing/dtos/inputs/billing-checkout-session.input';
import { BillingSessionInput } from 'src/engine/core-modules/billing/dtos/inputs/billing-session.input';
import { BillingSwitchPlanInput } from 'src/engine/core-modules/billing/dtos/inputs/billing-switch-plan.input';
import { BillingUpdateUserCreditsFallbackInput } from 'src/engine/core-modules/billing/dtos/inputs/billing-update-user-credits-fallback.input';
import { BillingUpdateSubscriptionItemPriceInput } from 'src/engine/core-modules/billing/dtos/inputs/billing-update-subscription-item-price.input';
import { BillingCustomerEntity } from 'src/engine/core-modules/billing/entities/billing-customer.entity';
import { BillingPlanService } from 'src/engine/core-modules/billing/services/billing-plan.service';
import { BillingPortalWorkspaceService } from 'src/engine/core-modules/billing/services/billing-portal.workspace-service';
import { BillingSubscriptionUpdateService } from 'src/engine/core-modules/billing/services/billing-subscription-update.service';
import { BillingSubscriptionService } from 'src/engine/core-modules/billing/services/billing-subscription.service';
import { BillingUsageService } from 'src/engine/core-modules/billing/services/billing-usage.service';
import { BillingService } from 'src/engine/core-modules/billing/services/billing.service';
import { formatBillingDatabaseProductToGraphqlDTO } from 'src/engine/core-modules/billing/utils/format-database-product-to-graphql-dto.util';
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 { toDisplayCredits } from 'src/engine/core-modules/usage/utils/to-display-credits.util';
import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { AuthApiKey } from 'src/engine/decorators/auth/auth-api-key.decorator';
import { AuthApplication } from 'src/engine/decorators/auth/auth-application.decorator';
import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-workspace-id.decorator';
import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { AllowSuspendedWorkspace } from 'src/engine/decorators/auth/allow-suspended-workspace.decorator';
import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
import { AuthPrincipalGuard } from 'src/engine/guards/auth-principal.guard';
import {
PermissionsException,
PermissionsExceptionCode,
PermissionsExceptionMessage,
} from 'src/engine/permissions/permissions.exception';
import { PermissionsService } from 'src/engine/permissions/permissions.service';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/permissions/utils/permissions-graphql-api-exception.filter';
@MetadataResolver()
@AllowSuspendedWorkspace()
@UsePipes(ResolverValidationPipe)
@UseFilters(
PermissionsGraphqlApiExceptionFilter,
PreventNestToAutoLogGraphqlErrorsFilter,
)
export class BillingResolver {
constructor(
private readonly billingSubscriptionService: BillingSubscriptionService,
private readonly billingSubscriptionUpdateService: BillingSubscriptionUpdateService,
private readonly billingPortalWorkspaceService: BillingPortalWorkspaceService,
private readonly billingPlanService: BillingPlanService,
private readonly billingService: BillingService,
private readonly billingUsageService: BillingUsageService,
private readonly permissionsService: PermissionsService,
) {}
@Query(() => BillingSessionDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async billingPortalSession(
@AuthWorkspace() workspace: WorkspaceEntity,
@Args() { returnUrlPath, forPaymentMethodUpdate }: BillingSessionInput,
) {
return {
url: await this.billingPortalWorkspaceService.computeBillingPortalSessionUrlOrThrow(
workspace,
returnUrlPath,
forPaymentMethodUpdate,
),
};
}
@Mutation(() => BillingSessionDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: false,
oauthClient: { withUser: true, withoutUser: false },
application: { withUser: true, withoutUser: false },
}),
NoPermissionGuard,
)
async checkoutSession(
@AuthWorkspace() workspace: WorkspaceEntity,
@AuthUser() user: AuthContextUser,
@AuthUserWorkspaceId() userWorkspaceId: string,
@Args()
{
recurringInterval,
successUrlPath,
plan,
requirePaymentMethod,
}: BillingCheckoutSessionInput,
@AuthApiKey() apiKey?: ApiKeyEntity,
@AuthApplication({ allowUndefined: true }) application?: FlatApplication,
) {
await this.validateCanCheckoutSessionPermissionOrThrow({
workspaceId: workspace.id,
userWorkspaceId,
apiKeyId: apiKey?.id,
applicationId: application?.id,
workspaceActivationStatus: workspace.activationStatus,
});
const billingPricesPerPlan =
await this.billingPlanService.getSellablePlanPricesByIntervalOrThrow({
planKey: plan,
interval: recurringInterval,
});
return await this.billingPortalWorkspaceService.withTrialLimitLock({
userId: user.id,
userEmail: user.email,
workspaceId: workspace.id,
createSubscription: async (isTrialLimitReached) => {
const isPaymentMethodRequired =
requirePaymentMethod || isTrialLimitReached;
const checkoutSessionParams = {
user,
workspace,
successUrlPath,
plan,
requirePaymentMethod: isPaymentMethodRequired,
isTrialLimitReached,
billingPricesPerPlan,
};
if (!isPaymentMethodRequired) {
const successUrl =
await this.billingPortalWorkspaceService.createDirectSubscription(
checkoutSessionParams,
);
return {
url: successUrl,
};
} else {
const checkoutSessionURL =
await this.billingPortalWorkspaceService.computeCheckoutSessionURL(
checkoutSessionParams,
);
return {
url: checkoutSessionURL,
};
}
},
});
}
@Mutation(() => BillingPaymentIntentDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: false,
oauthClient: { withUser: true, withoutUser: false },
application: { withUser: true, withoutUser: false },
}),
NoPermissionGuard,
)
async createSubscriptionPaymentIntent(
@AuthWorkspace() workspace: WorkspaceEntity,
@AuthUser() user: AuthContextUser,
@AuthUserWorkspaceId() userWorkspaceId: string,
@Args() { recurringInterval, plan }: BillingCheckoutSessionInput,
@Args('idempotencyKey', { type: () => String }) idempotencyKey: string,
@AuthApiKey() apiKey?: ApiKeyEntity,
@AuthApplication({ allowUndefined: true }) application?: FlatApplication,
): Promise<BillingPaymentIntentDTO> {
await this.validateCanCheckoutSessionPermissionOrThrow({
workspaceId: workspace.id,
userWorkspaceId,
apiKeyId: apiKey?.id,
applicationId: application?.id,
workspaceActivationStatus: workspace.activationStatus,
});
const billingPricesPerPlan =
await this.billingPlanService.getSellablePlanPricesByIntervalOrThrow({
planKey: plan,
interval: recurringInterval,
});
return await this.billingPortalWorkspaceService.withTrialLimitLock({
userId: user.id,
userEmail: user.email,
workspaceId: workspace.id,
createSubscription: (isTrialLimitReached) =>
this.billingPortalWorkspaceService.createSubscriptionPaymentIntent({
user,
workspace,
plan,
billingPricesPerPlan,
isTrialLimitReached,
idempotencyKey,
}),
});
}
@Mutation(() => BillingPaymentIntentDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async createBillingPaymentMethodSetupIntent(
@AuthWorkspace() workspace: WorkspaceEntity,
): Promise<BillingPaymentIntentDTO> {
return this.billingPortalWorkspaceService.createPaymentMethodSetupIntent(
workspace,
);
}
@Mutation(() => BillingUpdateDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async switchSubscriptionInterval(
@AuthWorkspace() workspace: WorkspaceEntity,
) {
await this.billingSubscriptionUpdateService.changeInterval(workspace.id);
return {
billingSubscriptions:
await this.billingSubscriptionService.getBillingSubscriptions(
workspace.id,
),
currentBillingSubscription:
await this.billingSubscriptionService.getCurrentBillingSubscriptionOrThrow(
{ workspaceId: workspace.id },
),
};
}
@Mutation(() => BillingUpdateDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async switchBillingPlan(
@AuthWorkspace() workspace: WorkspaceEntity,
@Args() { plan }: BillingSwitchPlanInput,
) {
await this.billingSubscriptionUpdateService.changePlan(workspace.id, plan);
return {
billingSubscriptions:
await this.billingSubscriptionService.getBillingSubscriptions(
workspace.id,
),
currentBillingSubscription:
await this.billingSubscriptionService.getCurrentBillingSubscriptionOrThrow(
{ workspaceId: workspace.id },
),
};
}
@Mutation(() => BillingUpdateDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async cancelSwitchBillingPlan(@AuthWorkspace() workspace: WorkspaceEntity) {
await this.billingSubscriptionUpdateService.cancelSwitchPlan(workspace.id);
return {
billingSubscriptions:
await this.billingSubscriptionService.getBillingSubscriptions(
workspace.id,
),
currentBillingSubscription:
await this.billingSubscriptionService.getCurrentBillingSubscriptionOrThrow(
{ workspaceId: workspace.id },
),
};
}
@Mutation(() => BillingUpdateDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async cancelSwitchBillingInterval(
@AuthWorkspace() workspace: WorkspaceEntity,
) {
await this.billingSubscriptionUpdateService.cancelSwitchInterval(
workspace.id,
);
return {
billingSubscriptions:
await this.billingSubscriptionService.getBillingSubscriptions(
workspace.id,
),
currentBillingSubscription:
await this.billingSubscriptionService.getCurrentBillingSubscriptionOrThrow(
{ workspaceId: workspace.id },
),
};
}
@Mutation(() => BillingUpdateDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async setResourceCreditSubscriptionPrice(
@AuthWorkspace() workspace: WorkspaceEntity,
@Args() { priceId }: BillingUpdateSubscriptionItemPriceInput,
) {
await this.billingSubscriptionUpdateService.changeResourceCreditPrice(
workspace.id,
priceId,
);
return {
billingSubscriptions:
await this.billingSubscriptionService.getBillingSubscriptions(
workspace.id,
),
currentBillingSubscription:
await this.billingSubscriptionService.getCurrentBillingSubscriptionOrThrow(
{ workspaceId: workspace.id },
),
};
}
@Mutation(() => BillingCustomerEntity)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: false,
oauthClient: false,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async updateUserCreditsFallback(
@AuthWorkspace() workspace: WorkspaceEntity,
@Args() { userCreditsFallback }: BillingUpdateUserCreditsFallbackInput,
): Promise<BillingCustomerEntity> {
return this.billingService.updateUserCreditsFallbackOrThrow({
workspaceId: workspace.id,
userCreditsFallback,
});
}
@Query(() => [BillingPlanDTO])
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: true,
}),
NoPermissionGuard,
)
async billingPlans(): Promise<BillingPlanDTO[]> {
const plans = await this.billingPlanService.listPlans();
return plans.map(formatBillingDatabaseProductToGraphqlDTO);
}
@Query(() => [BillingPlanDTO], {
deprecationReason: 'Use billingPlans instead.',
})
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: true,
}),
NoPermissionGuard,
)
async listPlans(): Promise<BillingPlanDTO[]> {
return this.billingPlans();
}
@Mutation(() => BillingEndTrialPeriodDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async endSubscriptionTrialPeriod(
@AuthWorkspace() workspace: WorkspaceEntity,
): Promise<BillingEndTrialPeriodDTO> {
const result =
await this.billingSubscriptionService.endTrialPeriod(workspace);
if (!result.hasPaymentMethod && result.stripeCustomerId) {
const billingPortalUrl =
await this.billingPortalWorkspaceService.computeBillingPortalSessionUrlForPaymentMethodUpdate(
workspace,
result.stripeCustomerId,
'/settings/billing',
);
return {
hasPaymentMethod: false,
status: undefined,
billingPortalUrl,
};
}
return {
hasPaymentMethod: result.hasPaymentMethod,
status: result.status,
currentBillingSubscription:
await this.billingSubscriptionService.getCurrentBillingSubscriptionOrThrow(
{ workspaceId: workspace.id },
),
billingSubscriptions:
await this.billingSubscriptionService.getBillingSubscriptions(
workspace.id,
),
};
}
@Query(() => [BillingResourceCreditUsageDTO])
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: true,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async getResourceCreditUsage(
@AuthWorkspace() workspace: WorkspaceEntity,
): Promise<BillingResourceCreditUsageDTO[]> {
const usageData =
await this.billingUsageService.getResourceCreditProductUsage(workspace);
return usageData.map((item) => ({
...item,
workspaceCreditsUsed: toDisplayCredits(item.workspaceCreditsUsed),
userCreditsUsed: toDisplayCredits(item.userCreditsUsed),
workspaceCreditsGranted: toDisplayCredits(item.workspaceCreditsGranted),
workspaceCreditsGrantedForSeats: toDisplayCredits(
item.workspaceCreditsGrantedForSeats,
),
workspaceCreditsExtraGranted: toDisplayCredits(
item.workspaceCreditsExtraGranted,
),
workspaceCreditsTotalGranted: toDisplayCredits(
item.workspaceCreditsTotalGranted,
),
unitPriceCents: item.unitPriceCents * INTERNAL_CREDITS_PER_DISPLAY_CREDIT,
}));
}
@Mutation(() => BillingUpdateDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: true,
workspaceAgnostic: false,
},
apiKey: true,
oauthClient: true,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.BILLING),
)
async cancelSwitchResourceCreditPrice(
@AuthWorkspace() workspace: WorkspaceEntity,
) {
await this.billingSubscriptionUpdateService.cancelSwitchResourceCreditPrice(
workspace,
);
return {
billingSubscriptions:
await this.billingSubscriptionService.getBillingSubscriptions(
workspace.id,
),
currentBillingSubscription:
await this.billingSubscriptionService.getCurrentBillingSubscriptionOrThrow(
{ workspaceId: workspace.id },
),
};
}
private async validateCanCheckoutSessionPermissionOrThrow({
workspaceId,
userWorkspaceId,
apiKeyId,
applicationId,
workspaceActivationStatus,
}: {
workspaceId: string;
userWorkspaceId: string;
apiKeyId?: string;
applicationId?: string;
workspaceActivationStatus: WorkspaceActivationStatus;
}) {
if (
(await this.billingService.isSubscriptionIncompleteOnboardingStatus(
workspaceId,
)) ||
workspaceActivationStatus ===
WorkspaceActivationStatus.PENDING_CREATION ||
workspaceActivationStatus === WorkspaceActivationStatus.ONGOING_CREATION
) {
return;
}
const userHasPermission =
await this.permissionsService.userHasWorkspaceSettingPermission({
userWorkspaceId,
workspaceId,
setting: PermissionFlagType.BILLING,
apiKeyId,
applicationId,
agentId: undefined,
});
if (!userHasPermission) {
throw new PermissionsException(
PermissionsExceptionMessage.PERMISSION_DENIED,
PermissionsExceptionCode.PERMISSION_DENIED,
);
}
}
}