apps/web/ui/partners/program-application-sheet.tsx (1)

87-97: Provide user feedback when preconditions fail.

The early return at line 88 still exits silently when group, program, partner.email, or partner.country are missing, leaving users without feedback about why submission did nothing.

Surface an error message to guide users:

  const onSubmit = async (data: FormData) => {
-   if (!group || !program || !partner?.email || !partner.country) return;
+   if (!group || !program) {
+     toast.error("Program or group data not loaded. Please try again.");
+     return;
+   }
+   if (!partner?.email || !partner.country) {
+     toast.error("Please complete your profile (email and country) before applying.");
+     setError("root.serverError", {
+       message: "Profile incomplete. Add email and country in your profile.",
+     });
+     return;
+   }

    const result = await executeAsync({

Note: This matches a previously flagged issue that remains unresolved.

apps/web/lib/actions/partners/update-group-branding.ts (4)

63-77: Restore workspace scoping on group updates.

Updating by bare id still lets anyone with a UUID mutate groups across workspaces/programs. Re-fetch the group scoped to the current programId (and bail if not found) before issuing the update.

-    const updatedGroup = await prisma.partnerGroup.update({
-      where: {
-        id: groupId,
-      },
+    const group = await prisma.partnerGroup.findFirst({
+      where: {
+        id: groupId,
+        programId,
+      },
+      select: {
+        id: true,
+        slug: true,
+      },
+    });
+    if (!group) {
+      throw new Error("Group not found in this workspace.");
+    }
+
+    const updatedGroup = await prisma.partnerGroup.update({
+      where: {
+        id: group.id,
+      },

---

90-99: Guard deletes to R2-backed assets only.

storage.delete will throw if program.logo|wordmark point off-R2. Add isStored to avoid firing deletes against third-party URLs.

-        ...(logoUpdated && program.logo
+        ...(logoUpdated && program.logo && isStored(program.logo)
           ? [storage.delete(program.logo.replace(`${R2_URL}/`, ""))]
           : []),
-        ...(wordmarkUpdated && program.wordmark
+        ...(wordmarkUpdated && program.wordmark && isStored(program.wordmark)
           ? [storage.delete(program.wordmark.replace(`${R2_URL}/`, ""))]
           : []),

---

108-117: Revalidate group pages whenever lander/form data change.

Lander updates aren’t triggering any revalidation, and group-scoped routes stay stale. Include landerDataInput and the slugged paths so both the default and group pages refresh.

-        ...(logoUpdated ||
-        wordmarkUpdated ||
-        brandColorUpdated ||
-        applicationFormDataInput
+        ...(logoUpdated ||
+          wordmarkUpdated ||
+          brandColorUpdated ||
+          applicationFormDataInput ||
+          landerDataInput
           ? [
               revalidatePath(`/partners.dub.co/${program.slug}`),
               revalidatePath(`/partners.dub.co/${program.slug}/apply`),
               revalidatePath(`/partners.dub.co/${program.slug}/apply/success`),
+              revalidatePath(
+                `/partners.dub.co/${program.slug}/${updatedGroup.slug}`,
+              ),
+              revalidatePath(
+                `/partners.dub.co/${program.slug}/${updatedGroup.slug}/apply`,
+              ),
+              revalidatePath(
+                `/partners.dub.co/${program.slug}/${updatedGroup.slug}/apply/success`,
+              ),
             ]
           : []),

---

136-142: Avoid throwing when form/lander data are null.

Calling .parse on null blows up whenever these payloads are absent. Switch to safeParse (or allow nullish in schema) and return null when parsing fails.

-    return {
-      success: true,
-      applicationFormData: programApplicationFormSchema.parse(
-        updatedGroup.applicationFormData,
-      ),
-      landerData: programLanderSchema.parse(updatedGroup.landerData),
+    const parsedApplicationForm = programApplicationFormSchema.safeParse(
+      updatedGroup.applicationFormData,
+    );
+    const parsedLander = programLanderSchema.safeParse(
+      updatedGroup.landerData,
+    );
+
+    return {
+      success: true,
+      applicationFormData: parsedApplicationForm.success
+        ? parsedApplicationForm.data
+        : null,
+      landerData: parsedLander.success ? parsedLander.data : null,
       program: ProgramWithLanderDataSchema.parse(updatedProgram),
     };

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/groups/[groupSlug]/group-header-selector.tsx (2)

35-42: Fix the infinite toggle loop.

This effect will cause an endless flip-flop: when groups.length >= GROUPS_MAX_PAGE_SIZE, it sets useAsync to true, but on the next render the condition evaluates to false (because !useAsync is now false), toggling it back. This creates continuous re-renders and fetch churn.

Apply this diff to only promote to true and never demote:

-  useEffect(
-    () =>
-      setUseAsync(
-        Boolean(groups && !useAsync && groups.length >= GROUPS_MAX_PAGE_SIZE),
-      ),
-    [groups, useAsync],
-  );
+  useEffect(() => {
+    if (groups && !useAsync && groups.length >= GROUPS_MAX_PAGE_SIZE) {
+      setUseAsync(true);
+    }
+  }, [groups, useAsync]);

---

92-107: Add null to the parameter type.

The Combobox component can pass null to setSelected when deselecting (see line 125 in the Combobox implementation), but the onChange callback currently only types the parameter as { value: string }. This will cause a TypeScript error.

Apply this diff to fix the type:

   const onChange = useCallback(
-    (option: { value: string }) => {
+    (option: { value: string } | null) => {
       if (!option) {
         return;
       }

apps/web/ui/partners/groups/design/branding-settings-form.tsx (1)

7-7: Stop importing from @dub/utils/src

The deep import keeps bypassing the package entry point and can pull non-transpiled sources into the bundle. Please switch to the public entry point.

-import { cn } from "@dub/utils/src";
+import { cn } from "@dub/utils";

apps/web/ui/partners/groups/design/branding-form.tsx (4)

184-202: Reset form with persisted asset URLs after successful publish

After publish, the form still holds pre-upload base64 strings for brand assets (logo, wordmark, brandColor) instead of the canonical URLs returned from the server. This keeps the UI out of sync and forces redundant uploads on the next submit.

Update the reset to include the persisted asset URLs:

     async onSuccess({ data }) {
       await mutateGroup();
       toast.success("Group updated successfully.");

       const currentValues = getValues();
-
-      // Still reset form state to clear isSubmitSuccessful
-      reset({
-        ...currentValues,
-        applicationFormData:
-          data?.applicationFormData ?? currentValues.applicationFormData,
-        landerData: data?.landerData ?? currentValues.landerData,
-      });
+      const program = data?.program;
+
+      reset({
+        ...currentValues,
+        logo: program?.logo ?? currentValues.logo,
+        wordmark: program?.wordmark ?? currentValues.wordmark,
+        brandColor: program?.brandColor ?? currentValues.brandColor,
+        applicationFormData:
+          data?.applicationFormData ?? currentValues.applicationFormData,
+        landerData: data?.landerData ?? currentValues.landerData,
+      });

---

229-241: Avoid spreading entire form data to prevent unintentional republishing

Spreading ...data sends all form fields to the server on every submit, which may republish unchanged landerData or applicationFormData and update their publishedAt timestamps unnecessarily.

Build a minimal payload containing only changed fields:

       onSubmit={handleSubmit(async (data) => {
-        const result = await executeAsync({
-          workspaceId: workspaceId!,
-          groupId: group.id,
-          ...data,
-        });
+        const payload: any = { workspaceId: workspaceId!, groupId: group.id };
+        
+        // Only include fields that changed
+        if (JSON.stringify(data.applicationFormData) !== JSON.stringify(group.applicationFormData)) {
+          payload.applicationFormData = data.applicationFormData;
+        }
+        if (JSON.stringify(data.landerData) !== JSON.stringify(group.landerData)) {
+          payload.landerData = data.landerData;
+        }
+        if (data.brandColor !== group.program?.brandColor) {
+          payload.brandColor = data.brandColor;
+        }
+        if (data.logo !== group.program?.logo) {
+          payload.logo = data.logo;
+        }
+        if (data.wordmark !== group.program?.wordmark) {
+          payload.wordmark = data.wordmark;
+        }
+        
+        const result = await executeAsync(payload);

For nested object comparison, prefer a deep-equal utility over JSON.stringify.

---

70-73: Update error message to reference "group" instead of "program"

The error message still references "program" but this component is now group-centric.

-      <div className="text-content-muted text-sm">Failed to load program</div>
+      <div className="text-content-muted text-sm">Failed to load group</div>

---

110-144: UUID generation on every invocation causes form data instability

Each time defaultApplicationFormData is called, uuid() generates new field IDs. If this function is invoked multiple times (e.g., during re-renders or when resetting defaults), the IDs will differ even though the structure is identical, causing unnecessary form state changes and potential draft mismatches.

Generate stable IDs by memoizing at module level or deriving deterministic IDs:

+const DEFAULT_FIELD_IDS = {
+  website: "default-field-website",
+  promotion: "default-field-promotion",
+  additional: "default-field-additional",
+};
+
 const defaultApplicationFormData = (
   program: ProgramProps,
 ): ProgramApplicationFormData => {
   return {
     fields: [
       {
-        id: uuid(),
+        id: DEFAULT_FIELD_IDS.website,
         type: "short-text",

apps/web/lib/swr/use-group.ts (1)

7-14: Default query to {} and constrain its type to primitives

Two issues flagged in past reviews remain unaddressed:

1. Runtime error risk: query is destructured without a default, so { ...query } on line 28 will throw when query is undefined.
2. Type safety: Record<string, any> allows objects that stringify to "[object Object]" in URLSearchParams.

Apply the fixes from the previous review:

 export default function useGroup<T = GroupProps>(
   {
     groupIdOrSlug: groupIdOrSlugProp,
-    query,
+    query = {},
   }: {
     groupIdOrSlug?: string;
-    query?: Record<string, any>;
+    query?: Record<string, string | number | boolean | null | undefined>;
   } = {},

Then optionally normalize values before building URLSearchParams:

const params = new URLSearchParams({ workspaceId });
Object.entries(query).forEach(([k, v]) => {
  if (v != null) params.set(k, String(v));
});

apps/web/scripts/migrations/migrate-application-form-data.ts (2)

99-108: Keep the migration idempotent; only seed groups missing form data.

updateMany currently overwrites every partner group’s applicationFormData on each run, clobbering any form the team may have published later. Add a guard (e.g., require both applicationFormData and applicationFormPublishedAt to be null) so the seeding happens only for groups that haven’t been initialized yet. Re-running the migration should be a no-op for groups that already have data.

-  const updatedGroups = await prisma.partnerGroup.updateMany({
-    where: {
-      id: {
-        in: groupIds,
-      },
-    },
-    data: {
-      applicationFormData,
-    },
-  });
+  const updatedGroups = await prisma.partnerGroup.updateMany({
+    where: {
+      id: { in: groupIds },
+      applicationFormData: null,
+      applicationFormPublishedAt: null,
+    },
+    data: {
+      applicationFormData,
+    },
+  });

---

113-127: Skip applications that already have formData to avoid wiping responses.

Re-running this script replaces every ProgramApplication.formData, even records that already contain structured submissions captured after the initial run. Filter for formData: null (or bail out per-record) so we only backfill legacy rows lacking the structured payload.

-  const applications = await prisma.programApplication.findMany({
-    where: {
-      programId: program.id,
-    },
-  });
+  const applications = await prisma.programApplication.findMany({
+    where: {
+      programId: program.id,
+      formData: null,
+    },
+    select: {
+      id: true,
+      website: true,
+      proposal: true,
+      comments: true,
+    },
+  });
…
-    await prisma.programApplication.update({
-      where: { id: application.id },
-      data: {
-        formData: defaultApplicationFormDataWithValues(program, application),
-      },
-    });
+    await prisma.programApplication.update({
+      where: { id: application.id },
+      data: {
+        formData: defaultApplicationFormDataWithValues(program, application as ProgramApplication),
+      },
+    });

apps/web/ui/partners/groups/design/branding-form.tsx (1)

50-50: Remove unused groupSlug from useParams

The groupSlug variable is extracted but never used in this component.

-  const { groupSlug } = useParams<{ groupSlug: string }>();
-
   const { group, mutateGroup, loading } = useGroup<GroupWithProgramProps>(

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

apps/web/ui/partners/partner-application-details.tsx (2)

70-75: Replace the empty heading with a visible skeleton bar.

The self-closing <h4> renders nothing, so the title placeholder is still invisible. Drop the empty heading and keep the animated bar.

-        <div key={idx}>
-          <h4 className="text-content-emphasis font-semibold" />
-          <div className="h-5 w-32 animate-pulse rounded-md bg-neutral-200" />
+        <div key={idx}>
+          <div
+            aria-hidden="true"
+            className="h-5 w-32 animate-pulse rounded-md bg-neutral-200"
+          />

---

17-30: Handle the SWR error state instead of looping the skeleton.

useSWRImmutable returns an error when the fetch fails; because we ignore it, application stays undefined and we render the skeleton forever. Surface the error (same copy we discussed previously) so ops teams see a failure instead of a perpetual loader.

Apply this diff to cover the basics:

-  const { data: application, isLoading } = useSWRImmutable<ProgramApplication>(
+  const {
+    data: application,
+    isLoading,
+    error,
+  } = useSWRImmutable<ProgramApplication>(
@@
-  if (isLoading || !application) {
+  if (error) {
+    return (
+      <div className="text-sm text-red-600">
+        Failed to load application details.
+      </div>
+    );
+  }
+
+  if (isLoading || !application) {
     return <PartnerApplicationDetailsSkeleton />;
   }

apps/web/ui/partners/applications/utils/format-application-form-data.ts (1)

7-24: Parse formData with the Zod schema before iterating.

application.formData is still a raw Prisma.JsonValue; if the payload is malformed we’ll throw while dereferencing field.data/field.label. Safe-parse with programApplicationFormDataWithValuesSchema and bail early on failure instead of trusting the cast.

-import { ProgramApplicationFormDataWithValues } from "@/lib/types";
+import { ProgramApplicationFormDataWithValues } from "@/lib/types";
+import { programApplicationFormDataWithValuesSchema } from "@/lib/zod/schemas/program-application-form";
@@
-export const formatApplicationFormData = (
-  application: ProgramApplication,
-): { title: string; value: string }[] => {
-  const formData =
-    application?.formData as ProgramApplicationFormDataWithValues;
+export const formatApplicationFormData = (
+  application: ProgramApplication,
+): { title: string; value: string }[] => {
+  const parsed =
+    programApplicationFormDataWithValuesSchema.safeParse(application?.formData);
+
+  if (!parsed.success) {
+    return [];
+  }
+
+  const formData: ProgramApplicationFormDataWithValues = parsed.data;

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

apps/web/lib/partners/format-application-form-data.ts (1)

28-42: Wrap the multiple-choice case in a block.

The let value declaration at line 29 needs block scope to prevent leaking to other switch cases, as previously noted.

Apply this diff to fix:

-        case "multiple-choice":
-          let value;
-
-          if (field.data.multiple) {
-            value = Array.isArray(field.value)
-              ? field.value.join(", ")
-              : field.value;
-          } else {
-            value = field.value;
-          }
-
-          return {
-            title: field.label,
-            value,
-          };
+        case "multiple-choice": {
+          let value;
+
+          if (field.data.multiple) {
+            value = Array.isArray(field.value)
+              ? field.value.join(", ")
+              : field.value;
+          } else {
+            value = field.value;
+          }
+
+          return {
+            title: field.label,
+            value,
+          };
+        }

apps/web/lib/actions/partners/update-group-branding.ts (1)

178-185: Avoid runtime throws when form data is null; use safeParse or allow nullish.

Lines 180-184 use .parse() on updatedGroup.applicationFormData and updatedGroup.landerData. If either field is null (which can happen when the user doesn't provide these fields), .parse() will throw a Zod validation error at runtime, causing the action to fail after successful database updates.

Apply this diff to use safeParse() and return null when data is absent:

+  const appForm = programApplicationFormSchema.safeParse(
+    updatedGroup.applicationFormData,
+  );
+  const lander = programLanderSchema.safeParse(updatedGroup.landerData);
+
   return {
     success: true,
-    applicationFormData: programApplicationFormSchema.parse(
-      updatedGroup.applicationFormData,
-    ),
-    landerData: programLanderSchema.parse(updatedGroup.landerData),
+    applicationFormData: appForm.success ? appForm.data : null,
+    landerData: lander.success ? lander.data : null,
     program: ProgramWithLanderDataSchema.parse(updatedProgram),
   };

apps/web/lib/partners/format-application-form-data.ts (1)

10-27: Consider consolidating the simple field type cases.

The short-text, long-text, and select cases are identical. You could simplify the switch statement by handling them in a single case.

Apply this diff to consolidate:

     .map((field) => {
       switch (field.type) {
-        case "short-text":
-          return {
-            title: field.label,
-            value: field.value,
-          };
-        case "long-text":
-          return {
-            title: field.label,
-            value: field.value,
-          };
-        case "select":
+        case "short-text":
+        case "long-text":
+        case "select":
           return {
             title: field.label,
             value: field.value,
           };

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

apps/web/lib/actions/partners/update-group-branding.ts (1)

187-194: Runtime error when form data is null.

Using .parse() on lines 189-192 will throw at runtime if applicationFormData or landerData are null (when not provided in the input). This critical issue remains unresolved from previous reviews.

Apply this diff to safely handle null values:

     return {
       success: true,
-      applicationFormData: programApplicationFormSchema.parse(
-        updatedGroup.applicationFormData,
-      ),
-      landerData: programLanderSchema.parse(updatedGroup.landerData),
+      applicationFormData: updatedGroup.applicationFormData
+        ? programApplicationFormSchema.parse(updatedGroup.applicationFormData)
+        : null,
+      landerData: updatedGroup.landerData
+        ? programLanderSchema.parse(updatedGroup.landerData)
+        : null,
       program: ProgramWithLanderDataSchema.parse(updatedProgram),
     };

packages/email/src/templates/partner-application-received.tsx (2)

143-144: Consider using index as fallback for the key prop.

Using field.title as the key assumes all form field titles are unique. If the application form contains duplicate titles (e.g., multiple "Additional comments" fields), React will encounter reconciliation issues.

Apply this diff to add index as a fallback:

-                  {partner.applicationFormData.map((field) => (
-                    <Section key={field.title} className="mb-6">
+                  {partner.applicationFormData.map((field, index) => (
+                    <Section key={`${field.title}-${index}`} className="mb-6">

Alternatively, if a stable unique identifier (like field.id) will be added to the data structure in the future, prefer that over title.

---

54-54: Consider adding a unique identifier to applicationFormData items.

The current type definition lacks a unique identifier field. Adding an id or fieldId property would provide a more stable key for React rendering and improve data traceability.

Consider updating the type to:

-    applicationFormData: { title: string; value: string }[];
+    applicationFormData: { id: string; title: string; value: string }[];

This change would require updates to the data formatting logic elsewhere in the codebase (e.g., formatApplicationFormData utility mentioned in the AI summary).

apps/web/lib/actions/partners/update-group-branding.ts (1)

72-79: Simplify conditional assignments.

The ternary pattern value ? value : undefined can be simplified using nullish coalescing or by relying on the conditional spread pattern.

Apply this diff to simplify:

       data: {
-        applicationFormData: applicationFormDataInput
-          ? applicationFormDataInput
-          : undefined,
+        applicationFormData: applicationFormDataInput ?? undefined,
         applicationFormPublishedAt: applicationFormDataInput
           ? new Date()
           : undefined,
-        landerData: landerDataInput ? landerDataInput : undefined,
+        landerData: landerDataInput ?? undefined,
         landerPublishedAt: landerDataInput ? new Date() : undefined,
       },

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro