https://github.com/nuty/vela
Web framework for Racket.
https://github.com/nuty/vela
framework racket restful web webframework
Last synced: about 1 month ago
JSON representation
Web framework for Racket.
- Host: GitHub
- URL: https://github.com/nuty/vela
- Owner: nuty
- License: mit
- Created: 2019-04-29T12:35:02.000Z (almost 7 years ago)
- Default Branch: master
- Last Pushed: 2023-07-14T02:07:02.000Z (over 2 years ago)
- Last Synced: 2025-10-20T14:58:00.631Z (5 months ago)
- Topics: framework, racket, restful, web, webframework
- Language: Racket
- Homepage:
- Size: 378 KB
- Stars: 41
- Watchers: 4
- Forks: 4
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-racket - vela - Simple web framework to build RESTful app in Racket. (Web Frameworks)
README
Vela
========
Simple web framework to build restful app in Racket.
Features
------------
- Web handlers with Function or Class.
- Friendly way to define url routers.
- Pluggable middlewares when request and response.
- Request params check and collector.
- Entirely on the racket webserver lib.
Installation
------------
`raco pkg install vela`
Quickstart
------------
```racket
#lang racket
(require vela)
(define index
(lambda (req)
(jsonify (hash 'msg "hello world!" ))))
(define routers
(urls
(url "/" index "index")))
(app-run routers #:port 8000)
```
Define Handler
-----------
There two ways to define a handler.
Use ```handler%```
```racket
(define hello-handler
(class handler%
(define/public (get [id null])
(define req (get-field request this))
(jsonify (hash 'code 200 'msg "handle get" )))
(define/public (post)
(jsonify (hash 'code 200 'msg "handle post" )))
(define/public (put id)
(jsonify (hash 'code 200 'msg "handle put" )))
(define/public (delete id)
(jsonify (hash 'code 200 'msg "handle delete" )))
(super-new)))
```
Use simple function:
```racket
(define index-handler
(lambda (req)
(jsonify (hash 'code 200 'msg "hello api" ))))
```
or
```racket
(define (index-handler req)
(jsonify (hash 'code 200 'msg "hello api" )))
```
Response
-----------
Use ```jsonify ``` to return JSON content.
```racket
(jsonify (hash 'name "rosso" 'msg "hello world!"))
```
Use ```render ``` to render TEXT or HTML template.
plain text
```racket
(render "hello world!")
```
HTML template
```racket
(require web-server/templates)
...
(render (include-template "index.html"))
```
URL routes
-----------
Use ```urls``` and ```url``` function to define route.
```racket
(define routers
(urls
(url "/" index-handler "handler with function")))
```
Use ```url-group``` grouping routes.
```racket
(define api-v1 (url-group "/api/v1"))
(define routers
(urls
...
(api-v1
(url "/hellos" hello-handler "hello-list/post")
(url "/hello/:id" hello-handler "hello-put/delete/get"))))
```
Use middleware
-----------
Use middleware in ```url``` or ```url-group```.
Whether it is request middleware or response middleware. When it returns a can-be-response?,
the entire request will be interrupted and the responsed by the middleware will be returned.
```racket
(require
vela
web-server/http/request-structs)
;; handler
(define (index req)
(jsonify "hello!"))
;; middlewares
(define (request-middleware req)
(displayln "current-datetime")
(jsonify "hi!"))
(define (response-middleware req resp)
(displayln "current-datetime")
(jsonify "bye!"))
;; url groups
(define req-urls
(url-group "/req" #:on-request (list request-middleware)))
(define resp-urls
(url-group "/resp" #:on-response (list response-middleware)))
(define req-and-resp-urls
(url-group "/both" #:on-request (list request-middleware) #:on-response (list response-middleware)))
;; routers
(define middles-test-routers
(urls
(url "/req" index #:on-request (list request-middleware) "request-middleware")
(url "/resp" index #:on-response (list response-middleware) "response-middleware")
(req-urls
(url "/test" index "test-req"))
(resp-urls
(url "/test" index "test-resp"))
(req-and-resp-urls
(url "/test" index "test-req-and-resp"))))
```
request middleware should set a request argument is request context. response middleware must set request and response arguments.
Customize Headers
-----------
You need require ```make-header``` from ```request-structs``` package.
```racket
(require
(only-in web-server/http/request-structs
make-header))
(define my-headers
(list
...
(make-header #"Access-Control-Allow-Origin" #"*")
(make-header #"Access-Control-Allow-Methods" #"PUT, POST, GET, DELETE, PATCH, OPTIONS")))
```
Customize Response
-----------
Use ```response```fuction
```racket
(define (my-custom-rsp xml-doc)
(response
#:headers my-headers
#:mime #"application/xml"
#:body xml-doc))
```
examples
----------
Very simple apps build with Vela in the [examples folder](https://github.com/nuty/vela/tree/master/examples).
License
-------
Licensed under the MIT License.