Move transaction related functions to a separate module

Extract `begin`, `commit` and `rollback` that can be used separately from
`withTransaction`.

Author: anttih

MODULE.md

@@ -135,25 +135,6 @@ withClient :: forall eff a. ConnectionInfo -> (Client -> Aff (db :: DB | eff) a)
 Takes a Client from the connection pool, runs the given function with
 the client and returns the results.
 
-#### `withTransaction`
-
-``` purescript
-withTransaction :: forall eff a. (Client -> Aff (db :: DB | eff) a) -> Client -> Aff (db :: DB | eff) a
-```
-
-Runs an asynchronous action in a database transaction. The transaction
-will be rolled back if the computation fails and committed otherwise.
-
-Here the first insert will be rolled back:
-
-```purescript
-moneyTransfer :: forall e. (Client -> Aff e Unit) -> Client -> Aff e Unit
-moneyTransfer = withTransaction $ \c -> do
-  execute_ (Query "insert into accounts ...") c
-  throwError $ error "Something went wrong"
-  execute_ (Query "insert into accounts ...") c
-```
-
 #### `end`
 
 ``` purescript
@@ -215,4 +196,47 @@ instance isSqlValueMaybe :: (IsSqlValue a) => IsSqlValue (Maybe a)
 
 
 
+## Module Database.Postgres.Transaction
+
+#### `withTransaction`
+
+``` purescript
+withTransaction :: forall eff a. (Client -> Aff (db :: DB | eff) a) -> Client -> Aff (db :: DB | eff) a
+```
+
+Runs an asynchronous action in a database transaction. The transaction
+will be rolled back if the computation fails and committed otherwise.
+
+Here the first insert will be rolled back:
+
+```purescript
+moneyTransfer :: forall e. (Client -> Aff e Unit) -> Client -> Aff e Unit
+moneyTransfer = withTransaction $ \c -> do
+  execute_ (Query "insert into accounts ...") c
+  throwError $ error "Something went wrong"
+  execute_ (Query "insert into accounts ...") c
+```
+
+#### `begin`
+
+``` purescript
+begin :: forall eff. Client -> Aff (db :: DB | eff) Unit
+```
+
+
+#### `commit`
+
+``` purescript
+commit :: forall eff. Client -> Aff (db :: DB | eff) Unit
+```
+
+
+#### `rollback`
+
+``` purescript
+rollback :: forall eff. Client -> Aff (db :: DB | eff) Unit
+```
+
+
+
 

src/Database/Postgres.purs

@@ -14,7 +14,6 @@ module Database.Postgres
   , queryOne, queryOne_
   , withConnection
   , withClient
-  , withTransaction
   ) where
 
 import Control.Alt
@@ -132,27 +131,6 @@ withClient :: forall eff a
   -> Aff (db :: DB | eff) a
 withClient info p = runFn2 _withClient (mkConnectionString info) p
 
--- | Runs an asynchronous action in a database transaction. The transaction
--- | will be rolled back if the computation fails and committed otherwise.
--- |
--- | Here the first insert will be rolled back:
--- |
--- | ```purescript
--- | moneyTransfer :: forall e. (Client -> Aff e Unit) -> Client -> Aff e Unit
--- | moneyTransfer = withTransaction $ \c -> do
--- |   execute_ (Query "insert into accounts ...") c
--- |   throwError $ error "Something went wrong"
--- |   execute_ (Query "insert into accounts ...") c
--- | ```
-withTransaction :: forall eff a. (Client -> Aff (db :: DB | eff) a) -> Client -> Aff (db :: DB | eff) a
-withTransaction act client = do
-  execute_ (Query "BEGIN TRANSACTION") client
-  res <- attempt (act client)
-  either rollback commit res
-    where
-    rollback err = execute_ (Query "ROLLBACK") client *> throwError err
-    commit v = execute_ (Query "COMMIT") client *> pure v
-
 liftError :: forall e a. ForeignError -> Aff e a
 liftError err = throwError $ error (show err)
 

src/Database/Postgres/Transaction.purs

@@ -0,0 +1,39 @@
+module Database.Postgres.Transaction where
+
+import Control.Apply ((*>))
+import Control.Monad.Aff
+import Control.Monad.Error.Class (throwError)
+import Data.Either
+
+import Database.Postgres
+import Database.Postgres.SqlValue
+
+-- | Runs an asynchronous action in a database transaction. The transaction
+-- | will be rolled back if the computation fails and committed otherwise.
+-- |
+-- | Here the first insert will be rolled back:
+-- |
+-- | ```purescript
+-- | moneyTransfer :: forall e. (Client -> Aff e Unit) -> Client -> Aff e Unit
+-- | moneyTransfer = withTransaction $ \c -> do
+-- |   execute_ (Query "insert into accounts ...") c
+-- |   throwError $ error "Something went wrong"
+-- |   execute_ (Query "insert into accounts ...") c
+-- | ```
+withTransaction :: forall eff a. (Client -> Aff (db :: DB | eff) a) -> Client -> Aff (db :: DB | eff) a
+withTransaction act client = do
+  begin client
+  res <- attempt (act client)
+  either rollback_ commit_ res
+    where
+    rollback_ err = rollback client *> throwError err
+    commit_ v = commit client *> pure v
+
+begin :: forall eff. Client -> Aff (db :: DB | eff) Unit
+begin = execute_ (Query "BEGIN TRANSACTION")
+
+commit :: forall eff. Client -> Aff (db :: DB | eff) Unit
+commit = execute_ (Query "COMMIT")
+
+rollback :: forall eff. Client -> Aff (db :: DB | eff) Unit
+rollback = execute_ (Query "ROLLBACK")

test/Main.purs

@@ -1,7 +1,5 @@
 module Test.Main where
 
-import Database.Postgres
-import Database.Postgres.SqlValue
 import Debug.Trace
 import Control.Monad.Eff
 import Control.Monad.Eff.Class
@@ -18,6 +16,10 @@ import Data.Foreign.Class
 import Data.Foreign.Index
 import Control.Monad.Aff
 
+import Database.Postgres
+import Database.Postgres.SqlValue
+import Database.Postgres.Transaction
+
 main = runAff (trace <<< show) (const $ trace "All ok") $ do
   liftEff <<< trace $ "connecting to " <> mkConnectionString connectionInfo <> "..."
   exampleUsingWithConnection