feat(vercel): add install param parser and org requirement helper

- Add getVercelInstallParams(request) to extract Vercel installation
  parameters (code, configurationId, next) from a request URL and only
  return them when the integration param is "vercel" or absent. This
  centralizes install URL parsing for Vercel flows.

- Add requireOrganization(request, organizationSlug) helper that
  ensures the caller is an authenticated member of the organization,
  returning the organization and userId or throwing a 404 response.
  This enforces access control for org-scoped routes.

- Refactor EnvironmentVariablesPresenter to use a Vercel integration
  service for fetching project integration and remove in-presenter
  legacy migration/parsing logic. The presenter now relies on
  VercelIntegrationService.getVercelProjectIntegration(projectId, true)
  to obtain parsed integration data, simplifying responsibilities and
  consolidating Vercel-related parsing/migration in the service layer.

These changes improve separation of concerns, centralize Vercel
integration parsing, and add a reusable org auth helper for request
handlers.

Author: 0ski

.vscode/settings.json

@@ -8,5 +8,5 @@
   },
   "vitest.disableWorkspaceWarning": true,
   "typescript.experimental.useTsgo": false,
-  "chat.agent.maxRequests": 0
+  "chat.agent.maxRequests": 10000
 }

apps/webapp/app/presenters/v3/EnvironmentVariablesPresenter.server.ts

@@ -1,16 +1,12 @@
-import { flipCauseOption } from "effect/Cause";
 import { PrismaClient, prisma } from "~/db.server";
 import { Project } from "~/models/project.server";
 import { User } from "~/models/user.server";
 import { filterOrphanedEnvironments, sortEnvironments } from "~/utils/environmentSort";
 import { EnvironmentVariablesRepository } from "~/v3/environmentVariables/environmentVariablesRepository.server";
 import {
-  VercelProjectIntegrationDataSchema,
   SyncEnvVarsMapping,
-  isLegacySyncEnvVarsMapping,
-  migrateLegacySyncEnvVarsMapping,
 } from "~/v3/vercel/vercelProjectIntegrationSchema";
-import { logger } from "~/services/logger.server";
+import { VercelIntegrationService } from "~/services/vercelIntegration.server";
 
 type Result = Awaited<ReturnType<EnvironmentVariablesPresenter["call"]>>;
 export type EnvironmentVariableWithSetValues = Result["environmentVariables"][number];
@@ -102,71 +98,15 @@ export class EnvironmentVariablesPresenter {
     const variables = await repository.getProject(project.id);
 
     // Get Vercel integration data if it exists
-    const vercelIntegration = await this.#prismaClient.organizationProjectIntegration.findFirst({
-      where: {
-        projectId: project.id,
-        deletedAt: null,
-        organizationIntegration: {
-          service: "VERCEL",
-          deletedAt: null,
-        },
-      },
-    });
+    const vercelService = new VercelIntegrationService(this.#prismaClient);
+    const vercelIntegration = await vercelService.getVercelProjectIntegration(project.id, true);
 
     let vercelSyncEnvVarsMapping: SyncEnvVarsMapping = {};
     let vercelPullEnvVarsEnabled = false;
 
     if (vercelIntegration) {
-      let parsedData = VercelProjectIntegrationDataSchema.safeParse(
-        vercelIntegration.integrationData
-      );
-      
-      // Handle migration from legacy format if needed
-      if (!parsedData.success) {
-        const rawData = vercelIntegration.integrationData as Record<string, unknown>;
-        
-        if (rawData && isLegacySyncEnvVarsMapping(rawData.syncEnvVarsMapping)) {
-          logger.info("Migrating legacy Vercel sync mapping format in presenter", {
-            projectId: project.id,
-            integrationId: vercelIntegration.id,
-          });
-
-          // Migrate the legacy format
-          const migratedMapping = migrateLegacySyncEnvVarsMapping(
-            rawData.syncEnvVarsMapping as Record<string, boolean>
-          );
-
-          // Update the data with migrated mapping
-          const migratedData = {
-            ...rawData,
-            syncEnvVarsMapping: migratedMapping,
-          };
-
-          // Try parsing again with migrated data
-          parsedData = VercelProjectIntegrationDataSchema.safeParse(migratedData);
-
-          if (parsedData.success) {
-            // Save the migrated data back to the database (fire and forget)
-            this.#prismaClient.organizationProjectIntegration.update({
-              where: { id: vercelIntegration.id },
-              data: {
-                integrationData: migratedData as any,
-              },
-            }).catch((error) => {
-              logger.error("Failed to save migrated Vercel sync mapping", {
-                projectId: project.id,
-                integrationId: vercelIntegration.id,
-                error,
-              });
-            });
-          }
-        }
-      }
-      
-      if (parsedData.success) {
-        vercelSyncEnvVarsMapping = parsedData.data.syncEnvVarsMapping;
-        vercelPullEnvVarsEnabled = parsedData.data.config.pullEnvVarsFromVercel;
-      }
+      vercelSyncEnvVarsMapping = vercelIntegration.parsedIntegrationData.syncEnvVarsMapping;
+      vercelPullEnvVarsEnabled = vercelIntegration.parsedIntegrationData.config.pullEnvVarsFromVercel;
     }
 
     return {

apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.integrations.vercel.tsx

@@ -12,7 +12,6 @@ import {
   Dialog,
   DialogContent,
   DialogDescription,
-  DialogFooter,
   DialogHeader,
   DialogTitle,
   DialogTrigger,
@@ -22,10 +21,9 @@ import { Header1 } from "~/components/primitives/Headers";
 import { PageBody, PageContainer } from "~/components/layout/AppLayout";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import { Table, TableBlankRow, TableBody, TableCell, TableHeader, TableHeaderCell, TableRow } from "~/components/primitives/Table";
-import { useOrganization } from "~/hooks/useOrganizations";
 import { VercelIntegrationRepository } from "~/models/vercelIntegration.server";
 import { $transaction, prisma } from "~/db.server";
-import { requireUserId } from "~/services/session.server";
+import { requireOrganization } from "~/services/org.server";
 import { OrganizationParamsSchema } from "~/utils/pathBuilder";
 import { logger } from "~/services/logger.server";
 import { TrashIcon } from "@heroicons/react/20/solid";
@@ -44,29 +42,15 @@ function formatDate(date: Date): string {
   }).format(date);
 }
 
-const SearchParamsSchema = z.object({
+const SearchParamsSchema = OrganizationParamsSchema.extend({
   configurationId: z.string().optional(),
 });
 
 export const loader = async ({ request, params }: LoaderFunctionArgs) => {
-  const userId = await requireUserId(request);
-  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+  const { organizationSlug, configurationId } = SearchParamsSchema.parse(params);
+  const { organization } = await requireOrganization(request, organizationSlug);
 
   const url = new URL(request.url);
-  const { configurationId } = SearchParamsSchema.parse(Object.fromEntries(url.searchParams));
-
-  // Check user has access to organization
-  const organization = await prisma.organization.findFirst({
-    where: {
-      slug: organizationSlug,
-      members: { some: { userId } },
-      deletedAt: null,
-    },
-  });
-
-  if (!organization) {
-    throw new Response("Not found", { status: 404 });
-  }
 
   // Find Vercel integration for this organization
   let vercelIntegration = await prisma.organizationIntegration.findFirst({
@@ -136,28 +120,9 @@ const ActionSchema = z.object({
 });
 
 export const action = async ({ request, params }: ActionFunctionArgs) => {
-  const userId = await requireUserId(request);
   const { organizationSlug } = OrganizationParamsSchema.parse(params);
+  const { organization, userId } = await requireOrganization(request, organizationSlug);
 
-  const formData = await request.formData();
-  const { intent } = ActionSchema.parse(Object.fromEntries(formData));
-
-  if (intent !== "uninstall") {
-    throw new Response("Invalid intent", { status: 400 });
-  }
-
-  // Check user has access to organization
-  const organization = await prisma.organization.findFirst({
-    where: {
-      slug: organizationSlug,
-      members: { some: { userId } },
-      deletedAt: null,
-    },
-  });
-
-  if (!organization) {
-    throw new Response("Not found", { status: 404 });
-  }
 
   // Find Vercel integration
   const vercelIntegration = await prisma.organizationIntegration.findFirst({

apps/webapp/app/routes/confirm-basic-details.tsx

@@ -25,6 +25,7 @@ import { redirectWithSuccessMessage } from "~/models/message.server";
 import { updateUser } from "~/models/user.server";
 import { requireUserId } from "~/services/session.server";
 import { rootPath } from "~/utils/pathBuilder";
+import { getVercelInstallParams } from "~/v3/vercel";
 
 function createSchema(
   constraints: {
@@ -106,22 +107,18 @@ export const action: ActionFunction = async ({ request }) => {
     });
 
     // Preserve Vercel integration params if present
-    const url = new URL(request.url);
-    const code = url.searchParams.get("code");
-    const configurationId = url.searchParams.get("configurationId");
-    const integration = url.searchParams.get("integration");
-    const next = url.searchParams.get("next");
+    const vercelParams = getVercelInstallParams(request);
     let redirectUrl = rootPath();
 
-    if (code && configurationId && integration === "vercel") {
+    if (vercelParams) {
       // Redirect to orgs/new with params preserved
       const params = new URLSearchParams({
-        code,
-        configurationId,
-        integration,
+        code: vercelParams.code,
+        configurationId: vercelParams.configurationId,
+        integration: "vercel",
       });
-      if (next) {
-        params.set("next", next);
+      if (vercelParams.next) {
+        params.set("next", vercelParams.next);
       }
       redirectUrl = `/orgs/new?${params.toString()}`;
     }

apps/webapp/app/services/org.server.ts

@@ -0,0 +1,20 @@
+import { prisma } from "~/db.server";
+import { requireUserId } from "./session.server";
+
+export async function requireOrganization(request: Request, organizationSlug: string) {
+  const userId = await requireUserId(request);
+  
+  const organization = await prisma.organization.findFirst({
+    where: {
+      slug: organizationSlug,
+      members: { some: { userId } },
+      deletedAt: null,
+    },
+  });
+
+  if (!organization) {
+    throw new Response("Organization not found", { status: 404 });
+  }
+
+  return { organization, userId };
+}

apps/webapp/app/services/vercelIntegration.server.ts

@@ -39,7 +39,8 @@ export class VercelIntegrationService {
   }
 
   async getVercelProjectIntegration(
-    projectId: string
+    projectId: string,
+    migrateIfNeeded: boolean = false
   ): Promise<VercelProjectIntegrationWithData | null> {
     const integration = await this.#prismaClient.organizationProjectIntegration.findFirst({
       where: {
@@ -60,6 +61,7 @@ export class VercelIntegrationService {
     }
 
     const parsedData = VercelProjectIntegrationDataSchema.safeParse(integration.integrationData);
+
     if (!parsedData.success) {
       logger.error("Failed to parse Vercel integration data", {
         projectId,

apps/webapp/app/v3/vercel/index.ts

@@ -6,3 +6,21 @@
 
 export * from "./vercelProjectIntegrationSchema";
 
+/**
+ * Extract Vercel installation parameters from a request URL.
+ */
+export function getVercelInstallParams(request: Request) {
+  const url = new URL(request.url);
+  const code = url.searchParams.get("code");
+  const configurationId = url.searchParams.get("configurationId");
+  const integration = url.searchParams.get("integration");
+  const next = url.searchParams.get("next");
+
+  if (code && configurationId && (integration === "vercel" || !integration)) {
+    return { code, configurationId, next };
+  }
+
+  return null;
+}
+
+

apps/webapp/app/v3/vercel/vercelProjectIntegrationSchema.ts

@@ -83,13 +83,6 @@ export const SyncEnvVarsMappingSchema = z.record(z.string(), EnvVarSyncSettingsS
 
 export type SyncEnvVarsMapping = z.infer<typeof SyncEnvVarsMappingSchema>;
 
-/**
- * Legacy mapping format (simple boolean per env var)
- * Used for migration from old format to new format.
- */
-export const LegacySyncEnvVarsMappingSchema = z.record(z.string(), z.boolean());
-export type LegacySyncEnvVarsMapping = z.infer<typeof LegacySyncEnvVarsMappingSchema>;
-
 /**
  * The complete integrationData schema for OrganizationProjectIntegration
  * when the integration service is VERCEL.
@@ -192,52 +185,3 @@ export function shouldSyncEnvVarForAnyEnvironment(
   const environments: TriggerEnvironmentType[] = ["PRODUCTION", "STAGING", "PREVIEW", "DEVELOPMENT"];
   return environments.some((env) => envVarSettings[env] !== false);
 }
-
-/**
- * Check if this is a legacy format mapping (simple boolean per env var)
- */
-export function isLegacySyncEnvVarsMapping(mapping: unknown): mapping is LegacySyncEnvVarsMapping {
-  if (!mapping || typeof mapping !== "object") {
-    return false;
-  }
-  // Check if any value is a boolean (legacy format)
-  // vs an object (new format)
-  for (const value of Object.values(mapping)) {
-    if (typeof value === "boolean") {
-      return true;
-    }
-    // If it's an object, it's the new format
-    if (typeof value === "object" && value !== null) {
-      return false;
-    }
-  }
-  // Empty object could be either, treat as new format
-  return false;
-}
-
-/**
- * Migrate legacy sync mapping format to new per-environment format.
- * If the env var was disabled in legacy format, it will be disabled for ALL environments.
- * If it was enabled (or not present), it will be enabled for all environments.
- */
-export function migrateLegacySyncEnvVarsMapping(
-  legacyMapping: LegacySyncEnvVarsMapping
-): SyncEnvVarsMapping {
-  const newMapping: SyncEnvVarsMapping = {};
-  const environments: TriggerEnvironmentType[] = ["PRODUCTION", "STAGING", "PREVIEW", "DEVELOPMENT"];
-
-  for (const [key, enabled] of Object.entries(legacyMapping)) {
-    if (enabled === false) {
-      // If disabled in legacy format, disable for all environments
-      newMapping[key] = {
-        PRODUCTION: false,
-        STAGING: false,
-        PREVIEW: false,
-        DEVELOPMENT: false,
-      };
-    }
-    // If enabled (true), we don't need to add it since default is enabled
-  }
-
-  return newMapping;
-}