fix(analytics): taking orderBy in query now

Author: 0xanshu

src/interface/storage/Storage.ts

@@ -2,6 +2,7 @@ import type { SerializedEvent, EventKind } from "../event/Event";
 import { type UserId } from "../../config/identifiers";
 import type { DateTime } from "luxon";
 import type { AuthContext } from "../../context/auth";
+import type { OrderByRequest } from "../../zod/data";
 
 export type QueryOperator = "EQ" | "GT" | "GTE" | "LT" | "LTE" | "NEQ";
 
@@ -54,6 +55,7 @@ export interface QueryRequest {
   groupBy?: string;
   limit?: number;
   offset?: number;
+  orderBy?: OrderByRequest;
 }
 
 export type QueryResultRow = Record<string, unknown>;

src/storage/adapter/common/clickHouseDialect.ts

@@ -47,7 +47,10 @@ export class ClickHouseQueryDialect implements QueryDialect {
     });
 
     let unionQuery = queries.join(" UNION ALL ");
-    unionQuery += " ORDER BY reportedTimestamp DESC";
+    const orderByField = request.orderBy?.field ?? "reportedTimestamp";
+    const orderByDir = request.orderBy?.descending ? "DESC" : "ASC";
+
+    unionQuery += ` ORDER BY ${orderByField} ${orderByDir}`;
 
     if (request.limit) {
       const limitParam = `p_${paramIndex.value++}`;

src/storage/adapter/common/postgresDialect.ts

@@ -37,10 +37,12 @@ export class PostgresQueryDialect implements QueryDialect {
     });
 
     const unionQuery = sql.join(subqueries, sql` UNION ALL `);
+    const orderByField = request.orderBy?.field ?? "reportedTimestamp";
+    const orderByDir = request.orderBy?.descending ? "DESC" : "ASC";
 
     const finalQuery = sql`
       ${unionQuery}
-      ORDER BY "reportedTimestamp" DESC
+      ORDER BY ${sql.raw(`"${orderByField}" ${orderByDir}`)}
       LIMIT ${request.limit ?? 100}
       OFFSET ${request.offset ?? 0}
     `;

src/storage/adapter/common/queryEventsBase.ts

@@ -6,9 +6,7 @@ import type {
 export type EventTypeLabel = "BASIC_USAGE" | "AI_TOKEN_USAGE" | "PAYMENT";
 
 export type EventTableName =
-  | "basic_usage_events"
-  | "ai_token_usage_events"
-  | "payment_events";
+  "basic_usage_events" | "ai_token_usage_events" | "payment_events";
 
 const EVENT_TYPE_TO_TABLE: Record<EventTypeLabel, EventTableName> = {
   BASIC_USAGE: "basic_usage_events",
@@ -43,50 +41,33 @@ export const OPERATOR_SQL: Record<string, string> = {
   NEQ: "!=",
 };
 
-interface EventTypeFilter {
-  operator: string;
-  value: string;
-}
+function canTableMatch(
+  group: QueryFilterGroup,
+  table: EventTableName
+): boolean {
+  const tableEventType = TABLE_TO_EVENT_TYPE[table];
 
-function collectEventTypeFilters(group: QueryFilterGroup): EventTypeFilter[] {
-  const filters: EventTypeFilter[] = [];
-  for (const c of group.conditions) {
+  const conditionResults = group.conditions.map((c) => {
     if (c.field === "eventType") {
-      filters.push({ operator: c.operator, value: c.value });
+      if (c.operator === "EQ") return c.value === tableEventType;
+      if (c.operator === "NEQ") return c.value !== tableEventType;
+      return true;
     }
-  }
-  for (const sub of group.groups) {
-    filters.push(...collectEventTypeFilters(sub));
-  }
-  return filters;
-}
+    return true;
+  });
 
-export function getTablesForRequest(where: QueryFilterGroup): EventTableName[] {
-  const filters = collectEventTypeFilters(where);
-  if (filters.length === 0) {
-    return [...ALL_TABLES];
-  }
+  const groupResults = group.groups.map((g) => canTableMatch(g, table));
+  const allResults = [...conditionResults, ...groupResults];
 
-  const included = new Set<EventTableName>();
-  const excluded = new Set<EventTableName>();
+  if (allResults.length === 0) return true;
 
-  for (const { operator, value } of filters) {
-    if (!(value in EVENT_TYPE_TO_TABLE)) continue;
-    const table = EVENT_TYPE_TO_TABLE[value as EventTypeLabel];
-    if (operator === "EQ") {
-      included.add(table);
-    } else if (operator === "NEQ") {
-      excluded.add(table);
-    }
-  }
-
-  if (included.size > 0) {
-    return [...included];
-  }
-
-  if (excluded.size > 0) {
-    return ALL_TABLES.filter((t) => !excluded.has(t));
+  if (group.logical === "AND") {
+    return allResults.every((res) => res);
+  } else {
+    return allResults.some((res) => res);
   }
+}
 
-  return [];
+export function getTablesForRequest(where: QueryFilterGroup): EventTableName[] {
+  return ALL_TABLES.filter((table) => canTableMatch(where, table));
 }

src/zod/data.ts

@@ -34,10 +34,11 @@ const filterGroupSchema = createFilterGroupSchema(
   LOGICAL_MAP
 );
 
-const orderBySchema = z.object({
+export const orderBySchema = z.object({
   field: z.string(),
   descending: z.boolean().default(false),
 });
+export type OrderByRequest = z.output<typeof orderBySchema>;
 
 export const dataQuerySchema = z
   .object({