middleware.method_override, http.put_req_query

Author: lpil

CHANGELOG.md

@@ -8,9 +8,10 @@
   `get_req_header`, `get_resp_header`, `prepend_req_header`, `seq_req_host`,
   `set_req_path`, `prepend_resp_header`, `set_req_method`, `set_req_body`,
   `set_resp_body`, `map_resp_body`, `map_req_body` `try_map_resp_body`,
-  `req_from_uri`, `default_req`, and `redirect`.
+  `set_req_query`, `req_from_uri`, `default_req`, and `redirect`.
 - Created the `gleam/http/middleware` module with the `Middleware` type and
-  the `prepend_resp_header`, `map_resp_body` type.
+  the `method_override`, `prepend_resp_header`, `map_resp_body` middleware
+  functions.
 
 ## v1.0.0 - 2020-06-30
 

src/gleam/http.gleam

@@ -13,6 +13,7 @@
 import gleam/list
 import gleam/option.{None, Option, Some}
 import gleam/string
+import gleam/string_builder
 import gleam/uri.{Uri}
 import gleam/dynamic.{Dynamic}
 
@@ -432,3 +433,43 @@ pub fn set_req_path(req: Request(body), path: String) -> Request(body) {
     query: query,
   )
 }
+
+// TODO: test
+// TODO: escape
+// TODO: record update syntax
+/// Set the query of the request.
+///
+pub fn set_req_query(
+  req: Request(body),
+  query: List(tuple(String, String)),
+) -> Request(body) {
+  let pair = fn(t: tuple(String, String)) {
+    string_builder.from_strings([t.0, "=", t.1])
+  }
+  let query = query
+    |> list.map(pair)
+    |> list.intersperse(string_builder.from_string("&"))
+    |> string_builder.concat
+    |> string_builder.to_string
+    |> Some
+  let Request(
+    method: method,
+    headers: headers,
+    body: body,
+    scheme: scheme,
+    host: host,
+    port: port,
+    path: path,
+    query: _,
+  ) = req
+  Request(
+    method: method,
+    headers: headers,
+    body: body,
+    scheme: scheme,
+    host: host,
+    port: port,
+    path: path,
+    query: query,
+  )
+}

src/gleam/http/middleware.gleam

@@ -1,4 +1,6 @@
-import gleam/http.{Request, Response, Service}
+import gleam/http.{Delete, Patch, Post, Put, Request, Response, Service}
+import gleam/list
+import gleam/result
 
 pub type Middleware(before_req, before_resp, after_req, after_resp) =
   fn(Service(before_req, before_resp)) -> Service(after_req, after_resp)
@@ -30,3 +32,45 @@ pub fn prepend_resp_header(
     |> http.prepend_resp_header(key, value)
   }
 }
+
+fn ensure_post(req: Request(a)) {
+  case req.method {
+    Post -> Ok(req)
+    _ -> Error(Nil)
+  }
+}
+
+fn get_override_method(req) {
+  try query_params = http.req_query(req)
+  try method = list.key_find(query_params, "_method")
+  try method = http.parse_method(method)
+  case method {
+    Put | Patch | Delete -> Ok(method)
+    _ -> Error(Nil)
+  }
+}
+
+/// A middleware that overrides an incoming POST request with a method given in
+/// the request's `_method` query paramerter. This is useful as web browsers
+/// typically only support GET and POST requests, but our application may
+/// expect other HTTP methods that are more semantically correct.
+///
+/// The methods PUT, PATCH, and DELETE are accepted for overriding, all others
+/// are ignored.
+///
+/// The `_method` query paramerter can be specified in a HTML form like so:
+///
+///    <form method="POST" action="/item/1?_method=DELETE">
+///      <button type="submit">Delete item</button>
+///    </form>
+///
+pub fn method_override(service: Service(req, resp)) -> Service(req, resp) {
+  fn(req) {
+    req
+    |> ensure_post
+    |> result.then(get_override_method)
+    |> result.map(http.set_req_method(req, _))
+    |> result.unwrap(req)
+    |> service
+  }
+}

test/gleam/http/middleware_test.gleam

@@ -0,0 +1,54 @@
+import gleam/should
+import gleam/http.{Delete, Get, Patch, Post, Put, Request, Response}
+import gleam/http/middleware
+
+pub fn method_override_test() {
+  let service = fn(req: Request(a)) {
+      http.response(200)
+      |> http.set_resp_body(req.method)
+    }
+    |> middleware.method_override
+
+  // No overriding without the query param
+  http.default_req()
+  |> http.set_req_method(Get)
+  |> service
+  |> should.equal(Response(200, [], Get))
+
+  http.default_req()
+  |> http.set_req_method(Post)
+  |> service
+  |> should.equal(Response(200, [], Post))
+
+  // Can override
+  http.default_req()
+  |> http.set_req_method(Post)
+  |> http.set_req_query([tuple("_method", "DELETE")])
+  |> service
+  |> should.equal(Response(200, [], Delete))
+
+  http.default_req()
+  |> http.set_req_method(Post)
+  |> http.set_req_query([tuple("_method", "PATCH")])
+  |> service
+  |> should.equal(Response(200, [], Patch))
+
+  http.default_req()
+  |> http.set_req_method(Post)
+  |> http.set_req_query([tuple("_method", "PUT")])
+  |> service
+  |> should.equal(Response(200, [], Put))
+
+  // Cannot override with other methods
+  http.default_req()
+  |> http.set_req_method(Post)
+  |> http.set_req_query([tuple("_method", "OPTIONS")])
+  |> service
+  |> should.equal(Response(200, [], Post))
+
+  http.default_req()
+  |> http.set_req_method(Post)
+  |> http.set_req_query([tuple("_method", "SOMETHING")])
+  |> service
+  |> should.equal(Response(200, [], Post))
+}