Merge pull request #6 from phel-lang/feat/json-parsed-body

ref: read JSON request bodies from :parsed-body

Author: Chemaclass

README.md

@@ -89,14 +89,19 @@ request data at the edge of a handler with `phel.schema` directly —
 
 ## Reading request bodies
 
-`phel.http` exposes form fields on `:parsed-body` (`$_POST`) and query string on
-`:query-params` (`$_GET`). For JSON APIs, read the raw stream — see
-`json-body` in `controller/routes.phel`:
+`phel.http` decodes the request body into `:parsed-body` for you: form fields
+(`$_POST`) for `application/x-www-form-urlencoded` / `multipart/form-data`, and
+the decoded JSON for `application/json`. Query string lives on `:query-params`
+(`$_GET`). Handlers just read the map — no manual `php://input` plumbing:
 
 ```phel
-(json/decode (php/file_get_contents "php://input"))
+(defn greet-post-handler [req]
+  (greet-response (or (:parsed-body req) {})))
 ```
 
+`:parsed-body` is `nil` for an empty or malformed body, so `(or … {})` gives a
+safe default and the schema reports the missing field.
+
 ## Routing
 
 Routes live in `src/app.phel` and use the built-in `phel.router`:

composer.json

@@ -12,11 +12,13 @@
   "type": "project",
   "require": {
     "php": ">=8.4",
-    "phel-lang/phel-lang": "^0.41"
+    "phel-lang/phel-lang": "dev-main"
   },
   "require-dev": {
     "symfony/var-dumper": "^7.3"
   },
+  "minimum-stability": "dev",
+  "prefer-stable": true,
   "scripts": {
     "run:dev": [
       "Composer\\Config::disableProcessTimeout",

composer.lock

@@ -31,41 +31,36 @@
       [:error (sc/human-readable-explain (sc/explain schema data))]
       [:ok result])))
 
-(defn- json-body
-  "Reads and decodes a JSON request body from the raw input stream.
-  Returns an empty map when the body is empty or malformed."
-  [_req]
-  (let [raw (php/file_get_contents "php://input")]
-    (if (and (string? raw) (not (php/empty raw)))
-      (try (json/decode raw) (catch \Throwable _ {}))
-      {})))
+(defn- greet-response
+  "Validates `params` against the greet schema and answers with a greeting or
+  a 400. Shared by the path-param and JSON-body greet routes."
+  [params]
+  (let [[status payload] (conform-or-error schema/greet-params params)]
+    (if (= status :ok)
+      (json-response 200 {:greeting (g/greet (:name payload))})
+      (bad-request payload))))
 
 (defn index-handler [_req]
   (html-response 200 index-html))
 
 (defn ping-handler [req]
-  ;; Pattern-match on the HTTP method instead of nested conds.
+  ;; Pattern-match on the HTTP method instead of nested conds. The JSON body is
+  ;; decoded by phel.http into :parsed-body, so there is no manual php://input read.
   (match [(:method req)]
-         ["POST"] (json-response 200 {:message "pong" :echo (json-body req) :ts (php/time)})
+         ["POST"] (json-response 200 {:message "pong" :echo (or (:parsed-body req) {}) :ts (php/time)})
          ["GET"]  (json-response 200 {:message "pong" :ts (php/time)})
          :else    (json-response 405 {:error "method not allowed"})))
 
 (defn greet-handler
   "GET /greet/{name} — validates the path param against a schema before use."
   [req]
-  (let [name            (get-in req [:attributes :match :path-params :name] "world")
-        [status result] (conform-or-error schema/greet-params {:name name})]
-    (if (= status :ok)
-      (json-response 200 {:greeting (g/greet (:name result))})
-      (bad-request result))))
+  (greet-response {:name (get-in req [:attributes :match :path-params :name] "world")}))
 
 (defn greet-post-handler
-  "POST /greet — reads a JSON body `{\"name\": \"...\"}`, validates, responds."
+  "POST /greet — reads a JSON body `{\"name\": \"...\"}`, validates, responds.
+  phel.http already decoded the body into `:parsed-body`."
   [req]
-  (let [[status result] (conform-or-error schema/greet-params (json-body req))]
-    (if (= status :ok)
-      (json-response 200 {:greeting (g/greet (:name result))})
-      (bad-request result))))
+  (greet-response (or (:parsed-body req) {})))
 
 (defn not-found-handler [_req]
   (html-response 404 "<h1>404</h1><p>Page not found.</p>"))

src/controller/routes.phel

@@ -35,10 +35,27 @@
     (is (= 400 (:status res)))))
 
 (deftest greet-post-handler-rejects-empty-body
-  ;; No request body in the test environment -> schema validation fails.
+  ;; No request body -> phel.http leaves :parsed-body nil -> validation fails.
   (let [res (routes/greet-post-handler {})]
     (is (= 400 (:status res)))))
 
+(deftest greet-post-handler-greets-from-parsed-body
+  ;; phel.http decodes the JSON body into :parsed-body; the handler just reads it.
+  (let [res (routes/greet-post-handler {:parsed-body {:name "Phel"}})]
+    (is (= 200 (:status res)))
+    (is (= "Hello, Phel!" (:greeting (json/decode (:body res)))))))
+
+(deftest greet-post-handler-rejects-too-long-name
+  (let [long-name (apply str (repeat 60 "x"))
+        res       (routes/greet-post-handler {:parsed-body {:name long-name}})]
+    (is (= 400 (:status res)))))
+
+(deftest ping-handler-echoes-parsed-body-on-post
+  (let [res  (routes/ping-handler {:method "POST" :parsed-body {:hello "world"}})
+        body (json/decode (:body res))]
+    (is (= 200 (:status res)))
+    (is (= {:hello "world"} (:echo body)))))
+
 (deftest not-found-handler-returns-404
   (let [res (routes/not-found-handler {})]
     (is (= 404 (:status res)))))