Merge branch 'main' into fix/discounts-on-update

Author: johnyeocx

server/src/internal/billing/v2/providers/stripe/setup/fetchStripeDiscountsForBilling.ts

@@ -65,7 +65,8 @@ export const filterDeletedCouponDiscounts = async ({
 				if (
 					error instanceof Stripe.errors.StripeError &&
 					error.code?.includes("resource_missing")
-				) return false;
+				)
+					return false;
 				throw error;
 			}
 		}),
@@ -76,8 +77,8 @@ export const filterDeletedCouponDiscounts = async ({
 
 /**
  * Fetches discounts for billing, combining existing Stripe discounts with optional param discounts.
- * Resolves param discounts via Stripe API and merges with existing subscription/customer discounts.
- * Deduplicates by coupon ID. Filters out discounts with deleted coupons.
+ * Deduplicates by coupon ID — logs and skips param discounts already on the subscription.
+ * Filters out discounts with deleted coupons.
  */
 export const fetchStripeDiscountsForBilling = async ({
 	ctx,
@@ -109,13 +110,19 @@ export const fetchStripeDiscountsForBilling = async ({
 		discounts: paramDiscounts,
 	});
 
-	// Merge with existing discounts, deduplicating by coupon ID
+	// Deduplicate by coupon ID — skip param discounts already on the subscription
 	const existingCouponIds = new Set(
 		existingDiscounts.map((d) => d.source.coupon.id),
 	);
-	const newDiscounts = resolvedParamDiscounts.filter(
-		(d) => !existingCouponIds.has(d.source.coupon.id),
-	);
+	const newDiscounts = resolvedParamDiscounts.filter((d) => {
+		if (existingCouponIds.has(d.source.coupon.id)) {
+			ctx.logger.warn(
+				`[fetchStripeDiscountsForBilling] Skipping duplicate discount ${d.source.coupon.id} — already applied to subscription`,
+			);
+			return false;
+		}
+		return true;
+	});
 
 	const allDiscounts = [...existingDiscounts, ...newDiscounts];
 	return filterDeletedCouponDiscounts({ stripeCli, discounts: allDiscounts });

server/src/queue/initWorkers.ts

@@ -25,8 +25,12 @@ const isFifoQueue = QUEUE_URL.endsWith(".fifo");
 
 // Stats tracking
 let messagesProcessed = 0;
+let totalMessagesProcessed = 0;
 let lastStatsTime = Date.now();
 
+// Process recycling — exit after processing this many messages to prevent memory leaks
+const MAX_MESSAGES_BEFORE_RECYCLE = 500_000;
+
 // Stale connection detection
 let consecutiveEmptyPolls = 0;
 let lastHeartbeatTime = Date.now();
@@ -56,8 +60,9 @@ const alertZeroMessages = () => {
 
 const logStatsAndCheckZeroMessages = () => {
 	const elapsedSeconds = ((Date.now() - lastStatsTime) / 1000).toFixed(0);
+	const mem = process.memoryUsage();
 	console.log(
-		`${logPrefix()} Processed ${messagesProcessed} messages in ${elapsedSeconds}s`,
+		`${logPrefix()} Processed ${messagesProcessed} messages in ${elapsedSeconds}s | rss=${(mem.rss / 1024 / 1024).toFixed(0)}MB heap=${(mem.heapUsed / 1024 / 1024).toFixed(0)}MB total=${totalMessagesProcessed}`,
 	);
 
 	if (messagesProcessed === 0) {
@@ -123,6 +128,7 @@ const handleSingleMessage = async ({
 
 	await processMessage({ message, db });
 	messagesProcessed++;
+	totalMessagesProcessed++;
 
 	// Return delete info (skip migration jobs - already deleted)
 	if (message.ReceiptHandle && job.name !== JobName.Migration) {
@@ -243,6 +249,20 @@ const startPollingLoop = async ({ db }: { db: DrizzleCli }) => {
 					}));
 
 				await batchDeleteMessages({ sqs, toDelete });
+
+				// Clear Sentry scope to prevent memory accumulation from breadcrumbs/tags
+				Sentry.getCurrentScope().clear();
+
+				// Recycle process to prevent memory leaks from long-running workers
+				// Exit with code 0 so cluster primary respawns a fresh worker
+				if (totalMessagesProcessed >= MAX_MESSAGES_BEFORE_RECYCLE) {
+					const mem = process.memoryUsage();
+					console.log(
+						`${logPrefix()} Recycling after ${totalMessagesProcessed} messages (rss=${(mem.rss / 1024 / 1024).toFixed(0)}MB heap=${(mem.heapUsed / 1024 / 1024).toFixed(0)}MB)`,
+					);
+					clearInterval(statsInterval);
+					process.exit(0);
+				}
 			} else {
 				const newClient = handleEmptyPoll();
 				if (newClient) sqs = newClient;

server/tests/integration/billing/attach/discounts/attach-discounts-double-use.test.ts

@@ -0,0 +1,276 @@
+/**
+ * Integration tests for duplicate discount handling across billing cycles.
+ *
+ * Tests that when a discount code already applied to a subscription is passed
+ * again on a subsequent billing cycle, it is silently ignored (not applied twice)
+ * and the attach still succeeds.
+ */
+
+import { expect, test } from "bun:test";
+import type { ApiCustomerV3 } from "@autumn/shared";
+import { expectCustomerProducts } from "@tests/integration/billing/utils/expectCustomerProductCorrect.js";
+import { hoursToFinalizeInvoice } from "@tests/utils/constants.js";
+import { items } from "@tests/utils/fixtures/items.js";
+import { products } from "@tests/utils/fixtures/products.js";
+import { advanceTestClock } from "@tests/utils/stripeUtils.js";
+import ctx from "@tests/utils/testInitUtils/createTestContext.js";
+import { initScenario, s } from "@tests/utils/testInitUtils/initScenario.js";
+import chalk from "chalk";
+import { addHours, addMonths } from "date-fns";
+import { createStripeCli } from "@/external/connect/createStripeCli.js";
+import {
+	createPercentCoupon,
+	getStripeSubscription,
+} from "../../utils/discounts/discountTestUtils.js";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 1: billing.attach - duplicate discount on next cycle is silently ignored
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Customer on free (no subscription)
+ * - Cycle 1: Attach pro WITH a 20% forever coupon → subscription created with coupon
+ * - Advance to next invoice (cycle 2)
+ * - Cycle 2: Upgrade to premium WITH same coupon → attach succeeds, duplicate ignored
+ *
+ * Expected:
+ * - No error — attach succeeds
+ * - premium is active, coupon not double-applied
+ */
+test.concurrent(`${chalk.yellowBright("attach-discount-double-use 1: billing.attach - duplicate discount on next cycle silently ignored")}`, async () => {
+	const customerId = "att-disc-double-use-attach";
+
+	const free = products.base({
+		id: "free",
+		items: [items.monthlyMessages({ includedUsage: 100 })],
+	});
+
+	const pro = products.pro({
+		id: "pro",
+		items: [items.monthlyMessages({ includedUsage: 500 })],
+	});
+
+	const premium = products.premium({
+		id: "premium",
+		items: [items.monthlyMessages({ includedUsage: 1000 })],
+	});
+
+	const { autumnV1, advancedTo, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [free, pro, premium] }),
+		],
+		actions: [s.billing.attach({ productId: free.id })],
+	});
+
+	const stripeCli = createStripeCli({ org: ctx.org, env: ctx.env });
+	const coupon = await createPercentCoupon({ stripeCli, percentOff: 20 });
+
+	// Cycle 1: Attach pro with discount
+	await autumnV1.billing.attach({
+		customer_id: customerId,
+		product_id: pro.id,
+		discounts: [{ reward_id: coupon.id }],
+	});
+
+	// Advance to next invoice (start of cycle 2)
+	await advanceTestClock({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+		advanceTo: addHours(
+			addMonths(new Date(advancedTo), 1),
+			hoursToFinalizeInvoice,
+		).getTime(),
+		waitForSeconds: 30,
+	});
+
+	// Cycle 2: Upgrade with same discount — should succeed, duplicate silently ignored
+	await autumnV1.billing.attach({
+		customer_id: customerId,
+		product_id: premium.id,
+		discounts: [{ reward_id: coupon.id }],
+	});
+
+	const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer,
+		active: [premium.id],
+		notPresent: [pro.id],
+	});
+
+	// Coupon must appear exactly once — not double-applied
+	const { subscription } = await getStripeSubscription({ customerId });
+	const couponDiscounts = subscription.discounts.filter((d) => {
+		if (typeof d === "string") return false;
+		const c = d.source?.coupon;
+		return typeof c !== "string" && c?.id === coupon.id;
+	});
+	expect(couponDiscounts).toHaveLength(1);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 2: billing.multiAttach - duplicate discount on next cycle is silently ignored
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Customer on free (no subscription)
+ * - Cycle 1: multiAttach [pro] WITH a 20% forever coupon → subscription created with coupon
+ * - Advance to next invoice (cycle 2)
+ * - Cycle 2: multiAttach [addon] WITH same coupon → attach succeeds, duplicate ignored
+ *
+ * Expected:
+ * - No error — attach succeeds
+ * - addon is active
+ */
+test.concurrent(`${chalk.yellowBright("attach-discount-double-use 2: billing.multiAttach - duplicate discount on next cycle silently ignored")}`, async () => {
+	const customerId = "att-disc-double-use-multi";
+
+	const free = products.base({
+		id: "free",
+		items: [items.monthlyMessages({ includedUsage: 100 })],
+	});
+
+	const pro = products.pro({
+		id: "pro",
+		items: [items.monthlyMessages({ includedUsage: 500 })],
+	});
+
+	const addon = products.recurringAddOn({
+		id: "addon",
+		items: [items.monthlyWords({ includedUsage: 100 })],
+	});
+
+	const { autumnV1, advancedTo, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [free, pro, addon] }),
+		],
+		actions: [s.billing.attach({ productId: free.id })],
+	});
+
+	const stripeCli = createStripeCli({ org: ctx.org, env: ctx.env });
+	const coupon = await createPercentCoupon({ stripeCli, percentOff: 20 });
+
+	// Cycle 1: multiAttach pro with discount
+	await autumnV1.billing.multiAttach({
+		customer_id: customerId,
+		plans: [{ plan_id: pro.id }],
+		discounts: [{ reward_id: coupon.id }],
+	});
+
+	// Advance to next invoice (start of cycle 2)
+	await advanceTestClock({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+		advanceTo: addHours(
+			addMonths(new Date(advancedTo), 1),
+			hoursToFinalizeInvoice,
+		).getTime(),
+		waitForSeconds: 30,
+	});
+
+	// Cycle 2: multiAttach addon with same discount — should succeed, duplicate silently ignored
+	await autumnV1.billing.multiAttach({
+		customer_id: customerId,
+		plans: [{ plan_id: addon.id }],
+		discounts: [{ reward_id: coupon.id }],
+	});
+
+	const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer,
+		active: [pro.id, addon.id],
+		notPresent: [free.id],
+	});
+
+	// Coupon must appear exactly once on the pro subscription — not double-applied
+	const { subscription } = await getStripeSubscription({ customerId });
+	const couponDiscounts = subscription.discounts.filter((d) => {
+		if (typeof d === "string") return false;
+		const c = d.source?.coupon;
+		return typeof c !== "string" && c?.id === coupon.id;
+	});
+	expect(couponDiscounts).toHaveLength(1);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 3: same coupon on a different customer's subscription → allowed
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Customer 1 attaches pro WITH a 20% forever coupon → their subscription gets the coupon
+ * - Customer 2 (different subscription) attaches pro with the SAME coupon → should succeed
+ *
+ * This confirms the check is per-subscription, not a global coupon blacklist.
+ * The same coupon ID may be freely used across different customers' subscriptions.
+ */
+test.concurrent(`${chalk.yellowBright("attach-discount-double-use 3: same coupon on different customer subscription → allowed")}`, async () => {
+	const customerId1 = "att-disc-double-use-c1";
+	const customerId2 = "att-disc-double-use-c2";
+
+	// Separate product objects per customer — initScenario mutates product.id in-place
+	const free1 = products.base({
+		id: "free",
+		items: [items.monthlyMessages({ includedUsage: 100 })],
+	});
+	const pro1 = products.pro({
+		id: "pro",
+		items: [items.monthlyMessages({ includedUsage: 500 })],
+	});
+
+	const free2 = products.base({
+		id: "free",
+		items: [items.monthlyMessages({ includedUsage: 100 })],
+	});
+	const pro2 = products.pro({
+		id: "pro",
+		items: [items.monthlyMessages({ includedUsage: 500 })],
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId: customerId1,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [free1, pro1] }),
+		],
+		actions: [s.billing.attach({ productId: free1.id })],
+	});
+
+	await initScenario({
+		customerId: customerId2,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [free2, pro2] }),
+		],
+		actions: [s.billing.attach({ productId: free2.id })],
+	});
+
+	const stripeCli = createStripeCli({ org: ctx.org, env: ctx.env });
+	const coupon = await createPercentCoupon({ stripeCli, percentOff: 20 });
+
+	// Customer 1: attach pro with coupon → their subscription gets the coupon
+	await autumnV1.billing.attach({
+		customer_id: customerId1,
+		product_id: pro1.id,
+		discounts: [{ reward_id: coupon.id }],
+	});
+
+	// Customer 2: attach pro with the SAME coupon → different subscription → must succeed
+	await autumnV1.billing.attach({
+		customer_id: customerId2,
+		product_id: pro2.id,
+		discounts: [{ reward_id: coupon.id }],
+	});
+
+	const customer2 = await autumnV1.customers.get<ApiCustomerV3>(customerId2);
+	await expectCustomerProducts({
+		customer: customer2,
+		active: [pro2.id],
+		notPresent: [free2.id],
+	});
+});

shared/api/products/items/mappers/planItemV0ToProductItem.ts

@@ -145,6 +145,7 @@ export const planItemV0ToProductItem = ({
 		tiers: planItem.price?.tiers?.map((tier) => ({
 			amount: tier.amount,
 			to: tier.to,
+			flat_amount: tier.flat_amount,
 		})),
 		tier_behavior: planItem.price?.tier_behavior,
 

shared/utils/cusEntUtils/cusEntUtils.ts

@@ -21,7 +21,8 @@ export const isEntityCusEnt = ({
 }): boolean => {
 	return !!(
 		cusEnt.entitlement.entity_feature_id ||
-		cusEnt.customer_product?.internal_entity_id
+		cusEnt.customer_product?.internal_entity_id ||
+		cusEnt?.internal_entity_id
 	);
 };