@teleporthq/teleport-plugin-next-data-source 0.43.57 → 0.43.60

package/__tests__/_helpers/pagination-widget-fixture.ts

@@ -0,0 +1,230 @@
+import * as types from '@babel/types'
+import { ChunkType, FileType, ChunkDefinition } from '@teleporthq/teleport-types'
+import { PAGINATION_CONTROL_ATTR } from '../../src/pagination-controls'
+
+/**
+ * A component shell carrying a `DataProvider` and the pagination controls a
+ * builder would have authored, so the wiring steps of the plugin have something
+ * real to find.
+ *
+ * `__tests__/_helpers` is excluded from the jest test match, so this file is a
+ * fixture rather than a suite.
+ */
+
+// tslint:disable:no-any
+
+interface ControlOptions {
+  /** Which `data-tq-pagination-control` markers to author. */
+  controls: string[]
+  /** Author Previous/Next with only the legacy class names, no markers. */
+  legacyOnly?: boolean
+  /** Number of DataProvider + widget pairs to emit (order-based zip coverage). */
+  mappers?: number
+}
+
+const control = (marker: string, children: types.JSXElement['children'] = []): types.JSXElement =>
+  types.jsxElement(
+    types.jsxOpeningElement(
+      types.jsxIdentifier('div'),
+      [
+        types.jsxAttribute(
+          types.jsxIdentifier('className'),
+          types.stringLiteral(`thq-${marker}-elm`)
+        ),
+        types.jsxAttribute(
+          types.jsxIdentifier(PAGINATION_CONTROL_ATTR),
+          types.stringLiteral(marker)
+        ),
+      ],
+      false
+    ),
+    types.jsxClosingElement(types.jsxIdentifier('div')),
+    children,
+    false
+  )
+
+const legacyControl = (direction: 'previous' | 'next'): types.JSXElement =>
+  types.jsxElement(
+    types.jsxOpeningElement(
+      types.jsxIdentifier('div'),
+      [
+        types.jsxAttribute(
+          types.jsxIdentifier('className'),
+          types.stringLiteral(`products-list-thq-${direction}-elm`)
+        ),
+      ],
+      false
+    ),
+    types.jsxClosingElement(types.jsxIdentifier('div')),
+    [types.jsxText(direction === 'previous' ? 'Previous' : 'Next')],
+    false
+  )
+
+const buildWidget = (options: ControlOptions): types.JSXElement => {
+  const children: types.JSXElement[] = []
+  for (const marker of options.controls) {
+    if (marker === 'pages') {
+      // The container holds ONE template button, which the generator repeats.
+      children.push(control('pages', [control('page', [types.jsxText('1')])]))
+      continue
+    }
+    if (options.legacyOnly && (marker === 'previous' || marker === 'next')) {
+      children.push(legacyControl(marker))
+      continue
+    }
+    children.push(control(marker))
+  }
+
+  return types.jsxElement(
+    types.jsxOpeningElement(
+      types.jsxIdentifier('div'),
+      [
+        types.jsxAttribute(
+          types.jsxIdentifier('className'),
+          types.stringLiteral('products-list-cms-pagination-node')
+        ),
+      ],
+      false
+    ),
+    types.jsxClosingElement(types.jsxIdentifier('div')),
+    children,
+    false
+  )
+}
+
+// Mirrors the real emitted shape: a self-closing `<DataProvider>` whose
+// `renderSuccess` returns a `<Repeater renderItem={row => …}>`. The plugin only
+// treats a provider as an array mapper when it can read that `renderItem`
+// parameter name, so the fixture must carry one.
+const buildDataProvider = (name: string, rowIdentifier: string): types.JSXElement =>
+  types.jsxElement(
+    types.jsxOpeningElement(
+      types.jsxIdentifier('DataProvider'),
+      [
+        types.jsxAttribute(
+          types.jsxIdentifier('name'),
+          types.jsxExpressionContainer(types.stringLiteral(name))
+        ),
+        types.jsxAttribute(
+          types.jsxIdentifier('renderSuccess'),
+          types.jsxExpressionContainer(
+            types.arrowFunctionExpression(
+              [types.identifier('items')],
+              types.jsxElement(
+                types.jsxOpeningElement(
+                  types.jsxIdentifier('Repeater'),
+                  [
+                    types.jsxAttribute(
+                      types.jsxIdentifier('renderItem'),
+                      types.jsxExpressionContainer(
+                        types.arrowFunctionExpression(
+                          [types.identifier(rowIdentifier)],
+                          types.jsxElement(
+                            types.jsxOpeningElement(types.jsxIdentifier('div'), [], true),
+                            null,
+                            [],
+                            true
+                          )
+                        )
+                      )
+                    ),
+                  ],
+                  true
+                ),
+                null,
+                [],
+                true
+              )
+            )
+          )
+        ),
+      ],
+      true
+    ),
+    null,
+    [],
+    true
+  )
+
+export const makeWidgetComponentChunk = (options: ControlOptions): ChunkDefinition => {
+  const sections: types.JSXElement[] = []
+  const mappers = options.mappers ?? 1
+  for (let i = 0; i < mappers; i += 1) {
+    const identifier = `items${i === 0 ? '' : i}`
+    sections.push(buildDataProvider(identifier, `${identifier}_row`))
+    sections.push(buildWidget(options))
+  }
+
+  const root = types.jsxElement(
+    types.jsxOpeningElement(types.jsxIdentifier('div'), [], false),
+    types.jsxClosingElement(types.jsxIdentifier('div')),
+    sections,
+    false
+  )
+
+  return {
+    name: 'jsx-component',
+    type: ChunkType.AST,
+    fileType: FileType.JS,
+    linkAfter: [],
+    content: types.variableDeclaration('const', [
+      types.variableDeclarator(
+        types.identifier('TestComponent'),
+        types.arrowFunctionExpression(
+          [types.identifier('props')],
+          types.blockStatement([types.returnStatement(root)])
+        )
+      ),
+    ]),
+    meta: {},
+  }
+}
+
+export interface RepeaterOptions {
+  paginated?: boolean
+  searchEnabled?: boolean
+  paginationMode?: 'buttons' | 'numbered'
+  infiniteScroll?: boolean
+  infiniteScrollLoadMore?: boolean
+  perPage?: number
+}
+
+export const makeUidlNode = (options: RepeaterOptions, identifier: string = 'items'): any => ({
+  type: 'data-source-list',
+  content: {
+    renderPropIdentifier: identifier,
+    resourceDefinition: {
+      dataSourceId: 'ds1',
+      tableName: 'products',
+      dataSourceType: 'postgresql',
+    },
+    resource: { params: { queryColumns: { content: ['name'] } } },
+    nodes: {
+      success: {
+        type: 'cms-list-repeater',
+        content: {
+          renderPropIdentifier: `${identifier}_row`,
+          paginated: options.paginated !== false,
+          perPage: options.perPage ?? 20,
+          searchEnabled: !!options.searchEnabled,
+          searchDebounce: 300,
+          ...(options.paginationMode ? { paginationMode: options.paginationMode } : {}),
+          ...(options.infiniteScroll ? { infiniteScroll: true } : {}),
+          ...(options.infiniteScrollLoadMore ? { infiniteScrollLoadMore: true } : {}),
+          nodes: { list: { type: 'element', content: { elementType: 'div' } } },
+        },
+      },
+    },
+  },
+})
+
+/** Wraps several data-source-lists in one element node, as a page would. */
+export const makeMultiMapperUidl = (repeaters: RepeaterOptions[]): any => ({
+  type: 'element',
+  content: {
+    elementType: 'container',
+    children: repeaters.map((options, index) =>
+      makeUidlNode(options, `items${index === 0 ? '' : index}`)
+    ),
+  },
+})

package/__tests__/ecommerce-product-allow-backorders.test.ts

@@ -0,0 +1,156 @@
+import { generateEcommerceProductTransformationCode } from '../src/transformations/ecommerce-product'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+import { buildProductTransformOptions } from '../src/transformations'
+
+/**
+ * With backorders allowed (or stock management disabled) the merchant sells
+ * past zero, so NOTHING in the storefront may present a product or a variant
+ * combination as sold out:
+ *
+ *   - `outOfStock` stays 'false' even at quantity <= 0;
+ *   - a zero-stock combination is NOT dead, IS default-selectable, and keeps
+ *     `hasPurchasableVariant: 'true'` / a non-empty `defaultVariantId`;
+ *   - a combination that does not exist at all is STILL unavailable — there
+ *     is no variant row to backorder.
+ *
+ * The flag is baked at export time via
+ * `EcommerceProductTransformOptions.allowBackorders`, resolved in ONE place
+ * (`buildProductTransformOptions`) as: stock management off OR
+ * `stockManagementConfig.allowBackorders` on.
+ */
+
+const evalBuildProduct = (
+  allowBackorders: boolean
+): ((r: unknown, o?: unknown) => Record<string, unknown>) => {
+  const code =
+    generateSharedTransformationCode() +
+    '\n' +
+    generateEcommerceProductTransformationCode({ allowBackorders })
+  return new Function(code + '\nreturn buildEcommerceProduct;')() as (
+    r: unknown,
+    o?: unknown
+  ) => Record<string, unknown>
+}
+
+type Axis = { key: string; values: Array<Record<string, unknown>> }
+
+const SIZE_AXIS = JSON.stringify([
+  {
+    key: 'size',
+    name: 'Size',
+    type: 'text',
+    values: [
+      { value: 'xs', label: 'XS' },
+      { value: 's', label: 'S' },
+    ],
+  },
+])
+
+const variantProduct = (overrides: Record<string, unknown> = {}) => ({
+  id: 'p1',
+  name: 'Tee',
+  slug: 'tee',
+  price: 20,
+  currency: 'USD',
+  variant_options: SIZE_AXIS,
+  ...overrides,
+})
+
+const values = (product: Record<string, unknown>): Array<Record<string, unknown>> =>
+  (product.variantOptions as Axis[])[0].values
+
+describe('ecommerce product transform — allowBackorders', () => {
+  const withBackorders = evalBuildProduct(true)
+  const withoutBackorders = evalBuildProduct(false)
+
+  it('a zero-quantity FLAT product is never out of stock with backorders', () => {
+    const record = { id: 'f', name: 'Mug', slug: 'mug', price: 9, currency: 'USD', quantity: 0 }
+    expect(withBackorders(record).outOfStock).toBe('false')
+    expect(withoutBackorders(record).outOfStock).toBe('true')
+  })
+
+  it('a NEGATIVE quantity (already oversold) is still not out of stock', () => {
+    const record = { id: 'f', name: 'Mug', slug: 'mug', price: 9, currency: 'USD', quantity: -3 }
+    expect(withBackorders(record).outOfStock).toBe('false')
+  })
+
+  it('every combination sold out: values stay alive and purchasable with backorders', () => {
+    const options = {
+      variantsByProductId: {
+        p1: [
+          { id: 'v-xs', options: { size: 'xs' }, quantity: 0 },
+          { id: 'v-s', options: { size: 's' }, quantity: 0 },
+        ],
+      },
+    }
+    const product = withBackorders(variantProduct(), options)
+    expect(values(product).every((v) => v.isDead === 'false')).toBe(true)
+    expect(product.hasPurchasableVariant).toBe('true')
+    // The first covering combination becomes the default selection again.
+    expect(product.defaultVariantId).toBe('v-xs')
+
+    // The strict build keeps its sold-out answer (regression guard for the
+    // flag's default).
+    const strict = withoutBackorders(variantProduct(), options)
+    expect(strict.hasPurchasableVariant).toBe('false')
+    expect(strict.defaultVariantId).toBe('')
+  })
+
+  it('a value with NO combination behind it stays dead even with backorders', () => {
+    const product = withBackorders(variantProduct(), {
+      variantsByProductId: { p1: [{ id: 'v-xs', options: { size: 'xs' }, quantity: 0 }] },
+    })
+    expect(values(product)[0].isDead).toBe('false')
+    // 's' has no variant row — nothing exists to backorder.
+    expect(values(product)[1].isDead).toBe('true')
+  })
+
+  it('looked up and there are NO combinations at all: still not purchasable', () => {
+    const product = withBackorders(variantProduct(), { variantsByProductId: {} })
+    expect(values(product).every((v) => v.isDead === 'true')).toBe(true)
+    expect(product.hasPurchasableVariant).toBe('false')
+  })
+
+  it('omitting the option keeps the strict pre-flag behaviour', () => {
+    const code =
+      generateSharedTransformationCode() + '\n' + generateEcommerceProductTransformationCode()
+    const build = new Function(code + '\nreturn buildEcommerceProduct;')() as (
+      r: unknown
+    ) => Record<string, unknown>
+    expect(
+      build({ id: 'f', name: 'Mug', slug: 'mug', price: 9, currency: 'USD', quantity: 0 })
+        .outOfStock
+    ).toBe('true')
+  })
+})
+
+describe('buildProductTransformOptions — allowBackorders resolution', () => {
+  const settings = (stockManagement: boolean, allowBackorders?: boolean) =>
+    ({
+      stockManagement,
+      stockManagementConfig:
+        allowBackorders === undefined ? null : { allowBackorders, lowStockThreshold: 5 },
+    } as never)
+
+  it('stock management ON + backorders ON → true', () => {
+    expect(
+      buildProductTransformOptions({ ecommerceSettings: settings(true, true) }).allowBackorders
+    ).toBe(true)
+  })
+
+  it('stock management ON + backorders OFF → false', () => {
+    expect(
+      buildProductTransformOptions({ ecommerceSettings: settings(true, false) }).allowBackorders
+    ).toBe(false)
+  })
+
+  it('stock management OFF → true regardless of the config block', () => {
+    expect(
+      buildProductTransformOptions({ ecommerceSettings: settings(false) }).allowBackorders
+    ).toBe(true)
+  })
+
+  it('no e-commerce settings at all → false (strict default)', () => {
+    expect(buildProductTransformOptions({}).allowBackorders).toBe(false)
+  })
+})

package/__tests__/ecommerce-product-discounts.test.ts

@@ -0,0 +1,196 @@
+import { generateEcommerceProductTransformationCode } from '../src/transformations/ecommerce-product'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+
+/**
+ * Per-product discounts in the GENERATED storefront transform — the third
+ * mirror of the rule that also lives in teleport-gui as
+ * `features/e-commerce/utils/product-discounts.ts` (editor/canvas) and
+ * `.../builders/ecommerce/product-discount-script.ts` (the baked add-to-cart
+ * script). The GUI's `product-discount-parity.spec.ts` pins those two together;
+ * this file is what keeps THIS copy honest.
+ *
+ * The two invariants under test: a discount comes off the NET price BEFORE tax,
+ * and the stored `price` never moves — every write path re-reads the raw row.
+ */
+
+const evalBuildProduct = (
+  storefrontTaxRate = 0
+): ((record: unknown) => Record<string, unknown>) => {
+  const code =
+    generateSharedTransformationCode() +
+    '\n' +
+    generateEcommerceProductTransformationCode({ storefrontTaxRate })
+  const fn = new Function(code + '\nreturn buildEcommerceProduct;')
+  return fn() as (record: unknown) => Record<string, unknown>
+}
+
+const FLAT_PRODUCT = { id: 'p1', name: 'P', slug: 'p', price: '100.00', currency: 'USD' }
+
+const discountsColumn = (
+  over: Partial<{
+    type: string
+    value: number
+    startsAt: string | null
+    endsAt: string | null
+  }> = {}
+): string =>
+  JSON.stringify([
+    { id: 'd1', type: 'percentage', value: 10, startsAt: null, endsAt: null, ...over },
+  ])
+
+describe('ecommerce product transform — per-product discounts', () => {
+  it('leaves `price` alone and marks the DISPLAY price down', () => {
+    const product = evalBuildProduct()({ ...FLAT_PRODUCT, discounts: discountsColumn() })
+    expect(product.price).toBe(100)
+    expect(product.displayPrice).toBe('90.00')
+    expect(product.hasDiscount).toBe('true')
+    expect(product.originalDisplayPrice).toBe('100.00')
+  })
+
+  it('takes the discount off the NET price, then adds tax on top of that', () => {
+    const product = evalBuildProduct(19)({ ...FLAT_PRODUCT, discounts: discountsColumn() })
+    // 100 → 90 net → 90 * 1.19 = 107.10 gross. Taxing first would give 119 − 10%.
+    expect(product.displayPrice).toBe('107.10')
+    expect(product.originalDisplayPrice).toBe('119.00')
+  })
+
+  it('emits the badge copy for both discount types', () => {
+    const percentage = evalBuildProduct()({ ...FLAT_PRODUCT, discounts: discountsColumn() })
+    expect(percentage.discountLabel).toBe('10% off')
+
+    const fixed = evalBuildProduct()({
+      ...FLAT_PRODUCT,
+      discounts: discountsColumn({ type: 'fixed', value: 15 }),
+    })
+    expect(fixed.discountLabel).toBe('$15 off')
+    expect(fixed.displayPrice).toBe('85.00')
+  })
+
+  it('puts the currency symbol where the currency wants it', () => {
+    const product = evalBuildProduct()({
+      ...FLAT_PRODUCT,
+      currency: 'SEK',
+      discounts: discountsColumn({ type: 'fixed', value: 20 }),
+    })
+    expect(String(product.discountLabel).endsWith(' off')).toBe(true)
+    expect(String(product.discountLabel)).toContain('20')
+  })
+
+  it('reports no discount — and no struck price — when nothing is scheduled', () => {
+    const product = evalBuildProduct()(FLAT_PRODUCT)
+    expect(product.hasDiscount).toBe('false')
+    expect(product.discountLabel).toBe('')
+    expect(product.originalDisplayPrice).toBe('')
+    expect(product.displayPrice).toBe('100.00')
+  })
+
+  it('honours the half-open window: live at the start instant, over at the end', () => {
+    const now = Date.now()
+    const live = evalBuildProduct()({
+      ...FLAT_PRODUCT,
+      discounts: JSON.stringify([
+        {
+          id: 'd1',
+          type: 'percentage',
+          value: 10,
+          startsAt: new Date(now - 1000).toISOString(),
+          endsAt: new Date(now + 60000).toISOString(),
+        },
+      ]),
+    })
+    expect(live.hasDiscount).toBe('true')
+
+    const expired = evalBuildProduct()({
+      ...FLAT_PRODUCT,
+      discounts: JSON.stringify([
+        {
+          id: 'd1',
+          type: 'percentage',
+          value: 10,
+          startsAt: new Date(now - 60000).toISOString(),
+          endsAt: new Date(now - 1000).toISOString(),
+        },
+      ]),
+    })
+    expect(expired.hasDiscount).toBe('false')
+    expect(expired.displayPrice).toBe('100.00')
+
+    const scheduled = evalBuildProduct()({
+      ...FLAT_PRODUCT,
+      discounts: JSON.stringify([
+        { id: 'd1', type: 'percentage', value: 10, startsAt: new Date(now + 60000).toISOString() },
+      ]),
+    })
+    expect(scheduled.hasDiscount).toBe('false')
+  })
+
+  it('never goes below zero, and never renders a negative price', () => {
+    const product = evalBuildProduct()({
+      ...FLAT_PRODUCT,
+      discounts: discountsColumn({ type: 'fixed', value: 500 }),
+    })
+    expect(product.displayPrice).toBe('0.00')
+  })
+
+  it('falls back to the list price when the column is unusable', () => {
+    const cases = ['{not json', JSON.stringify({ type: 'percentage' }), '', null]
+    cases.forEach((discounts) => {
+      const product = evalBuildProduct()({ ...FLAT_PRODUCT, discounts })
+      expect(product.hasDiscount).toBe('false')
+      expect(product.displayPrice).toBe('100.00')
+    })
+  })
+
+  it('discounts each variant from its OWN price, carrying the pre-discount twin', () => {
+    const record = {
+      ...FLAT_PRODUCT,
+      discounts: discountsColumn({ value: 50 }),
+      variant_options: JSON.stringify([
+        {
+          key: 'size',
+          name: 'Size',
+          type: 'text',
+          values: [
+            { value: 's', label: 'S' },
+            { value: 'l', label: 'L' },
+          ],
+        },
+      ]),
+    }
+    const build = new Function(
+      generateSharedTransformationCode() +
+        '\n' +
+        generateEcommerceProductTransformationCode({ storefrontTaxRate: 0 }) +
+        '\nreturn buildEcommerceProduct;'
+    )() as (row: unknown, variants: unknown) => Record<string, unknown>
+
+    const product = build(record, {
+      variantsByProductId: {
+        // An overriding combination, and one that INHERITS the product price.
+        p1: [
+          { id: 'v-s', options: { size: 's' }, price: '40.00', quantity: 5 },
+          { id: 'v-l', options: { size: 'l' }, price: null, quantity: 5 },
+        ],
+      },
+    })
+
+    const variantsDisplay = JSON.parse(String(product.variantsDisplayJson)) as Array<{
+      id: string
+      price: number
+      originalPrice: number | null
+    }>
+    const small = variantsDisplay.find((entry) => entry.id === 'v-s')
+    const large = variantsDisplay.find((entry) => entry.id === 'v-l')
+
+    expect(small?.price).toBe(20)
+    expect(small?.originalPrice).toBe(40)
+    // The inheriting combination is discounted from the PRODUCT price, not left
+    // at the undiscounted base.
+    expect(large?.price).toBe(50)
+    expect(large?.originalPrice).toBe(100)
+
+    // The net twins stay untouched — every write path re-reads them.
+    const variantsJson = JSON.parse(String(product.variantsJson)) as Array<{ price: number | null }>
+    expect(variantsJson.map((entry) => entry.price)).toEqual([40, null])
+  })
+})