@teleporthq/teleport-plugin-next-data-source 0.43.54 → 0.43.57

package/src/data-source-fetchers.ts

@@ -1,4 +1,4 @@
-import { DataSourceType, UIDLDataSource, UIDLEcommerceCategory } from '@teleporthq/teleport-types'
+import { DataSourceType, UIDLDataSource } from '@teleporthq/teleport-types'
 import {
   generatePostgreSQLFetcher,
   generateMySQLFetcher,
@@ -33,6 +33,9 @@ import {
 } from './fetchers'
 import { validateDatabaseConfig } from './validation'
 import { generateCountFetcher } from './count-fetchers'
+import type { EcommerceProductTransformOptions } from './transformations'
+import { DataCache } from '@teleporthq/teleport-shared'
+import type { DataSourceServerCacheOptions } from './cache/types'
 
 export { generateRawQueryFetcher, parseQueryTemplateVariables }
 
@@ -81,7 +84,7 @@ export const getDataSourceDependencies = (
 export function generateDataSourceFetcher(
   dataSource: UIDLDataSource,
   tableName: string,
-  categories?: UIDLEcommerceCategory[]
+  transformOptions: EcommerceProductTransformOptions = {}
 ): string {
   if (!dataSource || typeof dataSource !== 'object') {
     throw new Error('Invalid data source: data source must be a valid object')
@@ -237,7 +240,7 @@ export function generateDataSourceFetcher(
         if (!validation.isValid) {
           throw new Error(`Teleport config validation failed: ${validation.error}`)
         }
-        return generateTeleportFetcher(config, tableName, categories)
+        return generateTeleportFetcher(config, tableName, transformOptions)
       }
 
       default:
@@ -258,9 +261,10 @@ export function generateDataSourceFetcherWithCore(
   dataSource: UIDLDataSource,
   tableName: string,
   isApiRoute: boolean = false,
-  categories?: UIDLEcommerceCategory[]
+  transformOptions: EcommerceProductTransformOptions = {},
+  cacheOptions?: DataSourceServerCacheOptions
 ): string {
-  const apiHandler = generateDataSourceFetcher(dataSource, tableName, categories)
+  const apiHandler = generateDataSourceFetcher(dataSource, tableName, transformOptions)
 
   // Extract the handler function body from the API route
   // The API route is structured as: export default async function handler(req, res) { ... }
@@ -285,14 +289,64 @@ export function generateDataSourceFetcherWithCore(
   // Combine and deduplicate imports
   const allImports = Array.from(new Set([...imports, ...countImports]))
 
+  // Caching is applied HERE rather than in the API route because four separate
+  // places emit an `api/<file>` route and a fifth path (`getStaticProps` →
+  // `fetchData` → `handler`) never goes through a route at all. Wrapping the
+  // module's exports is the one point that covers all five, and leaves every
+  // route emitter untouched.
+  //
+  // The import depth differs by destination: this module is written to
+  // `utils/data-sources/` normally, but the `isApiRoute` variant is inlined
+  // straight into `pages/api/`.
+  const cachePreamble = cacheOptions
+    ? `import { tqWithCache } from '${isApiRoute ? '../../' : '../'}tq-cache/server'`
+    : ''
+
+  const cacheWiring = cacheOptions
+    ? `
+const __tqDataCache = ${JSON.stringify({
+        scope: cacheOptions.scope,
+        ttl: cacheOptions.ttlSeconds,
+        sMaxAge: cacheOptions.sMaxAge || 0,
+        swr: cacheOptions.staleWhileRevalidate || 0,
+      })}
+const __tqCountCache = ${JSON.stringify({
+        scope: DataCache.countScopeFor(cacheOptions.scope),
+        // Its OWN keyspace, but the DATA scope's version row. A write bumps one
+        // row; if the count kept a separate version nothing would ever bump it,
+        // and the total would stay stale after every create and delete — the
+        // grid showing one more row than the pager counts.
+        versionScope: cacheOptions.scope,
+        ttl: cacheOptions.ttlSeconds,
+        sMaxAge: cacheOptions.sMaxAge || 0,
+        swr: cacheOptions.staleWhileRevalidate || 0,
+      })}
+
+const cachedHandler = tqWithCache(handler, __tqDataCache)
+const cachedGetCount = tqWithCache(getCount, __tqCountCache)
+`
+    : ''
+
+  const handlerExport = cacheOptions ? 'cachedHandler' : 'handler'
+  const countExport = cacheOptions ? 'cachedGetCount' : 'getCount'
+
   // For API routes, export just the handler function
   // For utils files, export the full object with all functions
-  const exports = isApiRoute
-    ? 'export default handler'
-    : `export { fetchData, fetchCount, handler, getCount }
+  //
+  // The uncached branch is spelled out verbatim rather than interpolated, so an
+  // uncached project keeps generating byte-identical output — `handler as
+  // handler` would be harmless at runtime and still a diff in every snapshot.
+  const exports = !cacheOptions
+    ? isApiRoute
+      ? 'export default handler'
+      : `export { fetchData, fetchCount, handler, getCount }
 export default { fetchData, fetchCount, handler, getCount }`
+    : isApiRoute
+    ? `export default ${handlerExport}`
+    : `export { fetchData, fetchCount, ${handlerExport} as handler, ${countExport} as getCount }
+export default { fetchData, fetchCount, handler: ${handlerExport}, getCount: ${countExport} }`
 
-  return `${allImports.join('\n')}
+  return `${[...allImports, cachePreamble].filter(Boolean).join('\n')}
 
 async function fetchData(params = {}) {
   const req = {
@@ -314,7 +368,7 @@ async function fetchData(params = {}) {
     },
   }
   
-  await handler(req, res)
+  await ${handlerExport}(req, res)
   
   if (statusCode !== 200 || !result || !result.success) {
     throw new Error(result?.error || 'Failed to fetch data')
@@ -343,7 +397,7 @@ async function fetchCount(params = {}) {
     },
   }
   
-  await getCount(req, res)
+  await ${countExport}(req, res)
   
   if (statusCode !== 200 || !result || !result.success) {
     throw new Error(result?.error || 'Failed to get count')
@@ -355,7 +409,7 @@ async function fetchCount(params = {}) {
 ${countFetcherWithoutImports}
 
 ${handlerWithoutImports}
-
+${cacheWiring}
 ${exports}
 `
 }

package/src/fetchers/teleport.ts

@@ -1,4 +1,3 @@
-import type { UIDLEcommerceCategory } from '@teleporthq/teleport-types'
 import {
   replaceSecretReference,
   generateDateFormatterCode,
@@ -9,6 +8,7 @@ import {
   getTransformationCode,
   getTransformExpression,
   getTransformWrapperCode,
+  type EcommerceProductTransformOptions,
 } from '../transformations'
 
 interface TeleportDBConfig {
@@ -52,7 +52,7 @@ export const validateTeleportConfig = (
 export const generateTeleportFetcher = (
   config: Record<string, unknown>,
   tableName: string,
-  categories?: UIDLEcommerceCategory[]
+  transformOptions: EcommerceProductTransformOptions = {}
 ): string => {
   const dbConfig = config as TeleportDBConfig
   const schema = dbConfig.options?.schema
@@ -142,7 +142,7 @@ const getClient = () => {
 ${generateSafeJSONParseCode()}
 
 ${generateSearchEscapeHelpersCode()}
-${getTransformationCode(tableName, categories)}
+${getTransformationCode(tableName, transformOptions)}
 ${getTransformWrapperCode(tableName)}
 const processFilters = (filters, conditions, queryParams, paramIndex) => {
   if (!filters) return paramIndex

package/src/index.ts

@@ -14,6 +14,7 @@ import {
   hasUnresolvableDynamicParams,
 } from './utils'
 import { createNextArrayMapperPaginationPlugin } from './pagination-plugin'
+import { buildProductTransformOptions } from './transformations'
 import { DATA_SOURCE_ISR_REVALIDATE_SECONDS } from './isr'
 import * as types from '@babel/types'
 
@@ -608,7 +609,7 @@ export const createNextPagesDataSourcePlugin: ComponentPluginFactory<{}> = () =>
           dependencies,
           dynamicRouteAttr,
           uidl.outputOptions?.folderPath,
-          options.ecommerceSettings?.categories
+          buildProductTransformOptions(options)
         )
 
         if (result.success && result.chunk) {
@@ -646,7 +647,7 @@ export const createNextPagesDataSourcePlugin: ComponentPluginFactory<{}> = () =>
           dataSources,
           componentChunk,
           options.extractedResources,
-          options.ecommerceSettings?.categories
+          buildProductTransformOptions(options)
         )
       }
     })
@@ -1268,7 +1269,7 @@ export const createNextComponentDataSourcePlugin: ComponentPluginFactory<{}> = (
         dataSources,
         componentChunk,
         options.extractedResources,
-        options.ecommerceSettings?.categories
+        buildProductTransformOptions(options)
       )
     })
 
@@ -1354,7 +1355,7 @@ export const createNextComponentDataSourcePlugin: ComponentPluginFactory<{}> = (
               dataSource,
               firstDataSourceInfo.tableName,
               false,
-              options.ecommerceSettings?.categories
+              buildProductTransformOptions(options)
             )
             options.extractedResources[`utils/${fileName}`] = {
               fileName,
@@ -1398,3 +1399,8 @@ export * from './utils'
 export * from './array-mapper-pagination'
 export * from './pagination-plugin'
 export * from './count-fetchers'
+// The product transform's build-time options (category taxonomy + storefront
+// tax rate) — every package that emits a data-source fetcher has to derive
+// them the same way.
+export { buildProductTransformOptions } from './transformations'
+export type { EcommerceProductTransformOptions } from './transformations'

package/src/loading-state.ts

@@ -1,4 +1,5 @@
 import * as types from '@babel/types'
+import { findCachedFetchNetworkChain } from './cache/ast'
 
 /**
  * ------------------------------------------------------------------
@@ -137,17 +138,79 @@ export function applyLoadingStateToDataProvider(
   }
 
   const fetchArrow = findMemoizedFetchDataArrow(fetchDataAttr)
-  if (!fetchArrow || fetchArrow.body.type !== 'CallExpression') {
+  if (!fetchArrow) {
     return false
   }
 
-  fetchArrow.body = buildTrackedFetchBody(fetchArrow.body, vars)
+  if (fetchArrow.body.type === 'CallExpression') {
+    fetchArrow.body = buildTrackedFetchBody(fetchArrow.body, vars)
+  } else if (fetchArrow.body.type === 'BlockStatement') {
+    if (!injectTrackingIntoCachedBody(fetchArrow.body, vars)) {
+      return false
+    }
+  } else {
+    return false
+  }
 
   setPersistDataDuringLoading(attributes, vars)
 
   return true
 }
 
+/**
+ * Adds the in-flight bookkeeping to a CACHED `fetchData` body.
+ *
+ * The body already returns early with `Promise.resolve(hit)` on a cache hit, so
+ * the tracking is attached to the network chain BELOW that — never to the early
+ * return. That is the whole point: a hit must not raise `isFetching`, because
+ * `persistDataDuringLoading={!isFetching}` would then drop the provider into its
+ * loading slot for a frame and produce exactly the skeleton flash the cache
+ * exists to remove.
+ *
+ * Returns `false` when the body is not the shape this module knows how to wrap,
+ * so the caller emits no state declarations rather than half-wiring it.
+ */
+function injectTrackingIntoCachedBody(body: types.BlockStatement, vars: LoadingStateVars): boolean {
+  // Idempotent: a second pass over the same AST must not double-count.
+  if (containsIdentifier(body, vars.setIsFetchingVar)) {
+    return false
+  }
+
+  const networkChain = findCachedFetchNetworkChain(body)
+  if (!networkChain) {
+    return false
+  }
+
+  const tracked = buildTrackedFetchBody(networkChain.statement.argument as types.Expression, vars)
+  body.body.splice(networkChain.index, 1, ...tracked.body)
+
+  return true
+}
+
+// tslint:disable-next-line:no-any
+function containsIdentifier(node: any, name: string): boolean {
+  if (!node || typeof node !== 'object') {
+    return false
+  }
+  if (node.type === 'Identifier' && node.name === name) {
+    return true
+  }
+  for (const key of Object.keys(node)) {
+    if (key === 'loc' || key === 'start' || key === 'end') {
+      continue
+    }
+    const value = node[key]
+    if (Array.isArray(value)) {
+      if (value.some((entry) => containsIdentifier(entry, name))) {
+        return true
+      }
+    } else if (value && typeof value === 'object' && containsIdentifier(value, name)) {
+      return true
+    }
+  }
+  return false
+}
+
 // tslint:disable-next-line:no-any
 function findAttribute(attributes: any[], name: string): types.JSXAttribute | undefined {
   return attributes.find(