@teleporthq/teleport-plugin-next-workflows 0.43.65 → 0.43.66

package/__tests__/cart-clear-db-mirror.test.ts

@@ -1,3 +1,4 @@
+import { RegionalPricing } from '@teleporthq/teleport-shared'
 import { cartClear } from '../src/nodes/cart/cart-clear'
 
 // Regression: after a cash-on-delivery order the buyer's cart came back.
@@ -42,4 +43,15 @@ describe('cart-clear mirrors the empty cart into the database cart', () => {
   it('stamps the clear so the provider can tell it apart from a first visit', () => {
     expect(handlerCode).toContain("localStorage.setItem('workflow_cart_cleared_at'")
   })
+
+  it('forgets the shipping method picked for the emptied cart', () => {
+    // Otherwise the next order silently pre-selects (and charges) a rate the
+    // buyer chose for a previous one instead of the cheapest.
+    expect(handlerCode).toContain(
+      `localStorage.removeItem('${RegionalPricing.SHIPPING_RATE_STORAGE_KEY}')`
+    )
+    expect(handlerCode).toContain(
+      `dispatchEvent(new CustomEvent('${RegionalPricing.SHIPPING_RATE_CHANGED_EVENT}'))`
+    )
+  })
 })

package/__tests__/cart-get-total-regional-pricing.test.ts

@@ -0,0 +1,166 @@
+/* tslint:disable:no-eval */
+import { cartGetTotal } from '../src/nodes/cart/cart-get-total'
+import { resolveHandlerEntryName } from '../src/nodes/types'
+
+/**
+ * `cart-get-total` is where the place-order workflow's money comes from, so on
+ * a store with shipping zones and tax jurisdictions it re-prices the basket AT
+ * SUBMIT — for the address on the checkout form at that moment, from the rows
+ * the provider displayed — with the same shared rule the provider uses.
+ *
+ * A store without the feature must come out exactly as before: no `regional`
+ * key, and the untouched single-rate fields.
+ */
+
+function evalHandler(code: string): any {
+  return eval('(' + code + ')')
+}
+
+const runHandler = async () => evalHandler(cartGetTotal.generateHandler())()
+
+function mount(storage: Record<string, unknown>, fields: Record<string, string>): void {
+  const store: Record<string, string> = {}
+  for (const key of Object.keys(storage)) {
+    const value = storage[key]
+    store[key] = typeof value === 'string' ? value : JSON.stringify(value)
+  }
+  ;(global as any).localStorage = {
+    getItem: (key: string) => (key in store ? store[key] : null),
+  }
+  ;(global as any).document = {
+    querySelector: (selector: string) => {
+      const match = /^\[name="([^"]+)"\]$/.exec(selector)
+      const name = match ? match[1] : ''
+      return name in fields ? { value: fields[name] } : null
+    },
+  }
+}
+
+afterEach(() => {
+  delete (global as any).localStorage
+  delete (global as any).document
+})
+
+const STORE = {
+  deliveryEnabled: true,
+  storePickupEnabled: true,
+  deliveryPrice: 5,
+  freeDeliveryEnabled: false,
+  freeDeliveryThreshold: 0,
+  defaultTaxRate: 20,
+  defaultTaxIncluded: false,
+}
+
+const ROWS = {
+  zones: [{ id: 'z1', name: 'Germany', countries: 'DE', cod_enabled: 'f', is_active: 't' }],
+  rates: [
+    { id: 'r1', zone_id: 'z1', name: 'Standard', rate_type: 'flat', price: '10.00' },
+    { id: 'r2', zone_id: 'z1', name: 'Express', rate_type: 'flat', price: '20.00', sort_order: 1 },
+  ],
+  taxRates: [{ id: 't1', country_code: 'DE', rate: '19', tax_mode: 'added', tax_shipping: true }],
+}
+
+const CART = [{ id: 'l1', productId: 'p1', price: 100, quantity: 1 }]
+
+const settingsWith = (regional: Record<string, unknown> | null) => ({
+  maxQuantityPerProduct: null,
+  deliveryConfig: { deliveryPrice: 5, freeDeliveryEnabled: false, freeDeliveryThreshold: 0 },
+  taxConfig: { storefrontTaxRate: 20 },
+  ...(regional ? { regional } : {}),
+})
+
+const REGIONAL = {
+  store: STORE,
+  currency: 'EUR',
+  countryCodes: { germany: 'DE', brazil: 'BR' },
+  rows: ROWS,
+}
+
+describe('cart-get-total — regional pricing', () => {
+  it('stays one function expression whose entry point still resolves', () => {
+    const source = cartGetTotal.generateHandler()
+    expect(source.trim().startsWith('async function cart_get_total()')).toBe(true)
+    expect(resolveHandlerEntryName(source, 'cart-get-total')).toBe('cart_get_total')
+  })
+
+  it('adds no regional figures for a store without the feature', async () => {
+    mount({ workflow_cart: CART, workflow_cart_settings: settingsWith(null) }, {})
+    const out = await runHandler()
+    expect(out.regional).toBeUndefined()
+    expect(out.tax).toBe(20)
+    expect(out.total).toBe(120)
+  })
+
+  it("prices the destination read off the form, with the buyer's chosen rate", async () => {
+    mount(
+      {
+        workflow_cart: CART,
+        workflow_cart_settings: settingsWith(REGIONAL),
+        workflow_shipping_rate: 'r2',
+      },
+      { billingCountry: 'Germany', state: '' }
+    )
+    const out = await runHandler()
+    expect(out.subtotal).toBe(100)
+    expect(out.tax).toBe(19)
+    expect(out.total).toBe(119)
+    expect(out.regional).toMatchObject({
+      status: 'ok',
+      destination: { countryCode: 'DE', countryName: 'Germany' },
+      zoneName: 'Germany',
+      rateName: 'Express',
+      codAvailable: false,
+      goodsGross: 119,
+      shippingNet: 20,
+      shippingTax: 3.8,
+      shippingGross: 23.8,
+      taxRate: 19,
+      lines: [{ key: 'l1', productId: 'p1', unitGross: 119, taxRate: 19 }],
+    })
+  })
+
+  it('prices an address no zone lists at the store fee and default rate', async () => {
+    mount(
+      { workflow_cart: CART, workflow_cart_settings: settingsWith(REGIONAL) },
+      { billingCountry: 'Brazil', state: '' }
+    )
+    const out = await runHandler()
+    expect(out.regional).toMatchObject({
+      status: 'ok',
+      zoneName: '',
+      rateName: '',
+      codAvailable: true,
+      shippingNet: 5,
+      shippingGross: 5,
+    })
+    // Brazil has no tax row: the store default applies.
+    expect(out.tax).toBe(20)
+  })
+
+  it('prices the shipping address once its block is on the form', async () => {
+    mount(
+      { workflow_cart: CART, workflow_cart_settings: settingsWith(REGIONAL) },
+      { billingCountry: 'Germany', state: '', shippingCountry: 'Brazil', shippingState: '' }
+    )
+    const out = await runHandler()
+    expect(out.regional).toMatchObject({
+      status: 'ok',
+      zoneName: '',
+      shippingGross: 5,
+      destination: { countryCode: 'BR' },
+    })
+  })
+
+  it('falls back to the single-rate figures while the rows are still loading', async () => {
+    mount(
+      {
+        workflow_cart: CART,
+        workflow_cart_settings: settingsWith({ ...REGIONAL, rows: null }),
+      },
+      { billingCountry: 'Germany', state: '' }
+    )
+    const out = await runHandler()
+    expect(out.tax).toBe(20)
+    expect(out.regional).toMatchObject({ status: 'ok', shippingNet: 5, taxRate: 20 })
+  })
+})

package/__tests__/continue-on-error.test.ts

@@ -0,0 +1,119 @@
+import { generateSharedRuntimeUtilsCode, generateServerSegmentAPIRoute } from '../src'
+import type { WorkflowSegment } from '../src/types'
+
+// A node marked `continueOnError` reports a failed RESULT ({ success: false } /
+// { error }) under its id instead of aborting the workflow, so the next
+// if-statement can read `success` and warn. The default is unchanged: a
+// failed result aborts, and so does a handler that throws — with or without
+// the flag, because every provider handler reports failure as a result.
+
+interface SharedUtils {
+  executeNodes: (
+    nodes: unknown[],
+    edges: unknown[],
+    context: Record<string, unknown>,
+    handlers: Record<string, unknown>,
+    workflowConfig: unknown,
+    callServerSegment: unknown,
+    executionId: string
+  ) => Promise<void>
+  continuesOnError: (node: unknown) => boolean
+}
+
+function loadSharedRuntime(): SharedUtils {
+  const src = generateSharedRuntimeUtilsCode()
+  const wrapper: { exports: Record<string, unknown> } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', src)(wrapper, wrapper.exports)
+  return wrapper.exports as unknown as SharedUtils
+}
+
+const sendNode = (continueOnError?: boolean) => ({
+  id: 'send',
+  type: 'email-resend',
+  label: 'Send Shipped Email',
+  stepNumber: 1,
+  config: {
+    to: 'jane@example.com',
+    ...(continueOnError === undefined ? {} : { continueOnError }),
+  },
+})
+const afterNode = { id: 'after', type: 'toast-show', label: 'Toast', stepNumber: 2, config: {} }
+const edges = [{ id: 'e1', source: 'send', target: 'after' }]
+
+describe('continuesOnError — classification', () => {
+  it('opts in only on an explicit true', () => {
+    const utils = loadSharedRuntime()
+    expect(utils.continuesOnError(sendNode(true))).toBe(true)
+    expect(utils.continuesOnError(sendNode(false))).toBe(false)
+    expect(utils.continuesOnError(sendNode())).toBe(false)
+    expect(utils.continuesOnError({ id: 'x', type: 'toast-show' })).toBe(false)
+    expect(utils.continuesOnError(null)).toBe(false)
+  })
+})
+
+describe('executeNodes — a refused result on a continueOnError node', () => {
+  const refused = { id: '', success: false, error: 'Domain not verified' }
+
+  it('is published under the node id and the chain goes on', async () => {
+    const utils = loadSharedRuntime()
+    const ran: string[] = []
+    const handlers = {
+      'email-resend': async () => refused,
+      'toast-show': async () => {
+        ran.push('toast')
+        return { shown: true }
+      },
+    }
+    const context: Record<string, unknown> = {}
+    await utils.executeNodes([sendNode(true), afterNode], edges, context, handlers, {}, null, 'x1')
+    expect(context.send).toEqual(refused)
+    expect(ran).toEqual(['toast'])
+  })
+
+  it('still aborts the chain without the flag', async () => {
+    const utils = loadSharedRuntime()
+    const ran: string[] = []
+    const handlers = {
+      'email-resend': async () => refused,
+      'toast-show': async () => {
+        ran.push('toast')
+        return { shown: true }
+      },
+    }
+    const context: Record<string, unknown> = {}
+    await expect(
+      utils.executeNodes([sendNode(), afterNode], edges, context, handlers, {}, null, 'x2')
+    ).rejects.toThrow('Domain not verified')
+    expect(ran).toEqual([])
+  })
+
+  it('does not swallow a handler that throws', async () => {
+    const utils = loadSharedRuntime()
+    const handlers = {
+      'email-resend': async () => {
+        throw new Error('network down')
+      },
+      'toast-show': async () => ({ shown: true }),
+    }
+    await expect(
+      utils.executeNodes([sendNode(true), afterNode], edges, {}, handlers, {}, null, 'x3')
+    ).rejects.toThrow('network down')
+  })
+})
+
+describe('generated server segment route', () => {
+  const segment: WorkflowSegment = {
+    id: 'server-1',
+    env: 'server',
+    nodeIds: ['send'],
+    nodes: [{ ...sendNode(true), executionEnv: 'server' }],
+    edges: [],
+  }
+  it('gates its fatal-result check on the same predicate', () => {
+    const route = generateServerSegmentAPIRoute(segment, 'Send Shipped Email')
+    expect(route).toContain(
+      'if (utils.isFatalNodeResult(result) && !utils.continuesOnError(node)) {'
+    )
+  })
+})

package/__tests__/invoice-delivery-fee.test.ts

@@ -140,6 +140,66 @@ describe('invoice PDF renderer — delivery fee', () => {
     expect(withoutFee).not.toContain('<span>Delivery</span>')
   })
 
+  it('renders the template Delivery row gated on Invoice.hasShipping only when there is a fee', () => {
+    // The GUI emits the row's rendering condition as an `expr` reference
+    // (`invoiceData?.Invoice?.hasShipping`) compared with the STRING operand
+    // 'true'. The renderer resolves that expr to boolean true, so a strict
+    // `===` against the operand can never pass — the row was hidden on every
+    // invoice that had a fee.
+    const textNode = (children: unknown[]) => ({
+      type: 'element',
+      content: { elementType: 'text', semanticType: 'p', children },
+    })
+    const templateUidl = {
+      name: 'invoice-template',
+      node: {
+        type: 'element',
+        content: {
+          elementType: 'container',
+          children: [
+            {
+              type: 'conditional',
+              content: {
+                reference: { type: 'expr', content: 'invoiceData?.Invoice?.hasShipping' },
+                condition: { conditions: [{ operation: '=', operand: 'true' }] },
+                node: {
+                  type: 'element',
+                  content: {
+                    elementType: 'container',
+                    name: 'Delivery Row',
+                    children: [
+                      textNode([{ type: 'static', content: 'Delivery:' }]),
+                      textNode([{ type: 'expr', content: 'invoiceData?.Invoice?.shippingAmount' }]),
+                    ],
+                  },
+                },
+              },
+            },
+          ],
+        },
+      },
+    }
+    const code = generatePdfGeneratorCode(FAKE_SETTINGS, templateUidl, {})
+    const moduleObject = { exports: {} as Record<string, unknown> }
+    new Function('require', 'module', 'exports', `${code}; return module.exports;`)(
+      require,
+      moduleObject,
+      moduleObject.exports
+    )
+    const templated = moduleObject.exports as unknown as PdfGeneratorModule
+
+    const withFee = templated.buildInvoiceHtml({
+      ...baseInvoice,
+      shippingAmount: 9.99,
+      total: 209.99,
+    })
+    expect(withFee).toContain('Delivery:')
+    expect(withFee).toContain('$9.99')
+
+    const withoutFee = templated.buildInvoiceHtml({ ...baseInvoice, total: 200 })
+    expect(withoutFee).not.toContain('Delivery:')
+  })
+
   it('fills the {{shippingAmount}} merge token in the invoice email', () => {
     const data = pdfGenerator.buildDataContext({
       ...baseInvoice,
@@ -153,3 +213,47 @@ describe('invoice PDF renderer — delivery fee', () => {
     expect(pdfGenerator.replacePlaceholders('Due: {{totalAmount}}', data)).toBe('Due: $209.99')
   })
 })
+
+describe('invoice PDF renderer — each line says which VAT rate it was taxed at', () => {
+  const pdfGenerator = loadPdfGenerator()
+  const regionalInvoice = {
+    invoiceNumber: 'INV-0001',
+    taxRate: 20,
+    taxIncludedInPrice: false,
+    subtotal: 247,
+    taxAmount: 40,
+    shippingAmount: 0,
+    total: 287,
+    currency: 'RON',
+    items: [
+      {
+        name: 'Kettle',
+        quantity: 2,
+        unitPrice: 100,
+        totalPrice: 200,
+        taxRate: 20,
+        taxIncluded: false,
+      },
+      { name: 'Book', quantity: 1, unitPrice: 47, totalPrice: 47, taxRate: 9, taxIncluded: true },
+    ],
+  }
+
+  it('binds the per-line rate and VAT beside the net price', () => {
+    const products = (
+      pdfGenerator.buildInvoiceDataScope(regionalInvoice).invoiceData as unknown as {
+        Products: Array<Record<string, string>>
+      }
+    ).Products
+    expect(products.map((product) => product.lineVatRate)).toEqual(['20%', '9%'])
+    expect(products[0].lineVatAmount).toContain('40.00')
+    expect(products[1].lineVatAmount).toContain('3.88')
+  })
+
+  it('prints the VAT % and VAT columns and a VAT total on the fallback invoice', () => {
+    const html = pdfGenerator.buildInvoiceHtml(regionalInvoice)
+    expect(html).toContain('>VAT %</th>')
+    expect(html).toContain('>20%</td>')
+    expect(html).toContain('>9%</td>')
+    expect(html).toContain('<span>VAT</span>')
+  })
+})

package/__tests__/invoice-regional-tax.test.ts

@@ -0,0 +1,126 @@
+/* tslint:disable:function-constructor */
+import { generateInvoiceGenerateRouteCode } from '../src/invoice/api-routes-code'
+import { REGIONAL_INVOICE_TAX_CODE } from '../src/invoice/regional-invoice-tax-code'
+import type { UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+
+/**
+ * The invoice of an order priced by region (shipping zones + tax
+ * jurisdictions) is computed from the rates the order was CHARGED at —
+ * `teleport_orders.tax_breakdown` — not from the store's single default rate,
+ * and its total must equal `goods + shipping_amount - discount_amount`, the
+ * amount the buyer was debited.
+ */
+
+interface RegionalInvoiceTax {
+  taxRate: number
+  taxIncluded: boolean
+  subtotal: number
+  taxAmount: number
+  shippingNet: number
+  total: number
+  itemTax: Array<{ rate: number; included: boolean; amount: number }>
+}
+
+const api = new Function(
+  REGIONAL_INVOICE_TAX_CODE +
+    '\nreturn { parse: parseOrderTaxBreakdown, resolve: resolveRegionalInvoiceTax };'
+)() as {
+  parse: (raw: unknown) => Record<string, unknown> | null
+  resolve: (
+    breakdown: Record<string, unknown>,
+    items: Array<Record<string, unknown>>,
+    discountAmount: number,
+    shippingAmount: number
+  ) => RegionalInvoiceTax
+}
+
+const cents = (n: number) => Math.round(n * 100) / 100
+
+// Germany: food at 7% and tools at 19%, both added on top; 6.00 shipping taxed
+// at 19% → shipping_amount 7.14 on the order.
+const GERMAN_ORDER = {
+  taxRate: 19,
+  taxIncluded: false,
+  taxDecimals: 2,
+  shippingTax: 1.14,
+  lines: [
+    { productId: 'p1', variantId: '', taxRate: 7, taxIncluded: false },
+    { productId: 'p2', variantId: 'v2', taxRate: 19, taxIncluded: false },
+  ],
+}
+const GERMAN_ITEMS = [
+  { productId: 'p1', variantId: null, quantity: 2, unitPrice: 10, totalPrice: 20 },
+  { productId: 'p2', variantId: 'v2', quantity: 1, unitPrice: 25.99, totalPrice: 25.99 },
+]
+
+describe('invoice — regional tax breakdown', () => {
+  it('reads the breakdown from the TEXT column, and nothing from a legacy order', () => {
+    expect(api.parse(JSON.stringify(GERMAN_ORDER))).toMatchObject({ taxRate: 19 })
+    expect(api.parse(null)).toBeNull()
+    expect(api.parse('not json')).toBeNull()
+    expect(api.parse('{"taxRate":19}')).toBeNull()
+  })
+
+  it('taxes each line at its own rate and reconciles with the order total', () => {
+    const result = api.resolve(GERMAN_ORDER, GERMAN_ITEMS, 0, 7.14)
+    // goods: 21.40 + 30.93 = 52.33, tax 1.40 + 4.94 = 6.34; shipping tax 1.14.
+    expect(cents(result.total)).toBe(59.47)
+    expect(cents(result.taxAmount)).toBe(7.48)
+    expect(cents(result.subtotal)).toBe(45.99)
+    // Delivery prints net, so Subtotal + Tax + Delivery is the total.
+    expect(cents(result.shippingNet)).toBe(6)
+    expect(cents(result.subtotal + result.taxAmount + result.shippingNet)).toBe(59.47)
+    expect(result.itemTax).toEqual([
+      { rate: 7, included: false, amount: 1.4 },
+      { rate: 19, included: false, amount: 4.94 },
+    ])
+    expect(result.taxRate).toBe(19)
+  })
+
+  it('takes a discount off the goods first, then the shipping, shrinking each tax in proportion', () => {
+    const goodsOnly = api.resolve(GERMAN_ORDER, GERMAN_ITEMS, 10.466, 7.14)
+    // 52.33 - 10.466 leaves 80% of the goods: 6.34 * 0.8 = 5.072, shipping untouched.
+    expect(cents(goodsOnly.total)).toBe(cents(52.33 - 10.466 + 7.14))
+    expect(cents(goodsOnly.taxAmount)).toBe(cents(6.34 * 0.8 + 1.14))
+
+    const intoShipping = api.resolve(GERMAN_ORDER, GERMAN_ITEMS, 55.9, 7.14)
+    // The goods are fully discounted and 3.57 of 7.14 shipping is left: half its tax.
+    expect(cents(intoShipping.total)).toBe(3.57)
+    expect(cents(intoShipping.taxAmount)).toBe(0.57)
+    expect(intoShipping.subtotal).toBe(0)
+    expect(cents(intoShipping.shippingNet)).toBe(3)
+  })
+
+  it('extracts included tax without adding it, and falls back to the standard rate for an unmatched line', () => {
+    const french = api.resolve(
+      { taxRate: 20, taxIncluded: true, taxDecimals: 2, shippingTax: 1, lines: [] },
+      [{ productId: 'p9', quantity: 1, unitPrice: 25.99, totalPrice: 25.99 }],
+      0,
+      6
+    )
+    expect(cents(french.total)).toBe(31.99)
+    expect(cents(french.taxAmount)).toBe(5.33)
+    expect(french.itemTax).toEqual([{ rate: 20, included: true, amount: 4.33 }])
+  })
+})
+
+describe('/api/invoices/generate — regional tax wiring', () => {
+  const route = generateInvoiceGenerateRouteCode({
+    invoicePrefix: 'INV-',
+    defaultTaxRate: 20,
+    showDiscount: false,
+    taxIncludedInPrice: false,
+    companyDetails: {},
+    template: { document: null },
+    tables: { invoicesTable: 'teleport_invoices', invoiceItemsTable: 'teleport_invoice_items' },
+    emailDelivery: { enabled: false },
+  } as unknown as UIDLInvoiceSettings)
+
+  it('prices from the order breakdown unless the caller names its own rate', () => {
+    expect(route).toContain('function resolveRegionalInvoiceTax(')
+    expect(route).toContain('var regionalTaxBreakdown = body.taxRate == null')
+    expect(route).toContain('parseOrderTaxBreakdown(orderShippingSource.tax_breakdown)')
+    expect(route).toContain('taxIncludedInPrice: taxIncludedInPrice,')
+    expect(route).toContain('variantId: row.variant_id || row.variantId || null,')
+  })
+})

package/__tests__/payment-redirect-and-order-notification.test.ts

@@ -93,6 +93,12 @@ describe('data-create-item auto-fires order-notification for teleport_orders ins
     expect(src).toContain('paymentMethod: item.payment_method')
   })
 
+  it("sends the order's tax breakdown and each line's product ids, so the route prices lines at their rate", () => {
+    expect(src).toContain('taxBreakdown: item.tax_breakdown || null')
+    expect(src).toContain("product_id: it.productId || it.product_id || ''")
+    expect(src).toContain("variant_id: it.variantId || it.variant_id || ''")
+  })
+
   it('fires-and-forgets — does NOT await the notification call', () => {
     // Awaiting an email provider that times out would block the
     // workflow's success response back to the buyer, leaving the

package/__tests__/paypal-webhook-order-notification.test.ts

@@ -0,0 +1,41 @@
+import { generatePaypalWebhookCode } from '../src/webhook-generator'
+import type { UIDLEcommerceSettings, UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+
+/**
+ * The PayPal webhook tells the order-notification route which order was paid.
+ * The capture resource's own id is a PayPal id — it matches no `teleport_orders`
+ * row, so a notification keyed on it reached the merchant with no lines at all.
+ * The internal id travels in `custom_id`, and the helper that reads it must be
+ * emitted whenever notifications are on, not only when invoices are.
+ */
+const ecommerce = (orderNotifications: boolean): UIDLEcommerceSettings =>
+  ({ orderNotifications } as unknown as UIDLEcommerceSettings)
+
+const invoices = (enabled: boolean): UIDLInvoiceSettings =>
+  ({ enabled, autoGenerateOnPayment: enabled } as unknown as UIDLInvoiceSettings)
+
+describe('PayPal webhook — order notification order id', () => {
+  it('sends the internal order id, falling back to the capture id', () => {
+    const source = generatePaypalWebhookCode(invoices(false), ecommerce(true))
+    expect(source).toContain("orderId: __extractInternalOrderId(resource) || resource.id || ''")
+    expect(source).toContain('function __extractInternalOrderId(resource)')
+    // Invoices are off: their handler is not emitted, only the id helper both share.
+    expect(source).not.toContain('async function handlePaypalInvoiceGeneration')
+  })
+
+  it('emits the helper for invoices alone too, and both handlers when both are on', () => {
+    const invoicesOnly = generatePaypalWebhookCode(invoices(true), ecommerce(false))
+    expect(invoicesOnly).toContain('function __extractInternalOrderId(resource)')
+    expect(invoicesOnly).toContain('async function handlePaypalInvoiceGeneration')
+    expect(invoicesOnly).not.toContain('/api/ecommerce/order-notification')
+
+    const both = generatePaypalWebhookCode(invoices(true), ecommerce(true))
+    expect(both.match(/function __extractInternalOrderId\(resource\)/g)).toHaveLength(1)
+    expect(both).toContain('/api/ecommerce/order-notification')
+  })
+
+  it('emits neither when neither feature is on', () => {
+    const source = generatePaypalWebhookCode(invoices(false), ecommerce(false))
+    expect(source).not.toContain('__extractInternalOrderId')
+  })
+})