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

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

@@ -1,6 +1,11 @@
 import * as types from '@babel/types'
 import { ChunkType, FileType, ChunkDefinition } from '@teleporthq/teleport-types'
-import { PAGINATION_CONTROL_ATTR } from '../../src/pagination-controls'
+import {
+  PAGINATION_CONTROL_ATTR,
+  PAGINATION_FOR_ATTR,
+  RANGE_TEMPLATE_ATTR,
+} from '../../src/pagination-controls'
+import { SEARCH_FOR_ATTR } from '../../src/search-input'
 
 /**
  * A component shell carrying a `DataProvider` and the pagination controls a
@@ -20,9 +25,36 @@ interface ControlOptions {
   legacyOnly?: boolean
   /** Number of DataProvider + widget pairs to emit (order-based zip coverage). */
   mappers?: number
+  /** The element the providers render in: a table's body, a list. */
+  rootTag?: string
+  /**
+   * The `data-tq-range-template` of a `range` control in the widget. Defaults
+   * to the "Showing" wording; `null` authors the control with no template.
+   */
+  rangeTemplate?: string | null
+  /**
+   * A `range` text OUTSIDE every widget, placed BEFORE the first provider (a
+   * toolbar above the list), naming its mapper with `data-tq-pagination-for`.
+   */
+  standaloneRange?: { forNodeId: string; template?: string }
+  /**
+   * Search inputs OUTSIDE every widget, placed BEFORE the first provider, in
+   * this order: a page's own box naming its mapper with `data-tq-search-for`,
+   * or the platform's (`search-input` class) paired by order.
+   */
+  standaloneSearch?: Array<{ forNodeId?: string; name: string }>
 }
 
-const control = (marker: string, children: types.JSXElement['children'] = []): types.JSXElement =>
+// ASCII hyphen on purpose: the generator prints string literals through jsesc,
+// which would turn an en dash into `–` and make every assertion unreadable.
+export const RANGE_DRAWN_TEXT = 'Showing 1-8 of 12'
+export const RANGE_TEMPLATE = 'Showing {from}–{to} of {total}'
+
+const control = (
+  marker: string,
+  children: types.JSXElement['children'] = [],
+  extraAttrs: Array<[string, string]> = []
+): types.JSXElement =>
   types.jsxElement(
     types.jsxOpeningElement(
       types.jsxIdentifier('div'),
@@ -35,6 +67,9 @@ const control = (marker: string, children: types.JSXElement['children'] = []): t
           types.jsxIdentifier(PAGINATION_CONTROL_ATTR),
           types.stringLiteral(marker)
         ),
+        ...extraAttrs.map(([name, value]) =>
+          types.jsxAttribute(types.jsxIdentifier(name), types.stringLiteral(value))
+        ),
       ],
       false
     ),
@@ -43,6 +78,40 @@ const control = (marker: string, children: types.JSXElement['children'] = []): t
     false
   )
 
+const rangeControl = (
+  template: string | null | undefined,
+  forNodeId?: string
+): types.JSXElement => {
+  const attrs: Array<[string, string]> = []
+  if (template !== null) {
+    attrs.push([RANGE_TEMPLATE_ATTR, template ?? RANGE_TEMPLATE])
+  }
+  if (forNodeId) {
+    attrs.push([PAGINATION_FOR_ATTR, forNodeId])
+  }
+  return control('range', [types.jsxText(RANGE_DRAWN_TEXT)], attrs)
+}
+
+const searchInput = (name: string, forNodeId?: string): types.JSXElement =>
+  types.jsxElement(
+    types.jsxOpeningElement(
+      types.jsxIdentifier('input'),
+      [
+        types.jsxAttribute(types.jsxIdentifier('name'), types.stringLiteral(name)),
+        forNodeId
+          ? types.jsxAttribute(types.jsxIdentifier(SEARCH_FOR_ATTR), types.stringLiteral(forNodeId))
+          : types.jsxAttribute(
+              types.jsxIdentifier('className'),
+              types.stringLiteral('products-list-search-input')
+            ),
+      ],
+      true
+    ),
+    null,
+    [],
+    true
+  )
+
 const legacyControl = (direction: 'previous' | 'next'): types.JSXElement =>
   types.jsxElement(
     types.jsxOpeningElement(
@@ -72,6 +141,10 @@ const buildWidget = (options: ControlOptions): types.JSXElement => {
       children.push(legacyControl(marker))
       continue
     }
+    if (marker === 'range') {
+      children.push(rangeControl(options.rangeTemplate))
+      continue
+    }
     children.push(control(marker))
   }
 
@@ -148,6 +221,12 @@ const buildDataProvider = (name: string, rowIdentifier: string): types.JSXElemen
 
 export const makeWidgetComponentChunk = (options: ControlOptions): ChunkDefinition => {
   const sections: types.JSXElement[] = []
+  if (options.standaloneRange) {
+    sections.push(rangeControl(options.standaloneRange.template, options.standaloneRange.forNodeId))
+  }
+  for (const search of options.standaloneSearch ?? []) {
+    sections.push(searchInput(search.name, search.forNodeId))
+  }
   const mappers = options.mappers ?? 1
   for (let i = 0; i < mappers; i += 1) {
     const identifier = `items${i === 0 ? '' : i}`
@@ -155,9 +234,10 @@ export const makeWidgetComponentChunk = (options: ControlOptions): ChunkDefiniti
     sections.push(buildWidget(options))
   }
 
+  const rootTag = options.rootTag ?? 'div'
   const root = types.jsxElement(
-    types.jsxOpeningElement(types.jsxIdentifier('div'), [], false),
-    types.jsxClosingElement(types.jsxIdentifier('div')),
+    types.jsxOpeningElement(types.jsxIdentifier(rootTag), [], false),
+    types.jsxClosingElement(types.jsxIdentifier(rootTag)),
     sections,
     false
   )
@@ -189,6 +269,8 @@ export interface RepeaterOptions {
   perPage?: number
   /** The list's filters, as the inspector authors them (conditions and groups). */
   filters?: unknown[]
+  /** The mapper's editor node id, as the UIDL carries it on the repeater. */
+  nodeId?: string
 }
 
 export const makeUidlNode = (options: RepeaterOptions, identifier: string = 'items'): any => ({
@@ -218,6 +300,7 @@ export const makeUidlNode = (options: RepeaterOptions, identifier: string = 'ite
           ...(options.paginationMode ? { paginationMode: options.paginationMode } : {}),
           ...(options.infiniteScroll ? { infiniteScroll: true } : {}),
           ...(options.infiniteScrollLoadMore ? { infiniteScrollLoadMore: true } : {}),
+          ...(options.nodeId ? { nodeId: options.nodeId } : {}),
           nodes: { list: { type: 'element', content: { elementType: 'div' } } },
         },
       },

package/__tests__/booking-item-transform.test.ts

@@ -0,0 +1,120 @@
+import { generateBookingItemTransformationCode } from '../src/transformations/booking-item'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+import {
+  detectTransformationType,
+  getTransformExpression,
+  getTransformWrapperCode,
+} from '../src/transformations'
+
+// A booking page binds an item's columns as stored; the transform only puts
+// its texts in the page's language. These evaluate the EMITTED code, the way
+// the runtime does.
+
+type Build = (record: unknown, options?: Record<string, unknown>) => Record<string, unknown>
+
+const builderFor = (code: string): Build =>
+  new Function(
+    generateSharedTransformationCode() + '\n' + code + '\nreturn buildBookingItem;'
+  )() as Build
+
+const buildBookingItem = builderFor(generateBookingItemTransformationCode())
+
+const buildWithCategories = builderFor(
+  generateBookingItemTransformationCode({
+    categories: [
+      {
+        id: 'rooms',
+        name: 'Rooms',
+        slug: 'rooms',
+        parentId: null,
+        order: 0,
+        translations: { es: { name: 'Habitaciones' } },
+        children: [
+          {
+            id: 'suites',
+            name: 'Suites',
+            slug: 'suites',
+            parentId: 'rooms',
+            order: 0,
+            children: [],
+          },
+        ],
+      },
+    ],
+  })
+)
+
+const item = {
+  id: 'i1',
+  slug: 'double-room',
+  name: 'Double room',
+  es_name: 'Habitación doble',
+  description: '<p>Sea view.</p>',
+  es_description: '<p>Vista al mar.</p>',
+  location: 'Main street',
+  es_location: '',
+  price: '120.00',
+  booking_unit: 'night',
+}
+
+describe('the booking item transform', () => {
+  it('is applied to the booking items table only', () => {
+    expect(detectTransformationType('teleport_booking_items')).toBe('booking-item')
+    expect(detectTransformationType('public.TELEPORT_BOOKING_ITEMS')).toBe('booking-item')
+    expect(detectTransformationType('booking_items')).toBeNull()
+    expect(getTransformExpression('teleport_booking_items')).toContain('transformRecords')
+    expect(getTransformWrapperCode('teleport_booking_items')).toContain('transformBookingItems')
+  })
+
+  it('shows the texts in the page’s language, every column kept as stored', () => {
+    const row = buildBookingItem(item, { currentLanguage: 'es', mainLanguage: 'en' })
+    expect(row).toMatchObject({
+      name: 'Habitación doble',
+      description: '<p>Vista al mar.</p>',
+      // Not translated yet: the main language's.
+      location: 'Main street',
+      slug: 'double-room',
+      price: '120.00',
+      booking_unit: 'night',
+      es_name: 'Habitación doble',
+    })
+  })
+
+  it('names its category the way the taxonomy names its first one in the page’s language', () => {
+    const filed = { ...item, category: 'Rooms', category_ids: '["rooms","suites"]' }
+    expect(buildWithCategories(filed, { currentLanguage: 'es', mainLanguage: 'en' }).category).toBe(
+      'Habitaciones'
+    )
+    expect(buildWithCategories(filed, { currentLanguage: 'en', mainLanguage: 'en' }).category).toBe(
+      'Rooms'
+    )
+    // No translation: the main name; a nested category resolves too.
+    expect(
+      buildWithCategories(
+        { ...filed, category: 'Suites', category_ids: '["suites"]' },
+        { currentLanguage: 'es', mainLanguage: 'en' }
+      ).category
+    ).toBe('Suites')
+  })
+
+  it('keeps the stored category while none of its ids is a category', () => {
+    const legacy = { ...item, category: 'Rooms', category_ids: '["gone"]' }
+    expect(
+      buildWithCategories(legacy, { currentLanguage: 'es', mainLanguage: 'en' }).category
+    ).toBe('Rooms')
+    expect(buildBookingItem(legacy, { currentLanguage: 'es', mainLanguage: 'en' }).category).toBe(
+      'Rooms'
+    )
+    // A row without category columns gains none.
+    expect(
+      'category' in buildWithCategories(item, { currentLanguage: 'es', mainLanguage: 'en' })
+    ).toBe(false)
+  })
+
+  it('keeps the main language on its own pages and without a localization', () => {
+    expect(buildBookingItem(item, { currentLanguage: 'en', mainLanguage: 'en' }).name).toBe(
+      'Double room'
+    )
+    expect(buildBookingItem(item, {}).name).toBe('Double room')
+  })
+})

package/__tests__/browser-row-policy.test.ts

@@ -67,7 +67,10 @@ function bootTableRoute(tableName: string, options: BootOptions = {}) {
     options.cache
   )
   const code = esm
-    .replace("import { Client } from 'pg'", "const { Client } = require('pg')")
+    .replace(
+      "import { Client, types as pgTypes } from 'pg'",
+      "const { Client, types: pgTypes } = require('pg')"
+    )
     .replace(
       "import { tqWithCache } from '../tq-cache/server'",
       "const { tqWithCache } = require('tq-cache')"
@@ -417,7 +420,10 @@ describe('raw-query state routes bind {{Current User.*}} to the session', () =>
       paramFields
     )
     const code = esm
-      .replace("import { Client } from 'pg'", "const { Client } = require('pg')")
+      .replace(
+        "import { Client, types as pgTypes } from 'pg'",
+        "const { Client, types: pgTypes } = require('pg')"
+      )
       .replace(/^export default async function handler/m, 'async function handler')
       .concat('\nmodule.exports = { handler: handler }')
     const queries: Array<{ sql: string; params: unknown[] }> = []

package/__tests__/fetchers.test.ts

@@ -335,7 +335,7 @@ describe('generateDataSourceFetcher', () => {
     const dataSource = createPostgreSQLDataSource('ds-1')
     const code = generateDataSourceFetcher(dataSource, 'users')
 
-    expect(code).toContain('import { Client } from')
+    expect(code).toContain('import { Client, types as pgTypes } from')
     expect(code).toContain('export default async function handler')
     expect(code).toContain('SELECT * FROM "users"')
     expect(code).toContain('localhost')

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

@@ -157,7 +157,7 @@ describe('a list sort the editor fixed', () => {
     const code = await runPlugin('state', CACHE)
     expect(code).not.toContain('initialData=')
     expect(code).not.toContain('ds_0_cached')
-    expect(code).toContain('field: sortBy.split("-")[0]')
+    expect(code).toContain('field: sortBy.split("-")?.[0]')
   })
 })
 

package/__tests__/infinite-scroll.test.ts

@@ -1,7 +1,13 @@
+/* tslint:disable:function-constructor */
 import * as types from '@babel/types'
 import generator from '@babel/generator'
 import { ComponentStructure } from '@teleporthq/teleport-types'
 import { createNextArrayMapperPaginationPlugin } from '../src/pagination-plugin'
+import {
+  buildAccumulatingRequestMark,
+  buildAccumulatingResponseHandler,
+  getInfiniteScrollVars,
+} from '../src/infinite-scroll'
 import {
   makeMultiMapperUidl,
   makeUidlNode,
@@ -11,9 +17,10 @@ import {
 
 const runPlugin = async (
   repeater: RepeaterOptions,
-  controls: string[] = ['previous', 'next']
+  controls: string[] = ['previous', 'next'],
+  rootTag?: string
 ): Promise<string> => {
-  const chunk = makeWidgetComponentChunk({ controls })
+  const chunk = makeWidgetComponentChunk({ controls, rootTag })
   const structure: ComponentStructure = {
     uidl: { name: 'TestComponent', node: makeUidlNode(repeater) },
     chunks: [chunk],
@@ -31,7 +38,7 @@ describe('pagination plugin — infinite scroll', () => {
     const code = await runPlugin({ infiniteScroll: true })
     const flat = collapse(code)
 
-    expect(flat).toContain('const ds_0_accumRef = useRef({ sig: "", pages: {} })')
+    expect(flat).toContain('const ds_0_accumRef = useRef({ sig: "", pages: {}, latest: null })')
     expect(flat).toContain('const [ds_0_hasMoreFlag, setDs_0_hasMoreFlag] = useState(true)')
     // Two independent end-of-data signals: a short page, and the counted total.
     expect(flat).toContain(
@@ -42,12 +49,18 @@ describe('pagination plugin — infinite scroll', () => {
     // change must start a fresh list rather than interleave two result sets.
     expect(flat).toContain('const sig = JSON.stringify({ ...params, page: 0 })')
     expect(flat).toContain('if (ds_0_accumRef.current.sig !== sig)')
-    expect(flat).toContain('ds_0_accumRef.current = { sig, pages: {} }')
+    expect(flat).toContain('ds_0_accumRef.current.pages = {}')
     expect(flat).toContain('ds_0_accumRef.current.pages[page] = rows')
+    // fetchData records the request the list stands on before making it.
+    expect(flat).toContain(
+      'ds_0_accumRef.current.latest = { sig: JSON.stringify({ ...params, page: 0 }), page: Number(params.page) || 1 }'
+    )
     // A short page is the only end signal a source that cannot count gives.
     expect(flat).toContain('setDs_0_hasMoreFlag(rows.length >= 20)')
     // Numeric sort, so page 10 does not land between 1 and 2.
-    expect(flat).toContain('.map(Number).sort((a, b) => a - b).reduce(')
+    expect(flat).toMatch(
+      /\.map\(Number\)\.filter\(\(?p\)? => p <= last\)\.sort\(\(a, b\) => a - b\)\.reduce\(/
+    )
   })
 
   it('keeps the page out of the provider key and suppresses initialData', async () => {
@@ -82,6 +95,30 @@ describe('pagination plugin — infinite scroll', () => {
     )
   })
 
+  it('builds the sentinel as an element its parent may hold', async () => {
+    // A <div> among a table's rows is moved out of the table by the parser:
+    // the server's markup and the client's tree then differ and hydration fails.
+    const inBody = collapse(
+      await runPlugin({ infiniteScroll: true }, ['previous', 'next'], 'tbody')
+    )
+    expect(inBody).toContain(
+      '<tr ref={ds_0_sentinelRef} aria-hidden="true" style={{ height: "1px" }}><td style={{ padding: 0, border: 0 }} /></tr>'
+    )
+    expect(inBody).not.toContain('<div ref={ds_0_sentinelRef}')
+
+    const inList = collapse(await runPlugin({ infiniteScroll: true }, ['previous', 'next'], 'ul'))
+    expect(inList).toContain(
+      '<li ref={ds_0_sentinelRef} aria-hidden="true" style={{ height: "1px", listStyle: "none" }} />'
+    )
+
+    const inParagraph = collapse(
+      await runPlugin({ infiniteScroll: true }, ['previous', 'next'], 'p')
+    )
+    expect(inParagraph).toContain(
+      '<span ref={ds_0_sentinelRef} aria-hidden="true" style={{ display: "block", height: "1px" }} />'
+    )
+  })
+
   it('wires the authored Load More button instead, with no observer', async () => {
     const code = await runPlugin({ infiniteScroll: true, infiniteScrollLoadMore: true }, [
       'load-more',
@@ -141,3 +178,115 @@ describe('pagination plugin — infinite scroll', () => {
     expect(code).not.toContain('setDs_0_page(page => Math.max(1, page - 1))')
   })
 })
+
+/**
+ * The accumulator, executed: `fetchData` as the page emits it, answered in
+ * the orders a browser can produce. A sort (filter, search) change made on
+ * page 2 fires page 2 under the new query first, then page 1 once the page is
+ * reset — and `DataProvider` renders whichever answer lands last.
+ */
+describe('the appending list, run', () => {
+  const PER_PAGE = 2
+
+  interface Deferred {
+    params: { page: number; sorts: string }
+    resolve: (rows: string[]) => void
+    result: Promise<string[]>
+  }
+
+  function bootList() {
+    const vars = getInfiniteScrollVars(0)
+    const mark = generator(types.program([buildAccumulatingRequestMark(vars)])).code
+    const handler = generator(buildAccumulatingResponseHandler(vars, PER_PAGE)).code
+    const accumRef = { current: { sig: '', pages: {}, latest: null } }
+    const hasMore: boolean[] = []
+    const fetchData = new Function(
+      'ds_0_accumRef',
+      'setDs_0_hasMoreFlag',
+      'answer',
+      `return function fetchData(params) { ${mark}; return answer(params).then(${handler}) }`
+    )(
+      accumRef,
+      (value: boolean) => hasMore.push(value),
+      (params: Deferred['params']) => {
+        let resolve: (rows: string[]) => void = () => undefined
+        const answered = new Promise<{ data: string[] }>((done) => {
+          resolve = (rows) => done({ data: rows })
+        })
+        requests.push({ params, resolve, result: undefined as never })
+        return answered
+      }
+    ) as (params: Deferred['params']) => Promise<string[]>
+    const requests: Deferred[] = []
+    const request = (page: number, sorts: string): Deferred => {
+      const result = fetchData({ page, sorts })
+      const made = requests[requests.length - 1]
+      made.result = result
+      return made
+    }
+    return { request, hasMore }
+  }
+
+  const rowsOf = (sorts: string, page: number) => [`${sorts}${page}a`, `${sorts}${page}b`]
+
+  it('restarts at page 1 after a sort change on page 2, and loads page 2 on the next click', async () => {
+    const list = bootList()
+    const first = list.request(1, 'A')
+    first.resolve(rowsOf('A', 1))
+    const second = list.request(2, 'A')
+    second.resolve(rowsOf('A', 2))
+    expect(await second.result).toEqual([...rowsOf('A', 1), ...rowsOf('A', 2)])
+
+    const stray = list.request(2, 'B')
+    const restart = list.request(1, 'B')
+    stray.resolve(rowsOf('B', 2))
+    // The stray page changes nothing: the list on show stays until page 1 answers.
+    expect(await stray.result).toEqual([...rowsOf('A', 1), ...rowsOf('A', 2)])
+    restart.resolve(rowsOf('B', 1))
+    expect(await restart.result).toEqual(rowsOf('B', 1))
+
+    const next = list.request(2, 'B')
+    next.resolve(rowsOf('B', 2))
+    expect(await next.result).toEqual([...rowsOf('B', 1), ...rowsOf('B', 2)])
+  })
+
+  it('keeps the restarted list when the stray page answers last', async () => {
+    const list = bootList()
+    list.request(1, 'A').resolve(rowsOf('A', 1))
+    const second = list.request(2, 'A')
+    second.resolve(rowsOf('A', 2))
+    await second.result
+
+    const stray = list.request(2, 'B')
+    const restart = list.request(1, 'B')
+    restart.resolve(rowsOf('B', 1))
+    expect(await restart.result).toEqual(rowsOf('B', 1))
+    stray.resolve(rowsOf('B', 2))
+    expect(await stray.result).toEqual(rowsOf('B', 1))
+  })
+
+  it('never lets a late answer to an earlier query replace the list', async () => {
+    const list = bootList()
+    const before = list.request(1, 'A')
+    const after = list.request(1, 'B')
+    after.resolve(rowsOf('B', 1))
+    expect(await after.result).toEqual(rowsOf('B', 1))
+    before.resolve(rowsOf('A', 1))
+    expect(await before.result).toEqual(rowsOf('B', 1))
+  })
+
+  it('ends the list on a short page of the request it stands on only', async () => {
+    const list = bootList()
+    const stray = list.request(2, 'A')
+    const page1 = list.request(1, 'A')
+    stray.resolve(['A2a'])
+    await stray.result
+    expect(list.hasMore).toEqual([])
+    page1.resolve(rowsOf('A', 1))
+    await page1.result
+    const page2 = list.request(2, 'A')
+    page2.resolve(['A2a'])
+    expect(await page2.result).toEqual([...rowsOf('A', 1), 'A2a'])
+    expect(list.hasMore).toEqual([true, false])
+  })
+})

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

@@ -0,0 +1,61 @@
+import { parse } from '@babel/parser'
+import { generateDataSourceFetcher } from '../src/data-source-fetchers'
+
+/**
+ * How the SQL routes of the platform's listings order what a visitor's sort
+ * leaves tied or empty: a post without a reading time comes after the others
+ * whichever way the list is sorted ("longest read first" opened on them), and
+ * equal rows keep one order across pages.
+ *
+ * Pinned on the route the project generator ships (`generateDataSourceFetcher`),
+ * for both databases a blog can live in.
+ */
+
+const ROUTES = [
+  ['teleport', { host: 'db', database: 'blog' }],
+  ['postgresql', { connectionString: 'postgres://user:pw@host:5432/db' }],
+] as const
+
+const routeFor = (type: string, config: object, tableName: string): string =>
+  generateDataSourceFetcher(
+    { type, config } as unknown as Parameters<typeof generateDataSourceFetcher>[0],
+    tableName
+  )
+
+const orderByLines = (route: string): string[] =>
+  route.split('\n').filter((line) => line.includes('ORDER BY') && line.includes('Clauses.join'))
+
+describe.each(ROUTES)('the %s route of the blog listing', (type, config) => {
+  const route = routeFor(type, config, 'teleport_blog_posts')
+
+  it('parses as valid JavaScript', () => {
+    expect(() => parse(route, { sourceType: 'module', plugins: ['jsx'] })).not.toThrow()
+  })
+
+  it('puts the rows without a value last, in both directions', () => {
+    expect(route).toMatch(/\$\{orderOf\(sort\)\} NULLS LAST`/)
+    expect(route).toMatch(/\$\{sortByDirection\} NULLS LAST\$\{tiebreak\}`/)
+  })
+
+  it('falls back to a plain ORDER BY when the database rejects it', () => {
+    expect(route).toMatch(/plainClauses = valid\.map\(\(sort\) => `[^`]*\$\{orderOf\(sort\)\}`\)/)
+    expect(route).toContain('const usedRewrittenSort = orderBySql !== plainOrderBySql')
+    expect(route).toContain('if (!usedRewrittenSort) throw sortError')
+    expect(route).toContain('baseSql + plainOrderBySql + sqlTail')
+  })
+
+  it('breaks ties by id, in the ORDER BY and in its fallback', () => {
+    expect(route).toContain(`fields.includes("id") ? '' : ", \\"id\\" " + direction`)
+    const lines = orderByLines(route)
+    expect(lines).toHaveLength(2)
+    lines.forEach((line) => expect(line).toMatch(/\$\{tiebreak\}/))
+  })
+})
+
+describe('a table no listing sorts for visitors', () => {
+  it('gets the empty-values-last order but no tiebreaker', () => {
+    const route = routeFor('teleport', { host: 'db', database: 'store' }, 'teleport_orders')
+    expect(route).toMatch(/\$\{orderOf\(sort\)\} NULLS LAST`/)
+    expect(route).toContain("const rowOrderTiebreak = () => ''")
+  })
+})