release

server/src/cron/invoiceCron/runInvoiceCron.ts

@@ -4,6 +4,8 @@ import { addDays } from "date-fns";
 import { and, asc, eq, isNotNull, lt, or, sql } from "drizzle-orm";
 import type { Stripe } from "stripe";
 import { withStatementTimeout } from "@/db/withStatementTimeout.js";
+import { resolveRedisV2 } from "@/external/redis/resolveRedisV2.js";
+import { expirePendingCustomerProducts } from "@/internal/billing/v2/execute/expirePendingCustomerProducts";
 import { OrgService } from "@/internal/orgs/OrgService";
 import { createStripeCli } from "../../external/connect/createStripeCli";
 import { stripeInvoiceToStripeSubscriptionId } from "../../external/stripe/invoices/utils/convertStripeInvoice";
@@ -69,6 +71,22 @@ export const handleVoidInvoiceCron = async ({
 
 	const subId = stripeInvoiceToStripeSubscriptionId(invoice);
 	const voidSub = metadata.type === MetadataType.InvoiceCheckout;
+	const expirePendingRows = async () => {
+		try {
+			await expirePendingCustomerProducts({
+				ctx: {
+					db,
+					logger,
+					org: { id: org.id },
+					env: customer.env,
+					redisV2: resolveRedisV2(),
+				},
+				metadataId: metadata.id,
+			});
+		} catch (error) {
+			logger.error(`Error expiring pending customer products: ${error}`);
+		}
+	};
 
 	console.log(
 		`Invoice: ${metadata.stripe_invoice_id} for customer ${customer.id} (org: ${org.slug}) - status: ${invoice.status}`,
@@ -90,6 +108,7 @@ export const handleVoidInvoiceCron = async ({
 				}
 			}
 
+			await expirePendingRows();
 			await MetadataService.delete({
 				db,
 				id: metadata.id,
@@ -123,6 +142,7 @@ export const handleVoidInvoiceCron = async ({
 			}
 		}
 	} else if (invoice.status === "void" || invoice.status === "uncollectible") {
+		await expirePendingRows();
 		await MetadataService.delete({
 			db,
 			id: metadata.id,

server/src/external/revenueCat/webhookHandlers/handleRevenucatRenewal.ts

@@ -69,13 +69,18 @@ export const handleRenewal = async ({
 		return { success: true };
 	}
 
-	// Past-due → active recovery.
+	// Past-due → active recovery. A product cancelled before it went past due
+	// needs uncancel, since markActive leaves the cancellation fields set.
 	if (curSameProduct && curSameProduct.status === CusProductStatus.PastDue) {
 		logger.info(
 			`Renewal for existing past due product ${product.id}, marking as active`,
 		);
 
-		await customerProductActions.markActive({
+		const recoverPastDueProduct = curSameProduct.canceled
+			? customerProductActions.uncancel
+			: customerProductActions.markActive;
+
+		await recoverPastDueProduct({
 			ctx: customerCtx,
 			customerProduct: curSameProduct,
 			fullCustomer: customer,

server/src/external/stripe/subscriptionSchedules/utils/logStripeSchedulePhaseUtils.ts

@@ -111,6 +111,7 @@ const formatCustomerProductStatus = (
 	const statusLabels: Record<CusProductStatus, string> = {
 		[CusProductStatus.Active]: "✓ active",
 		[CusProductStatus.Scheduled]: "⏳ scheduled",
+		[CusProductStatus.Pending]: "⧖ pending",
 		[CusProductStatus.Expired]: "✗ expired",
 		[CusProductStatus.PastDue]: "⚠ past_due",
 		[CusProductStatus.Trialing]: "🔄 trialing",

server/src/external/stripe/webhookHandlers/handleStripeCheckoutSessionCompleted/tasks/handleCheckoutSessionMetadataV2/handleCheckoutSessionMetadataV2.ts

@@ -17,6 +17,7 @@ import {
 } from "@/internal/billing/v2/actions/createSchedule/utils/persistDeferredCreateSchedule";
 import { addStripeSubscriptionScheduleIdToBillingPlan } from "@/internal/billing/v2/execute/addStripeSubscriptionScheduleIdToBillingPlan";
 import { executeAutumnBillingPlan } from "@/internal/billing/v2/execute/executeAutumnBillingPlan";
+import { promotePendingCustomerProducts } from "@/internal/billing/v2/execute/promotePendingCustomerProducts";
 import { publishBillingTransition } from "@/internal/billing/v2/publish/publishBillingTransition.js";
 import { buildBillingLockKey } from "@/internal/billing/v2/utils/billingLock/buildBillingLockKey";
 import { withBillingLock } from "@/internal/billing/v2/utils/billingLock/withBillingLock";
@@ -165,6 +166,13 @@ const executeCheckoutSessionMetadataV2 = async ({
 		billingContext: updatedDeferredData.billingContext,
 	});
 
+	await promotePendingCustomerProducts({
+		ctx,
+		autumnBillingPlan: updatedDeferredData.billingPlan.autumn,
+		fullCustomer: updatedDeferredData.billingContext.fullCustomer,
+		metadataId: metadata.id,
+	});
+
 	// Execute autumn billing plan (includes customer products, upsertSubscription, upsertInvoice)
 	await executeAutumnBillingPlan({
 		ctx,

server/src/external/stripe/webhookHandlers/handleStripeCheckoutSessionExpired/handleStripeCheckoutSessionExpired.ts

@@ -1,6 +1,10 @@
 import { CusProductStatus } from "@autumn/shared";
 import type Stripe from "stripe";
 import type { StripeWebhookContext } from "@/external/stripe/webhookMiddlewares/stripeWebhookContext";
+import {
+	expireCustomerProducts,
+	expirePendingCustomerProducts,
+} from "@/internal/billing/v2/execute/expirePendingCustomerProducts";
 import { CusProductService } from "@/internal/customers/cusProducts/CusProductService";
 import { MetadataService } from "@/internal/metadata/MetadataService";
 
@@ -32,6 +36,10 @@ export const handleStripeCheckoutSessionExpired = async ({
 		// Try to clean up the metadata row even if no cusProduct ever got created
 		// (e.g. a deferred-flow checkout that expired).
 		if (session.metadata?.autumn_metadata_id) {
+			await expirePendingCustomerProducts({
+				ctx,
+				metadataId: session.metadata.autumn_metadata_id,
+			});
 			await MetadataService.delete({
 				db: ctx.db,
 				id: session.metadata.autumn_metadata_id,
@@ -40,21 +48,14 @@ export const handleStripeCheckoutSessionExpired = async ({
 		return;
 	}
 
-	const now = Date.now();
-
-	for (const cusProduct of cusProducts) {
-		// If the success-path webhook already linked a subscription, leave it.
-		if ((cusProduct.subscription_ids ?? []).length > 0) continue;
+	const abandonedCusProducts = cusProducts.filter(
+		(cusProduct) => (cusProduct.subscription_ids ?? []).length === 0,
+	);
 
-		await CusProductService.update({
-			ctx,
-			cusProductId: cusProduct.id,
-			updates: {
-				status: CusProductStatus.Expired,
-				ended_at: now,
-			},
-		});
-	}
+	await expireCustomerProducts({
+		ctx,
+		customerProducts: abandonedCusProducts,
+	});
 
 	if (session.metadata?.autumn_metadata_id) {
 		await MetadataService.delete({

server/src/internal/analytics/analyticsUtils.ts

@@ -4,7 +4,6 @@ import {
 	ErrCode,
 	type FullCusProduct,
 	type FullCustomer,
-	type FullCustomerEntitlement,
 	type FullProduct,
 	RecaseError,
 	type Subscription,
@@ -310,6 +309,14 @@ function calculateBillingCycleResult(
 	const gap = currentEndDate.getTime() - currentStartDate.getTime();
 	const gapDays = Math.floor(gap / (1000 * 60 * 60 * 24));
 
+	if (intervalType === "1bc") {
+		return {
+			startDate: startDates[0],
+			endDate: endDates[0],
+			gap: gapDays,
+		};
+	}
+
 	if (intervalType === "last_cycle") {
 		const earliestCreation = createdDates.reduce((earliest, current) => {
 			const currentDate = new Date(current);
@@ -339,7 +346,7 @@ function calculateBillingCycleResult(
 		};
 	}
 
-	const gapMultiplier = intervalType === "1bc" ? 1 : 3;
+	const gapMultiplier = 3;
 	const now = new Date();
 
 	// For analytics, we look BACKWARD from today for N billing cycles

server/src/internal/billing/v2/actions/generateRequest/compute/buildGenerationPrompts.ts

@@ -21,6 +21,7 @@ export const buildSystemPrompt = (tool: GenerateBillingTool) => {
 		"- You cannot ask questions and have no tools. Wherever the docs say to ask, clarify, or call a tool, decide yourself from the most literal reading of the request and produce the single best complete request. Never emit a partial or empty object.",
 		"- Never omit a required field. Always set plan_id to your best match from the context plans; when sibling variants exist (e.g. monthly vs yearly), pick the one matching the stated interval or amount, defaulting to the monthly variant.",
 		"- When the request states a price for a plan (e.g. 'at 10k/mo'), always set customize.price to it — including Enterprise/custom placeholder plans where the docs say to ask about the base price.",
+		"- customer.current_plans[].effective_plan is the subscription's live configuration in the same shape as context.plans. When changing a plan or version, explicitly preserve any current term the request says to keep by copying it into the corresponding customize override.",
 		"- Use ONLY plan ids and feature ids that appear in the context below.",
 		"- Monetary amounts are in major currency units (e.g. dollars). Never convert to cents.",
 		"- The operation always targets the customer in the context. Ignore any other customer mentioned in the request.",

server/src/internal/billing/v2/actions/generateRequest/setup/setupGenerationContext.ts

@@ -5,6 +5,7 @@ import type {
 	FullProduct,
 } from "@autumn/shared";
 import {
+	cusProductToProduct,
 	mapToProductV2,
 	productV2ToApiPlanV1,
 	toCreatePlanItemParams,
@@ -30,6 +31,7 @@ const compactPlan = ({
 	return {
 		id: productV2.id,
 		name: productV2.name,
+		version: productV2.version,
 		...(productV2.group ? { group: productV2.group } : {}),
 		...(productV2.is_add_on ? { is_add_on: true } : {}),
 		...(productV2.free_trial ? { free_trial: productV2.free_trial } : {}),
@@ -94,10 +96,16 @@ export const setupGenerationContext = async ({
 			customer: {
 				id: fullCustomer.id,
 				...(fullCustomer.name ? { name: fullCustomer.name } : {}),
-				current_plans: fullCustomer.customer_products.map((customerProduct) =>
-					compactCustomerProduct({
-						customerProduct,
-						entities: fullCustomer.entities ?? [],
+				current_plans: fullCustomer.customer_products.map(
+					(customerProduct) => ({
+						...compactCustomerProduct({
+							customerProduct,
+							entities: fullCustomer.entities ?? [],
+						}),
+						effective_plan: compactPlan({
+							features,
+							product: cusProductToProduct({ cusProduct: customerProduct }),
+						}),
 					}),
 				),
 				entities: (fullCustomer.entities ?? []).map((entity) => ({

server/src/internal/billing/v2/actions/resolveBillingRequest.ts

@@ -123,9 +123,15 @@ export const resolveBillingRequest = async ({
 			fullCustomer,
 			params: params.request,
 		});
-		fullProduct = cusProductToProduct({
-			cusProduct: targetCustomerProduct,
-		});
+		fullProduct = params.request.version
+			? await ProductService.getFull({
+					db: ctx.db,
+					env: ctx.env,
+					idOrInternalId: targetCustomerProduct.product.id,
+					orgId: ctx.org.id,
+					version: params.request.version,
+				})
+			: cusProductToProduct({ cusProduct: targetCustomerProduct });
 	}
 
 	const { request, unrepresentable } = billingParamsV1ToV0({

server/src/internal/billing/v2/actions/updateSubscription/setup/findTargetCustomerProduct.ts

@@ -1,4 +1,5 @@
 import {
+	ATTACH_CONFLICT_STATUSES,
 	cusProductToPrices,
 	ErrCode,
 	type FullCusProduct,
@@ -12,7 +13,6 @@ import {
 	isCustomerProductPaidRecurring,
 	isCustomerProductRecurring,
 	isPrepaidPrice,
-	RELEVANT_STATUSES,
 	RecaseError,
 	type UpdateSubscriptionV1Params,
 } from "@autumn/shared";
@@ -145,7 +145,7 @@ export const findTargetCustomerProduct = async ({
 
 	const candidates = fullCustomerToPlanProducts({ fullCustomer }).filter(
 		(cp) => {
-			if (!RELEVANT_STATUSES.includes(cp.status)) return false;
+			if (!ATTACH_CONFLICT_STATUSES.includes(cp.status)) return false;
 			return isCusProductOnEntity({ cusProduct: cp, internalEntityId });
 		},
 	);
@@ -160,7 +160,7 @@ export const findTargetCustomerProduct = async ({
 		const fallback = await CusProductService.getFull({
 			db: ctx.db,
 			id: params.customer_product_id,
-			inStatuses: RELEVANT_STATUSES,
+			inStatuses: ATTACH_CONFLICT_STATUSES,
 		});
 		const belongsToCustomer =
 			fallback?.internal_customer_id === fullCustomer.internal_id;

server/src/internal/billing/v2/execute/buildPendingReattachParams.ts

@@ -0,0 +1,41 @@
+import type {
+	AttachParamsV1,
+	BillingContext,
+	FullCusProduct,
+	UpdateSubscriptionV1Params,
+} from "@autumn/shared";
+
+export const buildPendingReattachParams = ({
+	params,
+	billingContext,
+	customerProduct,
+}: {
+	params: UpdateSubscriptionV1Params;
+	billingContext: BillingContext;
+	customerProduct: FullCusProduct;
+}): AttachParamsV1 => {
+	const { invoiceMode } = billingContext;
+
+	const featureQuantities =
+		params.feature_quantities ??
+		billingContext.featureQuantities.map((featureQuantity) => ({
+			feature_id: featureQuantity.feature_id,
+			quantity: featureQuantity.quantity ?? 0,
+		}));
+
+	return {
+		customer_id: params.customer_id,
+		plan_id: customerProduct.product.id,
+		entity_id: params.entity_id ?? customerProduct.entity_id ?? undefined,
+		feature_quantities: featureQuantities,
+		customize: params.customize,
+		version: params.version,
+		enable_plan_immediately: billingContext.enablePlanImmediately,
+		invoice_mode: invoiceMode && {
+			enabled: true,
+			enable_plan_immediately: invoiceMode.enableProductImmediately,
+			finalize: invoiceMode.finalizeInvoice,
+			net_terms_days: invoiceMode.daysUntilDue,
+		},
+	} as AttachParamsV1;
+};

server/src/internal/billing/v2/execute/discardPendingCustomerProduct.ts

@@ -0,0 +1,44 @@
+import type { FullCusProduct } from "@autumn/shared";
+import { createStripeCli } from "@/external/connect/createStripeCli";
+import { expireStripeCheckoutSession } from "@/external/stripe/checkoutSessions/operations/expireStripeCheckoutSession";
+import { voidStripeInvoiceIfOpen } from "@/external/stripe/invoices/operations/voidStripeInvoiceIfOpen";
+import type { AutumnContext } from "@/honoUtils/HonoEnv";
+import { CusProductService } from "@/internal/customers/cusProducts/CusProductService";
+import { MetadataService } from "@/internal/metadata/MetadataService";
+
+export const discardPendingCustomerProduct = async ({
+	ctx,
+	customerProduct,
+}: {
+	ctx: AutumnContext;
+	customerProduct: FullCusProduct;
+}) => {
+	const metadataId = customerProduct.metadata_id;
+
+	if (metadataId) {
+		const metadata = await MetadataService.get({ db: ctx.db, id: metadataId });
+
+		if (metadata?.stripe_checkout_session_id) {
+			await expireStripeCheckoutSession({
+				ctx,
+				checkoutSessionId: metadata.stripe_checkout_session_id,
+			});
+		}
+
+		if (metadata?.stripe_invoice_id) {
+			const stripeCli = createStripeCli({ org: ctx.org, env: ctx.env });
+			const stripeInvoice = await stripeCli.invoices.retrieve(
+				metadata.stripe_invoice_id,
+			);
+
+			await voidStripeInvoiceIfOpen({ ctx, stripeInvoice });
+		}
+
+		await MetadataService.delete({ db: ctx.db, id: metadataId });
+	}
+
+	await CusProductService.expireIfPending({
+		ctx,
+		cusProductId: customerProduct.id,
+	});
+};

server/src/internal/billing/v2/execute/discardPendingPlanIfAny.ts

@@ -0,0 +1,27 @@
+import type { AutumnContext } from "@/honoUtils/HonoEnv";
+import { discardPendingCustomerProduct } from "@/internal/billing/v2/execute/discardPendingCustomerProduct";
+import { findPendingCustomerProduct } from "@/internal/billing/v2/execute/findPendingCustomerProduct";
+
+export const discardPendingPlanIfAny = async ({
+	ctx,
+	customerId,
+	productId,
+	entityId,
+}: {
+	ctx: AutumnContext;
+	customerId: string;
+	productId?: string;
+	entityId?: string;
+}) => {
+	const customerProduct = await findPendingCustomerProduct({
+		ctx,
+		customerId,
+		productId,
+		entityId,
+	});
+
+	if (!customerProduct) return false;
+
+	await discardPendingCustomerProduct({ ctx, customerProduct });
+	return true;
+};