@teleporthq/teleport-plugin-next-data-source 0.43.74 → 0.44.0

package/__tests__/plain-list-sort.test.ts

@@ -0,0 +1,215 @@
+import * as types from '@babel/types'
+import generator from '@babel/generator'
+import {
+  ChunkType,
+  FileType,
+  ComponentStructure,
+  ChunkDefinition,
+} from '@teleporthq/teleport-types'
+import { createNextArrayMapperPaginationPlugin } from '../src/pagination-plugin'
+
+/**
+ * A PLAIN list — no pagination, no search — fetches with the sort its
+ * repeater carries, like every other list: the three paginated / searchable
+ * kinds rebuild their params with it, while a plain list's params were kept
+ * as they came and the sort never reached the fetch, so the rows arrived in
+ * the table's own order whatever the editor said.
+ */
+
+const element = (name: string, attributes: types.JSXAttribute[] = []) =>
+  types.jsxElement(
+    types.jsxOpeningElement(types.jsxIdentifier(name), attributes, true),
+    null,
+    [],
+    true
+  )
+
+const makeDataProviderJSX = (): types.JSXElement =>
+  element('DataProvider', [
+    types.jsxAttribute(
+      types.jsxIdentifier('name'),
+      types.jsxExpressionContainer(types.stringLiteral('items'))
+    ),
+    types.jsxAttribute(
+      types.jsxIdentifier('renderSuccess'),
+      types.jsxExpressionContainer(
+        types.arrowFunctionExpression(
+          [types.identifier('items')],
+          element('Repeater', [
+            types.jsxAttribute(
+              types.jsxIdentifier('renderItem'),
+              types.jsxExpressionContainer(
+                types.arrowFunctionExpression([types.identifier('post')], element('div'))
+              )
+            ),
+          ])
+        )
+      )
+    ),
+  ])
+
+const makeComponentChunk = (): ChunkDefinition => ({
+  name: 'jsx-component',
+  type: ChunkType.AST,
+  fileType: FileType.JS,
+  linkAfter: [],
+  content: types.variableDeclaration('const', [
+    types.variableDeclarator(
+      types.identifier('PostsList'),
+      types.arrowFunctionExpression(
+        [types.identifier('props')],
+        types.blockStatement([types.returnStatement(makeDataProviderJSX())])
+      )
+    ),
+  ]),
+  meta: {},
+})
+
+type SortKind = 'fixed' | 'state' | 'none'
+
+const SORTS: Record<SortKind, Record<string, unknown>> = {
+  fixed: {
+    sort: { type: 'static', content: 'title' },
+    sortDirection: { type: 'static', content: 'asc' },
+  },
+  state: {
+    sort: { type: 'expr', content: 'sortBy.split("-")[0]' },
+    sortDirection: { type: 'expr', content: 'sortBy.split("-")[1]' },
+  },
+  none: {},
+}
+
+const runPlugin = async (
+  sort: SortKind,
+  options: { legacySorts?: boolean; params?: boolean; prefetched?: boolean } = {}
+): Promise<string> => {
+  const chunk = makeComponentChunk()
+  if (options.prefetched) {
+    // A page's list, seeded with its server prefetch.
+    const provider = (
+      (chunk.content as types.VariableDeclaration).declarations[0]
+        .init as types.ArrowFunctionExpression
+    ).body as types.BlockStatement
+    const jsx = (provider.body[0] as types.ReturnStatement).argument as types.JSXElement
+    jsx.openingElement.attributes.push(
+      types.jsxAttribute(
+        types.jsxIdentifier('initialData'),
+        types.jsxExpressionContainer(
+          types.memberExpression(types.identifier('props'), types.identifier('items'))
+        )
+      )
+    )
+  }
+  if (options.params) {
+    // The params the data-source plugin writes for a plain list: its filters.
+    const provider = (
+      (chunk.content as types.VariableDeclaration).declarations[0]
+        .init as types.ArrowFunctionExpression
+    ).body as types.BlockStatement
+    const jsx = (provider.body[0] as types.ReturnStatement).argument as types.JSXElement
+    jsx.openingElement.attributes.push(
+      types.jsxAttribute(
+        types.jsxIdentifier('params'),
+        types.jsxExpressionContainer(
+          types.objectExpression([
+            types.objectProperty(types.identifier('filters'), types.stringLiteral('[]')),
+          ])
+        )
+      )
+    )
+  }
+  const structure: ComponentStructure = {
+    uidl: {
+      name: 'PostsList',
+      node: {
+        type: 'data-source-list',
+        content: {
+          renderPropIdentifier: 'items',
+          resourceDefinition: {
+            dataSourceId: 'ds1',
+            tableName: 'posts',
+            dataSourceType: 'postgresql',
+          },
+          resource: {
+            params: {
+              queryColumns: { content: ['title'] },
+              ...(options.legacySorts
+                ? { sorts: { content: [{ field: 'created_at', order: 'desc' }] } }
+                : {}),
+            },
+          },
+          nodes: {
+            success: {
+              type: 'cms-list-repeater',
+              content: {
+                renderPropIdentifier: 'post',
+                nodes: { list: { type: 'element', content: { elementType: 'div' } } },
+                ...SORTS[sort],
+              },
+            },
+          },
+        },
+      },
+    },
+    chunks: [chunk],
+    dependencies: {},
+    options: {
+      dataSources: {
+        ds1: {
+          id: 'ds1',
+          name: 'Content',
+          type: 'postgresql',
+          config: { host: 'h', database: 'd', user: 'u', password: 'p' },
+        },
+      },
+      extractedResources: {},
+    },
+  } as never
+  await createNextArrayMapperPaginationPlugin()(structure)
+  return generator(chunk.content as types.Node).code
+}
+
+const squash = (code: string) => code.replace(/\s+/g, ' ')
+
+describe('a plain list fetches with its repeater’s sort', () => {
+  it('sends a sort the editor fixed', async () => {
+    const code = squash(await runPlugin('fixed'))
+    expect(code).toContain(
+      'params={useMemo(() => ({ sorts: JSON.stringify([{ field: "title", order: "asc" }]) }), [])}'
+    )
+  })
+
+  it('sends a sort bound to state, and refetches when the state changes', async () => {
+    const code = squash(await runPlugin('state'))
+    expect(code).toContain(
+      'sorts: JSON.stringify([{ field: sortBy.split("-")?.[0], order: sortBy.split("-")?.[1] }])'
+    )
+    expect(code).toMatch(/\}\), \[sortBy\]\)\}/)
+  })
+
+  it('adds the sort beside the params the list already had', async () => {
+    const code = squash(await runPlugin('fixed', { params: true }))
+    expect(code).toContain(
+      'params={useMemo(() => ({ filters: "[]", sorts: JSON.stringify([{ field: "title", order: "asc" }]) }), [])}'
+    )
+  })
+
+  it('keeps the resource’s own sorts first, as every other list does', async () => {
+    const code = squash(await runPlugin('fixed', { legacySorts: true }))
+    expect(code).toContain('sorts: JSON.stringify([{ field: "created_at", order: "desc" }])')
+    expect(code).not.toContain('field: "title"')
+  })
+
+  it('drops the prefetched rows for a sort bound to state, which the server cannot know', async () => {
+    expect(squash(await runPlugin('state', { prefetched: true }))).not.toContain('initialData')
+    expect(squash(await runPlugin('fixed', { prefetched: true }))).toContain(
+      'initialData={props.items}'
+    )
+  })
+
+  it('leaves a list without a sort as it was', async () => {
+    const code = squash(await runPlugin('none'))
+    expect(code).not.toContain('sorts')
+    expect(code).not.toContain('params=')
+  })
+})

package/__tests__/product-price-sort.ts

@@ -5,12 +5,12 @@ import {
   buildProductEffectivePriceSql,
   generateSortFallbackFieldHelper,
   generateSortFieldSqlHelper,
-  generateSortTiebreakSql,
   supportsProductPriceSort,
 } from '../src/product-price-sort'
 import { generatePostgreSQLFetcher } from '../src/fetchers/postgresql'
 import { generateTeleportFetcher } from '../src/fetchers/teleport'
 import { generateDataSourceFetcher } from '../src/data-source-fetchers'
+import { generateRowOrderTiebreakHelper, rowIdentityColumn } from '../src/row-order'
 
 /**
  * Ordering a products list by what customers actually pay.
@@ -121,8 +121,8 @@ describe('the generated Postgres route', () => {
   it('keeps a plain-column ORDER BY to fall back to', () => {
     // If a database ever rejects the sub-select, the page must degrade to the
     // previous ordering rather than serve nothing.
-    expect(productsRoute).toContain('const usedDiscountAwareSort = orderBySql !== plainOrderBySql')
-    expect(productsRoute).toContain('if (!usedDiscountAwareSort) throw sortError')
+    expect(productsRoute).toContain('const usedRewrittenSort = orderBySql !== plainOrderBySql')
+    expect(productsRoute).toContain('if (!usedRewrittenSort) throw sortError')
     expect(productsRoute).toContain('baseSql + plainOrderBySql + sqlTail')
   })
 
@@ -201,23 +201,57 @@ describe('degrading safely', () => {
 })
 
 describe('stable pagination', () => {
-  it('breaks ties on the products table so pages cannot repeat or skip rows', () => {
-    // "Sort by discount" ties every undiscounted product at zero. Equal rows
-    // with no defined order can appear on two pages, or on none.
-    expect(generateSortTiebreakSql('teleport_products')).toBe(', "id" ASC')
-  })
-
-  it('adds nothing to a table it does not own', () => {
-    expect(generateSortTiebreakSql('teleport_orders')).toBe('')
-  })
-
-  it('is applied to both the real and the fallback ORDER BY', () => {
-    const route = generatePostgreSQLFetcher(PG_CONFIG, 'teleport_products')
-    const orderByLines = route
-      .split('\n')
-      .filter((line) => line.includes('ORDER BY') && line.includes('join'))
-    expect(orderByLines).toHaveLength(2)
-    orderByLines.forEach((line) => expect(line).toContain('"id" ASC'))
+  // Rows that share every requested key have no order of their own: "sort by
+  // discount" ties every undiscounted product at zero, an import dates hundreds
+  // of articles alike. Equal rows can appear on two pages, or on none.
+  const tiebreakOf = (identityColumn: string | null) =>
+    // eslint-disable-next-line no-new-func
+    new Function(`${generateRowOrderTiebreakHelper(identityColumn)}\nreturn rowOrderTiebreak`)()
+
+  it("ends every order with the row's own key, in the order's direction", () => {
+    const tiebreak = tiebreakOf('id')
+    expect(tiebreak(['created_at'], 'DESC')).toBe(', "id" DESC')
+    expect(tiebreak(['price'], 'ASC')).toBe(', "id" ASC')
+    expect(tiebreak(['id'], 'ASC')).toBe('')
+    expect(tiebreakOf(null)(['created_at'], 'DESC')).toBe('')
+  })
+
+  it("takes the table's primary key, else its id, and the products table's id", () => {
+    const saved = (columns: unknown[]) => ({ selectedTables: { posts: { columns } } })
+    expect(
+      rowIdentityColumn(saved([{ name: 'sku', isPrimaryKey: true }, { name: 'id' }]), 'posts')
+    ).toBe('sku')
+    expect(rowIdentityColumn(saved([{ name: 'title' }, { name: 'id' }]), 'posts')).toBe('id')
+    expect(rowIdentityColumn(saved([{ name: 'title' }]), 'posts')).toBeNull()
+    expect(rowIdentityColumn({}, 'teleport_products')).toBe('id')
+    expect(rowIdentityColumn({}, 'teleport_orders')).toBeNull()
+  })
+
+  it('breaks ties on every listing a visitor sorts: the blog listing and the booking page too', () => {
+    // "Sort by reading time" ties every five-minute post, "by price" every
+    // item at the same price.
+    expect(rowIdentityColumn({}, 'teleport_blog_posts')).toBe('id')
+    expect(rowIdentityColumn({}, 'teleport_booking_items')).toBe('id')
+  })
+
+  it('is applied to the real and the fallback ORDER BY, and to a single sort column', () => {
+    for (const route of [
+      generatePostgreSQLFetcher(PG_CONFIG, 'teleport_products'),
+      generateTeleportFetcher(
+        {
+          selectedTables: {
+            teleport_help_articles: { columns: [{ name: 'id', isPrimaryKey: true }] },
+          },
+        },
+        'teleport_help_articles'
+      ),
+    ]) {
+      const orderByLines = route.split('\n').filter((line) => line.includes('ORDER BY ${'))
+      expect(orderByLines.length).toBeGreaterThanOrEqual(3)
+      orderByLines.forEach((line) => expect(line).toMatch(/tiebreak|rowOrderTiebreak/))
+      expect(route).toContain('const rowOrderTiebreak = (fields, direction) =>')
+      expect(() => parse(route, { sourceType: 'module', plugins: ['jsx'] })).not.toThrow()
+    }
   })
 })
 
@@ -247,12 +281,11 @@ describe('the fetcher a generated storefront actually gets', () => {
   })
 
   it('keeps the plain-column fallback and the tiebreaker', () => {
-    expect(teleportProducts).toContain(
-      'const usedDiscountAwareSort = orderBySql !== plainOrderBySql'
-    )
-    expect(teleportProducts).toContain('if (!usedDiscountAwareSort) throw sortError')
+    expect(teleportProducts).toContain('const usedRewrittenSort = orderBySql !== plainOrderBySql')
+    expect(teleportProducts).toContain('if (!usedRewrittenSort) throw sortError')
     expect(teleportProducts).toContain('baseSql + plainOrderBySql + sqlTail')
-    expect(teleportProducts).toContain('"id" ASC')
+    expect(teleportProducts).toContain('const rowOrderTiebreak = (fields, direction) =>')
+    expect(teleportProducts).toMatch(/\$\{tiebreak\}/)
   })
 
   it('parses as valid JavaScript', () => {

package/__tests__/range-control.test.ts

@@ -0,0 +1,159 @@
+import * as types from '@babel/types'
+import generator from '@babel/generator'
+import { ComponentStructure } from '@teleporthq/teleport-types'
+import { createNextArrayMapperPaginationPlugin } from '../src/pagination-plugin'
+import {
+  makeUidlNode,
+  makeWidgetComponentChunk,
+  RANGE_DRAWN_TEXT,
+  type RepeaterOptions,
+} from './_helpers/pagination-widget-fixture'
+
+type ControlOptions = Parameters<typeof makeWidgetComponentChunk>[0]
+
+const runPlugin = async (repeater: RepeaterOptions, controls: ControlOptions): Promise<string> => {
+  const chunk = makeWidgetComponentChunk(controls)
+  const structure: ComponentStructure = {
+    uidl: { name: 'TestComponent', node: makeUidlNode(repeater) },
+    chunks: [chunk],
+    dependencies: {},
+    options: { dataSources: {}, extractedResources: {} },
+  } as never
+  await createNextArrayMapperPaginationPlugin()(structure)
+  return generator(chunk.content as types.Node).code
+}
+
+const collapse = (code: string): string => code.replace(/\s+/g, ' ')
+
+const TOTAL_STATE = 'const [ds_0_total, setDs_0_total] = useState(null)'
+const DRAWN = `ds_0_total === null ? "${RANGE_DRAWN_TEXT}" :`
+const FROM_BY_PAGE = '(ds_0_total === 0 ? 0 : (ds_0_page - 1) * 20 + 1).toLocaleString("en-US")'
+const FROM_FIRST_ROW = '(ds_0_total === 0 ? 0 : 1).toLocaleString("en-US")'
+const TO = 'Math.min(ds_0_page * 20, ds_0_total).toLocaleString("en-US")'
+const TOTAL = 'ds_0_total.toLocaleString("en-US")'
+
+describe('pagination plugin — range control', () => {
+  it('fills the authored words with the page window in buttons mode', async () => {
+    const flat = collapse(await runPlugin({}, { controls: ['previous', 'range', 'next'] }))
+
+    // The total is a state of its own — `maxPages` cannot give it back — and
+    // the count effect fills both from the same response.
+    expect(flat).toContain(TOTAL_STATE)
+    expect(flat).toContain('setDs_0_maxPages(')
+    expect(flat).toContain('setDs_0_total(data.count)')
+
+    // The drawn text stays until the count has answered; then the template.
+    expect(flat).toContain(`${DRAWN} \`Showing \${${FROM_BY_PAGE}}–\${${TO}} of \${${TOTAL}}\``)
+    // The marker and template ride along, so the DOM carries the contract.
+    expect(flat).toContain('data-tq-pagination-control="range"')
+    expect(flat).toContain('data-tq-range-template=')
+  })
+
+  it('counts from the first row in an appending list and survives the mode pruning', async () => {
+    const flat = collapse(
+      await runPlugin(
+        { infiniteScroll: true, infiniteScrollLoadMore: true },
+        { controls: ['previous', 'range', 'load-more', 'next'] }
+      )
+    )
+
+    // Previous/Next are pruned for an appending list; the range is not.
+    expect(flat).not.toContain('thq-previous-elm')
+    expect(flat).not.toContain('thq-next-elm')
+    expect(flat).toContain('thq-load-more-elm')
+    expect(flat).toContain('data-tq-pagination-control="range"')
+
+    // Everything loaded so far: 1 .. min(pages × perPage, total).
+    expect(flat).toContain(`${DRAWN} \`Showing \${${FROM_FIRST_ROW}}–\${${TO}} of \${${TOTAL}}\``)
+    expect(flat).not.toContain(FROM_BY_PAGE)
+  })
+
+  it('is kept and wired beside a sentinel-driven infinite scroll too', async () => {
+    const flat = collapse(await runPlugin({ infiniteScroll: true }, { controls: ['range'] }))
+
+    expect(flat).toContain('ds_0_sentinelRef')
+    expect(flat).toContain(TOTAL_STATE)
+    expect(flat).toContain(FROM_FIRST_ROW)
+  })
+
+  it('survives numbered mode with the page window', async () => {
+    const flat = collapse(
+      await runPlugin(
+        { paginationMode: 'numbered' },
+        { controls: ['first', 'previous', 'pages', 'range', 'next', 'last'] }
+      )
+    )
+
+    expect(flat).toContain('ds_0_pageTokens.map(token =>')
+    expect(flat).toContain('data-tq-pagination-control="range"')
+    expect(flat).toContain(FROM_BY_PAGE)
+  })
+
+  it('reads the page off the combined state beside a search input', async () => {
+    const flat = collapse(
+      await runPlugin({ searchEnabled: true }, { controls: ['previous', 'range', 'next'] })
+    )
+
+    expect(flat).toContain(TOTAL_STATE)
+    expect(flat).toContain('setDs_0_total(data.count)')
+    expect(flat).toContain(
+      '(ds_0_total === 0 ? 0 : (ds_0_state.page - 1) * 20 + 1).toLocaleString("en-US")'
+    )
+    expect(flat).toContain('Math.min(ds_0_state.page * 20, ds_0_total).toLocaleString("en-US")')
+  })
+
+  it('reads a template the JSX printer escaped the braces of', async () => {
+    const flat = collapse(
+      await runPlugin(
+        {},
+        {
+          controls: ['range'],
+          rangeTemplate: 'Showing &#123;from&#125;–&#123;to&#125; of &#123;total&#125;',
+        }
+      )
+    )
+    expect(flat).not.toContain('`Showing &#123;')
+    expect(flat).toMatch(/`Showing \$\{[^`]*–\$\{[^`]*of \$\{[^`]*`/)
+  })
+
+  it('falls back to "{from}–{to} of {total}" when no template is authored', async () => {
+    const flat = collapse(await runPlugin({}, { controls: ['range'], rangeTemplate: null }))
+
+    expect(flat).not.toContain('data-tq-range-template')
+    expect(flat).toContain(`${DRAWN} \`\${${FROM_BY_PAGE}}–\${${TO}} of \${${TOTAL}}\``)
+  })
+
+  it('wires a range outside every widget to the mapper it names, wherever it sits', async () => {
+    // Placed BEFORE the provider — a toolbar above the list — so the
+    // container-ownership rule could never have reached it.
+    const flat = collapse(
+      await runPlugin(
+        { nodeId: 'mapper-1' },
+        { controls: ['previous', 'next'], standaloneRange: { forNodeId: 'mapper-1' } }
+      )
+    )
+
+    expect(flat).toContain('data-tq-pagination-for="mapper-1"')
+    expect(flat).toContain(TOTAL_STATE)
+    expect(flat).toContain(`${DRAWN} \`Showing \${${FROM_BY_PAGE}}–\${${TO}} of \${${TOTAL}}\``)
+  })
+
+  it('leaves a range naming a mapper this component does not render as drawn', async () => {
+    const flat = collapse(
+      await runPlugin(
+        { nodeId: 'mapper-1' },
+        { controls: ['previous', 'next'], standaloneRange: { forNodeId: 'someone-else' } }
+      )
+    )
+
+    expect(flat).toContain(`>${RANGE_DRAWN_TEXT}</div>`)
+    expect(flat).not.toContain('ds_0_total === null')
+  })
+
+  it('changes nothing for a component without a range control', async () => {
+    const flat = collapse(await runPlugin({}, { controls: ['previous', 'next'] }))
+
+    expect(flat).not.toContain('ds_0_total')
+    expect(flat).not.toContain('setDs_0_total')
+  })
+})

package/__tests__/rest-api-key-header.test.ts

@@ -0,0 +1,18 @@
+import { generateRESTAPIFetcher } from '../src/fetchers/rest-api'
+
+describe('REST API fetcher with API key authorization', () => {
+  /*
+   * The editor's data fetcher sends the key as `X-API-Key`. The live site sent
+   * `Authorization: ApiKey …`, so a source that worked on the canvas failed once
+   * published.
+   */
+  it('sends the key in the same header the editor sends', () => {
+    const code = generateRESTAPIFetcher({
+      url: 'https://api.example.com/items',
+      method: 'GET',
+      authorization: { type: 'api-key', credentials: { apiKey: 'k-1' } },
+    })
+    expect(code).toContain("headers['X-API-Key'] = 'k-1'")
+    expect(code).not.toContain('ApiKey ')
+  })
+})

package/__tests__/search-input-marker.test.ts

@@ -0,0 +1,86 @@
+import * as types from '@babel/types'
+import generator from '@babel/generator'
+import { ComponentStructure } from '@teleporthq/teleport-types'
+import { createNextArrayMapperPaginationPlugin } from '../src/pagination-plugin'
+import {
+  makeMultiMapperUidl,
+  makeWidgetComponentChunk,
+  type RepeaterOptions,
+} from './_helpers/pagination-widget-fixture'
+
+type ControlOptions = Parameters<typeof makeWidgetComponentChunk>[0]
+
+/**
+ * A page's OWN search box, marked `data-tq-search-for` with its mapper's node
+ * id, is wired like the platform's `search-input`: controlled by the mapper's
+ * query state. It is paired by the id it names, never by its place among the
+ * platform inputs.
+ */
+
+const runPlugin = async (
+  repeaters: RepeaterOptions[],
+  controls: ControlOptions
+): Promise<string> => {
+  const chunk = makeWidgetComponentChunk(controls)
+  const structure: ComponentStructure = {
+    uidl: { name: 'TestComponent', node: makeMultiMapperUidl(repeaters) },
+    chunks: [chunk],
+    dependencies: {},
+    options: { dataSources: {}, extractedResources: {} },
+  } as never
+  await createNextArrayMapperPaginationPlugin()(structure)
+  return generator(chunk.content as types.Node).code
+}
+
+const collapse = (code: string): string => code.replace(/\s+/g, ' ')
+
+const wiredTo = (index: number): string =>
+  `onChange={e => setDs_${index}_searchQuery(e.target.value)} value={ds_${index}_searchQuery}`
+
+describe('pagination plugin — a page’s own search box', () => {
+  it('controls a marked input by the query of the mapper it names, and keeps Enter from submitting', async () => {
+    const flat = collapse(
+      await runPlugin([{ searchEnabled: true, nodeId: 'TQ_orders' }], {
+        controls: ['previous', 'next'],
+        standaloneSearch: [{ name: 'hm-search', forNodeId: 'TQ_orders' }],
+      })
+    )
+    expect(flat).toContain(`name="hm-search" data-tq-search-for="TQ_orders" ${wiredTo(0)}`)
+    expect(flat).toContain('onKeyDown={e => { if (e.key === "Enter") e.preventDefault(); }}')
+  })
+
+  it('pairs by the id named, whatever the order: the platform input keeps its place', async () => {
+    const flat = collapse(
+      await runPlugin(
+        [
+          { searchEnabled: true, nodeId: 'TQ_jobs' },
+          { searchEnabled: true, nodeId: 'TQ_orders' },
+        ],
+        {
+          controls: ['previous', 'next'],
+          mappers: 2,
+          standaloneSearch: [
+            { name: 'hm-search', forNodeId: 'TQ_orders' },
+            { name: 'platform-search' },
+          ],
+        }
+      )
+    )
+    // The marked box searches the second mapper; the platform box, first of its kind, the first.
+    expect(flat).toContain(`data-tq-search-for="TQ_orders" ${wiredTo(1)}`)
+    expect(flat).toContain(
+      `name="platform-search" className="products-list-search-input" ${wiredTo(0)}`
+    )
+  })
+
+  it('leaves a marked input alone when no search-enabled mapper carries its id', async () => {
+    const flat = collapse(
+      await runPlugin([{ searchEnabled: true, nodeId: 'TQ_orders' }], {
+        controls: ['previous', 'next'],
+        standaloneSearch: [{ name: 'hm-search', forNodeId: 'TQ_elsewhere' }],
+      })
+    )
+    expect(flat).toContain('name="hm-search" data-tq-search-for="TQ_elsewhere" />')
+    expect(flat).not.toContain('setDs_0_searchQuery(e.target.value)')
+  })
+})