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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

use indoc::indoc;

/// All types Prisma supports on a composite.
/// Allows for simple picking of whatever should be tested from a single model.
pub fn all_composite_types() -> String {
    let schema = indoc! {
        r#"model TestModel {
            #id(id, Int, @id)
            allOptional AllOptional?
            allRequired AllRequired?
            allLists    AllLists?
        }

        enum TestEnum {
            Foo
            Bar
        }

        type AllRequired {
            str   String
            bool  Boolean
            int   Int
            bInt  BigInt
            float Float
            dt    DateTime
            json  Json
            bytes Bytes
            enum  TestEnum
        }

        type AllOptional {
            str   String?
            bool  Boolean?
            int   Int?
            bInt  BigInt?
            float Float?
            dt    DateTime?
            json  Json?
            bytes Bytes?
            enum  TestEnum?
        }

        type AllLists {
            str String[]
            bool  Boolean[]
            int   Int[]
            bInt  BigInt[]
            float Float[]
            dt    DateTime[]
            json  Json[]
            bytes Bytes[]
            enum  TestEnum[]
        }
        "#
    };

    schema.to_owned()
}

/// Full to-one composite test model.
pub fn to_one_composites() -> String {
    let schema = indoc! {
        r#"model TestModel {
            #id(id, Int, @id)
            field String?
            a     A       @map("top_a")
            b     B?
        }

        type A {
            a_1 String @default("a_1 default") @map("a1")
            a_2 Int?
            b   B @map("nested_b")
        }

        type B {
            b_field String @default("b_field default")
            c C @map("nested_c")
        }

        type C {
            c_field String @default("c_field default")
            c_opt   String?
            b B?
        }
        "#
    };

    schema.to_owned()
}

/// Full to-many composite test model.
pub fn to_many_composites() -> String {
    let schema = indoc! {
        r#"model TestModel {
            #id(id, Int, @id)
            field String?
            to_many_as CompositeA[] @map("top_a")
            to_one_b   CompositeB?
        }

        type CompositeA {
            a_1          String       @default("a_1 default") @map("a1")
            a_2          Int?
            a_to_one_b   CompositeB?
            a_to_many_bs CompositeB[]
        }

        type CompositeB {
            b_field      Int?         @default(10)
            b_to_one_c   CompositeC?
            b_to_many_cs CompositeC[]
        }

        type CompositeC {
          c_field Int @default(10)

          // Mostly here to test ordering multiple nested selection sets.
          c_to_many_as CompositeA[]
        }
        "#
    };

    schema.to_owned()
}

/// Composites and relations mixed.
pub fn mixed_composites() -> String {
    let schema = indoc! {
        r#"model TestModel {
            #id(id, Int, @id)
            field        String?
            to_one_com   CompositeA?  @map("to_one_composite")
            to_many_com  CompositeB[] @map("to_many_composite")

            to_one_rel_id Int? @unique
            to_one_rel    RelatedModel? @relation(name: "ToOne", fields: [to_one_rel_id], references: [id])

            #m2m(to_many_rel, RelatedModel[], id, Int, ToMany)
        }

        type CompositeA {
            a_1              String       @default("a_1 default") @map("a1")
            a_2              Int?
            a_to_other_com   CompositeC?
            other_composites CompositeB[]
            scalar_list      String[]
        }

        type CompositeB {
            b_field       String       @default("b_field default")
            to_other_com  CompositeC?  @map("nested_c")
            to_other_coms CompositeC[]
            scalar_list   String[]
        }

        type CompositeC {
          c_field     String @default("c_field default")
          scalar_list String[]
        }

        model RelatedModel {
            #id(id, Int, @id)

            to_one_com   CompositeA?  @map("to_one_composite")
            to_many_com  CompositeB[] @map("to_many_composite")

            test_model TestModel? @relation(name: "ToOne")
            #m2m(many_test_model, TestModel[], id, Int, ToMany)
        }

        "#
    };

    schema.to_owned()
}