Use standard types

Author: TheodoreSpeaks

apps/sim/app/api/cron/cleanup-soft-deletes/route.ts

@@ -12,7 +12,7 @@ export async function GET(request: NextRequest) {
     const authError = verifyCronAuth(request, 'soft-delete cleanup')
     if (authError) return authError
 
-    const result = await dispatchCleanupJobs('cleanup-soft-deletes', 'softDeleteRetentionHours')
+    const result = await dispatchCleanupJobs('cleanup-soft-deletes')
 
     logger.info('Soft-delete cleanup jobs dispatched', result)
 

apps/sim/app/api/cron/cleanup-tasks/route.ts

@@ -12,7 +12,7 @@ export async function GET(request: NextRequest) {
     const authError = verifyCronAuth(request, 'task cleanup')
     if (authError) return authError
 
-    const result = await dispatchCleanupJobs('cleanup-tasks', 'taskCleanupHours')
+    const result = await dispatchCleanupJobs('cleanup-tasks')
 
     logger.info('Task cleanup jobs dispatched', result)
 

apps/sim/app/api/logs/cleanup/route.ts

@@ -12,7 +12,7 @@ export async function GET(request: NextRequest) {
     const authError = verifyCronAuth(request, 'logs cleanup')
     if (authError) return authError
 
-    const result = await dispatchCleanupJobs('cleanup-logs', 'logRetentionHours')
+    const result = await dispatchCleanupJobs('cleanup-logs')
 
     logger.info('Log cleanup jobs dispatched', result)
 

apps/sim/app/api/workspaces/[id]/data-retention/route.ts

@@ -6,10 +6,10 @@ import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
 import { getSession } from '@/lib/auth'
-import { getRetentionDefaultHours } from '@/lib/billing/cleanup-dispatcher'
+import { CLEANUP_CONFIG } from '@/lib/billing/cleanup-dispatcher'
 import { getHighestPrioritySubscription } from '@/lib/billing/core/plan'
 import { isEnterprisePlan } from '@/lib/billing/core/subscription'
-import { checkEnterprisePlan, checkProPlan, checkTeamPlan } from '@/lib/billing/subscriptions/utils'
+import { getPlanType, type PlanCategory } from '@/lib/billing/plan-helpers'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 import { getWorkspaceBilledAccountUserId } from '@/lib/workspaces/utils'
 
@@ -18,30 +18,23 @@ const logger = createLogger('DataRetentionAPI')
 const MIN_HOURS = 24
 const MAX_HOURS = 43800 // 5 years
 
-interface PlanDefaults {
+interface RetentionValues {
   logRetentionHours: number | null
   softDeleteRetentionHours: number | null
   taskCleanupHours: number | null
 }
 
-function getPlanDefaults(plan: 'free' | 'pro' | 'enterprise'): PlanDefaults {
-  const tier: 'free' | 'paid' | 'enterprise' =
-    plan === 'free' ? 'free' : plan === 'enterprise' ? 'enterprise' : 'paid'
+function getPlanDefaults(plan: PlanCategory): RetentionValues {
   return {
-    logRetentionHours: getRetentionDefaultHours(tier, 'logRetentionHours'),
-    softDeleteRetentionHours: getRetentionDefaultHours(tier, 'softDeleteRetentionHours'),
-    taskCleanupHours: getRetentionDefaultHours(tier, 'taskCleanupHours'),
+    logRetentionHours: CLEANUP_CONFIG['cleanup-logs'].defaults[plan],
+    softDeleteRetentionHours: CLEANUP_CONFIG['cleanup-soft-deletes'].defaults[plan],
+    taskCleanupHours: CLEANUP_CONFIG['cleanup-tasks'].defaults[plan],
   }
 }
 
-async function resolveWorkspacePlan(
-  billedAccountUserId: string
-): Promise<'free' | 'pro' | 'enterprise'> {
+async function resolveWorkspacePlan(billedAccountUserId: string): Promise<PlanCategory> {
   const sub = await getHighestPrioritySubscription(billedAccountUserId)
-  if (!sub) return 'free'
-  if (checkEnterprisePlan(sub)) return 'enterprise'
-  if (checkTeamPlan(sub) || checkProPlan(sub)) return 'pro'
-  return 'free'
+  return getPlanType(sub?.plan)
 }
 
 const updateRetentionSchema = z.object({

apps/sim/background/cleanup-logs.ts

@@ -1,13 +1,9 @@
 import { db } from '@sim/db'
-import { workflowExecutionLogs, workspace } from '@sim/db/schema'
+import { workflowExecutionLogs } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { task } from '@trigger.dev/sdk'
-import { and, eq, inArray, lt } from 'drizzle-orm'
-import {
-  type CleanupJobPayload,
-  getRetentionDefaultHours,
-  resolveTierWorkspaceIds,
-} from '@/lib/billing/cleanup-dispatcher'
+import { and, inArray, lt } from 'drizzle-orm'
+import { type CleanupJobPayload, resolveCleanupScope } from '@/lib/billing/cleanup-dispatcher'
 import { snapshotService } from '@/lib/logs/execution/snapshot/service'
 import { isUsingCloudStorage, StorageService } from '@/lib/uploads'
 import { deleteFileMetadata } from '@/lib/uploads/server/metadata'
@@ -40,24 +36,27 @@ function emptyTierResults(): TierResults {
 async function deleteExecutionFiles(files: unknown, results: TierResults): Promise<void> {
   if (!isUsingCloudStorage() || !files || !Array.isArray(files)) return
 
-  for (const file of files) {
-    if (!file || typeof file !== 'object' || !file.key) continue
-    results.filesTotal++
-    try {
-      await StorageService.deleteFile({ key: file.key, context: 'execution' })
-      await deleteFileMetadata(file.key)
-      results.filesDeleted++
-    } catch (fileError) {
-      results.filesDeleteFailed++
-      logger.error(`Failed to delete file ${file.key}:`, { fileError })
-    }
-  }
+  const keys = files.filter((f) => f && typeof f === 'object' && f.key).map((f) => f.key as string)
+  results.filesTotal += keys.length
+
+  await Promise.all(
+    keys.map(async (key) => {
+      try {
+        await StorageService.deleteFile({ key, context: 'execution' })
+        await deleteFileMetadata(key)
+        results.filesDeleted++
+      } catch (fileError) {
+        results.filesDeleteFailed++
+        logger.error(`Failed to delete file ${key}:`, { fileError })
+      }
+    })
+  )
 }
 
 async function cleanupTier(
   workspaceIds: string[],
   retentionDate: Date,
-  tierLabel: string
+  label: string
 ): Promise<TierResults> {
   const results = emptyTierResults()
   if (workspaceIds.length === 0) return results
@@ -101,77 +100,46 @@ async function cleanupTier(
       results.deleted += deleted.length
     } catch (deleteError) {
       results.deleteFailed += logIds.length
-      logger.error(`Batch delete failed for ${tierLabel}:`, { deleteError })
+      logger.error(`Batch delete failed for ${label}:`, { deleteError })
     }
 
     batchesProcessed++
     hasMore = batch.length === BATCH_SIZE
 
-    logger.info(`[${tierLabel}] Batch ${batchesProcessed}: ${batch.length} logs processed`)
+    logger.info(`[${label}] Batch ${batchesProcessed}: ${batch.length} logs processed`)
   }
 
   return results
 }
 
-async function resolvePayload(payload: CleanupJobPayload): Promise<{
-  workspaceIds: string[]
-  retentionHours: number
-  tierLabel: string
-} | null> {
-  if (payload.tier === 'free' || payload.tier === 'paid') {
-    const retentionHours = getRetentionDefaultHours(payload.tier, 'logRetentionHours')
-    if (retentionHours === null) {
-      logger.info(`[${payload.tier}] No default retention, skipping`)
-      return null
-    }
-    const workspaceIds = await resolveTierWorkspaceIds(payload.tier)
-    return { workspaceIds, retentionHours, tierLabel: payload.tier }
-  }
-
-  // enterprise
-  const [ws] = await db
-    .select({ logRetentionHours: workspace.logRetentionHours })
-    .from(workspace)
-    .where(eq(workspace.id, payload.workspaceId))
-    .limit(1)
-
-  if (!ws?.logRetentionHours) {
-    logger.info(`[enterprise/${payload.workspaceId}] No retention configured, skipping`)
-    return null
-  }
-
-  return {
-    workspaceIds: [payload.workspaceId],
-    retentionHours: ws.logRetentionHours,
-    tierLabel: `enterprise/${payload.workspaceId}`,
-  }
-}
-
 export async function runCleanupLogs(payload: CleanupJobPayload): Promise<void> {
   const startTime = Date.now()
 
-  const resolved = await resolvePayload(payload)
-  if (!resolved) return
+  const scope = await resolveCleanupScope('cleanup-logs', payload)
+  if (!scope) {
+    logger.info(`[${payload.plan}] No retention configured, skipping`)
+    return
+  }
 
-  const { workspaceIds, retentionHours, tierLabel } = resolved
+  const { workspaceIds, retentionHours, label } = scope
 
   if (workspaceIds.length === 0) {
-    logger.info(`[${tierLabel}] No workspaces to process`)
+    logger.info(`[${label}] No workspaces to process`)
     return
   }
 
   const retentionDate = new Date(Date.now() - retentionHours * 60 * 60 * 1000)
   logger.info(
-    `[${tierLabel}] Cleaning ${workspaceIds.length} workspaces, cutoff: ${retentionDate.toISOString()}`
+    `[${label}] Cleaning ${workspaceIds.length} workspaces, cutoff: ${retentionDate.toISOString()}`
   )
 
-  const results = await cleanupTier(workspaceIds, retentionDate, tierLabel)
+  const results = await cleanupTier(workspaceIds, retentionDate, label)
   logger.info(
-    `[${tierLabel}] Result: ${results.deleted} deleted, ${results.deleteFailed} failed out of ${results.total} candidates`
+    `[${label}] Result: ${results.deleted} deleted, ${results.deleteFailed} failed out of ${results.total} candidates`
   )
 
   // Snapshot cleanup runs only on the free job to avoid running it N times for N enterprise workspaces.
-  if (payload.tier === 'free') {
+  if (payload.plan === 'free') {
     try {
       const retentionDays = Math.floor(retentionHours / 24)
       const snapshotsCleaned = await snapshotService.cleanupOrphanedSnapshots(retentionDays + 1)
@@ -182,7 +150,7 @@ export async function runCleanupLogs(payload: CleanupJobPayload): Promise<void>
   }
 
   const timeElapsed = (Date.now() - startTime) / 1000
-  logger.info(`[${tierLabel}] Job completed in ${timeElapsed.toFixed(2)}s`)
+  logger.info(`[${label}] Job completed in ${timeElapsed.toFixed(2)}s`)
 }
 
 export const cleanupLogsTask = task({