@teleporthq/teleport-plugin-next-data-source 0.43.61 → 0.43.63

package/src/transformations/ecommerce-product.ts

@@ -1,5 +1,6 @@
 import type { UIDLEcommerceCategory } from '@teleporthq/teleport-types'
-import { ProductDiscounts, StorefrontTax } from '@teleporthq/teleport-shared'
+import { ProductDiscounts, ProductRatings, StorefrontTax } from '@teleporthq/teleport-shared'
+import { generateCategoryTaxonomyCode } from './category-taxonomy'
 
 /**
  * Everything the product transform needs baked in at export time, beyond the
@@ -28,47 +29,6 @@ export interface EcommerceProductTransformOptions {
   allowBackorders?: boolean
 }
 
-/**
- * Flattens the nested category tree (`ecommerceSettings.categories`, baked at
- * export time) into an `id -> {name, slug, translations}` lookup map,
- * JSON-embedded into the generated transform below so a product's
- * `category_ids` can be resolved to display names with no runtime DB lookup
- * (there is no DB table for the taxonomy — it lives only in the UIDL).
- * `translations` is carried through unresolved (a per-language `{name,
- * description}` map) so `buildEcommerceProduct` can resolve it against the
- * SAME per-request `currentLanguage`/`mainLanguage` used for every other i18n
- * field — `slug` is never localized (it's the language-neutral join key).
- * Tolerant of a missing/malformed tree.
- */
-const flattenCategoriesById = (
-  categories: UIDLEcommerceCategory[] | undefined
-): Record<
-  string,
-  { name: string; slug: string; translations?: UIDLEcommerceCategory['translations'] }
-> => {
-  const byId: Record<
-    string,
-    { name: string; slug: string; translations?: UIDLEcommerceCategory['translations'] }
-  > = {}
-  const visit = (nodes: UIDLEcommerceCategory[] | undefined): void => {
-    if (!Array.isArray(nodes)) {
-      return
-    }
-    for (const node of nodes) {
-      if (node && typeof node.id === 'string') {
-        byId[node.id] = {
-          name: node.name || '',
-          slug: node.slug || '',
-          translations: node.translations,
-        }
-        visit(node.children)
-      }
-    }
-  }
-  visit(categories)
-  return byId
-}
-
 /**
  * Generates JavaScript code for e-commerce product data transformation.
  * Transforms raw snake_case database records into the camelCase shape
@@ -77,7 +37,6 @@ const flattenCategoriesById = (
 export const generateEcommerceProductTransformationCode = (
   options: EcommerceProductTransformOptions = {}
 ): string => {
-  const categoriesByIdJson = JSON.stringify(flattenCategoriesById(options.categories))
   const taxHelperCode = StorefrontTax.generateStorefrontTaxHelperCode(
     options.storefrontTaxRate ?? 0
   )
@@ -86,29 +45,14 @@ export const generateEcommerceProductTransformationCode = (
   return `
 ${taxHelperCode}
 ${ProductDiscounts.generateProductDiscountHelperCode()}
+${ProductRatings.generateProductRatingHelperCode()}
 
 // Baked from the merchant's stock settings: TRUE when stock never blocks a
 // purchase (stock management off OR backorders allowed). Regenerating the
 // project refreshes it — do not hand-edit. See EcommerceProductTransformOptions.
 var ALLOW_BACKORDERS = ${allowBackordersLiteral}
 
-// Category taxonomy (id -> {name, slug, translations}), baked in at export
-// time — see flattenCategoriesById in ecommerce-product.ts. Empty when the
-// store has no category taxonomy, or products.category_ids simply resolves
-// to nothing.
-var PRODUCT_CATEGORIES_BY_ID = ${categoriesByIdJson}
-
-// Resolve a baked category's name to currentLang/mainLang from its
-// translations map (same per-request locale as every other i18n field via
-// resolveI18nField), falling back to the main-language name.
-function resolveCategoryName(categoryInfo, currentLang, mainLang) {
-  if (currentLang && mainLang && currentLang !== mainLang && categoryInfo.translations) {
-    var override = categoryInfo.translations[currentLang]
-    if (override && override.name) return override.name
-  }
-  return categoryInfo.name
-}
-
+${generateCategoryTaxonomyCode('PRODUCT_CATEGORIES_BY_ID', options.categories)}
 // The merchant's "Show 3D model by default" toggle, as every backend may hand
 // it back: a real boolean, 1/0, 'true'/'false'/'t'/'f' strings — and NULL /
 // absent / '' as ON, because a product that has a model shows it unless the
@@ -251,24 +195,17 @@ function buildEcommerceProduct(record, options) {
     visibleProperties.push(classifyProductProperty(propKey, propValue))
   })
 
-  // Assigned category ids -> resolved {id,name,slug} objects for the
-  // storefront category pills mapper. The taxonomy itself is not in the DB
-  // (categories are authored in the GUI and live only in
-  // ecommerceSettings.categories); resolved here against PRODUCT_CATEGORIES_BY_ID,
-  // baked in at export time (see flattenCategoriesById). Unknown/stale ids
-  // (a deleted category) are silently dropped.
-  var categoryIds = parseJsonArray(record.category_ids)
-  var categories = []
-  for (var ci = 0; ci < categoryIds.length; ci++) {
-    var categoryInfo = PRODUCT_CATEGORIES_BY_ID[categoryIds[ci]]
-    if (categoryInfo) {
-      categories.push({
-        id: categoryIds[ci],
-        name: resolveCategoryName(categoryInfo, currentLang, mainLang),
-        slug: categoryInfo.slug,
-      })
-    }
-  }
+  // Assigned category ids -> resolved {id,name,slug} objects for the storefront
+  // category pills mapper and the product-details breadcrumbs. The taxonomy
+  // itself is not in the DB (categories are authored in the GUI and live only in
+  // ecommerceSettings.categories); resolved against PRODUCT_CATEGORIES_BY_ID,
+  // baked in at export time. Unknown/stale ids are silently dropped.
+  var categories = resolveAssignedCategories(
+    record.category_ids,
+    PRODUCT_CATEGORIES_BY_ID,
+    currentLang,
+    mainLang
+  )
 
   // Purchasable variant COMBINATIONS for this product ({id, options map, price,
   // stock, image}). Empty for flat products. Fetched in ONE batched query by
@@ -323,6 +260,9 @@ function buildEcommerceProduct(record, options) {
       // card's picker. The batched query includes the related ids for exactly
       // this reason (see getTransformWrapperCode).
       variantsByProductId: options.variantsByProductId,
+      // Same reason: a related card draws its own star row, and the batched
+      // aggregate already covered its id.
+      ratingsByProductId: options.ratingsByProductId,
     }
     for (var rp = 0; rp < relatedProductIds.length; rp++) {
       var relatedId = relatedProductIds[rp]
@@ -531,6 +471,31 @@ function buildEcommerceProduct(record, options) {
     (requiresVariantSelection !== 'true' || !variantsResolved || hasInStockCombination)
       ? 'true'
       : 'false'
+  // Aggregate review rating, from ONE batched COUNT/AVG over approved reviews
+  // that transformRecords runs for every product on the page (keyed by product
+  // id in options.ratingsByProductId).
+  //
+  // ⛔ An ABSENT entry and a NULL map both mean "no rating to show", never "0
+  // stars": a product nobody has reviewed and a product whose rating query
+  // failed must both render with no stars at all. "0.0 out of 5" is the single
+  // worst thing a storefront can say about a product by accident.
+  //
+  // MUST mirror buildProductRatingFields in the GUI's
+  // features/e-commerce/utils/product-ratings.ts.
+  var ratingsByProductId = options.ratingsByProductId || {}
+  var ratingFields = __prBuildRatingFields(id != null ? ratingsByProductId[id] : null)
+
+  // The individual reviews behind those stars, for the product page's JSON-LD.
+  // Fetched ONLY for a single-product request (see getTransformWrapperCode), so
+  // this is an empty array on every listing — which is correct: a listing emits
+  // no Product markup to put them in.
+  //
+  // Not rendered anywhere. That is why there is no canvas mirror for it: the
+  // three-mirror rule exists for fields the editor DRAWS, and structured data
+  // is a publish-time concern the canvas has no equivalent of.
+  var reviewsByProductId = options.reviewsByProductId || {}
+  var reviews = (id != null && reviewsByProductId[id]) || []
+
   // Stringified companions: a data-* attr bound to an ARRAY renders
   // '[object Object]', so the picker's on-mount/click workflows read the
   // combinations + axes from these JSON strings via getAttribute.
@@ -598,6 +563,22 @@ function buildEcommerceProduct(record, options) {
     originalDisplayPrice: originalDisplayPrice,
     originalDefaultVariantDisplayPrice: originalDefaultVariantDisplayPrice,
     hasPurchasableVariant: hasPurchasableVariant,
+    // Aggregate review rating — see the ratingFields block above.
+    ratingAverage: ratingFields.ratingAverage,
+    ratingCount: ratingFields.ratingCount,
+    ratingAverageLabel: ratingFields.ratingAverageLabel,
+    ratingCountLabel: ratingFields.ratingCountLabel,
+    hasRatings: ratingFields.hasRatings,
+    ratingStar1: ratingFields.ratingStar1,
+    ratingStar2: ratingFields.ratingStar2,
+    ratingStar3: ratingFields.ratingStar3,
+    ratingStar4: ratingFields.ratingStar4,
+    ratingStar5: ratingFields.ratingStar5,
+    // Domain-shaped, not schema.org-shaped: the head-config plugin's
+    // 'reviewList' computed kind does the vocabulary. NO BACKTICKS ANYWHERE IN
+    // THIS FILE — it is one template literal, and a backtick in a comment ends
+    // the string.
+    reviews: reviews,
   }
 }
 
@@ -871,6 +852,124 @@ async function getRelatedProductsMap(getClientFn, records) {
   return map
 }
 
+// Aggregate review rating for every product on the page, keyed by product id,
+// so a card can draw its star row without a query per product.
+//
+// APPROVED ONLY, and 'approved' is a fixed literal rather than a bound value
+// because nothing may ever widen it: a pending review is one the merchant has
+// not agreed to publish, and a rejected one is a review they actively removed.
+//
+// Unlike getVariantsMap this returns an EMPTY MAP on failure rather than null.
+// The two "unknown" answers differ because the consequences differ: an unknown
+// variant map must stay permissive (never make a catalogue unbuyable), whereas
+// an unknown rating has exactly one safe rendering — no stars — which is also
+// what a product with no reviews shows. Collapsing both onto {} means every
+// caller has one case to handle instead of two.
+async function getRatingsMap(getClientFn, productIds) {
+  var map = {}
+  if (!Array.isArray(productIds) || productIds.length === 0) return map
+  var uniqueIds = []
+  var seenIds = {}
+  for (var u = 0; u < productIds.length; u++) {
+    var pid0 = productIds[u]
+    if (pid0 != null && !seenIds[pid0]) { seenIds[pid0] = true; uniqueIds.push(pid0) }
+  }
+  if (uniqueIds.length === 0) return map
+  var client
+  try {
+    client = getClientFn()
+    await client.connect()
+    var result = await client.query(
+      "SELECT product_id, AVG(rating)::float AS average, COUNT(*)::int AS count " +
+        'FROM teleport_product_reviews ' +
+        "WHERE status = 'approved' AND rating IS NOT NULL AND product_id = ANY($1) " +
+        'GROUP BY product_id',
+      [uniqueIds]
+    )
+    if (result && result.rows) {
+      for (var r = 0; r < result.rows.length; r++) {
+        var row = result.rows[r]
+        if (row && row.product_id != null) {
+          map[row.product_id] = { average: row.average, count: row.count }
+        }
+      }
+    }
+  } catch (e) {
+    // teleport_product_reviews may not exist (reviews were never enabled), or
+    // the query may have failed. Either way there is no rating to show, which
+    // is exactly what an empty map produces.
+    map = {}
+  } finally {
+    if (client) {
+      try { await client.end() } catch (e) { /* ignore */ }
+    }
+  }
+  return map
+}
+
+// The most recent APPROVED reviews for a product, for the product page's
+// structured data. Keyed by product id like every other batched lookup, though
+// in practice it is only ever called with one id.
+//
+// Three filters, and each one exists because of what the output is used for:
+//  - APPROVED only, as a fixed literal, for the same reason the aggregate is:
+//    a pending review is one the merchant has not agreed to publish.
+//  - A NON-EMPTY reviewer name. Google requires author.name on a review
+//    snippet, and an anonymous row would produce a Review object it rejects —
+//    taking the whole Product block down with it on some validators.
+//  - A CAP. The reviews are inlined into the page's props and then into its
+//    HTML twice over (once as data, once as JSON-LD); a product with four
+//    hundred reviews would otherwise put all of them in both.
+async function getProductReviewsMap(getClientFn, productIds, perProduct) {
+  var map = {}
+  if (!Array.isArray(productIds) || productIds.length === 0) return map
+  var uniqueIds = []
+  var seenIds = {}
+  for (var u = 0; u < productIds.length; u++) {
+    var pid0 = productIds[u]
+    if (pid0 != null && !seenIds[pid0]) { seenIds[pid0] = true; uniqueIds.push(pid0) }
+  }
+  if (uniqueIds.length === 0) return map
+  var client
+  try {
+    client = getClientFn()
+    await client.connect()
+    var result = await client.query(
+      'SELECT product_id, reviewer_name, rating, content, created_at ' +
+        'FROM teleport_product_reviews ' +
+        "WHERE status = 'approved' AND rating IS NOT NULL " +
+        "AND reviewer_name IS NOT NULL AND btrim(reviewer_name) <> '' " +
+        'AND product_id = ANY($1) ' +
+        'ORDER BY created_at DESC',
+      [uniqueIds]
+    )
+    var cap = typeof perProduct === 'number' && perProduct > 0 ? perProduct : 5
+    if (result && result.rows) {
+      for (var r = 0; r < result.rows.length; r++) {
+        var row = result.rows[r]
+        if (!row || row.product_id == null) continue
+        var bucket = map[row.product_id] || (map[row.product_id] = [])
+        if (bucket.length >= cap) continue
+        bucket.push({
+          author: String(row.reviewer_name).trim(),
+          rating: Number(row.rating),
+          body: row.content == null ? '' : String(row.content),
+          datePublished: row.created_at ? new Date(row.created_at).toISOString() : null,
+        })
+      }
+    }
+  } catch (e) {
+    // The reviews table may not exist (reviews were never enabled). No reviews
+    // to show is both the empty answer and the safe one.
+    map = {}
+  } finally {
+    if (client) {
+      try { await client.end() } catch (e) { /* ignore */ }
+    }
+  }
+  return map
+}
+
 // Combinations for every product on the page, keyed by product id. Returns NULL
 // when the lookup could not run, which the transform reads as "unknown" and
 // stays permissive with; an empty map means the query ran and this catalogue

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
@@ -901,7 +901,7 @@ export const extractDataSourceIntoGetStaticProps = (
   dependencies: Record<string, any>,
   dynamicRouteAttr?: string,
   folderPath?: string[],
-  transformOptions: EcommerceProductTransformOptions = {}
+  transformOptions: EntityTransformOptions = {}
 ): { success: boolean; chunk?: any } => {
   try {
     // Validate node content