chore: adds debug logs

Co-authored-by: Piyush Gupta <piyushguptaa2z123@gmail.com>

.cursor/rules/build-and-deployment.mdc

@@ -0,0 +1,61 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Build & Deployment Best Practices
+
+## Build Process
+
+### Running Builds
+- Use `pnpm build` from project root for full build
+- Monitor for React hooks warnings and fix them immediately
+- Ensure all TypeScript errors are resolved before deployment
+
+### Common Build Issues & Fixes
+
+#### React Hooks Warnings
+- Capture ref values in variables within useEffect cleanup
+- Avoid accessing `.current` directly in cleanup functions
+- Pattern for fixing ref cleanup warnings:
+```typescript
+useEffect(() => {
+  const currentRef = myRef.current;
+  return () => {
+    if (currentRef) {
+      currentRef.cleanup();
+    }
+  };
+}, []);
+```
+
+#### Test Failures During Build
+- Ensure all test mocks include required constants like `SESSION_MAX_AGE`
+- Mock Next.js navigation hooks properly: `useParams`, `useRouter`, `useSearchParams`
+- Remove unused imports and constants from test files
+- Use literal values instead of imported constants when the constant isn't actually needed
+
+### Test Execution
+- Run `pnpm test` to execute all tests
+- Use `pnpm test -- --run filename.test.tsx` for specific test files
+- Fix test failures before merging code
+- Ensure 100% test coverage for new components
+
+### Performance Monitoring
+- Monitor build times and optimize if necessary
+- Watch for memory usage during builds
+- Use proper caching strategies for faster rebuilds
+
+### Deployment Checklist
+1. All tests passing
+2. Build completes without warnings
+3. TypeScript compilation successful
+4. No linter errors
+5. Database migrations applied (if any)
+6. Environment variables configured
+
+### EKS Deployment Considerations
+- Ensure latest code is deployed to all pods
+- Monitor AWS RDS Performance Insights for database issues
+- Verify environment-specific configurations
+- Check pod health and resource usage

.cursor/rules/cache-optimization.mdc

@@ -0,0 +1,414 @@
+---
+description: Caching rules for performance improvements
+globs: 
+alwaysApply: false
+---
+# Cache Optimization Patterns for Formbricks
+
+## Cache Strategy Overview
+
+Formbricks uses a **hybrid caching approach** optimized for enterprise scale:
+
+- **Redis** for persistent cross-request caching  
+- **React `cache()`** for request-level deduplication
+- **NO Next.js `unstable_cache()`** - avoid for reliability
+
+## Key Files
+
+### Core Cache Infrastructure
+- [apps/web/modules/cache/lib/service.ts](mdc:apps/web/modules/cache/lib/service.ts) - Redis cache service
+- [apps/web/modules/cache/lib/withCache.ts](mdc:apps/web/modules/cache/lib/withCache.ts) - Cache wrapper utilities
+- [apps/web/modules/cache/lib/cacheKeys.ts](mdc:apps/web/modules/cache/lib/cacheKeys.ts) - Enterprise cache key patterns and utilities
+
+### Environment State Caching (Critical Endpoint)
+- [apps/web/app/api/v1/client/[environmentId]/environment/route.ts](mdc:apps/web/app/api/v1/client/[environmentId]/environment/route.ts) - Main endpoint serving hundreds of thousands of SDK clients
+- [apps/web/app/api/v1/client/[environmentId]/environment/lib/data.ts](mdc:apps/web/app/api/v1/client/[environmentId]/environment/lib/data.ts) - Optimized data layer with caching
+
+## Enterprise-Grade Cache Key Patterns
+
+**Always use** the `createCacheKey` utilities from [cacheKeys.ts](mdc:apps/web/modules/cache/lib/cacheKeys.ts):
+
+```typescript
+// ✅ Correct patterns
+createCacheKey.environment.state(environmentId)     // "fb:env:abc123:state"
+createCacheKey.organization.billing(organizationId) // "fb:org:xyz789:billing"
+createCacheKey.license.status(organizationId)       // "fb:license:org123:status"
+createCacheKey.user.permissions(userId, orgId)      // "fb:user:456:org:123:permissions"
+
+// ❌ Never use flat keys - collision-prone
+"environment_abc123"
+"user_data_456"
+```
+
+## When to Use Each Cache Type
+
+### Use React `cache()` for Request Deduplication
+```typescript
+// ✅ Prevents multiple calls within same request
+export const getEnterpriseLicense = reactCache(async () => {
+  // Complex license validation logic
+});
+```
+
+### Use `withCache()` for Simple Database Queries
+```typescript
+// ✅ Simple caching with automatic fallback (TTL in milliseconds)
+export const getActionClasses = (environmentId: string) => {
+  return withCache(() => fetchActionClassesFromDB(environmentId), {
+    key: createCacheKey.environment.actionClasses(environmentId),
+    ttl: 60 * 30 * 1000, // 30 minutes in milliseconds
+  })();
+};
+```
+
+### Use Explicit Redis Cache for Complex Business Logic
+```typescript
+// ✅ Full control for high-stakes endpoints
+export const getEnvironmentState = async (environmentId: string) => {
+  const cached = await environmentStateCache.getEnvironmentState(environmentId);
+  if (cached) return cached;
+  
+  const fresh = await buildComplexState(environmentId);
+  await environmentStateCache.setEnvironmentState(environmentId, fresh);
+  return fresh;
+};
+```
+
+## Caching Decision Framework
+
+### When TO Add Caching
+
+```typescript
+// ✅ Expensive operations that benefit from caching
+- Database queries (>10ms typical)
+- External API calls (>50ms typical)  
+- Complex computations (>5ms)
+- File system operations
+- Heavy data transformations
+
+// Example: Database query with complex joins (TTL in milliseconds)
+export const getEnvironmentWithDetails = withCache(
+  async (environmentId: string) => {
+    return prisma.environment.findUnique({
+      where: { id: environmentId },
+      include: { /* complex joins */ }
+    });
+  },
+  { key: createCacheKey.environment.details(environmentId), ttl: 60 * 30 * 1000 } // 30 minutes
+)();
+```
+
+### When NOT to Add Caching
+
+```typescript
+// ❌ Don't cache these operations - minimal overhead
+- Simple property access (<0.1ms)
+- Basic transformations (<1ms)
+- Functions that just call already-cached functions
+- Pure computation without I/O
+
+// ❌ Bad example: Redundant caching
+const getCachedLicenseFeatures = withCache(
+  async () => {
+    const license = await getEnterpriseLicense(); // Already cached!
+    return license.active ? license.features : null; // Just property access
+  },
+  { key: "license-features", ttl: 1800 * 1000 } // 30 minutes in milliseconds
+);
+
+// ✅ Good example: Simple and efficient
+const getLicenseFeatures = async () => {
+  const license = await getEnterpriseLicense(); // Already cached
+  return license.active ? license.features : null; // 0.1ms overhead
+};
+```
+
+### Computational Overhead Analysis
+
+Before adding caching, analyze the overhead:
+
+```typescript
+// ✅ High overhead - CACHE IT
+- Database queries: ~10-100ms
+- External APIs: ~50-500ms  
+- File I/O: ~5-50ms
+- Complex algorithms: >5ms
+
+// ❌ Low overhead - DON'T CACHE
+- Property access: ~0.001ms
+- Simple lookups: ~0.1ms
+- Basic validation: ~1ms
+- Type checks: ~0.01ms
+
+// Example decision tree:
+const expensiveOperation = async () => {
+  return prisma.query(); // 50ms - CACHE IT
+};
+
+const cheapOperation = (data: any) => {
+  return data.property; // 0.001ms - DON'T CACHE
+};
+```
+
+### Avoid Cache Wrapper Anti-Pattern
+
+```typescript
+// ❌ Don't create wrapper functions just for caching
+const getCachedUserPermissions = withCache(
+  async (userId: string) => getUserPermissions(userId),
+  { key: createCacheKey.user.permissions(userId), ttl: 3600 * 1000 } // 1 hour in milliseconds
+);
+
+// ✅ Add caching directly to the original function
+export const getUserPermissions = withCache(
+  async (userId: string) => {
+    return prisma.user.findUnique({
+      where: { id: userId },
+      include: { permissions: true }
+    });
+  },
+  { key: createCacheKey.user.permissions(userId), ttl: 3600 * 1000 } // 1 hour in milliseconds
+);
+```
+
+## TTL Coordination Strategy
+
+### Multi-Layer Cache Coordination
+For endpoints serving client SDKs, coordinate TTLs across layers:
+
+```typescript
+// Client SDK cache (expiresAt) - longest TTL for fewer requests
+const CLIENT_TTL = 60 * 60;           // 1 hour (seconds for client)
+
+// Server Redis cache - shorter TTL ensures fresh data for clients  
+const SERVER_TTL = 60 * 30 * 1000;   // 30 minutes in milliseconds
+
+// HTTP cache headers (seconds)
+const BROWSER_TTL = 60 * 60;         // 1 hour (max-age)
+const CDN_TTL = 60 * 30;             // 30 minutes (s-maxage)
+const CORS_TTL = 60 * 60;            // 1 hour (balanced approach)
+```
+
+### Standard TTL Guidelines (in milliseconds for cache-manager + Keyv)
+```typescript
+// Configuration data - rarely changes
+const CONFIG_TTL = 60 * 60 * 24 * 1000;     // 24 hours
+
+// User data - moderate frequency  
+const USER_TTL = 60 * 60 * 2 * 1000;        // 2 hours
+
+// Survey data - changes moderately
+const SURVEY_TTL = 60 * 15 * 1000;          // 15 minutes
+
+// Billing data - expensive to compute
+const BILLING_TTL = 60 * 30 * 1000;         // 30 minutes
+
+// Action classes - infrequent changes
+const ACTION_CLASS_TTL = 60 * 30 * 1000;    // 30 minutes
+```
+
+## High-Frequency Endpoint Optimization
+
+### Performance Patterns for High-Volume Endpoints
+
+```typescript
+// ✅ Optimized high-frequency endpoint pattern
+export const GET = async (request: NextRequest, props: { params: Promise<{ id: string }> }) => {
+  const params = await props.params;
+
+  try {
+    // Simple validation (avoid Zod for high-frequency)
+    if (!params.id || typeof params.id !== 'string') {
+      return responses.badRequestResponse("ID is required", undefined, true);
+    }
+
+    // Single optimized query with caching
+    const data = await getOptimizedData(params.id);
+
+    return responses.successResponse(
+      {
+        data,
+        expiresAt: new Date(Date.now() + CLIENT_TTL * 1000), // SDK cache duration
+      },
+      true,
+      "public, s-maxage=1800, max-age=3600, stale-while-revalidate=1800, stale-if-error=3600"
+    );
+  } catch (err) {
+    // Simplified error handling for performance
+    if (err instanceof ResourceNotFoundError) {
+      return responses.notFoundResponse(err.resourceType, err.resourceId);
+    }
+    logger.error({ error: err, url: request.url }, "Error in high-frequency endpoint");
+    return responses.internalServerErrorResponse(err.message, true);
+  }
+};
+```
+
+### Avoid These Performance Anti-Patterns
+
+```typescript
+// ❌ Avoid for high-frequency endpoints
+const inputValidation = ZodSchema.safeParse(input);     // Too slow
+const startTime = Date.now(); logger.debug(...);       // Logging overhead
+const { data, revalidateEnvironment } = await get();   // Complex return types
+```
+
+### CORS Optimization
+```typescript
+// ✅ Balanced CORS caching (not too aggressive)
+export const OPTIONS = async (): Promise<Response> => {
+  return responses.successResponse(
+    {},
+    true,
+    "public, s-maxage=3600, max-age=3600" // 1 hour balanced approach
+  );
+};
+```
+
+## Redis Cache Migration from Next.js
+
+### Avoid Legacy Next.js Patterns
+```typescript
+// ❌ Old Next.js unstable_cache pattern (avoid)
+const getCachedData = unstable_cache(
+  async (id) => fetchData(id),
+  ['cache-key'],
+  { tags: ['environment'], revalidate: 900 }
+);
+
+// ❌ Don't use revalidateEnvironment flags with Redis
+return { data, revalidateEnvironment: true }; // This gets cached incorrectly!
+
+// ✅ New Redis pattern with withCache (TTL in milliseconds)
+export const getCachedData = (id: string) => 
+  withCache(
+    () => fetchData(id),
+    {
+      key: createCacheKey.environment.data(id),
+      ttl: 60 * 15 * 1000, // 15 minutes in milliseconds
+    }
+  )();
+```
+
+### Remove Revalidation Logic
+When migrating from Next.js `unstable_cache`:
+- Remove `revalidateEnvironment` or similar flags
+- Remove tag-based invalidation logic  
+- Use TTL-based expiration instead
+- Handle one-time updates (like `appSetupCompleted`) directly in cache
+
+## Data Layer Optimization
+
+### Single Query Pattern
+```typescript
+// ✅ Optimize with single database query
+export const getOptimizedEnvironmentData = async (environmentId: string) => {
+  return prisma.environment.findUniqueOrThrow({
+    where: { id: environmentId },
+    include: {
+      project: { 
+        select: { id: true, recontactDays: true, /* ... */ }
+      },
+      organization: {
+        select: { id: true, billing: true }
+      },
+      surveys: {
+        where: { status: "inProgress" },
+        select: { id: true, name: true, /* ... */ }
+      },
+      actionClasses: {
+        select: { id: true, name: true, /* ... */ }
+      }
+    }
+  });
+};
+
+// ❌ Avoid multiple separate queries
+const environment = await getEnvironment(id);
+const organization = await getOrganization(environment.organizationId);  
+const surveys = await getSurveys(id);
+const actionClasses = await getActionClasses(id);
+```
+
+## Invalidation Best Practices
+
+**Always use explicit key-based invalidation:**
+
+```typescript
+// ✅ Clear and debuggable
+await invalidateCache(createCacheKey.environment.state(environmentId));
+await invalidateCache([
+  createCacheKey.environment.surveys(environmentId),
+  createCacheKey.environment.actionClasses(environmentId)
+]);
+
+// ❌ Avoid complex tag systems
+await invalidateByTags(["environment", "survey"]); // Don't do this
+```
+
+## Critical Performance Targets
+
+### High-Frequency Endpoint Goals
+- **Cache hit ratio**: >85%
+- **Response time P95**: <200ms  
+- **Database load reduction**: >60%
+- **HTTP cache duration**: 1hr browser, 30min Cloudflare
+- **SDK refresh interval**: 1 hour with 30min server cache
+
+### Performance Monitoring
+- Use **existing elastic cache analytics** for metrics
+- Log cache errors and warnings (not debug info)
+- Track database query reduction
+- Monitor response times for cached endpoints
+- **Avoid performance logging** in high-frequency endpoints
+
+## Error Handling Pattern
+
+Always provide fallback to fresh data on cache errors:
+
+```typescript
+try {
+  const cached = await cache.get(key);
+  if (cached) return cached;
+  
+  const fresh = await fetchFresh();
+  await cache.set(key, fresh, ttl); // ttl in milliseconds
+  return fresh;
+} catch (error) {
+  // ✅ Always fallback to fresh data
+  logger.warn("Cache error, fetching fresh", { key, error });
+  return fetchFresh();
+}
+```
+
+## Common Pitfalls to Avoid
+
+1. **Never use Next.js `unstable_cache()`** - unreliable in production
+2. **Don't use revalidation flags with Redis** - they get cached incorrectly
+3. **Avoid Zod validation** for simple parameters in high-frequency endpoints
+4. **Don't add performance logging** to high-frequency endpoints
+5. **Coordinate TTLs** between client and server caches
+6. **Don't over-engineer** with complex tag systems  
+7. **Avoid caching rapidly changing data** (real-time metrics)
+8. **Always validate cache keys** to prevent collisions
+9. **Don't add redundant caching layers** - analyze computational overhead first
+10. **Avoid cache wrapper functions** - add caching directly to expensive operations
+11. **Don't cache property access or simple transformations** - overhead is negligible
+12. **Analyze the full call chain** before adding caching to avoid double-caching
+13. **Remember TTL is in milliseconds** for cache-manager + Keyv stack (not seconds)
+
+## Monitoring Strategy
+
+- Use **existing elastic cache analytics** for metrics
+- Log cache errors and warnings  
+- Track database query reduction
+- Monitor response times for cached endpoints
+- **Don't add custom metrics** that duplicate existing monitoring
+
+## Important Notes
+
+### TTL Units
+- **cache-manager + Keyv**: TTL in **milliseconds**
+- **Direct Redis commands**: TTL in **seconds** (EXPIRE, SETEX) or **milliseconds** (PEXPIRE, PSETEX)
+- **HTTP cache headers**: TTL in **seconds** (max-age, s-maxage)
+- **Client SDK**: TTL in **seconds** (expiresAt calculation)

.cursor/rules/database-performance.mdc

@@ -0,0 +1,41 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Database Performance & Prisma Best Practices
+
+## Critical Performance Rules
+
+### Response Count Queries
+- **NEVER** use `skip`/`offset` with `prisma.response.count()` - this causes expensive subqueries with OFFSET
+- Always use only `where` clauses for count operations: `prisma.response.count({ where: { ... } })`
+- For pagination, separate count queries from data queries
+- Reference: [apps/web/lib/response/service.ts](mdc:apps/web/lib/response/service.ts) line 654-686
+
+### Prisma Query Optimization
+- Use proper indexes defined in [packages/database/schema.prisma](mdc:packages/database/schema.prisma)
+- Leverage existing indexes: `@@index([surveyId, createdAt])`, `@@index([createdAt])`
+- Use cursor-based pagination for large datasets instead of offset-based
+- Cache frequently accessed data using React Cache and custom cache tags
+
+### Date Range Filtering
+- When filtering by `createdAt`, always use indexed queries
+- Combine with `surveyId` for optimal performance: `{ surveyId, createdAt: { gte: start, lt: end } }`
+- Avoid complex WHERE clauses that can't utilize indexes
+
+### Count vs Data Separation
+- Always separate count queries from data fetching queries
+- Use `Promise.all()` to run count and data queries in parallel
+- Example pattern from [apps/web/modules/api/v2/management/responses/lib/response.ts](mdc:apps/web/modules/api/v2/management/responses/lib/response.ts):
+```typescript
+const [responses, totalCount] = await Promise.all([
+  prisma.response.findMany(query),
+  prisma.response.count({ where: whereClause }),
+]);
+```
+
+### Monitoring & Debugging
+- Monitor AWS RDS Performance Insights for problematic queries
+- Look for queries with OFFSET in count operations - these indicate performance issues
+- Use proper error handling with `DatabaseError` for Prisma exceptions

.cursor/rules/eks-alb-optimization.mdc

@@ -0,0 +1,152 @@
+---
+description:
+globs:
+alwaysApply: false
+---
+# EKS & ALB Optimization Guide for Error Reduction
+
+## Infrastructure Overview
+
+This project uses AWS EKS with Application Load Balancer (ALB) for the Formbricks application. The infrastructure has been optimized to minimize ELB 502/504 errors through careful configuration of connection handling, health checks, and pod lifecycle management.
+
+## Key Infrastructure Files
+
+### Terraform Configuration
+- **Main Infrastructure**: [infra/terraform/main.tf](mdc:infra/terraform/main.tf) - EKS cluster, VPC, Karpenter, and core AWS resources
+- **Monitoring**: [infra/terraform/cloudwatch.tf](mdc:infra/terraform/cloudwatch.tf) - CloudWatch alarms for 502/504 error tracking and alerting
+- **Database**: [infra/terraform/rds.tf](mdc:infra/terraform/rds.tf) - Aurora PostgreSQL configuration
+
+### Helm Configuration
+- **Production**: [infra/formbricks-cloud-helm/values.yaml.gotmpl](mdc:infra/formbricks-cloud-helm/values.yaml.gotmpl) - Optimized ALB and pod configurations
+- **Staging**: [infra/formbricks-cloud-helm/values-staging.yaml.gotmpl](mdc:infra/formbricks-cloud-helm/values-staging.yaml.gotmpl) - Staging environment with spot instances
+- **Deployment**: [infra/formbricks-cloud-helm/helmfile.yaml.gotmpl](mdc:infra/formbricks-cloud-helm/helmfile.yaml.gotmpl) - Multi-environment Helm releases
+
+## ALB Optimization Patterns
+
+### Connection Handling Optimizations
+```yaml
+# Key ALB annotations for reducing 502/504 errors
+alb.ingress.kubernetes.io/load-balancer-attributes: |
+  idle_timeout.timeout_seconds=120,
+  connection_logs.s3.enabled=false,
+  access_logs.s3.enabled=false
+
+alb.ingress.kubernetes.io/target-group-attributes: |
+  deregistration_delay.timeout_seconds=30,
+  stickiness.enabled=false,
+  load_balancing.algorithm.type=least_outstanding_requests,
+  target_group_health.dns_failover.minimum_healthy_targets.count=1
+```
+
+### Health Check Configuration
+- **Interval**: 15 seconds for faster detection of unhealthy targets
+- **Timeout**: 5 seconds to prevent false positives
+- **Thresholds**: 2 healthy, 3 unhealthy for balanced responsiveness
+- **Path**: `/health` endpoint optimized for < 100ms response time
+
+## Pod Lifecycle Management
+
+### Graceful Shutdown Pattern
+```yaml
+# PreStop hook to allow connection draining
+lifecycle:
+  preStop:
+    exec:
+      command: ["/bin/sh", "-c", "sleep 15"]
+
+# Termination grace period for complete cleanup
+terminationGracePeriodSeconds: 45
+```
+
+### Health Probe Strategy
+- **Startup Probe**: 5s initial delay, 5s interval, max 60s startup time
+- **Readiness Probe**: 10s delay, 10s interval for traffic readiness
+- **Liveness Probe**: 30s delay, 30s interval for container health
+
+### Rolling Update Configuration
+```yaml
+strategy:
+  type: RollingUpdate
+  rollingUpdate:
+    maxUnavailable: 25%  # Maintain capacity during updates
+    maxSurge: 50%        # Allow faster rollouts
+```
+
+## Karpenter Node Management
+
+### Node Lifecycle Optimization
+- **Startup Taints**: Prevent traffic during node initialization
+- **Graceful Shutdown**: 30s grace period for pod eviction
+- **Consolidation Delay**: 60s to reduce unnecessary churn
+- **Eviction Policies**: Configured for smooth pod migrations
+
+### Instance Selection
+- **Families**: c8g, c7g, m8g, m7g, r8g, r7g (ARM64 Graviton)
+- **Sizes**: 2, 4, 8 vCPUs for cost optimization
+- **Bottlerocket AMI**: Enhanced security and performance
+
+## Monitoring & Alerting
+
+### Critical ALB Metrics
+1. **ELB 502 Errors**: Threshold 20 over 5 minutes
+2. **ELB 504 Errors**: Threshold 15 over 5 minutes  
+3. **Target Connection Errors**: Threshold 50 over 5 minutes
+4. **4XX Errors**: Threshold 100 over 10 minutes (client issues)
+
+### Expected Improvements
+- **60-80% reduction** in ELB 502 errors
+- **Faster recovery** during pod restarts
+- **Better connection reuse** efficiency
+- **Improved autoscaling** responsiveness
+
+## Deployment Patterns
+
+### Infrastructure Updates
+1. **Terraform First**: Apply infrastructure changes via [infra/deploy-improvements.sh](mdc:infra/deploy-improvements.sh)
+2. **Helm Second**: Deploy application configurations
+3. **Verification**: Check pod status, endpoints, and ALB health
+4. **Monitoring**: Watch CloudWatch metrics for 24-48 hours
+
+### Environment-Specific Configurations
+- **Production**: On-demand instances, stricter resource limits
+- **Staging**: Spot instances, rate limiting disabled, relaxed resources
+
+## Troubleshooting Patterns
+
+### 502 Error Investigation
+1. Check pod readiness and health probe status
+2. Verify ALB target group health
+3. Review deregistration timing during deployments
+4. Monitor connection pool utilization
+
+### 504 Error Analysis  
+1. Check application response times
+2. Verify timeout configurations (ALB: 120s, App: aligned)
+3. Review database query performance
+4. Monitor resource utilization during traffic spikes
+
+### Connection Error Patterns
+1. Verify Karpenter node lifecycle timing
+2. Check pod termination grace periods
+3. Review ALB connection draining settings
+4. Monitor cluster autoscaling events
+
+## Best Practices
+
+### When Making Changes
+- **Test in staging first** with same configurations
+- **Monitor metrics** for 24-48 hours after changes
+- **Use gradual rollouts** with proper health checks
+- **Maintain ALB timeout alignment** across all layers
+
+### Performance Optimization
+- **Health endpoint** should respond < 100ms consistently  
+- **Connection pooling** aligned with ALB idle timeouts
+- **Resource requests/limits** tuned for consistent performance
+- **Graceful shutdown** implemented in application code
+
+### Monitoring Strategy
+- **Real-time alerts** for error rate spikes
+- **Trend analysis** for connection patterns
+- **Capacity planning** based on LCU usage
+- **4XX pattern analysis** for client behavior insights

.cursor/rules/formbricks-architecture.mdc

@@ -0,0 +1,334 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Formbricks Architecture & Patterns
+
+## Monorepo Structure
+
+### Apps Directory
+- `apps/web/` - Main Next.js web application
+- `packages/` - Shared packages and utilities
+
+### Key Directories in Web App
+```
+apps/web/
+├── app/                    # Next.js 13+ app directory
+│   ├── (app)/             # Main application routes
+│   ├── (auth)/            # Authentication routes
+│   ├── api/               # API routes
+│   └── share/             # Public sharing routes
+├── components/            # Shared components
+├── lib/                   # Utility functions and services
+└── modules/               # Feature-specific modules
+```
+
+## Routing Patterns
+
+### App Router Structure
+The application uses Next.js 13+ app router with route groups:
+
+```
+(app)/environments/[environmentId]/
+├── surveys/[surveyId]/
+│   ├── (analysis)/        # Analysis views
+│   │   ├── responses/     # Response management
+│   │   ├── summary/       # Survey summary
+│   │   └── hooks/         # Analysis-specific hooks
+│   ├── edit/              # Survey editing
+│   └── settings/          # Survey settings
+```
+
+### Dynamic Routes
+- `[environmentId]` - Environment-specific routes
+- `[surveyId]` - Survey-specific routes
+- `[sharingKey]` - Public sharing routes
+
+## Service Layer Pattern
+
+### Service Organization
+Services are organized by domain in `apps/web/lib/`:
+
+```typescript
+// Example: Response service
+// apps/web/lib/response/service.ts
+export const getResponseCountAction = async ({
+  surveyId,
+  filterCriteria,
+}: {
+  surveyId: string;
+  filterCriteria: any;
+}) => {
+  // Service implementation
+};
+```
+
+### Action Pattern
+Server actions follow a consistent pattern:
+
+```typescript
+// Action wrapper for service calls
+export const getResponseCountAction = async (params) => {
+  try {
+    const result = await responseService.getCount(params);
+    return { data: result };
+  } catch (error) {
+    return { error: error.message };
+  }
+};
+```
+
+## Context Patterns
+
+### Provider Structure
+Context providers follow a consistent pattern:
+
+```typescript
+// Provider component
+export const ResponseFilterProvider = ({ children }: { children: React.ReactNode }) => {
+  const [selectedFilter, setSelectedFilter] = useState(defaultFilter);
+  
+  const value = {
+    selectedFilter,
+    setSelectedFilter,
+    // ... other state and methods
+  };
+
+  return (
+    <ResponseFilterContext.Provider value={value}>
+      {children}
+    </ResponseFilterContext.Provider>
+  );
+};
+
+// Hook for consuming context
+export const useResponseFilter = () => {
+  const context = useContext(ResponseFilterContext);
+  if (!context) {
+    throw new Error('useResponseFilter must be used within ResponseFilterProvider');
+  }
+  return context;
+};
+```
+
+### Context Composition
+Multiple contexts are often composed together:
+
+```typescript
+// Layout component with multiple providers
+export default function AnalysisLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <ResponseFilterProvider>
+      <ResponseCountProvider>
+        {children}
+      </ResponseCountProvider>
+    </ResponseFilterProvider>
+  );
+}
+```
+
+## Component Patterns
+
+### Page Components
+Page components are located in the app directory and follow this pattern:
+
+```typescript
+// apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/responses/page.tsx
+export default function ResponsesPage() {
+  return (
+    <div>
+      <ResponsesTable />
+      <ResponsesPagination />
+    </div>
+  );
+}
+```
+
+### Component Organization
+- **Pages** - Route components in app directory
+- **Components** - Reusable UI components
+- **Modules** - Feature-specific components and logic
+
+### Shared Components
+Common components are in `apps/web/components/`:
+- UI components (buttons, inputs, modals)
+- Layout components (headers, sidebars)
+- Data display components (tables, charts)
+
+## Hook Patterns
+
+### Custom Hook Structure
+Custom hooks follow consistent patterns:
+
+```typescript
+export const useResponseCount = ({ 
+  survey, 
+  initialCount 
+}: {
+  survey: TSurvey;
+  initialCount?: number;
+}) => {
+  const [responseCount, setResponseCount] = useState(initialCount ?? 0);
+  const [isLoading, setIsLoading] = useState(false);
+  
+  // Hook logic...
+  
+  return {
+    responseCount,
+    isLoading,
+    refetch,
+  };
+};
+```
+
+### Hook Dependencies
+- Use context hooks for shared state
+- Implement proper cleanup with AbortController
+- Optimize dependency arrays to prevent unnecessary re-renders
+
+## Data Fetching Patterns
+
+### Server Actions
+The app uses Next.js server actions for data fetching:
+
+```typescript
+// Server action
+export async function getResponsesAction(params: GetResponsesParams) {
+  const responses = await getResponses(params);
+  return { data: responses };
+}
+
+// Client usage
+const { data } = await getResponsesAction(params);
+```
+
+### Error Handling
+Consistent error handling across the application:
+
+```typescript
+try {
+  const result = await apiCall();
+  return { data: result };
+} catch (error) {
+  console.error("Operation failed:", error);
+  return { error: error.message };
+}
+```
+
+## Type Safety
+
+### Type Organization
+Types are organized in packages:
+- `@formbricks/types` - Shared type definitions
+- Local types in component/hook files
+
+### Common Types
+```typescript
+import { TSurvey } from "@formbricks/types/surveys/types";
+import { TResponse } from "@formbricks/types/responses";
+import { TEnvironment } from "@formbricks/types/environment";
+```
+
+## State Management
+
+### Local State
+- Use `useState` for component-specific state
+- Use `useReducer` for complex state logic
+- Use refs for mutable values that don't trigger re-renders
+
+### Global State
+- React Context for feature-specific shared state
+- URL state for filters and pagination
+- Server state through server actions
+
+## Performance Considerations
+
+### Code Splitting
+- Dynamic imports for heavy components
+- Route-based code splitting with app router
+- Lazy loading for non-critical features
+
+### Caching Strategy
+- Server-side caching for database queries
+- Client-side caching with React Query (where applicable)
+- Static generation for public pages
+
+## Testing Strategy
+
+### Test Organization
+```
+component/
+├── Component.tsx
+├── Component.test.tsx
+└── hooks/
+    ├── useHook.ts
+    └── useHook.test.tsx
+```
+
+### Test Patterns
+- Unit tests for utilities and services
+- Integration tests for components with context
+- Hook tests with proper mocking
+
+## Build & Deployment
+
+### Build Process
+- TypeScript compilation
+- Next.js build optimization
+- Asset optimization and bundling
+
+### Environment Configuration
+- Environment-specific configurations
+- Feature flags for gradual rollouts
+- Database connection management
+
+## Security Patterns
+
+### Authentication
+- Session-based authentication
+- Environment-based access control
+- API route protection
+
+### Data Validation
+- Input validation on both client and server
+- Type-safe API contracts
+- Sanitization of user inputs
+
+## Monitoring & Observability
+
+### Error Tracking
+- Client-side error boundaries
+- Server-side error logging
+- Performance monitoring
+
+### Analytics
+- User interaction tracking
+- Performance metrics
+- Database query monitoring
+
+## Best Practices Summary
+
+### Code Organization
+- ✅ Follow the established directory structure
+- ✅ Use consistent naming conventions
+- ✅ Separate concerns (UI, logic, data)
+- ✅ Keep components focused and small
+
+### Performance
+- ✅ Implement proper loading states
+- ✅ Use AbortController for async operations
+- ✅ Optimize database queries
+- ✅ Implement proper caching strategies
+
+### Type Safety
+- ✅ Use TypeScript throughout
+- ✅ Define proper interfaces for props
+- ✅ Use type guards for runtime validation
+- ✅ Leverage shared type packages
+
+### Testing
+- ✅ Write tests for critical functionality
+- ✅ Mock external dependencies properly
+- ✅ Test error scenarios and edge cases
+- ✅ Maintain good test coverage

.cursor/rules/performance-optimization.mdc

@@ -0,0 +1,5 @@
+---
+description:
+globs:
+alwaysApply: false
+---

.cursor/rules/react-context-patterns.mdc

@@ -0,0 +1,52 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# React Context & Provider Patterns
+
+## Context Provider Best Practices
+
+### Provider Implementation
+- Use TypeScript interfaces for provider props with optional `initialCount` for testing
+- Implement proper cleanup in `useEffect` to avoid React hooks warnings
+- Reference: [apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/ResponseCountProvider.tsx](mdc:apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/ResponseCountProvider.tsx)
+
+### Cleanup Pattern for Refs
+```typescript
+useEffect(() => {
+  const currentPendingRequests = pendingRequests.current;
+  const currentAbortController = abortController.current;
+  
+  return () => {
+    if (currentAbortController) {
+      currentAbortController.abort();
+    }
+    currentPendingRequests.clear();
+  };
+}, []);
+```
+
+### Testing Context Providers
+- Always wrap components using context in the provider during tests
+- Use `initialCount` prop for predictable test scenarios
+- Mock context dependencies like `useParams`, `useResponseFilter`
+- Example from [apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SurveyAnalysisCTA.test.tsx](mdc:apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SurveyAnalysisCTA.test.tsx):
+
+```typescript
+render(
+  <ResponseCountProvider survey={dummySurvey} initialCount={5}>
+    <ComponentUnderTest />
+  </ResponseCountProvider>
+);
+```
+
+### Required Mocks for Context Testing
+- Mock `next/navigation` with `useParams` returning environment and survey IDs
+- Mock response filter context and actions
+- Mock API actions that the provider depends on
+
+### Context Hook Usage
+- Create custom hooks like `useResponseCountContext()` for consuming context
+- Provide meaningful error messages when context is used outside provider
+- Use context for shared state that multiple components need to access

.cursor/rules/react-context-providers.mdc

@@ -0,0 +1,5 @@
+---
+description:
+globs:
+alwaysApply: false
+---

.cursor/rules/testing-patterns.mdc

@@ -0,0 +1,327 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Testing Patterns & Best Practices
+
+## Running Tests
+
+### Test Commands
+From the **root directory** (formbricks/):
+- `npm test` - Run all tests across all packages (recommended for CI/full testing)
+- `npm run test:coverage` - Run all tests with coverage reports
+- `npm run test:e2e` - Run end-to-end tests with Playwright
+
+From the **apps/web directory** (apps/web/):
+- `npm run test` - Run only web app tests (fastest for development)
+- `npm run test:coverage` - Run web app tests with coverage
+- `npm run test -- <file-pattern>` - Run specific test files
+
+### Examples
+```bash
+# Run all tests from root (takes ~3 minutes, runs 790 test files with 5334+ tests)
+npm test
+
+# Run specific test file from apps/web (fastest for development)
+npm run test -- modules/cache/lib/service.test.ts
+
+# Run tests matching pattern from apps/web  
+npm run test -- modules/ee/license-check/lib/license.test.ts
+
+# Run with coverage from root
+npm run test:coverage
+
+# Run specific test with watch mode from apps/web (for development)
+npm run test -- --watch modules/cache/lib/service.test.ts
+
+# Run tests for a specific directory from apps/web
+npm run test -- modules/cache/
+```
+
+### Performance Tips
+- **For development**: Use `apps/web` directory commands to run only web app tests
+- **For CI/validation**: Use root directory commands to run all packages
+- **For specific features**: Use file patterns to target specific test files
+- **For debugging**: Use `--watch` mode for continuous testing during development
+
+### Test File Organization
+- Place test files in the **same directory** as the source file
+- Use `.test.ts` for utility/service tests (Node environment)
+- Use `.test.tsx` for React component tests (jsdom environment)
+
+## Test File Naming & Environment
+
+### File Extensions
+- Use `.test.tsx` for React component/hook tests (runs in jsdom environment)
+- Use `.test.ts` for utility/service tests (runs in Node environment)
+- The vitest config uses `environmentMatchGlobs` to automatically set jsdom for `.tsx` files
+
+### Test Structure
+```typescript
+// Import the mocked functions first
+import { useHook } from "@/path/to/hook";
+import { serviceFunction } from "@/path/to/service";
+import { renderHook, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+// Mock dependencies
+vi.mock("@/path/to/hook", () => ({
+  useHook: vi.fn(),
+}));
+
+describe("ComponentName", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Setup default mocks
+  });
+
+  test("descriptive test name", async () => {
+    // Test implementation
+  });
+});
+```
+
+## React Hook Testing
+
+### Context Mocking
+When testing hooks that use React Context:
+```typescript
+vi.mocked(useResponseFilter).mockReturnValue({
+  selectedFilter: {
+    filter: [],
+    onlyComplete: false,
+  },
+  setSelectedFilter: vi.fn(),
+  selectedOptions: {
+    questionOptions: [],
+    questionFilterOptions: [],
+  },
+  setSelectedOptions: vi.fn(),
+  dateRange: { from: new Date(), to: new Date() },
+  setDateRange: vi.fn(),
+  resetState: vi.fn(),
+});
+```
+
+### Testing Async Hooks
+- Always use `waitFor` for async operations
+- Test both loading and completed states
+- Verify API calls with correct parameters
+
+```typescript
+test("fetches data on mount", async () => {
+  const { result } = renderHook(() => useHook());
+  
+  expect(result.current.isLoading).toBe(true);
+  
+  await waitFor(() => {
+    expect(result.current.isLoading).toBe(false);
+  });
+  
+  expect(result.current.data).toBe(expectedData);
+  expect(vi.mocked(apiCall)).toHaveBeenCalledWith(expectedParams);
+});
+```
+
+### Testing Hook Dependencies
+To test useEffect dependencies, ensure mocks return different values:
+```typescript
+// First render
+mockGetFormattedFilters.mockReturnValue(mockFilters);
+
+// Change dependency and trigger re-render
+const newMockFilters = { ...mockFilters, finished: true };
+mockGetFormattedFilters.mockReturnValue(newMockFilters);
+rerender();
+```
+
+## Performance Testing
+
+### Race Condition Testing
+Test AbortController implementation:
+```typescript
+test("cancels previous request when new request is made", async () => {
+  let resolveFirst: (value: any) => void;
+  let resolveSecond: (value: any) => void;
+
+  const firstPromise = new Promise((resolve) => {
+    resolveFirst = resolve;
+  });
+  const secondPromise = new Promise((resolve) => {
+    resolveSecond = resolve;
+  });
+
+  vi.mocked(apiCall)
+    .mockReturnValueOnce(firstPromise as any)
+    .mockReturnValueOnce(secondPromise as any);
+
+  const { result } = renderHook(() => useHook());
+  
+  // Trigger second request
+  result.current.refetch();
+  
+  // Resolve in order - first should be cancelled
+  resolveFirst!({ data: 100 });
+  resolveSecond!({ data: 200 });
+
+  await waitFor(() => {
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  // Should have result from second request
+  expect(result.current.data).toBe(200);
+});
+```
+
+### Cleanup Testing
+```typescript
+test("cleans up on unmount", () => {
+  const abortSpy = vi.spyOn(AbortController.prototype, "abort");
+  
+  const { unmount } = renderHook(() => useHook());
+  unmount();
+  
+  expect(abortSpy).toHaveBeenCalled();
+  abortSpy.mockRestore();
+});
+```
+
+## Error Handling Testing
+
+### API Error Testing
+```typescript
+test("handles API errors gracefully", async () => {
+  const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+  vi.mocked(apiCall).mockRejectedValue(new Error("API Error"));
+
+  const { result } = renderHook(() => useHook());
+
+  await waitFor(() => {
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  expect(consoleSpy).toHaveBeenCalledWith("Error message:", expect.any(Error));
+  expect(result.current.data).toBe(fallbackValue);
+  
+  consoleSpy.mockRestore();
+});
+```
+
+### Cancelled Request Testing
+```typescript
+test("does not update state for cancelled requests", async () => {
+  const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+  let rejectFirst: (error: any) => void;
+  const firstPromise = new Promise((_, reject) => {
+    rejectFirst = reject;
+  });
+
+  vi.mocked(apiCall)
+    .mockReturnValueOnce(firstPromise as any)
+    .mockResolvedValueOnce({ data: 42 });
+
+  const { result } = renderHook(() => useHook());
+  result.current.refetch();
+
+  const abortError = new Error("Request cancelled");
+  rejectFirst!(abortError);
+
+  await waitFor(() => {
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  // Should not log error for cancelled request
+  expect(consoleSpy).not.toHaveBeenCalled();
+  consoleSpy.mockRestore();
+});
+```
+
+## Type Safety in Tests
+
+### Mock Type Assertions
+Use type assertions for edge cases:
+```typescript
+vi.mocked(apiCall).mockResolvedValue({
+  data: null as any, // For testing null handling
+});
+
+vi.mocked(apiCall).mockResolvedValue({
+  data: undefined as any, // For testing undefined handling
+});
+```
+
+### Proper Mock Typing
+Ensure mocks match the actual interface:
+```typescript
+const mockSurvey: TSurvey = {
+  id: "survey-123",
+  name: "Test Survey",
+  // ... other required properties
+} as unknown as TSurvey; // Use when partial mocking is needed
+```
+
+## Common Test Patterns
+
+### Testing State Changes
+```typescript
+test("updates state correctly", async () => {
+  const { result } = renderHook(() => useHook());
+  
+  // Initial state
+  expect(result.current.value).toBe(initialValue);
+  
+  // Trigger change
+  result.current.updateValue(newValue);
+  
+  // Verify change
+  expect(result.current.value).toBe(newValue);
+});
+```
+
+### Testing Multiple Scenarios
+```typescript
+test("handles different modes", async () => {
+  // Test regular mode
+  vi.mocked(useParams).mockReturnValue({ surveyId: "123" });
+  const { rerender } = renderHook(() => useHook());
+  
+  await waitFor(() => {
+    expect(vi.mocked(regularApi)).toHaveBeenCalled();
+  });
+  
+  // Test sharing mode
+  vi.mocked(useParams).mockReturnValue({ 
+    surveyId: "123", 
+    sharingKey: "share-123" 
+  });
+  rerender();
+  
+  await waitFor(() => {
+    expect(vi.mocked(sharingApi)).toHaveBeenCalled();
+  });
+});
+```
+
+## Test Organization
+
+### Comprehensive Test Coverage
+For hooks, ensure you test:
+- ✅ Initialization (with/without initial values)
+- ✅ Data fetching (success/error cases)
+- ✅ State updates and refetching
+- ✅ Dependency changes triggering effects
+- ✅ Manual actions (refetch, reset)
+- ✅ Race condition prevention
+- ✅ Cleanup on unmount
+- ✅ Mode switching (if applicable)
+- ✅ Edge cases (null/undefined data)
+
+### Test Naming
+Use descriptive test names that explain the scenario:
+- ✅ "initializes with initial count"
+- ✅ "fetches response count on mount for regular survey"
+- ✅ "cancels previous request when new request is made"
+- ❌ "test hook"
+- ❌ "it works"

apps/web/app/(app)/(onboarding)/lib/onboarding.test.ts

@@ -12,20 +12,6 @@ vi.mock("@formbricks/database", () => ({
   },
 }));
 
-vi.mock("@/lib/cache", () => ({
-  cache: (fn: any) => fn,
-}));
-
-vi.mock("@/lib/cache/team", () => ({
-  teamCache: {
-    tag: { byOrganizationId: vi.fn((id: string) => `organization-${id}-teams`) },
-  },
-}));
-
-vi.mock("@/lib/utils/validate", () => ({
-  validateInputs: vi.fn(),
-}));
-
 describe("getTeamsByOrganizationId", () => {
   beforeEach(() => {
     vi.clearAllMocks();

apps/web/app/(app)/(onboarding)/lib/onboarding.ts

@@ -1,8 +1,6 @@
 "use server";
 
 import { TOrganizationTeam } from "@/app/(app)/(onboarding)/types/onboarding";
-import { cache } from "@/lib/cache";
-import { teamCache } from "@/lib/cache/team";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
 import { cache as reactCache } from "react";
@@ -11,38 +9,31 @@ import { ZId } from "@formbricks/types/common";
 import { DatabaseError } from "@formbricks/types/errors";
 
 export const getTeamsByOrganizationId = reactCache(
-  async (organizationId: string): Promise<TOrganizationTeam[] | null> =>
-    cache(
-      async () => {
-        validateInputs([organizationId, ZId]);
-        try {
-          const teams = await prisma.team.findMany({
-            where: {
-              organizationId,
-            },
-            select: {
-              id: true,
-              name: true,
-            },
-          });
+  async (organizationId: string): Promise<TOrganizationTeam[] | null> => {
+    validateInputs([organizationId, ZId]);
+    try {
+      const teams = await prisma.team.findMany({
+        where: {
+          organizationId,
+        },
+        select: {
+          id: true,
+          name: true,
+        },
+      });
 
-          const projectTeams = teams.map((team) => ({
-            id: team.id,
-            name: team.name,
-          }));
+      const projectTeams = teams.map((team) => ({
+        id: team.id,
+        name: team.name,
+      }));
 
-          return projectTeams;
-        } catch (error) {
-          if (error instanceof Prisma.PrismaClientKnownRequestError) {
-            throw new DatabaseError(error.message);
-          }
-
-          throw error;
-        }
-      },
-      [`getTeamsByOrganizationId-${organizationId}`],
-      {
-        tags: [teamCache.tag.byOrganizationId(organizationId)],
+      return projectTeams;
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError) {
+        throw new DatabaseError(error.message);
       }
-    )()
+
+      throw error;
+    }
+  }
 );

apps/web/app/(app)/environments/[environmentId]/actions/actions.ts

@@ -1,7 +1,6 @@
 "use server";
 
 import { deleteActionClass, getActionClass, updateActionClass } from "@/lib/actionClass/service";
-import { cache } from "@/lib/cache";
 import { getSurveysByActionClassId } from "@/lib/survey/service";
 import { actionClient, authenticatedActionClient } from "@/lib/utils/action-client";
 import { checkAuthorizationUpdated } from "@/lib/utils/action-client-middleware";
@@ -104,31 +103,24 @@ export const getActiveInactiveSurveysAction = authenticatedActionClient
     return response;
   });
 
-const getLatestStableFbRelease = async (): Promise<string | null> =>
-  cache(
-    async () => {
-      try {
-        const res = await fetch("https://api.github.com/repos/formbricks/formbricks/releases");
-        const releases = await res.json();
+const getLatestStableFbRelease = async (): Promise<string | null> => {
+  try {
+    const res = await fetch("https://api.github.com/repos/formbricks/formbricks/releases");
+    const releases = await res.json();
 
-        if (Array.isArray(releases)) {
-          const latestStableReleaseTag = releases.filter((release) => !release.prerelease)?.[0]
-            ?.tag_name as string;
-          if (latestStableReleaseTag) {
-            return latestStableReleaseTag;
-          }
-        }
-
-        return null;
-      } catch (err) {
-        return null;
+    if (Array.isArray(releases)) {
+      const latestStableReleaseTag = releases.filter((release) => !release.prerelease)?.[0]
+        ?.tag_name as string;
+      if (latestStableReleaseTag) {
+        return latestStableReleaseTag;
       }
-    },
-    ["latest-fb-release"],
-    {
-      revalidate: 60 * 60 * 24, // 24 hours
     }
-  )();
+
+    return null;
+  } catch (err) {
+    return null;
+  }
+};
 
 export const getLatestStableFbReleaseAction = actionClient.action(async () => {
   return await getLatestStableFbRelease();

apps/web/app/(app)/environments/[environmentId]/integrations/lib/surveys.test.ts

@@ -1,10 +1,8 @@
-import { cache } from "@/lib/cache";
-import { surveyCache } from "@/lib/survey/cache";
 import { selectSurvey } from "@/lib/survey/service";
 import { transformPrismaSurvey } from "@/lib/survey/utils";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { prisma } from "@formbricks/database";
 import { logger } from "@formbricks/logger";
 import { DatabaseError } from "@formbricks/types/errors";
@@ -12,14 +10,6 @@ import { TSurvey } from "@formbricks/types/surveys/types";
 import { getSurveys } from "./surveys";
 
 // Mock dependencies
-vi.mock("@/lib/cache");
-vi.mock("@/lib/survey/cache", () => ({
-  surveyCache: {
-    tag: {
-      byEnvironmentId: vi.fn((environmentId) => `survey_environment_${environmentId}`),
-    },
-  },
-}));
 vi.mock("@/lib/survey/service", () => ({
   selectSurvey: { id: true, name: true, status: true, updatedAt: true }, // Expanded mock based on usage
 }));
@@ -46,11 +36,11 @@ vi.mock("react", async (importOriginal) => {
 });
 
 const environmentId = "test-environment-id";
-// Ensure mockPrismaSurveys includes all fields used in selectSurvey mock
+// Use 'as any' to bypass complex type matching for mock data
 const mockPrismaSurveys = [
   { id: "survey1", name: "Survey 1", status: "inProgress", updatedAt: new Date() },
   { id: "survey2", name: "Survey 2", status: "draft", updatedAt: new Date() },
-];
+] as any; // Use 'as any' to bypass complex type matching
 const mockTransformedSurveys: TSurvey[] = [
   {
     id: "survey1",
@@ -99,14 +89,8 @@ const mockTransformedSurveys: TSurvey[] = [
 ];
 
 describe("getSurveys", () => {
-  beforeEach(() => {
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-  });
-
   test("should fetch and transform surveys successfully", async () => {
-    vi.mocked(prisma.survey.findMany).mockResolvedValue(mockPrismaSurveys);
+    vi.mocked(prisma.survey.findMany).mockResolvedValue(mockPrismaSurveys as any);
     vi.mocked(transformPrismaSurvey).mockImplementation((survey) => {
       const found = mockTransformedSurveys.find((ts) => ts.id === survey.id);
       if (!found) throw new Error("Survey not found in mock transformed data");
@@ -134,39 +118,29 @@ describe("getSurveys", () => {
     expect(transformPrismaSurvey).toHaveBeenCalledTimes(mockPrismaSurveys.length);
     expect(transformPrismaSurvey).toHaveBeenCalledWith(mockPrismaSurveys[0]);
     expect(transformPrismaSurvey).toHaveBeenCalledWith(mockPrismaSurveys[1]);
-    // Check if the inner cache function was called with the correct arguments
-    expect(cache).toHaveBeenCalledWith(
-      expect.any(Function), // The async function passed to cache
-      [`getSurveys-${environmentId}`], // The cache key
-      {
-        tags: [surveyCache.tag.byEnvironmentId(environmentId)], // Cache tags
-      }
-    );
-    // Remove the assertion for reactCache being called within the test execution
-    // expect(reactCache).toHaveBeenCalled(); // Removed this line
+    // React cache is already mocked globally - no need to check it here
   });
 
   test("should throw DatabaseError on Prisma known request error", async () => {
-    // No need to mock cache here again as beforeEach handles it
-    const prismaError = new Prisma.PrismaClientKnownRequestError("Test error", {
-      code: "P2025",
-      clientVersion: "5.0.0",
-      meta: {}, // Added meta property
+    const prismaError = new Prisma.PrismaClientKnownRequestError("Database connection error", {
+      code: "P2002",
+      clientVersion: "4.0.0",
     });
-    vi.mocked(prisma.survey.findMany).mockRejectedValue(prismaError);
+
+    vi.mocked(prisma.survey.findMany).mockRejectedValueOnce(prismaError);
 
     await expect(getSurveys(environmentId)).rejects.toThrow(DatabaseError);
     expect(logger.error).toHaveBeenCalledWith({ error: prismaError }, "getSurveys: Could not fetch surveys");
-    expect(cache).toHaveBeenCalled(); // Ensure cache wrapper was still called
+    // React cache is already mocked globally - no need to check it here
   });
 
   test("should throw original error on other errors", async () => {
-    // No need to mock cache here again as beforeEach handles it
-    const genericError = new Error("Something went wrong");
-    vi.mocked(prisma.survey.findMany).mockRejectedValue(genericError);
+    const genericError = new Error("Some other error");
+
+    vi.mocked(prisma.survey.findMany).mockRejectedValueOnce(genericError);
 
     await expect(getSurveys(environmentId)).rejects.toThrow(genericError);
     expect(logger.error).not.toHaveBeenCalled();
-    expect(cache).toHaveBeenCalled(); // Ensure cache wrapper was still called
+    // React cache is already mocked globally - no need to check it here
   });
 });

apps/web/app/(app)/environments/[environmentId]/integrations/lib/surveys.ts

@@ -1,6 +1,4 @@
 import "server-only";
-import { cache } from "@/lib/cache";
-import { surveyCache } from "@/lib/survey/cache";
 import { selectSurvey } from "@/lib/survey/service";
 import { transformPrismaSurvey } from "@/lib/survey/utils";
 import { validateInputs } from "@/lib/utils/validate";
@@ -12,38 +10,29 @@ import { ZId } from "@formbricks/types/common";
 import { DatabaseError } from "@formbricks/types/errors";
 import { TSurvey } from "@formbricks/types/surveys/types";
 
-export const getSurveys = reactCache(
-  async (environmentId: string): Promise<TSurvey[]> =>
-    cache(
-      async () => {
-        validateInputs([environmentId, ZId]);
+export const getSurveys = reactCache(async (environmentId: string): Promise<TSurvey[]> => {
+  validateInputs([environmentId, ZId]);
 
-        try {
-          const surveysPrisma = await prisma.survey.findMany({
-            where: {
-              environmentId,
-              status: {
-                not: "completed",
-              },
-            },
-            select: selectSurvey,
-            orderBy: {
-              updatedAt: "desc",
-            },
-          });
-
-          return surveysPrisma.map((surveyPrisma) => transformPrismaSurvey<TSurvey>(surveyPrisma));
-        } catch (error) {
-          if (error instanceof Prisma.PrismaClientKnownRequestError) {
-            logger.error({ error }, "getSurveys: Could not fetch surveys");
-            throw new DatabaseError(error.message);
-          }
-          throw error;
-        }
+  try {
+    const surveysPrisma = await prisma.survey.findMany({
+      where: {
+        environmentId,
+        status: {
+          not: "completed",
+        },
       },
-      [`getSurveys-${environmentId}`],
-      {
-        tags: [surveyCache.tag.byEnvironmentId(environmentId)],
-      }
-    )()
-);
+      select: selectSurvey,
+      orderBy: {
+        updatedAt: "desc",
+      },
+    });
+
+    return surveysPrisma.map((surveyPrisma) => transformPrismaSurvey<TSurvey>(surveyPrisma));
+  } catch (error) {
+    if (error instanceof Prisma.PrismaClientKnownRequestError) {
+      logger.error({ error }, "getSurveys: Could not fetch surveys");
+      throw new DatabaseError(error.message);
+    }
+    throw error;
+  }
+});

apps/web/app/(app)/environments/[environmentId]/integrations/lib/webhook.test.ts

@@ -1,21 +1,10 @@
-import { cache } from "@/lib/cache";
-import { webhookCache } from "@/lib/cache/webhook";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { afterEach, describe, expect, test, vi } from "vitest";
 import { prisma } from "@formbricks/database";
 import { DatabaseError } from "@formbricks/types/errors";
 import { getWebhookCountBySource } from "./webhook";
 
-// Mock dependencies
-vi.mock("@/lib/cache");
-vi.mock("@/lib/cache/webhook", () => ({
-  webhookCache: {
-    tag: {
-      byEnvironmentIdAndSource: vi.fn((envId, source) => `webhook_${envId}_${source ?? "all"}`),
-    },
-  },
-}));
 vi.mock("@/lib/utils/validate");
 vi.mock("@formbricks/database", () => ({
   prisma: {
@@ -29,12 +18,6 @@ const environmentId = "test-environment-id";
 const sourceZapier = "zapier";
 
 describe("getWebhookCountBySource", () => {
-  beforeEach(() => {
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-  });
-
   afterEach(() => {
     vi.resetAllMocks();
   });
@@ -56,13 +39,6 @@ describe("getWebhookCountBySource", () => {
         source: sourceZapier,
       },
     });
-    expect(cache).toHaveBeenCalledWith(
-      expect.any(Function),
-      [`getWebhookCountBySource-${environmentId}-${sourceZapier}`],
-      {
-        tags: [webhookCache.tag.byEnvironmentIdAndSource(environmentId, sourceZapier)],
-      }
-    );
   });
 
   test("should return total webhook count when source is undefined", async () => {
@@ -82,13 +58,6 @@ describe("getWebhookCountBySource", () => {
         source: undefined,
       },
     });
-    expect(cache).toHaveBeenCalledWith(
-      expect.any(Function),
-      [`getWebhookCountBySource-${environmentId}-undefined`],
-      {
-        tags: [webhookCache.tag.byEnvironmentIdAndSource(environmentId, undefined)],
-      }
-    );
   });
 
   test("should throw DatabaseError on Prisma known request error", async () => {
@@ -100,7 +69,6 @@ describe("getWebhookCountBySource", () => {
 
     await expect(getWebhookCountBySource(environmentId, sourceZapier)).rejects.toThrow(DatabaseError);
     expect(prisma.webhook.count).toHaveBeenCalledTimes(1);
-    expect(cache).toHaveBeenCalledTimes(1);
   });
 
   test("should throw original error on other errors", async () => {
@@ -109,6 +77,5 @@ describe("getWebhookCountBySource", () => {
 
     await expect(getWebhookCountBySource(environmentId)).rejects.toThrow(genericError);
     expect(prisma.webhook.count).toHaveBeenCalledTimes(1);
-    expect(cache).toHaveBeenCalledTimes(1);
   });
 });

apps/web/app/(app)/environments/[environmentId]/integrations/lib/webhook.ts

@@ -1,5 +1,3 @@
-import { cache } from "@/lib/cache";
-import { webhookCache } from "@/lib/cache/webhook";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma, Webhook } from "@prisma/client";
 import { z } from "zod";
@@ -7,29 +5,25 @@ import { prisma } from "@formbricks/database";
 import { ZId } from "@formbricks/types/common";
 import { DatabaseError } from "@formbricks/types/errors";
 
-export const getWebhookCountBySource = (environmentId: string, source?: Webhook["source"]): Promise<number> =>
-  cache(
-    async () => {
-      validateInputs([environmentId, ZId], [source, z.string().optional()]);
+export const getWebhookCountBySource = async (
+  environmentId: string,
+  source?: Webhook["source"]
+): Promise<number> => {
+  validateInputs([environmentId, ZId], [source, z.string().optional()]);
 
-      try {
-        const count = await prisma.webhook.count({
-          where: {
-            environmentId,
-            source,
-          },
-        });
-        return count;
-      } catch (error) {
-        if (error instanceof Prisma.PrismaClientKnownRequestError) {
-          throw new DatabaseError(error.message);
-        }
-
-        throw error;
-      }
-    },
-    [`getWebhookCountBySource-${environmentId}-${source}`],
-    {
-      tags: [webhookCache.tag.byEnvironmentIdAndSource(environmentId, source)],
+  try {
+    const count = await prisma.webhook.count({
+      where: {
+        environmentId,
+        source,
+      },
+    });
+    return count;
+  } catch (error) {
+    if (error instanceof Prisma.PrismaClientKnownRequestError) {
+      throw new DatabaseError(error.message);
     }
-  )();
+
+    throw error;
+  }
+};

apps/web/app/(app)/environments/[environmentId]/settings/(account)/profile/actions.ts

@@ -1,7 +1,7 @@
 "use server";
 
 import {
-  checkUserExistsByEmail,
+  getIsEmailUnique,
   verifyUserPassword,
 } from "@/app/(app)/environments/[environmentId]/settings/(account)/profile/lib/user";
 import { EMAIL_VERIFICATION_DISABLED } from "@/lib/constants";
@@ -10,13 +10,13 @@ import { getFileNameWithIdFromUrl } from "@/lib/storage/utils";
 import { updateUser } from "@/lib/user/service";
 import { authenticatedActionClient } from "@/lib/utils/action-client";
 import { rateLimit } from "@/lib/utils/rate-limit";
+import { updateBrevoCustomer } from "@/modules/auth/lib/brevo";
 import { sendVerificationNewEmail } from "@/modules/email";
 import { z } from "zod";
 import { ZId } from "@formbricks/types/common";
 import {
   AuthenticationError,
   AuthorizationError,
-  InvalidInputError,
   OperationNotAllowedError,
   TooManyRequestsError,
 } from "@formbricks/types/errors";
@@ -37,10 +37,11 @@ export const updateUserAction = authenticatedActionClient
     const inputEmail = parsedInput.email?.trim().toLowerCase();
 
     let payload: TUserUpdateInput = {
-      name: parsedInput.name,
-      locale: parsedInput.locale,
+      ...(parsedInput.name && { name: parsedInput.name }),
+      ...(parsedInput.locale && { locale: parsedInput.locale }),
     };
 
+    // Only process email update if a new email is provided and it's different from current email
     if (inputEmail && ctx.user.email !== inputEmail) {
       // Check rate limit
       try {
@@ -61,20 +62,26 @@ export const updateUserAction = authenticatedActionClient
         throw new AuthorizationError("Incorrect credentials");
       }
 
-      const doesUserExist = await checkUserExistsByEmail(inputEmail);
+      // Check if the new email is unique, no user exists with the new email
+      const isEmailUnique = await getIsEmailUnique(inputEmail);
 
-      if (doesUserExist) {
-        throw new InvalidInputError("This email is already in use");
-      }
-
-      if (EMAIL_VERIFICATION_DISABLED) {
-        payload.email = inputEmail;
-      } else {
-        await sendVerificationNewEmail(ctx.user.id, inputEmail);
+      // If the new email is unique, proceed with the email update
+      if (isEmailUnique) {
+        if (EMAIL_VERIFICATION_DISABLED) {
+          payload.email = inputEmail;
+          await updateBrevoCustomer({ id: ctx.user.id, email: inputEmail });
+        } else {
+          await sendVerificationNewEmail(ctx.user.id, inputEmail);
+        }
       }
     }
 
-    return await updateUser(ctx.user.id, payload);
+    // Only proceed with updateUser if we have actual changes to make
+    if (Object.keys(payload).length > 0) {
+      await updateUser(ctx.user.id, payload);
+    }
+
+    return true;
   });
 
 const ZUpdateAvatarAction = z.object({

apps/web/app/(app)/environments/[environmentId]/settings/(account)/profile/components/EditProfileDetailsForm.tsx

@@ -7,7 +7,8 @@ import { Button } from "@/modules/ui/components/button";
 import {
   DropdownMenu,
   DropdownMenuContent,
-  DropdownMenuItem,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
   DropdownMenuTrigger,
 } from "@/modules/ui/components/dropdown-menu";
 import { FormControl, FormError, FormField, FormItem, FormLabel } from "@/modules/ui/components/form";
@@ -21,11 +22,13 @@ import { useState } from "react";
 import { FormProvider, SubmitHandler, useForm } from "react-hook-form";
 import toast from "react-hot-toast";
 import { z } from "zod";
-import { TUser, TUserUpdateInput, ZUser } from "@formbricks/types/user";
+import { TUser, TUserUpdateInput, ZUser, ZUserEmail } from "@formbricks/types/user";
 import { updateUserAction } from "../actions";
 
 // Schema & types
-const ZEditProfileNameFormSchema = ZUser.pick({ name: true, locale: true, email: true });
+const ZEditProfileNameFormSchema = ZUser.pick({ name: true, locale: true, email: true }).extend({
+  email: ZUserEmail.transform((val) => val?.trim().toLowerCase()),
+});
 type TEditProfileNameForm = z.infer<typeof ZEditProfileNameFormSchema>;
 
 export const EditProfileDetailsForm = ({
@@ -80,9 +83,9 @@ export const EditProfileDetailsForm = ({
 
     if (updatedUserResult?.data) {
       if (!emailVerificationDisabled) {
-        toast.success(t("auth.verification-requested.verification_email_successfully_sent", { email }));
+        toast.success(t("auth.verification-requested.new_email_verification_success"));
       } else {
-        toast.success(t("environments.settings.profile.profile_updated_successfully"));
+        toast.success(t("environments.settings.profile.email_change_initiated"));
         await signOut({ redirect: false });
         router.push(`/email-change-without-verification-success`);
         return;
@@ -98,11 +101,6 @@ export const EditProfileDetailsForm = ({
   };
 
   const onSubmit: SubmitHandler<TEditProfileNameForm> = async (data) => {
-    if (data.email !== user.email && data.email.toLowerCase() === user.email.toLowerCase()) {
-      toast.error(t("auth.email-change.email_already_exists"));
-      return;
-    }
-
     if (data.email !== user.email) {
       setShowModal(true);
     } else {
@@ -178,20 +176,24 @@ export const EditProfileDetailsForm = ({
                         variant="ghost"
                         className="h-10 w-full border border-slate-300 px-3 text-left">
                         <div className="flex w-full items-center justify-between">
-                          {appLanguages.find((l) => l.code === field.value)?.label[field.value] ?? "NA"}
+                          {appLanguages.find((l) => l.code === field.value)?.label["en-US"] ?? "NA"}
                           <ChevronDownIcon className="h-4 w-4 text-slate-500" />
                         </div>
                       </Button>
                     </DropdownMenuTrigger>
-                    <DropdownMenuContent className="w-40 bg-slate-50 text-slate-700" align="start">
-                      {appLanguages.map((lang) => (
-                        <DropdownMenuItem
-                          key={lang.code}
-                          onClick={() => field.onChange(lang.code)}
-                          className="min-h-8 cursor-pointer">
-                          {lang.label[field.value]}
-                        </DropdownMenuItem>
-                      ))}
+                    <DropdownMenuContent
+                      className="min-w-[var(--radix-dropdown-menu-trigger-width)] bg-slate-50 text-slate-700"
+                      align="start">
+                      <DropdownMenuRadioGroup value={field.value} onValueChange={field.onChange}>
+                        {appLanguages.map((lang) => (
+                          <DropdownMenuRadioItem
+                            key={lang.code}
+                            value={lang.code}
+                            className="min-h-8 cursor-pointer">
+                            {lang.label["en-US"]}
+                          </DropdownMenuRadioItem>
+                        ))}
+                      </DropdownMenuRadioGroup>
                     </DropdownMenuContent>
                   </DropdownMenu>
                 </FormControl>

apps/web/app/(app)/environments/[environmentId]/settings/(account)/profile/lib/user.test.ts

@@ -2,17 +2,7 @@ import { verifyPassword as mockVerifyPasswordImported } from "@/modules/auth/lib
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { prisma } from "@formbricks/database";
 import { InvalidInputError, ResourceNotFoundError } from "@formbricks/types/errors";
-import { checkUserExistsByEmail, verifyUserPassword } from "./user";
-
-// Mock dependencies
-vi.mock("@/lib/user/cache", () => ({
-  userCache: {
-    tag: {
-      byId: vi.fn((id) => `user-${id}-tag`),
-      byEmail: vi.fn((email) => `user-email-${email}-tag`),
-    },
-  },
-}));
+import { getIsEmailUnique, verifyUserPassword } from "./user";
 
 vi.mock("@/modules/auth/lib/utils", () => ({
   verifyPassword: vi.fn(),
@@ -26,9 +16,6 @@ vi.mock("@formbricks/database", () => ({
   },
 }));
 
-// reactCache (from "react") and unstable_cache (from "next/cache") are mocked in vitestSetup.ts
-// to be pass-through, so the inner logic of cached functions is tested.
-
 const mockPrismaUserFindUnique = vi.mocked(prisma.user.findUnique);
 const mockVerifyPasswordUtil = vi.mocked(mockVerifyPasswordImported);
 
@@ -116,27 +103,27 @@ describe("User Library Tests", () => {
     });
   });
 
-  describe("checkUserExistsByEmail", () => {
+  describe("getIsEmailUnique", () => {
     const email = "test@example.com";
 
-    test("should return true if user exists", async () => {
+    test("should return false if user exists", async () => {
       mockPrismaUserFindUnique.mockResolvedValue({
         id: "some-user-id",
       } as any);
 
-      const result = await checkUserExistsByEmail(email);
-      expect(result).toBe(true);
+      const result = await getIsEmailUnique(email);
+      expect(result).toBe(false);
       expect(mockPrismaUserFindUnique).toHaveBeenCalledWith({
         where: { email },
         select: { id: true },
       });
     });
 
-    test("should return false if user does not exist", async () => {
+    test("should return true if user does not exist", async () => {
       mockPrismaUserFindUnique.mockResolvedValue(null);
 
-      const result = await checkUserExistsByEmail(email);
-      expect(result).toBe(false);
+      const result = await getIsEmailUnique(email);
+      expect(result).toBe(true);
       expect(mockPrismaUserFindUnique).toHaveBeenCalledWith({
         where: { email },
         select: { id: true },

apps/web/app/(app)/environments/[environmentId]/settings/(account)/profile/lib/user.ts

@@ -1,5 +1,3 @@
-import { cache } from "@/lib/cache";
-import { userCache } from "@/lib/user/cache";
 import { verifyPassword } from "@/modules/auth/lib/utils";
 import { User } from "@prisma/client";
 import { cache as reactCache } from "react";
@@ -7,28 +5,21 @@ import { prisma } from "@formbricks/database";
 import { InvalidInputError, ResourceNotFoundError } from "@formbricks/types/errors";
 
 export const getUserById = reactCache(
-  async (userId: string): Promise<Pick<User, "password" | "identityProvider">> =>
-    cache(
-      async () => {
-        const user = await prisma.user.findUnique({
-          where: {
-            id: userId,
-          },
-          select: {
-            password: true,
-            identityProvider: true,
-          },
-        });
-        if (!user) {
-          throw new ResourceNotFoundError("user", userId);
-        }
-        return user;
+  async (userId: string): Promise<Pick<User, "password" | "identityProvider">> => {
+    const user = await prisma.user.findUnique({
+      where: {
+        id: userId,
       },
-      [`getUserById-${userId}`],
-      {
-        tags: [userCache.tag.byId(userId)],
-      }
-    )()
+      select: {
+        password: true,
+        identityProvider: true,
+      },
+    });
+    if (!user) {
+      throw new ResourceNotFoundError("user", userId);
+    }
+    return user;
+  }
 );
 
 export const verifyUserPassword = async (userId: string, password: string): Promise<boolean> => {
@@ -47,24 +38,15 @@ export const verifyUserPassword = async (userId: string, password: string): Prom
   return true;
 };
 
-export const checkUserExistsByEmail = reactCache(
-  async (email: string): Promise<boolean> =>
-    cache(
-      async () => {
-        const user = await prisma.user.findUnique({
-          where: {
-            email: email.toLowerCase(),
-          },
-          select: {
-            id: true,
-          },
-        });
+export const getIsEmailUnique = reactCache(async (email: string): Promise<boolean> => {
+  const user = await prisma.user.findUnique({
+    where: {
+      email: email.toLowerCase(),
+    },
+    select: {
+      id: true,
+    },
+  });
 
-        return !!user;
-      },
-      [`checkUserExistsByEmail-${email}`],
-      {
-        tags: [userCache.tag.byEmail(email)],
-      }
-    )()
-);
+  return !user;
+});

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/actions.ts

@@ -75,7 +75,6 @@ export const getSurveySummaryAction = authenticatedActionClient
         },
       ],
     });
-
     return getSurveySummary(parsedInput.surveyId, parsedInput.filterCriteria);
   });
 

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/SurveyAnalysisNavigation.test.tsx

@@ -5,7 +5,6 @@ import {
 } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/actions";
 import { SurveyAnalysisNavigation } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/SurveyAnalysisNavigation";
 import { getFormattedFilters } from "@/app/lib/surveys/surveys";
-import { useIntervalWhenFocused } from "@/lib/utils/hooks/useIntervalWhenFocused";
 import { SecondaryNavigation } from "@/modules/ui/components/secondary-navigation";
 import { act, cleanup, render, waitFor } from "@testing-library/react";
 import { useParams, usePathname, useSearchParams } from "next/navigation";
@@ -52,7 +51,6 @@ vi.mock("@/app/(app)/environments/[environmentId]/components/ResponseFilterConte
 vi.mock("@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/actions");
 vi.mock("@/app/lib/surveys/surveys");
 vi.mock("@/app/share/[sharingKey]/actions");
-vi.mock("@/lib/utils/hooks/useIntervalWhenFocused");
 vi.mock("@/modules/ui/components/secondary-navigation", () => ({
   SecondaryNavigation: vi.fn(() => <div data-testid="secondary-navigation" />),
 }));
@@ -69,7 +67,6 @@ const mockUseResponseFilter = vi.mocked(useResponseFilter);
 const mockGetResponseCountAction = vi.mocked(getResponseCountAction);
 const mockRevalidateSurveyIdPath = vi.mocked(revalidateSurveyIdPath);
 const mockGetFormattedFilters = vi.mocked(getFormattedFilters);
-const mockUseIntervalWhenFocused = vi.mocked(useIntervalWhenFocused);
 const MockSecondaryNavigation = vi.mocked(SecondaryNavigation);
 
 const mockSurveyLanguages: TSurveyLanguage[] = [
@@ -120,7 +117,6 @@ const mockSurvey = {
 const defaultProps = {
   environmentId: "testEnvId",
   survey: mockSurvey,
-  initialTotalResponseCount: 10,
   activeId: "summary",
 };
 
@@ -167,23 +163,20 @@ describe("SurveyAnalysisNavigation", () => {
     );
   });
 
-  test("passes correct runWhen flag to useIntervalWhenFocused based on share embed modal", () => {
+  test("renders navigation correctly for sharing page", () => {
     mockUsePathname.mockReturnValue(
       `/environments/${defaultProps.environmentId}/surveys/${mockSurvey.id}/summary`
     );
-    mockUseParams.mockReturnValue({ environmentId: defaultProps.environmentId, surveyId: mockSurvey.id });
+    mockUseParams.mockReturnValue({ sharingKey: "test-sharing-key" });
     mockUseResponseFilter.mockReturnValue({ selectedFilter: "all", dateRange: {} } as any);
     mockGetFormattedFilters.mockReturnValue([] as any);
     mockGetResponseCountAction.mockResolvedValue({ data: 5 });
 
-    mockUseSearchParams.mockReturnValue({ get: vi.fn().mockReturnValue("true") } as any);
     render(<SurveyAnalysisNavigation {...defaultProps} />);
-    expect(mockUseIntervalWhenFocused).toHaveBeenCalledWith(expect.any(Function), 10000, false, false);
-    cleanup();
 
-    mockUseSearchParams.mockReturnValue({ get: vi.fn().mockReturnValue(null) } as any);
-    render(<SurveyAnalysisNavigation {...defaultProps} />);
-    expect(mockUseIntervalWhenFocused).toHaveBeenCalledWith(expect.any(Function), 10000, true, false);
+    expect(MockSecondaryNavigation).toHaveBeenCalled();
+    const lastCallArgs = MockSecondaryNavigation.mock.calls[MockSecondaryNavigation.mock.calls.length - 1][0];
+    expect(lastCallArgs.navigation[0].href).toContain("/share/test-sharing-key");
   });
 
   test("displays correct response count string in label for various scenarios", async () => {
@@ -196,8 +189,8 @@ describe("SurveyAnalysisNavigation", () => {
     mockGetFormattedFilters.mockReturnValue([] as any);
 
     // Scenario 1: total = 10, filtered = null (initial state)
-    render(<SurveyAnalysisNavigation {...defaultProps} initialTotalResponseCount={10} />);
-    expect(MockSecondaryNavigation.mock.calls[0][0].navigation[1].label).toBe("common.responses (10)");
+    render(<SurveyAnalysisNavigation {...defaultProps} />);
+    expect(MockSecondaryNavigation.mock.calls[0][0].navigation[1].label).toBe("common.responses");
     cleanup();
     vi.resetAllMocks(); // Reset mocks for next case
 
@@ -213,11 +206,11 @@ describe("SurveyAnalysisNavigation", () => {
       if (args && "filterCriteria" in args) return { data: 15, error: null, success: true };
       return { data: 15, error: null, success: true };
     });
-    render(<SurveyAnalysisNavigation {...defaultProps} initialTotalResponseCount={15} />);
+    render(<SurveyAnalysisNavigation {...defaultProps} />);
     await waitFor(() => {
       const lastCallArgs =
         MockSecondaryNavigation.mock.calls[MockSecondaryNavigation.mock.calls.length - 1][0];
-      expect(lastCallArgs.navigation[1].label).toBe("common.responses (15)");
+      expect(lastCallArgs.navigation[1].label).toBe("common.responses");
     });
     cleanup();
     vi.resetAllMocks();
@@ -234,11 +227,11 @@ describe("SurveyAnalysisNavigation", () => {
       if (args && "filterCriteria" in args) return { data: 15, error: null, success: true };
       return { data: 10, error: null, success: true };
     });
-    render(<SurveyAnalysisNavigation {...defaultProps} initialTotalResponseCount={10} />);
+    render(<SurveyAnalysisNavigation {...defaultProps} />);
     await waitFor(() => {
       const lastCallArgs =
         MockSecondaryNavigation.mock.calls[MockSecondaryNavigation.mock.calls.length - 1][0];
-      expect(lastCallArgs.navigation[1].label).toBe("common.responses (15)");
+      expect(lastCallArgs.navigation[1].label).toBe("common.responses");
     });
   });
 });

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/SurveyAnalysisNavigation.tsx

@@ -1,105 +1,30 @@
 "use client";
 
-import { useResponseFilter } from "@/app/(app)/environments/[environmentId]/components/ResponseFilterContext";
-import {
-  getResponseCountAction,
-  revalidateSurveyIdPath,
-} from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/actions";
-import { getFormattedFilters } from "@/app/lib/surveys/surveys";
-import { getResponseCountBySurveySharingKeyAction } from "@/app/share/[sharingKey]/actions";
-import { useIntervalWhenFocused } from "@/lib/utils/hooks/useIntervalWhenFocused";
+import { revalidateSurveyIdPath } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/actions";
 import { SecondaryNavigation } from "@/modules/ui/components/secondary-navigation";
 import { useTranslate } from "@tolgee/react";
 import { InboxIcon, PresentationIcon } from "lucide-react";
-import { useParams, usePathname, useSearchParams } from "next/navigation";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useParams, usePathname } from "next/navigation";
 import { TSurvey } from "@formbricks/types/surveys/types";
 
 interface SurveyAnalysisNavigationProps {
   environmentId: string;
   survey: TSurvey;
-  initialTotalResponseCount: number | null;
   activeId: string;
 }
 
 export const SurveyAnalysisNavigation = ({
   environmentId,
   survey,
-  initialTotalResponseCount,
   activeId,
 }: SurveyAnalysisNavigationProps) => {
   const pathname = usePathname();
   const { t } = useTranslate();
   const params = useParams();
-  const [filteredResponseCount, setFilteredResponseCount] = useState<number | null>(null);
-  const [totalResponseCount, setTotalResponseCount] = useState<number | null>(initialTotalResponseCount);
   const sharingKey = params.sharingKey as string;
   const isSharingPage = !!sharingKey;
 
-  const searchParams = useSearchParams();
-  const isShareEmbedModalOpen = searchParams.get("share") === "true";
-
   const url = isSharingPage ? `/share/${sharingKey}` : `/environments/${environmentId}/surveys/${survey.id}`;
-  const { selectedFilter, dateRange } = useResponseFilter();
-
-  const filters = useMemo(
-    () => getFormattedFilters(survey, selectedFilter, dateRange),
-    [selectedFilter, dateRange, survey]
-  );
-
-  const latestFiltersRef = useRef(filters);
-  latestFiltersRef.current = filters;
-
-  const getResponseCount = () => {
-    if (isSharingPage) return getResponseCountBySurveySharingKeyAction({ sharingKey });
-    return getResponseCountAction({ surveyId: survey.id });
-  };
-
-  const fetchResponseCount = async () => {
-    const count = await getResponseCount();
-    const responseCount = count?.data ?? 0;
-    setTotalResponseCount(responseCount);
-  };
-
-  const getFilteredResponseCount = useCallback(() => {
-    if (isSharingPage)
-      return getResponseCountBySurveySharingKeyAction({
-        sharingKey,
-        filterCriteria: latestFiltersRef.current,
-      });
-    return getResponseCountAction({ surveyId: survey.id, filterCriteria: latestFiltersRef.current });
-  }, [isSharingPage, sharingKey, survey.id]);
-
-  const fetchFilteredResponseCount = useCallback(async () => {
-    const count = await getFilteredResponseCount();
-    const responseCount = count?.data ?? 0;
-    setFilteredResponseCount(responseCount);
-  }, [getFilteredResponseCount]);
-
-  useEffect(() => {
-    fetchFilteredResponseCount();
-  }, [filters, isSharingPage, sharingKey, survey.id, fetchFilteredResponseCount]);
-
-  useIntervalWhenFocused(
-    () => {
-      fetchResponseCount();
-      fetchFilteredResponseCount();
-    },
-    10000,
-    !isShareEmbedModalOpen,
-    false
-  );
-
-  const getResponseCountString = () => {
-    if (totalResponseCount === null) return "";
-    if (filteredResponseCount === null) return `(${totalResponseCount})`;
-
-    const totalCount = Math.max(totalResponseCount, filteredResponseCount);
-
-    if (totalCount === filteredResponseCount) return `(${totalCount})`;
-
-    return `(${filteredResponseCount} of ${totalCount})`;
-  };
 
   const navigation = [
     {
@@ -114,7 +39,7 @@ export const SurveyAnalysisNavigation = ({
     },
     {
       id: "responses",
-      label: `${t("common.responses")} ${getResponseCountString()}`,
+      label: t("common.responses"),
       icon: <InboxIcon className="h-5 w-5" />,
       href: `${url}/responses?referer=true`,
       current: pathname?.includes("/responses"),

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/responses/components/ResponsePage.test.tsx

@@ -162,7 +162,6 @@ describe("ResponsePage", () => {
       expect(screen.getByTestId("results-share-button")).toBeInTheDocument();
       expect(screen.getByTestId("response-data-view")).toBeInTheDocument();
     });
-    expect(mockGetResponseCountAction).toHaveBeenCalled();
     expect(mockGetResponsesAction).toHaveBeenCalled();
   });
 
@@ -179,7 +178,6 @@ describe("ResponsePage", () => {
     await waitFor(() => {
       expect(screen.queryByTestId("results-share-button")).not.toBeInTheDocument();
     });
-    expect(mockGetResponseCountBySurveySharingKeyAction).toHaveBeenCalled();
     expect(mockGetResponsesBySurveySharingKeyAction).toHaveBeenCalled();
   });
 
@@ -297,8 +295,7 @@ describe("ResponsePage", () => {
     rerender(<ResponsePage {...defaultProps} />);
 
     await waitFor(() => {
-      // Should fetch count and responses again due to filter change
-      expect(mockGetResponseCountAction).toHaveBeenCalledTimes(2);
+      // Should fetch responses again due to filter change
       expect(mockGetResponsesAction).toHaveBeenCalledTimes(2);
       // Check if it fetches with offset 0 (first page)
       expect(mockGetResponsesAction).toHaveBeenLastCalledWith(

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/responses/components/ResponsePage.tsx

@@ -1,18 +1,12 @@
 "use client";
 
 import { useResponseFilter } from "@/app/(app)/environments/[environmentId]/components/ResponseFilterContext";
-import {
-  getResponseCountAction,
-  getResponsesAction,
-} from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/actions";
+import { getResponsesAction } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/actions";
 import { ResponseDataView } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/responses/components/ResponseDataView";
 import { CustomFilter } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/components/CustomFilter";
 import { ResultsShareButton } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/components/ResultsShareButton";
 import { getFormattedFilters } from "@/app/lib/surveys/surveys";
-import {
-  getResponseCountBySurveySharingKeyAction,
-  getResponsesBySurveySharingKeyAction,
-} from "@/app/share/[sharingKey]/actions";
+import { getResponsesBySurveySharingKeyAction } from "@/app/share/[sharingKey]/actions";
 import { replaceHeadlineRecall } from "@/lib/utils/recall";
 import { useParams, useSearchParams } from "next/navigation";
 import { useCallback, useEffect, useMemo, useState } from "react";
@@ -49,7 +43,6 @@ export const ResponsePage = ({
   const sharingKey = params.sharingKey as string;
   const isSharingPage = !!sharingKey;
 
-  const [responseCount, setResponseCount] = useState<number | null>(null);
   const [responses, setResponses] = useState<TResponse[]>([]);
   const [page, setPage] = useState<number>(1);
   const [hasMore, setHasMore] = useState<boolean>(true);
@@ -97,9 +90,6 @@ export const ResponsePage = ({
 
   const deleteResponses = (responseIds: string[]) => {
     setResponses(responses.filter((response) => !responseIds.includes(response.id)));
-    if (responseCount) {
-      setResponseCount(responseCount - responseIds.length);
-    }
   };
 
   const updateResponse = (responseId: string, updatedResponse: TResponse) => {
@@ -118,29 +108,6 @@ export const ResponsePage = ({
     }
   }, [searchParams, resetState]);
 
-  useEffect(() => {
-    const handleResponsesCount = async () => {
-      let responseCount = 0;
-
-      if (isSharingPage) {
-        const responseCountActionResponse = await getResponseCountBySurveySharingKeyAction({
-          sharingKey,
-          filterCriteria: filters,
-        });
-        responseCount = responseCountActionResponse?.data || 0;
-      } else {
-        const responseCountActionResponse = await getResponseCountAction({
-          surveyId,
-          filterCriteria: filters,
-        });
-        responseCount = responseCountActionResponse?.data || 0;
-      }
-
-      setResponseCount(responseCount);
-    };
-    handleResponsesCount();
-  }, [filters, isSharingPage, sharingKey, surveyId]);
-
   useEffect(() => {
     const fetchInitialResponses = async () => {
       try {

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/responses/page.test.tsx

@@ -1,3 +1,4 @@
+import { ResponseFilterProvider } from "@/app/(app)/environments/[environmentId]/components/ResponseFilterContext";
 import { SurveyAnalysisNavigation } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/SurveyAnalysisNavigation";
 import { ResponsePage } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/responses/components/ResponsePage";
 import Page from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/responses/page";
@@ -61,6 +62,7 @@ vi.mock("@/lib/constants", () => ({
   SENTRY_DSN: "mock-sentry-dsn",
   WEBAPP_URL: "http://localhost:3000",
   RESPONSES_PER_PAGE: 10,
+  SESSION_MAX_AGE: 1000,
 }));
 
 vi.mock("@/lib/getSurveyUrl", () => ({
@@ -109,6 +111,14 @@ vi.mock("@/tolgee/server", () => ({
   getTranslate: async () => (key: string) => key,
 }));
 
+vi.mock("next/navigation", () => ({
+  useParams: () => ({
+    environmentId: "test-env-id",
+    surveyId: "test-survey-id",
+    sharingKey: null,
+  }),
+}));
+
 const mockEnvironmentId = "test-env-id";
 const mockSurveyId = "test-survey-id";
 const mockUserId = "test-user-id";
@@ -180,7 +190,7 @@ describe("ResponsesPage", () => {
   test("renders correctly with all data", async () => {
     const props = { params: mockParams };
     const jsx = await Page(props);
-    render(jsx);
+    render(<ResponseFilterProvider>{jsx}</ResponseFilterProvider>);
 
     await screen.findByTestId("page-content-wrapper");
     expect(screen.getByTestId("page-header")).toBeInTheDocument();
@@ -196,7 +206,6 @@ describe("ResponsesPage", () => {
         isReadOnly: false,
         user: mockUser,
         surveyDomain: mockSurveyDomain,
-        responseCount: 10,
       }),
       undefined
     );
@@ -206,7 +215,6 @@ describe("ResponsesPage", () => {
         environmentId: mockEnvironmentId,
         survey: mockSurvey,
         activeId: "responses",
-        initialTotalResponseCount: 10,
       }),
       undefined
     );

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/responses/page.tsx

@@ -33,7 +33,8 @@ const Page = async (props) => {
 
   const tags = await getTagsByEnvironmentId(params.environmentId);
 
-  const totalResponseCount = await getResponseCountBySurveyId(params.surveyId);
+  // Get response count for the CTA component
+  const responseCount = await getResponseCountBySurveyId(params.surveyId);
 
   const locale = await findMatchingLocale();
   const surveyDomain = getSurveyDomain();
@@ -49,15 +50,10 @@ const Page = async (props) => {
             isReadOnly={isReadOnly}
             user={user}
             surveyDomain={surveyDomain}
-            responseCount={totalResponseCount}
+            responseCount={responseCount}
           />
         }>
-        <SurveyAnalysisNavigation
-          environmentId={environment.id}
-          survey={survey}
-          activeId="responses"
-          initialTotalResponseCount={totalResponseCount}
-        />
+        <SurveyAnalysisNavigation environmentId={environment.id} survey={survey} activeId="responses" />
       </PageHeader>
       <ResponsePage
         environment={environment}

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SummaryList.tsx

@@ -38,18 +38,10 @@ interface SummaryListProps {
   responseCount: number | null;
   environment: TEnvironment;
   survey: TSurvey;
-  totalResponseCount: number;
   locale: TUserLocale;
 }
 
-export const SummaryList = ({
-  summary,
-  environment,
-  responseCount,
-  survey,
-  totalResponseCount,
-  locale,
-}: SummaryListProps) => {
+export const SummaryList = ({ summary, environment, responseCount, survey, locale }: SummaryListProps) => {
   const { setSelectedFilter, selectedFilter } = useResponseFilter();
   const { t } = useTranslate();
   const setFilter = (
@@ -115,11 +107,7 @@ export const SummaryList = ({
           type="response"
           environment={environment}
           noWidgetRequired={survey.type === "link"}
-          emptyMessage={
-            totalResponseCount === 0
-              ? undefined
-              : t("environments.surveys.summary.no_response_matches_filter")
-          }
+          emptyMessage={t("environments.surveys.summary.no_responses_found")}
         />
       ) : (
         summary.map((questionSummary) => {

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SummaryPage.tsx

@@ -1,30 +1,23 @@
 "use client";
 
 import { useResponseFilter } from "@/app/(app)/environments/[environmentId]/components/ResponseFilterContext";
-import {
-  getResponseCountAction,
-  getSurveySummaryAction,
-} from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/actions";
+import { getSurveySummaryAction } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/actions";
 import ScrollToTop from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/ScrollToTop";
 import { SummaryDropOffs } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SummaryDropOffs";
 import { CustomFilter } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/components/CustomFilter";
 import { ResultsShareButton } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/components/ResultsShareButton";
 import { getFormattedFilters } from "@/app/lib/surveys/surveys";
-import {
-  getResponseCountBySurveySharingKeyAction,
-  getSummaryBySurveySharingKeyAction,
-} from "@/app/share/[sharingKey]/actions";
-import { useIntervalWhenFocused } from "@/lib/utils/hooks/useIntervalWhenFocused";
+import { getSummaryBySurveySharingKeyAction } from "@/app/share/[sharingKey]/actions";
 import { replaceHeadlineRecall } from "@/lib/utils/recall";
 import { useParams, useSearchParams } from "next/navigation";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { TEnvironment } from "@formbricks/types/environment";
 import { TSurvey, TSurveySummary } from "@formbricks/types/surveys/types";
-import { TUser, TUserLocale } from "@formbricks/types/user";
+import { TUserLocale } from "@formbricks/types/user";
 import { SummaryList } from "./SummaryList";
 import { SummaryMetadata } from "./SummaryMetadata";
 
-const initialSurveySummary: TSurveySummary = {
+const defaultSurveySummary: TSurveySummary = {
   meta: {
     completedPercentage: 0,
     completedResponses: 0,
@@ -44,11 +37,9 @@ interface SummaryPageProps {
   survey: TSurvey;
   surveyId: string;
   webAppUrl: string;
-  user?: TUser;
-  totalResponseCount: number;
-  documentsPerPage?: number;
   locale: TUserLocale;
   isReadOnly: boolean;
+  initialSurveySummary?: TSurveySummary;
 }
 
 export const SummaryPage = ({
@@ -56,98 +47,69 @@ export const SummaryPage = ({
   survey,
   surveyId,
   webAppUrl,
-  totalResponseCount,
   locale,
   isReadOnly,
+  initialSurveySummary,
 }: SummaryPageProps) => {
   const params = useParams();
   const sharingKey = params.sharingKey as string;
   const isSharingPage = !!sharingKey;
 
   const searchParams = useSearchParams();
-  const isShareEmbedModalOpen = searchParams.get("share") === "true";
 
-  const [responseCount, setResponseCount] = useState<number | null>(null);
-  const [surveySummary, setSurveySummary] = useState<TSurveySummary>(initialSurveySummary);
+  const [surveySummary, setSurveySummary] = useState<TSurveySummary>(
+    initialSurveySummary || defaultSurveySummary
+  );
   const [showDropOffs, setShowDropOffs] = useState<boolean>(false);
-  const [isLoading, setIsLoading] = useState(true);
+  const [isLoading, setIsLoading] = useState(!initialSurveySummary);
 
   const { selectedFilter, dateRange, resetState } = useResponseFilter();
 
-  const filters = useMemo(
-    () => getFormattedFilters(survey, selectedFilter, dateRange),
-    [selectedFilter, dateRange, survey]
-  );
+  // Only fetch data when filters change or when there's no initial data
+  useEffect(() => {
+    // If we have initial data and no filters are applied, don't fetch
+    const hasNoFilters =
+      (!selectedFilter ||
+        Object.keys(selectedFilter).length === 0 ||
+        (selectedFilter.filter && selectedFilter.filter.length === 0)) &&
+      (!dateRange || (!dateRange.from && !dateRange.to));
 
-  // Use a ref to keep the latest state and props
-  const latestFiltersRef = useRef(filters);
-  latestFiltersRef.current = filters;
+    if (initialSurveySummary && hasNoFilters) {
+      setIsLoading(false);
+      return;
+    }
 
-  const getResponseCount = useCallback(() => {
-    if (isSharingPage)
-      return getResponseCountBySurveySharingKeyAction({
-        sharingKey,
-        filterCriteria: latestFiltersRef.current,
-      });
-    return getResponseCountAction({
-      surveyId,
-      filterCriteria: latestFiltersRef.current,
-    });
-  }, [isSharingPage, sharingKey, surveyId]);
-
-  const getSummary = useCallback(() => {
-    if (isSharingPage)
-      return getSummaryBySurveySharingKeyAction({
-        sharingKey,
-        filterCriteria: latestFiltersRef.current,
-      });
-
-    return getSurveySummaryAction({
-      surveyId,
-      filterCriteria: latestFiltersRef.current,
-    });
-  }, [isSharingPage, sharingKey, surveyId]);
-
-  const handleInitialData = useCallback(
-    async (isInitialLoad = false) => {
-      if (isInitialLoad) {
-        setIsLoading(true);
-      }
+    const fetchSummary = async () => {
+      setIsLoading(true);
 
       try {
-        const [updatedResponseCountData, updatedSurveySummary] = await Promise.all([
-          getResponseCount(),
-          getSummary(),
-        ]);
+        // Recalculate filters inside the effect to ensure we have the latest values
+        const currentFilters = getFormattedFilters(survey, selectedFilter, dateRange);
+        let updatedSurveySummary;
 
-        const responseCount = updatedResponseCountData?.data ?? 0;
-        const surveySummary = updatedSurveySummary?.data ?? initialSurveySummary;
+        if (isSharingPage) {
+          updatedSurveySummary = await getSummaryBySurveySharingKeyAction({
+            sharingKey,
+            filterCriteria: currentFilters,
+          });
+        } else {
+          updatedSurveySummary = await getSurveySummaryAction({
+            surveyId,
+            filterCriteria: currentFilters,
+          });
+        }
 
-        setResponseCount(responseCount);
+        const surveySummary = updatedSurveySummary?.data ?? defaultSurveySummary;
         setSurveySummary(surveySummary);
       } catch (error) {
         console.error(error);
       } finally {
-        if (isInitialLoad) {
-          setIsLoading(false);
-        }
+        setIsLoading(false);
       }
-    },
-    [getResponseCount, getSummary]
-  );
+    };
 
-  useEffect(() => {
-    handleInitialData(true);
-  }, [filters, isSharingPage, sharingKey, surveyId, handleInitialData]);
-
-  useIntervalWhenFocused(
-    () => {
-      handleInitialData(false);
-    },
-    10000,
-    !isShareEmbedModalOpen,
-    false
-  );
+    fetchSummary();
+  }, [selectedFilter, dateRange, survey, isSharingPage, sharingKey, surveyId, initialSurveySummary]);
 
   const surveyMemoized = useMemo(() => {
     return replaceHeadlineRecall(survey, "default");
@@ -177,10 +139,9 @@ export const SummaryPage = ({
       <ScrollToTop containerId="mainContent" />
       <SummaryList
         summary={surveySummary.summary}
-        responseCount={responseCount}
+        responseCount={surveySummary.meta.totalResponses}
         survey={surveyMemoized}
         environment={environment}
-        totalResponseCount={totalResponseCount}
         locale={locale}
       />
     </>

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SurveyAnalysisCTA.test.tsx

@@ -51,6 +51,7 @@ vi.mock("next/navigation", () => ({
   useRouter: () => ({ push: mockPush }),
   useSearchParams: () => mockSearchParams,
   usePathname: () => "/current",
+  useParams: () => ({ environmentId: "env123", surveyId: "survey123" }),
 }));
 
 // Mock copySurveyLink to return a predictable string
@@ -69,6 +70,23 @@ vi.mock("@/lib/utils/helper", () => ({
   getFormattedErrorMessage: vi.fn((response) => response?.error || "Unknown error"),
 }));
 
+// Mock ResponseCountProvider dependencies
+vi.mock("@/app/(app)/environments/[environmentId]/components/ResponseFilterContext", () => ({
+  useResponseFilter: vi.fn(() => ({ selectedFilter: "all", dateRange: {} })),
+}));
+
+vi.mock("@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/actions", () => ({
+  getResponseCountAction: vi.fn(() => Promise.resolve({ data: 5 })),
+}));
+
+vi.mock("@/app/lib/surveys/surveys", () => ({
+  getFormattedFilters: vi.fn(() => []),
+}));
+
+vi.mock("@/app/share/[sharingKey]/actions", () => ({
+  getResponseCountBySurveySharingKeyAction: vi.fn(() => Promise.resolve({ data: 5 })),
+}));
+
 vi.spyOn(toast, "success");
 vi.spyOn(toast, "error");
 

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SurveyAnalysisCTA.tsx

@@ -171,7 +171,7 @@ export const SurveyAnalysisCTA = ({
       icon: SquarePenIcon,
       tooltip: t("common.edit"),
       onClick: () => {
-        responseCount && responseCount > 0
+        responseCount > 0
           ? setIsCautionDialogOpen(true)
           : router.push(`/environments/${environment.id}/surveys/${survey.id}/edit`);
       },

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/lib/surveySummary.test.ts

@@ -1,4 +1,3 @@
-import { cache } from "@/lib/cache";
 import { getDisplayCountBySurveyId } from "@/lib/display/service";
 import { getLocalizedValue } from "@/lib/i18n/utils";
 import { getResponseCountBySurveyId } from "@/lib/response/service";
@@ -26,23 +25,6 @@ import {
 // Ensure this path is correct
 import { convertFloatTo2Decimal } from "./utils";
 
-// Mock dependencies
-vi.mock("@/lib/cache", async () => {
-  const actual = await vi.importActual("@/lib/cache");
-  return {
-    ...(actual as any),
-    cache: vi.fn((fn) => fn()), // Mock cache function to just execute the passed function
-  };
-});
-
-vi.mock("react", async () => {
-  const actual = await vi.importActual("react");
-  return {
-    ...actual,
-    cache: vi.fn().mockImplementation((fn) => fn),
-  };
-});
-
 vi.mock("@/lib/display/service", () => ({
   getDisplayCountBySurveyId: vi.fn(),
 }));
@@ -162,10 +144,6 @@ describe("getSurveySummaryMeta", () => {
     vi.mocked(convertFloatTo2Decimal).mockImplementation((num) =>
       num !== undefined && num !== null ? parseFloat(num.toFixed(2)) : 0
     );
-
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
   });
 
   test("calculates meta correctly", () => {
@@ -226,9 +204,6 @@ describe("getSurveySummaryDropOff", () => {
       requiredQuestionIds: [],
       calculations: {},
     });
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
   });
 
   test("calculates dropOff correctly with welcome card disabled", () => {
@@ -367,9 +342,7 @@ describe("getQuestionSummary", () => {
     vi.mocked(convertFloatTo2Decimal).mockImplementation((num) =>
       num !== undefined && num !== null ? parseFloat(num.toFixed(2)) : 0
     );
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
+    // React cache is already mocked globally - no need to mock it again
   });
 
   test("summarizes OpenText questions", async () => {
@@ -746,9 +719,7 @@ describe("getSurveySummary", () => {
     vi.mocked(convertFloatTo2Decimal).mockImplementation((num) =>
       num !== undefined && num !== null ? parseFloat(num.toFixed(2)) : 0
     );
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
+    // React cache is already mocked globally - no need to mock it again
   });
 
   test("returns survey summary successfully", async () => {
@@ -758,7 +729,6 @@ describe("getSurveySummary", () => {
     expect(summary.dropOff).toBeDefined();
     expect(summary.summary).toBeDefined();
     expect(getSurvey).toHaveBeenCalledWith(mockSurveyId);
-    expect(getResponseCountBySurveyId).toHaveBeenCalledWith(mockSurveyId, undefined);
     expect(prisma.response.findMany).toHaveBeenCalled(); // Check if getResponsesForSummary was effectively called
     expect(getDisplayCountBySurveyId).toHaveBeenCalled();
   });
@@ -770,7 +740,6 @@ describe("getSurveySummary", () => {
 
   test("handles filterCriteria", async () => {
     const filterCriteria: TResponseFilterCriteria = { finished: true };
-    vi.mocked(getResponseCountBySurveyId).mockResolvedValue(2); // Assume 2 finished responses
     const finishedResponses = mockResponses
       .filter((r) => r.finished)
       .map((r) => ({ ...r, contactId: null, personAttributes: {} }));
@@ -778,7 +747,6 @@ describe("getSurveySummary", () => {
 
     await getSurveySummary(mockSurveyId, filterCriteria);
 
-    expect(getResponseCountBySurveyId).toHaveBeenCalledWith(mockSurveyId, filterCriteria);
     expect(prisma.response.findMany).toHaveBeenCalledWith(
       expect.objectContaining({
         where: expect.objectContaining({ surveyId: mockSurveyId }), // buildWhereClause is mocked
@@ -798,9 +766,7 @@ describe("getResponsesForSummary", () => {
     vi.mocked(prisma.response.findMany).mockResolvedValue(
       mockResponses.map((r) => ({ ...r, contactId: null, personAttributes: {} })) as any
     );
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
+    // React cache is already mocked globally - no need to mock it again
   });
 
   test("fetches and transforms responses", async () => {
@@ -843,6 +809,16 @@ describe("getResponsesForSummary", () => {
       language: "en",
       ttc: {},
       finished: true,
+      createdAt: new Date(),
+      meta: {},
+      variables: {},
+      surveyId: "survey-1",
+      contactId: null,
+      personAttributes: {},
+      singleUseId: null,
+      isFinished: true,
+      displayId: "display-1",
+      endingId: null,
     };
 
     vi.mocked(getSurvey).mockResolvedValue(mockSurvey);
@@ -876,6 +852,16 @@ describe("getResponsesForSummary", () => {
       language: "en",
       ttc: {},
       finished: true,
+      createdAt: new Date(),
+      meta: {},
+      variables: {},
+      surveyId: "survey-1",
+      contactId: "contact-1",
+      personAttributes: {},
+      singleUseId: null,
+      isFinished: true,
+      displayId: "display-1",
+      endingId: null,
     };
 
     vi.mocked(getSurvey).mockResolvedValue(mockSurvey);
@@ -904,6 +890,16 @@ describe("getResponsesForSummary", () => {
       language: "en",
       ttc: {},
       finished: true,
+      createdAt: new Date(),
+      meta: {},
+      variables: {},
+      surveyId: "survey-1",
+      contactId: "contact-1",
+      personAttributes: {},
+      singleUseId: null,
+      isFinished: true,
+      displayId: "display-1",
+      endingId: null,
     };
 
     vi.mocked(getSurvey).mockResolvedValue(mockSurvey);

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/lib/surveySummary.ts

@@ -1,18 +1,14 @@
 import "server-only";
-import { cache } from "@/lib/cache";
 import { RESPONSES_PER_PAGE } from "@/lib/constants";
-import { displayCache } from "@/lib/display/cache";
 import { getDisplayCountBySurveyId } from "@/lib/display/service";
 import { getLocalizedValue } from "@/lib/i18n/utils";
-import { responseCache } from "@/lib/response/cache";
-import { getResponseCountBySurveyId } from "@/lib/response/service";
 import { buildWhereClause } from "@/lib/response/utils";
-import { surveyCache } from "@/lib/survey/cache";
 import { getSurvey } from "@/lib/survey/service";
 import { evaluateLogic, performActions } from "@/lib/surveyLogic/utils";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
 import { cache as reactCache } from "react";
+import { z } from "zod";
 import { prisma } from "@formbricks/database";
 import { ZId, ZOptionalNumber } from "@formbricks/types/common";
 import { DatabaseError, ResourceNotFoundError } from "@formbricks/types/errors";
@@ -905,66 +901,57 @@ export const getQuestionSummary = async (
 };
 
 export const getSurveySummary = reactCache(
-  async (surveyId: string, filterCriteria?: TResponseFilterCriteria): Promise<TSurveySummary> =>
-    cache(
-      async () => {
-        validateInputs([surveyId, ZId], [filterCriteria, ZResponseFilterCriteria.optional()]);
+  async (surveyId: string, filterCriteria?: TResponseFilterCriteria): Promise<TSurveySummary> => {
+    validateInputs([surveyId, ZId], [filterCriteria, ZResponseFilterCriteria.optional()]);
 
-        try {
-          const survey = await getSurvey(surveyId);
-          if (!survey) {
-            throw new ResourceNotFoundError("Survey", surveyId);
-          }
-
-          const batchSize = 5000;
-          const responseCount = await getResponseCountBySurveyId(surveyId, filterCriteria);
-
-          const hasFilter = Object.keys(filterCriteria ?? {}).length > 0;
-
-          const pages = Math.ceil(responseCount / batchSize);
-
-          // Create an array of batch fetch promises
-          const batchPromises = Array.from({ length: pages }, (_, i) =>
-            getResponsesForSummary(surveyId, batchSize, i * batchSize, filterCriteria)
-          );
-
-          // Fetch all batches in parallel
-          const batchResults = await Promise.all(batchPromises);
-
-          // Combine all batch results
-          const responses = batchResults.flat();
-
-          const responseIds = hasFilter ? responses.map((response) => response.id) : [];
-
-          const displayCount = await getDisplayCountBySurveyId(surveyId, {
-            createdAt: filterCriteria?.createdAt,
-            ...(hasFilter && { responseIds }),
-          });
-
-          const dropOff = getSurveySummaryDropOff(survey, responses, displayCount);
-          const [meta, questionWiseSummary] = await Promise.all([
-            getSurveySummaryMeta(responses, displayCount),
-            getQuestionSummary(survey, responses, dropOff),
-          ]);
-
-          return { meta, dropOff, summary: questionWiseSummary };
-        } catch (error) {
-          if (error instanceof Prisma.PrismaClientKnownRequestError) {
-            throw new DatabaseError(error.message);
-          }
-
-          throw error;
-        }
-      },
-      [`getSurveySummary-${surveyId}-${JSON.stringify(filterCriteria)}`],
-      {
-        tags: [
-          surveyCache.tag.byId(surveyId),
-          responseCache.tag.bySurveyId(surveyId),
-          displayCache.tag.bySurveyId(surveyId),
-        ],
+    try {
+      const survey = await getSurvey(surveyId);
+      if (!survey) {
+        throw new ResourceNotFoundError("Survey", surveyId);
       }
-    )()
+
+      const batchSize = 5000;
+      const hasFilter = Object.keys(filterCriteria ?? {}).length > 0;
+
+      // Use cursor-based pagination instead of count + offset to avoid expensive queries
+      const responses: TSurveySummaryResponse[] = [];
+      let cursor: string | undefined = undefined;
+      let hasMore = true;
+
+      while (hasMore) {
+        const batch = await getResponsesForSummary(surveyId, batchSize, 0, filterCriteria, cursor);
+        responses.push(...batch);
+
+        if (batch.length < batchSize) {
+          hasMore = false;
+        } else {
+          // Use the last response's ID as cursor for next batch
+          cursor = batch[batch.length - 1].id;
+        }
+      }
+
+      const responseIds = hasFilter ? responses.map((response) => response.id) : [];
+
+      const displayCount = await getDisplayCountBySurveyId(surveyId, {
+        createdAt: filterCriteria?.createdAt,
+        ...(hasFilter && { responseIds }),
+      });
+
+      const dropOff = getSurveySummaryDropOff(survey, responses, displayCount);
+      const [meta, questionWiseSummary] = await Promise.all([
+        getSurveySummaryMeta(responses, displayCount),
+        getQuestionSummary(survey, responses, dropOff),
+      ]);
+
+      return { meta, dropOff, summary: questionWiseSummary };
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError) {
+        throw new DatabaseError(error.message);
+      }
+
+      throw error;
+    }
+  }
 );
 
 export const getResponsesForSummary = reactCache(
@@ -972,80 +959,87 @@ export const getResponsesForSummary = reactCache(
     surveyId: string,
     limit: number,
     offset: number,
-    filterCriteria?: TResponseFilterCriteria
-  ): Promise<TSurveySummaryResponse[]> =>
-    cache(
-      async () => {
-        validateInputs(
-          [surveyId, ZId],
-          [limit, ZOptionalNumber],
-          [offset, ZOptionalNumber],
-          [filterCriteria, ZResponseFilterCriteria.optional()]
-        );
+    filterCriteria?: TResponseFilterCriteria,
+    cursor?: string
+  ): Promise<TSurveySummaryResponse[]> => {
+    validateInputs(
+      [surveyId, ZId],
+      [limit, ZOptionalNumber],
+      [offset, ZOptionalNumber],
+      [filterCriteria, ZResponseFilterCriteria.optional()],
+      [cursor, z.string().cuid2().optional()]
+    );
 
-        const queryLimit = limit ?? RESPONSES_PER_PAGE;
-        const survey = await getSurvey(surveyId);
-        if (!survey) return [];
-        try {
-          const responses = await prisma.response.findMany({
-            where: {
-              surveyId,
-              ...buildWhereClause(survey, filterCriteria),
-            },
+    const queryLimit = limit ?? RESPONSES_PER_PAGE;
+    const survey = await getSurvey(surveyId);
+    if (!survey) return [];
+    try {
+      const whereClause: Prisma.ResponseWhereInput = {
+        surveyId,
+        ...buildWhereClause(survey, filterCriteria),
+      };
+
+      // Add cursor condition for cursor-based pagination
+      if (cursor) {
+        whereClause.id = {
+          lt: cursor, // Get responses with ID less than cursor (for desc order)
+        };
+      }
+
+      const responses = await prisma.response.findMany({
+        where: whereClause,
+        select: {
+          id: true,
+          data: true,
+          updatedAt: true,
+          contact: {
             select: {
               id: true,
-              data: true,
-              updatedAt: true,
-              contact: {
-                select: {
-                  id: true,
-                  attributes: {
-                    select: { attributeKey: true, value: true },
-                  },
-                },
+              attributes: {
+                select: { attributeKey: true, value: true },
               },
-              contactAttributes: true,
-              language: true,
-              ttc: true,
-              finished: true,
             },
-            orderBy: [
-              {
-                createdAt: "desc",
-              },
-            ],
-            take: queryLimit,
-            skip: offset,
-          });
+          },
+          contactAttributes: true,
+          language: true,
+          ttc: true,
+          finished: true,
+        },
+        orderBy: [
+          {
+            createdAt: "desc",
+          },
+          {
+            id: "desc", // Secondary sort by ID for consistent pagination
+          },
+        ],
+        take: queryLimit,
+        skip: offset,
+      });
 
-          const transformedResponses: TSurveySummaryResponse[] = await Promise.all(
-            responses.map((responsePrisma) => {
-              return {
-                ...responsePrisma,
-                contact: responsePrisma.contact
-                  ? {
-                      id: responsePrisma.contact.id as string,
-                      userId: responsePrisma.contact.attributes.find(
-                        (attribute) => attribute.attributeKey.key === "userId"
-                      )?.value as string,
-                    }
-                  : null,
-              };
-            })
-          );
+      const transformedResponses: TSurveySummaryResponse[] = await Promise.all(
+        responses.map((responsePrisma) => {
+          return {
+            ...responsePrisma,
+            contact: responsePrisma.contact
+              ? {
+                  id: responsePrisma.contact.id as string,
+                  userId: responsePrisma.contact.attributes.find(
+                    (attribute) => attribute.attributeKey.key === "userId"
+                  )?.value as string,
+                }
+              : null,
+          };
+        })
+      );
 
-          return transformedResponses;
-        } catch (error) {
-          if (error instanceof Prisma.PrismaClientKnownRequestError) {
-            throw new DatabaseError(error.message);
-          }
-
-          throw error;
-        }
-      },
-      [`getResponsesForSummary-${surveyId}-${limit}-${offset}-${JSON.stringify(filterCriteria)}`],
-      {
-        tags: [responseCache.tag.bySurveyId(surveyId)],
+      return transformedResponses;
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError) {
+        throw new DatabaseError(error.message);
       }
-    )()
+
+      throw error;
+    }
+  }
 );

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/page.test.tsx

@@ -1,7 +1,9 @@
+import { ResponseFilterProvider } from "@/app/(app)/environments/[environmentId]/components/ResponseFilterContext";
 import { SurveyAnalysisNavigation } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/SurveyAnalysisNavigation";
 import { SummaryPage } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SummaryPage";
+import { getSurveySummary } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/lib/surveySummary";
 import SurveyPage from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/page";
-import { DEFAULT_LOCALE, DOCUMENTS_PER_PAGE, WEBAPP_URL } from "@/lib/constants";
+import { DEFAULT_LOCALE, WEBAPP_URL } from "@/lib/constants";
 import { getSurveyDomain } from "@/lib/getSurveyUrl";
 import { getResponseCountBySurveyId } from "@/lib/response/service";
 import { getSurvey } from "@/lib/survey/service";
@@ -38,7 +40,7 @@ vi.mock("@/lib/constants", () => ({
   SENTRY_DSN: "mock-sentry-dsn",
   WEBAPP_URL: "http://localhost:3000",
   RESPONSES_PER_PAGE: 10,
-  DOCUMENTS_PER_PAGE: 10,
+  SESSION_MAX_AGE: 1000,
 }));
 
 vi.mock(
@@ -78,6 +80,13 @@ vi.mock("@/lib/user/service", () => ({
   getUser: vi.fn(),
 }));
 
+vi.mock(
+  "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/lib/surveySummary",
+  () => ({
+    getSurveySummary: vi.fn(),
+  })
+);
+
 vi.mock("@/modules/environments/lib/utils", () => ({
   getEnvironmentAuth: vi.fn(),
 }));
@@ -100,6 +109,11 @@ vi.mock("@/tolgee/server", () => ({
 
 vi.mock("next/navigation", () => ({
   notFound: vi.fn(),
+  useParams: () => ({
+    environmentId: "test-environment-id",
+    surveyId: "test-survey-id",
+    sharingKey: null,
+  }),
 }));
 
 const mockEnvironmentId = "test-environment-id";
@@ -172,6 +186,21 @@ const mockSession = {
   expires: new Date(Date.now() + 3600 * 1000).toISOString(), // 1 hour from now
 } as any;
 
+const mockSurveySummary = {
+  meta: {
+    completedPercentage: 75,
+    completedResponses: 15,
+    displayCount: 20,
+    dropOffPercentage: 25,
+    dropOffCount: 5,
+    startsPercentage: 80,
+    totalResponses: 20,
+    ttcAverage: 120,
+  },
+  dropOff: [],
+  summary: [],
+};
+
 describe("SurveyPage", () => {
   beforeEach(() => {
     vi.mocked(getEnvironmentAuth).mockResolvedValue({
@@ -183,6 +212,7 @@ describe("SurveyPage", () => {
     vi.mocked(getUser).mockResolvedValue(mockUser);
     vi.mocked(getResponseCountBySurveyId).mockResolvedValue(10);
     vi.mocked(getSurveyDomain).mockReturnValue("test.domain.com");
+    vi.mocked(getSurveySummary).mockResolvedValue(mockSurveySummary);
     vi.mocked(notFound).mockClear();
   });
 
@@ -193,7 +223,8 @@ describe("SurveyPage", () => {
 
   test("renders correctly with valid data", async () => {
     const params = Promise.resolve({ environmentId: mockEnvironmentId, surveyId: mockSurveyId });
-    render(await SurveyPage({ params }));
+    const jsx = await SurveyPage({ params });
+    render(<ResponseFilterProvider>{jsx}</ResponseFilterProvider>);
 
     expect(screen.getByTestId("page-content-wrapper")).toBeInTheDocument();
     expect(screen.getByTestId("page-header")).toBeInTheDocument();
@@ -204,7 +235,6 @@ describe("SurveyPage", () => {
     expect(vi.mocked(getEnvironmentAuth)).toHaveBeenCalledWith(mockEnvironmentId);
     expect(vi.mocked(getSurvey)).toHaveBeenCalledWith(mockSurveyId);
     expect(vi.mocked(getUser)).toHaveBeenCalledWith(mockUserId);
-    expect(vi.mocked(getResponseCountBySurveyId)).toHaveBeenCalledWith(mockSurveyId);
     expect(vi.mocked(getSurveyDomain)).toHaveBeenCalled();
 
     expect(vi.mocked(SurveyAnalysisNavigation).mock.calls[0][0]).toEqual(
@@ -212,7 +242,6 @@ describe("SurveyPage", () => {
         environmentId: mockEnvironmentId,
         survey: mockSurvey,
         activeId: "summary",
-        initialTotalResponseCount: 10,
       })
     );
 
@@ -222,18 +251,17 @@ describe("SurveyPage", () => {
         survey: mockSurvey,
         surveyId: mockSurveyId,
         webAppUrl: WEBAPP_URL,
-        user: mockUser,
-        totalResponseCount: 10,
-        documentsPerPage: DOCUMENTS_PER_PAGE,
         isReadOnly: false,
         locale: mockUser.locale ?? DEFAULT_LOCALE,
+        initialSurveySummary: mockSurveySummary,
       })
     );
   });
 
   test("calls notFound if surveyId is not present in params", async () => {
     const params = Promise.resolve({ environmentId: mockEnvironmentId, surveyId: undefined }) as any;
-    render(await SurveyPage({ params }));
+    const jsx = await SurveyPage({ params });
+    render(<ResponseFilterProvider>{jsx}</ResponseFilterProvider>);
     expect(vi.mocked(notFound)).toHaveBeenCalled();
   });
 
@@ -243,7 +271,7 @@ describe("SurveyPage", () => {
     try {
       // We need to await the component itself because it's an async component
       const SurveyPageComponent = await SurveyPage({ params });
-      render(SurveyPageComponent);
+      render(<ResponseFilterProvider>{SurveyPageComponent}</ResponseFilterProvider>);
     } catch (e: any) {
       expect(e.message).toBe("common.survey_not_found");
     }
@@ -256,7 +284,7 @@ describe("SurveyPage", () => {
     const params = Promise.resolve({ environmentId: mockEnvironmentId, surveyId: mockSurveyId });
     try {
       const SurveyPageComponent = await SurveyPage({ params });
-      render(SurveyPageComponent);
+      render(<ResponseFilterProvider>{SurveyPageComponent}</ResponseFilterProvider>);
     } catch (e: any) {
       expect(e.message).toBe("common.user_not_found");
     }

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/page.tsx

@@ -1,9 +1,9 @@
 import { SurveyAnalysisNavigation } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/SurveyAnalysisNavigation";
 import { SummaryPage } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SummaryPage";
 import { SurveyAnalysisCTA } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SurveyAnalysisCTA";
-import { DEFAULT_LOCALE, DOCUMENTS_PER_PAGE, WEBAPP_URL } from "@/lib/constants";
+import { getSurveySummary } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/lib/surveySummary";
+import { DEFAULT_LOCALE, WEBAPP_URL } from "@/lib/constants";
 import { getSurveyDomain } from "@/lib/getSurveyUrl";
-import { getResponseCountBySurveyId } from "@/lib/response/service";
 import { getSurvey } from "@/lib/survey/service";
 import { getUser } from "@/lib/user/service";
 import { getEnvironmentAuth } from "@/modules/environments/lib/utils";
@@ -37,10 +37,8 @@ const SurveyPage = async (props: { params: Promise<{ environmentId: string; surv
     throw new Error(t("common.user_not_found"));
   }
 
-  const totalResponseCount = await getResponseCountBySurveyId(params.surveyId);
-
-  // I took this out cause it's cloud only right?
-  // const { active: isEnterpriseEdition } = await getEnterpriseLicense();
+  // Fetch initial survey summary data on the server to prevent duplicate API calls during hydration
+  const initialSurveySummary = await getSurveySummary(surveyId);
 
   const surveyDomain = getSurveyDomain();
 
@@ -55,26 +53,19 @@ const SurveyPage = async (props: { params: Promise<{ environmentId: string; surv
             isReadOnly={isReadOnly}
             user={user}
             surveyDomain={surveyDomain}
-            responseCount={totalResponseCount}
+            responseCount={initialSurveySummary?.meta.totalResponses ?? 0}
           />
         }>
-        <SurveyAnalysisNavigation
-          environmentId={environment.id}
-          survey={survey}
-          activeId="summary"
-          initialTotalResponseCount={totalResponseCount}
-        />
+        <SurveyAnalysisNavigation environmentId={environment.id} survey={survey} activeId="summary" />
       </PageHeader>
       <SummaryPage
         environment={environment}
         survey={survey}
         surveyId={params.surveyId}
         webAppUrl={WEBAPP_URL}
-        user={user}
-        totalResponseCount={totalResponseCount}
-        documentsPerPage={DOCUMENTS_PER_PAGE}
         isReadOnly={isReadOnly}
         locale={user.locale ?? DEFAULT_LOCALE}
+        initialSurveySummary={initialSurveySummary}
       />
 
       <SettingsId title={t("common.survey_id")} id={surveyId}></SettingsId>

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/components/SurveyStatusDropdown.tsx

@@ -11,6 +11,7 @@ import {
 import { SurveyStatusIndicator } from "@/modules/ui/components/survey-status-indicator";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/modules/ui/components/tooltip";
 import { useTranslate } from "@tolgee/react";
+import { useRouter } from "next/navigation";
 import toast from "react-hot-toast";
 import { TEnvironment } from "@formbricks/types/environment";
 import { TSurvey } from "@formbricks/types/surveys/types";
@@ -28,6 +29,7 @@ export const SurveyStatusDropdown = ({
   survey,
 }: SurveyStatusDropdownProps) => {
   const { t } = useTranslate();
+  const router = useRouter();
   const isCloseOnDateEnabled = survey.closeOnDate !== null;
   const closeOnDate = survey.closeOnDate ? new Date(survey.closeOnDate) : null;
   const isStatusChangeDisabled =
@@ -47,6 +49,8 @@ export const SurveyStatusDropdown = ({
               ? t("common.survey_completed")
               : ""
       );
+
+      router.refresh();
     } else {
       const errorMessage = getFormattedErrorMessage(updateSurveyActionResponse);
       toast.error(errorMessage);

apps/web/app/api/(internal)/pipeline/route.ts

@@ -1,8 +1,6 @@
 import { ZPipelineInput } from "@/app/api/(internal)/pipeline/types/pipelines";
 import { responses } from "@/app/lib/api/response";
 import { transformErrorToDetails } from "@/app/lib/api/validator";
-import { cache } from "@/lib/cache";
-import { webhookCache } from "@/lib/cache/webhook";
 import { CRON_SECRET } from "@/lib/constants";
 import { getIntegrations } from "@/lib/integration/service";
 import { getOrganizationByEnvironmentId } from "@/lib/organization/service";
@@ -51,22 +49,17 @@ export const POST = async (request: Request) => {
   }
 
   // Fetch webhooks
-  const getWebhooksForPipeline = cache(
-    async (environmentId: string, event: PipelineTriggers, surveyId: string) => {
-      const webhooks = await prisma.webhook.findMany({
-        where: {
-          environmentId,
-          triggers: { has: event },
-          OR: [{ surveyIds: { has: surveyId } }, { surveyIds: { isEmpty: true } }],
-        },
-      });
-      return webhooks;
-    },
-    [`getWebhooksForPipeline-${environmentId}-${event}-${surveyId}`],
-    {
-      tags: [webhookCache.tag.byEnvironmentId(environmentId)],
-    }
-  );
+  const getWebhooksForPipeline = async (environmentId: string, event: PipelineTriggers, surveyId: string) => {
+    const webhooks = await prisma.webhook.findMany({
+      where: {
+        environmentId,
+        triggers: { has: event },
+        OR: [{ surveyIds: { has: surveyId } }, { surveyIds: { isEmpty: true } }],
+      },
+    });
+    return webhooks;
+  };
+
   const webhooks: Webhook[] = await getWebhooksForPipeline(environmentId, event, surveyId);
   // Prepare webhook and email promises
 

apps/web/app/api/auth/saml/well-known/cert/route.ts

@@ -0,0 +1,3 @@
+import { GET } from "@/modules/ee/auth/saml/api/well-known/cert/route";
+
+export { GET };

apps/web/app/api/auth/saml/well-known/sp-metadata/route.ts

@@ -0,0 +1,3 @@
+import { GET } from "@/modules/ee/auth/saml/api/well-known/sp-metadata/route";
+
+export { GET };

apps/web/app/api/cron/survey-status/route.ts

@@ -1,6 +1,5 @@
 import { responses } from "@/app/lib/api/response";
 import { CRON_SECRET } from "@/lib/constants";
-import { surveyCache } from "@/lib/survey/cache";
 import { headers } from "next/headers";
 import { prisma } from "@formbricks/database";
 
@@ -66,15 +65,6 @@ export const POST = async () => {
     });
   }
 
-  const updatedSurveys = [...surveysToClose, ...scheduledSurveys];
-
-  for (const survey of updatedSurveys) {
-    surveyCache.revalidate({
-      id: survey.id,
-      environmentId: survey.environmentId,
-    });
-  }
-
   return responses.successResponse({
     message: `Updated ${surveysToClose.length} surveys to completed and ${scheduledSurveys.length} surveys to inProgress.`,
   });

apps/web/app/api/v1/client/[environmentId]/app/sync/[userId]/route.ts

@@ -6,7 +6,6 @@ import { replaceAttributeRecall } from "@/app/api/v1/client/[environmentId]/app/
 import { responses } from "@/app/lib/api/response";
 import { transformErrorToDetails } from "@/app/lib/api/validator";
 import { getActionClasses } from "@/lib/actionClass/service";
-import { contactCache } from "@/lib/cache/contact";
 import { IS_FORMBRICKS_CLOUD } from "@/lib/constants";
 import { getEnvironment, updateEnvironment } from "@/lib/environment/service";
 import {
@@ -133,14 +132,6 @@ export const GET = async (
           attributes: { select: { attributeKey: { select: { key: true } }, value: true } },
         },
       });
-
-      if (contact) {
-        contactCache.revalidate({
-          userId: contact.attributes.find((attr) => attr.attributeKey.key === "userId")?.value,
-          id: contact.id,
-          environmentId,
-        });
-      }
     }
 
     const contactAttributes = contact.attributes.reduce((acc, attribute) => {

apps/web/app/api/v1/client/[environmentId]/app/sync/lib/contact.test.ts

@@ -1,6 +1,5 @@
-import { cache } from "@/lib/cache";
 import { TContact } from "@/modules/ee/contacts/types/contact";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { afterEach, describe, expect, test, vi } from "vitest";
 import { prisma } from "@formbricks/database";
 import { getContactByUserId } from "./contact";
 
@@ -13,15 +12,6 @@ vi.mock("@formbricks/database", () => ({
   },
 }));
 
-// Mock cache\
-vi.mock("@/lib/cache", async () => {
-  const actual = await vi.importActual("@/lib/cache");
-  return {
-    ...(actual as any),
-    cache: vi.fn((fn) => fn()), // Mock cache function to just execute the passed function
-  };
-});
-
 const environmentId = "test-environment-id";
 const userId = "test-user-id";
 const contactId = "test-contact-id";
@@ -37,12 +27,6 @@ const contactMock: Partial<TContact> & {
 };
 
 describe("getContactByUserId", () => {
-  beforeEach(() => {
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-  });
-
   afterEach(() => {
     vi.resetAllMocks();
   });

apps/web/app/api/v1/client/[environmentId]/app/sync/lib/contact.ts

@@ -1,11 +1,9 @@
 import "server-only";
-import { cache } from "@/lib/cache";
-import { contactCache } from "@/lib/cache/contact";
 import { cache as reactCache } from "react";
 import { prisma } from "@formbricks/database";
 
 export const getContactByUserId = reactCache(
-  (
+  async (
     environmentId: string,
     userId: string
   ): Promise<{
@@ -16,36 +14,29 @@ export const getContactByUserId = reactCache(
       };
     }[];
     id: string;
-  } | null> =>
-    cache(
-      async () => {
-        const contact = await prisma.contact.findFirst({
-          where: {
-            attributes: {
-              some: {
-                attributeKey: {
-                  key: "userId",
-                  environmentId,
-                },
-                value: userId,
-              },
+  } | null> => {
+    const contact = await prisma.contact.findFirst({
+      where: {
+        attributes: {
+          some: {
+            attributeKey: {
+              key: "userId",
+              environmentId,
             },
+            value: userId,
           },
-          select: {
-            id: true,
-            attributes: { select: { attributeKey: { select: { key: true } }, value: true } },
-          },
-        });
-
-        if (!contact) {
-          return null;
-        }
-
-        return contact;
+        },
       },
-      [`getContactByUserId-sync-api-${environmentId}-${userId}`],
-      {
-        tags: [contactCache.tag.byEnvironmentIdAndUserId(environmentId, userId)],
-      }
-    )()
+      select: {
+        id: true,
+        attributes: { select: { attributeKey: { select: { key: true } }, value: true } },
+      },
+    });
+
+    if (!contact) {
+      return null;
+    }
+
+    return contact;
+  }
 );

apps/web/app/api/v1/client/[environmentId]/app/sync/lib/survey.test.ts

@@ -1,4 +1,3 @@
-import { cache } from "@/lib/cache";
 import { getProjectByEnvironmentId } from "@/lib/project/service";
 import { getSurveys } from "@/lib/survey/service";
 import { anySurveyHasFilters } from "@/lib/survey/utils";
@@ -14,15 +13,6 @@ import { TSegment } from "@formbricks/types/segment";
 import { TSurvey } from "@formbricks/types/surveys/types";
 import { getSyncSurveys } from "./survey";
 
-// Mock dependencies
-vi.mock("@/lib/cache", async () => {
-  const actual = await vi.importActual("@/lib/cache");
-  return {
-    ...(actual as any),
-    cache: vi.fn((fn) => fn()), // Mock cache function to just execute the passed function
-  };
-});
-
 vi.mock("@/lib/project/service", () => ({
   getProjectByEnvironmentId: vi.fn(),
 }));
@@ -120,9 +110,6 @@ const baseSurvey: TSurvey = {
 
 describe("getSyncSurveys", () => {
   beforeEach(() => {
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
     vi.mocked(getProjectByEnvironmentId).mockResolvedValue(mockProject);
     vi.mocked(prisma.display.findMany).mockResolvedValue([]);
     vi.mocked(prisma.response.findMany).mockResolvedValue([]);

apps/web/app/api/v1/client/[environmentId]/app/sync/lib/survey.ts

@@ -1,11 +1,5 @@
 import "server-only";
-import { cache } from "@/lib/cache";
-import { contactCache } from "@/lib/cache/contact";
-import { contactAttributeCache } from "@/lib/cache/contact-attribute";
-import { displayCache } from "@/lib/display/cache";
-import { projectCache } from "@/lib/project/cache";
 import { getProjectByEnvironmentId } from "@/lib/project/service";
-import { surveyCache } from "@/lib/survey/cache";
 import { getSurveys } from "@/lib/survey/service";
 import { anySurveyHasFilters } from "@/lib/survey/utils";
 import { diffInDays } from "@/lib/utils/datetime";
@@ -20,154 +14,135 @@ import { DatabaseError, ResourceNotFoundError } from "@formbricks/types/errors";
 import { TSurvey } from "@formbricks/types/surveys/types";
 
 export const getSyncSurveys = reactCache(
-  (
+  async (
     environmentId: string,
     contactId: string,
     contactAttributes: Record<string, string | number>,
     deviceType: "phone" | "desktop" = "desktop"
-  ): Promise<TSurvey[]> =>
-    cache(
-      async () => {
-        validateInputs([environmentId, ZId]);
-        try {
-          const product = await getProjectByEnvironmentId(environmentId);
+  ): Promise<TSurvey[]> => {
+    validateInputs([environmentId, ZId]);
+    try {
+      const product = await getProjectByEnvironmentId(environmentId);
 
-          if (!product) {
-            throw new Error("Product not found");
-          }
-
-          let surveys = await getSurveys(environmentId);
-
-          // filtered surveys for running and web
-          surveys = surveys.filter((survey) => survey.status === "inProgress" && survey.type === "app");
-
-          // if no surveys are left, return an empty array
-          if (surveys.length === 0) {
-            return [];
-          }
-
-          const displays = await prisma.display.findMany({
-            where: {
-              contactId,
-            },
-          });
-
-          const responses = await prisma.response.findMany({
-            where: {
-              contactId,
-            },
-          });
-
-          // filter surveys that meet the displayOption criteria
-          surveys = surveys.filter((survey) => {
-            switch (survey.displayOption) {
-              case "respondMultiple":
-                return true;
-              case "displayOnce":
-                return displays.filter((display) => display.surveyId === survey.id).length === 0;
-              case "displayMultiple":
-                if (!responses) return true;
-                else {
-                  return responses.filter((response) => response.surveyId === survey.id).length === 0;
-                }
-              case "displaySome":
-                if (survey.displayLimit === null) {
-                  return true;
-                }
-
-                if (
-                  responses &&
-                  responses.filter((response) => response.surveyId === survey.id).length !== 0
-                ) {
-                  return false;
-                }
-
-                return (
-                  displays.filter((display) => display.surveyId === survey.id).length < survey.displayLimit
-                );
-              default:
-                throw Error("Invalid displayOption");
-            }
-          });
-
-          const latestDisplay = displays[0];
-
-          // filter surveys that meet the recontactDays criteria
-          surveys = surveys.filter((survey) => {
-            if (!latestDisplay) {
-              return true;
-            } else if (survey.recontactDays !== null) {
-              const lastDisplaySurvey = displays.filter((display) => display.surveyId === survey.id)[0];
-              if (!lastDisplaySurvey) {
-                return true;
-              }
-              return diffInDays(new Date(), new Date(lastDisplaySurvey.createdAt)) >= survey.recontactDays;
-            } else if (product.recontactDays !== null) {
-              return diffInDays(new Date(), new Date(latestDisplay.createdAt)) >= product.recontactDays;
-            } else {
-              return true;
-            }
-          });
-
-          // if no surveys are left, return an empty array
-          if (surveys.length === 0) {
-            return [];
-          }
-
-          // if no surveys have segment filters, return the surveys
-          if (!anySurveyHasFilters(surveys)) {
-            return surveys;
-          }
-
-          // the surveys now have segment filters, so we need to evaluate them
-          const surveyPromises = surveys.map(async (survey) => {
-            const { segment } = survey;
-            // if the survey has no segment, or the segment has no filters, we return the survey
-            if (!segment || !segment.filters?.length) {
-              return survey;
-            }
-
-            // Evaluate the segment filters
-            const result = await evaluateSegment(
-              {
-                attributes: contactAttributes ?? {},
-                deviceType,
-                environmentId,
-                contactId,
-                userId: String(contactAttributes.userId),
-              },
-              segment.filters
-            );
-
-            return result ? survey : null;
-          });
-
-          const resolvedSurveys = await Promise.all(surveyPromises);
-          surveys = resolvedSurveys.filter((survey) => !!survey) as TSurvey[];
-
-          if (!surveys) {
-            throw new ResourceNotFoundError("Survey", environmentId);
-          }
-          return surveys;
-        } catch (error) {
-          if (error instanceof Prisma.PrismaClientKnownRequestError) {
-            logger.error(error);
-            throw new DatabaseError(error.message);
-          }
-
-          throw error;
-        }
-      },
-      [`getSyncSurveys-${environmentId}-${contactId}`],
-      {
-        tags: [
-          contactCache.tag.byEnvironmentId(environmentId),
-          contactCache.tag.byId(contactId),
-          displayCache.tag.byContactId(contactId),
-          surveyCache.tag.byEnvironmentId(environmentId),
-          projectCache.tag.byEnvironmentId(environmentId),
-          contactAttributeCache.tag.byContactId(contactId),
-        ],
+      if (!product) {
+        throw new Error("Product not found");
       }
-    )()
+
+      let surveys = await getSurveys(environmentId);
+
+      // filtered surveys for running and web
+      surveys = surveys.filter((survey) => survey.status === "inProgress" && survey.type === "app");
+
+      // if no surveys are left, return an empty array
+      if (surveys.length === 0) {
+        return [];
+      }
+
+      const displays = await prisma.display.findMany({
+        where: {
+          contactId,
+        },
+      });
+
+      const responses = await prisma.response.findMany({
+        where: {
+          contactId,
+        },
+      });
+
+      // filter surveys that meet the displayOption criteria
+      surveys = surveys.filter((survey) => {
+        switch (survey.displayOption) {
+          case "respondMultiple":
+            return true;
+          case "displayOnce":
+            return displays.filter((display) => display.surveyId === survey.id).length === 0;
+          case "displayMultiple":
+            if (!responses) return true;
+            else {
+              return responses.filter((response) => response.surveyId === survey.id).length === 0;
+            }
+          case "displaySome":
+            if (survey.displayLimit === null) {
+              return true;
+            }
+
+            if (responses && responses.filter((response) => response.surveyId === survey.id).length !== 0) {
+              return false;
+            }
+
+            return displays.filter((display) => display.surveyId === survey.id).length < survey.displayLimit;
+          default:
+            throw Error("Invalid displayOption");
+        }
+      });
+
+      const latestDisplay = displays[0];
+
+      // filter surveys that meet the recontactDays criteria
+      surveys = surveys.filter((survey) => {
+        if (!latestDisplay) {
+          return true;
+        } else if (survey.recontactDays !== null) {
+          const lastDisplaySurvey = displays.filter((display) => display.surveyId === survey.id)[0];
+          if (!lastDisplaySurvey) {
+            return true;
+          }
+          return diffInDays(new Date(), new Date(lastDisplaySurvey.createdAt)) >= survey.recontactDays;
+        } else if (product.recontactDays !== null) {
+          return diffInDays(new Date(), new Date(latestDisplay.createdAt)) >= product.recontactDays;
+        } else {
+          return true;
+        }
+      });
+
+      // if no surveys are left, return an empty array
+      if (surveys.length === 0) {
+        return [];
+      }
+
+      // if no surveys have segment filters, return the surveys
+      if (!anySurveyHasFilters(surveys)) {
+        return surveys;
+      }
+
+      // the surveys now have segment filters, so we need to evaluate them
+      const surveyPromises = surveys.map(async (survey) => {
+        const { segment } = survey;
+        // if the survey has no segment, or the segment has no filters, we return the survey
+        if (!segment || !segment.filters?.length) {
+          return survey;
+        }
+
+        // Evaluate the segment filters
+        const result = await evaluateSegment(
+          {
+            attributes: contactAttributes ?? {},
+            deviceType,
+            environmentId,
+            contactId,
+            userId: String(contactAttributes.userId),
+          },
+          segment.filters
+        );
+
+        return result ? survey : null;
+      });
+
+      const resolvedSurveys = await Promise.all(surveyPromises);
+      surveys = resolvedSurveys.filter((survey) => !!survey) as TSurvey[];
+
+      if (!surveys) {
+        throw new ResourceNotFoundError("Survey", environmentId);
+      }
+      return surveys;
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError) {
+        logger.error(error);
+        throw new DatabaseError(error.message);
+      }
+
+      throw error;
+    }
+  }
 );

apps/web/app/api/v1/client/[environmentId]/displays/lib/contact.ts

@@ -1,41 +1,32 @@
-import { cache } from "@/lib/cache";
-import { contactCache } from "@/lib/cache/contact";
 import { cache as reactCache } from "react";
 import { prisma } from "@formbricks/database";
 
 export const getContactByUserId = reactCache(
-  (
+  async (
     environmentId: string,
     userId: string
   ): Promise<{
     id: string;
-  } | null> =>
-    cache(
-      async () => {
-        const contact = await prisma.contact.findFirst({
-          where: {
-            attributes: {
-              some: {
-                attributeKey: {
-                  key: "userId",
-                  environmentId,
-                },
-                value: userId,
-              },
+  } | null> => {
+    const contact = await prisma.contact.findFirst({
+      where: {
+        attributes: {
+          some: {
+            attributeKey: {
+              key: "userId",
+              environmentId,
             },
+            value: userId,
           },
-          select: { id: true },
-        });
-
-        if (!contact) {
-          return null;
-        }
-
-        return contact;
+        },
       },
-      [`getContactByUserIdForDisplaysApi-${environmentId}-${userId}`],
-      {
-        tags: [contactCache.tag.byEnvironmentIdAndUserId(environmentId, userId)],
-      }
-    )()
+      select: { id: true },
+    });
+
+    if (!contact) {
+      return null;
+    }
+
+    return contact;
+  }
 );

apps/web/app/api/v1/client/[environmentId]/displays/lib/display.ts

@@ -1,4 +1,3 @@
-import { displayCache } from "@/lib/display/cache";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
 import { prisma } from "@formbricks/database";
@@ -51,14 +50,6 @@ export const createDisplay = async (displayInput: TDisplayCreateInput): Promise<
       select: { id: true, contactId: true, surveyId: true },
     });
 
-    displayCache.revalidate({
-      id: display.id,
-      contactId: display.contactId,
-      surveyId: display.surveyId,
-      userId,
-      environmentId,
-    });
-
     return display;
   } catch (error) {
     if (error instanceof Prisma.PrismaClientKnownRequestError) {

apps/web/app/api/v1/client/[environmentId]/displays/route.ts

@@ -14,7 +14,13 @@ interface Context {
 }
 
 export const OPTIONS = async (): Promise<Response> => {
-  return responses.successResponse({}, true);
+  return responses.successResponse(
+    {},
+    true,
+    // Cache CORS preflight responses for 1 hour (conservative approach)
+    // Balances performance gains with flexibility for CORS policy changes
+    "public, s-maxage=3600, max-age=3600"
+  );
 };
 
 export const POST = async (request: Request, context: Context): Promise<Response> => {

apps/web/app/api/v1/client/[environmentId]/environment/lib/actionClass.test.ts

@@ -1,86 +0,0 @@
-import { cache } from "@/lib/cache";
-import { validateInputs } from "@/lib/utils/validate";
-import { describe, expect, test, vi } from "vitest";
-import { prisma } from "@formbricks/database";
-import { TActionClassNoCodeConfig } from "@formbricks/types/action-classes";
-import { DatabaseError } from "@formbricks/types/errors";
-import { TJsEnvironmentStateActionClass } from "@formbricks/types/js";
-import { getActionClassesForEnvironmentState } from "./actionClass";
-
-// Mock dependencies
-vi.mock("@/lib/cache");
-vi.mock("@/lib/utils/validate");
-vi.mock("@formbricks/database", () => ({
-  prisma: {
-    actionClass: {
-      findMany: vi.fn(),
-    },
-  },
-}));
-
-const environmentId = "test-environment-id";
-const mockActionClasses: TJsEnvironmentStateActionClass[] = [
-  {
-    id: "action1",
-    type: "code",
-    name: "Code Action",
-    key: "code-action",
-    noCodeConfig: null,
-  },
-  {
-    id: "action2",
-    type: "noCode",
-    name: "No Code Action",
-    key: null,
-    noCodeConfig: { type: "click" } as TActionClassNoCodeConfig,
-  },
-];
-
-describe("getActionClassesForEnvironmentState", () => {
-  test("should return action classes successfully", async () => {
-    vi.mocked(prisma.actionClass.findMany).mockResolvedValue(mockActionClasses);
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-
-    const result = await getActionClassesForEnvironmentState(environmentId);
-
-    expect(result).toEqual(mockActionClasses);
-    expect(validateInputs).toHaveBeenCalledWith([environmentId, expect.any(Object)]); // ZId is an object
-    expect(prisma.actionClass.findMany).toHaveBeenCalledWith({
-      where: { environmentId },
-      select: {
-        id: true,
-        type: true,
-        name: true,
-        key: true,
-        noCodeConfig: true,
-      },
-    });
-    expect(cache).toHaveBeenCalledWith(
-      expect.any(Function),
-      [`getActionClassesForEnvironmentState-${environmentId}`],
-      { tags: [`environments-${environmentId}-actionClasses`] }
-    );
-  });
-
-  test("should throw DatabaseError on prisma error", async () => {
-    const mockError = new Error("Prisma error");
-    vi.mocked(prisma.actionClass.findMany).mockRejectedValue(mockError);
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-
-    await expect(getActionClassesForEnvironmentState(environmentId)).rejects.toThrow(DatabaseError);
-    await expect(getActionClassesForEnvironmentState(environmentId)).rejects.toThrow(
-      `Database error when fetching actions for environment ${environmentId}`
-    );
-    expect(validateInputs).toHaveBeenCalledWith([environmentId, expect.any(Object)]);
-    expect(prisma.actionClass.findMany).toHaveBeenCalled();
-    expect(cache).toHaveBeenCalledWith(
-      expect.any(Function),
-      [`getActionClassesForEnvironmentState-${environmentId}`],
-      { tags: [`environments-${environmentId}-actionClasses`] }
-    );
-  });
-});

apps/web/app/api/v1/client/[environmentId]/environment/lib/actionClass.ts

@@ -1,38 +0,0 @@
-import { actionClassCache } from "@/lib/actionClass/cache";
-import { cache } from "@/lib/cache";
-import { validateInputs } from "@/lib/utils/validate";
-import { cache as reactCache } from "react";
-import { prisma } from "@formbricks/database";
-import { ZId } from "@formbricks/types/common";
-import { DatabaseError } from "@formbricks/types/errors";
-import { TJsEnvironmentStateActionClass } from "@formbricks/types/js";
-
-export const getActionClassesForEnvironmentState = reactCache(
-  async (environmentId: string): Promise<TJsEnvironmentStateActionClass[]> =>
-    cache(
-      async () => {
-        validateInputs([environmentId, ZId]);
-
-        try {
-          return await prisma.actionClass.findMany({
-            where: {
-              environmentId: environmentId,
-            },
-            select: {
-              id: true,
-              type: true,
-              name: true,
-              key: true,
-              noCodeConfig: true,
-            },
-          });
-        } catch (error) {
-          throw new DatabaseError(`Database error when fetching actions for environment ${environmentId}`);
-        }
-      },
-      [`getActionClassesForEnvironmentState-${environmentId}`],
-      {
-        tags: [actionClassCache.tag.byEnvironmentId(environmentId)],
-      }
-    )()
-);

apps/web/app/api/v1/client/[environmentId]/environment/lib/data.ts

@@ -0,0 +1,202 @@
+import "server-only";
+import { validateInputs } from "@/lib/utils/validate";
+import { transformPrismaSurvey } from "@/modules/survey/lib/utils";
+import { Prisma } from "@prisma/client";
+import { prisma } from "@formbricks/database";
+import { logger } from "@formbricks/logger";
+import { ZId } from "@formbricks/types/common";
+import { DatabaseError, ResourceNotFoundError } from "@formbricks/types/errors";
+import {
+  TJsEnvironmentStateActionClass,
+  TJsEnvironmentStateProject,
+  TJsEnvironmentStateSurvey,
+} from "@formbricks/types/js";
+
+/**
+ * Optimized data fetcher for environment state
+ * Uses a single Prisma query with strategic includes to minimize database calls
+ * Critical for performance on high-frequency endpoint serving hundreds of thousands of SDK clients
+ */
+export interface EnvironmentStateData {
+  environment: {
+    id: string;
+    type: string;
+    appSetupCompleted: boolean;
+    project: TJsEnvironmentStateProject;
+  };
+  organization: {
+    id: string;
+    billing: any;
+  };
+  surveys: TJsEnvironmentStateSurvey[];
+  actionClasses: TJsEnvironmentStateActionClass[];
+}
+
+/**
+ * Single optimized query that fetches all required data
+ * Replaces multiple separate service calls with one efficient database operation
+ */
+export const getEnvironmentStateData = async (environmentId: string): Promise<EnvironmentStateData> => {
+  validateInputs([environmentId, ZId]);
+
+  try {
+    // Single query that fetches everything needed for environment state
+    // Uses strategic includes and selects to minimize data transfer
+    const environmentData = await prisma.environment.findUnique({
+      where: { id: environmentId },
+      select: {
+        id: true,
+        type: true,
+        appSetupCompleted: true,
+        // Project data (optimized select)
+        project: {
+          select: {
+            id: true,
+            recontactDays: true,
+            clickOutsideClose: true,
+            darkOverlay: true,
+            placement: true,
+            inAppSurveyBranding: true,
+            styling: true,
+            // Organization data (nested select for efficiency)
+            organization: {
+              select: {
+                id: true,
+                billing: true,
+              },
+            },
+          },
+        },
+        // Action classes (optimized for environment state)
+        actionClasses: {
+          select: {
+            id: true,
+            type: true,
+            name: true,
+            key: true,
+            noCodeConfig: true,
+          },
+        },
+        // Surveys (optimized for app surveys only)
+        surveys: {
+          where: {
+            type: "app",
+            status: "inProgress",
+          },
+          orderBy: {
+            createdAt: "desc",
+          },
+          take: 30, // Limit for performance
+          select: {
+            id: true,
+            welcomeCard: true,
+            name: true,
+            questions: true,
+            variables: true,
+            type: true,
+            showLanguageSwitch: true,
+            languages: {
+              select: {
+                default: true,
+                enabled: true,
+                language: {
+                  select: {
+                    id: true,
+                    code: true,
+                    alias: true,
+                    createdAt: true,
+                    updatedAt: true,
+                    projectId: true,
+                  },
+                },
+              },
+            },
+            endings: true,
+            autoClose: true,
+            styling: true,
+            status: true,
+            recaptcha: true,
+            segment: {
+              include: {
+                surveys: {
+                  select: {
+                    id: true,
+                  },
+                },
+              },
+            },
+            recontactDays: true,
+            displayLimit: true,
+            displayOption: true,
+            hiddenFields: true,
+            isBackButtonHidden: true,
+            triggers: {
+              select: {
+                actionClass: {
+                  select: {
+                    name: true,
+                  },
+                },
+              },
+            },
+            displayPercentage: true,
+            delay: true,
+            projectOverwrites: true,
+          },
+        },
+      },
+    });
+
+    if (!environmentData) {
+      throw new ResourceNotFoundError("environment", environmentId);
+    }
+
+    if (!environmentData.project) {
+      throw new ResourceNotFoundError("project", null);
+    }
+
+    if (!environmentData.project.organization) {
+      throw new ResourceNotFoundError("organization", null);
+    }
+
+    // Transform surveys using existing utility
+    const transformedSurveys = environmentData.surveys.map((survey) =>
+      transformPrismaSurvey<TJsEnvironmentStateSurvey>(survey)
+    );
+
+    return {
+      environment: {
+        id: environmentData.id,
+        type: environmentData.type,
+        appSetupCompleted: environmentData.appSetupCompleted,
+        project: {
+          id: environmentData.project.id,
+          recontactDays: environmentData.project.recontactDays,
+          clickOutsideClose: environmentData.project.clickOutsideClose,
+          darkOverlay: environmentData.project.darkOverlay,
+          placement: environmentData.project.placement,
+          inAppSurveyBranding: environmentData.project.inAppSurveyBranding,
+          styling: environmentData.project.styling,
+        },
+      },
+      organization: {
+        id: environmentData.project.organization.id,
+        billing: environmentData.project.organization.billing,
+      },
+      surveys: transformedSurveys,
+      actionClasses: environmentData.actionClasses as TJsEnvironmentStateActionClass[],
+    };
+  } catch (error) {
+    if (error instanceof ResourceNotFoundError) {
+      throw error;
+    }
+
+    if (error instanceof Prisma.PrismaClientKnownRequestError) {
+      logger.error(error, "Database error in getEnvironmentStateData");
+      throw new DatabaseError(`Database error when fetching environment state for ${environmentId}`);
+    }
+
+    logger.error(error, "Unexpected error in getEnvironmentStateData");
+    throw error;
+  }
+};

apps/web/app/api/v1/client/[environmentId]/environment/lib/environmentState.test.ts

@@ -1,34 +1,25 @@
-import { cache } from "@/lib/cache";
-import { getEnvironment } from "@/lib/environment/service";
-import {
-  getMonthlyOrganizationResponseCount,
-  getOrganizationByEnvironmentId,
-} from "@/lib/organization/service";
+import { getMonthlyOrganizationResponseCount } from "@/lib/organization/service";
 import {
   capturePosthogEnvironmentEvent,
   sendPlanLimitsReachedEventToPosthogWeekly,
 } from "@/lib/posthogServer";
+import { withCache } from "@/modules/cache/lib/withCache";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { prisma } from "@formbricks/database";
 import { logger } from "@formbricks/logger";
 import { TActionClass } from "@formbricks/types/action-classes";
-import { TEnvironment } from "@formbricks/types/environment";
 import { ResourceNotFoundError } from "@formbricks/types/errors";
-import { TJsEnvironmentState } from "@formbricks/types/js";
+import { TJsEnvironmentState, TJsEnvironmentStateProject } from "@formbricks/types/js";
 import { TOrganization } from "@formbricks/types/organizations";
-import { TProject } from "@formbricks/types/project";
 import { TSurvey } from "@formbricks/types/surveys/types";
-import { getActionClassesForEnvironmentState } from "./actionClass";
+import { EnvironmentStateData, getEnvironmentStateData } from "./data";
 import { getEnvironmentState } from "./environmentState";
-import { getProjectForEnvironmentState } from "./project";
-import { getSurveysForEnvironmentState } from "./survey";
 
 // Mock dependencies
-vi.mock("@/lib/cache");
-vi.mock("@/lib/environment/service");
 vi.mock("@/lib/organization/service");
 vi.mock("@/lib/posthogServer");
-vi.mock("@/modules/ee/license-check/lib/utils");
+vi.mock("@/modules/cache/lib/withCache");
+
 vi.mock("@formbricks/database", () => ({
   prisma: {
     environment: {
@@ -41,11 +32,9 @@ vi.mock("@formbricks/logger", () => ({
     error: vi.fn(),
   },
 }));
-vi.mock("./actionClass");
-vi.mock("./project");
-vi.mock("./survey");
+vi.mock("./data");
 vi.mock("@/lib/constants", () => ({
-  IS_FORMBRICKS_CLOUD: true, // Default to false, override in specific tests
+  IS_FORMBRICKS_CLOUD: true,
   RECAPTCHA_SITE_KEY: "mock_recaptcha_site_key",
   RECAPTCHA_SECRET_KEY: "mock_recaptcha_secret_key",
   IS_RECAPTCHA_CONFIGURED: true,
@@ -56,13 +45,16 @@ vi.mock("@/lib/constants", () => ({
 
 const environmentId = "test-environment-id";
 
-const mockEnvironment: TEnvironment = {
-  id: environmentId,
-  createdAt: new Date(),
-  updatedAt: new Date(),
-  projectId: "test-project-id",
-  type: "production",
-  appSetupCompleted: true, // Default to true
+const mockProject: TJsEnvironmentStateProject = {
+  id: "test-project-id",
+  recontactDays: 30,
+  inAppSurveyBranding: true,
+  placement: "bottomRight",
+  clickOutsideClose: true,
+  darkOverlay: false,
+  styling: {
+    allowStyleOverwrite: false,
+  },
 };
 
 const mockOrganization: TOrganization = {
@@ -77,7 +69,7 @@ const mockOrganization: TOrganization = {
     limits: {
       projects: 1,
       monthly: {
-        responses: 100, // Default limit
+        responses: 100,
         miu: 1000,
       },
     },
@@ -86,29 +78,6 @@ const mockOrganization: TOrganization = {
   isAIEnabled: false,
 };
 
-const mockProject: TProject = {
-  id: "test-project-id",
-  createdAt: new Date(),
-  updatedAt: new Date(),
-  name: "Test Project",
-  config: {
-    channel: "link",
-    industry: "eCommerce",
-  },
-  organizationId: mockOrganization.id,
-  styling: {
-    allowStyleOverwrite: false,
-  },
-  recontactDays: 30,
-  inAppSurveyBranding: true,
-  linkSurveyBranding: true,
-  placement: "bottomRight",
-  clickOutsideClose: true,
-  darkOverlay: false,
-  environments: [],
-  languages: [],
-};
-
 const mockSurveys: TSurvey[] = [
   {
     id: "survey-app-inProgress",
@@ -149,84 +118,6 @@ const mockSurveys: TSurvey[] = [
     createdBy: null,
     recaptcha: { enabled: false, threshold: 0.5 },
   },
-  {
-    id: "survey-app-paused",
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    name: "App Survey Paused",
-    environmentId: environmentId,
-    displayLimit: null,
-    endings: [],
-    followUps: [],
-    isBackButtonHidden: false,
-    isSingleResponsePerEmailEnabled: false,
-    isVerifyEmailEnabled: false,
-    projectOverwrites: null,
-    runOnDate: null,
-    showLanguageSwitch: false,
-    type: "app",
-    status: "paused",
-    questions: [],
-    displayOption: "displayOnce",
-    recontactDays: null,
-    autoClose: null,
-    closeOnDate: null,
-    delay: 0,
-    displayPercentage: null,
-    autoComplete: null,
-    singleUse: null,
-    triggers: [],
-    languages: [],
-    pin: null,
-    resultShareKey: null,
-    segment: null,
-    styling: null,
-    surveyClosedMessage: null,
-    hiddenFields: { enabled: false },
-    welcomeCard: { enabled: false, showResponseCount: false, timeToFinish: false },
-    variables: [],
-    createdBy: null,
-    recaptcha: { enabled: false, threshold: 0.5 },
-  },
-  {
-    id: "survey-web-inProgress",
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    name: "Web Survey In Progress",
-    environmentId: environmentId,
-    type: "link",
-    displayLimit: null,
-    endings: [],
-    followUps: [],
-    isBackButtonHidden: false,
-    isSingleResponsePerEmailEnabled: false,
-    isVerifyEmailEnabled: false,
-    projectOverwrites: null,
-    runOnDate: null,
-    showLanguageSwitch: false,
-    status: "inProgress",
-    questions: [],
-    displayOption: "displayOnce",
-    recontactDays: null,
-    autoClose: null,
-    closeOnDate: null,
-    delay: 0,
-    displayPercentage: null,
-    autoComplete: null,
-    singleUse: null,
-    triggers: [],
-    languages: [],
-    pin: null,
-    resultShareKey: null,
-    segment: null,
-    styling: null,
-    surveyClosedMessage: null,
-    hiddenFields: { enabled: false },
-    welcomeCard: { enabled: false, showResponseCount: false, timeToFinish: false },
-    variables: [],
-    createdBy: null,
-    recaptcha: { enabled: false, threshold: 0.5 },
-  },
 ];
 
 const mockActionClasses: TActionClass[] = [
@@ -243,19 +134,30 @@ const mockActionClasses: TActionClass[] = [
   },
 ];
 
+const mockEnvironmentStateData: EnvironmentStateData = {
+  environment: {
+    id: environmentId,
+    type: "production",
+    appSetupCompleted: true,
+    project: mockProject,
+  },
+  organization: {
+    id: mockOrganization.id,
+    billing: mockOrganization.billing,
+  },
+  surveys: mockSurveys,
+  actionClasses: mockActionClasses,
+};
+
 describe("getEnvironmentState", () => {
   beforeEach(() => {
     vi.resetAllMocks();
-    // Mock the cache implementation
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
+
+    // Mock withCache to simply execute the function without caching for tests
+    vi.mocked(withCache).mockImplementation((fn) => fn);
+
     // Default mocks for successful retrieval
-    vi.mocked(getEnvironment).mockResolvedValue(mockEnvironment);
-    vi.mocked(getOrganizationByEnvironmentId).mockResolvedValue(mockOrganization);
-    vi.mocked(getProjectForEnvironmentState).mockResolvedValue(mockProject);
-    vi.mocked(getSurveysForEnvironmentState).mockResolvedValue([mockSurveys[0]]); // Only return the app, inProgress survey
-    vi.mocked(getActionClassesForEnvironmentState).mockResolvedValue(mockActionClasses);
+    vi.mocked(getEnvironmentStateData).mockResolvedValue(mockEnvironmentStateData);
     vi.mocked(getMonthlyOrganizationResponseCount).mockResolvedValue(50); // Default below limit
   });
 
@@ -268,42 +170,45 @@ describe("getEnvironmentState", () => {
 
     const expectedData: TJsEnvironmentState["data"] = {
       recaptchaSiteKey: "mock_recaptcha_site_key",
-      surveys: [mockSurveys[0]], // Only app, inProgress survey
+      surveys: mockSurveys,
       actionClasses: mockActionClasses,
       project: mockProject,
     };
 
     expect(result.data).toEqual(expectedData);
-    expect(result.revalidateEnvironment).toBe(false);
-    expect(getEnvironment).toHaveBeenCalledWith(environmentId);
-    expect(getOrganizationByEnvironmentId).toHaveBeenCalledWith(environmentId);
-    expect(getProjectForEnvironmentState).toHaveBeenCalledWith(environmentId);
-    expect(getSurveysForEnvironmentState).toHaveBeenCalledWith(environmentId);
-    expect(getActionClassesForEnvironmentState).toHaveBeenCalledWith(environmentId);
+    expect(getEnvironmentStateData).toHaveBeenCalledWith(environmentId);
     expect(prisma.environment.update).not.toHaveBeenCalled();
     expect(capturePosthogEnvironmentEvent).not.toHaveBeenCalled();
-    expect(getMonthlyOrganizationResponseCount).toHaveBeenCalled(); // Not cloud
+    expect(getMonthlyOrganizationResponseCount).toHaveBeenCalledWith(mockOrganization.id);
     expect(sendPlanLimitsReachedEventToPosthogWeekly).not.toHaveBeenCalled();
   });
 
   test("should throw ResourceNotFoundError if environment not found", async () => {
-    vi.mocked(getEnvironment).mockResolvedValue(null);
+    vi.mocked(getEnvironmentStateData).mockRejectedValue(
+      new ResourceNotFoundError("environment", environmentId)
+    );
     await expect(getEnvironmentState(environmentId)).rejects.toThrow(ResourceNotFoundError);
   });
 
   test("should throw ResourceNotFoundError if organization not found", async () => {
-    vi.mocked(getOrganizationByEnvironmentId).mockResolvedValue(null);
+    vi.mocked(getEnvironmentStateData).mockRejectedValue(new ResourceNotFoundError("organization", null));
     await expect(getEnvironmentState(environmentId)).rejects.toThrow(ResourceNotFoundError);
   });
 
   test("should throw ResourceNotFoundError if project not found", async () => {
-    vi.mocked(getProjectForEnvironmentState).mockResolvedValue(null);
+    vi.mocked(getEnvironmentStateData).mockRejectedValue(new ResourceNotFoundError("project", null));
     await expect(getEnvironmentState(environmentId)).rejects.toThrow(ResourceNotFoundError);
   });
 
   test("should update environment and capture event if app setup not completed", async () => {
-    const incompleteEnv = { ...mockEnvironment, appSetupCompleted: false };
-    vi.mocked(getEnvironment).mockResolvedValue(incompleteEnv);
+    const incompleteEnvironmentData = {
+      ...mockEnvironmentStateData,
+      environment: {
+        ...mockEnvironmentStateData.environment,
+        appSetupCompleted: false,
+      },
+    };
+    vi.mocked(getEnvironmentStateData).mockResolvedValue(incompleteEnvironmentData);
 
     const result = await getEnvironmentState(environmentId);
 
@@ -312,14 +217,14 @@ describe("getEnvironmentState", () => {
       data: { appSetupCompleted: true },
     });
     expect(capturePosthogEnvironmentEvent).toHaveBeenCalledWith(environmentId, "app setup completed");
-    expect(result.revalidateEnvironment).toBe(true);
+    expect(result.data).toBeDefined();
   });
 
   test("should return empty surveys if monthly response limit reached (Cloud)", async () => {
     vi.mocked(getMonthlyOrganizationResponseCount).mockResolvedValue(100); // Exactly at limit
-    vi.mocked(getSurveysForEnvironmentState).mockResolvedValue(mockSurveys);
 
     const result = await getEnvironmentState(environmentId);
+
     expect(result.data.surveys).toEqual([]);
     expect(getMonthlyOrganizationResponseCount).toHaveBeenCalledWith(mockOrganization.id);
     expect(sendPlanLimitsReachedEventToPosthogWeekly).toHaveBeenCalledWith(environmentId, {
@@ -339,7 +244,7 @@ describe("getEnvironmentState", () => {
 
     const result = await getEnvironmentState(environmentId);
 
-    expect(result.data.surveys).toEqual([mockSurveys[0]]);
+    expect(result.data.surveys).toEqual(mockSurveys);
     expect(getMonthlyOrganizationResponseCount).toHaveBeenCalledWith(mockOrganization.id);
     expect(sendPlanLimitsReachedEventToPosthogWeekly).not.toHaveBeenCalled();
   });
@@ -364,9 +269,12 @@ describe("getEnvironmentState", () => {
     expect(result.data.recaptchaSiteKey).toBe("mock_recaptcha_site_key");
   });
 
-  test("should filter surveys correctly (only app type and inProgress status)", async () => {
-    const result = await getEnvironmentState(environmentId);
-    expect(result.data.surveys).toHaveLength(1);
-    expect(result.data.surveys[0].id).toBe("survey-app-inProgress");
+  test("should use withCache for caching with correct cache key and TTL", () => {
+    getEnvironmentState(environmentId);
+
+    expect(withCache).toHaveBeenCalledWith(expect.any(Function), {
+      key: `fb:env:${environmentId}:state`,
+      ttl: 60 * 30 * 1000, // 30 minutes in milliseconds
+    });
   });
 });

apps/web/app/api/v1/client/[environmentId]/environment/lib/environmentState.ts

@@ -1,125 +1,93 @@
-import { actionClassCache } from "@/lib/actionClass/cache";
-import { cache } from "@/lib/cache";
+import "server-only";
 import { IS_FORMBRICKS_CLOUD, IS_RECAPTCHA_CONFIGURED, RECAPTCHA_SITE_KEY } from "@/lib/constants";
-import { environmentCache } from "@/lib/environment/cache";
-import { getEnvironment } from "@/lib/environment/service";
-import { organizationCache } from "@/lib/organization/cache";
-import {
-  getMonthlyOrganizationResponseCount,
-  getOrganizationByEnvironmentId,
-} from "@/lib/organization/service";
+import { getMonthlyOrganizationResponseCount } from "@/lib/organization/service";
 import {
   capturePosthogEnvironmentEvent,
   sendPlanLimitsReachedEventToPosthogWeekly,
 } from "@/lib/posthogServer";
-import { projectCache } from "@/lib/project/cache";
-import { surveyCache } from "@/lib/survey/cache";
+import { createCacheKey } from "@/modules/cache/lib/cacheKeys";
+import { withCache } from "@/modules/cache/lib/withCache";
 import { prisma } from "@formbricks/database";
 import { logger } from "@formbricks/logger";
-import { ResourceNotFoundError } from "@formbricks/types/errors";
 import { TJsEnvironmentState } from "@formbricks/types/js";
-import { getActionClassesForEnvironmentState } from "./actionClass";
-import { getProjectForEnvironmentState } from "./project";
-import { getSurveysForEnvironmentState } from "./survey";
+import { getEnvironmentStateData } from "./data";
 
 /**
+ * Optimized environment state fetcher using new caching approach
+ * Uses withCache for Redis-backed caching with graceful fallback
+ * Single database query via optimized data service
  *
- * @param environmentId
+ * @param environmentId - The environment ID to fetch state for
  * @returns The environment state
- * @throws ResourceNotFoundError if the environment or organization does not exist
+ * @throws ResourceNotFoundError if environment, organization, or project not found
  */
 export const getEnvironmentState = async (
   environmentId: string
-): Promise<{ data: TJsEnvironmentState["data"]; revalidateEnvironment?: boolean }> =>
-  cache(
+): Promise<{ data: TJsEnvironmentState["data"] }> => {
+  // Use withCache for efficient Redis caching with automatic fallback
+  const getCachedEnvironmentState = withCache(
     async () => {
-      let revalidateEnvironment = false;
-      const [environment, organization, project] = await Promise.all([
-        getEnvironment(environmentId),
-        getOrganizationByEnvironmentId(environmentId),
-        getProjectForEnvironmentState(environmentId),
-      ]);
-
-      if (!environment) {
-        throw new ResourceNotFoundError("environment", environmentId);
-      }
-
-      if (!organization) {
-        throw new ResourceNotFoundError("organization", null);
-      }
-
-      if (!project) {
-        throw new ResourceNotFoundError("project", null);
-      }
+      // Single optimized database call replacing multiple service calls
+      const { environment, organization, surveys, actionClasses } =
+        await getEnvironmentStateData(environmentId);
 
+      // Handle app setup completion update if needed
+      // This is a one-time setup flag that can tolerate TTL-based cache expiration
       if (!environment.appSetupCompleted) {
         await Promise.all([
           prisma.environment.update({
-            where: {
-              id: environmentId,
-            },
+            where: { id: environmentId },
             data: { appSetupCompleted: true },
           }),
           capturePosthogEnvironmentEvent(environmentId, "app setup completed"),
         ]);
-
-        revalidateEnvironment = true;
       }
 
-      // check if MAU limit is reached
+      // Check monthly response limits for Formbricks Cloud
       let isMonthlyResponsesLimitReached = false;
-
       if (IS_FORMBRICKS_CLOUD) {
         const monthlyResponseLimit = organization.billing.limits.monthly.responses;
-
         const currentResponseCount = await getMonthlyOrganizationResponseCount(organization.id);
         isMonthlyResponsesLimitReached =
           monthlyResponseLimit !== null && currentResponseCount >= monthlyResponseLimit;
-      }
 
-      if (isMonthlyResponsesLimitReached) {
-        try {
-          await sendPlanLimitsReachedEventToPosthogWeekly(environmentId, {
-            plan: organization.billing.plan,
-            limits: {
-              projects: null,
-              monthly: {
-                miu: null,
-                responses: organization.billing.limits.monthly.responses,
+        // Send plan limits event if needed
+        if (isMonthlyResponsesLimitReached) {
+          try {
+            await sendPlanLimitsReachedEventToPosthogWeekly(environmentId, {
+              plan: organization.billing.plan,
+              limits: {
+                projects: null,
+                monthly: {
+                  miu: null,
+                  responses: organization.billing.limits.monthly.responses,
+                },
               },
-            },
-          });
-        } catch (err) {
-          logger.error(err, "Error sending plan limits reached event to Posthog");
+            });
+          } catch (err) {
+            logger.error(err, "Error sending plan limits reached event to Posthog");
+          }
         }
       }
 
-      const [surveys, actionClasses] = await Promise.all([
-        getSurveysForEnvironmentState(environmentId),
-        getActionClassesForEnvironmentState(environmentId),
-      ]);
-
+      // Build the response data
       const data: TJsEnvironmentState["data"] = {
         surveys: !isMonthlyResponsesLimitReached ? surveys : [],
         actionClasses,
-        project: project,
+        project: environment.project,
         ...(IS_RECAPTCHA_CONFIGURED ? { recaptchaSiteKey: RECAPTCHA_SITE_KEY } : {}),
       };
 
-      return {
-        data,
-        revalidateEnvironment,
-      };
+      return { data };
     },
-    [`environmentState-${environmentId}`],
     {
-      ...(IS_FORMBRICKS_CLOUD && { revalidate: 24 * 60 * 60 }),
-      tags: [
-        environmentCache.tag.byId(environmentId),
-        organizationCache.tag.byEnvironmentId(environmentId),
-        projectCache.tag.byEnvironmentId(environmentId),
-        surveyCache.tag.byEnvironmentId(environmentId),
-        actionClassCache.tag.byEnvironmentId(environmentId),
-      ],
+      // Use enterprise-grade cache key pattern
+      key: createCacheKey.environment.state(environmentId),
+      // 30 minutes TTL ensures fresh data for hourly SDK checks
+      // Balances performance with freshness requirements
+      ttl: 60 * 30 * 1000, // 30 minutes in milliseconds
     }
-  )();
+  );
+
+  return getCachedEnvironmentState();
+};

apps/web/app/api/v1/client/[environmentId]/environment/lib/project.test.ts

@@ -1,120 +0,0 @@
-import { cache } from "@/lib/cache";
-import { projectCache } from "@/lib/project/cache";
-import { Prisma } from "@prisma/client";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { prisma } from "@formbricks/database";
-import { logger } from "@formbricks/logger";
-import { DatabaseError } from "@formbricks/types/errors";
-import { TJsEnvironmentStateProject } from "@formbricks/types/js";
-import { getProjectForEnvironmentState } from "./project";
-
-// Mock dependencies
-vi.mock("@/lib/cache");
-vi.mock("@/lib/project/cache");
-vi.mock("@formbricks/database", () => ({
-  prisma: {
-    project: {
-      findFirst: vi.fn(),
-    },
-  },
-}));
-vi.mock("@formbricks/logger", () => ({
-  logger: {
-    error: vi.fn(),
-  },
-}));
-vi.mock("@/lib/utils/validate"); // Mock validateInputs if needed, though it's often tested elsewhere
-
-const environmentId = "test-environment-id";
-const mockProject: TJsEnvironmentStateProject = {
-  id: "test-project-id",
-  recontactDays: 30,
-  clickOutsideClose: true,
-  darkOverlay: false,
-  placement: "bottomRight",
-  inAppSurveyBranding: true,
-  styling: { allowStyleOverwrite: false },
-};
-
-describe("getProjectForEnvironmentState", () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-
-    // Mock cache implementation
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-
-    // Mock projectCache tags
-    vi.mocked(projectCache.tag.byEnvironmentId).mockReturnValue(`project-env-${environmentId}`);
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-
-  test("should return project state successfully", async () => {
-    vi.mocked(prisma.project.findFirst).mockResolvedValue(mockProject);
-
-    const result = await getProjectForEnvironmentState(environmentId);
-
-    expect(result).toEqual(mockProject);
-    expect(prisma.project.findFirst).toHaveBeenCalledWith({
-      where: {
-        environments: {
-          some: {
-            id: environmentId,
-          },
-        },
-      },
-      select: {
-        id: true,
-        recontactDays: true,
-        clickOutsideClose: true,
-        darkOverlay: true,
-        placement: true,
-        inAppSurveyBranding: true,
-        styling: true,
-      },
-    });
-    expect(cache).toHaveBeenCalledTimes(1);
-    expect(cache).toHaveBeenCalledWith(
-      expect.any(Function),
-      [`getProjectForEnvironmentState-${environmentId}`],
-      {
-        tags: [`project-env-${environmentId}`],
-      }
-    );
-  });
-
-  test("should return null if project not found", async () => {
-    vi.mocked(prisma.project.findFirst).mockResolvedValue(null);
-
-    const result = await getProjectForEnvironmentState(environmentId);
-
-    expect(result).toBeNull();
-    expect(prisma.project.findFirst).toHaveBeenCalledTimes(1);
-    expect(cache).toHaveBeenCalledTimes(1);
-  });
-
-  test("should throw DatabaseError on PrismaClientKnownRequestError", async () => {
-    const prismaError = new Prisma.PrismaClientKnownRequestError("Test error", {
-      code: "P2001",
-      clientVersion: "test",
-    });
-    vi.mocked(prisma.project.findFirst).mockRejectedValue(prismaError);
-
-    await expect(getProjectForEnvironmentState(environmentId)).rejects.toThrow(DatabaseError);
-    expect(logger.error).toHaveBeenCalledWith(prismaError, "Error getting project for environment state");
-    expect(cache).toHaveBeenCalledTimes(1);
-  });
-
-  test("should re-throw unknown errors", async () => {
-    const unknownError = new Error("Something went wrong");
-    vi.mocked(prisma.project.findFirst).mockRejectedValue(unknownError);
-
-    await expect(getProjectForEnvironmentState(environmentId)).rejects.toThrow(unknownError);
-    expect(logger.error).not.toHaveBeenCalled(); // Should not log unknown errors here
-    expect(cache).toHaveBeenCalledTimes(1);
-  });
-});

apps/web/app/api/v1/client/[environmentId]/environment/lib/project.ts

@@ -1,50 +0,0 @@
-import { cache } from "@/lib/cache";
-import { projectCache } from "@/lib/project/cache";
-import { validateInputs } from "@/lib/utils/validate";
-import { Prisma } from "@prisma/client";
-import { cache as reactCache } from "react";
-import { prisma } from "@formbricks/database";
-import { logger } from "@formbricks/logger";
-import { ZId } from "@formbricks/types/common";
-import { DatabaseError } from "@formbricks/types/errors";
-import { TJsEnvironmentStateProject } from "@formbricks/types/js";
-
-export const getProjectForEnvironmentState = reactCache(
-  async (environmentId: string): Promise<TJsEnvironmentStateProject | null> =>
-    cache(
-      async () => {
-        validateInputs([environmentId, ZId]);
-
-        try {
-          return await prisma.project.findFirst({
-            where: {
-              environments: {
-                some: {
-                  id: environmentId,
-                },
-              },
-            },
-            select: {
-              id: true,
-              recontactDays: true,
-              clickOutsideClose: true,
-              darkOverlay: true,
-              placement: true,
-              inAppSurveyBranding: true,
-              styling: true,
-            },
-          });
-        } catch (error) {
-          if (error instanceof Prisma.PrismaClientKnownRequestError) {
-            logger.error(error, "Error getting project for environment state");
-            throw new DatabaseError(error.message);
-          }
-          throw error;
-        }
-      },
-      [`getProjectForEnvironmentState-${environmentId}`],
-      {
-        tags: [projectCache.tag.byEnvironmentId(environmentId)],
-      }
-    )()
-);

apps/web/app/api/v1/client/[environmentId]/environment/lib/survey.test.ts

@@ -1,155 +0,0 @@
-import { cache } from "@/lib/cache";
-import { validateInputs } from "@/lib/utils/validate";
-import { transformPrismaSurvey } from "@/modules/survey/lib/utils";
-import { Prisma } from "@prisma/client";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { prisma } from "@formbricks/database";
-import { logger } from "@formbricks/logger";
-import { DatabaseError } from "@formbricks/types/errors";
-import { TJsEnvironmentStateSurvey } from "@formbricks/types/js";
-import { getSurveysForEnvironmentState } from "./survey";
-
-// Mock dependencies
-vi.mock("@/lib/cache");
-vi.mock("@/lib/utils/validate");
-vi.mock("@/modules/survey/lib/utils");
-vi.mock("@formbricks/database", () => ({
-  prisma: {
-    survey: {
-      findMany: vi.fn(),
-    },
-  },
-}));
-vi.mock("@formbricks/logger", () => ({
-  logger: {
-    error: vi.fn(),
-  },
-}));
-
-const environmentId = "test-environment-id";
-
-const mockPrismaSurvey = {
-  id: "survey-1",
-  welcomeCard: { enabled: false },
-  name: "Test Survey",
-  questions: [],
-  variables: [],
-  type: "app",
-  showLanguageSwitch: false,
-  languages: [],
-  endings: [],
-  autoClose: null,
-  styling: null,
-  status: "inProgress",
-  recaptcha: null,
-  segment: null,
-  recontactDays: null,
-  displayLimit: null,
-  displayOption: "displayOnce",
-  hiddenFields: { enabled: false },
-  isBackButtonHidden: false,
-  triggers: [],
-  displayPercentage: null,
-  delay: 0,
-  projectOverwrites: null,
-};
-
-const mockTransformedSurvey: TJsEnvironmentStateSurvey = {
-  id: "survey-1",
-  welcomeCard: { enabled: false } as TJsEnvironmentStateSurvey["welcomeCard"],
-  name: "Test Survey",
-  questions: [],
-  variables: [],
-  type: "app",
-  showLanguageSwitch: false,
-  languages: [],
-  endings: [],
-  autoClose: null,
-  styling: null,
-  status: "inProgress",
-  recaptcha: null,
-  segment: null,
-  recontactDays: null,
-  displayLimit: null,
-  displayOption: "displayOnce",
-  hiddenFields: { enabled: false },
-  isBackButtonHidden: false,
-  triggers: [],
-  displayPercentage: null,
-  delay: 0,
-  projectOverwrites: null,
-};
-
-describe("getSurveysForEnvironmentState", () => {
-  beforeEach(() => {
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-    vi.mocked(validateInputs).mockReturnValue([environmentId]); // Assume validation passes
-    vi.mocked(transformPrismaSurvey).mockReturnValue(mockTransformedSurvey);
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-
-  test("should return transformed surveys on successful fetch", async () => {
-    vi.mocked(prisma.survey.findMany).mockResolvedValue([mockPrismaSurvey]);
-
-    const result = await getSurveysForEnvironmentState(environmentId);
-
-    expect(validateInputs).toHaveBeenCalledWith([environmentId, expect.any(Object)]);
-    expect(prisma.survey.findMany).toHaveBeenCalledWith({
-      where: {
-        environmentId,
-        type: "app",
-        status: "inProgress",
-      },
-      select: expect.any(Object), // Check if select is called, specific fields are in the original code
-      orderBy: { createdAt: "desc" },
-      take: 30,
-    });
-    expect(transformPrismaSurvey).toHaveBeenCalledWith(mockPrismaSurvey);
-    expect(result).toEqual([mockTransformedSurvey]);
-    expect(logger.error).not.toHaveBeenCalled();
-  });
-
-  test("should return an empty array if no surveys are found", async () => {
-    vi.mocked(prisma.survey.findMany).mockResolvedValue([]);
-
-    const result = await getSurveysForEnvironmentState(environmentId);
-
-    expect(prisma.survey.findMany).toHaveBeenCalledWith({
-      where: {
-        environmentId,
-        type: "app",
-        status: "inProgress",
-      },
-      select: expect.any(Object),
-      orderBy: { createdAt: "desc" },
-      take: 30,
-    });
-    expect(transformPrismaSurvey).not.toHaveBeenCalled();
-    expect(result).toEqual([]);
-    expect(logger.error).not.toHaveBeenCalled();
-  });
-
-  test("should throw DatabaseError on Prisma known request error", async () => {
-    const prismaError = new Prisma.PrismaClientKnownRequestError("Test Prisma Error", {
-      code: "P2025",
-      clientVersion: "5.0.0",
-    });
-    vi.mocked(prisma.survey.findMany).mockRejectedValue(prismaError);
-
-    await expect(getSurveysForEnvironmentState(environmentId)).rejects.toThrow(DatabaseError);
-    expect(logger.error).toHaveBeenCalledWith(prismaError, "Error getting surveys for environment state");
-  });
-
-  test("should rethrow unknown errors", async () => {
-    const unknownError = new Error("Something went wrong");
-    vi.mocked(prisma.survey.findMany).mockRejectedValue(unknownError);
-
-    await expect(getSurveysForEnvironmentState(environmentId)).rejects.toThrow(unknownError);
-    expect(logger.error).not.toHaveBeenCalled();
-  });
-});

apps/web/app/api/v1/client/[environmentId]/environment/lib/survey.ts

@@ -1,102 +0,0 @@
-import { cache } from "@/lib/cache";
-import { surveyCache } from "@/lib/survey/cache";
-import { validateInputs } from "@/lib/utils/validate";
-import { transformPrismaSurvey } from "@/modules/survey/lib/utils";
-import { Prisma } from "@prisma/client";
-import { cache as reactCache } from "react";
-import { prisma } from "@formbricks/database";
-import { logger } from "@formbricks/logger";
-import { ZId } from "@formbricks/types/common";
-import { DatabaseError } from "@formbricks/types/errors";
-import { TJsEnvironmentStateSurvey } from "@formbricks/types/js";
-
-export const getSurveysForEnvironmentState = reactCache(
-  async (environmentId: string): Promise<TJsEnvironmentStateSurvey[]> =>
-    cache(
-      async () => {
-        validateInputs([environmentId, ZId]);
-
-        try {
-          const surveysPrisma = await prisma.survey.findMany({
-            where: {
-              environmentId,
-              type: "app",
-              status: "inProgress",
-            },
-            orderBy: {
-              createdAt: "desc",
-            },
-            take: 30,
-            select: {
-              id: true,
-              welcomeCard: true,
-              name: true,
-              questions: true,
-              variables: true,
-              type: true,
-              showLanguageSwitch: true,
-              languages: {
-                select: {
-                  default: true,
-                  enabled: true,
-                  language: {
-                    select: {
-                      id: true,
-                      code: true,
-                      alias: true,
-                      createdAt: true,
-                      updatedAt: true,
-                      projectId: true,
-                    },
-                  },
-                },
-              },
-              endings: true,
-              autoClose: true,
-              styling: true,
-              status: true,
-              recaptcha: true,
-              segment: {
-                include: {
-                  surveys: {
-                    select: {
-                      id: true,
-                    },
-                  },
-                },
-              },
-              recontactDays: true,
-              displayLimit: true,
-              displayOption: true,
-              hiddenFields: true,
-              isBackButtonHidden: true,
-              triggers: {
-                select: {
-                  actionClass: {
-                    select: {
-                      name: true,
-                    },
-                  },
-                },
-              },
-              displayPercentage: true,
-              delay: true,
-              projectOverwrites: true,
-            },
-          });
-
-          return surveysPrisma.map((survey) => transformPrismaSurvey<TJsEnvironmentStateSurvey>(survey));
-        } catch (error) {
-          if (error instanceof Prisma.PrismaClientKnownRequestError) {
-            logger.error(error, "Error getting surveys for environment state");
-            throw new DatabaseError(error.message);
-          }
-          throw error;
-        }
-      },
-      [`getSurveysForEnvironmentState-${environmentId}`],
-      {
-        tags: [surveyCache.tag.byEnvironmentId(environmentId)],
-      }
-    )()
-);

apps/web/app/api/v1/client/[environmentId]/environment/route.ts

@@ -1,14 +1,19 @@
 import { getEnvironmentState } from "@/app/api/v1/client/[environmentId]/environment/lib/environmentState";
 import { responses } from "@/app/lib/api/response";
-import { transformErrorToDetails } from "@/app/lib/api/validator";
-import { environmentCache } from "@/lib/environment/cache";
 import { NextRequest } from "next/server";
 import { logger } from "@formbricks/logger";
 import { ResourceNotFoundError } from "@formbricks/types/errors";
-import { ZJsSyncInput } from "@formbricks/types/js";
 
 export const OPTIONS = async (): Promise<Response> => {
-  return responses.successResponse({}, true);
+  return responses.successResponse(
+    {},
+    true,
+    // Cache CORS preflight responses for 1 hour (balanced approach)
+    // Allows for reasonable flexibility while still providing good performance
+    // max-age=3600: 1hr browser cache
+    // s-maxage=3600: 1hr Cloudflare cache
+    "public, s-maxage=3600, max-age=3600"
+  );
 };
 
 export const GET = async (
@@ -22,51 +27,49 @@ export const GET = async (
   const params = await props.params;
 
   try {
-    // validate using zod
-    const inputValidation = ZJsSyncInput.safeParse({
-      environmentId: params.environmentId,
-    });
-
-    if (!inputValidation.success) {
-      return responses.badRequestResponse(
-        "Fields are missing or incorrectly formatted",
-        transformErrorToDetails(inputValidation.error),
-        true
-      );
+    // Simple validation for environmentId (faster than Zod for high-frequency endpoint)
+    if (!params.environmentId || typeof params.environmentId !== "string") {
+      return responses.badRequestResponse("Environment ID is required", undefined, true);
     }
 
-    try {
-      const environmentState = await getEnvironmentState(params.environmentId);
-      const { data, revalidateEnvironment } = environmentState;
+    // Use optimized environment state fetcher with new caching approach
+    const environmentState = await getEnvironmentState(params.environmentId);
+    const { data } = environmentState;
 
-      if (revalidateEnvironment) {
-        environmentCache.revalidate({
-          id: inputValidation.data.environmentId,
-          projectId: data.project.id,
-        });
-      }
-
-      return responses.successResponse(
+    return responses.successResponse(
+      {
+        data,
+        expiresAt: new Date(Date.now() + 1000 * 60 * 60), // 1 hour for SDK to recheck
+      },
+      true,
+      // Optimized cache headers for Cloudflare CDN and browser caching
+      // max-age=3600: 1hr browser cache (per guidelines)
+      // s-maxage=1800: 30min Cloudflare cache (per guidelines)
+      // stale-while-revalidate=1800: 30min stale serving during revalidation
+      // stale-if-error=3600: 1hr stale serving on origin errors
+      "public, s-maxage=1800, max-age=3600, stale-while-revalidate=1800, stale-if-error=3600"
+    );
+  } catch (err) {
+    if (err instanceof ResourceNotFoundError) {
+      logger.warn(
         {
-          data,
-          expiresAt: new Date(Date.now() + 1000 * 60 * 30), // 30 minutes
+          environmentId: params.environmentId,
+          resourceType: err.resourceType,
+          resourceId: err.resourceId,
         },
-        true,
-        "public, s-maxage=600, max-age=840, stale-while-revalidate=600, stale-if-error=600"
+        "Resource not found in environment endpoint"
       );
-    } catch (err) {
-      if (err instanceof ResourceNotFoundError) {
-        return responses.notFoundResponse(err.resourceType, err.resourceId);
-      }
-
-      logger.error(
-        { error: err, url: request.url },
-        "Error in GET /api/v1/client/[environmentId]/environment"
-      );
-      return responses.internalServerErrorResponse(err.message, true);
+      return responses.notFoundResponse(err.resourceType, err.resourceId);
     }
-  } catch (error) {
-    logger.error({ error, url: request.url }, "Error in GET /api/v1/client/[environmentId]/environment");
-    return responses.internalServerErrorResponse("Unable to handle the request: " + error.message, true);
+
+    logger.error(
+      {
+        error: err,
+        url: request.url,
+        environmentId: params.environmentId,
+      },
+      "Error in GET /api/v1/client/[environmentId]/environment"
+    );
+    return responses.internalServerErrorResponse(err.message, true);
   }
 };

apps/web/app/api/v1/client/[environmentId]/responses/lib/contact.test.ts

@@ -1,6 +1,5 @@
-import { cache } from "@/lib/cache";
 import { Prisma } from "@prisma/client";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { afterEach, describe, expect, test, vi } from "vitest";
 import { prisma } from "@formbricks/database";
 import { DatabaseError } from "@formbricks/types/errors";
 import { getContact, getContactByUserId } from "./contact";
@@ -15,9 +14,6 @@ vi.mock("@formbricks/database", () => ({
   },
 }));
 
-// Mock cache module
-vi.mock("@/lib/cache");
-
 // Mock react cache
 vi.mock("react", async () => {
   const actual = await vi.importActual("react");
@@ -32,12 +28,6 @@ const mockEnvironmentId = "test-env-id";
 const mockUserId = "test-user-id";
 
 describe("Contact API Lib", () => {
-  beforeEach(() => {
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-  });
-
   afterEach(() => {
     vi.resetAllMocks();
   });

apps/web/app/api/v1/client/[environmentId]/responses/lib/contact.ts

@@ -1,84 +1,67 @@
-import { cache } from "@/lib/cache";
-import { contactCache } from "@/lib/cache/contact";
 import { Prisma } from "@prisma/client";
 import { cache as reactCache } from "react";
 import { prisma } from "@formbricks/database";
 import { TContactAttributes } from "@formbricks/types/contact-attribute";
 import { DatabaseError } from "@formbricks/types/errors";
 
-export const getContact = reactCache((contactId: string) =>
-  cache(
-    async () => {
-      try {
-        const contact = await prisma.contact.findUnique({
-          where: { id: contactId },
-          select: { id: true },
-        });
+export const getContact = reactCache(async (contactId: string) => {
+  try {
+    const contact = await prisma.contact.findUnique({
+      where: { id: contactId },
+      select: { id: true },
+    });
 
-        return contact;
-      } catch (error) {
-        if (error instanceof Prisma.PrismaClientKnownRequestError) {
-          throw new DatabaseError(error.message);
-        }
-      }
-    },
-    [`getContact-responses-api-${contactId}`],
-    {
-      tags: [contactCache.tag.byId(contactId)],
+    return contact;
+  } catch (error) {
+    if (error instanceof Prisma.PrismaClientKnownRequestError) {
+      throw new DatabaseError(error.message);
     }
-  )()
-);
+  }
+});
 
 export const getContactByUserId = reactCache(
-  (
+  async (
     environmentId: string,
     userId: string
   ): Promise<{
     id: string;
     attributes: TContactAttributes;
-  } | null> =>
-    cache(
-      async () => {
-        const contact = await prisma.contact.findFirst({
-          where: {
-            attributes: {
-              some: {
-                attributeKey: {
-                  key: "userId",
-                  environmentId,
-                },
-                value: userId,
-              },
+  } | null> => {
+    const contact = await prisma.contact.findFirst({
+      where: {
+        attributes: {
+          some: {
+            attributeKey: {
+              key: "userId",
+              environmentId,
             },
+            value: userId,
           },
-          select: {
-            id: true,
-            attributes: {
-              select: {
-                attributeKey: { select: { key: true } },
-                value: true,
-              },
-            },
-          },
-        });
-
-        if (!contact) {
-          return null;
-        }
-
-        const contactAttributes = contact.attributes.reduce((acc, attr) => {
-          acc[attr.attributeKey.key] = attr.value;
-          return acc;
-        }, {}) as TContactAttributes;
-
-        return {
-          id: contact.id,
-          attributes: contactAttributes,
-        };
+        },
       },
-      [`getContactByUserIdForResponsesApi-${environmentId}-${userId}`],
-      {
-        tags: [contactCache.tag.byEnvironmentIdAndUserId(environmentId, userId)],
-      }
-    )()
+      select: {
+        id: true,
+        attributes: {
+          select: {
+            attributeKey: { select: { key: true } },
+            value: true,
+          },
+        },
+      },
+    });
+
+    if (!contact) {
+      return null;
+    }
+
+    const contactAttributes = contact.attributes.reduce((acc, attr) => {
+      acc[attr.attributeKey.key] = attr.value;
+      return acc;
+    }, {}) as TContactAttributes;
+
+    return {
+      id: contact.id,
+      attributes: contactAttributes,
+    };
+  }
 );

apps/web/app/api/v1/client/[environmentId]/responses/lib/response.test.ts

@@ -29,22 +29,10 @@ vi.mock("@/lib/posthogServer", () => ({
   sendPlanLimitsReachedEventToPosthogWeekly: vi.fn(),
 }));
 
-vi.mock("@/lib/response/cache", () => ({
-  responseCache: {
-    revalidate: vi.fn(),
-  },
-}));
-
 vi.mock("@/lib/response/utils", () => ({
   calculateTtcTotal: vi.fn((ttc) => ttc),
 }));
 
-vi.mock("@/lib/responseNote/cache", () => ({
-  responseNoteCache: {
-    revalidate: vi.fn(),
-  },
-}));
-
 vi.mock("@/lib/telemetry", () => ({
   captureTelemetry: vi.fn(),
 }));

apps/web/app/api/v1/client/[environmentId]/responses/lib/response.ts

@@ -5,9 +5,7 @@ import {
   getOrganizationByEnvironmentId,
 } from "@/lib/organization/service";
 import { sendPlanLimitsReachedEventToPosthogWeekly } from "@/lib/posthogServer";
-import { responseCache } from "@/lib/response/cache";
 import { calculateTtcTotal } from "@/lib/response/utils";
-import { responseNoteCache } from "@/lib/responseNote/cache";
 import { captureTelemetry } from "@/lib/telemetry";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
@@ -149,19 +147,6 @@ export const createResponse = async (responseInput: TResponseInput): Promise<TRe
       tags: responsePrisma.tags.map((tagPrisma: { tag: TTag }) => tagPrisma.tag),
     };
 
-    responseCache.revalidate({
-      environmentId,
-      id: response.id,
-      contactId: contact?.id,
-      ...(singleUseId && { singleUseId }),
-      userId: userId ?? undefined,
-      surveyId,
-    });
-
-    responseNoteCache.revalidate({
-      responseId: response.id,
-    });
-
     if (IS_FORMBRICKS_CLOUD) {
       const responsesCount = await getMonthlyOrganizationResponseCount(organization.id);
       const responsesLimit = organization.billing.limits.monthly.responses;

apps/web/app/api/v1/client/[environmentId]/responses/route.ts

@@ -20,7 +20,13 @@ interface Context {
 }
 
 export const OPTIONS = async (): Promise<Response> => {
-  return responses.successResponse({}, true);
+  return responses.successResponse(
+    {},
+    true,
+    // Cache CORS preflight responses for 1 hour (conservative approach)
+    // Balances performance gains with flexibility for CORS policy changes
+    "public, s-maxage=3600, max-age=3600"
+  );
 };
 
 export const POST = async (request: Request, context: Context): Promise<Response> => {

apps/web/app/api/v1/client/[environmentId]/storage/local/route.ts

@@ -19,15 +19,12 @@ interface Context {
 }
 
 export const OPTIONS = async (): Promise<Response> => {
-  return Response.json(
+  return responses.successResponse(
     {},
-    {
-      headers: {
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-        "Access-Control-Allow-Headers": "Content-Type, Authorization",
-      },
-    }
+    true,
+    // Cache CORS preflight responses for 1 hour (conservative approach)
+    // Balances performance gains with flexibility for CORS policy changes
+    "public, s-maxage=3600, max-age=3600"
   );
 };
 

apps/web/app/api/v1/client/[environmentId]/storage/route.ts

@@ -15,7 +15,13 @@ interface Context {
 }
 
 export const OPTIONS = async (): Promise<Response> => {
-  return responses.successResponse({}, true);
+  return responses.successResponse(
+    {},
+    true,
+    // Cache CORS preflight responses for 1 hour (conservative approach)
+    // Balances performance gains with flexibility for CORS policy changes
+    "public, s-maxage=3600, max-age=3600"
+  );
 };
 
 // api endpoint for uploading private files

apps/web/app/api/v1/management/action-classes/lib/action-classes.ts

@@ -1,8 +1,6 @@
 "use server";
 
 import "server-only";
-import { actionClassCache } from "@/lib/actionClass/cache";
-import { cache } from "@/lib/cache";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
 import { cache as reactCache } from "react";
@@ -23,29 +21,20 @@ const selectActionClass = {
   environmentId: true,
 } satisfies Prisma.ActionClassSelect;
 
-export const getActionClasses = reactCache(
-  async (environmentIds: string[]): Promise<TActionClass[]> =>
-    cache(
-      async () => {
-        validateInputs([environmentIds, ZId.array()]);
+export const getActionClasses = reactCache(async (environmentIds: string[]): Promise<TActionClass[]> => {
+  validateInputs([environmentIds, ZId.array()]);
 
-        try {
-          return await prisma.actionClass.findMany({
-            where: {
-              environmentId: { in: environmentIds },
-            },
-            select: selectActionClass,
-            orderBy: {
-              createdAt: "asc",
-            },
-          });
-        } catch (error) {
-          throw new DatabaseError(`Database error when fetching actions for environment ${environmentIds}`);
-        }
+  try {
+    return await prisma.actionClass.findMany({
+      where: {
+        environmentId: { in: environmentIds },
       },
-      environmentIds.map((environmentId) => `getActionClasses-management-api-${environmentId}`),
-      {
-        tags: environmentIds.map((environmentId) => actionClassCache.tag.byEnvironmentId(environmentId)),
-      }
-    )()
-);
+      select: selectActionClass,
+      orderBy: {
+        createdAt: "asc",
+      },
+    });
+  } catch (error) {
+    throw new DatabaseError(`Database error when fetching actions for environment ${environmentIds}`);
+  }
+});

apps/web/app/api/v1/management/responses/lib/contact.test.ts

@@ -1,6 +1,4 @@
-import { cache } from "@/lib/cache";
-import { contactCache } from "@/lib/cache/contact";
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { prisma } from "@formbricks/database";
 import { TContactAttributes } from "@formbricks/types/contact-attribute";
 import { getContactByUserId } from "./contact";
@@ -14,8 +12,6 @@ vi.mock("@formbricks/database", () => ({
   },
 }));
 
-vi.mock("@/lib/cache");
-
 const environmentId = "test-env-id";
 const userId = "test-user-id";
 const contactId = "test-contact-id";
@@ -36,12 +32,6 @@ const expectedContactAttributes: TContactAttributes = {
 };
 
 describe("getContactByUserId", () => {
-  beforeEach(() => {
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-  });
-
   test("should return contact with attributes when found", async () => {
     vi.mocked(prisma.contact.findFirst).mockResolvedValue(mockContactDbData);
 
@@ -73,13 +63,6 @@ describe("getContactByUserId", () => {
       id: contactId,
       attributes: expectedContactAttributes,
     });
-    expect(cache).toHaveBeenCalledWith(
-      expect.any(Function),
-      [`getContactByUserIdForResponsesApi-${environmentId}-${userId}`],
-      {
-        tags: [contactCache.tag.byEnvironmentIdAndUserId(environmentId, userId)],
-      }
-    );
   });
 
   test("should return null when contact is not found", async () => {
@@ -110,12 +93,5 @@ describe("getContactByUserId", () => {
       },
     });
     expect(contact).toBeNull();
-    expect(cache).toHaveBeenCalledWith(
-      expect.any(Function),
-      [`getContactByUserIdForResponsesApi-${environmentId}-${userId}`],
-      {
-        tags: [contactCache.tag.byEnvironmentIdAndUserId(environmentId, userId)],
-      }
-    );
   });
 });

apps/web/app/api/v1/management/responses/lib/contact.ts

@@ -1,60 +1,51 @@
 import "server-only";
-import { cache } from "@/lib/cache";
-import { contactCache } from "@/lib/cache/contact";
 import { cache as reactCache } from "react";
 import { prisma } from "@formbricks/database";
 import { TContactAttributes } from "@formbricks/types/contact-attribute";
 
 export const getContactByUserId = reactCache(
-  (
+  async (
     environmentId: string,
     userId: string
   ): Promise<{
     id: string;
     attributes: TContactAttributes;
-  } | null> =>
-    cache(
-      async () => {
-        const contact = await prisma.contact.findFirst({
-          where: {
-            attributes: {
-              some: {
-                attributeKey: {
-                  key: "userId",
-                  environmentId,
-                },
-                value: userId,
-              },
+  } | null> => {
+    const contact = await prisma.contact.findFirst({
+      where: {
+        attributes: {
+          some: {
+            attributeKey: {
+              key: "userId",
+              environmentId,
             },
+            value: userId,
           },
-          select: {
-            id: true,
-            attributes: {
-              select: {
-                attributeKey: { select: { key: true } },
-                value: true,
-              },
-            },
-          },
-        });
-
-        if (!contact) {
-          return null;
-        }
-
-        const contactAttributes = contact.attributes.reduce((acc, attr) => {
-          acc[attr.attributeKey.key] = attr.value;
-          return acc;
-        }, {}) as TContactAttributes;
-
-        return {
-          id: contact.id,
-          attributes: contactAttributes,
-        };
+        },
       },
-      [`getContactByUserIdForResponsesApi-${environmentId}-${userId}`],
-      {
-        tags: [contactCache.tag.byEnvironmentIdAndUserId(environmentId, userId)],
-      }
-    )()
+      select: {
+        id: true,
+        attributes: {
+          select: {
+            attributeKey: { select: { key: true } },
+            value: true,
+          },
+        },
+      },
+    });
+
+    if (!contact) {
+      return null;
+    }
+
+    const contactAttributes = contact.attributes.reduce((acc, attr) => {
+      acc[attr.attributeKey.key] = attr.value;
+      return acc;
+    }, {}) as TContactAttributes;
+
+    return {
+      id: contact.id,
+      attributes: contactAttributes,
+    };
+  }
 );

apps/web/app/api/v1/management/responses/lib/response.test.ts

@@ -1,13 +1,10 @@
-import { cache } from "@/lib/cache";
 import {
   getMonthlyOrganizationResponseCount,
   getOrganizationByEnvironmentId,
 } from "@/lib/organization/service";
 import { sendPlanLimitsReachedEventToPosthogWeekly } from "@/lib/posthogServer";
-import { responseCache } from "@/lib/response/cache";
 import { getResponseContact } from "@/lib/response/service";
 import { calculateTtcTotal } from "@/lib/response/utils";
-import { responseNoteCache } from "@/lib/responseNote/cache";
 import { validateInputs } from "@/lib/utils/validate";
 import { Organization, Prisma, Response as ResponsePrisma } from "@prisma/client";
 import { beforeEach, describe, expect, test, vi } from "vitest";
@@ -99,7 +96,6 @@ const mockResponsesPrisma = [mockResponsePrisma, { ...mockResponsePrisma, id: "r
 const mockTransformedResponses = [mockResponse, { ...mockResponse, id: "response-2" }];
 
 // Mock dependencies
-vi.mock("@/lib/cache");
 vi.mock("@/lib/constants", () => ({
   IS_FORMBRICKS_CLOUD: true,
   POSTHOG_API_KEY: "mock-posthog-api-key",
@@ -125,10 +121,8 @@ vi.mock("@/lib/constants", () => ({
 }));
 vi.mock("@/lib/organization/service");
 vi.mock("@/lib/posthogServer");
-vi.mock("@/lib/response/cache");
 vi.mock("@/lib/response/service");
 vi.mock("@/lib/response/utils");
-vi.mock("@/lib/responseNote/cache");
 vi.mock("@/lib/telemetry");
 vi.mock("@/lib/utils/validate");
 vi.mock("@formbricks/database", () => ({
@@ -145,10 +139,6 @@ vi.mock("./contact");
 describe("Response Lib Tests", () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    // No need to mock IS_FORMBRICKS_CLOUD here anymore unless specifically changing it from the default
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
   });
 
   describe("createResponse", () => {
@@ -174,13 +164,6 @@ describe("Response Lib Tests", () => {
           }),
         })
       );
-      expect(responseCache.revalidate).toHaveBeenCalledWith(
-        expect.objectContaining({
-          contactId: mockContact.id,
-          userId: mockUserId,
-        })
-      );
-      expect(responseNoteCache.revalidate).toHaveBeenCalled();
       expect(response.contact).toEqual({ id: mockContact.id, userId: mockUserId });
     });
 
@@ -296,7 +279,6 @@ describe("Response Lib Tests", () => {
       );
       expect(getResponseContact).toHaveBeenCalledTimes(mockResponsesPrisma.length);
       expect(responses).toEqual(mockTransformedResponses);
-      expect(cache).toHaveBeenCalled();
     });
 
     test("should return responses with limit and offset", async () => {
@@ -311,7 +293,6 @@ describe("Response Lib Tests", () => {
           skip: mockOffset,
         })
       );
-      expect(cache).toHaveBeenCalled();
     });
 
     test("should return empty array if no responses found", async () => {
@@ -322,7 +303,6 @@ describe("Response Lib Tests", () => {
       expect(responses).toEqual([]);
       expect(prisma.response.findMany).toHaveBeenCalled();
       expect(getResponseContact).not.toHaveBeenCalled();
-      expect(cache).toHaveBeenCalled();
     });
 
     test("should handle PrismaClientKnownRequestError", async () => {
@@ -333,7 +313,6 @@ describe("Response Lib Tests", () => {
       vi.mocked(prisma.response.findMany).mockRejectedValue(prismaError);
 
       await expect(getResponsesByEnvironmentIds(mockEnvironmentIds)).rejects.toThrow(DatabaseError);
-      expect(cache).toHaveBeenCalled();
     });
 
     test("should handle generic errors", async () => {
@@ -341,7 +320,6 @@ describe("Response Lib Tests", () => {
       vi.mocked(prisma.response.findMany).mockRejectedValue(genericError);
 
       await expect(getResponsesByEnvironmentIds(mockEnvironmentIds)).rejects.toThrow(genericError);
-      expect(cache).toHaveBeenCalled();
     });
   });
 });

apps/web/app/api/v1/management/responses/lib/response.ts

@@ -1,15 +1,12 @@
 import "server-only";
-import { cache } from "@/lib/cache";
 import { IS_FORMBRICKS_CLOUD } from "@/lib/constants";
 import {
   getMonthlyOrganizationResponseCount,
   getOrganizationByEnvironmentId,
 } from "@/lib/organization/service";
 import { sendPlanLimitsReachedEventToPosthogWeekly } from "@/lib/posthogServer";
-import { responseCache } from "@/lib/response/cache";
 import { getResponseContact } from "@/lib/response/service";
 import { calculateTtcTotal } from "@/lib/response/utils";
-import { responseNoteCache } from "@/lib/responseNote/cache";
 import { captureTelemetry } from "@/lib/telemetry";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
@@ -153,19 +150,6 @@ export const createResponse = async (responseInput: TResponseInput): Promise<TRe
       tags: responsePrisma.tags.map((tagPrisma: { tag: TTag }) => tagPrisma.tag),
     };
 
-    responseCache.revalidate({
-      environmentId,
-      id: response.id,
-      contactId: contact?.id,
-      ...(singleUseId && { singleUseId }),
-      userId: userId ?? undefined,
-      surveyId,
-    });
-
-    responseNoteCache.revalidate({
-      responseId: response.id,
-    });
-
     if (IS_FORMBRICKS_CLOUD) {
       const responsesCount = await getMonthlyOrganizationResponseCount(organization.id);
       const responsesLimit = organization.billing.limits.monthly.responses;
@@ -200,51 +184,42 @@ export const createResponse = async (responseInput: TResponseInput): Promise<TRe
 };
 
 export const getResponsesByEnvironmentIds = reactCache(
-  async (environmentIds: string[], limit?: number, offset?: number): Promise<TResponse[]> =>
-    cache(
-      async () => {
-        validateInputs([environmentIds, ZId.array()], [limit, ZOptionalNumber], [offset, ZOptionalNumber]);
-        try {
-          const responses = await prisma.response.findMany({
-            where: {
-              survey: {
-                environmentId: { in: environmentIds },
-              },
-            },
-            select: responseSelection,
-            orderBy: [
-              {
-                createdAt: "desc",
-              },
-            ],
-            take: limit ? limit : undefined,
-            skip: offset ? offset : undefined,
-          });
+  async (environmentIds: string[], limit?: number, offset?: number): Promise<TResponse[]> => {
+    validateInputs([environmentIds, ZId.array()], [limit, ZOptionalNumber], [offset, ZOptionalNumber]);
+    try {
+      const responses = await prisma.response.findMany({
+        where: {
+          survey: {
+            environmentId: { in: environmentIds },
+          },
+        },
+        select: responseSelection,
+        orderBy: [
+          {
+            createdAt: "desc",
+          },
+        ],
+        take: limit ? limit : undefined,
+        skip: offset ? offset : undefined,
+      });
 
-          const transformedResponses: TResponse[] = await Promise.all(
-            responses.map((responsePrisma) => {
-              return {
-                ...responsePrisma,
-                contact: getResponseContact(responsePrisma),
-                tags: responsePrisma.tags.map((tagPrisma: { tag: TTag }) => tagPrisma.tag),
-              };
-            })
-          );
+      const transformedResponses: TResponse[] = await Promise.all(
+        responses.map((responsePrisma) => {
+          return {
+            ...responsePrisma,
+            contact: getResponseContact(responsePrisma),
+            tags: responsePrisma.tags.map((tagPrisma: { tag: TTag }) => tagPrisma.tag),
+          };
+        })
+      );
 
-          return transformedResponses;
-        } catch (error) {
-          if (error instanceof Prisma.PrismaClientKnownRequestError) {
-            throw new DatabaseError(error.message);
-          }
-
-          throw error;
-        }
-      },
-      environmentIds.map(
-        (environmentId) => `getResponses-management-api-${environmentId}-${limit}-${offset}`
-      ),
-      {
-        tags: environmentIds.map((environmentId) => responseCache.tag.byEnvironmentId(environmentId)),
+      return transformedResponses;
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError) {
+        throw new DatabaseError(error.message);
       }
-    )()
+
+      throw error;
+    }
+  }
 );

apps/web/app/api/v1/management/surveys/[surveyId]/lib/surveys.test.ts

@@ -1,6 +1,3 @@
-import { segmentCache } from "@/lib/cache/segment";
-import { responseCache } from "@/lib/response/cache";
-import { surveyCache } from "@/lib/survey/cache";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
@@ -9,22 +6,6 @@ import { logger } from "@formbricks/logger";
 import { DatabaseError } from "@formbricks/types/errors";
 import { deleteSurvey } from "./surveys";
 
-// Mock dependencies
-vi.mock("@/lib/cache/segment", () => ({
-  segmentCache: {
-    revalidate: vi.fn(),
-  },
-}));
-vi.mock("@/lib/response/cache", () => ({
-  responseCache: {
-    revalidate: vi.fn(),
-  },
-}));
-vi.mock("@/lib/survey/cache", () => ({
-  surveyCache: {
-    revalidate: vi.fn(),
-  },
-}));
 vi.mock("@/lib/utils/validate", () => ({
   validateInputs: vi.fn(),
 }));
@@ -91,14 +72,7 @@ describe("deleteSurvey", () => {
       },
     });
     expect(prisma.segment.delete).not.toHaveBeenCalled();
-    expect(segmentCache.revalidate).not.toHaveBeenCalled(); // No segment to revalidate
-    expect(responseCache.revalidate).toHaveBeenCalledWith({ surveyId, environmentId });
-    expect(surveyCache.revalidate).toHaveBeenCalledTimes(1); // Only for surveyId
-    expect(surveyCache.revalidate).toHaveBeenCalledWith({
-      id: surveyId,
-      environmentId,
-      resultShareKey: undefined,
-    });
+
     expect(deletedSurvey).toEqual(mockDeletedSurveyLink);
   });
 
@@ -112,9 +86,6 @@ describe("deleteSurvey", () => {
     await expect(deleteSurvey(surveyId)).rejects.toThrow(DatabaseError);
     expect(logger.error).toHaveBeenCalledWith({ error: prismaError, surveyId }, "Error deleting survey");
     expect(prisma.segment.delete).not.toHaveBeenCalled();
-    expect(segmentCache.revalidate).not.toHaveBeenCalled();
-    expect(responseCache.revalidate).not.toHaveBeenCalled();
-    expect(surveyCache.revalidate).not.toHaveBeenCalled();
   });
 
   test("should handle PrismaClientKnownRequestError during segment deletion", async () => {
@@ -128,7 +99,6 @@ describe("deleteSurvey", () => {
     await expect(deleteSurvey(surveyId)).rejects.toThrow(DatabaseError);
     expect(logger.error).toHaveBeenCalledWith({ error: prismaError, surveyId }, "Error deleting survey");
     expect(prisma.segment.delete).toHaveBeenCalledWith({ where: { id: segmentId } });
-    // Caches might have been partially revalidated before the error
   });
 
   test("should handle generic errors during deletion", async () => {
@@ -136,7 +106,7 @@ describe("deleteSurvey", () => {
     vi.mocked(prisma.survey.delete).mockRejectedValue(genericError);
 
     await expect(deleteSurvey(surveyId)).rejects.toThrow(genericError);
-    expect(logger.error).not.toHaveBeenCalled(); // Should not log generic errors here
+    expect(logger.error).not.toHaveBeenCalled();
     expect(prisma.segment.delete).not.toHaveBeenCalled();
   });
 

apps/web/app/api/v1/management/surveys/[surveyId]/lib/surveys.ts

@@ -1,6 +1,3 @@
-import { segmentCache } from "@/lib/cache/segment";
-import { responseCache } from "@/lib/response/cache";
-import { surveyCache } from "@/lib/survey/cache";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
 import { z } from "zod";
@@ -27,44 +24,13 @@ export const deleteSurvey = async (surveyId: string) => {
     });
 
     if (deletedSurvey.type === "app" && deletedSurvey.segment?.isPrivate) {
-      const deletedSegment = await prisma.segment.delete({
+      await prisma.segment.delete({
         where: {
           id: deletedSurvey.segment.id,
         },
       });
-
-      if (deletedSegment) {
-        segmentCache.revalidate({
-          id: deletedSegment.id,
-          environmentId: deletedSurvey.environmentId,
-        });
-      }
     }
 
-    responseCache.revalidate({
-      surveyId,
-      environmentId: deletedSurvey.environmentId,
-    });
-    surveyCache.revalidate({
-      id: deletedSurvey.id,
-      environmentId: deletedSurvey.environmentId,
-      resultShareKey: deletedSurvey.resultShareKey ?? undefined,
-    });
-
-    if (deletedSurvey.segment?.id) {
-      segmentCache.revalidate({
-        id: deletedSurvey.segment.id,
-        environmentId: deletedSurvey.environmentId,
-      });
-    }
-
-    // Revalidate public triggers by actionClassId
-    deletedSurvey.triggers.forEach((trigger) => {
-      surveyCache.revalidate({
-        actionClassId: trigger.actionClass.id,
-      });
-    });
-
     return deletedSurvey;
   } catch (error) {
     if (error instanceof Prisma.PrismaClientKnownRequestError) {

apps/web/app/api/v1/management/surveys/lib/surveys.test.ts

@@ -1,4 +1,3 @@
-import { cache } from "@/lib/cache";
 import { selectSurvey } from "@/lib/survey/service";
 import { transformPrismaSurvey } from "@/lib/survey/utils";
 import { validateInputs } from "@/lib/utils/validate";
@@ -11,8 +10,6 @@ import { TSurvey } from "@formbricks/types/surveys/types";
 import { getSurveys } from "./surveys";
 
 // Mock dependencies
-vi.mock("@/lib/cache");
-vi.mock("@/lib/survey/cache");
 vi.mock("@/lib/survey/utils");
 vi.mock("@/lib/utils/validate");
 vi.mock("@formbricks/database", () => ({
@@ -75,10 +72,6 @@ const mockSurveyTransformed3: TSurvey = {
 describe("getSurveys (Management API)", () => {
   beforeEach(() => {
     vi.resetAllMocks();
-    // Mock the cache function to simply execute the underlying function
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
     vi.mocked(transformPrismaSurvey).mockImplementation((survey) => ({
       ...survey,
       displayPercentage: null,
@@ -112,7 +105,6 @@ describe("getSurveys (Management API)", () => {
     expect(transformPrismaSurvey).toHaveBeenCalledTimes(1);
     expect(transformPrismaSurvey).toHaveBeenCalledWith(mockSurveyPrisma2);
     expect(surveys).toEqual([mockSurveyTransformed2]);
-    expect(cache).toHaveBeenCalledTimes(1);
   });
 
   test("should return surveys for multiple environment IDs without limit and offset", async () => {
@@ -138,7 +130,6 @@ describe("getSurveys (Management API)", () => {
     });
     expect(transformPrismaSurvey).toHaveBeenCalledTimes(3);
     expect(surveys).toEqual([mockSurveyTransformed1, mockSurveyTransformed2, mockSurveyTransformed3]);
-    expect(cache).toHaveBeenCalledTimes(1);
   });
 
   test("should return an empty array if no surveys are found", async () => {
@@ -149,7 +140,6 @@ describe("getSurveys (Management API)", () => {
     expect(prisma.survey.findMany).toHaveBeenCalled();
     expect(transformPrismaSurvey).not.toHaveBeenCalled();
     expect(surveys).toEqual([]);
-    expect(cache).toHaveBeenCalledTimes(1);
   });
 
   test("should handle PrismaClientKnownRequestError", async () => {
@@ -161,7 +151,6 @@ describe("getSurveys (Management API)", () => {
 
     await expect(getSurveys([environmentId1])).rejects.toThrow(DatabaseError);
     expect(logger.error).toHaveBeenCalledWith(prismaError, "Error getting surveys");
-    expect(cache).toHaveBeenCalledTimes(1);
   });
 
   test("should handle generic errors", async () => {
@@ -170,7 +159,6 @@ describe("getSurveys (Management API)", () => {
 
     await expect(getSurveys([environmentId1])).rejects.toThrow(genericError);
     expect(logger.error).not.toHaveBeenCalled();
-    expect(cache).toHaveBeenCalledTimes(1);
   });
 
   test("should throw validation error for invalid input", async () => {
@@ -182,6 +170,5 @@ describe("getSurveys (Management API)", () => {
 
     await expect(getSurveys([invalidEnvId])).rejects.toThrow(validationError);
     expect(prisma.survey.findMany).not.toHaveBeenCalled();
-    expect(cache).toHaveBeenCalledTimes(1); // Cache wrapper is still called
   });
 });

apps/web/app/api/v1/management/surveys/lib/surveys.ts

@@ -1,6 +1,4 @@
 import "server-only";
-import { cache } from "@/lib/cache";
-import { surveyCache } from "@/lib/survey/cache";
 import { selectSurvey } from "@/lib/survey/service";
 import { transformPrismaSurvey } from "@/lib/survey/utils";
 import { validateInputs } from "@/lib/utils/validate";
@@ -8,41 +6,33 @@ import { Prisma } from "@prisma/client";
 import { cache as reactCache } from "react";
 import { prisma } from "@formbricks/database";
 import { logger } from "@formbricks/logger";
-import { ZOptionalNumber } from "@formbricks/types/common";
-import { ZId } from "@formbricks/types/common";
+import { ZId, ZOptionalNumber } from "@formbricks/types/common";
 import { DatabaseError } from "@formbricks/types/errors";
 import { TSurvey } from "@formbricks/types/surveys/types";
 
 export const getSurveys = reactCache(
-  async (environmentIds: string[], limit?: number, offset?: number): Promise<TSurvey[]> =>
-    cache(
-      async () => {
-        validateInputs([environmentIds, ZId.array()], [limit, ZOptionalNumber], [offset, ZOptionalNumber]);
+  async (environmentIds: string[], limit?: number, offset?: number): Promise<TSurvey[]> => {
+    validateInputs([environmentIds, ZId.array()], [limit, ZOptionalNumber], [offset, ZOptionalNumber]);
 
-        try {
-          const surveysPrisma = await prisma.survey.findMany({
-            where: {
-              environmentId: { in: environmentIds },
-            },
-            select: selectSurvey,
-            orderBy: {
-              updatedAt: "desc",
-            },
-            take: limit,
-            skip: offset,
-          });
-          return surveysPrisma.map((surveyPrisma) => transformPrismaSurvey<TSurvey>(surveyPrisma));
-        } catch (error) {
-          if (error instanceof Prisma.PrismaClientKnownRequestError) {
-            logger.error(error, "Error getting surveys");
-            throw new DatabaseError(error.message);
-          }
-          throw error;
-        }
-      },
-      environmentIds.map((environmentId) => `getSurveys-management-api-${environmentId}-${limit}-${offset}`),
-      {
-        tags: environmentIds.map((environmentId) => surveyCache.tag.byEnvironmentId(environmentId)),
+    try {
+      const surveysPrisma = await prisma.survey.findMany({
+        where: {
+          environmentId: { in: environmentIds },
+        },
+        select: selectSurvey,
+        orderBy: {
+          updatedAt: "desc",
+        },
+        take: limit,
+        skip: offset,
+      });
+      return surveysPrisma.map((surveyPrisma) => transformPrismaSurvey<TSurvey>(surveyPrisma));
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError) {
+        logger.error(error, "Error getting surveys");
+        throw new DatabaseError(error.message);
       }
-    )()
+      throw error;
+    }
+  }
 );

apps/web/app/api/v1/webhooks/[webhookId]/lib/webhook.test.ts

@@ -1,4 +1,3 @@
-import { webhookCache } from "@/lib/cache/webhook";
 import { Prisma, Webhook } from "@prisma/client";
 import { cleanup } from "@testing-library/react";
 import { afterEach, describe, expect, test, vi } from "vitest";
@@ -15,15 +14,6 @@ vi.mock("@formbricks/database", () => ({
   },
 }));
 
-vi.mock("@/lib/cache/webhook", () => ({
-  webhookCache: {
-    tag: {
-      byId: () => "mockTag",
-    },
-    revalidate: vi.fn(),
-  },
-}));
-
 vi.mock("@/lib/utils/validate", () => ({
   validateInputs: vi.fn(),
   ValidationError: class ValidationError extends Error {
@@ -34,11 +24,6 @@ vi.mock("@/lib/utils/validate", () => ({
   },
 }));
 
-vi.mock("@/lib/cache", () => ({
-  // Accept any function and return the exact same generic Fn – keeps typings intact
-  cache: <T extends (...args: any[]) => any>(fn: T): T => fn,
-}));
-
 describe("deleteWebhook", () => {
   afterEach(() => {
     cleanup();
@@ -68,10 +53,9 @@ describe("deleteWebhook", () => {
         id: "test-webhook-id",
       },
     });
-    expect(webhookCache.revalidate).toHaveBeenCalled();
   });
 
-  test("should delete the webhook and call webhookCache.revalidate with correct parameters", async () => {
+  test("should delete the webhook", async () => {
     const mockedWebhook: Webhook = {
       id: "test-webhook-id",
       url: "https://example.com",
@@ -94,11 +78,6 @@ describe("deleteWebhook", () => {
         id: "test-webhook-id",
       },
     });
-    expect(webhookCache.revalidate).toHaveBeenCalledWith({
-      id: mockedWebhook.id,
-      environmentId: mockedWebhook.environmentId,
-      source: mockedWebhook.source,
-    });
   });
 
   test("should throw an error when called with an invalid webhook ID format", async () => {
@@ -110,7 +89,6 @@ describe("deleteWebhook", () => {
     await expect(deleteWebhook("invalid-id")).rejects.toThrow(ValidationError);
 
     expect(prisma.webhook.delete).not.toHaveBeenCalled();
-    expect(webhookCache.revalidate).not.toHaveBeenCalled();
   });
 
   test("should throw ResourceNotFoundError when webhook does not exist", async () => {
@@ -122,7 +100,6 @@ describe("deleteWebhook", () => {
     vi.mocked(prisma.webhook.delete).mockRejectedValueOnce(prismaError);
 
     await expect(deleteWebhook("non-existent-id")).rejects.toThrow(ResourceNotFoundError);
-    expect(webhookCache.revalidate).not.toHaveBeenCalled();
   });
 
   test("should throw DatabaseError when database operation fails", async () => {
@@ -134,14 +111,12 @@ describe("deleteWebhook", () => {
     vi.mocked(prisma.webhook.delete).mockRejectedValueOnce(prismaError);
 
     await expect(deleteWebhook("test-webhook-id")).rejects.toThrow(DatabaseError);
-    expect(webhookCache.revalidate).not.toHaveBeenCalled();
   });
 
   test("should throw DatabaseError when an unknown error occurs", async () => {
     vi.mocked(prisma.webhook.delete).mockRejectedValueOnce(new Error("Unknown error"));
 
     await expect(deleteWebhook("test-webhook-id")).rejects.toThrow(DatabaseError);
-    expect(webhookCache.revalidate).not.toHaveBeenCalled();
   });
 });
 

apps/web/app/api/v1/webhooks/[webhookId]/lib/webhook.ts

@@ -1,12 +1,9 @@
-import { cache } from "@/lib/cache";
-import { webhookCache } from "@/lib/cache/webhook";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma, Webhook } from "@prisma/client";
 import { prisma } from "@formbricks/database";
 import { PrismaErrorType } from "@formbricks/database/types/error";
 import { ZId } from "@formbricks/types/common";
-import { DatabaseError } from "@formbricks/types/errors";
-import { ResourceNotFoundError } from "@formbricks/types/errors";
+import { DatabaseError, ResourceNotFoundError } from "@formbricks/types/errors";
 
 export const deleteWebhook = async (id: string): Promise<Webhook> => {
   validateInputs([id, ZId]);
@@ -18,12 +15,6 @@ export const deleteWebhook = async (id: string): Promise<Webhook> => {
       },
     });
 
-    webhookCache.revalidate({
-      id: deletedWebhook.id,
-      environmentId: deletedWebhook.environmentId,
-      source: deletedWebhook.source,
-    });
-
     return deletedWebhook;
   } catch (error) {
     if (
@@ -36,28 +27,21 @@ export const deleteWebhook = async (id: string): Promise<Webhook> => {
   }
 };
 
-export const getWebhook = async (id: string): Promise<Webhook | null> =>
-  cache(
-    async () => {
-      validateInputs([id, ZId]);
+export const getWebhook = async (id: string): Promise<Webhook | null> => {
+  validateInputs([id, ZId]);
 
-      try {
-        const webhook = await prisma.webhook.findUnique({
-          where: {
-            id,
-          },
-        });
-        return webhook;
-      } catch (error) {
-        if (error instanceof Prisma.PrismaClientKnownRequestError) {
-          throw new DatabaseError(error.message);
-        }
-
-        throw error;
-      }
-    },
-    [`getWebhook-${id}`],
-    {
-      tags: [webhookCache.tag.byId(id)],
+  try {
+    const webhook = await prisma.webhook.findUnique({
+      where: {
+        id,
+      },
+    });
+    return webhook;
+  } catch (error) {
+    if (error instanceof Prisma.PrismaClientKnownRequestError) {
+      throw new DatabaseError(error.message);
     }
-  )();
+
+    throw error;
+  }
+};

apps/web/app/api/v1/webhooks/lib/webhook.test.ts

@@ -1,6 +1,5 @@
 import { createWebhook } from "@/app/api/v1/webhooks/lib/webhook";
 import { TWebhookInput } from "@/app/api/v1/webhooks/types/webhooks";
-import { webhookCache } from "@/lib/cache/webhook";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma, WebhookSource } from "@prisma/client";
 import { cleanup } from "@testing-library/react";
@@ -16,12 +15,6 @@ vi.mock("@formbricks/database", () => ({
   },
 }));
 
-vi.mock("@/lib/cache/webhook", () => ({
-  webhookCache: {
-    revalidate: vi.fn(),
-  },
-}));
-
 vi.mock("@/lib/utils/validate", () => ({
   validateInputs: vi.fn(),
 }));
@@ -31,7 +24,7 @@ describe("createWebhook", () => {
     cleanup();
   });
 
-  test("should create a webhook and revalidate the cache when provided with valid input data", async () => {
+  test("should create a webhook", async () => {
     const webhookInput: TWebhookInput = {
       environmentId: "test-env-id",
       name: "Test Webhook",
@@ -74,12 +67,6 @@ describe("createWebhook", () => {
       },
     });
 
-    expect(webhookCache.revalidate).toHaveBeenCalledWith({
-      id: createdWebhook.id,
-      environmentId: createdWebhook.environmentId,
-      source: createdWebhook.source,
-    });
-
     expect(result).toEqual(createdWebhook);
   });
 
@@ -120,39 +107,6 @@ describe("createWebhook", () => {
     await expect(createWebhook(webhookInput)).rejects.toThrowError(DatabaseError);
   });
 
-  test("should call webhookCache.revalidate with the correct parameters after successfully creating a webhook", async () => {
-    const webhookInput: TWebhookInput = {
-      environmentId: "env-id",
-      name: "Test Webhook",
-      url: "https://example.com",
-      source: "user",
-      triggers: ["responseCreated"],
-      surveyIds: ["survey1"],
-    };
-
-    const createdWebhook = {
-      id: "webhook123",
-      environmentId: "env-id",
-      name: "Test Webhook",
-      url: "https://example.com",
-      source: "user",
-      triggers: ["responseCreated"],
-      surveyIds: ["survey1"],
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    } as any;
-
-    vi.mocked(prisma.webhook.create).mockResolvedValueOnce(createdWebhook);
-
-    await createWebhook(webhookInput);
-
-    expect(webhookCache.revalidate).toHaveBeenCalledWith({
-      id: createdWebhook.id,
-      environmentId: createdWebhook.environmentId,
-      source: createdWebhook.source,
-    });
-  });
-
   test("should throw a DatabaseError when provided with invalid surveyIds", async () => {
     const webhookInput: TWebhookInput = {
       environmentId: "test-env-id",
@@ -197,7 +151,5 @@ describe("createWebhook", () => {
         },
       },
     });
-
-    expect(webhookCache.revalidate).not.toHaveBeenCalled();
   });
 });

apps/web/app/api/v1/webhooks/lib/webhook.ts

@@ -1,6 +1,4 @@
 import { TWebhookInput, ZWebhookInput } from "@/app/api/v1/webhooks/types/webhooks";
-import { cache } from "@/lib/cache";
-import { webhookCache } from "@/lib/cache/webhook";
 import { ITEMS_PER_PAGE } from "@/lib/constants";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma, Webhook } from "@prisma/client";
@@ -27,12 +25,6 @@ export const createWebhook = async (webhookInput: TWebhookInput): Promise<Webhoo
       },
     });
 
-    webhookCache.revalidate({
-      id: createdWebhook.id,
-      environmentId: createdWebhook.environmentId,
-      source: createdWebhook.source,
-    });
-
     return createdWebhook;
   } catch (error) {
     if (error instanceof Prisma.PrismaClientKnownRequestError) {
@@ -49,30 +41,23 @@ export const createWebhook = async (webhookInput: TWebhookInput): Promise<Webhoo
   }
 };
 
-export const getWebhooks = (environmentIds: string[], page?: number): Promise<Webhook[]> =>
-  cache(
-    async () => {
-      validateInputs([environmentIds, ZId.array()], [page, ZOptionalNumber]);
+export const getWebhooks = async (environmentIds: string[], page?: number): Promise<Webhook[]> => {
+  validateInputs([environmentIds, ZId.array()], [page, ZOptionalNumber]);
 
-      try {
-        const webhooks = await prisma.webhook.findMany({
-          where: {
-            environmentId: { in: environmentIds },
-          },
-          take: page ? ITEMS_PER_PAGE : undefined,
-          skip: page ? ITEMS_PER_PAGE * (page - 1) : undefined,
-        });
-        return webhooks;
-      } catch (error) {
-        if (error instanceof Prisma.PrismaClientKnownRequestError) {
-          throw new DatabaseError(error.message);
-        }
-
-        throw error;
-      }
-    },
-    environmentIds.map((environmentId) => `getWebhooks-${environmentId}-${page}`),
-    {
-      tags: environmentIds.map((environmentId) => webhookCache.tag.byEnvironmentId(environmentId)),
+  try {
+    const webhooks = await prisma.webhook.findMany({
+      where: {
+        environmentId: { in: environmentIds },
+      },
+      take: page ? ITEMS_PER_PAGE : undefined,
+      skip: page ? ITEMS_PER_PAGE * (page - 1) : undefined,
+    });
+    return webhooks;
+  } catch (error) {
+    if (error instanceof Prisma.PrismaClientKnownRequestError) {
+      throw new DatabaseError(error.message);
     }
-  )();
+
+    throw error;
+  }
+};

apps/web/app/api/v2/client/[environmentId]/displays/lib/contact.test.ts

@@ -1,5 +1,3 @@
-import { cache } from "@/lib/cache";
-import { contactCache } from "@/lib/cache/contact";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { prisma } from "@formbricks/database";
 import { doesContactExist } from "./contact";
@@ -13,16 +11,6 @@ vi.mock("@formbricks/database", () => ({
   },
 }));
 
-// Mock cache module
-vi.mock("@/lib/cache");
-vi.mock("@/lib/cache/contact", () => ({
-  contactCache: {
-    tag: {
-      byId: vi.fn((id) => `contact-${id}`),
-    },
-  },
-}));
-
 // Mock react cache
 vi.mock("react", async () => {
   const actual = await vi.importActual("react");
@@ -35,12 +23,6 @@ vi.mock("react", async () => {
 const contactId = "test-contact-id";
 
 describe("doesContactExist", () => {
-  beforeEach(() => {
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-  });
-
   afterEach(() => {
     vi.resetAllMocks();
   });
@@ -55,9 +37,6 @@ describe("doesContactExist", () => {
       where: { id: contactId },
       select: { id: true },
     });
-    expect(cache).toHaveBeenCalledWith(expect.any(Function), [`doesContactExistDisplaysApiV2-${contactId}`], {
-      tags: [contactCache.tag.byId(contactId)],
-    });
   });
 
   test("should return false if contact does not exist", async () => {
@@ -70,8 +49,5 @@ describe("doesContactExist", () => {
       where: { id: contactId },
       select: { id: true },
     });
-    expect(cache).toHaveBeenCalledWith(expect.any(Function), [`doesContactExistDisplaysApiV2-${contactId}`], {
-      tags: [contactCache.tag.byId(contactId)],
-    });
   });
 });

apps/web/app/api/v2/client/[environmentId]/displays/lib/contact.ts

@@ -1,26 +1,15 @@
-import { cache } from "@/lib/cache";
-import { contactCache } from "@/lib/cache/contact";
 import { cache as reactCache } from "react";
 import { prisma } from "@formbricks/database";
 
-export const doesContactExist = reactCache(
-  (id: string): Promise<boolean> =>
-    cache(
-      async () => {
-        const contact = await prisma.contact.findFirst({
-          where: {
-            id,
-          },
-          select: {
-            id: true,
-          },
-        });
+export const doesContactExist = reactCache(async (id: string): Promise<boolean> => {
+  const contact = await prisma.contact.findFirst({
+    where: {
+      id,
+    },
+    select: {
+      id: true,
+    },
+  });
 
-        return !!contact;
-      },
-      [`doesContactExistDisplaysApiV2-${id}`],
-      {
-        tags: [contactCache.tag.byId(id)],
-      }
-    )()
-);
+  return !!contact;
+});

apps/web/app/api/v2/client/[environmentId]/displays/lib/display.test.ts

@@ -1,4 +1,3 @@
-import { displayCache } from "@/lib/display/cache";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
 import { beforeEach, describe, expect, test, vi } from "vitest";
@@ -8,13 +7,6 @@ import { TDisplayCreateInputV2 } from "../types/display";
 import { doesContactExist } from "./contact";
 import { createDisplay } from "./display";
 
-// Mock dependencies
-vi.mock("@/lib/display/cache", () => ({
-  displayCache: {
-    revalidate: vi.fn(),
-  },
-}));
-
 vi.mock("@/lib/utils/validate", () => ({
   validateInputs: vi.fn((inputs) => inputs.map((input) => input[0])), // Pass through validation for testing
 }));
@@ -79,12 +71,6 @@ describe("createDisplay", () => {
       },
       select: { id: true, contactId: true, surveyId: true },
     });
-    expect(displayCache.revalidate).toHaveBeenCalledWith({
-      id: displayId,
-      contactId,
-      surveyId,
-      environmentId,
-    });
     expect(result).toEqual(mockDisplay); // Changed this line
   });
 
@@ -101,12 +87,6 @@ describe("createDisplay", () => {
       },
       select: { id: true, contactId: true, surveyId: true },
     });
-    expect(displayCache.revalidate).toHaveBeenCalledWith({
-      id: displayId,
-      contactId: null,
-      surveyId,
-      environmentId,
-    });
     expect(result).toEqual(mockDisplayWithoutContact); // Changed this line
   });
 
@@ -125,12 +105,6 @@ describe("createDisplay", () => {
       },
       select: { id: true, contactId: true, surveyId: true },
     });
-    expect(displayCache.revalidate).toHaveBeenCalledWith({
-      id: displayId,
-      contactId: null, // Assuming prisma returns null if contact wasn't connected
-      surveyId,
-      environmentId,
-    });
     expect(result).toEqual(mockDisplayWithoutContact); // Changed this line
   });
 
@@ -143,7 +117,6 @@ describe("createDisplay", () => {
     await expect(createDisplay(displayInput)).rejects.toThrow(ValidationError);
     expect(doesContactExist).not.toHaveBeenCalled();
     expect(prisma.display.create).not.toHaveBeenCalled();
-    expect(displayCache.revalidate).not.toHaveBeenCalled();
   });
 
   test("should throw DatabaseError on Prisma known request error", async () => {
@@ -155,7 +128,6 @@ describe("createDisplay", () => {
     vi.mocked(prisma.display.create).mockRejectedValue(prismaError);
 
     await expect(createDisplay(displayInput)).rejects.toThrow(DatabaseError);
-    expect(displayCache.revalidate).not.toHaveBeenCalled();
   });
 
   test("should throw original error on other errors during creation", async () => {
@@ -164,7 +136,6 @@ describe("createDisplay", () => {
     vi.mocked(prisma.display.create).mockRejectedValue(genericError);
 
     await expect(createDisplay(displayInput)).rejects.toThrow(genericError);
-    expect(displayCache.revalidate).not.toHaveBeenCalled();
   });
 
   test("should throw original error if doesContactExist fails", async () => {
@@ -173,6 +144,5 @@ describe("createDisplay", () => {
 
     await expect(createDisplay(displayInput)).rejects.toThrow(contactCheckError);
     expect(prisma.display.create).not.toHaveBeenCalled();
-    expect(displayCache.revalidate).not.toHaveBeenCalled();
   });
 });

apps/web/app/api/v2/client/[environmentId]/displays/lib/display.ts

@@ -2,7 +2,6 @@ import {
   TDisplayCreateInputV2,
   ZDisplayCreateInputV2,
 } from "@/app/api/v2/client/[environmentId]/displays/types/display";
-import { displayCache } from "@/lib/display/cache";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
 import { prisma } from "@formbricks/database";
@@ -12,7 +11,7 @@ import { doesContactExist } from "./contact";
 export const createDisplay = async (displayInput: TDisplayCreateInputV2): Promise<{ id: string }> => {
   validateInputs([displayInput, ZDisplayCreateInputV2]);
 
-  const { environmentId, contactId, surveyId } = displayInput;
+  const { contactId, surveyId } = displayInput;
 
   try {
     const contactExists = contactId ? await doesContactExist(contactId) : false;
@@ -36,13 +35,6 @@ export const createDisplay = async (displayInput: TDisplayCreateInputV2): Promis
       select: { id: true, contactId: true, surveyId: true },
     });
 
-    displayCache.revalidate({
-      id: display.id,
-      contactId: display.contactId,
-      surveyId: display.surveyId,
-      environmentId,
-    });
-
     return display;
   } catch (error) {
     if (error instanceof Prisma.PrismaClientKnownRequestError) {

apps/web/app/api/v2/client/[environmentId]/displays/route.ts

@@ -14,7 +14,13 @@ interface Context {
 }
 
 export const OPTIONS = async (): Promise<Response> => {
-  return responses.successResponse({}, true);
+  return responses.successResponse(
+    {},
+    true,
+    // Cache CORS preflight responses for 1 hour (conservative approach)
+    // Balances performance gains with flexibility for CORS policy changes
+    "public, s-maxage=3600, max-age=3600"
+  );
 };
 
 export const POST = async (request: Request, context: Context): Promise<Response> => {

apps/web/app/api/v2/client/[environmentId]/responses/lib/contact.test.ts

@@ -1,4 +1,3 @@
-import { cache } from "@/lib/cache";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { prisma } from "@formbricks/database";
 import { TContactAttributes } from "@formbricks/types/contact-attribute";
@@ -13,8 +12,6 @@ vi.mock("@formbricks/database", () => ({
   },
 }));
 
-vi.mock("@/lib/cache");
-
 const contactId = "test-contact-id";
 const mockContact = {
   id: contactId,
@@ -30,12 +27,6 @@ const expectedContactAttributes: TContactAttributes = {
 };
 
 describe("getContact", () => {
-  beforeEach(() => {
-    vi.mocked(cache).mockImplementation((fn) => async () => {
-      return fn();
-    });
-  });
-
   test("should return contact with formatted attributes when found", async () => {
     vi.mocked(prisma.contact.findUnique).mockResolvedValue(mockContact);
 
@@ -57,8 +48,6 @@ describe("getContact", () => {
       id: contactId,
       attributes: expectedContactAttributes,
     });
-    // Check if cache wrapper was called (though mocked to pass through)
-    expect(cache).toHaveBeenCalled();
   });
 
   test("should return null when contact is not found", async () => {
@@ -79,7 +68,5 @@ describe("getContact", () => {
       },
     });
     expect(result).toBeNull();
-    // Check if cache wrapper was called (though mocked to pass through)
-    expect(cache).toHaveBeenCalled();
   });
 });

apps/web/app/api/v2/client/[environmentId]/responses/lib/contact.ts

@@ -1,42 +1,32 @@
-import { cache } from "@/lib/cache";
-import { contactCache } from "@/lib/cache/contact";
 import { cache as reactCache } from "react";
 import { prisma } from "@formbricks/database";
 import { TContactAttributes } from "@formbricks/types/contact-attribute";
 
-export const getContact = reactCache((contactId: string) =>
-  cache(
-    async () => {
-      const contact = await prisma.contact.findUnique({
-        where: { id: contactId },
+export const getContact = reactCache(async (contactId: string) => {
+  const contact = await prisma.contact.findUnique({
+    where: { id: contactId },
+    select: {
+      id: true,
+      attributes: {
         select: {
-          id: true,
-          attributes: {
-            select: {
-              attributeKey: { select: { key: true } },
-              value: true,
-            },
-          },
+          attributeKey: { select: { key: true } },
+          value: true,
         },
-      });
-
-      if (!contact) {
-        return null;
-      }
-
-      const contactAttributes = contact.attributes.reduce((acc, attr) => {
-        acc[attr.attributeKey.key] = attr.value;
-        return acc;
-      }, {}) as TContactAttributes;
-
-      return {
-        id: contact.id,
-        attributes: contactAttributes,
-      };
+      },
     },
-    [`getContact-responses-api-${contactId}`],
-    {
-      tags: [contactCache.tag.byId(contactId)],
-    }
-  )()
-);
+  });
+
+  if (!contact) {
+    return null;
+  }
+
+  const contactAttributes = contact.attributes.reduce((acc, attr) => {
+    acc[attr.attributeKey.key] = attr.value;
+    return acc;
+  }, {}) as TContactAttributes;
+
+  return {
+    id: contact.id,
+    attributes: contactAttributes,
+  };
+});

apps/web/app/api/v2/client/[environmentId]/responses/lib/organization.test.ts

@@ -16,19 +16,6 @@ vi.mock("@formbricks/logger", () => ({
     error: vi.fn(),
   },
 }));
-vi.mock("@/lib/cache", () => ({
-  cache: (fn: any) => fn,
-}));
-vi.mock("@/lib/organization/cache", () => ({
-  organizationCache: {
-    tag: {
-      byEnvironmentId: (id: string) => `tag-${id}`,
-    },
-  },
-}));
-vi.mock("react", () => ({
-  cache: (fn: any) => fn,
-}));
 
 describe("getOrganizationBillingByEnvironmentId", () => {
   const environmentId = "env-123";

apps/web/app/api/v2/client/[environmentId]/responses/lib/organization.ts

@@ -1,45 +1,36 @@
-import { cache } from "@/lib/cache";
-import { organizationCache } from "@/lib/organization/cache";
 import { Organization } from "@prisma/client";
 import { cache as reactCache } from "react";
 import { prisma } from "@formbricks/database";
 import { logger } from "@formbricks/logger";
 
 export const getOrganizationBillingByEnvironmentId = reactCache(
-  async (environmentId: string): Promise<Organization["billing"] | null> =>
-    cache(
-      async () => {
-        try {
-          const organization = await prisma.organization.findFirst({
-            where: {
-              projects: {
+  async (environmentId: string): Promise<Organization["billing"] | null> => {
+    try {
+      const organization = await prisma.organization.findFirst({
+        where: {
+          projects: {
+            some: {
+              environments: {
                 some: {
-                  environments: {
-                    some: {
-                      id: environmentId,
-                    },
-                  },
+                  id: environmentId,
                 },
               },
             },
-            select: {
-              billing: true,
-            },
-          });
+          },
+        },
+        select: {
+          billing: true,
+        },
+      });
 
-          if (!organization) {
-            return null;
-          }
-
-          return organization.billing;
-        } catch (error) {
-          logger.error(error, "Failed to get organization billing by environment ID");
-          return null;
-        }
-      },
-      [`api-v2-client-getOrganizationBillingByEnvironmentId-${environmentId}`],
-      {
-        tags: [organizationCache.tag.byEnvironmentId(environmentId)],
+      if (!organization) {
+        return null;
       }
-    )()
+
+      return organization.billing;
+    } catch (error) {
+      logger.error(error, "Failed to get organization billing by environment ID");
+      return null;
+    }
+  }
 );

apps/web/app/api/v2/client/[environmentId]/responses/lib/response.test.ts

@@ -4,9 +4,7 @@ import {
   getOrganizationByEnvironmentId,
 } from "@/lib/organization/service";
 import { sendPlanLimitsReachedEventToPosthogWeekly } from "@/lib/posthogServer";
-import { responseCache } from "@/lib/response/cache";
 import { calculateTtcTotal } from "@/lib/response/utils";
-import { responseNoteCache } from "@/lib/responseNote/cache";
 import { captureTelemetry } from "@/lib/telemetry";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
@@ -50,9 +48,7 @@ vi.mock("@/lib/constants", () => ({
 
 vi.mock("@/lib/organization/service");
 vi.mock("@/lib/posthogServer");
-vi.mock("@/lib/response/cache");
 vi.mock("@/lib/response/utils");
-vi.mock("@/lib/responseNote/cache");
 vi.mock("@/lib/telemetry");
 vi.mock("@/lib/utils/validate");
 vi.mock("@formbricks/database", () => ({
@@ -138,8 +134,6 @@ describe("createResponse V2", () => {
       ...ttc,
       _total: Object.values(ttc).reduce((a, b) => a + b, 0),
     }));
-    vi.mocked(responseCache.revalidate).mockResolvedValue(undefined);
-    vi.mocked(responseNoteCache.revalidate).mockResolvedValue(undefined);
     vi.mocked(captureTelemetry).mockResolvedValue(undefined);
     vi.mocked(getMonthlyOrganizationResponseCount).mockResolvedValue(50);
     vi.mocked(sendPlanLimitsReachedEventToPosthogWeekly).mockResolvedValue(undefined);

apps/web/app/api/v2/client/[environmentId]/responses/lib/response.ts

@@ -7,9 +7,7 @@ import {
   getOrganizationByEnvironmentId,
 } from "@/lib/organization/service";
 import { sendPlanLimitsReachedEventToPosthogWeekly } from "@/lib/posthogServer";
-import { responseCache } from "@/lib/response/cache";
 import { calculateTtcTotal } from "@/lib/response/utils";
-import { responseNoteCache } from "@/lib/responseNote/cache";
 import { captureTelemetry } from "@/lib/telemetry";
 import { validateInputs } from "@/lib/utils/validate";
 import { Prisma } from "@prisma/client";
@@ -44,7 +42,6 @@ export const createResponse = async (responseInput: TResponseInputV2): Promise<T
 
   try {
     let contact: { id: string; attributes: TContactAttributes } | null = null;
-    let userId: string | undefined = undefined;
 
     const organization = await getOrganizationByEnvironmentId(environmentId);
     if (!organization) {
@@ -53,7 +50,6 @@ export const createResponse = async (responseInput: TResponseInputV2): Promise<T
 
     if (contactId) {
       contact = await getContact(contactId);
-      userId = contact?.attributes.userId;
     }
 
     const ttc = initialTtc ? (finished ? calculateTtcTotal(initialTtc) : initialTtc) : {};
@@ -101,19 +97,6 @@ export const createResponse = async (responseInput: TResponseInputV2): Promise<T
       tags: responsePrisma.tags.map((tagPrisma: { tag: TTag }) => tagPrisma.tag),
     };
 
-    responseCache.revalidate({
-      environmentId,
-      id: response.id,
-      contactId: contact?.id,
-      ...(singleUseId && { singleUseId }),
-      userId,
-      surveyId,
-    });
-
-    responseNoteCache.revalidate({
-      responseId: response.id,
-    });
-
     if (IS_FORMBRICKS_CLOUD) {
       const responsesCount = await getMonthlyOrganizationResponseCount(organization.id);
       const responsesLimit = organization.billing.limits.monthly.responses;

apps/web/app/api/v2/client/[environmentId]/responses/route.ts

@@ -22,7 +22,13 @@ interface Context {
 }
 
 export const OPTIONS = async (): Promise<Response> => {
-  return responses.successResponse({}, true);
+  return responses.successResponse(
+    {},
+    true,
+    // Cache CORS preflight responses for 1 hour (conservative approach)
+    // Balances performance gains with flexibility for CORS policy changes
+    "public, s-maxage=3600, max-age=3600"
+  );
 };
 
 export const POST = async (request: Request, context: Context): Promise<Response> => {

apps/web/app/lib/survey-builder.ts

@@ -56,15 +56,15 @@ export const buildMultipleChoiceQuestion = ({
   return {
     id: id ?? createId(),
     type,
-    subheader: subheader ? { default: subheader } : undefined,
-    headline: { default: headline },
+    subheader: subheader ? createI18nString(subheader, []) : undefined,
+    headline: createI18nString(headline, []),
     choices: choices.map((choice, index) => {
       const isLastIndex = index === choices.length - 1;
       const id = containsOther && isLastIndex ? "other" : choiceIds ? choiceIds[index] : createId();
-      return { id, label: { default: choice } };
+      return { id, label: createI18nString(choice, []) };
     }),
-    buttonLabel: { default: buttonLabel || t(defaultButtonLabel) },
-    backButtonLabel: { default: backButtonLabel || t(defaultBackButtonLabel) },
+    buttonLabel: createI18nString(buttonLabel || t(defaultButtonLabel), []),
+    backButtonLabel: createI18nString(backButtonLabel || t(defaultBackButtonLabel), []),
     shuffleOption: shuffleOption || "none",
     required: required ?? true,
     logic,
@@ -100,11 +100,11 @@ export const buildOpenTextQuestion = ({
     id: id ?? createId(),
     type: TSurveyQuestionTypeEnum.OpenText,
     inputType,
-    subheader: subheader ? { default: subheader } : undefined,
-    placeholder: placeholder ? { default: placeholder } : undefined,
-    headline: { default: headline },
-    buttonLabel: { default: buttonLabel || t(defaultButtonLabel) },
-    backButtonLabel: { default: backButtonLabel || t(defaultBackButtonLabel) },
+    subheader: subheader ? createI18nString(subheader, []) : undefined,
+    placeholder: placeholder ? createI18nString(placeholder, []) : undefined,
+    headline: createI18nString(headline, []),
+    buttonLabel: createI18nString(buttonLabel || t(defaultButtonLabel), []),
+    backButtonLabel: createI18nString(backButtonLabel || t(defaultBackButtonLabel), []),
     required: required ?? true,
     longAnswer,
     logic,
@@ -147,16 +147,16 @@ export const buildRatingQuestion = ({
   return {
     id: id ?? createId(),
     type: TSurveyQuestionTypeEnum.Rating,
-    subheader: subheader ? { default: subheader } : undefined,
-    headline: { default: headline },
+    subheader: subheader ? createI18nString(subheader, []) : undefined,
+    headline: createI18nString(headline, []),
     scale,
     range,
-    buttonLabel: { default: buttonLabel || t(defaultButtonLabel) },
-    backButtonLabel: { default: backButtonLabel || t(defaultBackButtonLabel) },
+    buttonLabel: createI18nString(buttonLabel || t(defaultButtonLabel), []),
+    backButtonLabel: createI18nString(backButtonLabel || t(defaultBackButtonLabel), []),
     required: required ?? true,
     isColorCodingEnabled,
-    lowerLabel: lowerLabel ? { default: lowerLabel } : undefined,
-    upperLabel: upperLabel ? { default: upperLabel } : undefined,
+    lowerLabel: lowerLabel ? createI18nString(lowerLabel, []) : undefined,
+    upperLabel: upperLabel ? createI18nString(upperLabel, []) : undefined,
     logic,
   };
 };
@@ -190,14 +190,14 @@ export const buildNPSQuestion = ({
   return {
     id: id ?? createId(),
     type: TSurveyQuestionTypeEnum.NPS,
-    subheader: subheader ? { default: subheader } : undefined,
-    headline: { default: headline },
-    buttonLabel: { default: buttonLabel || t(defaultButtonLabel) },
-    backButtonLabel: { default: backButtonLabel || t(defaultBackButtonLabel) },
+    subheader: subheader ? createI18nString(subheader, []) : undefined,
+    headline: createI18nString(headline, []),
+    buttonLabel: createI18nString(buttonLabel || t(defaultButtonLabel), []),
+    backButtonLabel: createI18nString(backButtonLabel || t(defaultBackButtonLabel), []),
     required: required ?? true,
     isColorCodingEnabled,
-    lowerLabel: lowerLabel ? { default: lowerLabel } : undefined,
-    upperLabel: upperLabel ? { default: upperLabel } : undefined,
+    lowerLabel: lowerLabel ? createI18nString(lowerLabel, []) : undefined,
+    upperLabel: upperLabel ? createI18nString(upperLabel, []) : undefined,
     logic,
   };
 };
@@ -226,12 +226,12 @@ export const buildConsentQuestion = ({
   return {
     id: id ?? createId(),
     type: TSurveyQuestionTypeEnum.Consent,
-    subheader: subheader ? { default: subheader } : undefined,
-    headline: { default: headline },
-    buttonLabel: { default: buttonLabel || t(defaultButtonLabel) },
-    backButtonLabel: { default: backButtonLabel || t(defaultBackButtonLabel) },
+    subheader: subheader ? createI18nString(subheader, []) : undefined,
+    headline: createI18nString(headline, []),
+    buttonLabel: createI18nString(buttonLabel || t(defaultButtonLabel), []),
+    backButtonLabel: createI18nString(backButtonLabel || t(defaultBackButtonLabel), []),
     required: required ?? true,
-    label: { default: label },
+    label: createI18nString(label, []),
     logic,
   };
 };
@@ -264,11 +264,11 @@ export const buildCTAQuestion = ({
   return {
     id: id ?? createId(),
     type: TSurveyQuestionTypeEnum.CTA,
-    html: html ? { default: html } : undefined,
-    headline: { default: headline },
-    buttonLabel: { default: buttonLabel || t(defaultButtonLabel) },
-    backButtonLabel: { default: backButtonLabel || t(defaultBackButtonLabel) },
-    dismissButtonLabel: dismissButtonLabel ? { default: dismissButtonLabel } : undefined,
+    html: html ? createI18nString(html, []) : undefined,
+    headline: createI18nString(headline, []),
+    buttonLabel: createI18nString(buttonLabel || t(defaultButtonLabel), []),
+    backButtonLabel: createI18nString(backButtonLabel || t(defaultBackButtonLabel), []),
+    dismissButtonLabel: dismissButtonLabel ? createI18nString(dismissButtonLabel, []) : undefined,
     required: required ?? true,
     buttonExternal,
     buttonUrl,
@@ -360,9 +360,9 @@ export const hiddenFieldsDefault: TSurveyHiddenFields = {
 export const getDefaultWelcomeCard = (t: TFnType): TSurveyWelcomeCard => {
   return {
     enabled: false,
-    headline: { default: t("templates.default_welcome_card_headline") },
-    html: { default: t("templates.default_welcome_card_html") },
-    buttonLabel: { default: t("templates.default_welcome_card_button_label") },
+    headline: createI18nString(t("templates.default_welcome_card_headline"), []),
+    html: createI18nString(t("templates.default_welcome_card_html"), []),
+    buttonLabel: createI18nString(t("templates.default_welcome_card_button_label"), []),
     timeToFinish: false,
     showResponseCount: false,
   };

apps/web/app/lib/templates.ts

@@ -12,6 +12,7 @@ import {
   getDefaultSurveyPreset,
   hiddenFieldsDefault,
 } from "@/app/lib/survey-builder";
+import { createI18nString } from "@/lib/i18n/utils";
 import { createId } from "@paralleldrive/cuid2";
 import { TFnType } from "@tolgee/react";
 import { TSurvey, TSurveyOpenTextQuestion, TSurveyQuestionTypeEnum } from "@formbricks/types/surveys/types";
@@ -254,7 +255,7 @@ const productMarketFitSuperhuman = (t: TFnType): TTemplate => {
         }),
         buildMultipleChoiceQuestion({
           type: TSurveyQuestionTypeEnum.MultipleChoiceSingle,
-          headline: "templates.product_market_fit_superhuman_question_3_headline",
+          headline: t("templates.product_market_fit_superhuman_question_3_headline"),
           subheader: t("templates.product_market_fit_superhuman_question_3_subheader"),
           required: true,
           shuffleOption: "none",
@@ -3479,9 +3480,9 @@ export const customSurveyTemplate = (t: TFnType): TTemplate => {
         {
           id: createId(),
           type: TSurveyQuestionTypeEnum.OpenText,
-          headline: { default: t("templates.custom_survey_question_1_headline") },
-          placeholder: { default: t("templates.custom_survey_question_1_placeholder") },
-          buttonLabel: { default: t("templates.next") },
+          headline: createI18nString(t("templates.custom_survey_question_1_headline"), []),
+          placeholder: createI18nString(t("templates.custom_survey_question_1_placeholder"), []),
+          buttonLabel: createI18nString(t("templates.next"), []),
           required: true,
           inputType: "text",
           charLimit: {
@@ -3504,13 +3505,9 @@ export const previewSurvey = (projectName: string, t: TFnType) => {
     createdBy: "cltwumfbz0000echxysz6ptvq",
     status: "inProgress",
     welcomeCard: {
-      html: {
-        default: t("templates.preview_survey_welcome_card_html"),
-      },
+      html: createI18nString(t("templates.preview_survey_welcome_card_html"), []),
       enabled: false,
-      headline: {
-        default: t("templates.preview_survey_welcome_card_headline"),
-      },
+      headline: createI18nString(t("templates.preview_survey_welcome_card_headline"), []),
       timeToFinish: false,
       showResponseCount: false,
     },
@@ -3553,8 +3550,8 @@ export const previewSurvey = (projectName: string, t: TFnType) => {
       {
         id: "cltyqp5ng000108l9dmxw6nde",
         type: "endScreen",
-        headline: { default: t("templates.preview_survey_ending_card_headline") },
-        subheader: { default: t("templates.preview_survey_ending_card_description") },
+        headline: createI18nString(t("templates.preview_survey_ending_card_headline"), []),
+        subheader: createI18nString(t("templates.preview_survey_ending_card_description"), []),
       },
     ],
     hiddenFields: {

apps/web/app/middleware/endpoint-validator.test.ts

@@ -59,7 +59,6 @@ describe("endpoint-validator", () => {
 
   describe("isClientSideApiRoute", () => {
     test("should return true for client-side API routes", () => {
-      expect(isClientSideApiRoute("/api/packages/something")).toBe(true);
       expect(isClientSideApiRoute("/api/v1/js/actions")).toBe(true);
       expect(isClientSideApiRoute("/api/v1/client/storage")).toBe(true);
       expect(isClientSideApiRoute("/api/v1/client/other")).toBe(true);

apps/web/app/middleware/endpoint-validator.ts

@@ -8,7 +8,6 @@ export const isVerifyEmailRoute = (url: string) => url === "/auth/verify-email";
 export const isForgotPasswordRoute = (url: string) => url === "/auth/forgot-password";
 
 export const isClientSideApiRoute = (url: string): boolean => {
-  if (url.includes("/api/packages/")) return true;
   if (url.includes("/api/v1/js/actions")) return true;
   if (url.includes("/api/v1/client/storage")) return true;
   const regex = /^\/api\/v\d+\/client\//;

apps/web/app/share/[sharingKey]/(analysis)/responses/page.tsx

@@ -3,7 +3,6 @@ import { ResponsePage } from "@/app/(app)/environments/[environmentId]/surveys/[
 import { RESPONSES_PER_PAGE, WEBAPP_URL } from "@/lib/constants";
 import { getEnvironment } from "@/lib/environment/service";
 import { getProjectByEnvironmentId } from "@/lib/project/service";
-import { getResponseCountBySurveyId } from "@/lib/response/service";
 import { getSurvey, getSurveyIdByResultShareKey } from "@/lib/survey/service";
 import { getTagsByEnvironmentId } from "@/lib/tag/service";
 import { findMatchingLocale } from "@/lib/utils/locale";
@@ -46,19 +45,13 @@ const Page = async (props: ResponsesPageProps) => {
     throw new Error(t("common.project_not_found"));
   }
 
-  const totalResponseCount = await getResponseCountBySurveyId(surveyId);
   const locale = await findMatchingLocale();
 
   return (
     <div className="flex w-full justify-center">
       <PageContentWrapper className="w-full">
         <PageHeader pageTitle={survey.name}>
-          <SurveyAnalysisNavigation
-            survey={survey}
-            environmentId={environment.id}
-            activeId="responses"
-            initialTotalResponseCount={totalResponseCount}
-          />
+          <SurveyAnalysisNavigation survey={survey} environmentId={environment.id} activeId="responses" />
         </PageHeader>
         <ResponsePage
           environment={environment}

apps/web/app/share/[sharingKey]/(analysis)/summary/page.tsx

@@ -1,9 +1,9 @@
 import { SurveyAnalysisNavigation } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/SurveyAnalysisNavigation";
 import { SummaryPage } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SummaryPage";
+import { getSurveySummary } from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/lib/surveySummary";
 import { DEFAULT_LOCALE, WEBAPP_URL } from "@/lib/constants";
 import { getEnvironment } from "@/lib/environment/service";
 import { getProjectByEnvironmentId } from "@/lib/project/service";
-import { getResponseCountBySurveyId } from "@/lib/response/service";
 import { getSurvey, getSurveyIdByResultShareKey } from "@/lib/survey/service";
 import { PageContentWrapper } from "@/modules/ui/components/page-content-wrapper";
 import { PageHeader } from "@/modules/ui/components/page-header";
@@ -47,27 +47,23 @@ const Page = async (props: SummaryPageProps) => {
     throw new Error(t("common.project_not_found"));
   }
 
-  const totalResponseCount = await getResponseCountBySurveyId(surveyId);
+  // Fetch initial survey summary data on the server to prevent duplicate API calls during hydration
+  const initialSurveySummary = await getSurveySummary(surveyId);
 
   return (
     <div className="flex w-full justify-center">
       <PageContentWrapper className="w-full">
         <PageHeader pageTitle={survey.name}>
-          <SurveyAnalysisNavigation
-            survey={survey}
-            environmentId={environment.id}
-            activeId="summary"
-            initialTotalResponseCount={totalResponseCount}
-          />
+          <SurveyAnalysisNavigation survey={survey} environmentId={environment.id} activeId="summary" />
         </PageHeader>
         <SummaryPage
           environment={environment}
           survey={survey}
           surveyId={survey.id}
           webAppUrl={WEBAPP_URL}
-          totalResponseCount={totalResponseCount}
           isReadOnly={true}
           locale={DEFAULT_LOCALE}
+          initialSurveySummary={initialSurveySummary}
         />
       </PageContentWrapper>
     </div>

apps/web/app/share/[sharingKey]/actions.ts

@@ -43,7 +43,7 @@ export const getSummaryBySurveySharingKeyAction = actionClient
     const surveyId = await getSurveyIdByResultShareKey(parsedInput.sharingKey);
     if (!surveyId) throw new AuthorizationError("Not authorized");
 
-    return await getSurveySummary(surveyId, parsedInput.filterCriteria);
+    return getSurveySummary(surveyId, parsedInput.filterCriteria);
   });
 
 const ZGetResponseCountBySurveySharingKeyAction = z.object({
@@ -57,7 +57,7 @@ export const getResponseCountBySurveySharingKeyAction = actionClient
     const surveyId = await getSurveyIdByResultShareKey(parsedInput.sharingKey);
     if (!surveyId) throw new AuthorizationError("Not authorized");
 
-    return await getResponseCountBySurveyId(surveyId, parsedInput.filterCriteria);
+    return getResponseCountBySurveyId(surveyId, parsedInput.filterCriteria);
   });
 
 const ZGetSurveyFilterDataBySurveySharingKeyAction = z.object({

apps/web/app/storage/[environmentId]/[accessType]/[fileName]/lib/delete-file.ts

@@ -1,5 +1,4 @@
 import { responses } from "@/app/lib/api/response";
-import { storageCache } from "@/lib/storage/cache";
 import { deleteFile } from "@/lib/storage/service";
 import { type TAccessType } from "@formbricks/types/storage";
 
@@ -8,8 +7,6 @@ export const handleDeleteFile = async (environmentId: string, accessType: TAcces
     const { message, success, code } = await deleteFile(environmentId, accessType, fileName);
 
     if (success) {
-      // revalidate cache
-      storageCache.revalidate({ fileKey: `${environmentId}/${accessType}/${fileName}` });
       return responses.successResponse(message);
     }
 

apps/web/cache-handler.js

@@ -11,6 +11,8 @@ const { PHASE_PRODUCTION_BUILD } = require("next/constants");
 
 // @fortedigital/nextjs-cache-handler dependencies
 const createRedisHandler = require("@fortedigital/nextjs-cache-handler/redis-strings").default;
+const createBufferStringHandler =
+  require("@fortedigital/nextjs-cache-handler/buffer-string-decorator").default;
 const { Next15CacheHandler } = require("@fortedigital/nextjs-cache-handler/next-15-cache-handler");
 
 // Usual onCreation from @neshca/cache-handler
@@ -85,7 +87,7 @@ CacheHandler.onCreation(() => {
     global.cacheHandlerConfigPromise = null;
 
     global.cacheHandlerConfig = {
-      handlers: [redisCacheHandler],
+      handlers: [createBufferStringHandler(redisCacheHandler)],
     };
 
     return global.cacheHandlerConfig;