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

package/__tests__/blog-post-reading-time.test.ts

@@ -0,0 +1,55 @@
+import { generateBlogPostTransformationCode } from '../src/transformations/blog-post'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+
+/**
+ * A post that stores no reading time gets one from its body — its words at
+ * about 200 a minute, at least one, as the editor's post form computes it —
+ * so a card or post page never prints "min read" with no number before it.
+ * The SAME cases as teleport-gui `packages/renderer/src/utils/__tests__/
+ * blog-reading-time.test.ts`: the canvas and the site must agree.
+ */
+
+const buildPost = (headingAnchors = false): ((record: unknown) => Record<string, unknown>) => {
+  const code =
+    generateSharedTransformationCode() +
+    '\n' +
+    generateBlogPostTransformationCode({ headingAnchors })
+  return new Function(code + '\nreturn buildBlogPost;')() as (
+    record: unknown
+  ) => Record<string, unknown>
+}
+
+const words = (count: number) => `<p>${Array.from({ length: count }, () => 'word').join(' ')}</p>`
+const POST = { id: 'p1', title: 'Connect a domain', slug: 'connect-a-domain', status: 'published' }
+
+describe('a post’s reading time', () => {
+  it('is the one the post stores', () => {
+    expect(
+      buildPost()({ ...POST, reading_time_minutes: 7, content: words(401) }).readingTimeMinutes
+    ).toBe(7)
+  })
+
+  it('comes from the body when the post stores none', () => {
+    expect(buildPost()({ ...POST, content: words(401) }).readingTimeMinutes).toBe(3)
+    expect(
+      buildPost()({ ...POST, reading_time_minutes: null, content: words(12) }).readingTimeMinutes
+    ).toBe(1)
+    expect(
+      buildPost()({
+        ...POST,
+        content: '<h2>Steps</h2><ul><li>Open the panel</li><li>Click Save</li></ul>',
+      }).readingTimeMinutes
+    ).toBe(1)
+  })
+
+  it('counts the words, not the heading anchors a site adds', () => {
+    const content = `<h2>One</h2>${words(399)}`
+    expect(buildPost(true)({ ...POST, content }).readingTimeMinutes).toBe(2)
+    expect(buildPost(false)({ ...POST, content }).readingTimeMinutes).toBe(2)
+  })
+
+  it('is none for a post with no body', () => {
+    expect(buildPost()({ ...POST, content: '' }).readingTimeMinutes).toBeNull()
+    expect(buildPost()({ ...POST, content: '<p> </p>' }).readingTimeMinutes).toBeNull()
+  })
+})

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')"
@@ -233,7 +236,11 @@ describe('blog posts: a visitor reads the published posts, never an author email
   it('serves the store everything: the admin, a server segment and getStaticProps', async () => {
     const admin = await posts.run({ session: { role: 'admin' } })
     expect(mainQuery(admin)).not.toContain("status = 'published'")
-    expect(JSON.stringify(admin.body.data)).toContain('ana@example.com')
+    // The post view model carries no email for anyone — a page's data must not
+    // ship it (transformations/blog-post.ts); the admin form reads raw rows.
+    expect(JSON.stringify(admin.body.data)).not.toContain('ana@example.com')
+    const adminRaw = await posts.run({ session: { role: 'admin' }, query: { rawRows: 'true' } })
+    expect(JSON.stringify(adminRaw.body.data)).toContain('ana@example.com')
 
     const server = await posts.run({ headers: internal })
     expect(mainQuery(server)).not.toContain("status = 'published'")
@@ -413,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__/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__/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

@@ -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()
+  })
+})