@teleporthq/teleport-plugin-next-data-source 0.43.66 → 0.43.68

package/__tests__/ecommerce-product-storefront-contract.test.ts

@@ -145,3 +145,296 @@ describe('ecommerce product transform — storefront picker contract', () => {
     expect(Array.isArray(productWithVariants().visibleProperties)).toBe(true)
   })
 })
+
+/**
+ * Every field the generated product page reads to say what buying a product
+ * MEANS — the "Purchase details" block and the price-row pills. Strings where
+ * a rendering condition gates on them; the block is hidden by absence, so a
+ * plain one-time product must still carry every key.
+ */
+const PURCHASE_DETAILS_CONTRACT = [
+  'billingPeriod',
+  'billingSummary',
+  'trialDays',
+  'recurringIntervalCount',
+  'isDigital',
+  'isGiftCard',
+]
+
+const subscriptionPlan = (over: Record<string, unknown>) =>
+  buildEcommerceProduct(
+    {
+      id: 'p3',
+      name: 'Plan',
+      slug: 'plan',
+      price: '12',
+      currency: 'USD',
+      payment_type: 'recurring',
+      recurring_interval: 'month',
+      ...over,
+    },
+    { variantsByProductId: {} }
+  )
+
+describe('ecommerce product transform — storefront purchase-details contract', () => {
+  it.each(PURCHASE_DETAILS_CONTRACT)('always emits %s, for a product WITH variants', (field) => {
+    expect(productWithVariants()).toHaveProperty(field)
+  })
+
+  it.each(PURCHASE_DETAILS_CONTRACT)('always emits %s, for a product WITHOUT variants', (field) => {
+    expect(productWithoutVariants()).toHaveProperty(field)
+  })
+
+  it('says nothing about billing, a download or a gift card on a plain one-time product', () => {
+    expect(productWithoutVariants()).toMatchObject({
+      billingSummary: '',
+      trialDays: 0,
+      isDigital: 'false',
+      isGiftCard: 'false',
+    })
+  })
+
+  it('prints the billing sentence of a subscription, with its free trial when it has one', () => {
+    expect(subscriptionPlan({ recurring_interval_count: '3', trial_days: '14' })).toMatchObject({
+      billingPeriod: '3 months',
+      billingSummary: 'Billed every 3 months · 14-day free trial',
+      trialDays: 14,
+      recurringIntervalCount: 3,
+    })
+    // NULL / zero columns read as "every month, no trial" — and the count the
+    // schedule is built from is never below 1 on a subscription.
+    for (const over of [
+      { recurring_interval_count: null, trial_days: null },
+      { recurring_interval_count: 0, trial_days: 0 },
+      { recurring_interval_count: 'x', trial_days: -3 },
+    ]) {
+      expect(subscriptionPlan(over)).toMatchObject({
+        billingPeriod: 'month',
+        billingSummary: 'Billed every month',
+        trialDays: 0,
+        recurringIntervalCount: 1,
+      })
+    }
+  })
+
+  it('gates the gift-card pill with the STRING "true"/"false", however the column is spelled', () => {
+    for (const raw of [true, 't', 'true', 1, '1']) {
+      expect(
+        buildEcommerceProduct({ id: 'g', name: 'G', price: '5', is_gift_card: raw }).isGiftCard
+      ).toBe('true')
+    }
+    for (const raw of [false, 'f', 'false', 0, '0', null, undefined, '']) {
+      expect(
+        buildEcommerceProduct({ id: 'g', name: 'G', price: '5', is_gift_card: raw }).isGiftCard
+      ).toBe('false')
+    }
+  })
+})
+
+/**
+ * Every field the generated product page and cards read to draw product
+ * options: the configurator, the configured price, the card's quick-add gate
+ * and the buy button's attributes. A listing and a product without options
+ * carry the EMPTY values — a binding to an absent field renders undefined, and
+ * the configurator's gates would read that as a configured product.
+ */
+const OPTIONS_CONTRACT = [
+  'hasProductOptions',
+  'optionsRequireInput',
+  'optionsQuickAdd',
+  'optionGroups',
+  'optionGroupsJson',
+  'optionsPricingJson',
+  'optionsDefaultDisplayPrice',
+  'optionsDefaultOriginalDisplayPrice',
+  'optionsDefaultSummary',
+  'optionsFreshKey',
+  'optionsValidKey',
+  'optionsOriginalKey',
+  'optionsSummaryKey',
+  'optionsFilesKey',
+]
+
+const OPTION_GROUP_CONTRACT = [
+  'id',
+  'key',
+  'label',
+  'helpText',
+  'placeholder',
+  'unit',
+  'required',
+  'isChoice',
+  'isMulti',
+  'isText',
+  'isLongText',
+  'isNumber',
+  'isToggle',
+  'isUpload',
+  'isButtons',
+  'isSwatches',
+  'isCards',
+  'isSelectable',
+  'isInput',
+  'initiallyVisible',
+  'cellRole',
+  'rowRole',
+  'rowRequired',
+  'idleTabIndex',
+  'inputType',
+  'inputMode',
+  'maxLengthText',
+  'minText',
+  'maxText',
+  'stepText',
+  'defaultValueText',
+  'rangeHint',
+  'acceptKind',
+  'acceptMime',
+  'priceVariants',
+  'headerPriceVariants',
+  'hiddenKey',
+  'shownKey',
+  'missingKey',
+  'invalidKey',
+  'rejectedKey',
+  'failedKey',
+  'uploadedKey',
+  'uploadingKey',
+  'freshKey',
+  'values',
+]
+
+const OPTION_VALUE_CONTRACT = [
+  'id',
+  'key',
+  'label',
+  'description',
+  'color',
+  'imageUrl',
+  'isDefault',
+  'showSwatch',
+  'showImage',
+  'selectedKey',
+  'freshKey',
+  'priceVariants',
+]
+
+const OPTION_GROUPS = [
+  {
+    key: 'size',
+    label: 'Size',
+    type: 'choice',
+    required: true,
+    values: [
+      { key: 'a5', label: 'A5', price: { mode: 'none' }, default: true },
+      { key: 'a3', label: 'A3', price: { mode: 'fixed', amount: 9 } },
+    ],
+  },
+  { key: 'gift-wrap', label: 'Gift wrap', type: 'toggle', price: { mode: 'fixed', amount: 2 } },
+  { key: 'engraving', label: 'Engraving', type: 'text', maxLength: 20 },
+]
+
+const configurableProduct = (includeOptionDetail: boolean) =>
+  buildEcommerceProduct(
+    {
+      id: 'p4',
+      name: 'Lighter',
+      slug: 'lighter',
+      price: '30',
+      currency: 'USD',
+      option_groups: JSON.stringify(OPTION_GROUPS),
+    },
+    { variantsByProductId: {}, includeOptionDetail }
+  )
+
+describe('ecommerce product transform — storefront product-options contract', () => {
+  it.each(OPTIONS_CONTRACT)('always emits %s, for a product WITH variants', (field) => {
+    expect(productWithVariants()).toHaveProperty(field)
+  })
+
+  it.each(OPTIONS_CONTRACT)('always emits %s, for a product WITHOUT variants', (field) => {
+    expect(productWithoutVariants()).toHaveProperty(field)
+  })
+
+  it.each(OPTIONS_CONTRACT)('always emits %s, for a configurable product in a listing', (field) => {
+    expect(configurableProduct(false)).toHaveProperty(field)
+  })
+
+  it('gates with the STRING flags, never booleans', () => {
+    expect(productWithoutVariants()).toMatchObject({
+      hasProductOptions: 'false',
+      optionsRequireInput: 'false',
+      optionsQuickAdd: 'true',
+    })
+    expect(configurableProduct(false)).toMatchObject({
+      hasProductOptions: 'true',
+      optionsRequireInput: 'false',
+      optionsQuickAdd: 'true',
+    })
+  })
+
+  it('enriches every group and value with the fields the configurator binds', () => {
+    const groups = configurableProduct(true).optionGroups as Array<Record<string, unknown>>
+    expect(groups).toHaveLength(3)
+    for (const group of groups) {
+      for (const field of OPTION_GROUP_CONTRACT) {
+        expect(group).toHaveProperty(field)
+      }
+      for (const value of group.values as Array<Record<string, unknown>>) {
+        for (const field of OPTION_VALUE_CONTRACT) {
+          expect(value).toHaveProperty(field)
+        }
+      }
+    }
+  })
+
+  it('keys every repeater row by the product, so typed text never follows the shopper', () => {
+    const [size, wrap] = configurableProduct(true).optionGroups as Array<{
+      id: string
+      values: Array<{ id: string }>
+    }>
+    expect(size.id).toBe('p4|size')
+    expect(size.values.map((value) => value.id)).toEqual(['p4|size|a5', 'p4|size|a3'])
+    expect(wrap.values.map((value) => value.id)).toEqual(['p4|gift-wrap|on'])
+  })
+
+  it('ships the JSON companions the configurator workflows parse', () => {
+    const product = configurableProduct(true)
+    expect(JSON.parse(product.optionGroupsJson as string)).toHaveLength(3)
+    expect(JSON.parse(product.optionsPricingJson as string)).toMatchObject({
+      productId: 'p4',
+      netBase: 30,
+      pricesDisabled: false,
+    })
+  })
+
+  // ARIA allows aria-required on a radiogroup, not on a group: a required
+  // pick-several row carrying it fails axe and Lighthouse (aria-allowed-attr).
+  it('lets only a pick-one row say it is required, with null (never undefined) elsewhere', () => {
+    const extras = {
+      key: 'extras',
+      label: 'Extras',
+      type: 'multi-choice',
+      required: true,
+      values: [{ key: 'ribbon', label: 'Ribbon', price: { mode: 'none' } }],
+    }
+    const product = buildEcommerceProduct(
+      {
+        id: 'p5',
+        name: 'Hamper',
+        slug: 'hamper',
+        price: '40',
+        currency: 'USD',
+        option_groups: JSON.stringify([...OPTION_GROUPS, extras]),
+      },
+      { variantsByProductId: {}, includeOptionDetail: true }
+    )
+    const groups = product.optionGroups as Array<Record<string, unknown>>
+    expect(groups.map((group) => [group.key, group.rowRole, group.rowRequired])).toEqual([
+      ['size', 'radiogroup', 'true'],
+      ['gift-wrap', 'group', null],
+      ['engraving', 'group', null],
+      ['extras', 'group', null],
+    ])
+  })
+})

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

@@ -0,0 +1,121 @@
+/* tslint:disable:function-constructor */
+import { generateEcommerceProductTransformationCode } from '../src/transformations/ecommerce-product'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+
+/**
+ * What a product card says about a subscription and a download: the period a
+ * recurring price is followed by (`billingPeriod`, "/ month") and the
+ * `isDigital` gate of the "Instant download" pill. Both are STRINGS the
+ * builders bind and gate on, and both exist in two copies — this generated
+ * transform and the editor's canvas transform.
+ *
+ * ⚠️ `PERIOD_FIXTURES` IS SHARED. It is byte-identical to the table in
+ * teleport-gui's `features/e-commerce/utils/__tests__/recurring-summary-parity.spec.ts`,
+ * which runs it against `formatBillingPeriod`. Two specs, one table.
+ */
+
+const buildProduct = (): ((record: unknown, options?: unknown) => Record<string, unknown>) => {
+  const code =
+    generateSharedTransformationCode() + '\n' + generateEcommerceProductTransformationCode({})
+  return new Function(code + '\nreturn buildEcommerceProduct;')() as (
+    record: unknown,
+    options?: unknown
+  ) => Record<string, unknown>
+}
+
+/** SHARED PARITY TABLE — keep byte-identical with the GUI spec. */
+const PERIOD_FIXTURES: Array<{ interval: unknown; count: unknown; period: string }> = [
+  { interval: 'month', count: 1, period: 'month' },
+  { interval: 'month', count: 3, period: '3 months' },
+  { interval: 'year', count: 1, period: 'year' },
+  { interval: 'week', count: 2, period: '2 weeks' },
+  { interval: ' DAY ', count: '7', period: '7 days' },
+  { interval: 'fortnight', count: 0, period: 'month' },
+  { interval: null, count: null, period: 'month' },
+]
+
+const BASE = { id: 'p1', name: 'P', slug: 'p', price: '10.00', currency: 'USD' }
+
+describe('ecommerce product transform — subscriptions and digital delivery', () => {
+  const build = buildProduct()
+
+  it.each(PERIOD_FIXTURES)(
+    'follows a recurring price billed every $interval × $count with "$period"',
+    ({ interval, count, period }) => {
+      const product = build({
+        ...BASE,
+        payment_type: 'recurring',
+        recurring_interval: interval,
+        recurring_interval_count: count,
+      })
+      expect(product.billingPeriod).toBe(period)
+    }
+  )
+
+  it('follows a one-time price with nothing, whatever the interval columns hold', () => {
+    expect(build({ ...BASE, recurring_interval: 'month' }).billingPeriod).toBe('')
+    expect(
+      build({ ...BASE, payment_type: 'one_time', recurring_interval: 'year' }).billingPeriod
+    ).toBe('')
+  })
+
+  it('reads the digital flag as every backend spells it, and NULL as physical', () => {
+    for (const raw of [true, 't', 'true', 1, '1', 'YES']) {
+      expect(build({ ...BASE, is_digital: raw }).isDigital).toBe('true')
+    }
+    for (const raw of [false, 'f', 'false', 0, '0', null, undefined, '']) {
+      expect(build({ ...BASE, is_digital: raw }).isDigital).toBe('false')
+    }
+  })
+})
+
+/**
+ * SHARED PARITY TABLE — keep byte-identical with the GUI's
+ * `packages/renderer/src/utils/__tests__/ecommerce-products-purchase-details.test.ts`,
+ * which runs it against the canvas transform.
+ */
+const BILLING_SUMMARY_FIXTURES: Array<{
+  interval: unknown
+  count: unknown
+  trialDays: unknown
+  summary: string
+}> = [
+  { interval: 'month', count: 1, trialDays: null, summary: 'Billed every month' },
+  {
+    interval: 'month',
+    count: 3,
+    trialDays: 14,
+    summary: 'Billed every 3 months · 14-day free trial',
+  },
+  { interval: 'year', count: 1, trialDays: '30', summary: 'Billed every year · 30-day free trial' },
+  {
+    interval: 'week',
+    count: '2',
+    trialDays: 1,
+    summary: 'Billed every 2 weeks · 1-day free trial',
+  },
+  { interval: ' DAY ', count: '7', trialDays: 0, summary: 'Billed every 7 days' },
+  { interval: null, count: null, trialDays: '', summary: 'Billed every month' },
+]
+
+describe('ecommerce product transform — the billing summary of a subscription', () => {
+  const build = buildProduct()
+
+  it.each(BILLING_SUMMARY_FIXTURES)(
+    'describes $interval × $count with a $trialDays-day trial as "$summary"',
+    ({ interval, count, trialDays, summary }) => {
+      const product = build({
+        ...BASE,
+        payment_type: 'recurring',
+        recurring_interval: interval,
+        recurring_interval_count: count,
+        trial_days: trialDays,
+      })
+      expect(product.billingSummary).toBe(summary)
+    }
+  )
+
+  it('describes a one-time product with nothing, whatever its trial column holds', () => {
+    expect(build({ ...BASE, trial_days: 14 }).billingSummary).toBe('')
+  })
+})

package/__tests__/fetchers.test.ts

@@ -355,9 +355,9 @@ describe('generateDataSourceFetcher', () => {
     const code = generateDataSourceFetcher(dataSource, 'teleport_products')
 
     // The multi-select Category Filter writes ?categoryFilter=a,b,c; the scalar
-    // array_overlap branch splits it so jsonb_exists_any matches the union.
+    // array_overlap branch splits it so the overlap matches the union.
     expect(code).toContain('array_overlap')
-    expect(code).toContain('jsonb_exists_any')
+    expect(code).toContain('function arrayOverlapSql(columns, param)')
     expect(code).toContain("String(value).split(',')")
   })
 

package/__tests__/gated-data-provider.test.ts

@@ -0,0 +1,88 @@
+import * as types from '@babel/types'
+import generator from '@babel/generator'
+import { parse } from '@babel/parser'
+import {
+  ChunkType,
+  FileType,
+  ComponentStructure,
+  ChunkDefinition,
+} from '@teleporthq/teleport-types'
+import { createNextArrayMapperPaginationPlugin } from '../src/pagination-plugin'
+
+/**
+ * A paginated list under a tab panel — `{activeTabIndex === 0 && (…)}` — is a
+ * DataProvider on the RIGHT of a logical expression. The plugin's JSX walkers
+ * visited children, bodies, arguments and ternary branches, never `left` /
+ * `right`, so the provider was never wired: no page params, no fetcher, and a
+ * shop whose grid sat under its first tab rendered nothing.
+ */
+const makeComponentChunk = (): ChunkDefinition => {
+  const program = parse(
+    `const TestComponent = (props) => {
+      return (
+        <div>
+          {activeTabIndex === 0 && (
+            <div className="panel">
+              <DataProvider name={'items'} renderSuccess={(items) => (
+                <Repeater items={items || []} renderItem={(product) => <div>{product.name}</div>} />
+              )} />
+            </div>
+          )}
+        </div>
+      )
+    }`,
+    { sourceType: 'module', plugins: ['jsx'] }
+  )
+  return {
+    name: 'jsx-component',
+    type: ChunkType.AST,
+    fileType: FileType.JS,
+    linkAfter: [],
+    content: program.program.body[0] as types.VariableDeclaration,
+    meta: {},
+  }
+}
+
+// tslint:disable-next-line:no-any
+const makeUidlNode = (): any => ({
+  type: 'data-source-list',
+  content: {
+    renderPropIdentifier: 'items',
+    resourceDefinition: {
+      dataSourceId: 'ds1',
+      tableName: 'products',
+      dataSourceType: 'postgresql',
+    },
+    resource: { params: { queryColumns: { content: ['name'] } } },
+    nodes: {
+      success: {
+        type: 'cms-list-repeater',
+        content: {
+          renderPropIdentifier: 'product',
+          paginated: true,
+          perPage: 20,
+          searchEnabled: false,
+          nodes: { list: { type: 'element', content: { elementType: 'div' } } },
+        },
+      },
+    },
+  },
+})
+
+describe('pagination plugin — a provider gated by a logical expression', () => {
+  it('wires the page params and the fetcher onto a DataProvider under `cond && (…)`', async () => {
+    const chunk = makeComponentChunk()
+    const structure: ComponentStructure = {
+      uidl: { name: 'TestComponent', node: makeUidlNode() },
+      chunks: [chunk],
+      dependencies: {},
+      options: { dataSources: {}, extractedResources: {} },
+    } as never
+    await createNextArrayMapperPaginationPlugin()(structure)
+    const code = generator(chunk.content as types.Node).code.replace(/\s+/g, ' ')
+
+    expect(code).toContain('page: ds_0_page')
+    expect(code).toContain('perPage: 20')
+    expect(code).toContain('fetchData={')
+  })
+})

package/__tests__/items-path.test.ts

@@ -0,0 +1,150 @@
+import * as types from '@babel/types'
+import generator from '@babel/generator'
+import { ComponentStructure } from '@teleporthq/teleport-types'
+import { createNextArrayMapperPaginationPlugin } from '../src/pagination-plugin'
+import { extractItemsPath } from '../src/items-path'
+import { generateRESTAPIFetcher } from '../src/fetchers/rest-api'
+import { generateJavaScriptFetcher } from '../src/fetchers/javascript'
+import { makeUidlNode, makeWidgetComponentChunk } from './_helpers/pagination-widget-fixture'
+
+/**
+ * A paginated list bound to an array INSIDE a REST payload
+ * (`{ templates: [...], total }` -> `data?.templates || []`) rendered every row
+ * on every page: the fetcher only paged a payload that was itself an array, and
+ * the count measured the wrapper as 0 rows.
+ */
+
+const runHandler = async (
+  code: string,
+  query: Record<string, unknown>,
+  fetchImpl?: () => Promise<unknown>
+) => {
+  const withoutImports = code.replace(/^import\s+.*?$/gm, '')
+  const factory = new Function(
+    'fetch',
+    `${withoutImports.replace('export default async function handler', 'async function handler')}
+    return handler`
+  )
+  const handler = factory(fetchImpl)
+
+  let payload: Record<string, unknown> = {}
+  const res = {
+    status: () => res,
+    json: (data: Record<string, unknown>) => {
+      payload = data
+      return res
+    },
+  }
+
+  await handler({ query, body: undefined }, res)
+  return payload
+}
+
+const rows = Array.from({ length: 25 }, (_, i) => ({ id: i + 1, name: `row ${i + 1}` }))
+const respondWith = (body: unknown) => () =>
+  Promise.resolve({ ok: true, status: 200, statusText: 'OK', json: () => Promise.resolve(body) })
+
+describe('extractItemsPath', () => {
+  it('reads the property chain off the data source render prop', () => {
+    expect(extractItemsPath('ds?.templates || []', 'ds', 'rest-api')).toEqual(['templates'])
+    expect(extractItemsPath('ds?.data?.items', 'ds', 'rest-api')).toEqual(['data', 'items'])
+    expect(extractItemsPath('ds?.["my list"] || []', 'ds', 'javascript')).toEqual(['my list'])
+  })
+
+  it('is absent when the list is bound to the payload itself', () => {
+    expect(extractItemsPath('ds || []', 'ds', 'rest-api')).toBeUndefined()
+    expect(extractItemsPath('ds', 'ds', 'rest-api')).toBeUndefined()
+  })
+
+  it('leaves anything it cannot read, and non-wrapping source types, alone', () => {
+    expect(extractItemsPath('ds?.items.filter(Boolean)', 'ds', 'rest-api')).toBeUndefined()
+    expect(extractItemsPath('other?.items', 'ds', 'rest-api')).toBeUndefined()
+    expect(extractItemsPath('ds?.items', 'ds', 'postgresql')).toBeUndefined()
+  })
+})
+
+interface FetcherSetup {
+  code: string
+  fetchImpl?: () => Promise<unknown>
+}
+
+describe.each<[string, FetcherSetup]>([
+  [
+    'REST API',
+    {
+      code: generateRESTAPIFetcher({ url: 'https://api.test/items', method: 'GET' }),
+      fetchImpl: respondWith({ templates: rows, total: 25 }),
+    },
+  ],
+  [
+    'JavaScript',
+    { code: generateJavaScriptFetcher({ code: JSON.stringify({ templates: rows, total: 25 }) }) },
+  ],
+])('%s fetcher — itemsPath', (_label, setup) => {
+  it('pages the inner array and keeps the wrapper', async () => {
+    const result = await runHandler(
+      setup.code,
+      {
+        page: '2',
+        perPage: '10',
+        itemsPath: JSON.stringify(['templates']),
+      },
+      setup.fetchImpl
+    )
+
+    const data = result.data as { templates: Array<{ id: number }>; total: number }
+    expect(data.total).toBe(25)
+    expect(data.templates.map((r) => r.id)).toEqual([11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
+  })
+
+  it('searches the inner array', async () => {
+    const result = await runHandler(
+      setup.code,
+      {
+        query: 'row 2',
+        queryColumns: JSON.stringify(['name']),
+        itemsPath: JSON.stringify(['templates']),
+      },
+      setup.fetchImpl
+    )
+
+    const data = result.data as { templates: Array<{ id: number }> }
+    expect(data.templates.map((r) => r.id)).toEqual([2, 20, 21, 22, 23, 24, 25])
+  })
+
+  it('returns the payload untouched without the param', async () => {
+    const result = await runHandler(setup.code, { page: '1', perPage: '10' }, setup.fetchImpl)
+    expect((result.data as { templates: unknown[] }).templates).toHaveLength(25)
+  })
+})
+
+describe('pagination plugin — list bound to a wrapped REST payload', () => {
+  const runPlugin = async (source: string): Promise<string> => {
+    const node = makeUidlNode({})
+    node.content.resourceDefinition.dataSourceType = 'rest-api'
+    node.content.nodes.success.content.source = source
+    const chunk = makeWidgetComponentChunk({ controls: ['previous', 'next'] })
+    const structure: ComponentStructure = {
+      uidl: { name: 'TestComponent', node },
+      chunks: [chunk],
+      dependencies: {},
+      options: { dataSources: {}, extractedResources: {} },
+    } as never
+    await createNextArrayMapperPaginationPlugin()(structure)
+    return generator(chunk.content as types.Node).code.replace(/\s+/g, ' ')
+  }
+
+  it('sends itemsPath with the page fetch and collectionPath with the count', async () => {
+    const flat = await runPlugin('items?.templates || []')
+
+    expect(flat).toContain('itemsPath: "[\\"templates\\"]"')
+    expect(flat).toContain('collectionPath: "[\\"templates\\"]"')
+  })
+
+  it('sends neither when the list is the payload', async () => {
+    const flat = await runPlugin('items || []')
+
+    expect(flat).not.toContain('itemsPath')
+    expect(flat).not.toContain('collectionPath')
+  })
+})