@resapi/express 0.2.0 → 0.4.0

package/README.md

@@ -8,4 +8,4 @@ npm install @resapi/core @resapi/express express
 
 Add `"@resapi/core"` and `"@resapi/express"` to `dependencies` in `rescript.json`. Modules are under the `ResApiExpress` namespace. Requires Express 5 (tested with 5.2).
 
-See the [README](https://github.com/Seaside-Logic/resapi#readme) and [API reference](https://github.com/Seaside-Logic/resapi/blob/main/docs/api.md).
+See the [README](https://github.com/Seaside-Logic/resapi#readme) and [API reference](https://github.com/Seaside-Logic/resapi/blob/main/site/content/api.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resapi/express",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Express server adapter for resAPI contracts.",
   "license": "MIT",
   "homepage": "https://resapi.dev",
@@ -32,9 +32,9 @@
     "rescript": "^12.3.1"
   },
   "dependencies": {
-    "@resapi/core": "^0.2.0"
+    "@resapi/core": "^0.4.0"
   },
   "devDependencies": {
-    "express": "5.2.1"
+    "express": "5.3.0"
   }
 }

package/src/EndpointHandler.res

@@ -15,7 +15,7 @@ type route = {
   run: (Req.t, Res.t) => promise<unit>,
 }
 
-// Router.register mounts POST routes behind `express.text`, so the body is the raw string. A body
+// Router.register mounts POST and PUT routes behind `express.text`, so the body is the raw string. A body
 // already parsed by an upstream `express.json()` is used as it is. No body at all parses as "".
 let rawBody = req =>
   switch req->Req.body->Nullable.toOption {

package/src/Router.res

@@ -16,16 +16,20 @@ type server
 @module("express") external text: {"type": string => bool} => middleware = "text"
 @send external expressGet: (t, string, handler) => unit = "get"
 @send external expressPost: (t, string, handler) => unit = "post"
+@send external expressPut: (t, string, handler) => unit = "put"
+@send external expressDelete: (t, string, handler) => unit = "delete"
 @send external expressAll: (t, string, handler) => unit = "all"
 @send external expressPostWith: (t, string, middleware, handler) => unit = "post"
+@send external expressPutWith: (t, string, middleware, handler) => unit = "put"
 @send external expressUse: (t, middleware) => unit = "use"
 @send external expressUseAt: (t, string, middleware) => unit = "use"
 
 @send external listen: (t, int, unit => unit) => server = "listen"
 @send external close: server => unit = "close"
 
-// Express's error handler logs `err.stack`, which a raw ReScript exception lacks: it logs as
-// "[object Object]". Rethrowing it as an Error keeps the log readable. JS errors pass untouched.
+// Express's error page reads `err.stack`, which a raw ReScript exception lacks: outside production it
+// shows "[object Object]", and Express before 5.3 logs that too. Rethrowing it as an Error keeps both
+// readable. JS errors pass untouched.
 let rethrowAsError = exn =>
   switch exn {
   | JsExn(e) => JsExn.throw(e)
@@ -51,6 +55,16 @@ let post = (router, path, handler) => {
   router
 }
 
+let put = (router, path, handler) => {
+  router->expressPut(path, catchExceptions(handler))
+  router
+}
+
+let delete = (router, path, handler) => {
+  router->expressDelete(path, catchExceptions(handler))
+  router
+}
+
 let all = (router, path, handler) => {
   router->expressAll(path, catchExceptions(handler))
   router
@@ -83,6 +97,8 @@ let register = (router, route: EndpointHandler.route) => {
   switch route.method {
   | Get => router->expressGet(route.path, route.run)
   | Post => router->expressPostWith(route.path, rawText, route.run)
+  | Put => router->expressPutWith(route.path, rawText, route.run)
+  | Delete => router->expressDelete(route.path, route.run)
   }
   router
 }

package/src/Router.resi

@@ -23,12 +23,14 @@ type server
 /** A rejected handler goes to Express's error handler. */
 let get: (t, string, handler) => t
 let post: (t, string, handler) => t
+let put: (t, string, handler) => t
+let delete: (t, string, handler) => t
 
 /** Runs for every request whose path starts with `~path` (default all), including unmatched routes.
     The first `use` is the outermost layer. */
 let use: (t, ~path: string=?, middleware) => t
 
-/** POST endpoints get a raw-text body parser (100kb limit). A body already parsed upstream is used as is. */
+/** POST and PUT endpoints get a raw-text body parser (100kb limit). A body already parsed upstream is used as is. */
 let register: (t, EndpointHandler.route) => t
 
 /** A plain route for every HTTP method. For unmatched requests, add a last `use` (Express has no