Like any kind of apps, there are difficult issues to solve when we write Node apps.
In this article, we’ll look at some solutions to common problems when writing Node apps.
Return JSON Using Node or Express
We can render a JSON response with the http package by setting the Content-Type header and the res.end method.
For instance, we can write:
const http = require('http');
const app = http.createServer((req, res) => {
res.setHeader('Content-Type', 'application/json');
res.end(JSON.stringify({
a: 1
}));
});
app.listen(3000);
We call createServer to create an HTTP server.
In the callback, we set the Content-Type response header to application/json to set the response data to JSON.
Then we call res.end with the stringified JSON to render the response.
With Express, we just have to write:
res.json({
foo: "bar"
});
in our middleware.
res.json sets the headers and render the JSON.
Enable HTTPS with Express
We can enable HTTPS with Express by reading the certificate data and use http.createServer to create the server.
For instance, we can write;
const fs = require('fs');
const http = require('http');
const https = require('https');
const privateKey = fs.readFileSync('sslcert/server.key', 'utf8');
const certificate = fs.readFileSync('sslcert/server.crt', 'utf8');
const credentials = {
key: privateKey,
cert: certificate
};
const express = require('express');
const app = express();
const httpServer = http.createServer(app);
const httpsServer = https.createServer(credentials, app);
httpServer.listen(3000);
httpsServer.listen(3443);
We read the private key and certificate files from the server.
Then we pass them all in an object and that object is passed to https.createServer to create the server.
Then we call listen on the httpsServer to create the server.
We still have to create the HTTP server to listen to non-secure HTTP requests.
Fix ‘Error: request entity too large’ Error from Express
We can fix the ‘request entity too large’ error by increasing the allowed size of requests.
For instance, we can write:
const bodyParser = require('body-parser');
app.use(bodyParser.json({
limit: '50mb'
}));
app.use(bodyParser.urlencoded({
limit: '50mb',
extended: true
}));
We set limit in the object that we passed in as the argument to set the max size of the request payload.
'50mb' is 50 megabytes.
Download a File from Node Server Using Express
We can send a file download response to the client with res.download .
For instance, we can write:
app.get('/download', (req, res) => {
const file = path.join(__dirname, '/upload-folder/movie.mp4');
res.download(file);
});
The res.download requires the absolute path to the file, so we need to combine __dirname with the rest of the path.
res.download will set the Content-Disposition and other headers automatically and send the file to the client.
Server Static Files with Express
We can serve static files with Express using the express.static middleware.
For instance, we can write:
app.use(express.static(path.join(__dirname, '/public')));
We serve the folder we want to serve as the static folder with the absolute path.
express.static will expose the folder to the client.
Get the JSON POST Data in an Express Application
We can get the JSON data from a POST request by using the req.body property.
For instance, we can write:
const express = require('express');
const bodyParser = require('body-parser');
const app = express.createServer();
app.use(`bodyParser`.`json`());
app.post('/', (req, res) => {
console.log(req.body);
response.send(req.body);
});
app.listen(3000);
req.body has the JSON request payload.
The req.body property is available if we ran the bodyParser.json() middleware.
We did that with:
app.use(bodyParser.json());
Remove Documents Using Node.js Mongoose
We can remove a document with Mongoose by using the remove method on the model class.
For example, we can write:
Model.remove({
_id: id
}, (err) => {
if (err) {
console.log(err);
}
});
Get Uploaded Files with Express
To get uploaded files with Express, we can use the express-fileupload package.
For example, we can write:
const fileupload = require("express-fileupload");
app.use(fileupload());
app.post("/upload", (req, res) => {
if (!req.files) {
res.send("File not found");
return;
}
const file = req.files.photo;
res.send("File Uploaded");
});
We used the fileupload middleware from the express-fileupload package.
To use it, we write:
app.use(fileupload());
The req.files should be available when we upload one or more files.
We can get the files by using the req.files object.
photo is the field name of the file input.
We can replace that with the correct name.
Conclusion
There are a few ways to render JSON response to the client.
We can get file uploads with a middleware package.
Also, we can return a file download response with res.download .
We’ve to use body-parser to parse JSON request payloads.
