@startsimpli/funnels 0.4.13 → 0.4.14

package/src/api/paths.ts

@@ -0,0 +1,146 @@
+/**
+ * The funnel path family (bd startsim-pxzlf).
+ *
+ * WHY THIS EXISTS: FunnelApiClient hardcoded '/api/v1/funnels' in every method,
+ * so the one client in the estate could only ever talk to the central API. The
+ * same endpoints are mounted on at least four surfaces:
+ *
+ *   central        /api/v1/funnels/…                     runs addressed globally
+ *   control plane  /api/v1/foundry/tenants/<slug>/funnels/…   runs nested (startsim-9xbz2)
+ *   tenant proxy   /central-api/api/v1/funnels/…         a prefix on the central family
+ *   a fork's own   whatever the fork mounted
+ *
+ * They differ in exactly two ways: the prefix, and whether a run is addressed
+ * on its own or under its funnel. So the family is data — a small object of
+ * path builders — and the client takes one.
+ *
+ * @packageDocumentation
+ */
+
+/** The central API's funnel prefix. */
+export const DEFAULT_FUNNEL_PATH_PREFIX = '/api/v1/funnels';
+
+/** The central API's run prefix — its own router entry, not nested. */
+export const DEFAULT_FUNNEL_RUNS_PATH_PREFIX = '/api/v1/funnel-runs';
+
+/**
+ * Every URL the funnel client needs, as builders.
+ *
+ * Run-addressing methods take an optional funnelId because a nested family
+ * needs it; on a flat family it is ignored.
+ */
+export interface FunnelPaths {
+  /** The prefix this family was built on — for logging and for telling surfaces apart. */
+  readonly prefix: string;
+
+  list(): string;
+  detail(funnelId: string): string;
+  stages(funnelId: string): string;
+  stage(funnelId: string, stageId: string): string;
+  preview(funnelId: string): string;
+  fields(): string;
+
+  run(funnelId: string): string;
+  runs(funnelId: string): string;
+  runDetail(runId: string, funnelId?: string): string;
+  runResults(runId: string, funnelId?: string): string;
+  runCancel(runId: string, funnelId?: string): string;
+}
+
+export interface FunnelPathsOptions {
+  /** Where the funnel collection is mounted. Default: the central API. */
+  prefix?: string;
+  /**
+   * Where runs are mounted when they are addressed on their own.
+   * Ignored when `nestRuns` is set. Default: the central API's /funnel-runs.
+   */
+  runsPrefix?: string;
+  /**
+   * Address a run under its funnel (<prefix>/<funnelId>/runs/<runId>/) instead
+   * of on its own. The control-plane viewset nests them this way.
+   */
+  nestRuns?: boolean;
+}
+
+function trimSlashes(value: string): string {
+  return value.replace(/\/+$/, '');
+}
+
+/** Encode one path segment: an id or slug must not be able to escape the family. */
+function segment(value: string): string {
+  return encodeURIComponent(String(value));
+}
+
+/**
+ * Build a funnel path family.
+ *
+ * ```ts
+ * createFunnelPaths()                                        // central
+ * createFunnelPaths({ prefix: '/central-api/api/v1/funnels',
+ *                     runsPrefix: '/central-api/api/v1/funnel-runs' })
+ * createFunnelPaths({ prefix: '/api/v1/foundry/tenants/acme/funnels',
+ *                     nestRuns: true })
+ * ```
+ */
+export function createFunnelPaths(options: FunnelPathsOptions = {}): FunnelPaths {
+  const prefix = trimSlashes(options.prefix ?? DEFAULT_FUNNEL_PATH_PREFIX);
+  const runsPrefix = trimSlashes(options.runsPrefix ?? DEFAULT_FUNNEL_RUNS_PATH_PREFIX);
+  const nestRuns = options.nestRuns ?? false;
+
+  function runBase(runId: string, funnelId?: string): string {
+    if (!nestRuns) return `${runsPrefix}/${segment(runId)}`;
+    if (!funnelId) {
+      throw new Error(
+        `This funnel path family nests runs under their funnel, so addressing run ` +
+          `'${runId}' needs a funnelId. Pass it: getFunnelRun(runId, funnelId).`
+      );
+    }
+    return `${prefix}/${segment(funnelId)}/runs/${segment(runId)}`;
+  }
+
+  return {
+    prefix,
+
+    list: () => `${prefix}/`,
+    detail: (funnelId) => `${prefix}/${segment(funnelId)}/`,
+    stages: (funnelId) => `${prefix}/${segment(funnelId)}/stages/`,
+    stage: (funnelId, stageId) => `${prefix}/${segment(funnelId)}/stages/${segment(stageId)}/`,
+    preview: (funnelId) => `${prefix}/${segment(funnelId)}/preview/`,
+    // The registry endpoint lives beside the collection on every surface
+    // (config/api_router.py: path("funnels/fields/", FunnelFieldsView…)).
+    fields: () => `${prefix}/fields/`,
+
+    run: (funnelId) => `${prefix}/${segment(funnelId)}/run/`,
+    runs: (funnelId) => `${prefix}/${segment(funnelId)}/runs/`,
+    runDetail: (runId, funnelId) => `${runBase(runId, funnelId)}/`,
+    runResults: (runId, funnelId) => `${runBase(runId, funnelId)}/results/`,
+    runCancel: (runId, funnelId) => `${runBase(runId, funnelId)}/cancel/`,
+  };
+}
+
+/** The central API family: what the client used to hardcode. */
+export const centralFunnelPaths: FunnelPaths = createFunnelPaths();
+
+/**
+ * The control-plane family for one foundry (startsim-9xbz2):
+ * /api/v1/foundry/tenants/<slug>/funnels/… with runs nested under their funnel.
+ */
+export function foundryTenantFunnelPaths(slug: string): FunnelPaths {
+  return createFunnelPaths({
+    prefix: `/api/v1/foundry/tenants/${segment(slug)}/funnels`,
+    nestRuns: true,
+  });
+}
+
+/**
+ * The same central family reached through a fork's same-origin proxy, e.g.
+ * '/central-api'. A tenant page cannot call the central API cross-origin
+ * (project_foreign_apex_sso_same_origin_proxy), so it proxies it.
+ */
+export function proxiedCentralFunnelPaths(proxyPrefix: string): FunnelPaths {
+  const base = trimSlashes(proxyPrefix);
+  return createFunnelPaths({
+    prefix: `${base}${DEFAULT_FUNNEL_PATH_PREFIX}`,
+    runsPrefix: `${base}${DEFAULT_FUNNEL_RUNS_PATH_PREFIX}`,
+  });
+}

package/src/components/FilterRuleEditor/FieldSelector.tsx

@@ -29,10 +29,12 @@
  * - Focus visible on keyboard navigation
  */
 
-import { FieldDefinition } from '../../types';
+import { FieldDefinitionInput } from '../../types';
+import { fieldKey } from '../../types';
 
 interface FieldSelectorProps {
-  fields: FieldDefinition[];
+  /** Canonical /fields/ entries or legacy {name,label,type,operators} ones. */
+  fields: FieldDefinitionInput[];
   value: string;
   onChange: (fieldName: string) => void;
   error?: string;
@@ -54,7 +56,7 @@ export function FieldSelector({
     }
     acc[category].push(field);
     return acc;
-  }, {} as Record<string, FieldDefinition[]>);
+  }, {} as Record<string, FieldDefinitionInput[]>);
 
   const categories = Object.keys(grouped).sort();
 
@@ -78,8 +80,8 @@ export function FieldSelector({
         {categories.map((category) => (
           <optgroup key={category} label={category}>
             {grouped[category].map((field) => (
-              <option key={field.name} value={field.name}>
-                {field.label}
+              <option key={fieldKey(field)} value={fieldKey(field)}>
+                {field.label ?? fieldKey(field)}
               </option>
             ))}
           </optgroup>

package/src/components/FilterRuleEditor/FilterRuleEditor.stories.tsx

@@ -6,7 +6,7 @@
 
 import { useState } from 'react';
 import { FilterRuleEditor } from './FilterRuleEditor';
-import { FilterRule, FilterLogic, FieldDefinition } from '../../types';
+import { FilterRule, FilterLogic, FieldDefinitionInput } from '../../types';
 
 export default {
   title: 'Components/FilterRuleEditor',
@@ -17,7 +17,7 @@ export default {
 // Investor Field Registry
 // ============================================================================
 
-const investorFields: FieldDefinition[] = [
+const investorFields: FieldDefinitionInput[] = [
   {
     name: 'name',
     label: 'Name',
@@ -101,7 +101,7 @@ const investorFields: FieldDefinition[] = [
 // Recipe Field Registry
 // ============================================================================
 
-const recipeFields: FieldDefinition[] = [
+const recipeFields: FieldDefinitionInput[] = [
   {
     name: 'title',
     label: 'Recipe Title',

package/src/components/FilterRuleEditor/FilterRuleEditor.test.tsx

@@ -5,7 +5,7 @@
  */
 
 import { describe, it, expect, vi } from 'vitest';
-import { FilterRule, FieldDefinition, FilterLogic } from '../../types';
+import { FilterRule, FieldDefinitionInput, FilterLogic } from '../../types';
 import { validateFilterRule } from '../../types';
 
 // ============================================================================
@@ -15,7 +15,7 @@ import { validateFilterRule } from '../../types';
 /**
  * Investor field registry
  */
-const investorFieldRegistry: FieldDefinition[] = [
+const investorFieldRegistry: FieldDefinitionInput[] = [
   {
     name: 'name',
     label: 'Name',
@@ -73,7 +73,7 @@ const investorFieldRegistry: FieldDefinition[] = [
 /**
  * Recipe field registry - completely different domain!
  */
-const recipeFieldRegistry: FieldDefinition[] = [
+const recipeFieldRegistry: FieldDefinitionInput[] = [
   {
     name: 'title',
     label: 'Recipe Title',
@@ -132,15 +132,20 @@ const recipeFieldRegistry: FieldDefinition[] = [
 // ============================================================================
 
 describe('FilterRuleEditor - Generic Validation', () => {
-  it('validates empty fieldPath', () => {
+  it('validates empty field', () => {
     const rule: FilterRule = {
-      fieldPath: '',
+      field: '',
       operator: 'eq',
       value: 'test',
     };
 
     const errors = validateFilterRule(rule);
-    expect(errors).toContain('fieldPath is required');
+    expect(errors).toContain('field is required');
+  });
+
+  it('still accepts a rule that names its field the deprecated way', () => {
+    const legacy = { fieldPath: 'name', operator: 'eq', value: 'test' } as FilterRule;
+    expect(validateFilterRule(legacy)).toEqual([]);
   });
 
   it('validates missing operator', () => {
@@ -414,7 +419,7 @@ describe('FilterRuleEditor - Field Registry Grouping', () => {
       }
       acc[category].push(field);
       return acc;
-    }, {} as Record<string, FieldDefinition[]>);
+    }, {} as Record<string, FieldDefinitionInput[]>);
 
     expect(Object.keys(grouped)).toContain('Profile');
     expect(Object.keys(grouped)).toContain('Investment');
@@ -431,7 +436,7 @@ describe('FilterRuleEditor - Field Registry Grouping', () => {
       }
       acc[category].push(field);
       return acc;
-    }, {} as Record<string, FieldDefinition[]>);
+    }, {} as Record<string, FieldDefinitionInput[]>);
 
     expect(Object.keys(grouped)).toContain('Basic Info');
     expect(Object.keys(grouped)).toContain('Classification');

package/src/components/FilterRuleEditor/FilterRuleEditor.tsx

@@ -50,7 +50,7 @@
  * - Transitions: transition-all, duration-200
  */
 
-import { FilterRule, FilterLogic, FieldDefinition } from '../../types';
+import { FilterRule, FilterLogic, FieldDefinitionInput } from '../../types';
 import { LogicToggle } from './LogicToggle';
 import { RuleRow } from './RuleRow';
 import { validateFilterRule } from '../../types';
@@ -63,7 +63,8 @@ export interface FilterRuleEditorProps {
   onChange: (rules: FilterRule[]) => void;
 
   /** Field registry for the entity type */
-  fieldRegistry: FieldDefinition[];
+  /** Canonical /fields/ entries or legacy {name,label,type,operators} ones. */
+  fieldRegistry: FieldDefinitionInput[];
 
   /** Filter logic (AND/OR) */
   logic?: FilterLogic;
@@ -86,6 +87,10 @@ export function FilterRuleEditor({
   // Add a new empty rule
   const handleAddRule = () => {
     const newRule: FilterRule = {
+      field: '',
+      // Both keys start empty: RuleRow decides which one carries the chosen
+      // name, depending on whether the registry entry is a resolver key or a
+      // hand-written one (see its handleFieldChange).
       fieldPath: '',
       operator: 'eq' as any,
       value: null,

package/src/components/FilterRuleEditor/OperatorSelector.tsx

@@ -24,7 +24,7 @@
  * - Focus visible on keyboard navigation
  */
 
-import { Operator, FieldDefinition } from '../../types';
+import { Operator, FieldDefinitionInput } from '../../types';
 import { OPERATOR_LABELS } from './constants';
 
 interface OperatorSelectorProps {

package/src/components/FilterRuleEditor/RuleRow.test.tsx

@@ -0,0 +1,166 @@
+/**
+ * RuleRow renders BOTH field-registry shapes (bd startsim-pxzlf).
+ *
+ * The canonical registry is the backend's /fields/ payload
+ * ({key,label,category,valueType,enumValues,allowedOperators}). The registries
+ * that predate it are hand-written arrays of {name,label,type,operators} —
+ * market-web's LEAD_FIELDS is one, and it is live. Both have to render, or
+ * "one contract" is just a rename that breaks a shipped app.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { RuleRow } from './RuleRow';
+import type { FieldDefinitionInput, FilterRule } from '../../types';
+
+const canonicalRegistry: FieldDefinitionInput[] = [
+  {
+    key: 'tag.stage_focus',
+    label: 'stage_focus',
+    category: 'Tags',
+    valueType: 'enum',
+    enumValues: ['pre_seed', 'seed'],
+    allowedOperators: ['eq', 'ne', 'exists', 'not_exists'],
+  },
+  {
+    key: 'metric.financial.check_size_min',
+    label: 'check_size_min',
+    category: 'Financial',
+    valueType: 'number',
+    allowedOperators: ['gte', 'lte', 'between'],
+  },
+];
+
+const legacyRegistry: FieldDefinitionInput[] = [
+  {
+    name: 'contact__name',
+    label: 'Name',
+    type: 'string',
+    category: 'Profile',
+    operators: ['eq', 'contains'],
+  },
+];
+
+function noop() {}
+
+describe('RuleRow with the canonical registry', () => {
+  it('selects the field the rule names with `field`', () => {
+    const rule: FilterRule = { field: 'tag.stage_focus', operator: 'eq', value: 'seed' };
+    render(
+      <RuleRow rule={rule} onChange={noop} onRemove={noop} fieldRegistry={canonicalRegistry} />
+    );
+
+    const fieldSelect = screen.getByLabelText('Field') as HTMLSelectElement;
+    expect(fieldSelect.value).toBe('tag.stage_focus');
+  });
+
+  it('offers the operators the registry allows, including the backend-only ones', () => {
+    const rule: FilterRule = {
+      field: 'metric.financial.check_size_min',
+      operator: 'gte',
+      value: 1,
+    };
+    render(
+      <RuleRow rule={rule} onChange={noop} onRemove={noop} fieldRegistry={canonicalRegistry} />
+    );
+
+    const operatorSelect = screen.getByLabelText('Operator') as HTMLSelectElement;
+    const offered = Array.from(operatorSelect.options).map((o) => o.value);
+    expect(offered).toEqual(expect.arrayContaining(['gte', 'lte', 'between']));
+  });
+
+  it('renders an enum field as a picker over its enum values', () => {
+    const rule: FilterRule = { field: 'tag.stage_focus', operator: 'eq', value: 'seed' };
+    render(
+      <RuleRow rule={rule} onChange={noop} onRemove={noop} fieldRegistry={canonicalRegistry} />
+    );
+
+    // The value input is a select over the tag category's known values.
+    const selects = screen.getAllByRole('combobox') as HTMLSelectElement[];
+    const values = selects.flatMap((s) => Array.from(s.options).map((o) => o.value));
+    expect(values).toEqual(expect.arrayContaining(['pre_seed', 'seed']));
+  });
+
+  it('writes the canonical key on the rule when the field changes', () => {
+    const onChange = vi.fn();
+    const rule: FilterRule = { field: '', operator: 'eq', value: null };
+    render(
+      <RuleRow
+        rule={rule}
+        onChange={onChange}
+        onRemove={noop}
+        fieldRegistry={canonicalRegistry}
+      />
+    );
+
+    const fieldSelect = screen.getByLabelText('Field') as HTMLSelectElement;
+    fieldSelect.value = 'tag.stage_focus';
+    fieldSelect.dispatchEvent(new Event('change', { bubbles: true }));
+
+    expect(onChange).toHaveBeenCalledWith(
+      expect.objectContaining({ field: 'tag.stage_focus', operator: 'eq' })
+    );
+  });
+});
+
+describe('RuleRow with a hand-written registry that predates /fields/', () => {
+  it('does NOT write a non-registry name into `field` — that would be a 400', () => {
+    // 'contact__name' is not a resolver key. The serializer's strict branch
+    // fires on any truthy `field` and rejects an unknown one, so a picker
+    // driven by a hand-written registry has to keep taking the legacy branch:
+    // `field` empty, the name on `fieldPath`.
+    const onChange = vi.fn();
+    const rule = { field: '', operator: 'eq', value: null } as FilterRule;
+    render(
+      <RuleRow rule={rule} onChange={onChange} onRemove={noop} fieldRegistry={legacyRegistry} />
+    );
+
+    const fieldSelect = screen.getByLabelText('Field') as HTMLSelectElement;
+    fieldSelect.value = 'contact__name';
+    fieldSelect.dispatchEvent(new Event('change', { bubbles: true }));
+
+    expect(onChange).toHaveBeenCalledWith(
+      expect.objectContaining({ field: '', fieldPath: 'contact__name', operator: 'eq' })
+    );
+  });
+
+  it('resolves a row the backend auto-migrated, which carries BOTH keys', () => {
+    // The serializer's legacy branch sets attrs['field'] and does NOT clear
+    // field_path, and _create_rule_tree persists the whole validated dict — so
+    // every rule market has saved since that change round-trips as
+    // {field: 'contact.name', fieldPath: 'contact__name'}. Preferring `field`
+    // alone would leave the picker blank against a registry keyed the old way,
+    // and re-saving that blank row would drop the rule.
+    const migrated = {
+      field: 'contact.name',
+      fieldPath: 'contact__name',
+      operator: 'contains',
+      value: 'Ada',
+    } as FilterRule;
+    render(
+      <RuleRow rule={migrated} onChange={noop} onRemove={noop} fieldRegistry={legacyRegistry} />
+    );
+
+    const fieldSelect = screen.getByLabelText('Field') as HTMLSelectElement;
+    expect(fieldSelect.value).toBe('contact__name');
+
+    const operatorSelect = screen.getByLabelText('Operator') as HTMLSelectElement;
+    expect(operatorSelect.disabled).toBe(false);
+    expect(Array.from(operatorSelect.options).map((o) => o.value)).toEqual(
+      expect.arrayContaining(['eq', 'contains'])
+    );
+  });
+
+  it('still resolves a rule that names its field the deprecated way', () => {
+    const rule = { fieldPath: 'contact__name', operator: 'contains', value: 'Ada' } as FilterRule;
+    render(<RuleRow rule={rule} onChange={noop} onRemove={noop} fieldRegistry={legacyRegistry} />);
+
+    const fieldSelect = screen.getByLabelText('Field') as HTMLSelectElement;
+    expect(fieldSelect.value).toBe('contact__name');
+
+    const operatorSelect = screen.getByLabelText('Operator') as HTMLSelectElement;
+    expect(Array.from(operatorSelect.options).map((o) => o.value)).toEqual(
+      expect.arrayContaining(['eq', 'contains'])
+    );
+  });
+});

package/src/components/FilterRuleEditor/RuleRow.tsx

@@ -38,7 +38,14 @@
  * - Focus management when adding/removing rules
  */
 
-import { FilterRule, FieldDefinition, Operator } from '../../types';
+import { FilterRule, FieldDefinitionInput, Operator } from '../../types';
+import {
+  fieldKey,
+  fieldOperators,
+  fieldValueType,
+  normalizeFieldDefinition,
+  ruleField,
+} from '../../types';
 import { FieldSelector } from './FieldSelector';
 import { OperatorSelector } from './OperatorSelector';
 import { NULL_VALUE_OPERATORS, MULTI_VALUE_OPERATORS } from './constants';
@@ -55,7 +62,12 @@ interface RuleRowProps {
   rule: FilterRule;
   onChange: (rule: FilterRule) => void;
   onRemove: () => void;
-  fieldRegistry: FieldDefinition[];
+  /**
+   * Accepts the canonical /fields/ shape AND the hand-written
+   * {name,type,operators} registries that predate it — every read goes through
+   * the accessors (bd startsim-pxzlf).
+   */
+  fieldRegistry: FieldDefinitionInput[];
   className?: string;
 }
 
@@ -66,11 +78,27 @@ export function RuleRow({
   fieldRegistry,
   className = '',
 }: RuleRowProps) {
-  // Find the selected field definition
-  const selectedField = fieldRegistry.find((f) => f.name === rule.fieldPath);
+  // Which of the rule's two keys this registry can actually resolve.
+  //
+  // A rule the backend auto-migrated carries BOTH: the serializer's legacy
+  // branch sets `field` from the adapter and leaves `field_path` in place, and
+  // _create_rule_tree persists the whole validated dict. So a rule market saved
+  // comes back {field: 'contact.name', fieldPath: 'contact__name'} while its
+  // registry is still keyed 'contact__name'. Preferring `field` unconditionally
+  // would blank the picker on exactly those rows — and re-saving a blank row
+  // drops the rule. Try the canonical key first, fall back to the deprecated
+  // one, and only then give up (showing the canonical key, so the user sees
+  // which field the row names rather than an empty box).
+  const canonicalKey = rule.field || '';
+  const legacyKey = rule.fieldPath || '';
+  const entryFor = (key: string) =>
+    key ? fieldRegistry.find((f) => fieldKey(f) === key) : undefined;
+  const selectedRaw = entryFor(canonicalKey) ?? entryFor(legacyKey);
+  const selectedKey = selectedRaw ? fieldKey(selectedRaw) : ruleField(rule);
+  const selectedField = selectedRaw ? normalizeFieldDefinition(selectedRaw) : undefined;
 
   // Get valid operators for the selected field
-  const availableOperators = selectedField?.operators || [];
+  const availableOperators = selectedField?.allowedOperators || [];
 
   // Determine if value input is needed
   const needsValue = rule.operator && !NULL_VALUE_OPERATORS.includes(rule.operator);
@@ -79,11 +107,28 @@ export function RuleRow({
 
   // Handle field change
   const handleFieldChange = (fieldName: string) => {
-    const field = fieldRegistry.find((f) => f.name === fieldName);
+    const entry = fieldRegistry.find((f) => fieldKey(f) === fieldName);
+
+    // WHAT GOES ON THE WIRE depends on where the name came from.
+    //
+    // A registry entry carrying `key` came from GET …/funnels/fields/, so the
+    // name IS a resolver key and belongs in `field`. A hand-written entry
+    // carries only `name` — 'contact__name', 'tag:stage_focus:seed' — which the
+    // resolver registry does not know. Putting THAT in `field` would take the
+    // serializer's strict branch (`if attrs.get("field")`) and earn a 400;
+    // leaving `field` empty takes the legacy branch, which is what those names
+    // have always been translated by. `field: ''` is accepted on the wire:
+    // FunnelFilterRule.field is a blank=True CharField, so DRF gives it
+    // allow_blank=True, and '' is falsy in the branch that matters.
+    const isRegistryKey = Boolean(entry && entry.key);
+
     onChange({
       ...rule,
+      field: isRegistryKey ? fieldName : '',
+      // The deprecated mirror carries the name either way: it is what the
+      // legacy branch reads, and a canonical rule ignores it.
       fieldPath: fieldName,
-      operator: field?.operators[0] || ('' as Operator),
+      operator: (fieldOperators(entry ?? {})[0] as Operator) || ('' as Operator),
       value: null,
     });
   };
@@ -110,7 +155,8 @@ export function RuleRow({
     if (!needsValue) return null;
     if (!selectedField) return null;
 
-    const { type, constraints } = selectedField;
+    const { constraints } = selectedField;
+    const type = fieldValueType(selectedField);
 
     // Multi-value operators
     if (needsMultiValue) {
@@ -135,6 +181,23 @@ export function RuleRow({
 
     // Single-value operators
     switch (type) {
+      case 'enum':
+        if (constraints?.choices) {
+          return (
+            <ChoiceValueInput
+              value={rule.value || ''}
+              onChange={handleValueChange}
+              choices={constraints.choices}
+            />
+          );
+        }
+        return (
+          <TextValueInput
+            value={rule.value || ''}
+            onChange={handleValueChange}
+          />
+        );
+
       case 'string':
         if (constraints?.choices && rule.operator === 'eq') {
           return (
@@ -228,7 +291,7 @@ export function RuleRow({
       <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-3 pr-8">
         <FieldSelector
           fields={fieldRegistry}
-          value={rule.fieldPath}
+          value={selectedKey}
           onChange={handleFieldChange}
         />
 
@@ -236,7 +299,7 @@ export function RuleRow({
           operators={availableOperators}
           value={rule.operator || ''}
           onChange={handleOperatorChange}
-          disabled={!rule.fieldPath}
+          disabled={!selectedKey}
         />
 
         {needsValue && renderValueInput()}

package/src/components/FilterRuleEditor/constants.ts

@@ -16,6 +16,7 @@ export const OPERATOR_LABELS: Record<Operator, string> = {
   lt: 'less than',
   gte: 'greater or equal',
   lte: 'less or equal',
+  between: 'is between',
 
   // String operations
   contains: 'contains',
@@ -30,6 +31,10 @@ export const OPERATOR_LABELS: Record<Operator, string> = {
   has_any: 'has any of',
   has_all: 'has all of',
 
+  // Presence
+  exists: 'is set',
+  not_exists: 'is not set',
+
   // Null checks
   isnull: 'is empty',
   isnotnull: 'is not empty',
@@ -47,6 +52,8 @@ export const OPERATOR_LABELS: Record<Operator, string> = {
  * Operators that don't require a value input
  */
 export const NULL_VALUE_OPERATORS: Operator[] = [
+  'exists',
+  'not_exists',
   'isnull',
   'isnotnull',
   'is_true',
@@ -62,3 +69,8 @@ export const MULTI_VALUE_OPERATORS: Operator[] = [
   'has_any',
   'has_all',
 ];
+
+/**
+ * Operators whose value is a [min, max] pair.
+ */
+export const RANGE_OPERATORS: Operator[] = ['between'];