@teleporthq/teleport-plugin-next-workflows 0.43.1

package/src/nodes/transform/transform-merge.ts

@@ -0,0 +1,179 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function transform_merge(config: any, context: Record<string, unknown>) {
+  const inputs = config.inputs || []
+  const mergeStrategy = config.mergeStrategy || 'shallow'
+  const arrayHandling = config.arrayHandling || 'replace'
+  const nullHandling = config.nullHandling || 'keep'
+  const nullReplacement = config.nullReplacement
+  let result: any
+
+  function deepMerge(target, source) {
+    const output = {}
+    const tKeys = Object.keys(target)
+    for (let ti = 0; ti < tKeys.length; ti++) {
+      output[tKeys[ti]] = target[tKeys[ti]]
+    }
+    const sKeys = Object.keys(source)
+    for (let si = 0; si < sKeys.length; si++) {
+      const key = sKeys[si]
+      const sVal = source[key]
+      const tVal = output[key]
+      if (
+        sVal !== null &&
+        typeof sVal === 'object' &&
+        !Array.isArray(sVal) &&
+        tVal !== null &&
+        typeof tVal === 'object' &&
+        !Array.isArray(tVal)
+      ) {
+        output[key] = deepMerge(tVal, sVal)
+      } else if (Array.isArray(sVal) && Array.isArray(tVal)) {
+        if (arrayHandling === 'concat') {
+          output[key] = tVal.concat(sVal)
+        } else {
+          output[key] = sVal
+        }
+      } else {
+        if (sVal === null && nullHandling === 'skip') {
+          continue
+        } else if (sVal === null && nullHandling === 'replace') {
+          output[key] = nullReplacement
+        } else {
+          output[key] = sVal
+        }
+      }
+    }
+    return output
+  }
+
+  try {
+    switch (mergeStrategy) {
+      case 'shallow':
+        result = {}
+        for (let i = 0; i < inputs.length; i++) {
+          const obj = inputs[i] || {}
+          const objKeys = Object.keys(obj)
+          for (let k = 0; k < objKeys.length; k++) {
+            const val = obj[objKeys[k]]
+            if (val === null && nullHandling === 'skip') {
+              continue
+            } else if (val === null && nullHandling === 'replace') {
+              result[objKeys[k]] = nullReplacement
+            } else {
+              result[objKeys[k]] = val
+            }
+          }
+        }
+        break
+      case 'deep':
+        result = {}
+        for (let di = 0; di < inputs.length; di++) {
+          result = deepMerge(result, inputs[di] || {})
+        }
+        break
+      case 'concat':
+        if (Array.isArray(inputs[0])) {
+          result = []
+          for (let ci = 0; ci < inputs.length; ci++) {
+            const arr = Array.isArray(inputs[ci]) ? inputs[ci] : [inputs[ci]]
+            result = result.concat(arr)
+          }
+        } else {
+          result = {}
+          for (let coi = 0; coi < inputs.length; coi++) {
+            const cObj = inputs[coi] || {}
+            const cKeys = Object.keys(cObj)
+            for (let ck = 0; ck < cKeys.length; ck++) {
+              if (Array.isArray(result[cKeys[ck]]) && Array.isArray(cObj[cKeys[ck]])) {
+                result[cKeys[ck]] = result[cKeys[ck]].concat(cObj[cKeys[ck]])
+              } else {
+                result[cKeys[ck]] = cObj[cKeys[ck]]
+              }
+            }
+          }
+        }
+        break
+      case 'union':
+        result = []
+        for (let ui = 0; ui < inputs.length; ui++) {
+          const uArr = Array.isArray(inputs[ui]) ? inputs[ui] : [inputs[ui]]
+          for (let uj = 0; uj < uArr.length; uj++) {
+            let exists = false
+            for (let ux = 0; ux < result.length; ux++) {
+              if (JSON.stringify(result[ux]) === JSON.stringify(uArr[uj])) {
+                exists = true
+                break
+              }
+            }
+            if (!exists) {
+              result.push(uArr[uj])
+            }
+          }
+        }
+        break
+      case 'intersection':
+        if (inputs.length === 0) {
+          result = []
+        } else {
+          const first = Array.isArray(inputs[0]) ? inputs[0] : [inputs[0]]
+          result = first.slice()
+          for (let ii = 1; ii < inputs.length; ii++) {
+            const other = Array.isArray(inputs[ii]) ? inputs[ii] : [inputs[ii]]
+            const filtered = []
+            for (let ix = 0; ix < result.length; ix++) {
+              let inOther = false
+              for (let iy = 0; iy < other.length; iy++) {
+                if (JSON.stringify(result[ix]) === JSON.stringify(other[iy])) {
+                  inOther = true
+                  break
+                }
+              }
+              if (inOther) {
+                filtered.push(result[ix])
+              }
+            }
+            result = filtered
+          }
+        }
+        break
+      case 'difference':
+        if (inputs.length === 0) {
+          result = []
+        } else {
+          result = Array.isArray(inputs[0]) ? inputs[0].slice() : [inputs[0]]
+          for (let dfi = 1; dfi < inputs.length; dfi++) {
+            const diffArr = Array.isArray(inputs[dfi]) ? inputs[dfi] : [inputs[dfi]]
+            const diffResult = []
+            for (let dx = 0; dx < result.length; dx++) {
+              let inDiff = false
+              for (let dy = 0; dy < diffArr.length; dy++) {
+                if (JSON.stringify(result[dx]) === JSON.stringify(diffArr[dy])) {
+                  inDiff = true
+                  break
+                }
+              }
+              if (!inDiff) {
+                diffResult.push(result[dx])
+              }
+            }
+            result = diffResult
+          }
+        }
+        break
+      default:
+        return { result: null, error: 'Unknown merge strategy: ' + mergeStrategy }
+    }
+
+    return { result }
+  } catch (err: unknown) {
+    return { result: null, error: (err as Error).message }
+  }
+}
+export const transformMerge: NodeHandlerGenerator = {
+  nodeType: 'transform-merge',
+  executionEnv: 'universal',
+  generateHandler(): string {
+    return handlerToString(transform_merge)
+  },
+}

package/src/nodes/transform/transform-object.ts

@@ -0,0 +1,161 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function transform_object(config: any, context: Record<string, unknown>) {
+  const operation = config.operation || 'merge'
+  const input = config.input || {}
+  const inputs = config.inputs || []
+  const keys = config.keys || []
+  const key = config.key || ''
+  const value = config.value
+  const path = config.path || ''
+  const defaultValue = config.defaultValue
+  let result: any
+
+  try {
+    switch (operation) {
+      case 'merge':
+        result = {}
+        const allObjs = [input].concat(inputs)
+        for (let mi = 0; mi < allObjs.length; mi++) {
+          const obj = allObjs[mi] || {}
+          const objKeys = Object.keys(obj)
+          for (let mk = 0; mk < objKeys.length; mk++) {
+            result[objKeys[mk]] = obj[objKeys[mk]]
+          }
+        }
+        break
+      case 'pick':
+        result = {}
+        for (let pi = 0; pi < keys.length; pi++) {
+          if (input.hasOwnProperty(keys[pi])) {
+            result[keys[pi]] = input[keys[pi]]
+          }
+        }
+        break
+      case 'omit':
+        result = {}
+        const inputKeys = Object.keys(input)
+        for (let oi = 0; oi < inputKeys.length; oi++) {
+          let shouldOmit = false
+          for (let ok = 0; ok < keys.length; ok++) {
+            if (inputKeys[oi] === keys[ok]) {
+              shouldOmit = true
+              break
+            }
+          }
+          if (!shouldOmit) {
+            result[inputKeys[oi]] = input[inputKeys[oi]]
+          }
+        }
+        break
+      case 'keys':
+        result = Object.keys(input)
+        break
+      case 'values':
+        const vKeys = Object.keys(input)
+        result = []
+        for (let vi = 0; vi < vKeys.length; vi++) {
+          result.push(input[vKeys[vi]])
+        }
+        break
+      case 'entries':
+        const eKeys = Object.keys(input)
+        result = []
+        for (let ei = 0; ei < eKeys.length; ei++) {
+          result.push([eKeys[ei], input[eKeys[ei]]])
+        }
+        break
+      case 'get':
+        const pathParts = path ? path.split('.') : [key]
+        let current = input
+        for (let gi = 0; gi < pathParts.length; gi++) {
+          if (current === null || current === undefined) {
+            current = undefined
+            break
+          }
+          current = current[pathParts[gi]]
+        }
+        result = current !== undefined ? current : defaultValue
+        break
+      case 'set':
+        result = JSON.parse(JSON.stringify(input))
+        const setParts = path ? path.split('.') : [key]
+        let setTarget = result
+        for (let si = 0; si < setParts.length - 1; si++) {
+          if (setTarget[setParts[si]] === undefined || setTarget[setParts[si]] === null) {
+            setTarget[setParts[si]] = {}
+          }
+          setTarget = setTarget[setParts[si]]
+        }
+        setTarget[setParts[setParts.length - 1]] = value
+        break
+      case 'delete':
+        result = JSON.parse(JSON.stringify(input))
+        const delParts = path ? path.split('.') : [key]
+        let delTarget = result
+        for (let di = 0; di < delParts.length - 1; di++) {
+          if (delTarget[delParts[di]] === undefined) {
+            break
+          }
+          delTarget = delTarget[delParts[di]]
+        }
+        delete delTarget[delParts[delParts.length - 1]]
+        break
+      case 'has':
+        const hasParts = path ? path.split('.') : [key]
+        let hasCurrent = input
+        result = true
+        for (let hi = 0; hi < hasParts.length; hi++) {
+          if (
+            hasCurrent === null ||
+            hasCurrent === undefined ||
+            !hasCurrent.hasOwnProperty(hasParts[hi])
+          ) {
+            result = false
+            break
+          }
+          hasCurrent = hasCurrent[hasParts[hi]]
+        }
+        break
+      case 'assign':
+        result = {}
+        const assignKeys = Object.keys(input)
+        for (let ai = 0; ai < assignKeys.length; ai++) {
+          result[assignKeys[ai]] = input[assignKeys[ai]]
+        }
+        for (let aj = 0; aj < inputs.length; aj++) {
+          const srcObj = inputs[aj] || {}
+          const srcKeys = Object.keys(srcObj)
+          for (let ak = 0; ak < srcKeys.length; ak++) {
+            result[srcKeys[ak]] = srcObj[srcKeys[ak]]
+          }
+        }
+        break
+      case 'clone':
+        result = JSON.parse(JSON.stringify(input))
+        break
+      case 'freeze':
+        result = Object.freeze(JSON.parse(JSON.stringify(input)))
+        break
+      case 'seal':
+        result = Object.seal(JSON.parse(JSON.stringify(input)))
+        break
+      case 'stringify':
+        result = JSON.stringify(input)
+        break
+      default:
+        return { result: null, error: 'Unknown operation: ' + operation }
+    }
+
+    return { result }
+  } catch (err: unknown) {
+    return { result: null, error: (err as Error).message }
+  }
+}
+export const transformObject: NodeHandlerGenerator = {
+  nodeType: 'transform-object',
+  executionEnv: 'universal',
+  generateHandler(): string {
+    return handlerToString(transform_object)
+  },
+}

package/src/nodes/transform/transform-string.ts

@@ -0,0 +1,116 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function transform_string(config: any, context: Record<string, unknown>) {
+  const operation = config.operation || 'concat'
+  let input = config.input !== undefined ? String(config.input) : ''
+  const inputs = config.inputs || []
+  const separator = config.separator !== undefined ? config.separator : ''
+  const searchValue = config.searchValue || ''
+  const replaceValue = config.replaceValue !== undefined ? config.replaceValue : ''
+  const start = config.start !== undefined ? Number(config.start) : 0
+  const end = config.end
+  const length = config.length
+  const padString = config.padString || ' '
+  const times = config.times !== undefined ? Number(config.times) : 1
+  const maxLength = config.maxLength
+  const ellipsis = config.ellipsis !== undefined ? config.ellipsis : '...'
+  let result: any
+
+  try {
+    switch (operation) {
+      case 'concat':
+        const parts = inputs.length > 0 ? inputs.map(String) : [input]
+        result = parts.join(separator)
+        break
+      case 'split':
+        result = input.split(separator)
+        break
+      case 'trim':
+        result = input.trim()
+        break
+      case 'uppercase':
+        result = input.toUpperCase()
+        break
+      case 'lowercase':
+        result = input.toLowerCase()
+        break
+      case 'capitalize':
+        result = input.charAt(0).toUpperCase() + input.slice(1)
+        break
+      case 'replace':
+        result = input.split(searchValue).join(replaceValue)
+        break
+      case 'substring':
+        const subEnd =
+          end !== undefined
+            ? Number(end)
+            : length !== undefined
+            ? start + Number(length)
+            : undefined
+        result = subEnd !== undefined ? input.substring(start, subEnd) : input.substring(start)
+        break
+      case 'length':
+        result = input.length
+        break
+      case 'includes':
+        result = input.indexOf(searchValue) !== -1
+        break
+      case 'startsWith':
+        result = input.indexOf(searchValue) === 0
+        break
+      case 'endsWith':
+        result = input.indexOf(searchValue, input.length - searchValue.length) !== -1
+        break
+      case 'padStart':
+        const psLen = length !== undefined ? Number(length) : input.length
+        while (input.length < psLen) {
+          input = padString + input
+        }
+        result = input.substring(0, psLen)
+        break
+      case 'padEnd':
+        const peLen = length !== undefined ? Number(length) : input.length
+        while (input.length < peLen) {
+          input = input + padString
+        }
+        result = input.substring(0, peLen)
+        break
+      case 'repeat':
+        result = ''
+        for (let r = 0; r < times; r++) {
+          result += input
+        }
+        break
+      case 'reverse':
+        result = input.split('').reverse().join('')
+        break
+      case 'slugify':
+        result = input
+          .toLowerCase()
+          .replace(/[^a-z0-9]+/g, '-')
+          .replace(/^-|-$/g, '')
+        break
+      case 'truncate':
+        const ml = maxLength !== undefined ? Number(maxLength) : input.length
+        if (input.length > ml) {
+          result = input.substring(0, ml) + ellipsis
+        } else {
+          result = input
+        }
+        break
+      default:
+        return { result: null, error: 'Unknown operation: ' + operation }
+    }
+
+    return { result }
+  } catch (err: unknown) {
+    return { result: null, error: (err as Error).message }
+  }
+}
+export const transformString: NodeHandlerGenerator = {
+  nodeType: 'transform-string',
+  executionEnv: 'universal',
+  generateHandler(): string {
+    return handlerToString(transform_string)
+  },
+}

package/src/nodes/transform/transform-validate.ts

@@ -0,0 +1,121 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function transform_validate(config: any, context: Record<string, unknown>) {
+  const input = config.input || {}
+  const rules = config.rules || []
+  const stopOnFirstError = config.stopOnFirstError || false
+  const errors = []
+
+  try {
+    for (let i = 0; i < rules.length; i++) {
+      const rule = rules[i]
+      const field = rule.field
+      const fieldValue = input[field]
+      const ruleType = rule.rule
+      const errorMsg = rule.message || 'Validation failed for field: ' + field
+      let valid = true
+
+      switch (ruleType) {
+        case 'required':
+          valid = fieldValue !== undefined && fieldValue !== null && fieldValue !== ''
+          break
+        case 'email':
+          valid =
+            typeof fieldValue === 'string' && /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(fieldValue)
+          break
+        case 'min':
+          if (typeof fieldValue === 'number') {
+            valid = fieldValue >= Number(rule.min)
+          } else if (typeof fieldValue === 'string') {
+            valid = fieldValue.length >= Number(rule.min)
+          }
+          break
+        case 'max':
+          if (typeof fieldValue === 'number') {
+            valid = fieldValue <= Number(rule.max)
+          } else if (typeof fieldValue === 'string') {
+            valid = fieldValue.length <= Number(rule.max)
+          }
+          break
+        case 'range':
+          const numVal = Number(fieldValue)
+          valid = numVal >= Number(rule.min) && numVal <= Number(rule.max)
+          break
+        case 'pattern':
+          valid = typeof fieldValue === 'string' && new RegExp(rule.pattern).test(fieldValue)
+          break
+        case 'type':
+          valid = typeof fieldValue === rule.value
+          break
+        case 'in':
+          const allowed = rule.allowedValues || []
+          valid = false
+          for (let a = 0; a < allowed.length; a++) {
+            if (fieldValue === allowed[a]) {
+              valid = true
+              break
+            }
+          }
+          break
+        case 'url':
+          try {
+            new URL(String(fieldValue))
+            valid = true
+          } catch (e) {
+            valid = false
+          }
+          break
+        case 'date':
+          const d = new Date(fieldValue)
+          valid = !isNaN(d.getTime())
+          break
+        case 'date-before':
+          const db = new Date(fieldValue)
+          const dc = new Date(rule.dateToCompare)
+          valid = !isNaN(db.getTime()) && !isNaN(dc.getTime()) && db < dc
+          break
+        case 'date-after':
+          const da = new Date(fieldValue)
+          const dac = new Date(rule.dateToCompare)
+          valid = !isNaN(da.getTime()) && !isNaN(dac.getTime()) && da > dac
+          break
+        case 'length':
+          if (typeof fieldValue === 'string' || Array.isArray(fieldValue)) {
+            valid = fieldValue.length === Number(rule.value)
+          } else {
+            valid = false
+          }
+          break
+        case 'numeric':
+          valid = !isNaN(Number(fieldValue)) && fieldValue !== null && fieldValue !== ''
+          break
+        case 'alpha':
+          valid = typeof fieldValue === 'string' && /^[a-zA-Z]+$/.test(fieldValue)
+          break
+        case 'alphanumeric':
+          valid = typeof fieldValue === 'string' && /^[a-zA-Z0-9]+$/.test(fieldValue)
+          break
+        default:
+          valid = false
+      }
+
+      if (!valid) {
+        errors.push({ id: rule.id || i, field, rule: ruleType, message: errorMsg })
+        if (stopOnFirstError) {
+          break
+        }
+      }
+    }
+
+    return { isValid: errors.length === 0, errors }
+  } catch (err: unknown) {
+    return { isValid: false, errors: [{ message: (err as Error).message }] }
+  }
+}
+export const transformValidate: NodeHandlerGenerator = {
+  nodeType: 'transform-validate',
+  executionEnv: 'universal',
+  generateHandler(): string {
+    return handlerToString(transform_validate)
+  },
+}

package/src/nodes/types.ts

@@ -0,0 +1,18 @@
+export type HandlerFn = (config: unknown, context: Record<string, unknown>) => Promise<unknown>
+
+export function handlerToString(fn: HandlerFn): string {
+  return fn.toString()
+}
+
+export interface NodeHandlerGenerator {
+  nodeType: string
+  executionEnv: 'client' | 'server' | 'universal'
+  isTerminal?: boolean
+  dependencies?: Record<string, string>
+  generateHandler(): string
+  generateServerHandler?(): string
+}
+
+export interface IntegrationHandlerGenerator extends NodeHandlerGenerator {
+  secretFields: string[]
+}

package/src/nodes/url/url-get-current-url.ts

@@ -0,0 +1,24 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function url_get_current_url(config: any, context: Record<string, unknown>) {
+  const loc = window.location
+
+  return {
+    url: loc.href,
+    protocol: loc.protocol,
+    host: loc.host,
+    hostname: loc.hostname,
+    port: loc.port,
+    pathname: loc.pathname,
+    search: loc.search,
+    hash: loc.hash,
+    origin: loc.origin,
+  }
+}
+export const urlGetCurrentUrl: NodeHandlerGenerator = {
+  nodeType: 'url-get-current-url',
+  executionEnv: 'client',
+  generateHandler(): string {
+    return handlerToString(url_get_current_url)
+  },
+}

package/src/nodes/url/url-get-query-parameter.ts

@@ -0,0 +1,18 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function url_get_query_parameter(config: any, context: Record<string, unknown>) {
+  const parameterName = config.parameterName
+  const defaultValue = config.defaultValue || ''
+
+  const params = new URLSearchParams(window.location.search)
+  const value = params.get(parameterName)
+
+  return { value: value !== null ? value : defaultValue }
+}
+export const urlGetQueryParameter: NodeHandlerGenerator = {
+  nodeType: 'url-get-query-parameter',
+  executionEnv: 'client',
+  generateHandler(): string {
+    return handlerToString(url_get_query_parameter)
+  },
+}