HTTP-Modular
A universal library for converting server-side functions into ES Modules.
HTTP-Modular is a compact RPC library that unlocks the full potential of BFF (Back end for FrontEnd) capabilities.
Gone are the days of cumbersome code like this:
// server-side
app.post('/save', async (context) => {
......
const data = await getData(context);
const result = await db.save(data);
context.body = result;
});// in browser
...
const res = await fetch('https://<server.url>:<port>/save', {
method: 'POST',
body: JSON.stringify(data),
headers: {
...
}
);
const result = await res.json();
...Embrace the future of coding with modular capabilities:
// server-side
...
async function save(data) {
......
return await db.save(data);
}
app.all('/action', modular({save, list, delete}, config.koa));// in browser
import {save, list, delete} from 'https://<server.url>:<port>/action';
...
const result = await save(data); // done!
...Explore the Online Demo
Server: Check out the GitHub repository
Client: Experiment with the library on CodePen
Features
-
🧸 Lightweight and user-friendly design.
-
🌎 Compatible everywhere: Supports a wide range of Node.js HTTP servers and cloud environments.
HTTP-Modular seamlessly integrates with various environments using dedicated configurations for:
-
🧩 Effortless extensibility.
Extend HTTP-Modular to other environments like Deno, Edge Runtime, or Ben by crafting custom configurations.
Quick Started
1. Integrating with Koa:
import Koa from "koa";
import { bodyParser } from "@koa/bodyparser";
import { modular, context, config } from 'http-modular';
function add(x, y) {
return x + y;
}
const getHost = context(ctx => ctx.request.hostname);
const app = new Koa();
app.use(bodyParser());
// response
app.use(modular({ add, getHost }, config.koa));
app.listen(3000);2. Integrating with Express:
import express from "express";
import bodyParser from 'body-parser';
import { modular, context, config } from 'http-modular';
const app = express();
app.use(bodyParser.json({
limit: '4.5mb',
type: '*/*',
}));
function add(x, y) {
return x + y;
}
const getHost = context(ctx => ctx.request.hostname);
function getMessage() {
return {hi: 'there'};
}
app.all('/', modular({ add, getHost, getMessage }, config.express));
app.listen(3000);3. Integrating with Fastify:
import Fastify from 'fastify';
import { modular, context, config } from 'http-modular';
const fastify = Fastify({
logger: true
});
function add(x, y) {
return x + y;
}
const getHost = context(ctx => ctx.request.hostname);
function getMessage() {
return {hi: 'there'};
}
// Declare a route
fastify.all('/', modular({add, getHost, getMessage}, config.fastify));
// Run the server!
fastify.listen({ port: 3000 }, function (err, address) {
if (err) {
fastify.log.error(err);
process.exit(1);
}
// Server is now listening on ${address}
});4. Integrating with Nitro
import { modular, context, config } from 'http-modular';
function add(x, y) {
return x + y;
}
const echo = context(async (ctx) => {
return await readBody(ctx);
})
function getMessage() {
return {hi: 'there'};
}
export default eventHandler(
modular({add, echo, getMessage}, config.nitro)
);5. Integrating with Vercel API Functions:
import { modular, context, config } from 'http-modular';
function add(x, y) {
return x + y;
}
const echo = context(ctx => ctx.request.body);
function getMessage() {
return {hi: 'there'};
}
export default modular({add, echo, getMessage}, config.vercel);6. Integrating with AirCode Cloud Functions:
import {config, context, modular} from 'http-modular';
function add(x, y) {
return x + y;
}
const getUrl = context(ctx => ctx.url);
export default modular({
add,
getUrl,
}, config.aircode);