@teleporthq/teleport-plugin-next-workflows 0.43.67 → 0.43.69

package/__tests__/cart-get-total-subscriptions.test.ts

@@ -0,0 +1,221 @@
+/* tslint:disable:no-eval */
+import { cartGetTotal } from '../src/nodes/cart/cart-get-total'
+
+/**
+ * `cart-get-total` is what the place-order workflow branches on: a cart
+ * holding a subscription opens the provider's checkout in subscription mode,
+ * a cart of downloads is charged no delivery. Both facts are read off the
+ * flags the add-to-cart node stamps, so a storefront exported before them
+ * reads as neither — and a digital-only cart's shipping is zero in every
+ * figure the workflow could read it from.
+ */
+
+function evalHandler(code: string): any {
+  return eval('(' + code + ')')
+}
+
+function mount(storage: Record<string, unknown>, fields: Record<string, string> = {}): void {
+  const store: Record<string, string> = {}
+  for (const key of Object.keys(storage)) {
+    store[key] = JSON.stringify(storage[key])
+  }
+  ;(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 runHandler = async () => evalHandler(cartGetTotal.generateHandler())()
+
+const DELIVERY = {
+  deliveryPrice: 10,
+  freeDeliveryEnabled: false,
+  freeDeliveryThreshold: 0,
+  deliveryEnabled: true,
+  storePickupEnabled: true,
+}
+
+describe('cart-get-total — subscriptions and digital delivery', () => {
+  it('reports neither on a cart written before the flags existed', async () => {
+    mount({ workflow_cart: [{ price: 100, quantity: 1 }] })
+    const out = await runHandler()
+    expect(out.hasRecurringLines).toBe(false)
+    expect(out.isDigitalOnly).toBe(false)
+  })
+
+  it('reports a subscription however its flag is spelled', async () => {
+    mount({ workflow_cart: [{ price: 12, quantity: 1, isRecurring: 't', isDigital: true }] })
+    const out = await runHandler()
+    expect(out.hasRecurringLines).toBe(true)
+    expect(out.isDigitalOnly).toBe(true)
+  })
+
+  it('calls a cart digital-only when every line is, and never an empty one', async () => {
+    mount({
+      workflow_cart: [
+        { price: 20, quantity: 1, isDigital: true },
+        { price: 30, quantity: 2, isDigital: false },
+      ],
+    })
+    expect((await runHandler()).isDigitalOnly).toBe(false)
+    mount({ workflow_cart: [] })
+    expect((await runHandler()).isDigitalOnly).toBe(false)
+  })
+
+  it('charges a digital-only cart no delivery when it prices the discounts', async () => {
+    mount({
+      workflow_cart: [{ id: 'l1', productId: 'p1', price: 100, quantity: 1, isDigital: true }],
+      workflow_cart_settings: {
+        deliveryConfig: DELIVERY,
+        discounts: { enabled: true, automaticDiscounts: false, rows: [] },
+      },
+    })
+    const out = await runHandler()
+    // The amount the buyer was shown: goods only, no fee to waive.
+    expect(out.displayedAmountDue).toBe(100)
+    expect(out.discounts.shippingDiscount).toBe(0)
+
+    mount({
+      workflow_cart: [{ id: 'l1', productId: 'p1', price: 100, quantity: 1, isDigital: false }],
+      workflow_cart_settings: {
+        deliveryConfig: DELIVERY,
+        discounts: { enabled: true, automaticDiscounts: false, rows: [] },
+      },
+    })
+    expect((await runHandler()).displayedAmountDue).toBe(110)
+  })
+
+  it('zeroes the zone fee of a digital-only cart on a store with shipping zones', async () => {
+    const regional = {
+      currency: 'EUR',
+      countryCodes: { germany: 'DE' },
+      store: {
+        countryCode: 'DE',
+        deliveryEnabled: true,
+        storePickupEnabled: true,
+        deliveryPrice: 5,
+        freeDeliveryEnabled: false,
+        freeDeliveryThreshold: 0,
+        defaultTaxRate: 0,
+        defaultTaxIncluded: false,
+      },
+      rows: {
+        zones: [{ id: 'z1', name: 'Germany', countries: 'DE', cod_enabled: 't', is_active: 't' }],
+        rates: [{ id: 'r1', zone_id: 'z1', name: 'Standard', rate_type: 'flat', price: '10.00' }],
+        taxRates: [],
+      },
+    }
+    const address = { billingCountry: 'Germany', state: '' }
+    mount(
+      {
+        workflow_cart: [{ id: 'l1', productId: 'p1', price: 100, quantity: 1, isDigital: true }],
+        workflow_cart_settings: { regional },
+      },
+      address
+    )
+    const out = await runHandler()
+    expect(out.isDigitalOnly).toBe(true)
+    expect(out.regional).toMatchObject({
+      status: 'ok',
+      zoneName: 'Germany',
+      shippingNet: 0,
+      shippingTax: 0,
+      shippingGross: 0,
+    })
+
+    mount(
+      {
+        workflow_cart: [{ id: 'l1', productId: 'p1', price: 100, quantity: 1 }],
+        workflow_cart_settings: { regional },
+      },
+      address
+    )
+    expect((await runHandler()).regional.shippingGross).toBe(10)
+  })
+
+  it("lets a gift card pay the subscription's first charge, never below the provider minimum", async () => {
+    mount({
+      workflow_cart: [{ id: 'l1', productId: 'sub', price: 50, quantity: 1, isRecurring: true }],
+      workflow_cart_settings: {
+        deliveryConfig: DELIVERY,
+        giftCards: { enabled: true, currency: 'EUR', recurringTender: true },
+      },
+      workflow_gift_card: { id: 'gc', last4: 'ABCD', balance: 100, currency: 'EUR' },
+    })
+    const out = await runHandler()
+    expect(out.hasRecurringLines).toBe(true)
+    expect(out.giftCard).toEqual({
+      id: 'gc',
+      last4: 'ABCD',
+      balance: 100,
+      amount: 59.5,
+      amountDue: 0.5,
+    })
+    expect(out.displayedAmountDue).toBe(0.5)
+  })
+
+  it('lets no gift card pay for a subscription on a checkout built before the first charge could be reduced', async () => {
+    mount({
+      workflow_cart: [{ id: 'l1', productId: 'sub', price: 50, quantity: 1, isRecurring: true }],
+      workflow_cart_settings: {
+        deliveryConfig: DELIVERY,
+        giftCards: { enabled: true, currency: 'EUR' },
+      },
+      workflow_gift_card: { id: 'gc', last4: 'ABCD', balance: 100, currency: 'EUR' },
+    })
+    const out = await runHandler()
+    expect(out.giftCard).toBeNull()
+    expect(out.displayedAmountDue).toBe(60)
+  })
+
+  it('lets no gift card pay for a subscription that starts with a free trial', async () => {
+    mount({
+      workflow_cart: [
+        { id: 'l1', productId: 'sub', price: 50, quantity: 1, isRecurring: true, trialDays: 14 },
+      ],
+      workflow_cart_settings: {
+        deliveryConfig: DELIVERY,
+        giftCards: { enabled: true, currency: 'EUR' },
+      },
+      workflow_gift_card: { id: 'gc', last4: 'ABCD', balance: 100, currency: 'EUR' },
+    })
+    const out = await runHandler()
+    expect(out.giftCard).toBeNull()
+    expect(out.displayedAmountDue).toBe(60)
+  })
+
+  it('hands the place-order script the providers that can bill a subscription', async () => {
+    // Read from the mirror the storefront wrote at export, so a provider the
+    // merchant enabled after the checkout page was built still counts there.
+    mount({
+      workflow_cart: [{ id: 'l1', productId: 'sub', price: 50, quantity: 1, isRecurring: true }],
+      workflow_cart_settings: {
+        deliveryConfig: DELIVERY,
+        subscriptions: { enabled: true, providers: ['stripe', 'paypal'] },
+      },
+    })
+    expect((await runHandler()).subscriptions).toEqual({
+      enabled: true,
+      providers: ['stripe', 'paypal'],
+    })
+  })
+
+  it('adds no subscriptions key for a storefront that never mirrored one', async () => {
+    mount({
+      workflow_cart: [{ id: 'l1', productId: 'p1', price: 100, quantity: 1 }],
+      workflow_cart_settings: { deliveryConfig: DELIVERY },
+    })
+    expect('subscriptions' in (await runHandler())).toBe(false)
+  })
+})

package/__tests__/cart-price-order.test.ts

@@ -0,0 +1,283 @@
+import { loadHandler } from './_helpers/load-handler'
+
+// The checkout's server pricing step. A cart line's price, the storefront tax,
+// the delivery fee and every discount come from the database and the store's
+// baked settings — never from what the browser says the line costs. These run
+// the EMITTED handler against a stubbed data API.
+
+type Rows = Record<string, unknown[]>
+
+const baseSettings = {
+  dataSourceId: 'ds-1',
+  deliveryConfig: {
+    deliveryEnabled: true,
+    storePickupEnabled: false,
+    deliveryPrice: 5,
+    freeDeliveryEnabled: true,
+    freeDeliveryThreshold: 200,
+  },
+  taxConfig: { storefrontTaxRate: 0 },
+  vouchersEnabled: true,
+  subscriptions: { enabled: false, providers: [] },
+  paymentKinds: {},
+  regional: null,
+  discounts: null,
+  giftCards: null,
+}
+
+const product = (id: string, fields: Record<string, unknown> = {}) => ({
+  id,
+  name: 'Product ' + id,
+  price: 50,
+  status: 'active',
+  ...fields,
+})
+
+function withDataApi(rows: Rows, failTable?: string): { restore: () => void; calls: string[] } {
+  const original = (globalThis as any).fetch
+  const calls: string[] = []
+  ;(globalThis as any).fetch = async (_url: string, init: { body: string; headers: any }) => {
+    const body = JSON.parse(init.body)
+    calls.push(body.tableName)
+    if (body.tableName === failTable) {
+      return { ok: false, json: async () => ({}) }
+    }
+    let result = rows[body.tableName] || []
+    const filter = (body.filters || [])[0]
+    if (filter && Array.isArray(filter.value)) {
+      result = result.filter((row: any) => filter.value.indexOf(String(row[filter.field])) !== -1)
+    }
+    return { ok: true, json: async () => ({ rows: result }) }
+  }
+  return {
+    calls,
+    restore: () => {
+      ;(globalThis as any).fetch = original
+    },
+  }
+}
+
+async function price(
+  config: Record<string, unknown>,
+  rows: Rows,
+  settings: unknown = baseSettings,
+  failTable?: string
+): Promise<any> {
+  const handler = loadHandler('cart-price-order', { cartPricingSettings: settings })
+  const api = withDataApi(rows, failTable)
+  try {
+    return await handler(config, { __baseUrl: 'http://store.test' })
+  } finally {
+    api.restore()
+  }
+}
+
+describe('cart-price-order', () => {
+  it('prices every line from its product row, whatever the browser says it costs', async () => {
+    const result = await price(
+      { items: [{ id: 'l1', productId: 'p1', quantity: 2, price: 0.01 }] },
+      { teleport_products: [product('p1')] }
+    )
+    expect(result.priced).toBe(true)
+    expect(result.lines[0].price).toBe(50)
+    expect(result.subtotal).toBe(100)
+    expect(result.total).toBe(100)
+  })
+
+  it('applies the markdown live right now, and the storefront tax on top', async () => {
+    const discounts = JSON.stringify([
+      { type: 'percentage', value: 20, startsAt: null, endsAt: null },
+    ])
+    const result = await price(
+      { items: [{ productId: 'p1', quantity: 1, price: 50 }] },
+      { teleport_products: [product('p1', { discounts })] },
+      { ...baseSettings, taxConfig: { storefrontTaxRate: 10 } }
+    )
+    expect(result.lines[0].price).toBe(40)
+    expect(result.lines[0].discountAmount).toBe(10)
+    expect(result.subtotal).toBe(40)
+    expect(result.tax).toBe(4)
+    expect(result.total).toBe(44)
+  })
+
+  it('prices a variant line at the variant, and only a variant of its own product', async () => {
+    const rows = {
+      teleport_products: [product('p1'), product('p2', { price: 1 })],
+      teleport_product_variants: [
+        { id: 'v1', product_id: 'p1', price: 70, options: {} },
+        { id: 'v2', product_id: 'p2', price: 1, options: {} },
+      ],
+    }
+    const own = await price({ items: [{ productId: 'p1', variantId: 'v1', quantity: 1 }] }, rows)
+    expect(own.lines[0].price).toBe(70)
+    const foreign = await price(
+      { items: [{ productId: 'p1', variantId: 'v2', quantity: 1 }] },
+      rows
+    )
+    expect(foreign).toMatchObject({ priced: false })
+    expect(foreign.reason).toMatch(/no longer available/)
+  })
+
+  it('refuses a product that is not for sale, a missing product and an empty cart', async () => {
+    expect(
+      await price(
+        { items: [{ productId: 'p1', quantity: 1 }] },
+        { teleport_products: [product('p1', { status: 'draft' })] }
+      )
+    ).toMatchObject({ priced: false })
+    expect(
+      await price({ items: [{ productId: 'gone', quantity: 1 }] }, { teleport_products: [] })
+    ).toMatchObject({
+      priced: false,
+    })
+    expect(await price({ items: [] }, {})).toMatchObject({
+      priced: false,
+      reason: 'Your cart is empty.',
+    })
+  })
+
+  it('refuses to price without the store settings or when the database cannot be read', async () => {
+    const items = [{ productId: 'p1', quantity: 1 }]
+    expect(await price({ items }, { teleport_products: [product('p1')] }, null)).toMatchObject({
+      priced: false,
+    })
+    expect(
+      await price(
+        { items },
+        { teleport_products: [product('p1')] },
+        baseSettings,
+        'teleport_products'
+      )
+    ).toMatchObject({ priced: false })
+  })
+
+  it("records the order in its products' currency, read off the rows, never the browser's", async () => {
+    const result = await price(
+      { items: [{ productId: 'p1', quantity: 1, currency: 'USD' }] },
+      { teleport_products: [product('p1', { currency: 'ron' })] }
+    )
+    expect(result).toMatchObject({ priced: true, currency: 'RON' })
+    expect(result.lines[0]).toMatchObject({ currency: 'RON' })
+    // A product that names no currency leaves the order to the store's.
+    const unnamed = await price(
+      { items: [{ productId: 'p1', quantity: 1, currency: 'EUR' }] },
+      { teleport_products: [product('p1')] }
+    )
+    expect(unnamed).toMatchObject({ priced: true, currency: '' })
+  })
+
+  it('refuses a cart whose products are priced in more than one currency', async () => {
+    const result = await price(
+      {
+        items: [
+          { productId: 'p1', quantity: 1, currency: 'USD' },
+          { productId: 'p2', quantity: 1, currency: 'USD' },
+          { productId: 'p3', quantity: 1, currency: 'USD' },
+        ],
+      },
+      {
+        teleport_products: [
+          product('p1', { currency: 'USD' }),
+          product('p2', { currency: 'EUR' }),
+          product('p3', { currency: 'RON' }),
+        ],
+      }
+    )
+    expect(result).toEqual({
+      priced: false,
+      reason:
+        'Your cart holds products priced in USD, EUR and RON. Each currency needs its own order: remove the products priced in one of them and try again.',
+      lines: [],
+    })
+  })
+
+  it('reports the store delivery settings the order is charged from', async () => {
+    const result = await price(
+      { items: [{ productId: 'p1', quantity: 1 }] },
+      { teleport_products: [product('p1')] }
+    )
+    expect(result.deliveryConfig).toMatchObject({ deliveryPrice: 5, freeDeliveryThreshold: 200 })
+  })
+
+  it('prices the voucher the database confirmed, never the browser copy', async () => {
+    const result = await price(
+      {
+        items: [{ productId: 'p1', quantity: 2 }],
+        voucherCheck: {
+          voucherRow: {
+            id: 'vc1',
+            code: 'TEN',
+            discount_type: 'percentage',
+            discount_value: 10,
+            is_active: 'true',
+          },
+        },
+        clientTotal: { voucher: { code: 'TEN', discount_type: 'percentage', discount_value: 100 } },
+      },
+      { teleport_products: [product('p1')] },
+      { ...baseSettings, discounts: { automaticDiscounts: false } }
+    )
+    expect(result.priced).toBe(true)
+    expect(result.discounts.voucherDiscount).toBe(10)
+  })
+
+  it('applies the gift card the database confirmed as tender', async () => {
+    const result = await price(
+      {
+        items: [{ productId: 'p1', quantity: 2 }],
+        giftCardCheck: {
+          ok: 'true',
+          giftCardRow: { id: 'g1', code: 'ABCD1234', balance: 30, currency: 'USD' },
+        },
+      },
+      { teleport_products: [product('p1')] },
+      { ...baseSettings, giftCards: { currency: 'USD', recurringTender: false } }
+    )
+    expect(result.giftCard).toMatchObject({ id: 'g1', amount: 30 })
+    expect(result.displayedAmountDue).toBe(75)
+  })
+
+  it('prices shipping and tax for the address the order ships to', async () => {
+    const regional = {
+      store: { ...baseSettings.deliveryConfig, defaultTaxRate: 0, defaultTaxIncluded: false },
+      currency: 'EUR',
+      countryCodes: { romania: 'RO', germany: 'DE' },
+      storeCountryCode: 'RO',
+    }
+    const rows = {
+      teleport_products: [product('p1')],
+      teleport_shipping_zones: [],
+      teleport_shipping_rates: [],
+      teleport_tax_rates: [
+        {
+          id: 't1',
+          country_code: 'DE',
+          region: '',
+          rate: 19,
+          tax_included: 'added',
+          is_active: 'true',
+        },
+      ],
+    }
+    const toGermany = await price(
+      {
+        items: [{ productId: 'p1', quantity: 1 }],
+        form: { billingCountry: 'Romania', shippingCountry: 'Germany' },
+        shipToDifferent: 'true',
+      },
+      rows,
+      { ...baseSettings, regional }
+    )
+    expect(toGermany.regional.destination).toMatchObject({ countryCode: 'DE' })
+    const toBilling = await price(
+      {
+        items: [{ productId: 'p1', quantity: 1 }],
+        form: { billingCountry: 'Romania', shippingCountry: 'Germany' },
+        shipToDifferent: 'false',
+      },
+      rows,
+      { ...baseSettings, regional }
+    )
+    expect(toBilling.regional.destination).toMatchObject({ countryCode: 'RO' })
+  })
+})

package/__tests__/cart-update-item-quantity-recurring.test.ts

@@ -0,0 +1,75 @@
+/* tslint:disable:function-constructor */
+import { cartUpdateItemQuantity } from '../src/nodes/cart/cart-update-item-quantity'
+
+/**
+ * A subscription is ONE unit: the provider bills the plan, not a quantity.
+ * The cart page hides the stepper for such a line, but nothing stops a
+ * workflow from asking — so the node itself keeps the line at one, whatever
+ * the mode, and still lets it be removed.
+ */
+
+type Handler = (config: Record<string, unknown>) => Promise<{ id: string; quantity: number }>
+
+function loadHandler(store: Record<string, string>): Handler {
+  ;(global as any).localStorage = {
+    getItem: (key: string) => (key in store ? store[key] : null),
+    setItem: (key: string, value: string) => {
+      store[key] = value
+    },
+  }
+  ;(global as any).window = { dispatchEvent: () => true }
+  ;(global as any).CustomEvent = function CustomEvent() {
+    return {}
+  }
+  const source = cartUpdateItemQuantity.generateHandler()
+  return new Function('config', `${source}\nreturn cart_update_item_quantity(config)`) as Handler
+}
+
+const storeWith = (line: Record<string, unknown>): Record<string, string> => ({
+  workflow_cart: JSON.stringify([
+    { id: 'cart_1', productId: 'p1', quantity: 1, price: 10, ...line },
+  ]),
+})
+
+const storedQuantity = (store: Record<string, string>): number | undefined =>
+  JSON.parse(store.workflow_cart)[0]?.quantity
+
+afterEach(() => {
+  delete (global as any).localStorage
+  delete (global as any).window
+  delete (global as any).CustomEvent
+})
+
+describe('cart-update-item-quantity — a subscription stays at one unit', () => {
+  it('ignores an increment, however the flag is spelled', async () => {
+    for (const isRecurring of [true, 'true']) {
+      const store = storeWith({ isRecurring })
+      const out = await loadHandler(store)({
+        itemId: 'cart_1',
+        quantity: 1,
+        updateMode: 'increment',
+      })
+      expect(out).toEqual({ id: 'cart_1', quantity: 1 })
+      expect(storedQuantity(store)).toBe(1)
+    }
+  })
+
+  it('ignores a set above one', async () => {
+    const store = storeWith({ isRecurring: true })
+    await loadHandler(store)({ itemId: 'cart_1', quantity: 5, updateMode: 'set' })
+    expect(storedQuantity(store)).toBe(1)
+  })
+
+  it('still removes the line when the quantity drops to zero', async () => {
+    const store = storeWith({ isRecurring: true })
+    const out = await loadHandler(store)({ itemId: 'cart_1', quantity: 1, updateMode: 'decrement' })
+    expect(out).toEqual({ id: 'cart_1', quantity: 0 })
+    expect(JSON.parse(store.workflow_cart)).toEqual([])
+  })
+
+  it('leaves an ordinary line exactly as it was', async () => {
+    const store = storeWith({ isRecurring: false })
+    await loadHandler(store)({ itemId: 'cart_1', quantity: 2, updateMode: 'increment' })
+    expect(storedQuantity(store)).toBe(3)
+  })
+})