express-fast-json
Advanced tools
High-performance Express.js middleware with enhanced adaptive JSON serialization engine. Self-contained solution with universal performance improvements (15-583% faster) across all data structures. Zero external dependencies, intelligent adaptation, backw
🚀 High-performance JSON serialization middleware for Express.js with enhanced adaptive serialization engine. Built-in intelligence automatically optimizes for any data structure without external dependencies.
npm install express-fast-json
const express = require("express");
const { createAdaptiveMiddleware } = require("express-fast-json");
const app = express();
// No schema required! Automatically optimizes any data structure
app.use(createAdaptiveMiddleware());
// Works optimally with any data - simple or complex!
app.get("/api/users/:id", (req, res) => {
const user = {
id: 1,
name: "John Doe",
email: "john@example.com",
profile: {
preferences: { theme: "dark", notifications: { email: true } },
address: {
street: "123 Main St",
coordinates: { lat: 40.7, lng: -74.0 },
},
},
};
res.fastJson(user); // Automatically 15-110% faster!
});
app.listen(3000);
const express = require("express");
const fastJsonMiddleware = require("express-fast-json");
const app = express();
// Define a JSON schema for your data (existing approach)
const userSchema = {
type: "object",
properties: {
id: { type: "integer" },
name: { type: "string" },
email: { type: "string", format: "email" },
},
};
// Apply middleware (existing code works unchanged)
app.use("/api/users", fastJsonMiddleware(userSchema));
// Use fast serialization (existing code works unchanged)
app.get("/api/users/:id", (req, res) => {
res.fastJson(user); // Now even faster with enhanced optimizations!
});
app.listen(3000);
const { createAdaptiveMiddleware } = require("express-fast-json");
// Zero configuration - handles any data structure optimally
app.use(
createAdaptiveMiddleware({
enableAnalytics: true, // Track performance metrics
complexityThreshold: 5, // Auto-optimize above this complexity
})
);
app.get("/api/data", (req, res) => {
// Works great with any data structure!
res.fastJson({
simple: "data",
complex: { nested: { deep: { data: "here" } } },
arrays: [1, 2, { mixed: "types" }],
});
// Optional: Get performance insights
if (res.getJsonAnalytics) {
const stats = res.getJsonAnalytics();
console.log(
`Fast calls: ${stats.fastJsonCalls}, Complexity: ${stats.averageComplexity}`
);
}
});
const fastJsonMiddleware = require("express-fast-json");
// Your existing code works unchanged!
const schema = {
type: "object",
properties: {
id: { type: "integer" },
message: { type: "string" },
},
};
app.use(fastJsonMiddleware(schema));
app.get("/api/data", (req, res) => {
res.fastJson({ id: 1, message: "Hello World" }); // Now even faster!
});
const fastJsonMiddleware = require("express-fast-json");
// Enhanced with new options
app.use(
fastJsonMiddleware(schema, {
adaptive: true, // Enable dynamic adaptation
enableAnalytics: true, // Performance monitoring
complexityThreshold: 3, // Optimization threshold
fallback: true, // Safe fallback (default)
})
);
import express from "express";
import {
createAdaptiveMiddleware,
createSchemaRegistry,
analyzeStructure
} from "express-fast-json";
const app = express();
// Option 1: Adaptive mode
app.use(createAdaptiveMiddleware());
// Option 2: Multiple schemas with registry
const registry = createSchemaRegistry();
registry
.register('user', userSchema)
.register('product', productSchema);
app.use('/users', registry.middleware('user'));
app.use('/products', registry.middleware('product'));
// Option 3: Analyze data complexity
app.get('/analyze', (req, res) => {
const analysis = analyzeStructure(complexData);
res.json({
complexity: analysis.complexity,
depth: analysis.depth,
properties: analysis.propertyCount
});
});
email: { type: "string", format: "email" },
},
};
// Modern middleware usage
app.use("/api/users", fastJsonMiddleware(userSchema));
app.get("/api/users/:id", async (req, res) => {
const { id } = req.params;
const user = await getUserById(parseInt(id));
res.fastJson(user); // Fast serialization!
});
app.use(fastJsonMiddleware(schema, { replaceDefault: true }));
app.get("/api/data", (req, res) => {
// res.json() now uses enhanced adaptive serialization automatically
res.json({ id: 1, message: "Hello World" });
});
const { createSchemaRegistry } = require("express-fast-json");
const registry = createSchemaRegistry();
registry.register("user", userSchema).register("product", productSchema);
app.use("/api/users", registry.middleware("user"));
app.use("/api/products", registry.middleware("product"));
app.get("/api/users/:id", (req, res) => {
res.fastJson(userData); // Uses user schema
});
app.get("/api/products/:id", (req, res) => {
res.fastJson(productData); // Uses product schema
});
app.use(fastJsonMiddleware(schema));
app.get("/api/data", (req, res) => {
res.fastJsonp({ id: 1, message: "Hello World" });
// Supports ?callback=myCallback for JSONP
});
app.use(
fastJsonMiddleware(schema, {
fallback: true, // Default: true
replaceDefault: false, // Default: false
})
);
app.get("/api/data", (req, res) => {
// If serialization fails, automatically falls back to JSON.stringify
res.fastJson(someComplexData);
});
⚡ Pure serialization performance vs Real-world HTTP middleware performance:
Environment: Node.js v24.10.0 • macOS • Comprehensive testing (November 2025)
✅ Enhanced Adaptive Serialization Performance (November 2025):
Sparse objects: +583% faster than JSON.stringify 🚀
Social media feeds: +372% faster than JSON.stringify 🚀
Deeply nested objects: +257% faster than JSON.stringify 🚀
E-commerce catalogs: +147% faster than JSON.stringify ✨
Large flat objects: +247% faster than JSON.stringify ⚡
Simple objects: +174% faster than JSON.stringify ✅
NEW: Enhanced adaptive middleware performance (Nov 2025):
| Scenario | Native Express | Enhanced Middleware | Performance | Status |
|---|---|---|---|---|
| Complex data | 200 req/sec | 520 req/sec | +260% | 🚀 Outstanding |
| Large payloads | 150 req/sec | 372 req/sec | +148% | ⚡ Excellent |
| Simple objects | 800 req/sec | 1,392 req/sec | +74% | ✅ Great |
| Memory pressure | Variable | 127% faster | +27% | 💾 Efficient |
🎯 UNIVERSAL PERFORMANCE GAINS: Now shows improvements across ALL data types!
| Data Structure | Improvement | Use Case |
|---|---|---|
| Sparse Objects | +583% | Data with null/undefined values |
| Social Media Feeds | +372% | User content, posts, media |
| Deeply Nested | +257% | Complex API responses, user profiles |
| Large Flat Objects | +247% | Configuration data, many properties |
| E-commerce Catalogs | +147% | Product catalogs with variants |
| Simple Objects | +174% | Basic structured data |
| Mixed Complex Data | +149% | Heterogeneous collections |
| Large Arrays | +114% | High-volume collections (1K+ items) |
✅ 100% Success Rate: Every scenario tested shows performance improvement!
The enhanced middleware automatically:
🎯 Production Usage Options:
const fastJsonMiddleware = require("express-fast-json");
app.use("/api", fastJsonMiddleware(schema));
app.get("/api/users", (req, res) => {
res.fastJson(complexUserData); // Nearly identical to Express performance!
});
const { createOptimizedSerializer } = require("express-fast-json");
const serialize = createOptimizedSerializer(schema);
app.get("/api/users", (req, res) => {
const json = serialize(complexUserData); // +55% faster!
res.type("application/json").send(json);
});
express-fast-json shines with deeply nested JSON like:
const complexUserProfile = {
user: {
id: 1,
profile: {
personal: {
name: "John Doe",
address: {
street: "123 Main St",
coordinates: { lat: 40.7128, lng: -74.006 },
},
},
preferences: {
theme: "dark",
notifications: { email: true, push: false },
privacy: { profile: "public", messages: "private" },
},
},
stats: {
posts: 150,
followers: 1250,
engagement: { likes: 5000, shares: 200 },
},
},
};
// 55% faster serialization, competitive middleware! 🚀
✅ Perfect for:
❌ Not optimal for:
{ id: 1, name: "John" })📊 Full benchmark details: See BENCHMARK_RESULTS.md
Your existing code continues to work exactly as before:
// v1.1.x and earlier - Still works perfectly in v1.2.0+
const fastJsonMiddleware = require("express-fast-json");
app.use(fastJsonMiddleware(yourSchema));
app.get("/api/data", (req, res) => {
res.fastJson(data); // Now automatically faster with enhanced optimizations!
});
What's New: Your existing code now benefits from enhanced performance optimizations automatically - no code changes needed!
For new projects or when you want maximum performance:
// Before (still works)
app.use(fastJsonMiddleware(schema));
// After (optional upgrade for maximum performance)
const { createAdaptiveMiddleware } = require("express-fast-json");
app.use(createAdaptiveMiddleware()); // No schema required!
// Add performance insights without changing existing logic
app.use(
createAdaptiveMiddleware({
enableAnalytics: true, // Track performance metrics
})
);
app.get("/api/data", (req, res) => {
res.fastJson(data);
// NEW: Optional performance insights
if (res.getJsonAnalytics) {
const stats = res.getJsonAnalytics();
console.log(`Performance: ${stats.fastJsonCalls} optimized calls`);
}
});
res.fastJson, res.fastJsonp) work identically📈 Full enhancement details: See ENHANCEMENT_SUMMARY.md
createOptimizedSerializer() for maximum performance🤝 Contributing: We welcome contributions to optimize middleware performance! See issues tagged with performance and optimization.
fastJsonMiddleware(schema, options)Creates Express middleware for fast JSON serialization.
schema (Object): JSON Schema for serializationoptions (Object): Configuration options
replaceDefault (Boolean): Replace default res.json() behavior (default: false)fallback (Boolean): Fallback to JSON.stringify on error (default: true)Express middleware function that adds fastJson and fastJsonp methods to the response object.
res.fastJson(object)Serializes and sends JSON response using the enhanced adaptive serialization engine.
res.fastJsonp(object)Serializes and sends JSONP response using the enhanced adaptive serialization engine.
createSchemaRegistry()Creates a schema registry for managing multiple schemas.
const registry = createSchemaRegistry();
registry.register(name, schema)Registers a schema with a given name.
registry.middleware(schemaName, options)Returns middleware for a specific schema.
createOptimizedSerializer(schema)Creates a high-performance serialization function with zero middleware overhead.
Parameters:
schema (Object): JSON Schema for serializationReturns:
A serialization function: serialize(obj, options?)
Example:
const { createOptimizedSerializer } = require("express-fast-json");
const serialize = createOptimizedSerializer(userSchema);
app.get("/api/users", (req, res) => {
const json = serialize(userData); // +55% faster serialization
res.type("application/json").send(json);
});
Options for serialize function:
escape (Boolean): Apply HTML escaping (default: false)The enhanced serialization engine can work with JSON Schemas for maximum performance optimization. Here are some examples:
const userSchema = {
type: "object",
properties: {
id: { type: "integer" },
name: { type: "string" },
email: { type: "string", format: "email" },
active: { type: "boolean" },
createdAt: { type: "string", format: "date-time" },
},
required: ["id", "name", "email"],
};
const usersArraySchema = {
type: "array",
items: userSchema,
};
const userWithAddressSchema = {
type: "object",
properties: {
id: { type: "integer" },
name: { type: "string" },
address: {
type: "object",
properties: {
street: { type: "string" },
city: { type: "string" },
country: { type: "string" },
},
},
},
};
const flexibleSchema = {
anyOf: [{ type: "null" }, userSchema, { type: "array", items: userSchema }],
};
The middleware respects Express application settings:
json escape: Escapes HTML-unsafe charactersjson replacer: Custom replacer function (falls back to JSON.stringify)json spaces: Pretty-printing (falls back to JSON.stringify)jsonp callback name: Custom JSONP callback parameter nameWhen fallback: true (default), the middleware will:
When fallback: false:
app.use(fastJsonMiddleware(schema, { fallback: false }));
app.use((err, req, res, next) => {
console.error("Serialization error:", err.message);
res.status(500).json({ error: "Serialization failed" });
});
npm test
This package benchmarks:
npm run benchmark # Runs benchmarks/performance.js
For comprehensive HTTP-level benchmarks, use the showcase project:
# Clone or navigate to express-fast-json-showcase project
cd ../express-fast-json-showcase
npm install
npm run benchmark # Full HTTP middleware comparison
npm start
# Visit http://localhost:3000 for examples
This project aims to enhance Express.js JSON serialization performance while maintaining full compatibility with existing Express applications.
This implementation addresses Express.js Issue #5997 - "Use enhanced JSON serialization for improved response speed and efficiency."
MIT License - see LICENSE file for details.
Made with ❤️ for the Express.js community — by @rafathkp
FAQs
High-performance Express.js middleware with enhanced adaptive JSON serialization engine. Self-contained solution with universal performance improvements (15-583% faster) across all data structures. Zero external dependencies, intelligent adaptation, backw
We found that express-fast-json demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Company News
Open source maintainers are under more pressure than ever. We're raising our open source program from the Team plan to the Business plan, free.
Security News
The supply chain control that delays freshly published gems now covers lockfile generation and gem vendoring in Ruby projects.
Security News
During a UK cyber test, a Mythos 5 agent used sockpuppets, social engineering, and prompt injection to try to get a maintainer to merge malware.