https://github.com/abarbu/servant-reason

Automatically derive bindings for Servant APIs in Reason
https://github.com/abarbu/servant-reason

haskell reason reasonml servant web

Last synced: 25 days ago
JSON representation

Automatically derive bindings for Servant APIs in Reason

• Host: GitHub
• URL: https://github.com/abarbu/servant-reason
• Owner: abarbu
• License: bsd-3-clause
• Created: 2019-05-26T22:34:17.000Z (over 5 years ago)
• Default Branch: master
• Last Pushed: 2019-06-01T07:55:55.000Z (over 5 years ago)
• Last Synced: 2024-09-29T17:41:58.620Z (about 1 month ago)
• Topics: haskell, reason, reasonml, servant, web
• Language: Haskell
• Size: 17.6 KB
• Stars: 12
• Watchers: 5
• Forks: 1
• Open Issues: 2
• Metadata Files:
  • Readme: README.md
  • Changelog: ChangeLog.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# Servant Reason

[![Build Status](https://travis-ci.org/abarbu/servant-reason.svg)](https://travis-ci.org/abarbu/servant-reason)





Automatically derive bindings for Servant APIs in Reason.  Originally build by

converting [servant-elm](http://hackage.haskell.org/package/servant-elm) to

Reason. Types are generated using

[reason-export](https://github.com/abarbu/reason-export).

More docs on [Hackage](http://hackage.haskell.org/package/servant-reason).

A full example of how to integrate Servant and Reason is available at

[servant-reason-example](https://github.com/abarbu/servant-reason-example).

## Usage

Run the tests if you want a concrete example. They will build a _test-cache

directory that contains a sample Reason repository for a servant API. test also

contain example output files for different kinds of bindings.

Usage is simple and automatic. If you have an API like the one below

```haskell

{-# LANGUAGE DataKinds         #-}

{-# LANGUAGE DeriveGeneric     #-}

{-# LANGUAGE OverloadedStrings #-}

{-# LANGUAGE TypeOperators     #-}

import           Reason          (Spec (Spec), specsToDir, toReasonDecoderSource,

                               toReasonTypeSource)

import           GHC.Generics (Generic)

import           Servant.API  ((:>), Capture, Get, JSON)

import           Servant.Reason  (ReasonType, Proxy (Proxy), defReasonImports,

                               generateReasonForAPI)

data Book = Book

    { name :: String

    } deriving (Generic)

instance ReasonType Book

type BooksApi = "books" :> Capture "bookId" Int :> Get '[JSON] Book

```

You can expose your API to reason with:

```haskell

module Main where

import Data.Proxy

import Reason

import           Data.Text hiding (intercalate, map)

import Db

main :: IO ()

main = do

  let code = defReasonImports

             : toReasonTypeSource    (Proxy :: Proxy Book)

             : toReasonDecoderSource (Proxy :: Proxy Book)

             : generateReasonForAPI  (Proxy :: Proxy BooksApi))

  writeFile "Api.re" $ intercalate "\n\n" $ map unpack code

```

That's it. You can now include `Api.re` in a Reason project.

## Reason setup

The generated code needs access to two Reason libraries

[@glennsl/bs-json](https://github.com/glennsl/bs-json) and

[bs-fetch](https://github.com/reasonml-community/bs-fetch). Get the latest

install instructions from the upstream repos, but at the time of writing these

were:

```sh

npm install --save @glennsl/bs-json

npm install --save bs-fetch

```

Then add `@glennsl/bs-json` and `bs-fetch` to `bs-dependencies` in your `bsconfig.json`:

```js

{

  ...

  "bs-dependencies": ["@glennsl/bs-json", "bs-fetch"]

}

```