Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

24.3 KB
Raw Blame
use chrono::{TimeZone, Utc};
use models_databases::ColumnId;
use models_databases::views::{
    Conjunction, DatabaseView, DateOperator, FilterCondition, FilterGroup, FilterNode, FilterTest,
    NumberOperator, PresenceOperator, SetOperator, SortDirection, SortKey, TextOperator, ValueKind,
    ViewLayout, ViewProblem, ViewQuery,
};

use super::*;
use crate::catalog::TableSource;
use crate::resolve::{
    Binding, ComparisonOperator, Direction, Filter, Order, OrderKey, Relation, SelectItem, Value,
    row_position_key,
};
use crate::test_support::*;

const SAM: &str = "macro|[email protected]";
const ANA: &str = "macro|[email protected]";

#[test]
fn a_nested_view_is_the_select_its_sql_resolves_to() {
    let view = DatabaseView {
        id: ISSUES_VIEW,
        database_id: WORK,
        table_id: ISSUES,
        name: "Open work".into(),
        position: "80".parse().unwrap(),
        query: ViewQuery {
            filter: Some(FilterGroup {
                conjunction: Conjunction::And,
                conditions: vec![
                    FilterNode::Condition(FilterCondition {
                        column: SUMMARY_PLACEMENT,
                        test: FilterTest::Text {
                            operator: TextOperator::Contains,
                            value: "50%_off\\".into(),
                        },
                    }),
                    FilterNode::Group(FilterGroup {
                        conjunction: Conjunction::Or,
                        conditions: vec![
                            FilterNode::Condition(FilterCondition {
                                column: STATUS_PLACEMENT,
                                test: FilterTest::Options {
                                    operator: SetOperator::IsNoneOf,
                                    options: vec![WONT_DO],
                                },
                            }),
                            FilterNode::Condition(FilterCondition {
                                column: POINTS_PLACEMENT,
                                test: FilterTest::Number {
                                    operator: NumberOperator::GreaterThan,
                                    value: 3.0,
                                },
                            }),
                        ],
                    }),
                ],
            }),
            sort: vec![
                SortKey {
                    column: DUE_PLACEMENT,
                    direction: SortDirection::Descending,
                },
                SortKey {
                    column: SUMMARY_PLACEMENT,
                    direction: SortDirection::Ascending,
                },
            ],
        },
        layout: ViewLayout::Table { columns: vec![] },
        created_at: Utc.with_ymd_and_hms(2026, 9, 1, 0, 0, 0).unwrap(),
        updated_at: Utc.with_ymd_and_hms(2026, 9, 1, 0, 0, 0).unwrap(),
    };

    let expected = SelectQuery {
        distinct: false,
        relations: vec![Relation {
            table: ISSUES,
            alias: "issues".into(),
            source: TableSource::Database,
        }],
        joins: vec![],
        items: vec![
            SelectItem::Column(SUMMARY),
            SelectItem::Column(POINTS),
            SelectItem::Column(STATUS),
            SelectItem::Column(DUE),
            SelectItem::Column(BLOCKED),
            SelectItem::Column(LABELS),
            SelectItem::Column(ASSIGNEE),
            SelectItem::Column(REVIEWERS),
            SelectItem::Column(SPEC),
            SelectItem::Column(PARENT),
        ],
        labels: vec![],
        where_: Some(Filter::And(vec![
            Filter::Like {
                column: SUMMARY,
                pattern: "%50\\%\\_off\\\\%".into(),
                escape: Some('\\'),
                negated: false,
            },
            Filter::Or(vec![
                Filter::Or(vec![
                    Filter::In {
                        column: STATUS,
                        values: vec![Value::Option(WONT_DO)],
                        negated: true,
                    },
                    Filter::IsNull {
                        column: STATUS,
                        negated: false,
                    },
                ]),
                Filter::Comparison {
                    column: POINTS,
                    operator: ComparisonOperator::Greater,
                    value: Value::Number(3.0),
                },
            ]),
        ])),
        group_by: None,
        order_by: vec![
            Order {
                key: OrderKey::Column(DUE),
                direction: Direction::Descending,
            },
            Order {
                key: OrderKey::Column(SUMMARY),
                direction: Direction::Ascending,
            },
            Order {
                key: OrderKey::Column(row_position_key(ISSUES)),
                direction: Direction::Ascending,
            },
        ],
        limit: None,
        offset: None,
        bindings: vec![
            Binding {
                key: SUMMARY,
                relation: 0,
                column: Some(SUMMARY),
            },
            Binding {
                key: POINTS,
                relation: 0,
                column: Some(POINTS),
            },
            Binding {
                key: STATUS,
                relation: 0,
                column: Some(STATUS),
            },
            Binding {
                key: DUE,
                relation: 0,
                column: Some(DUE),
            },
            Binding {
                key: BLOCKED,
                relation: 0,
                column: Some(BLOCKED),
            },
            Binding {
                key: LABELS,
                relation: 0,
                column: Some(LABELS),
            },
            Binding {
                key: ASSIGNEE,
                relation: 0,
                column: Some(ASSIGNEE),
            },
            Binding {
                key: REVIEWERS,
                relation: 0,
                column: Some(REVIEWERS),
            },
            Binding {
                key: SPEC,
                relation: 0,
                column: Some(SPEC),
            },
            Binding {
                key: PARENT,
                relation: 0,
                column: Some(PARENT),
            },
            Binding {
                key: row_position_key(ISSUES),
                relation: 0,
                column: None,
            },
        ],
    };

    assert_eq!(compile_view(&view, &issues_catalog()), Ok(expected.clone()));
    assert_eq!(
        compile_table_query(ISSUES, &view.query, &issues_catalog()),
        Ok(expected)
    );
}

#[test]
fn every_test_compiles_to_its_filter() {
    let due = Utc.with_ymd_and_hms(2026, 10, 1, 9, 30, 0).unwrap();
    let cases: Vec<(ColumnId, FilterTest, Filter)> = vec![
        (
            DUE_PLACEMENT,
            FilterTest::Presence {
                operator: PresenceOperator::IsEmpty,
            },
            Filter::IsNull {
                column: DUE,
                negated: false,
            },
        ),
        (
            LABELS_PLACEMENT,
            FilterTest::Presence {
                operator: PresenceOperator::IsNotEmpty,
            },
            Filter::IsNull {
                column: LABELS,
                negated: true,
            },
        ),
        (
            SUMMARY_PLACEMENT,
            FilterTest::Text {
                operator: TextOperator::Is,
                value: "Ship it".into(),
            },
            Filter::Comparison {
                column: SUMMARY,
                operator: ComparisonOperator::Equal,
                value: Value::Text("Ship it".into()),
            },
        ),
        (
            SUMMARY_PLACEMENT,
            FilterTest::Text {
                operator: TextOperator::IsNot,
                value: "Ship it".into(),
            },
            Filter::Or(vec![
                Filter::Comparison {
                    column: SUMMARY,
                    operator: ComparisonOperator::NotEqual,
                    value: Value::Text("Ship it".into()),
                },
                Filter::IsNull {
                    column: SUMMARY,
                    negated: false,
                },
            ]),
        ),
        (
            SUMMARY_PLACEMENT,
            FilterTest::Text {
                operator: TextOperator::Contains,
                value: "login".into(),
            },
            Filter::Like {
                column: SUMMARY,
                pattern: "%login%".into(),
                escape: Some('\\'),
                negated: false,
            },
        ),
        (
            SUMMARY_PLACEMENT,
            FilterTest::Text {
                operator: TextOperator::DoesNotContain,
                value: "login".into(),
            },
            Filter::Or(vec![
                Filter::Like {
                    column: SUMMARY,
                    pattern: "%login%".into(),
                    escape: Some('\\'),
                    negated: true,
                },
                Filter::IsNull {
                    column: SUMMARY,
                    negated: false,
                },
            ]),
        ),
        (
            SPEC_PLACEMENT,
            FilterTest::Text {
                operator: TextOperator::StartsWith,
                value: "https://".into(),
            },
            Filter::Like {
                column: SPEC,
                pattern: "https://%".into(),
                escape: Some('\\'),
                negated: false,
            },
        ),
        (
            SUMMARY_PLACEMENT,
            FilterTest::Text {
                operator: TextOperator::EndsWith,
                value: "100%".into(),
            },
            Filter::Like {
                column: SUMMARY,
                pattern: "%100\\%".into(),
                escape: Some('\\'),
                negated: false,
            },
        ),
        (
            POINTS_PLACEMENT,
            FilterTest::Number {
                operator: NumberOperator::Is,
                value: 5.0,
            },
            Filter::Comparison {
                column: POINTS,
                operator: ComparisonOperator::Equal,
                value: Value::Number(5.0),
            },
        ),
        (
            POINTS_PLACEMENT,
            FilterTest::Number {
                operator: NumberOperator::IsNot,
                value: 5.0,
            },
            Filter::Or(vec![
                Filter::Comparison {
                    column: POINTS,
                    operator: ComparisonOperator::NotEqual,
                    value: Value::Number(5.0),
                },
                Filter::IsNull {
                    column: POINTS,
                    negated: false,
                },
            ]),
        ),
        (
            POINTS_PLACEMENT,
            FilterTest::Number {
                operator: NumberOperator::GreaterThan,
                value: -1.5,
            },
            Filter::Comparison {
                column: POINTS,
                operator: ComparisonOperator::Greater,
                value: Value::Number(-1.5),
            },
        ),
        (
            POINTS_PLACEMENT,
            FilterTest::Number {
                operator: NumberOperator::GreaterThanOrEqual,
                value: 2.0,
            },
            Filter::Comparison {
                column: POINTS,
                operator: ComparisonOperator::GreaterOrEqual,
                value: Value::Number(2.0),
            },
        ),
        (
            POINTS_PLACEMENT,
            FilterTest::Number {
                operator: NumberOperator::LessThan,
                value: 8.0,
            },
            Filter::Comparison {
                column: POINTS,
                operator: ComparisonOperator::Less,
                value: Value::Number(8.0),
            },
        ),
        (
            POINTS_PLACEMENT,
            FilterTest::Number {
                operator: NumberOperator::LessThanOrEqual,
                value: 8.0,
            },
            Filter::Comparison {
                column: POINTS,
                operator: ComparisonOperator::LessOrEqual,
                value: Value::Number(8.0),
            },
        ),
        (
            DUE_PLACEMENT,
            FilterTest::Date {
                operator: DateOperator::Before,
                value: due,
            },
            Filter::Comparison {
                column: DUE,
                operator: ComparisonOperator::Less,
                value: Value::Date(due),
            },
        ),
        (
            DUE_PLACEMENT,
            FilterTest::Date {
                operator: DateOperator::After,
                value: due,
            },
            Filter::Comparison {
                column: DUE,
                operator: ComparisonOperator::Greater,
                value: Value::Date(due),
            },
        ),
        (
            DUE_PLACEMENT,
            FilterTest::Date {
                operator: DateOperator::OnOrBefore,
                value: due,
            },
            Filter::Comparison {
                column: DUE,
                operator: ComparisonOperator::LessOrEqual,
                value: Value::Date(due),
            },
        ),
        (
            DUE_PLACEMENT,
            FilterTest::Date {
                operator: DateOperator::OnOrAfter,
                value: due,
            },
            Filter::Comparison {
                column: DUE,
                operator: ComparisonOperator::GreaterOrEqual,
                value: Value::Date(due),
            },
        ),
        (
            BLOCKED_PLACEMENT,
            FilterTest::Checkbox { checked: true },
            Filter::Comparison {
                column: BLOCKED,
                operator: ComparisonOperator::Equal,
                value: Value::Bool(true),
            },
        ),
        (
            BLOCKED_PLACEMENT,
            FilterTest::Checkbox { checked: false },
            Filter::Or(vec![
                Filter::Comparison {
                    column: BLOCKED,
                    operator: ComparisonOperator::Equal,
                    value: Value::Bool(false),
                },
                Filter::IsNull {
                    column: BLOCKED,
                    negated: false,
                },
            ]),
        ),
        (
            STATUS_PLACEMENT,
            FilterTest::Options {
                operator: SetOperator::IsAnyOf,
                options: vec![TODO, DOING],
            },
            Filter::In {
                column: STATUS,
                values: vec![Value::Option(TODO), Value::Option(DOING)],
                negated: false,
            },
        ),
        (
            STATUS_PLACEMENT,
            FilterTest::Options {
                operator: SetOperator::IsNoneOf,
                options: vec![TODO, DOING],
            },
            Filter::Or(vec![
                Filter::In {
                    column: STATUS,
                    values: vec![Value::Option(TODO), Value::Option(DOING)],
                    negated: true,
                },
                Filter::IsNull {
                    column: STATUS,
                    negated: false,
                },
            ]),
        ),
        (
            LABELS_PLACEMENT,
            FilterTest::Options {
                operator: SetOperator::HasAny,
                options: vec![BUG],
            },
            Filter::Has {
                column: LABELS,
                value: Value::Option(BUG),
                negated: false,
            },
        ),
        (
            LABELS_PLACEMENT,
            FilterTest::Options {
                operator: SetOperator::HasAny,
                options: vec![BUG, FEATURE],
            },
            Filter::Or(vec![
                Filter::Has {
                    column: LABELS,
                    value: Value::Option(BUG),
                    negated: false,
                },
                Filter::Has {
                    column: LABELS,
                    value: Value::Option(FEATURE),
                    negated: false,
                },
            ]),
        ),
        (
            LABELS_PLACEMENT,
            FilterTest::Options {
                operator: SetOperator::HasAll,
                options: vec![BUG, FEATURE],
            },
            Filter::And(vec![
                Filter::Has {
                    column: LABELS,
                    value: Value::Option(BUG),
                    negated: false,
                },
                Filter::Has {
                    column: LABELS,
                    value: Value::Option(FEATURE),
                    negated: false,
                },
            ]),
        ),
        (
            LABELS_PLACEMENT,
            FilterTest::Options {
                operator: SetOperator::HasNone,
                options: vec![BUG, FEATURE],
            },
            Filter::And(vec![
                Filter::Has {
                    column: LABELS,
                    value: Value::Option(BUG),
                    negated: true,
                },
                Filter::Has {
                    column: LABELS,
                    value: Value::Option(FEATURE),
                    negated: true,
                },
            ]),
        ),
        (
            ASSIGNEE_PLACEMENT,
            FilterTest::Entities {
                operator: SetOperator::IsAnyOf,
                entities: vec![SAM.into()],
            },
            Filter::In {
                column: ASSIGNEE,
                values: vec![Value::Entity(SAM.into())],
                negated: false,
            },
        ),
        (
            PARENT_PLACEMENT,
            FilterTest::Entities {
                operator: SetOperator::IsNoneOf,
                entities: vec!["00000000-0000-0000-0000-000000000101".into()],
            },
            Filter::Or(vec![
                Filter::In {
                    column: PARENT,
                    values: vec![Value::Entity("00000000-0000-0000-0000-000000000101".into())],
                    negated: true,
                },
                Filter::IsNull {
                    column: PARENT,
                    negated: false,
                },
            ]),
        ),
        (
            REVIEWERS_PLACEMENT,
            FilterTest::Entities {
                operator: SetOperator::HasAny,
                entities: vec![SAM.into(), ANA.into()],
            },
            Filter::Or(vec![
                Filter::Has {
                    column: REVIEWERS,
                    value: Value::Entity(SAM.into()),
                    negated: false,
                },
                Filter::Has {
                    column: REVIEWERS,
                    value: Value::Entity(ANA.into()),
                    negated: false,
                },
            ]),
        ),
        (
            REVIEWERS_PLACEMENT,
            FilterTest::Entities {
                operator: SetOperator::HasAll,
                entities: vec![SAM.into()],
            },
            Filter::Has {
                column: REVIEWERS,
                value: Value::Entity(SAM.into()),
                negated: false,
            },
        ),
        (
            REVIEWERS_PLACEMENT,
            FilterTest::Entities {
                operator: SetOperator::HasNone,
                entities: vec![SAM.into()],
            },
            Filter::Has {
                column: REVIEWERS,
                value: Value::Entity(SAM.into()),
                negated: true,
            },
        ),
    ];

    for (column, test, expected) in cases {
        let compiled = compile_view(
            &issues_view(
                ViewQuery {
                    filter: Some(FilterGroup {
                        conjunction: Conjunction::And,
                        conditions: vec![FilterNode::Condition(FilterCondition {
                            column,
                            test: test.clone(),
                        })],
                    }),
                    sort: vec![],
                },
                ViewLayout::Table { columns: vec![] },
            ),
            &issues_catalog(),
        )
        .unwrap();
        assert_eq!(compiled.where_, Some(expected), "{test:?}");
    }
}

#[test]
fn groups_collapse_and_empty_groups_keep_every_row() {
    let blocked = FilterNode::Condition(FilterCondition {
        column: BLOCKED_PLACEMENT,
        test: FilterTest::Checkbox { checked: true },
    });
    let blocked_filter = Filter::Comparison {
        column: BLOCKED,
        operator: ComparisonOperator::Equal,
        value: Value::Bool(true),
    };
    let empty = |conjunction| FilterGroup {
        conjunction,
        conditions: vec![],
    };
    let cases: Vec<(&str, Option<FilterGroup>, Option<Filter>)> = vec![
        ("no filter", None, None),
        ("an empty group", Some(empty(Conjunction::And)), None),
        (
            "one condition, either conjunction",
            Some(FilterGroup {
                conjunction: Conjunction::Or,
                conditions: vec![blocked.clone()],
            }),
            Some(blocked_filter.clone()),
        ),
        (
            "a group holding one group holding one condition",
            Some(FilterGroup {
                conjunction: Conjunction::And,
                conditions: vec![FilterNode::Group(FilterGroup {
                    conjunction: Conjunction::Or,
                    conditions: vec![blocked.clone()],
                })],
            }),
            Some(blocked_filter.clone()),
        ),
        (
            "an empty group under AND asks nothing more",
            Some(FilterGroup {
                conjunction: Conjunction::And,
                conditions: vec![blocked.clone(), FilterNode::Group(empty(Conjunction::Or))],
            }),
            Some(blocked_filter.clone()),
        ),
        (
            "an empty group under OR lets every row through",
            Some(FilterGroup {
                conjunction: Conjunction::Or,
                conditions: vec![blocked.clone(), FilterNode::Group(empty(Conjunction::And))],
            }),
            None,
        ),
    ];

    for (case, filter, expected) in cases {
        let compiled = compile_view(
            &issues_view(
                ViewQuery {
                    filter,
                    sort: vec![],
                },
                ViewLayout::Table { columns: vec![] },
            ),
            &issues_catalog(),
        )
        .unwrap();
        assert_eq!(compiled.where_, expected, "{case}");
    }
}

#[test]
fn an_unsorted_view_keeps_the_table_order() {
    let compiled = compile_view(
        &issues_view(ViewQuery::default(), ViewLayout::Table { columns: vec![] }),
        &issues_catalog(),
    )
    .unwrap();

    assert_eq!(
        compiled.order_by,
        vec![Order {
            key: OrderKey::Column(row_position_key(ISSUES)),
            direction: Direction::Ascending,
        }]
    );
}

#[test]
fn a_view_that_does_not_fit_its_table_is_refused() {
    let in_another_table = DatabaseView {
        table_id: DEALS,
        ..issues_view(ViewQuery::default(), ViewLayout::Table { columns: vec![] })
    };
    assert_eq!(
        compile_view(&in_another_table, &issues_catalog()),
        Err(ViewProblem::UnknownTable { table: DEALS })
    );

    let by_definition = issues_view(
        ViewQuery {
            filter: None,
            sort: vec![SortKey {
                column: ColumnId::from_uuid(SUMMARY),
                direction: SortDirection::Ascending,
            }],
        },
        ViewLayout::Table { columns: vec![] },
    );
    assert_eq!(
        compile_view(&by_definition, &issues_catalog()),
        Err(ViewProblem::UnknownColumn {
            column: ColumnId::from_uuid(SUMMARY)
        })
    );

    let misfit = issues_view(
        ViewQuery {
            filter: Some(FilterGroup {
                conjunction: Conjunction::And,
                conditions: vec![FilterNode::Condition(FilterCondition {
                    column: POINTS_PLACEMENT,
                    test: FilterTest::Text {
                        operator: TextOperator::Is,
                        value: "5".into(),
                    },
                })],
            }),
            sort: vec![],
        },
        ViewLayout::Table { columns: vec![] },
    );
    assert_eq!(
        compile_view(&misfit, &issues_catalog()),
        Err(ViewProblem::TestDoesNotFit {
            column: "points".into(),
            holds: ValueKind::Number,
            test: ValueKind::Text,
        })
    );
}