Skip to content

The open alternative to Salesforce, designed for AI.

feat(usage-limit): gate intra-workspace limits behind the Organization entitlement (#25292)

Etienne30dce1487a26
diff --git a/packages/twenty-client-sdk/src/metadata/generated/schema.graphql b/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
index 4f8c0437a55..18f225ca2cc 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
+++ b/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
@@ -2486,6 +2486,7 @@ enum BillingEntitlementKey {
CUSTOM_DOMAIN
RLS
AUDIT_LOGS
+ USAGE_LIMIT
}
type DomainRecord {
diff --git a/packages/twenty-client-sdk/src/metadata/generated/schema.ts b/packages/twenty-client-sdk/src/metadata/generated/schema.ts
index f852271ed5c..f3884850a91 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/schema.ts
+++ b/packages/twenty-client-sdk/src/metadata/generated/schema.ts
@@ -2107,7 +2107,7 @@ export interface BillingEntitlement {
__typename: 'BillingEntitlement'
}
-export type BillingEntitlementKey = 'SSO' | 'CUSTOM_DOMAIN' | 'RLS' | 'AUDIT_LOGS'
+export type BillingEntitlementKey = 'SSO' | 'CUSTOM_DOMAIN' | 'RLS' | 'AUDIT_LOGS' | 'USAGE_LIMIT'
export interface DomainRecord {
validationType: Scalars['String']
@@ -10371,7 +10371,8 @@ export const enumBillingEntitlementKey = {
SSO: 'SSO' as const,
CUSTOM_DOMAIN: 'CUSTOM_DOMAIN' as const,
RLS: 'RLS' as const,
- AUDIT_LOGS: 'AUDIT_LOGS' as const
+ AUDIT_LOGS: 'AUDIT_LOGS' as const,
+ USAGE_LIMIT: 'USAGE_LIMIT' as const
}
export const enumApplicationExportCoverageStatus = {
diff --git a/packages/twenty-front/src/generated-metadata/graphql.ts b/packages/twenty-front/src/generated-metadata/graphql.ts
index aa3e690c7f1..76df0daf515 100644
--- a/packages/twenty-front/src/generated-metadata/graphql.ts
+++ b/packages/twenty-front/src/generated-metadata/graphql.ts
@@ -702,7 +702,8 @@ export enum BillingEntitlementKey {
AUDIT_LOGS = 'AUDIT_LOGS',
CUSTOM_DOMAIN = 'CUSTOM_DOMAIN',
RLS = 'RLS',
- SSO = 'SSO'
+ SSO = 'SSO',
+ USAGE_LIMIT = 'USAGE_LIMIT'
}
export type BillingLicensedProduct = BillingProductDto & {
diff --git a/packages/twenty-server/src/engine/core-modules/billing-webhook/services/billing-webhook-entitlement.service.ts b/packages/twenty-server/src/engine/core-modules/billing-webhook/services/billing-webhook-entitlement.service.ts
index 401416f3fc9..f341af3ff69 100644
--- a/packages/twenty-server/src/engine/core-modules/billing-webhook/services/billing-webhook-entitlement.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/billing-webhook/services/billing-webhook-entitlement.service.ts
@@ -7,6 +7,7 @@ import { Repository } from 'typeorm';
import type Stripe from 'stripe';
+import { isEntitlementGrantedByStripeEvent } from 'src/engine/core-modules/billing-webhook/utils/is-entitlement-granted-by-stripe-event.util';
import { transformStripeEntitlementUpdatedEventToDatabaseEntitlement } from 'src/engine/core-modules/billing-webhook/utils/transform-stripe-entitlement-updated-event-to-database-entitlement.util';
import {
BillingException,
@@ -15,6 +16,7 @@ import {
import { BillingCustomerEntity } from 'src/engine/core-modules/billing/entities/billing-customer.entity';
import { BillingEntitlementEntity } from 'src/engine/core-modules/billing/entities/billing-entitlement.entity';
import { BillingEntitlementKey } from 'src/engine/core-modules/billing/enums/billing-entitlement-key.enum';
+import { UsageLimitQuotaService } from 'src/engine/core-modules/usage-limit/services/usage-limit-quota.service';
import { RowLevelPermissionPredicateGroupService } from 'src/engine/metadata-modules/row-level-permission-predicate/services/row-level-permission-predicate-group.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';
@@ -28,6 +30,7 @@ export class BillingWebhookEntitlementService {
@InjectWorkspaceScopedRepository(BillingEntitlementEntity)
private readonly billingEntitlementRepository: WorkspaceScopedRepository<BillingEntitlementEntity>,
private readonly rowLevelPermissionPredicateGroupService: RowLevelPermissionPredicateGroupService,
+ private readonly usageLimitQuotaService: UsageLimitQuotaService,
) {}
async processStripeEvent(
@@ -74,6 +77,17 @@ export class BillingWebhookEntitlementService {
);
}
+ if (
+ isEntitlementGrantedByStripeEvent({
+ data,
+ key: BillingEntitlementKey.USAGE_LIMIT,
+ })
+ ) {
+ await this.usageLimitQuotaService.dropIntraWorkspaceLimitCounters(
+ workspaceId,
+ );
+ }
+
return {
stripeEntitlementCustomerId: data.object.customer,
};
diff --git a/packages/twenty-server/src/engine/core-modules/billing-webhook/utils/__tests__/is-entitlement-granted-by-stripe-event.util.spec.ts b/packages/twenty-server/src/engine/core-modules/billing-webhook/utils/__tests__/is-entitlement-granted-by-stripe-event.util.spec.ts
new file mode 100644
index 00000000000..707ee687c57
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/billing-webhook/utils/__tests__/is-entitlement-granted-by-stripe-event.util.spec.ts
@@ -0,0 +1,86 @@
+/* @license Enterprise */
+
+import type Stripe from 'stripe';
+
+import { isEntitlementGrantedByStripeEvent } from 'src/engine/core-modules/billing-webhook/utils/is-entitlement-granted-by-stripe-event.util';
+import { BillingEntitlementKey } from 'src/engine/core-modules/billing/enums/billing-entitlement-key.enum';
+
+const buildEntitlement = (
+ lookupKey: string,
+): Stripe.Entitlements.ActiveEntitlement => ({
+ id: `ent_${lookupKey}`,
+ object: 'entitlements.active_entitlement',
+ feature: `feat_${lookupKey}`,
+ livemode: false,
+ lookup_key: lookupKey,
+});
+
+const buildData = ({
+ current,
+ previous,
+}: {
+ current: string[];
+ previous?: string[];
+}): Stripe.EntitlementsActiveEntitlementSummaryUpdatedEvent.Data => ({
+ object: {
+ object: 'entitlements.active_entitlement_summary',
+ customer: 'cus_123',
+ livemode: false,
+ entitlements: {
+ object: 'list',
+ data: current.map(buildEntitlement),
+ has_more: false,
+ url: '',
+ },
+ },
+ ...(previous
+ ? {
+ previous_attributes: {
+ entitlements: {
+ data: previous.map(buildEntitlement),
+ } as Stripe.ApiList<Stripe.Entitlements.ActiveEntitlement>,
+ },
+ }
+ : {}),
+});
+
+describe('isEntitlementGrantedByStripeEvent', () => {
+ it('is true when the key appears in the current list only', () => {
+ expect(
+ isEntitlementGrantedByStripeEvent({
+ data: buildData({ current: ['USAGE_LIMIT', 'SSO'], previous: ['SSO'] }),
+ key: BillingEntitlementKey.USAGE_LIMIT,
+ }),
+ ).toBe(true);
+ });
+
+ it('is false when the key was already granted', () => {
+ expect(
+ isEntitlementGrantedByStripeEvent({
+ data: buildData({
+ current: ['USAGE_LIMIT', 'SSO'],
+ previous: ['USAGE_LIMIT'],
+ }),
+ key: BillingEntitlementKey.USAGE_LIMIT,
+ }),
+ ).toBe(false);
+ });
+
+ it('is false when the key is revoked', () => {
+ expect(
+ isEntitlementGrantedByStripeEvent({
+ data: buildData({ current: [], previous: ['USAGE_LIMIT'] }),
+ key: BillingEntitlementKey.USAGE_LIMIT,
+ }),
+ ).toBe(false);
+ });
+
+ it('is false when the event carries no previous entitlements', () => {
+ expect(
+ isEntitlementGrantedByStripeEvent({
+ data: buildData({ current: ['USAGE_LIMIT'] }),
+ key: BillingEntitlementKey.USAGE_LIMIT,
+ }),
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/billing-webhook/utils/__tests__/transform-stripe-entitlement-updated-event-to-database-entitlement.util.spec.ts b/packages/twenty-server/src/engine/core-modules/billing-webhook/utils/__tests__/transform-stripe-entitlement-updated-event-to-database-entitlement.util.spec.ts
index 256764f61f2..a8761bd5065 100644
--- a/packages/twenty-server/src/engine/core-modules/billing-webhook/utils/__tests__/transform-stripe-entitlement-updated-event-to-database-entitlement.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/billing-webhook/utils/__tests__/transform-stripe-entitlement-updated-event-to-database-entitlement.util.spec.ts
@@ -59,6 +59,12 @@ describe('transformStripeEntitlementUpdatedEventToDatabaseEntitlement', () => {
value: false,
workspaceId: 'workspaceId',
},
+ {
+ key: BillingEntitlementKey.USAGE_LIMIT,
+ stripeCustomerId: 'cus_123',
+ value: false,
+ workspaceId: 'workspaceId',
+ },
]);
});
@@ -115,6 +121,12 @@ describe('transformStripeEntitlementUpdatedEventToDatabaseEntitlement', () => {
value: false,
workspaceId: 'workspaceId',
},
+ {
+ key: BillingEntitlementKey.USAGE_LIMIT,
+ stripeCustomerId: 'cus_123',
+ value: false,
+ workspaceId: 'workspaceId',
+ },
]);
});
});
diff --git a/packages/twenty-server/src/engine/core-modules/billing-webhook/utils/is-entitlement-granted-by-stripe-event.util.ts b/packages/twenty-server/src/engine/core-modules/billing-webhook/utils/is-entitlement-granted-by-stripe-event.util.ts
new file mode 100644
index 00000000000..693314581b5
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/billing-webhook/utils/is-entitlement-granted-by-stripe-event.util.ts
@@ -0,0 +1,33 @@
+/* @license Enterprise */
+
+import { isDefined } from 'twenty-shared/utils';
+
+import type Stripe from 'stripe';
+
+import { type BillingEntitlementKey } from 'src/engine/core-modules/billing/enums/billing-entitlement-key.enum';
+
+const hasEntitlementKey = (
+ entitlements: { lookup_key: string }[] | undefined,
+ key: BillingEntitlementKey,
+): boolean =>
+ isDefined(entitlements) &&
+ entitlements.some((entitlement) => entitlement.lookup_key === key);
+
+export const isEntitlementGrantedByStripeEvent = ({
+ data,
+ key,
+}: {
+ data: Stripe.EntitlementsActiveEntitlementSummaryUpdatedEvent.Data;
+ key: BillingEntitlementKey;
+}): boolean => {
+ const previousEntitlements = data.previous_attributes?.entitlements?.data;
+
+ if (!isDefined(previousEntitlements)) {
+ return false;
+ }
+
+ return (
+ !hasEntitlementKey(previousEntitlements, key) &&
+ hasEntitlementKey(data.object.entitlements.data, key)
+ );
+};
diff --git a/packages/twenty-server/src/engine/core-modules/billing/billing.module.ts b/packages/twenty-server/src/engine/core-modules/billing/billing.module.ts
index 670e1eacbfb..5fe0be4d622 100644
--- a/packages/twenty-server/src/engine/core-modules/billing/billing.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/billing/billing.module.ts
@@ -32,6 +32,7 @@ import { BillingProductService } from 'src/engine/core-modules/billing/services/
import { BillingSubscriptionItemService } from 'src/engine/core-modules/billing/services/billing-subscription-item.service';
import { BillingSubscriptionPhaseService } from 'src/engine/core-modules/billing/services/billing-subscription-phase.service';
import { BillingCreditAllowanceProvider } from 'src/engine/core-modules/billing/services/billing-credit-allowance-provider.service';
+import { BillingUsageLimitEntitlementProvider } from 'src/engine/core-modules/billing/services/billing-usage-limit-entitlement-provider.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 { BillingUsageCacheService } from 'src/engine/core-modules/billing/services/billing-usage-cache.service';
@@ -102,6 +103,7 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
BillingUsageService,
BillingUsageCacheService,
BillingCreditAllowanceProvider,
+ BillingUsageLimitEntitlementProvider,
BillingPriceService,
BillingCreditRolloverService,
BillingCreditGrantService,
diff --git a/packages/twenty-server/src/engine/core-modules/billing/enums/billing-entitlement-key.enum.ts b/packages/twenty-server/src/engine/core-modules/billing/enums/billing-entitlement-key.enum.ts
index 3c137dc0944..7618bfbb73e 100644
--- a/packages/twenty-server/src/engine/core-modules/billing/enums/billing-entitlement-key.enum.ts
+++ b/packages/twenty-server/src/engine/core-modules/billing/enums/billing-entitlement-key.enum.ts
@@ -5,4 +5,5 @@ export enum BillingEntitlementKey {
CUSTOM_DOMAIN = 'CUSTOM_DOMAIN',
RLS = 'RLS',
AUDIT_LOGS = 'AUDIT_LOGS',
+ USAGE_LIMIT = 'USAGE_LIMIT',
}
diff --git a/packages/twenty-server/src/engine/core-modules/billing/services/billing-subscription.service.ts b/packages/twenty-server/src/engine/core-modules/billing/services/billing-subscription.service.ts
index 6e6cce0df26..7ff21482786 100644
--- a/packages/twenty-server/src/engine/core-modules/billing/services/billing-subscription.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/billing/services/billing-subscription.service.ts
@@ -37,6 +37,7 @@ import { StripeCustomerService } from 'src/engine/core-modules/billing/stripe/se
import { StripeSubscriptionScheduleService } from 'src/engine/core-modules/billing/stripe/services/stripe-subscription-schedule.service';
import { StripeSubscriptionService } from 'src/engine/core-modules/billing/stripe/services/stripe-subscription.service';
import { getPlanKeyFromSubscription } from 'src/engine/core-modules/billing/utils/get-plan-key-from-subscription.util';
+import { isEntitlementActive } from 'src/engine/core-modules/billing/utils/is-entitlement-active.util';
import { resolveBillingPeriodBoundaryUpdate } from 'src/engine/core-modules/billing/utils/resolve-billing-period-boundary-update.util';
import { EnterprisePlanService } from 'src/engine/core-modules/enterprise/services/enterprise-plan.service';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
@@ -237,9 +238,11 @@ export class BillingSubscriptionService {
return Object.values(BillingEntitlementKey).map((key) => ({
key,
- value:
- hasValidEnterprisePlan &&
- (!isBillingEnabled || (entitlementsByKey[key]?.value ?? false)),
+ value: isEntitlementActive({
+ hasValidEnterprisePlan,
+ isBillingEnabled,
+ stripeEntitlementValue: entitlementsByKey[key]?.value ?? false,
+ }),
}));
}
@@ -255,6 +258,25 @@ export class BillingSubscriptionService {
return entitlement?.value ?? false;
}
+ async getWorkspaceEntitlementValue(
+ workspaceId: string,
+ key: BillingEntitlementKey,
+ ): Promise<boolean> {
+ const hasValidEnterprisePlan = this.enterprisePlanService.isValid();
+ const isBillingEnabled = this.twentyConfigService.get('IS_BILLING_ENABLED');
+
+ const stripeEntitlementValue =
+ hasValidEnterprisePlan && isBillingEnabled
+ ? await this.getWorkspaceEntitlementByKey(workspaceId, key)
+ : false;
+
+ return isEntitlementActive({
+ hasValidEnterprisePlan,
+ isBillingEnabled,
+ stripeEntitlementValue,
+ });
+ }
+
async endTrialPeriod(workspace: WorkspaceEntity) {
const billingSubscription = await this.getCurrentBillingSubscriptionOrThrow(
{ workspaceId: workspace.id },
diff --git a/packages/twenty-server/src/engine/core-modules/billing/services/billing-usage-limit-entitlement-provider.service.ts b/packages/twenty-server/src/engine/core-modules/billing/services/billing-usage-limit-entitlement-provider.service.ts
new file mode 100644
index 00000000000..d90d5e58882
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/billing/services/billing-usage-limit-entitlement-provider.service.ts
@@ -0,0 +1,25 @@
+/* @license Enterprise */
+
+import { Injectable } from '@nestjs/common';
+
+import { BillingEntitlementKey } from 'src/engine/core-modules/billing/enums/billing-entitlement-key.enum';
+import { BillingSubscriptionService } from 'src/engine/core-modules/billing/services/billing-subscription.service';
+import { UsageLimitEntitlementProvider } from 'src/engine/core-modules/usage-limit/interfaces/usage-limit-entitlement-provider.service';
+
+@Injectable()
+export class BillingUsageLimitEntitlementProvider extends UsageLimitEntitlementProvider {
+ constructor(
+ private readonly billingSubscriptionService: BillingSubscriptionService,
+ ) {
+ super();
+ }
+
+ async hasIntraWorkspaceLimitEntitlement(
+ workspaceId: string,
+ ): Promise<boolean> {
+ return this.billingSubscriptionService.getWorkspaceEntitlementValue(
+ workspaceId,
+ BillingEntitlementKey.USAGE_LIMIT,
+ );
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/billing/utils/__tests__/is-entitlement-active.util.spec.ts b/packages/twenty-server/src/engine/core-modules/billing/utils/__tests__/is-entitlement-active.util.spec.ts
new file mode 100644
index 00000000000..6e5938940fa
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/billing/utils/__tests__/is-entitlement-active.util.spec.ts
@@ -0,0 +1,41 @@
+import { isEntitlementActive } from 'src/engine/core-modules/billing/utils/is-entitlement-active.util';
+
+describe('isEntitlementActive', () => {
+ it('is false without a valid Organization license, whatever billing says', () => {
+ expect(
+ isEntitlementActive({
+ hasValidEnterprisePlan: false,
+ isBillingEnabled: false,
+ stripeEntitlementValue: true,
+ }),
+ ).toBe(false);
+ });
+
+ it('is true on a licensed instance with billing disabled (self-host)', () => {
+ expect(
+ isEntitlementActive({
+ hasValidEnterprisePlan: true,
+ isBillingEnabled: false,
+ stripeEntitlementValue: false,
+ }),
+ ).toBe(true);
+ });
+
+ it('follows the Stripe entitlement value when licensed and billing is enabled (cloud)', () => {
+ expect(
+ isEntitlementActive({
+ hasValidEnterprisePlan: true,
+ isBillingEnabled: true,
+ stripeEntitlementValue: true,
+ }),
+ ).toBe(true);
+
+ expect(
+ isEntitlementActive({
+ hasValidEnterprisePlan: true,
+ isBillingEnabled: true,
+ stripeEntitlementValue: false,
+ }),
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/billing/utils/is-entitlement-active.util.ts b/packages/twenty-server/src/engine/core-modules/billing/utils/is-entitlement-active.util.ts
new file mode 100644
index 00000000000..de6674dd3df
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/billing/utils/is-entitlement-active.util.ts
@@ -0,0 +1,12 @@
+/* @license Enterprise */
+
+export const isEntitlementActive = ({
+ hasValidEnterprisePlan,
+ isBillingEnabled,
+ stripeEntitlementValue,
+}: {
+ hasValidEnterprisePlan: boolean;
+ isBillingEnabled: boolean;
+ stripeEntitlementValue: boolean;
+}): boolean =>
+ hasValidEnterprisePlan && (!isBillingEnabled || stripeEntitlementValue);
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/constants/operator-only-spender-types.constant.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/constants/operator-only-spender-types.constant.ts
deleted file mode 100644
index 7d2f0a68621..00000000000
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/constants/operator-only-spender-types.constant.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { type SpenderType } from 'src/engine/core-modules/usage-limit/types/spender-type.type';
-
-export const OPERATOR_ONLY_SPENDER_TYPES: SpenderType[] = ['workspace'];
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/exceptions/usage-limit.exception.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/exceptions/usage-limit.exception.ts
index 95bf031d24a..9f9cc2dbc97 100644
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/exceptions/usage-limit.exception.ts
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/exceptions/usage-limit.exception.ts
@@ -10,6 +10,7 @@ export enum UsageLimitExceptionCode {
RATE_LIMITED = 'RATE_LIMITED',
QUOTA_EXHAUSTED = 'QUOTA_EXHAUSTED',
LIMIT_INVALID = 'LIMIT_INVALID',
+ LIMIT_NOT_ENTITLED = 'LIMIT_NOT_ENTITLED',
}
const getUsageLimitExceptionUserFriendlyMessage = (
@@ -22,6 +23,8 @@ const getUsageLimitExceptionUserFriendlyMessage = (
return msg`Usage quota exhausted for this period.`;
case UsageLimitExceptionCode.LIMIT_INVALID:
return msg`This limit cannot be saved.`;
+ case UsageLimitExceptionCode.LIMIT_NOT_ENTITLED:
+ return msg`Limits scoped below the workspace require the Organization plan.`;
default:
assertUnreachable(code);
}
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/filters/__tests__/usage-limit-graphql-api-exception.filter.spec.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/filters/__tests__/usage-limit-graphql-api-exception.filter.spec.ts
index cae4db2d426..a424e7f7fdb 100644
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/filters/__tests__/usage-limit-graphql-api-exception.filter.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/filters/__tests__/usage-limit-graphql-api-exception.filter.spec.ts
@@ -35,6 +35,17 @@ describe('UsageLimitGraphqlApiExceptionFilter', () => {
);
});
+ it('surfaces a not-entitled limit as a forbidden error', () => {
+ const graphqlError = catchAsGraphQLError(
+ new UsageLimitException(
+ 'Intra-workspace usage limits require the Organization plan',
+ UsageLimitExceptionCode.LIMIT_NOT_ENTITLED,
+ ),
+ );
+
+ expect(graphqlError.extensions.code).toBe(ErrorCode.FORBIDDEN);
+ });
+
it('surfaces an exhausted quota through the shared enforcement mapping', () => {
const graphqlError = catchAsGraphQLError(
new UsageLimitException(
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/filters/usage-limit-graphql-api-exception.filter.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/filters/usage-limit-graphql-api-exception.filter.ts
index b927f53d91b..1422d62786a 100644
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/filters/usage-limit-graphql-api-exception.filter.ts
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/filters/usage-limit-graphql-api-exception.filter.ts
@@ -2,7 +2,10 @@ import { Catch, type ExceptionFilter } from '@nestjs/common';
import { assertUnreachable } from 'twenty-shared/utils';
-import { UserInputError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+import {
+ ForbiddenError,
+ UserInputError,
+} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
import {
UsageLimitException,
UsageLimitExceptionCode,
@@ -15,6 +18,8 @@ export class UsageLimitGraphqlApiExceptionFilter implements ExceptionFilter {
switch (exception.code) {
case UsageLimitExceptionCode.LIMIT_INVALID:
throw new UserInputError(exception);
+ case UsageLimitExceptionCode.LIMIT_NOT_ENTITLED:
+ throw new ForbiddenError(exception);
case UsageLimitExceptionCode.RATE_LIMITED:
case UsageLimitExceptionCode.QUOTA_EXHAUSTED:
return usageLimitToGraphqlApiExceptionHandler(exception);
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/interfaces/usage-limit-entitlement-provider.service.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/interfaces/usage-limit-entitlement-provider.service.ts
new file mode 100644
index 00000000000..11abcab6986
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/interfaces/usage-limit-entitlement-provider.service.ts
@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export abstract class UsageLimitEntitlementProvider {
+ abstract hasIntraWorkspaceLimitEntitlement(
+ workspaceId: string,
+ ): Promise<boolean>;
+}
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/services/__tests__/usage-limit-quota.service.spec.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/services/__tests__/usage-limit-quota.service.spec.ts
index 98cfd1bd254..8df3cd09e7e 100644
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/services/__tests__/usage-limit-quota.service.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/services/__tests__/usage-limit-quota.service.spec.ts
@@ -13,6 +13,8 @@ import {
UsageLimitExceptionCode,
} from 'src/engine/core-modules/usage-limit/exceptions/usage-limit.exception';
import { CreditAllowanceProvider } from 'src/engine/core-modules/usage-limit/interfaces/credit-allowance-provider.service';
+import { UsageLimitEntitlementProvider } from 'src/engine/core-modules/usage-limit/interfaces/usage-limit-entitlement-provider.service';
+import { UsageLimitEntitlementService } from 'src/engine/core-modules/usage-limit/services/usage-limit-entitlement.service';
import { UsageLimitQuotaService } from 'src/engine/core-modules/usage-limit/services/usage-limit-quota.service';
import { type FlatUsageLimit } from 'src/engine/core-modules/usage-limit/types/flat-usage-limit.type';
import { type UsageLimitCounterScope } from 'src/engine/core-modules/usage-limit/types/usage-limit-counter-scope.type';
@@ -45,6 +47,10 @@ class TestCreditAllowanceProvider extends CreditAllowanceProvider {
getCreditAllowance = jest.fn().mockResolvedValue(null);
}
+class TestUsageLimitEntitlementProvider extends UsageLimitEntitlementProvider {
+ hasIntraWorkspaceLimitEntitlement = jest.fn();
+}
+
const buildLimitCounterScope = (
overrides: Partial<UsageLimitCounterScope> = {},
): UsageLimitCounterScope => ({
@@ -77,12 +83,13 @@ const buildLimit = (overrides: Partial<FlatUsageLimit>): FlatUsageLimit => ({
describe('UsageLimitQuotaService', () => {
let service: UsageLimitQuotaService;
let creditAllowanceProvider: TestCreditAllowanceProvider;
+ let entitlementProvider: TestUsageLimitEntitlementProvider;
const cacheStorage = {
mget: jest.fn().mockResolvedValue([]),
mset: jest.fn().mockResolvedValue(undefined),
runScript: jest.fn().mockResolvedValue([]),
- del: jest.fn().mockResolvedValue(undefined),
+ mdel: jest.fn().mockResolvedValue(undefined),
};
const workspaceCacheService = {
@@ -140,6 +147,10 @@ describe('UsageLimitQuotaService', () => {
beforeEach(async () => {
jest.clearAllMocks();
creditAllowanceProvider = new TestCreditAllowanceProvider();
+ entitlementProvider = new TestUsageLimitEntitlementProvider();
+ entitlementProvider.hasIntraWorkspaceLimitEntitlement.mockResolvedValue(
+ true,
+ );
cacheStorage.mget.mockResolvedValue([]);
cacheStorage.runScript.mockResolvedValue([]);
clickHouseService.selectOrThrow.mockResolvedValue([]);
@@ -154,6 +165,7 @@ describe('UsageLimitQuotaService', () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
UsageLimitQuotaService,
+ UsageLimitEntitlementService,
{
provide: CacheStorageNamespace.EngineUsageLimit,
useValue: cacheStorage,
@@ -165,7 +177,10 @@ describe('UsageLimitQuotaService', () => {
{
provide: DiscoveryService,
useValue: {
- getProviders: () => [{ instance: creditAllowanceProvider }],
+ getProviders: () => [
+ { instance: creditAllowanceProvider },
+ { instance: entitlementProvider },
+ ],
},
},
],
@@ -173,6 +188,7 @@ describe('UsageLimitQuotaService', () => {
service = module.get<UsageLimitQuotaService>(UsageLimitQuotaService);
service.onModuleInit();
+ module.get(UsageLimitEntitlementService).onModuleInit();
});
it('admits on a warm counter with budget left', async () => {
@@ -379,24 +395,127 @@ describe('UsageLimitQuotaService', () => {
expect(exhausted).toEqual([]);
});
+ describe('intra-workspace limit entitlement', () => {
+ it('does not check entitlement when only workspace-scope quota rows exist', async () => {
+ setLimits([buildLimit({})]);
+ cacheStorage.mget.mockResolvedValue([250]);
+
+ await assertQuotaNotExhausted();
+
+ expect(
+ entitlementProvider.hasIntraWorkspaceLimitEntitlement,
+ ).not.toHaveBeenCalled();
+ });
+
+ it('enforces only workspace-scope quota rows when not entitled', async () => {
+ entitlementProvider.hasIntraWorkspaceLimitEntitlement.mockResolvedValue(
+ false,
+ );
+ setLimits([
+ buildLimit({ id: 'ws' }),
+ buildLimit({ id: 'uw', spenderType: 'userWorkspace' }),
+ ]);
+ cacheStorage.mget.mockResolvedValue([250]);
+
+ await assertQuotaNotExhausted();
+
+ expect(cacheStorage.mget.mock.calls[0][0]).toHaveLength(1);
+ });
+
+ it('enforces intra-workspace quota rows when entitled', async () => {
+ setLimits([
+ buildLimit({ id: 'ws' }),
+ buildLimit({ id: 'uw', spenderType: 'userWorkspace' }),
+ ]);
+ cacheStorage.mget.mockResolvedValue([250, 250]);
+
+ await assertQuotaNotExhausted();
+
+ expect(cacheStorage.mget.mock.calls[0][0]).toHaveLength(2);
+ });
+ });
+
describe('dropAllowanceCounter', () => {
it('drops the counter keyed by the current period', async () => {
setAllowance(2_000_000);
await service.dropAllowanceCounter('workspace-1');
- expect(cacheStorage.del).toHaveBeenCalledWith(
+ expect(cacheStorage.mdel).toHaveBeenCalledWith([
buildAllowanceCounterKey({
workspaceId: 'workspace-1',
periodStart: ALLOWANCE_PERIOD.periodStart,
}),
- );
+ ]);
});
it('does nothing when no allowance exists', async () => {
await service.dropAllowanceCounter('workspace-1');
- expect(cacheStorage.del).not.toHaveBeenCalled();
+ expect(cacheStorage.mdel).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('dropIntraWorkspaceLimitCounters', () => {
+ it('drops every intra-workspace quota counter under the warm lock', async () => {
+ setLimits([
+ buildLimit({ id: 'workspace-month' }),
+ buildLimit({
+ id: 'member-month',
+ spenderType: 'userWorkspace',
+ spenderId: 'user-1',
+ }),
+ buildLimit({
+ id: 'agent-week',
+ spenderType: 'agent',
+ periodUnit: 'week',
+ }),
+ buildLimit({
+ id: 'member-speed',
+ spenderType: 'userWorkspace',
+ limitKind: 'speed',
+ periodUnit: 'second',
+ meter: 'quantity',
+ }),
+ ]);
+
+ await service.dropIntraWorkspaceLimitCounters('workspace-1');
+
+ expect(cacheLockService.withLock).toHaveBeenCalledWith(
+ expect.any(Function),
+ buildQuotaWarmLockKey('workspace-1'),
+ expect.anything(),
+ );
+ expect(cacheStorage.mdel).toHaveBeenCalledWith([
+ buildQuotaCounterKey({
+ workspaceId: 'workspace-1',
+ resourceType: UsageResourceType.AI,
+ operationType: UsageOperationType.AI_CHAT_TOKEN,
+ spenderType: 'userWorkspace',
+ spenderId: 'user-1',
+ meter: 'creditsUsedMicro',
+ periodUnit: 'month',
+ periodStart: MONTH_PERIOD.periodStart,
+ }),
+ buildQuotaCounterKey({
+ workspaceId: 'workspace-1',
+ resourceType: UsageResourceType.AI,
+ operationType: UsageOperationType.AI_CHAT_TOKEN,
+ spenderType: 'agent',
+ spenderId: '',
+ meter: 'creditsUsedMicro',
+ periodUnit: 'week',
+ periodStart: WEEK_PERIOD.periodStart,
+ }),
+ ]);
+ });
+
+ it('does nothing when the workspace only has workspace-scoped limits', async () => {
+ setLimits([buildLimit({})]);
+
+ await service.dropIntraWorkspaceLimitCounters('workspace-1');
+
+ expect(cacheStorage.mdel).not.toHaveBeenCalled();
});
});
@@ -409,7 +528,7 @@ describe('UsageLimitQuotaService', () => {
buildQuotaWarmLockKey('workspace-1'),
expect.anything(),
);
- expect(cacheStorage.del).toHaveBeenCalledWith(
+ expect(cacheStorage.mdel).toHaveBeenCalledWith([
buildQuotaCounterKey({
workspaceId: 'workspace-1',
resourceType: UsageResourceType.AI,
@@ -420,7 +539,7 @@ describe('UsageLimitQuotaService', () => {
periodUnit: 'month',
periodStart: MONTH_PERIOD.periodStart,
}),
- );
+ ]);
});
it('ignores a speed limit', async () => {
@@ -428,7 +547,7 @@ describe('UsageLimitQuotaService', () => {
buildLimitCounterScope({ limitKind: 'speed', periodUnit: 'second' }),
);
- expect(cacheStorage.del).not.toHaveBeenCalled();
+ expect(cacheStorage.mdel).not.toHaveBeenCalled();
});
it('dels without the lock when acquiring it times out', async () => {
@@ -441,7 +560,7 @@ describe('UsageLimitQuotaService', () => {
await service.dropLimitCounter(buildLimitCounterScope());
- expect(cacheStorage.del).toHaveBeenCalledTimes(1);
+ expect(cacheStorage.mdel).toHaveBeenCalledTimes(1);
});
});
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/services/__tests__/usage-limit-speed.service.spec.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/services/__tests__/usage-limit-speed.service.spec.ts
index 153d4b36d1e..5c8ed119616 100644
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/services/__tests__/usage-limit-speed.service.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/services/__tests__/usage-limit-speed.service.spec.ts
@@ -1,3 +1,4 @@
+import { DiscoveryService } from '@nestjs/core';
import { Test, type TestingModule } from '@nestjs/testing';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
@@ -7,7 +8,10 @@ import {
} from 'src/engine/core-modules/cache-storage/exceptions/cache-storage.exception';
import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
+import { UsageLimitEntitlementProvider } from 'src/engine/core-modules/usage-limit/interfaces/usage-limit-entitlement-provider.service';
+import { UsageLimitEntitlementService } from 'src/engine/core-modules/usage-limit/services/usage-limit-entitlement.service';
import { UsageLimitSpeedService } from 'src/engine/core-modules/usage-limit/services/usage-limit-speed.service';
+import { type FlatUsageLimit } from 'src/engine/core-modules/usage-limit/types/flat-usage-limit.type';
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 {
@@ -22,8 +26,30 @@ const apiKeyContext = {
apiKey: { id: 'key-1' },
} as WorkspaceAuthContext;
+class TestUsageLimitEntitlementProvider extends UsageLimitEntitlementProvider {
+ hasIntraWorkspaceLimitEntitlement = jest.fn();
+}
+
+const API_KEY_OVERRIDE_BUCKET_KEY =
+ '{workspace-1}:speed:API:API_REQUEST:apiKey:key-1:60';
+
+const buildApiKeySpeedLimit = (): FlatUsageLimit => ({
+ id: 'speed-1',
+ resourceType: UsageResourceType.API,
+ operationType: UsageOperationType.API_REQUEST,
+ spenderType: 'apiKey',
+ spenderId: 'key-1',
+ limitKind: 'speed',
+ periodCount: 60,
+ periodUnit: 'second',
+ meter: 'quantity',
+ limitValue: 100,
+ burstValue: null,
+});
+
describe('UsageLimitSpeedService', () => {
let service: UsageLimitSpeedService;
+ let entitlementProvider: TestUsageLimitEntitlementProvider;
const cacheStorage = {
runScript: jest.fn().mockResolvedValue([1, 0, 0]),
@@ -48,20 +74,32 @@ describe('UsageLimitSpeedService', () => {
beforeEach(async () => {
jest.clearAllMocks();
+ entitlementProvider = new TestUsageLimitEntitlementProvider();
+ entitlementProvider.hasIntraWorkspaceLimitEntitlement.mockResolvedValue(
+ true,
+ );
const module: TestingModule = await Test.createTestingModule({
providers: [
UsageLimitSpeedService,
+ UsageLimitEntitlementService,
{
provide: CacheStorageNamespace.EngineUsageLimit,
useValue: cacheStorage,
},
{ provide: WorkspaceCacheService, useValue: workspaceCacheService },
{ provide: TwentyConfigService, useValue: twentyConfigService },
+ {
+ provide: DiscoveryService,
+ useValue: {
+ getProviders: () => [{ instance: entitlementProvider }],
+ },
+ },
],
}).compile();
service = module.get<UsageLimitSpeedService>(UsageLimitSpeedService);
+ module.get(UsageLimitEntitlementService).onModuleInit();
});
it('admits the request when the limits cannot be read from storage', async () => {
@@ -100,4 +138,27 @@ describe('UsageLimitSpeedService', () => {
await expect(consume()).rejects.toThrow(/Rate limit exceeded/);
});
+
+ it('enforces a stored apiKey speed override only when the workspace is entitled', async () => {
+ workspaceCacheService.getOrRecompute.mockResolvedValue({
+ usageLimits: {
+ byResourceType: { [UsageResourceType.API]: [buildApiKeySpeedLimit()] },
+ },
+ });
+
+ await consume();
+ const entitledKeys: string[] = cacheStorage.runScript.mock.calls[0][0].keys;
+
+ entitlementProvider.hasIntraWorkspaceLimitEntitlement.mockResolvedValue(
+ false,
+ );
+ await consume();
+ const notEntitledKeys: string[] =
+ cacheStorage.runScript.mock.calls[1][0].keys;
+
+ expect(entitledKeys).toContain(API_KEY_OVERRIDE_BUCKET_KEY);
+ expect(notEntitledKeys).toEqual(
+ entitledKeys.filter((key) => key !== API_KEY_OVERRIDE_BUCKET_KEY),
+ );
+ });
});
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-entitlement.service.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-entitlement.service.ts
new file mode 100644
index 00000000000..acc5860bbfb
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-entitlement.service.ts
@@ -0,0 +1,58 @@
+import { Injectable, Logger, type OnModuleInit } from '@nestjs/common';
+import { DiscoveryService } from '@nestjs/core';
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { type UsageLimitEntitlementProvider } from 'src/engine/core-modules/usage-limit/interfaces/usage-limit-entitlement-provider.service';
+import { type FlatUsageLimit } from 'src/engine/core-modules/usage-limit/types/flat-usage-limit.type';
+import { findEnforceableLimits } from 'src/engine/core-modules/usage-limit/utils/find-enforceable-limits.util';
+import { findUsageLimitEntitlementProvider } from 'src/engine/core-modules/usage-limit/utils/find-usage-limit-entitlement-provider.util';
+import { isIntraWorkspaceScoped } from 'src/engine/core-modules/usage-limit/utils/is-intra-workspace-scoped.util';
+
+@Injectable()
+export class UsageLimitEntitlementService implements OnModuleInit {
+ private readonly logger = new Logger(UsageLimitEntitlementService.name);
+
+ private entitlementProvider: UsageLimitEntitlementProvider | null = null;
+
+ constructor(private readonly discoveryService: DiscoveryService) {}
+
+ onModuleInit() {
+ this.entitlementProvider = findUsageLimitEntitlementProvider(
+ this.discoveryService,
+ );
+ }
+
+ async isIntraWorkspaceLimitEntitled(workspaceId: string): Promise<boolean> {
+ return isDefined(this.entitlementProvider)
+ ? this.entitlementProvider.hasIntraWorkspaceLimitEntitlement(workspaceId)
+ : true;
+ }
+
+ async findEnforceableLimits({
+ workspaceId,
+ limits,
+ }: {
+ workspaceId: string;
+ limits: FlatUsageLimit[];
+ }): Promise<FlatUsageLimit[]> {
+ if (!limits.some((limit) => isIntraWorkspaceScoped(limit.spenderType))) {
+ return limits;
+ }
+
+ try {
+ return findEnforceableLimits({
+ limits,
+ isIntraWorkspaceLimitEntitled:
+ await this.isIntraWorkspaceLimitEntitled(workspaceId),
+ });
+ } catch (error) {
+ // Enforcement fails open: an entitlement outage must not drop configured limits
+ this.logger.warn(
+ `Could not read the intra-workspace limit entitlement for workspace ${workspaceId}, enforcing every stored limit: ${error instanceof Error ? error.message : 'unknown error'}`,
+ );
+
+ return limits;
+ }
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-quota.service.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-quota.service.ts
index 6166eab4fe9..cbdc04416f2 100644
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-quota.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-quota.service.ts
@@ -20,6 +20,7 @@ import {
UsageLimitExceptionCode,
} from 'src/engine/core-modules/usage-limit/exceptions/usage-limit.exception';
import { CreditAllowanceProvider } from 'src/engine/core-modules/usage-limit/interfaces/credit-allowance-provider.service';
+import { UsageLimitEntitlementService } from 'src/engine/core-modules/usage-limit/services/usage-limit-entitlement.service';
import { type ExhaustedScope } from 'src/engine/core-modules/usage-limit/types/exhausted-scope.type';
import { type FlatUsageLimit } from 'src/engine/core-modules/usage-limit/types/flat-usage-limit.type';
import { type PeriodUnit } from 'src/engine/core-modules/usage-limit/types/period-unit.type';
@@ -31,6 +32,7 @@ import { type QuotaCost } from 'src/engine/core-modules/usage-limit/types/quota-
import { type QuotaCounter } from 'src/engine/core-modules/usage-limit/types/quota-counter.type';
import { type UsageLimitCounterScope } from 'src/engine/core-modules/usage-limit/types/usage-limit-counter-scope.type';
import { buildAllowanceCounterKey } from 'src/engine/core-modules/usage-limit/utils/build-allowance-counter-key.util';
+import { buildIntraWorkspaceLimitCounterKeys } from 'src/engine/core-modules/usage-limit/utils/build-intra-workspace-limit-counter-keys.util';
import { buildLimitWarmedEntries } from 'src/engine/core-modules/usage-limit/utils/build-limit-warmed-entries.util';
import { buildPeriodGroupKey } from 'src/engine/core-modules/usage-limit/utils/build-period-group-key.util';
import { buildQuotaCounterKey } from 'src/engine/core-modules/usage-limit/utils/build-quota-counter-key.util';
@@ -77,6 +79,7 @@ export class UsageLimitQuotaService implements OnModuleInit {
private readonly clickHouseService: ClickHouseService,
private readonly usagePeriodService: UsagePeriodService,
private readonly discoveryService: DiscoveryService,
+ private readonly usageLimitEntitlementService: UsageLimitEntitlementService,
) {}
onModuleInit() {
@@ -133,11 +136,31 @@ export class UsageLimitQuotaService implements OnModuleInit {
await this.delUnderWarmLock({
workspaceId,
- key: buildAllowanceCounterKey({
- workspaceId,
- periodStart: period.periodStart,
- }),
+ keys: [
+ buildAllowanceCounterKey({
+ workspaceId,
+ periodStart: period.periodStart,
+ }),
+ ],
+ });
+ }
+
+ // Intra-workspace counters are not debited while the entitlement is off, so
+ // a warm balance misses that usage; dropping them forces a ClickHouse rewarm.
+ async dropIntraWorkspaceLimitCounters(workspaceId: string): Promise<void> {
+ const limits = await this.findAllLimits(workspaceId);
+
+ const keys = buildIntraWorkspaceLimitCounterKeys({
+ workspaceId,
+ limits,
+ periodByUnit: this.getCurrentPeriodsByUnit(limits),
});
+
+ if (keys.length === 0) {
+ return;
+ }
+
+ await this.delUnderWarmLock({ workspaceId, keys });
}
async dropLimitCounter(usageLimit: UsageLimitCounterScope): Promise<void> {
@@ -154,16 +177,18 @@ export class UsageLimitQuotaService implements OnModuleInit {
await this.delUnderWarmLock({
workspaceId: usageLimit.workspaceId,
- key: buildQuotaCounterKey({
- workspaceId: usageLimit.workspaceId,
- resourceType: usageLimit.resourceType,
- operationType: usageLimit.operationType,
- spenderType: usageLimit.spenderType,
- spenderId: usageLimit.spenderId,
- meter: usageLimit.meter,
- periodUnit: usageLimit.periodUnit,
- periodStart: period.periodStart,
- }),
+ keys: [
+ buildQuotaCounterKey({
+ workspaceId: usageLimit.workspaceId,
+ resourceType: usageLimit.resourceType,
+ operationType: usageLimit.operationType,
+ spenderType: usageLimit.spenderType,
+ spenderId: usageLimit.spenderId,
+ meter: usageLimit.meter,
+ periodUnit: usageLimit.periodUnit,
+ periodStart: period.periodStart,
+ }),
+ ],
});
}
@@ -190,14 +215,14 @@ export class UsageLimitQuotaService implements OnModuleInit {
private async delUnderWarmLock({
workspaceId,
- key,
+ keys,
}: {
workspaceId: string;
- key: string;
+ keys: string[];
}): Promise<void> {
try {
await this.cacheLockService.withLock(
- () => this.cacheStorage.del(key),
+ () => this.cacheStorage.mdel(keys),
buildQuotaWarmLockKey(workspaceId),
QUOTA_WARM_LOCK_OPTIONS,
);
@@ -210,13 +235,24 @@ export class UsageLimitQuotaService implements OnModuleInit {
}
this.logger.warn(
- `Dropping quota counter ${key} without the warm lock: ${error.message}`,
+ `Dropping quota counters ${keys.join(', ')} without the warm lock: ${error.message}`,
);
- await this.cacheStorage.del(key);
+ await this.cacheStorage.mdel(keys);
}
}
+ private async findAllLimits(workspaceId: string): Promise<FlatUsageLimit[]> {
+ const { usageLimits } = await this.workspaceCacheService.getOrRecompute(
+ workspaceId,
+ ['usageLimits'],
+ );
+
+ return Object.values(usageLimits.byResourceType).flatMap(
+ (limits) => limits ?? [],
+ );
+ }
+
private async findExhaustedScopesAdmittingOnFailure(
args: QuotaConsumeArgs,
): Promise<ExhaustedScope[]> {
@@ -468,9 +504,14 @@ export class UsageLimitQuotaService implements OnModuleInit {
['usageLimits'],
);
- return (usageLimits.byResourceType[resourceType] ?? []).filter(
+ const quotaLimits = (usageLimits.byResourceType[resourceType] ?? []).filter(
(limit) => limit.limitKind === 'quota',
);
+
+ return this.usageLimitEntitlementService.findEnforceableLimits({
+ workspaceId,
+ limits: quotaLimits,
+ });
}
private async readRemainings({
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-speed.service.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-speed.service.ts
index 66eea6c816a..18541b2479b 100644
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-speed.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit-speed.service.ts
@@ -13,6 +13,7 @@ import {
UsageLimitException,
UsageLimitExceptionCode,
} from 'src/engine/core-modules/usage-limit/exceptions/usage-limit.exception';
+import { UsageLimitEntitlementService } from 'src/engine/core-modules/usage-limit/services/usage-limit-entitlement.service';
import { type FlatUsageLimit } from 'src/engine/core-modules/usage-limit/types/flat-usage-limit.type';
import { type SpeedBucketOutcome } from 'src/engine/core-modules/usage-limit/types/speed-bucket-outcome.type';
import { type SpeedBucketRequest } from 'src/engine/core-modules/usage-limit/types/speed-bucket-request.type';
@@ -35,6 +36,7 @@ export class UsageLimitSpeedService {
private readonly cacheStorage: CacheStorageService,
private readonly workspaceCacheService: WorkspaceCacheService,
private readonly twentyConfigService: TwentyConfigService,
+ private readonly usageLimitEntitlementService: UsageLimitEntitlementService,
) {}
async consumeOrThrow({
@@ -179,6 +181,12 @@ export class UsageLimitSpeedService {
return [];
}
+ const enforceableLimits =
+ await this.usageLimitEntitlementService.findEnforceableLimits({
+ workspaceId: authContext.workspace.id,
+ limits,
+ });
+
return buildSpeedBuckets({
speedLimitDefaults: definition.defaults.map(
(speedLimitDefaultDefinition) => ({
@@ -193,7 +201,7 @@ export class UsageLimitSpeedService {
),
}),
),
- limits,
+ limits: enforceableLimits,
authContext,
resourceType,
operationType,
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit.service.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit.service.ts
index 0d25816f9d0..9f874380984 100644
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/services/usage-limit.service.ts
@@ -10,9 +10,11 @@ import {
UsageLimitException,
UsageLimitExceptionCode,
} from 'src/engine/core-modules/usage-limit/exceptions/usage-limit.exception';
+import { UsageLimitEntitlementService } from 'src/engine/core-modules/usage-limit/services/usage-limit-entitlement.service';
import { UsageLimitQuotaService } from 'src/engine/core-modules/usage-limit/services/usage-limit-quota.service';
import { type SpenderType } from 'src/engine/core-modules/usage-limit/types/spender-type.type';
import { UsageLimitEntity } from 'src/engine/core-modules/usage-limit/usage-limit.entity';
+import { isIntraWorkspaceScoped } from 'src/engine/core-modules/usage-limit/utils/is-intra-workspace-scoped.util';
import { validateUsageLimitAgainstDefinition } from 'src/engine/core-modules/usage-limit/utils/validate-usage-limit-against-definition.util';
import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
import { AgentEntity } from 'src/engine/metadata-modules/ai/ai-agent/entities/agent.entity';
@@ -38,6 +40,7 @@ export class UsageLimitService {
private readonly logicFunctionRepository: WorkspaceScopedRepository<LogicFunctionEntity>,
private readonly workspaceCacheService: WorkspaceCacheService,
private readonly usageLimitQuotaService: UsageLimitQuotaService,
+ private readonly usageLimitEntitlementService: UsageLimitEntitlementService,
) {}
async findAll(workspaceId: string): Promise<UsageLimitEntity[]> {
@@ -53,6 +56,18 @@ export class UsageLimitService {
}): Promise<UsageLimitEntity> {
validateUsageLimitAgainstDefinition(input);
+ if (
+ isIntraWorkspaceScoped(input.spenderType) &&
+ !(await this.usageLimitEntitlementService.isIntraWorkspaceLimitEntitled(
+ workspaceId,
+ ))
+ ) {
+ throw new UsageLimitException(
+ 'Intra-workspace usage limits require the Organization plan',
+ UsageLimitExceptionCode.LIMIT_NOT_ENTITLED,
+ );
+ }
+
if (isNonEmptyString(input.spenderId)) {
await this.validateSpenderBelongsToWorkspace({
workspaceId,
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/usage-limit.module.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/usage-limit.module.ts
index db5528130d1..d0decb24947 100644
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/usage-limit.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/usage-limit.module.ts
@@ -12,6 +12,7 @@ import { ApplicationEntity } from 'src/engine/core-modules/application/applicati
import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
import { AgentEntity } from 'src/engine/metadata-modules/ai/ai-agent/entities/agent.entity';
import { LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import { UsageLimitEntitlementService } from 'src/engine/core-modules/usage-limit/services/usage-limit-entitlement.service';
import { UsageLimitSpeedService } from 'src/engine/core-modules/usage-limit/services/usage-limit-speed.service';
import { UsageLimitResolver } from 'src/engine/core-modules/usage-limit/usage-limit.resolver';
import { UsageLimitService } from 'src/engine/core-modules/usage-limit/services/usage-limit.service';
@@ -41,6 +42,7 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
providers: [
UsageLimitQuotaService,
UsageLimitSpeedService,
+ UsageLimitEntitlementService,
UsageLimitsCacheService,
UsagePeriodService,
UsageLimitService,
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/utils/__tests__/build-intra-workspace-limit-counter-keys.util.spec.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/__tests__/build-intra-workspace-limit-counter-keys.util.spec.ts
new file mode 100644
index 00000000000..d1d07d8484b
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/__tests__/build-intra-workspace-limit-counter-keys.util.spec.ts
@@ -0,0 +1,79 @@
+import { type FlatUsageLimit } from 'src/engine/core-modules/usage-limit/types/flat-usage-limit.type';
+import { buildIntraWorkspaceLimitCounterKeys } from 'src/engine/core-modules/usage-limit/utils/build-intra-workspace-limit-counter-keys.util';
+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';
+
+const MONTH_PERIOD = {
+ periodStart: new Date('2026-08-01T00:00:00.000Z'),
+ periodEnd: new Date('2026-09-01T00:00:00.000Z'),
+};
+
+const WEEK_PERIOD = {
+ periodStart: new Date('2026-08-24T00:00:00.000Z'),
+ periodEnd: new Date('2026-08-31T00:00:00.000Z'),
+};
+
+const buildLimit = (overrides: Partial<FlatUsageLimit>): FlatUsageLimit => ({
+ id: 'limit-1',
+ resourceType: UsageResourceType.AI,
+ operationType: UsageOperationType.ALL,
+ spenderType: 'userWorkspace',
+ spenderId: '',
+ limitKind: 'quota',
+ periodCount: 1,
+ periodUnit: 'month',
+ meter: 'creditsUsedMicro',
+ limitValue: 1_000,
+ burstValue: null,
+ ...overrides,
+});
+
+describe('buildIntraWorkspaceLimitCounterKeys', () => {
+ it('keys every intra-workspace quota on its period unit', () => {
+ expect(
+ buildIntraWorkspaceLimitCounterKeys({
+ workspaceId: 'workspace-1',
+ limits: [
+ buildLimit({}),
+ buildLimit({
+ id: 'limit-2',
+ spenderType: 'agent',
+ spenderId: 'agent-1',
+ periodUnit: 'week',
+ }),
+ ],
+ periodByUnit: { month: MONTH_PERIOD, week: WEEK_PERIOD },
+ }),
+ ).toEqual([
+ `{workspace-1}:quota:AI:ALL:userWorkspace:-:creditsUsedMicro:month:${MONTH_PERIOD.periodStart.getTime()}`,
+ `{workspace-1}:quota:AI:ALL:agent:agent-1:creditsUsedMicro:week:${WEEK_PERIOD.periodStart.getTime()}`,
+ ]);
+ });
+
+ it('leaves workspace-scoped quotas and speed limits alone', () => {
+ expect(
+ buildIntraWorkspaceLimitCounterKeys({
+ workspaceId: 'workspace-1',
+ limits: [
+ buildLimit({ spenderType: 'workspace' }),
+ buildLimit({
+ limitKind: 'speed',
+ periodUnit: 'second',
+ meter: 'quantity',
+ }),
+ ],
+ periodByUnit: { month: MONTH_PERIOD },
+ }),
+ ).toEqual([]);
+ });
+
+ it('skips a quota whose period is unknown', () => {
+ expect(
+ buildIntraWorkspaceLimitCounterKeys({
+ workspaceId: 'workspace-1',
+ limits: [buildLimit({ periodUnit: 'week' })],
+ periodByUnit: { month: MONTH_PERIOD },
+ }),
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/utils/__tests__/find-enforceable-limits.util.spec.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/__tests__/find-enforceable-limits.util.spec.ts
new file mode 100644
index 00000000000..867a0d64c27
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/__tests__/find-enforceable-limits.util.spec.ts
@@ -0,0 +1,43 @@
+import { type FlatUsageLimit } from 'src/engine/core-modules/usage-limit/types/flat-usage-limit.type';
+import { type SpenderType } from 'src/engine/core-modules/usage-limit/types/spender-type.type';
+import { findEnforceableLimits } from 'src/engine/core-modules/usage-limit/utils/find-enforceable-limits.util';
+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';
+
+const buildLimit = (spenderType: SpenderType, id: string): FlatUsageLimit => ({
+ id,
+ resourceType: UsageResourceType.API,
+ operationType: UsageOperationType.API_REQUEST,
+ spenderType,
+ spenderId: '',
+ limitKind: 'quota',
+ periodCount: 1,
+ periodUnit: 'month',
+ meter: 'quantity',
+ limitValue: 100,
+ burstValue: null,
+});
+
+describe('findEnforceableLimits', () => {
+ const workspaceLimit = buildLimit('workspace', 'ws');
+ const userWorkspaceLimit = buildLimit('userWorkspace', 'uw');
+ const apiKeyLimit = buildLimit('apiKey', 'ak');
+
+ it('keeps every limit when the workspace is entitled', () => {
+ expect(
+ findEnforceableLimits({
+ limits: [workspaceLimit, userWorkspaceLimit, apiKeyLimit],
+ isIntraWorkspaceLimitEntitled: true,
+ }),
+ ).toEqual([workspaceLimit, userWorkspaceLimit, apiKeyLimit]);
+ });
+
+ it('keeps only workspace-scope limits when not entitled', () => {
+ expect(
+ findEnforceableLimits({
+ limits: [workspaceLimit, userWorkspaceLimit, apiKeyLimit],
+ isIntraWorkspaceLimitEntitled: false,
+ }),
+ ).toEqual([workspaceLimit]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/utils/build-intra-workspace-limit-counter-keys.util.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/build-intra-workspace-limit-counter-keys.util.ts
new file mode 100644
index 00000000000..5901cbc43de
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/build-intra-workspace-limit-counter-keys.util.ts
@@ -0,0 +1,43 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type FlatUsageLimit } from 'src/engine/core-modules/usage-limit/types/flat-usage-limit.type';
+import { type PeriodUnit } from 'src/engine/core-modules/usage-limit/types/period-unit.type';
+import { type UsagePeriod } from 'src/engine/core-modules/usage-limit/types/usage-period.type';
+import { buildQuotaCounterKey } from 'src/engine/core-modules/usage-limit/utils/build-quota-counter-key.util';
+import { isIntraWorkspaceScoped } from 'src/engine/core-modules/usage-limit/utils/is-intra-workspace-scoped.util';
+
+export const buildIntraWorkspaceLimitCounterKeys = ({
+ workspaceId,
+ limits,
+ periodByUnit,
+}: {
+ workspaceId: string;
+ limits: FlatUsageLimit[];
+ periodByUnit: Partial<Record<PeriodUnit, UsagePeriod>>;
+}): string[] =>
+ limits
+ .filter(
+ (limit) =>
+ limit.limitKind === 'quota' &&
+ isIntraWorkspaceScoped(limit.spenderType),
+ )
+ .flatMap((limit) => {
+ const period = periodByUnit[limit.periodUnit];
+
+ if (!isDefined(period)) {
+ return [];
+ }
+
+ return [
+ buildQuotaCounterKey({
+ workspaceId,
+ resourceType: limit.resourceType,
+ operationType: limit.operationType,
+ spenderType: limit.spenderType,
+ spenderId: limit.spenderId,
+ meter: limit.meter,
+ periodUnit: limit.periodUnit,
+ periodStart: period.periodStart,
+ }),
+ ];
+ });
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-credit-allowance-provider.util.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-credit-allowance-provider.util.ts
index f9edbbf376d..1c75ec210fa 100644
--- a/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-credit-allowance-provider.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-credit-allowance-provider.util.ts
@@ -1,19 +1,12 @@
import { type DiscoveryService } from '@nestjs/core';
-import { isDefined } from 'twenty-shared/utils';
-
import { CreditAllowanceProvider } from 'src/engine/core-modules/usage-limit/interfaces/credit-allowance-provider.service';
+import { findProviderInstance } from 'src/engine/core-modules/usage-limit/utils/find-provider-instance.util';
export const findCreditAllowanceProvider = (
discoveryService: DiscoveryService,
-): CreditAllowanceProvider | null => {
- for (const wrapper of discoveryService.getProviders()) {
- const { instance } = wrapper;
-
- if (isDefined(instance) && instance instanceof CreditAllowanceProvider) {
- return instance;
- }
- }
-
- return null;
-};
+): CreditAllowanceProvider | null =>
+ findProviderInstance({
+ discoveryService,
+ providerClass: CreditAllowanceProvider,
+ });
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-enforceable-limits.util.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-enforceable-limits.util.ts
new file mode 100644
index 00000000000..d5abefd4a10
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-enforceable-limits.util.ts
@@ -0,0 +1,13 @@
+import { type FlatUsageLimit } from 'src/engine/core-modules/usage-limit/types/flat-usage-limit.type';
+import { isIntraWorkspaceScoped } from 'src/engine/core-modules/usage-limit/utils/is-intra-workspace-scoped.util';
+
+export const findEnforceableLimits = ({
+ limits,
+ isIntraWorkspaceLimitEntitled,
+}: {
+ limits: FlatUsageLimit[];
+ isIntraWorkspaceLimitEntitled: boolean;
+}): FlatUsageLimit[] =>
+ isIntraWorkspaceLimitEntitled
+ ? limits
+ : limits.filter((limit) => !isIntraWorkspaceScoped(limit.spenderType));
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-provider-instance.util.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-provider-instance.util.ts
new file mode 100644
index 00000000000..9717cdfd675
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-provider-instance.util.ts
@@ -0,0 +1,21 @@
+import { type DiscoveryService } from '@nestjs/core';
+
+import { isDefined } from 'twenty-shared/utils';
+
+export const findProviderInstance = <TProvider>({
+ discoveryService,
+ providerClass,
+}: {
+ discoveryService: DiscoveryService;
+ providerClass: abstract new (...args: never[]) => TProvider;
+}): TProvider | null => {
+ for (const wrapper of discoveryService.getProviders()) {
+ const { instance } = wrapper;
+
+ if (isDefined(instance) && instance instanceof providerClass) {
+ return instance;
+ }
+ }
+
+ return null;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-usage-limit-entitlement-provider.util.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-usage-limit-entitlement-provider.util.ts
new file mode 100644
index 00000000000..62e59bdedbb
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/find-usage-limit-entitlement-provider.util.ts
@@ -0,0 +1,12 @@
+import { type DiscoveryService } from '@nestjs/core';
+
+import { UsageLimitEntitlementProvider } from 'src/engine/core-modules/usage-limit/interfaces/usage-limit-entitlement-provider.service';
+import { findProviderInstance } from 'src/engine/core-modules/usage-limit/utils/find-provider-instance.util';
+
+export const findUsageLimitEntitlementProvider = (
+ discoveryService: DiscoveryService,
+): UsageLimitEntitlementProvider | null =>
+ findProviderInstance({
+ discoveryService,
+ providerClass: UsageLimitEntitlementProvider,
+ });
diff --git a/packages/twenty-server/src/engine/core-modules/usage-limit/utils/is-intra-workspace-scoped.util.ts b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/is-intra-workspace-scoped.util.ts
new file mode 100644
index 00000000000..879c475c516
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/usage-limit/utils/is-intra-workspace-scoped.util.ts
@@ -0,0 +1,4 @@
+import { type SpenderType } from 'src/engine/core-modules/usage-limit/types/spender-type.type';
+
+export const isIntraWorkspaceScoped = (spenderType: SpenderType): boolean =>
+ spenderType !== 'workspace';