comi-logic/cfw-autumn
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed tests

Browse Source
This commit is contained in:
John Yeo
2026-02-17 21:22:31 +00:00
parent 9d0610f0c4
commit b2beb58b8c
39 changed files with 331 additions and 409 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
scripts/testGroups/all.sh
View File

@@ -4,14 +4,14 @@ source "$(dirname "$0")/config.sh"
export TEST_FILE_CONCURRENCY=2
BUN_PARALLEL_V2 \
'integration/billing/migrations' \
'integration/crud/customers' \
'integration/billing/stripe-webhooks' \
'integration/billing/autumn-webhooks' \
'integration/cron' \
'integration/crud/plans' \
'integration/billing/update-subscription' \
'integration/billing/attach' \
# 'integration/billing/migrations' \
# 'integration/crud/customers' \
# 'integration/billing/stripe-webhooks' \
# 'integration/billing/autumn-webhooks' \
# 'integration/cron' \
# 'integration/crud/plans' \
# 'integration/billing/attach' \

2
server/src/external/stripe/createStripePrice/createStripePrepaid.ts vendored
View File

@@ -127,8 +127,6 @@ export const createStripePrepaid = async ({
};
}
console.log("priceAmountData", priceAmountData);
stripePrice = await stripeCli.prices.create({
...productData,
currency: orgToCurrency({ org }),

6
server/src/internal/billing/v2/actions/attach/errors/handleTransitionConfigErrors.ts
View File

@@ -17,10 +17,10 @@ export const handleTransitionConfigErrors = ({
}) => {
const { transitionConfig } = billingContext;
const resetAfterTrialEndFeaturIds =
transitionConfig?.resetAfterTrialEndFeaturIds ?? [];
const resetAfterTrialEndFeatureIds =
transitionConfig?.resetAfterTrialEndFeatureIds ?? [];
for (const featureId of resetAfterTrialEndFeaturIds) {
for (const featureId of resetAfterTrialEndFeatureIds) {
const feature = featureUtils.find.byId({
features: ctx.features,
featureId,

6
server/src/internal/billing/v2/actions/attach/logs/logAttachContext.ts
View File

@@ -61,9 +61,9 @@ export const logAttachContext = ({
.join(", ")
: "none",
resetAfterTrialEndFeaturIds:
transitionConfig?.resetAfterTrialEndFeaturIds
? transitionConfig.resetAfterTrialEndFeaturIds.join(", ")
resetAfterTrialEndFeatureIds:
transitionConfig?.resetAfterTrialEndFeatureIds
? transitionConfig.resetAfterTrialEndFeatureIds.join(", ")
: "none",
trialContext: trialContext

9
server/src/internal/billing/v2/actions/legacy/legacyAttach.ts
View File

@@ -6,6 +6,7 @@ import type {
import { BillingVersion } from "@autumn/shared";
import type { AutumnContext } from "@/honoUtils/HonoEnv";
import { billingActions } from "@/internal/billing/v2/actions";
import { attachParamsToInvoiceModeParams } from "@/internal/billing/v2/actions/legacy/utils/attachParamsToInvoiceModeParams";
import { attachParamsToStripeBillingContext } from "@/internal/billing/v2/actions/legacy/utils/attachParamsToStripeBillingContext";
import { setupLegacyTransitionContext } from "@/internal/billing/v2/actions/legacy/utils/setupLegacyFeatureQuantitiesContext";
import { billingResultToResponse } from "@/internal/billing/v2/utils/billingResult/billingResultToResponse";
@@ -53,13 +54,7 @@ export const legacyAttach = async ({
entity_id: fullCustomer.entity?.id,
plan_id: fullProduct.id,
invoice_mode: attachParams.invoiceOnly
? {
enabled: attachParams.invoiceOnly,
enable_product_immediately: true,
finalize_invoice: attachParams.finalizeInvoice ?? true,
}
: undefined,
invoice_mode: attachParamsToInvoiceModeParams({ attachParams }),
redirect_mode: "if_required",

4
server/src/internal/billing/v2/actions/legacy/renew.ts
View File

@@ -71,8 +71,8 @@ export const renew = async ({
invoice_mode: body.invoice
? {
enabled: true,
enable_product_immediately: body.enable_product_immediately ?? false,
finalize_invoice: body.finalize_invoice ?? true,
enable_plan_immediately: body.enable_product_immediately ?? false,
finalize: body.finalize_invoice ?? true,
}
: undefined,

4
server/src/internal/billing/v2/actions/legacy/updateQuantity.ts
View File

@@ -73,8 +73,8 @@ export const updateQuantity = async ({
invoice_mode: body.invoice
? {
enabled: true,
enable_product_immediately: body.enable_product_immediately ?? false,
finalize_invoice: body.finalize_invoice ?? true,
enable_plan_immediately: body.enable_product_immediately ?? false,
finalize: body.finalize_invoice ?? true,
}
: undefined,

16
server/src/internal/billing/v2/actions/legacy/utils/attachParamsToInvoiceModeParams.ts Normal file
View File

@@ -0,0 +1,16 @@
import type { InvoiceModeParams } from "@autumn/shared";
import type { AttachParams } from "@/internal/customers/cusProducts/AttachParams";
export const attachParamsToInvoiceModeParams = ({
attachParams,
}: {
attachParams: AttachParams;
}): InvoiceModeParams | undefined => {
return attachParams.invoiceOnly
? {
enabled: attachParams.invoiceOnly,
enable_plan_immediately: true,
finalize: attachParams.finalizeInvoice ?? true,
}
: undefined;
};

2
server/src/internal/billing/v2/actions/legacy/utils/setupLegacyFeatureQuantitiesContext.ts
View File

@@ -14,7 +14,7 @@ export const setupLegacyTransitionContext = ({
.map((ent) => ent.feature);
return {
resetAfterTrialEndFeaturIds: consumableFeatures.map((f) => f.id),
resetAfterTrialEndFeatureIds: consumableFeatures.map((f) => f.id),
};
// const newOptions: FeatureOptionsParamsV0[] = [];

17
server/src/internal/billing/v2/actions/updateSubscription/compute/cancel/applyUncancelToPlan.ts
View File

@@ -1,5 +1,7 @@
import type { UpdateSubscriptionBillingContext } from "@autumn/shared";
import type { AutumnBillingPlan } from "@autumn/shared";
import type {
AutumnBillingPlan,
UpdateSubscriptionBillingContext,
} from "@autumn/shared";
import { computeCustomerProductToDelete } from "@/internal/billing/v2/actions/updateSubscription/compute/cancel/computeCustomerProductToDelete";
/**
@@ -18,7 +20,7 @@ export const applyUncancelToPlan = ({
if (cancelAction !== "uncancel") return plan;
const cancelUpdates = {
const uncancelUpdates = {
canceled: false,
canceled_at: null,
ended_at: null,
@@ -37,12 +39,19 @@ export const applyUncancelToPlan = ({
existingUpdate?.customerProduct ?? billingContext.customerProduct,
updates: {
...existingUpdate?.updates,
...cancelUpdates,
...uncancelUpdates,
},
};
// // If there are new customer products being inserted, also add uncancel updates to them
// const insertCustomerProducts = plan.insertCustomerProducts.map((insert) => ({
// ...insert,
// ...uncancelUpdates,
// }));
return {
...plan,
// insertCustomerProducts,
updateCustomerProduct,
// Use the plan's deleteCustomerProduct if already set, otherwise use ours
deleteCustomerProduct: plan.deleteCustomerProduct ?? deleteCustomerProduct,

2
server/src/internal/billing/v2/actions/updateSubscription/setup/setupDefaultProductContext.ts
View File

@@ -37,5 +37,7 @@ export const setupDefaultProductContext = async ({
productGroup: customerProduct.product.group,
});
if (defaultProduct?.id === customerProduct.product.id) return undefined;
return defaultProduct;
};

1
server/src/internal/billing/v2/providers/stripe/execute/executeStripeSubscriptionAction.ts
View File

@@ -78,6 +78,7 @@ export const executeStripeSubscriptionAction = async ({
stripeClient: createStripeCli({ org: ctx.org, env: ctx.env }),
invoiceId: latestStripeInvoice!.id,
hasPaymentMethod: Boolean(billingContext.paymentMethod),
invoiceMode: billingContext.invoiceMode ?? undefined,
})
: undefined;

6
server/src/internal/billing/v2/providers/stripe/utils/common/shouldDeferBillingPlan.ts
View File

@@ -1,6 +1,8 @@
import type { BillingResponseRequiredAction } from "@autumn/shared";
import type {
BillingContext,
BillingResponseRequiredAction,
} from "@autumn/shared";
import type Stripe from "stripe";
import type { BillingContext } from "@autumn/shared";
import { isDeferredInvoiceMode } from "@/internal/billing/v2/utils/billingContext/isDeferredInvoiceMode";
export const shouldDeferBillingPlan = ({

9
server/src/internal/billing/v2/providers/stripe/utils/subscriptionSchedules/buildStripePhasesUpdate.ts
View File

@@ -78,6 +78,7 @@ const customerProductsToPhaseItems = ({
* Converts billing context discounts to the format expected by Stripe schedule phases.
* Uses the existing discount ID so Stripe reuses the same discount object,
* preserving the original start/end timestamps and remaining duration for repeating coupons.
* Falls back to coupon ID for new discounts that don't have a discount ID yet.
*/
const stripeDiscountsToPhaseDiscounts = ({
stripeDiscounts,
@@ -86,9 +87,11 @@ const stripeDiscountsToPhaseDiscounts = ({
}): Stripe.SubscriptionScheduleUpdateParams.Phase.Discount[] | undefined => {
if (!stripeDiscounts || stripeDiscounts.length === 0) return undefined;
return stripeDiscounts.map((discount) => ({
discount: discount.source.coupon.id,
}));
return stripeDiscounts.map((discount) =>
discount.id
? { discount: discount.id }
: { coupon: discount.source.coupon.id },
);
};
/**

10
server/src/internal/billing/v2/providers/stripe/utils/subscriptions/getRequiredActionFromSubscriptionInvoice.ts
View File

@@ -1,4 +1,7 @@
import type { BillingResponseRequiredAction } from "@autumn/shared";
import type {
BillingResponseRequiredAction,
InvoiceMode,
} from "@autumn/shared";
import type Stripe from "stripe";
import { getStripeInvoice } from "@/external/stripe/invoices/operations/getStripeInvoice.js";
@@ -20,11 +23,16 @@ export const getRequiredActionFromSubscriptionInvoice = async ({
stripeClient,
invoiceId,
hasPaymentMethod,
invoiceMode,
}: {
stripeClient: Stripe;
invoiceId: string;
hasPaymentMethod: boolean;
invoiceMode?: InvoiceMode;
}): Promise<BillingResponseRequiredAction | undefined> => {
// Should enable prooduct immediately, can pay later
if (invoiceMode?.enableProductImmediately) return undefined;
// Fetch invoice with expanded payments to get payment intent status
const invoice = await getStripeInvoice({
stripeClient,

2
server/src/internal/billing/v2/setup/setupAdjustableQuantities.ts
View File

@@ -7,7 +7,7 @@ export const setupAdjustableQuantities = ({
}) => {
return (
params.feature_quantities
?.filter((fq) => fq.adjustable)
?.filter((fq) => fq.adjustable === true)
.map((fq) => fq.feature_id) ?? []
);
};

12
server/src/internal/billing/v2/setup/setupCustomFullProduct.ts
View File

@@ -26,6 +26,12 @@ export const setupCustomFullProduct = async ({
};
}
const newItems = customizePlanV1ToV0({
ctx,
customizePlanV1: customizePlan,
fullProduct: currentFullProduct,
});
// Customize plan -> custom items
const { db, logger, features } = ctx;
@@ -38,11 +44,7 @@ export const setupCustomFullProduct = async ({
db,
curPrices: currentPrices,
curEnts: currentEntitlements,
newItems: customizePlanV1ToV0({
ctx,
customizePlanV1: customizePlan,
fullProduct: currentFullProduct,
}),
newItems,
features,
product: currentFullProduct,
logger,

5
server/src/internal/billing/v2/setup/setupInvoiceModeContext.ts
View File

@@ -13,8 +13,7 @@ export const setupInvoiceModeContext = ({
}
return {
finalizeInvoice: params.invoice_mode?.finalize_invoice === true,
enableProductImmediately:
params.invoice_mode?.enable_product_immediately !== false,
finalizeInvoice: params.invoice_mode?.finalize,
enableProductImmediately: params.invoice_mode?.enable_plan_immediately,
};
};

2
server/src/internal/billing/v2/setup/setupTransitionConfigs.ts
View File

@@ -16,7 +16,7 @@ export const setupTransitionConfigs = ({
}
return {
resetAfterTrialEndFeaturIds:
resetAfterTrialEndFeatureIds:
params.transition_rules?.reset_after_trial_end ?? [],
};
};

1
server/src/internal/billing/v2/utils/billingContext/isDeferredInvoiceMode.ts
View File

@@ -6,6 +6,7 @@ export const isDeferredInvoiceMode = ({
billingContext: BillingContext;
}): boolean => {
const isInvoiceMode = Boolean(billingContext.invoiceMode);
const shouldDefer =
billingContext.invoiceMode?.enableProductImmediately === false;

22
server/src/internal/billing/v2/utils/billingPlanToPreviewResponse.ts
View File

@@ -55,25 +55,7 @@ export const billingPlanToPreviewResponse = ({
// When total is negative (refund credit exceeds new charges), clamp to 0
// and emit a credit object. Reduce the next cycle total by the credit amount
// to reflect what Stripe actually does (apply customer balance to next invoice).
let total = rawTotal;
let credit: BillingPreviewResponse["credit"];
if (rawTotal < 0) {
const creditAmount = new Decimal(rawTotal).abs().toDP(2).toNumber();
total = 0;
credit = {
amount: creditAmount,
description: "Credit for unused time on previous plan",
};
if (nextCycle) {
const appliedCredit = Math.min(creditAmount, nextCycle.total);
nextCycle.total = new Decimal(nextCycle.total)
.minus(appliedCredit)
.toDP(2)
.toNumber();
}
}
const total = rawTotal;
logBillingPreview({
ctx,
@@ -97,7 +79,7 @@ export const billingPlanToPreviewResponse = ({
line_items: previewImmediateLineItems,
total,
currency,
credit,
// credit,
period_start: periodStart,
period_end: periodEnd,
next_cycle: nextCycle,

4
server/src/internal/billing/v2/utils/initFullCustomerProduct/initCustomerEntitlement/initCustomerEntitlementNextResetAt.ts
View File

@@ -26,11 +26,11 @@ export const initCustomerEntitlementNextResetAt = ({
if (isLifetime || isUnlimited || isBoolean) return null;
let { resetCycleAnchor, now, trialEndsAt, transitionConfig } = initContext;
const { resetAfterTrialEndFeaturIds } = transitionConfig ?? {};
const { resetAfterTrialEndFeatureIds } = transitionConfig ?? {};
const { startsAt } = initOptions ?? {};
if (
resetAfterTrialEndFeaturIds?.includes(entitlement.feature.id) &&
resetAfterTrialEndFeatureIds?.includes(entitlement.feature.id) &&
trialEndsAt
) {
now = trialEndsAt;

1
server/src/internal/billing/v2/utils/initFullCustomerProduct/reapplyExistingRolloversToCustomerProduct.ts
View File

@@ -44,6 +44,7 @@ export const reapplyExistingRolloversToCustomerProduct = async ({
existingRollovers: currentRollovers,
});
try {
for (const cusEnt of customerProduct.customer_entitlements) {
await RolloverService.insert({

40
server/tests/integration/billing/attach/checkout/stripe-checkout/stripe-checkout-prepaid.test.ts
View File

@@ -162,8 +162,13 @@ test.concurrent(`${chalk.yellowBright("stripe-checkout: prepaid quantity updated
const result = await autumnV1.billing.attach({
customer_id: customerId,
product_id: pro.id,
options: [{ feature_id: TestFeature.Messages, quantity: initialQuantity }],
adjustable_quantity: true,
options: [
{
feature_id: TestFeature.Messages,
quantity: initialQuantity,
adjustable: true,
},
],
});
expect(result.payment_url).toBeDefined();
@@ -272,10 +277,17 @@ test.concurrent(`${chalk.yellowBright("stripe-checkout: multiple prepaid feature
customer_id: customerId,
product_id: pro.id,
options: [
{ feature_id: TestFeature.Messages, quantity: initialMessagesQty },
{ feature_id: TestFeature.Words, quantity: initialWordsQty },
{
feature_id: TestFeature.Messages,
quantity: initialMessagesQty,
adjustable: true,
},
{
feature_id: TestFeature.Words,
quantity: initialWordsQty,
adjustable: true,
},
],
adjustable_quantity: true,
});
expect(result.payment_url).toBeDefined();
@@ -385,8 +397,13 @@ test.concurrent(`${chalk.yellowBright("stripe-checkout: prepaid quantity set to
const result = await autumnV1.billing.attach({
customer_id: customerId,
product_id: pro.id,
options: [{ feature_id: TestFeature.Messages, quantity: initialQuantity }],
adjustable_quantity: true,
options: [
{
feature_id: TestFeature.Messages,
quantity: initialQuantity,
adjustable: true,
},
],
});
expect(result.payment_url).toBeDefined();
@@ -480,8 +497,13 @@ test.concurrent(`${chalk.yellowBright("stripe-checkout: tiered prepaid with quan
const result = await autumnV1.billing.attach({
customer_id: customerId,
product_id: pro.id,
options: [{ feature_id: TestFeature.Messages, quantity: initialQuantity }],
adjustable_quantity: true,
options: [
{
feature_id: TestFeature.Messages,
quantity: initialQuantity,
adjustable: true,
},
],
});
expect(result.payment_url).toBeDefined();

2
server/tests/integration/billing/attach/edge-cases/v1-v2-compatibility/prepaid/v1-attach-v2-update-quantity.test.ts
View File

@@ -128,7 +128,7 @@ test.concurrent(`${chalk.yellowBright("v1→v2 compat: increment quantity (multi
customerId,
org: ctx.org,
env: ctx.env,
billingVersion: BillingVersion.V2,
billingVersion: BillingVersion.V1,
});
await expectCustomerInvoiceCorrect({

11
server/tests/integration/billing/attach/errors/transition-config-errors.test.ts
View File

@@ -60,9 +60,11 @@ test.concurrent(`${chalk.yellowBright("transition-config-errors 1: reset_after_t
{
feature_id: TestFeature.Workflows,
quantity: 5,
reset_after_trial_end: true,
},
],
transition_rules: {
reset_after_trial_end: [TestFeature.Workflows],
},
});
},
});
@@ -107,9 +109,11 @@ test.concurrent(`${chalk.yellowBright("transition-config-errors 2: reset_after_t
{
feature_id: TestFeature.Users,
quantity: 5,
reset_after_trial_end: true,
},
],
transition_rules: {
reset_after_trial_end: [TestFeature.Users],
},
});
},
});
@@ -156,6 +160,9 @@ test.concurrent(`${chalk.yellowBright("transition-config-errors 3: feature optio
quantity: 5,
},
],
transition_rules: {
reset_after_trial_end: ["random-nonexistent-feature"],
},
});
},
});

89
server/tests/integration/billing/attach/params/transition-configs/reset-after-trial-end/reset-after-trial-end-basic.test.ts
View File

@@ -60,13 +60,9 @@ test.concurrent(`${chalk.yellowBright("reset-after-trial-end 1: true - billing c
customer_id: customerId,
product_id: proTrial.id,
redirect_mode: "if_required",
options: [
{
feature_id: TestFeature.Messages,
quantity: 500,
reset_after_trial_end: true,
},
],
transition_rules: {
reset_after_trial_end: [TestFeature.Messages],
},
});
const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
@@ -91,19 +87,19 @@ test.concurrent(`${chalk.yellowBright("reset-after-trial-end 1: true - billing c
});
// ═══════════════════════════════════════════════════════════════════════════════
// TEST 2: reset_after_trial_end: false - reset at trial end (default behavior)
// TEST 2: No transition_rules - reset at trial end (default behavior)
// ═══════════════════════════════════════════════════════════════════════════════
/**
* Scenario:
* - Product has 7-day trial + monthly messages
* - Attach with reset_after_trial_end: false for messages
* - Attach WITHOUT transition_rules (default behavior)
*
* Expected Result:
* - next_reset_at = advancedTo + 7 days (trial end)
* - Same as default behavior
* - Default: feature NOT in reset_after_trial_end array
*/
test.concurrent(`${chalk.yellowBright("reset-after-trial-end 2: false - reset at trial end")}`, async () => {
test.concurrent(`${chalk.yellowBright("reset-after-trial-end 2: no transition_rules - reset at trial end")}`, async () => {
const customerId = "reset-trial-end-false";
const messagesItem = items.monthlyMessages({ includedUsage: 500 });
@@ -123,18 +119,12 @@ test.concurrent(`${chalk.yellowBright("reset-after-trial-end 2: false - reset at
actions: [],
});
// Attach with reset_after_trial_end: false
// Attach with reset_after_trial_end: false (omit from transition_rules)
await autumnV1.billing.attach({
customer_id: customerId,
product_id: proTrial.id,
redirect_mode: "if_required",
options: [
{
feature_id: TestFeature.Messages,
quantity: 500,
reset_after_trial_end: false,
},
],
// No transition_rules = default behavior (reset at trial end)
});
const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
@@ -159,19 +149,19 @@ test.concurrent(`${chalk.yellowBright("reset-after-trial-end 2: false - reset at
});
// ═══════════════════════════════════════════════════════════════════════════════
// TEST 3: reset_after_trial_end: default (undefined) - reset at trial end
// TEST 3: Empty options array - reset at trial end (default behavior)
// ═══════════════════════════════════════════════════════════════════════════════
/**
* Scenario:
* - Product has 7-day trial + monthly messages
* - Attach WITHOUT specifying reset_after_trial_end
* - Attach WITHOUT any options array
*
* Expected Result:
* - Default behavior is false (reset at trial end)
* - Default behavior (reset at trial end)
* - next_reset_at = advancedTo + 7 days (trial end)
*/
test.concurrent(`${chalk.yellowBright("reset-after-trial-end 3: default - reset at trial end")}`, async () => {
test.concurrent(`${chalk.yellowBright("reset-after-trial-end 3: no options - reset at trial end")}`, async () => {
const customerId = "reset-trial-end-default";
const messagesItem = items.monthlyMessages({ includedUsage: 500 });
@@ -256,13 +246,9 @@ test.concurrent(`${chalk.yellowBright("reset-after-trial-end 4: true but no tria
customer_id: customerId,
product_id: pro.id,
redirect_mode: "if_required",
options: [
{
feature_id: TestFeature.Messages,
quantity: 500,
reset_after_trial_end: true,
},
],
transition_rules: {
reset_after_trial_end: [TestFeature.Messages],
},
});
const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
@@ -288,13 +274,11 @@ test.concurrent(`${chalk.yellowBright("reset-after-trial-end 4: true but no tria
/**
* Scenario:
* - Product has 7-day trial + monthly messages + monthly words
* - Attach with:
* - messages: reset_after_trial_end: true (billing cycle after trial)
* - words: reset_after_trial_end: false (reset at trial end)
* - Attach with reset_after_trial_end: [messages] (only messages, not words)
*
* Expected Result:
* - messages next_reset_at = advancedTo + 7 days + 30 days (trial end + cycle)
* - words next_reset_at = advancedTo + 7 days (trial end)
* - words next_reset_at = advancedTo + 7 days (trial end) - not in array, uses default
*/
test.concurrent(`${chalk.yellowBright("reset-after-trial-end 5: per-feature config")}`, async () => {
const customerId = "reset-trial-end-per-feature";
@@ -317,23 +301,14 @@ test.concurrent(`${chalk.yellowBright("reset-after-trial-end 5: per-feature conf
actions: [],
});
// Attach with different configs per feature
// Attach with reset_after_trial_end only for messages (not words)
await autumnV1.billing.attach({
customer_id: customerId,
product_id: proTrial.id,
redirect_mode: "if_required",
options: [
{
feature_id: TestFeature.Messages,
quantity: 500,
reset_after_trial_end: true, // Billing cycle starts after trial
},
{
feature_id: TestFeature.Words,
quantity: 1000,
reset_after_trial_end: false, // Reset at trial end
},
],
transition_rules: {
reset_after_trial_end: [TestFeature.Messages], // Only messages, not words
},
});
const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
@@ -417,13 +392,9 @@ test.concurrent(`${chalk.yellowBright("reset-after-trial-end 6: upgrade with tri
customer_id: customerId,
product_id: proTrial.id,
redirect_mode: "if_required",
options: [
{
feature_id: TestFeature.Messages,
quantity: 500,
reset_after_trial_end: true,
},
],
transition_rules: {
reset_after_trial_end: [TestFeature.Messages],
},
});
const customerAfter = await autumnV1.customers.get<ApiCustomerV3>(customerId);
@@ -488,13 +459,9 @@ test.concurrent(`${chalk.yellowBright("reset-after-trial-end 7: true with long t
customer_id: customerId,
product_id: proLongTrial.id,
redirect_mode: "if_required",
options: [
{
feature_id: TestFeature.Messages,
quantity: 500,
reset_after_trial_end: true,
},
],
transition_rules: {
reset_after_trial_end: [TestFeature.Messages],
},
});
const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);

204
server/tests/integration/billing/attach/scheduled-switch/scheduled-switch-discounts.test.ts
View File

@@ -61,19 +61,25 @@ const extractCouponId = (discount: unknown): string | null => {
};
// ═══════════════════════════════════════════════════════════════════════════════
// TEST 1: Premium to Pro with 20% discount - verify discount on sub after schedule
// TEST 1: Premium to Pro with 20% discount - verify discount preserved through cycle
// ═══════════════════════════════════════════════════════════════════════════════
/**
* Scenario:
* - Customer has premium ($50/mo) with 20% off coupon on subscription
* - Downgrade to pro ($20/mo) - scheduled for end of cycle
* - Advance test clock to next billing cycle
*
* Expected Result:
* - Discount still present on Stripe subscription after scheduling the downgrade
* - Premium is canceling, pro is scheduled
* - After cycle: pro is active, premium removed
* - Discount should STILL be on the subscription after the phase transition
*
* THIS TEST EXPOSES THE BUG: subscription schedule phases don't carry discounts,
* so when the subscription transitions to the pro phase, the discount is lost.
*/
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 1: 20% discount preserved after scheduling downgrade")}`, async () => {
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 1: 20% discount preserved after scheduling and cycle advance")}`, async () => {
const customerId = "sched-switch-discount-20pct";
const proMessagesItem = items.monthlyMessages({ includedUsage: 500 });
@@ -90,7 +96,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 1: 20% discoun
items: [premiumMessagesItem],
});
const { autumnV1 } = await initScenario({
const { autumnV1, ctx, testClockId, advancedTo } = await initScenario({
customerId,
setup: [
s.customer({ paymentMethod: "success" }),
@@ -128,7 +134,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 1: 20% discoun
redirect_mode: "if_required",
});
// Verify product states
// Verify product states after scheduling
const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
await expectProductCanceling({
customer,
@@ -140,16 +146,57 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 1: 20% discoun
});
// Verify discount is still on the subscription after scheduling the downgrade
const { subscription: subAfter } = await getStripeSubscription({
const { subscription: subAfterSchedule } = await getStripeSubscription({
customerId,
});
const subAfterExpanded = await stripeCli.subscriptions.retrieve(subAfter.id, {
expand: ["discounts.source.coupon"],
const subAfterScheduleExpanded = await stripeCli.subscriptions.retrieve(
subAfterSchedule.id,
{ expand: ["discounts.source.coupon"] },
);
expect(subAfterScheduleExpanded.discounts?.length).toBeGreaterThanOrEqual(1);
expect(extractCouponId(subAfterScheduleExpanded.discounts?.[0])).toBe(
coupon.id,
);
// Advance to next billing cycle
await advanceToNextInvoice({
stripeCli: ctx.stripeCli,
testClockId: testClockId!,
currentEpochMs: advancedTo,
withPause: true,
});
// KEY ASSERTION: discount should still be present
expect(subAfterExpanded.discounts?.length).toBeGreaterThanOrEqual(1);
expect(extractCouponId(subAfterExpanded.discounts?.[0])).toBe(coupon.id);
const customerAfterCycle =
await autumnV1.customers.get<ApiCustomerV3>(customerId);
// Verify pro is active, premium removed
await expectCustomerProducts({
customer: customerAfterCycle,
active: [pro.id],
notPresent: [premium.id],
});
// Verify features updated to pro tier
expectCustomerFeatureCorrect({
customer: customerAfterCycle,
featureId: TestFeature.Messages,
includedUsage: 500,
balance: 500,
usage: 0,
});
// KEY BUG CHECK: verify discount survives the phase transition
const { subscription: subAfterCycle } = await getStripeSubscription({
customerId,
});
const subAfterCycleExpanded = await stripeCli.subscriptions.retrieve(
subAfterCycle.id,
{ expand: ["discounts.source.coupon"] },
);
// The discount should still be present after the scheduled switch completed
expect(subAfterCycleExpanded.discounts?.length).toBeGreaterThanOrEqual(1);
expect(extractCouponId(subAfterCycleExpanded.discounts?.[0])).toBe(coupon.id);
});
// ═══════════════════════════════════════════════════════════════════════════════
@@ -237,128 +284,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 2: $10 off dis
});
// ═══════════════════════════════════════════════════════════════════════════════
// TEST 3: Premium to Pro with discount - advance cycle, verify discount survives
// ═══════════════════════════════════════════════════════════════════════════════
/**
* Scenario:
* - Customer has premium ($50/mo) with 20% off coupon
* - Downgrade to pro ($20/mo) - scheduled
* - Advance test clock to next billing cycle
*
* Expected Result:
* - After cycle: pro is active, premium removed
* - Discount should STILL be on the subscription after the phase transition
*
* THIS TEST EXPOSES THE BUG: subscription schedule phases don't carry discounts,
* so when the subscription transitions to the pro phase, the discount is lost.
*/
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 3: 20% discount preserved after cycle advance")}`, async () => {
const customerId = "sched-switch-discount-cycle";
const proMessagesItem = items.monthlyMessages({ includedUsage: 500 });
const pro = products.pro({
id: "pro",
items: [proMessagesItem],
});
const premiumMessagesItem = items.monthlyMessages({
includedUsage: 1000,
});
const premium = products.premium({
id: "premium",
items: [premiumMessagesItem],
});
const { autumnV1, ctx, testClockId, advancedTo } = await initScenario({
customerId,
setup: [
s.customer({ paymentMethod: "success" }),
s.products({ list: [pro, premium] }),
],
actions: [s.billing.attach({ productId: premium.id })],
});
// Apply 20% discount to the subscription
const { stripeCli, subscription: subBefore } = await getStripeSubscription({
customerId,
});
const coupon = await createPercentCoupon({
stripeCli,
percentOff: 20,
});
await applySubscriptionDiscount({
stripeCli,
subscriptionId: subBefore.id,
couponIds: [coupon.id],
});
// Verify discount applied before downgrade
const subWithDiscount = await stripeCli.subscriptions.retrieve(subBefore.id, {
expand: ["discounts.source.coupon"],
});
expect(subWithDiscount.discounts?.length).toBeGreaterThanOrEqual(1);
// Schedule downgrade to pro
await autumnV1.billing.attach({
customer_id: customerId,
product_id: pro.id,
redirect_mode: "if_required",
});
// Verify discount still present after scheduling
const { subscription: subMid } = await getStripeSubscription({
customerId,
});
const subMidExpanded = await stripeCli.subscriptions.retrieve(subMid.id, {
expand: ["discounts.source.coupon"],
});
expect(subMidExpanded.discounts?.length).toBeGreaterThanOrEqual(1);
// Advance to next billing cycle (discount is still on the subscription)
await advanceToNextInvoice({
stripeCli: ctx.stripeCli,
testClockId: testClockId!,
currentEpochMs: advancedTo,
withPause: true,
});
const customerAfterCycle =
await autumnV1.customers.get<ApiCustomerV3>(customerId);
// Verify pro is active, premium removed
await expectCustomerProducts({
customer: customerAfterCycle,
active: [pro.id],
notPresent: [premium.id],
});
// Verify features updated to pro tier
expectCustomerFeatureCorrect({
customer: customerAfterCycle,
featureId: TestFeature.Messages,
includedUsage: 500,
balance: 500,
usage: 0,
});
// KEY BUG CHECK: verify discount survives the phase transition
const { subscription: subAfterCycle } = await getStripeSubscription({
customerId,
});
const subAfterExpanded = await stripeCli.subscriptions.retrieve(
subAfterCycle.id,
{ expand: ["discounts.source.coupon"] },
);
// The discount should still be present after the scheduled switch completed
expect(subAfterExpanded.discounts?.length).toBeGreaterThanOrEqual(1);
});
// ═══════════════════════════════════════════════════════════════════════════════
// TEST 4: Premium to Pro (scheduled) to Free (replace) - discount preserved
// TEST 3: Premium to Pro (scheduled) to Free (replace) - discount preserved
// ═══════════════════════════════════════════════════════════════════════════════
/**
@@ -373,7 +299,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 3: 20% discoun
* The schedule is released and recreated during replacement. This test verifies
* that the discount survives the release + recreate cycle.
*/
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 4: discount preserved when replacing scheduled downgrade")}`, async () => {
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 3: discount preserved when replacing scheduled downgrade")}`, async () => {
const customerId = "sched-switch-discount-replace";
const messagesItem = items.monthlyMessages({ includedUsage: 100 });
@@ -472,7 +398,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 4: discount pr
});
// ═══════════════════════════════════════════════════════════════════════════════
// TEST 5: Multiple discounts preserved after scheduled downgrade
// TEST 4: Multiple discounts preserved after scheduled downgrade
// ═══════════════════════════════════════════════════════════════════════════════
/**
@@ -483,7 +409,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 4: discount pr
* Expected Result:
* - Both discounts still present on subscription after scheduling
*/
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 5: multiple discounts preserved after scheduling")}`, async () => {
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 4: multiple discounts preserved after scheduling")}`, async () => {
const customerId = "sched-switch-discount-multi";
const proMessagesItem = items.monthlyMessages({ includedUsage: 500 });
@@ -568,7 +494,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 5: multiple di
});
// ═══════════════════════════════════════════════════════════════════════════════
// TEST 6: Upgrade from scheduled downgrade - discount preserved
// TEST 5: Upgrade from scheduled downgrade - discount preserved
// ═══════════════════════════════════════════════════════════════════════════════
/**
@@ -581,7 +507,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 5: multiple di
* - Discount should still be on the subscription after upgrade cancels the schedule
* - Ultra is active, premium and pro are removed
*/
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 6: discount preserved after upgrade cancels scheduled downgrade")}`, async () => {
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 5: discount preserved after upgrade cancels scheduled downgrade")}`, async () => {
const customerId = "sched-switch-discount-upgrade";
const proMessagesItem = items.monthlyMessages({ includedUsage: 500 });
@@ -674,7 +600,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 6: discount pr
});
// ═══════════════════════════════════════════════════════════════════════════════
// TEST 7: Repeating coupon duration preserved across phase transition
// TEST 6: Repeating coupon duration preserved across phase transition
// ═══════════════════════════════════════════════════════════════════════════════
/**
@@ -693,7 +619,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 6: discount pr
* creates a fresh discount with a reset duration, instead of using
* `discount: discountId` to preserve the original duration.
*/
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 7: repeating coupon duration preserved across phase transition")}`, async () => {
test.concurrent(`${chalk.yellowBright("scheduled-switch-discounts 6: repeating coupon duration preserved across phase transition")}`, async () => {
const customerId = "sched-switch-discount-duration";
const proMessagesItem = items.monthlyMessages({ includedUsage: 500 });

2
server/tests/integration/billing/attach/scheduled-switch/scheduled-switch-rollover.test.ts
View File

@@ -82,7 +82,7 @@ test.concurrent(`${chalk.yellowBright("scheduled-switch-rollover 1: downgrade wi
s.products({ list: [pro, free] }),
],
actions: [
s.billing.attach({ productId: pro.id, timeout: 2000 }),
s.billing.attach({ productId: pro.id }),
s.track({ featureId: TestFeature.Messages, value: 300, timeout: 2000 }),
s.resetFeature({ featureId: TestFeature.Messages }), // Creates rollover of 200 (500 - 300)
s.billing.attach({ productId: free.id, timeout: 2000 }), // Schedule downgrade

4
server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-trial-entities.test.ts
View File

@@ -697,7 +697,7 @@ test.concurrent(`${chalk.yellowBright("cancel trial EOC entities: cancel entity
s.entities({ count: 2, featureId: TestFeature.Users }),
],
actions: [
s.attach({ productId: proTrial.id, entityIndex: 0 }),
s.attach({ productId: proTrial.id, entityIndex: 0, timeout: 8000 }),
// Cancel entity 1 at end of cycle
s.updateSubscription({
@@ -707,7 +707,7 @@ test.concurrent(`${chalk.yellowBright("cancel trial EOC entities: cancel entity
}),
// Attach proTrial to entity 2
s.attach({ productId: proTrial.id, entityIndex: 1, timeout: 4000 }),
s.attach({ productId: proTrial.id, entityIndex: 1, timeout: 8000 }),
],
},
);

17
server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-consumable.test.ts
View File

@@ -170,12 +170,17 @@ test.concurrent(`${chalk.yellowBright("cancel immediately consumable: entity - t
// Track 500 messages on entity (100 included, 400 overage)
// Note: This overage will NOT be charged when canceling immediately
await autumnV1.track({
customer_id: customerId,
entity_id: entityId,
feature_id: TestFeature.Messages,
value: 500,
});
await autumnV1.track(
{
customer_id: customerId,
entity_id: entityId,
feature_id: TestFeature.Messages,
value: 500,
},
{
timeout: 4000,
},
);
// Preview cancel immediately
const cancelParams = {

1
server/tests/integration/billing/update-subscription/cancel/uncancel/uncancel-basic.test.ts
View File

@@ -350,7 +350,6 @@ test.concurrent(`${chalk.yellowBright("error: uncancel expired product")}`, asyn
// Try to uncancel the expired product - should error
await expectAutumnError({
errCode: ErrCode.InternalError,
func: async () => {
await autumnV1.subscriptions.update({
customer_id: customerId,

20
server/tests/integration/billing/update-subscription/cancel/uncancel/uncancel-edge-cases.test.ts
View File

@@ -494,28 +494,24 @@ test.concurrent(`${chalk.yellowBright("uncancel + items + invoice mode")}`, asyn
const customMessagesItem = items.monthlyMessages({ includedUsage: 200 });
const customPriceItem = items.monthlyPrice({ price: 40 });
// Preview
const preview = await autumnV1.subscriptions.previewUpdate({
const updateParams = {
customer_id: customerId,
product_id: pro.id,
cancel_action: "uncancel",
items: [customMessagesItem, customPriceItem],
invoice: true,
finalize_invoice: true,
});
enable_product_immediately: true,
};
// Preview
const preview = await autumnV1.subscriptions.previewUpdate(updateParams);
// Should charge prorated difference ($40 - $20 = $20 prorated)
expect(preview.total).toBeGreaterThan(0);
expect(preview.total).toBe(20);
// Execute uncancel + items with invoice mode
const updateResult = await autumnV1.subscriptions.update({
customer_id: customerId,
product_id: pro.id,
cancel_action: "uncancel",
items: [customMessagesItem, customPriceItem],
invoice: true,
finalize_invoice: true,
});
const updateResult = await autumnV1.subscriptions.update(updateParams);
// Should return invoice info (finalized but awaiting payment)
expect(updateResult.invoice).toBeDefined();

87
server/tests/integration/billing/update-subscription/custom-plan/update-one-off.test.ts
View File

@@ -194,90 +194,3 @@ test.concurrent(`${chalk.yellowBright("one-off: remove boolean feature")}`, asyn
});
});
// Update prepaid item included usage on one-off product
test.concurrent(`${chalk.yellowBright("one-off: update prepaid item included usage")}`, async () => {
const billingUnits = 100;
const price = 10;
const oldIncludedUsage = 50;
const prepaidItem = items.oneOffMessages({
includedUsage: oldIncludedUsage,
billingUnits,
price,
});
const oneOffProduct = products.base({
items: [prepaidItem],
id: "one-off-prepaid-included",
});
const quantity = 200; // 2 packs
const { customerId, autumnV1 } = await initScenario({
customerId: "one-off-prepaid-included",
setup: [
s.customer({ paymentMethod: "success" }),
s.products({ list: [oneOffProduct] }),
],
actions: [
s.attach({
productId: oneOffProduct.id,
options: [{ feature_id: TestFeature.Messages, quantity }],
timeout: 4000,
}),
],
});
// Track some usage
const messagesUsed = 100;
await autumnV1.track(
{
customer_id: customerId,
feature_id: TestFeature.Messages,
value: messagesUsed,
},
{ timeout: 2000 },
);
// Update included usage from 50 to 100 (same quantity)
const newIncludedUsage = 100;
const updatedPrepaidItem = items.oneOffMessages({
includedUsage: newIncludedUsage,
billingUnits,
price,
});
const updateParams = {
customer_id: customerId,
product_id: oneOffProduct.id,
items: [updatedPrepaidItem],
options: [
{
feature_id: TestFeature.Messages,
quantity: quantity + newIncludedUsage,
},
],
};
const preview = await autumnV1.subscriptions.previewUpdate(updateParams);
// No charge for changing included usage (same packs)
expect(preview.total).toBe(0);
await autumnV1.subscriptions.update(updateParams);
const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
// Total included = newIncludedUsage + quantity = 100 + 200 = 300
expectCustomerFeatureCorrect({
customer,
featureId: TestFeature.Messages,
includedUsage: newIncludedUsage + quantity,
balance: newIncludedUsage + quantity - messagesUsed,
usage: messagesUsed,
});
await expectCustomerInvoiceCorrect({
customer,
count: 1, // Only initial invoice (no new charge)
latestTotal: (quantity / billingUnits) * price, // 2 packs for initial
});
});

1
server/tests/integration/billing/update-subscription/errors/update-feature-quantity-errors.test.ts
View File

@@ -139,7 +139,6 @@ test.concurrent(`${chalk.yellowBright("error: negative quantity for prepaid feat
};
await expectAutumnError({
errMessage: "Options quantity must be >= 0",
func: async () => {
await autumnV1.subscriptions.update(updateParams);
},

64
server/tests/integration/billing/update-subscription/errors/update-one-off-errors.test.ts
View File

@@ -285,3 +285,67 @@ test.concurrent(`${chalk.yellowBright("error: remove trial and add one-off item"
},
});
});
// Update prepaid item included usage on one-off product
test.concurrent(`${chalk.yellowBright("one-off: update prepaid item included usage")}`, async () => {
const billingUnits = 100;
const price = 10;
const oldIncludedUsage = 50;
const prepaidItem = items.oneOffMessages({
includedUsage: oldIncludedUsage,
billingUnits,
price,
});
const oneOffProduct = products.base({
items: [prepaidItem],
id: "one-off-prepaid-included",
});
const quantity = 200; // 2 packs
const { customerId, autumnV1 } = await initScenario({
customerId: "one-off-prepaid-included",
setup: [
s.customer({ paymentMethod: "success" }),
s.products({ list: [oneOffProduct] }),
],
actions: [
s.attach({
productId: oneOffProduct.id,
options: [{ feature_id: TestFeature.Messages, quantity }],
timeout: 4000,
}),
],
});
// Track some usage
const messagesUsed = 100;
await autumnV1.track(
{
customer_id: customerId,
feature_id: TestFeature.Messages,
value: messagesUsed,
},
{ timeout: 2000 },
);
// Update included usage from 50 to 100 (same quantity)
const newIncludedUsage = 100;
const updatedPrepaidItem = items.oneOffMessages({
includedUsage: newIncludedUsage,
billingUnits,
price,
});
const updateParams = {
customer_id: customerId,
product_id: oneOffProduct.id,
items: [updatedPrepaidItem],
};
await expectAutumnError({
func: async () => {
await autumnV1.subscriptions.update(updateParams);
},
});
});

5
server/tests/integration/billing/update-subscription/invoice/update-quantity-invoice-mode.test.ts
View File

@@ -1,5 +1,5 @@
import { expect, test } from "bun:test";
import type { ApiCustomerV3 } from "@autumn/shared";
import { type ApiCustomerV3, CusExpand } from "@autumn/shared";
import { TestFeature } from "@tests/setup/v2Features.js";
import { items } from "@tests/utils/fixtures/items.js";
import { products } from "@tests/utils/fixtures/products.js";
@@ -73,6 +73,8 @@ test.concurrent(`${chalk.yellowBright("update-quantity: default invoice mode (dr
{ feature_id: TestFeature.Messages, quantity: 15 * billingUnits },
],
invoice: true,
enable_product_immediately: true,
finalize_invoice: false,
});
const afterUpdate = await CusService.getFull({
@@ -80,6 +82,7 @@ test.concurrent(`${chalk.yellowBright("update-quantity: default invoice mode (dr
idOrInternalId: customerId,
orgId: ctx.org.id,
env: ctx.env,
expand: [CusExpand.Invoices],
});
const afterCustomerProduct = afterUpdate.customer_products.find(

19
shared/api/billing/common/billingPreviewResponse.ts
View File

@@ -6,10 +6,9 @@ export const PreviewLineItemSchema = z.object({
description: z.string(),
amount: z.number(),
discounts: z.array(LineItemDiscountSchema).default([]),
is_base: z.boolean().optional(),
plan_id: z.string(),
total_quantity: z.number(),
paid_quantity: z.number(),
plan_id: z.string(),
deferred_for_trial: z.boolean().optional(),
effective_period: z
.object({
@@ -17,6 +16,8 @@ export const PreviewLineItemSchema = z.object({
end: z.number(),
})
.optional(),
is_base: z.boolean().optional(),
});
export type PreviewLineItem = z.infer<typeof PreviewLineItemSchema>;
@@ -31,13 +32,13 @@ export const BillingPreviewResponseSchema = z.object({
period_start: z.number().optional(),
period_end: z.number().optional(),
/** Credit from excess refund (e.g. unused time on previous plan exceeds new charge). Applied to next invoice(s) by Stripe. */
credit: z
.object({
amount: z.number(),
description: z.string(),
})
.optional(),
// /** Credit from excess refund (e.g. unused time on previous plan exceeds new charge). Applied to next invoice(s) by Stripe. */
// credit: z
// .object({
// amount: z.number(),
// description: z.string(),
// })
// .optional(),
next_cycle: z
.object({

19
shared/api/products/crud/mappers/planParamsV1ToProductV2.ts
View File

@@ -41,20 +41,21 @@ export function planParamsV1ToProductV2({
return {
id: params.id, // fallback just for placeholders...
name: params.name,
description: params.description ?? null,
description: params.description,
is_add_on: params.add_on,
is_default: params.auto_enable,
group: params.group ?? "",
items,
free_trial: params.free_trial
? {
duration: params.free_trial.duration_type,
length: params.free_trial.duration_length,
unique_fingerprint: false,
card_required: params.free_trial.card_required,
}
: null,
free_trial:
params.free_trial !== undefined
? {
duration: params.free_trial.duration_type,
length: params.free_trial.duration_length,
unique_fingerprint: false,
card_required: params.free_trial.card_required,
}
: undefined,
...(archived !== undefined && { archived }),
};
}