Deprecation notice

- Closes #28

.gitignore

@@ -1,2 +1,6 @@
 dist/
 config/config.dhall
+/ctags
+/TAGS
+/result*
+/backend/config

.stylish-haskell.yaml

@@ -0,0 +1,233 @@
+# stylish-haskell configuration file
+# ==================================
+
+# The stylish-haskell tool is mainly configured by specifying steps. These steps
+# are a list, so they have an order, and one specific step may appear more than
+# once (if needed). Each file is processed by these steps in the given order.
+steps:
+  # Convert some ASCII sequences to their Unicode equivalents. This is disabled
+  # by default.
+  # - unicode_syntax:
+  #     # In order to make this work, we also need to insert the UnicodeSyntax
+  #     # language pragma. If this flag is set to true, we insert it when it's
+  #     # not already present. You may want to disable it if you configure
+  #     # language extensions using some other method than pragmas. Default:
+  #     # true.
+  #     add_language_pragma: true
+
+  # Align the right hand side of some elements.  This is quite conservative
+  # and only applies to statements where each element occupies a single
+  # line.
+  - simple_align:
+      cases: true
+      top_level_patterns: true
+      records: true
+
+  # Import cleanup
+  - imports:
+      # There are different ways we can align names and lists.
+      #
+      # - global: Align the import names and import list throughout the entire
+      #   file.
+      #
+      # - file: Like global, but don't add padding when there are no qualified
+      #   imports in the file.
+      #
+      # - group: Only align the imports per group (a group is formed by adjacent
+      #   import lines).
+      #
+      # - none: Do not perform any alignment.
+      #
+      # Default: global.
+      align: global
+
+      # The following options affect only import list alignment.
+      #
+      # List align has following options:
+      #
+      # - after_alias: Import list is aligned with end of import including
+      #   'as' and 'hiding' keywords.
+      #
+      #   > import qualified Data.List      as List (concat, foldl, foldr, head,
+      #   >                                          init, last, length)
+      #
+      # - with_alias: Import list is aligned with start of alias or hiding.
+      #
+      #   > import qualified Data.List      as List (concat, foldl, foldr, head,
+      #   >                                 init, last, length)
+      #
+      # - new_line: Import list starts always on new line.
+      #
+      #   > import qualified Data.List      as List
+      #   >     (concat, foldl, foldr, head, init, last, length)
+      #
+      # Default: after_alias
+      list_align: after_alias
+
+      # Right-pad the module names to align imports in a group:
+      #
+      # - true: a little more readable
+      #
+      #   > import qualified Data.List       as List (concat, foldl, foldr,
+      #   >                                           init, last, length)
+      #   > import qualified Data.List.Extra as List (concat, foldl, foldr,
+      #   >                                           init, last, length)
+      #
+      # - false: diff-safe
+      #
+      #   > import qualified Data.List as List (concat, foldl, foldr, init,
+      #   >                                     last, length)
+      #   > import qualified Data.List.Extra as List (concat, foldl, foldr,
+      #   >                                           init, last, length)
+      #
+      # Default: true
+      pad_module_names: true
+
+      # Long list align style takes effect when import is too long. This is
+      # determined by 'columns' setting.
+      #
+      # - inline: This option will put as much specs on same line as possible.
+      #
+      # - new_line: Import list will start on new line.
+      #
+      # - new_line_multiline: Import list will start on new line when it's
+      #   short enough to fit to single line. Otherwise it'll be multiline.
+      #
+      # - multiline: One line per import list entry.
+      #   Type with constructor list acts like single import.
+      #
+      #   > import qualified Data.Map as M
+      #   >     ( empty
+      #   >     , singleton
+      #   >     , ...
+      #   >     , delete
+      #   >     )
+      #
+      # Default: inline
+      long_list_align: inline
+
+      # Align empty list (importing instances)
+      #
+      # Empty list align has following options
+      #
+      # - inherit: inherit list_align setting
+      #
+      # - right_after: () is right after the module name:
+      #
+      #   > import Vector.Instances ()
+      #
+      # Default: inherit
+      empty_list_align: inherit
+
+      # List padding determines indentation of import list on lines after import.
+      # This option affects 'long_list_align'.
+      #
+      # - <integer>: constant value
+      #
+      # - module_name: align under start of module name.
+      #   Useful for 'file' and 'group' align settings.
+      list_padding: 4
+
+      # Separate lists option affects formatting of import list for type
+      # or class. The only difference is single space between type and list
+      # of constructors, selectors and class functions.
+      #
+      # - true: There is single space between Foldable type and list of it's
+      #   functions.
+      #
+      #   > import Data.Foldable (Foldable (fold, foldl, foldMap))
+      #
+      # - false: There is no space between Foldable type and list of it's
+      #   functions.
+      #
+      #   > import Data.Foldable (Foldable(fold, foldl, foldMap))
+      #
+      # Default: true
+      separate_lists: true
+
+      # Space surround option affects formatting of import lists on a single
+      # line. The only difference is single space after the initial
+      # parenthesis and a single space before the terminal parenthesis.
+      #
+      # - true: There is single space associated with the enclosing
+      #   parenthesis.
+      #
+      #   > import Data.Foo ( foo )
+      #
+      # - false: There is no space associated with the enclosing parenthesis
+      #
+      #   > import Data.Foo (foo)
+      #
+      # Default: false
+      space_surround: false
+
+  # Language pragmas
+  - language_pragmas:
+      # We can generate different styles of language pragma lists.
+      #
+      # - vertical: Vertical-spaced language pragmas, one per line.
+      #
+      # - compact: A more compact style.
+      #
+      # - compact_line: Similar to compact, but wrap each line with
+      #   `{-#LANGUAGE #-}'.
+      #
+      # Default: vertical.
+      style: vertical
+
+      # Align affects alignment of closing pragma brackets.
+      #
+      # - true: Brackets are aligned in same column.
+      #
+      # - false: Brackets are not aligned together. There is only one space
+      #   between actual import and closing bracket.
+      #
+      # Default: true
+      align: true
+
+      # stylish-haskell can detect redundancy of some language pragmas. If this
+      # is set to true, it will remove those redundant pragmas. Default: true.
+      remove_redundant: true
+
+  # Replace tabs by spaces. This is disabled by default.
+  # - tabs:
+  #     # Number of spaces to use for each tab. Default: 8, as specified by the
+  #     # Haskell report.
+  #     spaces: 8
+
+  # Remove trailing whitespace
+  - trailing_whitespace: {}
+
+  # Squash multiple spaces between the left and right hand sides of some
+  # elements into single spaces. Basically, this undoes the effect of
+  # simple_align but is a bit less conservative.
+  # - squash: {}
+
+# A common setting is the number of columns (parts of) code will be wrapped
+# to. Different steps take this into account. Default: 80.
+columns: 80
+
+# By default, line endings are converted according to the OS. You can override
+# preferred format here.
+#
+# - native: Native newline format. CRLF on Windows, LF on other OSes.
+#
+# - lf: Convert to LF ("\n").
+#
+# - crlf: Convert to CRLF ("\r\n").
+#
+# Default: native.
+newline: native
+
+# Sometimes, language extensions are specified in a cabal file or from the
+# command line instead of using language pragmas in the file. stylish-haskell
+# needs to be aware of these, so it can parse the file correctly.
+#
+# No language extensions are enabled by default.
+language_extensions:
+  - DeriveGeneric
+  - NoImplicitPrelude
+  - OverloadedStrings
+  - RecordWildCards
+  # - TemplateHaskell
+  # - QuasiQuotes

.travis.yml

@@ -0,0 +1,12 @@
+language: nix
+
+os:
+  - linux
+
+before_script:
+  - mkdir -m 0755 -p /nix/var/nix/{profiles,gcroots}/per-user/$USER
+  - mkdir -p ~/.config/nixpkgs
+
+script:
+  - nix build -f ./release.nix --option trusted-public-keys "masser-ebook-manager.cachix.org-1:mtFSkQ2MO5MvjUpulZoFKjKUIa8g8CTcdPVuJaPKS1w= cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=" --option binary-caches "https://masser-ebook-manager.cachix.org https://cache.nixos.org" ghc.backend ghc.frontend
+  - nix build -f ./release.nix --option trusted-public-keys "masser-ebook-manager.cachix.org-1:mtFSkQ2MO5MvjUpulZoFKjKUIa8g8CTcdPVuJaPKS1w= cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=" --option binary-caches "https://masser-ebook-manager.cachix.org https://cache.nixos.org" ghcjs.frontend

README.md

@@ -0,0 +1,2 @@
+**DEPRECATED**
+[![Build Status](https://travis-ci.org/MasseR/ebook-manager.svg?branch=master)](https://travis-ci.org/MasseR/ebook-manager)

backend/ChangeLog.md

@@ -0,0 +1,5 @@
+# Revision history for backend
+
+## 0.1.0.0 -- YYYY-mm-dd
+
+* First version. Released on an unsuspecting world.

backend/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2018, Mats Rauhala
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Mats Rauhala nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

backend/Setup.hs

@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain

backend/backend.cabal

@@ -1,4 +1,7 @@
-name:                ebook-manager
+-- Initial backend.cabal generated by cabal init.  For further
+-- documentation, see http://haskell.org/cabal/users-guide/
+
+name:                backend
 version:             0.1.0.0
 -- synopsis:
 -- description:
@@ -12,8 +15,9 @@ build-type:          Simple
 extra-source-files:  ChangeLog.md
 cabal-version:       >=1.10
 
-executable ebook-manager
+executable backend
   main-is:             Main.hs
+  ghc-options:         -Wall -threaded -rtsopts -with-rtsopts=-N
   other-modules:       Devel.Main
                      , API
                      , API.Books
@@ -21,10 +25,10 @@ executable ebook-manager
                      , API.Channels
                      , API.Users
                      , Configuration
-                     , Data.Versioned
                      , Database
                      , Database.Book
                      , Database.Channel
+                     , Database.Tag
                      , Database.Schema
                      , Database.User
                      , Datastore
@@ -34,7 +38,10 @@ executable ebook-manager
                      , Types
                      , View
   -- other-extensions:
-  build-depends:       base >=4.10 && <4.11
+  build-depends:       base >=4.10
+                     , exceptions
+                     , monad-control
+                     , common
                      , aeson
                      , asn1-data
                      , asn1-types
@@ -63,6 +70,7 @@ executable ebook-manager
                      , servant
                      , servant-auth
                      , servant-auth-server
+                     , servant-auth-docs
                      , servant-docs
                      , servant-lucid
                      , servant-multipart
@@ -76,8 +84,68 @@ executable ebook-manager
                      , xml-conduit
                      , xml-hamlet
   hs-source-dirs:      src
+  default-language:    Haskell2010
+  default-extensions:  DeriveGeneric
+                     , NoImplicitPrelude
+                     , OverloadedStrings
+                     , RecordWildCards
+
+test-suite spec
+  type:                exitcode-stdio-1.0
+  main-is:             Spec.hs
+  hs-source-dirs:      src
+  build-depends:       base >=4.10
+                     , aeson
+                     , asn1-data
+                     , asn1-types
+                     , bytestring
+                     , classy-prelude
+                     , common
+                     , cryptonite
+                     , dhall
+                     , directory
+                     , exceptions
+                     , foreign-store
+                     , generic-lens
+                     , genvalidity-hspec
+                     , genvalidity-hspec-aeson
+                     , genvalidity-property
+                     , genvalidity-text
+                     , hspec
+                     , http-api-data
+                     , http-media
+                     , jose
+                     , lens
+                     , lucid
+                     , memory
+                     , monad-control
+                     , monad-logger
+                     , mtl
+                     , pandoc
+                     , pandoc-types
+                     , pem
+                     , process
+                     , resource-pool
+                     , selda
+                     , selda-postgresql
+                     , servant
+                     , servant-auth
+                     , servant-auth-docs
+                     , servant-auth-server
+                     , servant-docs
+                     , servant-lucid
+                     , servant-multipart
+                     , servant-server
+                     , text
+                     , transformers
+                     , validity
+                     , wai
+                     , warp
+                     , x509
+                     , x509-store
+                     , xml-conduit
+                     , xml-hamlet
   default-extensions:  DeriveGeneric
                      , NoImplicitPrelude
                      , OverloadedStrings
                      , RecordWildCards
-  default-language:    Haskell2010

backend/src/API.hs

@@ -0,0 +1,30 @@
+{-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NoImplicitPrelude     #-}
+{-# LANGUAGE TypeFamilies          #-}
+{-# LANGUAGE TypeOperators         #-}
+module API (API, handler) where
+
+
+import           Servant
+import           Types
+
+import qualified API.Books          as Books
+import qualified API.Catalogue      as Catalogue
+import qualified API.Channels       as Channels
+import qualified API.Users          as Users
+
+type API = "api" :> Users.API
+      :<|> "api" :> "current" :> Channels.API
+      :<|> "api" :> "current" :> Books.API
+      :<|> "api" :> "1" :> Catalogue.VersionedAPI 1
+      :<|> "api" :> "current" :> Catalogue.VersionedAPI 1
+
+handler :: ServerT API AppM
+handler = Users.handler
+    :<|> Channels.handler
+    :<|> Books.handler
+    :<|> Catalogue.handler
+    :<|> Catalogue.handler
+

backend/src/API/Books.hs

@@ -0,0 +1,127 @@
+{-# LANGUAGE DataKinds                  #-}
+{-# LANGUAGE DeriveGeneric              #-}
+{-# LANGUAGE DuplicateRecordFields      #-}
+{-# LANGUAGE FlexibleInstances          #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses      #-}
+{-# LANGUAGE NamedFieldPuns             #-}
+{-# LANGUAGE NoImplicitPrelude          #-}
+{-# LANGUAGE OverloadedStrings          #-}
+{-# LANGUAGE QuasiQuotes                #-}
+{-# LANGUAGE RecordWildCards            #-}
+{-# LANGUAGE TemplateHaskell            #-}
+{-# LANGUAGE TypeApplications           #-}
+{-# LANGUAGE TypeFamilies               #-}
+{-# LANGUAGE TypeOperators              #-}
+module API.Books where
+
+import           ClassyPrelude
+import           Control.Lens
+import           Control.Monad.Catch       (throwM)
+import           Control.Monad.Trans.Maybe
+import           Crypto.Hash               (digestFromByteString)
+import           Data.Aeson
+import           Data.ByteArray            (convert)
+import           Data.Generics.Product
+import           Database
+import           Database.Book
+import           Database.Channel
+import           Database.Tag
+import qualified Datastore                 as DS
+import           Servant                   hiding (contentType)
+import           Servant.Auth              as SA
+import qualified Servant.Docs              as Docs
+import           Server.Auth
+import           Types
+
+data JsonBook = JsonBook { identifier  :: BookID
+                         , contentType :: Text
+                         , title       :: Text
+                         , description :: Maybe Text
+                         , channels    :: [Text]
+                         , tags        :: [Text] }
+              deriving (Generic, Show, Eq)
+
+instance Docs.ToSample JsonBook where
+  toSamples _ = [("Book", JsonBook 13 "epub" "title" (Just "Description") [] [])]
+
+instance Docs.ToSample PostBook where
+  toSamples _ = [("Book", PostBook "epub" "title" (Just "Description") [] [])]
+
+data PostBook = PostBook { contentType :: Text
+                         , title       :: Text
+                         , description :: Maybe Text
+                         , channels    :: [Text]
+                         , tags        :: [Text] }
+              deriving (Generic, Show, Eq)
+
+
+instance ToJSON JsonBook
+instance FromJSON JsonBook
+instance ToJSON PostBook
+instance FromJSON PostBook
+
+type API = Auth '[SA.BasicAuth, SA.JWT] SafeUser :> BaseAPI
+
+
+type BaseAPI = "books" :> Get '[JSON] [JsonBook]
+       :<|> "books" :> ReqBody '[JSON] PostBook :> Post '[JSON] JsonBook
+       :<|> "books" :> Capture "book_id" BookID :> "meta" :> ReqBody '[JSON] JsonBook :> Put '[JSON] JsonBook
+       :<|> "books" :> Capture "book_id" BookID :> ReqBody '[OctetStream] FileContent :> Put '[JSON] NoContent
+       :<|> GetBook
+
+newtype FileContent = FileContent { getFileContent :: ByteString } deriving (MimeUnrender OctetStream, MimeRender OctetStream )
+
+instance Docs.ToSample FileContent where
+  toSamples _ = [("File contents", FileContent "bytes here and there")]
+
+type GetBook = "books" :> Capture "book_id" BookID :> Get '[OctetStream] FileContent
+
+handler :: ServerT API AppM
+handler user = listBooksHandler user
+          :<|> postBookMetaHandler user
+          :<|> putBookMetaHandler user
+          :<|> putBookContentHandler user
+          :<|> getBookContentHandler user
+
+getBookContentHandler :: AuthResult SafeUser -> BookID -> AppM FileContent
+getBookContentHandler auth bookId = requireBookOwner auth bookId $ \SafeUser{username} -> do
+  content <- runMaybeT $ do
+    Book{contentHash=mHash} <- MaybeT $ runDB (getBook bookId username)
+    contentHash <- MaybeT $ return (mHash >>= digestFromByteString . unHex)
+    FileContent <$> MaybeT (DS.get contentHash)
+  maybe (throwM err404) return content
+
+requireBookOwner :: AuthResult SafeUser -> BookID -> (SafeUser -> AppM a) -> AppM a
+requireBookOwner auth bookId f = flip requireLoggedIn auth $ \u@SafeUser{username} -> do
+  exists <- runDB $ bookExists bookId
+  unless exists $ throwM err404
+  runDB (isBookOwner bookId username) >>= \o -> if o then f u else throwM err403
+
+putBookContentHandler :: AuthResult SafeUser -> BookID -> FileContent -> AppM NoContent
+putBookContentHandler auth bookId fc = requireBookOwner auth bookId $ \SafeUser{username} -> do
+  let content = getFileContent fc
+  key <- HashDigest . convert <$> DS.put content
+  runDB (setContent bookId username key)
+  return NoContent
+
+postBookMetaHandler :: AuthResult SafeUser -> PostBook -> AppM JsonBook
+postBookMetaHandler auth PostBook{..} = flip requireLoggedIn auth $ \SafeUser{username} -> do
+  mIdentifier <- runDB $ insertBook InsertBook{owner=username,..}
+  maybe (throwM err403{errBody="Could not insert book"}) (\identifier -> pure JsonBook{..}) mIdentifier
+
+
+putBookMetaHandler :: AuthResult SafeUser -> BookID -> JsonBook -> AppM JsonBook
+putBookMetaHandler auth bookId JsonBook{..}
+  | bookId == identifier = requireBookOwner auth bookId $ \SafeUser{username=owner} ->
+        maybe (throwM err403) (return . view (super @JsonBook)) =<< runDB (updateBook UpdateBook{..})
+  | otherwise = throwM err403
+
+listBooksHandler :: AuthResult SafeUser -> AppM [JsonBook]
+listBooksHandler = requireLoggedIn $ \user -> do
+  runDB (usersBooks (view (field @"username") user) >>= mapM augment)
+    where
+      augment Book{identifier=bookId,contentType,title,description} = do
+        channels <- fmap (view (field @"channel")) <$> booksChannels bookId
+        tags <- fmap (view (field @"tag")) <$> booksTags bookId
+        pure JsonBook{identifier=bookId,..}

backend/src/API/Catalogue.hs

@@ -16,15 +16,19 @@
 {-# Language ScopedTypeVariables #-}
 module API.Catalogue (VersionedAPI, handler) where
 
-import Types
+import qualified API.Books
-import Servant
+import           ClassyPrelude hiding (link)
-import ClassyPrelude
-import GHC.TypeLits
-import Server.Auth
-import Servant.Auth as SA
-import Servant.XML
-import qualified Database.Channel as Channel
 import           Database
+import           Database.Book (Book(..))
+import qualified Database.Channel as Channel
+import           GHC.TypeLits
+import           Servant hiding (contentType)
+import           Servant.Auth as SA
+import qualified Servant.Docs as Docs
+import           Servant.XML
+import           Server.Auth
+import           System.IO.Unsafe (unsafePerformIO)
+import           Types
 
 -- This is my first try on going to versioned apis, things might change
 -- I think my rule of thumb is that you can add new things as you want, but
@@ -38,19 +42,20 @@ newtype Rel = Rel { unRel :: Text } deriving (IsString, Show)
 
 data Pagination = Pagination { previous :: Maybe Rel
                              , next :: Maybe Rel }
-                deriving (Show)
+                deriving (Show, Generic)
 
 newtype SubSection = SubSection Rel deriving (Show)
 newtype Acquisition = Acquisition Rel deriving (Show)
+newtype Time = Time { getTime :: UTCTime } deriving Show
 
 data instance Entry 1 = EntryV1 { title :: Text
                                 , identifier :: Text
-                                , updated :: UTCTime
+                                , updated :: Time
                                 , content :: Text
                                 , link :: Either SubSection Acquisition
                                 }
 
-data instance Catalog 1 = CatalogV1 { updated :: UTCTime
+data instance Catalog 1 = CatalogV1 { updated :: Time
                                     , self :: Rel
                                     , start :: Rel
                                     , pagination :: Pagination
@@ -62,6 +67,20 @@ deriving instance Show (Entry 1)
 deriving instance Generic (Catalog 1)
 deriving instance Generic (Entry 1)
 
+instance Docs.ToSample (Entry 1) where
+  toSamples _ = [("Entry", EntryV1 "title" "identifier" docsTime "content" (Left (SubSection (Rel "sub"))))]
+instance Docs.ToSample Time where
+  toSamples _ = [("time", docsTime)]
+instance Docs.ToSample Rel where
+  toSamples _ = [("Relative link", Rel "next")]
+instance Docs.ToSample Pagination
+instance Docs.ToSample (Catalog 1) -- where
+  -- toSamples _ = [("catalog", CatalogV1 docsTime (Rel "prev") (Rel "next") (Pagination (Just "previous") (Just "next")) [])]
+
+docsTime :: Time
+docsTime = Time $ unsafePerformIO getCurrentTime
+
+
 instance ToNode SubSection where
   toNode (SubSection rel) = [xml|<link type="application/atom+xml;profile=opds-catalog;kind=acquisition" rel="subsection" href="#{unRel rel}">|]
 
@@ -73,7 +92,7 @@ instance ToNode (Entry 1) where
 <entry>
   <title>#{title}
   <id>#{identifier}
-  <updated>#{iso8601 updated}
+  <updated>#{iso8601 $ getTime updated}
   <content>#{content}
   ^{either toNode toNode link}
   |]
@@ -83,7 +102,7 @@ instance ToNode (Catalog 1) where
 <feed xmlns="http://www.w3.org/2005/Atom" xmlns:opds="http://opds-spec.org/2010/catalog">
   <id>#{unRel self}
   <title>Give me a title
-  <updated>#{iso8601 updated}
+  <updated>#{iso8601 $ getTime updated}
   <link type="application/atom+xml;profile=opds-catalog;kind=navigation" rel="self" href="#{unRel self}">
   <link type="application/atom+xml;profile=opds-catalog;kind=navigation" rel="start" href="#{unRel start}">
   $maybe n <- (next pagination)
@@ -96,27 +115,49 @@ instance ToNode (Catalog 1) where
 
 class Monad m => VersionedCatalog m (v :: Nat) where
   getChannels :: SafeUser -> m (Catalog v)
+  getBooks :: Channel.ChannelID -> SafeUser -> m (Catalog v)
 
 instance VersionedCatalog AppM 1 where
   getChannels = getChannelsV1
+  getBooks = getBooksV1
+
+relUrl :: Link -> Rel
+relUrl x = Rel ("/api/current/" <> (pack . uriPath . linkURI $ x))
+
+getBooksV1 :: Channel.ChannelID -> SafeUser -> AppM (Catalog 1)
+getBooksV1 channelID SafeUser{username} = do
+  updated <- Time <$> liftIO getCurrentTime
+  let self = relUrl selfUrl
+      start = relUrl startUrl
+      selfUrl = safeLink (Proxy @(BaseAPI 1)) (Proxy @(ChannelCatalog 1)) channelID
+      startUrl = safeLink (Proxy @(BaseAPI 1)) (Proxy @(RootCatalog 1))
+      pagination = Pagination Nothing Nothing
+  entries <- map (toEntry updated) <$> runDB (Channel.channelBooks username channelID)
+  pure CatalogV1{..}
+  where
+    toEntry updated Book{description,title,identifier=bookId} =
+      let content = fromMaybe "no content" description
+          identifier = pack . show $ bookId
+          link = Right (Acquisition (relUrl (safeLink (Proxy @API.Books.BaseAPI) (Proxy @API.Books.GetBook) bookId)))
+      in EntryV1{..}
 
 getChannelsV1 :: SafeUser -> AppM (Catalog 1)
 getChannelsV1 SafeUser{username} = do
-  updated <- liftIO getCurrentTime
+  updated <- Time <$> liftIO getCurrentTime
-  let self = Rel ("/api/current/" <> selfUrl)
+  let self = relUrl selfUrl
       -- I'm not sure if this safe link approach is really useable with this
       -- api hierarchy since I can't access the topmost api from here. Also
       -- authentication would bring a little bit of extra effort as well
-      selfUrl = pack . uriPath . linkURI $ safeLink (Proxy @(BaseAPI 1)) (Proxy @(RootCatalog 1))
+      selfUrl = safeLink (Proxy @(BaseAPI 1)) (Proxy @(RootCatalog 1))
       start = self
       pagination = Pagination Nothing Nothing
   entries <- map (fromChannel updated) <$> runDB (Channel.userChannels username)
   pure CatalogV1{..}
   where
-    fromChannel :: UTCTime -> Channel.Channel -> Entry 1
+    fromChannel :: Time -> Channel.Channel -> Entry 1
     fromChannel updated Channel.Channel{..} =
-      let url = pack . uriPath . linkURI $ safeLink (Proxy @(BaseAPI 1)) (Proxy @(ChannelCatalog 1)) identifier
+      let url = safeLink (Proxy @(BaseAPI 1)) (Proxy @(ChannelCatalog 1)) identifier
-          self = Rel ("/api/current/" <> url)
+          self = relUrl url
       in EntryV1 channel channel updated channel (Left $ SubSection self)
 
 type VersionedAPI (v :: Nat) = Auth '[SA.BasicAuth, SA.JWT] SafeUser :> BaseAPI v
@@ -133,7 +174,7 @@ handler auth = catalogRoot :<|> catalogChannels
   where
     catalogChannels :: Channel.ChannelID -> AppM (Catalog v)
     -- Channel specific catalog returns tags inside the catalog
-    catalogChannels _ = throwM err403{errBody="Not implemented"}
+    catalogChannels identifier = flip requireLoggedIn auth (getBooks identifier)
     catalogRoot :: AppM (Catalog v)
     -- catalog root returns channels
     catalogRoot = flip requireLoggedIn auth getChannels

backend/src/API/Channels.hs

@@ -0,0 +1,82 @@
+{-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE DeriveGeneric         #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NamedFieldPuns        #-}
+{-# LANGUAGE NoImplicitPrelude     #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE RecordWildCards       #-}
+{-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE TypeApplications      #-}
+{-# LANGUAGE TypeFamilies          #-}
+{-# LANGUAGE TypeOperators         #-}
+module API.Channels (API, handler, JsonChannel(..)) where
+
+import           ClassyPrelude
+import           Control.Lens
+import           Control.Monad.Catch   (throwM)
+import           Control.Monad.Logger
+import           Data.Aeson
+import           Data.Generics.Product
+import           Database
+import           Database.Channel
+import           Servant
+import           Servant.Auth          as SA
+import qualified Servant.Docs          as Docs
+import           Server.Auth
+import           Types
+
+data JsonChannel = JsonChannel { channel    :: Text
+                               , visibility :: Visibility }
+                 deriving (Show, Generic)
+data UpdateChannel = UpdateChannel { identifier :: ChannelID
+                                   , channel    :: Text
+                                   , visibility :: Visibility }
+                 deriving (Show, Generic)
+
+instance Docs.ToSample JsonChannel where
+  toSamples _ = [("Channel", JsonChannel "channel" Private)]
+
+instance Docs.ToSample UpdateChannel where
+  toSamples _ = [("Channel", UpdateChannel 13 "channel" Private)]
+
+instance ToJSON JsonChannel
+instance FromJSON JsonChannel
+instance ToJSON UpdateChannel
+instance FromJSON UpdateChannel
+
+type API = Auth '[SA.BasicAuth, SA.Cookie, SA.JWT] SafeUser :> BaseAPI
+
+type BaseAPI = "channels" :> ReqBody '[JSON] JsonChannel :> Post '[JSON] UpdateChannel
+          :<|> "channels" :> Capture "channel_id" ChannelID :> ReqBody '[JSON] UpdateChannel :> Put '[JSON] UpdateChannel
+          :<|> "channels" :> Get '[JSON] [JsonChannel]
+
+handler :: ServerT API AppM
+handler user = newChannelHandler user :<|> updateChannelHandler user :<|> listChannelsHandler user
+
+requireChannelOwner :: AuthResult SafeUser -> ChannelID -> (SafeUser -> AppM a) -> AppM a
+requireChannelOwner auth channelId f = flip requireLoggedIn auth $ \u@SafeUser{username} -> do
+  unlessM (runDB . channelExists $ channelId) $ throwM err404
+  runDB (isChannelOwner channelId username) >>= \o -> if o then f u else throwM err403
+
+updateChannelHandler :: AuthResult SafeUser -> ChannelID -> UpdateChannel -> AppM UpdateChannel
+updateChannelHandler auth channelId UpdateChannel{visibility} = requireChannelOwner auth channelId $ \_ -> do
+  mChannel <- fmap toChannel <$> runDB (updateChannelPrivacy channelId visibility)
+  maybe (throwM err403) return mChannel
+
+listChannelsHandler :: AuthResult SafeUser -> AppM [JsonChannel]
+listChannelsHandler = requireLoggedIn $ \user ->
+  -- I could use the super thing from generic-lens, but then I would need to
+  -- use the 'channel' accessor somehow or export it
+  fmap (\Channel{..} -> JsonChannel{..}) <$> runDB (userChannels (view (field @"username") user))
+
+newChannelHandler :: AuthResult SafeUser -> JsonChannel -> AppM UpdateChannel
+newChannelHandler auth JsonChannel{..} = flip requireLoggedIn auth $ \user -> do
+  $logInfo $ "Creating channel for user " <> pack (show user)
+  mChannel <- fmap toChannel <$> runDB (insertChannel (view (field @"username") user) channel visibility)
+  maybe (throwM err403{errBody="Could not create the channel"}) return mChannel
+
+toChannel :: Channel -> UpdateChannel
+toChannel Channel{..} = UpdateChannel{..}

backend/src/API/Users.hs

@@ -1,23 +1,25 @@
-{-# Language DataKinds #-}
+{-# LANGUAGE DataKinds             #-}
-{-# Language TypeFamilies #-}
+{-# LANGUAGE DuplicateRecordFields #-}
-{-# Language OverloadedStrings #-}
+{-# LANGUAGE NoImplicitPrelude     #-}
-{-# Language NoImplicitPrelude #-}
+{-# LANGUAGE OverloadedStrings     #-}
-{-# Language TypeOperators #-}
+{-# LANGUAGE TypeApplications      #-}
-{-# Language DuplicateRecordFields #-}
+{-# LANGUAGE TypeFamilies          #-}
-{-# Language TypeApplications #-}
+{-# LANGUAGE TypeOperators         #-}
 module API.Users  where
 
-import Servant
 import           ClassyPrelude
-import Types
+import           Control.Monad.Catch (throwM)
 import           Data.Aeson
-import Web.FormUrlEncoded
 import           Database            (runDB)
-import Database.User
 import           Database.Schema
-import Server.Auth
+import           Database.User
-import Servant.Auth.Server as SAS
+import           Servant
 import           Servant.Auth        as SA
+import           Servant.Auth.Server as SAS
+import qualified Servant.Docs        as Docs
+import           Server.Auth
+import           Types
+import           Web.FormUrlEncoded
 
 
 data RegisterForm = RegisterForm { username      :: Username
@@ -26,12 +28,17 @@ data RegisterForm = RegisterForm { username :: Username
                                  , passwordAgain :: PlainPassword }
                   deriving (Generic, Show)
 
+instance Docs.ToSample RegisterForm
+
 data LoginStatus = LoginStatus ( Maybe SafeUser ) deriving Generic
 
 data RegisterStatus = RegisterStatus deriving Generic
 
+instance Docs.ToSample RegisterStatus
+
 instance ToJSON LoginStatus
 instance FromJSON LoginStatus
+instance Docs.ToSample LoginStatus
 
 instance FromJSON RegisterForm
 instance ToJSON RegisterForm

backend/src/Configuration.hs

@@ -9,15 +9,20 @@ import Dhall (Interpret)
 data Pg = Pg { username :: Text
              , password :: Text
              , host :: Text
-             , database :: Text }
+             , database :: Text
+             , migrations :: Text }
         deriving (Show, Generic)
 
-newtype Store = Store { path :: Text } deriving (Show, Generic)
+data Store = Filestore { path :: Text }
+           | IPFS { common :: Text }
+           deriving (Show, Generic)
 
 data Config = Config { database :: Pg
-                     , store :: Store }
+                     , store :: Store
+                     , port :: Integer }
             deriving (Show, Generic)
 
 instance Interpret Pg
 instance Interpret Store
 instance Interpret Config
+

backend/src/Database.hs

@@ -11,18 +11,21 @@ module Database
   , fromRel
   , fromRels
   , toRel
+  , transaction
   , SeldaT )
   where
 
-import Data.Generics.Product
-import Control.Lens (view)
-import Data.Pool (Pool, withResource)
-import Database.Selda.Backend (SeldaConnection, runSeldaT, SeldaT)
-import Database.Selda (query, select)
-import Database.Selda.Generic (gen, fromRel, fromRels, toRel)
 import ClassyPrelude
+import Control.Lens (view)
+import Control.Monad.Catch (MonadMask)
+import Control.Monad.Trans.Control (MonadBaseControl)
+import Data.Generics.Product
+import Data.Pool (Pool, withResource)
+import Database.Selda (query, select, transaction)
+import Database.Selda.Backend (SeldaConnection, runSeldaT, SeldaT)
+import Database.Selda.Generic (gen, fromRel, fromRels, toRel)
 
-type DBLike r m = (MonadIO m, MonadReader r m, MonadBaseControl IO m, MonadMask m, HasField' "database" r (Pool SeldaConnection))
+type DBLike r m = (MonadBaseControl IO m, MonadIO m, MonadReader r m, HasField "database" r r (Pool SeldaConnection) (Pool SeldaConnection), MonadMask m)
 
 runDB :: DBLike r m => SeldaT m a -> m a
 runDB q = do

backend/src/Database/Book.hs

@@ -18,12 +18,17 @@ module Database.Book
   , BookID) where
 
 import ClassyPrelude
-import Database.Schema
+import Control.Lens (view)
+import Control.Monad.Catch (MonadCatch)
+import Data.Generics.Product
 import Database
+import Database.Channel (booksChannels, attachChannel, clearChannels)
+import Database.Schema (books, users, Username, Book(..), BookID(..), UserID, HashDigest(..))
 import Database.Selda
 import Database.Selda.Generic
+import Database.Tag (booksTags, attachTag, clearTags)
 
-usersBooks :: (MonadSelda m, MonadMask m, MonadIO m) => Username -> m [Book]
+usersBooks :: (MonadSelda m, MonadIO m) => Username -> m [Book]
 usersBooks username = fromRels <$> query q
   where
     q = do
@@ -35,7 +40,7 @@ usersBooks username = fromRels <$> query q
       return book
 
 
-getBook :: (MonadSelda m, MonadMask m, MonadIO m) => BookID -> Username -> m (Maybe Book)
+getBook :: (MonadSelda m, MonadIO m) => BookID -> Username -> m (Maybe Book)
 getBook identifier owner = listToMaybe . fromRels <$> query q
   where
     q = do
@@ -45,12 +50,12 @@ getBook identifier owner = listToMaybe . fromRels <$> query q
       return book
 
 data InsertBook = InsertBook { contentType :: Text
-                             , title :: Maybe Text
+                             , title :: Text
                              , description :: Maybe Text
                              , owner :: Username }
 
 -- Always inserts
-insertBook :: (MonadSelda m, MonadMask m, MonadIO m) => InsertBook -> m (Maybe BookID)
+insertBook :: (MonadSelda m, MonadIO m) => InsertBook -> m (Maybe BookID)
 insertBook InsertBook{..} = do
   mUserId <- query $ do
     userId :*: _ :*: username' :*: _ <- select (gen users)
@@ -62,11 +67,14 @@ insertBook InsertBook{..} = do
 
 data UpdateBook = UpdateBook { identifier :: BookID
                              , contentType :: Text
-                             , title :: Maybe Text
+                             , title :: Text
                              , description :: Maybe Text
-                             , owner :: Username }
+                             , owner :: Username
+                             , tags :: [Text]
+                             , channels :: [Text] }
+                deriving (Show, Generic)
 
-bookExists :: (MonadSelda m, MonadMask m, MonadIO m) => BookID -> m Bool
+bookExists :: (MonadSelda m, MonadIO m) => BookID -> m Bool
 bookExists identifier = not . null <$> query q
   where
     q = do
@@ -74,7 +82,7 @@ bookExists identifier = not . null <$> query q
       restrict (bookId .== literal identifier)
       return bookId
 
-isBookOwner :: (MonadSelda m, MonadIO m, MonadThrow m) => BookID -> Username -> m Bool
+isBookOwner :: (MonadSelda m, MonadIO m) => BookID -> Username -> m Bool
 isBookOwner identifier username = not . null <$> query (bookOwner' identifier username)
 
 bookOwner' :: BookID -> Username -> Query s (Col s UserID :*: Col s BookID)
@@ -86,19 +94,34 @@ bookOwner' identifier username = do
   restrict (bookId .== literal identifier)
   return (userId :*: bookId)
 
-updateBook :: (MonadSelda m, MonadMask m, MonadIO m) => UpdateBook -> m (Maybe UpdateBook)
+updateBook :: (MonadCatch m, MonadSelda m, MonadIO m) => UpdateBook -> m (Maybe UpdateBook)
-updateBook book@UpdateBook{..} = do
+updateBook UpdateBook{..} = do
+  clearTags identifier >> connectTags
+  clearChannels identifier >> connectChannels
+  updateBook'
+  getUpdateBook identifier owner
+  where
+    connectTags = mapM_ (attachTag owner identifier) tags
+    connectChannels = mapM_ (attachChannel owner identifier) channels
+    updateBook' = do
       mUserId <- query (bookOwner' identifier owner)
-  forM (listToMaybe mUserId) $ \_userId -> do
+      forM_ (listToMaybe mUserId) $ \_userId -> do
         update_ (gen books) predicate (\b -> b `with` [ pContentType := literal contentType
                                                       , pTitle := literal title
                                                       , pDescription := literal description ])
-    return book
-  where
     _ :*: _ :*: pContentType :*: pTitle :*: pDescription :*: _ = selectors (gen books)
     predicate (bookId :*: _) = bookId .== literal identifier
 
-setContent :: (MonadSelda m, MonadMask m, MonadIO m) => BookID -> Username -> HashDigest -> m ()
+
+getUpdateBook :: (MonadIO m, MonadSelda m) => BookID -> Username -> m (Maybe UpdateBook)
+getUpdateBook bookId username = do
+  mBook <- getBook bookId username
+  forM mBook $ \Book{..} -> do
+    channels <- map (view (field @"channel")) <$> booksChannels bookId
+    tags <- map (view (field @"tag")) <$> booksTags bookId
+    return UpdateBook{owner=username,..}
+
+setContent :: (MonadSelda m, MonadIO m) => BookID -> Username -> HashDigest -> m ()
 setContent identifier owner digest = do
   mOwner <- query (bookOwner' identifier owner)
   void $ forM (listToMaybe mOwner) $ \_ ->

backend/src/Database/Channel.hs

@@ -0,0 +1,128 @@
+{-# Language TypeApplications #-}
+{-# Language DataKinds #-}
+{-# Language NamedFieldPuns #-}
+module Database.Channel
+  ( userChannels
+  , insertChannel
+  , channelExists
+  , isChannelOwner
+  , updateChannelPrivacy
+  , attachChannel
+  , Visibility(..)
+  , clearChannels
+  , booksChannels
+  , channelBooks
+  , Channel(..)
+  , ChannelID(..) )
+  where
+
+import ClassyPrelude
+import Control.Monad.Catch (MonadMask)
+import Database
+import Database.Schema
+import Database.Selda
+import Database.Selda.Generic
+
+import Control.Monad.Trans.Maybe
+
+getChannel :: (MonadSelda m, MonadIO m) => ChannelID -> m (Maybe Channel)
+getChannel identifier = listToMaybe . fromRels <$> query q
+  where
+    q = do
+      ch@(channelId :*: _) <- select (gen channels)
+      restrict (channelId .== literal identifier)
+      return ch
+
+channelExists :: (MonadSelda m, MonadIO m) => ChannelID -> m Bool
+channelExists identifier = not . null <$> getChannel identifier
+
+isChannelOwner :: (MonadSelda m, MonadIO m) => ChannelID -> Username -> m Bool
+isChannelOwner identifier username = not . null <$> query q
+  where
+    q = do
+      userId :*: _ :*: username' :*: _ <- select (gen users)
+      channelId :*: _ :*: channelOwner :*: _ <- select (gen channels)
+      restrict (userId .== channelOwner)
+      restrict (username' .== literal username)
+      restrict (channelId .== literal identifier)
+      return channelId
+
+userChannels :: (MonadMask m, MonadIO m) => Username -> SeldaT m [Channel]
+userChannels username = fromRels <$> query q
+  where
+    q = do
+      userId :*: _ :*: username' :*: _ <- select (gen users)
+      channel@(_ :*: _ :*: owner :*: _) <- select (gen channels)
+      restrict (owner .== userId)
+      restrict (username' .== literal username)
+      return channel
+
+updateChannelPrivacy :: (MonadIO m, MonadSelda m) => ChannelID -> Visibility -> m (Maybe Channel)
+updateChannelPrivacy channelId visibility = do
+  void $ update (gen channels) predicate (\channel -> channel `with` [pVis := literal visibility])
+  getChannel channelId
+  where
+    predicate (channelId' :*: _) = channelId' .== literal channelId
+    _ :*: _ :*: _ :*: pVis = selectors (gen channels)
+
+insertChannel :: (MonadMask m, MonadIO m, MonadSelda m) => Username -> Text -> Visibility -> m (Maybe Channel)
+insertChannel username channel visibility = runMaybeT $ do
+  userId <- MaybeT (listToMaybe <$> getUser)
+  channelId <- toChannelId <$> MaybeT (insertUnless (gen channels) (doesNotExist userId) [ def :*: channel :*: userId :*: visibility ])
+  MaybeT (listToMaybe . fromRels <$> query (q channelId))
+  where
+    q channelId = do
+      ch@(channelId' :*: _) <- select (gen channels)
+      restrict (channelId' .== literal channelId)
+      return ch
+    toChannelId = ChannelID . fromRowId
+    doesNotExist userId (_ :*: channel' :*: userId' :*: _) = channel' .== literal channel .&& userId' .== literal userId
+    getUser = query $ do
+      userId :*: _ :*: user :*: _ <- select (gen users)
+      restrict (user .== literal username)
+      return userId
+
+channelBooks :: (MonadSelda m, MonadIO m) => Username -> ChannelID -> m [Book]
+channelBooks username identifier = fromRels <$> query q
+  where
+    q = do
+      channelId :*: bookId' <- select (gen bookChannels)
+      channelId' :*: _ :*: owner :*: _ <- select (gen channels)
+      userId :*: _ :*: username' :*: _ <- select (gen users)
+      book@(bookId :*: _) <- select (gen books)
+      restrict (username' .== literal username .&& owner .== userId)
+      restrict (channelId .== literal identifier .&& channelId .== channelId')
+      restrict (bookId .== bookId')
+      return book
+
+booksChannels :: (MonadSelda m, MonadIO m) => BookID -> m [Channel]
+booksChannels bookId = fromRels <$> query q
+  where
+    q = do
+      channelId :*: bookId' <- select (gen bookChannels)
+      ch@(channelId' :*: _) <- select (gen channels)
+      restrict (channelId .== channelId')
+      restrict (bookId' .== literal bookId)
+      return ch
+
+attachChannel :: (MonadIO m, MonadSelda m) => Username -> BookID -> Text -> m ()
+attachChannel username bookId channel = do
+  mCh <- fromRels <$> query channelQ
+  forM_ mCh $ \Channel{identifier} ->
+    whenM (null <$> query (attachQ identifier)) $
+      void $ insertGen bookChannels [BookChannel identifier bookId]
+  where
+    attachQ channelId = do
+      (channelId' :*: bookId') <- select (gen bookChannels)
+      restrict (channelId' .== literal channelId .&& bookId' .== literal bookId)
+      return channelId'
+    channelQ = do
+      userId :*: _ :*: username' :*: _ <- select (gen users)
+      ch@(_ :*: channel' :*: owner :*: _) <- select (gen channels)
+      restrict (username' .== literal username)
+      restrict (owner .== userId)
+      restrict (channel' .== literal channel)
+      return ch
+
+clearChannels :: (MonadIO m, MonadSelda m) => BookID -> m Int
+clearChannels bookId = deleteFrom (gen bookChannels) (\(_ :*: bookId') -> bookId' .== literal bookId)

backend/src/Database/Schema.hs

@@ -1,26 +1,39 @@
-{-# Language NoImplicitPrelude #-}
+{-# LANGUAGE DeriveGeneric              #-}
-{-# Language DeriveGeneric #-}
+{-# LANGUAGE DuplicateRecordFields      #-}
-{-# Language OverloadedStrings #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# Language DuplicateRecordFields #-}
+{-# LANGUAGE NoImplicitPrelude          #-}
-{-# Language GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE OverloadedStrings          #-}
+{-# LANGUAGE DataKinds          #-}
+{-# LANGUAGE TypeSynonymInstances          #-}
+{-# LANGUAGE FlexibleInstances          #-}
 module Database.Schema where
 
 import           ClassyPrelude
-import Database.Selda.Generic
+import           Data.Aeson
 import           Database.Selda
 import           Database.Selda.Backend
-
+import           Database.Selda.Generic
-import Data.Aeson
+import qualified Servant.Docs           as Docs
+import Servant (Capture)
 import           Web.HttpApiData
 
 -- | User type
-newtype PlainPassword = PlainPassword Text deriving (Show, ToJSON, FromJSON, ToHttpApiData, FromHttpApiData, Eq)
+newtype PlainPassword = PlainPassword Text deriving (Show, ToJSON, FromJSON, ToHttpApiData, FromHttpApiData, Eq, Generic)
 newtype HashedPassword = HashedPassword {unHashed :: ByteString}
 data NoPassword = NoPassword
 
-newtype Email = Email { unEmail :: Text } deriving (Show, ToJSON, FromJSON, ToHttpApiData, FromHttpApiData)
+newtype Email = Email { unEmail :: Text } deriving (Show, ToJSON, FromJSON, ToHttpApiData, FromHttpApiData, Generic, Eq, IsString)
 
-newtype Username = Username { unUsername :: Text } deriving (Show, ToJSON, FromJSON, ToHttpApiData, FromHttpApiData)
+newtype Username = Username { unUsername :: Text } deriving (Show, ToJSON, FromJSON, ToHttpApiData, FromHttpApiData, Eq, Generic, IsString)
+
+instance Docs.ToSample Username where
+  toSamples _ = [("Username", Username "user123")]
+
+instance Docs.ToSample Email where
+  toSamples _ = [("Email", Email "first.last@example.com")]
+
+instance Docs.ToSample PlainPassword where
+  toSamples _ = [("Password", PlainPassword "password123")]
 
 instance SqlType HashedPassword where
   mkLit = LCustom . LBlob . unHashed
@@ -42,9 +55,15 @@ instance SqlType Username where
 
 newtype UserID = UserID {unUserID :: Int} deriving (Show)
 
-newtype BookID = BookID {unBookID :: Int} deriving (Show, ToJSON, FromJSON, FromHttpApiData, Eq, Ord)
+newtype BookID = BookID {unBookID :: Int} deriving (Show, ToJSON, FromJSON, FromHttpApiData, Eq, Ord, ToHttpApiData, Generic, Num)
 
-newtype ChannelID = ChannelID {unChannelID :: Int} deriving (Show, ToHttpApiData, FromHttpApiData)
+instance Docs.ToCapture (Capture "book_id" BookID) where
+  toCapture _ = Docs.DocCapture "book_id" "The book id"
+
+newtype ChannelID = ChannelID {unChannelID :: Int} deriving (Show, ToHttpApiData, FromHttpApiData, ToJSON, FromJSON, Eq, Generic, Num)
+
+instance Docs.ToCapture (Capture "channel_id" ChannelID) where
+  toCapture _ = Docs.DocCapture "channel_id" "The channel id"
 
 newtype TagID = TagID {unTagID :: Int} deriving (Show)
 
@@ -77,7 +96,7 @@ data User pass = User { identifier :: UserID
                       , password   :: pass }
           deriving (Show, Generic)
 
-data Role = UserRole | AdminRole deriving (Show, Read, Enum, Bounded, Typeable, Generic)
+data Role = UserRole | AdminRole deriving (Show, Read, Enum, Bounded, Typeable, Generic, Eq)
 
 instance ToJSON Role
 instance FromJSON Role
@@ -101,7 +120,7 @@ newtype HashDigest = HashDigest { unHex :: ByteString } deriving Show
 data Book = Book { identifier  :: BookID
                  , contentHash :: Maybe HashDigest
                  , contentType :: Text
-                 , title :: Maybe Text
+                 , title       :: Text
                  , description :: Maybe Text
                  , owner       :: UserID }
           deriving (Show, Generic)
@@ -124,9 +143,22 @@ data Tag = Tag { identifier :: TagID
                , owner      :: UserID }
          deriving (Show, Generic)
 
+data Visibility = Public | Private | Followers
+                deriving (Show, Read, Generic, Eq)
+
+instance ToJSON Visibility
+instance FromJSON Visibility
+
+instance SqlType Visibility where
+  mkLit = LCustom . LText . pack . show
+  fromSql (SqlString x) = fromMaybe (error "fromSql: Not a valid visibility token") . readMay . unpack $ x
+  fromSql _             = error "fromSql: Not a valid visibility token"
+  defaultValue = mkLit Private
+
 data Channel = Channel { identifier :: ChannelID
                        , channel    :: Text
-                       , owner :: UserID }
+                       , owner      :: UserID
+                       , visibility :: Visibility }
              deriving (Show, Generic)
 
 tags :: GenTable Tag

backend/src/Database/Tag.hs

@@ -0,0 +1,62 @@
+{-# Language TypeApplications #-}
+{-# Language TypeOperators #-}
+{-# Language DataKinds #-}
+{-# Language DuplicateRecordFields #-}
+{-# Language NamedFieldPuns #-}
+module Database.Tag
+  ( def
+  , booksTags
+  , attachTag
+  , upsertTag
+  , clearTags
+  , Tag(..) ) where
+
+import ClassyPrelude
+import Control.Monad.Catch (MonadCatch)
+import Control.Monad.Trans.Maybe
+import Database
+import Database.Schema
+import Database.Selda
+import Database.Selda.Generic
+
+upsertTag :: (MonadCatch m, MonadIO m, MonadSelda m) => Username -> Text -> m (Maybe Tag)
+upsertTag username tag = runMaybeT $ do
+  userId <- MaybeT (listToMaybe <$> query userQ)
+  void $ lift $ upsert (gen tags) (predicate userId) id [toRel (Tag def tag userId)]
+  MaybeT (listToMaybe . fromRels <$> query (tagQ userId))
+  where
+    predicate userId (_ :*: tag' :*: owner) = tag' .== literal tag .&& owner .== literal userId
+    tagQ userId = do
+      t@(_ :*: tag' :*: owner) <- select (gen tags)
+      restrict (tag' .== literal tag .&& owner .== literal userId)
+      return t
+    userQ = do
+      userId :*: _ :*: username' :*: _ <- select (gen users)
+      restrict (username' .== literal username)
+      return userId
+
+booksTags :: (MonadIO m, MonadSelda m) => BookID -> m [Tag]
+booksTags bookId = fromRels <$> query q
+  where
+    q = do
+      tagId :*: bookId' <- select (gen bookTags)
+      tag@(tagId' :*: _) <- select (gen tags)
+      restrict (tagId .== tagId')
+      restrict (bookId' .== literal bookId)
+      return tag
+
+attachTag :: (MonadCatch m, MonadIO m, MonadSelda m) => Username -> BookID -> Text -> m ()
+attachTag username bookId tag = do
+  maybeT <- upsertTag username tag
+  forM_ maybeT $ \Tag{identifier} -> do
+    whenM (null <$> query (tagQ identifier)) $
+      void $ insertGen bookTags [BookTag identifier bookId]
+  where
+    tagQ tagId = do
+      (tagId' :*: bookId') <- select (gen bookTags)
+      restrict (tagId' .== literal tagId .&& bookId' .== literal bookId)
+      return tagId'
+
+clearTags :: (MonadIO m, MonadSelda m) => BookID -> m Int
+clearTags bookId = deleteFrom (gen bookTags) (\(_ :*: bookId') -> bookId' .== literal bookId)
+

backend/src/Database/User.hs

@@ -5,20 +5,21 @@
 module Database.User where
 
 import ClassyPrelude
+import Control.Lens (view, over, _Just)
+import Control.Monad (mfilter)
+import Control.Monad.Catch (MonadMask)
+import Control.Monad.Logger
+import Crypto.KDF.BCrypt
+import Crypto.Random.Types (MonadRandom)
+import Data.Generics.Product
 import Database
 import Database.Schema
 import Database.Selda
-import Control.Lens (view, over, _Just)
-import Data.Generics.Product
-import Crypto.KDF.BCrypt
-import Crypto.Random.Types (MonadRandom)
-import Control.Monad.Logger
-import Control.Monad (mfilter)
 
 data UserExistsError = UserExistsError
 
 
-insertUser :: (MonadLogger m, MonadIO m, MonadMask m, MonadRandom m) => Username -> Email -> PlainPassword -> SeldaT m (Either UserExistsError (User NoPassword))
+insertUser :: (MonadMask m, MonadLogger m, MonadIO m, MonadRandom m) => Username -> Email -> PlainPassword -> SeldaT m (Either UserExistsError (User NoPassword))
 insertUser username email (PlainPassword password) =
   getUser' username >>= maybe insert' (const (return $ Left UserExistsError))
   where

backend/src/Datastore.hs

@@ -5,6 +5,7 @@
 {-# Language FlexibleContexts #-}
 {-# Language TypeSynonymInstances #-}
 {-# Language FlexibleInstances #-}
+{-# Language ScopedTypeVariables #-}
 module Datastore where
 
 import ClassyPrelude
@@ -28,26 +29,26 @@ instance MonadDS AppM where
   get = getLocal
 
 putLocal :: ( MonadIO m
-            , HasField' "config" r config
+            , HasField "config" r r config config
-            , HasField' "store" config store
+            , HasField "store" config config store store
-            , HasField' "path" store Text
+            , HasType Text store
             , MonadReader r m)
             => ByteString -> m (Digest SHA256)
 putLocal bs = do
-  store <- unpack <$> view (field @"config" . field @"store" . field @"path")
+  store :: FilePath <- unpack <$> view (field @"config" . field @"store" . typed @Text)
   liftIO $ createDirectoryIfMissing True store
   let key = hashWith SHA256 bs
   writeFile (store </> show key) bs
   return key
 
 getLocal :: ( MonadIO m
-            , HasField' "config" r config
+            , HasField "config" r r config config
-            , HasField' "store" config store
+            , HasField "store" config config store store
-            , HasField' "path" store Text
+            , HasType Text store
             , MonadReader r m)
             => Digest SHA256 -> m (Maybe ByteString)
 getLocal key = do
-  store <- unpack <$> view (field @"config" . field @"store" . field @"path")
+  store <- unpack <$> view (field @"config" . field @"store" . typed @Text)
   liftIO $ createDirectoryIfMissing True store
   let file = store </> show key
   exists <- liftIO $ doesFileExist file

backend/src/Devel/Main.hs

@@ -3,19 +3,18 @@
 {-# Language FlexibleContexts #-}
 module Devel.Main where
 
-import Prelude
-import Control.Monad.Trans.Reader (runReaderT)
-import Main (withApp, defaultMain)
 import Control.Concurrent
 import Control.Monad (void)
+import Control.Monad.Trans.Reader (runReaderT)
 import Data.IORef (IORef, newIORef, readIORef, writeIORef)
-import Foreign.Store (Store(..), lookupStore, readStore, storeAction, withStore)
+import Database
-import GHC.Word (Word32)
-import Dhall (input, auto)
-
 import Database.Schema
 import Database.Selda (tryCreateTable)
-import Database
+import Dhall (input, auto)
+import Foreign.Store (Store(..), lookupStore, readStore, storeAction, withStore)
+import GHC.Word (Word32)
+import Main (withApp, defaultMain)
+import Prelude
 
 update :: IO ()
 update = do
@@ -37,7 +36,7 @@ update = do
 
 develMain :: IO ()
 develMain = do
-  conf <- input auto "./config/devel.dhall"
+  conf <- input auto "../config/devel.dhall"
   withApp conf $ \app -> do
     void $ runReaderT (runDB migrate) app
     defaultMain app

backend/src/Main.hs

@@ -0,0 +1,42 @@
+{-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE NoImplicitPrelude     #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE RecordWildCards       #-}
+{-# LANGUAGE TypeApplications      #-}
+module Main where
+
+import           ClassyPrelude
+import           Configuration
+import           Control.Lens              (view, to)
+import           Data.Generics.Product
+import           Data.Pool                 (createPool)
+import           Database.Selda.PostgreSQL (PGConnectInfo (..), pgOpen,
+                                            seldaClose)
+import           Dhall                     (auto, input)
+import           Network.Wai.Handler.Warp  (run)
+import           Servant.Auth.Server       (generateKey)
+import           Server                    (server)
+import           Types
+import System.Environment (getEnvironment)
+
+defaultMain :: App -> IO ()
+defaultMain app = run (view (field @"config" . field @"port" . to fromIntegral) app) $ server app
+
+withApp :: Config -> (App -> IO ()) -> IO ()
+withApp config f = do
+  let pgHost = view (field @"database" . field @"host") config
+      pgPort = 5432
+      pgSchema = Nothing
+      pgDatabase = view (field @"database" . field @"database") config
+      pgUsername = Just (view (field @"database" . field @"username") config)
+      pgPassword = Just (view (field @"database" . field @"password") config)
+  database <- createPool (pgOpen (PGConnectInfo{..})) seldaClose 10 2 5
+  jwk <- generateKey
+  f App{..}
+
+main :: IO ()
+main = do
+  path <- fmap pack . lookup "CONF" <$> getEnvironment
+  c <- input auto (fromMaybe "./config/config.dhall" path)
+  withApp c defaultMain

backend/src/Server.hs

@@ -0,0 +1,45 @@
+{-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NoImplicitPrelude     #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE ScopedTypeVariables   #-}
+{-# LANGUAGE TypeApplications      #-}
+{-# LANGUAGE TypeFamilies          #-}
+{-# LANGUAGE TypeOperators         #-}
+module Server where
+
+import qualified API
+import           ClassyPrelude         hiding (Handler)
+import           Control.Lens
+import           Control.Monad.Except
+import           Control.Monad.Logger
+import           Data.Generics.Product
+import           Servant
+import           Servant.Auth.Docs     ()
+import           Servant.Auth.Server   as SAS
+import qualified Servant.Docs          as Docs
+import           Servant.HTML.Lucid    (HTML)
+import           Server.Auth           (SafeUser, authCheck)
+import           Types
+
+type API = API.API
+  :<|> "api" :> "help" :> Get '[PlainText, HTML] String
+
+type Ctx = '[BasicAuthData -> IO (AuthResult SafeUser), CookieSettings, JWTSettings]
+
+server :: App -> Application
+server app = serveWithContext api cfg (hoistServerWithContext (Proxy @ API.API) (Proxy @ Ctx) server' API.handler :<|> serveDocs)
+  where
+    apiDocs :: Docs.API
+    apiDocs = Docs.docs (Proxy @API.API)
+    serveDocs = pure $ Docs.markdown apiDocs
+    myKey = view (field @"jwk") app
+    jwtCfg = defaultJWTSettings myKey
+    authCfg = authCheck app
+    cookieSettings = SAS.defaultCookieSettings{cookieIsSecure=SAS.NotSecure}
+    cfg = jwtCfg :. cookieSettings :. authCfg :. EmptyContext
+    server' :: AppM a -> Servant.Handler a
+    server' = Handler . ExceptT . try . (`runReaderT` app) . runFileLoggingT "logs/server.log"
+    api :: Proxy API
+    api = Proxy

backend/src/Server/Auth.hs

@@ -1,11 +1,11 @@
-{-# Language DataKinds #-}
+{-# LANGUAGE DataKinds             #-}
-{-# Language TypeFamilies #-}
+{-# LANGUAGE DuplicateRecordFields #-}
-{-# Language OverloadedStrings #-}
+{-# LANGUAGE NoImplicitPrelude     #-}
-{-# Language NoImplicitPrelude #-}
+{-# LANGUAGE OverloadedStrings     #-}
-{-# Language TypeOperators #-}
+{-# LANGUAGE TemplateHaskell       #-}
-{-# Language DuplicateRecordFields #-}
+{-# LANGUAGE TypeApplications      #-}
-{-# Language TypeApplications #-}
+{-# LANGUAGE TypeFamilies          #-}
-{-# Language TemplateHaskell #-}
+{-# LANGUAGE TypeOperators         #-}
 module Server.Auth
   ( SafeUser(..)
   , authCheck
@@ -14,16 +14,18 @@ module Server.Auth
   where
 
 import           ClassyPrelude
-import Servant.Auth.Server as SAS
+import           Control.Lens          (view)
+import           Control.Monad.Catch   (MonadThrow, throwM)
+import           Control.Monad.Logger
 import           Data.Aeson
+import           Data.Generics.Product
+import           Database
 import           Database.Schema
 import           Database.User
-import Database
-import Types
-import Control.Lens (view)
-import Data.Generics.Product
 import           Servant               (err401)
-import Control.Monad.Logger
+import           Servant.Auth.Server   as SAS
+import qualified Servant.Docs          as Docs
+import           Types
 
 -- generic-lens can convert similar types to this
 -- I'm trying out servant-auth-server which uses a jwt style login. IIRC anyone
@@ -35,6 +37,9 @@ data SafeUser = SafeUser { email :: Email
                          , role     :: Role }
               deriving (Show, Generic)
 
+instance Docs.ToSample SafeUser where
+  toSamples _ = [("User", SafeUser "user@example.com" "user" UserRole )]
+
 instance ToJSON SafeUser where
 instance FromJSON SafeUser where
 instance ToJWT SafeUser where
@@ -53,6 +58,6 @@ authCheck app (BasicAuthData username password) = flip runReaderT app $
     password' = PlainPassword $ decodeUtf8 password
     authenticated = SAS.Authenticated . view (super @SafeUser)
 
-requireLoggedIn :: (MonadLogger m, MonadThrow m, Monad m) => (SafeUser -> m a) -> AuthResult SafeUser -> m a
+requireLoggedIn :: (MonadThrow m, MonadLogger m, Monad m) => (SafeUser -> m a) -> AuthResult SafeUser -> m a
 requireLoggedIn f (Authenticated user) = f user
 requireLoggedIn _ u = $logError (pack (show u)) >> throwM err401

backend/src/Spec.hs

@@ -0,0 +1,66 @@
+{-# LANGUAGE TypeApplications #-}
+module Main where
+
+import           API.Books
+import qualified Data.Aeson            as A
+import           Data.Char             (isPrint)
+import           Data.GenValidity.Text ()
+import qualified Data.Text             as T
+import           Database.Schema
+import           Prelude
+import           Test.Hspec
+import           Test.Validity
+import           Test.Validity.Aeson
+
+instance GenUnchecked PlainPassword
+instance GenValid PlainPassword
+instance GenInvalid PlainPassword
+instance Validity PlainPassword
+instance GenUnchecked Email
+instance GenValid Email
+instance GenInvalid Email
+instance Validity Email
+instance GenUnchecked Username
+instance GenValid Username
+instance GenInvalid Username
+instance Validity Username
+instance GenUnchecked BookID
+instance GenValid BookID
+instance GenInvalid BookID
+instance Validity BookID
+instance GenUnchecked ChannelID
+instance GenValid ChannelID
+instance GenInvalid ChannelID
+instance Validity ChannelID
+instance GenUnchecked Role
+instance GenValid Role
+instance GenInvalid Role
+instance Validity Role
+instance GenUnchecked Visibility
+instance GenValid Visibility
+instance GenInvalid Visibility
+instance Validity Visibility
+instance GenUnchecked JsonBook
+instance GenValid JsonBook
+instance GenInvalid JsonBook
+instance Validity JsonBook
+instance GenUnchecked PostBook
+instance GenValid PostBook
+instance GenInvalid PostBook
+instance Validity PostBook
+
+spec :: Spec
+spec = do
+  describe "JSON encoding" $ do
+    jsonSpecOnValid @PlainPassword
+    jsonSpecOnValid @Email
+    jsonSpecOnValid @Username
+    jsonSpecOnValid @BookID
+    jsonSpecOnValid @ChannelID
+    jsonSpecOnValid @Role
+    jsonSpecOnValid @Visibility
+    jsonSpecOnValid @JsonBook
+    jsonSpecOnValid @PostBook
+
+main :: IO ()
+main = hspec spec

common/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2018, Mats Rauhala
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Mats Rauhala nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

common/common.cabal

@@ -0,0 +1,47 @@
+name:                common
+version:             0.1.0.0
+-- synopsis:
+-- description:
+license:             BSD3
+license-file:        LICENSE
+author:              Mats Rauhala
+maintainer:          mats.rauhala@iki.fi
+-- copyright:
+category:            Web
+build-type:          Simple
+extra-source-files:  ChangeLog.md
+cabal-version:       >=1.10
+
+library
+  exposed-modules:     Data.Versioned
+  -- other-extensions:
+  build-depends:       base >=4.10
+                     , classy-prelude
+                     , generic-lens
+                     , lens
+                     , mtl
+                     , text
+                     , transformers
+  hs-source-dirs:      src
+  default-extensions:  DeriveGeneric
+                     , NoImplicitPrelude
+                     , OverloadedStrings
+                     , RecordWildCards
+  default-language:    Haskell2010
+
+-- test-suite spec
+--   type:                exitcode-stdio-1.0
+--   main-is:             Spec.hs
+--   hs-source-dirs:      src
+--   build-depends:       base >=4.10
+--                      , classy-prelude
+--                      , foreign-store
+--                      , generic-lens
+--                      , lens
+--                      , mtl
+--                      , text
+--                      , transformers
+--                      , validity
+--                      , genvalidity-hspec
+--                      , genvalidity-property
+--                      , hspec

common/src/Spec.hs

@@ -0,0 +1,9 @@
+module Main where
+
+import Test.Hspec
+
+spec :: Spec
+spec = describe "test" $ it "verifies tests work" $ True == True
+
+main :: IO ()
+main = hspec spec

config/Configuration.dhall

@@ -0,0 +1,8 @@
+{ database : { username : Text
+             , password : Text
+             , host : Text
+             , database : Text
+             , migrations : Text }
+, store : < Filestore : { path : Text } | IPFS : { common : Text } >
+, port : Integer
+}

config/config.dhall.sample

@@ -4,5 +4,7 @@
     , password = "password"
     , host = "hostname"
     , database = "ebook"
+    , migrations = "./migrations"
   }
+  store = { path = "/tmp/store" }
 }

default.nix

@@ -1,10 +1,62 @@
-{ mkDerivation, base, stdenv }:
+{ nixpkgs, haskellPackages }:
-mkDerivation {
+
-  pname = "ebook-manager";
+let
-  version = "0.1.0.0";
+  miso = nixpkgs.fetchFromGitHub {
-  src = ./.;
+    owner = "dmjio";
-  isLibrary = false;
+    repo = "miso";
-  isExecutable = true;
+    rev = "630e823dd40a434b73124e12b229a79d9fefb01d";
-  executableHaskellDepends = [ base ];
+    sha256 = "046gdp3ah2lsipfcy89rh20mn08xbhcgrj549v8zzy69j33xjm2l";
-  license = stdenv.lib.licenses.bsd3;
+  };
+  miso-jsaddle = super: if haskellPackages.ghc.isGhcjs or false then (super.callPackage (miso + "/miso-ghcjs.nix") {}) else (super.callPackage (miso + "/miso-ghc-jsaddle.nix") {});
+
+  dontCheck = nixpkgs.haskell.lib.dontCheck;
+
+in
+
+(import ./project.nix nixpkgs) {
+  haskellPackages = haskellPackages;
+  packages = {
+    common = ./common;
+    backend = ./backend;
+    frontend = ./frontend;
+  };
+  overrides = self: super: {
+    generic-lens = nixpkgs.haskell.lib.dontCheck super.generic-lens;
+    miso = miso-jsaddle super;
+    # doctest = null; # Not compilable with ghcjs
+    # comonad = dontCheck super.comonad;
+    # Glob = dontCheck super.Glob;
+    # SHA = dontCheck super.SHA;
+    # iproute = dontCheck super.iproute;
+    # semigroupoids = dontCheck super.semigroupoids;
+    # wai-app-static = dontCheck super.wai-app-static;
+    # attoparsec = dontCheck super.attoparsec;
+    # http-date = dontCheck super.http-date;
+    # lens = dontCheck super.lens;
+    # unix-time = dontCheck super.unix-time;
+    # http-types = dontCheck super.http-types;
+    # servant = dontCheck super.servant;
+    # servant-server = dontCheck super.servant-server;
+    # servant-auth-docs = dontCheck super.servant-auth-docs;
+    # lens-aeson = dontCheck super.lens-aeson;
+    # word8 = dontCheck super.word8;
+    # http2 = dontCheck super.http2;
+    # wai-extra = dontCheck super.wai-extra;
+    # pgp-wordlist = dontCheck super.pgp-wordlist;
+    # prettyprinter = dontCheck super.prettyprinter;
+    # unliftio = dontCheck super.unliftio;
+    # prettyprinter-ansi-terminal = dontCheck super.prettyprinter-ansi-terminal;
+    # distributive = dontCheck super.distributive;
+    # genvalidity-property = dontCheck super.genvalidity-property;
+    # genvalidity-hspec = dontCheck super.genvalidity-hspec;
+    # genvalidity = dontCheck super.genvalidity;
+    # megaparsec = dontCheck super.megaparsec;
+    # ncurses = null;
+    # haskeline = super.callHackage "haskeline" "0.7.4.2" {};
+    # terminfo = super.callHackage "terminfo" "0.4.1.1" {};
+  };
+  tools = with haskellPackages; [
+    ghcid
+    hasktags
+  ];
 }

frontend/ChangeLog.md

@@ -0,0 +1,5 @@
+# Revision history for frontend
+
+## 0.1.0.0 -- YYYY-mm-dd
+
+* First version. Released on an unsuspecting world.

frontend/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2018, Mats Rauhala
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Mats Rauhala nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

frontend/Setup.hs

@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain

frontend/frontend.cabal

@@ -0,0 +1,32 @@
+-- Initial frontend.cabal generated by cabal init.  For further
+-- documentation, see http://haskell.org/cabal/users-guide/
+
+name:                frontend
+version:             0.1.0.0
+-- synopsis:
+-- description:
+license:             BSD3
+license-file:        LICENSE
+author:              Mats Rauhala
+maintainer:          mats.rauhala@iki.fi
+-- copyright:
+category:            Web
+build-type:          Simple
+extra-source-files:  ChangeLog.md
+cabal-version:       >=1.10
+
+executable frontend
+  main-is:             Main.hs
+  -- other-modules:
+  -- other-extensions:
+  build-depends:       base >=4.11 && <4.12
+                     , common
+                     , generic-lens
+                     , jsaddle-warp
+                     , lens
+                     , miso
+                     , mtl
+                     , servant
+  hs-source-dirs:      src
+  default-language:    Haskell2010
+  ghc-options:         -Wall

frontend/src/Main.hs

@@ -0,0 +1,93 @@
+{-# LANGUAGE DataKinds                  #-}
+{-# LANGUAGE DeriveGeneric              #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE LambdaCase                 #-}
+{-# LANGUAGE OverloadedStrings          #-}
+{-# LANGUAGE ScopedTypeVariables          #-}
+{-# LANGUAGE RecordWildCards            #-}
+{-# LANGUAGE TypeApplications           #-}
+{-# LANGUAGE TypeOperators              #-}
+{-# LANGUAGE GADTs              #-}
+module Main where
+
+import           Control.Lens                     (over, set)
+import           Control.Monad.Trans              (liftIO)
+import           Data.Generics.Product
+import           GHC.Generics                     (Generic)
+import           Language.Javascript.JSaddle.Warp
+import           Miso                             hiding (set)
+import           Miso.String
+import           Servant.API
+import           Servant.Links
+import Data.Proxy (Proxy(..))
+
+type API = Home :<|> Login :<|> Register
+type Home = View Action
+type Login = "login" :> View Action
+type Register = "register" :> View Action
+
+data Action = Add
+            | Subtract
+            | SayHello
+            | HandleURI URI
+            | ChangeURI URI
+            | NoOp
+
+data Model = Model { counter :: Int
+                   , uri     :: URI }
+  deriving (Eq, Generic)
+
+updateModel :: Model -> Action -> Effect Action Model
+updateModel m = \case
+  Add -> noEff (over (field @"counter") (+1) m)
+  Subtract -> noEff (over (field @"counter") (\x -> x - 1) m)
+  SayHello -> m <# (liftIO (putStrLn "Hello world") >> pure NoOp)
+  HandleURI uri -> noEff (set (field @"uri") uri m)
+  ChangeURI uri -> m <# do
+    liftIO $ putStrLn $ "Pushing uri " <> show uri
+    pushURI uri
+    return $ HandleURI uri
+  NoOp -> noEff m
+
+viewModel :: Model -> View Action
+viewModel model = view
+  where
+    view = either (const the404) id $ runRoute @API Proxy handlers uri model
+    handlers = home :<|> login :<|> register
+    home _ = div_ [] [ button_  [ onClick Add ] [ text "+" ]
+              , text (ms (counter model))
+              , button_ [ onClick Subtract ] [ text "-" ]
+              , button_ [ onClick goLogin ] [ text "go login" ]
+              , button_ [ onClick goRegister ] [ text "go register" ]
+            ]
+    login _ = div_ [] []
+    register _ = div_ [] [
+        h3_ [] [text "register"]
+      , label_ [] [text "Username"], input_ [id_ "username", name_ "username"]
+      , label_ [] [text "Email"], input_ [id_ "email", name_ "email"]
+      , label_ [] [text "Password"], input_ [id_ "password", name_ "password"]
+      , label_ [] [text "Password again"], input_ [id_ "passwordAgain", name_ "passwordAgain"]
+      , button_ [] [text "Register"]
+      ]
+    the404 = div_ [] []
+
+goLogin, goHome, goRegister :: Action
+goLogin = goto @Login @API Proxy Proxy
+goHome = goto @Home @API Proxy Proxy
+goRegister = goto @Register @API Proxy Proxy
+
+goto :: (IsElem endpoint api, HasLink endpoint, MkLink endpoint Link ~ Link) => Proxy api -> Proxy endpoint -> Action
+goto a b = ChangeURI (linkURI (safeLink a b))
+
+main :: IO ()
+main = run 8081 $ do
+  model <- mkModel
+  startApp App{..}
+  where
+    mkModel = Model <$> pure 0 <*> getCurrentURI
+    initialAction = SayHello
+    update = flip updateModel
+    view = viewModel
+    subs = [ uriSub HandleURI ]
+    events = defaultEvents
+    mountPoint = Nothing

ghcjs.patch

@@ -0,0 +1,16 @@
+diff --git a/lib/boot/shims/src/string.js b/lib/boot/shims/src/string.js
+index d82f75a..f16e55a 100644
+--- a/lib/boot/shims/src/string.js
++++ b/lib/boot/shims/src/string.js
+@@ -780,11 +780,7 @@ function h$throwJSException(e) {
+   // adding the Exception dictionary
+   var strVal = e.toString() + '\n' + Array.prototype.join.call(e.stack, '\n');
+   var someE = MK_SOMEEXCEPTION(HS_JSEXCEPTION_EXCEPTION,
+-#ifdef GHCJS_PROF
+-                               MK_JSEXCEPTION(MK_JSVAL(e), h$toHsString(strVal), h$CCS_SYSTEM))
+-#else
+                                MK_JSEXCEPTION(MK_JSVAL(e), h$toHsString(strVal))
+-#endif
+                               );
+   return h$throw(someE, true);
+ }

jsaddle-warp-ghcjs.nix

@@ -0,0 +1,14 @@
+{ mkDerivation, base, fetchgit, stdenv }:
+mkDerivation {
+  pname = "jsaddle-warp";
+  version = "0.9.5.0";
+  src = fetchgit {
+    url = "https://github.com/ghcjs/jsaddle.git";
+    rev = "34fe7d61b3f387b81aa748294ac8d993243f53b4";
+    sha256 = "0qdh5qdk23vcp1yp910zgw2hs4zpbx9ig25xgaax0iwj2m1ifh5x";
+  };
+  postUnpack = "sourceRoot+=/jsaddle-warp; echo source root reset to $sourceRoot";
+  libraryHaskellDepends = [ base ];
+  description = "Interface for JavaScript that works with GHCJS and GHC";
+  license = stdenv.lib.licenses.mit;
+}

migrations/V1.1__Channel_visibility.sql

@@ -0,0 +1 @@
+alter table channels add column visibility text NOT NULL default 'Private';

migrations/V1.2__unique_tags.sql

@@ -0,0 +1 @@
+create unique index tag_owner on tags (tag, owner);

nixpkgs-version.json

@@ -1,7 +1,7 @@
 {
   "url": "https://github.com/nixos/nixpkgs.git",
-  "rev": "83a5765b1fea2472ec9cf9d179d3efd18b45c77e",
+  "rev": "4507926b80c6b8f73053775ffee17f6781c7e7c8",
   "date": "2018-01-08T11:52:28+01:00",
-  "sha256": "01rb61dkbzjbwnb3p8lgs03a94f4584199dlr0cwdmqzaxnp506h",
+  "sha256": "068v9xh7d8klk62p2qwr76fyfqfh1bp08xc12x138g5q6pg6yfzb",
   "fetchSubmodules": true
 }

project.nix

@@ -0,0 +1,45 @@
+nixpkgs:
+
+let
+
+  inherit (nixpkgs.lib) mapAttrs mapAttrsToList escapeShellArg optionalString concatStringsSep concatMapStringsSep;
+
+in
+
+{ haskellPackages
+, packages
+, overrides ? _ : _ : {}
+, tools ? []
+}:
+
+let
+
+  overrides' = nixpkgs.lib.foldr nixpkgs.lib.composeExtensions (_: _: {}) [
+    (self: super: mapAttrs (name: path: self.callCabal2nix name path {}) packages)
+    overrides
+  ];
+  haskellPackages' = haskellPackages.extend overrides';
+  packages' = mapAttrs (name: _: haskellPackages'."${name}") packages;
+  mkShell = name: pkg:
+  let
+    n =  "${name}-shell";
+    deps = with haskellPackages'; [
+      ghcid
+      cabal-install
+      hasktags
+      (haskellPackages'.ghcWithHoogle (pkgs: pkg.buildInputs ++ pkg.propagatedBuildInputs))
+    ];
+  in
+  {
+    name = "${n}";
+    value = nixpkgs.buildEnv {
+      name = "${n}";
+      paths = tools;
+      buildInputs = tools ++ [deps];
+    };
+  };
+  shells = nixpkgs.lib.listToAttrs (mapAttrsToList mkShell packages');
+
+in
+
+packages' // shells

release.nix

@@ -0,0 +1,72 @@
+{ nixpkgs ? import <nixpkgs> {} }:
+
+let
+
+  jsaddle = nixpkgs.fetchFromGitHub {
+    owner = "ghcjs";
+    repo = "jsaddle";
+    rev = "34fe7d61b3f387b81aa748294ac8d993243f53b4";
+    sha256 = "0qdh5qdk23vcp1yp910zgw2hs4zpbx9ig25xgaax0iwj2m1ifh5x";
+  };
+  config = {
+    packageOverrides = pkgs: with pkgs.haskell.lib;  with pkgs.lib; {
+      haskell = pkgs.haskell // {
+        packages = pkgs.haskell.packages // {
+          ghccustom = pkgs.haskell.packages.ghc843.override {
+            overrides = self: super: {
+              jsaddle-warp = dontCheck (super.callPackage (jsaddle + "/jsaddle-warp") {});
+              # jsaddle-warp = super.callPackage ./jsaddle-warp-ghcjs.nix {};
+              jsaddle = dontCheck (super.callPackage (jsaddle + "/jsaddle") {});
+            };
+          };
+          ghcjscustom = pkgs.haskell.packages.ghcjs84.override {
+            overrides = self: super: {
+              doctest = null;
+              comonad = dontCheck (super.comonad);
+              classy-prelude = dontCheck (super.classy-prelude);
+              unliftio = dontCheck (super.unliftio);
+              semigroupoids = dontCheck (super.semigroupoids);
+              lens = dontCheck (super.lens);
+              directory-tree = dontCheck (super.directory-tree);
+              http-types = dontCheck (super.http-types);
+              tasty-quickcheck = dontCheck (super.tasty-quickcheck);
+              scientific = dontCheck (super.scientific);
+              servant = dontCheck (super.servant);
+              jsaddle-warp = super.callPackage ./jsaddle-warp-ghcjs.nix {};
+              ghc = overrideDerivation (super.ghc.override {
+                ghcjsSrc = pkgs.fetchgit {
+                  url = "https://github.com/ghcjs/ghcjs.git";
+                  rev = "dc190b1bb2453cfa484124e9f335ee3cad1492f7";
+                  sha256 = "0dh52gj0f3700zfyrhisy44b6y9p1bsawwrmd5pllpdyw21zd9lw";
+                  fetchSubmodules = true;
+                };
+              }) (drv: { patches = (drv.patches or []) ++ [ ./ghcjs.patch ]; });
+            };
+          };
+        };
+      };
+    };
+  };
+  pinnedVersion = nixpkgs.lib.importJSON ./nixpkgs-version.json;
+  pinnedPkgs = import (nixpkgs.fetchFromGitHub {
+    owner = "NixOS";
+    repo = "nixpkgs";
+    inherit (pinnedVersion) rev sha256;
+  }) { inherit config; };
+  ghc = import ./default.nix { nixpkgs = pinnedPkgs; haskellPackages = pinnedPkgs.haskell.packages.ghccustom; };
+  ghcjs = import ./default.nix { nixpkgs = pinnedPkgs; haskellPackages = pinnedPkgs.haskell.packages.ghcjscustom; };
+  inherit (pinnedPkgs) pkgs;
+
+  in
+
+{
+  inherit ghc ghcjs;
+  deps = pkgs.buildEnv {
+    name = "deps";
+    paths = [
+      (pkgs.haskell.packages.ghccustom.ghcWithPackages (_: ghc.backend.buildInputs ++ ghc.backend.propagatedBuildInputs))
+      (pkgs.haskell.packages.ghcjscustom.ghcWithPackages (_: ghcjs.frontend.buildInputs ++ ghcjs.frontend.propagatedBuildInputs))
+    ];
+    buildInputs = [ ];
+  };
+}

src/API.hs

@@ -1,50 +0,0 @@
-{-# Language DataKinds #-}
-{-# Language TypeFamilies #-}
-{-# Language TypeOperators #-}
-{-# Language NoImplicitPrelude #-}
-{-# Language MultiParamTypeClasses #-}
-{-# Language OverloadedStrings #-}
-{-# Language TemplateHaskell #-}
-{-# Language QuasiQuotes #-}
-{-# Language RecordWildCards #-}
-{-# Language DeriveGeneric #-}
-{-# Language FlexibleInstances #-}
-module API (API, handler) where
-
-
-import Servant
-import Servant.HTML.Lucid (HTML)
-import Types
-
-import View
-
-import qualified API.Users as Users
-import qualified API.Channels as Channels
-import qualified API.Books as Books
-import qualified API.Catalogue as Catalogue
-
-data Index = Index
-
-type API = Get '[HTML] (AppView Index)
-      :<|> Users.API
-      :<|> "api" :> Channels.API
-      :<|> "api" :> Books.API
-      :<|> "api" :> "1" :> Catalogue.VersionedAPI 1
-      :<|> "api" :> "current" :> Catalogue.VersionedAPI 1
-
-handler :: ServerT API AppM
-handler = indexHandler
-    :<|> Users.handler
-    :<|> Channels.handler
-    :<|> Books.handler
-    :<|> Catalogue.handler
-    :<|> Catalogue.handler
-
-instance ToHtml Index where
-  toHtml _ = do
-    h1_ [class_ "title"] "Home page"
-    p_ [class_ "subtitle"] "Hello world"
-  toHtmlRaw = toHtml
-
-indexHandler :: AppM (AppView Index)
-indexHandler = mkView "Home" Index

src/API/Books.hs

@@ -1,109 +0,0 @@
-{-# Language DuplicateRecordFields #-}
-{-# Language DataKinds #-}
-{-# Language TypeFamilies #-}
-{-# Language TypeOperators #-}
-{-# Language NoImplicitPrelude #-}
-{-# Language MultiParamTypeClasses #-}
-{-# Language OverloadedStrings #-}
-{-# Language TemplateHaskell #-}
-{-# Language QuasiQuotes #-}
-{-# Language RecordWildCards #-}
-{-# Language DeriveGeneric #-}
-{-# Language FlexibleInstances #-}
-{-# Language TypeApplications #-}
-{-# Language DataKinds #-}
-{-# Language NamedFieldPuns #-}
-module API.Books where
-
-import Servant hiding (contentType)
-import Types
-import ClassyPrelude
-import Server.Auth
-import Servant.Auth as SA
-import Data.Aeson
-import API.Channels (JsonChannel(..))
-import Database.Book
-import Database.Channel
-import Database
-import Control.Lens
-import Data.Generics.Product
-
-import Control.Monad.Trans.Maybe
-
-import qualified Datastore as DS
-import Data.ByteArray (convert)
-import Crypto.Hash (digestFromByteString)
-
-data JsonBook = JsonBook { identifier :: BookID
-                         , contentType :: Text
-                         , title :: Maybe Text
-                         , description :: Maybe Text
-                         , channels :: [JsonChannel] }
-              deriving (Generic, Show)
-
-data PostBook = PostBook { contentType :: Text
-                         , title :: Maybe Text
-                         , description :: Maybe Text
-                         , channels :: [JsonChannel] }
-              deriving (Generic, Show)
-
-
-instance ToJSON JsonBook
-instance FromJSON JsonBook
-instance ToJSON PostBook
-instance FromJSON PostBook
-
-type API = Auth '[SA.BasicAuth, SA.JWT] SafeUser :> BaseAPI
-
-type BaseAPI = "books" :> Get '[JSON] [JsonBook]
-       :<|> "books" :> ReqBody '[JSON] PostBook :> Post '[JSON] JsonBook
-       :<|> "books" :> Capture "book_id" BookID :> "meta" :> ReqBody '[JSON] JsonBook :> Put '[JSON] JsonBook
-       :<|> "books" :> Capture "book_id" BookID :> ReqBody '[OctetStream] ByteString :> Put '[JSON] NoContent
-       :<|> "books" :> Capture "book_id" BookID :> Get '[OctetStream] ByteString
-
-handler :: ServerT API AppM
-handler user = listBooksHandler user
-          :<|> postBookMetaHandler user
-          :<|> putBookMetaHandler user
-          :<|> putBookContentHandler user
-          :<|> getBookContentHandler user
-
-getBookContentHandler :: AuthResult SafeUser -> BookID -> AppM ByteString
-getBookContentHandler auth bookId = requireBookOwner auth bookId $ \SafeUser{username} -> do
-  content <- runMaybeT $ do
-    Book{contentHash=mHash} <- MaybeT $ runDB (getBook bookId username)
-    contentHash <- MaybeT $ return (mHash >>= digestFromByteString . unHex)
-    MaybeT $ DS.get contentHash
-  maybe (throwM err404) return content
-
-requireBookOwner :: AuthResult SafeUser -> BookID -> (SafeUser -> AppM a) -> AppM a
-requireBookOwner auth bookId f = flip requireLoggedIn auth $ \u@SafeUser{username} -> do
-  exists <- runDB $ bookExists bookId
-  unless exists $ throwM err404
-  runDB (isBookOwner bookId username) >>= \o -> if o then f u else throwM err403
-
-putBookContentHandler :: AuthResult SafeUser -> BookID -> ByteString -> AppM NoContent
-putBookContentHandler auth bookId content = requireBookOwner auth bookId $ \SafeUser{username} -> do
-  key <- HashDigest . convert <$> DS.put content
-  runDB (setContent bookId username key)
-  return NoContent
-
-postBookMetaHandler :: AuthResult SafeUser -> PostBook -> AppM JsonBook
-postBookMetaHandler auth PostBook{..} = flip requireLoggedIn auth $ \SafeUser{username} -> do
-  mIdentifier <- runDB $ insertBook InsertBook{owner=username,..}
-  maybe (throwM err403{errBody="Could not insert book"}) (\identifier -> pure JsonBook{..}) mIdentifier
-
-
-putBookMetaHandler :: AuthResult SafeUser -> BookID -> JsonBook -> AppM JsonBook
-putBookMetaHandler auth bookId b@JsonBook{..}
-  | bookId == identifier = requireBookOwner auth bookId $ \SafeUser{username=owner} ->
-        maybe (throwM err403) (const (return b)) =<< runDB (updateBook UpdateBook{..})
-  | otherwise = throwM err403
-
-listBooksHandler :: AuthResult SafeUser -> AppM [JsonBook]
-listBooksHandler = requireLoggedIn $ \user -> do
-  runDB (usersBooks (view (field @"username") user) >>= mapM augment)
-    where
-      augment Book{identifier=bookId,contentType,title,description} = do
-        channels <- fmap (\Channel{..} -> JsonChannel{..}) <$> booksChannels bookId
-        pure JsonBook{identifier=bookId,..}

src/API/Channels.hs

@@ -1,51 +0,0 @@
-{-# Language DataKinds #-}
-{-# Language TypeFamilies #-}
-{-# Language TypeOperators #-}
-{-# Language NoImplicitPrelude #-}
-{-# Language MultiParamTypeClasses #-}
-{-# Language OverloadedStrings #-}
-{-# Language TemplateHaskell #-}
-{-# Language QuasiQuotes #-}
-{-# Language RecordWildCards #-}
-{-# Language DeriveGeneric #-}
-{-# Language FlexibleInstances #-}
-{-# Language TypeApplications #-}
-{-# Language DataKinds #-}
-module API.Channels (API, handler, JsonChannel(..)) where
-
-import Servant
-import Types
-import ClassyPrelude
-import Server.Auth
-import Servant.Auth as SA
-import Control.Monad.Logger
-import Database
-import Database.Channel
-import Data.Aeson
-import Control.Lens
-import Data.Generics.Product
-
-data JsonChannel = JsonChannel { channel :: Text } deriving (Show, Generic)
-
-instance ToJSON JsonChannel
-instance FromJSON JsonChannel
-
-type API = Auth '[SA.BasicAuth, SA.Cookie, SA.JWT] SafeUser :> BaseAPI
-
-type BaseAPI = "channels" :> ReqBody '[JSON] JsonChannel :> Put '[JSON] JsonChannel
-          :<|> "channels" :> Get '[JSON] [JsonChannel]
-
-handler :: ServerT API AppM
-handler user = newChannelHandler user :<|> listChannelsHandler user
-
-listChannelsHandler :: AuthResult SafeUser -> AppM [JsonChannel]
-listChannelsHandler = requireLoggedIn $ \user ->
-  -- I could use the super thing from generic-lens, but then I would need to
-  -- use the 'channel' accessor somehow or export it
-  fmap (\Channel{..} -> JsonChannel{..}) <$> runDB (userChannels (view (field @"username") user))
-
-newChannelHandler :: AuthResult SafeUser -> JsonChannel -> AppM JsonChannel
-newChannelHandler auth ch@JsonChannel{..} = flip requireLoggedIn auth $ \user -> do
-  $logInfo $ "Creating channel for user " <> pack (show user)
-  runDB (insertChannel (view (field @"username") user) channel)
-  return ch

src/Database/Channel.hs

@@ -1,46 +0,0 @@
-{-# Language TypeApplications #-}
-{-# Language DataKinds #-}
-module Database.Channel
-  ( userChannels
-  , insertChannel
-  , booksChannels
-  , Channel(..)
-  , ChannelID )
-  where
-
-import ClassyPrelude
-import Database.Schema
-import Database
-import Database.Selda
-
-userChannels :: (MonadMask m, MonadIO m) => Username -> SeldaT m [Channel]
-userChannels username = fromRels <$> query q
-  where
-    q = do
-      userId :*: _ :*: username' :*: _ <- select (gen users)
-      channel@(_ :*: _ :*: owner) <- select (gen channels)
-      restrict (owner .== userId)
-      restrict (username' .== literal username)
-      return channel
-
-insertChannel :: (MonadMask m, MonadIO m) => Username -> Text -> SeldaT m ()
-insertChannel username channel = do
-  mUserId <- listToMaybe <$> getUser
-  void $ forM mUserId $ \userId ->
-    insertUnless (gen channels) (doesNotExist userId) [ def :*: channel :*: userId ]
-  where
-    doesNotExist userId (_ :*: channel' :*: userId') = channel' .== literal channel .&& userId' .== literal userId
-    getUser = query $ do
-      userId :*: _ :*: user :*: _ <- select (gen users)
-      restrict (user .== literal username)
-      return userId
-
-booksChannels :: (MonadMask m, MonadIO m) => BookID -> SeldaT m [Channel]
-booksChannels contentHash = fromRels <$> query q
-  where
-    q = do
-      channelId :*: contentHash' <- select (gen bookChannels)
-      ch@(channelId' :*: _) <- select (gen channels)
-      restrict (channelId .== channelId')
-      restrict (contentHash' .== literal contentHash)
-      return ch

src/Main.hs

@@ -1,38 +0,0 @@
-{-# Language OverloadedStrings #-}
-{-# Language RecordWildCards #-}
-{-# Language DuplicateRecordFields #-}
-{-# Language TypeApplications #-}
-{-# Language DataKinds #-}
-{-# Language NoImplicitPrelude #-}
-module Main where
-
-import Server (server)
-import Network.Wai.Handler.Warp (run)
-import Types
-import Configuration
-import Dhall (input, auto)
-import ClassyPrelude
-import Control.Lens (view)
-import Data.Generics.Product
-import Data.Pool (createPool)
-import Database.Selda.PostgreSQL (PGConnectInfo(..), pgOpen, seldaClose)
-import Servant.Auth.Server (generateKey)
-
-defaultMain :: App -> IO ()
-defaultMain = run 8080 . server
-
-withApp :: Config -> (App -> IO ()) -> IO ()
-withApp config f = do
-  let pgHost = view (field @"database" . field @"host") config
-      pgPort = 5432
-      pgDatabase = view (field @"database" . field @"database") config
-      pgUsername = Just (view (field @"database" . field @"username") config)
-      pgPassword = Just (view (field @"database" . field @"password") config)
-  database <- createPool (pgOpen (PGConnectInfo{..})) seldaClose 10 2 5
-  jwk <- generateKey
-  f App{..}
-
-main :: IO ()
-main = do
-  c <- input auto "./config/config.dhall"
-  withApp c defaultMain

src/Server.hs

@@ -1,40 +0,0 @@
-{-# Language DataKinds #-}
-{-# Language TypeFamilies #-}
-{-# Language TypeOperators #-}
-{-# Language NoImplicitPrelude #-}
-{-# Language MultiParamTypeClasses #-}
-{-# Language OverloadedStrings #-}
-{-# Language TemplateHaskell #-}
-{-# Language QuasiQuotes #-}
-{-# Language RecordWildCards #-}
-{-# Language DeriveGeneric #-}
-{-# Language FlexibleInstances #-}
-{-# Language TypeApplications #-}
-module Server where
-
-import qualified API as API
-import Server.Auth (authCheck)
-import Servant
-import Types
-import ClassyPrelude hiding (Handler)
-import Control.Monad.Logger
-import Control.Monad.Except
-import Servant.Auth.Server as SAS
-import Control.Lens
-import Data.Generics.Product
-
-type API = API.API :<|> "static" :> Raw
-
-
-server :: App -> Application
-server app = serveWithContext api cfg (enter server' API.handler :<|> serveDirectoryFileServer "static")
-  where
-    myKey = view (field @"jwk") app
-    jwtCfg = defaultJWTSettings myKey
-    authCfg = authCheck app
-    cookieSettings = SAS.defaultCookieSettings{cookieIsSecure=SAS.NotSecure}
-    cfg = jwtCfg :. cookieSettings :. authCfg :. EmptyContext
-    server' :: AppM :~> Servant.Handler
-    server' = NT (Handler . ExceptT . try . (`runReaderT` app) . (runFileLoggingT "logs/server.log"))
-    api :: Proxy API
-    api = Proxy

to-flyway.dhall

@@ -0,0 +1,8 @@
+\(conf : ./config/Configuration.dhall)
+->
+''
+flyway.locations=filesystem:${conf.database.migrations}/
+flyway.url=jdbc:postgresql://${conf.database.host}/${conf.database.database}
+flyway.user=${conf.database.username}
+flyway.password=${conf.database.password}
+''