servant-client/CHANGELOG.md · typeable/servant

git.iko.soy/typeable/servant

on try-fix-uverb help sign in

typeable/servant/servant-client/CHANGELOG.md

357 lines 12 kB history raw

1[The latest version of this document is on GitHub.](https://github.com/haskell-servant/servant/blob/master/servant-client/CHANGELOG.md)

2[Changelog for `servant` package contains significant entries for all core packages.](https://github.com/haskell-servant/servant/blob/master/servant/CHANGELOG.md)

40.18.2

5------

7### Significant changes

9- Support `Fragment` combinator.

110.18.1

12------

14### Significant changes

16- Union verbs

18### Other changes

20- Bump "tested-with" ghc versions

220.18

23----

25### Significant changes

27- Support for ghc8.8 (#1318, #1326, #1327)

300.17

31----

33### Significant changes

35- Add NoContentVerb [#1028](https://github.com/haskell-servant/servant/issues/1028) [#1219](https://github.com/haskell-servant/servant/pull/1219) [#1228](https://github.com/haskell-servant/servant/pull/1228)

37 The `NoContent` API endpoints should now use `NoContentVerb` combinator.

38 The API type changes are usually of the kind

40 ```diff

41 - :<|> PostNoContent '[JSON] NoContent

42 + :<|> PostNoContent

43 ```

45 i.e. one doesn't need to specify the content-type anymore. There is no content.

47- `Capture` can be `Lenient` [#1155](https://github.com/haskell-servant/servant/issues/1155) [#1156](https://github.com/haskell-servant/servant/pull/1156)

49 You can specify a lenient capture as

51 ```haskell

52 :<|> "capture-lenient" :> Capture' '[Lenient] "foo" Int :> GET

53 ```

55 which will make the capture always succeed. Handlers will be of the

56 type `Either String CapturedType`, where `Left err` represents

57 the possible parse failure.

59- *servant-client* Added a function to create Client.Request in ClientEnv [#1213](https://github.com/haskell-servant/servant/pull/1213) [#1255](https://github.com/haskell-servant/servant/pull/1255)

61 The new member `makeClientRequest` of `ClientEnv` is used to create

62 `http-client` `Request` from `servant-client-core` `Request`.

63 This functionality can be used for example to set

64 dynamic timeouts for each request.

66### Other changes

68- *servant-client* *servant-client-core* *servant-http-streams* Fix Verb with headers checking content type differently [#1200](https://github.com/haskell-servant/servant/issues/1200) [#1204](https://github.com/haskell-servant/servant/pull/1204)

70 For `Verb`s with response `Headers`, the implementation didn't check

71 for the content-type of the response. Now it does.

73- *servant-client* *servant-http-streams* `HasClient` instance for `Stream` with `Headers` [#1170](https://github.com/haskell-servant/servant/issues/1170) [#1197](https://github.com/haskell-servant/servant/pull/1197)

74- *servant-client* Redact the authorization header in Show and exceptions [#1238](https://github.com/haskell-servant/servant/pull/1238)

780.16.0.1

79--------

81- Allow `base-compat-0.11`

830.16

84----

86- Rename `ServantError` to `ClientError`, `ServantErr` to `ServerError`

87 [#1131](https://github.com/haskell-servant/servant/pull/1131)

89- *servant-client-core* Rearrange modules. No more `Internal` modules, whole

90 API is versioned.

91 [#1130](https://github.com/haskell-servant/servant/pull/1130)

93- *servant-client-core* `RequestBody` is now

95 ```haskell

96 = RequestBodyLBS LBS.ByteString

97 | RequestBodyBS BS.ByteString

98 | RequestBodySource (SourceIO LBS.ByteString)

99 ```

100

101 i.e. no more replicates `http-client`s API.

102 [#1117](https://github.com/haskell-servant/servant/pull/1117)

103

104- *servant-client-core* Keep structured exceptions in `ConnectionError`

105 constructor of `ClientError`

106 [#1115](https://github.com/haskell-servant/servant/pull/1115)

107

108 ```diff

109 -| ConnectionError Text

110 +| ConnectionError SomeException

111 ```

112

113- *servant-client-core* Preserve failing request in `FailureResponse`

114 constructor of `ClientError`

115 [#1114](https://github.com/haskell-servant/servant/pull/1114)

116

117 ```diff

118 -FailureResponse Response

119 +-- | The server returned an error response including the

120 +-- failing request. 'requestPath' includes the 'BaseUrl' and the

121 +-- path of the request.

122 +FailureResponse (RequestF () (BaseUrl, BS.ByteString)) Response

123 ```

124

125- *servant-client* Fix (implement) `StreamBody` instance

126 [#1110](https://github.com/haskell-servant/servant/pull/1110)

127

128- *servant-client* Update CookieJar with intermediate request/responses (redirects)

129 [#1104](https://github.com/haskell-servant/servant/pull/1104)

130

1310.15

132----

133

134- Streaming refactoring.

135 [#991](https://github.com/haskell-servant/servant/pull/991)

136 [#1076](https://github.com/haskell-servant/servant/pull/1076)

137 [#1077](https://github.com/haskell-servant/servant/pull/1077)

138

139 The streaming functionality (`Servant.API.Stream`) is refactored to use

140 `servant`'s own `SourceIO` type (see `Servant.Types.SourceT` documentation),

141 which replaces both `StreamGenerator` and `ResultStream` types.

142

143 New conversion type-classes are `ToSourceIO` and `FromSourceIO`

144 (replacing `ToStreamGenerator` and `BuildFromStream`).

145 There are instances for *conduit*, *pipes* and *machines* in new packages:

146 [servant-conduit](https://hackage.haskell.org/package/servant-conduit)

147 [servant-pipes](https://hackage.haskell.org/package/servant-pipes) and

148 [servant-machines](https://hackage.haskell.org/package/servant-machines)

149 respectively.

150

151 Writing new framing strategies is simpler. Check existing strategies for examples.

152

153 This change shouldn't affect you, if you don't use streaming endpoints.

154

155- *servant-client* Separate streaming client.

156 [#1066](https://github.com/haskell-servant/servant/pull/1066)

157

158 We now have two `http-client` based clients,

159 in `Servant.Client` and `Servant.Client.Streaming`.

160

161 Their API is the same, except for

162 - `Servant.Client` **cannot** request `Stream` endpoints.

163 - `Servant.Client` is *run* by direct

164 `runClientM :: ClientM a -> ClientEnv -> IO (Either ServantError a)`

165 - `Servant.Client.Streaming` **can** request `Stream` endpoints.

166 - `Servant.Client.Streaming` is *used* by CPSised

167 `withClientM :: ClientM a -> ClientEnv -> (Either ServantError a -> IO b) -> IO b`

168

169 To access `Stream` endpoints use `Servant.Client.Streaming` with

170 `withClientM`; otherwise you can continue using `Servant.Client` with `runClientM`.

171 You can use both too, `ClientEnv` and `BaseUrl` types are same for both.

172

173 **Note:** `Servant.Client.Streaming` doesn't *stream* non-`Stream` endpoints.

174 Requesting ordinary `Verb` endpoints (e.g. `Get`) will block until

175 the whole response is received.

176

177 There is `Servant.Client.Streaming.runClientM` function, but it has

178 restricted type. `NFData a` constraint prevents using it with

179 `SourceT`, `Conduit` etc. response types.

180

181 ```haskell

182 runClientM :: NFData a => ClientM a -> ClientEnv -> IO (Either ServantError a)

183 ```

184

185 This change shouldn't affect you, if you don't use streaming endpoints.

186

187- Drop support for GHC older than 8.0

188 [#1008](https://github.com/haskell-servant/servant/pull/1008)

189 [#1009](https://github.com/haskell-servant/servant/pull/1009)

190

191- *servant-client-core* Add `NFData (GenResponse a)` and `NFData ServantError` instances.

192 [#1076](https://github.com/haskell-servant/servant/pull/1076)

193

194 *servant-client-core* Add `aeson` and `Lift BaseUrl` instances

195 [#1037](https://github.com/haskell-servant/servant/pull/1037)

196

1970.14

198----

199

200- `Stream` takes a status code argument

201

202 ```diff

203 -Stream method framing ctype a

204 +Stream method status framing ctype a

205 ```

206

207 ([#966](https://github.com/haskell-servant/servant/pull/966)

208 [#972](https://github.com/haskell-servant/servant/pull/972))

209

210- `ToStreamGenerator` definition changed, so it's possible to write an instance

211 for conduits.

212

213 ```diff

214 -class ToStreamGenerator f a where

215 - toStreamGenerator :: f a -> StreamGenerator a

216 +class ToStreamGenerator a b | a -> b where

217 + toStreamGenerator :: a -> StreamGenerator b

218 ```

219

220 ([#959](https://github.com/haskell-servant/servant/pull/959))

221

222- Added `NoFraming` streaming strategy

223 ([#959](https://github.com/haskell-servant/servant/pull/959))

224

225- *servant-client-core* Add `hoistClient` to `HasClient`.

226 Just like `hoistServer` allows us to change the monad in which request handlers

227 of a web application live, we also have `hoistClient` for changing the monad

228 in which *client functions* live.

229 Read [tutorial section for more information](https://docs.servant.dev/en/release-0.14/tutorial/Client.html#changing-the-monad-the-client-functions-live-in).

230 ([#936](https://github.com/haskell-servant/servant/pull/936))

231

232- *servant-client* Add more constructors to `RequestBody`, including

233 `RequestBodyStream`.

234 *Note:* we are looking for http-library agnostic API,

235 so the might change again soon.

236 Tell us which constructors are useful for you!

237 ([#913](https://github.com/haskell-servant/servant/pull/913))

238

2390.13.0.1

240--------

241