@teleporthq/teleport-plugin-next-workflows 0.43.1

package/src/nodes/integrations/integration-wrike.ts

@@ -0,0 +1,177 @@
+import { IntegrationHandlerGenerator, handlerToString } from '../types'
+
+async function integration_wrike(config: any, context: Record<string, unknown>) {
+  // Safely parse a fetch response: providers (Dropbox, Stripe legacy errors,
+  // Slack rate-limit pages, …) sometimes return plain text on failure.
+  // We read once as text and only parse JSON when it actually parses.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const __readJson = async (resp: any): Promise<any> => {
+    const text = await resp.text()
+    if (!text) {
+      return {}
+    }
+    try {
+      return JSON.parse(text)
+    } catch (e: unknown) {
+      void e
+      return { error_summary: text, error: text, message: text, raw: text }
+    }
+  }
+  const accessToken = config.accessToken
+  const action = config.action
+  const baseUrl = 'https://www.wrike.com/api/v4/'
+  const headers = {
+    'Content-Type': 'application/json',
+    Authorization: 'Bearer ' + accessToken,
+  }
+
+  switch (action) {
+    case 'create-task': {
+      const body: Record<string, any> = {
+        title: config.title,
+      }
+      if (config.description) {
+        body.description = config.description
+      }
+      if (config.status) {
+        body.status = config.status
+      }
+      if (config.importance) {
+        body.importance = config.importance
+      }
+      if (config.dates) {
+        body.dates = config.dates
+      }
+      if (config.responsibles) {
+        body.responsibles = config.responsibles
+      }
+      const response = await fetch(baseUrl + 'folders/' + config.folderId + '/tasks', {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return { success: false, error: data.errorDescription || 'Failed to create task' }
+      }
+      return { success: true, task: data.data && data.data[0] }
+    }
+    case 'get-task': {
+      const response = await fetch(baseUrl + 'tasks/' + config.taskId, {
+        method: 'GET',
+        headers,
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return { success: false, error: data.errorDescription || 'Failed to get task' }
+      }
+      return { success: true, task: data.data && data.data[0] }
+    }
+    case 'list-tasks': {
+      let url = baseUrl + 'tasks'
+      const params = []
+      if (config.folderId) {
+        url = baseUrl + 'folders/' + config.folderId + '/tasks'
+      }
+      if (config.limit) {
+        params.push('limit=' + config.limit)
+      }
+      if (config.status) {
+        params.push('status=' + config.status)
+      }
+      if (params.length > 0) {
+        url = url + '?' + params.join('&')
+      }
+      const response = await fetch(url, { method: 'GET', headers })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return { success: false, error: data.errorDescription || 'Failed to list tasks' }
+      }
+      return { success: true, tasks: data.data || [] }
+    }
+    case 'update-task': {
+      const body: Record<string, any> = {}
+      if (config.title !== undefined) {
+        body.title = config.title
+      }
+      if (config.description !== undefined) {
+        body.description = config.description
+      }
+      if (config.status !== undefined) {
+        body.status = config.status
+      }
+      const response = await fetch(baseUrl + 'tasks/' + config.taskId, {
+        method: 'PUT',
+        headers,
+        body: JSON.stringify(body),
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return { success: false, error: data.errorDescription || 'Failed to update task' }
+      }
+      return { success: true, task: data.data && data.data[0] }
+    }
+    case 'delete-task': {
+      const response = await fetch(baseUrl + 'tasks/' + config.taskId, {
+        method: 'DELETE',
+        headers,
+      })
+      if (!response.ok) {
+        const data = await __readJson(response)
+        return { success: false, error: data.errorDescription || 'Failed to delete task' }
+      }
+      return { success: true }
+    }
+    case 'create-folder': {
+      // Schema canonical name is `parentFolderId`; older workflows used `folderId`. Accept either.
+      const parentFolderIdVal = config.parentFolderId || config.folderId
+      const body: Record<string, any> = { title: config.title }
+      if (config.project) {
+        body.project = config.project
+      }
+      const response = await fetch(baseUrl + 'folders/' + parentFolderIdVal + '/folders', {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return { success: false, error: data.errorDescription || 'Failed to create folder' }
+      }
+      return { success: true, folder: data.data && data.data[0] }
+    }
+    case 'get-folder': {
+      const response = await fetch(baseUrl + 'folders/' + config.folderId, {
+        method: 'GET',
+        headers,
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return { success: false, error: data.errorDescription || 'Failed to get folder' }
+      }
+      return { success: true, folder: data.data && data.data[0] }
+    }
+    case 'list-folders': {
+      let url = baseUrl + 'folders'
+      if (config.spaceId) {
+        url = baseUrl + 'spaces/' + config.spaceId + '/folders'
+      }
+      const response = await fetch(url, { method: 'GET', headers })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return { success: false, error: data.errorDescription || 'Failed to list folders' }
+      }
+      return { success: true, folders: data.data || [] }
+    }
+    default:
+      throw new Error('Unknown integration-wrike action: ' + action)
+  }
+}
+export const integrationWrike: IntegrationHandlerGenerator = {
+  nodeType: 'integration-wrike',
+  executionEnv: 'server',
+  secretFields: ['accessToken'],
+  generateHandler(): string {
+    return handlerToString(integration_wrike)
+  },
+}

package/src/nodes/integrations/integration-x.ts

@@ -0,0 +1,3 @@
+import { createGenericIntegration } from './integration-generic'
+
+export const integrationX = createGenericIntegration('integration-x')

package/src/nodes/integrations/integration-xero.ts

@@ -0,0 +1,3 @@
+import { createGenericIntegration } from './integration-generic'
+
+export const integrationXero = createGenericIntegration('integration-xero')

package/src/nodes/integrations/integration-youtube.ts

@@ -0,0 +1,172 @@
+import { IntegrationHandlerGenerator, handlerToString } from '../types'
+
+async function integration_youtube(config: any, context: Record<string, unknown>) {
+  // Safely parse a fetch response: providers (Dropbox, Stripe legacy errors,
+  // Slack rate-limit pages, …) sometimes return plain text on failure.
+  // We read once as text and only parse JSON when it actually parses.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const __readJson = async (resp: any): Promise<any> => {
+    const text = await resp.text()
+    if (!text) {
+      return {}
+    }
+    try {
+      return JSON.parse(text)
+    } catch (e: unknown) {
+      void e
+      return { error_summary: text, error: text, message: text, raw: text }
+    }
+  }
+  const apiKey = config.apiKey
+  const accessToken = config.accessToken
+  // YouTube Data API accepts either ?key=<API_KEY> or
+  // ?access_token=<OAUTH_TOKEN>; use whichever the user provided.
+  const authParam = accessToken ? 'access_token=' + accessToken : 'key=' + apiKey
+  const action = config.action
+  const baseUrl = 'https://www.googleapis.com/youtube/v3/'
+
+  switch (action) {
+    case 'search-videos': {
+      const url = baseUrl + 'search'
+      const params = [authParam, 'part=snippet', 'type=video']
+      if (config.q) {
+        params.push('q=' + encodeURIComponent(config.q))
+      }
+      if (config.maxResults) {
+        params.push('maxResults=' + config.maxResults)
+      }
+      if (config.order) {
+        params.push('order=' + config.order)
+      }
+      if (config.channelId) {
+        params.push('channelId=' + config.channelId)
+      }
+      if (config.pageToken) {
+        params.push('pageToken=' + config.pageToken)
+      }
+      if (config.publishedAfter) {
+        params.push('publishedAfter=' + config.publishedAfter)
+      }
+      const response = await fetch(url + '?' + params.join('&'), { method: 'GET' })
+      const data = await __readJson(response)
+      if (data.error) {
+        return { success: false, error: data.error.message || 'Failed to search videos' }
+      }
+      return {
+        success: true,
+        items: data.items || [],
+        nextPageToken: data.nextPageToken,
+        totalResults: data.pageInfo && data.pageInfo.totalResults,
+      }
+    }
+    case 'get-video': {
+      const parts = config.parts || ['snippet', 'contentDetails', 'statistics']
+      const url =
+        baseUrl + 'videos?key=' + apiKey + '&id=' + config.videoId + '&part=' + parts.join(',')
+      const response = await fetch(url, { method: 'GET' })
+      const data = await __readJson(response)
+      if (data.error) {
+        return { success: false, error: data.error.message || 'Failed to get video' }
+      }
+      return { success: true, video: data.items && data.items[0] }
+    }
+    case 'list-videos': {
+      const parts = config.parts || ['snippet', 'contentDetails', 'statistics']
+      let url = baseUrl + 'videos?key=' + apiKey + '&part=' + parts.join(',')
+      if (config.chart) {
+        url = url + '&chart=' + config.chart
+      }
+      if (config.id) {
+        url = url + '&id=' + config.id.join(',')
+      }
+      if (config.maxResults) {
+        url = url + '&maxResults=' + config.maxResults
+      }
+      if (config.regionCode) {
+        url = url + '&regionCode=' + config.regionCode
+      }
+      const response = await fetch(url, { method: 'GET' })
+      const data = await __readJson(response)
+      if (data.error) {
+        return { success: false, error: data.error.message || 'Failed to list videos' }
+      }
+      return { success: true, items: data.items || [], nextPageToken: data.nextPageToken }
+    }
+    case 'get-channel': {
+      let url = baseUrl + 'channels?key=' + apiKey + '&part=snippet,statistics'
+      if (config.id) {
+        url += '&id=' + config.id
+      }
+      if (config.forUsername) {
+        url += '&forUsername=' + encodeURIComponent(config.forUsername)
+      }
+      const response = await fetch(url, { method: 'GET' })
+      const data = await __readJson(response)
+      if (data.error) {
+        return { success: false, error: data.error.message || 'Failed to get channel' }
+      }
+      return { success: true, channel: data.items && data.items[0] }
+    }
+    case 'list-playlists': {
+      let url = baseUrl + 'playlists?key=' + apiKey + '&part=snippet'
+      if (config.channelId) {
+        url += '&channelId=' + config.channelId
+      }
+      if (config.maxResults) {
+        url += '&maxResults=' + config.maxResults
+      }
+      const response = await fetch(url, { method: 'GET' })
+      const data = await __readJson(response)
+      if (data.error) {
+        return { success: false, error: data.error.message || 'Failed to list playlists' }
+      }
+      return { success: true, playlists: data.items || [] }
+    }
+    case 'get-playlist-items': {
+      let url =
+        baseUrl + 'playlistItems?key=' + apiKey + '&part=snippet&playlistId=' + config.playlistId
+      if (config.maxResults) {
+        url += '&maxResults=' + config.maxResults
+      }
+      const response = await fetch(url, { method: 'GET' })
+      const data = await __readJson(response)
+      if (data.error) {
+        return { success: false, error: data.error.message || 'Failed to get playlist items' }
+      }
+      return { success: true, items: data.items || [] }
+    }
+    case 'get-comments': {
+      let url = baseUrl + 'commentThreads?key=' + apiKey + '&part=snippet&videoId=' + config.videoId
+      if (config.maxResults) {
+        url += '&maxResults=' + config.maxResults
+      }
+      const response = await fetch(url, { method: 'GET' })
+      const data = await __readJson(response)
+      if (data.error) {
+        return { success: false, error: data.error.message || 'Failed to get comments' }
+      }
+      return { success: true, comments: data.items || [] }
+    }
+    case 'get-video-stats': {
+      const response = await fetch(
+        baseUrl + 'videos?key=' + apiKey + '&id=' + config.videoId + '&part=statistics,snippet',
+        { method: 'GET' }
+      )
+      const data = await __readJson(response)
+      if (data.error) {
+        return { success: false, error: data.error.message || 'Failed to get stats' }
+      }
+      return { success: true, video: data.items && data.items[0] }
+    }
+    default:
+      throw new Error('Unknown integration-youtube action: ' + action)
+  }
+}
+export const integrationYoutube: IntegrationHandlerGenerator = {
+  nodeType: 'integration-youtube',
+  executionEnv: 'server',
+  secretFields: ['apiKey', 'accessToken'],
+  generateHandler(): string {
+    return handlerToString(integration_youtube)
+  },
+}

package/src/nodes/integrations/integration-zendesk.ts

@@ -0,0 +1,308 @@
+import { IntegrationHandlerGenerator, handlerToString } from '../types'
+
+async function integration_zendesk(config: any, context: Record<string, unknown>) {
+  // Safely parse a fetch response: providers (Dropbox, Stripe legacy errors,
+  // Slack rate-limit pages, …) sometimes return plain text on failure.
+  // We read once as text and only parse JSON when it actually parses.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const __readJson = async (resp: any): Promise<any> => {
+    const text = await resp.text()
+    if (!text) {
+      return {}
+    }
+    try {
+      return JSON.parse(text)
+    } catch (e: unknown) {
+      void e
+      return { error_summary: text, error: text, message: text, raw: text }
+    }
+  }
+  const email = config.email
+  const apiToken = config.apiToken
+  const subdomain = config.subdomain
+  const action = config.action
+  const baseUrl = 'https://' + subdomain + '.zendesk.com/api/v2/'
+  const headers = {
+    'Content-Type': 'application/json',
+    Authorization: 'Basic ' + btoa(email + '/token:' + apiToken),
+  }
+
+  switch (action) {
+    case 'create-ticket': {
+      const ticket: Record<string, any> = {
+        subject: config.subject,
+        description: config.description,
+      }
+      if (config.priority) {
+        ticket.priority = config.priority
+      }
+      if (config.status) {
+        ticket.status = config.status
+      }
+      if (config.type) {
+        ticket.type = config.type
+      }
+      if (config.assigneeId) {
+        ticket.assignee_id = config.assigneeId
+      }
+      if (config.requesterId) {
+        ticket.requester_id = config.requesterId
+      }
+      if (config.groupId) {
+        ticket.group_id = config.groupId
+      }
+      if (config.tags) {
+        ticket.tags = config.tags
+      }
+      if (config.customFields) {
+        ticket.custom_fields = config.customFields
+      }
+      const response = await fetch(baseUrl + 'tickets.json', {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ ticket }),
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || data.description || 'Failed to create ticket',
+        }
+      }
+      return { success: true, ticket: data.ticket }
+    }
+    case 'get-ticket': {
+      const response = await fetch(baseUrl + 'tickets/' + config.ticketId + '.json', {
+        method: 'GET',
+        headers,
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return { success: false, error: data.error || 'Failed to get ticket' }
+      }
+      return { success: true, ticket: data.ticket }
+    }
+    case 'list-tickets': {
+      let url = baseUrl + 'tickets.json'
+      const params = []
+      if (config.sortBy) {
+        params.push('sort_by=' + config.sortBy)
+      }
+      if (config.sortOrder) {
+        params.push('sort_order=' + config.sortOrder)
+      }
+      if (config.perPage) {
+        params.push('per_page=' + config.perPage)
+      }
+      if (config.page) {
+        params.push('page=' + config.page)
+      }
+      if (params.length > 0) {
+        url = url + '?' + params.join('&')
+      }
+      const response = await fetch(url, { method: 'GET', headers })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return { success: false, error: data.error || 'Failed to list tickets' }
+      }
+      return {
+        success: true,
+        tickets: data.tickets || [],
+        count: data.count,
+        nextPage: data.next_page,
+      }
+    }
+    case 'update-ticket': {
+      const ticket: Record<string, any> = {}
+      if (config.subject !== undefined) {
+        ticket.subject = config.subject
+      }
+      if (config.description !== undefined) {
+        ticket.description = config.description
+      }
+      if (config.priority !== undefined) {
+        ticket.priority = config.priority
+      }
+      if (config.status !== undefined) {
+        ticket.status = config.status
+      }
+      if (config.assigneeId !== undefined) {
+        ticket.assignee_id = config.assigneeId
+      }
+      const response = await fetch(baseUrl + 'tickets/' + config.ticketId + '.json', {
+        method: 'PUT',
+        headers,
+        body: JSON.stringify({ ticket }),
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return {
+          success: false,
+          error:
+            (data.error && data.error.message) || data.description || 'Failed to update ticket',
+        }
+      }
+      return { success: true, ticket: data.ticket }
+    }
+    case 'delete-ticket': {
+      const response = await fetch(baseUrl + 'tickets/' + config.ticketId + '.json', {
+        method: 'DELETE',
+        headers,
+      })
+      if (!response.ok) {
+        const data = await __readJson(response)
+        return {
+          success: false,
+          error: (data.error && data.error.message) || 'Failed to delete ticket',
+        }
+      }
+      return { success: true }
+    }
+    case 'search-tickets': {
+      const query = config.query || 'type:ticket'
+      const response = await fetch(
+        baseUrl +
+          'search.json?query=' +
+          encodeURIComponent(query) +
+          (config.sortBy ? '&sort_by=' + config.sortBy : '') +
+          (config.sortOrder ? '&sort_order=' + config.sortOrder : ''),
+        {
+          method: 'GET',
+          headers,
+        }
+      )
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return {
+          success: false,
+          error: (data.error && data.error.message) || 'Failed to search tickets',
+        }
+      }
+      return { success: true, results: data.results || [], count: data.count }
+    }
+    case 'add-comment': {
+      const response = await fetch(baseUrl + 'tickets/' + config.ticketId + '.json', {
+        method: 'PUT',
+        headers,
+        body: JSON.stringify({
+          ticket: {
+            comment: {
+              body: config.comment,
+              public: config.public !== false,
+            },
+          },
+        }),
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return {
+          success: false,
+          error: (data.error && data.error.message) || 'Failed to add comment',
+        }
+      }
+      return { success: true, ticket: data.ticket }
+    }
+    case 'create-user': {
+      const user: Record<string, any> = { name: config.name, email: config.email }
+      if (config.verified) {
+        user.verified = config.verified
+      }
+      if (config.phone) {
+        user.phone = config.phone
+      }
+      const response = await fetch(baseUrl + 'users.json', {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ user }),
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return {
+          success: false,
+          error: (data.error && data.error.message) || 'Failed to create user',
+        }
+      }
+      return { success: true, user: data.user }
+    }
+    case 'get-user': {
+      const response = await fetch(baseUrl + 'users/' + config.userId + '.json', {
+        method: 'GET',
+        headers,
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return { success: false, error: (data.error && data.error.message) || 'Failed to get user' }
+      }
+      return { success: true, user: data.user }
+    }
+    case 'update-user': {
+      const user: Record<string, any> = {}
+      if (config.name !== undefined) {
+        user.name = config.name
+      }
+      if (config.email !== undefined) {
+        user.email = config.email
+      }
+      const response = await fetch(baseUrl + 'users/' + config.userId + '.json', {
+        method: 'PUT',
+        headers,
+        body: JSON.stringify({ user }),
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return {
+          success: false,
+          error: (data.error && data.error.message) || 'Failed to update user',
+        }
+      }
+      return { success: true, user: data.user }
+    }
+    case 'create-organization': {
+      const response = await fetch(baseUrl + 'organizations.json', {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          organization: {
+            name: config.name,
+            details: config.details || '',
+            notes: config.notes || '',
+          },
+        }),
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return {
+          success: false,
+          error: (data.error && data.error.message) || 'Failed to create organization',
+        }
+      }
+      return { success: true, organization: data.organization }
+    }
+    case 'get-organization': {
+      // Schema canonical name is `organizationId`; older workflows used `orgId`. Accept either.
+      const zendeskOrgId = config.organizationId || config.orgId
+      const response = await fetch(baseUrl + 'organizations/' + zendeskOrgId + '.json', {
+        method: 'GET',
+        headers,
+      })
+      const data = await __readJson(response)
+      if (!response.ok) {
+        return {
+          success: false,
+          error: (data.error && data.error.message) || 'Failed to get organization',
+        }
+      }
+      return { success: true, organization: data.organization }
+    }
+    default:
+      throw new Error('Unknown integration-zendesk action: ' + action)
+  }
+}
+export const integrationZendesk: IntegrationHandlerGenerator = {
+  nodeType: 'integration-zendesk',
+  executionEnv: 'server',
+  secretFields: ['email', 'apiToken', 'subdomain'],
+  generateHandler(): string {
+    return handlerToString(integration_zendesk)
+  },
+}

package/src/nodes/navigation/navigation-go-back.ts

@@ -0,0 +1,14 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function navigation_go_back(config: any, context: Record<string, unknown>) {
+  window.history.back()
+  return { __terminal: true }
+}
+export const navigationGoBack: NodeHandlerGenerator = {
+  nodeType: 'navigation-go-back',
+  executionEnv: 'client',
+  isTerminal: true,
+  generateHandler(): string {
+    return handlerToString(navigation_go_back)
+  },
+}