davidl/tolaria
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: support relative date view filters

Browse Source
This commit is contained in:
lucaronin
2026-04-07 23:02:55 +02:00
parent b0b6a4f4cd
commit 037fd39c95
7 changed files with 335 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
src-tauri/src/vault/views.rs
View File

@@ -1,3 +1,4 @@
use chrono::{DateTime, Duration, Months, NaiveDate, NaiveDateTime, Utc};
use regex::RegexBuilder;
use serde::de::{self, MapAccess, Visitor};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -313,6 +314,82 @@ fn build_regex(pattern: &str) -> Option<regex::Regex> {
.ok()
}
fn parse_relative_amount(token: &str) -> Option<u32> {
match token {
"a" | "an" | "one" => Some(1),
"two" => Some(2),
"three" => Some(3),
"four" => Some(4),
"five" => Some(5),
"six" => Some(6),
"seven" => Some(7),
"eight" => Some(8),
"nine" => Some(9),
"ten" => Some(10),
"eleven" => Some(11),
"twelve" => Some(12),
_ => token.parse::<u32>().ok(),
}
}
fn parse_relative_date_filter(value: &str, reference: DateTime<Utc>) -> Option<DateTime<Utc>> {
let normalized = value.trim().to_lowercase();
if normalized.is_empty() {
return None;
}
let base = reference.date_naive().and_hms_opt(0, 0, 0)?.and_utc();
match normalized.as_str() {
"today" => return Some(base),
"yesterday" => return Some(base - Duration::days(1)),
"tomorrow" => return Some(base + Duration::days(1)),
_ => {}
}
let tokens: Vec<&str> = normalized.split_whitespace().collect();
let (future, amount_token, unit_token) = match tokens.as_slice() {
["in", amount, unit] => (true, *amount, *unit),
[amount, unit, "ago"] => (false, *amount, *unit),
_ => return None,
};
let amount = parse_relative_amount(amount_token)?;
let unit = unit_token.strip_suffix('s').unwrap_or(unit_token);
match (future, unit) {
(true, "day") => Some(base + Duration::days(amount as i64)),
(false, "day") => Some(base - Duration::days(amount as i64)),
(true, "week") => Some(base + Duration::weeks(amount as i64)),
(false, "week") => Some(base - Duration::weeks(amount as i64)),
(true, "month") => base.checked_add_months(Months::new(amount)),
(false, "month") => base.checked_sub_months(Months::new(amount)),
(true, "year") => base.checked_add_months(Months::new(amount * 12)),
(false, "year") => base.checked_sub_months(Months::new(amount * 12)),
_ => None,
}
}
fn parse_date_filter_timestamp(value: &str, reference: DateTime<Utc>) -> Option<i64> {
let trimmed = value.trim();
if trimmed.is_empty() {
return None;
}
if let Ok(date) = NaiveDate::parse_from_str(trimmed, "%Y-%m-%d") {
return Some(date.and_hms_opt(0, 0, 0)?.and_utc().timestamp_millis());
}
if let Ok(datetime) = NaiveDateTime::parse_from_str(trimmed, "%Y-%m-%dT%H:%M:%S") {
return Some(datetime.and_utc().timestamp_millis());
}
if let Ok(datetime) = DateTime::parse_from_rfc3339(trimmed) {
return Some(datetime.with_timezone(&Utc).timestamp_millis());
}
parse_relative_date_filter(trimmed, reference).map(|datetime| datetime.timestamp_millis())
}
fn supports_regex(op: &FilterOp) -> bool {
matches!(
op,
@@ -434,11 +511,23 @@ fn evaluate_condition(cond: &FilterCondition, entry: &VaultEntry) -> bool {
FilterOp::IsEmpty => field_value.as_deref().map_or(true, |s| s.is_empty()),
FilterOp::IsNotEmpty => field_value.as_deref().is_some_and(|s| !s.is_empty()),
FilterOp::Before => match (&field_value, &cond_value) {
(Some(f), Some(v)) => f < v,
(Some(f), Some(v)) => match (
parse_date_filter_timestamp(f, Utc::now()),
parse_date_filter_timestamp(v, Utc::now()),
) {
(Some(field_ts), Some(target_ts)) => field_ts < target_ts,
_ => false,
},
_ => false,
},
FilterOp::After => match (&field_value, &cond_value) {
(Some(f), Some(v)) => f > v,
(Some(f), Some(v)) => match (
parse_date_filter_timestamp(f, Utc::now()),
parse_date_filter_timestamp(v, Utc::now()),
) {
(Some(field_ts), Some(target_ts)) => field_ts > target_ts,
_ => false,
},
_ => false,
},
}
@@ -558,6 +647,7 @@ fn yaml_value_to_string_vec(v: &serde_yaml::Value) -> Option<Vec<String>> {
#[cfg(test)]
mod tests {
use super::*;
use chrono::TimeZone;
use std::collections::HashMap;
fn make_entry(overrides: impl FnOnce(&mut VaultEntry)) -> VaultEntry {
@@ -720,6 +810,28 @@ filters:
assert!(result.is_empty());
}
#[test]
fn test_parse_relative_date_filter_days_ago() {
let reference = Utc.with_ymd_and_hms(2026, 4, 7, 12, 0, 0).unwrap();
let parsed = parse_date_filter_timestamp("10 days ago", reference).unwrap();
let expected = Utc
.with_ymd_and_hms(2026, 3, 28, 0, 0, 0)
.unwrap()
.timestamp_millis();
assert_eq!(parsed, expected);
}
#[test]
fn test_parse_relative_date_filter_one_week_ago() {
let reference = Utc.with_ymd_and_hms(2026, 4, 7, 12, 0, 0).unwrap();
let parsed = parse_date_filter_timestamp("one week ago", reference).unwrap();
let expected = Utc
.with_ymd_and_hms(2026, 3, 31, 0, 0, 0)
.unwrap()
.timestamp_millis();
assert_eq!(parsed, expected);
}
#[test]
fn test_evaluate_nested_and_or() {
let yaml = r#"

25
src/components/FilterBuilder.test.tsx
View File

@@ -1,4 +1,4 @@
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import { render, screen, fireEvent } from '@testing-library/react'
import { FilterBuilder } from './FilterBuilder'
import type { FilterGroup } from '../types'
@@ -10,6 +10,10 @@ describe('FilterBuilder value inputs', () => {
vi.clearAllMocks()
})
afterEach(() => {
vi.useRealTimers()
})
function renderBuilder(group?: FilterGroup) {
const defaultGroup: FilterGroup = {
all: [{ field: 'title', op: 'contains', value: '' }],
@@ -97,10 +101,10 @@ describe('FilterBuilder value inputs', () => {
all: [{ field: 'created', op: 'before', value: '2024-06-01' }],
})
expect(screen.getByTestId('date-value-input')).toHaveValue('2024-06-01')
const dateButton = screen.getByTestId('date-picker-trigger')
expect(dateButton).toBeInTheDocument()
expect(dateButton).toHaveTextContent('Jun 1, 2024')
expect(screen.queryByDisplayValue('2024-06-01')).not.toBeInTheDocument()
expect(dateButton).toHaveAttribute('title', 'Jun 1, 2024')
})
it('renders date picker placeholder when no date is selected', () => {
@@ -108,10 +112,23 @@ describe('FilterBuilder value inputs', () => {
all: [{ field: 'created', op: 'after', value: '' }],
})
expect(screen.getByTestId('date-picker-trigger')).toHaveTextContent('Pick a date')
expect(screen.getByTestId('date-value-input')).toHaveValue('')
expect(screen.getByTestId('date-picker-trigger')).toHaveAttribute('title', 'Pick a date')
expect(screen.queryByTestId('filter-regex-toggle')).not.toBeInTheDocument()
})
it('allows free-text relative date phrases for date operators', () => {
vi.useFakeTimers()
vi.setSystemTime(new Date('2026-04-07T12:00:00Z'))
renderBuilder({
all: [{ field: 'created', op: 'after', value: '10 days ago' }],
})
expect(screen.getByTestId('date-value-input')).toHaveValue('10 days ago')
expect(screen.getByTestId('date-picker-trigger')).toHaveAttribute('title', 'Mar 28, 2026')
})
it('shows body field in field dropdown separated from property fields', () => {
render(
<FilterBuilder

56
src/components/FilterBuilder.tsx
View File

@@ -1,5 +1,5 @@
import { Plus, X, CalendarBlank, WarningCircle } from '@phosphor-icons/react'
import { format, parseISO } from 'date-fns'
import { format } from 'date-fns'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Calendar } from '@/components/ui/calendar'
@@ -7,6 +7,7 @@ import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover
import { Select, SelectContent, SelectItem, SelectSeparator, SelectTrigger, SelectValue } from '@/components/ui/select'
import { cn } from '@/lib/utils'
import type { FilterCondition, FilterOp, FilterGroup, FilterNode } from '../types'
import { parseDateFilterInput } from '../utils/filterDates'
const OPERATORS: { value: FilterOp; label: string }[] = [
{ value: 'equals', label: 'equals' },
@@ -116,28 +117,39 @@ function OperatorSelect({ value, onChange }: {
}
function DateValueInput({ value, onChange }: { value: string; onChange: (v: string) => void }) {
const parsed = value ? parseISO(value) : undefined
const selected = parsed && !isNaN(parsed.getTime()) ? parsed : undefined
const selected = value ? parseDateFilterInput(value) ?? undefined : undefined
return (
<Popover>
<PopoverTrigger asChild>
<Button
variant="outline"
data-testid="date-picker-trigger"
className="h-8 flex-1 min-w-0 justify-start gap-2 px-2 text-sm font-normal"
>
<CalendarBlank size={14} className="shrink-0 text-muted-foreground" />
{selected ? format(selected, 'MMM d, yyyy') : <span className="text-muted-foreground">Pick a date</span>}
</Button>
</PopoverTrigger>
<PopoverContent className="w-auto p-0" align="start">
<Calendar
mode="single"
selected={selected}
onSelect={(day) => onChange(day ? format(day, 'yyyy-MM-dd') : '')}
/>
</PopoverContent>
</Popover>
<div className="flex flex-1 min-w-0 items-center gap-1">
<Input
className="h-8 flex-1 min-w-0 text-sm"
placeholder='YYYY-MM-DD or "10 days ago"'
value={value}
onChange={(e) => onChange(e.target.value)}
data-testid="date-value-input"
/>
<Popover>
<PopoverTrigger asChild>
<Button
type="button"
variant="outline"
size="sm"
data-testid="date-picker-trigger"
className="h-8 w-8 shrink-0 px-0"
title={selected ? format(selected, 'MMM d, yyyy') : 'Pick a date'}
aria-label={selected ? `Open date picker (${format(selected, 'MMM d, yyyy')})` : 'Open date picker'}
>
<CalendarBlank size={14} className="shrink-0 text-muted-foreground" />
</Button>
</PopoverTrigger>
<PopoverContent className="w-auto p-0" align="start">
<Calendar
mode="single"
selected={selected}
onSelect={(day) => onChange(day ? format(day, 'yyyy-MM-dd') : '')}
/>
</PopoverContent>
</Popover>
</div>
)
}

37
src/utils/filterDates.test.ts Normal file
View File

@@ -0,0 +1,37 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
import { format } from 'date-fns'
import { parseDateFilterInput, toDateFilterTimestamp } from './filterDates'
describe('filterDates', () => {
afterEach(() => {
vi.useRealTimers()
})
it('parses absolute ISO dates', () => {
const parsed = parseDateFilterInput('2026-04-01')
expect(parsed && format(parsed, 'yyyy-MM-dd')).toBe('2026-04-01')
})
it('parses numeric relative day phrases', () => {
const reference = new Date('2026-04-07T12:00:00Z')
const parsed = parseDateFilterInput('10 days ago', reference)
expect(parsed && format(parsed, 'yyyy-MM-dd')).toBe('2026-03-28')
})
it('parses word-based relative week phrases', () => {
const reference = new Date('2026-04-07T12:00:00Z')
const parsed = parseDateFilterInput('one week ago', reference)
expect(parsed && format(parsed, 'yyyy-MM-dd')).toBe('2026-03-31')
})
it('returns null for unsupported date phrases', () => {
expect(parseDateFilterInput('eventually')).toBeNull()
})
it('converts parsed filter values into timestamps', () => {
const reference = new Date('2026-04-07T12:00:00Z')
const timestamp = toDateFilterTimestamp('yesterday', reference)
expect(timestamp).not.toBeNull()
expect(format(new Date(timestamp!), 'yyyy-MM-dd')).toBe('2026-04-06')
})
})

104
src/utils/filterDates.ts Normal file
View File

@@ -0,0 +1,104 @@
import {
addDays,
addMonths,
addWeeks,
addYears,
isValid,
parseISO,
startOfDay,
subDays,
subMonths,
subWeeks,
subYears,
} from 'date-fns'
type RelativeUnit = 'day' | 'week' | 'month' | 'year'
const NUMBER_WORDS: Record<string, number> = {
a: 1,
an: 1,
one: 1,
two: 2,
three: 3,
four: 4,
five: 5,
six: 6,
seven: 7,
eight: 8,
nine: 9,
ten: 10,
eleven: 11,
twelve: 12,
}
function parseRelativeAmount(token: string): number | null {
if (/^\d+$/.test(token)) return Number(token)
return NUMBER_WORDS[token] ?? null
}
function normalizeRelativeUnit(token: string): RelativeUnit | null {
const unit = token.toLowerCase().replace(/s$/, '')
if (unit === 'day' || unit === 'week' || unit === 'month' || unit === 'year') return unit
return null
}
function shiftRelativeDate(reference: Date, unit: RelativeUnit, amount: number, future: boolean): Date {
if (unit === 'day') return future ? addDays(reference, amount) : subDays(reference, amount)
if (unit === 'week') return future ? addWeeks(reference, amount) : subWeeks(reference, amount)
if (unit === 'month') return future ? addMonths(reference, amount) : subMonths(reference, amount)
return future ? addYears(reference, amount) : subYears(reference, amount)
}
function parseRelativeDateInput(value: string, reference: Date): Date | null {
const normalized = value.trim().toLowerCase()
if (!normalized) return null
const base = startOfDay(reference)
if (normalized === 'today') return base
if (normalized === 'yesterday') return subDays(base, 1)
if (normalized === 'tomorrow') return addDays(base, 1)
const tokens = normalized.split(/\s+/)
let future = false
let amountToken = ''
let unitToken = ''
if (tokens.length === 3 && tokens[0] === 'in') {
future = true
amountToken = tokens[1]
unitToken = tokens[2]
} else if (tokens.length === 3 && tokens[2] === 'ago') {
amountToken = tokens[0]
unitToken = tokens[1]
} else {
return null
}
const amount = parseRelativeAmount(amountToken)
const unit = normalizeRelativeUnit(unitToken)
if (amount == null || unit == null) return null
return shiftRelativeDate(base, unit, amount, future)
}
export function parseDateFilterInput(value: string, reference = new Date()): Date | null {
const trimmed = value.trim()
if (!trimmed) return null
const relative = parseRelativeDateInput(trimmed, reference)
if (relative) return relative
if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
const parsed = parseISO(trimmed)
return isValid(parsed) ? parsed : null
}
const timestamp = Date.parse(trimmed)
if (Number.isNaN(timestamp)) return null
return new Date(timestamp)
}
export function toDateFilterTimestamp(value: string, reference = new Date()): number | null {
const parsed = parseDateFilterInput(value, reference)
return parsed ? parsed.getTime() : null
}

22
src/utils/viewFilters.test.ts
View File

@@ -1,4 +1,4 @@
import { describe, it, expect } from 'vitest'
import { afterEach, describe, it, expect, vi } from 'vitest'
import { evaluateView } from './viewFilters'
import type { VaultEntry, ViewDefinition } from '../types'
@@ -19,6 +19,10 @@ function makeEntry(overrides: Partial<VaultEntry>): VaultEntry {
}
describe('evaluateView', () => {
afterEach(() => {
vi.useRealTimers()
})
it('filters by type equals', () => {
const view: ViewDefinition = {
name: 'Projects', icon: null, color: null, sort: null,
@@ -244,6 +248,22 @@ describe('evaluateView', () => {
expect(result.map((e) => e.title)).toEqual(['Match'])
})
it('before/after accept natural-language relative date phrases', () => {
vi.useFakeTimers()
vi.setSystemTime(new Date('2026-04-07T12:00:00Z'))
const view: ViewDefinition = {
name: 'Recent', icon: null, color: null, sort: null,
filters: { all: [{ field: 'Date', op: 'after', value: '10 days ago' }] },
}
const entries = [
makeEntry({ title: 'Older', properties: { Date: '2026-03-20' } }),
makeEntry({ title: 'Recent', properties: { Date: '2026-03-30' } }),
]
const result = evaluateView(view, entries)
expect(result.map((e) => e.title)).toEqual(['Recent'])
})
it('body contains filters on snippet text (case-insensitive)', () => {
const view: ViewDefinition = {
name: 'Body search', icon: null, color: null, sort: null,

8
src/utils/viewFilters.ts
View File

@@ -1,4 +1,5 @@
import type { VaultEntry, ViewDefinition, FilterGroup, FilterNode, FilterCondition } from '../types'
import { toDateFilterTimestamp } from './filterDates'
/** Evaluate a view's filters against a list of entries, returning only matches. */
export function evaluateView(definition: ViewDefinition, entries: VaultEntry[]): VaultEntry[] {
@@ -169,12 +170,11 @@ function evaluateCondition(cond: FilterCondition, entry: VaultEntry): boolean {
if (typeof resolved.scalar === 'number') {
tsMs = resolved.scalar * 1000 // Unix timestamp (seconds) → milliseconds
} else if (typeof resolved.scalar === 'string') {
const parsed = Date.parse(resolved.scalar)
tsMs = isNaN(parsed) ? null : parsed
tsMs = toDateFilterTimestamp(resolved.scalar)
}
if (tsMs == null) return false
const target = Date.parse(condVal)
if (isNaN(target)) return false
const target = toDateFilterTimestamp(condVal)
if (target == null) return false
return op === 'before' ? tsMs < target : tsMs > target
}