fix: Remove ARRAY JOIN from property queries to fix cost calculation discrepancy (#5519)

The property page queries (totalCost, totalRequests, averageLatency) were using
ARRAY JOIN which required the search_properties filter. This change:

- Adds transformSearchPropertiesToPropertyKey() helper to convert search_properties
  filters to property_key filters
- Removes ARRAY JOIN from all three property queries
- Uses has(mapKeys(properties), 'key') instead of ARRAY JOIN + key column

This aligns the property queries with the dashboard query pattern and eliminates
potential cost calculation discrepancies.

Fixes ENG-3213

Co-authored-by: Justin Torre <justin@Justins-MacBook-Pro.local>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: 3 people

web/lib/api/property/averageLatency.ts

@@ -1,34 +1,41 @@
 import { FilterNode } from "@helicone-package/filters/filterDefs";
 import { timeFilterToFilterNode } from "@helicone-package/filters/helpers";
-import { buildFilterWithAuthClickHousePropertiesV2 } from "@helicone-package/filters/filters";
+import { buildFilterWithAuthClickHouse } from "@helicone-package/filters/filters";
 import { Result, resultMap } from "@/packages/common/result";
 import { dbQueryClickhouse } from "../db/dbExecute";
+import { transformSearchPropertiesToPropertyKey } from "./propertyFilterHelpers";
 
 export async function getAverageLatency(
   filter: FilterNode,
   timeFilter: {
     start: Date;
     end: Date;
   },
-  org_id: string,
+  org_id: string
 ): Promise<Result<number, string>> {
-  const { filter: filterString, argsAcc } =
-    await buildFilterWithAuthClickHousePropertiesV2({
+  // Transform search_properties to property_key to avoid ARRAY JOIN
+  const transformedFilter = transformSearchPropertiesToPropertyKey({
+    left: timeFilterToFilterNode(timeFilter, "request_response_rmt"),
+    right: filter,
+    operator: "and",
+  });
+
+  const { filter: filterString, argsAcc } = await buildFilterWithAuthClickHouse(
+    {
       org_id,
-      filter: {
-        left: timeFilterToFilterNode(timeFilter, "request_response_rmt"),
-        right: filter,
-        operator: "and",
-      },
+      filter: transformedFilter,
       argsAcc: [],
-    });
+    }
+  );
+
+  // Query without ARRAY JOIN - uses property_key filter which generates
+  // has(mapKeys(properties), 'key') instead of requiring ARRAY JOIN
   const query = `
   WITH total_count AS (
-    SELECT 
+    SELECT
       count(*) as count,
       sum(request_response_rmt.latency) as total_latency
     FROM request_response_rmt
-    ARRAY JOIN mapKeys(properties) AS key
     WHERE (
       (${filterString})
     )

web/lib/api/property/propertyFilterHelpers.ts

@@ -0,0 +1,56 @@
+import {
+  FilterBranch,
+  FilterLeaf,
+  FilterNode,
+} from "@helicone-package/filters/filterDefs";
+
+/**
+ * Transforms search_properties filters to property_key filters.
+ * This allows queries to work without ARRAY JOIN.
+ *
+ * search_properties: { "prop_name": { equals: "prop_name" } }
+ * becomes: property_key: { equals: "prop_name" }
+ *
+ * The search_properties filter requires ARRAY JOIN to create a `key` column,
+ * while property_key uses has(mapKeys(properties), 'key') which doesn't need ARRAY JOIN.
+ */
+export function transformSearchPropertiesToPropertyKey(
+  filter: FilterNode
+): FilterNode {
+  if (filter === "all") {
+    return filter;
+  }
+
+  // Check if it's a leaf node with search_properties
+  if ("request_response_rmt" in filter) {
+    const leaf = filter as FilterLeaf;
+    const rmt = leaf.request_response_rmt;
+    if (rmt && "search_properties" in rmt && rmt.search_properties) {
+      // Extract the property key from search_properties
+      const propKey = Object.keys(rmt.search_properties)[0];
+      if (propKey) {
+        // Transform to property_key filter
+        return {
+          request_response_rmt: {
+            property_key: {
+              equals: propKey,
+            },
+          },
+        } as FilterLeaf;
+      }
+    }
+    return filter;
+  }
+
+  // Check if it's a branch node
+  if ("left" in filter && "right" in filter && "operator" in filter) {
+    const branch = filter as FilterBranch;
+    return {
+      left: transformSearchPropertiesToPropertyKey(branch.left),
+      right: transformSearchPropertiesToPropertyKey(branch.right),
+      operator: branch.operator,
+    };
+  }
+
+  return filter;
+}

web/lib/api/property/totalCosts.ts

@@ -1,9 +1,10 @@
 import { FilterNode } from "@helicone-package/filters/filterDefs";
 import { timeFilterToFilterNode } from "@helicone-package/filters/helpers";
-import { buildFilterWithAuthClickHousePropertiesV2 } from "@helicone-package/filters/filters";
+import { buildFilterWithAuthClickHouse } from "@helicone-package/filters/filters";
 import { Result, resultMap } from "@/packages/common/result";
 import { dbQueryClickhouse } from "../db/dbExecute";
 import { COST_PRECISION_MULTIPLIER } from "@helicone-package/cost/costCalc";
+import { transformSearchPropertiesToPropertyKey } from "./propertyFilterHelpers";
 
 export interface TotalCost {
   cost: number;
@@ -12,20 +13,25 @@ export interface TotalCost {
 
 export async function getTotalCostRaw(
   filter: FilterNode,
-  org_id: string,
+  org_id: string
 ): Promise<Result<number, string>> {
-  const { filter: filterString, argsAcc } =
-    await buildFilterWithAuthClickHousePropertiesV2({
+  // Transform search_properties to property_key to avoid ARRAY JOIN
+  const transformedFilter = transformSearchPropertiesToPropertyKey(filter);
+
+  const { filter: filterString, argsAcc } = await buildFilterWithAuthClickHouse(
+    {
       org_id,
-      filter: filter,
+      filter: transformedFilter,
       argsAcc: [],
-    });
+    }
+  );
 
+  // Query without ARRAY JOIN - uses property_key filter which generates
+  // has(mapKeys(properties), 'key') instead of requiring ARRAY JOIN
   const query = `
   WITH total_cost AS (
     SELECT sum(cost) / ${COST_PRECISION_MULTIPLIER} as cost
     FROM request_response_rmt
-    ARRAY JOIN mapKeys(properties) AS key
     WHERE (
       (${filterString})
     )

web/lib/api/property/totalRequests.ts

@@ -1,33 +1,39 @@
 import { FilterNode } from "@helicone-package/filters/filterDefs";
 import { timeFilterToFilterNode } from "@helicone-package/filters/helpers";
-import { buildFilterWithAuthClickHousePropertiesV2 } from "@helicone-package/filters/filters";
+import { buildFilterWithAuthClickHouse } from "@helicone-package/filters/filters";
 import { Result, resultMap } from "@/packages/common/result";
 import { dbQueryClickhouse } from "../db/dbExecute";
+import { transformSearchPropertiesToPropertyKey } from "./propertyFilterHelpers";
 
 export async function getTotalRequests(
   filter: FilterNode,
   timeFilter: {
     start: Date;
     end: Date;
   },
-  org_id: string,
+  org_id: string
 ): Promise<Result<number, string>> {
-  const { filter: filterString, argsAcc } =
-    await buildFilterWithAuthClickHousePropertiesV2({
+  // Transform search_properties to property_key to avoid ARRAY JOIN
+  const transformedFilter = transformSearchPropertiesToPropertyKey({
+    left: timeFilterToFilterNode(timeFilter, "request_response_rmt"),
+    right: filter,
+    operator: "and",
+  });
+
+  const { filter: filterString, argsAcc } = await buildFilterWithAuthClickHouse(
+    {
       org_id,
-      filter: {
-        left: timeFilterToFilterNode(timeFilter, "request_response_rmt"),
-        right: filter,
-        operator: "and",
-      },
+      filter: transformedFilter,
       argsAcc: [],
-    });
-  const query = `
+    }
+  );
 
+  // Query without ARRAY JOIN - uses property_key filter which generates
+  // has(mapKeys(properties), 'key') instead of requiring ARRAY JOIN
+  const query = `
   WITH total_count AS (
     SELECT count(*) as count
     FROM request_response_rmt
-    ARRAY JOIN mapKeys(properties) AS key
     WHERE (
       (${filterString})
     )