feat: Add PostHog

.claude/skills/posthog-integration-nextjs-pages-router/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: integration-nextjs-pages-router
+description: PostHog integration for Next.js Pages Router applications
+metadata:
+  author: PostHog
+  version: 1.8.1
+---
+
+# PostHog integration for Next.js Pages Router
+
+This skill helps you add PostHog analytics to Next.js Pages Router applications.
+
+## Workflow
+
+Follow these steps in order to complete the integration:
+
+1. `basic-integration-1.0-begin.md` - PostHog Setup - Begin ← **Start here**
+2. `basic-integration-1.1-edit.md` - PostHog Setup - Edit
+3. `basic-integration-1.2-revise.md` - PostHog Setup - Revise
+4. `basic-integration-1.3-conclude.md` - PostHog Setup - Conclusion
+
+## Reference files
+
+- `EXAMPLE.md` - Next.js Pages Router example project code
+- `next-js.md` - Next.js - docs
+- `identify-users.md` - Identify users - docs
+- `basic-integration-1.0-begin.md` - PostHog setup - begin
+- `basic-integration-1.1-edit.md` - PostHog setup - edit
+- `basic-integration-1.2-revise.md` - PostHog setup - revise
+- `basic-integration-1.3-conclude.md` - PostHog setup - conclusion
+
+The example project shows the target implementation pattern. Consult the documentation for API details.
+
+## Key principles
+
+- **Environment variables**: Always use environment variables for PostHog keys. Never hardcode them.
+- **Minimal changes**: Add PostHog code alongside existing integrations. Don't replace or restructure existing code.
+- **Match the example**: Your implementation should follow the example project's patterns as closely as possible.
+
+## Framework guidelines
+
+- For Next.js 15.3+, initialize PostHog in instrumentation-client.ts for the simplest setup
+- For feature flags, use useFeatureFlagEnabled() or useFeatureFlagPayload() hooks - they handle loading states and external sync automatically
+- Add analytics capture in event handlers where user actions occur, NOT in useEffect reacting to state changes
+- Do NOT use useEffect for data transformation - calculate derived values during render instead
+- Do NOT use useEffect to respond to user events - put that logic in the event handler itself
+- Do NOT use useEffect to chain state updates - calculate all related updates together in the event handler
+- Do NOT use useEffect to notify parent components - call the parent callback alongside setState in the event handler
+- To reset component state when a prop changes, pass the prop as the component's key instead of using useEffect
+- useEffect is ONLY for synchronizing with external systems (non-React widgets, browser APIs, network subscriptions)
+
+## Identifying users
+
+Identify users during login and signup events. Refer to the example code and documentation for the correct identify pattern for this framework. If both frontend and backend code exist, pass the client-side session and distinct ID using `X-POSTHOG-DISTINCT-ID` and `X-POSTHOG-SESSION-ID` headers to maintain correlation.
+
+## Error tracking
+
+Add PostHog error tracking to relevant files, particularly around critical user flows and API boundaries.

.claude/skills/posthog-integration-nextjs-pages-router/references/EXAMPLE.md

@@ -0,0 +1,761 @@
+# PostHog Next.js Pages Router Example Project
+
+Repository: https://github.com/PostHog/context-mill
+Path: basics/next-pages-router
+
+---
+
+## README.md
+
+# PostHog Next.js pages router example
+
+This is a [Next.js](https://nextjs.org) Pages Router example demonstrating PostHog integration with product analytics, session replay, feature flags, and error tracking.
+
+## Features
+
+- **Product Analytics**: Track user events and behaviors
+- **Session Replay**: Record and replay user sessions
+- **Error Tracking**: Capture and track errors
+- **User Authentication**: Demo login system with PostHog user identification
+- **Server-side & Client-side Tracking**: Examples of both tracking methods
+- **Reverse Proxy**: PostHog ingestion through Next.js rewrites
+
+## Getting Started
+
+### 1. Install Dependencies
+
+```bash
+npm install
+# or
+pnpm install
+```
+
+### 2. Configure Environment Variables
+
+Create a `.env.local` file in the root directory:
+
+```bash
+NEXT_PUBLIC_POSTHOG_KEY=your_posthog_project_api_key
+NEXT_PUBLIC_POSTHOG_HOST=https://us.i.posthog.com
+```
+
+Get your PostHog API key from your [PostHog project settings](https://app.posthog.com/project/settings).
+
+### 3. Run the Development Server
+
+```bash
+npm run dev
+# or
+pnpm dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the app.
+
+## Project Structure
+
+```
+src/
+├── components/
+│   └── Header.tsx           # Navigation header with auth state
+├── contexts/
+│   └── AuthContext.tsx      # Authentication context with PostHog integration
+├── lib/
+│   └── posthog-server.ts    # Server-side PostHog client
+├── pages/
+│   ├── _app.tsx             # App wrapper with Auth provider
+│   ├── _document.tsx        # Document wrapper
+│   ├── index.tsx            # Home/Login page
+│   ├── burrito.tsx          # Demo feature page with event tracking
+│   ├── profile.tsx          # User profile with error tracking demo
+│   └── api/
+│       └── auth/
+│           └── login.ts     # Login API with server-side tracking
+└── styles/
+    └── globals.css          # Global styles
+
+instrumentation-client.ts    # Client-side PostHog initialization
+```
+
+## Key Integration Points
+
+### Client-side initialization (instrumentation-client.ts)
+
+```typescript
+import posthog from "posthog-js"
+
+posthog.init(process.env.NEXT_PUBLIC_POSTHOG_KEY!, {
+  api_host: "/ingest",
+  ui_host: "https://us.posthog.com",
+  defaults: '2026-01-30',
+  capture_exceptions: true,
+  debug: process.env.NODE_ENV === "development",
+});
+```
+
+### User identification (AuthContext.tsx)
+
+```typescript
+posthog.identify(username, {
+  username: username,
+});
+```
+
+### Event tracking (burrito.tsx)
+
+```typescript
+posthog.capture('burrito_considered', {
+  total_considerations: count,
+  username: username,
+});
+```
+
+### Error tracking (profile.tsx)
+
+```typescript
+posthog.captureException(error);
+```
+
+### Server-side tracking (api/auth/login.ts)
+
+```typescript
+const posthog = getPostHogClient();
+posthog.capture({
+  distinctId: username,
+  event: 'server_login',
+  properties: { ... }
+});
+```
+
+## Pages router differences from app router
+
+This example uses Next.js Pages Router instead of App Router. Key differences:
+
+1. **File-based routing**: Pages in `src/pages/` instead of `src/app/`
+2. **_app.tsx**: Custom App component wraps all pages
+3. **API Routes**: Located in `src/pages/api/`
+4. **No 'use client'**: All pages are client-side by default
+5. **useRouter**: From `next/router` instead of `next/navigation`
+6. **Head component**: Using `next/head` for metadata instead of `metadata` export
+
+## Learn More
+
+- [PostHog Documentation](https://posthog.com/docs)
+- [Next.js Pages Router Documentation](https://nextjs.org/docs/pages)
+- [PostHog Next.js Integration Guide](https://posthog.com/docs/libraries/next-js)
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new).
+
+Check out the [Next.js deployment documentation](https://nextjs.org/docs/pages/building-your-application/deploying) for more details.
+
+---
+
+## instrumentation-client.ts
+
+```ts
+import posthog from "posthog-js"
+
+posthog.init(process.env.NEXT_PUBLIC_POSTHOG_KEY!, {
+  api_host: "/ingest",
+  ui_host: "https://us.posthog.com",
+  // Include the defaults option as required by PostHog
+  defaults: '2026-01-30',
+  // Enables capturing unhandled exceptions via Error Tracking
+  capture_exceptions: true,
+  // Turn on debug in development mode
+  debug: process.env.NODE_ENV === "development",
+});
+
+//IMPORTANT: Never combine this approach with other client-side PostHog initialization approaches, especially components like a PostHogProvider. instrumentation-client.ts is the correct solution for initializating client-side PostHog in Next.js 15.3+ apps.
+```
+
+---
+
+## next.config.ts
+
+```ts
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+  reactStrictMode: true,
+  async rewrites() {
+    return [
+      {
+        source: "/ingest/static/:path*",
+        destination: "https://us-assets.i.posthog.com/static/:path*",
+      },
+      {
+        source: "/ingest/:path*",
+        destination: "https://us.i.posthog.com/:path*",
+      },
+    ];
+  },
+  // This is required to support PostHog trailing slash API requests
+  skipTrailingSlashRedirect: true,
+};
+
+export default nextConfig;
+
+```
+
+---
+
+## src/components/Header.tsx
+
+```tsx
+import Link from 'next/link';
+import { useAuth } from '@/contexts/AuthContext';
+
+export default function Header() {
+  const { user, logout } = useAuth();
+
+  return (
+    <header className="header">
+      <div className="header-container">
+        <nav>
+          <Link href="/">Home</Link>
+          {user && (
+            <>
+              <Link href="/burrito">Burrito Consideration</Link>
+              <Link href="/profile">Profile</Link>
+            </>
+          )}
+        </nav>
+        <div className="user-section">
+          {user ? (
+            <>
+              <span>Welcome, {user.username}!</span>
+              <button onClick={logout} className="btn-logout">
+                Logout
+              </button>
+            </>
+          ) : (
+            <span>Not logged in</span>
+          )}
+        </div>
+      </div>
+    </header>
+  );
+}
+
+```
+
+---
+
+## src/contexts/AuthContext.tsx
+
+```tsx
+import { createContext, useContext, useState, ReactNode } from 'react';
+import posthog from 'posthog-js';
+
+interface User {
+  username: string;
+  burritoConsiderations: number;
+}
+
+interface AuthContextType {
+  user: User | null;
+  login: (username: string, password: string) => Promise<boolean>;
+  logout: () => void;
+  incrementBurritoConsiderations: () => void;
+}
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+const users: Map<string, User> = new Map();
+
+export function AuthProvider({ children }: { children: ReactNode }) {
+  // Use lazy initializer to read from localStorage only once on mount
+  const [user, setUser] = useState<User | null>(() => {
+    if (typeof window === 'undefined') return null;
+
+    const storedUsername = localStorage.getItem('currentUser');
+    if (storedUsername) {
+      const existingUser = users.get(storedUsername);
+      if (existingUser) {
+        return existingUser;
+      }
+    }
+    return null;
+  });
+
+  const login = async (username: string, password: string): Promise<boolean> => {
+    try {
+      const response = await fetch('/api/auth/login', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ username, password }),
+      });
+
+      if (response.ok) {
+        const { user: userData } = await response.json();
+
+        // Get or create user in local map
+        let localUser = users.get(username);
+        if (!localUser) {
+          localUser = userData as User;
+          users.set(username, localUser);
+        }
+
+        setUser(localUser);
+        localStorage.setItem('currentUser', username);
+
+        // Identify user in PostHog using username as distinct ID
+        posthog.identify(username, {
+          username: username,
+        });
+
+        // Capture login event
+        posthog.capture('user_logged_in', {
+          username: username,
+        });
+
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error('Login error:', error);
+      return false;
+    }
+  };
+
+  const logout = () => {
+    // Capture logout event before resetting
+    posthog.capture('user_logged_out');
+    posthog.reset();
+
+    setUser(null);
+    localStorage.removeItem('currentUser');
+  };
+
+  const incrementBurritoConsiderations = () => {
+    if (user) {
+      user.burritoConsiderations++;
+      users.set(user.username, user);
+      setUser({ ...user });
+    }
+  };
+
+  return (
+    <AuthContext.Provider value={{ user, login, logout, incrementBurritoConsiderations }}>
+      {children}
+    </AuthContext.Provider>
+  );
+}
+
+export function useAuth() {
+  const context = useContext(AuthContext);
+  if (context === undefined) {
+    throw new Error('useAuth must be used within an AuthProvider');
+  }
+  return context;
+}
+
+```
+
+---
+
+## src/lib/posthog-server.ts
+
+```ts
+import { PostHog } from 'posthog-node';
+
+let posthogClient: PostHog | null = null;
+
+export function getPostHogClient() {
+  if (!posthogClient) {
+    posthogClient = new PostHog(
+      process.env.NEXT_PUBLIC_POSTHOG_KEY!,
+      {
+        host: process.env.NEXT_PUBLIC_POSTHOG_HOST,
+        flushAt: 1,
+        flushInterval: 0
+      }
+    );
+  }
+  return posthogClient;
+}
+
+export async function shutdownPostHog() {
+  if (posthogClient) {
+    await posthogClient.shutdown();
+  }
+}
+
+```
+
+---
+
+## src/pages/_app.tsx
+
+```tsx
+import "@/styles/globals.css";
+import type { AppProps } from "next/app";
+import { AuthProvider } from "@/contexts/AuthContext";
+
+export default function App({ Component, pageProps }: AppProps) {
+  return (
+    <AuthProvider>
+      <Component {...pageProps} />
+    </AuthProvider>
+  );
+}
+
+```
+
+---
+
+## src/pages/_document.tsx
+
+```tsx
+import { Html, Head, Main, NextScript } from "next/document";
+
+export default function Document() {
+  return (
+    <Html lang="en">
+      <Head />
+      <body>
+        <Main />
+        <NextScript />
+      </body>
+    </Html>
+  );
+}
+
+```
+
+---
+
+## src/pages/api/auth/login.ts
+
+```ts
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { getPostHogClient } from '@/lib/posthog-server';
+
+const users = new Map<string, { username: string; burritoConsiderations: number }>();
+
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse
+) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  const { username, password } = req.body;
+
+  if (!username || !password) {
+    return res.status(400).json({ error: 'Username and password required' });
+  }
+
+  let user = users.get(username);
+  const isNewUser = !user;
+
+  if (!user) {
+    user = { username, burritoConsiderations: 0 };
+    users.set(username, user);
+  }
+
+  // Capture server-side login event
+  const posthog = getPostHogClient();
+  posthog.capture({
+    distinctId: username,
+    event: 'server_login',
+    properties: {
+      username: username,
+      isNewUser: isNewUser,
+      source: 'api'
+    }
+  });
+
+  // Identify user on server side
+  posthog.identify({
+    distinctId: username,
+    properties: {
+      username: username,
+      createdAt: isNewUser ? new Date().toISOString() : undefined
+    }
+  });
+
+  return res.status(200).json({ success: true, user });
+}
+
+```
+
+---
+
+## src/pages/api/hello.ts
+
+```ts
+// Next.js API route support: https://nextjs.org/docs/api-routes/introduction
+import type { NextApiRequest, NextApiResponse } from "next";
+
+type Data = {
+  name: string;
+};
+
+export default function handler(
+  req: NextApiRequest,
+  res: NextApiResponse<Data>,
+) {
+  res.status(200).json({ name: "John Doe" });
+}
+
+```
+
+---
+
+## src/pages/burrito.tsx
+
+```tsx
+import { useState } from 'react';
+import Head from 'next/head';
+import { useRouter } from 'next/router';
+import posthog from 'posthog-js';
+import { useAuth } from '@/contexts/AuthContext';
+import Header from '@/components/Header';
+
+export default function BurritoPage() {
+  const { user, incrementBurritoConsiderations } = useAuth();
+  const router = useRouter();
+  const [hasConsidered, setHasConsidered] = useState(false);
+
+  // Redirect to home if not logged in
+  if (!user) {
+    router.push('/');
+    return null;
+  }
+
+  const handleConsideration = () => {
+    incrementBurritoConsiderations();
+    setHasConsidered(true);
+    setTimeout(() => setHasConsidered(false), 2000);
+
+    // Capture burrito consideration event
+    posthog.capture('burrito_considered', {
+      total_considerations: user.burritoConsiderations + 1,
+      username: user.username,
+    });
+  };
+
+  return (
+    <>
+      <Head>
+        <title>Burrito Consideration - Burrito Consideration App</title>
+        <meta name="description" content="Consider the potential of burritos" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <link rel="icon" href="/favicon.ico" />
+      </Head>
+      <Header />
+      <main>
+        <div className="container">
+          <h1>Burrito consideration zone</h1>
+          <p>Take a moment to truly consider the potential of burritos.</p>
+
+          <div style={{ textAlign: 'center' }}>
+            <button
+              onClick={handleConsideration}
+              className="btn-burrito"
+            >
+              I have considered the burrito potential
+            </button>
+
+            {hasConsidered && (
+              <p className="success">
+                Thank you for your consideration! Count: {user.burritoConsiderations}
+              </p>
+            )}
+          </div>
+
+          <div className="stats">
+            <h3>Consideration stats</h3>
+            <p>Total considerations: {user.burritoConsiderations}</p>
+          </div>
+        </div>
+      </main>
+    </>
+  );
+}
+
+```
+
+---
+
+## src/pages/index.tsx
+
+```tsx
+import { useState } from 'react';
+import Head from 'next/head';
+import { useAuth } from '@/contexts/AuthContext';
+import Header from '@/components/Header';
+
+export default function Home() {
+  const { user, login } = useAuth();
+  const [username, setUsername] = useState('');
+  const [password, setPassword] = useState('');
+  const [error, setError] = useState('');
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setError('');
+
+    try {
+      const success = await login(username, password);
+      if (success) {
+        setUsername('');
+        setPassword('');
+      } else {
+        setError('Please provide both username and password');
+      }
+    } catch (err) {
+      console.error('Login failed:', err);
+      setError('An error occurred during login');
+    }
+  };
+
+  return (
+    <>
+      <Head>
+        <title>Burrito Consideration App</title>
+        <meta name="description" content="Consider the potential of burritos" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <link rel="icon" href="/favicon.ico" />
+      </Head>
+      <Header />
+      <main>
+        {user ? (
+          <div className="container">
+            <h1>Welcome back, {user.username}!</h1>
+            <p>You are now logged in. Feel free to explore:</p>
+            <ul>
+              <li>Consider the potential of burritos</li>
+              <li>View your profile and statistics</li>
+            </ul>
+          </div>
+        ) : (
+          <div className="container">
+            <h1>Welcome to Burrito Consideration App</h1>
+            <p>Please sign in to begin your burrito journey</p>
+
+            <form onSubmit={handleSubmit} className="form">
+              <div className="form-group">
+                <label htmlFor="username">Username:</label>
+                <input
+                  type="text"
+                  id="username"
+                  value={username}
+                  onChange={(e) => setUsername(e.target.value)}
+                  placeholder="Enter any username"
+                />
+              </div>
+
+              <div className="form-group">
+                <label htmlFor="password">Password:</label>
+                <input
+                  type="password"
+                  id="password"
+                  value={password}
+                  onChange={(e) => setPassword(e.target.value)}
+                  placeholder="Enter any password"
+                />
+              </div>
+
+              {error && <p className="error">{error}</p>}
+
+              <button type="submit" className="btn-primary">Sign In</button>
+            </form>
+
+            <p className="note">
+              Note: This is a demo app. Use any username and password to sign in.
+            </p>
+          </div>
+        )}
+      </main>
+    </>
+  );
+}
+
+```
+
+---
+
+## src/pages/profile.tsx
+
+```tsx
+import Head from 'next/head';
+import { useRouter } from 'next/router';
+import posthog from 'posthog-js';
+import { useAuth } from '@/contexts/AuthContext';
+import Header from '@/components/Header';
+
+export default function ProfilePage() {
+  const { user } = useAuth();
+  const router = useRouter();
+
+  // Redirect to home if not logged in
+  if (!user) {
+    router.push('/');
+    return null;
+  }
+
+  const triggerTestError = () => {
+    try {
+      throw new Error('Test error for PostHog error tracking');
+    } catch (err) {
+      posthog.captureException(err);
+      console.error('Captured error:', err);
+      alert('Error captured and sent to PostHog!');
+    }
+  };
+
+  return (
+    <>
+      <Head>
+        <title>Profile - Burrito Consideration App</title>
+        <meta name="description" content="Your burrito consideration profile" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <link rel="icon" href="/favicon.ico" />
+      </Head>
+      <Header />
+      <main>
+        <div className="container">
+          <h1>User Profile</h1>
+
+          <div className="stats">
+            <h2>Your Information</h2>
+            <p><strong>Username:</strong> {user.username}</p>
+            <p><strong>Burrito Considerations:</strong> {user.burritoConsiderations}</p>
+          </div>
+
+          <div style={{ marginTop: '2rem' }}>
+            <button onClick={triggerTestError} className="btn-primary" style={{ backgroundColor: '#dc3545' }}>
+              Trigger Test Error (for PostHog)
+            </button>
+          </div>
+
+          <div style={{ marginTop: '2rem' }}>
+            <h3>Your Burrito Journey</h3>
+            {user.burritoConsiderations === 0 ? (
+              <p>You haven&apos;t considered any burritos yet. Visit the Burrito Consideration page to start!</p>
+            ) : user.burritoConsiderations === 1 ? (
+              <p>You&apos;ve considered the burrito potential once. Keep going!</p>
+            ) : user.burritoConsiderations < 5 ? (
+              <p>You&apos;re getting the hang of burrito consideration!</p>
+            ) : user.burritoConsiderations < 10 ? (
+              <p>You&apos;re becoming a burrito consideration expert!</p>
+            ) : (
+              <p>You are a true burrito consideration master! 🌯</p>
+            )}
+          </div>
+        </div>
+      </main>
+    </>
+  );
+}
+
+```
+
+---
+

.claude/skills/posthog-integration-nextjs-pages-router/references/basic-integration-1.0-begin.md

@@ -0,0 +1,43 @@
+---
+title: PostHog Setup - Begin
+description: Start the event tracking setup process by analyzing the project and creating an event tracking plan
+---
+
+We're making an event tracking plan for this project.
+
+Before proceeding, find any existing `posthog.capture()` code. Make note of event name formatting.
+
+From the project's file list, select between 10 and 15 files that might have interesting business value for event tracking, especially conversion and churn events. Also look for additional files related to login that could be used for identifying users, along with error handling. Read the files. If a file is already well-covered by PostHog events, replace it with another option. Do not spawn subagents.
+
+Look for opportunities to track client-side events.
+
+**IMPORTANT: Server-side events are REQUIRED** if the project includes any instrumentable server-side code. If the project has API routes (e.g., `app/api/**/route.ts`) or Server Actions, you MUST include server-side events for critical business operations like:
+
+  - Payment/checkout completion
+  - Webhook handlers
+  - Authentication endpoints
+
+Do not skip server-side events - they capture actions that cannot be tracked client-side.
+
+Create a new file with a JSON array at the root of the project: .posthog-events.json. It should include one object for each event we want to add: event name, event description, and the file path we want to place the event in. If events already exist, don't duplicate them; supplement them.
+
+Track actions only, not pageviews. These can be captured automatically. Exceptions can be made for "viewed"-type events that correspond to the top of a conversion funnel.
+
+As you review files, make an internal note of opportunities to identify users and catch errors. We'll need them for the next step.
+
+## Status
+
+Before beginning a phase of the setup, you will send a status message with the exact prefix '[STATUS]', as in:
+
+[STATUS] Checking project structure.
+
+Status to report in this phase:
+
+- Checking project structure
+- Verifying PostHog dependencies
+- Generating events based on project
+
+
+---
+
+**Upon completion, continue with:** [basic-integration-1.1-edit.md](basic-integration-1.1-edit.md)

.claude/skills/posthog-integration-nextjs-pages-router/references/basic-integration-1.1-edit.md

@@ -0,0 +1,37 @@
+---
+title: PostHog Setup - Edit
+description: Implement PostHog event tracking in the identified files, following best practices and the example project
+---
+
+For each of the files and events noted in .posthog-events.json, make edits to capture events using PostHog. Make sure to set up any helper files needed. Carefully examine the included example project code: your implementation should match it as closely as possible. Do not spawn subagents.
+
+Use environment variables for PostHog keys. Do not hardcode PostHog keys.
+
+If a file already has existing integration code for other tools or services, don't overwrite or remove that code. Place PostHog code below it.
+
+For each event, add useful properties, and use your access to the PostHog source code to ensure correctness. You also have access to documentation about creating new events with PostHog. Consider this documentation carefully and follow it closely before adding events. Your integration should be based on documented best practices. Carefully consider how the user project's framework version may impact the correct PostHog integration approach.
+
+Remember that you can find the source code for any dependency in the node_modules directory. This may be necessary to properly populate property names. There are also example project code files available via the PostHog MCP; use these for reference.
+
+Where possible, add calls for PostHog's identify() function on the client side upon events like logins and signups. Use the contents of login and signup forms to identify users on submit. If there is server-side code, pass the client-side session and distinct ID to the server-side code to identify the user. On the server side, make sure events have a matching distinct ID where relevant. 
+
+It's essential to do this in both client code and server code, so that user behavior from both domains is easy to correlate.
+
+You should also add PostHog exception capture error tracking to these files where relevant.
+
+Remember: Do not alter the fundamental architecture of existing files. Make your additions minimal and targeted.
+
+Remember the documentation and example project resources you were provided at the beginning. Read them now.
+
+## Status
+
+Status to report in this phase:
+
+- Inserting PostHog capture code
+- A status message for each file whose edits you are planning, including a high level summary of changes
+- A status message for each file you have edited
+
+
+---
+
+**Upon completion, continue with:** [basic-integration-1.2-revise.md](basic-integration-1.2-revise.md)

.claude/skills/posthog-integration-nextjs-pages-router/references/basic-integration-1.2-revise.md

@@ -0,0 +1,22 @@
+---
+title: PostHog Setup - Revise
+description: Review and fix any errors in the PostHog integration implementation
+---
+
+Check the project for errors. Read the package.json file for any type checking or build scripts that may provide input about what to fix. Remember that you can find the source code for any dependency in the node_modules directory. Do not spawn subagents.
+
+Ensure that any components created were actually used.
+
+Once all other tasks are complete, run any linter or prettier-like scripts found in the package.json, but ONLY on the files you have edited or created during this session. Do not run formatting or linting across the entire project's codebase.
+
+## Status
+
+Status to report in this phase:
+
+- Finding and correcting errors
+- Report details of any errors you fix
+- Linting, building and prettying
+
+---
+
+**Upon completion, continue with:** [basic-integration-1.3-conclude.md](basic-integration-1.3-conclude.md)

.claude/skills/posthog-integration-nextjs-pages-router/references/basic-integration-1.3-conclude.md

@@ -0,0 +1,38 @@
+---
+title: PostHog Setup - Conclusion
+description: Review and fix any errors in the PostHog integration implementation
+---
+
+Use the PostHog MCP to create a new dashboard named "Analytics basics" based on the events created here. Make sure to use the exact same event names as implemented in the code. Populate it with up to five insights, with special emphasis on things like conversion funnels, churn events, and other business critical insights.  
+
+Search for a file called `.posthog-events.json` and read it for available events. Do not spawn subagents.
+
+Create the file posthog-setup-report.md. It should include a summary of the integration edits, a table with the event names, event descriptions, and files where events were added, along with a list of links for the dashboard and insights created. Follow this format:
+
+<wizard-report>
+# PostHog post-wizard report
+
+The wizard has completed a deep integration of your project. [Detailed summary of changes]
+
+[table of events/descriptions/files]
+
+## Next steps
+
+We've built some insights and a dashboard for you to keep an eye on user behavior, based on the events we just instrumented:
+
+[links]
+
+### Agent skill
+
+We've left an agent skill folder in your project. You can use this context for further agent development when using Claude Code. This will help ensure the model provides the most up-to-date approaches for integrating PostHog.
+
+</wizard-report>
+
+Upon completion, remove .posthog-events.json.
+
+## Status
+
+Status to report in this phase:
+
+- Configured dashboard: [insert PostHog dashboard URL]
+- Created setup report: [insert full local file path]

.claude/skills/posthog-integration-nextjs-pages-router/references/identify-users.md

@@ -0,0 +1,202 @@
+# Identify users - Docs
+
+Linking events to specific users enables you to build a full picture of how they're using your product across different sessions, devices, and platforms.
+
+This is straightforward to do when [capturing backend events](/docs/product-analytics/capture-events?tab=Node.js.md), as you associate events to a specific user using a `distinct_id`, which is a required argument.
+
+However, in the frontend of a [web](/docs/libraries/js/features#capturing-events.md) or [mobile app](/docs/libraries/ios#capturing-events.md), a `distinct_id` is not a required argument — PostHog's SDKs will generate an anonymous `distinct_id` for you automatically and you can capture events anonymously, provided you use the appropriate [configuration](/docs/libraries/js/features#capturing-anonymous-events.md).
+
+To link events to specific users, call `identify`:
+
+PostHog AI
+
+### Web
+
+```javascript
+posthog.identify(
+  'distinct_id',  // Replace 'distinct_id' with your user's unique identifier
+  { email: 'max@hedgehogmail.com', name: 'Max Hedgehog' } // optional: set additional person properties
+);
+```
+
+### Android
+
+```kotlin
+PostHog.identify(
+    distinctId = distinctID, // Replace 'distinctID' with your user's unique identifier
+    // optional: set additional person properties
+    userProperties = mapOf(
+        "name" to "Max Hedgehog",
+        "email" to "max@hedgehogmail.com"
+    )
+)
+```
+
+### iOS
+
+```swift
+PostHogSDK.shared.identify("distinct_id", // Replace "distinct_id" with your user's unique identifier
+                           userProperties: ["name": "Max Hedgehog", "email": "max@hedgehogmail.com"]) // optional: set additional person properties
+```
+
+### React Native
+
+```jsx
+posthog.identify('distinct_id', { // Replace "distinct_id" with your user's unique identifier
+    email: 'max@hedgehogmail.com', // optional: set additional person properties
+    name: 'Max Hedgehog'
+})
+```
+
+### Dart
+
+```dart
+await Posthog().identify(
+  userId: 'distinct_id', // Replace "distinct_id" with your user's unique identifier
+  userProperties: {
+    email: "max@hedgehogmail.com", // optional: set additional person properties
+    name: "Max Hedgehog"
+});
+```
+
+Events captured after calling `identify` are identified events and this creates a person profile if one doesn't exist already.
+
+Due to the cost of processing them, anonymous events can be up to 4x cheaper than identified events, so it's recommended you only capture identified events when needed.
+
+## How identify works
+
+When a user starts browsing your website or app, PostHog automatically assigns them an **anonymous ID**, which is stored locally.
+
+Provided you've [configured persistence](/docs/libraries/js/persistence.md) to use cookies or `localStorage`, this enables us to track anonymous users – even across different sessions.
+
+By calling `identify` with a `distinct_id` of your choice (usually the user's ID in your database, or their email), you link the anonymous ID and distinct ID together.
+
+Thus, all past and future events made with that anonymous ID are now associated with the distinct ID.
+
+This enables you to do things like associate events with a user from before they log in for the first time, or associate their events across different devices or platforms.
+
+Using identify in the backend
+
+Although you can call `identify` using our backend SDKs, it is used most in frontends. This is because there is no concept of anonymous sessions in the backend SDKs, so calling `identify` only updates person profiles.
+
+## Best practices when using `identify`
+
+### 1\. Call `identify` as soon as you're able to
+
+In your frontend, you should call `identify` as soon as you're able to.
+
+Typically, this is every time your **app loads** for the first time, and directly after your **users log in**.
+
+This ensures that events sent during your users' sessions are correctly associated with them.
+
+You only need to call `identify` once per session, and you should avoid calling it multiple times unnecessarily.
+
+If you call `identify` multiple times with the same data without reloading the page in between, PostHog will ignore the subsequent calls.
+
+### 2\. Use unique strings for distinct IDs
+
+If two users have the same distinct ID, their data is merged and they are considered one user in PostHog. Two common ways this can happen are:
+
+-   Your logic for generating IDs does not generate sufficiently strong IDs and you can end up with a clash where 2 users have the same ID.
+-   There's a bug, typo, or mistake in your code leading to most or all users being identified with generic IDs like `null`, `true`, or `distinctId`.
+
+PostHog also has built-in protections to stop the most common distinct ID mistakes.
+
+### 3\. Reset after logout
+
+If a user logs out on your frontend, you should call `reset()` to unlink any future events made on that device with that user.
+
+This is important if your users are sharing a computer, as otherwise all of those users are grouped together into a single user due to shared cookies between sessions.
+
+**We strongly recommend you call `reset` on logout even if you don't expect users to share a computer.**
+
+You can do that like so:
+
+PostHog AI
+
+### Web
+
+```javascript
+posthog.reset()
+```
+
+### iOS
+
+```swift
+PostHogSDK.shared.reset()
+```
+
+### Android
+
+```kotlin
+PostHog.reset()
+```
+
+### React Native
+
+```jsx
+posthog.reset()
+```
+
+### Dart
+
+```dart
+Posthog().reset()
+```
+
+If you *also* want to reset the `device_id` so that the device will be considered a new device in future events, you can pass `true` as an argument:
+
+Web
+
+PostHog AI
+
+```javascript
+posthog.reset(true)
+```
+
+### 4\. Person profiles and properties
+
+You'll notice that one of the parameters in the `identify` method is a `properties` object.
+
+This enables you to set [person properties](/docs/product-analytics/person-properties.md).
+
+Whenever possible, we recommend passing in all person properties you have available each time you call identify, as this ensures their person profile on PostHog is up to date.
+
+Person properties can also be set being adding a `$set` property to a event `capture` call.
+
+See our [person properties docs](/docs/product-analytics/person-properties.md) for more details on how to work with them and best practices.
+
+### 5\. Use deep links between platforms
+
+We recommend you call `identify` [as soon as you're able](#1-call-identify-as-soon-as-youre-able), typically when a user signs up or logs in.
+
+This doesn't work if one or both platforms are unauthenticated. Some examples of such cases are:
+
+-   Onboarding and signup flows before authentication.
+-   Unauthenticated web pages redirecting to authenticated mobile apps.
+-   Authenticated web apps prompting an app download.
+
+In these cases, you can use a [deep link](https://developer.android.com/training/app-links/deep-linking) on Android and [universal links](https://developer.apple.com/documentation/xcode/supporting-universal-links-in-your-app) on iOS to identify users.
+
+1.  Use `posthog.get_distinct_id()` to get the current distinct ID. Even if you cannot call identify because the user is unauthenticated, this will return an anonymous distinct ID generated by PostHog.
+2.  Add the distinct ID to the deep link as query parameters, along with other properties like UTM parameters.
+3.  When the user is redirected to the app, parse the deep link and handle the following cases:
+
+-   The user is already authenticated on the mobile app. In this case, call [`posthog.alias()`](/docs/libraries/js/features#alias.md) with the distinct ID from the web. This associates the two distinct IDs as a single person.
+-   The user is unauthenticated. In this case, call [`posthog.identify()`](/docs/libraries/js/features#identifying-users.md) with the distinct ID from the web. Events will be associated with this distinct ID.
+
+As long as you associate the distinct IDs with `posthog.identify()` or `posthog.alias()`, you can track events generated across platforms.
+
+## Further reading
+
+-   [Identifying users docs](/docs/product-analytics/identify.md)
+-   [How person processing works](/docs/how-posthog-works/ingestion-pipeline#2-person-processing.md)
+-   [An introductory guide to identifying users in PostHog](/tutorials/identifying-users-guide.md)
+
+### Community questions
+
+Ask a question
+
+### Was this page useful?
+
+HelpfulCould be better

.claude/skills/posthog-integration-nextjs-pages-router/references/next-js.md

@@ -0,0 +1,377 @@
+# Next.js - Docs
+
+PostHog makes it easy to get data about traffic and usage of your [Next.js](https://nextjs.org/) app. Integrating PostHog into your site enables analytics about user behavior, custom events capture, session recordings, feature flags, and more.
+
+This guide walks you through integrating PostHog into your Next.js app using the [React](/docs/libraries/react.md) and the [Node.js](/docs/libraries/node.md) SDKs.
+
+> You can see a working example of this integration in our [Next.js demo app](https://github.com/PostHog/posthog-js/tree/main/playground/nextjs).
+
+Next.js has both client and server-side rendering, as well as pages and app routers. We'll cover all of these options in this guide.
+
+## Prerequisites
+
+To follow this guide along, you need:
+
+1.  A PostHog instance (either [Cloud](https://app.posthog.com/signup) or [self-hosted](/docs/self-host.md))
+2.  A Next.js application
+
+## Beta: integration via LLM
+
+Install PostHog for Next.js in seconds with our wizard by running this prompt with [LLM coding agents](/blog/envoy-wizard-llm-agent.md) like Cursor and Bolt, or by running it in your terminal.
+
+`npx @posthog/wizard@latest`
+
+[Learn more](/wizard.md)
+
+Or, to integrate manually, continue with the rest of this guide.
+
+## Client-side setup
+
+Install `posthog-js` using your package manager:
+
+PostHog AI
+
+### npm
+
+```bash
+npm install --save posthog-js
+```
+
+### Yarn
+
+```bash
+yarn add posthog-js
+```
+
+### pnpm
+
+```bash
+pnpm add posthog-js
+```
+
+### Bun
+
+```bash
+bun add posthog-js
+```
+
+Add your environment variables to your `.env.local` file and to your hosting provider (e.g. Vercel, Netlify, AWS). You can find your project token in your [project settings](https://app.posthog.com/project/settings).
+
+.env.local
+
+PostHog AI
+
+```shell
+NEXT_PUBLIC_POSTHOG_TOKEN=<ph_project_token>
+NEXT_PUBLIC_POSTHOG_HOST=https://us.i.posthog.com
+```
+
+These values need to start with `NEXT_PUBLIC_` to be accessible on the client-side.
+
+## Integration
+
+Next.js provides the [`instrumentation-client.ts|js`](https://nextjs.org/docs/app/api-reference/file-conventions/instrumentation-client) file for client-side setup. Add it to the root of your Next.js app (for both app and pages router) and initialize PostHog in it like this:
+
+PostHog AI
+
+### instrumentation-client.js
+
+```javascript
+import posthog from 'posthog-js'
+posthog.init(process.env.NEXT_PUBLIC_POSTHOG_TOKEN, {
+  api_host: process.env.NEXT_PUBLIC_POSTHOG_HOST,
+  defaults: '2026-01-30'
+});
+```
+
+### instrumentation-client.ts
+
+```typescript
+import posthog from 'posthog-js'
+posthog.init(process.env.NEXT_PUBLIC_POSTHOG_TOKEN!, {
+  api_host: process.env.NEXT_PUBLIC_POSTHOG_HOST,
+  defaults: '2026-01-30'
+});
+```
+
+Bootstrapping with `instrumentation-client`
+
+When using `instrumentation-client`, the values you pass to `posthog.init` remain fixed for the entire session. This means bootstrapping only works if you evaluate flags **before your app renders** (for example, on the server).
+
+If you need flag values after the app has rendered, you’ll want to:
+
+-   Evaluate the flag on the server and pass the value into your app, or
+-   Evaluate the flag in an earlier page/state, then store and re-use it when needed.
+
+Both approaches avoid flicker and give you the same outcome as bootstrapping, as long as you use the same `distinct_id` across client and server.
+
+See the [bootstrapping guide](/docs/feature-flags/bootstrapping.md) for more information.
+
+Set up a reverse proxy (recommended)
+
+We recommend [setting up a reverse proxy](/docs/advanced/proxy.md), so that events are less likely to be intercepted by tracking blockers.
+
+We have our [own managed reverse proxy service](/docs/advanced/proxy/managed-reverse-proxy.md), which is free for all PostHog Cloud users, routes through our infrastructure, and makes setting up your proxy easy.
+
+If you don't want to use our managed service then there are several other options for creating a reverse proxy, including using [Cloudflare](/docs/advanced/proxy/cloudflare.md), [AWS Cloudfront](/docs/advanced/proxy/cloudfront.md), and [Vercel](/docs/advanced/proxy/vercel.md).
+
+Grouping products in one project (recommended)
+
+If you have multiple customer-facing products (e.g. a marketing website + mobile app + web app), it's best to install PostHog on them all and [group them in one project](/docs/settings/projects.md).
+
+This makes it possible to track users across their entire journey (e.g. from visiting your marketing website to signing up for your product), or how they use your product across multiple platforms.
+
+Add IPs to Firewall/WAF allowlists (recommended)
+
+For certain features like [heatmaps](/docs/toolbar/heatmaps.md), your Web Application Firewall (WAF) may be blocking PostHog’s requests to your site. Add these IP addresses to your WAF allowlist or rules to let PostHog access your site.
+
+**EU**: `3.75.65.221`, `18.197.246.42`, `3.120.223.253`
+
+**US**: `44.205.89.55`, `52.4.194.122`, `44.208.188.173`
+
+These are public, stable IPs used by PostHog services (e.g., Celery tasks for snapshots).
+
+## Accessing PostHog
+
+Once initialized in `instrumentation-client.js|ts`, import `posthog` from `posthog-js` anywhere and call the methods you need on the `posthog` object.
+
+JavaScript
+
+PostHog AI
+
+```javascript
+'use client'
+import posthog from 'posthog-js'
+export default function Home() {
+  return (
+    <div>
+      <button onClick={() => posthog.capture('test_event')}>
+        Click me for an event
+      </button>
+    </div>
+  );
+}
+```
+
+### Using React hooks
+
+The [React feature flag hooks](/docs/libraries/react#feature-flags.md) work automatically when PostHog is initialized via `instrumentation-client.ts`. The hooks use the initialized posthog-js singleton:
+
+JavaScript
+
+PostHog AI
+
+```javascript
+'use client'
+import { useFeatureFlagEnabled } from 'posthog-js/react'
+export default function FeatureComponent() {
+  const showNewFeature = useFeatureFlagEnabled('new-feature')
+  return showNewFeature ? <NewFeature /> : <OldFeature />
+}
+```
+
+### Usage
+
+See the [React SDK docs](/docs/libraries/react.md) for examples of how to use:
+
+-   [`posthog-js` functions like custom event capture, user identification, and more.](/docs/libraries/react#using-posthog-js-functions.md)
+-   [Feature flags including variants and payloads.](/docs/libraries/react#feature-flags.md)
+
+You can also read [the full `posthog-js` documentation](/docs/libraries/js/features.md) for all the usable functions.
+
+## Server-side analytics
+
+Next.js enables you to both server-side render pages and add server-side functionality. To integrate PostHog into your Next.js app on the server-side, you can use the [Node SDK](/docs/libraries/node.md).
+
+First, install the `posthog-node` library:
+
+PostHog AI
+
+### npm
+
+```bash
+npm install posthog-node --save
+```
+
+### Yarn
+
+```bash
+yarn add posthog-node
+```
+
+### pnpm
+
+```bash
+pnpm add posthog-node
+```
+
+### Bun
+
+```bash
+bun add posthog-node
+```
+
+### Router-specific instructions
+
+## App router
+
+For the app router, we can initialize the `posthog-node` SDK once with a `PostHogClient` function, and import it into files.
+
+This enables us to send events and fetch data from PostHog on the server – without making client-side requests.
+
+JavaScript
+
+PostHog AI
+
+```javascript
+// app/posthog.js
+import { PostHog } from 'posthog-node'
+export default function PostHogClient() {
+  const posthogClient = new PostHog(process.env.NEXT_PUBLIC_POSTHOG_TOKEN, {
+    host: process.env.NEXT_PUBLIC_POSTHOG_HOST,
+    flushAt: 1,
+    flushInterval: 0
+  })
+  return posthogClient
+}
+```
+
+> **Note:** Because server-side functions in Next.js can be short-lived, we set `flushAt` to `1` and `flushInterval` to `0`.
+>
+> -   `flushAt` sets how many capture calls we should flush the queue (in one batch).
+> -   `flushInterval` sets how many milliseconds we should wait before flushing the queue. Setting them to the lowest number ensures events are sent immediately and not batched. We also need to call `await posthog.shutdown()` once done.
+
+To use this client, we import it into our pages and call it with the `PostHogClient` function:
+
+JavaScript
+
+PostHog AI
+
+```javascript
+import Link from 'next/link'
+import PostHogClient from '../posthog'
+export default async function About() {
+  const posthog = PostHogClient()
+  const flags = await posthog.getAllFlags(
+    'user_distinct_id' // replace with a user's distinct ID
+  );
+  await posthog.shutdown()
+  return (
+    <main>
+      <h1>About</h1>
+      <Link href="/">Go home</Link>
+      { flags['main-cta'] &&
+        <Link href="http://posthog.com/">Go to PostHog</Link>
+      }
+    </main>
+  )
+}
+```
+
+## Pages router
+
+For the pages router, we can use the `getServerSideProps` function to access PostHog on the server-side, send events, evaluate feature flags, and more.
+
+This looks like this:
+
+JavaScript
+
+PostHog AI
+
+```javascript
+// pages/posts/[id].js
+import { useContext, useEffect, useState } from 'react'
+import { getServerSession } from "next-auth/next"
+import { PostHog } from 'posthog-node'
+export default function Post({ post, flags }) {
+  const [ctaState, setCtaState] = useState()
+  useEffect(() => {
+    if (flags) {
+      setCtaState(flags['blog-cta'])
+    }
+  })
+  return (
+    <div>
+      <h1>{post.title}</h1>
+      <p>By: {post.author}</p>
+      <p>{post.content}</p>
+      {ctaState &&
+        <p><a href="/">Go to PostHog</a></p>
+      }
+      <button onClick={likePost}>Like</button>
+    </div>
+  )
+}
+export async function getServerSideProps(ctx) {
+  const session = await getServerSession(ctx.req, ctx.res)
+  let flags = null
+  if (session) {
+    const client = new PostHog(
+      process.env.NEXT_PUBLIC_POSTHOG_TOKEN,
+      {
+        host: process.env.NEXT_PUBLIC_POSTHOG_HOST,
+      }
+    )
+    flags = await client.getAllFlags(session.user.email);
+    client.capture({
+      distinctId: session.user.email,
+      event: 'loaded blog article',
+      properties: {
+        $current_url: ctx.req.url,
+      },
+    });
+    await client.shutdown()
+  }
+  const { posts } = await import('../../blog.json')
+  const post = posts.find((post) => post.id.toString() === ctx.params.id)
+  return {
+    props: {
+      post,
+      flags
+    },
+  }
+}
+```
+
+> **Note**: Make sure to *always* call `await client.shutdown()` after sending events from the server-side. PostHog queues events into larger batches, and this call forces all batched events to be flushed immediately.
+
+### Server-side configuration
+
+Next.js overrides the default `fetch` behavior on the server to introduce their own cache. PostHog ignores that cache by default, as this is Next.js's default behavior for any fetch call.
+
+You can override that configuration when initializing PostHog, but make sure you understand the pros/cons of using Next.js's cache and that you might get cached results rather than the actual result our server would return. This is important for feature flags, for example.
+
+TSX
+
+PostHog AI
+
+```jsx
+posthog.init(process.env.NEXT_PUBLIC_POSTHOG_TOKEN, {
+  // ... your configuration
+  fetch_options: {
+    cache: 'force-cache', // Use Next.js cache
+    next_options: {       // Passed to the `next` option for `fetch`
+      revalidate: 60,     // Cache for 60 seconds
+      tags: ['posthog'],  // Can be used with Next.js `revalidateTag` function
+    },
+  }
+})
+```
+
+## Configuring a reverse proxy to PostHog
+
+To improve the reliability of client-side tracking and make requests less likely to be intercepted by tracking blockers, you can setup a reverse proxy in Next.js. Read more about deploying a reverse proxy using [Next.js rewrites](/docs/advanced/proxy/nextjs.md), [Next.js middleware](/docs/advanced/proxy/nextjs-middleware.md), and [Vercel rewrites](/docs/advanced/proxy/vercel.md).
+
+## Further reading
+
+-   [How to set up Next.js analytics, feature flags, and more](/tutorials/nextjs-analytics.md)
+-   [How to set up Next.js pages router analytics, feature flags, and more](/tutorials/nextjs-pages-analytics.md)
+-   [How to set up Next.js A/B tests](/tutorials/nextjs-ab-tests.md)
+
+### Community questions
+
+Ask a question
+
+### Was this page useful?
+
+HelpfulCould be better

.env.example

@@ -150,8 +150,6 @@ NOTION_OAUTH_CLIENT_ID=
 NOTION_OAUTH_CLIENT_SECRET=
 
 # Stripe Billing Variables
-STRIPE_PRICING_TABLE_ID=
-STRIPE_PUBLISHABLE_KEY=
 STRIPE_SECRET_KEY=
 STRIPE_WEBHOOK_SECRET=
 
@@ -232,4 +230,4 @@ REDIS_URL=redis://localhost:6379
 
 
 # Lingo.dev API key for translation generation
-LINGODOTDEV_API_KEY=your_api_key_here
+LINGODOTDEV_API_KEY=your_api_key_here

.github/actions/build-and-push-docker/action.yml

@@ -285,14 +285,12 @@ runs:
           encryption_key=${{ env.DUMMY_ENCRYPTION_KEY }}
           redis_url=${{ env.DUMMY_REDIS_URL }}
           sentry_auth_token=${{ env.SENTRY_AUTH_TOKEN }}
-          posthog_key=${{ env.POSTHOG_KEY }}
       env:
         DEPOT_PROJECT_TOKEN: ${{ env.DEPOT_PROJECT_TOKEN }}
         DUMMY_DATABASE_URL: ${{ env.DUMMY_DATABASE_URL }}
         DUMMY_ENCRYPTION_KEY: ${{ env.DUMMY_ENCRYPTION_KEY }}
         DUMMY_REDIS_URL: ${{ env.DUMMY_REDIS_URL }}
         SENTRY_AUTH_TOKEN: ${{ env.SENTRY_AUTH_TOKEN }}
-        POSTHOG_KEY: ${{ env.POSTHOG_KEY }}
 
     - name: Sign GHCR image (GHCR only)
       if: ${{ inputs.registry_type == 'ghcr' && (github.event_name == 'workflow_call' || github.event_name == 'release' || github.event_name == 'workflow_dispatch') }}

.github/workflows/build-and-push-ecr.yml

@@ -92,4 +92,3 @@ jobs:
           DUMMY_ENCRYPTION_KEY: ${{ secrets.DUMMY_ENCRYPTION_KEY }}
           DUMMY_REDIS_URL: ${{ secrets.DUMMY_REDIS_URL }}
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
-          POSTHOG_KEY: ${{ secrets.POSTHOG_KEY }}

.gitignore

@@ -66,3 +66,4 @@ i18n.cache
 stats.html
 # next-agents-md
 .next-docs/
+.env

apps/storybook/package.json

@@ -12,18 +12,18 @@
   },
   "devDependencies": {
     "@chromatic-com/storybook": "^5.0.1",
-    "@storybook/addon-a11y": "10.2.17",
-    "@storybook/addon-links": "10.2.17",
-    "@storybook/addon-onboarding": "10.2.17",
-    "@storybook/react-vite": "10.2.17",
-    "@typescript-eslint/eslint-plugin": "8.57.0",
+    "@storybook/addon-a11y": "10.2.15",
+    "@storybook/addon-links": "10.2.15",
+    "@storybook/addon-onboarding": "10.2.15",
+    "@storybook/react-vite": "10.2.15",
+    "@typescript-eslint/eslint-plugin": "8.56.1",
     "@tailwindcss/vite": "4.2.1",
-    "@typescript-eslint/parser": "8.57.0",
+    "@typescript-eslint/parser": "8.56.1",
     "@vitejs/plugin-react": "5.1.4",
     "eslint-plugin-react-refresh": "0.4.26",
-    "eslint-plugin-storybook": "10.2.17",
-    "storybook": "10.2.17",
+    "eslint-plugin-storybook": "10.2.14",
+    "storybook": "10.2.15",
     "vite": "7.3.1",
-    "@storybook/addon-docs": "10.2.17"
+    "@storybook/addon-docs": "10.2.15"
   }
 }

apps/web/Dockerfile

@@ -18,7 +18,7 @@ FROM node:24-alpine3.23 AS base
 FROM base AS installer
 
 # Enable corepack and prepare pnpm
-RUN npm install --ignore-scripts -g corepack@latest
+RUN npm install --ignore-scripts -g corepack@latest 
 RUN corepack enable
 RUN corepack prepare pnpm@10.28.2 --activate
 
@@ -67,7 +67,6 @@ RUN --mount=type=secret,id=database_url \
     --mount=type=secret,id=encryption_key \
     --mount=type=secret,id=redis_url \
     --mount=type=secret,id=sentry_auth_token \
-    --mount=type=secret,id=posthog_key \
     /tmp/read-secrets.sh pnpm build --filter=@formbricks/web...
 
 #
@@ -75,10 +74,9 @@ RUN --mount=type=secret,id=database_url \
 #
 FROM base AS runner
 
-# Upgrade Alpine system packages to pick up security patches, update npm to latest, then create user
+# Update npm to latest, then create user
 # Note: npm's bundled tar has a known vulnerability but npm is only used during build, not at runtime
-RUN apk update && apk upgrade --no-cache \
-    && npm install --ignore-scripts -g npm@latest \
+RUN npm install --ignore-scripts -g npm@latest \
     && addgroup -S nextjs \
     && adduser -S -u 1001 -G nextjs nextjs
 
@@ -122,11 +120,8 @@ RUN chown -R nextjs:nextjs ./node_modules/.prisma && chmod -R 755 ./node_modules
 COPY --from=installer /app/node_modules/@paralleldrive/cuid2 ./node_modules/@paralleldrive/cuid2
 RUN chmod -R 755 ./node_modules/@paralleldrive/cuid2
 
-# Runtime migrations import uuid v7 from the database package, so copy the
-# database package's resolved install instead of the repo-root hoisted version.
-COPY --from=installer /app/packages/database/node_modules/uuid ./node_modules/uuid
-RUN chmod -R 755 ./node_modules/uuid \
-    && node --input-type=module -e "import('uuid').then((module) => { if (typeof module.v7 !== 'function') throw new Error('uuid v7 missing in runtime image'); })"
+COPY --from=installer /app/node_modules/uuid ./node_modules/uuid
+RUN chmod -R 755 ./node_modules/uuid
 
 COPY --from=installer /app/node_modules/@noble/hashes ./node_modules/@noble/hashes
 RUN chmod -R 755 ./node_modules/@noble/hashes
@@ -169,4 +164,4 @@ RUN mkdir -p /home/nextjs/apps/web/uploads/ && \
 VOLUME /home/nextjs/apps/web/uploads/
 VOLUME /home/nextjs/apps/web/saml-connection
 
-CMD ["/home/nextjs/start.sh"]
+CMD ["/home/nextjs/start.sh"]

apps/web/app/(app)/(onboarding)/environments/[environmentId]/layout.tsx

@@ -4,10 +4,7 @@ import { AuthorizationError } from "@formbricks/types/errors";
 import { hasUserEnvironmentAccess } from "@/lib/environment/auth";
 import { authOptions } from "@/modules/auth/lib/authOptions";
 
-const OnboardingLayout = async (props: {
-  params: Promise<{ environmentId: string }>;
-  children: React.ReactNode;
-}) => {
+const OnboardingLayout = async (props) => {
   const params = await props.params;
 
   const { children } = props;

apps/web/app/(app)/(onboarding)/environments/[environmentId]/xm-templates/lib/utils.test.ts

@@ -2,7 +2,6 @@ import "@testing-library/jest-dom/vitest";
 import { cleanup } from "@testing-library/react";
 import { afterEach, describe, expect, test } from "vitest";
 import { TProject } from "@formbricks/types/project";
-import { TSurveyElementTypeEnum } from "@formbricks/types/surveys/constants";
 import { TXMTemplate } from "@formbricks/types/templates";
 import { replacePresetPlaceholders } from "./utils";
 
@@ -40,13 +39,13 @@ const mockTemplate: TXMTemplate = {
       elements: [
         {
           id: "q1",
-          type: "openText" as TSurveyElementTypeEnum.OpenText,
+          type: "openText" as const,
           inputType: "text" as const,
           headline: { default: "$[projectName] Question" },
           subheader: { default: "" },
           required: false,
           placeholder: { default: "" },
-          charLimit: { enabled: true, max: 1000 },
+          charLimit: 1000,
         },
       ],
     },

apps/web/app/(app)/(onboarding)/environments/[environmentId]/xm-templates/lib/xm-templates.test.ts

@@ -14,7 +14,7 @@ describe("xm-templates", () => {
   });
 
   test("getXMSurveyDefault returns default survey template", () => {
-    const tMock = vi.fn((key: string) => key) as unknown as TFunction;
+    const tMock = vi.fn((key) => key) as TFunction;
     const result = getXMSurveyDefault(tMock);
 
     expect(result).toEqual({
@@ -29,7 +29,7 @@ describe("xm-templates", () => {
   });
 
   test("getXMTemplates returns all templates", () => {
-    const tMock = vi.fn((key: string) => key) as unknown as TFunction;
+    const tMock = vi.fn((key) => key) as TFunction;
     const result = getXMTemplates(tMock);
 
     expect(result).toHaveLength(6);
@@ -44,7 +44,7 @@ describe("xm-templates", () => {
   test("getXMTemplates handles errors gracefully", async () => {
     const tMock = vi.fn(() => {
       throw new Error("Test error");
-    }) as unknown as TFunction;
+    }) as TFunction;
 
     const result = getXMTemplates(tMock);
 

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

@@ -19,8 +19,8 @@ describe("getTeamsByOrganizationId", () => {
 
   test("returns mapped teams", async () => {
     const mockTeams = [
-      { id: "t1", name: "Team 1", createdAt: new Date(), updatedAt: new Date(), organizationId: "org1" },
-      { id: "t2", name: "Team 2", createdAt: new Date(), updatedAt: new Date(), organizationId: "org1" },
+      { id: "t1", name: "Team 1" },
+      { id: "t2", name: "Team 2" },
     ];
     vi.mocked(prisma.team.findMany).mockResolvedValueOnce(mockTeams);
     const result = await getTeamsByOrganizationId("org1");

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

@@ -22,10 +22,12 @@ export const getTeamsByOrganizationId = reactCache(
         },
       });
 
-      return teams.map((team: TOrganizationTeam) => ({
+      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);

apps/web/app/(app)/(onboarding)/organizations/[organizationId]/landing/layout.tsx

@@ -5,10 +5,7 @@ import { getMembershipByUserIdOrganizationId } from "@/lib/membership/service";
 import { getUserProjects } from "@/lib/project/service";
 import { authOptions } from "@/modules/auth/lib/authOptions";
 
-const LandingLayout = async (props: {
-  params: Promise<{ organizationId: string }>;
-  children: React.ReactNode;
-}) => {
+const LandingLayout = async (props) => {
   const params = await props.params;
 
   const { children } = props;

apps/web/app/(app)/(onboarding)/organizations/[organizationId]/landing/page.tsx

@@ -10,7 +10,7 @@ import { getIsMultiOrgEnabled } from "@/modules/ee/license-check/lib/utils";
 import { getOrganizationAuth } from "@/modules/organization/lib/utils";
 import { Header } from "@/modules/ui/components/header";
 
-const Page = async (props: { params: Promise<{ organizationId: string }> }) => {
+const Page = async (props) => {
   const params = await props.params;
   const t = await getTranslate();
 

apps/web/app/(app)/(onboarding)/organizations/[organizationId]/layout.tsx

@@ -8,10 +8,7 @@ import { getTranslate } from "@/lingodotdev/server";
 import { authOptions } from "@/modules/auth/lib/authOptions";
 import { ToasterClient } from "@/modules/ui/components/toaster-client";
 
-const ProjectOnboardingLayout = async (props: {
-  params: Promise<{ organizationId: string }>;
-  children: React.ReactNode;
-}) => {
+const ProjectOnboardingLayout = async (props) => {
   const params = await props.params;
 
   const { children } = props;

apps/web/app/(app)/(onboarding)/organizations/[organizationId]/workspaces/new/layout.tsx

@@ -8,10 +8,7 @@ import { getTranslate } from "@/lingodotdev/server";
 import { authOptions } from "@/modules/auth/lib/authOptions";
 import { getOrganizationProjectsLimit } from "@/modules/ee/license-check/lib/utils";
 
-const OnboardingLayout = async (props: {
-  params: Promise<{ organizationId: string }>;
-  children: React.ReactNode;
-}) => {
+const OnboardingLayout = async (props) => {
   const params = await props.params;
 
   const { children } = props;
@@ -31,10 +28,8 @@ const OnboardingLayout = async (props: {
     throw new Error(t("common.organization_not_found"));
   }
 
-  const [organizationProjectsLimit, organizationProjectsCount] = await Promise.all([
-    getOrganizationProjectsLimit(organization.id),
-    getOrganizationProjectsCount(organization.id),
-  ]);
+  const organizationProjectsLimit = await getOrganizationProjectsLimit(organization.billing.limits);
+  const organizationProjectsCount = await getOrganizationProjectsCount(organization.id);
 
   if (organizationProjectsCount >= organizationProjectsLimit) {
     return redirect(`/`);

apps/web/app/(app)/(onboarding)/organizations/[organizationId]/workspaces/new/plan/components/select-plan-onboarding.tsx

@@ -1,22 +0,0 @@
-import { getTranslate } from "@/lingodotdev/server";
-import { SelectPlanCard } from "@/modules/ee/billing/components/select-plan-card";
-import { Header } from "@/modules/ui/components/header";
-
-interface SelectPlanOnboardingProps {
-  organizationId: string;
-}
-
-export const SelectPlanOnboarding = async ({ organizationId }: SelectPlanOnboardingProps) => {
-  const t = await getTranslate();
-  const nextUrl = `/organizations/${organizationId}/workspaces/new/mode`;
-
-  return (
-    <div className="flex min-h-full min-w-full flex-col items-center justify-center space-y-8">
-      <Header
-        title={t("environments.settings.billing.select_plan_header_title")}
-        subtitle={t("environments.settings.billing.select_plan_header_subtitle")}
-      />
-      <SelectPlanCard nextUrl={nextUrl} organizationId={organizationId} />
-    </div>
-  );
-};

apps/web/app/(app)/(onboarding)/organizations/[organizationId]/workspaces/new/plan/page.tsx

@@ -1,28 +0,0 @@
-import { redirect } from "next/navigation";
-import { IS_FORMBRICKS_CLOUD } from "@/lib/constants";
-import { getOrganizationAuth } from "@/modules/organization/lib/utils";
-import { SelectPlanOnboarding } from "./components/select-plan-onboarding";
-
-interface PlanPageProps {
-  params: Promise<{
-    organizationId: string;
-  }>;
-}
-
-const Page = async (props: PlanPageProps) => {
-  const params = await props.params;
-
-  if (!IS_FORMBRICKS_CLOUD) {
-    return redirect(`/organizations/${params.organizationId}/workspaces/new/mode`);
-  }
-
-  const { session } = await getOrganizationAuth(params.organizationId);
-
-  if (!session?.user) {
-    return redirect(`/auth/login`);
-  }
-
-  return <SelectPlanOnboarding organizationId={params.organizationId} />;
-};
-
-export default Page;

apps/web/app/(app)/(onboarding)/organizations/[organizationId]/workspaces/new/settings/page.tsx

@@ -42,7 +42,7 @@ const Page = async (props: ProjectSettingsPageProps) => {
 
   const organizationTeams = await getTeamsByOrganizationId(params.organizationId);
 
-  const isAccessControlAllowed = await getAccessControlPermission(organization.id);
+  const isAccessControlAllowed = await getAccessControlPermission(organization.billing.plan);
 
   if (!organizationTeams) {
     throw new Error(t("common.organization_teams_not_found"));

apps/web/app/(app)/(onboarding)/organizations/components/OnboardingOptionsContainer.tsx

@@ -16,7 +16,7 @@ interface OnboardingOptionsContainerProps {
 }
 
 export const OnboardingOptionsContainer = ({ options }: OnboardingOptionsContainerProps) => {
-  const getOptionCard = (option: OnboardingOptionsContainerProps["options"][number]) => {
+  const getOptionCard = (option) => {
     const Icon = option.icon;
     return (
       <OptionCard

apps/web/app/(app)/(survey-editor)/environments/[environmentId]/layout.tsx

@@ -2,10 +2,7 @@ import { redirect } from "next/navigation";
 import { getEnvironment } from "@/lib/environment/service";
 import { environmentIdLayoutChecks } from "@/modules/environments/lib/utils";
 
-const SurveyEditorEnvironmentLayout = async (props: {
-  params: Promise<{ environmentId: string }>;
-  children: React.ReactNode;
-}) => {
+const SurveyEditorEnvironmentLayout = async (props) => {
   const params = await props.params;
 
   const { children } = props;

apps/web/app/(app)/billing-confirmation/components/ConfirmationPage.tsx

@@ -6,26 +6,15 @@ import { useTranslation } from "react-i18next";
 import { Button } from "@/modules/ui/components/button";
 import { Confetti } from "@/modules/ui/components/confetti";
 
-const BILLING_CONFIRMATION_ENVIRONMENT_ID_KEY = "billingConfirmationEnvironmentId";
+interface ConfirmationPageProps {
+  environmentId: string;
+}
 
-export const ConfirmationPage = () => {
+export const ConfirmationPage = ({ environmentId }: ConfirmationPageProps) => {
   const { t } = useTranslation();
   const [showConfetti, setShowConfetti] = useState(false);
-  const [resolvedEnvironmentId, setResolvedEnvironmentId] = useState<string | null>(null);
-
   useEffect(() => {
     setShowConfetti(true);
-
-    if (globalThis.window === undefined) {
-      return;
-    }
-
-    const storedEnvironmentId = globalThis.window.sessionStorage.getItem(
-      BILLING_CONFIRMATION_ENVIRONMENT_ID_KEY
-    );
-    if (storedEnvironmentId) {
-      setResolvedEnvironmentId(storedEnvironmentId);
-    }
   }, []);
 
   return (
@@ -41,12 +30,7 @@ export const ConfirmationPage = () => {
           </p>
         </div>
         <Button asChild className="w-full justify-center">
-          <Link
-            href={
-              resolvedEnvironmentId
-                ? `/environments/${resolvedEnvironmentId}/settings/billing`
-                : "/environments"
-            }>
+          <Link href={`/environments/${environmentId}/settings/billing`}>
             {t("billing_confirmation.back_to_billing_overview")}
           </Link>
         </Button>

apps/web/app/(app)/billing-confirmation/page.tsx

@@ -3,10 +3,13 @@ import { PageContentWrapper } from "@/modules/ui/components/page-content-wrapper
 
 export const dynamic = "force-dynamic";
 
-const Page = async () => {
+const Page = async (props) => {
+  const searchParams = await props.searchParams;
+  const { environmentId } = searchParams;
+
   return (
     <PageContentWrapper>
-      <ConfirmationPage />
+      <ConfirmationPage environmentId={environmentId?.toString()} />
     </PageContentWrapper>
   );
 };

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

@@ -10,6 +10,7 @@ import { getOrganizationProjectsCount } from "@/lib/project/service";
 import { updateUser } from "@/lib/user/service";
 import { authenticatedActionClient } from "@/lib/utils/action-client";
 import { checkAuthorizationUpdated } from "@/lib/utils/action-client/action-client-middleware";
+import { AuthenticatedActionClientCtx } from "@/lib/utils/action-client/types/context";
 import { withAuditLogging } from "@/modules/ee/audit-logs/lib/handler";
 import {
   getAccessControlPermission,
@@ -25,62 +26,66 @@ const ZCreateProjectAction = z.object({
 });
 
 export const createProjectAction = authenticatedActionClient.inputSchema(ZCreateProjectAction).action(
-  withAuditLogging("created", "project", async ({ ctx, parsedInput }) => {
-    const { user } = ctx;
+  withAuditLogging(
+    "created",
+    "project",
+    async ({ ctx, parsedInput }: { ctx: AuthenticatedActionClientCtx; parsedInput: Record<string, any> }) => {
+      const { user } = ctx;
 
-    const organizationId = parsedInput.organizationId;
+      const organizationId = parsedInput.organizationId;
 
-    await checkAuthorizationUpdated({
-      userId: user.id,
-      organizationId: parsedInput.organizationId,
-      access: [
-        {
-          data: parsedInput.data,
-          schema: ZProjectUpdateInput,
-          type: "organization",
-          roles: ["owner", "manager"],
-        },
-      ],
-    });
+      await checkAuthorizationUpdated({
+        userId: user.id,
+        organizationId: parsedInput.organizationId,
+        access: [
+          {
+            data: parsedInput.data,
+            schema: ZProjectUpdateInput,
+            type: "organization",
+            roles: ["owner", "manager"],
+          },
+        ],
+      });
 
-    const organization = await getOrganization(organizationId);
+      const organization = await getOrganization(organizationId);
 
-    if (!organization) {
-      throw new Error("Organization not found");
-    }
-
-    const organizationProjectsLimit = await getOrganizationProjectsLimit(organization.id);
-    const organizationProjectsCount = await getOrganizationProjectsCount(organization.id);
-
-    if (organizationProjectsCount >= organizationProjectsLimit) {
-      throw new OperationNotAllowedError("Organization workspace limit reached");
-    }
-
-    if (parsedInput.data.teamIds && parsedInput.data.teamIds.length > 0) {
-      const isAccessControlAllowed = await getAccessControlPermission(organization.id);
-
-      if (!isAccessControlAllowed) {
-        throw new OperationNotAllowedError("You do not have permission to manage roles");
+      if (!organization) {
+        throw new Error("Organization not found");
       }
+
+      const organizationProjectsLimit = await getOrganizationProjectsLimit(organization.billing.limits);
+      const organizationProjectsCount = await getOrganizationProjectsCount(organization.id);
+
+      if (organizationProjectsCount >= organizationProjectsLimit) {
+        throw new OperationNotAllowedError("Organization workspace limit reached");
+      }
+
+      if (parsedInput.data.teamIds && parsedInput.data.teamIds.length > 0) {
+        const isAccessControlAllowed = await getAccessControlPermission(organization.billing.plan);
+
+        if (!isAccessControlAllowed) {
+          throw new OperationNotAllowedError("You do not have permission to manage roles");
+        }
+      }
+
+      const project = await createProject(parsedInput.organizationId, parsedInput.data);
+      const updatedNotificationSettings = {
+        ...user.notificationSettings,
+        alert: {
+          ...user.notificationSettings?.alert,
+        },
+      };
+
+      await updateUser(user.id, {
+        notificationSettings: updatedNotificationSettings,
+      });
+
+      ctx.auditLoggingCtx.organizationId = organizationId;
+      ctx.auditLoggingCtx.projectId = project.id;
+      ctx.auditLoggingCtx.newObject = project;
+      return project;
     }
-
-    const project = await createProject(parsedInput.organizationId, parsedInput.data);
-    const updatedNotificationSettings = {
-      ...user.notificationSettings,
-      alert: {
-        ...user.notificationSettings?.alert,
-      },
-    };
-
-    await updateUser(user.id, {
-      notificationSettings: updatedNotificationSettings,
-    });
-
-    ctx.auditLoggingCtx.organizationId = organizationId;
-    ctx.auditLoggingCtx.projectId = project.id;
-    ctx.auditLoggingCtx.newObject = project;
-    return project;
-  })
+  )
 );
 
 const ZGetOrganizationsForSwitcherAction = z.object({

apps/web/app/(app)/environments/[environmentId]/components/EnvironmentLayout.tsx

@@ -29,6 +29,7 @@ export const EnvironmentLayout = async ({ layoutData, children }: EnvironmentLay
     isAccessControlAllowed,
     projectPermission,
     license,
+    peopleCount,
     responseCount,
   } = layoutData;
 
@@ -37,7 +38,7 @@ export const EnvironmentLayout = async ({ layoutData, children }: EnvironmentLay
 
   const { features, lastChecked, isPendingDowngrade, active, status } = license;
   const isMultiOrgEnabled = features?.isMultiOrgEnabled ?? false;
-  const organizationProjectsLimit = await getOrganizationProjectsLimit(organization.id);
+  const organizationProjectsLimit = await getOrganizationProjectsLimit(organization.billing.limits);
   const isOwnerOrManager = isOwner || isManager;
 
   // Validate that project permission exists for members
@@ -51,6 +52,7 @@ export const EnvironmentLayout = async ({ layoutData, children }: EnvironmentLay
         <LimitsReachedBanner
           organization={organization}
           environmentId={environment.id}
+          peopleCount={peopleCount}
           responseCount={responseCount}
         />
       )}

apps/web/app/(app)/environments/[environmentId]/components/MainNavigation.tsx

@@ -126,7 +126,7 @@ export const MainNavigation = ({
         name: t("common.configuration"),
         href: `/environments/${environment.id}/workspace/general`,
         icon: Cog,
-        isActive: pathname?.includes("/workspace"),
+        isActive: pathname?.includes("/project"),
       },
     ],
     [t, environment.id, pathname, isFormbricksCloud]

apps/web/app/(app)/environments/[environmentId]/page.tsx

@@ -4,7 +4,7 @@ import { getMembershipByUserIdOrganizationId } from "@/lib/membership/service";
 import { getAccessFlags } from "@/lib/membership/utils";
 import { getEnvironmentAuth } from "@/modules/environments/lib/utils";
 
-const EnvironmentPage = async (props: { params: Promise<{ environmentId: string }> }) => {
+const EnvironmentPage = async (props) => {
   const params = await props.params;
   const { session, organization } = await getEnvironmentAuth(params.environmentId);
 

apps/web/app/(app)/environments/[environmentId]/settings/(account)/layout.tsx

@@ -4,10 +4,7 @@ import { getProjectByEnvironmentId } from "@/lib/project/service";
 import { getTranslate } from "@/lingodotdev/server";
 import { authOptions } from "@/modules/auth/lib/authOptions";
 
-const AccountSettingsLayout = async (props: {
-  params: Promise<{ environmentId: string }>;
-  children: React.ReactNode;
-}) => {
+const AccountSettingsLayout = async (props) => {
   const params = await props.params;
 
   const { children } = props;

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

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { ZUserNotificationSettings } from "@formbricks/types/user";
 import { getUser, updateUser } from "@/lib/user/service";
 import { authenticatedActionClient } from "@/lib/utils/action-client";
+import { AuthenticatedActionClientCtx } from "@/lib/utils/action-client/types/context";
 import { withAuditLogging } from "@/modules/ee/audit-logs/lib/handler";
 
 const ZUpdateNotificationSettingsAction = z.object({
@@ -13,14 +14,24 @@ const ZUpdateNotificationSettingsAction = z.object({
 export const updateNotificationSettingsAction = authenticatedActionClient
   .inputSchema(ZUpdateNotificationSettingsAction)
   .action(
-    withAuditLogging("updated", "user", async ({ ctx, parsedInput }) => {
-      const oldObject = await getUser(ctx.user.id);
-      const result = await updateUser(ctx.user.id, {
-        notificationSettings: parsedInput.notificationSettings,
-      });
-      ctx.auditLoggingCtx.userId = ctx.user.id;
-      ctx.auditLoggingCtx.oldObject = oldObject;
-      ctx.auditLoggingCtx.newObject = result;
-      return result;
-    })
+    withAuditLogging(
+      "updated",
+      "user",
+      async ({
+        ctx,
+        parsedInput,
+      }: {
+        ctx: AuthenticatedActionClientCtx;
+        parsedInput: Record<string, any>;
+      }) => {
+        const oldObject = await getUser(ctx.user.id);
+        const result = await updateUser(ctx.user.id, {
+          notificationSettings: parsedInput.notificationSettings,
+        });
+        ctx.auditLoggingCtx.userId = ctx.user.id;
+        ctx.auditLoggingCtx.oldObject = oldObject;
+        ctx.auditLoggingCtx.newObject = result;
+        return result;
+      }
+    )
   );

apps/web/app/(app)/environments/[environmentId]/settings/(account)/notifications/page.tsx

@@ -16,8 +16,8 @@ const setCompleteNotificationSettings = (
   notificationSettings: TUserNotificationSettings,
   memberships: Membership[]
 ): TUserNotificationSettings => {
-  const newNotificationSettings: TUserNotificationSettings = {
-    alert: {} as Record<string, boolean>,
+  const newNotificationSettings = {
+    alert: {},
     unsubscribedOrganizationIds: notificationSettings.unsubscribedOrganizationIds || [],
   };
   for (const membership of memberships) {
@@ -26,8 +26,7 @@ const setCompleteNotificationSettings = (
       for (const environment of project.environments) {
         for (const survey of environment.surveys) {
           newNotificationSettings.alert[survey.id] =
-            (notificationSettings as unknown as Record<string, Record<string, boolean>>)[survey.id]
-              ?.responseFinished ||
+            notificationSettings[survey.id]?.responseFinished ||
             (notificationSettings.alert && notificationSettings.alert[survey.id]) ||
             false; // check for legacy notification settings w/o "alerts" key
         }
@@ -137,10 +136,7 @@ const getMemberships = async (userId: string): Promise<Membership[]> => {
   return memberships;
 };
 
-const Page = async (props: {
-  params: Promise<{ environmentId: string }>;
-  searchParams: Promise<Record<string, string>>;
-}) => {
+const Page = async (props) => {
   const searchParams = await props.searchParams;
   const params = await props.params;
   const t = await getTranslate();

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

@@ -20,7 +20,7 @@ import { rateLimitConfigs } from "@/modules/core/rate-limit/rate-limit-configs";
 import { withAuditLogging } from "@/modules/ee/audit-logs/lib/handler";
 import { sendForgotPasswordEmail, sendVerificationNewEmail } from "@/modules/email";
 
-function buildUserUpdatePayload(parsedInput: TUserPersonalInfoUpdateInput): TUserUpdateInput {
+function buildUserUpdatePayload(parsedInput: any): TUserUpdateInput {
   return {
     ...(parsedInput.name && { name: parsedInput.name }),
     ...(parsedInput.locale && { locale: parsedInput.locale }),
@@ -64,35 +64,49 @@ async function handleEmailUpdate({
 }
 
 export const updateUserAction = authenticatedActionClient.inputSchema(ZUserPersonalInfoUpdateInput).action(
-  withAuditLogging("updated", "user", async ({ ctx, parsedInput }) => {
-    const oldObject = await getUser(ctx.user.id);
-    let payload = buildUserUpdatePayload(parsedInput);
-    payload = await handleEmailUpdate({ ctx, parsedInput, payload });
+  withAuditLogging(
+    "updated",
+    "user",
+    async ({
+      ctx,
+      parsedInput,
+    }: {
+      ctx: AuthenticatedActionClientCtx;
+      parsedInput: TUserPersonalInfoUpdateInput;
+    }) => {
+      const oldObject = await getUser(ctx.user.id);
+      let payload = buildUserUpdatePayload(parsedInput);
+      payload = await handleEmailUpdate({ ctx, parsedInput, payload });
 
-    // Only proceed with updateUser if we have actual changes to make
-    let newObject = oldObject;
-    if (Object.keys(payload).length > 0) {
-      newObject = await updateUser(ctx.user.id, payload);
+      // Only proceed with updateUser if we have actual changes to make
+      let newObject = oldObject;
+      if (Object.keys(payload).length > 0) {
+        newObject = await updateUser(ctx.user.id, payload);
+      }
+
+      ctx.auditLoggingCtx.userId = ctx.user.id;
+      ctx.auditLoggingCtx.oldObject = oldObject;
+      ctx.auditLoggingCtx.newObject = newObject;
+
+      return true;
     }
-
-    ctx.auditLoggingCtx.userId = ctx.user.id;
-    ctx.auditLoggingCtx.oldObject = oldObject;
-    ctx.auditLoggingCtx.newObject = newObject;
-
-    return true;
-  })
+  )
 );
 
 export const resetPasswordAction = authenticatedActionClient.action(
-  withAuditLogging("passwordReset", "user", async ({ ctx }) => {
-    if (ctx.user.identityProvider !== "email") {
-      throw new OperationNotAllowedError("Password reset is not allowed for this user.");
+  withAuditLogging(
+    "passwordReset",
+    "user",
+    async ({ ctx }: { ctx: AuthenticatedActionClientCtx; parsedInput: undefined }) => {
+      if (ctx.user.identityProvider !== "email") {
+        throw new OperationNotAllowedError("Password reset is not allowed for this user.");
+      }
+
+      await sendForgotPasswordEmail(ctx.user);
+
+      ctx.auditLoggingCtx.userId = ctx.user.id;
+
+      return { success: true };
     }
-
-    await sendForgotPasswordEmail(ctx.user);
-
-    ctx.auditLoggingCtx.userId = ctx.user.id;
-
-    return { success: true };
-  })
+  )
 );

apps/web/app/(app)/environments/[environmentId]/settings/(organization)/domain/page.tsx

@@ -28,7 +28,7 @@ const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
     throw new Error(t("common.session_not_found"));
   }
 
-  const hasWhiteLabelPermission = await getWhiteLabelPermission(organization.id);
+  const hasWhiteLabelPermission = await getWhiteLabelPermission(organization.billing.plan);
   const isOwnerOrManager = isManager || isOwner;
 
   const surveys = await getSurveysWithSlugsByOrganizationId(organization.id);

apps/web/app/(app)/environments/[environmentId]/settings/(organization)/enterprise/components/EnterpriseLicenseStatus.tsx

@@ -7,20 +7,21 @@ import { useState } from "react";
 import toast from "react-hot-toast";
 import { useTranslation } from "react-i18next";
 import { recheckLicenseAction } from "@/modules/ee/license-check/actions";
-import type { TLicenseStatus } from "@/modules/ee/license-check/types/enterprise-license";
 import { Alert, AlertDescription } from "@/modules/ui/components/alert";
 import { Badge } from "@/modules/ui/components/badge";
 import { Button } from "@/modules/ui/components/button";
 import { SettingsCard } from "../../../components/SettingsCard";
 
+type LicenseStatus = "active" | "expired" | "unreachable" | "invalid_license";
+
 interface EnterpriseLicenseStatusProps {
-  status: TLicenseStatus;
+  status: LicenseStatus;
   gracePeriodEnd?: Date;
   environmentId: string;
 }
 
 const getBadgeConfig = (
-  status: TLicenseStatus,
+  status: LicenseStatus,
   t: TFunction
 ): { type: "success" | "error" | "warning" | "gray"; label: string } => {
   switch (status) {
@@ -28,11 +29,6 @@ const getBadgeConfig = (
       return { type: "success", label: t("environments.settings.enterprise.license_status_active") };
     case "expired":
       return { type: "error", label: t("environments.settings.enterprise.license_status_expired") };
-    case "instance_mismatch":
-      return {
-        type: "error",
-        label: t("environments.settings.enterprise.license_status_instance_mismatch"),
-      };
     case "unreachable":
       return { type: "warning", label: t("environments.settings.enterprise.license_status_unreachable") };
     case "invalid_license":
@@ -63,8 +59,6 @@ export const EnterpriseLicenseStatus = ({
       if (result?.data) {
         if (result.data.status === "unreachable") {
           toast.error(t("environments.settings.enterprise.recheck_license_unreachable"));
-        } else if (result.data.status === "instance_mismatch") {
-          toast.error(t("environments.settings.enterprise.recheck_license_instance_mismatch"));
         } else if (result.data.status === "invalid_license") {
           toast.error(t("environments.settings.enterprise.recheck_license_invalid"));
         } else {
@@ -134,13 +128,6 @@ export const EnterpriseLicenseStatus = ({
             </AlertDescription>
           </Alert>
         )}
-        {status === "instance_mismatch" && (
-          <Alert variant="error" size="small">
-            <AlertDescription className="overflow-visible whitespace-normal">
-              {t("environments.settings.enterprise.license_instance_mismatch_description")}
-            </AlertDescription>
-          </Alert>
-        )}
         <p className="border-t border-slate-100 pt-4 text-sm text-slate-500">
           {t("environments.settings.enterprise.questions_please_reach_out_to")}{" "}
           <a

apps/web/app/(app)/environments/[environmentId]/settings/(organization)/enterprise/page.tsx

@@ -11,7 +11,7 @@ import { Button } from "@/modules/ui/components/button";
 import { PageContentWrapper } from "@/modules/ui/components/page-content-wrapper";
 import { PageHeader } from "@/modules/ui/components/page-header";
 
-const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
+const Page = async (props) => {
   const params = await props.params;
   const t = await getTranslate();
   if (IS_FORMBRICKS_CLOUD) {
@@ -94,7 +94,7 @@ const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
       </PageHeader>
       {hasLicense ? (
         <EnterpriseLicenseStatus
-          status={licenseState.status}
+          status={licenseState.status as "active" | "expired" | "unreachable" | "invalid_license"}
           gracePeriodEnd={
             licenseState.status === "unreachable"
               ? new Date(licenseState.lastChecked.getTime() + GRACE_PERIOD_MS)

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

@@ -7,6 +7,7 @@ import { ZOrganizationUpdateInput } from "@formbricks/types/organizations";
 import { deleteOrganization, getOrganization, updateOrganization } from "@/lib/organization/service";
 import { authenticatedActionClient } from "@/lib/utils/action-client";
 import { checkAuthorizationUpdated } from "@/lib/utils/action-client/action-client-middleware";
+import { AuthenticatedActionClientCtx } from "@/lib/utils/action-client/types/context";
 import { withAuditLogging } from "@/modules/ee/audit-logs/lib/handler";
 import { getIsMultiOrgEnabled } from "@/modules/ee/license-check/lib/utils";
 
@@ -18,26 +19,36 @@ const ZUpdateOrganizationNameAction = z.object({
 export const updateOrganizationNameAction = authenticatedActionClient
   .inputSchema(ZUpdateOrganizationNameAction)
   .action(
-    withAuditLogging("updated", "organization", async ({ ctx, parsedInput }) => {
-      await checkAuthorizationUpdated({
-        userId: ctx.user.id,
-        organizationId: parsedInput.organizationId,
-        access: [
-          {
-            type: "organization",
-            schema: ZOrganizationUpdateInput.pick({ name: true }),
-            data: parsedInput.data,
-            roles: ["owner"],
-          },
-        ],
-      });
-      ctx.auditLoggingCtx.organizationId = parsedInput.organizationId;
-      const oldObject = await getOrganization(parsedInput.organizationId);
-      const result = await updateOrganization(parsedInput.organizationId, parsedInput.data);
-      ctx.auditLoggingCtx.oldObject = oldObject;
-      ctx.auditLoggingCtx.newObject = result;
-      return result;
-    })
+    withAuditLogging(
+      "updated",
+      "organization",
+      async ({
+        ctx,
+        parsedInput,
+      }: {
+        ctx: AuthenticatedActionClientCtx;
+        parsedInput: Record<string, any>;
+      }) => {
+        await checkAuthorizationUpdated({
+          userId: ctx.user.id,
+          organizationId: parsedInput.organizationId,
+          access: [
+            {
+              type: "organization",
+              schema: ZOrganizationUpdateInput.pick({ name: true }),
+              data: parsedInput.data,
+              roles: ["owner"],
+            },
+          ],
+        });
+        ctx.auditLoggingCtx.organizationId = parsedInput.organizationId;
+        const oldObject = await getOrganization(parsedInput.organizationId);
+        const result = await updateOrganization(parsedInput.organizationId, parsedInput.data);
+        ctx.auditLoggingCtx.oldObject = oldObject;
+        ctx.auditLoggingCtx.newObject = result;
+        return result;
+      }
+    )
   );
 
 const ZDeleteOrganizationAction = z.object({
@@ -47,23 +58,33 @@ const ZDeleteOrganizationAction = z.object({
 export const deleteOrganizationAction = authenticatedActionClient
   .inputSchema(ZDeleteOrganizationAction)
   .action(
-    withAuditLogging("deleted", "organization", async ({ ctx, parsedInput }) => {
-      const isMultiOrgEnabled = await getIsMultiOrgEnabled();
-      if (!isMultiOrgEnabled) throw new OperationNotAllowedError("Organization deletion disabled");
+    withAuditLogging(
+      "deleted",
+      "organization",
+      async ({
+        ctx,
+        parsedInput,
+      }: {
+        ctx: AuthenticatedActionClientCtx;
+        parsedInput: Record<string, any>;
+      }) => {
+        const isMultiOrgEnabled = await getIsMultiOrgEnabled();
+        if (!isMultiOrgEnabled) throw new OperationNotAllowedError("Organization deletion disabled");
 
-      await checkAuthorizationUpdated({
-        userId: ctx.user.id,
-        organizationId: parsedInput.organizationId,
-        access: [
-          {
-            type: "organization",
-            roles: ["owner"],
-          },
-        ],
-      });
-      ctx.auditLoggingCtx.organizationId = parsedInput.organizationId;
-      const oldObject = await getOrganization(parsedInput.organizationId);
-      ctx.auditLoggingCtx.oldObject = oldObject;
-      return await deleteOrganization(parsedInput.organizationId);
-    })
+        await checkAuthorizationUpdated({
+          userId: ctx.user.id,
+          organizationId: parsedInput.organizationId,
+          access: [
+            {
+              type: "organization",
+              roles: ["owner"],
+            },
+          ],
+        });
+        ctx.auditLoggingCtx.organizationId = parsedInput.organizationId;
+        const oldObject = await getOrganization(parsedInput.organizationId);
+        ctx.auditLoggingCtx.oldObject = oldObject;
+        return await deleteOrganization(parsedInput.organizationId);
+      }
+    )
   );

apps/web/app/(app)/environments/[environmentId]/settings/(organization)/general/components/DeleteOrganization.tsx

@@ -107,7 +107,7 @@ const DeleteOrganizationModal = ({
 }: DeleteOrganizationModalProps) => {
   const [inputValue, setInputValue] = useState("");
   const { t } = useTranslation();
-  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+  const handleInputChange = (e) => {
     setInputValue(e.target.value);
   };
 

apps/web/app/(app)/environments/[environmentId]/settings/(organization)/general/components/EditOrganizationNameForm.tsx

@@ -61,7 +61,7 @@ export const EditOrganizationNameForm = ({ organization, membershipRole }: EditO
         toast.error(errorMessage);
       }
     } catch (err) {
-      toast.error(`Error: ${err instanceof Error ? err.message : "Unknown error occurred"}`);
+      toast.error(`Error: ${err.message}`);
     }
   };
 

apps/web/app/(app)/environments/[environmentId]/settings/(organization)/general/page.tsx

@@ -26,7 +26,7 @@ const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
   const user = session?.user?.id ? await getUser(session.user.id) : null;
 
   const isMultiOrgEnabled = await getIsMultiOrgEnabled();
-  const hasWhiteLabelPermission = await getWhiteLabelPermission(organization.id);
+  const hasWhiteLabelPermission = await getWhiteLabelPermission(organization.billing.plan);
 
   const isDeleteDisabled = !isOwner || !isMultiOrgEnabled;
   const currentUserRole = currentUserMembership?.role;

apps/web/app/(app)/environments/[environmentId]/settings/(organization)/layout.tsx

@@ -4,7 +4,7 @@ import { getProjectByEnvironmentId } from "@/lib/project/service";
 import { getTranslate } from "@/lingodotdev/server";
 import { authOptions } from "@/modules/auth/lib/authOptions";
 
-const Layout = async (props: { params: Promise<{ environmentId: string }>; children: React.ReactNode }) => {
+const Layout = async (props) => {
   const params = await props.params;
 
   const { children } = props;

apps/web/app/(app)/environments/[environmentId]/settings/components/SettingsTitle.tsx

@@ -1,3 +1,3 @@
-export const SettingsTitle = ({ title }: { title: string }) => {
+export const SettingsTitle = ({ title }) => {
   return <h2 className="my-4 text-2xl font-medium leading-6 text-slate-800">{title}</h2>;
 };

apps/web/app/(app)/environments/[environmentId]/settings/page.tsx

@@ -1,6 +1,6 @@
 import { redirect } from "next/navigation";
 
-const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
+const Page = async (props) => {
   const params = await props.params;
   return redirect(`/environments/${params.environmentId}/settings/profile`);
 };

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

@@ -27,7 +27,7 @@ export const generateMetadata = async (props: Props): Promise<Metadata> => {
   };
 };
 
-const SurveyLayout = async ({ children }: { children: React.ReactNode }) => {
+const SurveyLayout = async ({ children }) => {
   return <ResponseFilterProvider>{children}</ResponseFilterProvider>;
 };
 

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

@@ -205,11 +205,11 @@ export const ResponseTable = ({
   };
 
   // Handle downloading selected responses
-  const downloadSelectedRows = async (responseIds: string[], format: "xlsx" | "csv") => {
+  const downloadSelectedRows = async (responseIds: string[], format: "csv" | "xlsx") => {
     try {
       const downloadResponse = await getResponsesDownloadUrlAction({
         surveyId: survey.id,
-        format,
+        format: format,
         filterCriteria: { responseIds },
       });
 

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

@@ -5,7 +5,7 @@ import { TFunction } from "i18next";
 import { CircleHelpIcon, EyeOffIcon, MailIcon, TagIcon } from "lucide-react";
 import Link from "next/link";
 import { TResponseTableData } from "@formbricks/types/responses";
-import { TSurveyElement, TSurveyElementTypeEnum } from "@formbricks/types/surveys/elements";
+import { TSurveyElement } from "@formbricks/types/surveys/elements";
 import { TSurvey } from "@formbricks/types/surveys/types";
 import { getTextContent } from "@formbricks/types/surveys/validation";
 import { getLocalizedValue } from "@/lib/i18n/utils";
@@ -41,7 +41,7 @@ const getElementColumnsData = (
   const contactInfoFields = ["firstName", "lastName", "email", "phone", "company"];
 
   // Helper function to create consistent column headers
-  const createElementHeader = (elementType: TSurveyElementTypeEnum, headline: string, suffix?: string) => {
+  const createElementHeader = (elementType: string, headline: string, suffix?: string) => {
     const title = suffix ? `${headline} - ${suffix}` : headline;
     const ElementHeader = () => (
       <div className="flex items-center justify-between">
@@ -232,7 +232,7 @@ const getMetadataColumnsData = (t: TFunction): ColumnDef<TResponseTableData>[] =
   const metadataColumns: ColumnDef<TResponseTableData>[] = [];
 
   METADATA_FIELDS.forEach((label) => {
-    const IconComponent = COLUMNS_ICON_MAP[label as keyof typeof COLUMNS_ICON_MAP];
+    const IconComponent = COLUMNS_ICON_MAP[label];
 
     metadataColumns.push({
       accessorKey: "METADATA_" + label,

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

@@ -1,5 +1,4 @@
 import "@testing-library/jest-dom/vitest";
-import { TFunction } from "i18next";
 import {
   AirplayIcon,
   ArrowUpFromDotIcon,
@@ -39,7 +38,7 @@ describe("utils", () => {
       "environments.surveys.responses.source": "Source",
     };
     return translations[key] || key;
-  }) as unknown as TFunction;
+  });
 
   describe("getAddressFieldLabel", () => {
     test("returns correct label for addressLine1", () => {

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

@@ -80,24 +80,9 @@ export const COLUMNS_ICON_MAP = {
 const userAgentFields = ["browser", "os", "device"];
 export const METADATA_FIELDS = ["action", "country", ...userAgentFields, "source", "url"];
 
-export const getMetadataValue = (
-  meta: TResponseMeta,
-  label: (typeof METADATA_FIELDS)[number]
-): string | undefined => {
-  switch (label) {
-    case "browser":
-      return meta.userAgent?.browser;
-    case "os":
-      return meta.userAgent?.os;
-    case "device":
-      return meta.userAgent?.device;
-    case "action":
-      return meta.action;
-    case "country":
-      return meta.country;
-    case "source":
-      return meta.source;
-    case "url":
-      return meta.url;
+export const getMetadataValue = (meta: TResponseMeta, label: string) => {
+  if (userAgentFields.includes(label)) {
+    return meta.userAgent?.[label];
   }
+  return meta[label];
 };

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

@@ -17,7 +17,7 @@ import { getOrganizationBilling } from "@/modules/survey/lib/survey";
 import { PageContentWrapper } from "@/modules/ui/components/page-content-wrapper";
 import { PageHeader } from "@/modules/ui/components/page-header";
 
-const Page = async (props: { params: Promise<{ environmentId: string; surveyId: string }> }) => {
+const Page = async (props) => {
   const params = await props.params;
   const t = await getTranslate();
 
@@ -27,7 +27,7 @@ const Page = async (props: { params: Promise<{ environmentId: string; surveyId:
     getSurvey(params.surveyId),
     getUser(session.user.id),
     getTagsByEnvironmentId(params.environmentId),
-    getIsContactsEnabled(organization.id),
+    getIsContactsEnabled(),
     getResponseCountBySurveyId(params.surveyId),
     findMatchingLocale(),
   ]);
@@ -53,7 +53,7 @@ const Page = async (props: { params: Promise<{ environmentId: string; surveyId:
     throw new Error(t("common.organization_not_found"));
   }
 
-  const isQuotasAllowed = await getIsQuotasEnabled(organization.id);
+  const isQuotasAllowed = await getIsQuotasEnabled(organizationBilling.plan);
   const quotas = isQuotasAllowed ? await getQuotas(survey.id) : [];
 
   // Fetch initial responses on the server to prevent duplicate client-side fetch

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

@@ -7,6 +7,7 @@ import { getEmailTemplateHtml } from "@/app/(app)/environments/[environmentId]/s
 import { getSurvey, updateSurvey } from "@/lib/survey/service";
 import { authenticatedActionClient } from "@/lib/utils/action-client";
 import { checkAuthorizationUpdated } from "@/lib/utils/action-client/action-client-middleware";
+import { AuthenticatedActionClientCtx } from "@/lib/utils/action-client/types/context";
 import { convertToCsv } from "@/lib/utils/file-conversion";
 import { getOrganizationIdFromSurveyId, getProjectIdFromSurveyId } from "@/lib/utils/helper";
 import { withAuditLogging } from "@/modules/ee/audit-logs/lib/handler";
@@ -69,42 +70,52 @@ const ZResetSurveyAction = z.object({
 });
 
 export const resetSurveyAction = authenticatedActionClient.inputSchema(ZResetSurveyAction).action(
-  withAuditLogging("updated", "survey", async ({ ctx, parsedInput }) => {
-    await checkAuthorizationUpdated({
-      userId: ctx.user.id,
-      organizationId: parsedInput.organizationId,
-      access: [
-        {
-          type: "organization",
-          roles: ["owner", "manager"],
-        },
-        {
-          type: "projectTeam",
-          minPermission: "readWrite",
-          projectId: parsedInput.projectId,
-        },
-      ],
-    });
+  withAuditLogging(
+    "updated",
+    "survey",
+    async ({
+      ctx,
+      parsedInput,
+    }: {
+      ctx: AuthenticatedActionClientCtx;
+      parsedInput: z.infer<typeof ZResetSurveyAction>;
+    }) => {
+      await checkAuthorizationUpdated({
+        userId: ctx.user.id,
+        organizationId: parsedInput.organizationId,
+        access: [
+          {
+            type: "organization",
+            roles: ["owner", "manager"],
+          },
+          {
+            type: "projectTeam",
+            minPermission: "readWrite",
+            projectId: parsedInput.projectId,
+          },
+        ],
+      });
 
-    ctx.auditLoggingCtx.organizationId = parsedInput.organizationId;
-    ctx.auditLoggingCtx.surveyId = parsedInput.surveyId;
-    ctx.auditLoggingCtx.oldObject = null;
+      ctx.auditLoggingCtx.organizationId = parsedInput.organizationId;
+      ctx.auditLoggingCtx.surveyId = parsedInput.surveyId;
+      ctx.auditLoggingCtx.oldObject = null;
 
-    const { deletedResponsesCount, deletedDisplaysCount } = await deleteResponsesAndDisplaysForSurvey(
-      parsedInput.surveyId
-    );
+      const { deletedResponsesCount, deletedDisplaysCount } = await deleteResponsesAndDisplaysForSurvey(
+        parsedInput.surveyId
+      );
 
-    ctx.auditLoggingCtx.newObject = {
-      deletedResponsesCount: deletedResponsesCount,
-      deletedDisplaysCount: deletedDisplaysCount,
-    };
+      ctx.auditLoggingCtx.newObject = {
+        deletedResponsesCount: deletedResponsesCount,
+        deletedDisplaysCount: deletedDisplaysCount,
+      };
 
-    return {
-      success: true,
-      deletedResponsesCount: deletedResponsesCount,
-      deletedDisplaysCount: deletedDisplaysCount,
-    };
-  })
+      return {
+        success: true,
+        deletedResponsesCount: deletedResponsesCount,
+        deletedDisplaysCount: deletedDisplaysCount,
+      };
+    }
+  )
 );
 
 const ZGetEmailHtmlAction = z.object({
@@ -143,8 +154,7 @@ const ZGeneratePersonalLinksAction = z.object({
 export const generatePersonalLinksAction = authenticatedActionClient
   .inputSchema(ZGeneratePersonalLinksAction)
   .action(async ({ ctx, parsedInput }) => {
-    const organizationId = await getOrganizationIdFromSurveyId(parsedInput.surveyId);
-    const isContactsEnabled = await getIsContactsEnabled(organizationId);
+    const isContactsEnabled = await getIsContactsEnabled();
     if (!isContactsEnabled) {
       throw new OperationNotAllowedError("Contacts are not enabled for this environment");
     }

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

@@ -60,9 +60,7 @@ export const NPSSummary = ({ elementSummary, survey, setFilter }: NPSSummaryProp
       },
     };
 
-    const filter = (filters as Record<string, { comparison: string; values: string | string[] | undefined }>)[
-      group
-    ];
+    const filter = filters[group];
 
     if (filter) {
       setFilter(
@@ -106,7 +104,7 @@ export const NPSSummary = ({ elementSummary, survey, setFilter }: NPSSummaryProp
         <TabsContent value="aggregated" className="mt-4">
           <div className="px-4 pb-6 pt-4 md:px-6">
             <div className="space-y-5 text-sm md:text-base">
-              {(["promoters", "passives", "detractors", "dismissed"] as const).map((group) => (
+              {["promoters", "passives", "detractors", "dismissed"].map((group) => (
                 <button
                   className="w-full cursor-pointer hover:opacity-80"
                   key={group}

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

@@ -15,7 +15,7 @@ interface SummaryMetadataProps {
   isQuotasAllowed: boolean;
 }
 
-const formatTime = (ttc: number) => {
+const formatTime = (ttc) => {
   const seconds = ttc / 1000;
   let formattedValue;
 

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

@@ -105,7 +105,7 @@ export const SummaryPage = ({
       setDisplays(data);
       setHasMoreDisplays(data.length === DISPLAYS_PER_PAGE);
     } catch (error) {
-      toast.error(error instanceof Error ? error.message : String(error));
+      toast.error(error);
       setDisplays([]);
       setHasMoreDisplays(false);
     } finally {

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/share-survey-modal.tsx

@@ -75,7 +75,17 @@ export const ShareSurveyModal = ({
   const [showView, setShowView] = useState<ModalView>(modalView);
   const { email } = user;
   const { t } = useTranslation();
-  const linkTabs = useMemo(() => {
+  const linkTabs: {
+    id: ShareViaType | ShareSettingsType;
+    type: LinkTabsType;
+    label: string;
+    icon: React.ElementType;
+    title: string;
+    description: string;
+    componentType: React.ComponentType<unknown>;
+    componentProps: unknown;
+    disabled?: boolean;
+  }[] = useMemo(() => {
     const tabs = [
       {
         id: ShareViaType.ANON_LINKS,

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

@@ -47,7 +47,6 @@ const createNoCodeConfigType = (t: ReturnType<typeof useTranslation>["t"]) => ({
   pageView: t("environments.actions.page_view"),
   exitIntent: t("environments.actions.exit_intent"),
   fiftyPercentScroll: t("environments.actions.fifty_percent_scroll"),
-  pageDwell: t("environments.actions.time_on_page"),
 });
 
 const formatRecontactDaysString = (days: number, t: ReturnType<typeof useTranslation>["t"]) => {

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/shareEmbedModal/qr-code-tab.tsx

@@ -39,7 +39,7 @@ export const QRCodeTab = ({ surveyUrl }: QRCodeTabProps) => {
           }
         }
       } catch (error) {
-        logger.error(error as Error, "Failed to generate QR code");
+        logger.error("Failed to generate QR code:", error);
         setHasError(true);
       } finally {
         setIsLoading(false);
@@ -66,7 +66,7 @@ export const QRCodeTab = ({ surveyUrl }: QRCodeTabProps) => {
       downloadInstance.download({ name: "survey-qr-code", extension: "png" });
       toast.success(t("environments.surveys.summary.qr_code_download_with_start_soon"));
     } catch (error) {
-      logger.error(error as Error, "Failed to download QR code");
+      logger.error("Failed to download QR code:", error);
       toast.error(t("environments.surveys.summary.qr_code_download_failed"));
     } finally {
       setIsDownloading(false);

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/shareEmbedModal/success-view.tsx

@@ -4,10 +4,6 @@ import React from "react";
 import { useTranslation } from "react-i18next";
 import { TSurvey } from "@formbricks/types/surveys/types";
 import { TUser } from "@formbricks/types/user";
-import {
-  ShareSettingsType,
-  ShareViaType,
-} from "@/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/types/share";
 import { ShareSurveyLink } from "@/modules/analysis/components/ShareSurveyLink";
 import { Badge } from "@/modules/ui/components/badge";
 
@@ -17,9 +13,9 @@ interface SuccessViewProps {
   publicDomain: string;
   setSurveyUrl: (url: string) => void;
   user: TUser;
-  tabs: { id: ShareViaType | ShareSettingsType; label: string; icon: React.ElementType }[];
-  handleViewChange: (view: "start" | "share") => void;
-  handleEmbedViewWithTab: (tabId: ShareViaType | ShareSettingsType) => void;
+  tabs: { id: string; label: string; icon: React.ElementType }[];
+  handleViewChange: (view: string) => void;
+  handleEmbedViewWithTab: (tabId: string) => void;
   isReadOnly: boolean;
 }
 

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

@@ -96,7 +96,7 @@ describe("Tests for getQuotasSummary service", () => {
         _count: {
           quotaLinks: 0,
         },
-      } as unknown as Awaited<ReturnType<typeof prisma.surveyQuota.findMany>>[number],
+      },
     ]);
 
     const result = await getQuotasSummary(surveyId);
@@ -120,7 +120,7 @@ describe("Tests for getQuotasSummary service", () => {
         _count: {
           quotaLinks: 0,
         },
-      } as unknown as Awaited<ReturnType<typeof prisma.surveyQuota.findMany>>[number],
+      },
     ]);
 
     const result = await getQuotasSummary(surveyId);

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

@@ -662,23 +662,17 @@ describe("getQuestionSummary", () => {
       expect((summary[0] as any).choices).toHaveLength(3);
 
       // Item 1 is in position 1 once and position 2 once, so avg ranking should be (1+2)/2 = 1.5
-      const item1 = (summary[0] as any).choices.find(
-        (c: { value: string; count: number; avgRanking: number }) => c.value === "Item 1"
-      );
+      const item1 = (summary[0] as any).choices.find((c) => c.value === "Item 1");
       expect(item1.count).toBe(2);
       expect(item1.avgRanking).toBe(1.5);
 
       // Item 2 is in position 1 once and position 2 once, so avg ranking should be (1+2)/2 = 1.5
-      const item2 = (summary[0] as any).choices.find(
-        (c: { value: string; count: number; avgRanking: number }) => c.value === "Item 2"
-      );
+      const item2 = (summary[0] as any).choices.find((c) => c.value === "Item 2");
       expect(item2.count).toBe(2);
       expect(item2.avgRanking).toBe(1.5);
 
       // Item 3 is in position 3 twice, so avg ranking should be 3
-      const item3 = (summary[0] as any).choices.find(
-        (c: { value: string; count: number; avgRanking: number }) => c.value === "Item 3"
-      );
+      const item3 = (summary[0] as any).choices.find((c) => c.value === "Item 3");
       expect(item3.count).toBe(2);
       expect(item3.avgRanking).toBe(3);
     });
@@ -753,23 +747,17 @@ describe("getQuestionSummary", () => {
       expect(summary[0].responseCount).toBe(1);
 
       // Item 1 is in position 2, so avg ranking should be 2
-      const item1 = (summary[0] as any).choices.find(
-        (c: { value: string; count: number; avgRanking: number }) => c.value === "Item 1"
-      );
+      const item1 = (summary[0] as any).choices.find((c) => c.value === "Item 1");
       expect(item1.count).toBe(1);
       expect(item1.avgRanking).toBe(2);
 
       // Item 2 is in position 1, so avg ranking should be 1
-      const item2 = (summary[0] as any).choices.find(
-        (c: { value: string; count: number; avgRanking: number }) => c.value === "Item 2"
-      );
+      const item2 = (summary[0] as any).choices.find((c) => c.value === "Item 2");
       expect(item2.count).toBe(1);
       expect(item2.avgRanking).toBe(1);
 
       // Item 3 is in position 3, so avg ranking should be 3
-      const item3 = (summary[0] as any).choices.find(
-        (c: { value: string; count: number; avgRanking: number }) => c.value === "Item 3"
-      );
+      const item3 = (summary[0] as any).choices.find((c) => c.value === "Item 3");
       expect(item3.count).toBe(1);
       expect(item3.avgRanking).toBe(3);
     });
@@ -842,12 +830,10 @@ describe("getQuestionSummary", () => {
       expect((summary[0] as any).choices).toHaveLength(3);
 
       // All items should have count 0 and avgRanking 0
-      (summary[0] as any).choices.forEach(
-        (choice: { value?: string; count: number; avgRanking?: number; percentage?: number }) => {
-          expect(choice.count).toBe(0);
-          expect(choice.avgRanking).toBe(0);
-        }
-      );
+      (summary[0] as any).choices.forEach((choice) => {
+        expect(choice.count).toBe(0);
+        expect(choice.avgRanking).toBe(0);
+      });
     });
 
     test("getQuestionSummary handles ranking question with non-array answers", async () => {
@@ -908,12 +894,10 @@ describe("getQuestionSummary", () => {
       expect((summary[0] as any).choices).toHaveLength(3);
 
       // All items should have count 0 and avgRanking 0 since we had no valid ranking data
-      (summary[0] as any).choices.forEach(
-        (choice: { value?: string; count: number; avgRanking?: number; percentage?: number }) => {
-          expect(choice.count).toBe(0);
-          expect(choice.avgRanking).toBe(0);
-        }
-      );
+      (summary[0] as any).choices.forEach((choice) => {
+        expect(choice.count).toBe(0);
+        expect(choice.avgRanking).toBe(0);
+      });
     });
 
     test("getQuestionSummary handles ranking question with values not in choices", async () => {
@@ -974,23 +958,17 @@ describe("getQuestionSummary", () => {
       expect((summary[0] as any).choices).toHaveLength(3);
 
       // Item 1 is in position 1, so avg ranking should be 1
-      const item1 = (summary[0] as any).choices.find(
-        (c: { value: string; count: number; avgRanking: number }) => c.value === "Item 1"
-      );
+      const item1 = (summary[0] as any).choices.find((c) => c.value === "Item 1");
       expect(item1.count).toBe(1);
       expect(item1.avgRanking).toBe(1);
 
       // Item 2 was not ranked, so should have count 0 and avgRanking 0
-      const item2 = (summary[0] as any).choices.find(
-        (c: { value: string; count: number; avgRanking: number }) => c.value === "Item 2"
-      );
+      const item2 = (summary[0] as any).choices.find((c) => c.value === "Item 2");
       expect(item2.count).toBe(0);
       expect(item2.avgRanking).toBe(0);
 
       // Item 3 is in position 3, so avg ranking should be 3
-      const item3 = (summary[0] as any).choices.find(
-        (c: { value: string; count: number; avgRanking: number }) => c.value === "Item 3"
-      );
+      const item3 = (summary[0] as any).choices.find((c) => c.value === "Item 3");
       expect(item3.count).toBe(1);
       expect(item3.avgRanking).toBe(3);
     });
@@ -1008,11 +986,7 @@ describe("getSurveySummary", () => {
     // Since getSurveySummary calls getResponsesForSummary internally, we'll mock prisma.response.findMany
     // which is used by the actual implementation of getResponsesForSummary.
     vi.mocked(prisma.response.findMany).mockResolvedValue(
-      mockResponses.map((r: Record<string, unknown>) => ({
-        ...r,
-        contactId: null,
-        personAttributes: {},
-      })) as any
+      mockResponses.map((r) => ({ ...r, contactId: null, personAttributes: {} })) as any
     );
     vi.mocked(getDisplayCountBySurveyId).mockResolvedValue(10);
 
@@ -1046,8 +1020,8 @@ describe("getSurveySummary", () => {
   test("handles filterCriteria", async () => {
     const filterCriteria: TResponseFilterCriteria = { finished: true };
     const finishedResponses = mockResponses
-      .filter((r: Record<string, unknown>) => r.finished)
-      .map((r: Record<string, unknown>) => ({ ...r, contactId: null, personAttributes: {} }));
+      .filter((r) => r.finished)
+      .map((r) => ({ ...r, contactId: null, personAttributes: {} }));
     vi.mocked(prisma.response.findMany).mockResolvedValue(finishedResponses as any);
 
     await getSurveySummary(mockSurveyId, filterCriteria);
@@ -1069,11 +1043,7 @@ describe("getResponsesForSummary", () => {
     vi.resetAllMocks();
     vi.mocked(getSurvey).mockResolvedValue(mockBaseSurvey);
     vi.mocked(prisma.response.findMany).mockResolvedValue(
-      mockResponses.map((r: Record<string, unknown>) => ({
-        ...r,
-        contactId: null,
-        personAttributes: {},
-      })) as any
+      mockResponses.map((r) => ({ ...r, contactId: null, personAttributes: {} })) as any
     );
     // React cache is already mocked globally - no need to mock it again
   });
@@ -1872,63 +1842,23 @@ describe("Matrix question type tests", () => {
     expect(summary[0].responseCount).toBe(2);
 
     // Verify Speed row
-    const speedRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Speed"
-    );
+    const speedRow = summary[0].data.find((row) => row.rowLabel === "Speed");
     expect(speedRow.totalResponsesForRow).toBe(2);
     expect(speedRow.columnPercentages).toHaveLength(4); // 4 columns
-    expect(
-      speedRow.columnPercentages.find((col: { column: string; percentage: number }) => col.column === "Good")
-        .percentage
-    ).toBe(50);
-    expect(
-      speedRow.columnPercentages.find(
-        (col: { column: string; percentage: number }) => col.column === "Average"
-      ).percentage
-    ).toBe(50);
+    expect(speedRow.columnPercentages.find((col) => col.column === "Good").percentage).toBe(50);
+    expect(speedRow.columnPercentages.find((col) => col.column === "Average").percentage).toBe(50);
 
     // Verify Quality row
-    const qualityRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Quality"
-    );
+    const qualityRow = summary[0].data.find((row) => row.rowLabel === "Quality");
     expect(qualityRow.totalResponsesForRow).toBe(2);
-    expect(
-      qualityRow.columnPercentages.find(
-        (col: { column: string; percentage: number }) => col.column === "Excellent"
-      ).percentage
-    ).toBe(50);
-    expect(
-      qualityRow.columnPercentages.find(
-        (col: { column: string; percentage: number }) => col.column === "Good"
-      ).percentage
-    ).toBe(50);
+    expect(qualityRow.columnPercentages.find((col) => col.column === "Excellent").percentage).toBe(50);
+    expect(qualityRow.columnPercentages.find((col) => col.column === "Good").percentage).toBe(50);
 
     // Verify Price row
-    const priceRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Price"
-    );
+    const priceRow = summary[0].data.find((row) => row.rowLabel === "Price");
     expect(priceRow.totalResponsesForRow).toBe(2);
-    expect(
-      priceRow.columnPercentages.find((col: { column: string; percentage: number }) => col.column === "Poor")
-        .percentage
-    ).toBe(50);
-    expect(
-      priceRow.columnPercentages.find(
-        (col: { column: string; percentage: number }) => col.column === "Average"
-      ).percentage
-    ).toBe(50);
+    expect(priceRow.columnPercentages.find((col) => col.column === "Poor").percentage).toBe(50);
+    expect(priceRow.columnPercentages.find((col) => col.column === "Average").percentage).toBe(50);
   });
 
   test("getQuestionSummary correctly processes Matrix question with non-default language responses", async () => {
@@ -2019,48 +1949,19 @@ describe("Matrix question type tests", () => {
     expect(summary[0].responseCount).toBe(1);
 
     // Verify Speed row with localized values mapped to default language
-    const speedRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Speed"
-    );
+    const speedRow = summary[0].data.find((row) => row.rowLabel === "Speed");
     expect(speedRow.totalResponsesForRow).toBe(1);
-    expect(
-      speedRow.columnPercentages.find((col: { column: string; percentage: number }) => col.column === "Good")
-        .percentage
-    ).toBe(100);
+    expect(speedRow.columnPercentages.find((col) => col.column === "Good").percentage).toBe(100);
 
     // Verify Quality row
-    const qualityRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Quality"
-    );
+    const qualityRow = summary[0].data.find((row) => row.rowLabel === "Quality");
     expect(qualityRow.totalResponsesForRow).toBe(1);
-    expect(
-      qualityRow.columnPercentages.find(
-        (col: { column: string; percentage: number }) => col.column === "Excellent"
-      ).percentage
-    ).toBe(100);
+    expect(qualityRow.columnPercentages.find((col) => col.column === "Excellent").percentage).toBe(100);
 
     // Verify Price row
-    const priceRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Price"
-    );
+    const priceRow = summary[0].data.find((row) => row.rowLabel === "Price");
     expect(priceRow.totalResponsesForRow).toBe(1);
-    expect(
-      priceRow.columnPercentages.find(
-        (col: { column: string; percentage: number }) => col.column === "Average"
-      ).percentage
-    ).toBe(100);
+    expect(priceRow.columnPercentages.find((col) => col.column === "Average").percentage).toBe(100);
   });
 
   test("getQuestionSummary handles missing or invalid data for Matrix questions", async () => {
@@ -2154,18 +2055,12 @@ describe("Matrix question type tests", () => {
     expect(summary[0].responseCount).toBe(3); // Count is 3 because responses 2, 3, and 4 have the "matrix-q1" property
 
     // All rows should have zero responses for all columns
-    summary[0].data.forEach(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => {
-        expect(row.totalResponsesForRow).toBe(0);
-        row.columnPercentages.forEach((col: { column: string; percentage: number }) => {
-          expect(col.percentage).toBe(0);
-        });
-      }
-    );
+    summary[0].data.forEach((row) => {
+      expect(row.totalResponsesForRow).toBe(0);
+      row.columnPercentages.forEach((col) => {
+        expect(col.percentage).toBe(0);
+      });
+    });
   });
 
   test("getQuestionSummary handles partial and incomplete matrix responses", async () => {
@@ -2252,59 +2147,22 @@ describe("Matrix question type tests", () => {
     expect(summary[0].responseCount).toBe(2);
 
     // Verify Speed row - both responses provided data
-    const speedRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Speed"
-    );
+    const speedRow = summary[0].data.find((row) => row.rowLabel === "Speed");
     expect(speedRow.totalResponsesForRow).toBe(2);
-    expect(
-      speedRow.columnPercentages.find((col: { column: string; percentage: number }) => col.column === "Good")
-        .percentage
-    ).toBe(50);
-    expect(
-      speedRow.columnPercentages.find(
-        (col: { column: string; percentage: number }) => col.column === "Average"
-      ).percentage
-    ).toBe(50);
+    expect(speedRow.columnPercentages.find((col) => col.column === "Good").percentage).toBe(50);
+    expect(speedRow.columnPercentages.find((col) => col.column === "Average").percentage).toBe(50);
 
     // Verify Quality row - only one response provided data
-    const qualityRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Quality"
-    );
+    const qualityRow = summary[0].data.find((row) => row.rowLabel === "Quality");
     expect(qualityRow.totalResponsesForRow).toBe(1);
-    expect(
-      qualityRow.columnPercentages.find(
-        (col: { column: string; percentage: number }) => col.column === "Good"
-      ).percentage
-    ).toBe(100);
+    expect(qualityRow.columnPercentages.find((col) => col.column === "Good").percentage).toBe(100);
 
     // Verify Price row - both responses provided data
-    const priceRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Price"
-    );
+    const priceRow = summary[0].data.find((row) => row.rowLabel === "Price");
     expect(priceRow.totalResponsesForRow).toBe(2);
 
     // ExtraRow should not appear in the summary
-    expect(
-      summary[0].data.find(
-        (row: {
-          rowLabel: string;
-          totalResponsesForRow: number;
-          columnPercentages: { column: string; percentage: number }[];
-        }) => row.rowLabel === "ExtraRow"
-      )
-    ).toBeUndefined();
+    expect(summary[0].data.find((row) => row.rowLabel === "ExtraRow")).toBeUndefined();
   });
 
   test("getQuestionSummary handles zero responses for Matrix question correctly", async () => {
@@ -2363,18 +2221,12 @@ describe("Matrix question type tests", () => {
     // All rows should have proper structure but zero counts
     expect(summary[0].data).toHaveLength(2); // 2 rows
 
-    summary[0].data.forEach(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => {
-        expect(row.columnPercentages).toHaveLength(2); // 2 columns
-        expect(row.totalResponsesForRow).toBe(0);
-        expect(row.columnPercentages[0].percentage).toBe(0);
-        expect(row.columnPercentages[1].percentage).toBe(0);
-      }
-    );
+    summary[0].data.forEach((row) => {
+      expect(row.columnPercentages).toHaveLength(2); // 2 columns
+      expect(row.totalResponsesForRow).toBe(0);
+      expect(row.columnPercentages[0].percentage).toBe(0);
+      expect(row.columnPercentages[1].percentage).toBe(0);
+    });
   });
 
   test("getQuestionSummary handles Matrix question with mixed valid and invalid column values", async () => {
@@ -2444,46 +2296,21 @@ describe("Matrix question type tests", () => {
     expect(summary[0].responseCount).toBe(1);
 
     // Speed row should have a valid response
-    const speedRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Speed"
-    );
+    const speedRow = summary[0].data.find((row) => row.rowLabel === "Speed");
     expect(speedRow.totalResponsesForRow).toBe(1);
-    expect(
-      speedRow.columnPercentages.find((col: { column: string; percentage: number }) => col.column === "Good")
-        .percentage
-    ).toBe(100);
+    expect(speedRow.columnPercentages.find((col) => col.column === "Good").percentage).toBe(100);
 
     // Quality row should have no valid responses
-    const qualityRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Quality"
-    );
+    const qualityRow = summary[0].data.find((row) => row.rowLabel === "Quality");
     expect(qualityRow.totalResponsesForRow).toBe(0);
-    qualityRow.columnPercentages.forEach((col: { column: string; percentage: number }) => {
+    qualityRow.columnPercentages.forEach((col) => {
       expect(col.percentage).toBe(0);
     });
 
     // Price row should have a valid response
-    const priceRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Price"
-    );
+    const priceRow = summary[0].data.find((row) => row.rowLabel === "Price");
     expect(priceRow.totalResponsesForRow).toBe(1);
-    expect(
-      priceRow.columnPercentages.find(
-        (col: { column: string; percentage: number }) => col.column === "Average"
-      ).percentage
-    ).toBe(100);
+    expect(priceRow.columnPercentages.find((col) => col.column === "Average").percentage).toBe(100);
   });
 
   test("getQuestionSummary handles Matrix question with invalid row labels", async () => {
@@ -2554,48 +2381,17 @@ describe("Matrix question type tests", () => {
     expect(summary[0].data).toHaveLength(2); // 2 rows
 
     // Speed row should have a valid response
-    const speedRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Speed"
-    );
+    const speedRow = summary[0].data.find((row) => row.rowLabel === "Speed");
     expect(speedRow.totalResponsesForRow).toBe(1);
-    expect(
-      speedRow.columnPercentages.find((col: { column: string; percentage: number }) => col.column === "Good")
-        .percentage
-    ).toBe(100);
+    expect(speedRow.columnPercentages.find((col) => col.column === "Good").percentage).toBe(100);
 
     // Quality row should have no responses
-    const qualityRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Quality"
-    );
+    const qualityRow = summary[0].data.find((row) => row.rowLabel === "Quality");
     expect(qualityRow.totalResponsesForRow).toBe(0);
 
     // Invalid rows should not appear in the summary
-    expect(
-      summary[0].data.find(
-        (row: {
-          rowLabel: string;
-          totalResponsesForRow: number;
-          columnPercentages: { column: string; percentage: number }[];
-        }) => row.rowLabel === "InvalidRow"
-      )
-    ).toBeUndefined();
-    expect(
-      summary[0].data.find(
-        (row: {
-          rowLabel: string;
-          totalResponsesForRow: number;
-          columnPercentages: { column: string; percentage: number }[];
-        }) => row.rowLabel === "AnotherInvalidRow"
-      )
-    ).toBeUndefined();
+    expect(summary[0].data.find((row) => row.rowLabel === "InvalidRow")).toBeUndefined();
+    expect(summary[0].data.find((row) => row.rowLabel === "AnotherInvalidRow")).toBeUndefined();
   });
 
   test("getQuestionSummary handles Matrix question with mixed language responses", async () => {
@@ -2697,27 +2493,12 @@ describe("Matrix question type tests", () => {
     expect(summary[0].responseCount).toBe(2);
 
     // Speed row should have both responses
-    const speedRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Speed"
-    );
+    const speedRow = summary[0].data.find((row) => row.rowLabel === "Speed");
     expect(speedRow.totalResponsesForRow).toBe(2);
-    expect(
-      speedRow.columnPercentages.find((col: { column: string; percentage: number }) => col.column === "Good")
-        .percentage
-    ).toBe(100);
+    expect(speedRow.columnPercentages.find((col) => col.column === "Good").percentage).toBe(100);
 
     // Quality row should have no responses
-    const qualityRow = summary[0].data.find(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => row.rowLabel === "Quality"
-    );
+    const qualityRow = summary[0].data.find((row) => row.rowLabel === "Quality");
     expect(qualityRow.totalResponsesForRow).toBe(0);
   });
 
@@ -2776,18 +2557,12 @@ describe("Matrix question type tests", () => {
     expect(summary[0].responseCount).toBe(0); // Counts as response even with null data
 
     // Both rows should have zero responses
-    summary[0].data.forEach(
-      (row: {
-        rowLabel: string;
-        totalResponsesForRow: number;
-        columnPercentages: { column: string; percentage: number }[];
-      }) => {
-        expect(row.totalResponsesForRow).toBe(0);
-        row.columnPercentages.forEach((col: { column: string; percentage: number }) => {
-          expect(col.percentage).toBe(0);
-        });
-      }
-    );
+    summary[0].data.forEach((row) => {
+      expect(row.totalResponsesForRow).toBe(0);
+      row.columnPercentages.forEach((col) => {
+        expect(col.percentage).toBe(0);
+      });
+    });
   });
 });
 
@@ -3219,33 +2994,23 @@ describe("Rating question type tests", () => {
     expect(summary[0].average).toBe(4.25);
 
     // Verify each rating option count and percentage
-    const rating5 = summary[0].choices.find(
-      (c: { rating: number; count: number; percentage: number }) => c.rating === 5
-    );
+    const rating5 = summary[0].choices.find((c) => c.rating === 5);
     expect(rating5.count).toBe(2);
     expect(rating5.percentage).toBe(50); // 2/4 * 100
 
-    const rating4 = summary[0].choices.find(
-      (c: { rating: number; count: number; percentage: number }) => c.rating === 4
-    );
+    const rating4 = summary[0].choices.find((c) => c.rating === 4);
     expect(rating4.count).toBe(1);
     expect(rating4.percentage).toBe(25); // 1/4 * 100
 
-    const rating3 = summary[0].choices.find(
-      (c: { rating: number; count: number; percentage: number }) => c.rating === 3
-    );
+    const rating3 = summary[0].choices.find((c) => c.rating === 3);
     expect(rating3.count).toBe(1);
     expect(rating3.percentage).toBe(25); // 1/4 * 100
 
-    const rating2 = summary[0].choices.find(
-      (c: { rating: number; count: number; percentage: number }) => c.rating === 2
-    );
+    const rating2 = summary[0].choices.find((c) => c.rating === 2);
     expect(rating2.count).toBe(0);
     expect(rating2.percentage).toBe(0);
 
-    const rating1 = summary[0].choices.find(
-      (c: { rating: number; count: number; percentage: number }) => c.rating === 1
-    );
+    const rating1 = summary[0].choices.find((c) => c.rating === 1);
     expect(rating1.count).toBe(0);
     expect(rating1.percentage).toBe(0);
 
@@ -3389,12 +3154,10 @@ describe("Rating question type tests", () => {
     expect(summary[0].average).toBe(0);
 
     // Verify all ratings have 0 count and percentage
-    summary[0].choices.forEach(
-      (choice: { value?: string; count: number; avgRanking?: number; percentage?: number }) => {
-        expect(choice.count).toBe(0);
-        expect(choice.percentage).toBe(0);
-      }
-    );
+    summary[0].choices.forEach((choice) => {
+      expect(choice.count).toBe(0);
+      expect(choice.percentage).toBe(0);
+    });
 
     // Verify dismissed is 0
     expect(summary[0].dismissed.count).toBe(0);
@@ -3469,21 +3232,15 @@ describe("PictureSelection question type tests", () => {
     expect(summary[0].selectionCount).toBe(3); // Total selections: img1, img2, img3
 
     // Check individual choice counts
-    const img1 = summary[0].choices.find(
-      (c: { id: string; count: number; percentage: number }) => c.id === "img1"
-    );
+    const img1 = summary[0].choices.find((c) => c.id === "img1");
     expect(img1.count).toBe(1);
     expect(img1.percentage).toBe(50);
 
-    const img2 = summary[0].choices.find(
-      (c: { id: string; count: number; percentage: number }) => c.id === "img2"
-    );
+    const img2 = summary[0].choices.find((c) => c.id === "img2");
     expect(img2.count).toBe(1);
     expect(img2.percentage).toBe(50);
 
-    const img3 = summary[0].choices.find(
-      (c: { id: string; count: number; percentage: number }) => c.id === "img3"
-    );
+    const img3 = summary[0].choices.find((c) => c.id === "img3");
     expect(img3.count).toBe(1);
     expect(img3.percentage).toBe(50);
   });
@@ -3554,12 +3311,10 @@ describe("PictureSelection question type tests", () => {
     expect(summary[0].selectionCount).toBe(0);
 
     // All choices should have zero count
-    summary[0].choices.forEach(
-      (choice: { value?: string; count: number; avgRanking?: number; percentage?: number }) => {
-        expect(choice.count).toBe(0);
-        expect(choice.percentage).toBe(0);
-      }
-    );
+    summary[0].choices.forEach((choice) => {
+      expect(choice.count).toBe(0);
+      expect(choice.percentage).toBe(0);
+    });
   });
 
   test("getQuestionSummary handles PictureSelection with invalid choice ids", async () => {
@@ -3618,23 +3373,17 @@ describe("PictureSelection question type tests", () => {
     expect(summary[0].selectionCount).toBe(2); // Total selections including invalid one
 
     // img1 should be counted
-    const img1 = summary[0].choices.find(
-      (c: { id: string; count: number; percentage: number }) => c.id === "img1"
-    );
+    const img1 = summary[0].choices.find((c) => c.id === "img1");
     expect(img1.count).toBe(1);
     expect(img1.percentage).toBe(100);
 
     // img2 should not be counted
-    const img2 = summary[0].choices.find(
-      (c: { id: string; count: number; percentage: number }) => c.id === "img2"
-    );
+    const img2 = summary[0].choices.find((c) => c.id === "img2");
     expect(img2.count).toBe(0);
     expect(img2.percentage).toBe(0);
 
     // Invalid ID should not appear in choices
-    expect(
-      summary[0].choices.find((c: { id: string; count: number; percentage: number }) => c.id === "invalid-id")
-    ).toBeUndefined();
+    expect(summary[0].choices.find((c) => c.id === "invalid-id")).toBeUndefined();
   });
 });
 

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

@@ -14,7 +14,11 @@ import {
   TResponseVariables,
   ZResponseFilterCriteria,
 } from "@formbricks/types/responses";
-import { TSurveyElement, TSurveyElementTypeEnum } from "@formbricks/types/surveys/elements";
+import {
+  TSurveyElement,
+  TSurveyElementChoice,
+  TSurveyElementTypeEnum,
+} from "@formbricks/types/surveys/elements";
 import {
   TSurvey,
   TSurveyElementSummaryAddress,
@@ -289,10 +293,7 @@ const checkForI18n = (
 ) => {
   const element = elements.find((element) => element.id === id);
 
-  if (
-    element?.type === TSurveyElementTypeEnum.MultipleChoiceMulti ||
-    element?.type === TSurveyElementTypeEnum.Ranking
-  ) {
+  if (element?.type === "multipleChoiceMulti" || element?.type === "ranking") {
     // Initialize an array to hold the choice values
     let choiceValues = [] as string[];
 
@@ -317,9 +318,13 @@ const checkForI18n = (
   }
 
   // Return the localized value of the choice fo multiSelect single element
-  if (element?.type === TSurveyElementTypeEnum.MultipleChoiceSingle) {
-    const choice = element.choices?.find((choice) => choice.label[languageCode] === responseData[id]);
-    return choice ? getLocalizedValue(choice.label, "default") || responseData[id] : responseData[id];
+  if (element && "choices" in element) {
+    const choice = element.choices?.find(
+      (choice: TSurveyElementChoice) => choice.label?.[languageCode] === responseData[id]
+    );
+    return choice && "label" in choice
+      ? getLocalizedValue(choice.label, "default") || responseData[id]
+      : responseData[id];
   }
 
   return responseData[id];
@@ -827,19 +832,13 @@ export const getElementSummary = async (
         let totalResponseCount = 0;
 
         // Initialize count object
-        const countMap: Record<string, Record<string, number>> = rows.reduce(
-          (acc: Record<string, Record<string, number>>, row) => {
-            acc[row] = columns.reduce(
-              (colAcc: Record<string, number>, col) => {
-                colAcc[col] = 0;
-                return colAcc;
-              },
-              {} as Record<string, number>
-            );
-            return acc;
-          },
-          {} as Record<string, Record<string, number>>
-        );
+        const countMap: Record<string, string> = rows.reduce((acc, row) => {
+          acc[row] = columns.reduce((colAcc, col) => {
+            colAcc[col] = 0;
+            return colAcc;
+          }, {});
+          return acc;
+        }, {});
 
         responses.forEach((response) => {
           const selectedResponses = response.data[element.id] as Record<string, string>;

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

@@ -40,11 +40,10 @@ const SurveyPage = async (props: { params: Promise<{ environmentId: string; surv
   if (!user) {
     throw new Error(t("common.user_not_found"));
   }
-  const organizationId = await getOrganizationIdFromEnvironmentId(environment.id);
-
-  const isContactsEnabled = await getIsContactsEnabled(organizationId);
+  const isContactsEnabled = await getIsContactsEnabled();
   const segments = isContactsEnabled ? await getSegments(environment.id) : [];
 
+  const organizationId = await getOrganizationIdFromEnvironmentId(environment.id);
   if (!organizationId) {
     throw new Error(t("common.organization_not_found"));
   }
@@ -52,7 +51,7 @@ const SurveyPage = async (props: { params: Promise<{ environmentId: string; surv
   if (!organizationBilling) {
     throw new Error(t("common.organization_not_found"));
   }
-  const isQuotasAllowed = await getIsQuotasEnabled(organizationId);
+  const isQuotasAllowed = await getIsQuotasEnabled(organizationBilling.plan);
 
   // Fetch initial survey summary data on the server to prevent duplicate API calls during hydration
   const initialSurveySummary = await getSurveySummary(surveyId);

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

@@ -4,16 +4,18 @@ import { z } from "zod";
 import { ZId } from "@formbricks/types/common";
 import { OperationNotAllowedError, ResourceNotFoundError } from "@formbricks/types/errors";
 import { ZResponseFilterCriteria } from "@formbricks/types/responses";
-import { ZSurvey } from "@formbricks/types/surveys/types";
+import { TSurvey, ZSurvey } from "@formbricks/types/surveys/types";
 import { getOrganization } from "@/lib/organization/service";
 import { getResponseDownloadFile, getResponseFilteringValues } from "@/lib/response/service";
 import { getSurvey, updateSurvey } from "@/lib/survey/service";
 import { getTagsByEnvironmentId } from "@/lib/tag/service";
 import { authenticatedActionClient } from "@/lib/utils/action-client";
 import { checkAuthorizationUpdated } from "@/lib/utils/action-client/action-client-middleware";
+import { AuthenticatedActionClientCtx } from "@/lib/utils/action-client/types/context";
 import { getOrganizationIdFromSurveyId, getProjectIdFromSurveyId } from "@/lib/utils/helper";
 import { withAuditLogging } from "@/modules/ee/audit-logs/lib/handler";
 import { getIsQuotasEnabled } from "@/modules/ee/license-check/lib/utils";
+import { checkMultiLanguagePermission } from "@/modules/ee/multi-language-surveys/lib/actions";
 import { getQuotas } from "@/modules/ee/quotas/lib/quotas";
 import { getSurveyFollowUpsPermission } from "@/modules/survey/follow-ups/lib/utils";
 import { checkSpamProtectionPermission } from "@/modules/survey/lib/permission";
@@ -87,7 +89,7 @@ export const getSurveyFilterDataAction = authenticatedActionClient
       throw new ResourceNotFoundError("Organization", organizationId);
     }
 
-    const isQuotasAllowed = await getIsQuotasEnabled(organizationId);
+    const isQuotasAllowed = await getIsQuotasEnabled(organizationBilling.plan);
 
     const [tags, { contactAttributes: attributes, meta, hiddenFields }, quotas = []] = await Promise.all([
       getTagsByEnvironmentId(survey.environmentId),
@@ -113,52 +115,60 @@ const checkSurveyFollowUpsPermission = async (organizationId: string): Promise<v
     throw new ResourceNotFoundError("Organization not found", organizationId);
   }
 
-  const isSurveyFollowUpsEnabled = await getSurveyFollowUpsPermission(organizationId);
+  const isSurveyFollowUpsEnabled = await getSurveyFollowUpsPermission(organization.billing.plan);
   if (!isSurveyFollowUpsEnabled) {
     throw new OperationNotAllowedError("Survey follow ups are not enabled for this organization");
   }
 };
 
 export const updateSurveyAction = authenticatedActionClient.inputSchema(ZSurvey).action(
-  withAuditLogging("updated", "survey", async ({ ctx, parsedInput }) => {
-    const organizationId = await getOrganizationIdFromSurveyId(parsedInput.id);
-    await checkAuthorizationUpdated({
-      userId: ctx.user?.id ?? "",
-      organizationId,
-      access: [
-        {
-          type: "organization",
-          roles: ["owner", "manager"],
-        },
-        {
-          type: "projectTeam",
-          projectId: await getProjectIdFromSurveyId(parsedInput.id),
-          minPermission: "readWrite",
-        },
-      ],
-    });
+  withAuditLogging(
+    "updated",
+    "survey",
+    async ({ ctx, parsedInput }: { ctx: AuthenticatedActionClientCtx; parsedInput: TSurvey }) => {
+      const organizationId = await getOrganizationIdFromSurveyId(parsedInput.id);
+      await checkAuthorizationUpdated({
+        userId: ctx.user?.id ?? "",
+        organizationId,
+        access: [
+          {
+            type: "organization",
+            roles: ["owner", "manager"],
+          },
+          {
+            type: "projectTeam",
+            projectId: await getProjectIdFromSurveyId(parsedInput.id),
+            minPermission: "readWrite",
+          },
+        ],
+      });
 
-    const { followUps } = parsedInput;
+      const { followUps } = parsedInput;
 
-    const oldSurvey = await getSurvey(parsedInput.id);
+      const oldSurvey = await getSurvey(parsedInput.id);
 
-    if (parsedInput.recaptcha?.enabled) {
-      await checkSpamProtectionPermission(organizationId);
+      if (parsedInput.recaptcha?.enabled) {
+        await checkSpamProtectionPermission(organizationId);
+      }
+
+      if (followUps?.length) {
+        await checkSurveyFollowUpsPermission(organizationId);
+      }
+
+      if (parsedInput.languages?.length) {
+        await checkMultiLanguagePermission(organizationId);
+      }
+
+      // Context for audit log
+      ctx.auditLoggingCtx.surveyId = parsedInput.id;
+      ctx.auditLoggingCtx.organizationId = organizationId;
+      ctx.auditLoggingCtx.oldObject = oldSurvey;
+
+      const newSurvey = await updateSurvey(parsedInput);
+
+      ctx.auditLoggingCtx.newObject = newSurvey;
+
+      return newSurvey;
     }
-
-    if (followUps?.length) {
-      await checkSurveyFollowUpsPermission(organizationId);
-    }
-
-    // Context for audit log
-    ctx.auditLoggingCtx.surveyId = parsedInput.id;
-    ctx.auditLoggingCtx.organizationId = organizationId;
-    ctx.auditLoggingCtx.oldObject = oldSurvey;
-
-    const newSurvey = await updateSurvey(parsedInput);
-
-    ctx.auditLoggingCtx.newObject = newSurvey;
-
-    return newSurvey;
-  })
+  )
 );

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

@@ -18,6 +18,7 @@ import {
 } from "date-fns";
 import { TFunction } from "i18next";
 import { Loader2 } from "lucide-react";
+import posthog from "posthog-js";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import toast from "react-hot-toast";
 import { useTranslation } from "react-i18next";
@@ -164,12 +165,12 @@ export const CustomFilter = ({ survey }: CustomFilterProps) => {
 
   const datePickerRef = useRef<HTMLDivElement>(null);
 
-  const extractMetadataKeys = useCallback((obj: Record<string, unknown>, parentKey = "") => {
+  const extractMetadataKeys = useCallback((obj, parentKey = "") => {
     let keys: string[] = [];
 
     for (let key in obj) {
       if (typeof obj[key] === "object" && obj[key] !== null) {
-        keys = keys.concat(extractMetadataKeys(obj[key] as Record<string, unknown>, parentKey + key + " - "));
+        keys = keys.concat(extractMetadataKeys(obj[key], parentKey + key + " - "));
       } else {
         keys.push(parentKey + key);
       }
@@ -257,6 +258,12 @@ export const CustomFilter = ({ survey }: CustomFilterProps) => {
           responsesDownloadUrlResponse.data.fileContents,
           fileType
         );
+        posthog.capture("responses_exported", {
+          surveyId: survey.id,
+          surveyName: survey.name,
+          format: fileType,
+          filterType: filter === FilterDownload.ALL ? "all" : "filtered",
+        });
       } else {
         toast.error(t("environments.surveys.responses.error_downloading_responses"));
       }

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

@@ -113,9 +113,7 @@ const elementIcons = {
 };
 
 const getIcon = (type: string) => {
-  const IconComponent = (elementIcons as Record<string, (typeof elementIcons)[keyof typeof elementIcons]>)[
-    type
-  ];
+  const IconComponent = elementIcons[type];
   return IconComponent ? <IconComponent className="h-5 w-5" strokeWidth={1.5} /> : null;
 };
 

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

@@ -198,7 +198,7 @@ export const ResponseFilter = ({ survey }: ResponseFilterProps) => {
     };
     setFilterValue({ ...filterValue });
   };
-  const handleRemoveMultiSelect = (value: string[], index: number) => {
+  const handleRemoveMultiSelect = (value: string[], index) => {
     filterValue.filter[index] = {
       ...filterValue.filter[index],
       filterType: {

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

@@ -34,27 +34,23 @@ export const SurveyStatusDropdown = ({
     const updateSurveyActionResponse = await updateSurveyAction({ ...survey, status });
 
     if (updateSurveyActionResponse?.data) {
-      const resultingStatus = updateSurveyActionResponse.data.status;
-      const statusToToastMessage: Partial<Record<TSurvey["status"], string>> = {
-        inProgress: t("common.survey_live"),
-        paused: t("common.survey_paused"),
-        completed: t("common.survey_completed"),
-      };
-
-      const toastMessage = statusToToastMessage[resultingStatus];
-      if (toastMessage) {
-        toast.success(toastMessage);
-      }
-
-      if (updateLocalSurveyStatus) {
-        updateLocalSurveyStatus(resultingStatus);
-      }
+      toast.success(
+        status === "inProgress"
+          ? t("common.survey_live")
+          : status === "paused"
+            ? t("common.survey_paused")
+            : status === "completed"
+              ? t("common.survey_completed")
+              : ""
+      );
 
       router.refresh();
     } else {
       const errorMessage = getFormattedErrorMessage(updateSurveyActionResponse);
       toast.error(errorMessage);
     }
+
+    if (updateLocalSurveyStatus) updateLocalSurveyStatus(status);
   };
 
   return (

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

@@ -1,6 +1,6 @@
 import { redirect } from "next/navigation";
 
-const Page = async (props: { params: Promise<{ environmentId: string; surveyId: string }> }) => {
+const Page = async (props) => {
   const params = await props.params;
   return redirect(`/environments/${params.environmentId}/surveys/${params.surveyId}/summary`);
 };

apps/web/app/(app)/environments/[environmentId]/workflows/components/workflows-page.tsx

@@ -110,7 +110,7 @@ export const WorkflowsPage = ({ userEmail, organizationName, billingPlan }: Work
       <div className="flex h-full flex-col items-center px-4 pt-[15vh]">
         <div className="w-full max-w-2xl space-y-8">
           <div className="space-y-3 text-center">
-            <div className="mx-auto mb-4 flex h-12 w-12 items-center justify-center rounded-xl bg-gradient-to-br from-brand-light to-brand-dark shadow-md">
+            <div className="from-brand-light to-brand-dark mx-auto mb-4 flex h-12 w-12 items-center justify-center rounded-xl bg-gradient-to-br shadow-md">
               <Sparkles className="h-6 w-6 text-white" />
             </div>
             <h1 className="text-4xl font-bold tracking-tight text-slate-800">{t("workflows.heading")}</h1>
@@ -123,7 +123,7 @@ export const WorkflowsPage = ({ userEmail, organizationName, billingPlan }: Work
               onChange={(e) => setPromptValue(e.target.value)}
               placeholder={t("workflows.placeholder")}
               rows={5}
-              className="w-full resize-none rounded-xl border border-slate-200 bg-white px-5 py-4 text-base text-slate-800 shadow-sm transition-all placeholder:text-slate-400 focus:border-brand-dark focus:outline-none focus:ring-2 focus:ring-brand-light/20"
+              className="focus:border-brand-dark focus:ring-brand-light/20 w-full resize-none rounded-xl border border-slate-200 bg-white px-5 py-4 text-base text-slate-800 shadow-sm transition-all placeholder:text-slate-400 focus:outline-none focus:ring-2"
               onKeyDown={(e) => {
                 if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
                   handleGenerateWorkflow();
@@ -156,7 +156,7 @@ export const WorkflowsPage = ({ userEmail, organizationName, billingPlan }: Work
         <div className="w-full max-w-2xl space-y-8">
           <div className="space-y-3 text-center">
             <div className="mx-auto mb-4 flex h-12 w-12 items-center justify-center rounded-xl bg-slate-100">
-              <Sparkles className="h-6 w-6 text-brand-dark" />
+              <Sparkles className="text-brand-dark h-6 w-6" />
             </div>
             <h1 className="text-3xl font-bold tracking-tight text-slate-800">
               {t("workflows.coming_soon_title")}
@@ -175,7 +175,7 @@ export const WorkflowsPage = ({ userEmail, organizationName, billingPlan }: Work
               onChange={(e) => setDetailsValue(e.target.value)}
               placeholder={t("workflows.follow_up_placeholder")}
               rows={4}
-              className="w-full resize-none rounded-lg border border-slate-200 bg-slate-50 px-4 py-3 text-sm text-slate-800 transition-all placeholder:text-slate-400 focus:border-brand-dark focus:bg-white focus:outline-none focus:ring-2 focus:ring-brand-light/20"
+              className="focus:border-brand-dark focus:ring-brand-light/20 w-full resize-none rounded-lg border border-slate-200 bg-slate-50 px-4 py-3 text-sm text-slate-800 transition-all placeholder:text-slate-400 focus:bg-white focus:outline-none focus:ring-2"
             />
             <div className="mt-4 flex items-center justify-end gap-3">
               <Button variant="ghost" onClick={handleSkipFeedback} className="text-slate-500">

apps/web/app/(app)/environments/[environmentId]/workflows/page.tsx

@@ -2,7 +2,6 @@ import { Metadata } from "next";
 import { notFound, redirect } from "next/navigation";
 import { IS_FORMBRICKS_CLOUD } from "@/lib/constants";
 import { getUser } from "@/lib/user/service";
-import { getCloudBillingDisplayContext } from "@/modules/ee/billing/lib/cloud-billing-display";
 import { getEnvironmentAuth } from "@/modules/environments/lib/utils";
 import { WorkflowsPage } from "./components/workflows-page";
 
@@ -28,13 +27,11 @@ const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
     return redirect("/auth/login");
   }
 
-  const cloudBillingDisplayContext = await getCloudBillingDisplayContext(organization.id);
-
   return (
     <WorkflowsPage
       userEmail={user.email}
       organizationName={organization.name}
-      billingPlan={cloudBillingDisplayContext.currentCloudPlan}
+      billingPlan={organization.billing.plan}
     />
   );
 };

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

@@ -4,8 +4,10 @@ import { z } from "zod";
 import { ZId } from "@formbricks/types/common";
 import { ZIntegrationInput } from "@formbricks/types/integration";
 import { createOrUpdateIntegration, deleteIntegration } from "@/lib/integration/service";
+import { getPostHogClient } from "@/lib/posthog-server";
 import { authenticatedActionClient } from "@/lib/utils/action-client";
 import { checkAuthorizationUpdated } from "@/lib/utils/action-client/action-client-middleware";
+import { AuthenticatedActionClientCtx } from "@/lib/utils/action-client/types/context";
 import {
   getOrganizationIdFromEnvironmentId,
   getOrganizationIdFromIntegrationId,
@@ -22,8 +24,68 @@ const ZCreateOrUpdateIntegrationAction = z.object({
 export const createOrUpdateIntegrationAction = authenticatedActionClient
   .inputSchema(ZCreateOrUpdateIntegrationAction)
   .action(
-    withAuditLogging("createdUpdated", "integration", async ({ ctx, parsedInput }) => {
-      const organizationId = await getOrganizationIdFromEnvironmentId(parsedInput.environmentId);
+    withAuditLogging(
+      "createdUpdated",
+      "integration",
+      async ({
+        ctx,
+        parsedInput,
+      }: {
+        ctx: AuthenticatedActionClientCtx;
+        parsedInput: Record<string, any>;
+      }) => {
+        const organizationId = await getOrganizationIdFromEnvironmentId(parsedInput.environmentId);
+
+        await checkAuthorizationUpdated({
+          userId: ctx.user.id,
+          organizationId,
+          access: [
+            {
+              type: "organization",
+              roles: ["owner", "manager"],
+            },
+            {
+              type: "projectTeam",
+              minPermission: "readWrite",
+              projectId: await getProjectIdFromEnvironmentId(parsedInput.environmentId),
+            },
+          ],
+        });
+
+        ctx.auditLoggingCtx.organizationId = organizationId;
+        const result = await createOrUpdateIntegration(
+          parsedInput.environmentId,
+          parsedInput.integrationData
+        );
+        ctx.auditLoggingCtx.integrationId = result.id;
+        ctx.auditLoggingCtx.newObject = result;
+
+        const posthog = getPostHogClient();
+        posthog.capture({
+          distinctId: ctx.user.email,
+          event: "integration_connected",
+          properties: {
+            integrationType: parsedInput.integrationData.type,
+            environmentId: parsedInput.environmentId,
+            organizationId,
+          },
+        });
+
+        return result;
+      }
+    )
+  );
+
+const ZDeleteIntegrationAction = z.object({
+  integrationId: ZId,
+});
+
+export const deleteIntegrationAction = authenticatedActionClient.inputSchema(ZDeleteIntegrationAction).action(
+  withAuditLogging(
+    "deleted",
+    "integration",
+    async ({ ctx, parsedInput }: { ctx: AuthenticatedActionClientCtx; parsedInput: Record<string, any> }) => {
+      const organizationId = await getOrganizationIdFromIntegrationId(parsedInput.integrationId);
 
       await checkAuthorizationUpdated({
         userId: ctx.user.id,
@@ -35,48 +97,17 @@ export const createOrUpdateIntegrationAction = authenticatedActionClient
           },
           {
             type: "projectTeam",
+            projectId: await getProjectIdFromIntegrationId(parsedInput.integrationId),
             minPermission: "readWrite",
-            projectId: await getProjectIdFromEnvironmentId(parsedInput.environmentId),
           },
         ],
       });
 
       ctx.auditLoggingCtx.organizationId = organizationId;
-      const result = await createOrUpdateIntegration(parsedInput.environmentId, parsedInput.integrationData);
-      ctx.auditLoggingCtx.integrationId = result.id;
-      ctx.auditLoggingCtx.newObject = result;
+      ctx.auditLoggingCtx.integrationId = parsedInput.integrationId;
+      const result = await deleteIntegration(parsedInput.integrationId);
+      ctx.auditLoggingCtx.oldObject = result;
       return result;
-    })
-  );
-
-const ZDeleteIntegrationAction = z.object({
-  integrationId: ZId,
-});
-
-export const deleteIntegrationAction = authenticatedActionClient.inputSchema(ZDeleteIntegrationAction).action(
-  withAuditLogging("deleted", "integration", async ({ ctx, parsedInput }) => {
-    const organizationId = await getOrganizationIdFromIntegrationId(parsedInput.integrationId);
-
-    await checkAuthorizationUpdated({
-      userId: ctx.user.id,
-      organizationId,
-      access: [
-        {
-          type: "organization",
-          roles: ["owner", "manager"],
-        },
-        {
-          type: "projectTeam",
-          projectId: await getProjectIdFromIntegrationId(parsedInput.integrationId),
-          minPermission: "readWrite",
-        },
-      ],
-    });
-
-    ctx.auditLoggingCtx.organizationId = organizationId;
-    ctx.auditLoggingCtx.integrationId = parsedInput.integrationId;
-    const result = await deleteIntegration(parsedInput.integrationId);
-    ctx.auditLoggingCtx.oldObject = result;
-    return result;
-  })
+    }
+  )
 );

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/airtable/components/AddIntegrationModal.tsx

@@ -284,7 +284,7 @@ export const AddIntegrationModal = ({
       }
       handleClose();
     } catch (e) {
-      toast.error(e instanceof Error ? e.message : "Unknown error occurred");
+      toast.error(e.message);
     }
   };
 
@@ -322,7 +322,7 @@ export const AddIntegrationModal = ({
 
       toast.success(t("environments.integrations.integration_removed_successfully"));
     } catch (e) {
-      toast.error(e instanceof Error ? e.message : "Unknown error occurred");
+      toast.error(e.message);
     }
   };
 

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/airtable/page.tsx

@@ -13,7 +13,7 @@ import { GoBackButton } from "@/modules/ui/components/go-back-button";
 import { PageContentWrapper } from "@/modules/ui/components/page-content-wrapper";
 import { PageHeader } from "@/modules/ui/components/page-header";
 
-const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
+const Page = async (props) => {
   const params = await props.params;
   const t = await getTranslate();
   const isEnabled = !!AIRTABLE_CLIENT_ID;

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/google-sheets/components/AddIntegrationModal.tsx

@@ -195,7 +195,7 @@ export const AddIntegrationModal = ({
       resetForm();
       setOpen(false);
     } catch (e) {
-      toast.error(e instanceof Error ? e.message : "Unknown error occurred");
+      toast.error(e.message);
     } finally {
       setIsLinkingSheet(false);
     }
@@ -237,7 +237,7 @@ export const AddIntegrationModal = ({
       toast.success(t("environments.integrations.integration_removed_successfully"));
       setOpen(false);
     } catch (error) {
-      toast.error(error instanceof Error ? error.message : "Unknown error occurred");
+      toast.error(error.message);
     } finally {
       setIsDeleting(false);
     }

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/google-sheets/page.tsx

@@ -16,7 +16,7 @@ import { GoBackButton } from "@/modules/ui/components/go-back-button";
 import { PageContentWrapper } from "@/modules/ui/components/page-content-wrapper";
 import { PageHeader } from "@/modules/ui/components/page-header";
 
-const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
+const Page = async (props) => {
   const params = await props.params;
   const t = await getTranslate();
   const isEnabled = !!(GOOGLE_SHEETS_CLIENT_ID && GOOGLE_SHEETS_CLIENT_SECRET && GOOGLE_SHEETS_REDIRECT_URL);

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/notion/components/AddIntegrationModal.tsx

@@ -234,7 +234,7 @@ export const AddIntegrationModal = ({
       resetForm();
       setOpen(false);
     } catch (e) {
-      toast.error(e instanceof Error ? e.message : "Unknown error occurred");
+      toast.error(e.message);
     } finally {
       setIsLinkingDatabase(false);
     }
@@ -255,7 +255,7 @@ export const AddIntegrationModal = ({
       toast.success(t("environments.integrations.integration_removed_successfully"));
       setOpen(false);
     } catch (error) {
-      toast.error(error instanceof Error ? error.message : "Unknown error occurred");
+      toast.error(error.message);
     } finally {
       setIsDeleting(false);
     }

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/notion/components/MappingRow.tsx

@@ -65,7 +65,7 @@ const MappingErrorMessage = ({
               question_label: element.label,
               col_name: col.name,
               col_type: col.type,
-              mapped_type: (TYPE_MAPPING as Record<string, string[]>)[element.id].join(" ,"),
+              mapped_type: TYPE_MAPPING[element.id].join(" ,"),
             })}
           </>
         );
@@ -135,7 +135,7 @@ export const MappingRow = ({
           return copy;
         }
 
-        const isValidColType = (TYPE_MAPPING as Record<string, string[]>)[item.type]?.includes(col.type);
+        const isValidColType = TYPE_MAPPING[item.type].includes(col.type);
         if (!isValidColType) {
           copy[idx] = {
             ...copy[idx],
@@ -166,7 +166,7 @@ export const MappingRow = ({
           return copy;
         }
 
-        const isValidElemType = (TYPE_MAPPING as Record<string, string[]>)[elem.type]?.includes(item.type);
+        const isValidElemType = TYPE_MAPPING[elem.type].includes(item.type);
         if (!isValidElemType) {
           copy[idx] = {
             ...copy[idx],

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/notion/components/NotionWrapper.tsx

@@ -36,7 +36,7 @@ export const NotionWrapper = ({
 }: NotionWrapperProps) => {
   const [isModalOpen, setIsModalOpen] = useState(false);
   const [isConnected, setIsConnected] = useState(
-    notionIntegration ? !!notionIntegration.config.key?.bot_id : false
+    notionIntegration ? notionIntegration.config.key?.bot_id : false
   );
   const [selectedIntegration, setSelectedIntegration] = useState<
     (TIntegrationNotionConfigData & { index: number }) | null

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/notion/page.tsx

@@ -18,7 +18,7 @@ import { GoBackButton } from "@/modules/ui/components/go-back-button";
 import { PageContentWrapper } from "@/modules/ui/components/page-content-wrapper";
 import { PageHeader } from "@/modules/ui/components/page-header";
 
-const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
+const Page = async (props) => {
   const params = await props.params;
   const t = await getTranslate();
   const enabled = !!(

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/page.tsx

@@ -27,7 +27,7 @@ const getStatusText = (count: number, t: TFunction, type: string) => {
   return `${count} ${type}s`;
 };
 
-const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
+const Page = async (props) => {
   const params = await props.params;
   const t = await getTranslate();
 

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/slack/components/AddChannelMappingModal.tsx

@@ -161,7 +161,7 @@ export const AddChannelMappingModal = ({
       resetForm();
       setOpen(false);
     } catch (e) {
-      toast.error(e instanceof Error ? e.message : "Unknown error occurred");
+      toast.error(e.message);
     } finally {
       setIsLinkingChannel(false);
     }
@@ -200,7 +200,7 @@ export const AddChannelMappingModal = ({
       toast.success(t("environments.integrations.integration_removed_successfully"));
       setOpen(false);
     } catch (error) {
-      toast.error(error instanceof Error ? error.message : "Unknown error occurred");
+      toast.error(error.message);
     } finally {
       setIsDeleting(false);
     }

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/slack/components/SlackWrapper.tsx

@@ -30,7 +30,7 @@ export const SlackWrapper = ({
   webAppUrl,
   locale,
 }: SlackWrapperProps) => {
-  const [isConnected, setIsConnected] = useState(slackIntegration ? !!slackIntegration.config?.key : false);
+  const [isConnected, setIsConnected] = useState(slackIntegration ? slackIntegration.config?.key : false);
   const [slackChannels, setSlackChannels] = useState<TIntegrationItem[]>([]);
   const [isModalOpen, setIsModalOpen] = useState<boolean>(false);
   const [showReconnectButton, setShowReconnectButton] = useState<boolean>(false);

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/slack/page.tsx

@@ -11,7 +11,7 @@ import { GoBackButton } from "@/modules/ui/components/go-back-button";
 import { PageContentWrapper } from "@/modules/ui/components/page-content-wrapper";
 import { PageHeader } from "@/modules/ui/components/page-header";
 
-const Page = async (props: { params: Promise<{ environmentId: string }> }) => {
+const Page = async (props) => {
   const params = await props.params;
   const isEnabled = !!(SLACK_CLIENT_ID && SLACK_CLIENT_SECRET);
 

apps/web/app/(app)/environments/[environmentId]/workspace/languages/loading.tsx

@@ -1,3 +1,3 @@
-import { LanguagesLoading } from "@/modules/projects/settings/languages/loading";
+import { LanguagesLoading } from "@/modules/ee/languages/loading";
 
 export default LanguagesLoading;

apps/web/app/(app)/environments/[environmentId]/workspace/languages/page.tsx

@@ -1,3 +1,3 @@
-import { LanguagesPage } from "@/modules/projects/settings/languages/page";
+import { LanguagesPage } from "@/modules/ee/languages/page";
 
 export default LanguagesPage;

apps/web/app/(app)/layout.tsx

@@ -1,19 +1,13 @@
 import { getServerSession } from "next-auth";
 import { ChatwootWidget } from "@/app/chatwoot/ChatwootWidget";
-import { PostHogIdentify } from "@/app/posthog/PostHogIdentify";
-import {
-  CHATWOOT_BASE_URL,
-  CHATWOOT_WEBSITE_TOKEN,
-  IS_CHATWOOT_CONFIGURED,
-  POSTHOG_KEY,
-} from "@/lib/constants";
+import { CHATWOOT_BASE_URL, CHATWOOT_WEBSITE_TOKEN, IS_CHATWOOT_CONFIGURED } from "@/lib/constants";
 import { getUser } from "@/lib/user/service";
 import { authOptions } from "@/modules/auth/lib/authOptions";
 import { ClientLogout } from "@/modules/ui/components/client-logout";
 import { NoMobileOverlay } from "@/modules/ui/components/no-mobile-overlay";
 import { ToasterClient } from "@/modules/ui/components/toaster-client";
 
-const AppLayout = async ({ children }: { children: React.ReactNode }) => {
+const AppLayout = async ({ children }) => {
   const session = await getServerSession(authOptions);
   const user = session?.user?.id ? await getUser(session.user.id) : null;
 
@@ -25,9 +19,6 @@ const AppLayout = async ({ children }: { children: React.ReactNode }) => {
   return (
     <>
       <NoMobileOverlay />
-      {POSTHOG_KEY && user && (
-        <PostHogIdentify posthogKey={POSTHOG_KEY} userId={user.id} email={user.email} name={user.name} />
-      )}
       {IS_CHATWOOT_CONFIGURED && (
         <ChatwootWidget
           userEmail={user?.email}

apps/web/app/(auth)/layout.tsx

@@ -1,6 +1,6 @@
 import { NoMobileOverlay } from "@/modules/ui/components/no-mobile-overlay";
 
-const AppLayout = async ({ children }: { children: React.ReactNode }) => {
+const AppLayout = async ({ children }) => {
   return (
     <>
       <NoMobileOverlay />

apps/web/app/api/(internal)/pipeline/lib/__mocks__/survey-follow-up.mock.ts

@@ -169,9 +169,6 @@ export const mockSurvey: TSurvey = {
   segment: null,
   followUps: mockFollowUps,
   metadata: {},
-  blocks: [],
-  isCaptureIpEnabled: false,
-  slug: null,
 };
 
 export const mockContactQuestion: TSurveyContactInfoQuestion = {

apps/web/app/api/(internal)/pipeline/lib/handleIntegrations.ts

@@ -156,7 +156,7 @@ const handleAirtableIntegration = async (
   } catch (err) {
     return {
       ok: false,
-      error: err instanceof Error ? err : new Error(String(err)),
+      error: err,
     };
   }
 };
@@ -197,7 +197,7 @@ const handleGoogleSheetsIntegration = async (
   } catch (err) {
     return {
       ok: false,
-      error: err instanceof Error ? err : new Error(String(err)),
+      error: err,
     };
   }
 };
@@ -239,7 +239,7 @@ const handleSlackIntegration = async (
   } catch (err) {
     return {
       ok: false,
-      error: err instanceof Error ? err : new Error(String(err)),
+      error: err,
     };
   }
 };
@@ -349,7 +349,7 @@ const handleNotionIntegration = async (
   } catch (err) {
     return {
       ok: false,
-      error: err instanceof Error ? err : new Error(String(err)),
+      error: err,
     };
   }
 };
@@ -374,8 +374,8 @@ const buildNotionPayloadProperties = (
       const pictureElement = surveyElements.find((el) => el.id === resp);
 
       responses[resp] = (pictureElement as any)?.choices
-        .filter((choice: { id: string; imageUrl: string }) => selectedChoiceIds.includes(choice.id))
-        .map((choice: { id: string; imageUrl: string }) => resolveStorageUrlAuto(choice.imageUrl));
+        .filter((choice) => selectedChoiceIds.includes(choice.id))
+        .map((choice) => resolveStorageUrlAuto(choice.imageUrl));
     }
   });
 

apps/web/app/api/(internal)/pipeline/lib/telemetry.test.ts

@@ -6,12 +6,7 @@ import { logger } from "@formbricks/logger";
 import { sendTelemetryEvents } from "./telemetry";
 
 // Mock dependencies
-vi.mock("@formbricks/cache", () => ({
-  getCacheService: vi.fn(),
-  createCacheKey: {
-    custom: vi.fn((_namespace: string, key: string) => key),
-  },
-}));
+vi.mock("@formbricks/cache");
 vi.mock("@formbricks/database", () => ({
   prisma: {
     organization: {

apps/web/app/api/(internal)/pipeline/lib/telemetry.ts

@@ -1,5 +1,5 @@
 import { IntegrationType } from "@prisma/client";
-import { createCacheKey, getCacheService } from "@formbricks/cache";
+import { type CacheKey, getCacheService } from "@formbricks/cache";
 import { prisma } from "@formbricks/database";
 import { logger } from "@formbricks/logger";
 import { env } from "@/lib/env";
@@ -7,8 +7,8 @@ import { getInstanceInfo } from "@/lib/instance";
 import packageJson from "@/package.json";
 
 const TELEMETRY_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
-const TELEMETRY_LOCK_KEY = createCacheKey.custom("analytics", "telemetry_lock");
-const TELEMETRY_LAST_SENT_KEY = createCacheKey.custom("analytics", "telemetry_last_sent_ts");
+const TELEMETRY_LOCK_KEY = "telemetry_lock" as CacheKey;
+const TELEMETRY_LAST_SENT_KEY = "telemetry_last_sent_ts" as CacheKey;
 
 /**
  * In-memory timestamp for the next telemetry check.

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

@@ -18,7 +18,6 @@ import { convertDatesInObject } from "@/lib/time";
 import { validateWebhookUrl } from "@/lib/utils/validate-webhook-url";
 import { queueAuditEvent } from "@/modules/ee/audit-logs/lib/handler";
 import { TAuditStatus, UNKNOWN_DATA } from "@/modules/ee/audit-logs/types/audit-log";
-import { recordResponseCreatedMeterEvent } from "@/modules/ee/billing/lib/metering";
 import { sendResponseFinishedEmail } from "@/modules/email";
 import { resolveStorageUrlsInObject } from "@/modules/storage/utils";
 import { sendFollowUpsForResponse } from "@/modules/survey/follow-ups/lib/follow-ups";
@@ -291,14 +290,6 @@ export const POST = async (request: Request) => {
     });
   }
   if (event === "responseCreated") {
-    recordResponseCreatedMeterEvent({
-      stripeCustomerId: organization.billing.stripeCustomerId,
-      responseId: response.id,
-      createdAt: response.createdAt,
-    }).catch((error) => {
-      logger.error({ error, responseId: response.id }, "Failed to record response meter event");
-    });
-
     // Send telemetry events
     await sendTelemetryEvents();
   }

apps/web/app/api/auth/[...nextauth]/route.ts

@@ -1,7 +1,5 @@
 import * as Sentry from "@sentry/nextjs";
-import NextAuth, { Account, Profile, User } from "next-auth";
-import { AdapterUser } from "next-auth/adapters";
-import { CredentialInput } from "next-auth/providers/credentials";
+import NextAuth from "next-auth";
 import { logger } from "@formbricks/logger";
 import { IS_PRODUCTION, SENTRY_DSN } from "@/lib/constants";
 import { authOptions as baseAuthOptions } from "@/modules/auth/lib/authOptions";
@@ -75,19 +73,7 @@ const handler = async (req: Request, ctx: any) => {
         if (error) throw error;
         return result;
       },
-      async signIn({
-        user,
-        account,
-        profile,
-        email,
-        credentials,
-      }: {
-        user: User | AdapterUser;
-        account: Account | null;
-        profile?: Profile;
-        email?: { verificationRequest?: boolean };
-        credentials?: Record<string, CredentialInput>;
-      }) {
+      async signIn({ user, account, profile, email, credentials }) {
         let result: boolean | string = true;
         let error: any = undefined;
         let authMethod = "unknown";

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

@@ -8,9 +8,7 @@ import { getContactByUserId } from "./contact";
 import { createDisplay } from "./display";
 
 vi.mock("@/lib/utils/validate", () => ({
-  validateInputs: vi.fn((inputs: [unknown, unknown][]) =>
-    inputs.map((input: [unknown, unknown]) => input[0])
-  ), // Pass through validation for testing
+  validateInputs: vi.fn((inputs) => inputs.map((input) => input[0])), // Pass through validation for testing
 }));
 
 vi.mock("@formbricks/database", () => ({

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

@@ -1,13 +1,20 @@
+import { NextRequest } from "next/server";
 import { logger } from "@formbricks/logger";
 import { ZDisplayCreateInput } from "@formbricks/types/displays";
 import { ResourceNotFoundError } from "@formbricks/types/errors";
 import { responses } from "@/app/lib/api/response";
 import { transformErrorToDetails } from "@/app/lib/api/validator";
-import { THandlerParams, withV1ApiWrapper } from "@/app/lib/api/with-api-logging";
-import { getOrganizationIdFromEnvironmentId } from "@/lib/utils/helper";
+import { withV1ApiWrapper } from "@/app/lib/api/with-api-logging";
+import { getPostHogClient } from "@/lib/posthog-server";
 import { getIsContactsEnabled } from "@/modules/ee/license-check/lib/utils";
 import { createDisplay } from "./lib/display";
 
+interface Context {
+  params: Promise<{
+    environmentId: string;
+  }>;
+}
+
 export const OPTIONS = async (): Promise<Response> => {
   return responses.successResponse(
     {},
@@ -19,7 +26,7 @@ export const OPTIONS = async (): Promise<Response> => {
 };
 
 export const POST = withV1ApiWrapper({
-  handler: async ({ req, props }: THandlerParams<{ params: Promise<{ environmentId: string }> }>) => {
+  handler: async ({ req, props }: { req: NextRequest; props: Context }) => {
     const params = await props.params;
     const jsonInput = await req.json();
     const inputValidation = ZDisplayCreateInput.safeParse({
@@ -38,8 +45,7 @@ export const POST = withV1ApiWrapper({
     }
 
     if (inputValidation.data.userId) {
-      const organizationId = await getOrganizationIdFromEnvironmentId(params.environmentId);
-      const isContactsEnabled = await getIsContactsEnabled(organizationId);
+      const isContactsEnabled = await getIsContactsEnabled();
       if (!isContactsEnabled) {
         return {
           response: responses.forbiddenResponse(
@@ -53,6 +59,17 @@ export const POST = withV1ApiWrapper({
     try {
       const response = await createDisplay(inputValidation.data);
 
+      const posthog = getPostHogClient();
+      posthog.capture({
+        distinctId: params.environmentId,
+        event: "survey_displayed",
+        properties: {
+          surveyId: inputValidation.data.surveyId,
+          environmentId: params.environmentId,
+          hasUserId: !!inputValidation.data.userId,
+        },
+      });
+
       return {
         response: responses.successResponse(response, true),
       };

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

@@ -38,6 +38,13 @@ const mockEnvironmentData = {
     placement: "bottomRight",
     inAppSurveyBranding: true,
     styling: { allowStyleOverwrite: false },
+    organization: {
+      id: "org-123",
+      billing: {
+        plan: "free",
+        limits: { monthly: { responses: 100 } },
+      },
+    },
   },
   actionClasses: [
     {
@@ -107,6 +114,13 @@ describe("getEnvironmentStateData", () => {
           styling: { allowStyleOverwrite: false },
         },
       },
+      organization: {
+        id: "org-123",
+        billing: {
+          plan: "free",
+          limits: { monthly: { responses: 100 } },
+        },
+      },
       surveys: mockEnvironmentData.surveys,
       actionClasses: mockEnvironmentData.actionClasses,
     });
@@ -140,6 +154,18 @@ describe("getEnvironmentStateData", () => {
     await expect(getEnvironmentStateData(environmentId)).rejects.toThrow(ResourceNotFoundError);
   });
 
+  test("should throw ResourceNotFoundError when organization is not found", async () => {
+    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
+      ...mockEnvironmentData,
+      project: {
+        ...mockEnvironmentData.project,
+        organization: null,
+      },
+    } as never);
+
+    await expect(getEnvironmentStateData(environmentId)).rejects.toThrow(ResourceNotFoundError);
+  });
+
   test("should throw DatabaseError on Prisma database errors", async () => {
     const prismaError = new Prisma.PrismaClientKnownRequestError("Connection failed", {
       code: "P2024",
@@ -257,11 +283,32 @@ describe("getEnvironmentStateData", () => {
     expect(result.environment.appSetupCompleted).toBe(false);
   });
 
-  test("should not include organization in result", async () => {
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue(mockEnvironmentData as never);
+  test("should correctly extract organization billing data", async () => {
+    const customBilling = {
+      plan: "enterprise",
+      stripeCustomerId: "cus_123",
+      limits: {
+        monthly: { responses: 10000, miu: 50000 },
+        projects: 100,
+      },
+    };
+
+    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
+      ...mockEnvironmentData,
+      project: {
+        ...mockEnvironmentData.project,
+        organization: {
+          id: "org-enterprise",
+          billing: customBilling,
+        },
+      },
+    } as never);
 
     const result = await getEnvironmentStateData(environmentId);
 
-    expect(result).not.toHaveProperty("organization");
+    expect(result.organization).toEqual({
+      id: "org-enterprise",
+      billing: customBilling,
+    });
   });
 });