@teleporthq/teleport-plugin-next-workflows 0.43.1

package/src/nodes/payment/payment-create-customer.ts

@@ -0,0 +1,64 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_create_customer(config: any, _context: Record<string, unknown>) {
+  const provider = config.provider || 'stripe'
+  const email = config.email
+  const name = config.name
+  const metadata = config.metadata || {}
+
+  if (!email) {
+    return { customerId: '', provider, error: 'Email is required to create a customer' }
+  }
+
+  if (provider === 'paypal') {
+    return { customerId: email, provider: 'paypal' }
+  }
+
+  const secretKey = config.secretKey
+  if (!secretKey) {
+    return { customerId: '', provider: 'stripe', error: 'Stripe secret key is required' }
+  }
+
+  try {
+    const params = new URLSearchParams()
+    params.append('email', email)
+    if (name) {
+      params.append('name', name)
+    }
+
+    const metaKeys = Object.keys(metadata)
+    for (let i = 0; i < metaKeys.length; i++) {
+      params.append('metadata[' + metaKeys[i] + ']', String(metadata[metaKeys[i]]))
+    }
+
+    const response = await fetch('https://api.stripe.com/v1/customers', {
+      method: 'POST',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: params.toString(),
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        customerId: '',
+        provider: 'stripe',
+        error: data.error ? data.error.message : 'Create customer failed',
+      }
+    }
+
+    return { customerId: data.id || '', provider: 'stripe' }
+  } catch (err: unknown) {
+    return { customerId: '', provider: 'stripe', error: (err as Error).message }
+  }
+}
+export const paymentCreateCustomer: NodeHandlerGenerator = {
+  nodeType: 'payment-create-customer',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_create_customer)
+  },
+}

package/src/nodes/payment/payment-create-product.ts

@@ -0,0 +1,69 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_create_product(config: any, context: Record<string, unknown>) {
+  const name = config.name
+  const description = config.description || ''
+  const price = config.price
+  const currency = config.currency || 'usd'
+  const secretKey = config.secretKey
+
+  try {
+    const productParams = new URLSearchParams()
+    productParams.append('name', name)
+    if (description) {
+      productParams.append('description', description)
+    }
+
+    const productResponse = await fetch('https://api.stripe.com/v1/products', {
+      method: 'POST',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: productParams.toString(),
+    })
+
+    const productData = await productResponse.json()
+
+    if (!productResponse.ok) {
+      return {
+        productId: '',
+        error: productData.error ? productData.error.message : 'Create product failed',
+      }
+    }
+
+    const priceParams = new URLSearchParams()
+    priceParams.append('product', productData.id)
+    priceParams.append('unit_amount', String(price))
+    priceParams.append('currency', currency)
+
+    const priceResponse = await fetch('https://api.stripe.com/v1/prices', {
+      method: 'POST',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: priceParams.toString(),
+    })
+
+    const priceData = await priceResponse.json()
+
+    if (!priceResponse.ok) {
+      return {
+        productId: productData.id,
+        error: priceData.error ? priceData.error.message : 'Create price failed',
+      }
+    }
+
+    return { productId: productData.id || '' }
+  } catch (err: unknown) {
+    return { productId: '', error: (err as Error).message }
+  }
+}
+export const paymentCreateProduct: NodeHandlerGenerator = {
+  nodeType: 'payment-create-product',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_create_product)
+  },
+}

package/src/nodes/payment/payment-create-subscription.ts

@@ -0,0 +1,42 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_create_subscription(config: any, context: Record<string, unknown>) {
+  const customerId = config.customerId
+  const planId = config.planId
+  const secretKey = config.secretKey
+
+  try {
+    const params = new URLSearchParams()
+    params.append('customer', customerId)
+    params.append('items[0][price]', planId)
+
+    const response = await fetch('https://api.stripe.com/v1/subscriptions', {
+      method: 'POST',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: params.toString(),
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        subscriptionId: '',
+        error: data.error ? data.error.message : 'Create subscription failed',
+      }
+    }
+
+    return { subscriptionId: data.id || '' }
+  } catch (err: unknown) {
+    return { subscriptionId: '', error: (err as Error).message }
+  }
+}
+export const paymentCreateSubscription: NodeHandlerGenerator = {
+  nodeType: 'payment-create-subscription',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_create_subscription)
+  },
+}

package/src/nodes/payment/payment-get-customer.ts

@@ -0,0 +1,32 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_get_customer(config: any, context: Record<string, unknown>) {
+  const customerId = config.customerId
+  const secretKey = config.secretKey
+
+  try {
+    const response = await fetch('https://api.stripe.com/v1/customers/' + customerId, {
+      method: 'GET',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+      },
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return { customer: null, error: data.error ? data.error.message : 'Get customer failed' }
+    }
+
+    return { customer: data }
+  } catch (err: unknown) {
+    return { customer: null, error: (err as Error).message }
+  }
+}
+export const paymentGetCustomer: NodeHandlerGenerator = {
+  nodeType: 'payment-get-customer',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_get_customer)
+  },
+}

package/src/nodes/payment/payment-get-product.ts

@@ -0,0 +1,32 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_get_product(config: any, context: Record<string, unknown>) {
+  const productId = config.productId
+  const secretKey = config.secretKey
+
+  try {
+    const response = await fetch('https://api.stripe.com/v1/products/' + productId, {
+      method: 'GET',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+      },
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return { product: null, error: data.error ? data.error.message : 'Get product failed' }
+    }
+
+    return { product: data }
+  } catch (err: unknown) {
+    return { product: null, error: (err as Error).message }
+  }
+}
+export const paymentGetProduct: NodeHandlerGenerator = {
+  nodeType: 'payment-get-product',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_get_product)
+  },
+}

package/src/nodes/payment/payment-list-customers.ts

@@ -0,0 +1,39 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_list_customers(config: any, context: Record<string, unknown>) {
+  const limit = config.limit || 10
+  const offset = config.offset
+  const secretKey = config.secretKey
+
+  try {
+    const params = new URLSearchParams()
+    params.append('limit', String(limit))
+    if (offset) {
+      params.append('starting_after', offset)
+    }
+
+    const response = await fetch('https://api.stripe.com/v1/customers?' + params.toString(), {
+      method: 'GET',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+      },
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return { customers: [], error: data.error ? data.error.message : 'List customers failed' }
+    }
+
+    return { customers: data.data || [] }
+  } catch (err: unknown) {
+    return { customers: [], error: (err as Error).message }
+  }
+}
+export const paymentListCustomers: NodeHandlerGenerator = {
+  nodeType: 'payment-list-customers',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_list_customers)
+  },
+}

package/src/nodes/payment/payment-list-plans.ts

@@ -0,0 +1,39 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_list_plans(config: any, context: Record<string, unknown>) {
+  const limit = config.limit || 10
+  const offset = config.offset
+  const secretKey = config.secretKey
+
+  try {
+    const params = new URLSearchParams()
+    params.append('limit', String(limit))
+    if (offset) {
+      params.append('starting_after', offset)
+    }
+
+    const response = await fetch('https://api.stripe.com/v1/prices?' + params.toString(), {
+      method: 'GET',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+      },
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return { plans: [], error: data.error ? data.error.message : 'List plans failed' }
+    }
+
+    return { plans: data.data || [] }
+  } catch (err: unknown) {
+    return { plans: [], error: (err as Error).message }
+  }
+}
+export const paymentListPlans: NodeHandlerGenerator = {
+  nodeType: 'payment-list-plans',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_list_plans)
+  },
+}

package/src/nodes/payment/payment-list-products.ts

@@ -0,0 +1,39 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_list_products(config: any, context: Record<string, unknown>) {
+  const limit = config.limit || 10
+  const offset = config.offset
+  const secretKey = config.secretKey
+
+  try {
+    const params = new URLSearchParams()
+    params.append('limit', String(limit))
+    if (offset) {
+      params.append('starting_after', offset)
+    }
+
+    const response = await fetch('https://api.stripe.com/v1/products?' + params.toString(), {
+      method: 'GET',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+      },
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return { products: [], error: data.error ? data.error.message : 'List products failed' }
+    }
+
+    return { products: data.data || [] }
+  } catch (err: unknown) {
+    return { products: [], error: (err as Error).message }
+  }
+}
+export const paymentListProducts: NodeHandlerGenerator = {
+  nodeType: 'payment-list-products',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_list_products)
+  },
+}

package/src/nodes/payment/payment-list-subscriptions.ts

@@ -0,0 +1,44 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_list_subscriptions(config: any, context: Record<string, unknown>) {
+  const customerId = config.customerId
+  const limit = config.limit || 10
+  const offset = config.offset
+  const secretKey = config.secretKey
+
+  try {
+    const params = new URLSearchParams()
+    params.append('customer', customerId)
+    params.append('limit', String(limit))
+    if (offset) {
+      params.append('starting_after', offset)
+    }
+
+    const response = await fetch('https://api.stripe.com/v1/subscriptions?' + params.toString(), {
+      method: 'GET',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+      },
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        subscriptions: [],
+        error: data.error ? data.error.message : 'List subscriptions failed',
+      }
+    }
+
+    return { subscriptions: data.data || [] }
+  } catch (err: unknown) {
+    return { subscriptions: [], error: (err as Error).message }
+  }
+}
+export const paymentListSubscriptions: NodeHandlerGenerator = {
+  nodeType: 'payment-list-subscriptions',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_list_subscriptions)
+  },
+}

package/src/nodes/payment/payment-subscribe-to-plan.ts

@@ -0,0 +1,46 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_subscribe_to_plan(config: any, context: Record<string, unknown>) {
+  const planId = config.planId
+  const customerId = config.customerId
+  const secretKey = config.secretKey
+
+  try {
+    const params = new URLSearchParams()
+    params.append('customer', customerId)
+    params.append('items[0][price]', planId)
+
+    const response = await fetch('https://api.stripe.com/v1/subscriptions', {
+      method: 'POST',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: params.toString(),
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        subscriptionId: '',
+        status: 'failed',
+        error: data.error ? data.error.message : 'Subscription failed',
+      }
+    }
+
+    return {
+      subscriptionId: data.id || '',
+      status: data.status || '',
+    }
+  } catch (err: unknown) {
+    return { subscriptionId: '', status: 'failed', error: (err as Error).message }
+  }
+}
+export const paymentSubscribeToPlan: NodeHandlerGenerator = {
+  nodeType: 'payment-subscribe-to-plan',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_subscribe_to_plan)
+  },
+}

package/src/nodes/payment/payment-update-customer.ts

@@ -0,0 +1,50 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function payment_update_customer(config: any, context: Record<string, unknown>) {
+  const customerId = config.customerId
+  const fields = config.fields || {}
+  const secretKey = config.secretKey
+
+  try {
+    const params = new URLSearchParams()
+    const fieldKeys = Object.keys(fields)
+    for (let i = 0; i < fieldKeys.length; i++) {
+      const key = fieldKeys[i]
+      const val = fields[key]
+      if (typeof val === 'object' && val !== null) {
+        const subKeys = Object.keys(val)
+        for (let j = 0; j < subKeys.length; j++) {
+          params.append(key + '[' + subKeys[j] + ']', String(val[subKeys[j]]))
+        }
+      } else {
+        params.append(key, String(val))
+      }
+    }
+
+    const response = await fetch('https://api.stripe.com/v1/customers/' + customerId, {
+      method: 'POST',
+      headers: {
+        Authorization: 'Bearer ' + secretKey,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: params.toString(),
+    })
+
+    const data = await response.json()
+
+    if (!response.ok) {
+      return { customer: null, error: data.error ? data.error.message : 'Update customer failed' }
+    }
+
+    return { customer: data }
+  } catch (err: unknown) {
+    return { customer: null, error: (err as Error).message }
+  }
+}
+export const paymentUpdateCustomer: NodeHandlerGenerator = {
+  nodeType: 'payment-update-customer',
+  executionEnv: 'server',
+  generateHandler(): string {
+    return handlerToString(payment_update_customer)
+  },
+}

package/src/nodes/realtime/realtime-join-channel.ts

@@ -0,0 +1,85 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function realtime_join_channel(config: any, context: Record<string, unknown>) {
+  const channelName = config.channelName
+  if (!channelName) {
+    return { success: false, error: 'channelName is required' }
+  }
+
+  const rt = typeof window !== 'undefined' ? (window as any).__teleportRealtime : null
+  const userId = rt ? rt.getUserId() : 'anon'
+  const userName = rt ? rt.getUserName() : 'Anonymous'
+  const channelData = config.channelData || undefined
+  let parsedChannelData
+  if (channelData && typeof channelData === 'string') {
+    try {
+      parsedChannelData = JSON.parse(channelData)
+    } catch (e) {
+      parsedChannelData = undefined
+    }
+  } else if (channelData && typeof channelData === 'object') {
+    parsedChannelData = channelData
+  }
+
+  try {
+    const baseUrl = (context && (context as any).__baseUrl) || ''
+    const joinRes = await fetch(baseUrl + '/api/realtime/join', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        channelName,
+        userId,
+        userName,
+        userData: parsedChannelData,
+      }),
+    })
+    const joinData = await joinRes.json()
+
+    if (!joinRes.ok) {
+      return {
+        success: false,
+        error: (joinData.error && joinData.error.message) || 'Failed to join channel',
+        errorCode: joinData.error && joinData.error.code,
+      }
+    }
+
+    if (rt) {
+      const client = rt.initializeClient(joinData)
+      if (client) {
+        await rt.whenReady()
+        const nsChannelName = rt.getNamespacedChannelName(channelName)
+        const channel = client.channels.get(nsChannelName)
+        await channel.attach()
+        try {
+          await channel.presence.enter({
+            userId,
+            userName,
+            userData: parsedChannelData,
+          })
+        } catch (presErr: unknown) {
+          /* presence enter may fail if capabilities don't include it */
+        }
+        rt.incrementChannelRef(nsChannelName)
+      }
+    }
+
+    return {
+      channelName,
+      success: true,
+      memberCount: joinData.memberCount || 0,
+      namespace: joinData.namespace || '',
+      timestamp: Date.now(),
+    }
+  } catch (err: unknown) {
+    return { success: false, error: (err as Error).message || 'Failed to join channel' }
+  }
+}
+
+export const realtimeJoinChannel: NodeHandlerGenerator = {
+  nodeType: 'realtime-join-channel',
+  executionEnv: 'client',
+  dependencies: { ably: '^2.6.0' },
+  generateHandler(): string {
+    return handlerToString(realtime_join_channel)
+  },
+}

package/src/nodes/realtime/realtime-leave-channel.ts

@@ -0,0 +1,61 @@
+import { NodeHandlerGenerator, handlerToString } from '../types'
+
+async function realtime_leave_channel(config: any, context: Record<string, unknown>) {
+  const channelName = config.channelName
+  if (!channelName) {
+    return { success: false, error: 'channelName is required' }
+  }
+
+  const rt = typeof window !== 'undefined' ? (window as any).__teleportRealtime : null
+  const userId = rt ? rt.getUserId() : 'anon'
+
+  try {
+    const baseUrl = (context && (context as any).__baseUrl) || ''
+    const leaveRes = await fetch(baseUrl + '/api/realtime/leave', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ channelName, userId }),
+    })
+    const leaveData = await leaveRes.json()
+    const serverError = !leaveRes.ok
+      ? (leaveData.error && leaveData.error.message) || 'Server leave failed'
+      : null
+
+    if (rt) {
+      await rt.whenReady()
+      const client = rt.getAblyClient()
+      if (client) {
+        const nsChannelName = rt.getNamespacedChannelName(channelName)
+        const channel = client.channels.get(nsChannelName)
+
+        try {
+          await channel.presence.leave()
+        } catch (e: unknown) {
+          /* ignore */
+        }
+
+        const remaining = rt.decrementChannelRef(nsChannelName)
+        if (remaining === 0) {
+          await channel.detach()
+        }
+      }
+    }
+
+    return {
+      channelName,
+      success: !serverError,
+      serverError: serverError || undefined,
+      timestamp: Date.now(),
+    }
+  } catch (err: unknown) {
+    return { success: false, error: (err as Error).message || 'Failed to leave channel' }
+  }
+}
+
+export const realtimeLeaveChannel: NodeHandlerGenerator = {
+  nodeType: 'realtime-leave-channel',
+  executionEnv: 'client',
+  generateHandler(): string {
+    return handlerToString(realtime_leave_channel)
+  },
+}