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

package/src/transformations/index.ts

@@ -1,7 +1,8 @@
-import type { GeneratorOptions } from '@teleporthq/teleport-types'
+import type { GeneratorOptions, UIDLEcommerceCategory } from '@teleporthq/teleport-types'
 import { StorefrontTax } from '@teleporthq/teleport-shared'
 import { generateSharedTransformationCode } from './shared-utils'
 import { generateBlogPostTransformationCode } from './blog-post'
+import { generateCustomPageTransformationCode } from './custom-page'
 import {
   generateEcommerceProductTransformationCode,
   type EcommerceProductTransformOptions,
@@ -9,6 +10,17 @@ import {
 
 export type { EcommerceProductTransformOptions }
 
+/**
+ * Everything a generated fetcher bakes in, for EITHER entity. One options object
+ * because `getTransformationCode` is called with a table name and has to be able
+ * to serve whichever transform that resolves to — the product fields are ignored
+ * for a blog table and vice versa.
+ */
+export interface EntityTransformOptions extends EcommerceProductTransformOptions {
+  /** Blog post-category taxonomy — see `blogSettings.categories`. */
+  blogCategories?: UIDLEcommerceCategory[]
+}
+
 /**
  * Stock never gates purchasability when the merchant disabled stock management
  * entirely or opted into backorders. Mirrors the GUI rule in
@@ -35,14 +47,15 @@ const resolveAllowBackorders = (
  * "stock never blocks a purchase" flag — see `resolveAllowBackorders`.
  */
 export const buildProductTransformOptions = (
-  options: Pick<GeneratorOptions, 'ecommerceSettings' | 'invoiceSettings'>
-): EcommerceProductTransformOptions => ({
+  options: Pick<GeneratorOptions, 'ecommerceSettings' | 'invoiceSettings' | 'blogSettings'>
+): EntityTransformOptions => ({
   categories: options.ecommerceSettings?.categories,
+  blogCategories: options.blogSettings?.categories,
   storefrontTaxRate: StorefrontTax.resolveStorefrontTaxRate(options.invoiceSettings),
   allowBackorders: resolveAllowBackorders(options.ecommerceSettings),
 })
 
-export type TransformationType = 'blog-post' | 'ecommerce-product' | null
+export type TransformationType = 'blog-post' | 'ecommerce-product' | 'custom-page' | null
 
 /**
  * Strips a leading `schema.` qualifier from a table name so that only the
@@ -80,6 +93,9 @@ export const detectTransformationType = (tableName: string): TransformationType
   if (bare === 'teleport_products') {
     return 'ecommerce-product'
   }
+  if (bare === 'teleport_pages') {
+    return 'custom-page'
+  }
   return null
 }
 
@@ -90,7 +106,7 @@ export const detectTransformationType = (tableName: string): TransformationType
  */
 export const getTransformationCode = (
   tableName: string,
-  options: EcommerceProductTransformOptions = {}
+  options: EntityTransformOptions = {}
 ): string => {
   const type = detectTransformationType(tableName)
   if (!type) {
@@ -101,9 +117,11 @@ export const getTransformationCode = (
 
   switch (type) {
     case 'blog-post':
-      return shared + generateBlogPostTransformationCode()
+      return shared + generateBlogPostTransformationCode({ categories: options.blogCategories })
     case 'ecommerce-product':
       return shared + generateEcommerceProductTransformationCode(options)
+    case 'custom-page':
+      return shared + generateCustomPageTransformationCode()
     default:
       return ''
   }
@@ -126,11 +144,23 @@ export const getTransformExpression = (tableName: string): string | null => {
       return 'await transformRecords(safeData, getClient, req.query)'
     case 'ecommerce-product':
       return 'await transformRecords(safeData, getClient, req.query)'
+    case 'custom-page':
+      return 'await transformRecords(safeData, getClient, req.query)'
     default:
       return null
   }
 }
 
+/**
+ * How many reviews a product page carries into its structured data.
+ *
+ * They are inlined TWICE — once into the page's props, once into the JSON-LD
+ * script rendered from them — so this number is paid for in bytes on every
+ * request. Five is what a review snippet shows; the rest are on the page itself,
+ * fetched by the reviews section's own paginated query.
+ */
+export const REVIEWS_PER_PRODUCT = 5
+
 /**
  * Returns the transform wrapper function code that handles asset map loading
  * and calls the appropriate transformer.
@@ -142,7 +172,12 @@ export const getTransformWrapperCode = (tableName: string): string => {
     return ''
   }
 
-  const transformFn = type === 'blog-post' ? 'transformBlogPosts' : 'transformEcommerceProducts'
+  const transformFn =
+    type === 'blog-post'
+      ? 'transformBlogPosts'
+      : type === 'custom-page'
+      ? 'transformCustomPages'
+      : 'transformEcommerceProducts'
 
   // Products additionally get their purchasable variant combinations attached in
   // ONE batched query (keyed by product id). Blog posts have no such enrichment.
@@ -160,8 +195,11 @@ export const getTransformWrapperCode = (tableName: string): string => {
     type === 'ecommerce-product'
       ? `
   var variantsByProductId = null
+  // Declared OUTSIDE the try because the ratings lookup below reuses it. \`var\`
+  // would hoist it anyway, but relying on that would make this block break
+  // silently the day someone modernises it to \`let\`.
+  var __variantPids = []
   try {
-    var __variantPids = []
     for (var __i = 0; __i < records.length; __i++) {
       if (records[__i] && records[__i].id != null) __variantPids.push(records[__i].id)
     }
@@ -178,11 +216,41 @@ export const getTransformWrapperCode = (tableName: string): string => {
     variantsByProductId = await getVariantsMap(getClientFn, __variantPids)
   } catch (e) {
     // Leaves the map null — "unknown", never "none".
+  }
+  // The aggregate star rating for the same id set, in ONE more query. Reuses
+  // __variantPids so a details page's related cards get their ratings from the
+  // same round trip rather than one query per card.
+  //
+  // Unlike the variants map this stays {} on failure: "no rating to show" is
+  // both the empty answer and the safe answer, so there is no unknown state for
+  // a caller to reason about.
+  var ratingsByProductId = {}
+  try {
+    ratingsByProductId = await getRatingsMap(getClientFn, __variantPids)
+  } catch (e) {
+    // Leaves the map empty — the star rows simply stay hidden.
+  }
+  // The individual reviews behind the stars, for the product page's JSON-LD.
+  //
+  // Gated on the SINGLE-RECORD heuristic, unlike the two lookups above. Those
+  // feed something every card on the page draws; this feeds structured data,
+  // which only a details page emits — and a listing of 24 products would
+  // otherwise fetch and inline 120 review rows that nothing on it renders or
+  // markup-references.
+  var reviewsByProductId = {}
+  if (Array.isArray(records) && records.length === 1) {
+    try {
+      reviewsByProductId = await getProductReviewsMap(getClientFn, __variantPids, ${REVIEWS_PER_PRODUCT})
+    } catch (e) {
+      // Best-effort; the product simply ships without review snippets.
+    }
   }`
       : ''
 
   const variantOption =
-    type === 'ecommerce-product' ? ', variantsByProductId: variantsByProductId' : ''
+    type === 'ecommerce-product'
+      ? ', variantsByProductId: variantsByProductId, ratingsByProductId: ratingsByProductId, reviewsByProductId: reviewsByProductId'
+      : ''
 
   // Related items are resolved for a SINGLE-record fetch only — which is the
   // details page, the one surface that renders them (it looks the row up by
@@ -195,9 +263,13 @@ export const getTransformWrapperCode = (tableName: string): string => {
   // A one-product store's listing does pay for one extra query. That is the
   // whole cost of the heuristic, and it beats plumbing a page-role flag through
   // every fetcher.
+  // Custom pages have no related items and no variants: their transform only
+  // normalises the row's SEO fields.
+  const hasRelatedItems = type === 'blog-post' || type === 'ecommerce-product'
   const relatedMapVar = type === 'blog-post' ? 'relatedPostsById' : 'relatedProductsById'
   const relatedMapFn = type === 'blog-post' ? 'getRelatedPostsMap' : 'getRelatedProductsMap'
-  const relatedEnrichment = `
+  const relatedEnrichment = hasRelatedItems
+    ? `
   var ${relatedMapVar} = null
   if (Array.isArray(records) && records.length === 1) {
     try {
@@ -206,6 +278,8 @@ export const getTransformWrapperCode = (tableName: string): string => {
       // Best-effort; the related rail stays hidden behind its empty gate.
     }
   }`
+    : ''
+  const relatedOption = hasRelatedItems ? `, ${relatedMapVar}: ${relatedMapVar}` : ''
 
   return `
 async function transformRecords(records, getClientFn, reqQuery) {
@@ -217,7 +291,7 @@ async function transformRecords(records, getClientFn, reqQuery) {
   }${relatedEnrichment}${variantEnrichment}
   var currentLanguage = (reqQuery && reqQuery.lang) || null
   var mainLanguage = (reqQuery && reqQuery.mainLang) || null
-  var options = { assetMap: assetMap, currentLanguage: currentLanguage, mainLanguage: mainLanguage${variantOption}, ${relatedMapVar}: ${relatedMapVar} }
+  var options = { assetMap: assetMap, currentLanguage: currentLanguage, mainLanguage: mainLanguage${variantOption}${relatedOption} }
   return ${transformFn}(records, options)
 }
 `

package/src/transformations/shared-utils.ts

@@ -248,6 +248,15 @@ function resolveMediaUrl(value, assetMap) {
   return isResolvedMediaUrl(resolved) ? resolved : null
 }
 
+// Trims a per-row SEO URL cell (blog posts, custom pages); blank/non-string
+// values — including columns that don't exist yet on tables provisioned before
+// the feature — become null.
+function normalizeSeoUrlField(value) {
+  if (typeof value !== 'string') return null
+  var trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed : null
+}
+
 function resolveAssetUrls(values, assetMap) {
   if (!Array.isArray(values)) return []
   return values

package/src/utils.ts

@@ -12,7 +12,7 @@ import * as types from '@babel/types'
 import { ASTUtils } from '@teleporthq/teleport-plugin-common'
 import { GenericUtils, StringUtils } from '@teleporthq/teleport-shared'
 import { generateDataSourceFetcherWithCore } from './data-source-fetchers'
-import type { EcommerceProductTransformOptions } from './transformations'
+import type { EntityTransformOptions } from './transformations'
 import { DATA_SOURCE_ISR_REVALIDATE_SECONDS } from './isr'
 
 const VALID_DATA_SOURCE_TYPES: DataSourceType[] = [
@@ -192,7 +192,7 @@ export const extractDataSourceIntoNextAPIFolder = (
   dataSources: Record<string, UIDLDataSource>,
   componentChunk: ChunkDefinition,
   extractedResources: GeneratorOptions['extractedResources'],
-  transformOptions: EcommerceProductTransformOptions = {}
+  transformOptions: EntityTransformOptions = {}
 ) => {
   try {
     // Validate node content structure
@@ -596,6 +596,146 @@ const dateReplacer = (key, value) => {
 }`
 }
 
+/**
+ * Every leaf condition of a filters array, unwrapping any `{ type: 'group' }`
+ * envelopes the inspector wrapped them in. Generator-side checks that ask
+ * "does any destination reference state / a route param?" must look through
+ * groups — asking `entry.destination` of a group silently answers "no", which
+ * is how a dynamic filter ends up baked into initialData at build time.
+ */
+export const collectFilterLeafConditions = (entries: unknown): unknown[] => {
+  if (!Array.isArray(entries)) {
+    return []
+  }
+  const leaves: unknown[] = []
+  const walk = (entry: unknown): void => {
+    if (!entry || typeof entry !== 'object') {
+      return
+    }
+    const node = entry as { type?: string; children?: unknown[] }
+    if (node.type === 'group') {
+      ;(node.children || []).forEach(walk)
+      return
+    }
+    leaves.push(entry)
+  }
+  entries.forEach(walk)
+  return leaves
+}
+
+/**
+ * Rebuilds a filters array keeping its group structure, dropping leaf
+ * conditions that `keepCondition` rejects and any group left empty by that.
+ * Used so the SSG emit can discard unresolvable dynamic destinations without
+ * flattening an `or` group into ANDs on the way.
+ */
+export const pruneFilterTree = (
+  entries: unknown[],
+  keepCondition: (condition: unknown) => boolean
+): unknown[] => {
+  const prune = (entry: unknown): unknown | null => {
+    if (!entry || typeof entry !== 'object') {
+      return null
+    }
+    const node = entry as { type?: string; children?: unknown[] }
+    if (node.type === 'group') {
+      const children = (node.children || []).map(prune).filter(Boolean)
+      if (children.length === 0) {
+        return null
+      }
+      return { ...node, children }
+    }
+    return keepCondition(entry) ? entry : null
+  }
+  return entries.map(prune).filter(Boolean) as unknown[]
+}
+
+/**
+ * Runtime helpers for the filter TREE the GUI authors.
+ *
+ * The inspector emits filters as a tree — a root `{ type: 'group', operator,
+ * children }` whose children are `{ type: 'condition', source, destination,
+ * operand }` leaves or further groups (an `or` group nested inside the root
+ * `and` is how "A and (B or C)" is expressed). Older projects, and params built
+ * by hand, still send a flat array of bare conditions or a plain `{ key: value }`
+ * map.
+ *
+ * Every fetcher used to hand-roll `parsedFilters.forEach(f => { if (!f.source)
+ * return ... })`, which silently DROPPED any group — a group has no `.source`,
+ * so the whole filter became a no-op and the page rendered unfiltered rows.
+ * These helpers exist so no fetcher has to know the shape: `normalizeFilterTree`
+ * turns all three input forms into one tree, and the walkers below consume it.
+ */
+export const generateFilterTreeHelpersCode = (): string => {
+  return `const normalizeFilterTree = (parsed) => {
+  if (parsed === null || parsed === undefined) return null
+
+  const toNode = (entry) => {
+    if (!entry || typeof entry !== 'object') return null
+    if (entry.type === 'group') {
+      const children = Array.isArray(entry.children)
+        ? entry.children.map(toNode).filter(Boolean)
+        : []
+      if (children.length === 0) return null
+      return { type: 'group', operator: entry.operator === 'or' ? 'or' : 'and', children }
+    }
+    if (!entry.source || entry.destination === undefined) return null
+    return {
+      type: 'condition',
+      source: entry.source,
+      destination: entry.destination,
+      operand: entry.operand || '=',
+    }
+  }
+
+  const children = Array.isArray(parsed)
+    ? parsed.map(toNode).filter(Boolean)
+    : Object.entries(parsed).map(([source, destination]) =>
+        toNode({ source, destination, operand: '=' })
+      ).filter(Boolean)
+
+  if (children.length === 0) return null
+  // A single root group is already the tree; wrapping it in another and-group
+  // would only add a redundant level.
+  if (children.length === 1 && children[0].type === 'group') return children[0]
+  return { type: 'group', operator: 'and', children }
+}
+
+const evaluateFilterTree = (node, testCondition) => {
+  if (!node) return true
+  if (node.type === 'group') {
+    if (node.children.length === 0) return true
+    return node.operator === 'or'
+      ? node.children.some((child) => evaluateFilterTree(child, testCondition))
+      : node.children.every((child) => evaluateFilterTree(child, testCondition))
+  }
+  return testCondition(node)
+}
+
+const buildFilterTreeClause = (node, buildCondition) => {
+  if (!node) return null
+  if (node.type === 'group') {
+    const parts = []
+    for (const child of node.children) {
+      const clause = buildFilterTreeClause(child, buildCondition)
+      if (clause) parts.push(clause)
+    }
+    if (parts.length === 0) return null
+    if (parts.length === 1) return parts[0]
+    return '(' + parts.join(node.operator === 'or' ? ' OR ' : ' AND ') + ')'
+  }
+  return buildCondition(node)
+}
+
+const flattenFilterConditions = (node) => {
+  if (!node) return []
+  if (node.type === 'group') {
+    return node.children.reduce((acc, child) => acc.concat(flattenFilterConditions(child)), [])
+  }
+  return [node]
+}`
+}
+
 export const generateSortFilterHelperCode = (): string => {
   return `function getNestedValue(obj, path) {
   if (!obj || typeof obj !== 'object') return undefined
@@ -801,13 +941,14 @@ export const hasUnresolvableDynamicParams = (
     }
 
     if (param.type === 'static' && Array.isArray(param.content)) {
-      const hasDynamicDestinations = param.content.some(
+      const leafConditions = collectFilterLeafConditions(param.content)
+      const hasDynamicDestinations = leafConditions.some(
         (item: any) =>
           item && typeof item === 'object' && ASTUtils.isUIDLDynamicReference(item?.destination)
       )
 
       if (hasDynamicDestinations && dynamicRouteAttr) {
-        const allResolvable = param.content.every((item: any) => {
+        const allResolvable = leafConditions.every((item: any) => {
           if (!item || typeof item !== 'object') {
             return true
           }
@@ -901,7 +1042,7 @@ export const extractDataSourceIntoGetStaticProps = (
   dependencies: Record<string, any>,
   dynamicRouteAttr?: string,
   folderPath?: string[],
-  transformOptions: EcommerceProductTransformOptions = {}
+  transformOptions: EntityTransformOptions = {}
 ): { success: boolean; chunk?: any } => {
   try {
     // Validate node content
@@ -1165,9 +1306,9 @@ export const extractDataSourceIntoGetStaticProps = (
     // tslint:disable-next-line:no-any
     const resourceParamsForFilters = (node.content as any).resource?.params || {}
     const nodeFilters = resourceParamsForFilters.filters?.content || []
-    const hasDynamicFilterDestinations =
-      Array.isArray(nodeFilters) &&
-      nodeFilters.some((f: any) => ASTUtils.isUIDLDynamicReference(f?.destination))
+    const hasDynamicFilterDestinations = collectFilterLeafConditions(nodeFilters).some((f: any) =>
+      ASTUtils.isUIDLDynamicReference(f?.destination)
+    )
 
     // Update all target JSX nodes with initialData (only those that don't already have it)
     for (const jsxNode of nodesToUpdate) {
@@ -1291,9 +1432,12 @@ export const extractDataSourceIntoGetStaticProps = (
           if (key === 'sorts' || key === 'filters' || key === 'queryColumns') {
             let itemsToProcess = validItems
             if (key === 'filters') {
-              // Keep filter items that are either static or route-resolvable (via dynamicRouteAttr)
-              // Filter out items with unresolvable dynamic destinations
-              itemsToProcess = validItems.filter((item: any) => {
+              // Keep filter conditions that are either static or route-resolvable
+              // (via dynamicRouteAttr) and drop the ones with unresolvable dynamic
+              // destinations. Pruned through the tree so a condition nested in a
+              // group is judged on its own destination, and an `or` group keeps
+              // its shape on the way to the data source.
+              itemsToProcess = pruneFilterTree(validItems, (item: any) => {
                 if (!ASTUtils.isUIDLDynamicReference(item?.destination)) {
                   return true
                 }
@@ -1310,36 +1454,49 @@ export const extractDataSourceIntoGetStaticProps = (
             const hasRouteResolvableFilters =
               key === 'filters' &&
               dynamicRouteAttr &&
-              itemsToProcess.some(
+              collectFilterLeafConditions(itemsToProcess).some(
                 (item: any) =>
                   item &&
                   typeof item === 'object' &&
                   ASTUtils.isUIDLDynamicReference(item?.destination)
               )
 
-            const arrayExpr = types.arrayExpression(
-              itemsToProcess.map((item: any) => {
-                if (typeof item === 'string') {
-                  return types.stringLiteral(item)
-                }
-                if (typeof item === 'number') {
-                  return types.numericLiteral(item)
-                }
-                if (typeof item === 'boolean') {
-                  return types.booleanLiteral(item)
-                }
-                if (typeof item === 'object' && item !== null) {
-                  if (
-                    hasRouteResolvableFilters &&
-                    ASTUtils.isUIDLDynamicReference(item?.destination)
-                  ) {
-                    return buildFilterObjectAST(item, dynamicRouteAttr)
-                  }
-                  return ASTUtils.objectToObjectExpression(item)
-                }
+            // Recurses through groups so a route-resolvable destination nested
+            // inside one still gets its `context.params.*` AST instead of being
+            // emitted as a raw UIDL dynamic-reference object.
+            const buildFilterEntryAST = (item: any): types.Expression => {
+              if (typeof item === 'string') {
+                return types.stringLiteral(item)
+              }
+              if (typeof item === 'number') {
+                return types.numericLiteral(item)
+              }
+              if (typeof item === 'boolean') {
+                return types.booleanLiteral(item)
+              }
+              if (typeof item !== 'object' || item === null) {
                 return types.nullLiteral()
-              })
-            )
+              }
+              if (item.type === 'group' && Array.isArray(item.children)) {
+                return types.objectExpression([
+                  types.objectProperty(types.identifier('type'), types.stringLiteral('group')),
+                  types.objectProperty(
+                    types.identifier('operator'),
+                    types.stringLiteral(item.operator === 'or' ? 'or' : 'and')
+                  ),
+                  types.objectProperty(
+                    types.identifier('children'),
+                    types.arrayExpression(item.children.map(buildFilterEntryAST))
+                  ),
+                ])
+              }
+              if (hasRouteResolvableFilters && ASTUtils.isUIDLDynamicReference(item?.destination)) {
+                return buildFilterObjectAST(item, dynamicRouteAttr)
+              }
+              return ASTUtils.objectToObjectExpression(item)
+            }
+
+            const arrayExpr = types.arrayExpression(itemsToProcess.map(buildFilterEntryAST))
             // Wrap in JSON.stringify()
             astValue = types.callExpression(
               types.memberExpression(types.identifier('JSON'), types.identifier('stringify')),