feat(tesseract): expose view default value filters to Tesseract

Wires the view-only `filters` field (added to the Joi schema in a703f81)
end-to-end:

- CubeEvaluator.prepareViewFilters resolves `member`/`unless` against the
  view's includedMembers (short, real-cube and view-prefixed paths all
  normalize to the real cube path) and stringifies `values` to match the
  existing FilterItem.values contract.
- New ViewFilterDefinition bridge in cubesqlplanner (static-only, no
  trait fields) plus an optional `filters()` getter on CubeDefinition.
- MockViewFilterDefinition and `filters` field on MockCubeDefinition for
  Rust-side test fixtures.
- backend-native bridge_registry registration with fixture, expected
  field set and round-trip coverage for the new struct.

Author: waralexrom

packages/cubejs-backend-native/src/bridge_test_exports.rs

@@ -91,6 +91,9 @@ use cubesqlplanner::cube_bridge::{
     timeshift_definition::{
         time_shift_definition_bridge_fields_meta, NativeTimeShiftDefinition, TimeShiftDefinition,
     },
+    view_filter_definition::{
+        view_filter_definition_bridge_fields_meta, NativeViewFilterDefinition,
+    },
 };
 use neon::prelude::*;
 use std::any::Any;
@@ -451,6 +454,7 @@ bridge_registry! {
     "sqlUtils"                    => NativeSqlUtils,                    sql_utils_bridge_fields_meta,                    invoke_sql_utils;
     "structWithSqlMember"         => NativeStructWithSqlMember,         struct_with_sql_member_bridge_fields_meta,       invoke_struct_with_sql_member;
     "timeShiftDefinition"         => NativeTimeShiftDefinition,         time_shift_definition_bridge_fields_meta,        invoke_time_shift_definition;
+    "viewFilterDefinition"        => NativeViewFilterDefinition,        view_filter_definition_bridge_fields_meta,       invoke_view_filter_definition;
 }
 
 fn list_bridge_fields_inner<IT: InnerTypes>(
@@ -708,10 +712,17 @@ fn invoke_time_shift_definition<IT: InnerTypes>(b: &NativeTimeShiftDefinition<IT
     r
 }
 
+fn invoke_view_filter_definition<IT: InnerTypes>(
+    _b: &NativeViewFilterDefinition<IT>,
+) -> InvokeResult {
+    InvokeResult::new()
+}
+
 fn invoke_cube_definition<IT: InnerTypes>(b: &NativeCubeDefinition<IT>) -> InvokeResult {
     let mut r = InvokeResult::new();
     r.record("sql_table", b.sql_table());
     r.record("sql", b.sql());
+    r.record("filters", b.filters());
     r
 }
 

packages/cubejs-backend-native/test/bridge/bridge-fixtures.ts

@@ -131,10 +131,20 @@ export const preAggregationDescriptionFixture = (): unknown => ({
   // measure_references, dimension_references, etc — all optional getters
 });
 
+export const viewFilterDefinitionFixture = (): unknown => ({
+  operator: 'equals',
+  memberReference: 'orders.currency',
+  // Values are stringified by CubeEvaluator.prepareViewFilters before reaching
+  // Tesseract; nulls are kept to exercise the Option<Vec<Option<String>>> shape.
+  valuesReferences: ['USD', null],
+  unlessReferences: ['orders.currency'],
+});
+
 export const cubeDefinitionFixture = (): unknown => ({
   name: 'Orders',
   // sqlAlias, isView, isCalendar, joinMap optional
   // sql_table, sql optional getters
+  filters: [viewFilterDefinitionFixture()],
 });
 
 export const dimensionDefinitionFixture = (): unknown => ({
@@ -270,4 +280,5 @@ export const FIXTURES: Record<string, BridgeFixtureFactory> = {
   sqlUtils: sqlUtilsFixture,
   structWithSqlMember: structWithSqlMemberFixture,
   timeShiftDefinition: timeShiftDefinitionFixture,
+  viewFilterDefinition: viewFilterDefinitionFixture,
 };

packages/cubejs-backend-native/test/bridge/object-bridges-coverage.test.ts

@@ -87,7 +87,16 @@ const BRIDGES: BridgeSpec[] = [
   { name: 'caseSwitchItem', expected: ['sql', 'value'] },
   {
     name: 'cubeDefinition',
-    expected: ['is_calendar', 'is_view', 'join_map', 'name', 'sql', 'sql_alias', 'sql_table'],
+    expected: [
+      'filters',
+      'is_calendar',
+      'is_view',
+      'join_map',
+      'name',
+      'sql',
+      'sql_alias',
+      'sql_table',
+    ],
   },
   {
     name: 'cubeEvaluator',
@@ -215,6 +224,10 @@ const BRIDGES: BridgeSpec[] = [
   { name: 'sqlUtils', expected: [] },
   { name: 'structWithSqlMember', expected: ['sql'] },
   { name: 'timeShiftDefinition', expected: ['interval', 'name', 'sql', 'timeshift_type'] },
+  {
+    name: 'viewFilterDefinition',
+    expected: ['member_reference', 'operator', 'unless_references', 'values_references'],
+  },
 ];
 
 const describeBridge = bridgeHarnessAvailable ? describe : describe.skip;

packages/cubejs-schema-compiler/src/compiler/CubeEvaluator.ts

@@ -13,6 +13,7 @@ import {
   PreAggregationDefinition,
   PreAggregationDefinitionRollup,
   type ToString,
+  ViewDefaultValueFilter,
   ViewIncludedMember
 } from './CubeSymbols';
 import { UserError } from './UserError';
@@ -147,6 +148,7 @@ export type EvaluatedCube = {
   accessPolicy?: AccessPolicyDefinition[];
   isView?: boolean;
   includedMembers?: ViewIncludedMember[];
+  filters?: ViewDefaultValueFilter[];
 };
 
 export class CubeEvaluator extends CubeSymbols {
@@ -207,10 +209,86 @@ export class CubeEvaluator extends CubeSymbols {
     this.prepareFolders(cube, errorReporter);
 
     this.prepareAccessPolicy(cube, errorReporter);
+    this.prepareViewFilters(cube, errorReporter);
 
     return cube;
   }
 
+  private prepareViewFilters(cube: any, errorReporter: ErrorReporter) {
+    if (!cube.filters) {
+      return;
+    }
+
+    const included = (cube.includedMembers as ViewIncludedMember[] | undefined) || [];
+
+    const resolveViewMember = (memberType: string, reference: string): string | null => {
+      let lookupName = reference;
+      let lookupPath: string | null = null;
+
+      if (reference.indexOf('.') !== -1) {
+        const parts = reference.split('.');
+        if (parts[0] === cube.name) {
+          // Identifier form resolved via view's own namespace, e.g. 'orders_view.currency'
+          lookupName = parts.slice(1).join('.');
+        } else {
+          // Fully-qualified member path, e.g. 'orders.currency'
+          lookupPath = reference;
+        }
+      }
+
+      const match = lookupPath
+        ? included.find((m) => m.memberPath === lookupPath)
+        : included.find((m) => m.name === lookupName);
+
+      if (!match) {
+        errorReporter.error(
+          `Member '${reference}' used as ${memberType} in default value filter is not included in view '${cube.name}'`
+        );
+        return null;
+      }
+      return match.memberPath;
+    };
+
+    for (const filter of cube.filters as ViewDefaultValueFilter[]) {
+      const rawMember = this.evaluateReferences(cube.name, filter.member);
+      const resolved = resolveViewMember('member', rawMember);
+      if (resolved !== null) {
+        filter.memberReference = resolved;
+      }
+
+      if (filter.values) {
+        const evaluated = filter.values();
+        if (!Array.isArray(evaluated)) {
+          errorReporter.error(
+            `'values' in default value filter for view '${cube.name}' must evaluate to an array, got: ${typeof evaluated}`
+          );
+        } else {
+          // Coerce to strings to match the FilterItem.values contract used by
+          // regular query filters (Option<Vec<Option<String>>> on the Rust side).
+          filter.valuesReferences = evaluated.map(
+            (v) => (v === null || v === undefined ? null : String(v))
+          );
+        }
+      }
+
+      if (filter.unless) {
+        const rawUnless = this.evaluateReferences(
+          cube.name,
+          filter.unless,
+          { originalSorting: true }
+        );
+        const resolvedUnless: string[] = [];
+        for (const ref of rawUnless) {
+          const r = resolveViewMember('unless', ref);
+          if (r !== null) {
+            resolvedUnless.push(r);
+          }
+        }
+        filter.unlessReferences = resolvedUnless;
+      }
+    }
+  }
+
   private allMembersOrList(cube: any, specifier: string | string[]): string[] {
     const types = ['measures', 'dimensions', 'segments'];
     if (specifier === '*') {

packages/cubejs-schema-compiler/src/compiler/CubeSymbols.ts

@@ -148,6 +148,16 @@ export type AccessPolicyDefinition = {
   }[]
 };
 
+export type ViewDefaultValueFilter = {
+  member: (...args: Array<unknown>) => ToString;
+  memberReference?: string;
+  operator: string;
+  values?: (...args: Array<unknown>) => Array<unknown>;
+  valuesReferences?: Array<unknown>;
+  unless?: (...args: Array<unknown>) => Array<ToString>;
+  unlessReferences?: string[];
+};
+
 export type ViewIncludedMember = {
   type: string;
   memberPath: string;
@@ -216,6 +226,7 @@ export interface CubeDefinition {
   isView?: boolean;
   viewGroup?: string | ((...args: any[]) => any);
   viewGroups?: string[] | ((...args: any[]) => any);
+  filters?: ViewDefaultValueFilter[];
   calendar?: boolean;
   isSplitView?: boolean;
   includedMembers?: ViewIncludedMember[];