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

package/src/count-effect.ts

@@ -0,0 +1,137 @@
+import * as types from '@babel/types'
+
+/**
+ * The client-side "how many rows match?" fetch that drives `ds_N_maxPages`.
+ *
+ * One builder for every caller, because the two hand-written copies had already
+ * drifted: the search-enabled list sent the query, the columns and the filters,
+ * while the paginated-only list fetched a bare `/api/<file>-count` with NO
+ * params at all — so a filtered list counted the WHOLE table and "Next" stayed
+ * enabled long past the end of the filtered results.
+ *
+ * The endpoint deliberately receives no `sorts` and no `limit`: ordering cannot
+ * change how many rows match, and a limit would count the page rather than the
+ * result set.
+ */
+
+interface CountEffectOptions {
+  /** `<fileName>-count` is the generated API route. */
+  fileName: string
+  /** Divisor for the page count; the mapper's resolved `perPage`. */
+  perPage: number
+  /** Name of the `setDs_N_maxPages` setter. */
+  setMaxPagesVar: string
+  /**
+   * Params sent to the count endpoint: the search query (when the list has
+   * one), `queryColumns`, and the filter array. Built by the caller because
+   * only it knows how this usage's filter destinations resolve to expressions.
+   */
+  urlParams: types.ObjectProperty[]
+  /** Dependencies that should re-run the count. */
+  deps: types.Expression[]
+}
+
+/**
+ * `data.count === 0 ? 0 : Math.ceil(data.count / perPage)`
+ *
+ * Zero is special-cased rather than left to `Math.ceil(0 / n)` so the intent —
+ * "no results at all", which numbered pagination renders as an empty strip — is
+ * visible in the generated code.
+ */
+const buildMaxPagesExpression = (perPage: number): types.Expression =>
+  types.conditionalExpression(
+    types.binaryExpression(
+      '===',
+      types.memberExpression(types.identifier('data'), types.identifier('count')),
+      types.numericLiteral(0)
+    ),
+    types.numericLiteral(0),
+    types.callExpression(
+      types.memberExpression(types.identifier('Math'), types.identifier('ceil')),
+      [
+        types.binaryExpression(
+          '/',
+          types.memberExpression(types.identifier('data'), types.identifier('count')),
+          types.numericLiteral(perPage)
+        ),
+      ]
+    )
+  )
+
+export const buildCountFetchStatement = (
+  options: Pick<CountEffectOptions, 'fileName' | 'perPage' | 'setMaxPagesVar' | 'urlParams'>
+): types.Statement =>
+  types.expressionStatement(
+    types.callExpression(
+      types.memberExpression(
+        types.callExpression(
+          types.memberExpression(
+            types.callExpression(types.identifier('fetch'), [
+              types.templateLiteral(
+                [
+                  types.templateElement({
+                    raw: `/api/${options.fileName}-count?`,
+                    cooked: `/api/${options.fileName}-count?`,
+                  }),
+                  types.templateElement({ raw: '', cooked: '' }),
+                ],
+                [
+                  types.newExpression(types.identifier('URLSearchParams'), [
+                    types.objectExpression(options.urlParams),
+                  ]),
+                ]
+              ),
+            ]),
+            types.identifier('then')
+          ),
+          [
+            types.arrowFunctionExpression(
+              [types.identifier('res')],
+              types.callExpression(
+                types.memberExpression(types.identifier('res'), types.identifier('json')),
+                []
+              )
+            ),
+          ]
+        ),
+        types.identifier('then')
+      ),
+      [
+        types.arrowFunctionExpression(
+          [types.identifier('data')],
+          types.blockStatement([
+            types.ifStatement(
+              types.logicalExpression(
+                '&&',
+                types.identifier('data'),
+                types.binaryExpression('in', types.stringLiteral('count'), types.identifier('data'))
+              ),
+              types.blockStatement([
+                types.expressionStatement(
+                  types.callExpression(types.identifier(options.setMaxPagesVar), [
+                    buildMaxPagesExpression(options.perPage),
+                  ])
+                ),
+              ])
+            ),
+          ])
+        ),
+      ]
+    )
+  )
+
+/**
+ * The whole `useEffect(...)` wrapper.
+ *
+ * ⛔ No skip-on-mount guard, on purpose: a page seeds `maxPages` from the
+ * build-time `getStaticProps` count, and that snapshot goes stale the moment
+ * rows are added after the build — leaving "Next" disabled on a list that has
+ * grown. Re-counting on mount is what corrects it.
+ */
+export const buildCountFetchEffect = (options: CountEffectOptions): types.ExpressionStatement =>
+  types.expressionStatement(
+    types.callExpression(types.identifier('useEffect'), [
+      types.arrowFunctionExpression([], types.blockStatement([buildCountFetchStatement(options)])),
+      types.arrayExpression(options.deps),
+    ])
+  )

package/src/fetchers/postgresql.ts

@@ -4,6 +4,11 @@ import {
   generateSafeJSONParseCode,
   generateSearchEscapeHelpersCode,
 } from '../utils'
+import {
+  generateSortFallbackFieldHelper,
+  generateSortFieldSqlHelper,
+  generateSortTiebreakSql,
+} from '../product-price-sort'
 
 interface PostgreSQLConfig {
   connectionString?: string
@@ -134,6 +139,10 @@ const processFilters = (filters, conditions, queryParams, paramIndex) => {
 
 ${generateDateFormatterCode()}
 
+${generateSortFieldSqlHelper(tableName)}
+
+${generateSortFallbackFieldHelper(tableName)}
+
 export default async function handler(req, res) {
   const client = getClient()
   
@@ -198,36 +207,66 @@ export default async function handler(req, res) {
       sql += \` WHERE \${conditions.join(' AND ')}\`
     }
     
-    // Handle sorts - new array format
+    // Handle sorts - new array format. Two ORDER BY clauses are built: the one
+    // actually used, and a plain-column twin kept only as the fallback below.
+    let orderBySql = ''
+    let plainOrderBySql = ''
     if (sorts) {
       const parsedSorts = safeJSONParse(sorts)
       if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
-        const orderClauses = parsedSorts.map((sort) => {
-          if (!sort.field) return null
-          const order = (sort.order || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'
-          return \`\${sort.field} \${order}\`
-        }).filter(Boolean)
+        const valid = parsedSorts.filter((sort) => sort && sort.field)
+        const orderOf = (sort) => (sort.order || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'
+        const orderClauses = valid.map((sort) => \`\${sortFieldSql(sort.field)} \${orderOf(sort)}\`)
+        const plainClauses = valid.map((sort) => \`\${sortFallbackField(sort.field)} \${orderOf(sort)}\`)
 
         if (orderClauses.length > 0) {
-          sql += \` ORDER BY \${orderClauses.join(', ')}\`
+          // A deterministic tiebreaker keeps pagination stable: "sort by
+          // discount" ties every undiscounted product at zero, and equal rows
+          // with no defined order can repeat across pages or vanish between them.
+          orderBySql = \` ORDER BY \${orderClauses.join(', ')}${generateSortTiebreakSql(
+            tableName
+          )}\`
+          plainOrderBySql = \` ORDER BY \${plainClauses.join(', ')}${generateSortTiebreakSql(
+            tableName
+          )}\`
         }
       }
     } else if (sortBy) {
-      sql += \` ORDER BY \${sortBy} \${(sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'}\`
+      orderBySql = \` ORDER BY \${sortBy} \${(sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'}\`
+      plainOrderBySql = orderBySql
     }
-    
+    const usedDiscountAwareSort = orderBySql !== plainOrderBySql
+
     const limitValue = limit || perPage
     const offsetValue = offset !== undefined ? parseInt(offset) : (page && perPage ? (parseInt(page) - 1) * parseInt(perPage) : undefined)
-    
+
+    let sqlTail = ''
     if (limitValue) {
-      sql += \` LIMIT \${limitValue}\`
+      sqlTail += \` LIMIT \${limitValue}\`
     }
     
     if (offsetValue !== undefined) {
-      sql += \` OFFSET \${offsetValue}\`
+      sqlTail += \` OFFSET \${offsetValue}\`
     }
+
+    const baseSql = sql
+    sql = baseSql + orderBySql + sqlTail
     
-    const result = await client.query(sql, queryParams)
+    // The discount-aware price ordering is an inline sub-select over a JSON
+    // column. It is written to be unraisable, but it runs inside ORDER BY for
+    // the whole table — so if a database ever rejects it, fall back to ordering
+    // by the stored list price rather than serving an empty products page.
+    let result
+    try {
+      result = await client.query(sql, queryParams)
+    } catch (sortError) {
+      if (!usedDiscountAwareSort) throw sortError
+      console.warn(
+        'Discount-aware price sort failed; falling back to the list price:',
+        sortError && sortError.message
+      )
+      result = await client.query(baseSql + plainOrderBySql + sqlTail, queryParams)
+    }
     const rows = Array.isArray(result?.rows) ? result.rows : []
     const plainRows = rows.map((row) =>
       row && typeof row.toJSON === 'function' ? row.toJSON() : row

package/src/fetchers/teleport.ts

@@ -10,6 +10,11 @@ import {
   getTransformWrapperCode,
   type EcommerceProductTransformOptions,
 } from '../transformations'
+import {
+  generateSortFallbackFieldHelper,
+  generateSortFieldSqlHelper,
+  generateSortTiebreakSql,
+} from '../product-price-sort'
 
 interface TeleportDBConfig {
   host?: string
@@ -221,6 +226,10 @@ const processFilters = (filters, conditions, queryParams, paramIndex) => {
 
 ${generateDateFormatterCode()}
 
+${generateSortFieldSqlHelper(tableName)}
+
+${generateSortFallbackFieldHelper(tableName)}
+
 // Matches DDL / dangerous statements the raw-query branch should refuse.
 // Keep this list conservative — anything destructive or schema-changing is
 // out of scope for a client-triggered fetch. SELECT and CTEs (WITH ...) are
@@ -346,35 +355,66 @@ export default async function handler(req, res) {
       sql += \` WHERE \${conditions.join(' AND ')}\`
     }
     
+    // Handle sorts - new array format. Two ORDER BY clauses are built: the one
+    // actually used, and a plain-column twin kept only as the fallback below.
+    let orderBySql = ''
+    let plainOrderBySql = ''
     if (sorts) {
       const parsedSorts = safeJSONParse(sorts)
       if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {
-        const orderClauses = parsedSorts.map((sort) => {
-          if (!sort.field) return null
-          const order = (sort.order || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'
-          return \`\${sort.field} \${order}\`
-        }).filter(Boolean)
+        const valid = parsedSorts.filter((sort) => sort && sort.field)
+        const orderOf = (sort) => (sort.order || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'
+        const orderClauses = valid.map((sort) => \`\${sortFieldSql(sort.field)} \${orderOf(sort)}\`)
+        const plainClauses = valid.map((sort) => \`\${sortFallbackField(sort.field)} \${orderOf(sort)}\`)
 
         if (orderClauses.length > 0) {
-          sql += \` ORDER BY \${orderClauses.join(', ')}\`
+          // A deterministic tiebreaker keeps pagination stable: "sort by
+          // discount" ties every undiscounted product at zero, and equal rows
+          // with no defined order can repeat across pages or vanish between them.
+          orderBySql = \` ORDER BY \${orderClauses.join(', ')}${generateSortTiebreakSql(
+            tableName
+          )}\`
+          plainOrderBySql = \` ORDER BY \${plainClauses.join(', ')}${generateSortTiebreakSql(
+            tableName
+          )}\`
         }
       }
     } else if (sortBy) {
-      sql += \` ORDER BY \${sortBy} \${(sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'}\`
+      orderBySql = \` ORDER BY \${sortBy} \${(sortOrder || '').toUpperCase().startsWith('DESC') ? 'DESC' : 'ASC'}\`
+      plainOrderBySql = orderBySql
     }
-    
+    const usedDiscountAwareSort = orderBySql !== plainOrderBySql
+
     const limitValue = limit || perPage
     const offsetValue = offset !== undefined ? parseInt(offset) : (page && perPage ? (parseInt(page) - 1) * parseInt(perPage) : undefined)
-    
+
+    let sqlTail = ''
     if (limitValue) {
-      sql += \` LIMIT \${limitValue}\`
+      sqlTail += \` LIMIT \${limitValue}\`
     }
     
     if (offsetValue !== undefined) {
-      sql += \` OFFSET \${offsetValue}\`
+      sqlTail += \` OFFSET \${offsetValue}\`
+    }
+
+    const baseSql = sql
+    sql = baseSql + orderBySql + sqlTail
+
+    // The discount-aware price ordering is an inline sub-select over a JSON
+    // column. It is written to be unraisable, but it runs inside ORDER BY for
+    // the whole table - so if a database ever rejects it, fall back to ordering
+    // by the stored list price rather than serving an empty products page.
+    let result
+    try {
+      result = await client.query(sql, queryParams)
+    } catch (sortError) {
+      if (!usedDiscountAwareSort) throw sortError
+      console.warn(
+        'Discount-aware price sort failed; falling back to the list price:',
+        sortError && sortError.message
+      )
+      result = await client.query(baseSql + plainOrderBySql + sqlTail, queryParams)
     }
-    
-    const result = await client.query(sql, queryParams)
     const rows = Array.isArray(result?.rows) ? result.rows : []
     const plainRows = rows.map((row) =>
       row && typeof row.toJSON === 'function' ? row.toJSON() : row