@@ -6,11 +6,10 @@ import Control.Monad.Error.Class (throwError)
66import Data.Array as Array
77import Data.Maybe (Maybe(..), isNothing)
88import Effect.Aff (Aff)
9−import Effect.Class (liftEffect)
10−import Effect.Exception (error)
9+import Effect.Class (class MonadEffect, liftEffect)
10+import Effect.Exception as Exception
1111import Foreign (MultipleErrors)
1212import Test.Spec (Spec, describe, it)
13−import Test.Spec.Assertions (shouldEqual)
1413import Type.Function (type (#))
1514import Type.Proxy (Proxy(..))
1615import Yoga.Om as Om
@@ -32,422 +31,400 @@ import Yoga.Postgres.ClientOm
3231 , gt, gte, ilike, inArray, join, like_, lt, lte
3332 , maxOf, minOf, minOfWhere, ne, not_, or_
3433 , selectFrom, selectFromWhere, selectOneFrom, selectOneFromWhere
35− , sumOf, sumOfWhere, updateWhere, upsert, upsertMany, withTransaction
34+ , sumOf, sumOfWhere, transactionally, updateWhere, upsert, upsertMany
3635 )
37−import Yoga.Postgres.Schema (Table, PrimaryKey, AutoIncrement, Unique, Default, DefaultExpr, ForeignKey, References, PGUUID)
36+import Yoga.Postgres.Schema (Table, PrimaryKey, AutoIncrement, Unique, Default, ForeignKey, References, PGUUID)
3837
3938spec :: Spec Unit
4039spec = describe "ClientOm" do
4140
4241 describe "Creating records" do
43− it "inserts a record and returns it with generated fields" $ withUsersTable \conn -> do
44− created <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
42+ it "inserts a record and returns it with generated fields" $ withUsersTable do
43+ created <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
4544 alice <- shouldBeJust created
4645 alice.name `shouldEqual` "Alice"
4746 (alice.id > 0) `shouldEqual` true
4847
49− it "lets the database fill in defaults" $ withUsersTable \conn -> do
50− created <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
48+ it "lets the database fill in defaults" $ withUsersTable do
49+ created <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
5150 alice <- shouldBeJust created
5251 alice.active `shouldEqual` true
5352
54− it "inserts many records at once" $ withUsersTable \conn -> do
53+ it "inserts many records at once" $ withUsersTable do
5554 let noUsers = [] :: Array { name :: String, email :: String, role :: String }
56− empty <- conn # run do usersTable # createMany noUsers
55+ empty <- usersTable # createMany noUsers
5756 Array.length empty `shouldEqual` 0
58− users <- conn # run do
59− usersTable # createMany
60− [ { name: "Alice", email: "a@t.com", role: "admin" }
61− , { name: "Bob", email: "b@t.com", role: "user" }
62− , { name: "Carol", email: "c@t.com", role: "user" }
63− ]
57+ users <- usersTable # createMany
58+ [ { name: "Alice", email: "a@t.com", role: "admin" }
59+ , { name: "Bob", email: "b@t.com", role: "user" }
60+ , { name: "Carol", email: "c@t.com", role: "user" }
61+ ]
6462 Array.length users `shouldEqual` 3
65− n <- conn # runNoErr do usersTable # count
63+ n <- usersTable # count
6664 n `shouldEqual` 3
6765
68− it "skips insert when a conflict would occur" $ withSettingsTable \conn -> do
69− inserted <- conn # run do settingsTable # createIfNotExists { key: "theme", value: "dark" }
66+ it "skips insert when a conflict would occur" $ withSettingsTable do
67+ inserted <- settingsTable # createIfNotExists { key: "theme", value: "dark" }
7068 r1 <- shouldBeJust inserted
7169 r1.value `shouldEqual` "dark"
72− skipped <- conn # run do settingsTable # createIfNotExists { key: "theme", value: "light" }
70+ skipped <- settingsTable # createIfNotExists { key: "theme", value: "light" }
7371 isNothing skipped `shouldEqual` true
74− found <- conn # run do settingsTable # findOneBy @"key" "theme"
72+ found <- settingsTable # findOneBy @"key" "theme"
7573 existing <- shouldBeJust found
7674 existing.value `shouldEqual` "dark"
7775
78− it "upserts: inserts or updates on conflict" $ withSettingsTable \conn -> do
79− inserted <- conn # run do settingsTable # upsert { key: "theme", value: "dark" }
76+ it "upserts: inserts or updates on conflict" $ withSettingsTable do
77+ inserted <- settingsTable # upsert { key: "theme", value: "dark" }
8078 r1 <- shouldBeJust inserted
8179 r1.value `shouldEqual` "dark"
82− updated <- conn # run do settingsTable # upsert { key: "theme", value: "light" }
80+ updated <- settingsTable # upsert { key: "theme", value: "light" }
8381 r2 <- shouldBeJust updated
8482 r2.value `shouldEqual` "light"
85− n <- conn # runNoErr do settingsTable # count
83+ n <- settingsTable # count
8684 n `shouldEqual` 1
8785
88− it "bulk upserts a batch" $ withSettingsTable \conn -> do
89− _ <- conn # run do
90− settingsTable # upsertMany
91− [ { key: "theme", value: "dark" }
92− , { key: "lang", value: "en" }
93− ]
94− n1 <- conn # runNoErr do settingsTable # count
86+ it "bulk upserts a batch" $ withSettingsTable do
87+ _ <- settingsTable # upsertMany
88+ [ { key: "theme", value: "dark" }
89+ , { key: "lang", value: "en" }
90+ ]
91+ n1 <- settingsTable # count
9592 n1 `shouldEqual` 2
96− updated <- conn # run do
97− settingsTable # upsertMany
98− [ { key: "theme", value: "light" }
99− , { key: "lang", value: "de" }
100− , { key: "tz", value: "UTC" }
101− ]
93+ updated <- settingsTable # upsertMany
94+ [ { key: "theme", value: "light" }
95+ , { key: "lang", value: "de" }
96+ , { key: "tz", value: "UTC" }
97+ ]
10298 Array.length updated `shouldEqual` 3
103− n2 <- conn # runNoErr do settingsTable # count
99+ n2 <- settingsTable # count
104100 n2 `shouldEqual` 3
105− found <- conn # run do settingsTable # findOneBy @"key" "theme"
101+ found <- settingsTable # findOneBy @"key" "theme"
106102 setting <- shouldBeJust found
107103 setting.value `shouldEqual` "light"
108104
109105 describe "Finding records" do
110− it "finds a single record by primary key" $ withUsersTable \conn -> do
111− created <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
106+ it "finds a single record by primary key" $ withUsersTable do
107+ created <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
112108 alice <- shouldBeJust created
113− found <- conn # run do usersTable # findById alice.id
109+ found <- usersTable # findById alice.id
114110 r <- shouldBeJust found
115111 r.name `shouldEqual` "Alice"
116112
117− it "finds a single record by any unique column" $ withUsersTable \conn -> do
118− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
119− found <- conn # run do usersTable # findOneBy @"email" "a@t.com"
113+ it "finds a single record by any unique column" $ withUsersTable do
114+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
115+ found <- usersTable # findOneBy @"email" "a@t.com"
120116 alice <- shouldBeJust found
121117 alice.name `shouldEqual` "Alice"
122118
123− it "finds all records matching a column value" $ withUsersTable \conn -> do
124− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
125− _ <- conn # run do usersTable # create { name: "Bob", email: "b@t.com", role: "admin" }
126− _ <- conn # run do usersTable # create { name: "Carol", email: "c@t.com", role: "user" }
127− admins <- conn # run do usersTable # findBy @"role" "admin"
119+ it "finds all records matching a column value" $ withUsersTable do
120+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
121+ _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "admin" }
122+ _ <- usersTable # create { name: "Carol", email: "c@t.com", role: "user" }
123+ admins <- usersTable # findBy @"role" "admin"
128124 Array.length admins `shouldEqual` 2
129125
130− it "finds all records matching multiple conditions" $ withUsersTable \conn -> do
131− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
132− _ <- conn # run do usersTable # create { name: "Bob", email: "b@t.com", role: "admin" }
133− _ <- conn # run do usersTable # create { name: "Carol", email: "c@t.com", role: "user" }
134− alices <- conn # run do usersTable # findAllWhere { name: "Alice", role: "admin" }
126+ it "finds all records matching multiple conditions" $ withUsersTable do
127+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
128+ _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "admin" }
129+ _ <- usersTable # create { name: "Carol", email: "c@t.com", role: "user" }
130+ alices <- usersTable # findAllWhere { name: "Alice", role: "admin" }
135131 Array.length alices `shouldEqual` 1
136132 alice <- shouldBeJust (Array.head alices)
137133 alice.email `shouldEqual` "a@t.com"
138134
139− it "returns Nothing when no record matches" $ withUsersTable \conn -> do
140− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
141− missing <- conn # run do usersTable # findOneBy @"email" "nobody@t.com"
135+ it "returns Nothing when no record matches" $ withUsersTable do
136+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
137+ missing <- usersTable # findOneBy @"email" "nobody@t.com"
142138 isNothing missing `shouldEqual` true
143− alsoMissing <- conn # run do usersTable # findOneWhere { name: "Alice", role: "user" }
139+ alsoMissing <- usersTable # findOneWhere { name: "Alice", role: "user" }
144140 isNothing alsoMissing `shouldEqual` true
145141
146− it "finds records by a list of primary keys" $ withUsersTable \conn -> do
147− created1 <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
142+ it "finds records by a list of primary keys" $ withUsersTable do
143+ created1 <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
148144 u1 <- shouldBeJust created1
149− created2 <- conn # run do usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
145+ created2 <- usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
150146 u2 <- shouldBeJust created2
151− _ <- conn # run do usersTable # create { name: "Carol", email: "c@t.com", role: "user" }
152− found <- conn # run do usersTable # findByIdIn [ u1.id, u2.id ]
147+ _ <- usersTable # create { name: "Carol", email: "c@t.com", role: "user" }
148+ found <- usersTable # findByIdIn [ u1.id, u2.id ]
153149 Array.length found `shouldEqual` 2
154− empty <- conn # run do usersTable # findByIdIn ([] :: Array Int)
150+ empty <- usersTable # findByIdIn ([] :: Array Int)
155151 Array.length empty `shouldEqual` 0
156152
157− it "returns all records in the table" $ withUsersTable \conn -> do
158− _ <- conn # run do
159− usersTable # createMany
160− [ { name: "Alice", email: "a@t.com", role: "admin" }
161− , { name: "Bob", email: "b@t.com", role: "user" }
162− ]
163− all <- conn # run do usersTable # findAll
153+ it "returns all records in the table" $ withUsersTable do
154+ _ <- usersTable # createMany
155+ [ { name: "Alice", email: "a@t.com", role: "admin" }
156+ , { name: "Bob", email: "b@t.com", role: "user" }
157+ ]
158+ all <- usersTable # findAll
164159 Array.length all `shouldEqual` 2
165160
166161 describe "Filtering with operators" do
167− it "compares with gt, gte, lt, lte" $ withUsersTable \conn -> do
168− _ <- conn # run do
169− usersTable # createMany
170− [ { name: "Alice", email: "a@t.com", role: "admin" }
171− , { name: "Bob", email: "b@t.com", role: "user" }
172− , { name: "Carol", email: "c@t.com", role: "user" }
173− ]
174− all <- conn # run do usersTable # findAll
162+ it "compares with gt, gte, lt, lte" $ withUsersTable do
163+ _ <- usersTable # createMany
164+ [ { name: "Alice", email: "a@t.com", role: "admin" }
165+ , { name: "Bob", email: "b@t.com", role: "user" }
166+ , { name: "Carol", email: "c@t.com", role: "user" }
167+ ]
168+ all <- usersTable # findAll
175169 let
176170 id1 = case Array.head all of
177171 Just u -> u.id
178172 Nothing -> 0
179− gtRows <- conn # run do usersTable # findAllWhere { id: gt id1 }
173+ gtRows <- usersTable # findAllWhere { id: gt id1 }
180174 Array.length gtRows `shouldEqual` 2
181− gteRows <- conn # run do usersTable # findAllWhere { id: gte id1 }
175+ gteRows <- usersTable # findAllWhere { id: gte id1 }
182176 Array.length gteRows `shouldEqual` 3
183− ltRows <- conn # run do usersTable # findAllWhere { id: lt (id1 + 3) }
177+ ltRows <- usersTable # findAllWhere { id: lt (id1 + 3) }
184178 Array.length ltRows `shouldEqual` 3
185− lteRows <- conn # run do usersTable # findAllWhere { id: lte id1 }
179+ lteRows <- usersTable # findAllWhere { id: lte id1 }
186180 Array.length lteRows `shouldEqual` 1
187181
188− it "excludes with ne" $ withUsersTable \conn -> do
189− _ <- conn # run do
190− usersTable # createMany
191− [ { name: "Alice", email: "a@t.com", role: "admin" }
192− , { name: "Bob", email: "b@t.com", role: "user" }
193− , { name: "Carol", email: "c@t.com", role: "user" }
194− ]
195− rows <- conn # run do usersTable # findAllWhere { role: ne "admin" }
182+ it "excludes with ne" $ withUsersTable do
183+ _ <- usersTable # createMany
184+ [ { name: "Alice", email: "a@t.com", role: "admin" }
185+ , { name: "Bob", email: "b@t.com", role: "user" }
186+ , { name: "Carol", email: "c@t.com", role: "user" }
187+ ]
188+ rows <- usersTable # findAllWhere { role: ne "admin" }
196189 Array.length rows `shouldEqual` 2
197190
198− it "pattern-matches with like_ and ilike" $ withUsersTable \conn -> do
199− _ <- conn # run do
200− usersTable # createMany
201− [ { name: "Alice", email: "a@t.com", role: "admin" }
202− , { name: "Bob", email: "b@t.com", role: "user" }
203− , { name: "Carol", email: "c@t.com", role: "user" }
204− ]
205− likeRows <- conn # run do usersTable # findAllWhere { name: like_ "A%" }
191+ it "pattern-matches with like_ and ilike" $ withUsersTable do
192+ _ <- usersTable # createMany
193+ [ { name: "Alice", email: "a@t.com", role: "admin" }
194+ , { name: "Bob", email: "b@t.com", role: "user" }
195+ , { name: "Carol", email: "c@t.com", role: "user" }
196+ ]
197+ likeRows <- usersTable # findAllWhere { name: like_ "A%" }
206198 Array.length likeRows `shouldEqual` 1
207− ilikeRows <- conn # run do usersTable # findAllWhere { name: ilike "a%" }
199+ ilikeRows <- usersTable # findAllWhere { name: ilike "a%" }
208200 Array.length ilikeRows `shouldEqual` 1
209201
210− it "checks membership with inArray" $ withUsersTable \conn -> do
211− _ <- conn # run do
212− usersTable # createMany
213− [ { name: "Alice", email: "a@t.com", role: "admin" }
214− , { name: "Bob", email: "b@t.com", role: "user" }
215− , { name: "Carol", email: "c@t.com", role: "mod" }
216− ]
217− rows <- conn # run do usersTable # findAllWhere { role: inArray [ "admin", "mod" ] }
202+ it "checks membership with inArray" $ withUsersTable do
203+ _ <- usersTable # createMany
204+ [ { name: "Alice", email: "a@t.com", role: "admin" }
205+ , { name: "Bob", email: "b@t.com", role: "user" }
206+ , { name: "Carol", email: "c@t.com", role: "mod" }
207+ ]
208+ rows <- usersTable # findAllWhere { role: inArray [ "admin", "mod" ] }
218209 Array.length rows `shouldEqual` 2
219210
220− it "combines conditions with or_" $ withUsersTable \conn -> do
221− _ <- conn # run do
222− usersTable # createMany
223− [ { name: "Alice", email: "a@t.com", role: "admin" }
224− , { name: "Bob", email: "b@t.com", role: "user" }
225− , { name: "Carol", email: "c@t.com", role: "mod" }
226− ]
227− rows <- conn # run do usersTable # findAllWhere { role: or_ (eq_ "admin") (eq_ "mod") }
211+ it "combines conditions with or_" $ withUsersTable do
212+ _ <- usersTable # createMany
213+ [ { name: "Alice", email: "a@t.com", role: "admin" }
214+ , { name: "Bob", email: "b@t.com", role: "user" }
215+ , { name: "Carol", email: "c@t.com", role: "mod" }
216+ ]
217+ rows <- usersTable # findAllWhere { role: or_ (eq_ "admin") (eq_ "mod") }
228218 Array.length rows `shouldEqual` 2
229219
230− it "negates conditions with not_" $ withUsersTable \conn -> do
231− _ <- conn # run do
232− usersTable # createMany
233− [ { name: "Alice", email: "a@t.com", role: "admin" }
234− , { name: "Bob", email: "b@t.com", role: "user" }
235− , { name: "Carol", email: "c@t.com", role: "user" }
236− ]
237− rows <- conn # run do usersTable # findAllWhere { role: not_ (eq_ "admin") }
220+ it "negates conditions with not_" $ withUsersTable do
221+ _ <- usersTable # createMany
222+ [ { name: "Alice", email: "a@t.com", role: "admin" }
223+ , { name: "Bob", email: "b@t.com", role: "user" }
224+ , { name: "Carol", email: "c@t.com", role: "user" }
225+ ]
226+ rows <- usersTable # findAllWhere { role: not_ (eq_ "admin") }
238227 Array.length rows `shouldEqual` 2
239228
240229 describe "Updating and deleting" do
241− it "updates rows matching a condition" $ withUsersTable \conn -> do
242− _ <- conn # run do
243− usersTable # createMany
244− [ { name: "Alice", email: "a@t.com", role: "admin" }
245− , { name: "Bob", email: "b@t.com", role: "user" }
246− , { name: "Carol", email: "c@t.com", role: "user" }
247− ]
248− updated <- conn # run do usersTable # updateWhere { role: "user" } { role: "member" }
230+ it "updates rows matching a condition" $ withUsersTable do
231+ _ <- usersTable # createMany
232+ [ { name: "Alice", email: "a@t.com", role: "admin" }
233+ , { name: "Bob", email: "b@t.com", role: "user" }
234+ , { name: "Carol", email: "c@t.com", role: "user" }
235+ ]
236+ updated <- usersTable # updateWhere { role: "user" } { role: "member" }
249237 Array.length updated `shouldEqual` 2
250− members <- conn # run do usersTable # findBy @"role" "member"
238+ members <- usersTable # findBy @"role" "member"
251239 Array.length members `shouldEqual` 2
252240
253− it "deletes rows matching a condition" $ withUsersTable \conn -> do
254− _ <- conn # run do
255− usersTable # createMany
256− [ { name: "Alice", email: "a@t.com", role: "admin" }
257− , { name: "Bob", email: "b@t.com", role: "user" }
258− , { name: "Carol", email: "c@t.com", role: "user" }
259− ]
260− deleted <- conn # runNoErr do usersTable # deleteWhere { role: "user" }
241+ it "deletes rows matching a condition" $ withUsersTable do
242+ _ <- usersTable # createMany
243+ [ { name: "Alice", email: "a@t.com", role: "admin" }
244+ , { name: "Bob", email: "b@t.com", role: "user" }
245+ , { name: "Carol", email: "c@t.com", role: "user" }
246+ ]
247+ deleted <- usersTable # deleteWhere { role: "user" }
261248 deleted `shouldEqual` 2
262− remaining <- conn # runNoErr do usersTable # count
249+ remaining <- usersTable # count
263250 remaining `shouldEqual` 1
264251
265− it "deletes and returns the deleted rows" $ withUsersTable \conn -> do
266− _ <- conn # run do
267− usersTable # createMany
268− [ { name: "Alice", email: "a@t.com", role: "admin" }
269− , { name: "Bob", email: "b@t.com", role: "user" }
270− , { name: "Carol", email: "c@t.com", role: "user" }
271− ]
272− deleted <- conn # run do usersTable # deleteWhereReturning { role: "user" }
252+ it "deletes and returns the deleted rows" $ withUsersTable do
253+ _ <- usersTable # createMany
254+ [ { name: "Alice", email: "a@t.com", role: "admin" }
255+ , { name: "Bob", email: "b@t.com", role: "user" }
256+ , { name: "Carol", email: "c@t.com", role: "user" }
257+ ]
258+ deleted <- usersTable # deleteWhereReturning { role: "user" }
273259 Array.length deleted `shouldEqual` 2
274260 Array.sort (map _.name deleted) `shouldEqual` [ "Bob", "Carol" ]
275− remaining <- conn # runNoErr do usersTable # count
261+ remaining <- usersTable # count
276262 remaining `shouldEqual` 1
277263
278− it "deletes everything" $ withUsersTable \conn -> do
279− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
280− _ <- conn # run do usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
281− deleted <- conn # runNoErr do usersTable # deleteAll
264+ it "deletes everything" $ withUsersTable do
265+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
266+ _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
267+ deleted <- usersTable # deleteAll
282268 deleted `shouldEqual` 2
283− n <- conn # runNoErr do usersTable # count
269+ n <- usersTable # count
284270 n `shouldEqual` 0
285271
286272 describe "Ordering and pagination" do
287− it "orders results by a column" $ withUsersTable \conn -> do
288− _ <- conn # run do
289− usersTable # createMany
290− [ { name: "Carol", email: "c@t.com", role: "user" }
291− , { name: "Alice", email: "a@t.com", role: "admin" }
292− , { name: "Bob", email: "b@t.com", role: "user" }
293− ]
294− asc <- conn # run do usersTable # findOrdered @"name" Asc
273+ it "orders results by a column" $ withUsersTable do
274+ _ <- usersTable # createMany
275+ [ { name: "Carol", email: "c@t.com", role: "user" }
276+ , { name: "Alice", email: "a@t.com", role: "admin" }
277+ , { name: "Bob", email: "b@t.com", role: "user" }
278+ ]
279+ asc <- usersTable # findOrdered @"name" Asc
295280 (map _.name asc) `shouldEqual` [ "Alice", "Bob", "Carol" ]
296− desc <- conn # run do usersTable # findOrdered @"name" Desc
281+ desc <- usersTable # findOrdered @"name" Desc
297282 (map _.name desc) `shouldEqual` [ "Carol", "Bob", "Alice" ]
298283
299− it "filters, orders, and limits in one call" $ withUsersTable \conn -> do
300− _ <- conn # run do
301− usersTable # createMany
302− [ { name: "Alice", email: "a@t.com", role: "user" }
303− , { name: "Bob", email: "b@t.com", role: "user" }
304− , { name: "Carol", email: "c@t.com", role: "user" }
305− , { name: "Dave", email: "d@t.com", role: "user" }
306− ]
307− page1 <- conn # run do usersTable # findWhereLimited @"name" { role: "user" } Asc { limit: 2, offset: 0 }
284+ it "filters, orders, and limits in one call" $ withUsersTable do
285+ _ <- usersTable # createMany
286+ [ { name: "Alice", email: "a@t.com", role: "user" }
287+ , { name: "Bob", email: "b@t.com", role: "user" }
288+ , { name: "Carol", email: "c@t.com", role: "user" }
289+ , { name: "Dave", email: "d@t.com", role: "user" }
290+ ]
291+ page1 <- usersTable # findWhereLimited @"name" { role: "user" } Asc { limit: 2, offset: 0 }
308292 (map _.name page1) `shouldEqual` [ "Alice", "Bob" ]
309− page2 <- conn # run do usersTable # findWhereLimited @"name" { role: "user" } Asc { limit: 2, offset: 2 }
293+ page2 <- usersTable # findWhereLimited @"name" { role: "user" } Asc { limit: 2, offset: 2 }
310294 (map _.name page2) `shouldEqual` [ "Carol", "Dave" ]
311295
312− it "paginates forward with cursors" $ withUsersTable \conn -> do
313− _ <- conn # run do
314− usersTable # createMany
315− [ { name: "Alice", email: "a@t.com", role: "admin" }
316− , { name: "Bob", email: "b@t.com", role: "user" }
317− , { name: "Carol", email: "c@t.com", role: "user" }
318− , { name: "Dave", email: "d@t.com", role: "user" }
319− , { name: "Eve", email: "e@t.com", role: "admin" }
320− ]
321− page1 <- conn # run do usersTable # findFirst @"id" 2
296+ it "paginates forward with cursors" $ withUsersTable do
297+ _ <- usersTable # createMany
298+ [ { name: "Alice", email: "a@t.com", role: "admin" }
299+ , { name: "Bob", email: "b@t.com", role: "user" }
300+ , { name: "Carol", email: "c@t.com", role: "user" }
301+ , { name: "Dave", email: "d@t.com", role: "user" }
302+ , { name: "Eve", email: "e@t.com", role: "admin" }
303+ ]
304+ page1 <- usersTable # findFirst @"id" 2
322305 Array.length page1.items `shouldEqual` 2
323306 page1.hasMore `shouldEqual` true
324307 let
325308 lastId = case Array.last page1.items of
326309 Just u -> u.id
327310 Nothing -> 0
328− page2 <- conn # run do usersTable # findAfter @"id" lastId 2
311+ page2 <- usersTable # findAfter @"id" lastId 2
329312 Array.length page2.items `shouldEqual` 2
330313 page2.hasMore `shouldEqual` true
331314 let
332315 lastId2 = case Array.last page2.items of
333316 Just u -> u.id
334317 Nothing -> 0
335− page3 <- conn # run do usersTable # findAfter @"id" lastId2 2
318+ page3 <- usersTable # findAfter @"id" lastId2 2
336319 Array.length page3.items `shouldEqual` 1
337320 page3.hasMore `shouldEqual` false
338321
339− it "paginates backward with cursors" $ withUsersTable \conn -> do
340− _ <- conn # run do
341− usersTable # createMany
342− [ { name: "Alice", email: "a@t.com", role: "admin" }
343− , { name: "Bob", email: "b@t.com", role: "user" }
344− , { name: "Carol", email: "c@t.com", role: "user" }
345− , { name: "Dave", email: "d@t.com", role: "user" }
346− , { name: "Eve", email: "e@t.com", role: "admin" }
347− ]
348− all <- conn # run do usersTable # findAll
322+ it "paginates backward with cursors" $ withUsersTable do
323+ _ <- usersTable # createMany
324+ [ { name: "Alice", email: "a@t.com", role: "admin" }
325+ , { name: "Bob", email: "b@t.com", role: "user" }
326+ , { name: "Carol", email: "c@t.com", role: "user" }
327+ , { name: "Dave", email: "d@t.com", role: "user" }
328+ , { name: "Eve", email: "e@t.com", role: "admin" }
329+ ]
330+ all <- usersTable # findAll
349331 let
350332 lastUser = case Array.last all of
351333 Just u -> u
352334 Nothing -> { id: 0, name: "", email: "", active: true, role: "" }
353− page <- conn # run do usersTable # findBefore @"id" lastUser.id 2
335+ page <- usersTable # findBefore @"id" lastUser.id 2
354336 Array.length page.items `shouldEqual` 2
355337 page.hasMore `shouldEqual` true
356338
357− it "paginates with a filter applied" $ withUsersTable \conn -> do
358− _ <- conn # run do
359− usersTable # createMany
360− [ { name: "Alice", email: "a@t.com", role: "admin" }
361− , { name: "Bob", email: "b@t.com", role: "user" }
362− , { name: "Carol", email: "c@t.com", role: "user" }
363− , { name: "Dave", email: "d@t.com", role: "user" }
364− , { name: "Eve", email: "e@t.com", role: "admin" }
365− ]
366− page1 <- conn # run do usersTable # findFirstWhere @"id" { role: "user" } 2
339+ it "paginates with a filter applied" $ withUsersTable do
340+ _ <- usersTable # createMany
341+ [ { name: "Alice", email: "a@t.com", role: "admin" }
342+ , { name: "Bob", email: "b@t.com", role: "user" }
343+ , { name: "Carol", email: "c@t.com", role: "user" }
344+ , { name: "Dave", email: "d@t.com", role: "user" }
345+ , { name: "Eve", email: "e@t.com", role: "admin" }
346+ ]
347+ page1 <- usersTable # findFirstWhere @"id" { role: "user" } 2
367348 Array.length page1.items `shouldEqual` 2
368349 page1.hasMore `shouldEqual` true
369350 let
370351 lastId = case Array.last page1.items of
371352 Just u -> u.id
372353 Nothing -> 0
373− page2 <- conn # run do usersTable # findAfterWhere @"id" { role: "user" } lastId 2
354+ page2 <- usersTable # findAfterWhere @"id" { role: "user" } lastId 2
374355 Array.length page2.items `shouldEqual` 1
375356 page2.hasMore `shouldEqual` false
376357
377358 describe "Aggregations and checks" do
378− it "counts rows, optionally with a filter" $ withUsersTable \conn -> do
379− n0 <- conn # runNoErr do usersTable # count
359+ it "counts rows, optionally with a filter" $ withUsersTable do
360+ n0 <- usersTable # count
380361 n0 `shouldEqual` 0
381− _ <- conn # run do
382− usersTable # createMany
383− [ { name: "Alice", email: "a@t.com", role: "admin" }
384− , { name: "Bob", email: "b@t.com", role: "user" }
385− , { name: "Carol", email: "c@t.com", role: "admin" }
386− ]
387− n3 <- conn # runNoErr do usersTable # count
362+ _ <- usersTable # createMany
363+ [ { name: "Alice", email: "a@t.com", role: "admin" }
364+ , { name: "Bob", email: "b@t.com", role: "user" }
365+ , { name: "Carol", email: "c@t.com", role: "admin" }
366+ ]
367+ n3 <- usersTable # count
388368 n3 `shouldEqual` 3
389− nAdmins <- conn # runNoErr do usersTable # countWhere { role: "admin" }
369+ nAdmins <- usersTable # countWhere { role: "admin" }
390370 nAdmins `shouldEqual` 2
391371
392− it "checks whether a record exists" $ withUsersTable \conn -> do
393− created <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
372+ it "checks whether a record exists" $ withUsersTable do
373+ created <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
394374 alice <- shouldBeJust created
395− yes <- conn # runNoErr do usersTable # exists alice.id
375+ yes <- usersTable # exists alice.id
396376 yes `shouldEqual` true
397− no <- conn # runNoErr do usersTable # exists 99999
377+ no <- usersTable # exists 99999
398378 no `shouldEqual` false
399− yesWhere <- conn # runNoErr do usersTable # existsWhere { name: "Alice", role: "admin" }
379+ yesWhere <- usersTable # existsWhere { name: "Alice", role: "admin" }
400380 yesWhere `shouldEqual` true
401− noWhere <- conn # runNoErr do usersTable # existsWhere { name: "Alice", role: "user" }
381+ noWhere <- usersTable # existsWhere { name: "Alice", role: "user" }
402382 noWhere `shouldEqual` false
403383
404− it "sums and averages a numeric column" $ withUsersTable \conn -> do
405− _ <- conn # run do
406− usersTable # createMany
407− [ { name: "Alice", email: "a@t.com", role: "admin" }
408− , { name: "Bob", email: "b@t.com", role: "user" }
409− ]
410− total <- conn # runNoErr do usersTable # sumOf @"id"
384+ it "sums and averages a numeric column" $ withUsersTable do
385+ _ <- usersTable # createMany
386+ [ { name: "Alice", email: "a@t.com", role: "admin" }
387+ , { name: "Bob", email: "b@t.com", role: "user" }
388+ ]
389+ total <- usersTable # sumOf @"id"
411390 (total > 0.0) `shouldEqual` true
412− emptySum <- conn # runNoErr do usersTable # sumOfWhere @"id" { role: "nobody" }
391+ emptySum <- usersTable # sumOfWhere @"id" { role: "nobody" }
413392 emptySum `shouldEqual` 0.0
414− avg <- conn # runNoErr do usersTable # avgOf @"id"
393+ avg <- usersTable # avgOf @"id"
415394 isNothing avg `shouldEqual` false
416− emptyAvg <- conn # runNoErr do usersTable # avgOfWhere @"id" { role: "nobody" }
395+ emptyAvg <- usersTable # avgOfWhere @"id" { role: "nobody" }
417396 isNothing emptyAvg `shouldEqual` true
418397
419− it "finds the min and max of a column" $ withUsersTable \conn -> do
420− _ <- conn # run do
421− usersTable # createMany
422− [ { name: "Alice", email: "a@t.com", role: "admin" }
423− , { name: "Bob", email: "b@t.com", role: "user" }
424− , { name: "Carol", email: "c@t.com", role: "user" }
425− ]
426− minName <- conn # run do usersTable # minOf @"name"
398+ it "finds the min and max of a column" $ withUsersTable do
399+ _ <- usersTable # createMany
400+ [ { name: "Alice", email: "a@t.com", role: "admin" }
401+ , { name: "Bob", email: "b@t.com", role: "user" }
402+ , { name: "Carol", email: "c@t.com", role: "user" }
403+ ]
404+ minName <- usersTable # minOf @"name"
427405 minName `shouldEqual` (Just "Alice")
428− maxName <- conn # run do usersTable # maxOf @"name"
406+ maxName <- usersTable # maxOf @"name"
429407 maxName `shouldEqual` (Just "Carol")
430− noMin <- conn # run do usersTable # minOfWhere @"name" { role: "nobody" }
408+ noMin <- usersTable # minOfWhere @"name" { role: "nobody" }
431409 isNothing noMin `shouldEqual` true
432410
433− it "lists distinct values of a column" $ withUsersTable \conn -> do
434− _ <- conn # run do
435− usersTable # createMany
436− [ { name: "Alice", email: "a@t.com", role: "admin" }
437− , { name: "Bob", email: "b@t.com", role: "user" }
438− , { name: "Carol", email: "c@t.com", role: "user" }
439− ]
440− roles <- conn # run do usersTable # findDistinct @"role"
411+ it "lists distinct values of a column" $ withUsersTable do
412+ _ <- usersTable # createMany
413+ [ { name: "Alice", email: "a@t.com", role: "admin" }
414+ , { name: "Bob", email: "b@t.com", role: "user" }
415+ , { name: "Carol", email: "c@t.com", role: "user" }
416+ ]
417+ roles <- usersTable # findDistinct @"role"
441418 Array.sort roles `shouldEqual` [ "admin", "user" ]
442− activeRoles <- conn # run do usersTable # findDistinctWhere @"role" { active: true }
419+ activeRoles <- usersTable # findDistinctWhere @"role" { active: true }
443420 Array.sort activeRoles `shouldEqual` [ "admin", "user" ]
444421
445422 describe "Selecting specific columns" do
446− it "fetches only the columns you need" $ withUsersTable \conn -> do
447− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
448− _ <- conn # run do usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
449− _ <- conn # run do usersTable # create { name: "Carol", email: "c@t.com", role: "user" }
450− rows <- conn # run do usersTable # selectFrom @"name, email"
423+ it "fetches only the columns you need" $ withUsersTable do
424+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
425+ _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
426+ _ <- usersTable # create { name: "Carol", email: "c@t.com", role: "user" }
427+ rows <- usersTable # selectFrom @"name, email"
451428 Array.length rows `shouldEqual` 3
452429 let
453430 first = case Array.head rows of
@@ -455,31 +432,31 @@ spec = describe "ClientOm" do
455432 Nothing -> { name: "", email: "" }
456433 first.name `shouldEqual` "Alice"
457434 first.email `shouldEqual` "a@t.com"
458− filtered <- conn # run do usersTable # selectFromWhere @"name" { role: "user" }
435+ filtered <- usersTable # selectFromWhere @"name" { role: "user" }
459436 Array.length filtered `shouldEqual` 2
460437 Array.sort (map _.name filtered) `shouldEqual` [ "Bob", "Carol" ]
461438
462− it "fetches one row with specific columns and a filter" $ withUsersTable \conn -> do
463− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
464− _ <- conn # run do usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
465− found <- conn # run do usersTable # selectOneFrom @"name, role"
439+ it "fetches one row with specific columns and a filter" $ withUsersTable do
440+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
441+ _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
442+ found <- usersTable # selectOneFrom @"name, role"
466443 r <- shouldBeJust found
467444 r.name `shouldEqual` "Alice"
468445 r.role `shouldEqual` "admin"
469− byName <- conn # run do usersTable # selectOneFromWhere @"email" { name: "Bob" }
446+ byName <- usersTable # selectOneFromWhere @"email" { name: "Bob" }
470447 r2 <- shouldBeJust byName
471448 r2.email `shouldEqual` "b@t.com"
472− missing <- conn # run do usersTable # selectOneFromWhere @"email" { name: "Nobody" }
449+ missing <- usersTable # selectOneFromWhere @"email" { name: "Nobody" }
473450 isNothing missing `shouldEqual` true
474451
475452 describe "Relationships" do
476− it "joins a child table to its parent (flat)" $ withPostsTable \conn -> do
477− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
478− _ <- conn # run do usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
479− _ <- conn # run do postsTable # create { title: "First Post", body: "Hello", user_id: 1 }
480− _ <- conn # run do postsTable # create { title: "Second Post", body: "World", user_id: 1 }
481− _ <- conn # run do postsTable # create { title: "Bob's Post", body: "Hi", user_id: 2 }
482− rows <- conn # run do findWith postsTable usersTable
453+ it "joins a child table to its parent (flat)" $ withPostsTable do
454+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
455+ _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
456+ _ <- postsTable # create { title: "First Post", body: "Hello", user_id: 1 }
457+ _ <- postsTable # create { title: "Second Post", body: "World", user_id: 1 }
458+ _ <- postsTable # create { title: "Bob's Post", body: "Hi", user_id: 2 }
459+ rows <- findWith postsTable usersTable
483460 Array.length rows `shouldEqual` 3
484461 let
485462 r = case Array.head rows of
@@ -488,20 +465,20 @@ spec = describe "ClientOm" do
488465 r.test_om_posts.title `shouldEqual` "First Post"
489466 r.test_om_users.name `shouldEqual` "Alice"
490467
491− it "finds a joined record by primary key" $ withPostsTable \conn -> do
492− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
493− _ <- conn # run do postsTable # create { title: "My Post", body: "Content", user_id: 1 }
494− found <- conn # run do findByIdWith 1 postsTable usersTable
468+ it "finds a joined record by primary key" $ withPostsTable do
469+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
470+ _ <- postsTable # create { title: "My Post", body: "Content", user_id: 1 }
471+ found <- findByIdWith 1 postsTable usersTable
495472 r <- shouldBeJust found
496473 r.test_om_posts.title `shouldEqual` "My Post"
497474 r.test_om_users.name `shouldEqual` "Alice"
498475
499− it "joins with a filter" $ withPostsTable \conn -> do
500− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
501− _ <- conn # run do usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
502− _ <- conn # run do postsTable # create { title: "Post A", body: "A", user_id: 1 }
503− _ <- conn # run do postsTable # create { title: "Post B", body: "B", user_id: 2 }
504− rows <- conn # run do findWithWhere { user_id: 1 } postsTable usersTable
476+ it "joins with a filter" $ withPostsTable do
477+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
478+ _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
479+ _ <- postsTable # create { title: "Post A", body: "A", user_id: 1 }
480+ _ <- postsTable # create { title: "Post B", body: "B", user_id: 2 }
481+ rows <- findWithWhere { user_id: 1 } postsTable usersTable
505482 Array.length rows `shouldEqual` 1
506483 let
507484 r = case Array.head rows of
@@ -509,12 +486,12 @@ spec = describe "ClientOm" do
509486 Nothing -> { test_om_posts: { id: 0, title: "", body: "", user_id: 0 }, test_om_users: { id: 0, name: "", email: "", active: false, role: "" } }
510487 r.test_om_posts.title `shouldEqual` "Post A"
511488
512− it "nests children under their parent" $ withPostsTable \conn -> do
513− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
514− _ <- conn # run do usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
515− _ <- conn # run do postsTable # create { title: "Post 1", body: "A", user_id: 1 }
516− _ <- conn # run do postsTable # create { title: "Post 2", body: "B", user_id: 1 }
517− rows <- conn # run do findIncluding @"posts" usersTable postsTable
489+ it "nests children under their parent" $ withPostsTable do
490+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
491+ _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
492+ _ <- postsTable # create { title: "Post 1", body: "A", user_id: 1 }
493+ _ <- postsTable # create { title: "Post 2", body: "B", user_id: 1 }
494+ rows <- findIncluding @"posts" usersTable postsTable
518495 Array.length rows `shouldEqual` 2
519496 let
520497 alice = case Array.head rows of
@@ -523,22 +500,22 @@ spec = describe "ClientOm" do
523500 alice.name `shouldEqual` "Alice"
524501 Array.length alice.posts `shouldEqual` 2
525502
526− it "nests children for a single parent by id" $ withPostsTable \conn -> do
527− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
528− _ <- conn # run do postsTable # create { title: "Post 1", body: "A", user_id: 1 }
529− _ <- conn # run do postsTable # create { title: "Post 2", body: "B", user_id: 1 }
530− found <- conn # run do findByIdIncluding @"posts" 1 usersTable postsTable
503+ it "nests children for a single parent by id" $ withPostsTable do
504+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
505+ _ <- postsTable # create { title: "Post 1", body: "A", user_id: 1 }
506+ _ <- postsTable # create { title: "Post 2", body: "B", user_id: 1 }
507+ found <- findByIdIncluding @"posts" 1 usersTable postsTable
531508 r <- shouldBeJust found
532509 r.name `shouldEqual` "Alice"
533510 Array.length r.posts `shouldEqual` 2
534511
535− it "uses the join combinator to compose tables" $ withPostsTable \conn -> do
536− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
537− _ <- conn # run do usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
538− _ <- conn # run do postsTable # create { title: "Post 1", body: "A", user_id: 1 }
539− _ <- conn # run do postsTable # create { title: "Post 2", body: "B", user_id: 1 }
540− _ <- conn # run do postsTable # create { title: "Post 3", body: "C", user_id: 2 }
541− rows <- conn # run do (usersTable # join postsTable) # findAll
512+ it "uses the join combinator to compose tables" $ withPostsTable do
513+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
514+ _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
515+ _ <- postsTable # create { title: "Post 1", body: "A", user_id: 1 }
516+ _ <- postsTable # create { title: "Post 2", body: "B", user_id: 1 }
517+ _ <- postsTable # create { title: "Post 3", body: "C", user_id: 2 }
518+ rows <- (usersTable # join postsTable) # findAll
542519 Array.length rows `shouldEqual` 2
543520 let
544521 alice = case Array.head rows of
@@ -547,12 +524,12 @@ spec = describe "ClientOm" do
547524 alice.name `shouldEqual` "Alice"
548525 Array.length alice.test_om_posts `shouldEqual` 2
549526
550− it "joins multiple child tables at once" $ withPostsAndCommentsTable \conn -> do
551− _ <- conn # run do usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
552− _ <- conn # run do postsTable # create { title: "Post 1", body: "A", user_id: 1 }
553− _ <- conn # run do postsTable # create { title: "Post 2", body: "B", user_id: 1 }
554− _ <- conn # run do commentsTable # create { text: "Nice!", user_id: 1 }
555− rows <- conn # run do (usersTable # join postsTable # join commentsTable) # findAll
527+ it "joins multiple child tables at once" $ withPostsAndCommentsTable do
528+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
529+ _ <- postsTable # create { title: "Post 1", body: "A", user_id: 1 }
530+ _ <- postsTable # create { title: "Post 2", body: "B", user_id: 1 }
531+ _ <- commentsTable # create { text: "Nice!", user_id: 1 }
532+ rows <- (usersTable # join postsTable # join commentsTable) # findAll
556533 Array.length rows `shouldEqual` 1
557534 let
558535 r = case Array.head rows of
@@ -563,29 +540,28 @@ spec = describe "ClientOm" do
563540 Array.length r.test_om_comments `shouldEqual` 1
564541
565542 describe "Transactions" do
566− it "commits multiple inserts atomically" $ withUsersTable \conn -> do
567− conn # run do
568− withTransaction do
569− _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
570− _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
571− pure unit
572− n <- conn # runNoErr do usersTable # count
543+ it "commits multiple inserts atomically" $ withUsersTable do
544+ transactionally do
545+ _ <- usersTable # create { name: "Alice", email: "a@t.com", role: "admin" }
546+ _ <- usersTable # create { name: "Bob", email: "b@t.com", role: "user" }
547+ pure unit
548+ n <- usersTable # count
573549 n `shouldEqual` 2
574550
575551 describe "UUIDs and newtypes" do
576− it "round-trips a UUID primary key through create/find/exists" $ withUuidTable \conn -> do
577− created <- conn # run do uuidTable # create { label: "first" }
552+ it "round-trips a UUID primary key through create/find/exists" $ withUuidTable do
553+ created <- uuidTable # create { label: "first" }
578554 row <- shouldBeJust created
579555 row.label `shouldEqual` "first"
580− found <- conn # run do uuidTable # findById row.id
556+ found <- uuidTable # findById row.id
581557 r2 <- shouldBeJust found
582558 r2.label `shouldEqual` "first"
583− byCol <- conn # run do uuidTable # findBy @"label" "first"
559+ byCol <- uuidTable # findBy @"label" "first"
584560 Array.length byCol `shouldEqual` 1
585− byId <- conn # run do uuidTable # findOneBy @"id" row.id
561+ byId <- uuidTable # findOneBy @"id" row.id
586562 r3 <- shouldBeJust byId
587563 r3.label `shouldEqual` "first"
588− yes <- conn # runNoErr do uuidTable # exists row.id
564+ yes <- uuidTable # exists row.id
589565 yes `shouldEqual` true
590566
591567-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -612,7 +588,7 @@ settingsTable :: Proxy SettingsTable
612588settingsTable = Proxy
613589
614590type UuidTable = Table "test_om_uuid_things"
615− ( id :: PGUUID # PrimaryKey # DefaultExpr "gen_random_uuid()"
591+ ( id :: PGUUID # PrimaryKey # Default "gen_random_uuid()"
616592 , label :: String
617593 )
618594
@@ -642,6 +618,15 @@ commentsTable = Proxy
642618-- Helpers
643619-- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
644620
621+type TestOm = Om.Om { postgresConnection :: PG.Connection } (parseError :: MultipleErrors) Unit
622+
623+shouldEqual :: forall m t. MonadEffect m => Show t => Eq t => t -> t -> m Unit
624+shouldEqual v1 v2 = when (v1 /= v2) $ liftEffect $ Exception.throwException $ Exception.error $ show v1 <> " ≠ " <> show v2
625+
626+shouldBeJust :: forall m a. MonadEffect m => Maybe a -> m a
627+shouldBeJust (Just a) = pure a
628+shouldBeJust Nothing = liftEffect $ Exception.throwException $ Exception.error "Expected Just but got Nothing"
629+
645630testConnection :: Aff PG.Connection
646631testConnection =
647632 PG.postgres
@@ -652,31 +637,25 @@ testConnection =
652637 , password: PG.PostgresPassword "postgres"
653638 } # liftEffect
654639
655−run
656− :: forall a
657− . Om.Om { postgresConnection :: PG.Connection } (parseError :: MultipleErrors) a
658− -> PG.Connection
659− -> Aff a
660−run om conn = Om.runOm { postgresConnection: conn }
661− { exception: \e -> throwError e
662− , parseError: \errs -> throwError (error ("Parse error: " <> show errs))
663− }
664− om
665−
666−runNoErr
667− :: forall a
668− . Om.Om { postgresConnection :: PG.Connection } () a
669− -> PG.Connection
670− -> Aff a
671−runNoErr om conn = Om.runOm { postgresConnection: conn }
672− { exception: \e -> throwError e }
673− om
674−
675−withUsersTable :: (PG.Connection -> Aff Unit) -> Aff Unit
640+runOm :: TestOm -> Aff Unit
641+runOm om = do
642+ conn <- testConnection
643+ Om.runOm { postgresConnection: conn }
644+ { exception: \e -> throwError e
645+ , parseError: \errs -> throwError (Exception.error ("Parse error: " <> show errs))
646+ }
647+ om
648+ PG.end conn
649+
650+withUsersTable :: TestOm -> Aff Unit
676651withUsersTable test = do
677652 conn <- testConnection
678653 _ <- PG.executeSimple createDDL conn
679− test conn
654+ Om.runOm { postgresConnection: conn }
655+ { exception: \e -> throwError e
656+ , parseError: \errs -> throwError (Exception.error ("Parse error: " <> show errs))
657+ }
658+ test
680659 _ <- PG.executeSimple dropDDL conn
681660 PG.end conn
682661 where
@@ -691,11 +670,15 @@ withUsersTable test = do
691670 role TEXT NOT NULL
692671 )"""
693672
694−withSettingsTable :: (PG.Connection -> Aff Unit) -> Aff Unit
673+withSettingsTable :: TestOm -> Aff Unit
695674withSettingsTable test = do
696675 conn <- testConnection
697676 _ <- PG.executeSimple createDDL conn
698− test conn
677+ Om.runOm { postgresConnection: conn }
678+ { exception: \e -> throwError e
679+ , parseError: \errs -> throwError (Exception.error ("Parse error: " <> show errs))
680+ }
681+ test
699682 _ <- PG.executeSimple dropDDL conn
700683 PG.end conn
701684 where
@@ -707,11 +690,15 @@ withSettingsTable test = do
707690 value TEXT NOT NULL
708691 )"""
709692
710−withUuidTable :: (PG.Connection -> Aff Unit) -> Aff Unit
693+withUuidTable :: TestOm -> Aff Unit
711694withUuidTable test = do
712695 conn <- testConnection
713696 _ <- PG.executeSimple createDDL conn
714− test conn
697+ Om.runOm { postgresConnection: conn }
698+ { exception: \e -> throwError e
699+ , parseError: \errs -> throwError (Exception.error ("Parse error: " <> show errs))
700+ }
701+ test
715702 _ <- PG.executeSimple dropDDL conn
716703 PG.end conn
717704 where
@@ -723,11 +710,15 @@ withUuidTable test = do
723710 label TEXT NOT NULL
724711 )"""
725712
726−withPostsTable :: (PG.Connection -> Aff Unit) -> Aff Unit
713+withPostsTable :: TestOm -> Aff Unit
727714withPostsTable test = do
728715 conn <- testConnection
729716 _ <- PG.executeSimple createDDL conn
730− test conn
717+ Om.runOm { postgresConnection: conn }
718+ { exception: \e -> throwError e
719+ , parseError: \errs -> throwError (Exception.error ("Parse error: " <> show errs))
720+ }
721+ test
731722 _ <- PG.executeSimple (PG.SQL "DROP TABLE IF EXISTS test_om_posts CASCADE") conn
732723 _ <- PG.executeSimple (PG.SQL "DROP TABLE IF EXISTS test_om_users CASCADE") conn
733724 PG.end conn
@@ -749,11 +740,15 @@ withPostsTable test = do
749740 user_id INTEGER NOT NULL REFERENCES test_om_users(id)
750741 )"""
751742
752−withPostsAndCommentsTable :: (PG.Connection -> Aff Unit) -> Aff Unit
743+withPostsAndCommentsTable :: TestOm -> Aff Unit
753744withPostsAndCommentsTable test = do
754745 conn <- testConnection
755746 _ <- PG.executeSimple createDDL conn
756− test conn
747+ Om.runOm { postgresConnection: conn }
748+ { exception: \e -> throwError e
749+ , parseError: \errs -> throwError (Exception.error ("Parse error: " <> show errs))
750+ }
751+ test
757752 _ <- PG.executeSimple (PG.SQL "DROP TABLE IF EXISTS test_om_comments CASCADE") conn
758753 _ <- PG.executeSimple (PG.SQL "DROP TABLE IF EXISTS test_om_posts CASCADE") conn
759754 _ <- PG.executeSimple (PG.SQL "DROP TABLE IF EXISTS test_om_users CASCADE") conn
@@ -781,7 +776,3 @@ withPostsAndCommentsTable test = do
781776 text TEXT NOT NULL,
782777 user_id INTEGER NOT NULL REFERENCES test_om_users(id)
783778 )"""
784−
785−shouldBeJust :: forall a. Maybe a -> Aff a
786−shouldBeJust (Just a) = pure a
787−shouldBeJust Nothing = throwError $ error "Expected Just but got Nothing"