feat(editor): ✨ Team workspaces

apps/viewer/pages/api/typebots.ts

@@ -9,7 +9,7 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
     const user = await authenticateUser(req)
     if (!user) return res.status(401).json({ message: 'Not authenticated' })
     const typebots = await prisma.typebot.findMany({
-      where: { ownerId: user.id },
+      where: { workspace: { members: { some: { userId: user.id } } } },
       select: { name: true, publishedTypebotId: true, id: true },
     })
     return res.send({ typebots })

apps/viewer/pages/api/typebots/[typebotId]/blocks/[blockId]/sampleResult.ts

@@ -6,13 +6,16 @@ import { parseSampleResult } from 'services/api/webhooks'
 import { methodNotAllowed } from 'utils'
 
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  const user = await authenticateUser(req)
+  if (!user) return res.status(401).json({ message: 'Not authenticated' })
   if (req.method === 'GET') {
-    const user = await authenticateUser(req)
-    if (!user) return res.status(401).json({ message: 'Not authenticated' })
     const typebotId = req.query.typebotId.toString()
     const stepId = req.query.blockId.toString()
-    const typebot = (await prisma.typebot.findUnique({
-      where: { id_ownerId: { id: typebotId, ownerId: user.id } },
+    const typebot = (await prisma.typebot.findFirst({
+      where: {
+        id: typebotId,
+        workspace: { members: { some: { userId: user.id } } },
+      },
     })) as unknown as Typebot | undefined
     if (!typebot) return res.status(400).send({ message: 'Typebot not found' })
     const step = typebot.blocks

apps/viewer/pages/api/typebots/[typebotId]/blocks/[blockId]/steps/[stepId]/sampleResult.ts

@@ -6,13 +6,16 @@ import { parseSampleResult } from 'services/api/webhooks'
 import { methodNotAllowed } from 'utils'
 
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  const user = await authenticateUser(req)
+  if (!user) return res.status(401).json({ message: 'Not authenticated' })
   if (req.method === 'GET') {
-    const user = await authenticateUser(req)
-    if (!user) return res.status(401).json({ message: 'Not authenticated' })
     const typebotId = req.query.typebotId.toString()
     const blockId = req.query.blockId.toString()
-    const typebot = (await prisma.typebot.findUnique({
-      where: { id_ownerId: { id: typebotId, ownerId: user.id } },
+    const typebot = (await prisma.typebot.findFirst({
+      where: {
+        id: typebotId,
+        workspace: { members: { some: { userId: user.id } } },
+      },
     })) as unknown as Typebot | undefined
     if (!typebot) return res.status(400).send({ message: 'Typebot not found' })
     const linkedTypebots = await getLinkedTypebots(typebot, user)

apps/viewer/pages/api/typebots/[typebotId]/blocks/[blockId]/steps/[stepId]/subscribeWebhook.ts

@@ -6,9 +6,9 @@ import { authenticateUser } from 'services/api/utils'
 import { byId, methodNotAllowed } from 'utils'
 
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  const user = await authenticateUser(req)
+  if (!user) return res.status(401).json({ message: 'Not authenticated' })
   if (req.method === 'POST') {
-    const user = await authenticateUser(req)
-    if (!user) return res.status(401).json({ message: 'Not authenticated' })
     const body = req.body as Record<string, string>
     if (!('url' in body))
       return res.status(403).send({ message: 'url is missing in body' })
@@ -16,8 +16,11 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
     const typebotId = req.query.typebotId.toString()
     const blockId = req.query.blockId.toString()
     const stepId = req.query.stepId.toString()
-    const typebot = (await prisma.typebot.findUnique({
-      where: { id_ownerId: { id: typebotId, ownerId: user.id } },
+    const typebot = (await prisma.typebot.findFirst({
+      where: {
+        id: typebotId,
+        workspace: { members: { some: { userId: user.id } } },
+      },
     })) as unknown as Typebot | undefined
     if (!typebot) return res.status(400).send({ message: 'Typebot not found' })
     try {

apps/viewer/pages/api/typebots/[typebotId]/blocks/[blockId]/steps/[stepId]/unsubscribeWebhook.ts

@@ -6,14 +6,17 @@ import { authenticateUser } from 'services/api/utils'
 import { byId, methodNotAllowed } from 'utils'
 
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  const user = await authenticateUser(req)
+  if (!user) return res.status(401).json({ message: 'Not authenticated' })
   if (req.method === 'POST') {
-    const user = await authenticateUser(req)
-    if (!user) return res.status(401).json({ message: 'Not authenticated' })
     const typebotId = req.query.typebotId.toString()
     const blockId = req.query.blockId.toString()
     const stepId = req.query.stepId.toString()
-    const typebot = (await prisma.typebot.findUnique({
-      where: { id_ownerId: { id: typebotId, ownerId: user.id } },
+    const typebot = (await prisma.typebot.findFirst({
+      where: {
+        id: typebotId,
+        workspace: { members: { some: { userId: user.id } } },
+      },
     })) as unknown as Typebot | undefined
     if (!typebot) return res.status(400).send({ message: 'Typebot not found' })
     try {

apps/viewer/pages/api/typebots/[typebotId]/blocks/[blockId]/subscribeWebhook.ts

@@ -6,17 +6,20 @@ import { authenticateUser } from 'services/api/utils'
 import { byId, methodNotAllowed } from 'utils'
 
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  const user = await authenticateUser(req)
+  if (!user) return res.status(401).json({ message: 'Not authenticated' })
   if (req.method === 'POST') {
-    const user = await authenticateUser(req)
-    if (!user) return res.status(401).json({ message: 'Not authenticated' })
     const body = req.body as Record<string, string>
     if (!('url' in body))
       return res.status(403).send({ message: 'url is missing in body' })
     const { url } = body
     const typebotId = req.query.typebotId.toString()
     const stepId = req.query.blockId.toString()
-    const typebot = (await prisma.typebot.findUnique({
-      where: { id_ownerId: { id: typebotId, ownerId: user.id } },
+    const typebot = (await prisma.typebot.findFirst({
+      where: {
+        id: typebotId,
+        workspace: { members: { some: { userId: user.id } } },
+      },
     })) as unknown as Typebot | undefined
     if (!typebot) return res.status(400).send({ message: 'Typebot not found' })
     try {

apps/viewer/pages/api/typebots/[typebotId]/blocks/[blockId]/unsubscribeWebhook.ts

@@ -6,13 +6,16 @@ import { authenticateUser } from 'services/api/utils'
 import { byId, methodNotAllowed } from 'utils'
 
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  const user = await authenticateUser(req)
+  if (!user) return res.status(401).json({ message: 'Not authenticated' })
   if (req.method === 'POST') {
-    const user = await authenticateUser(req)
-    if (!user) return res.status(401).json({ message: 'Not authenticated' })
     const typebotId = req.query.typebotId.toString()
     const stepId = req.query.blockId.toString()
-    const typebot = (await prisma.typebot.findUnique({
-      where: { id_ownerId: { id: typebotId, ownerId: user.id } },
+    const typebot = (await prisma.typebot.findFirst({
+      where: {
+        id: typebotId,
+        workspace: { members: { some: { userId: user.id } } },
+      },
     })) as unknown as Typebot | undefined
     if (!typebot) return res.status(400).send({ message: 'Typebot not found' })
     try {

apps/viewer/pages/api/typebots/[typebotId]/results.ts

@@ -9,13 +9,14 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
     const user = await authenticateUser(req)
     if (!user) return res.status(401).json({ message: 'Not authenticated' })
     const typebotId = req.query.typebotId.toString()
-    const typebot = await prisma.typebot.findUnique({
-      where: { id_ownerId: { id: typebotId, ownerId: user.id } },
-    })
-    if (!typebot) return res.status(400).send({ message: 'Typebot not found' })
     const limit = Number(req.query.limit)
     const results = (await prisma.result.findMany({
-      where: { typebotId: typebot.id },
+      where: {
+        typebot: {
+          id: typebotId,
+          workspace: { members: { some: { userId: user.id } } },
+        },
+      },
       orderBy: { createdAt: 'desc' },
       take: limit,
       include: { answers: true },

apps/viewer/pages/api/typebots/[typebotId]/webhookBlocks.ts

@@ -10,8 +10,11 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
     const user = await authenticateUser(req)
     if (!user) return res.status(401).json({ message: 'Not authenticated' })
     const typebotId = req.query.typebotId.toString()
-    const typebot = await prisma.typebot.findUnique({
-      where: { id_ownerId: { id: typebotId, ownerId: user.id } },
+    const typebot = await prisma.typebot.findFirst({
+      where: {
+        id: typebotId,
+        workspace: { members: { some: { userId: user.id } } },
+      },
       select: { blocks: true, webhooks: true },
     })
     const emptyWebhookSteps = (typebot?.blocks as Block[]).reduce<

apps/viewer/pages/api/typebots/[typebotId]/webhookSteps.ts

@@ -10,8 +10,11 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
     const user = await authenticateUser(req)
     if (!user) return res.status(401).json({ message: 'Not authenticated' })
     const typebotId = req.query.typebotId.toString()
-    const typebot = await prisma.typebot.findUnique({
-      where: { id_ownerId: { id: typebotId, ownerId: user.id } },
+    const typebot = await prisma.typebot.findFirst({
+      where: {
+        id: typebotId,
+        workspace: { members: { some: { userId: user.id } } },
+      },
       select: { blocks: true, webhooks: true },
     })
     const emptyWebhookSteps = (typebot?.blocks as Block[]).reduce<

apps/viewer/playwright/services/database.ts

@@ -8,16 +8,21 @@ import {
   Typebot,
   Webhook,
 } from 'models'
-import { PrismaClient } from 'db'
+import { PrismaClient, WorkspaceRole } from 'db'
 import { readFileSync } from 'fs'
 import { encrypt } from 'utils'
 
 const prisma = new PrismaClient()
 
+const proWorkspaceId = 'proWorkspaceViewer'
+
 export const teardownDatabase = async () => {
   try {
-    await prisma.user.delete({
-      where: { id: 'proUser' },
+    await prisma.workspace.deleteMany({
+      where: { members: { some: { userId: { in: ['proUser'] } } } },
+    })
+    await prisma.user.deleteMany({
+      where: { id: { in: ['proUser'] } },
     })
   } catch (err) {
     console.error(err)
@@ -34,6 +39,17 @@ export const createUser = () =>
       email: 'user@email.com',
       name: 'User',
       apiToken: 'userToken',
+      workspaces: {
+        create: {
+          role: WorkspaceRole.ADMIN,
+          workspace: {
+            create: {
+              id: proWorkspaceId,
+              name: 'Pro workspace',
+            },
+          },
+        },
+      },
     },
   })
 
@@ -81,6 +97,7 @@ const parseTestTypebot = (partialTypebot: Partial<Typebot>): Typebot => ({
   folderId: null,
   name: 'My typebot',
   ownerId: 'proUser',
+  workspaceId: proWorkspaceId,
   icon: null,
   theme: defaultTheme,
   settings: defaultSettings,
@@ -143,6 +160,7 @@ export const importTypebotInDatabase = async (
   const typebot: any = {
     ...JSON.parse(readFileSync(path).toString()),
     ...updates,
+    workspaceId: proWorkspaceId,
     ownerId: 'proUser',
   }
   await prisma.typebot.create({
@@ -203,6 +221,7 @@ export const createSmtpCredentials = (
       name: smtpData.from.email as string,
       type: CredentialsType.SMTP,
       ownerId: 'proUser',
+      workspaceId: proWorkspaceId,
     },
   })
 }