Landing ──→ Checkout ──payment.success──→ Cap OTO
                                            │
                         accepted ──────────┤──→ Tote OTO ──→ Thank you
                         declined ──────────┘──→ Cap downsell
                                                    │
                                 accepted ──────────┤──→ Tote OTO ──→ Thank you
                                 declined ──────────┘──→ Thank you

const order = await tagada.customer.getOrder(orderId, { waitForRelatedOrders: true });
// order.items              → tee
// order.relatedOrders[0]   → cap (if they accepted the OTO)
// order.relatedOrders[1]   → tote (if they accepted the second offer)

import Tagada from '@tagadapay/node-sdk';

const tagada = new Tagada('your-api-key');
const STORE_ID = 'store_...';

// 1. Products — tee, cap, cap-sale, tote (see Node SDK upsell tutorial for the full create shape)
const tee = await tagada.products.create({ /* $29.99 */ });
const cap = await tagada.products.create({ /* $19.99 */ });
const capSale = await tagada.products.create({ /* $14.99 */ });
const tote = await tagada.products.create({ /* $24.00 */ });

const price = (product: { variants: { prices: { id: string }[] }[] }) =>
  product.variants[0].prices[0].id;

// 2. Offers
const capOffer = await tagada.checkoutOffers.create({
  storeId: STORE_ID,
  type: 'upsell',
  titleTrans: { en: 'Essential Cap — $19.99' },
  lineItems: [{ priceId: price(cap), quantity: 1 }],
});
const capDownsell = await tagada.checkoutOffers.create({
  storeId: STORE_ID,
  type: 'upsell',
  titleTrans: { en: 'Essential Cap — $14.99' },
  lineItems: [{ priceId: price(capSale), quantity: 1 }],
});
const toteOffer = await tagada.checkoutOffers.create({
  storeId: STORE_ID,
  type: 'upsell',
  titleTrans: { en: 'Essential Tote — $24' },
  lineItems: [{ priceId: price(tote), quantity: 1 }],
});

// 3. Funnel
const funnel = await tagada.funnels.create({
  storeId: STORE_ID,
  config: {
    name: 'Basic post-purchase',
    version: '1.0.0',
    nodes: [
      {
        id: 'step_landing',
        name: 'Landing',
        kind: 'step',
        type: 'landing',
        isEntry: true,
        position: { x: 0, y: 0 },
        config: { path: '/' },
      },
      {
        id: 'step_checkout',
        name: 'Checkout',
        kind: 'step',
        type: 'checkout',
        position: { x: 400, y: 0 },
        config: { path: '/checkout' },
      },
      {
        id: 'step_cap',
        name: 'Cap OTO',
        kind: 'step',
        type: 'offer',
        position: { x: 800, y: 0 },
        config: {
          path: '/offer/:orderId',
          stepConfig: { resources: { offer: capOffer.id } },
        },
      },
      {
        id: 'step_downsell',
        name: 'Cap downsell',
        kind: 'step',
        type: 'offer',
        position: { x: 800, y: 180 },
        config: {
          path: '/downsell/:orderId',
          stepConfig: { resources: { offer: capDownsell.id } },
        },
      },
      {
        id: 'step_tote',
        name: 'Tote OTO',
        kind: 'step',
        type: 'offer',
        position: { x: 1200, y: 0 },
        config: {
          path: '/offer-tote/:orderId',
          stepConfig: { resources: { offer: toteOffer.id } },
        },
      },
      {
        id: 'step_thankyou',
        name: 'Thank You',
        kind: 'step',
        type: 'thankyou',
        position: { x: 1600, y: 0 },
        config: { path: '/thankyou/:orderId' },
      },
    ],
    edges: [
      { id: 'e_land', source: 'step_landing', target: 'step_checkout' },
      {
        id: 'e_pay',
        source: 'step_checkout',
        target: 'step_cap',
        conditions: { when: 'payment.success' },
      },
      {
        id: 'e_cap_yes',
        source: 'step_cap',
        target: 'step_tote',
        conditions: { when: 'offer.accepted' },
      },
      {
        id: 'e_cap_no',
        source: 'step_cap',
        target: 'step_downsell',
        conditions: { when: 'offer.declined' },
      },
      {
        id: 'e_ds_yes',
        source: 'step_downsell',
        target: 'step_tote',
        conditions: { when: 'offer.accepted' },
      },
      {
        id: 'e_ds_no',
        source: 'step_downsell',
        target: 'step_thankyou',
        conditions: { when: 'offer.declined' },
      },
      { id: 'e_tote', source: 'step_tote', target: 'step_thankyou' },
    ],
  },
});

await tagada.funnels.update(funnel.id, { storeId: STORE_ID, config: funnel.config });

const session = await tagada.checkout.createSession({
  storeId: STORE_ID,
  items: [{ variantId: tee.variants[0].id, quantity: 1 }],
  currency: 'USD',
  checkoutUrl, // from the mounted checkout node
});

import { createHeadlessClient } from '@tagadapay/headless-sdk';

const tagada = createHeadlessClient({
  storeId: 'store_xxx',
  environment: 'production',
});

// 1. Landing CTA
const { url } = await tagada.checkout.createSessionUrl({
  items: [{ variantId: 'variant_tee', quantity: 1 }],
  currency: 'USD',
  checkoutPath: '/checkout',
});
window.location.href = url;

// 2. /checkout — tokens from the query string
const tokens = tagada.checkout.parseTokensFromUrl();
if (!tokens) throw new Error('no checkoutToken in URL — send the shopper back to the landing');
const session = await tagada.checkout.loadSession(tokens.checkoutToken, tokens.sessionToken);
await tagada.checkout.updateCustomer(session.id, { email, firstName, lastName });
await tagada.checkout.updateAddress(session.id, { shippingAddress });
const { tagadaToken } = await tagada.payment.tokenizeCard({ cardNumber, expiryDate, cvc });
const paid = await tagada.payment.processPayment({
  checkoutSessionId: session.id,
  tagadaToken,
});
if (paid.status !== 'succeeded' || !paid.order?.id) throw new Error('pay failed');
const orderId = paid.order.id;
window.location.href = `/offer?orderId=${orderId}`;

// 3. /offer — pin the cap offer id
const oto = await tagada.offers.processOfferPayment({
  offerId: 'offer_cap',
  mainOrderId: orderId,
  returnUrl: window.location.href,
});
window.location.href = oto.status === 'succeeded'
  ? `/offer-tote?orderId=${orderId}`
  : `/downsell?orderId=${orderId}`; // or just go here on "No thanks"

// 4. /thank-you — waits for the upsell child orders (max 8s), never throws
const order = await tagada.customer.getOrder(orderId, { waitForRelatedOrders: true });
// order.items + order.relatedOrders — one child order per accepted offer

import { useOrder } from '@tagadapay/headless-sdk/react';

const { order, relatedOrders } = useOrder(orderId);
// Main order paints immediately; upsells pop in when their child orders land.