♻️ Introduce typebot v6 with events (#1013)

Closes #885

packages/bot-engine/startBotFlow.ts

@@ -1,36 +1,71 @@
 import { TRPCError } from '@trpc/server'
-import { ChatReply, SessionState } from '@typebot.io/schemas'
+import { ChatReply, SessionState, StartElementId } from '@typebot.io/schemas'
 import { executeGroup } from './executeGroup'
 import { getNextGroup } from './getNextGroup'
+import { VisitedEdge } from '@typebot.io/prisma'
 
 type Props = {
   version: 1 | 2
   state: SessionState
-  startGroupId?: string
-}
+} & StartElementId
 
 export const startBotFlow = async ({
   version,
   state,
-  startGroupId,
-}: Props): Promise<ChatReply & { newSessionState: SessionState }> => {
+  ...props
+}: Props): Promise<
+  ChatReply & { newSessionState: SessionState; visitedEdges: VisitedEdge[] }
+> => {
   let newSessionState = state
-  if (startGroupId) {
+  const visitedEdges: VisitedEdge[] = []
+  if ('startGroupId' in props) {
     const group = state.typebotsQueue[0].typebot.groups.find(
-      (group) => group.id === startGroupId
+      (group) => group.id === props.startGroupId
     )
     if (!group)
       throw new TRPCError({
         code: 'BAD_REQUEST',
-        message: "startGroupId doesn't exist",
+        message: "Start group doesn't exist",
       })
-    return executeGroup(group, { version, state: newSessionState })
+    return executeGroup(group, {
+      version,
+      state: newSessionState,
+      visitedEdges,
+    })
   }
-  const firstEdgeId =
-    newSessionState.typebotsQueue[0].typebot.groups[0].blocks[0].outgoingEdgeId
-  if (!firstEdgeId) return { messages: [], newSessionState }
+  const firstEdgeId = getFirstEdgeId({
+    state: newSessionState,
+    startEventId: 'startEventId' in props ? props.startEventId : undefined,
+  })
+  if (!firstEdgeId) return { messages: [], newSessionState, visitedEdges: [] }
   const nextGroup = await getNextGroup(newSessionState)(firstEdgeId)
   newSessionState = nextGroup.newSessionState
-  if (!nextGroup.group) return { messages: [], newSessionState }
-  return executeGroup(nextGroup.group, { version, state: newSessionState })
+  if (nextGroup.visitedEdge) visitedEdges.push(nextGroup.visitedEdge)
+  if (!nextGroup.group) return { messages: [], newSessionState, visitedEdges }
+  return executeGroup(nextGroup.group, {
+    version,
+    state: newSessionState,
+    visitedEdges,
+  })
+}
+
+const getFirstEdgeId = ({
+  state,
+  startEventId,
+}: {
+  state: SessionState
+  startEventId: string | undefined
+}) => {
+  const { typebot } = state.typebotsQueue[0]
+  if (startEventId) {
+    const event = typebot.events?.find((e) => e.id === startEventId)
+    if (!event)
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: "Start event doesn't exist",
+      })
+    return event.outgoingEdgeId
+  }
+  if (typebot.version === '6') return typebot.events[0].outgoingEdgeId
+  return typebot.groups[0].blocks[0].outgoingEdgeId
 }