queryweave-derive 0.2.0

Derive macros generating filtering, sorting, paging and merge-patch types for a domain model and the layers mirroring it.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Every derive's generated code compiles and works when its runtime crate is
//! reached through another path, given by `#[queryweave(crate = path)]`: here,
//! modules re-exporting the runtime crates, as a crate wrapping `queryweave`
//! would.

#![allow(dead_code, clippy::option_option)]

use pretty_assertions::assert_eq;
use queryweave_derive::{
    AppendConditions, AppendToQuery, Columns, Filters, MergePatch, MergePatchNullableFields,
    RawValue, ValidateNonNullable,
};
use sqlx::{Postgres, QueryBuilder};
use validator::Validate;

/// The core runtime, re-exported.
mod core_runtime {
    pub use queryweave::*;
}

/// The API runtime (with the core), re-exported.
mod api_runtime {
    pub use queryweave_api::*;
}

/// The SQL runtime (with the core), re-exported.
mod sql_runtime {
    pub use queryweave_sql::*;
}

#[derive(Debug, Clone, PartialEq, RawValue)]
#[queryweave(crate = crate::core_runtime)]
struct Label<T = String>(T);

#[derive(Debug, Clone, PartialEq, Filters, MergePatch)]
#[queryweave(crate = crate::core_runtime)]
#[merge_patch(patch = MergePatchWidgetModel)]
struct WidgetModel {
    #[filter(sw)]
    #[sortable]
    label: Label<String>,

    note: Option<String>,
}

#[derive(Default, MergePatchNullableFields)]
#[queryweave(crate = crate::core_runtime)]
struct MergePatchWidgetModel {
    label: Option<Label<String>>,
    note: queryweave::Patch<String>,
}

#[derive(Debug, serde::Serialize, Filters)]
#[queryweave(crate = crate::api_runtime)]
#[filters(mirrors = WidgetModel, serde, utoipa, validator)]
struct WidgetDto {
    #[filter(sw)]
    #[sortable]
    label: String,
}

#[derive(Validate, ValidateNonNullable)]
#[queryweave(crate = crate::api_runtime)]
#[validate_non_nullable(mirrors = MergePatchWidgetModel, validator)]
struct MergePatchWidgetDto {
    label: queryweave::Patch<String>,
    note: queryweave::Patch<String>,
}

#[derive(Columns)]
#[queryweave(crate = crate::sql_runtime)]
#[columns(model = WidgetModel)]
struct Widget {
    label: String,
    note: Option<String>,
}

#[derive(Debug, AppendConditions)]
#[queryweave(crate = crate::sql_runtime)]
#[append_conditions(columns = Widget)]
struct WidgetsFilterOptionsModelWrapper(WidgetsFilterOptionsModel);

#[derive(Debug, AppendToQuery)]
#[queryweave(crate = crate::sql_runtime)]
#[append_to_query(columns = Widget, filters = WidgetsFilterOptionsModelWrapper)]
struct WidgetsQueryModelWrapper(WidgetsQueryModel);

type NoGuard = Option<fn(&mut QueryBuilder<'_, Postgres>, &WidgetsQueryModelWrapper)>;

// The mirror converts into the root model's query, which the wrappers write
// as SQL: every derive works through the re-exported runtimes.
#[test]
fn test_the_derives_work_through_re_exported_runtime_crates() {
    let query_params: WidgetsQueryParams = serde_json::from_value(serde_json::json!({
        "label_sw": "ab",
        "sort": [{ "field": "label", "order": "descending" }],
    }))
    .unwrap();
    let query: WidgetsQueryModel = query_params.into();

    let mut query_builder = QueryBuilder::<Postgres>::new("SELECT * FROM widgets ");
    WidgetsQueryModelWrapper(query).append_to_query(&mut query_builder, NoGuard::None);

    assert_eq!(
        query_builder.sql(),
        "SELECT * FROM widgets WHERE label LIKE $1 ESCAPE '!' ORDER BY label DESC "
    );
}

#[test]
fn test_merge_patching_works_through_re_exported_runtime_crates() {
    let mut widget = WidgetModel {
        label: Label(String::from("old")),
        note: Some(String::from("note")),
    };

    widget.merge(MergePatchWidgetModel {
        label: Some(Label(String::from("new"))),
        note: queryweave::Patch::Null,
    });

    assert_eq!(
        widget,
        WidgetModel {
            label: Label(String::from("new")),
            note: None,
        }
    );
    assert!(
        MergePatchWidgetDto {
            label: queryweave::Patch::Null,
            note: queryweave::Patch::Missing,
        }
        .validate_non_nullable()
        .is_err()
    );
}