@teleporthq/teleport-plugin-next-workflows 0.43.1

package/src/nodes/utility/utility-anonymize-data.ts

@@ -0,0 +1,175 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function utility_anonymize_data(config: any, context: Record<string, unknown>) {
+  const data = config.data
+  const fields = config.fields || []
+  const strategy = config.strategy || 'mask'
+  const fieldStrategies = config.fieldStrategies || {}
+
+  if (data === undefined || data === null) {
+    return { result: null, error: 'No data provided' }
+  }
+
+  try {
+    let result = JSON.parse(JSON.stringify(data))
+
+    function anonymizeValue(val: any, strat: string): any {
+      if (val === null || val === undefined) {
+        return val
+      }
+      const strVal = String(val)
+
+      switch (strat) {
+        case 'mask': {
+          if (strVal.indexOf('@') !== -1) {
+            const atIndex = strVal.indexOf('@')
+            const local = strVal.substring(0, atIndex)
+            const domain = strVal.substring(atIndex)
+            if (local.length <= 2) {
+              return '**' + domain
+            }
+            return (
+              local.charAt(0) +
+              new Array(local.length - 1).join('*') +
+              local.charAt(local.length - 1) +
+              domain
+            )
+          }
+          if (/^\+?[\d\s\-\(\)\.]{7,}$/.test(strVal)) {
+            const digits = strVal.replace(/[^\d]/g, '')
+            if (digits.length >= 4) {
+              return (
+                strVal.substring(0, strVal.length - 4).replace(/\d/g, '*') +
+                strVal.substring(strVal.length - 4)
+              )
+            }
+          }
+          if (strVal.length <= 2) {
+            return '**'
+          }
+          return (
+            strVal.charAt(0) +
+            new Array(strVal.length - 1).join('*') +
+            strVal.charAt(strVal.length - 1)
+          )
+        }
+        case 'redact':
+          return '[REDACTED]'
+        case 'hash': {
+          let hash = 5381
+          const uint32mod = 0x100000000
+          for (let i = 0; i < strVal.length; i++) {
+            hash = hash * 32 + hash + strVal.charCodeAt(i)
+            hash = ((hash % uint32mod) + uint32mod) % uint32mod
+          }
+          return 'anon_' + Math.abs(hash).toString(16)
+        }
+        case 'randomize': {
+          if (typeof val === 'number') {
+            const magnitude = Math.pow(10, Math.floor(Math.log10(Math.abs(val) || 1)))
+            return Math.floor(Math.random() * 9 * magnitude + magnitude)
+          }
+          const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
+          let randomized = ''
+          for (let r = 0; r < strVal.length; r++) {
+            randomized += chars.charAt(Math.floor(Math.random() * chars.length))
+          }
+          return randomized
+        }
+        case 'remove':
+          return undefined
+        case 'partial-mask': {
+          if (strVal.length <= 4) {
+            return '****'
+          }
+          const visibleCount = Math.max(1, Math.floor(strVal.length / 4))
+          return (
+            strVal.substring(0, visibleCount) +
+            new Array(strVal.length - visibleCount * 2 + 1).join('*') +
+            strVal.substring(strVal.length - visibleCount)
+          )
+        }
+        case 'generalize': {
+          if (typeof val === 'number') {
+            const bucket = Math.pow(10, Math.floor(Math.log10(Math.abs(val) || 1)))
+            return (
+              Math.floor(val / bucket) * bucket +
+              '-' +
+              (Math.floor(val / bucket) * bucket + bucket - 1)
+            )
+          }
+          return strVal.charAt(0) + '***'
+        }
+        case 'nullify':
+          return null
+        default:
+          return '[ANONYMIZED]'
+      }
+    }
+
+    function anonymizeObject(
+      obj: any,
+      fieldList: string[],
+      defaultStrat: string,
+      perFieldStrats: Record<string, string>
+    ): any {
+      if (typeof obj !== 'object' || obj === null) {
+        return obj
+      }
+
+      if (Array.isArray(obj)) {
+        for (let ai = 0; ai < obj.length; ai++) {
+          obj[ai] = anonymizeObject(obj[ai], fieldList, defaultStrat, perFieldStrats)
+        }
+        return obj
+      }
+
+      const keys = Object.keys(obj)
+      for (let k = 0; k < keys.length; k++) {
+        let shouldAnonymize = false
+        if (fieldList.length === 0) {
+          shouldAnonymize = false
+        } else {
+          for (let f = 0; f < fieldList.length; f++) {
+            if (keys[k] === fieldList[f]) {
+              shouldAnonymize = true
+              break
+            }
+            if (fieldList[f].indexOf('.') !== -1) {
+              const pathParts = fieldList[f].split('.')
+              if (pathParts[pathParts.length - 1] === keys[k]) {
+                shouldAnonymize = true
+                break
+              }
+            }
+          }
+        }
+
+        if (shouldAnonymize) {
+          const fieldStrat = perFieldStrats[keys[k]] || defaultStrat
+          const anonVal = anonymizeValue(obj[keys[k]], fieldStrat)
+          if (anonVal === undefined) {
+            delete obj[keys[k]]
+          } else {
+            obj[keys[k]] = anonVal
+          }
+        } else if (typeof obj[keys[k]] === 'object' && obj[keys[k]] !== null) {
+          obj[keys[k]] = anonymizeObject(obj[keys[k]], fieldList, defaultStrat, perFieldStrats)
+        }
+      }
+      return obj
+    }
+
+    result = anonymizeObject(result, fields, strategy, fieldStrategies)
+    return { result }
+  } catch (err: unknown) {
+    return { result: null, error: (err as Error).message }
+  }
+}
+export const utilityAnonymizeData: NodeHandlerGenerator = {
+  nodeType: 'utility-anonymize-data',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(utility_anonymize_data)
+  },
+}

package/src/nodes/utility/utility-barcode-generate.ts

@@ -0,0 +1,83 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function utility_barcode_generate(config: any, context: Record<string, unknown>) {
+  const data = config.data || ''
+  const format = config.format || 'code128'
+  const scale = config.scale !== undefined ? Number(config.scale) : 3
+  const height = config.height !== undefined ? Number(config.height) : 10
+  const includeText = config.includeText !== undefined ? config.includeText : true
+  const textAlign = config.textAlign || 'center'
+  const textSize = config.textSize !== undefined ? Number(config.textSize) : 10
+  const foreground = config.foreground || '000000'
+  const background = config.background || 'FFFFFF'
+  const rotate = config.rotate || 'N'
+
+  if (!data) {
+    return { imageUrl: null, imageData: null, error: 'No data provided for barcode generation' }
+  }
+
+  const formatMap: Record<string, string> = {
+    code128: 'code128',
+    CODE128: 'code128',
+    code39: 'code39',
+    CODE39: 'code39',
+    ean13: 'ean13',
+    EAN13: 'ean13',
+    ean8: 'ean8',
+    EAN8: 'ean8',
+    upca: 'upca',
+    'UPC-A': 'upca',
+    upce: 'upce',
+    'UPC-E': 'upce',
+    itf14: 'itf14',
+    ITF14: 'itf14',
+    itf: 'interleaved2of5',
+    ITF: 'interleaved2of5',
+    msi: 'msi',
+    MSI: 'msi',
+    pharmacode: 'pharmacode',
+    codabar: 'rationalizedCodabar',
+    datamatrix: 'datamatrix',
+    pdf417: 'pdf417',
+    azteccode: 'azteccode',
+    qrcode: 'qrcode',
+  }
+
+  try {
+    const bwipjs = require('bwip-js')
+    const bcid = formatMap[format] || format.toLowerCase()
+
+    const opts: Record<string, any> = {
+      bcid,
+      text: String(data),
+      scale,
+      height,
+      rotate,
+      backgroundcolor: background,
+      barcolor: foreground,
+    }
+
+    if (includeText) {
+      opts.alttext = String(data)
+      opts.textalign = textAlign
+      opts.textsize = textSize
+    }
+
+    const png = await bwipjs.toBuffer(opts)
+    const imageData = 'data:image/png;base64,' + png.toString('base64')
+
+    return { imageUrl: null, imageData }
+  } catch (err: unknown) {
+    return { imageUrl: null, imageData: null, error: (err as Error).message }
+  }
+}
+export const utilityBarcodeGenerate: NodeHandlerGenerator = {
+  nodeType: 'utility-barcode-generate',
+  executionEnv: 'server',
+  dependencies: {
+    'bwip-js': '^4.1.0',
+  },
+  generateHandler(): string {
+    return handlerToString(utility_barcode_generate)
+  },
+}

package/src/nodes/utility/utility-csv-parse.ts

@@ -0,0 +1,317 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function utility_csv_parse(config: any, context: Record<string, unknown>) {
+  const operation = config.operation || 'parse'
+  let data = config.data || ''
+  let delimiter = config.delimiter || ','
+  const hasHeaders = config.hasHeaders !== undefined ? config.hasHeaders : true
+  const trimFields = config.trimFields !== undefined ? config.trimFields : true
+  const skipEmpty = config.skipEmpty !== undefined ? config.skipEmpty : true
+
+  if (operation === 'generate') {
+    const genRows = config.rows || []
+    const columns = config.columns || null
+    const includeHeaders = config.includeHeaders !== undefined ? config.includeHeaders : true
+    const quoteAll = config.quoteAll !== undefined ? config.quoteAll : false
+    const lineEnding = config.lineEnding || '\n'
+
+    try {
+      if (!genRows || genRows.length === 0) {
+        return { csv: '', rowCount: 0, headers: [] }
+      }
+
+      let headers: string[] = []
+      const isObjects = typeof genRows[0] === 'object' && !Array.isArray(genRows[0])
+
+      if (isObjects) {
+        if (columns && columns.length > 0) {
+          headers = columns
+        } else {
+          const keySet: Record<string, boolean> = {}
+          for (let ki = 0; ki < genRows.length; ki++) {
+            const objKeys = Object.keys(genRows[ki])
+            for (let kj = 0; kj < objKeys.length; kj++) {
+              keySet[objKeys[kj]] = true
+            }
+          }
+          headers = Object.keys(keySet)
+        }
+      } else if (columns && columns.length > 0) {
+        headers = columns
+      }
+
+      function escapeField(value: any): string {
+        const str = value === null || value === undefined ? '' : String(value)
+        let needsQuote = quoteAll
+        if (!needsQuote) {
+          for (let ei = 0; ei < str.length; ei++) {
+            const ec = str.charAt(ei)
+            if (ec === delimiter || ec === '"' || ec === '\n' || ec === '\r') {
+              needsQuote = true
+              break
+            }
+          }
+        }
+        if (needsQuote) {
+          let escaped = ''
+          for (let ej = 0; ej < str.length; ej++) {
+            const esc = str.charAt(ej)
+            if (esc === '"') {
+              escaped += '""'
+            } else {
+              escaped += esc
+            }
+          }
+          return '"' + escaped + '"'
+        }
+        return str
+      }
+
+      const csvLines: string[] = []
+
+      if (includeHeaders && headers.length > 0) {
+        let headerLine = ''
+        for (let hi = 0; hi < headers.length; hi++) {
+          if (hi > 0) {
+            headerLine += delimiter
+          }
+          headerLine += escapeField(headers[hi])
+        }
+        csvLines.push(headerLine)
+      }
+
+      for (let ri = 0; ri < genRows.length; ri++) {
+        const row = genRows[ri]
+        let line = ''
+        if (isObjects) {
+          for (let fi = 0; fi < headers.length; fi++) {
+            if (fi > 0) {
+              line += delimiter
+            }
+            line += escapeField(row[headers[fi]])
+          }
+        } else if (Array.isArray(row)) {
+          for (let ai = 0; ai < row.length; ai++) {
+            if (ai > 0) {
+              line += delimiter
+            }
+            line += escapeField(row[ai])
+          }
+        } else {
+          line += escapeField(row)
+        }
+        csvLines.push(line)
+      }
+
+      let csv = ''
+      for (let li = 0; li < csvLines.length; li++) {
+        if (li > 0) {
+          csv += lineEnding
+        }
+        csv += csvLines[li]
+      }
+
+      return { csv, rowCount: genRows.length, headers }
+    } catch (err: unknown) {
+      return { csv: '', rowCount: 0, headers: [], error: (err as Error).message }
+    }
+  }
+
+  if (operation === 'auto-detect') {
+    const detectDelimiters = [',', ';', '\t', '|']
+    const sampleLines: string[] = []
+    let sampleCurrent = ''
+    let sampleCount = 0
+
+    for (let si = 0; si < data.length && sampleCount < 5; si++) {
+      const sch = data.charAt(si)
+      if (sch === '\n' || sch === '\r') {
+        sampleLines.push(sampleCurrent)
+        sampleCurrent = ''
+        sampleCount++
+        if (sch === '\r' && si + 1 < data.length && data.charAt(si + 1) === '\n') {
+          si++
+        }
+      } else {
+        sampleCurrent += sch
+      }
+    }
+    if (sampleCurrent.length > 0 && sampleCount < 5) {
+      sampleLines.push(sampleCurrent)
+    }
+
+    let bestDelimiter = ','
+    let bestScore = -1
+
+    for (let di = 0; di < detectDelimiters.length; di++) {
+      const testDelim = detectDelimiters[di]
+      const counts: number[] = []
+      for (let dli = 0; dli < sampleLines.length; dli++) {
+        let cnt = 0
+        for (let dci = 0; dci < sampleLines[dli].length; dci++) {
+          if (sampleLines[dli].charAt(dci) === testDelim) {
+            cnt++
+          }
+        }
+        counts.push(cnt)
+      }
+
+      if (counts.length === 0) {
+        continue
+      }
+
+      let allZero = true
+      for (let zi = 0; zi < counts.length; zi++) {
+        if (counts[zi] > 0) {
+          allZero = false
+          break
+        }
+      }
+      if (allZero) {
+        continue
+      }
+
+      let sum = 0
+      for (let smi = 0; smi < counts.length; smi++) {
+        sum += counts[smi]
+      }
+      const avg = sum / counts.length
+
+      let variance = 0
+      for (let vi = 0; vi < counts.length; vi++) {
+        const diff = counts[vi] - avg
+        variance += diff * diff
+      }
+      variance = variance / counts.length
+
+      const consistency = avg / (1 + variance)
+
+      if (consistency > bestScore) {
+        bestScore = consistency
+        bestDelimiter = testDelim
+      }
+    }
+
+    delimiter = bestDelimiter
+  }
+
+  if (operation === 'parse' || operation === 'auto-detect') {
+    if (!data) {
+      return { rows: [], headers: [], rowCount: 0 }
+    }
+
+    try {
+      if (data.charCodeAt(0) === 0xfeff) {
+        data = data.substring(1)
+      }
+
+      const lines: string[] = []
+      let current = ''
+      let inQuotes = false
+
+      for (let ci = 0; ci < data.length; ci++) {
+        const ch = data.charAt(ci)
+        if (ch === '"') {
+          current += ch
+          if (inQuotes && ci + 1 < data.length && data.charAt(ci + 1) === '"') {
+            current += '"'
+            ci++
+          } else {
+            inQuotes = !inQuotes
+          }
+        } else if ((ch === '\n' || ch === '\r') && !inQuotes) {
+          lines.push(current)
+          current = ''
+          if (ch === '\r' && ci + 1 < data.length && data.charAt(ci + 1) === '\n') {
+            ci++
+          }
+        } else {
+          current += ch
+        }
+      }
+      if (current.length > 0 || lines.length > 0) {
+        lines.push(current)
+      }
+
+      function parseLine(line: string): string[] {
+        const fields: string[] = []
+        let field = ''
+        let inQ = false
+        for (let pi = 0; pi < line.length; pi++) {
+          const pc = line.charAt(pi)
+          if (pc === '"') {
+            if (inQ && pi + 1 < line.length && line.charAt(pi + 1) === '"') {
+              field += '"'
+              pi++
+            } else {
+              inQ = !inQ
+            }
+          } else if (pc === delimiter && !inQ) {
+            fields.push(trimFields ? field.trim() : field)
+            field = ''
+          } else {
+            field += pc
+          }
+        }
+        fields.push(trimFields ? field.trim() : field)
+        return fields
+      }
+
+      function isEmptyLine(line: string): boolean {
+        for (let i = 0; i < line.length; i++) {
+          const c = line.charAt(i)
+          if (c !== ' ' && c !== '\t' && c !== '\r') {
+            return false
+          }
+        }
+        return true
+      }
+
+      let headers: string[] = []
+      const rows: any[] = []
+
+      if (hasHeaders && lines.length > 0) {
+        headers = parseLine(lines[0])
+        for (let hi = 1; hi < lines.length; hi++) {
+          if (skipEmpty && isEmptyLine(lines[hi])) {
+            continue
+          }
+          const values = parseLine(lines[hi])
+          const parseRow: Record<string, string> = {}
+          for (let hj = 0; hj < headers.length; hj++) {
+            parseRow[headers[hj]] = hj < values.length ? values[hj] : ''
+          }
+          for (let extra = headers.length; extra < values.length; extra++) {
+            parseRow['_col' + extra] = values[extra]
+          }
+          rows.push(parseRow)
+        }
+      } else {
+        for (let ri = 0; ri < lines.length; ri++) {
+          if (skipEmpty && isEmptyLine(lines[ri])) {
+            continue
+          }
+          rows.push(parseLine(lines[ri]))
+        }
+      }
+
+      const result: any = { rows, headers, rowCount: rows.length }
+      if (operation === 'auto-detect') {
+        result.detectedDelimiter = delimiter
+      }
+      return result
+    } catch (err: unknown) {
+      return { rows: [], headers: [], rowCount: 0, error: (err as Error).message }
+    }
+  }
+
+  return { rows: [], headers: [], rowCount: 0, error: 'Unknown operation: ' + operation }
+}
+
+export const utilityCsvParse: NodeHandlerGenerator = {
+  nodeType: 'utility-csv-parse',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(utility_csv_parse)
+  },
+}

package/src/nodes/utility/utility-encode-decode.ts

@@ -0,0 +1,104 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function utility_encode_decode(config: any, context: Record<string, unknown>) {
+  const data = config.data !== undefined ? String(config.data) : ''
+  const operation = config.operation || 'base64-encode'
+  let result: any
+
+  if (!data && operation !== 'json-encode') {
+    return { result: '', error: null }
+  }
+
+  try {
+    switch (operation) {
+      case 'base64-encode':
+        result = Buffer.from(data, 'utf-8').toString('base64')
+        break
+      case 'base64-decode':
+        result = Buffer.from(data, 'base64').toString('utf-8')
+        break
+      case 'base64url-encode':
+        result = Buffer.from(data, 'utf-8').toString('base64url')
+        break
+      case 'base64url-decode':
+        result = Buffer.from(data, 'base64url').toString('utf-8')
+        break
+      case 'url-encode':
+        result = encodeURIComponent(data)
+        break
+      case 'url-decode':
+        result = decodeURIComponent(data)
+        break
+      case 'url-encode-full':
+        result = encodeURI(data)
+        break
+      case 'url-decode-full':
+        result = decodeURI(data)
+        break
+      case 'html-encode':
+        result = data
+          .replace(/&/g, '&amp;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;')
+          .replace(/'/g, '&#39;')
+        break
+      case 'html-decode':
+        result = data
+          .replace(/&#39;/g, "'")
+          .replace(/&quot;/g, '"')
+          .replace(/&gt;/g, '>')
+          .replace(/&lt;/g, '<')
+          .replace(/&amp;/g, '&')
+        break
+      case 'hex-encode':
+        result = Buffer.from(data, 'utf-8').toString('hex')
+        break
+      case 'hex-decode':
+        result = Buffer.from(data, 'hex').toString('utf-8')
+        break
+      case 'json-encode':
+        const jsonInput = config.data
+        result = JSON.stringify(jsonInput)
+        break
+      case 'json-decode':
+        result = JSON.parse(data)
+        break
+      case 'unicode-escape':
+        result = ''
+        for (let i = 0; i < data.length; i++) {
+          const code = data.charCodeAt(i)
+          if (code > 127) {
+            result += '\\u' + ('0000' + code.toString(16)).slice(-4)
+          } else {
+            result += data.charAt(i)
+          }
+        }
+        break
+      case 'unicode-unescape':
+        result = data.replace(/\\u([0-9a-fA-F]{4})/g, function (_: string, hex: string) {
+          return String.fromCharCode(parseInt(hex, 16))
+        })
+        break
+      default:
+        return {
+          result: null,
+          error:
+            'Unknown operation: ' +
+            operation +
+            '. Supported: base64-encode, base64-decode, base64url-encode, base64url-decode, url-encode, url-decode, url-encode-full, url-decode-full, html-encode, html-decode, hex-encode, hex-decode, json-encode, json-decode, unicode-escape, unicode-unescape',
+        }
+    }
+
+    return { result }
+  } catch (err: unknown) {
+    return { result: null, error: (err as Error).message }
+  }
+}
+export const utilityEncodeDecode: NodeHandlerGenerator = {
+  nodeType: 'utility-encode-decode',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(utility_encode_decode)
+  },
+}