🐛 (webhook) Fix parent linked typebot data parsing in webhook

apps/viewer/src/features/blocks/integrations/sendEmail/api/utils/executeSendEmailBlock.tsx

@@ -1,4 +1,3 @@
-import { getLinkedTypebots } from '@/features/blocks/logic/typebotLink/api'
 import { ExecuteIntegrationResponse } from '@/features/chat'
 import { saveErrorLog, saveSuccessLog } from '@/features/logs/api'
 import { parseVariables } from '@/features/variables'
@@ -183,13 +182,12 @@ const getEmailBody = async ({
     where: { typebotId },
   })) as unknown as PublicTypebot
   if (!typebot) return
-  const linkedTypebots = await getLinkedTypebots(typebot)
   const resultValues = (await prisma.result.findUnique({
     where: { id: resultId },
     include: { answers: true },
   })) as ResultValues | null
   if (!resultValues) return
-  const answers = parseAnswers(typebot, linkedTypebots)(resultValues)
+  const answers = parseAnswers(typebot, [])(resultValues)
   return {
     html: render(
       <DefaultBotNotificationEmail

apps/viewer/src/features/blocks/integrations/webhook/api/utils/executeWebhookBlock.ts

@@ -24,7 +24,6 @@ import { stringify } from 'qs'
 import { byId, omit, parseAnswers } from 'utils'
 import got, { Method, Headers, HTTPError } from 'got'
 import { getResultValues } from '@/features/results/api'
-import { getLinkedTypebots } from '@/features/blocks/logic/typebotLink/api'
 import { parseSampleResult } from './parseSampleResult'
 
 export const executeWebhookBlock = async (
@@ -45,7 +44,7 @@ export const executeWebhookBlock = async (
   const preparedWebhook = prepareWebhookAttributes(webhook, block.options)
   const resultValues = await getResultValues(result.id)
   if (!resultValues) return { outgoingEdgeId: block.outgoingEdgeId }
-  const webhookResponse = await executeWebhook(typebot)(
+  const webhookResponse = await executeWebhook({ typebot })(
     preparedWebhook,
     typebot.variables,
     block.groupId,
@@ -112,7 +111,7 @@ const prepareWebhookAttributes = (
 const checkIfBodyIsAVariable = (body: string) => /^{{.+}}$/.test(body)
 
 export const executeWebhook =
-  (typebot: SessionState['typebot']) =>
+  ({ typebot }: Pick<SessionState, 'typebot'>) =>
   async (
     webhook: Webhook,
     variables: Variable[],
@@ -148,11 +147,10 @@ export const executeWebhook =
       convertKeyValueTableToObject(webhook.queryParams, variables)
     )
     const contentType = headers ? headers['Content-Type'] : undefined
-    const linkedTypebots = await getLinkedTypebots(typebot)
 
     const bodyContent = await getBodyContent(
       typebot,
-      linkedTypebots
+      []
     )({
       body: webhook.body,
       resultValues,

apps/viewer/src/features/blocks/logic/typebotLink/api/utils/getLinkedTypebots.ts

@@ -1,41 +1,20 @@
 import prisma from '@/lib/prisma'
-import { canReadTypebots } from '@/utils/api/dbRules'
-import { User } from 'db'
-import {
-  LogicBlockType,
-  PublicTypebot,
-  Typebot,
-  TypebotLinkBlock,
-} from 'models'
-import { isDefined } from 'utils'
+import { PublicTypebot, Typebot } from 'models'
 
-export const getLinkedTypebots = async (
-  typebot: Pick<PublicTypebot, 'groups'>,
-  user?: User
-): Promise<(Typebot | PublicTypebot)[]> => {
-  const linkedTypebotIds = (
-    typebot.groups
-      .flatMap((g) => g.blocks)
-      .filter(
-        (s) =>
-          s.type === LogicBlockType.TYPEBOT_LINK &&
-          isDefined(s.options.typebotId)
-      ) as TypebotLinkBlock[]
-  ).map((s) => s.options.typebotId as string)
-  if (linkedTypebotIds.length === 0) return []
-  const typebots = (await ('typebotId' in typebot
-    ? prisma.publicTypebot.findMany({
-        where: { id: { in: linkedTypebotIds } },
-      })
-    : prisma.typebot.findMany({
-        where: user
-          ? {
-              AND: [
-                { id: { in: linkedTypebotIds } },
-                canReadTypebots(linkedTypebotIds, user as User),
-              ],
-            }
-          : { id: { in: linkedTypebotIds } },
-      }))) as unknown as (Typebot | PublicTypebot)[]
-  return typebots
+type Props = {
+  isPreview: boolean
+  typebotIds: string[]
+}
+
+export const getLinkedTypebots = async ({ isPreview, typebotIds }: Props) => {
+  const linkedTypebots = (
+    isPreview
+      ? await prisma.typebot.findMany({
+          where: { id: { in: typebotIds } },
+        })
+      : await prisma.publicTypebot.findMany({
+          where: { id: { in: typebotIds } },
+        })
+  ) as (Typebot | PublicTypebot)[]
+  return linkedTypebots
 }

apps/viewer/src/features/blocks/logic/typebotLink/api/utils/getLinkedTypebotsChildren.ts

@@ -0,0 +1,63 @@
+import prisma from '@/lib/prisma'
+import { canReadTypebots } from '@/utils/api/dbRules'
+import { User } from 'db'
+import {
+  LogicBlockType,
+  PublicTypebot,
+  Typebot,
+  TypebotLinkBlock,
+} from 'models'
+import { isDefined } from 'utils'
+
+type Props = {
+  typebots: Pick<PublicTypebot, 'groups'>[]
+  user?: User
+  isPreview?: boolean
+}
+
+export const getLinkedTypebotsChildren =
+  ({ typebots, user, isPreview }: Props) =>
+  async (
+    capturedLinkedBots: (Typebot | PublicTypebot)[]
+  ): Promise<(Typebot | PublicTypebot)[]> => {
+    const linkedTypebotIds = typebots
+      .flatMap((typebot) =>
+        (
+          typebot.groups
+            .flatMap((group) => group.blocks)
+            .filter(
+              (block) =>
+                block.type === LogicBlockType.TYPEBOT_LINK &&
+                isDefined(block.options.typebotId) &&
+                !capturedLinkedBots.some(
+                  (bot) =>
+                    ('typebotId' in bot ? bot.typebotId : bot.id) ===
+                    block.options.typebotId
+                )
+            ) as TypebotLinkBlock[]
+        ).map((s) => s.options.typebotId)
+      )
+      .filter(isDefined)
+    if (linkedTypebotIds.length === 0) return capturedLinkedBots
+    const linkedTypebots = (
+      isPreview
+        ? await prisma.typebot.findMany({
+            where: user
+              ? {
+                  AND: [
+                    { id: { in: linkedTypebotIds } },
+                    canReadTypebots(linkedTypebotIds, user as User),
+                  ],
+                }
+              : { id: { in: linkedTypebotIds } },
+          })
+        : await prisma.publicTypebot.findMany({
+            where: { id: { in: linkedTypebotIds } },
+          })
+    ) as (Typebot | PublicTypebot)[]
+    return getLinkedTypebotsChildren({
+      typebots: linkedTypebots,
+      user,
+      isPreview,
+    })([...capturedLinkedBots, ...linkedTypebots])
+  }

apps/viewer/src/features/blocks/logic/typebotLink/api/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './executeTypebotLink'
 export * from './getLinkedTypebots'
+export * from './getLinkedTypebotsChildren'