snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-server/test/integration/billing/utils/billing-credit-fixtures.util.ts

@@ -0,0 +1,264 @@
+import { createClient, type RedisClientType } from 'redis';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
+
+import { type BillingCreditGrantType } from 'src/engine/core-modules/billing/enums/billing-credit-grant-type.enum';
+import { type SubscriptionStatus } from 'src/engine/core-modules/billing/enums/billing-subscription-status.enum';
+import { type BillingUsageCacheService } from 'src/engine/core-modules/billing/services/billing-usage-cache.service';
+import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
+import { buildAllowanceCounterKey } from 'src/engine/core-modules/usage-limit/utils/build-allowance-counter-key.util';
+
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+
+// The dev seeder gives every workspace a billingCustomer and an active
+// billingSubscription, but no subscription item, and no period. Rollover needs
+// the whole chain — subscription -> item -> product -> price with a
+// credit_amount — so these helpers finish the fixture and put the period where
+// the test wants it.
+export const TEST_STRIPE_CUSTOMER_ID = 'cus_default0';
+export const TEST_STRIPE_SUBSCRIPTION_ID = 'sub_default0';
+
+const TEST_STRIPE_PRODUCT_ID = 'prod_resource_credit_test';
+const TEST_STRIPE_PRICE_ID = 'price_resource_credit_test';
+const TEST_STRIPE_SUBSCRIPTION_ITEM_ID = 'si_resource_credit_test';
+
+export type CreditGrantRow = {
+  id: string;
+  amountMicro: number;
+  type: BillingCreditGrantType;
+  effectiveAt: Date;
+  expiresAt: Date | null;
+  revokedAt: Date | null;
+  reason: string | null;
+  idempotencyKey: string | null;
+  sourceGrantId: string | null;
+};
+
+const query = async <T>(sql: string, params: unknown[] = []): Promise<T[]> =>
+  global.testDataSource.query(sql, params);
+
+// The billing seeds insert with orIgnore, so the customer and subscription
+// land on exactly one workspace and which one is not worth hardcoding.
+export const getSeededBillingWorkspaceId = async (): Promise<string> => {
+  const [row] = await query<{ workspaceId: string }>(
+    `SELECT "workspaceId" FROM core."billingSubscription" WHERE "stripeSubscriptionId" = $1`,
+    [TEST_STRIPE_SUBSCRIPTION_ID],
+  );
+
+  if (!row) {
+    throw new Error(
+      `No seeded billing subscription ${TEST_STRIPE_SUBSCRIPTION_ID}: the dev seeder did not run`,
+    );
+  }
+
+  return row.workspaceId;
+};
+
+export const setupResourceCreditSubscription = async ({
+  workspaceId,
+  periodStart,
+  periodEnd,
+  creditAmountMicro,
+  status = 'active',
+  trialStart = null,
+  trialEnd = null,
+}: {
+  workspaceId: string;
+  periodStart: Date;
+  periodEnd: Date;
+  creditAmountMicro: number;
+  status?: string;
+  trialStart?: Date | null;
+  trialEnd?: Date | null;
+}): Promise<{ subscriptionId: string }> => {
+  await query(
+    `UPDATE core."billingSubscription"
+     SET "currentPeriodStart" = $2, "currentPeriodEnd" = $3, status = $4,
+         "trialStart" = $5, "trialEnd" = $6, interval = 'month'
+     WHERE "workspaceId" = $1 AND "stripeSubscriptionId" = $7`,
+    [
+      workspaceId,
+      periodStart,
+      periodEnd,
+      status,
+      trialStart,
+      trialEnd,
+      TEST_STRIPE_SUBSCRIPTION_ID,
+    ],
+  );
+
+  const [subscription] = await query<{ id: string }>(
+    `SELECT id FROM core."billingSubscription"
+     WHERE "workspaceId" = $1 AND "stripeSubscriptionId" = $2`,
+    [workspaceId, TEST_STRIPE_SUBSCRIPTION_ID],
+  );
+
+  await query(
+    `INSERT INTO core."billingProduct"
+       ("stripeProductId", active, name, description, metadata)
+     VALUES ($1, true, 'Test resource credit', '', $2)
+     ON CONFLICT ("stripeProductId") DO UPDATE SET metadata = EXCLUDED.metadata`,
+    [TEST_STRIPE_PRODUCT_ID, JSON.stringify({ productKey: 'RESOURCE_CREDIT' })],
+  );
+
+  await query(
+    `INSERT INTO core."billingPrice"
+       ("stripePriceId", "stripeProductId", active, currency, "taxBehavior",
+        type, "billingScheme", "usageType", interval, "unitAmount", metadata)
+     VALUES ($1, $2, true, 'usd', 'UNSPECIFIED', 'RECURRING', 'PER_UNIT',
+             'LICENSED', 'month', 1000, $3)
+     ON CONFLICT ("stripePriceId") DO UPDATE SET metadata = EXCLUDED.metadata`,
+    [
+      TEST_STRIPE_PRICE_ID,
+      TEST_STRIPE_PRODUCT_ID,
+      JSON.stringify({ credit_amount: String(creditAmountMicro) }),
+    ],
+  );
+
+  await query(
+    `INSERT INTO core."billingSubscriptionItem"
+       ("billingSubscriptionId", "stripeSubscriptionId", "stripeProductId",
+        "stripePriceId", "stripeSubscriptionItemId", quantity)
+     VALUES ($1, $2, $3, $4, $5, 1)
+     ON CONFLICT ("stripeSubscriptionItemId") DO UPDATE
+       SET "stripePriceId" = EXCLUDED."stripePriceId",
+           "stripeProductId" = EXCLUDED."stripeProductId"`,
+    [
+      subscription.id,
+      TEST_STRIPE_SUBSCRIPTION_ID,
+      TEST_STRIPE_PRODUCT_ID,
+      TEST_STRIPE_PRICE_ID,
+      TEST_STRIPE_SUBSCRIPTION_ITEM_ID,
+    ],
+  );
+
+  return { subscriptionId: subscription.id };
+};
+
+export const insertCreditGrant = async ({
+  workspaceId,
+  amountMicro,
+  type,
+  effectiveAt,
+  expiresAt,
+  idempotencyKey = null,
+}: {
+  workspaceId: string;
+  amountMicro: number;
+  type: BillingCreditGrantType;
+  effectiveAt: Date;
+  expiresAt: Date | null;
+  idempotencyKey?: string | null;
+}): Promise<string> => {
+  const [row] = await query<{ id: string }>(
+    `INSERT INTO core."billingCreditGrant"
+       ("workspaceId", "amountMicro", type, "effectiveAt", "expiresAt", "idempotencyKey")
+     VALUES ($1, $2, $3, $4, $5, $6)
+     RETURNING id`,
+    [workspaceId, amountMicro, type, effectiveAt, expiresAt, idempotencyKey],
+  );
+
+  return row.id;
+};
+
+export const listCreditGrants = async (
+  workspaceId: string,
+): Promise<CreditGrantRow[]> =>
+  query<CreditGrantRow>(
+    `SELECT id, "amountMicro"::bigint::int AS "amountMicro", type, "effectiveAt",
+            "expiresAt", "revokedAt", reason, "idempotencyKey", "sourceGrantId"
+     FROM core."billingCreditGrant"
+     WHERE "workspaceId" = $1
+     ORDER BY "createdAt" ASC`,
+    [workspaceId],
+  );
+
+let redisClient: RedisClientType | null = null;
+
+const getRedisClient = async (): Promise<RedisClientType> => {
+  if (!isDefined(redisClient)) {
+    redisClient = createClient({ url: process.env.REDIS_URL });
+    await redisClient.connect();
+  }
+
+  return redisClient;
+};
+
+export const quitBillingFixtureRedis = async (): Promise<void> => {
+  if (isDefined(redisClient)) {
+    await redisClient.quit();
+    redisClient = null;
+  }
+};
+
+const buildTestAllowanceCounterKey = (
+  workspaceId: string,
+  periodStart: Date,
+): string =>
+  `${CacheStorageNamespace.IntegrationTests}:${CacheStorageNamespace.EngineUsageLimit}:${buildAllowanceCounterKey({ workspaceId, periodStart })}`;
+
+export const warmAllowanceCounter = async (
+  workspaceId: string,
+  periodStart: Date,
+  valueMicro: number,
+): Promise<void> => {
+  const redis = await getRedisClient();
+
+  await redis.set(
+    buildTestAllowanceCounterKey(workspaceId, periodStart),
+    String(valueMicro),
+  );
+};
+
+export const readAllowanceCounter = async (
+  workspaceId: string,
+  periodStart: Date,
+): Promise<number | null> => {
+  const redis = await getRedisClient();
+  const value = await redis.get(
+    buildTestAllowanceCounterKey(workspaceId, periodStart),
+  );
+
+  return isDefined(value) ? Number(value) : null;
+};
+
+export const resetBillingCreditState = async (
+  workspaceId: string,
+): Promise<void> => {
+  await query(
+    `DELETE FROM core."billingCreditGrant" WHERE "workspaceId" = $1`,
+    [workspaceId],
+  );
+
+  const cache = getBillingUsageCacheService();
+
+  await cache.flushAvailableCredits(workspaceId);
+  await cache.flushCounterAdjustmentMarkers(workspaceId);
+
+  const redis = await getRedisClient();
+  const staleKeys = [
+    ...(await redis.keys(`*{${workspaceId}}:quota:allowance:*`)),
+    ...(await redis.keys(`*currentBillingSubscription:${workspaceId}*`)),
+  ];
+
+  if (isNonEmptyArray(staleKeys)) {
+    await redis.del(staleKeys);
+  }
+};
+
+export const getBillingUsageCacheService = (): BillingUsageCacheService =>
+  getAppProviderByClassName<BillingUsageCacheService>(
+    'BillingUsageCacheService',
+  );
+
+// Cancelling is what makes getCurrentBillingSubscription stop returning it, so
+// this is how a test reaches the no-subscription path without deleting rows the
+// rest of the suite shares.
+export const setSubscriptionStatus = async (
+  workspaceId: string,
+  status: SubscriptionStatus,
+): Promise<void> => {
+  await query(
+    `UPDATE "core"."billingSubscription" SET status = $2 WHERE "workspaceId" = $1`,
+    [workspaceId, status],
+  );
+};

packages/twenty-server/test/integration/billing/utils/create-mock-stripe-entitlement-updated-data.util.ts

@@ -0,0 +1,25 @@
+import type Stripe from 'stripe';
+export const createMockStripeEntitlementUpdatedData = (
+  overrides = {},
+): Stripe.EntitlementsActiveEntitlementSummaryUpdatedEvent.Data => ({
+  object: {
+    object: 'entitlements.active_entitlement_summary',
+    customer: 'cus_default1',
+    livemode: false,
+    entitlements: {
+      object: 'list',
+      data: [
+        {
+          id: 'ent_test_61',
+          object: 'entitlements.active_entitlement',
+          feature: 'feat_test_61',
+          livemode: false,
+          lookup_key: 'SSO',
+        },
+      ],
+      has_more: false,
+      url: '/v1/customer/cus_Q/entitlements',
+    },
+    ...overrides,
+  },
+});

packages/twenty-server/test/integration/billing/utils/create-mock-stripe-invoice-finalized-data.util.ts

@@ -0,0 +1,60 @@
+// Typed to what the handler actually reads rather than to Stripe.Invoice: the
+// payload crosses the wire as JSON, so the runtime shape is what matters, and
+// a full Stripe.Invoice fixture would be a few hundred lines of noise.
+export type MockStripeInvoiceFinalizedData = {
+  object: {
+    id: string;
+    object: 'invoice';
+    billing_reason: string;
+    created: number;
+    customer: string;
+    period_start: number;
+    period_end: number;
+    parent: {
+      subscription_details: {
+        subscription: string;
+      };
+    };
+  };
+};
+
+const toUnixSeconds = (date: Date): number => Math.floor(date.getTime() / 1000);
+
+export const createMockStripeInvoiceFinalizedData = ({
+  periodStart,
+  periodEnd,
+  stripeCustomerId = 'cus_default0',
+  stripeSubscriptionId = 'sub_default0',
+  billingReason = 'subscription_cycle',
+  invoiceId = 'in_test_default',
+  // Stripe raises a cycle invoice at the handover, which for an advance-stamped
+  // one is the period it opens. The boundary is resolved off this rather than
+  // off our own clock, so a fixture that leaves it out no longer models the
+  // handover at all.
+  createdAt = periodStart,
+}: {
+  periodStart: Date;
+  periodEnd: Date;
+  createdAt?: Date;
+  stripeCustomerId?: string;
+  stripeSubscriptionId?: string;
+  billingReason?: string;
+  invoiceId?: string;
+}): MockStripeInvoiceFinalizedData => ({
+  object: {
+    id: invoiceId,
+    object: 'invoice',
+    billing_reason: billingReason,
+    created: toUnixSeconds(createdAt),
+    customer: stripeCustomerId,
+    // The invoice for a subscription_cycle bills the period it opens, so its
+    // period_start is the instant the previous period closed.
+    period_start: toUnixSeconds(periodStart),
+    period_end: toUnixSeconds(periodEnd),
+    parent: {
+      subscription_details: {
+        subscription: stripeSubscriptionId,
+      },
+    },
+  },
+});

packages/twenty-server/test/integration/billing/utils/create-mock-stripe-price-created-data.util.ts

@@ -0,0 +1,33 @@
+import type Stripe from 'stripe';
+export const createMockStripePriceCreatedData = (
+  overrides = {},
+): Stripe.PriceCreatedEvent.Data => ({
+  object: {
+    id: 'price_1Q',
+    object: 'price',
+    active: true,
+    billing_scheme: 'per_unit',
+    created: 1733734326,
+    currency: 'usd',
+    custom_unit_amount: null,
+    livemode: false,
+    lookup_key: null,
+    metadata: {},
+    nickname: null,
+    product: 'prod_RLN',
+    recurring: {
+      interval: 'month',
+      interval_count: 1,
+      meter: null,
+      trial_period_days: null,
+      usage_type: 'licensed',
+    },
+    tax_behavior: 'unspecified',
+    tiers_mode: null,
+    transform_quantity: null,
+    type: 'recurring',
+    unit_amount: 0,
+    unit_amount_decimal: '0',
+    ...overrides,
+  },
+});

packages/twenty-server/test/integration/billing/utils/create-mock-stripe-product-updated-data.util.ts

@@ -0,0 +1,39 @@
+import type Stripe from 'stripe';
+
+import { BillingProductKey } from 'src/engine/core-modules/billing/enums/billing-product-key.enum';
+import { BillingUsageType } from 'src/engine/core-modules/billing/enums/billing-usage-type.enum';
+
+export const createMockStripeProductUpdatedData = (
+  overrides = {},
+): Stripe.ProductUpdatedEvent.Data => ({
+  object: {
+    id: 'prod_RLN',
+    object: 'product',
+    active: true,
+    created: 1733410584,
+    default_price: null,
+    description: null,
+    images: [],
+    livemode: false,
+    marketing_features: [],
+    metadata: {
+      planKey: 'base',
+      priceUsageBased: BillingUsageType.LICENSED,
+      productKey: BillingProductKey.BASE_PRODUCT,
+    },
+    name: 'kjnnjkjknkjnjkn',
+    package_dimensions: null,
+    shippable: null,
+    statement_descriptor: null,
+    tax_code: 'txcd_10103001',
+    type: 'service',
+    unit_label: null,
+    updated: 1734694649,
+    url: null,
+  },
+  previous_attributes: {
+    default_price: 'price_1Q',
+    updated: 1733410585,
+  },
+  ...overrides,
+});

packages/twenty-server/test/integration/billing/utils/create-mock-stripe-subscription-created-data.util.ts

@@ -0,0 +1,133 @@
+import type Stripe from 'stripe';
+
+export const createMockStripeSubscriptionCreatedData = (
+  overrides = {},
+): Stripe.CustomerSubscriptionCreatedEvent.Data => ({
+  object: {
+    object: 'subscription',
+    id: 'sub_default',
+    customer: 'cus_default1',
+    customer_account: null,
+    status: 'active',
+    items: {
+      data: [
+        {
+          plan: {
+            id: 'plan_default',
+            object: 'plan',
+            active: true,
+            amount_decimal: '0',
+            billing_scheme: 'per_unit',
+            interval_count: 1,
+            livemode: false,
+            nickname: null,
+            tiers_mode: null,
+            transform_usage: null,
+            trial_period_days: null,
+            interval: 'month',
+            currency: 'usd',
+            amount: 0,
+            created: 1672531200,
+            product: 'prod_default',
+            usage_type: 'licensed',
+            metadata: {},
+            meter: null,
+          },
+          id: '',
+          object: 'subscription_item',
+          billing_thresholds: null,
+          created: 0,
+          current_period_end: 1672531200,
+          current_period_start: 1672531200,
+          discounts: [],
+          metadata: {},
+          price: {
+            id: 'price_default',
+            object: 'price',
+            active: true,
+            billing_scheme: 'per_unit',
+            created: 1672531200,
+            currency: 'usd',
+            custom_unit_amount: null,
+            livemode: false,
+            lookup_key: null,
+            metadata: {},
+            nickname: null,
+            product: 'prod_default',
+            recurring: {
+              interval: 'month',
+              interval_count: 1,
+              meter: null,
+              trial_period_days: null,
+              usage_type: 'licensed',
+            },
+            tax_behavior: null,
+            tiers_mode: null,
+            transform_quantity: null,
+            type: 'recurring',
+            unit_amount: 1000,
+            unit_amount_decimal: '1000',
+          },
+          subscription: '',
+          tax_rates: null,
+        },
+      ],
+      object: 'list',
+      has_more: false,
+      url: '',
+    },
+    cancel_at_period_end: false,
+    currency: 'usd',
+    metadata: { workspaceId: '3b8e6458-5fc1-4e63-8563-008ccddaa6db' },
+    trial_end: null,
+    trial_start: null,
+    canceled_at: null,
+    ...overrides,
+    application: null,
+    application_fee_percent: null,
+    automatic_tax: {
+      disabled_reason: null,
+      enabled: true,
+      liability: {
+        type: 'self',
+      },
+    },
+    billing_cycle_anchor: 0,
+    billing_cycle_anchor_config: null,
+    billing_mode: {
+      type: 'flexible',
+      flexible: {},
+    },
+    billing_thresholds: null,
+    cancel_at: null,
+    cancellation_details: null,
+    collection_method: 'charge_automatically',
+    created: 0,
+    days_until_due: null,
+    default_payment_method: null,
+    default_source: null,
+    description: null,
+    discounts: [],
+    ended_at: null,
+    invoice_settings: {
+      account_tax_ids: null,
+      issuer: {
+        type: 'self',
+      },
+    },
+    latest_invoice: null,
+    livemode: false,
+    next_pending_invoice_item_invoice: null,
+    on_behalf_of: null,
+    pause_collection: null,
+    payment_settings: null,
+    pending_invoice_item_interval: null,
+    pending_setup_intent: null,
+    pending_update: null,
+    schedule: null,
+    start_date: 0,
+    test_clock: null,
+    transfer_data: null,
+    trial_settings: null,
+  },
+});