RESTHeart Framework
✅ Instant REST, GraphQL and Websockets APIs for MongoDB. ✅ Declarative Security, no code required. ✅ Implement your Backend in minutes.
Ask Sophia AI about RESTHeart
Run this docker command to start (go to Setup for more installation options)
$ docker pull softinstigate/restheart && curl https://raw.githubusercontent.com/SoftInstigate/restheart/master/docker-compose.yml --output docker-compose.yml && docker compose up --attach restheart
Then check the tutorials
MongoDB REST API Tutorial MongoDB GraphQL API Tutorial Framework Tutorial Auth TutorialRESTHeart Features
RESTHeart unlocks all the features of MongoDB via REST, GraphQL and WebSocket APIs.
Also supports Mongo Atlas, FerretDB, AWS DocumentDB, and Azure Cosmos DB
RESTHeart is available as a Docker image and tailored for the GraalVM to build lightweight native images with instant startup time, low memory footprint.
RESTHeart provides a powerful and battle-tested security layer that keeps your application secure without coding.
Unlock the Power of Microservices with Ease: discover our innovative development framework that simplifies the creation of microservices in Java, Kotlin, JavaScript, or TypeScript. Our framework provides a set of simple yet robust building blocks: Service, Provider, Interceptor, and Initializer.
Focus on Your Microservice Logic, Not the Complexity. Experience the freedom to code your microservice logic without worrying about complex and time-consuming tasks. Our framework takes care of crucial aspects such as runtime process management, security, concurrency, HTTP transport protocol, request routing, logging, configuration, and data protection.
The RESTHeart runtime leverages a scalable and pooled thread-per-request concurrency model. This means that developers, including those working with JavaScript, can enjoy a streamlined development process without the complexities of asynchronous programming.
Read, write and search JSON documents with HTTP requests without coding; specify MongoDB queries and projection options; deal with large result sets with automatic pagination.
The GraphQL plugin works side by side with the REST plugin to get an unified API to build modern applications. GraphQL applications are configured through an API without coding.
The WebSocket API notifies clients of data changes in real time and supports thousands of connected clients. Data streams are configured through an API without coding.
Data API
Query documents from the command line with httpie.
The GET request has two query parameters:
filter to apply a query and
pagesize to limit the response to one
document.
Here we use the brilliant
httpie, a modern command line HTTP client.
$ http -b GET
https://demo.restheart.org/messages'?filter={"from":"Bob"}&pagesize=1'
[ { "_id": { "$oid": "5c50963e477870eb8258fa68" }, "from": "Bob",
"message": "was here" } ] Query documents from the command line with cURL.
The GET request has two query parameters:
filter to apply a query (that needs to
be encoded with --data-urlencode option since it contains the
curly brackets) and pagesize to limit
the response to one document.
Here we use the immortal
cURL!
$ curl -G --data-urlencode
'filter={"from":"Bob"}'
https://demo.restheart.org/messages?pagesize=1 [ { "_id": { "$oid":
"5c50963e477870eb8258fa68" }, "from": "Bob", "message": "was here",
} ] Query documents with JavaScript.
The GET request has two query parameters:
filter to apply a query and
pagesize to limit the response to one
document.
Here we use the
fetch API.
const url =
encodeURI('https://demo.restheart.org/messages?filter={"from":"Bob"}&pagesize=1');
fetch(url) .then(response => response.json()) .then(json =>
JSON.stringify(json, null, 2)) .then(docs => console.log(docs)); Query documents with Java.
The GET request has two query parameters:
filter to apply a query and
pagesize to limit the response to one
document.
Here we use the
unirest
java http library.
public void printOutMessages() throws
UnirestException { var resp =
Unirest.get("https://demo.restheart.org/messages")
.queryString("filter", "{'from':'Bob'}") .queryString("pagesize",
"1") .asJson(); // print out each message
resp.getBody().getArray().forEach(msg ->
System.out.println(msg.toString())); } Query documents with Swift.
The GET request has two query parameters:
filter to appy a query and
pagesize to limit the response to one
document.
Here we use the JSONSerialization to parse the response body.
import UIKit import PlaygroundSupport var
urlComponents = URLComponents(string:
"https://demo.restheart.org/messages") // set the query parameters
var queryItems = [URLQueryItem]()
queryItems.append(URLQueryItem(name: "pagesize", value: "1"))
queryItems.append(URLQueryItem(name: "filter", value:
"{\"from\":\"Bob\"}")) urlComponents?.queryItems = queryItems var
urlRequest = URLRequest(url: (urlComponents?.url)!) // set request
method urlRequest.httpMethod = "GET"
URLSession.shared.dataTask(with: urlRequest) { (data, response,
error) in guard let dataResponse = data, error == nil else {
print(error?.localizedDescription ?? "Response Error") return } do {
let jsonResponse = try JSONSerialization.jsonObject(with:
dataResponse, options: []) print(jsonResponse) } catch let jsonError
{ print(jsonError) } }.resume() // only needed in playground
PlaygroundPage.current.needsIndefiniteExecution = true Polyglot Framework
Implement web services in minutes.
Implement a simple interface and deploy the web service by copying its jar file into the plugins directory.
See it on GitHub More examples @RegisterPlugin(name = "greetings", description
= "just another Hello World") public class GreeterService implements
JsonService { @Override public void handle(JsonRequest req,
JsonResponse res) { switch(req.getMethod()) { case GET ->
res.setContent(object().put("message", "Hello World!")); case
OPTIONS -> handleOptions(req); default ->
res.setStatusCode(HttpStatus.SC_METHOD_NOT_ALLOWED); } } } Implement plugins in Kotlin.
You can use Java and Kotlin to implement plugins.
Kotlin Service example @RegisterPlugin(name = "kotlinGreeterService",
description = "just another Hello World in Kotlin") class
GreeterService : JsonService { override fun handle(req: JsonRequest,
res: JsonResponse) { when(req.method) { METHOD.GET -> res.content =
obj().put("msg", "Hello World").get() METHOD.OPTIONS ->
handleOptions(req); else ->
res.setStatusCode(HttpStatus.SC_METHOD_NOT_ALLOWED); } } } Snoop and modify requests at different stages of their lifecycle.
This interceptor applies to requests of the hello web service
adding a timestamp to the response content.
Interceptor can be executed at different points of the request as
defined by the interceptPoint parameter of the annotation
RegisterPlugin
@RegisterPlugin(name = "helloInterceptor",
description = "add a timestamp to the response of /greetings",
interceptPoint = InterceptPoint.RESPONSE) public class
HelloInterceptor implements JsonInterceptor { @Override public void
handle(JsonRequest req, JsonResponse res) { res.getContent()
.getAsJsonObject() .addProperty("timestamp",
Instant.now().toString()); } @Override public boolean
resolve(JsonRequest req, JsonResponse res) { return
req.isHandledBy("greetings"); } } Implement plugins in JavaScript.
This is yet another Hello World web service.
Running RESTHeart on the GraalVM allows you to deploy JavaScript
Services and Interceptors.
export const options = { name:
"helloWorldService", description: "just another Hello World", uri:
"/hello" } export function handle(req, res) {
res.setContent(JSON.stringify({ msg: 'Hello World' }));
res.setContentTypeAsJson(); }