🛂 Reset isQuarantined when upgrading workspace

apps/builder/src/features/billing/api/updateSubscription.ts

@@ -148,10 +148,7 @@ export const updateSubscription = authenticatedProcedure
           plan,
           additionalChatsIndex: additionalChats,
           additionalStorageIndex: additionalStorage,
-          chatsLimitFirstEmailSentAt: null,
-          chatsLimitSecondEmailSentAt: null,
-          storageLimitFirstEmailSentAt: null,
-          storageLimitSecondEmailSentAt: null,
+          isQuarantined: false,
         },
       })
 

apps/builder/src/pages/api/stripe/webhook.ts

@@ -69,10 +69,7 @@ const webhookHandler = async (req: NextApiRequest, res: NextApiResponse) => {
                 stripeId: session.customer as string,
                 additionalChatsIndex: parseInt(additionalChats),
                 additionalStorageIndex: parseInt(additionalStorage),
-                chatsLimitFirstEmailSentAt: null,
-                chatsLimitSecondEmailSentAt: null,
-                storageLimitFirstEmailSentAt: null,
-                storageLimitSecondEmailSentAt: null,
+                isQuarantined: false,
               },
             })
 
@@ -137,10 +134,6 @@ const webhookHandler = async (req: NextApiRequest, res: NextApiResponse) => {
               plan: Plan.FREE,
               additionalChatsIndex: 0,
               additionalStorageIndex: 0,
-              chatsLimitFirstEmailSentAt: null,
-              chatsLimitSecondEmailSentAt: null,
-              storageLimitFirstEmailSentAt: null,
-              storageLimitSecondEmailSentAt: null,
               customChatsLimit: null,
               customStorageLimit: null,
               customSeatsLimit: null,

apps/viewer/src/features/blocks/inputs/fileUpload/api/getUploadUrl.ts

@@ -1,24 +1,16 @@
 import { publicProcedure } from '@/helpers/server/trpc'
 import prisma from '@/lib/prisma'
 import { TRPCError } from '@trpc/server'
-import { getStorageLimit } from '@typebot.io/lib/pricing'
 import {
   FileInputBlock,
   InputBlockType,
   LogicBlockType,
   PublicTypebot,
   TypebotLinkBlock,
 } from '@typebot.io/schemas'
-import { byId, env, isDefined } from '@typebot.io/lib'
+import { byId, isDefined } from '@typebot.io/lib'
 import { z } from 'zod'
 import { generatePresignedUrl } from '@typebot.io/lib/api/storage'
-import {
-  sendAlmostReachedStorageLimitEmail,
-  sendReachedStorageLimitEmail,
-} from '@typebot.io/emails'
-import { WorkspaceRole } from '@typebot.io/prisma'
-
-const LIMIT_EMAIL_TRIGGER_PERCENT = 0.8
 
 export const getUploadUrl = publicProcedure
   .meta({
@@ -58,7 +50,6 @@ export const getUploadUrl = publicProcedure
           'S3 not properly configured. Missing one of those variables: S3_ENDPOINT, S3_ACCESS_KEY, S3_SECRET_KEY',
       })
 
-    await checkIfStorageLimitReached(typebotId)
     const publicTypebot = (await prisma.publicTypebot.findFirst({
       where: { typebotId },
       select: {
@@ -118,111 +109,3 @@ const getFileUploadBlock = async (
     return fileUploadBlockFromLinkedTypebots
   return null
 }
-
-const checkIfStorageLimitReached = async (
-  typebotId: string
-): Promise<boolean> => {
-  const typebot = await prisma.typebot.findUnique({
-    where: { id: typebotId },
-    select: {
-      workspace: {
-        select: {
-          id: true,
-          additionalStorageIndex: true,
-          plan: true,
-          storageLimitFirstEmailSentAt: true,
-          storageLimitSecondEmailSentAt: true,
-          customStorageLimit: true,
-        },
-      },
-    },
-  })
-  if (!typebot?.workspace) throw new Error('Workspace not found')
-  const { workspace } = typebot
-  const {
-    _sum: { storageUsed: totalStorageUsed },
-  } = await prisma.answer.aggregate({
-    where: {
-      storageUsed: { gt: 0 },
-      result: {
-        typebot: {
-          workspaceId: typebot.workspace.id,
-        },
-      },
-    },
-    _sum: { storageUsed: true },
-  })
-  if (!totalStorageUsed) return false
-  const hasSentFirstEmail = workspace.storageLimitFirstEmailSentAt !== null
-  const hasSentSecondEmail = workspace.storageLimitSecondEmailSentAt !== null
-  const storageLimit = getStorageLimit(typebot.workspace)
-  if (storageLimit === -1) return false
-  const storageLimitBytes = storageLimit * 1024 * 1024 * 1024
-  if (
-    totalStorageUsed >= storageLimitBytes * LIMIT_EMAIL_TRIGGER_PERCENT &&
-    !hasSentFirstEmail &&
-    env('E2E_TEST') !== 'true'
-  )
-    await sendAlmostReachStorageLimitNotification({
-      workspaceId: workspace.id,
-      storageLimit,
-    })
-  if (
-    totalStorageUsed >= storageLimitBytes &&
-    !hasSentSecondEmail &&
-    env('E2E_TEST') !== 'true'
-  )
-    await sendReachStorageLimitNotification({
-      workspaceId: workspace.id,
-      storageLimit,
-    })
-  return totalStorageUsed >= storageLimitBytes
-}
-
-const sendAlmostReachStorageLimitNotification = async ({
-  workspaceId,
-  storageLimit,
-}: {
-  workspaceId: string
-  storageLimit: number
-}) => {
-  const members = await prisma.memberInWorkspace.findMany({
-    where: { role: WorkspaceRole.ADMIN, workspaceId },
-    include: { user: { select: { email: true } } },
-  })
-
-  await sendAlmostReachedStorageLimitEmail({
-    to: members.map((member) => member.user.email).filter(isDefined),
-    storageLimit,
-    url: `${process.env.NEXTAUTH_URL}/typebots?workspaceId=${workspaceId}`,
-  })
-
-  await prisma.workspace.update({
-    where: { id: workspaceId },
-    data: { storageLimitFirstEmailSentAt: new Date() },
-  })
-}
-
-const sendReachStorageLimitNotification = async ({
-  workspaceId,
-  storageLimit,
-}: {
-  workspaceId: string
-  storageLimit: number
-}) => {
-  const members = await prisma.memberInWorkspace.findMany({
-    where: { role: WorkspaceRole.ADMIN, workspaceId },
-    include: { user: { select: { email: true } } },
-  })
-
-  await sendReachedStorageLimitEmail({
-    to: members.map((member) => member.user.email).filter(isDefined),
-    storageLimit,
-    url: `${process.env.NEXTAUTH_URL}/typebots?workspaceId=${workspaceId}`,
-  })
-
-  await prisma.workspace.update({
-    where: { id: workspaceId },
-    data: { storageLimitSecondEmailSentAt: new Date() },
-  })
-}

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

@@ -3,7 +3,6 @@ import prisma from '@/lib/prisma'
 import { ResultWithAnswers } from '@typebot.io/schemas'
 import { NextApiRequest, NextApiResponse } from 'next'
 import { methodNotAllowed } from '@typebot.io/lib/api'
-import { checkChatsUsage } from '@/features/usage/checkChatsUsage'
 
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
   if (req.method === 'GET') {
@@ -26,8 +25,12 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
   }
   if (req.method === 'POST') {
     const typebotId = req.query.typebotId as string
-    const hasReachedLimit = await checkChatsUsage({ typebotId })
-    if (hasReachedLimit) return res.send({ result: null, hasReachedLimit })
+    const typebot = await prisma.typebot.findFirst({
+      where: { id: typebotId },
+      select: { workspace: { select: { isQuarantined: true } } },
+    })
+    if (typebot?.workspace.isQuarantined)
+      return res.send({ result: null, hasReachedLimit: true })
     const result = await prisma.result.create({
       data: {
         typebotId,