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

package/__tests__/content-preset-wiring.test.ts

@@ -0,0 +1,108 @@
+import { ContentTables, TableAccess } from '@teleporthq/teleport-shared'
+import {
+  BROWSER_READABLE_TABLES,
+  BROWSER_ROW_POLICIES as DATA_API_ROW_POLICIES,
+} from '../../teleport-plugin-next-workflows/src/data-api-route-generator'
+import {
+  BROWSER_ROW_POLICIES,
+  isViewDependentTable,
+} from '../src/fetchers/utils/browser-row-policy'
+import {
+  buildProductTransformOptions,
+  contentSettingsFor,
+  detectTransformationType,
+  getTransformWrapperCode,
+  getTransformationCode,
+} from '../src/transformations'
+import { generateBlogContextFileContent } from '../../teleport-project-generator-next/src/blog/blog-context-generator'
+
+/**
+ * Every content preset in the registry is wired through every generator that
+ * tells a content table apart from a custom one. A preset registered in
+ * teleport-shared but unknown to one of these would publish its drafts, or
+ * serve its rows raw — so each check runs per preset, and a new one fails
+ * here before it fails on a site.
+ */
+describe('content preset wiring in the generators', () => {
+  it.each(ContentTables.CONTENT_TABLES.map((tables) => [tables.key, tables]))(
+    'the "%s" preset is recognised everywhere',
+    (_key, tables: ContentTables.ContentTables) => {
+      // Visitors are served published rows only, through both route families.
+      expect(BROWSER_ROW_POLICIES[tables.posts]).toBe(
+        ContentTables.CONTENT_POSTS_VISITOR_ROW_POLICY
+      )
+      expect(DATA_API_ROW_POLICIES[tables.posts]).toBe(
+        ContentTables.CONTENT_POSTS_VISITOR_ROW_POLICY
+      )
+      expect(BROWSER_READABLE_TABLES).toContain(tables.posts)
+      expect(isViewDependentTable(tables.posts, TableAccess.PROTECTED_TABLES)).toBe(true)
+
+      // The rows go through the post view model, whose SQL names THIS preset's tables.
+      expect(detectTransformationType(tables.posts)).toBe('blog-post')
+      expect(detectTransformationType(`public.${tables.posts}`)).toBe('blog-post')
+      const code = getTransformationCode(tables.posts)
+      expect(code).toContain(`SELECT * FROM ${tables.posts} WHERE id = ANY($1)`)
+      expect(code).toContain(`SELECT p.* FROM ${tables.posts} p,`)
+      if (tables.comments) {
+        expect(code).toContain(`FROM ${tables.comments} c`)
+        // A browser never lists comments: the table carries the commenters' emails.
+        expect(TableAccess.CUSTOMER_RECORD_TABLES).toContain(tables.comments)
+        expect(BROWSER_READABLE_TABLES).not.toContain(tables.comments)
+      }
+    }
+  )
+
+  it('leaves a custom table that only sounds like posts alone', () => {
+    expect(detectTransformationType('blog_posts')).toBeNull()
+    expect(BROWSER_ROW_POLICIES.blog_posts).toBeUndefined()
+    expect(BROWSER_READABLE_TABLES).not.toContain('blog_posts')
+  })
+
+  it('bakes each preset\u2019s own settings into its transform, never another\u2019s', () => {
+    const blogTaxonomy = [{ id: 'b1', name: 'Blog cat', slug: 'blog-cat' }]
+    const helpTaxonomy = [{ id: 'h1', name: 'Help cat', slug: 'help-cat' }]
+    const options = buildProductTransformOptions({
+      blogSettings: { categories: blogTaxonomy as never, headingAnchors: false, comments: true },
+      helpCenterSettings: {
+        categories: helpTaxonomy as never,
+        headingAnchors: true,
+        comments: false,
+      },
+    })
+    expect(contentSettingsFor(options, 'teleport_blog_posts')).toEqual({
+      categories: blogTaxonomy,
+      headingAnchors: false,
+      comments: true,
+    })
+    expect(contentSettingsFor(options, 'teleport_help_articles')).toEqual({
+      categories: helpTaxonomy,
+      headingAnchors: true,
+      comments: false,
+    })
+    expect(contentSettingsFor(options, 'teleport_products')).toEqual({})
+    // The Blog's legacy fields still answer for a caller that set only them.
+    expect(contentSettingsFor({ blogComments: true }, 'teleport_blog_posts').comments).toBe(true)
+
+    // The article transform carries the Help Center's taxonomy and anchors, not the Blog's.
+    const helpCode = getTransformationCode('teleport_help_articles', options)
+    expect(helpCode).toContain('Help cat')
+    expect(helpCode).not.toContain('Blog cat')
+    expect(helpCode).toContain('var BLOG_HEADING_ANCHORS = true')
+    // Comments are a Blog feature: the article wrapper never queries a comments table.
+    expect(getTransformWrapperCode('teleport_help_articles', options)).not.toContain(
+      'getBlogCommentsMap('
+    )
+    expect(getTransformWrapperCode('teleport_blog_posts', options)).toContain('getBlogCommentsMap(')
+  })
+
+  it('exposes both taxonomies from the one generated context module', () => {
+    const code = generateBlogContextFileContent(
+      { categories: [{ id: 'b1', name: 'Blog cat', slug: 'blog-cat' }] as never },
+      { categories: [{ id: 'h1', name: 'Help cat', slug: 'help-cat' }] as never }
+    )
+    expect(code).toContain('const BLOG_CATEGORIES = [{"id":"b1"')
+    expect(code).toContain('const HELP_CATEGORIES = [{"id":"h1"')
+    expect(code).toContain('export const useBlogCategories = ()')
+    expect(code).toContain('export const useHelpCategories = ()')
+  })
+})

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

@@ -0,0 +1,183 @@
+import * as types from '@babel/types'
+import generator from '@babel/generator'
+import {
+  ChunkType,
+  FileType,
+  ComponentStructure,
+  ChunkDefinition,
+  UIDLDataCacheConfig,
+} from '@teleporthq/teleport-types'
+import { createNextArrayMapperPaginationPlugin } from '../src/pagination-plugin'
+import { readFixedSort } from '../src/sort-utils'
+
+/**
+ * A list whose sort the editor FIXED (a blog listing's newest first: a static
+ * column, a static direction) is a static sort. Read as dynamic, it made the
+ * list skip the server-side first page — `initialData` is left out for a
+ * dynamic sort, since that prefetch ran without one — so the pre-rendered
+ * HTML of every blog and help center listing carried no posts, and the
+ * browser fetched page 1 a second time. Only a sort bound to state is dynamic.
+ */
+
+const CACHE: UIDLDataCacheConfig = {
+  enabled: true,
+  ttlSeconds: 60,
+  client: true,
+  server: true,
+  versionScope: 'ds1:posts',
+}
+
+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: 'created_at' },
+    sortDirection: { type: 'static', content: 'desc' },
+  },
+  state: {
+    sort: { type: 'expr', content: 'sortBy.split("-")[0]' },
+    sortDirection: { type: 'expr', content: 'sortBy.split("-")[1]' },
+  },
+  none: {},
+}
+
+const runPlugin = async (sort: SortKind, cache?: UIDLDataCacheConfig): Promise<string> => {
+  const chunk = makeComponentChunk()
+  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'] } } },
+          nodes: {
+            success: {
+              type: 'cms-list-repeater',
+              content: {
+                renderPropIdentifier: 'post',
+                paginated: true,
+                perPage: 20,
+                searchEnabled: true,
+                searchDebounce: 300,
+                nodes: { list: { type: 'element', content: { elementType: 'div' } } },
+                ...(cache ? { cache } : {}),
+                ...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.replace(/\s+/g, ' ')
+}
+
+describe('a list sort the editor fixed', () => {
+  it('keeps the server-side first page and asks for the sort itself', async () => {
+    const code = await runPlugin('fixed')
+    expect(code).toContain('initialData=')
+    expect(code).toContain('sorts: JSON.stringify([{ field: "created_at", order: "desc" }])')
+  })
+
+  it('may peek at the browser cache on mount, as an unsorted list may', async () => {
+    expect(await runPlugin('fixed', CACHE)).toContain('ds_0_cached')
+    expect(await runPlugin('none', CACHE)).toContain('ds_0_cached')
+  })
+
+  it('leaves a sort bound to state dynamic: no first page from the server, no peek', async () => {
+    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]')
+  })
+})
+
+describe('readFixedSort', () => {
+  it('reads a static column and direction, ascending by default', () => {
+    expect(
+      readFixedSort({ type: 'static', content: 'created_at' }, { type: 'static', content: 'desc' })
+    ).toEqual({ field: 'created_at', order: 'desc' })
+    expect(readFixedSort({ type: 'static', content: 'title' }, undefined)).toEqual({
+      field: 'title',
+      order: 'asc',
+    })
+  })
+
+  it('refuses anything bound to state, and an empty column', () => {
+    expect(readFixedSort({ type: 'expr', content: 'sortBy' }, undefined)).toBeUndefined()
+    expect(
+      readFixedSort({ type: 'static', content: 'title' }, { type: 'expr', content: 'direction' })
+    ).toBeUndefined()
+    expect(readFixedSort({ type: 'static', content: ' ' }, undefined)).toBeUndefined()
+    expect(readFixedSort(undefined, undefined)).toBeUndefined()
+  })
+})

package/__tests__/pagination-filter-groups.test.ts

@@ -0,0 +1,186 @@
+import * as types from '@babel/types'
+import generator from '@babel/generator'
+import {
+  ChunkDefinition,
+  ChunkType,
+  ComponentStructure,
+  FileType,
+} from '@teleporthq/teleport-types'
+import { createNextArrayMapperPaginationPlugin } from '../src/pagination-plugin'
+import {
+  makeUidlNode,
+  makeWidgetComponentChunk,
+  type RepeaterOptions,
+} from './_helpers/pagination-widget-fixture'
+
+/**
+ * A list filter can say "Category is Commercial OR Narrative" — an "any of"
+ * group. The paginated and searchable lists used to flatten that group into a
+ * flat list the fetcher joined with AND, so the published site showed the rows
+ * that were BOTH Commercial and Narrative: none. The group now reaches the
+ * fetcher as a group, in the browser fetch and in the build-time prefetch
+ * alike, and the fetcher's own `normalizeFilterTree` honours its operator
+ * (`filter-groups.test.ts`).
+ */
+
+const condition = (source: string, destination: unknown, operand = '=') => ({
+  type: 'condition',
+  source,
+  destination,
+  operand,
+})
+
+const group = (operator: 'and' | 'or', children: unknown[]) => ({
+  type: 'group',
+  operator,
+  children,
+})
+
+const stateRef = (id: string) => ({ type: 'dynamic', content: { referenceType: 'state', id } })
+
+const collapse = (code: string): string => code.replace(/\s+/g, ' ')
+
+// The page's `getStaticProps` as the main data-source plugin leaves it: a
+// `Promise.all` of prefetches and a `props` object, which the pagination plugin
+// extends with the paginated list's first page and its count.
+const makeGetStaticPropsChunk = (): ChunkDefinition => ({
+  name: 'getStaticProps',
+  type: ChunkType.AST,
+  fileType: FileType.JS,
+  linkAfter: ['jsx-component'],
+  meta: {},
+  content: types.exportNamedDeclaration(
+    types.functionDeclaration(
+      types.identifier('getStaticProps'),
+      [types.identifier('context')],
+      types.blockStatement([
+        types.tryStatement(
+          types.blockStatement([
+            types.variableDeclaration('const', [
+              types.variableDeclarator(
+                types.arrayPattern([]),
+                types.awaitExpression(
+                  types.callExpression(
+                    types.memberExpression(types.identifier('Promise'), types.identifier('all')),
+                    [types.arrayExpression([])]
+                  )
+                )
+              ),
+            ]),
+            types.returnStatement(
+              types.objectExpression([
+                types.objectProperty(types.identifier('props'), types.objectExpression([])),
+              ])
+            ),
+          ]),
+          types.catchClause(
+            types.identifier('error'),
+            types.blockStatement([
+              types.returnStatement(
+                types.objectExpression([
+                  types.objectProperty(types.identifier('props'), types.objectExpression([])),
+                ])
+              ),
+            ])
+          )
+        ),
+      ]),
+      false,
+      true
+    )
+  ),
+})
+
+const runPlugin = async (repeater: RepeaterOptions) => {
+  const chunk = makeWidgetComponentChunk({ controls: ['previous', 'next'] })
+  const staticProps = makeGetStaticPropsChunk()
+  const structure: ComponentStructure = {
+    uidl: { name: 'TestComponent', node: makeUidlNode(repeater) },
+    chunks: [chunk, staticProps],
+    dependencies: {},
+    options: { dataSources: {}, extractedResources: {} },
+  } as never
+  await createNextArrayMapperPaginationPlugin()(structure)
+  return {
+    component: collapse(generator(chunk.content as types.Node).code),
+    staticProps: collapse(generator(staticProps.content as types.Node).code),
+  }
+}
+
+const OR_GROUP = [
+  group('or', [condition('Category', 'Commercial'), condition('Category', 'Narrative')]),
+]
+
+const expectOrGroup = (code: string) => {
+  expect(code).toContain('type: "group"')
+  expect(code).toContain('operator: "or"')
+  expect(code).toContain('source: "Category", destination: "Commercial", operand: "="')
+  expect(code).toContain('source: "Category", destination: "Narrative", operand: "="')
+  // The two conditions sit INSIDE the group's children, never beside it.
+  expect(code).toMatch(/children: \[[^\]]*Commercial[^\]]*Narrative[^\]]*\]/)
+}
+
+describe('pagination plugin — filter groups', () => {
+  it('a paginated list keeps an or-group as an or-group in its browser fetch', async () => {
+    const { component } = await runPlugin({ paginated: true, filters: OR_GROUP })
+    expectOrGroup(component)
+  })
+
+  it('a searchable list keeps it too', async () => {
+    const { component } = await runPlugin({
+      paginated: true,
+      searchEnabled: true,
+      filters: OR_GROUP,
+    })
+    expectOrGroup(component)
+  })
+
+  it('the build-time prefetch and its count carry the same group', async () => {
+    const { staticProps } = await runPlugin({ paginated: true, filters: OR_GROUP })
+    expect(staticProps).toContain('page: 1')
+    expectOrGroup(staticProps)
+    // Once for the first page, once for the count.
+    expect(staticProps.match(/operator: "or"/g)).toHaveLength(2)
+  })
+
+  it('the runtime drop of empty destinations lets a group through and prunes inside it', async () => {
+    const { component } = await runPlugin({
+      paginated: true,
+      filters: [
+        group('or', [
+          condition('Category', 'Commercial'),
+          condition('Category', stateRef('picked')),
+        ]),
+      ],
+    })
+    // Every level is filtered; the predicate keeps groups themselves.
+    expect(component).toContain('__f.type === "group" ||')
+    expect(component).toMatch(/children: \[.*\]\.filter\(__f =>/)
+    // The state-bound leaf is still a dependency of the fetch params.
+    expect(component).toContain('picked')
+  })
+
+  it('the prefetch prunes a dynamic leaf but keeps the group around its static sibling', async () => {
+    const { staticProps } = await runPlugin({
+      paginated: true,
+      filters: [
+        group('or', [
+          condition('Category', 'Commercial'),
+          condition('Category', stateRef('picked')),
+        ]),
+      ],
+    })
+    expect(staticProps).toContain('operator: "or"')
+    expect(staticProps).toContain('destination: "Commercial"')
+    expect(staticProps).not.toContain('picked')
+  })
+
+  it('a legacy flat condition list still works', async () => {
+    const { component } = await runPlugin({
+      paginated: true,
+      filters: [{ source: 'Category', destination: 'Commercial', operand: '=' }],
+    })
+    expect(component).toContain('source: "Category", destination: "Commercial", operand: "="')
+    expect(component).not.toContain('type: "group"')
+  })
+})

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=')
+  })
+})