Develop Reference

Node express mysql second route call crashes

I am trying to set an API. when the default route is called, with '/', the route can be called several times but the route '/count' can only be called once before crashing with this error:
/Users/node_modules/mysql/lib/protocol/Parser.js:437
throw err; // Rethrow non-MySQL errors
^
Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client
at ServerResponse.setHeader (_http_outgoing.js:467:11)
at ServerResponse.header (/Users/node_modules/express/lib/response.js:771:10)
at ServerResponse.send (/Users/node_modules/express/lib/response.js:170:12)
at ServerResponse.json (/Users/node_modules/express/lib/response.js:267:15)
at ServerResponse.send (/Users/node_modules/express/lib/response.js:158:21)
at Query.<anonymous> (/Users/server_sql/testingAPI/routes/index.js:25:36)
at Query.<anonymous> (/Users/node_modules/mysql/lib/Connection.js:525:10)
at Query._callback (/Users/node_modules/mysql/lib/Connection.js:491:16)
at Query.Sequence.end (/Users/node_modules/mysql/lib/protocol/sequences/Sequence.js:83:24)
at Query._handleFinalResultPacket (/Users/node_modules/mysql/lib/protocol/sequences/Query.js:139:8)
app.js
const http = require('http');
const cors = require('cors');
const body_parser = require('body-parser');
const databases = require('./connection_management');
const route = require('./routes/index');
const app = express();
app.use(cors());
app.use(body_parser.urlencoded({
extended: true
}));
app.use(body_parser.json());
app.use(databases.connectionsSql);
app.use('/', route);
http.createServer(app).listen(8080, (err) => {
if (!err)
console.log("API ready and HTTP listen on port 8080.");
else
console.log(err)
});
module.exports = app;
route/index.js
var router = require('express').Router();
var connection = require('../connection_management');
router.get('/', function(req, res){
res.send('Default route');
});
function getCo(){
return connection.coSql['test'].pool;
}
router.get('/count', function(req, res){
var pool = getCo();
var countQuery = "SELECT COUNT(data) FROM table WHERE data IS NOT NULL";
try {
pool.getConnection(function(errco, connection){
if(errco) return res.send(errco);
connection.query(countQuery, function(error, result){
if (error) throw error;
else {
try{
connection.release();
return res.send(result);
} catch (err) {
return res.send(err);
}
}
});
})
}catch (err){
return res.send(err);
}
})
module.exports = router;
connection_management.js
const fs = require('fs');
var mysql = require('mysql');
var config = fs.readFileSync('config.json');
config = JSON.parse(config);
const coSql = [];
exports.connectionsSql = (req, res, next) => {
for (let i = 0; i < config.sql.databases.length; i++) {
if (coSql[config.sql.databases[i].name]) {
next();
} else {
coSql[config.sql.databases[i].name] = {};
coSql[config.sql.databases[i].name].pool = mysql.createPool({
host: config.sql.databases[i].host,
user: config.sql.user,
password: config.sql.password,
database: config.sql.databases[i].name});
}
}
next();
}
module.exports.coSql = coSql;
config.js
{
"sql":{
"user": "foo",
"password": "bar",
"databases":[
{
"name": "test",
"host": "localhost"
}
]
}
}
Thanks for your help, fixing and understanding the problem.

In route/index.js:
router.get('/count', function(req, res){
var pool = getCo();
var countQuery = "SELECT COUNT(data) FROM table WHERE data IS NOT NULL";
try {
pool.getConnection(function(errco, connection){
if(errco) throw New Error(errco); // <---- CHANGED THIS.
connection.query(countQuery, function(error, result){
if (error) throw error;
else {
try{
connection.release();
return res.send(result);
} catch (err) {
throw New Error(err); // <---- CHANGED THIS.
}
}
});
})
}catch (err){
return res.send(err);
}
})
You might be calling res.send more than once in your code due to the way you've written you error catching.
I have replaced 2 of your res.send() method calls with thrown errors so that they are caught and dealt with in the final catch block at the bottom.

pendingItem.callback is not a function?

I am trying to view the first row of a table but I get the error
TypeError: pendingItem.callback is not a function
at client.connect
var express = require("express");
const {Pool} = require("pg");
var app = express();
var conStr = "postgres://postgres:password#localhost:5432/postgres";
const pool = new Pool();
app.get("/", function(req, res, next) {
pool.connect(conStr, function(err, client, done) {
if (err) {
console.log("not able to get connection " + err);
res.status(400).send(err);
}
client.query("SELECT * FROM Users where id= $1", [1], function(err, result) {
done();
if (err) {
console.log(err);
res.status(400).send(err);
}
res.status(200).send(result.rows);
});
});
});

On Postgres connection Pool using connectionString
First if you are choosing to connect to Postgres using connectionURI, you need to initialize Pool with connectionString param:
const pool = new Pool({
connectionString: connectionString,
})
Then when calling pool.connect you only need to pass callback function:
pool.connect((err, client, release) => {...});
Check documentation on Pooling and different ways of making a connection to Postgres using node-postgres package: here and here
In your case this, it should look like this:
var express = require("express");
const pg = require("pg");
const {Pool} = require("pg");
var app = express();
var conStr = "postgres://postgres:password#localhost:5432/postgres";
const pool = new Pool({
connectionString: conStr
});
app.get("/", function(req, res, next) {
pool.connect(function(err, client, done) {
if (err) {
console.log("not able to get connection " + err);
res.status(400).send(err);
}
client.query("SELECT * FROM Users where id= $1", [1], function(err, result) {
done();
if (err) {
console.log(err);
res.status(400).send(err);
}
res.status(200).send(result.rows);
});
});
});

Best practise to define a PostgreSQL database connection variable globally in a node.js web application?

I am creating a node and express REST application with a PostgreSQL database.
My question is how to define the connection variable globally in a minimalist express application (for a Hello World example)?
I have the following file structure with the following key files included.
{PROJECT_ROOT}\bin\www
{PROJECT_ROOT}\app.js
{PROJECT_ROOT}\routes\index.js
{PROJECT_ROOT}\db\db.js
{PROJECT_ROOT}\db\location.js
{PROJECT_ROOT}\OTHER FILES
The db.js should contain definition of a variable for a connection to the PostgreSQL database globally. This variable should be shared by other modules whenever necessay so that duplicated connections should be avoided.
db.js
var promise = require('bluebird');
/**
*Use dotenv to read .env vars into Node
*/
require('dotenv').config();
const options = {
// Initialization Options
promiseLib: promise,
connect(client, dc, useCount) {
const cp = client.connectionParameters;
console.log('Connected to database:', cp.database);
}
};
const pgp = require('pg-promise')(options);
const connectionString = process.env.PG_CONN_STR;
const db = pgp(connectionString);
module.exports = {
pgp, db
};
location.js defines the business logic to manipulate the gcur_point_location table.
var db_global = require('./db');
var db = db_global.db;
// add query functions
module.exports = {
getAllLocations: getAllLocations,
getLocation: getLocation,
createLocation: createLocation,
updateLocation: updateLocation,
removeLocation: removeLocation
};
function getAllLocations(req, res, next) {
db.any('select * from gcur_point_location')
.then(function (data) {
res.status(200)
.json({
status: 'success',
data: data,
message: 'Retrieved ALL GCUR Point Locations'
});
})
.catch(function (err) {
return next(err);
});
}
function getLocation(req, res, next) {
var locationId = parseInt(req.params.id);
db.one('select * from gcur_point_location where locationid = $1', locationId)
.then(function (data) {
res.status(200)
.json({
status: 'success',
data: data,
message: 'Retrieved ONE Location by Id'
});
})
.catch(function (err) {
return next(err);
});
}
function createLocation(req, res, next) {
req.body.age = parseInt(req.body.age);
db.none('insert into gcur_point_location(locationname, locationstatus, lng, lat)' +
'values(${locationname}, ${locationstatus}, ${lng}, ${lat})',
req.body)
.then(function () {
res.status(200)
.json({
status: 'success',
message: 'Inserted one Location'
});
})
.catch(function (err) {
return next(err);
});
}
function updateLocation(req, res, next) {
db.none('update gcur_point_location set locationname=$1, locationstatus=$2, lng=$3, lat=$4 where locationid=$5',
[req.body.locationname, req.body.locationstatus, parseFloat(req.body.lng),
parseFloat(req.body.lat), parseInt(req.params.id)])
.then(function () {
res.status(200)
.json({
status: 'success',
message: 'Updated Location'
});
})
.catch(function (err) {
return next(err);
});
}
function removeLocation(req, res, next) {
var locationId = parseInt(req.params.id);
db.result('delete from gcur_point_location where locationid=$1', locationId)
.then(function (result) {
/* jshint ignore:start */
res.status(200)
.json({
status: 'success',
message: `Removed ${result.rowCount} Location`
});
/* jshint ignore:end */
})
.catch(function (err) {
return next(err);
});
}
Likewise, munipulation of different tables will be defined in individual js files. All of them will require the db.js.
routes/index.js
var express = require('express');
var router = express.Router();
var db = require('../db/location');
/* GET home page. */
router.get('/', function(req, res, next) {
res.render('index', { title: 'Express' });
});
router.get('/api/locations', db.getAllLocations);
router.get('/api/location/:id', db.getLocation);
router.post('/api/location', db.createLocation);
router.put('/api/location/:id', db.updateLocation);
router.delete('/api/location/:id', db.removeLocation);
module.exports = router;
app.js
var createError = require('http-errors');
var express = require('express');
var path = require('path');
var cookieParser = require('cookie-parser');
var logger = require('morgan');
var indexRouter = require('./routes/index');
var usersRouter = require('./routes/users');
var app = express();
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
app.use(logger('dev'));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));
app.use('/', indexRouter);
app.use('/users', usersRouter);
// catch 404 and forward to error handler
app.use(function(req, res, next) {
next(createError(404));
});
// error handler
app.use(function(err, req, res, next) {
// set locals, only providing error in development
res.locals.message = err.message;
res.locals.error = req.app.get('env') === 'development' ? err : {};
// render the error page
res.status(err.status || 500);
res.render('error');
});
module.exports = app;
I would like to have some ideas about whether the above code is a good or a bad practise or any potential failure?

Most of the code makes sense to me, though I would implement your own ORM and model layers, so you can remove some of the code for PSQL queries and follow MVC design pattern. If all you are building is an express api server, then you do not need the View portion.
I usually have a file called ORM, which has something similar to the following:
var orm = {
all: function(tableInput, cb) {
var queryString = "SELECT * FROM " + tableInput + ";";
connection.query(queryString, function(err, result) {
if (err) {
throw err;
}
cb(result);
});
},
create: function(table, cols, vals, cb) {
var queryString = "INSERT INTO " + table;
queryString += " (";
queryString += cols.toString();
queryString += ") ";
queryString += "VALUES (";
queryString += printQuestionMarks(vals.length);
queryString += ") ";
console.log(queryString);
connection.query(queryString, vals, function(err, result) {
if (err) {
throw err;
}
cb(result);
});
},
// An example of objColVals would be {name: panther, sleepy: true}
update: function(table, objColVals, condition, cb) {
var queryString = "UPDATE " + table;
queryString += " SET ";
queryString += objToSql(objColVals);
queryString += " WHERE ";
queryString += condition;
console.log(queryString);
connection.query(queryString, function(err, result) {
if (err) {
throw err;
}
cb(result);
});
}
};
// Export the orm object for the model (cat.js).
module.exports = orm;
Then I define a model file for each table you have in psql as following:
// Import the ORM to create functions that will interact with the database.
var orm = require("../config/orm.js");
var cat = {
all: function(cb) {
orm.all("cats", function(res) {
cb(res);
});
},
// The variables cols and vals are arrays.
create: function(cols, vals, cb) {
orm.create("cats", cols, vals, function(res) {
cb(res);
});
},
update: function(objColVals, condition, cb) {
orm.update("cats", objColVals, condition, function(res) {
cb(res);
});
}
};
// Export the database functions for the controller (catsController.js).
module.exports = cat;
A controller:
var express = require("express");
var router = express.Router();
// Import the model (cat.js) to use its database functions.
var cat = require("../models/cat.js");
// Create all our routes and set up logic within those routes where required.
router.get("/", function(req, res) {
cat.all(function(data) {
var hbsObject = {
cats: data
};
console.log(hbsObject);
res.render("index", hbsObject);
});
});
router.post("/api/cats", function(req, res) {
cat.create(["name", "sleepy"], [req.body.name, req.body.sleepy], function(result) {
// Send back the ID of the new quote
res.json({ id: result.insertId });
});
});
router.put("/api/cats/:id", function(req, res) {
var condition = "id = " + req.params.id;
console.log("condition", condition);
cat.update(
{
sleepy: req.body.sleepy
},
condition,
function(result) {
if (result.changedRows === 0) {
// If no rows were changed, then the ID must not exist, so 404
return res.status(404).end();
}
res.status(200).end();
}
);
});
// Export routes for server.js to use.
module.exports = router;
This follows MVC design pattern which is very easy to read and understand. So my whole folder structure would look something like this:

Best practices for structuring a database layer with pg-promise are shown in pg-promise-demo.
For a complete, real-world example of using that approach, see LISK database layer.

how to use socket.io in controller file

I am using Node.JS Express and socket.io.
So my idea was to emit the message directly from my controller’s insert-method. In my server.js file, iam creating the socket.io object and try to make it accessible for other modules:
My server.js is like this
require('rootpath')();
var express = require('express');
var app = express();
var cors = require('cors');
var bodyParser = require('body-parser');
var expressJwt = require('express-jwt');
var config = require('config.json');
var mongoose = require('mongoose');
mongoose.connect(config.connectionString);
var db = mongoose.connection;
db.on('error',console.error.bind(console,'Connection error'));
db.on('open',function(){
console.log('connected');
});
app.use(cors());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
// use JWT auth to secure the api, the token can be passed in the authorization header or querystring
app.use(expressJwt({
secret: config.secret,
getToken: function (req) {
if (req.headers.authorization && req.headers.authorization.split(' ')[0] === 'Bearer') {
return req.headers.authorization.split(' ')[1];
} else if (req.query && req.query.token) {
return req.query.token;
}
return null;
}
}).unless({
path: [
'/users/authenticate',
'/users/register',
'/users',
'/chats','/chats/sendMessage',
'/rooms','/rooms/create',
'/chats/connection',
'/chats/add-message'
]
}));
// routes
app.use('/users', require('./controllers/users.controller'));
app.use('/chats', require('./controllers/chats.controller'));
app.use('/rooms', require('./controllers/rooms.controller'));
var http = require('http').Server(app);
var io = require('socket.io')(http);
io.on('connection', (socket) => {
console.log('The user is connected');
socket.on('new-message', (message,userInfo) => {
console.log(userInfo);
console.log(message);
io.emit('message', {type:'new-message', text: message});
});
socket.on('disconnect', function(){
console.log('The user is disconnected');
});
socket.on('add-message', (message,userInfo) => {
console.log(userInfo);
console.log(message);
io.emit('message', {type:'new-message', text: message});
});
socket.on('add-record', (record) => {
io.emit('getrecord', {type:'new-record', text: record});
});
});
// start server
var port = process.env.NODE_ENV === 'production' ? 80 : 4000;
var server = http.listen(port, function () {
console.log('Server listening on port ' + port);
});
Client - Data received
Emit welcome message on connection
how can i use this below socket connection in chat.controller.js
io.on('connection', (socket) => {
console.log('The user is connected');
socket.on('new-message', (message,userInfo) => {
console.log(userInfo);
console.log(message);
io.emit('message', {type:'new-message', text: message});
});
socket.on('disconnect', function(){
console.log('The user is disconnected');
});
socket.on('add-message', (message,userInfo) => {
console.log(userInfo);
console.log(message);
io.emit('message', {type:'new-message', text: message});
});
socket.on('add-record', (record) => {
io.emit('getrecord', {type:'new-record', text: record});
});
});
and i am creating controller file like this
chats.controller.js
var config = require('config.json');
var express = require('express');
var router = express.Router();
var userService = require('../services/user.service');
var chatService = require('../services/chat.service');
// routes
router.post('/sendMessage', send);
router.get('/', getAll);
module.exports = router;
function send(req, res) {
chatService.sendMessage(req.body)
.then(function () {
res.sendStatus(200);
})
.catch(function (err) {
res.status(400).send(err);
});
}
function getAll(req, res) {
chatService.getAllMessage()
.then(function (chats) {
res.send(chats);
})
.catch(function (err) {
res.status(400).send(err);
});
}
function getCurrent(req, res) {
userService.getById(req.user.sub)
.then(function (user) {
if (user) {
res.send(user);
} else {
res.sendStatus(404);
}
})
.catch(function (err) {
res.status(400).send(err);
});
}
function update(req, res) {
userService.update(req.params._id, req.body)
.then(function () {
res.sendStatus(200);
})
.catch(function (err) {
res.status(400).send(err);
});
}
function _delete(req, res) {
userService.delete(req.params._id)
.then(function () {
res.sendStatus(200);
})
.catch(function (err) {
res.status(400).send(err);
});
}
And also i have created one service file
name is chat.service.js
var config = require('config.json');
var _ = require('lodash');
var jwt = require('jsonwebtoken');
var bcrypt = require('bcryptjs');
var Q = require('q');
var mongoose = require('mongoose');
var Chat = require('../model/chat');
var service = {};
service.sendMessage = sendMessage;
service.getAllMessage = getAllMessage;
module.exports = service;
function sendMessage(userParam) {
var deferred = Q.defer();
var chat = new Chat({
room_id:userParam.from_id,
from_id:userParam.from_id,
to_id:userParam.to_id,
chatrp_id:userParam.chatrp_id,
message:userParam.message
});
chat.save(function (err,doc) {
if (err) deferred.reject(err.name + ': ' + err.message);
deferred.resolve();
})
return deferred.promise;
}
function getAllMessage() {
var deferred = Q.defer();
Chat.find({},function (err, response) {
if (err) deferred.reject(err.name + ': ' + err.message);
// return users (without hashed passwords)
response = _.map(response, function (res) {
return _.omit(res, 'hash');
});
deferred.resolve(response);
});
return deferred.promise;
}
But is is neither giving me an error or not working.
Can anyone please help, how can I export that in a separate file so that client and server code can be separated?
Thanks in advance for helping.

This how I got this to work.
Steps are as follows:
1) I created a utils folder, inside which I created a file named socket.js
utils/socket.js
const Server = require('socket.io');
const io = new Server();
var Socket = {
emit: function (event, data) {
console.log(event, data);
io.sockets.emit(event, data);
}
};
io.on("connection", function (socket) {
console.log("A user connected");
});
exports.Socket = Socket;
exports.io = io;
2) Then in my server(app.js) I did this
app.js
const app = express();
const server = http.createServer(app);
const { io } = require("./utils/socket");
io.attach(server);
module.exports = app;
3)After this 2 steps, In your controller file or any other file(s) where you need to emit an event, you can then just do this:
const { Socket } = require("../../utils/socket");
Socket.emit("newMessage", {
message: "hello from controller"
});

To emit messages from your controllers, the controllers need to have access to the original socket.io instance.
So, in chats.controller.js I would do like this:
module.exports = function(io){
return {
function: getAll(req, res){
// here you now have access to socket.io.
// you can either do:
io.emit('new-message',{
// new message object
});
// or you can include your chat service the same way
// that this file is included and call the appropriate function
},
}
};
To use this controller, just do
const someController = require('./path/to/chats.controller.js')(io);
You can do exactly the same in your service file.

I created REST API for SQL SERVER to get the all the record using node.js

Below is code of Node.js for getting the data from SQL server but it give an error
"Global connection already exists. Call sql.close() first."
var express = require('express');
var app = express();
app.get('/', function (req, res) {
var sql = require("mssql");
var config = {
user: 'sa',
password: '',
server: '',
database: 'Test'
};
sql.connect(config, function (err) {
if (err) console.log(err);
var request = new sql.Request();
request.query('select * from TestTable', function (err, recordset) {
if (err) console.log(err)
res.send(recordset);
});
});
});
var server = app.listen(5000, function () {
console.log('Server is running..');
});

You should add sql.close() to your code after sql.connect() and it should work.