Documentation

module MusicCatalogueDb.Statements.SelectArtistIdsByName where

import Data.Functor.Contravariant
import Data.Text (Text)
import Data.UUID (UUID)
import Data.Vector (Vector)
import qualified Hasql.Decoders as Decoders
import qualified Hasql.Encoders as Encoders
import Hasql.Mapping.IsStatement
import Prelude

data SelectArtistIdsByName = SelectArtistIdsByName
  { name :: Text
  }

type SelectArtistIdsByNameResult = Vector SelectArtistIdsByNameResultRow

data SelectArtistIdsByNameResultRow = SelectArtistIdsByNameResultRow
  { id :: UUID
  }

instance IsStatement SelectArtistIdsByName where
  type Result SelectArtistIdsByName = SelectArtistIdsByNameResult
  statement =
    Statement.preparable sql encoder decoder
    where
      sql =
        "select id from artist\n\
        \where name = $1\n\
        \limit 1"
      encoder =
        mconcat
          [ (\(SelectArtistIdsByName x) -> x)
              >$< Encoders.param (Encoders.nonNullable Encoders.text)
          ]
      decoder =
        Decoders.rowVector
          ( SelectArtistIdsByNameResultRow
              <$> Decoders.column (Decoders.nonNullable Decoders.uuid)
          )

module MusicCatalogueDb.Transactions.InsertAlbumWithTracks where

import Hasql.Mapping.IsTransaction
import qualified Hasql.Transaction as Transaction
import qualified MusicCatalogueDb.Statements.InsertAlbum as InsertAlbum
import qualified MusicCatalogueDb.Statements.InsertTrack as InsertTrack
import Prelude

data InsertAlbumWithTracks = InsertAlbumWithTracks
  { album :: InsertAlbum.InsertAlbum,
    tracks :: [InsertTrack.InsertTrack]
  }

type InsertAlbumWithTracksResult = InsertAlbum.InsertAlbumResult

instance IsTransaction InsertAlbumWithTracks where
  type Result InsertAlbumWithTracks = InsertAlbumWithTracksResult
  isolation = ReadCommitted -- inserts only fresh rows, so no anomaly exposure
  transaction params = do
    albumId <- Transaction.statement params.album InsertAlbum.statement
    for_ params.tracks \track ->
      Transaction.statement track InsertTrack.statement
    pure albumId

Insert-and-catch is preferable to check-then-insert: the latter needs Serializable to be correct and costs an extra round trip, while the former is correct at any isolation level in one. Catching above toSessionWithoutRetries is safe because by the time an error escapes the runner, the transaction has already been rolled back:

module MusicCatalogueDb.Sessions.RegisterAlbum where

import Hasql.Mapping.IsSession
import qualified Hasql.Mapping.IsTransaction as IsTransaction
import Prelude

data RegisterAlbum = RegisterAlbum { ... }

data RegisterAlbumError = AlbumAlreadyExists

type RegisterAlbumResult = Either RegisterAlbumError AlbumId

instance IsSession RegisterAlbum where
  type Result RegisterAlbum = RegisterAlbumResult
  session params =
    catchingSqlState (\case "23505" -> Just AlbumAlreadyExists; _ -> Nothing)
      $ IsTransaction.toSessionWithoutRetries (InsertAlbumWithTracks params.album params.tracks)

(catchingSqlState is proposed upstream at nikita-volkov/hasql#322 and is not yet part of hasql; the shape above is illustrative of how it will compose over this class.)