@teleporthq/teleport-plugin-next-data-source 0.43.62 → 0.43.64

package/__tests__/blog-post-categories.test.ts

@@ -0,0 +1,131 @@
+import { generateBlogPostTransformationCode } from '../src/transformations/blog-post'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+import { buildProductTransformOptions, getTransformationCode } from '../src/transformations'
+import type { UIDLBlogSettings, UIDLEcommerceCategory } from '@teleporthq/teleport-types'
+
+/**
+ * A blog post's assigned categories are resolved AT REQUEST TIME against a
+ * taxonomy baked into the generated fetcher — there is no DB table for it, it
+ * lives only in `blogSettings.categories`. The post-details BREADCRUMBS map over
+ * the resulting `categories` array and gate each crumb on it, so a post whose
+ * ids resolve to nothing renders no crumbs at all.
+ *
+ * The editor produces the same array through `resolveAssignedCategories`
+ * (teleport-gui `features/shared/taxonomy/category-tree.ts`); a difference
+ * between the two is a canvas that shows crumbs the deployed blog does not.
+ */
+
+const category = (
+  id: string,
+  name: string,
+  slug: string,
+  children: UIDLEcommerceCategory[] = [],
+  translations?: UIDLEcommerceCategory['translations']
+): UIDLEcommerceCategory => ({
+  id,
+  name,
+  slug,
+  parentId: null,
+  order: 0,
+  children,
+  ...(translations ? { translations } : {}),
+})
+
+const TAXONOMY: UIDLEcommerceCategory[] = [
+  category('news', 'News', 'news', [
+    { ...category('releases', 'Releases', 'releases'), parentId: 'news' },
+  ]),
+  category('guides', 'Guides', 'guides', [], { fr: { name: 'Guides FR' } }),
+]
+
+const buildPost = (
+  categories: UIDLEcommerceCategory[] | undefined
+): ((record: unknown, options?: unknown) => Record<string, unknown>) => {
+  const code =
+    generateSharedTransformationCode() + '\n' + generateBlogPostTransformationCode({ categories })
+  return new Function(code + '\nreturn buildBlogPost;')() as (
+    record: unknown,
+    options?: unknown
+  ) => Record<string, unknown>
+}
+
+const POST = { id: 'p1', title: 'T', slug: 't', status: 'published' }
+
+describe('blog post transform — assigned categories', () => {
+  it('resolves category_ids to {id,name,slug}, in the order they were assigned', () => {
+    const post = buildPost(TAXONOMY)({
+      ...POST,
+      category_ids: JSON.stringify(['releases', 'guides']),
+    })
+    expect(post.categories).toEqual([
+      { id: 'releases', name: 'Releases', slug: 'releases' },
+      { id: 'guides', name: 'Guides', slug: 'guides' },
+    ])
+  })
+
+  it('drops ids that resolve to nothing — a deleted category leaves no ghost crumb', () => {
+    const post = buildPost(TAXONOMY)({
+      ...POST,
+      category_ids: JSON.stringify(['gone', 'news']),
+    })
+    expect(post.categories).toEqual([{ id: 'news', name: 'News', slug: 'news' }])
+  })
+
+  it('is empty (never undefined) for a post that names no category at all', () => {
+    expect(buildPost(TAXONOMY)({ ...POST, category_ids: null }).categories).toEqual([])
+    expect(buildPost(TAXONOMY)(POST).categories).toEqual([])
+    expect(
+      buildPost(undefined)({ ...POST, category_ids: JSON.stringify(['news']) }).categories
+    ).toEqual([])
+  })
+
+  it('falls back to the row’s own NAME when it has no resolvable ids', () => {
+    // ⛔ A row written before `category_ids` existed still carries `category`.
+    // Templates iterate `categories` now, so without this the card and the post
+    // header go blank exactly where a bound text used to be. The id is EMPTY, so
+    // a filter link built from it carries no value — which every listing reads
+    // as "no filter" — rather than pointing at a category that does not exist.
+    const legacy = buildPost(TAXONOMY)({ ...POST, category_ids: null, category: 'Old News' })
+    expect(legacy.categories).toEqual([{ id: '', name: 'Old News', slug: 'old-news' }])
+
+    // A row with real ids never reaches the fallback.
+    const modern = buildPost(TAXONOMY)({
+      ...POST,
+      category: 'Old News',
+      category_ids: JSON.stringify(['news']),
+    })
+    expect(modern.categories).toEqual([{ id: 'news', name: 'News', slug: 'news' }])
+  })
+
+  it('localizes the NAME per request and leaves id/slug language-neutral', () => {
+    const post = buildPost(TAXONOMY)(
+      { ...POST, category_ids: JSON.stringify(['guides']) },
+      { currentLanguage: 'fr', mainLanguage: 'en' }
+    )
+    expect(post.categories).toEqual([{ id: 'guides', name: 'Guides FR', slug: 'guides' }])
+  })
+
+  it('keeps `category` as the denormalized primary NAME beside the resolved array', () => {
+    const post = buildPost(TAXONOMY)({
+      ...POST,
+      category: 'News',
+      category_ids: JSON.stringify(['news']),
+    })
+    expect(post.category).toBe('News')
+    expect(post.categories).toHaveLength(1)
+  })
+})
+
+describe('blog taxonomy plumbing', () => {
+  it('routes blogSettings.categories into the blog-post fetcher, not the product one', () => {
+    const options = buildProductTransformOptions({
+      blogSettings: { categories: TAXONOMY } as UIDLBlogSettings,
+    })
+    expect(options.blogCategories).toBe(TAXONOMY)
+    expect(options.categories).toBeUndefined()
+
+    const code = getTransformationCode('teleport_blog_posts', options)
+    expect(code).toContain('var BLOG_CATEGORIES_BY_ID = ')
+    expect(code).toContain('"releases"')
+  })
+})

package/__tests__/custom-page-transform.test.ts

@@ -0,0 +1,119 @@
+import { generateCustomPageTransformationCode } from '../src/transformations/custom-page'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+import {
+  detectTransformationType,
+  getTransformExpression,
+  getTransformWrapperCode,
+} from '../src/transformations'
+
+// The `teleport_pages` transform is what lets a custom page's <Head> bind its
+// SEO with plain `??` fallbacks, and what lets getStaticProps answer the row's
+// own redirect — every field it emits is read by generated code somewhere. So
+// these evaluate the EMITTED code, the same way the runtime does.
+
+type Build = (record: unknown, options?: Record<string, unknown>) => Record<string, unknown>
+
+const evalTransform = (): Build => {
+  const bundle = generateSharedTransformationCode() + '\n' + generateCustomPageTransformationCode()
+  return new Function(bundle + '\nreturn buildCustomPage;')() as Build
+}
+
+const buildCustomPage = evalTransform()
+
+const page = (overrides: Record<string, unknown> = {}) => ({
+  id: 'p1',
+  title: 'About us',
+  slug: 'about-us',
+  status: 'published',
+  blocks: '[{"id":"b1","component":"tq:heading","props":{"text":"Hi"}}]',
+  ...overrides,
+})
+
+describe('custom page transform — the row itself', () => {
+  it('keeps every stored column, the blocks column above all', () => {
+    const built = buildCustomPage(page({ extra_column: 'kept' }))
+    expect(built.blocks).toBe('[{"id":"b1","component":"tq:heading","props":{"text":"Hi"}}]')
+    expect(built.slug).toBe('about-us')
+    expect(built.extra_column).toBe('kept')
+  })
+
+  it('is routed for the platform pages table only', () => {
+    expect(detectTransformationType('teleport_pages')).toBe('custom-page')
+    expect(detectTransformationType('public.TELEPORT_PAGES')).toBe('custom-page')
+    expect(detectTransformationType('pages')).toBeNull()
+    expect(detectTransformationType('my_pages')).toBeNull()
+    expect(getTransformExpression('teleport_pages')).toContain('transformRecords')
+  })
+
+  it('wraps the transform without the related-items or variant enrichment', () => {
+    const wrapper = getTransformWrapperCode('teleport_pages')
+    expect(wrapper).toContain('transformCustomPages(records, options)')
+    expect(wrapper).not.toContain('relatedPostsById')
+    expect(wrapper).not.toContain('relatedProductsById')
+    expect(wrapper).not.toContain('variantsByProductId')
+  })
+})
+
+describe('custom page transform — the meta pair', () => {
+  it('falls the meta title back to the page title, and trims what was typed', () => {
+    expect(buildCustomPage(page()).metaTitle).toBe('About us')
+    expect(buildCustomPage(page({ meta_title: '  Our story  ' })).metaTitle).toBe('Our story')
+    expect(buildCustomPage(page({ meta_title: '   ' })).metaTitle).toBe('About us')
+  })
+
+  it('emits null for an unset description so the page-level value inherits', () => {
+    expect(buildCustomPage(page()).metaDescription).toBeNull()
+    expect(buildCustomPage(page({ meta_description: ' A page. ' })).metaDescription).toBe('A page.')
+  })
+})
+
+describe('custom page transform — robots, canonical, redirect', () => {
+  it('emits robotsContent as "noindex" or NULL, never "" or false', () => {
+    expect(buildCustomPage(page()).robotsContent).toBeNull()
+    expect(buildCustomPage(page({ no_index: false })).robotsContent).toBeNull()
+    expect(buildCustomPage(page({ no_index: true })).robotsContent).toBe('noindex')
+    expect(buildCustomPage(page({ no_index: 'true' })).robotsContent).toBe('noindex')
+  })
+
+  it('normalises the canonical URL', () => {
+    expect(buildCustomPage(page()).canonicalUrl).toBeNull()
+    expect(buildCustomPage(page({ canonical_url: ' https://x.io/a ' })).canonicalUrl).toBe(
+      'https://x.io/a'
+    )
+  })
+
+  it('keeps a redirect type only beside a real destination, and only 301/302', () => {
+    expect(buildCustomPage(page({ redirect_type: '301' })).redirectType).toBeNull()
+    expect(buildCustomPage(page({ redirect_url: '/new', redirect_type: '302' }))).toMatchObject({
+      redirectUrl: '/new',
+      redirectType: '302',
+    })
+    expect(
+      buildCustomPage(page({ redirect_url: '/new', redirect_type: '307' })).redirectType
+    ).toBeNull()
+    expect(buildCustomPage(page({ redirect_url: '   ' })).redirectUrl).toBeNull()
+  })
+})
+
+describe('custom page transform — Open Graph', () => {
+  it('falls og title/description back to the meta pair', () => {
+    const built = buildCustomPage(page({ meta_description: 'Meta' }))
+    expect(built.ogTitle).toBe('About us')
+    expect(built.ogDescription).toBe('Meta')
+
+    const own = buildCustomPage(page({ og_title: 'Share me', og_description: 'Shared' }))
+    expect(own.ogTitle).toBe('Share me')
+    expect(own.ogDescription).toBe('Shared')
+  })
+
+  it('resolves an asset id to its URL and passes a plain URL through', () => {
+    const assetMap = { TQ_asset1: { remoteSrc: 'https://cdn.example/a.png' } }
+    expect(buildCustomPage(page({ og_image: 'TQ_asset1' }), { assetMap }).ogImage).toBe(
+      'https://cdn.example/a.png'
+    )
+    expect(buildCustomPage(page({ og_image: 'https://x.io/b.png' }), { assetMap }).ogImage).toBe(
+      'https://x.io/b.png'
+    )
+    expect(buildCustomPage(page()).ogImage).toBeNull()
+  })
+})

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

@@ -0,0 +1,155 @@
+import { generateEcommerceProductTransformationCode } from '../src/transformations/ecommerce-product'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+
+/**
+ * The aggregate star rating a product card and the product page draw.
+ *
+ * The one rule that matters more than the arithmetic: a product nobody has
+ * reviewed, and a product whose rating lookup FAILED, must render identically —
+ * as no stars at all. "0.0 out of 5" on an unreviewed product is the single
+ * worst thing a storefront can say about it by accident, and it is exactly what
+ * a well-meaning `|| 0` produces.
+ *
+ * PARITY: the same fixture table runs against the editor/canvas copy in
+ * teleport-gui's `features/e-commerce/utils/__tests__/product-rating-parity.spec.ts`.
+ * Keep the two tables identical — that is what proves the canvas and the
+ * deployed store agree.
+ */
+
+const buildProduct = (): ((record: unknown, options?: unknown) => Record<string, unknown>) => {
+  const code =
+    generateSharedTransformationCode() + '\n' + generateEcommerceProductTransformationCode({})
+  return new Function(code + '\nreturn buildEcommerceProduct;')() as (
+    record: unknown,
+    options?: unknown
+  ) => Record<string, unknown>
+}
+
+const PRODUCT = { id: 'p1', name: 'P', slug: 'p', price: '10.00', currency: 'USD' }
+
+const withRating = (average: number | null, count: number) =>
+  buildProduct()(PRODUCT, { ratingsByProductId: { p1: { average, count } } })
+
+/**
+ * SHARED PARITY TABLE — keep byte-identical with the GUI spec.
+ * [average, count, expected label, expected star states]
+ */
+export const RATING_FIXTURES: Array<{
+  average: number
+  count: number
+  label: string
+  stars: string[]
+}> = [
+  { average: 5, count: 3, label: '5.0', stars: ['full', 'full', 'full', 'full', 'full'] },
+  { average: 4.5, count: 128, label: '4.5', stars: ['full', 'full', 'full', 'full', 'half'] },
+  { average: 4.26, count: 9, label: '4.3', stars: ['full', 'full', 'full', 'full', 'half'] },
+  { average: 4.24, count: 9, label: '4.2', stars: ['full', 'full', 'full', 'full', 'empty'] },
+  { average: 3.75, count: 4, label: '3.8', stars: ['full', 'full', 'full', 'full', 'empty'] },
+  { average: 3.5, count: 4, label: '3.5', stars: ['full', 'full', 'full', 'half', 'empty'] },
+  { average: 2.7, count: 11, label: '2.7', stars: ['full', 'full', 'half', 'empty', 'empty'] },
+  { average: 1, count: 1, label: '1.0', stars: ['full', 'empty', 'empty', 'empty', 'empty'] },
+  { average: 0.4, count: 2, label: '0.4', stars: ['half', 'empty', 'empty', 'empty', 'empty'] },
+]
+
+const starsOf = (product: Record<string, unknown>): string[] => [
+  product.ratingStar1 as string,
+  product.ratingStar2 as string,
+  product.ratingStar3 as string,
+  product.ratingStar4 as string,
+  product.ratingStar5 as string,
+]
+
+describe('ecommerce product transform — aggregate rating', () => {
+  it.each(RATING_FIXTURES)(
+    'renders $average over $count reviews as "$label"',
+    ({ average, count, label, stars }) => {
+      const product = withRating(average, count)
+      expect(product.ratingAverageLabel).toBe(label)
+      expect(product.ratingCountLabel).toBe(String(count))
+      expect(product.hasRatings).toBe('true')
+      expect(starsOf(product)).toEqual(stars)
+    }
+  )
+
+  it('shows NOTHING for a product with no reviews — not zero stars', () => {
+    const product = buildProduct()(PRODUCT, { ratingsByProductId: {} })
+    expect(product.hasRatings).toBe('false')
+    expect(product.ratingAverageLabel).toBe('')
+    expect(product.ratingCountLabel).toBe('')
+    expect(product.ratingAverage).toBe(0)
+    expect(product.ratingCount).toBe(0)
+    expect(starsOf(product)).toEqual(['empty', 'empty', 'empty', 'empty', 'empty'])
+  })
+
+  // A failed lookup leaves the map empty, which is deliberately the SAME answer
+  // as "no reviews" — there is exactly one safe rendering for both.
+  it('shows nothing when the ratings map is absent entirely', () => {
+    const product = buildProduct()(PRODUCT, {})
+    expect(product.hasRatings).toBe('false')
+    expect(starsOf(product)).toEqual(['empty', 'empty', 'empty', 'empty', 'empty'])
+  })
+
+  it('shows nothing when a count arrives with no usable average', () => {
+    // Every approved row had a NULL rating: AVG() is NULL, COUNT() is not.
+    expect(withRating(null, 4).hasRatings).toBe('false')
+  })
+
+  it('shows nothing for a zero count even if an average somehow came back', () => {
+    expect(withRating(4.5, 0).hasRatings).toBe('false')
+  })
+
+  // `rating` is a plain integer column: the admin panel, a CSV import or a
+  // hand-written UPDATE can all put a 7 in it. An unclamped average would ask
+  // for a sixth star slot that does not exist.
+  it('clamps an out-of-range average to five stars', () => {
+    const product = withRating(7.4, 2)
+    expect(product.ratingAverage).toBe(5)
+    expect(product.ratingAverageLabel).toBe('5.0')
+    expect(starsOf(product)).toEqual(['full', 'full', 'full', 'full', 'full'])
+  })
+
+  it('treats a negative average as no rating at all', () => {
+    expect(withRating(-3, 2).hasRatings).toBe('false')
+  })
+
+  it('emits the count as a whole number even when the driver returns a string', () => {
+    const product = buildProduct()(PRODUCT, {
+      ratingsByProductId: { p1: { average: '4.5', count: '12' } },
+    })
+    expect(product.ratingCount).toBe(12)
+    expect(product.ratingCountLabel).toBe('12')
+    expect(product.ratingAverageLabel).toBe('4.5')
+  })
+
+  // The details page draws its related products as real cards, each with its
+  // own star row. They are covered by the same batched query, so they must get
+  // the same enrichment rather than transforming as unrated.
+  it('passes the ratings map down to related products', () => {
+    const product = buildProduct()(
+      { ...PRODUCT, related_product_ids: JSON.stringify(['p2']) },
+      {
+        ratingsByProductId: { p1: { average: 5, count: 1 }, p2: { average: 3, count: 8 } },
+        relatedProductsById: {
+          p2: { id: 'p2', name: 'Other', slug: 'other', price: '5.00', status: 'active' },
+        },
+      }
+    )
+    const related = product.relatedProducts as Array<Record<string, unknown>>
+    expect(related).toHaveLength(1)
+    expect(related[0].hasRatings).toBe('true')
+    expect(related[0].ratingAverageLabel).toBe('3.0')
+  })
+
+  it('keeps the label and the stars consistent for every fixture', () => {
+    // The label is rounded to one decimal and the stars to the nearest half OF
+    // THAT LABEL, so the stars can never contradict the number beside them.
+    for (const fixture of RATING_FIXTURES) {
+      const product = withRating(fixture.average, fixture.count)
+      const filled = starsOf(product).reduce(
+        (total, star) => total + (star === 'full' ? 1 : star === 'half' ? 0.5 : 0),
+        0
+      )
+      expect(Math.abs(filled - Number(product.ratingAverageLabel))).toBeLessThanOrEqual(0.25)
+    }
+  })
+})

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

@@ -0,0 +1,147 @@
+import { generateEcommerceProductTransformationCode } from '../src/transformations/ecommerce-product'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+
+/**
+ * The storefront variant picker and the visible-properties pills are gated on
+ * fields this transform has to put on every product. When they were missing, the
+ * picker worked on the editor canvas (whose own transform emitted them) and was
+ * INVISIBLE in the deployed store — `requiresVariantSelection` came back
+ * undefined, so the picker root's `=== 'true'` gate never matched.
+ *
+ * That failure is invisible from the editor by construction: a screenshot
+ * showing the picker is the canvas, never the deployed store. This test is the
+ * thing that can see it, so it asserts the whole gate contract rather than any
+ * one field.
+ */
+
+const evalBuildProduct = (): ((record: unknown, options?: unknown) => Record<string, unknown>) => {
+  const code =
+    generateSharedTransformationCode() + '\n' + generateEcommerceProductTransformationCode()
+  const fn = new Function(code + '\nreturn buildEcommerceProduct;')
+  return fn() as (record: unknown, options?: unknown) => Record<string, unknown>
+}
+
+const buildEcommerceProduct = evalBuildProduct()
+
+const VARIANT_OPTIONS = [
+  {
+    key: 'size',
+    name: 'Size',
+    type: 'text',
+    values: [
+      { value: 's', label: 'S' },
+      { value: 'm', label: 'M' },
+    ],
+  },
+  {
+    key: 'color',
+    name: 'Colour',
+    type: 'color',
+    values: [{ value: 'red', label: 'Red', color: '#ef4444' }],
+  },
+]
+
+// Combinations arrive from the batched lookup, keyed by product id — NOT from a
+// column on the record.
+const VARIANTS_BY_PRODUCT_ID = {
+  p1: [
+    { id: 'v-s-red', options: { size: 's', color: 'red' }, price: 25, quantity: 4 },
+    { id: 'v-m-red', options: { size: 'm', color: 'red' }, price: 27, quantity: 0 },
+  ],
+}
+
+const productWithVariants = () =>
+  buildEcommerceProduct(
+    {
+      id: 'p1',
+      name: 'Tee',
+      slug: 'tee',
+      price: '20',
+      currency: 'USD',
+      quantity: 4,
+      metadata: JSON.stringify({ Material: 'Cotton' }),
+      variant_options: JSON.stringify(VARIANT_OPTIONS),
+    },
+    { variantsByProductId: VARIANTS_BY_PRODUCT_ID }
+  )
+
+const productWithoutVariants = () =>
+  buildEcommerceProduct(
+    { id: 'p2', name: 'Mug', slug: 'mug', price: '10', currency: 'USD' },
+    { variantsByProductId: {} }
+  )
+
+/**
+ * Every field the generated storefront reads off a product to decide whether to
+ * render the picker, which values are selectable, and what price to show.
+ */
+const PICKER_CONTRACT = [
+  'variantOptions',
+  'requiresVariantSelection',
+  'variants',
+  'variantOptionsJson',
+  'variantsJson',
+  'defaultVariantId',
+  'defaultVariantPrice',
+  'hasPurchasableVariant',
+  'visibleProperties',
+]
+
+describe('ecommerce product transform — storefront picker contract', () => {
+  it.each(PICKER_CONTRACT)('always emits %s, for a product WITH variants', (field) => {
+    expect(productWithVariants()).toHaveProperty(field)
+  })
+
+  // The picker is hidden by absence, so a product with no variants must still
+  // carry the keys — undefined and "false" are different bugs.
+  it.each(PICKER_CONTRACT)('always emits %s, for a product WITHOUT variants', (field) => {
+    expect(productWithoutVariants()).toHaveProperty(field)
+  })
+
+  it('gates the picker with the STRING "true"/"false", never a boolean', () => {
+    expect(productWithVariants().requiresVariantSelection).toBe('true')
+    expect(productWithoutVariants().requiresVariantSelection).toBe('false')
+  })
+
+  it('enriches every axis value with the per-value flags the picker reads', () => {
+    const options = productWithVariants().variantOptions as Array<{
+      key: string
+      name: string
+      values: Array<Record<string, unknown>>
+    }>
+
+    expect(options).toHaveLength(2)
+    for (const axis of options) {
+      expect(axis.name).toBeTruthy()
+      for (const value of axis.values) {
+        // Rendered label, colour-circle gate, and availability gate.
+        expect(value).toHaveProperty('label')
+        expect(value).toHaveProperty('showSwatch')
+        expect(value).toHaveProperty('isDead')
+        expect(['true', 'false']).toContain(value.showSwatch)
+        expect(['true', 'false']).toContain(value.isDead)
+      }
+    }
+  })
+
+  it('ships the JSON companions the DOM-reading workflows parse', () => {
+    const product = productWithVariants()
+
+    // A data-* attribute bound to an array renders "[object Object]", so the
+    // picker workflows read these stringified companions instead.
+    expect(() => JSON.parse(product.variantOptionsJson as string)).not.toThrow()
+    expect(() => JSON.parse(product.variantsJson as string)).not.toThrow()
+    expect(JSON.parse(product.variantsJson as string)).toHaveLength(2)
+  })
+
+  it('preselects an in-stock combination', () => {
+    const product = productWithVariants()
+
+    expect(product.defaultVariantId).toBe('v-s-red')
+    expect(product.hasPurchasableVariant).toBe('true')
+  })
+
+  it('surfaces custom metadata as visible properties', () => {
+    expect(Array.isArray(productWithVariants().visibleProperties)).toBe(true)
+  })
+})