diff --git a/Setup.hs b/Setup.hs
deleted file mode 100644
--- a/Setup.hs
+++ /dev/null
@@ -1,2 +0,0 @@
-import Distribution.Simple
-main = defaultMain
diff --git a/hasql-cursor-transaction.cabal b/hasql-cursor-transaction.cabal
--- a/hasql-cursor-transaction.cabal
+++ b/hasql-cursor-transaction.cabal
@@ -1,5 +1,6 @@
+cabal-version: 3.0
 name: hasql-cursor-transaction
-version: 0.6.4
+version: 0.6.5
 category: Hasql, Database, PostgreSQL, Streaming
 synopsis: An abstraction for simultaneous fetching from multiple PostgreSQL cursors
 homepage: https://github.com/nikita-volkov/hasql-cursor-transaction
@@ -9,30 +10,67 @@
 copyright: (c) 2016, Nikita Volkov
 license: MIT
 license-file: LICENSE
-build-type: Simple
-cabal-version: >=1.10
 
 library
   hs-source-dirs: library
-  default-extensions: Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples
   default-language: Haskell2010
+  default-extensions:
+    Arrows
+    BangPatterns
+    ConstraintKinds
+    DataKinds
+    DefaultSignatures
+    DeriveDataTypeable
+    DeriveFoldable
+    DeriveFunctor
+    DeriveGeneric
+    DeriveTraversable
+    EmptyDataDecls
+    FlexibleContexts
+    FlexibleInstances
+    FunctionalDependencies
+    GADTs
+    GeneralizedNewtypeDeriving
+    LambdaCase
+    LiberalTypeSynonyms
+    MagicHash
+    MultiParamTypeClasses
+    MultiWayIf
+    NoImplicitPrelude
+    NoMonomorphismRestriction
+    OverloadedStrings
+    ParallelListComp
+    PatternGuards
+    QuasiQuotes
+    RankNTypes
+    RecordWildCards
+    ScopedTypeVariables
+    StandaloneDeriving
+    TemplateHaskell
+    TupleSections
+    TypeFamilies
+    TypeOperators
+    UnboxedTuples
+
   other-modules:
+    Hasql.CursorTransaction.Private.CursorTransaction
     Hasql.CursorTransaction.Private.Prelude
-    Hasql.CursorTransaction.Private.Statements
     Hasql.CursorTransaction.Private.Specs
+    Hasql.CursorTransaction.Private.Statements
     Hasql.CursorTransaction.Private.Transactions
-    Hasql.CursorTransaction.Private.CursorTransaction
+
   exposed-modules:
-    Hasql.CursorTransaction.Transactions
-    Hasql.CursorTransaction.Sessions
     Hasql.CursorTransaction
+    Hasql.CursorTransaction.Sessions
+    Hasql.CursorTransaction.Transactions
+
   build-depends:
     base >=4.9 && <5,
     base-prelude >=1 && <2,
-    bytestring >=0.10 && <0.11,
-    bytestring-tree-builder ==0.2.*,
-    contravariant >=1.3 && <2,
-    contravariant-extras >=0.3.3.1 && <0.4,
-    hasql >=1.4 && <1.5,
-    hasql-transaction >=0.7 && <0.8,
-    transformers >=0.4 && <0.6
+    bytestring >=0.10 && <0.14,
+    bytestring-tree-builder >=0.2 && <0.3,
+    contravariant >=1.5 && <2,
+    contravariant-extras >=0.3.5.4 && <0.4,
+    hasql ^>=1.6.4.1,
+    hasql-transaction ^>=1.1,
+    transformers >=0.4 && <0.7,
diff --git a/library/Hasql/CursorTransaction.hs b/library/Hasql/CursorTransaction.hs
--- a/library/Hasql/CursorTransaction.hs
+++ b/library/Hasql/CursorTransaction.hs
@@ -1,24 +1,25 @@
 module Hasql.CursorTransaction
-(
-  -- * Types
-  A.CursorTransaction,
-  A.Cursor,
-  B.BatchSize,
-  B.EncodedParams,
-  -- * Cursor Transactions
-  A.declareCursor,
-  A.fetchBatch,
-  A.transaction,
-  -- * Batch Sizes
-  B.batchSize_10,
-  B.batchSize_100,
-  B.batchSize_1000,
-  B.batchSize_10000,
-  -- * Encoded Params
-  B.encodedParams,
-)
+  ( -- * Types
+    A.CursorTransaction,
+    A.Cursor,
+    B.BatchSize,
+    B.EncodedParams,
+
+    -- * Cursor Transactions
+    A.declareCursor,
+    A.fetchBatch,
+    A.transaction,
+
+    -- * Batch Sizes
+    B.batchSize_10,
+    B.batchSize_100,
+    B.batchSize_1000,
+    B.batchSize_10000,
+
+    -- * Encoded Params
+    B.encodedParams,
+  )
 where
 
 import qualified Hasql.CursorTransaction.Private.CursorTransaction as A
 import qualified Hasql.CursorTransaction.Private.Specs as B
-
diff --git a/library/Hasql/CursorTransaction/Private/CursorTransaction.hs b/library/Hasql/CursorTransaction/Private/CursorTransaction.hs
--- a/library/Hasql/CursorTransaction/Private/CursorTransaction.hs
+++ b/library/Hasql/CursorTransaction/Private/CursorTransaction.hs
@@ -1,44 +1,43 @@
-module Hasql.CursorTransaction.Private.CursorTransaction
-where
+module Hasql.CursorTransaction.Private.CursorTransaction where
 
+import qualified ByteString.TreeBuilder as E
 import Hasql.CursorTransaction.Private.Prelude
-import qualified Hasql.Transaction as A
-import qualified Hasql.Encoders as D
-import qualified Hasql.Decoders as F
-import qualified Hasql.CursorTransaction.Private.Transactions as C
 import qualified Hasql.CursorTransaction.Private.Specs as G
-import qualified ByteString.TreeBuilder as E
-
+import qualified Hasql.CursorTransaction.Private.Transactions as C
+import qualified Hasql.Decoders as F
+import qualified Hasql.Encoders as D
+import qualified Hasql.Transaction as A
 
 -- |
 -- Context for fetching from multiple cursors in an intertwined fashion.
-newtype CursorTransaction s result =
-  CursorTransaction (StateT (Int, A.Transaction ()) A.Transaction result)
+newtype CursorTransaction s result
+  = CursorTransaction (StateT (Int, A.Transaction ()) A.Transaction result)
   deriving (Functor, Applicative, Monad)
 
 -- |
 -- Cursor reference.
-newtype Cursor s =
-  Cursor ByteString
+newtype Cursor s
+  = Cursor ByteString
 
 -- |
 -- Given a template and encoded params produces a cursor,
 -- while automating its resource management.
 declareCursor :: ByteString -> G.EncodedParams -> CursorTransaction s (Cursor s)
 declareCursor template (G.EncodedParams (Supplied encoder params)) =
-  CursorTransaction $
-  do
-    name <- state $ do
-      (inc, finaliser) <- id
-      name <- return (incToName inc)
-      newFinaliser <- return (finaliser *> C.closeCursor name)
-      return (name, (succ inc, newFinaliser))
-    lift (C.declareCursor name template encoder params)
-    return (Cursor name)
+  CursorTransaction
+    $ do
+      name <- state $ do
+        (inc, finaliser) <- id
+        name <- return (incToName inc)
+        newFinaliser <- return (finaliser *> C.closeCursor name)
+        return (name, (succ inc, newFinaliser))
+      lift (C.declareCursor name template encoder params)
+      return (Cursor name)
   where
     incToName inc =
-      E.toByteString $
-      E.byteString "Hasql_CursorTransaction_" <> E.asciiIntegral inc
+      E.toByteString
+        $ E.byteString "Hasql_CursorTransaction_"
+        <> E.asciiIntegral inc
 
 -- |
 -- Fetch from a cursor a batch of the given size and decode it using the specified result decoder.
diff --git a/library/Hasql/CursorTransaction/Private/Prelude.hs b/library/Hasql/CursorTransaction/Private/Prelude.hs
--- a/library/Hasql/CursorTransaction/Private/Prelude.hs
+++ b/library/Hasql/CursorTransaction/Private/Prelude.hs
@@ -1,16 +1,10 @@
 module Hasql.CursorTransaction.Private.Prelude
-( 
-  module Exports,
-)
+  ( module Exports,
+  )
 where
 
-
--- base-prelude
--------------------------
-import BasePrelude as Exports hiding (assert, left, right, isLeft, isRight, error)
-
--- transformers
--------------------------
+import BasePrelude as Exports hiding (assert, error, isLeft, isRight, left, right)
+import Contravariant.Extras as Exports
 import Control.Monad.IO.Class as Exports
 import Control.Monad.Trans.Class as Exports
 import Control.Monad.Trans.Cont as Exports hiding (shift)
@@ -19,17 +13,7 @@
 import Control.Monad.Trans.Reader as Exports hiding (liftCallCC)
 import Control.Monad.Trans.State.Strict as Exports hiding (liftCatch, liftListen, liftPass)
 import Control.Monad.Trans.Writer.Strict as Exports hiding (liftCallCC, liftCatch)
-import Data.Functor.Identity as Exports
-
--- contravariant
--------------------------
+import Data.ByteString as Exports (ByteString)
 import Data.Functor.Contravariant as Exports
 import Data.Functor.Contravariant.Divisible as Exports
-
--- contravariant-extras
--------------------------
-import Contravariant.Extras as Exports
-
--- bytestring
--------------------------
-import Data.ByteString as Exports (ByteString)
+import Data.Functor.Identity as Exports
diff --git a/library/Hasql/CursorTransaction/Private/Specs.hs b/library/Hasql/CursorTransaction/Private/Specs.hs
--- a/library/Hasql/CursorTransaction/Private/Specs.hs
+++ b/library/Hasql/CursorTransaction/Private/Specs.hs
@@ -1,15 +1,13 @@
-module Hasql.CursorTransaction.Private.Specs
-where
+module Hasql.CursorTransaction.Private.Specs where
 
 import Hasql.CursorTransaction.Private.Prelude
-import qualified Hasql.Encoders as A
 import qualified Hasql.Decoders as B
-
+import qualified Hasql.Encoders as A
 
 -- |
 -- Spefifies how many rows to fetch in a single DB roundtrip.
-newtype BatchSize =
-  BatchSize Int64
+newtype BatchSize
+  = BatchSize Int64
 
 -- |
 -- Batch size of 10.
@@ -35,11 +33,10 @@
 batchSize_10000 =
   BatchSize 10000
 
-
 -- |
 -- A parameters encoder immediately supplied with parameters.
-newtype EncodedParams =
-  EncodedParams (Supplied A.Params)
+newtype EncodedParams
+  = EncodedParams (Supplied A.Params)
   deriving (Semigroup, Monoid)
 
 -- |
diff --git a/library/Hasql/CursorTransaction/Private/Statements.hs b/library/Hasql/CursorTransaction/Private/Statements.hs
--- a/library/Hasql/CursorTransaction/Private/Statements.hs
+++ b/library/Hasql/CursorTransaction/Private/Statements.hs
@@ -1,21 +1,22 @@
-module Hasql.CursorTransaction.Private.Statements
-where
+module Hasql.CursorTransaction.Private.Statements where
 
+import qualified ByteString.TreeBuilder as D
 import Hasql.CursorTransaction.Private.Prelude
-import Hasql.Statement
-import qualified Hasql.Encoders as B
-import qualified Hasql.Decoders as C
 import qualified Hasql.CursorTransaction.Private.Specs as F
-import qualified ByteString.TreeBuilder as D
-
+import qualified Hasql.Decoders as C
+import qualified Hasql.Encoders as B
+import Hasql.Statement
 
 declareCursor :: ByteString -> ByteString -> B.Params a -> Statement a ()
 declareCursor name sql encoder =
   Statement sql' encoder C.noResult False
   where
     sql' =
-      D.toByteString $
-      "DECLARE " <> D.byteString name <> " NO SCROLL CURSOR FOR " <> D.byteString sql
+      D.toByteString
+        $ "DECLARE "
+        <> D.byteString name
+        <> " NO SCROLL CURSOR FOR "
+        <> D.byteString sql
 
 closeCursor :: ByteString -> Statement () ()
 closeCursor name =
@@ -29,7 +30,10 @@
   Statement sql encoder decoder True
   where
     sql =
-      D.toByteString $
-      "FETCH FORWARD " <> D.asciiIntegral batchSize <> " FROM " <> D.byteString name
+      D.toByteString
+        $ "FETCH FORWARD "
+        <> D.asciiIntegral batchSize
+        <> " FROM "
+        <> D.byteString name
     encoder =
       B.noParams
diff --git a/library/Hasql/CursorTransaction/Private/Transactions.hs b/library/Hasql/CursorTransaction/Private/Transactions.hs
--- a/library/Hasql/CursorTransaction/Private/Transactions.hs
+++ b/library/Hasql/CursorTransaction/Private/Transactions.hs
@@ -1,13 +1,11 @@
-module Hasql.CursorTransaction.Private.Transactions
-where
+module Hasql.CursorTransaction.Private.Transactions where
 
 import Hasql.CursorTransaction.Private.Prelude
-import qualified Hasql.CursorTransaction.Private.Statements as A
 import qualified Hasql.CursorTransaction.Private.Specs as B
-import qualified Hasql.Transaction as C
+import qualified Hasql.CursorTransaction.Private.Statements as A
 import qualified Hasql.Decoders as E
 import qualified Hasql.Encoders as F
-
+import qualified Hasql.Transaction as C
 
 declareCursor :: ByteString -> ByteString -> F.Params params -> params -> C.Transaction ()
 declareCursor cursorName template paramsEncoder params =
diff --git a/library/Hasql/CursorTransaction/Sessions.hs b/library/Hasql/CursorTransaction/Sessions.hs
--- a/library/Hasql/CursorTransaction/Sessions.hs
+++ b/library/Hasql/CursorTransaction/Sessions.hs
@@ -1,17 +1,16 @@
 module Hasql.CursorTransaction.Sessions
-(
-  cursorTransaction,
-)
+  ( cursorTransaction,
+  )
 where
 
-import Hasql.CursorTransaction.Private.Prelude
 import qualified Hasql.CursorTransaction.Private.CursorTransaction as A
-import qualified Hasql.Transaction.Sessions as D
+import Hasql.CursorTransaction.Private.Prelude
 import qualified Hasql.Session as C
+import qualified Hasql.Transaction.Sessions as D
 
 -- |
 -- Executes CursorTransaction in Session.
--- 
+--
 -- During the execution it establishes a Read transaction with the ReadCommitted isolation level.
 cursorTransaction :: (forall s. A.CursorTransaction s result) -> C.Session result
 cursorTransaction cursorTransaction =
diff --git a/library/Hasql/CursorTransaction/Transactions.hs b/library/Hasql/CursorTransaction/Transactions.hs
--- a/library/Hasql/CursorTransaction/Transactions.hs
+++ b/library/Hasql/CursorTransaction/Transactions.hs
@@ -1,11 +1,10 @@
 module Hasql.CursorTransaction.Transactions
-(
-  cursorTransaction,
-)
+  ( cursorTransaction,
+  )
 where
 
-import qualified Hasql.CursorTransaction.Private.Transactions as A
 import qualified Hasql.CursorTransaction.Private.CursorTransaction as B
+import qualified Hasql.CursorTransaction.Private.Transactions as A
 
 -- |
 -- Executes CursorTransaction in Transaction.