Code Complexity Auditor

Complexity Audit — src/services/checkout.ts

Functions scanned: 14 · Thresholds: cyclomatic 10, cognitive 15, params 5, length 60

Findings

processCheckout Critical

A single function body handles inventory validation, coupon stacking, tax, payment dispatch, and order record creation. The nested coupon-stacking conditionals alone contribute 11 cyclomatic points. Test coverage on this function is currently 41%, and three of the last five production incidents on checkout traced back here.

Refactor. Decompose into five focused functions. Each extracted function preserves the return type and side-effect contract of the corresponding block, so the public signature is unchanged.

// AFTER
async function processCheckout(cart: Cart, user: User, options: CheckoutOptions): Promise<OrderResult> {
  await validateInventory(cart);
  const discountedCart = await applyCoupons(cart, options.couponCodes);
  const taxedCart = await applyTax(discountedCart, user.address);
  const paymentResult = await dispatchPayment(taxedCart, user.paymentMethod);
  return createOrderRecord(taxedCart, user, paymentResult);
}

async function validateInventory(cart: Cart): Promise<void> {
  for (const item of cart.items) {
    const stock = await inventoryService.getStock(item.sku);
    if (stock < item.quantity) {
      throw new InsufficientStockError(item.sku, stock, item.quantity);
    }
  }
}

async function applyCoupons(cart: Cart, codes: string[]): Promise<Cart> {
  let discounted = { ...cart };
  for (const code of codes) {
    const coupon = await couponService.resolve(code);
    discounted = coupon.apply(discounted);
  }
  return discounted;
}

applyDiscountRules High

Six positional parameters (loyaltyTier, promoCode, isEmployee, cartTotal, itemCount, regionCode) and three levels of nested coupon-stacking logic. The parameter list alone is a maintenance trap — call sites have already swapped arguments twice in the past 90 days according to git blame.

Refactor. Introduce a DiscountContext value object and a tier-rate map. Keep the original signature as a thin shim so call sites do not change.

interface DiscountContext {
  loyaltyTier: string;
  promoCode: string | null;
  isEmployee: boolean;
  cartTotal: number;
  itemCount: number;
  regionCode: string;
}

function applyDiscountRulesFromContext(ctx: DiscountContext): number {
  const base = resolveBaseDiscount(ctx);
  const promo = resolvePromoDiscount(ctx.promoCode, ctx.cartTotal);
  return Math.min(base + promo, ctx.cartTotal);
}

function resolveBaseDiscount(ctx: DiscountContext): number {
  if (ctx.isEmployee) return ctx.cartTotal * 0.20;
  const rates: Record<string, number> = { gold: 0.15, silver: 0.10, bronze: 0.05 };
  return ctx.cartTotal * (rates[ctx.loyaltyTier] ?? 0);
}

Estimated after refactor: cyclomatic 2, cognitive 2.

buildOrderSummary Medium

Exceeds length threshold (74 lines) but branching is flat and linear. Low incident risk, but extraction improves readability and unit-test isolation for the currency and address formatters.

Refactor. Extract formatCustomerName, formatAddress, formatLineItem, formatTotals. No behavioral change.

resolvePaymentRouting Justifiable Exception

Cyclomatic 19 encodes a 16-rule gateway-selection state machine driven by regional financial compliance. Each branch maps to a documented regulatory citation. Cognitive complexity stays at 14 (below threshold) because the branching is structurally flat — a single switch on regionCode + paymentMethodKind. Decomposing would scatter the rule set across files and raise the risk of inconsistent updates when a rule changes.

Action. No refactor. Add a rule-table comment block above the function mapping each branch to its compliance reference.

Recommended Refactor Order

Before / After Summary

This audit reviews a hypothetical file for illustration. Run the proposed changes behind a feature-flagged checkout shadow before retiring the original code path.

This sample illustrates the skill's output format. Names, metrics, and operational details are illustrative unless the artifact explicitly analyzes public information.