Rename to

Author: oreshinya

README.md

@@ -29,9 +29,9 @@ import App.DB (Pool, createConnectionPool, withPool, selectItems, createItem)
 import Bucketchain (createServer, listen)
 import Bucketchain.Middleware (Middleware)
 import Bucketchain.SimpleAPI (withSimpleAPI)
-import Bucketchain.SimpleAPI.Action (Action, askExtra)
 import Bucketchain.SimpleAPI.Body (Body(..))
 import Bucketchain.SimpleAPI.JSON (JSON, success_)
+import Bucketchain.SimpleAPI.Proc (Proc, askExtra)
 import Effect (Effect)
 import Node.HTTP (ListenOptions, Server)
 
@@ -68,13 +68,13 @@ server = createServer $ withSimpleAPI pool routes
 
 -- Define endpoints.
 
-getItems :: Action Pool (JSON (Array Item))
+getItems :: Proc Pool (JSON (Array Item))
 getItems = do
   pool <- askExtra
   items <- liftAff $ withPool selectItems pool
   pure $ success_ 200 items
 
-createItem :: Body ItemParams -> Action Pool (JSON Item)
+createItem :: Body ItemParams -> Proc Pool (JSON Item)
 createItem (Body params) = do
   pool <- askExtra
   item <- liftAff $ withPool (createItem params) pool
@@ -131,8 +131,8 @@ Note: `POST /batch` responds 200 always.
 You can use `Authenticatable` for authentication.
 
 ```purescript
-import Bucketchain.SimpleAPI.Action (askExtra, askRaw)
 import Bucketchain.SimpleAPI.Auth.Class (class Authenticatable)
+import Bucketchain.SimpleAPI.Proc (askExtra, askRaw)
 
 newtype User = User { id :: Int, name :: String }
 
@@ -149,7 +149,7 @@ instance authenticatableUser :: Authenticatable Pool User where
 Then, define request handlers with `Auth`.
 
 ```purescript
-getItems :: Auth User -> Action Pool (JSON (Array Item))
+getItems :: Auth User -> Proc Pool (JSON (Array Item))
 getItems (Auth user) = -- ...
 ```
 

example/Main.purs

@@ -6,13 +6,13 @@ import Bucketchain (createServer, listen)
 import Bucketchain.Http (requestHeaders)
 import Bucketchain.Middleware (Middleware)
 import Bucketchain.SimpleAPI (withSimpleAPI)
-import Bucketchain.SimpleAPI.Action (Action, askExtra, askRaw)
 import Bucketchain.SimpleAPI.Auth (Auth(..))
 import Bucketchain.SimpleAPI.Auth.Class (class Authenticatable)
 import Bucketchain.SimpleAPI.Batch (Batch(..))
 import Bucketchain.SimpleAPI.Body (Body(..))
 import Bucketchain.SimpleAPI.FreeT.Class (class Transformable)
 import Bucketchain.SimpleAPI.JSON (JSON, failure, success, success_)
+import Bucketchain.SimpleAPI.Proc (Proc, askExtra, askRaw)
 import Bucketchain.SimpleAPI.RawData (RawData)
 import Control.Monad.Error.Class (throwError)
 import Control.Monad.Free.Trans (FreeT, liftFreeT)
@@ -66,49 +66,49 @@ middleware = withSimpleAPI 777 $ Batch
   , freeTTest
   }
 
-successTest :: Action Int (JSON (Array Item))
+successTest :: Proc Int (JSON (Array Item))
 successTest = do
   num <- askExtra
   { path, rawBody } <- askRaw
   pure $ success headers 200 [{ id: 1, name: "Item 1", num, path, rawBody }]
   where
     headers = singleton "X-Custom" "CustomValue"
 
-failureTest :: Action Int (JSON Item)
+failureTest :: Proc Int (JSON Item)
 failureTest = pure $ failure headers 503 $ singleton "core" ["This is error test"]
   where
     headers = singleton "X-Custom" "CustomValue2"
 
-bodyTest :: Body OtherItem -> Action Int (JSON OtherItem)
+bodyTest :: Body OtherItem -> Proc Int (JSON OtherItem)
 bodyTest (Body x) = pure $ success empty 201 x
 
-authTest :: Auth User -> Action Int (JSON OtherItem)
+authTest :: Auth User -> Proc Int (JSON OtherItem)
 authTest (Auth (User x)) = pure $ success empty 200 { name: x.name }
 
-errorTest :: Action Int (JSON OtherItem)
+errorTest :: Proc Int (JSON OtherItem)
 errorTest = throwError $ error "Test error"
 
-freeTTest :: VAction (JSON OtherItem)
+freeTTest :: VProc (JSON OtherItem)
 freeTTest = do
   num <- getExtra
   rawData <- getRawData
   pure $ success_ 200 { name: show num <> rawData.rawBody }
 
 -- FreeT Example
-data VActionF a
+data VProcF a
   = GetExtra (Int -> a)
   | GetRawData (RawData -> a)
 
-type VAction = FreeT VActionF (Action Int)
+type VProc = FreeT VProcF (Proc Int)
 
-derive instance functorVAction :: Functor VActionF
+derive instance functorVProc :: Functor VProcF
 
-getExtra :: VAction Int
+getExtra :: VProc Int
 getExtra = liftFreeT $ GetExtra identity
 
-getRawData :: VAction RawData
+getRawData :: VProc RawData
 getRawData = liftFreeT $ GetRawData identity
 
-instance transformableVActionF :: Transformable Int VActionF where
+instance transformableVProcF :: Transformable Int VProcF where
   transform (GetExtra k) = k <$> askExtra
   transform (GetRawData k) = k <$> askRaw

src/Bucketchain/SimpleAPI.purs

@@ -17,7 +17,7 @@ import Simple.JSON (writeJSON)
 
 -- | SimpleAPI middleware.
 -- |
--- | `ex` is any extra data. It is typically global context such as db connection and can be used in `Action`.
+-- | `ex` is any extra data. It is typically global context such as db connection and can be used in `Proc`.
 -- |
 -- | `server` is a `Servable` instance.
 withSimpleAPI

src/Bucketchain/SimpleAPI/Action.purs

@@ -6,6 +6,6 @@ module Bucketchain.SimpleAPI.Auth where
 -- |
 -- | ```purescript
 -- | -- This request handler is run with authentication.
--- | getItems :: Auth User -> Action AppContext (JSON Item)
+-- | getItems :: Auth User -> Proc AppContext (JSON Item)
 -- | ```
 newtype Auth a = Auth a

src/Bucketchain/SimpleAPI/Auth.purs

@@ -1,13 +1,13 @@
 module Bucketchain.SimpleAPI.Auth.Class where
 
-import Bucketchain.SimpleAPI.Action (Action)
+import Bucketchain.SimpleAPI.Proc (Proc)
 
 -- | A typeclass for authentication.
 -- |
--- | `ex` is any extra data. It is typically global context such as db connection and can be used in `Action`.
+-- | `ex` is any extra data. It is typically global context such as db connection and can be used in `Proc`.
 -- |
 -- | `a` is a authenticated result. It is typically user data.
 -- |
 -- | If you call `throwError` in `authenticate` implementation, a server responds 401.
 class Authenticatable ex a where
-  authenticate :: Action ex a
+  authenticate :: Proc ex a

src/Bucketchain/SimpleAPI/Auth/Class.purs

@@ -10,7 +10,7 @@ type BatchParams = Array
 
 -- | The type for enable batch operation.
 -- |
--- | The batch operation is a mechanism running multiple `Action` in one HTTP request.
+-- | The batch operation is a mechanism running multiple `Proc` in one HTTP request.
 -- |
 -- | How to use:
 -- |

src/Bucketchain/SimpleAPI/Batch.purs

@@ -2,12 +2,12 @@ module Bucketchain.SimpleAPI.Class where
 
 import Prelude
 
-import Bucketchain.SimpleAPI.Action (Action, context, runAction)
 import Bucketchain.SimpleAPI.Auth (Auth(..))
 import Bucketchain.SimpleAPI.Auth.Class (class Authenticatable, authenticate)
 import Bucketchain.SimpleAPI.Batch (BatchParams, Batch(..))
 import Bucketchain.SimpleAPI.Body (Body(..), decodeBody)
 import Bucketchain.SimpleAPI.FreeT.Class (class Transformable, transform)
+import Bucketchain.SimpleAPI.Proc (Proc, context, runProc)
 import Bucketchain.SimpleAPI.RawData (RawData)
 import Bucketchain.SimpleAPI.Response (Response, fromResponses, invalidRequestResponse, unauthorizedResponse, errorResponse)
 import Bucketchain.SimpleAPI.Response.Class (class Respondable, toResponse)
@@ -35,14 +35,14 @@ class Servable ex server where
 class ServableList ex (l :: RowList) (r :: # Type) | l -> r where
   serveList :: RLProxy l -> Record r -> ex -> RawData -> Aff (Maybe Response)
 
-instance servableAction :: (Respondable a) => Servable ex (Action ex a) where
+instance servableProc :: (Respondable a) => Servable ex (Proc ex a) where
   serve server extraData rawData = do
-    result <- attempt $ runAction server $ context extraData rawData
+    result <- attempt $ runProc server $ context extraData rawData
     case result of
       Left _ -> pure $ Just errorResponse
       Right x -> pure $ Just $ toResponse x
 
-instance servableFreeT :: (Transformable ex f, Respondable a) => Servable ex (FreeT f (Action ex) a) where
+instance servableFreeT :: (Transformable ex f, Respondable a) => Servable ex (FreeT f (Proc ex) a) where
   serve server extraData rawData = serve (runFreeT transform server) extraData rawData
 
 instance servableWithBody :: (ReadForeign a, Servable ex server) => Servable ex (Body a -> server) where
@@ -55,7 +55,7 @@ instance servableWithBody :: (ReadForeign a, Servable ex server) => Servable ex
 
 instance servableWithAuth :: (Authenticatable ex a, Servable ex server) => Servable ex (Auth a -> server) where
   serve server extraData rawData = do
-    result <- attempt $ runAction authenticate $ context extraData rawData
+    result <- attempt $ runProc authenticate $ context extraData rawData
     case result of
       Left _ -> pure $ Just unauthorizedResponse
       Right x ->

src/Bucketchain/SimpleAPI/Class.purs

@@ -2,11 +2,11 @@ module Bucketchain.SimpleAPI.FreeT.Class where
 
 import Prelude
 
-import Bucketchain.SimpleAPI.Action (Action)
+import Bucketchain.SimpleAPI.Proc (Proc)
 import Control.Monad.Free.Trans (FreeT)
 
 -- | A typeclass for `FreeT` request handlers.
 -- |
--- | `ex` is any extra data. It is typically global context such as db connection and can be used in `Action`.
+-- | `ex` is any extra data. It is typically global context such as db connection and can be used in `Proc`.
 class (Functor f) <= Transformable ex f where
-  transform :: forall a. f (FreeT f (Action ex) a) -> Action ex (FreeT f (Action ex) a)
+  transform :: forall a. f (FreeT f (Proc ex) a) -> Proc ex (FreeT f (Proc ex) a)

src/Bucketchain/SimpleAPI/FreeT/Class.purs

@@ -0,0 +1,63 @@
+module Bucketchain.SimpleAPI.Proc
+  ( Context
+  , Proc
+  , askExtra
+  , askRaw
+  , runProc
+  , context
+  ) where
+
+import Prelude
+
+import Bucketchain.SimpleAPI.RawData (RawData)
+import Control.Alt (class Alt)
+import Control.Monad.Error.Class (class MonadError, class MonadThrow)
+import Control.Monad.Reader (class MonadAsk, ReaderT, ask, runReaderT)
+import Control.Monad.Rec.Class (class MonadRec)
+import Control.Plus (class Plus)
+import Effect.Aff (Aff)
+import Effect.Aff.Class (class MonadAff)
+import Effect.Class (class MonadEffect)
+import Effect.Exception (Error)
+
+-- | This is for internal. Do not use it.
+newtype Context ex =
+  Context
+    { extraData :: ex
+    , rawData :: RawData
+    }
+
+-- | The type of request handler.
+newtype Proc ex a = Proc (ReaderT (Context ex) Aff a)
+
+derive newtype instance functorProc :: Functor (Proc ex)
+derive newtype instance applyProc :: Apply (Proc ex)
+derive newtype instance applicativeProc :: Applicative (Proc ex)
+derive newtype instance altProc :: Alt (Proc ex)
+derive newtype instance plusProc :: Plus (Proc ex)
+derive newtype instance bindProc :: Bind (Proc ex)
+derive newtype instance monadProc :: Monad (Proc ex)
+derive newtype instance semigroupProc :: Semigroup a => Semigroup (Proc ex a)
+derive newtype instance monoidProc :: Monoid a => Monoid (Proc ex a)
+derive newtype instance monadEffectProc :: MonadEffect (Proc ex)
+derive newtype instance monadAffProc :: MonadAff (Proc ex)
+derive newtype instance monadThrowProc :: MonadThrow Error (Proc ex)
+derive newtype instance monadErrorProc :: MonadError Error (Proc ex)
+derive newtype instance monadAskProc :: MonadAsk (Context ex) (Proc ex)
+derive newtype instance monadRecProc :: MonadRec (Proc ex)
+
+-- | Get global context.
+askExtra :: forall ex. Proc ex ex
+askExtra = flip map ask \(Context ctx) -> ctx.extraData
+
+-- | Get `RawData`.
+askRaw :: forall ex. Proc ex RawData
+askRaw = flip map ask \(Context ctx) -> ctx.rawData
+
+-- | This is for internal. Do not use it.
+runProc :: forall ex a. Proc ex a -> Context ex -> Aff a
+runProc (Proc readerT) = runReaderT readerT
+
+-- | This is for internal. Do not use it.
+context :: forall ex. ex -> RawData -> Context ex
+context extraData rawData = Context { extraData, rawData }