The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.graphqlindex 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_DOMAINRLSAUDIT_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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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-cacheBillingUsageService,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.tsindex 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.tsindex 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/seimport { 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsdeleted file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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/applicatiimport { 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-cacheproviders: [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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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';