@teleporthq/teleport-plugin-next-workflows 0.43.1

package/src/nodes/file-storage/file-storage-delete.ts

@@ -0,0 +1,52 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function file_storage_delete(config: any, _context: any) {
+  const fileId = config.fileId
+
+  if (!fileId) {
+    return { success: false, deletedFileId: '', error: 'fileId is required' }
+  }
+
+  const storageUrl = process.env.RUNTIME_STORAGE_URL
+  const apiKey = process.env.RUNTIME_STORAGE_API_KEY
+  const projectId = process.env.RUNTIME_STORAGE_PROJECT_ID
+
+  if (!storageUrl || !apiKey || !projectId) {
+    return { success: false, deletedFileId: '', error: 'Runtime storage is not configured' }
+  }
+
+  try {
+    const url =
+      storageUrl + '/project/' + projectId + '/files/' + encodeURIComponent(String(fileId))
+
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers: { Authorization: 'Bearer ' + apiKey },
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        success: false,
+        deletedFileId: '',
+        error: data.error || data.message || 'Failed to delete file',
+      }
+    }
+
+    return {
+      success: data.success !== undefined ? data.success : true,
+      deletedFileId: data.deletedFileId || String(fileId),
+    }
+  } catch (err: unknown) {
+    return { success: false, deletedFileId: '', error: (err as Error).message }
+  }
+}
+
+export const fileStorageDelete: NodeHandlerGenerator = {
+  nodeType: 'file-storage-delete',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(file_storage_delete)
+  },
+}

package/src/nodes/file-storage/file-storage-get-details.ts

@@ -0,0 +1,45 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function file_storage_get_details(config: any, _context: any) {
+  const fileId = config.fileId
+
+  if (!fileId) {
+    return { error: 'fileId is required' }
+  }
+
+  const storageUrl = process.env.RUNTIME_STORAGE_URL
+  const apiKey = process.env.RUNTIME_STORAGE_API_KEY
+  const projectId = process.env.RUNTIME_STORAGE_PROJECT_ID
+
+  if (!storageUrl || !apiKey || !projectId) {
+    return { error: 'Runtime storage is not configured' }
+  }
+
+  try {
+    const url =
+      storageUrl + '/project/' + projectId + '/files/' + encodeURIComponent(String(fileId))
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: { Authorization: 'Bearer ' + apiKey },
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return { error: data.error || data.message || 'Failed to get file details' }
+    }
+
+    return data
+  } catch (err: unknown) {
+    return { error: (err as Error).message }
+  }
+}
+
+export const fileStorageGetDetails: NodeHandlerGenerator = {
+  nodeType: 'file-storage-get-details',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(file_storage_get_details)
+  },
+}

package/src/nodes/file-storage/file-storage-list.ts

@@ -0,0 +1,71 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function file_storage_list(config: any, _context: any) {
+  const storageUrl = process.env.RUNTIME_STORAGE_URL
+  const apiKey = process.env.RUNTIME_STORAGE_API_KEY
+  const projectId = process.env.RUNTIME_STORAGE_PROJECT_ID
+
+  if (!storageUrl || !apiKey || !projectId) {
+    return { files: [], count: 0, totalSize: 0, error: 'Runtime storage is not configured' }
+  }
+
+  try {
+    const params = new URLSearchParams()
+    if (config.folder) {
+      params.set('folder', String(config.folder))
+    }
+    if (config.limit !== undefined && config.limit !== null) {
+      params.set('limit', String(config.limit))
+    }
+    if (config.skip !== undefined && config.skip !== null) {
+      params.set('skip', String(config.skip))
+    }
+    if (config.sortBy) {
+      params.set('sortBy', String(config.sortBy))
+    }
+    if (config.sortOrder) {
+      params.set('sortOrder', String(config.sortOrder))
+    }
+    if (config.mimeTypeFilter) {
+      params.set('mimeTypeFilter', String(config.mimeTypeFilter))
+    }
+    if (config.nameFilter) {
+      params.set('nameFilter', String(config.nameFilter))
+    }
+
+    const qs = params.toString()
+    const url = storageUrl + '/project/' + projectId + '/files' + (qs ? '?' + qs : '')
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: { Authorization: 'Bearer ' + apiKey },
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        files: [],
+        count: 0,
+        totalSize: 0,
+        error: data.error || data.message || 'Failed to list files',
+      }
+    }
+
+    return {
+      files: data.files || [],
+      count: data.count || 0,
+      totalSize: data.totalSize || 0,
+    }
+  } catch (err: unknown) {
+    return { files: [], count: 0, totalSize: 0, error: (err as Error).message }
+  }
+}
+
+export const fileStorageList: NodeHandlerGenerator = {
+  nodeType: 'file-storage-list',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(file_storage_list)
+  },
+}

package/src/nodes/file-storage/file-storage-upload.ts

@@ -0,0 +1,148 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+// `browser-pick-files` returns plain objects shaped like
+// `{ name, size, type, lastModified, data, dataURL }` — see the context
+// schema in `packages/workflow-schema/src/types/node-context-schemas.json`
+// and the matching handler in `nodes/browser/browser-pick-files.ts`. Those
+// objects are NOT `Blob` instances, so the previous `instanceof Blob`-only
+// FormData appender silently dropped every picked file and the upstream
+// runtime-storage proxy returned `{ error: "NO_FILES" }`. We now convert
+// any item carrying a `dataURL` (the canonical encoding the picker emits)
+// to a Blob before appending. Raw Blob/File values from other producers
+// continue to work unchanged.
+//
+// All helpers are declared INSIDE `file_storage_upload` because
+// `handlerToString` only serializes the function body via `Function.prototype
+// .toString()`. Anything declared at module scope is invisible to the
+// generated runtime and would `ReferenceError` at execution time.
+async function file_storage_upload(config: any, _context: any) {
+  const fileData = config.file
+
+  if (!fileData) {
+    return { files: [], error: 'No file provided' }
+  }
+
+  function dataURLToBlob(dataURL: string, fallbackMime: string): Blob | null {
+    if (!dataURL || typeof dataURL !== 'string') {
+      return null
+    }
+    const commaIdx = dataURL.indexOf(',')
+    if (commaIdx < 0) {
+      return null
+    }
+    const header = dataURL.slice(0, commaIdx)
+    const payload = dataURL.slice(commaIdx + 1)
+    const mimeMatch = header.match(/data:([^;]+)/)
+    const mime =
+      mimeMatch && mimeMatch[1] ? mimeMatch[1] : fallbackMime || 'application/octet-stream'
+    const isBase64 = header.indexOf(';base64') !== -1
+    let bytes: Uint8Array
+    try {
+      if (isBase64) {
+        const binary = atob(payload)
+        bytes = new Uint8Array(binary.length)
+        for (let i = 0; i < binary.length; i++) {
+          bytes[i] = binary.charCodeAt(i)
+        }
+      } else {
+        const decoded = decodeURIComponent(payload)
+        bytes = new Uint8Array(decoded.length)
+        for (let j = 0; j < decoded.length; j++) {
+          bytes[j] = decoded.charCodeAt(j)
+        }
+      }
+    } catch (_e) {
+      return null
+    }
+    return new Blob([bytes], { type: mime })
+  }
+
+  function appendFileEntry(formData: FormData, entry: any): boolean {
+    if (!entry) {
+      return false
+    }
+    if (entry instanceof Blob) {
+      const nativeName = (entry as File).name
+      if (nativeName) {
+        formData.append('file', entry, nativeName)
+      } else {
+        formData.append('file', entry)
+      }
+      return true
+    }
+    if (typeof entry === 'object') {
+      const blob = dataURLToBlob(String(entry.dataURL || ''), String(entry.type || ''))
+      if (blob) {
+        const fileName = entry.name ? String(entry.name) : 'file'
+        formData.append('file', blob, fileName)
+        return true
+      }
+    }
+    return false
+  }
+
+  try {
+    const formData = new FormData()
+    let appendedCount = 0
+
+    if (Array.isArray(fileData)) {
+      for (let k = 0; k < fileData.length; k++) {
+        if (appendFileEntry(formData, fileData[k])) {
+          appendedCount += 1
+        }
+      }
+    } else if (appendFileEntry(formData, fileData)) {
+      appendedCount += 1
+    }
+
+    if (appendedCount === 0) {
+      return { files: [], error: 'Invalid file data' }
+    }
+
+    if (
+      config.allowedMimeTypes &&
+      Array.isArray(config.allowedMimeTypes) &&
+      config.allowedMimeTypes.length > 0
+    ) {
+      formData.append('allowedMimeTypes', config.allowedMimeTypes.join(','))
+    }
+
+    if (config.maxFileSize !== undefined && config.maxFileSize !== null) {
+      formData.append('maxFileSize', String(config.maxFileSize))
+    }
+
+    if (config.folder) {
+      formData.append('folder', String(config.folder))
+    }
+
+    const response = await fetch('/api/runtime-storage/upload', {
+      method: 'POST',
+      body: formData,
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        files: [],
+        error: data.error || data.message || 'Upload failed',
+        statusCode: response.status,
+        currentUsage: data.currentUsage,
+        storageLimit: data.storageLimit,
+        requestedSize: data.requestedSize,
+      }
+    }
+
+    return { files: data.files || [] }
+  } catch (err: unknown) {
+    return { files: [], error: (err as Error).message }
+  }
+}
+
+export const fileStorageUpload: NodeHandlerGenerator = {
+  nodeType: 'file-storage-upload',
+  executionEnv: 'client',
+  generateHandler(): string {
+    return handlerToString(file_storage_upload)
+  },
+}

package/src/nodes/form/form-blur.ts

@@ -0,0 +1,23 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function form_blur(config: any, context: Record<string, unknown>) {
+  const nodeId = config.nodeId
+
+  const el =
+    document.getElementById(nodeId) ||
+    (config.elementHtmlId ? document.getElementById(config.elementHtmlId) : null)
+  if (!el) {
+    return { success: false }
+  }
+
+  el.blur()
+
+  return { success: true }
+}
+export const formBlur: NodeHandlerGenerator = {
+  nodeType: 'form-blur',
+  executionEnv: 'client',
+  generateHandler(): string {
+    return handlerToString(form_blur)
+  },
+}

package/src/nodes/form/form-focus.ts

@@ -0,0 +1,23 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function form_focus(config: any, context: Record<string, unknown>) {
+  const nodeId = config.nodeId
+
+  const el =
+    document.getElementById(nodeId) ||
+    (config.elementHtmlId ? document.getElementById(config.elementHtmlId) : null)
+  if (!el) {
+    return { success: false }
+  }
+
+  el.focus()
+
+  return { success: true }
+}
+export const formFocus: NodeHandlerGenerator = {
+  nodeType: 'form-focus',
+  executionEnv: 'client',
+  generateHandler(): string {
+    return handlerToString(form_focus)
+  },
+}

package/src/nodes/form/form-reset.ts

@@ -0,0 +1,25 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function form_reset(config: any, context: Record<string, unknown>) {
+  const formNodeId = config.formNodeId
+
+  const el =
+    document.getElementById(formNodeId) ||
+    (config.elementHtmlId ? document.getElementById(config.elementHtmlId) : null)
+  if (!el) {
+    return { success: false }
+  }
+
+  if (typeof (el as HTMLFormElement).reset === 'function') {
+    ;(el as HTMLFormElement).reset()
+  }
+
+  return { success: true }
+}
+export const formReset: NodeHandlerGenerator = {
+  nodeType: 'form-reset',
+  executionEnv: 'client',
+  generateHandler(): string {
+    return handlerToString(form_reset)
+  },
+}

package/src/nodes/form/form-set-value.ts

@@ -0,0 +1,27 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function form_set_value(config: any, context: Record<string, unknown>) {
+  const nodeId = config.nodeId
+  const value = config.value
+
+  const el =
+    document.getElementById(nodeId) ||
+    (config.elementHtmlId ? document.getElementById(config.elementHtmlId) : null)
+  if (!el) {
+    return { success: false }
+  }
+
+  ;(el as HTMLInputElement).value = value
+
+  const event = new Event('input', { bubbles: true })
+  el.dispatchEvent(event)
+
+  return { success: true }
+}
+export const formSetValue: NodeHandlerGenerator = {
+  nodeType: 'form-set-value',
+  executionEnv: 'client',
+  generateHandler(): string {
+    return handlerToString(form_set_value)
+  },
+}