@teleporthq/teleport-plugin-next-data-source 0.42.3 → 0.42.5

package/src/pagination-plugin.ts

@@ -774,12 +774,95 @@ export const createNextArrayMapperPaginationPlugin: ComponentPluginFactory<{}> =
       )
     }
 
+    cleanupStaticDataProviders(blockStatement)
+
     return structure
   }
 
   return paginationPlugin
 }
 
+function cleanupStaticDataProviders(blockStatement: types.BlockStatement): void {
+  const findAllDataProviders = (node: any, results: any[] = []): any[] => {
+    if (!node) {
+      return results
+    }
+
+    if (node.type === 'JSXElement' && node.openingElement?.name?.name === 'DataProvider') {
+      results.push(node)
+    }
+
+    if (node.type === 'ReturnStatement' && node.argument) {
+      findAllDataProviders(node.argument, results)
+    } else if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
+      if (node.children && Array.isArray(node.children)) {
+        node.children.forEach((child: any) => findAllDataProviders(child, results))
+      }
+    } else if (node.type === 'JSXExpressionContainer') {
+      if (
+        node.expression &&
+        (node.expression.type === 'JSXElement' || node.expression.type === 'JSXFragment')
+      ) {
+        findAllDataProviders(node.expression, results)
+      }
+    } else if (node.type === 'BlockStatement') {
+      if (node.body && Array.isArray(node.body)) {
+        node.body.forEach((stmt: any) => findAllDataProviders(stmt, results))
+      }
+    } else if (node.type === 'ConditionalExpression') {
+      findAllDataProviders(node.consequent, results)
+      findAllDataProviders(node.alternate, results)
+    }
+
+    return results
+  }
+
+  const allDataProviders = findAllDataProviders(blockStatement)
+
+  allDataProviders.forEach((dataProvider) => {
+    const hasInitialData = dataProvider.openingElement.attributes.some(
+      (attr: any) => attr.type === 'JSXAttribute' && attr.name.name === 'initialData'
+    )
+    const hasFetchData = dataProvider.openingElement.attributes.some(
+      (attr: any) => attr.type === 'JSXAttribute' && attr.name.name === 'fetchData'
+    )
+    const paramsAttr = dataProvider.openingElement.attributes.find(
+      (attr: any) => attr.type === 'JSXAttribute' && attr.name.name === 'params'
+    )
+
+    // Case 1: Static SSR/SSG DataProviders (initialData, no fetchData, params)
+    // Remove params to prevent refetch attempts - data was already fetched in getStaticProps
+    if (hasInitialData && !hasFetchData && paramsAttr) {
+      dataProvider.openingElement.attributes = dataProvider.openingElement.attributes.filter(
+        (attr: any) => attr.type !== 'JSXAttribute' || attr.name.name !== 'params'
+      )
+    }
+
+    // Case 2: Client-side DataProviders with plain object params (fetchData, non-memoized params)
+    // Wrap params in useMemo to prevent infinite refetch loops
+    else if (hasFetchData && paramsAttr && paramsAttr.value?.type === 'JSXExpressionContainer') {
+      const paramsExpression = paramsAttr.value.expression
+
+      // Check if params are already memoized (useMemo or useCallback call)
+      const isAlreadyMemoized =
+        paramsExpression.type === 'CallExpression' &&
+        paramsExpression.callee.type === 'Identifier' &&
+        (paramsExpression.callee.name === 'useMemo' ||
+          paramsExpression.callee.name === 'useCallback')
+
+      // If params are a plain ObjectExpression, wrap in useMemo
+      if (!isAlreadyMemoized && paramsExpression.type === 'ObjectExpression') {
+        const memoizedParams = types.callExpression(types.identifier('useMemo'), [
+          types.arrowFunctionExpression([], paramsExpression),
+          types.arrayExpression([]), // Empty deps - params are static
+        ])
+
+        paramsAttr.value.expression = memoizedParams
+      }
+    }
+  })
+}
+
 function findParentNode(root: any, target: any, currentParent: any = null): any | null {
   if (!root || !target) {
     return null
@@ -1049,14 +1132,16 @@ function detectPaginationsAndSearchFromJSX(
     } | null = null
     let searchInputInfo: { class: string | null; jsx: any } | null = null
 
-    const findSearchAndPaginationInScope = (scopeNode: any, skipNode: any = null): void => {
+    const findSearchAndPaginationInScope = (scopeNode: any, skipNode: any = null): boolean => {
       if (!scopeNode || !scopeNode.children || !Array.isArray(scopeNode.children)) {
-        return
+        return false
       }
 
-      scopeNode.children.forEach((child: any) => {
+      let foundSomething = false
+
+      for (const child of scopeNode.children) {
         if (child === skipNode) {
-          return
+          continue
         }
 
         if (child.type === 'JSXElement') {
@@ -1073,13 +1158,14 @@ function detectPaginationsAndSearchFromJSX(
                 prevClass,
                 nextClass,
               }
+              foundSomething = true
             }
           }
 
           // Found search container - search for input inside it
           if (childClassName && childClassName.includes('data-source-search-node')) {
             if (child.children && Array.isArray(child.children)) {
-              child.children.forEach((searchChild: any) => {
+              for (const searchChild of child.children) {
                 if (searchChild.type === 'JSXElement') {
                   const searchChildElementName = searchChild.openingElement?.name?.name
                   const searchChildClassName = getClassName(
@@ -1094,9 +1180,10 @@ function detectPaginationsAndSearchFromJSX(
                       class: searchChildClassName,
                       jsx: searchChild,
                     }
+                    foundSomething = true
                   }
                 }
-              })
+              }
             }
           }
 
@@ -1110,13 +1197,24 @@ function detectPaginationsAndSearchFromJSX(
               class: childClassName,
               jsx: child,
             }
+            foundSomething = true
           }
 
+          // Stop searching if we found both or if we found what we're looking for
+          if (foundSomething && (searchInputInfo || paginationNodeInfo)) {
+            return true
+          }
+
+          // Only recurse if we haven't found what we're looking for yet
           if (!searchInputInfo || !paginationNodeInfo) {
-            findSearchAndPaginationInScope(child, skipNode)
+            if (findSearchAndPaginationInScope(child, skipNode)) {
+              return true
+            }
           }
         }
-      })
+      }
+
+      return foundSomething
     }
 
     let currentScope = parent
@@ -1124,7 +1222,11 @@ function detectPaginationsAndSearchFromJSX(
     const maxDepth = 5
 
     while (currentScope && (!searchInputInfo || !paginationNodeInfo) && depth < maxDepth) {
-      findSearchAndPaginationInScope(currentScope, depth === 0 ? dataProvider : null)
+      const found = findSearchAndPaginationInScope(currentScope, depth === 0 ? dataProvider : null)
+      // Stop searching up the tree if we found a pagination node at this level
+      if (found && paginationNodeInfo) {
+        break
+      }
       currentScope = findParentNode(blockStatement, currentScope)
       depth++
     }