Skip to content

The open alternative to Salesforce, designed for AI.

Make email group sends free for paying customers, with rate limits (#26455)

neo773996a14970120
diff --git a/packages/twenty-server/src/engine/core-modules/billing/services/billing.service.ts b/packages/twenty-server/src/engine/core-modules/billing/services/billing.service.ts
index 3df408794f3..e20e9c1748a 100644
--- a/packages/twenty-server/src/engine/core-modules/billing/services/billing.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/billing/services/billing.service.ts
@@ -4,15 +4,18 @@ import { Injectable, Logger } from '@nestjs/common';
import { isDefined } from 'twenty-shared/utils';
+import { NO_BILLING_SUBSCRIPTION } from 'src/engine/core-modules/billing/constants/no-billing-subscription.constant';
import { BillingCustomerEntity } from 'src/engine/core-modules/billing/entities/billing-customer.entity';
import { BillingSubscriptionEntity } from 'src/engine/core-modules/billing/entities/billing-subscription.entity';
import { type BillingEntitlementKey } from 'src/engine/core-modules/billing/enums/billing-entitlement-key.enum';
+import { SubscriptionStatus } from 'src/engine/core-modules/billing/enums/billing-subscription-status.enum';
import { BillingProductService } from 'src/engine/core-modules/billing/services/billing-product.service';
import { BillingSubscriptionService } from 'src/engine/core-modules/billing/services/billing-subscription.service';
import { StripeCustomerService } from 'src/engine/core-modules/billing/stripe/services/stripe-customer.service';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
@Injectable()
export class BillingService {
protected readonly logger = new Logger(BillingService.name);
@@ -21,6 +24,7 @@ export class BillingService {
private readonly billingSubscriptionService: BillingSubscriptionService,
private readonly billingProductService: BillingProductService,
private readonly stripeCustomerService: StripeCustomerService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
@InjectWorkspaceScopedRepository(BillingSubscriptionEntity)
private readonly billingSubscriptionRepository: WorkspaceScopedRepository<BillingSubscriptionEntity>,
@InjectWorkspaceScopedRepository(BillingCustomerEntity)
@@ -85,6 +89,24 @@ export class BillingService {
);
}
+ async isPayingCustomer(workspaceId: string) {
+ const isBillingEnabled = this.isBillingEnabled();
+
+ if (!isBillingEnabled) {
+ return true;
+ }
+
+ const { currentBillingSubscription } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'currentBillingSubscription',
+ ]);
+
+ return (
+ currentBillingSubscription !== NO_BILLING_SUBSCRIPTION &&
+ currentBillingSubscription.status === SubscriptionStatus.Active
+ );
+ }
+
async isSubscriptionIncompleteOnboardingStatus(workspaceId: string) {
const hasAnySubscription =
await this.hasWorkspaceAnySubscription(workspaceId);
diff --git a/packages/twenty-server/src/engine/metadata-modules/message-channel/message-channel.exception.ts b/packages/twenty-server/src/engine/metadata-modules/message-channel/message-channel.exception.ts
index 2b55a4135fc..eb1b5ce5da7 100644
--- a/packages/twenty-server/src/engine/metadata-modules/message-channel/message-channel.exception.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/message-channel/message-channel.exception.ts
@@ -9,6 +9,7 @@ export enum MessageChannelExceptionCode {
INVALID_MESSAGE_CHANNEL_INPUT = 'INVALID_MESSAGE_CHANNEL_INPUT',
MESSAGE_CHANNEL_OWNERSHIP_VIOLATION = 'MESSAGE_CHANNEL_OWNERSHIP_VIOLATION',
EMAIL_GROUP_NOT_CONFIGURED = 'EMAIL_GROUP_NOT_CONFIGURED',
+ EMAIL_GROUP_SENDING_REQUIRES_PAID_PLAN = 'EMAIL_GROUP_SENDING_REQUIRES_PAID_PLAN',
}
const getMessageChannelExceptionUserFriendlyMessage = (
@@ -23,6 +24,8 @@ const getMessageChannelExceptionUserFriendlyMessage = (
return msg`You do not have access to this message channel.`;
case MessageChannelExceptionCode.EMAIL_GROUP_NOT_CONFIGURED:
return msg`Email group is not configured on this server.`;
+ case MessageChannelExceptionCode.EMAIL_GROUP_SENDING_REQUIRES_PAID_PLAN:
+ return msg`Sending from an email group is available once your workspace is on a paid plan and has been billed.`;
default:
assertUnreachable(code);
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/message-channel/utils/message-channel-graphql-api-exception-handler.util.ts b/packages/twenty-server/src/engine/metadata-modules/message-channel/utils/message-channel-graphql-api-exception-handler.util.ts
index 1e93fb5b64b..69dc4892bee 100644
--- a/packages/twenty-server/src/engine/metadata-modules/message-channel/utils/message-channel-graphql-api-exception-handler.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/message-channel/utils/message-channel-graphql-api-exception-handler.util.ts
@@ -28,6 +28,7 @@ export const messageChannelGraphqlApiExceptionHandler = (error: Error) => {
case MessageChannelExceptionCode.INVALID_MESSAGE_CHANNEL_INPUT:
throw new UserInputError(error);
case MessageChannelExceptionCode.MESSAGE_CHANNEL_OWNERSHIP_VIOLATION:
+ case MessageChannelExceptionCode.EMAIL_GROUP_SENDING_REQUIRES_PAID_PLAN:
throw new ForbiddenError(error);
case MessageChannelExceptionCode.EMAIL_GROUP_NOT_CONFIGURED:
throw new InternalServerError(error);
diff --git a/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/constants/email-group-send-throttle.constant.ts b/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/constants/email-group-send-throttle.constant.ts
new file mode 100644
index 00000000000..6ea8eb72ccf
--- /dev/null
+++ b/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/constants/email-group-send-throttle.constant.ts
@@ -0,0 +1,4 @@
+export const EMAIL_GROUP_SEND_THROTTLE = {
+ maxRecipients: 200,
+ windowMs: 24 * 60 * 60 * 1000,
+};
diff --git a/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/services/email-group-message-outbound.service.ts b/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/services/email-group-message-outbound.service.ts
index aa4534f5e10..585842ce858 100644
--- a/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/services/email-group-message-outbound.service.ts
+++ b/packages/twenty-server/src/modules/messaging/message-outbound-manager/drivers/email-group/services/email-group-message-outbound.service.ts
@@ -1,42 +1,65 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
import { isNonEmptyString } from '@sniptt/guards';
import { isDefined } from 'twenty-shared/utils';
import { v4 } from 'uuid';
+import { BillingService } from 'src/engine/core-modules/billing/services/billing.service';
+import { InjectCacheStorage } from 'src/engine/core-modules/cache-storage/decorators/cache-storage.decorator';
+import { CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
+import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
import { EmailingDomainStatus } from 'src/engine/core-modules/emailing-domain/drivers/types/emailing-domain-status.type';
import { EmailingDomainEntity } from 'src/engine/core-modules/emailing-domain/emailing-domain.entity';
-import { EmailBillingService } from 'src/modules/emailing/services/email-billing.service';
+import {
+ ThrottlerException,
+ ThrottlerExceptionCode,
+} from 'src/engine/core-modules/throttler/throttler.exception';
+import { UsageLimitSpeedService } from 'src/engine/core-modules/usage-limit/services/usage-limit-speed.service';
+import { UsageOperationType } from 'src/engine/core-modules/usage/enums/usage-operation-type.enum';
+import { UsageResourceType } from 'src/engine/core-modules/usage/enums/usage-resource-type.enum';
import { EmailingDomainSenderService } from 'src/modules/emailing/services/emailing-domain-sender.service';
import { type ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
import {
MessageChannelException,
MessageChannelExceptionCode,
} from 'src/engine/metadata-modules/message-channel/message-channel.exception';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
+import { EMAIL_GROUP_SEND_THROTTLE } from 'src/modules/messaging/message-outbound-manager/drivers/email-group/constants/email-group-send-throttle.constant';
import { type MessageOutboundDriver } from 'src/modules/messaging/message-outbound-manager/interfaces/message-outbound-driver.interface';
import { type SendMessageInput } from 'src/modules/messaging/message-outbound-manager/types/send-message-input.type';
import { type SendMessageResult } from 'src/modules/messaging/message-outbound-manager/types/send-message-result.type';
import { buildOutboundThreadingHeaders } from 'src/modules/messaging/message-outbound-manager/utils/build-outbound-threading-headers.util';
import { getDomainFromEmail } from 'src/utils/get-domain-from-email';
-import { countDeliveredRecipients } from 'src/engine/core-modules/emailing-domain/utils/count-delivered-recipients.util';
@Injectable()
export class EmailGroupMessageOutboundService implements MessageOutboundDriver {
- private readonly logger = new Logger(EmailGroupMessageOutboundService.name);
-
constructor(
@InjectWorkspaceScopedRepository(EmailingDomainEntity)
private readonly emailingDomainRepository: WorkspaceScopedRepository<EmailingDomainEntity>,
private readonly emailingDomainSenderService: EmailingDomainSenderService,
- private readonly emailBillingService: EmailBillingService,
+ private readonly usageLimitSpeedService: UsageLimitSpeedService,
+ private readonly billingService: BillingService,
+ @InjectCacheStorage(CacheStorageNamespace.ModuleMessaging)
+ private readonly cacheStorage: CacheStorageService,
) {}
async sendMessage(
sendMessageInput: SendMessageInput,
connectedAccount: ConnectedAccountEntity,
): Promise<SendMessageResult> {
+ const isPayingCustomer = await this.billingService.isPayingCustomer(
+ connectedAccount.workspaceId,
+ );
+
+ if (!isPayingCustomer) {
+ throw new MessageChannelException(
+ `Cannot send from ${connectedAccount.handle}: sending from an email group is available once your workspace is on a paid plan and has been billed.`,
+ MessageChannelExceptionCode.EMAIL_GROUP_SENDING_REQUIRES_PAID_PLAN,
+ );
+ }
+
const emailingDomain = await this.resolveEmailingDomain(connectedAccount);
if (emailingDomain.status !== EmailingDomainStatus.VERIFIED) {
@@ -46,19 +69,34 @@ export class EmailGroupMessageOutboundService implements MessageOutboundDriver {
);
}
- await this.emailBillingService.validateEmailCreditsOrThrow(
+ const recipientCount =
+ this.toRecipientArray(sendMessageInput.to).length +
+ this.toRecipientArray(sendMessageInput.cc).length +
+ this.toRecipientArray(sendMessageInput.bcc).length;
+
+ await this.usageLimitSpeedService.consumeOrThrow({
+ resourceType: UsageResourceType.EMAIL,
+ operationType: UsageOperationType.EMAIL_SEND,
+ authContext: buildSystemAuthContext(connectedAccount.workspaceId),
+ cost: recipientCount,
+ });
+
+ const dailyRecipientCountKey = this.buildDailyRecipientCountKey(
connectedAccount.workspaceId,
);
+ await this.consumeDailyRecipientAllowanceOrThrow(
+ dailyRecipientCountKey,
+ recipientCount,
+ );
+
const threadExternalId =
sendMessageInput.threadExternalId ??
sendMessageInput.inReplyTo ??
`<${v4()}@${emailingDomain.domain}>`;
- const result = await this.emailingDomainSenderService.sendEmail(
- connectedAccount.workspaceId,
- emailingDomain.id,
- {
+ const result = await this.emailingDomainSenderService
+ .sendEmail(connectedAccount.workspaceId, emailingDomain.id, {
sendKind: 'TRANSACTIONAL',
to: this.toRecipientArray(sendMessageInput.to),
cc: this.toRecipientArray(sendMessageInput.cc),
@@ -76,22 +114,11 @@ export class EmailGroupMessageOutboundService implements MessageOutboundDriver {
inReplyTo: sendMessageInput.inReplyTo,
references: sendMessageInput.references,
}),
- },
- );
-
- // The provider has already accepted the mail, so surfacing a billing
- // failure would invite a retry that sends it a second time.
- await this.emailBillingService
- .billSentEmails({
- workspaceId: connectedAccount.workspaceId,
- sentEmailCount: countDeliveredRecipients(result.deliveredRecipients),
})
- .catch((error) => {
- this.logger.error(
- `Workspace ${connectedAccount.workspaceId} sent email ${result.messageId} but failed to bill it, so this send is unbilled: ${
- error instanceof Error ? error.message : String(error)
- }`,
- );
+ .catch(async (error) => {
+ await this.cacheStorage.incrBy(dailyRecipientCountKey, -recipientCount);
+
+ throw error;
});
return {
@@ -145,6 +172,40 @@ export class EmailGroupMessageOutboundService implements MessageOutboundDriver {
return emailingDomain;
}
+ private buildDailyRecipientCountKey(workspaceId: string): string {
+ const windowIndex = Math.floor(
+ Date.now() / EMAIL_GROUP_SEND_THROTTLE.windowMs,
+ );
+
+ return `email-group-send:recipients:${workspaceId}:${windowIndex}`;
+ }
+
+ private async consumeDailyRecipientAllowanceOrThrow(
+ dailyRecipientCountKey: string,
+ recipientCount: number,
+ ): Promise<void> {
+ const recipientCountInWindow = await this.cacheStorage.incrBy(
+ dailyRecipientCountKey,
+ recipientCount,
+ );
+
+ await this.cacheStorage.expire(
+ dailyRecipientCountKey,
+ EMAIL_GROUP_SEND_THROTTLE.windowMs,
+ );
+
+ if (recipientCountInWindow <= EMAIL_GROUP_SEND_THROTTLE.maxRecipients) {
+ return;
+ }
+
+ await this.cacheStorage.incrBy(dailyRecipientCountKey, -recipientCount);
+
+ throw new ThrottlerException(
+ `Email group send limit reached: ${EMAIL_GROUP_SEND_THROTTLE.maxRecipients} recipients per day.`,
+ ThrottlerExceptionCode.LIMIT_REACHED,
+ );
+ }
+
private toRecipientArray(value: string | string[] | undefined): string[] {
if (!isDefined(value)) {
return [];
diff --git a/packages/twenty-server/src/modules/messaging/message-outbound-manager/messaging-send-manager.module.ts b/packages/twenty-server/src/modules/messaging/message-outbound-manager/messaging-send-manager.module.ts
index 74d166e565d..ee295fa97ae 100644
--- a/packages/twenty-server/src/modules/messaging/message-outbound-manager/messaging-send-manager.module.ts
+++ b/packages/twenty-server/src/modules/messaging/message-outbound-manager/messaging-send-manager.module.ts
@@ -1,7 +1,9 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
+import { BillingModule } from 'src/engine/core-modules/billing/billing.module';
import { EmailingDomainEntity } from 'src/engine/core-modules/emailing-domain/emailing-domain.entity';
+import { UsageLimitModule } from 'src/engine/core-modules/usage-limit/usage-limit.module';
import { EmailingModule } from 'src/modules/emailing/emailing.module';
import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
import { MessageFolderEntity } from 'src/engine/metadata-modules/message-folder/entities/message-folder.entity';
@@ -28,6 +30,8 @@ import { SentMessagePersistenceService } from 'src/modules/messaging/message-out
MessagingImportManagerModule,
MessagingMessageCleanerModule,
EmailingModule,
+ BillingModule,
+ UsageLimitModule,
TypeOrmModule.forFeature([
MessageChannelEntity,
MessageFolderEntity,