@teleporthq/teleport-plugin-next-data-source 0.42.35 → 0.43.0

package/src/transformations/shared-utils.ts

@@ -0,0 +1,271 @@
+/**
+ * Generates JavaScript code for shared data transformation utilities.
+ * These are included in the generated data source fetcher files
+ * when the table requires blog post or e-commerce product transformations.
+ */
+export const generateSharedTransformationCode = (): string => {
+  return `
+// ============================================================
+// Shared Data Transformation Utilities
+// ============================================================
+
+var CURRENCY_SYMBOLS = {
+  USD: { symbol: '$', position: 'before' },
+  EUR: { symbol: '€', position: 'before' },
+  GBP: { symbol: '£', position: 'before' },
+  JPY: { symbol: '¥', position: 'before' },
+  CAD: { symbol: 'C$', position: 'before' },
+  AUD: { symbol: 'A$', position: 'before' },
+  CHF: { symbol: 'CHF', position: 'before' },
+  CNY: { symbol: '¥', position: 'before' },
+  INR: { symbol: '₹', position: 'before' },
+  BRL: { symbol: 'R$', position: 'before' },
+  MXN: { symbol: 'MX$', position: 'before' },
+  KRW: { symbol: '₩', position: 'before' },
+  SGD: { symbol: 'S$', position: 'before' },
+  HKD: { symbol: 'HK$', position: 'before' },
+  NOK: { symbol: 'kr', position: 'after' },
+  SEK: { symbol: 'kr', position: 'after' },
+  DKK: { symbol: 'kr', position: 'after' },
+  PLN: { symbol: 'zł', position: 'after' },
+  CZK: { symbol: 'Kč', position: 'after' },
+  HUF: { symbol: 'Ft', position: 'after' },
+  RON: { symbol: 'lei', position: 'after' },
+  TRY: { symbol: '₺', position: 'before' },
+  THB: { symbol: '฿', position: 'before' },
+  IDR: { symbol: 'Rp', position: 'before' },
+  PHP: { symbol: '₱', position: 'before' },
+  ZAR: { symbol: 'R', position: 'before' },
+  RUB: { symbol: '₽', position: 'after' },
+  NZD: { symbol: 'NZ$', position: 'before' },
+  TWD: { symbol: 'NT$', position: 'before' },
+  ILS: { symbol: '₪', position: 'before' },
+  AED: { symbol: 'د.إ', position: 'before' },
+  SAR: { symbol: '﷼', position: 'before' },
+  MYR: { symbol: 'RM', position: 'before' },
+  VND: { symbol: '₫', position: 'after' },
+  CLP: { symbol: '$', position: 'before' },
+  COP: { symbol: '$', position: 'before' },
+  ARS: { symbol: '$', position: 'before' },
+  PEN: { symbol: 'S/', position: 'before' },
+  UAH: { symbol: '₴', position: 'after' },
+  BGN: { symbol: 'лв', position: 'after' },
+  HRK: { symbol: 'kn', position: 'after' },
+  ISK: { symbol: 'kr', position: 'after' },
+  NGN: { symbol: '₦', position: 'before' },
+  KES: { symbol: 'KSh', position: 'before' },
+  EGP: { symbol: 'E£', position: 'before' },
+  PKR: { symbol: '₨', position: 'before' },
+  BDT: { symbol: '৳', position: 'before' },
+  LKR: { symbol: '₨', position: 'before' },
+  GHS: { symbol: 'GH₵', position: 'before' },
+}
+
+function getCurrencyInfo(currencyCode) {
+  if (!currencyCode) return { symbol: '$', position: 'before' }
+  var upper = currencyCode.toUpperCase()
+  var entry = CURRENCY_SYMBOLS[upper]
+  return entry || { symbol: upper, position: 'before' }
+}
+
+function getCurrencySymbol(currencyCode) {
+  return getCurrencyInfo(currencyCode).symbol
+}
+
+function normalizeTimestamp(value) {
+  if (value == null) return Date.now()
+  if (typeof value === 'number') {
+    if (isNaN(value)) return Date.now()
+    return value < 100000000000 ? value * 1000 : value
+  }
+  if (typeof value === 'string') {
+    var parsed = Date.parse(value)
+    return isNaN(parsed) ? Date.now() : parsed
+  }
+  return Date.now()
+}
+
+function safeNumber(value, defaultValue) {
+  if (value == null) return defaultValue
+  var n = Number(value)
+  return isNaN(n) ? defaultValue : n
+}
+
+function parseJsonArray(value) {
+  if (!value) return []
+  if (Array.isArray(value)) return value.filter(function(item) { return typeof item === 'string' })
+  if (typeof value === 'string') {
+    try {
+      var parsed = JSON.parse(value)
+      if (Array.isArray(parsed)) return parsed.filter(function(item) { return typeof item === 'string' })
+      return []
+    } catch (e) {
+      return value.split(',').map(function(s) { return s.trim() }).filter(Boolean)
+    }
+  }
+  return []
+}
+
+function parseJsonObject(value) {
+  if (value == null) return {}
+  if (typeof value === 'object' && !Array.isArray(value)) return value
+  if (typeof value === 'string') {
+    try {
+      var parsed = JSON.parse(value)
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed
+      return {}
+    } catch (e) {
+      return {}
+    }
+  }
+  return {}
+}
+
+var HTML_ENTITY_MAP = {
+  '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"',
+  '&#39;': "'", '&#x27;': "'", '&apos;': "'", '&nbsp;': ' ',
+  '&#160;': ' ', '&copy;': '©', '&reg;': '®', '&trade;': '™',
+  '&hellip;': '…', '&mdash;': '—', '&ndash;': '–',
+}
+
+function decodeHtmlEntities(str) {
+  if (!str) return str
+  // Decode named and numeric entities
+  return str
+    .replace(/&(?:#x([0-9a-fA-F]+)|#([0-9]+)|([a-zA-Z]+));/g, function(match, hex, dec, named) {
+      if (hex) return String.fromCharCode(parseInt(hex, 16))
+      if (dec) return String.fromCharCode(parseInt(dec, 10))
+      var namedRef = '&' + named + ';'
+      return HTML_ENTITY_MAP[namedRef] || match
+    })
+}
+
+function stripHtmlTags(html) {
+  if (!html || typeof html !== 'string') return ''
+  // Remove script and style blocks entirely (including content)
+  var cleaned = html
+    .replace(/<script[\\s\\S]*?<\\/script>/gi, ' ')
+    .replace(/<style[\\s\\S]*?<\\/style>/gi, ' ')
+  // Strip remaining tags
+  cleaned = cleaned.replace(/<[^>]*>/g, ' ')
+  // Decode HTML entities
+  cleaned = decodeHtmlEntities(cleaned)
+  // Collapse whitespace
+  return cleaned.replace(/\\s+/g, ' ').trim()
+}
+
+function coerceBoolean(value, defaultValue) {
+  if (value === true || value === 'true' || value === 1 || value === '1') return true
+  if (value === false || value === 'false' || value === 0 || value === '0') return false
+  return defaultValue
+}
+
+function pickFirst() {
+  for (var i = 0; i < arguments.length; i++) {
+    var val = arguments[i]
+    if (val !== undefined && val !== null) return val
+  }
+  return null
+}
+
+function resolveI18nField(record, snakeCol, camelCol, currentLang, mainLang) {
+  if (currentLang && mainLang && currentLang !== mainLang) {
+    // Try language-prefixed snake_case column first, then camelCase
+    var langSnakeKey = currentLang + '_' + snakeCol
+    if (record[langSnakeKey] !== undefined && record[langSnakeKey] !== null && record[langSnakeKey] !== '') {
+      return record[langSnakeKey]
+    }
+    if (snakeCol !== camelCol) {
+      var langCamelKey = currentLang + '_' + camelCol
+      if (record[langCamelKey] !== undefined && record[langCamelKey] !== null && record[langCamelKey] !== '') {
+        return record[langCamelKey]
+      }
+    }
+  }
+  if (record[snakeCol] !== undefined && record[snakeCol] !== null) return record[snakeCol]
+  if (snakeCol !== camelCol && record[camelCol] !== undefined && record[camelCol] !== null) return record[camelCol]
+  return null
+}
+
+// Asset URL Resolution with TTL-based caching
+var __assetUrlCache = {}
+var __assetMapCache = null
+var __assetMapTimestamp = 0
+var ASSET_CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
+
+function isUrl(value) {
+  if (!value || typeof value !== 'string') return false
+  return value.startsWith('http://') || value.startsWith('https://') || value.startsWith('data:')
+}
+
+function resolveAssetUrl(value, assetMap) {
+  if (!value || typeof value !== 'string') return null
+  if (isUrl(value)) return value
+  // Also treat absolute paths (starting with /) as URLs
+  if (value.charAt(0) === '/') return value
+  if (__assetUrlCache[value]) return __assetUrlCache[value]
+  if (assetMap && assetMap[value]) {
+    var asset = assetMap[value]
+    var resolved = asset.remoteSrc || asset.imageSrc || asset.src || asset.url || value
+    __assetUrlCache[value] = resolved
+    return resolved
+  }
+  // Not found in asset map - return as-is (might already be a usable reference)
+  return value
+}
+
+function resolveAssetUrls(values, assetMap) {
+  if (!Array.isArray(values)) return []
+  return values
+    .map(function(v) { return resolveAssetUrl(v, assetMap) })
+    .filter(function(v) { return v != null && typeof v === 'string' })
+}
+
+function deduplicateStrings(arr) {
+  var seen = {}
+  return arr.filter(function(v) {
+    if (!v || typeof v !== 'string' || seen[v]) return false
+    seen[v] = true
+    return true
+  })
+}
+
+// Fetches the asset map from the database if available, with TTL-based caching
+async function getAssetMap(getClientFn) {
+  var now = Date.now()
+  if (__assetMapCache && (now - __assetMapTimestamp) < ASSET_CACHE_TTL_MS) {
+    return __assetMapCache
+  }
+  // Reset per-URL cache when asset map is refreshed
+  __assetUrlCache = {}
+  var map = {}
+  var client
+  try {
+    client = getClientFn()
+    await client.connect()
+    var result = await client.query('SELECT id, src, remote_src, image_src, url FROM teleport_assets')
+    if (result && result.rows) {
+      result.rows.forEach(function(row) {
+        map[row.id] = {
+          src: row.src || null,
+          remoteSrc: row.remote_src || null,
+          imageSrc: row.image_src || null,
+          url: row.url || null,
+        }
+      })
+    }
+    __assetMapCache = map
+    __assetMapTimestamp = now
+  } catch (e) {
+    // teleport_assets table may not exist - cache empty map with short TTL
+    __assetMapCache = map
+    __assetMapTimestamp = now
+  } finally {
+    if (client) {
+      try { await client.end() } catch (e) { /* ignore */ }
+    }
+  }
+  return map
+}
+`
+}

package/src/utils.ts

@@ -15,6 +15,7 @@ import { generateDataSourceFetcherWithCore } from './data-source-fetchers'
 
 const VALID_DATA_SOURCE_TYPES: DataSourceType[] = [
   'rest-api',
+  'teleport',
   'postgresql',
   'mysql',
   'mariadb',
@@ -31,7 +32,6 @@ const VALID_DATA_SOURCE_TYPES: DataSourceType[] = [
   'javascript',
   'google-sheets',
   'csv-file',
-  'static-collection',
 ]
 
 export const sanitizeFileName = (input: string): string => {
@@ -460,7 +460,7 @@ export default dataSourceModule.handler
 }
 
 export const isEmbeddedDataSource = (dataSourceType: string): boolean => {
-  return ['javascript', 'csv-file', 'static-collection'].includes(dataSourceType)
+  return ['javascript', 'csv-file'].includes(dataSourceType)
 }
 
 export const replaceSecretReference = (
@@ -510,6 +510,41 @@ export const replaceSecretReference = (
   }
 }
 
+/**
+ * Emit runtime helpers that every SQL-based fetcher needs to safely
+ * apply the `{ query, queryColumns }` search contract:
+ *
+ *   - `SEARCH_LIKE_ESCAPE_CHAR` — the char we register via `ESCAPE '|'`
+ *     in LIKE / ILIKE expressions. `|` is not special in any SQL
+ *     dialect's string-literal grammar, so the emitted SQL parses
+ *     unambiguously across Postgres, MySQL (regardless of
+ *     `NO_BACKSLASH_ESCAPES`), and SQLite.
+ *
+ *   - `escapeLikePattern(term)` — prefixes `|` to `|`, `%`, `_` so a
+ *     user typing `50%` matches a literal `%` rather than any-chars.
+ *
+ *   - `sanitizeSearchIdentifier(name)` — validates column identifiers
+ *     against `[A-Za-z_][A-Za-z0-9_]*` and throws on anything else. The
+ *     caller is responsible for wrapping in the dialect's quote chars.
+ *
+ * Kept as a single snippet so every fetcher imports the exact same
+ * contract and the canvas preview (data-fetcher-worker /
+ * database-provider-worker) and the generated Next.js app emit
+ * byte-identical search SQL.
+ */
+export const generateSearchEscapeHelpersCode = (): string => {
+  return `const SEARCH_LIKE_ESCAPE_CHAR = '|'
+const escapeLikePattern = (term) => {
+  return String(term == null ? '' : term).replace(/[|%_]/g, (m) => SEARCH_LIKE_ESCAPE_CHAR + m)
+}
+const sanitizeSearchIdentifier = (name) => {
+  if (typeof name !== 'string' || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new Error('Invalid search column identifier: ' + String(name))
+  }
+  return name
+}`
+}
+
 export const generateSafeJSONParseCode = (): string => {
   return `const safeJSONParse = (value) => {
   if (!value) return value
@@ -706,6 +741,147 @@ export const sanitizeIdentifier = (identifier: unknown): string => {
   return identifier.replace(/[^a-zA-Z0-9_-]/g, '').substring(0, 64)
 }
 
+/**
+ * Checks if a dynamic param is resolvable from the route's dynamic attribute
+ * (i.e. available via context.params in getStaticProps/getServerSideProps).
+ */
+const isDynamicParamRouteResolvable = (
+  param: { type: string; content?: { referenceType?: string; id?: string } },
+  dynamicRouteAttr: string
+): boolean => {
+  if (param.type !== 'dynamic') {
+    return false
+  }
+  return param.content?.referenceType === 'prop' && param.content?.id === dynamicRouteAttr
+}
+
+/**
+ * Checks if a filter destination (within a static filters array) is resolvable
+ * from the route's dynamic attribute.
+ */
+const isFilterDestinationRouteResolvable = (
+  destination: unknown,
+  dynamicRouteAttr: string
+): boolean => {
+  if (!ASTUtils.isUIDLDynamicReference(destination)) {
+    return false
+  }
+  const content = (destination as { content: { referenceType: string; id: string } }).content
+  return content.referenceType === 'prop' && content.id === dynamicRouteAttr
+}
+
+/**
+ * Determines if any resource params have dynamic values that cannot be resolved
+ * server-side. Params whose dynamic references match the page's dynamicRouteAttribute
+ * can be resolved from context.params and are NOT considered unresolvable.
+ */
+// tslint:disable-next-line:no-any
+export const hasUnresolvableDynamicParams = (
+  params: Record<string, any>,
+  dynamicRouteAttr?: string
+): boolean => {
+  return Object.values(params).some((param: any) => {
+    if (param.type === 'expr') {
+      return true
+    }
+
+    if (param.type === 'dynamic') {
+      if (dynamicRouteAttr && isDynamicParamRouteResolvable(param, dynamicRouteAttr)) {
+        return false
+      }
+      return true
+    }
+
+    if (param.type === 'static' && Array.isArray(param.content)) {
+      const hasDynamicDestinations = param.content.some(
+        (item: any) =>
+          item && typeof item === 'object' && ASTUtils.isUIDLDynamicReference(item?.destination)
+      )
+
+      if (hasDynamicDestinations && dynamicRouteAttr) {
+        const allResolvable = param.content.every((item: any) => {
+          if (!item || typeof item !== 'object') {
+            return true
+          }
+          if (!ASTUtils.isUIDLDynamicReference(item.destination)) {
+            return true
+          }
+          return isFilterDestinationRouteResolvable(item.destination, dynamicRouteAttr)
+        })
+        return !allResolvable
+      }
+
+      return hasDynamicDestinations
+    }
+
+    return false
+  })
+}
+
+const isValidJSIdentifier = (name: string): boolean => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)
+
+/**
+ * Generates context.params.attr or context.params['attr'] depending on
+ * whether the attribute name is a valid JS identifier.
+ */
+const createContextParamsAccess = (attr: string): types.MemberExpression => {
+  const contextParams = types.memberExpression(
+    types.identifier('context'),
+    types.identifier('params')
+  )
+  return isValidJSIdentifier(attr)
+    ? types.memberExpression(contextParams, types.identifier(attr))
+    : types.memberExpression(contextParams, types.stringLiteral(attr), true)
+}
+
+/**
+ * Builds an AST ObjectExpression for a filter item, resolving dynamic destinations
+ * that reference the route attribute to context.params[attr].
+ */
+const buildFilterObjectAST = (
+  filterItem: Record<string, unknown>,
+  dynamicRouteAttr?: string
+): types.ObjectExpression => {
+  const properties: types.ObjectProperty[] = []
+
+  for (const [key, value] of Object.entries(filterItem)) {
+    if (value === undefined) {
+      continue
+    }
+
+    if (key === 'destination' && dynamicRouteAttr && ASTUtils.isUIDLDynamicReference(value)) {
+      const content = (value as { content: { id: string } }).content
+      properties.push(
+        types.objectProperty(types.stringLiteral(key), createContextParamsAccess(content.id))
+      )
+    } else if (typeof value === 'string') {
+      properties.push(types.objectProperty(types.stringLiteral(key), types.stringLiteral(value)))
+    } else if (typeof value === 'number') {
+      properties.push(types.objectProperty(types.stringLiteral(key), types.numericLiteral(value)))
+    } else if (typeof value === 'boolean') {
+      properties.push(types.objectProperty(types.stringLiteral(key), types.booleanLiteral(value)))
+    } else if (value === null) {
+      properties.push(types.objectProperty(types.stringLiteral(key), types.nullLiteral()))
+    } else if (Array.isArray(value)) {
+      properties.push(
+        types.objectProperty(
+          types.stringLiteral(key),
+          types.arrayExpression(value.map((v) => ASTUtils.convertValueToLiteral(v)))
+        )
+      )
+    } else if (typeof value === 'object') {
+      properties.push(
+        types.objectProperty(
+          types.stringLiteral(key),
+          ASTUtils.objectToObjectExpression(value as Record<string, unknown>)
+        )
+      )
+    }
+  }
+
+  return types.objectExpression(properties)
+}
+
 // tslint:disable-next-line:no-any
 export const extractDataSourceIntoGetStaticProps = (
   node: UIDLDataSourceItemNode | UIDLDataSourceListNode,
@@ -714,7 +890,9 @@ export const extractDataSourceIntoGetStaticProps = (
   getStaticPropsChunk: any,
   chunks: any[],
   extractedResources: GeneratorOptions['extractedResources'],
-  dependencies: Record<string, any>
+  dependencies: Record<string, any>,
+  dynamicRouteAttr?: string,
+  folderPath?: string[]
 ): { success: boolean; chunk?: any } => {
   try {
     // Validate node content
@@ -1061,9 +1239,16 @@ export const extractDataSourceIntoGetStaticProps = (
 
     // Add dependency for the fetcher
     const fetcherImportName = StringUtils.dashCaseToCamelCase(fileName)
+    // Calculate the correct relative path based on page folder depth.
+    // folderPath contains subfolders within pages/ (e.g. ['admin'] for pages/admin/X.js).
+    // We add 1 for the pages/ directory itself.
+    // Pages at pages/X.js (folderPath=[]) need '../' (1 level up)
+    // Pages at pages/admin/X.js (folderPath=['admin']) need '../../' (2 levels up)
+    const depth = (folderPath ? folderPath.length : 0) + 1
+    const relativePrefix = '../'.repeat(depth)
     dependencies[fetcherImportName] = {
       type: 'local',
-      path: `../utils/data-sources/${fileName}`,
+      path: `${relativePrefix}utils/data-sources/${fileName}`,
     }
 
     // Build params object from resource params
@@ -1092,18 +1277,34 @@ export const extractDataSourceIntoGetStaticProps = (
 
           // For sorts, filters, and queryColumns, stringify the array for consistency with API handler
           if (key === 'sorts' || key === 'filters' || key === 'queryColumns') {
-            // For filters, filter out items with dynamic destinations (can't be resolved at build time)
             let itemsToProcess = validItems
             if (key === 'filters') {
-              itemsToProcess = validItems.filter(
-                (item: any) => !ASTUtils.isUIDLDynamicReference(item?.destination)
-              )
-              // Skip entirely if no static filters remain
+              // Keep filter items that are either static or route-resolvable (via dynamicRouteAttr)
+              // Filter out items with unresolvable dynamic destinations
+              itemsToProcess = validItems.filter((item: any) => {
+                if (!ASTUtils.isUIDLDynamicReference(item?.destination)) {
+                  return true
+                }
+                if (dynamicRouteAttr) {
+                  return isFilterDestinationRouteResolvable(item.destination, dynamicRouteAttr)
+                }
+                return false
+              })
               if (itemsToProcess.length === 0) {
                 return
               }
             }
 
+            const hasRouteResolvableFilters =
+              key === 'filters' &&
+              dynamicRouteAttr &&
+              itemsToProcess.some(
+                (item: any) =>
+                  item &&
+                  typeof item === 'object' &&
+                  ASTUtils.isUIDLDynamicReference(item?.destination)
+              )
+
             const arrayExpr = types.arrayExpression(
               itemsToProcess.map((item: any) => {
                 if (typeof item === 'string') {
@@ -1116,6 +1317,12 @@ export const extractDataSourceIntoGetStaticProps = (
                   return types.booleanLiteral(item)
                 }
                 if (typeof item === 'object' && item !== null) {
+                  if (
+                    hasRouteResolvableFilters &&
+                    ASTUtils.isUIDLDynamicReference(item?.destination)
+                  ) {
+                    return buildFilterObjectAST(item, dynamicRouteAttr)
+                  }
                   return ASTUtils.objectToObjectExpression(item)
                 }
                 return types.nullLiteral()
@@ -1159,9 +1366,18 @@ export const extractDataSourceIntoGetStaticProps = (
         }
 
         paramsProperties.push(types.objectProperty(types.stringLiteral(key), astValue))
+      } else if (
+        value.type === 'dynamic' &&
+        dynamicRouteAttr &&
+        isDynamicParamRouteResolvable(value, dynamicRouteAttr)
+      ) {
+        paramsProperties.push(
+          types.objectProperty(
+            types.stringLiteral(key),
+            createContextParamsAccess(value.content.id)
+          )
+        )
       }
-      // Note: We don't handle 'expr' or 'dynamic' params in getStaticProps
-      // as those should be detected by hasResourceDynamicParams check earlier
     })
 
     const fetchCallExpression = types.callExpression(

package/dist/cjs/fetchers/static-collection.d.ts

@@ -1,7 +0,0 @@
-export declare const validateStaticCollectionConfig: (config: Record<string, unknown>) => {
-    isValid: boolean;
-    error?: string;
-};
-export declare const generateStaticCollectionFetcher: (config: Record<string, unknown>) => string;
-export declare const generateStaticCollectionCountFetcher: (_config: any) => string;
-//# sourceMappingURL=static-collection.d.ts.map

package/dist/cjs/fetchers/static-collection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"static-collection.d.ts","sourceRoot":"","sources":["../../../src/fetchers/static-collection.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,8BAA8B,WACjC,OAAO,MAAM,EAAE,OAAO,CAAC,KAC9B;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAUpC,CAAA;AAMD,eAAO,MAAM,+BAA+B,WAAY,OAAO,MAAM,EAAE,OAAO,CAAC,KAAG,MA4JjF,CAAA;AAGD,eAAO,MAAM,oCAAoC,YAAa,GAAG,KAAG,MA+CnE,CAAA"}

package/dist/cjs/fetchers/static-collection.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStaticCollectionCountFetcher = exports.generateStaticCollectionFetcher = exports.validateStaticCollectionConfig = void 0;
-var utils_1 = require("../utils");
-var validateStaticCollectionConfig = function (config) {
-    if (!config || typeof config !== 'object') {
-        return { isValid: false, error: 'Config must be a valid object' };
-    }
-    if (!config.data || !Array.isArray(config.data)) {
-        return { isValid: false, error: 'Data must be an array' };
-    }
-    return { isValid: true };
-};
-exports.validateStaticCollectionConfig = validateStaticCollectionConfig;
-var generateStaticCollectionFetcher = function (config) {
-    var staticConfig = config;
-    return "const data = ".concat(JSON.stringify(staticConfig.data || []), "\n\n").concat((0, utils_1.generateSafeJSONParseCode)(), "\n\n").concat((0, utils_1.generateDateFormatterCode)(), "\n\n").concat((0, utils_1.generateSortFilterHelperCode)(), "\n\nexport default async function handler(req, res) {\n  try {\n    const { query, queryColumns, limit, page, perPage, sortBy, sortOrder, filters, sorts, offset: offsetParam } = req.query\n    \n    let filteredData = [...data]\n    \n    if (query) {\n      const searchQuery = query.toLowerCase()\n      \n      if (queryColumns) {\n        const columns = safeJSONParse(queryColumns)\n        filteredData = filteredData.filter((item) => {\n          return columns.some((col) => {\n            const value = getNestedValue(item, col)\n            return value && String(value).toLowerCase().includes(searchQuery)\n          })\n        })\n      } else {\n        filteredData = filteredData.filter((item) => {\n          try {\n            const stringified = JSON.stringify(item).toLowerCase()\n            return stringified.includes(searchQuery)\n          } catch {\n            return false\n          }\n        })\n      }\n    }\n    \n    if (filters) {\n      const parsedFilters = safeJSONParse(filters)\n      \n      if (Array.isArray(parsedFilters)) {\n        filteredData = filteredData.filter((item) => {\n          return parsedFilters.every((filter) => {\n            if (!filter.source || filter.destination === undefined) return true\n            \n            const field = filter.source\n            const value = getNestedValue(item, field)\n            const target = filter.destination\n            const operand = filter.operand || '='\n            \n            if (Array.isArray(target)) {\n              if (operand === '!=') {\n                return !target.includes(value)\n              }\n              return target.includes(value)\n            }\n            \n            return compareValues(value, target, operand)\n          })\n        })\n      } else {\n        filteredData = filteredData.filter((item) => {\n          return Object.entries(parsedFilters).every(([key, value]) => {\n            const itemValue = getNestedValue(item, key)\n            if (Array.isArray(value)) {\n              return value.includes(itemValue)\n            }\n            return compareValues(itemValue, value, '=')\n          })\n        })\n      }\n    }\n    \n    if (sorts) {\n      const parsedSorts = safeJSONParse(sorts)\n      if (Array.isArray(parsedSorts) && parsedSorts.length > 0) {\n        filteredData.sort((a, b) => {\n          for (const sort of parsedSorts) {\n            if (!sort.field) continue\n            const aVal = getNestedValue(a, sort.field)\n            const bVal = getNestedValue(b, sort.field)\n            const sortOrderValue = sort.order?.toLowerCase() === 'desc' ? -1 : 1\n            \n            let comparison = 0\n            if (aVal === null || aVal === undefined) {\n              comparison = bVal === null || bVal === undefined ? 0 : -1\n            } else if (bVal === null || bVal === undefined) {\n              comparison = 1\n            } else if (typeof aVal === 'number' && typeof bVal === 'number') {\n              comparison = aVal - bVal\n            } else if (aVal instanceof Date && bVal instanceof Date) {\n              comparison = aVal.getTime() - bVal.getTime()\n            } else {\n              const aStr = String(aVal)\n              const bStr = String(bVal)\n              if (aStr < bStr) comparison = -1\n              else if (aStr > bStr) comparison = 1\n            }\n            \n            if (comparison !== 0) return comparison * sortOrderValue\n          }\n          return 0\n        })\n      }\n    } else if (sortBy) {\n      filteredData.sort((a, b) => {\n        const aVal = getNestedValue(a, sortBy)\n        const bVal = getNestedValue(b, sortBy)\n        const sortOrderValue = sortOrder?.toLowerCase() === 'desc' ? -1 : 1\n        \n        let comparison = 0\n        if (aVal === null || aVal === undefined) {\n          comparison = bVal === null || bVal === undefined ? 0 : -1\n        } else if (bVal === null || bVal === undefined) {\n          comparison = 1\n        } else if (typeof aVal === 'number' && typeof bVal === 'number') {\n          comparison = aVal - bVal\n        } else if (aVal instanceof Date && bVal instanceof Date) {\n          comparison = aVal.getTime() - bVal.getTime()\n        } else {\n          const aStr = String(aVal)\n          const bStr = String(bVal)\n          if (aStr < bStr) comparison = -1\n          else if (aStr > bStr) comparison = 1\n        }\n        \n        return comparison * sortOrderValue\n      })\n    }\n    \n    const limitValue = limit || perPage\n    const offsetValue = offsetParam !== undefined ? parseInt(offsetParam) : (page && perPage ? (parseInt(page) - 1) * parseInt(perPage) : 0)\n    \n    if (limitValue) {\n      filteredData = filteredData.slice(offsetValue, offsetValue + parseInt(limitValue))\n    }\n    \n    const safeData = JSON.parse(JSON.stringify(filteredData, dateReplacer))\n    \n    return res.status(200).json({\n      success: true,\n      data: safeData,\n      timestamp: Date.now()\n    })\n  } catch (error) {\n    console.error('Static collection fetch error:', error)\n    return res.status(500).json({\n      success: false,\n      error: error.message || 'Failed to fetch data',\n      timestamp: Date.now()\n    })\n  }\n}\n");
-};
-exports.generateStaticCollectionFetcher = generateStaticCollectionFetcher;
-// tslint:disable-next-line:variable-name
-var generateStaticCollectionCountFetcher = function (_config) {
-    return "\nasync function getCount(req, res) {\n  try {\n    const { query, queryColumns, filters } = req.query\n    const fakeReq = { query: { query, queryColumns, filters }, method: 'GET' }\n    let result = null\n    let statusCode = 200\n    \n    const fakeRes = {\n      status: (code) => {\n        statusCode = code\n        return fakeRes\n      },\n      json: (data) => {\n        result = data\n        return fakeRes\n      },\n    }\n    \n    await handler(fakeReq, fakeRes)\n    \n    if (statusCode !== 200 || !result || !result.success) {\n      return res.status(500).json({\n        success: false,\n        error: 'Failed to get data for counting',\n        timestamp: Date.now()\n      })\n    }\n    \n    const count = Array.isArray(result.data) ? result.data.length : 0\n    \n    return res.status(200).json({\n      success: true,\n      count: count,\n      timestamp: Date.now()\n    })\n  } catch (error) {\n    console.error('Error getting count:', error)\n    return res.status(500).json({\n      success: false,\n      error: error.message || 'Failed to get count',\n      timestamp: Date.now()\n    })\n  }\n}\n";
-};
-exports.generateStaticCollectionCountFetcher = generateStaticCollectionCountFetcher;
-//# sourceMappingURL=static-collection.js.map

package/dist/cjs/fetchers/static-collection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"static-collection.js","sourceRoot":"","sources":["../../../src/fetchers/static-collection.ts"],"names":[],"mappings":";;;AAAA,kCAIiB;AAEV,IAAM,8BAA8B,GAAG,UAC5C,MAA+B;IAE/B,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;QACzC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,+BAA+B,EAAE,CAAA;KAClE;IAED,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;QAC/C,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,uBAAuB,EAAE,CAAA;KAC1D;IAED,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA;AAC1B,CAAC,CAAA;AAZY,QAAA,8BAA8B,kCAY1C;AAMM,IAAM,+BAA+B,GAAG,UAAC,MAA+B;IAC7E,IAAM,YAAY,GAAG,MAAgC,CAAA;IACrD,OAAO,uBAAgB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,IAAI,EAAE,CAAC,iBAE9D,IAAA,iCAAyB,GAAE,iBAE3B,IAAA,iCAAyB,GAAE,iBAE3B,IAAA,oCAA4B,GAAE,ypKAmJ/B,CAAA;AACD,CAAC,CAAA;AA5JY,QAAA,+BAA+B,mCA4J3C;AAED,yCAAyC;AAClC,IAAM,oCAAoC,GAAG,UAAC,OAAY;IAC/D,OAAO,knCA6CR,CAAA;AACD,CAAC,CAAA;AA/CY,QAAA,oCAAoC,wCA+ChD"}

package/dist/esm/fetchers/static-collection.d.ts

@@ -1,7 +0,0 @@
-export declare const validateStaticCollectionConfig: (config: Record<string, unknown>) => {
-    isValid: boolean;
-    error?: string;
-};
-export declare const generateStaticCollectionFetcher: (config: Record<string, unknown>) => string;
-export declare const generateStaticCollectionCountFetcher: (_config: any) => string;
-//# sourceMappingURL=static-collection.d.ts.map

package/dist/esm/fetchers/static-collection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"static-collection.d.ts","sourceRoot":"","sources":["../../../src/fetchers/static-collection.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,8BAA8B,WACjC,OAAO,MAAM,EAAE,OAAO,CAAC,KAC9B;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAUpC,CAAA;AAMD,eAAO,MAAM,+BAA+B,WAAY,OAAO,MAAM,EAAE,OAAO,CAAC,KAAG,MA4JjF,CAAA;AAGD,eAAO,MAAM,oCAAoC,YAAa,GAAG,KAAG,MA+CnE,CAAA"}