@datarecce/ui 0.1.30 → 0.1.31

package/recce-source/js/src/lib/dataGrid/dataGridFactory.ts

@@ -0,0 +1,397 @@
+/**
+ * @file dataGridFactory.ts
+ * @description Abstract factory for creating data grid configurations
+ *
+ * This file provides a unified interface for generating grid data
+ * for different run types (query, query_diff, value_diff, value_diff_detail, profile, profile_diff)
+ *
+ * It wraps the existing implementations:
+ * - toDataGrid for single DataFrame display
+ * - toDataDiffGrid for comparing two DataFrames
+ * - toValueDiffGrid for joined diff data (with in_a/in_b columns)
+ * - toValueDataGrid for value_diff summary (column match statistics)
+ */
+
+import type { ColDef, ColGroupDef } from "ag-grid-community";
+import { QueryDiffResult } from "@/lib/api/adhocQuery";
+import { NodeData } from "@/lib/api/info";
+import { ProfileDiffResult } from "@/lib/api/profile";
+import { RowCountDiffResult, RowCountResult } from "@/lib/api/rowcount";
+import {
+  ColumnRenderMode,
+  ColumnType,
+  DataFrame,
+  isProfileDiffRun,
+  isProfileRun,
+  isQueryBaseRun,
+  isQueryDiffRun,
+  isQueryRun,
+  isRowCountDiffRun,
+  isRowCountRun,
+  isValueDiffDetailRun,
+  isValueDiffRun,
+  RowObjectType,
+  Run,
+} from "@/lib/api/types";
+import { ValueDiffParams, ValueDiffResult } from "@/lib/api/valuediff";
+// Import existing implementations
+import { toDataDiffGrid } from "@/lib/dataGrid/generators/toDataDiffGrid";
+import { toDataGrid } from "@/lib/dataGrid/generators/toDataGrid";
+import { toRowCountDataGrid } from "@/lib/dataGrid/generators/toRowCountDataGrid";
+import { toRowCountDiffDataGrid } from "@/lib/dataGrid/generators/toRowCountDiffDataGrid";
+import {
+  mergeColumns,
+  type SchemaDataGridOptions,
+  type SchemaDataGridResult,
+  type SingleEnvSchemaDataGridResult,
+  toSchemaDataGrid,
+  toSingleEnvDataGrid,
+} from "@/lib/dataGrid/generators/toSchemaDataGrid";
+import { toValueDataGrid } from "@/lib/dataGrid/generators/toValueDataGrid";
+import { toValueDiffGrid } from "@/lib/dataGrid/generators/toValueDiffGrid";
+
+// ============================================================================
+// Types & Interfaces
+// ============================================================================
+
+/**
+ * Common options shared across all grid types
+ */
+export interface BaseGridOptions {
+  primaryKeys?: string[];
+  pinnedColumns?: string[];
+  columnsRenderMode?: Record<string, ColumnRenderMode>;
+  onPrimaryKeyChange?: (primaryKeys: string[]) => void;
+  onPinnedColumnsChange?: (pinnedColumns: string[]) => void;
+  onColumnsRenderModeChanged?: (cols: Record<string, ColumnRenderMode>) => void;
+}
+
+/**
+ * Additional options for diff grids
+ */
+export interface DiffGridOptions extends BaseGridOptions {
+  changedOnly?: boolean;
+  displayMode?: "inline" | "side_by_side";
+  baseTitle?: string;
+  currentTitle?: string;
+}
+
+/**
+ * Standard output structure for all grid generation functions
+ */
+export interface DataGridResult {
+  columns: ((ColDef<RowObjectType> | ColGroupDef<RowObjectType>) & {
+    columnType?: ColumnType;
+    columnRenderMode?: ColumnRenderMode;
+  })[];
+  rows: RowObjectType[];
+  invalidPKeyBase?: boolean;
+  invalidPKeyCurrent?: boolean;
+}
+
+/**
+ * Discriminated union for run result data
+ */
+type RunResultData =
+  | { kind: "query"; result: DataFrame }
+  | { kind: "query_diff_separate"; result: QueryDiffResult }
+  | {
+      kind: "query_diff_joined";
+      result: QueryDiffResult;
+      primaryKeys: string[];
+    }
+  | { kind: "value_diff"; result: ValueDiffResult; params: ValueDiffParams }
+  | { kind: "value_diff_detail"; result: DataFrame; primaryKeys: string[] }
+  | { kind: "profile"; result: ProfileDiffResult }
+  | { kind: "profile_diff"; result: ProfileDiffResult }
+  // NEW: Add row count types
+  | { kind: "row_count"; result: RowCountResult }
+  | { kind: "row_count_diff"; result: RowCountDiffResult };
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Determines the appropriate grid generation strategy based on run type and data
+ */
+function determineDataKind(run: Run): RunResultData | null {
+  if (isQueryRun(run) || isQueryBaseRun(run)) {
+    if (!run.result) return null;
+    return { kind: "query", result: run.result };
+  }
+
+  if (isQueryDiffRun(run)) {
+    if (!run.result) return null;
+    // If the result has a `diff` field, it's pre-joined data
+    if (run.result.diff && run.params?.primary_keys) {
+      return {
+        kind: "query_diff_joined",
+        result: run.result,
+        primaryKeys: run.params.primary_keys,
+      };
+    }
+    // Otherwise, it's separate base/current DataFrames
+    return { kind: "query_diff_separate", result: run.result };
+  }
+
+  if (isValueDiffRun(run)) {
+    if (!run.result || !run.params) return null;
+    return {
+      kind: "value_diff",
+      result: run.result,
+      params: run.params,
+    };
+  }
+
+  if (isValueDiffDetailRun(run)) {
+    if (!run.result || !run.params?.primary_key) return null;
+    const primaryKey = run.params.primary_key;
+    const primaryKeys = Array.isArray(primaryKey) ? primaryKey : [primaryKey];
+    return {
+      kind: "value_diff_detail",
+      result: run.result,
+      primaryKeys,
+    };
+  }
+
+  if (isProfileRun(run)) {
+    if (!run.result?.current) return null;
+    return { kind: "profile", result: run.result };
+  }
+
+  if (isProfileDiffRun(run)) {
+    if (!run.result) return null;
+    return { kind: "profile_diff", result: run.result };
+  }
+
+  if (isRowCountRun(run)) {
+    if (!run.result) return null;
+    return { kind: "row_count", result: run.result };
+  }
+
+  if (isRowCountDiffRun(run)) {
+    if (!run.result) return null;
+    return { kind: "row_count_diff", result: run.result };
+  }
+
+  return null;
+}
+
+/**
+ * Extracts the primary key field name from profile data
+ */
+function getProfilePrimaryKey(result: ProfileDiffResult): string {
+  const field = result.current?.columns.find(
+    (f) => f.name.toLowerCase() === "column_name",
+  );
+  return field?.name ?? "column_name";
+}
+
+// ============================================================================
+// Factory Function
+// ============================================================================
+
+/**
+ * Creates grid data from a Run object and options
+ *
+ * This is the main entry point that abstracts away the different
+ * data transformations needed for different run types.
+ *
+ * @param run - The Run object containing result data
+ * @param options - Grid configuration options
+ * @returns DataGridResult with columns and rows, or null if invalid
+ *
+ * @example
+ * ```tsx
+ * const gridData = createDataGrid(run, {
+ *   primaryKeys: ['id'],
+ *   pinnedColumns: ['name'],
+ *   changedOnly: true,
+ *   displayMode: 'inline',
+ * });
+ *
+ * if (gridData) {
+ *   return <ScreenshotDataGrid columns={gridData.columns} rows={gridData.rows} />;
+ * }
+ * ```
+ */
+export function createDataGrid(
+  run: Run,
+  options: DiffGridOptions = {},
+): DataGridResult | null {
+  const dataKind = determineDataKind(run);
+  if (!dataKind) return null;
+
+  switch (dataKind.kind) {
+    case "query":
+      return toDataGrid(dataKind.result, {
+        primaryKeys: options.primaryKeys,
+        pinnedColumns: options.pinnedColumns,
+        columnsRenderMode: options.columnsRenderMode,
+        onPrimaryKeyChange: options.onPrimaryKeyChange,
+        onPinnedColumnsChange: options.onPinnedColumnsChange,
+        onColumnsRenderModeChanged: options.onColumnsRenderModeChanged,
+      });
+
+    case "query_diff_separate":
+      return toDataDiffGrid(
+        dataKind.result.base,
+        dataKind.result.current,
+        options,
+      );
+
+    case "query_diff_joined":
+      if (!dataKind.result.diff) {
+        return null;
+      }
+      return toValueDiffGrid(dataKind.result.diff, dataKind.primaryKeys, {
+        changedOnly: options.changedOnly,
+        pinnedColumns: options.pinnedColumns,
+        onPinnedColumnsChange: options.onPinnedColumnsChange,
+        baseTitle: options.baseTitle,
+        currentTitle: options.currentTitle,
+        displayMode: options.displayMode,
+        columnsRenderMode: options.columnsRenderMode,
+        onColumnsRenderModeChanged: options.onColumnsRenderModeChanged,
+      });
+
+    case "value_diff":
+      return toValueDataGrid(dataKind.result, { params: dataKind.params });
+
+    case "value_diff_detail":
+      return toValueDiffGrid(dataKind.result, dataKind.primaryKeys, {
+        changedOnly: options.changedOnly,
+        pinnedColumns: options.pinnedColumns,
+        onPinnedColumnsChange: options.onPinnedColumnsChange,
+        displayMode: options.displayMode,
+        columnsRenderMode: options.columnsRenderMode,
+        onColumnsRenderModeChanged: options.onColumnsRenderModeChanged,
+      });
+
+    case "profile": {
+      if (!dataKind.result.current) {
+        return null;
+      }
+      const primaryKey = getProfilePrimaryKey(dataKind.result);
+      return toDataGrid(dataKind.result.current, {
+        primaryKeys: [primaryKey],
+        pinnedColumns: options.pinnedColumns,
+        onPinnedColumnsChange: options.onPinnedColumnsChange,
+        columnsRenderMode: options.columnsRenderMode,
+        onColumnsRenderModeChanged: options.onColumnsRenderModeChanged,
+      });
+    }
+
+    case "profile_diff": {
+      const primaryKey = getProfilePrimaryKey(dataKind.result);
+      return toDataDiffGrid(dataKind.result.base, dataKind.result.current, {
+        primaryKeys: [primaryKey],
+        pinnedColumns: options.pinnedColumns,
+        onPinnedColumnsChange: options.onPinnedColumnsChange,
+        displayMode: options.displayMode,
+        columnsRenderMode: options.columnsRenderMode,
+        onColumnsRenderModeChanged: options.onColumnsRenderModeChanged,
+      });
+    }
+
+    case "row_count":
+      return toRowCountDataGrid(dataKind.result);
+
+    case "row_count_diff":
+      return toRowCountDiffDataGrid(dataKind.result);
+
+    default:
+      return null;
+  }
+}
+
+/**
+ * Input types for the data-only factory function
+ */
+export type DataGridInput =
+  | { type: "single"; dataframe: DataFrame }
+  | { type: "dual"; base?: DataFrame; current?: DataFrame }
+  | { type: "joined"; dataframe: DataFrame; primaryKeys: string[] }
+  | {
+      type: "schema_diff";
+      base?: NodeData["columns"];
+      current?: NodeData["columns"];
+    }
+  | { type: "schema_single"; columns?: NodeData["columns"] };
+
+/**
+ * Union of all possible grid results from createDataGridFromData
+ */
+export type DataGridFromDataResult =
+  | DataGridResult
+  | SchemaDataGridResult
+  | SingleEnvSchemaDataGridResult;
+
+/**
+ * Alternative factory that accepts raw data instead of Run objects
+ * Useful for testing or when you have data outside the Run structure
+ *
+ * @overload For DataFrame inputs, returns DataGridResult
+ * @overload For schema inputs, returns schema-specific result types
+ */
+export function createDataGridFromData(
+  input:
+    | { type: "joined"; dataframe: DataFrame; primaryKeys: string[] }
+    | { type: "dual"; base?: DataFrame; current?: DataFrame }
+    | { type: "single"; dataframe: DataFrame },
+  options?: DiffGridOptions,
+): DataGridResult;
+export function createDataGridFromData(
+  input: {
+    type: "schema_diff";
+    base?: NodeData["columns"];
+    current?: NodeData["columns"];
+  },
+  options?: SchemaDataGridOptions,
+): SchemaDataGridResult;
+export function createDataGridFromData(
+  input: { type: "schema_single"; columns?: NodeData["columns"] },
+  options?: SchemaDataGridOptions,
+): SingleEnvSchemaDataGridResult;
+export function createDataGridFromData(
+  input: DataGridInput,
+  options?: DiffGridOptions | SchemaDataGridOptions,
+): DataGridFromDataResult {
+  switch (input.type) {
+    case "single":
+      return toDataGrid(input.dataframe, (options ?? {}) as DiffGridOptions);
+
+    case "dual":
+      return toDataDiffGrid(
+        input.base,
+        input.current,
+        (options ?? {}) as DiffGridOptions,
+      );
+
+    case "joined":
+      return toValueDiffGrid(
+        input.dataframe,
+        input.primaryKeys,
+        (options ?? {}) as DiffGridOptions,
+      );
+
+    case "schema_diff": {
+      const schemaDiff = mergeColumns(input.base, input.current);
+      return toSchemaDataGrid(
+        schemaDiff,
+        (options ?? {}) as SchemaDataGridOptions,
+      );
+    }
+
+    case "schema_single":
+      return toSingleEnvDataGrid(
+        input.columns,
+        (options ?? {}) as SchemaDataGridOptions,
+      );
+  }
+}
+
+// Re-export the underlying functions for backward compatibility
+export { toDataGrid, toDataDiffGrid, toValueDiffGrid };
+export { mergeColumns, toSchemaDataGrid, toSingleEnvDataGrid };

package/recce-source/js/src/lib/dataGrid/generators/rowCountUtils.test.ts

@@ -0,0 +1,132 @@
+import {
+  calculateDelta,
+  getRowCountDiffStatus,
+  rowCountDiffResultToDataFrame,
+  rowCountResultToDataFrame,
+} from "./rowCountUtils";
+
+// ============================================================================
+// calculateDelta Tests
+// ============================================================================
+
+describe("calculateDelta", () => {
+  test("returns '=' when values are equal", () => {
+    expect(calculateDelta(100, 100)).toBe("=");
+  });
+
+  test("returns percentage string when values differ", () => {
+    const result = calculateDelta(100, 150);
+    expect(result).toMatch(/^\+50(\.0)?%$/);
+  });
+
+  test("returns 'Added' when base is null", () => {
+    expect(calculateDelta(null, 100)).toBe("Added");
+  });
+
+  test("returns 'Removed' when current is null", () => {
+    expect(calculateDelta(100, null)).toBe("Removed");
+  });
+
+  test("returns 'N/A' when both are null", () => {
+    expect(calculateDelta(null, null)).toBe("N/A");
+  });
+});
+
+// ============================================================================
+// getRowCountDiffStatus Tests
+// ============================================================================
+
+describe("getRowCountDiffStatus", () => {
+  test("returns 'added' when only current exists", () => {
+    expect(getRowCountDiffStatus(null, 100)).toBe("added");
+  });
+
+  test("returns 'removed' when only base exists", () => {
+    expect(getRowCountDiffStatus(100, null)).toBe("removed");
+  });
+
+  test("returns 'modified' when values differ", () => {
+    expect(getRowCountDiffStatus(100, 200)).toBe("modified");
+  });
+
+  test("returns undefined when values are equal", () => {
+    expect(getRowCountDiffStatus(100, 100)).toBeUndefined();
+  });
+
+  test("returns undefined when both are null", () => {
+    expect(getRowCountDiffStatus(null, null)).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// rowCountDiffResultToDataFrame Tests
+// ============================================================================
+
+describe("rowCountDiffResultToDataFrame", () => {
+  test("converts empty result to empty DataFrame", () => {
+    const result = rowCountDiffResultToDataFrame({});
+
+    expect(result.columns).toHaveLength(4);
+    expect(result.data).toHaveLength(0);
+  });
+
+  test("converts single entry correctly", () => {
+    const result = rowCountDiffResultToDataFrame({
+      orders: { base: 100, curr: 150 },
+    });
+
+    expect(result.data).toHaveLength(1);
+    expect(result.data[0][0]).toBe("orders");
+    expect(result.data[0][1]).toBe(100);
+    expect(result.data[0][2]).toBe(150);
+  });
+
+  test("handles null values", () => {
+    const result = rowCountDiffResultToDataFrame({
+      new_model: { base: null, curr: 100 },
+    });
+
+    expect(result.data[0][1]).toBeNull();
+    expect(result.data[0][2]).toBe(100);
+    expect(result.data[0][3]).toBe("Added");
+  });
+
+  test("includes calculated delta", () => {
+    const result = rowCountDiffResultToDataFrame({
+      orders: { base: 100, curr: 100 },
+    });
+
+    expect(result.data[0][3]).toBe("=");
+  });
+});
+
+// ============================================================================
+// rowCountResultToDataFrame Tests
+// ============================================================================
+
+describe("rowCountResultToDataFrame", () => {
+  test("converts empty result to empty DataFrame", () => {
+    const result = rowCountResultToDataFrame({});
+
+    expect(result.columns).toHaveLength(2);
+    expect(result.data).toHaveLength(0);
+  });
+
+  test("converts single entry correctly", () => {
+    const result = rowCountResultToDataFrame({
+      orders: { curr: 150 },
+    });
+
+    expect(result.data).toHaveLength(1);
+    expect(result.data[0][0]).toBe("orders");
+    expect(result.data[0][1]).toBe(150);
+  });
+
+  test("handles null values", () => {
+    const result = rowCountResultToDataFrame({
+      failed_model: { curr: null },
+    });
+
+    expect(result.data[0][1]).toBeNull();
+  });
+});

package/recce-source/js/src/lib/dataGrid/generators/rowCountUtils.ts

@@ -0,0 +1,126 @@
+/**
+ * @file rowCountUtils.ts
+ * @description Utilities for converting row count results to DataFrame format
+ */
+
+import { deltaPercentageString } from "@/components/rowcount/delta";
+import { RowCountDiffResult, RowCountResult } from "@/lib/api/rowcount";
+import { DataFrame } from "@/lib/api/types";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/**
+ * Extended row data for row count diff grid
+ */
+export interface RowCountDiffRowData {
+  name: string;
+  base: number | null;
+  current: number | null;
+  delta: string;
+}
+
+/**
+ * Extended row data for row count grid (single env)
+ */
+export interface RowCountRowData {
+  name: string;
+  current: number | null;
+}
+
+// ============================================================================
+// Delta Calculation
+// ============================================================================
+
+/**
+ * Calculates the delta string for row count comparison
+ */
+export function calculateDelta(
+  base: number | null,
+  current: number | null,
+): string {
+  if (base !== null && current !== null) {
+    return base !== current ? deltaPercentageString(base, current) : "=";
+  }
+
+  if (base === current) return "N/A";
+  if (base === null) return "Added";
+  if (current === null) return "Removed";
+
+  return "N/A";
+}
+
+// ============================================================================
+// Data Conversion
+// ============================================================================
+
+/**
+ * Converts RowCountDiffResult to DataFrame format
+ *
+ * @param result - The row count diff result from the backend
+ * @returns DataFrame with name, base, current, and delta columns
+ */
+export function rowCountDiffResultToDataFrame(
+  result: RowCountDiffResult,
+): DataFrame {
+  const entries = Object.entries(result);
+
+  return {
+    columns: [
+      { key: "name", name: "Name", type: "text" },
+      { key: "base", name: "Base Rows", type: "number" },
+      { key: "current", name: "Current Rows", type: "number" },
+      { key: "delta", name: "Delta", type: "text" },
+    ],
+    data: entries.map(([name, counts]) => {
+      const base = typeof counts.base === "number" ? counts.base : null;
+      const current = typeof counts.curr === "number" ? counts.curr : null;
+      const delta = calculateDelta(base, current);
+
+      return [name, base, current, delta];
+    }),
+  };
+}
+
+/**
+ * Converts RowCountResult to DataFrame format
+ *
+ * @param result - The row count result from the backend
+ * @returns DataFrame with name and current columns
+ */
+export function rowCountResultToDataFrame(result: RowCountResult): DataFrame {
+  const entries = Object.entries(result);
+
+  return {
+    columns: [
+      { key: "name", name: "Name", type: "text" },
+      { key: "current", name: "Row Count", type: "number" },
+    ],
+    data: entries.map(([name, counts]) => {
+      const current = typeof counts.curr === "number" ? counts.curr : null;
+      return [name, current];
+    }),
+  };
+}
+
+// ============================================================================
+// Row Status Determination
+// ============================================================================
+
+/**
+ * Determines the diff status for a row count entry
+ *
+ * @param base - Base row count (null if not present)
+ * @param current - Current row count (null if not present)
+ * @returns Status string: "added" | "removed" | "modified" | undefined
+ */
+export function getRowCountDiffStatus(
+  base: number | null,
+  current: number | null,
+): "added" | "removed" | "modified" | undefined {
+  if (base === null && current !== null) return "added";
+  if (base !== null && current === null) return "removed";
+  if (base !== null && current !== null && base !== current) return "modified";
+  return undefined;
+}