diff --git a/apps/web/app/(ee)/api/cron/domains/delete/route.ts b/apps/web/app/(ee)/api/cron/domains/delete/route.ts
index adfc1a89a..5edcb761c 100644
--- a/apps/web/app/(ee)/api/cron/domains/delete/route.ts
+++ b/apps/web/app/(ee)/api/cron/domains/delete/route.ts
@@ -43,6 +43,11 @@ export async function POST(req: Request) {
             tag: true,
           },
         },
+        programEnrollment: {
+          select: {
+            groupId: true,
+          },
+        },
       },
       take: 100,
       orderBy: {
@@ -61,7 +66,12 @@ export async function POST(req: Request) {
       linkCache.deleteMany(links),
 
       // Record link in Tinybird
-      recordLink(links),
+      recordLink(
+        links.map((link) => ({
+          ...link,
+          partnerGroupId: link.programEnrollment?.groupId || null,
+        }))
+      ),
 
       // Remove image from R2 storage if it exists
       links

Analysis

Domain Delete CRON Job Missing Partner Group Data

Issue Description

The domain delete CRON job at apps/web/app/(ee)/api/cron/domains/delete/route.ts was recording link deletions to Tinybird without including partner group information, causing incomplete analytics data for partner links.

Root Cause Analysis

The Problem

The Prisma query that fetches links for deletion (lines 35-50) only included tags relation but missing the programEnrollment relation:

const links = await prisma.link.findMany({
  where: { domain },
  include: {
    tags: {
      select: { tag: true },
    },
    // Missing programEnrollment relation
  },
});

Expected Data Structure

The recordLink function expects an ExpandedLink type that includes partnerGroupId?: string | null. This field is populated from the programEnrollment.groupId value, but the query wasn't fetching this relationship.

The Tinybird analytics schema includes partner_group_id as a tracked field, which gets populated by the transformLinkTB function:

export const transformLinkTB = (link: ExpandedLink) => {
  return {
    // ... other fields
    partner_group_id: link.partnerGroupId ?? "",
    // ... other fields
  };
};

Data Model Relationships

From the Prisma schema:

• Link model has a compound relation to ProgramEnrollment: programEnrollment ProgramEnrollment? @relation(fields: [programId, partnerId], references: [programId, partnerId])
• ProgramEnrollment model has groupId field that references PartnerGroup
• PartnerGroup contains partner segmentation data crucial for analytics

Impact

Data Inconsistency: Partner links being deleted were recorded to Tinybird with empty partner_group_id values, making it impossible to:

• Track partner performance by group
• Generate accurate partner analytics reports
• Analyze conversion rates by partner segments
• Maintain data integrity in the analytics pipeline

Solution

The fix includes two changes to apps/web/app/(ee)/api/cron/domains/delete/route.ts:

1. Enhanced Query: Added programEnrollment relation with groupId selection:

include: {
  tags: {
    select: { tag: true },
  },
  programEnrollment: {
    select: { groupId: true },
  },
},

2. Data Mapping: Updated the recordLink call to properly map partnerGroupId:

recordLink(
  links.map((link) => ({
    ...link,
    partnerGroupId: link.programEnrollment?.groupId || null,
  }))
),

This ensures that when partner links are deleted, their group membership is correctly recorded in Tinybird analytics, maintaining data consistency across the partner program analytics pipeline.

diff --git a/apps/web/app/(ee)/api/cron/domains/transfer/route.ts b/apps/web/app/(ee)/api/cron/domains/transfer/route.ts
index e9586783e..076f332ef 100644
--- a/apps/web/app/(ee)/api/cron/domains/transfer/route.ts
+++ b/apps/web/app/(ee)/api/cron/domains/transfer/route.ts
@@ -29,6 +29,13 @@ export async function POST(req: Request) {
     const links = await prisma.link.findMany({
       where: { domain, projectId: currentWorkspaceId },
       take: 100,
+      include: {
+        programEnrollment: {
+          select: {
+            groupId: true,
+          },
+        },
+      },
       orderBy: {
         createdAt: "desc",
       },
@@ -85,6 +92,7 @@ export async function POST(req: Request) {
             ...link,
             projectId: newWorkspaceId,
             folderId: null,
+            partnerGroupId: link.programEnrollment?.groupId,
           })),
         ),
       ]);

Analysis

Domain Transfer CRON Job Missing Partner Group Data

Bug Description

The domain transfer CRON job in apps/web/app/(ee)/api/cron/domains/transfer/route.ts was not fetching partner group data when recording link metadata to Tinybird. This resulted in null or missing partnerGroupId values for partner links in analytics data.

Technical Analysis

Root Cause

The initial Prisma query (lines 29-35) fetched link records without including the programEnrollment relationship:

const links = await prisma.link.findMany({
  where: { domain, projectId: currentWorkspaceId },
  take: 100,
  orderBy: {
    createdAt: "desc",
  },
});

When recordLink() was called (lines 83-89), the links being passed didn't have access to the partner group information:

recordLink(
  links.map((link) => ({
    ...link,
    projectId: newWorkspaceId,
    folderId: null,
    // Missing: partnerGroupId field
  })),
)

Evidence from Codebase

The correct pattern is demonstrated in apps/web/scripts/migrations/backfill-partner-group-tb.ts, which:

1. Includes programEnrollment data in the Prisma query:

include: {
  programEnrollment: {
    select: {
      groupId: true,
    },
  },
}

2. Maps the partner group ID when calling recordLink():

recordLink(
  links.map((link) => ({
    ...link,
    partnerGroupId: link.programEnrollment?.groupId,
  })),
)

Impact

Data Consistency: Partner links transferred between domains would have missing partnerGroupId values in Tinybird analytics, causing:

• Incomplete partner attribution data
• Inaccurate partner performance metrics
• Potential issues with partner commission calculations

Analytics Integrity: The missing partner group associations would create gaps in analytics queries that depend on partner group segmentation.

Solution

The fix adds the missing programEnrollment include to the initial query and maps the partnerGroupId field when calling recordLink():

1. Enhanced Query: Include programEnrollment relationship to access groupId
2. Proper Mapping: Extract partnerGroupId from link.programEnrollment?.groupId when recording to Tinybird

This ensures partner links maintain their group associations during domain transfers, preserving analytics data integrity.

Files Modified

• apps/web/app/(ee)/api/cron/domains/transfer/route.ts: Added programEnrollment include and partnerGroupId mapping

diff --git a/apps/web/app/(ee)/api/cron/domains/update/route.ts b/apps/web/app/(ee)/api/cron/domains/update/route.ts
index 61707c974..1311f02a0 100644
--- a/apps/web/app/(ee)/api/cron/domains/update/route.ts
+++ b/apps/web/app/(ee)/api/cron/domains/update/route.ts
@@ -72,6 +72,11 @@ export async function POST(req: Request) {
             tag: true,
           },
         },
+        programEnrollment: {
+          select: {
+            groupId: true,
+          },
+        },
       },
     });
 
@@ -79,7 +84,12 @@ export async function POST(req: Request) {
       // update the `shortLink` field for each of the short links
       updateShortLinks(updatedLinks),
       // record new link values in Tinybird (dub_links_metadata)
-      recordLink(updatedLinks),
+      recordLink(
+        updatedLinks.map((link) => ({
+          ...link,
+          partnerGroupId: link.programEnrollment?.groupId,
+        }))
+      ),
       // expire the redis cache for the old links
       linkCache.expireMany(linksToUpdate),
     ]);

Analysis

Domain Update CRON Job Missing Partner Group Data Bug

Summary

The domain update CRON job (apps/web/app/(ee)/api/cron/domains/update/route.ts) was recording links to Tinybird without fetching partner group data, causing missing partnerGroupId values for partner links and creating data inconsistency in analytics.

Technical Analysis

The Problem

The domain update CRON job performs three key operations when updating links from an old domain to a new domain:

1. Updates the domain in the database
2. Updates short link URLs
3. Records updated links to Tinybird for analytics

However, the query to fetch updated links (lines 62-80) only included basic link data and tags:

const updatedLinks = await prisma.link.findMany({
  where: { id: { in: linkIdsToUpdate } },
  include: {
    tags: { select: { tag: true } }
  }
});

This query was missing the programEnrollment relation needed to access partner group data.

Data Flow Impact

When recordLink(updatedLinks) was called (line 82), partner links were missing their partnerGroupId values because:

1. The query didn't include programEnrollment.groupId
2. Links were passed directly to recordLink() without mapping the partner group data
3. The Tinybird schema transforms missing partnerGroupId to empty string ""

Pattern Analysis Evidence

Multiple other operations in the codebase correctly handle partner group data:

• create-link.ts: Uses getPartnerAndDiscount() and passes partnerGroupId: partner?.groupId
• update-link.ts: Uses getPartnerAndDiscount() and passes partnerGroupId: partner?.groupId
• propagate-partner-link-updates/route.ts: Manually adds partnerGroupId: group.id
• backfill-partner-group-tb.ts: Includes programEnrollment in query and maps partnerGroupId

The Fix

Updated the domain update CRON job to:

1. Include partner enrollment data in query:

   include: {
     tags: { select: { tag: true } },
     programEnrollment: { select: { groupId: true } }
   }

2. Map partner group data when recording to Tinybird:

   recordLink(
     updatedLinks.map((link) => ({
       ...link,
       partnerGroupId: link.programEnrollment?.groupId,
     }))
   )

Impact and Consequences

Before Fix

• Partner links updated during domain migrations had missing partnerGroupId in Tinybird
• Analytics queries grouping by partner groups would exclude these links
• Partner attribution and commission tracking could be inaccurate
• Data inconsistency between different link operations

After Fix

• All partner links maintain proper group attribution during domain updates
• Consistent partner analytics across all link operations
• Accurate partner commission and attribution tracking
• Data integrity maintained in Tinybird analytics

Related Components

• Tinybird Schema: dub_links_metadata datasource with partner_group_id field
• Link Analytics: Partner group attribution and reporting
• Partner Commissions: Group-based reward calculations
• Domain Migration: Bulk link updates preserving partner data

This fix ensures data consistency and prevents analytics gaps during domain migration operations.

apps/web/lib/api/links/propagate-bulk-link-changes.ts (1)

18-38: Bug: Assumes single programId; breaks partnerGroupId mapping for mixed-program batches.

Needs composite (programId, partnerId) mapping to fetch correct enrollments.

-  if (partnerLinks.length > 0) {
-    const programId = partnerLinks[0].programId!;
-    const uniquePartnerIds = [
-      ...new Set(partnerLinks.map((link) => link.partnerId) as string[]),
-    ];
-
-    const enrollments = await prisma.programEnrollment.findMany({
-      where: {
-        partnerId: {
-          in: uniquePartnerIds,
-        },
-        programId,
-      },
-      select: {
-        partnerId: true,
-        groupId: true,
-      },
-    });
-
-    partnerGroupMap = new Map(
-      enrollments.map(({ partnerId, groupId }) => [partnerId, groupId]),
-    );
-  }
+  if (partnerLinks.length > 0) {
+    // Unique (programId, partnerId) pairs
+    const pairs = [
+      ...new Map(
+        partnerLinks.map((l) => [
+          `${l.programId}:${l.partnerId}`,
+          { programId: l.programId!, partnerId: l.partnerId! },
+        ]),
+      ).values(),
+    ];
+
+    const enrollments = await prisma.programEnrollment.findMany({
+      where: {
+        OR: pairs.map(({ programId, partnerId }) => ({ programId, partnerId })),
+      },
+      select: {
+        programId: true,
+        partnerId: true,
+        groupId: true,
+      },
+    });
+
+    partnerGroupMap = new Map(
+      enrollments.map(({ programId, partnerId, groupId }) => [
+        `${programId}:${partnerId}`,
+        groupId,
+      ]),
+    );
+  }

packages/tinybird/pipes/v2_top_tags.pipe (1)

269-281: Normalize UTM encoding for consistency and correctness

Other pipes URL-encode UTM values. Do the same here to avoid mismatches on special characters.

-            AND url LIKE concat('%utm_source=', {{ String(utm_source) }}, '%')
+            AND url LIKE concat('%utm_source=', encodeURLFormComponent({{ String(utm_source) }}), '%')
-            AND url LIKE concat('%utm_medium=', {{ String(utm_medium) }}, '%')
+            AND url LIKE concat('%utm_medium=', encodeURLFormComponent({{ String(utm_medium) }}), '%')
-            AND url LIKE concat('%utm_campaign=', {{ String(utm_campaign) }}, '%')
+            AND url LIKE concat('%utm_campaign=', encodeURLFormComponent({{ String(utm_campaign) }}), '%')
-            AND url LIKE concat('%utm_term=', {{ String(utm_term) }}, '%')
+            AND url LIKE concat('%utm_term=', encodeURLFormComponent({{ String(utm_term) }}), '%')
-            AND url LIKE concat('%utm_content=', {{ String(utm_content) }}, '%')
+            AND url LIKE concat('%utm_content=', encodeURLFormComponent({{ String(utm_content) }}), '%')

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

61-65: Route rename to propagate-partner-link-updates — OK; guard null groupId

URL change looks correct. Consider skipping the QStash call if partnerGroup?.id is falsy.

-            ? qstash.publishJSON({
+            ? (partnerGroup?.id
+                ? qstash.publishJSON({
                   url: `${APP_DOMAIN_WITH_NGROK}/api/cron/links/propagate-partner-link-updates`,
                   body: {
                     groupId: partnerGroup?.id,
                   },
-              })
+                })
+                : Promise.resolve())
             : Promise.resolve(),

Confirm the cron route treats groupId as required to avoid no-op fanouts.

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/groups/groups-table.tsx (1)

272-281: Add “View analytics” menu item — nice UX win

Optional: preserve current analytics filters (date range, interval) by forwarding existing query params when pushing.

-                  router.push(
-                    `/${slug}/program/analytics?groupId=${row.original.id}`,
-                  )
+                  router.push(`/${slug}/program/analytics?groupId=${row.original.id}`)

If you want to retain filters, consider building from useRouterStuff().getQueryString() and merging groupId.

packages/tinybird/pipes/v2_referer_urls.pipe (1)

2-2: Fix description to reflect content

Consider “Top referer URLs” instead of “Top countries”.

packages/tinybird/pipes/v2_browsers.pipe (1)

2-2: Tweak description

Use “Top browsers”.

packages/tinybird/pipes/v2_devices.pipe (1)

2-2: Tweak description

Use “Top devices”.

packages/tinybird/pipes/v2_referers.pipe (1)

2-2: Tweak description

Use “Top referrers”.

packages/tinybird/pipes/v2_triggers.pipe (2)

1-2: Description mismatch (“Top countries”).

Rename to “Triggers” to reflect the endpoint.

-DESCRIPTION >
-	Top countries
+DESCRIPTION >
+	Triggers

---

169-170: Minor: standardize DateTime vs DateTime64.

Other pipes use DateTime64 for event timestamps; consider aligning for consistency/perf.

Also applies to: 227-228

packages/tinybird/pipes/v2_continents.pipe (1)

141-142: Minor: unify timestamp casting.

Mix of DateTime and DateTime64 across nodes; consider standardizing (prefer DateTime64).

Also applies to: 193-194, 242-243, 95-96

packages/tinybird/pipes/v2_count.pipe (2)

1-2: Description mismatch (“Top countries”).

Rename to “Counts” to reflect output.

-DESCRIPTION >
-	Top countries
+DESCRIPTION >
+	Counts

---

86-87: Minor: standardize DateTime vs DateTime64.

Consider using DateTime64 consistently across endpoints.

Also applies to: 121-122, 177-178, 233-234

apps/web/app/(ee)/api/cron/folders/delete/route.ts (1)

55-60: Ensure recordLink tolerates undefined partnerGroupId.

recordLink should map undefined to null for partner_group_id; otherwise coerce explicitly.

-        partnerGroupId: link.programEnrollment?.groupId,
+        partnerGroupId: link.programEnrollment?.groupId ?? null,

apps/web/lib/planetscale/get-partner-discount.ts (1)

32-46: Optional: alias Discount fields to avoid future name collisions.

Aliasing (e.g., Discount.type AS discountType) can prevent clashes if more tables/fields are added.

apps/web/lib/api/links/complete-ab-tests.ts (1)

83-86: Avoid passing programEnrollment to recordLink payload (potential excess property/type mismatch).

Prefer stripping programEnrollment before forwarding to Tinybird.

Apply:

-      recordLink({
-        ...response,
-        partnerGroupId: response.programEnrollment?.groupId,
-      }),
+      // Keep TB payload lean and TS-safe
+      (() => {
+        const { programEnrollment, ...rest } = response as any;
+        return recordLink({
+          ...rest,
+          partnerGroupId: programEnrollment?.groupId ?? null,
+        });
+      })(),

apps/web/lib/partners/approve-partner-enrollment.ts (1)

175-181: Always record the enrolled link with partnerGroupId (handles both updated and newly created link).

Unify the call so we also record when partnerLink is created via createPartnerLink.

Apply:

-        updatedLink
-          ? recordLink({
-              ...updatedLink,
-              partnerGroupId: group.id,
-            })
-          : Promise.resolve(null),
+        recordLink({
+          ...(updatedLink ?? partnerLink),
+          partnerGroupId: group.id,
+        }),

apps/web/app/(ee)/api/cron/merge-partner-accounts/route.ts (1)

174-190: Propagating partnerGroupId to TB after merge is correct; consider chunked ingestion.

Including programEnrollment.groupId and mapping partnerGroupId is spot on. If updatedLinks can be large, chunk the TB ingest to avoid 413s/timeouts.

Apply:

-        recordLink(
-          updatedLinks.map((link) => ({
-            ...link,
-            partnerGroupId: link.programEnrollment?.groupId,
-          })),
-        ),
+        (async () => {
+          const payload = updatedLinks.map((link) => ({
+            ...link,
+            partnerGroupId: link.programEnrollment?.groupId,
+          }));
+          const CHUNK = 500;
+          for (let i = 0; i < payload.length; i += CHUNK) {
+            await recordLink(payload.slice(i, i + CHUNK));
+          }
+        })(),

Also applies to: 193-200

apps/web/app/api/tags/[id]/route.ts (1)

101-105: Normalize undefined to null for consistency with TB schemas.

Avoid sending undefined (which may be omitted during serialization). Prefer explicit null.

Apply:

-            partnerGroupId: link.programEnrollment?.groupId,
+            partnerGroupId: link.programEnrollment?.groupId ?? null,

apps/web/lib/api/links/create-link.ts (2)

139-145: Don’t let partner lookup failure block all post-create tasks.

If getPartnerAndDiscount throws (DB/network), none of the subsequent tasks run. Catch and default to null so caching, Tinybird, image, qstash, usage updates, etc., still proceed.

Apply:

-    (async () => {
-      const { partner, discount } = await getPartnerAndDiscount({
-        programId: response.programId,
-        partnerId: response.partnerId,
-      });
+    (async () => {
+      let partner: Awaited<ReturnType<typeof getPartnerAndDiscount>>["partner"] | null = null;
+      let discount: Awaited<ReturnType<typeof getPartnerAndDiscount>>["discount"] | null = null;
+      try {
+        ({ partner, discount } = await getPartnerAndDiscount({
+          programId: response.programId,
+          partnerId: response.partnerId,
+        }));
+      } catch {
+        // swallow; proceed without partner/discount
+      }

---

154-157: Send explicit null for partnerGroupId.

Tinybird/transformers typically expect nullables; avoid undefined.

Apply:

-        recordLink({
-          ...response,
-          partnerGroupId: partner?.groupId,
-        }),
+        recordLink({
+          ...response,
+          partnerGroupId: partner?.groupId ?? null,
+        }),

apps/web/scripts/migrations/backfill-partner-group-tb.ts (1)

51-56: Normalize partnerGroupId to null.

Guarantee a concrete nullable for ingestion.

Apply:

-      links.map((link) => ({
-        ...link,
-        partnerGroupId: link.programEnrollment?.groupId,
-      })),
+      links.map((link) => ({
+        ...link,
+        partnerGroupId: link.programEnrollment?.groupId ?? null,
+      })),

apps/web/app/(ee)/api/cron/links/propagate-partner-link-updates/route.ts (2)

37-40: Return 204 No Content for missing group to avoid retries.

Explicit 204 makes intent clearer for job runners while keeping idempotency.

-  console.error(`Group ${groupId} not found.`);
-  return new Response("OK");
+  console.error(`Group ${groupId} not found.`);
+  return new Response(null, { status: 204 });

---

78-91: Surface failures from Promise.allSettled to avoid silent data loss.

Currently failures are swallowed; log and keep going per chunk.

-      await Promise.allSettled([
+      const results = await Promise.allSettled([
         // Expire the cache for the links
         linkCache.expireMany(
           linkChunk.map(({ domain, key }) => ({ domain, key })),
         ),

         // Record the updated links in Tinybird
         recordLink(
           linkChunk.map((link) => ({
             ...link,
             partnerGroupId: group.id,
           })),
         ),
       ]);
+      for (const r of results) {
+        if (r.status === "rejected") {
+          console.error("propagate-partner-link-updates error:", r.reason);
+        }
+      }

apps/web/lib/api/links/propagate-bulk-link-changes.ts (2)

47-53: Coalesce undefined to null for Tinybird schema consistency.

Map.get can return undefined. Coalesce to null to match nullable TB column.

-        partnerGroupId: link.partnerId
-          ? partnerGroupMap.get(link.partnerId)
-          : null,
+        partnerGroupId:
+          link.partnerId && link.programId
+            ? partnerGroupMap.get(`${link.programId}:${link.partnerId}`) ?? null
+            : null,

---

41-54: Optional: Avoid non-Promise values in Promise.all.

Minor readability: filter out falsy entry when skipRedisCache is true.

-return await Promise.all([
-  // update Redis cache
-  !skipRedisCache && linkCache.mset(links),
-  // update Tinybird
-  recordLink(/* ... */),
-]);
+const tasks: Promise<unknown>[] = [];
+if (!skipRedisCache) tasks.push(linkCache.mset(links));
+tasks.push(
+  recordLink(
+    links.map((link) => ({
+      ...link,
+      partnerGroupId:
+        link.partnerId && link.programId
+          ? partnerGroupMap.get(`${link.programId}:${link.partnerId}`) ?? null
+          : null,
+    })),
+  ),
+);
+return await Promise.all(tasks);

apps/web/ui/analytics/use-analytics-filters.tsx (1)

523-537: Use JSX for the group icon for consistency and clearer TSX semantics.

Calling the component as a function works but is atypical.

-                options: loadingGroups
-                  ? null
-                  : groups?.map((group) => ({
+                options: loadingGroups
+                  ? null
+                  : groups?.map((group) => ({
                     value: group.id,
                     label: group.name,
-                    icon: GroupColorCircle({ group }),
-                    right: nFormatter(group.partners, {
+                    icon: <GroupColorCircle group={group} />,
+                    right: nFormatter(
+                      // tolerate differing shapes across queries
+                      (typeof group.partners === "number"
+                        ? group.partners
+                        : (group as any).partnerCount ??
+                          (group as any)._count?.partners ??
+                          0) as number,
+                      {
                         full: true,
-                      }),
+                      },
+                    ),
                   })) ?? null,

apps/web/lib/api/links/update-link.ts (2)

177-217: Filter out non-promises in Promise.allSettled.

Several array entries can be boolean. Filtering improves clarity and avoids no-op settled values.

-      await Promise.allSettled([
+      await Promise.allSettled(
+        [
           // cache link in Redis
           linkCache.set({
             ...response,
             ...(partner && { partner }),
             ...(discount && { discount }),
           }),
@@
           testVariants &&
           testCompletedAt &&
           scheduleABTestCompletion(response),
-      ]);
+        ].filter(Boolean) as Promise<unknown>[]
+      );

---

203-207: Make R2 deletion robust to trailing slashes by parsing URL.

String replace can break if R2_URL has a trailing slash or differs by scheme/host casing. Extract the path instead.

-          storage.delete(oldLink.image.replace(`${R2_URL}/`, "")),
+          storage.delete(new URL(oldLink.image).pathname.slice(1)),

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: devkiran
PR: dubinc/dub#2177
File: apps/web/lib/api/links/bulk-create-links.ts:66-84
Timestamp: 2025-06-06T07:59:03.120Z
Learning: In apps/web/lib/api/links/bulk-create-links.ts, the team accepts the risk of potential undefined results from links.find() operations when building invalidLinks arrays, because existing links are fetched from the database based on the input links, so matches are expected to always exist.

packages/tinybird/pipes/v2_devices.pipe (1)

21-21: Devices pipeline: groupId support — LGTM

Addresses the earlier gating gap; PREWHERE now includes groupId across all nodes.

Also applies to: 52-54, 100-102, 143-145, 184-185

packages/tinybird/pipes/v2_regions.pipe (1)

21-21: Cast groupId to String for consistency with ID columns.

Mirror the casting used elsewhere (e.g., linkId/customerId) to avoid quoting issues.

-        {% if defined(groupId) %} AND partner_group_id = {{ groupId }} {% end %}
+        {% if defined(groupId) %} AND partner_group_id = {{ String(groupId) }} {% end %}

packages/tinybird/pipes/v2_utms.pipe (1)

15-15: Cast groupId to String to match column type and escape correctly.

-        {% if defined(groupId) %} AND partner_group_id = {{ groupId }} {% end %}
+        {% if defined(groupId) %} AND partner_group_id = {{ String(groupId) }} {% end %}

packages/tinybird/pipes/v2_timeseries.pipe (1)

134-137: PREWHERE gate now considers groupId — resolved

This addresses the earlier gating gap for clicks when only groupId is provided.

packages/tinybird/pipes/v2_referers.pipe (1)

51-54: Clicks PREWHERE gate includes groupId — LGTM

This resolves the previously flagged issue for referers_clicks.

packages/tinybird/pipes/v2_top_tags.pipe (1)

39-41: Include groupId in PREWHERE gates for performance parity

Without adding groupId, queries scoped only by groupId won’t prefilter events and may scan far more rows than needed.

Apply in each block:

-{% if defined(workspaceId) or defined(partnerId) or defined(programId) %}
+{% if defined(workspaceId) or defined(partnerId) or defined(programId) or defined(groupId) %}
     PREWHERE link_id in (SELECT link_id from workspace_links_with_tags)
 {% end %}

Also applies to: 99-101, 163-165

packages/tinybird/pipes/v2_count.pipe (2)

51-54: Adding groupId to PREWHERE gating: LGTM; optional: combine with customerId when both are provided.

Current elif skips workspace_links gating when customerId is also set. You can conjunct both predicates to narrow scans further.

Suggested refactor:

-        {% if defined(customerId) %}
-            PREWHERE click_id IN (
+        {% if defined(customerId) %}
+            PREWHERE click_id IN (
                 SELECT DISTINCT click_id
                 FROM dub_lead_events_mv
                 WHERE customer_id = {{ String(customerId) }}
-            )
+            ){% if not defined(linkId) and (defined(workspaceId) or defined(partnerId) or defined(programId) or defined(groupId)) %} 
+            AND link_id in (SELECT link_id from workspace_links){% endif %}
-        {% elif not defined(linkId) and (
+        {% elif not defined(linkId) and (
             defined(workspaceId) or defined(partnerId) or defined(programId) or defined(groupId)
         ) %} PREWHERE link_id in (SELECT link_id from workspace_links)

---

21-21: Cast groupId to String (partner_group_id is String).

• partner_group_id is declared as String in:
  packages/tinybird/datasources/dub_links_metadata.datasource
  packages/tinybird/datasources/dub_links_metadata_latest.datasource
  packages/tinybird/datasources/dub_regular_links_metadata_latest.datasource
• Apply diff:

-        {% if defined(groupId) %} AND partner_group_id = {{ groupId }} {% end %}
+        {% if defined(groupId) %} AND partner_group_id = {{ String(groupId) }} {% end %}

• No ORDER BY / PRIMARY KEY matches found in those datasource files; consider adding an ORDER BY/PRIMARY KEY that includes partner_group_id to improve filtering performance.

packages/tinybird/pipes/v2_utms.pipe (1)

60-62: Group PREWHERE gating in utms_clicks: LGTM; optional: also conjunct when customerId is set.

Same optional combination as count_clicks to reduce scanned rows when both scopes apply.

packages/tinybird/pipes/v2_timeseries.pipe (2)

128-137: Clicks with customerId bypasses group scoping — confirm intent

When customerId is defined, the query uses click_id IN (leads...) and skips link_id prefiltering, so groupId/workspaceId/partnerId/programId are ignored. If you want customerId + groupId to intersect, add the workspace_links constraint inside the subquery.

Proposed patch:

-        {% if defined(customerId) %}
-            PREWHERE click_id IN (
-                SELECT DISTINCT click_id
-                FROM dub_lead_events_mv
-                WHERE customer_id = {{ String(customerId) }}
-            )
+        {% if defined(customerId) %}
+            PREWHERE click_id IN (
+                SELECT DISTINCT click_id
+                FROM dub_lead_events_mv
+                WHERE customer_id = {{ String(customerId) }}
+                {% if defined(groupId) or defined(workspaceId) or defined(partnerId) or defined(programId) %}
+                    AND link_id in (SELECT link_id from workspace_links)
+                {% end %}
+            )

---

254-256: Nit: missing description

Node description shows “undefined”. Optional: add a brief description for sales node for clarity in TB UI.

packages/tinybird/pipes/v2_referers.pipe (1)

45-54: Clicks with customerId bypasses group scoping — mirror fix here if desired

Same behavior as timeseries: customerId path ignores groupId/workspaceId/partnerId/programId. If intersection is desired, replicate the subquery filter.

Proposed patch:

-        {% if defined(customerId) %}
-            PREWHERE click_id IN (
-                SELECT DISTINCT click_id
-                FROM dub_lead_events_mv
-                WHERE customer_id = {{ String(customerId) }}
-            )
+        {% if defined(customerId) %}
+            PREWHERE click_id IN (
+                SELECT DISTINCT click_id
+                FROM dub_lead_events_mv
+                WHERE customer_id = {{ String(customerId) }}
+                {% if defined(groupId) or defined(workspaceId) or defined(partnerId) or defined(programId) %}
+                    AND link_id in (SELECT link_id from workspace_links)
+                {% end %}
+            )

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro