Advisory boards aren’t only for executives.

Join the
LogRocket Content Advisory Board today →

Jan 26, 2024 ⋅ 15 min read

CRUD REST API

with Node.js,
Express, and
PostgreSQL
Tania Rascia
Software developer, writer,
maker of things. Find me online
at tania.dev.

Table of contents 

What is a RESTful API?

What is a CRUD API?

What is Express?

What is PostgreSQL?

What is node-postgres?

Creating a PostgreSQL
database

PostgreSQL command prompt

Creating a role in Postgres

Creating a database in Postgres

Creating a table in Postgres

Setting up an Express server

Connecting to a Postgres
database using a Client

Editor’s note: This post was last updated by

Emmanuel John on 26 January 2024 to discuss
securing the API and provide solutions to two
common issues developers may encounter while
developing APIs. A section was also added to cover
potential next steps for developers. This article was
previously updated on 6 June 2022 to reflect updates
to the pgAdmin client.

Working with APIs to facilitate

communication between software systems is
crucial for modern web developers. In this
tutorial, we’ll create a CRUD RESTful API in a
Node.js environment that runs on an Express
server and uses a PostgreSQL database.

We’ll also walk through connecting an Express

server with PostgreSQL using node-postgres.
Our API will be able to handle the HTTP
request methods that correspond to the
PostgreSQL database from which the API gets
its data. You’ll also learn how to install
PostgreSQL and work with it through the CLI.

Our goal is to allow CRUD operations —

GET , POST , PUT , and DELETE — on the
API, which will run the corresponding
database commands. To do so, we’ll set up a
route for each endpoint and a function for
each query.

To follow along with this tutorial, you‘ll need:

Familiarity with the JavaScript syntax

and fundamentals
Basic knowledge of working with the
command line
Node.js and npm installed

The complete code for the tutorial is available

in this GitHub repo. Let’s get started!

What is a RESTful API?

Representational State Transfer (REST)

defines a set of standards for web services.

An API is an interface that software programs

use to communicate with each other.
Therefore, a RESTful API is an API that
conforms to the REST architectural style and
constraints.

REST systems are stateless, scalable, cacheable,

and have a uniform interface.

What is a CRUD API?

When building an API, you want your model

to provide four basic functionalities. It should
be able to create, read, update, and delete
resources. This set of essential operations is
commonly referred to as CRUD.

RESTful APIs most commonly utilize HTTP

requests. Four of the most common HTTP
methods in a REST environment are GET ,
POST , PUT , and DELETE , which are the
methods by which a developer can create a
CRUD system:

Create : Use the HTTP POST method

to create a resource in a REST
environment
Read : Use the GET method to read a
resource, retrieving data without
altering it
Update : Use the PUT method to
update a resource
Delete : Use the DELETE method to
remove a resource from the system

What is Express?

According to the o!cial Express

documentation, Express is a fast,
unopinionated, minimalist web framework for
Node.js. Express is one of the most popular
frameworks for Node.js. In fact, each E in the
MERN, MEVN, and MEAN stacks stands for
Express.

Although Express is minimalist, it’s also very

flexible. This supports the development of
various Express middlewares that you can use
to address almost any task or problem
imaginable.

What is PostgreSQL?

PostgreSQL, commonly referred to as

Postgres, is a free and open source relational
database management system. You might be
familiar with a few other similar database
systems, like MySQL, Microsoft SQL Server,
or MariaDB, which compete with
PostgreSQL.

PostgreSQL is a robust relational database that

has been around since 1997. It’s available on all
major operating systems — Linux, Windows,
and macOS. Since PostgreSQL is known for
stability, extensibility, and standards
compliance, it’s a popular choice for
developers and companies.

It’s also possible to create a Node.js RESTful

CRUD API using Sequelize. Sequelize is a
promise-based Node.js ORM for Postgres,
MySQL, MariaDB, SQLite, and Microsoft
SQL Server.

For more on how to use Sequelize in a Node.js

REST API, check out the video tutorial below:

Building an API in Node.js wi…

What is node-postgres?

node-postgres, or pg, is a nonblocking

PostgreSQL client for Node.js. Essentially,
node-postgres is a collection of Node.js
modules for interfacing with a PostgreSQL
database.

node-postgres supports many features,

including callbacks, promises, async/await,
connection pooling, prepared statements,
cursors, rich type parsing, and C/C++
bindings.

Creating a PostgreSQL
database

We’ll begin this tutorial by installing

PostgreSQL, creating a new user, creating a
database, and initializing a table with a schema
and some data.

Over 200k developers use LogRocket to

create better digital experiences

Learn more →

Installation

If you’re using Windows, download a

Windows installer of PostgreSQL.

If you’re using a Mac, this tutorial assumes you

have Homebrew installed on your computer as
a package manager for installing new
programs. If you don’t, simply click on the link
and follow the instructions.

Open up the terminal and install

postgresql with brew :

brew install postgresql

You may see instructions on the web reading

brew install postgres instead of
PostgreSQL . Both options will install
PostgreSQL on your computer.

After the installation is complete, we’ll want to

get postgresql up and running, which we
can do with services start :

brew services start postgresql

==> Successfully started `postgresql` (label: homebrew.mxcl

If at any point you want to stop the

postgresql service, you can run brew

services stop postgresql .

With PostgreSQL installed, let’s next connect

to the postgres command line where we
can run SQL commands.

PostgreSQL command
prompt

psql is the PostgreSQL interactive terminal.

Running psql will connect you to a
PostgreSQL host. Running psql --help

will give you more information about the

available options for connecting with psql :

-h or --host=HOSTNAME : The
database server host or socket directory;
the default is local socket

-p or --port=PORT : The database

server port; the default is 5432

-U or --username=USERNAME : The
database username; the default is
your_username

-w or --no-password : Never prompt

for password
-W or --password : Force password
prompt, which should happen
automatically

We’ll connect to the default postgres

database with the default login information

and no option flags:

psql postgres

You’ll see that we’ve entered into a new

connection. We’re now inside psql in the
postgres database. The prompt ends with a
# to denote that we’re logged in as the
superuser, or root:

postgres=#

Commands within psql start with a

backslash \ . To test our first command, we
can check what database, user, and port we’ve
connected to using the \conninfo

command:

postgres=# \conninfo
You are connected to database "postgres" as user "your_user

The reference table below includes a few

common commands that we’ll use throughout
this tutorial:

\q : Exit psql connection

\c : Connect to a new database
\dt : List all tables
\du : List all roles
\list : List databases

Let’s create a new database and user so we’re

not using the default accounts, which have
superuser privileges.

Creating a role in
Postgres

First, we’ll create a role called me and give it a

password of password . A role can function
as a user or a group. In this case, we’ll use it as
a user:

postgres=# CREATE ROLE me WITH LOGIN PASSWORD 'password';

We want me to be able to create a database:

postgres=# ALTER ROLE me CREATEDB;

You can run \du to list all roles and users:

me | Create DB | {}
postgres | Superuser, Create role, Create DB | {}

Now, we want to create a database from the

me user. Exit from the default session with
\q for quit:

postgres=# \q

We’re back in our computer’s default terminal

connection. Now, we’ll connect postgres

with me :

psql -d postgres -U me

Instead of postgres=# , our prompt now

shows postgres=> , meaning we’re no
longer logged in as a superuser.

Creating a database in
Postgres

We can create a database with the SQL

command as follows:

postgres=> CREATE DATABASE api;

Use the \list command to see the available

databases:

Name | Owner | Encoding | Collate | Ctype

api | me | UTF8 | en_US.UTF-8 | en_US.UTF-

Let’s connect to the new api database with

me using the \c connect command:

postgres=> \c api
You are now connected to database "api" as user "me".
api=>

Our prompt now shows that we’re connected

to api .

Creating a table in
Postgres

Finally, in the psql command prompt, we’ll

create a table called users with three fields,
two VARCHAR types, and an auto-
incrementing PRIMARY KEY ID:

api=>
CREATE TABLE users (
ID SERIAL PRIMARY KEY,
name VARCHAR(30),
email VARCHAR(30)
);

Make sure not to use the backtick ` character

when creating and working with tables in
PostgreSQL. While backticks are allowed in
MySQL, they’re not valid in PostgreSQL. Also,
ensure that you do not have a trailing comma
in the CREATE TABLE command.

More great articles from

LogRocket:

Don't miss a moment with The Replay,

a curated newsletter from LogRocket
Learn how LogRocket's Galileo cuts
through the noise to proactively resolve
issues in your app
Use React's useE"ect to optimize your
application's performance
Switch between multiple versions of
Node
Discover how to use the React children
prop with TypeScript
Explore creating a custom mouse cursor
with CSS
Advisory boards aren’t just for
executives. Join LogRocket’s Content
Advisory Board. You’ll help inform the
type of content we create and get access
to exclusive meetups, social
 accreditation, and swag.

Let’s add some data to work with by adding

two entries to users :

INSERT INTO users (name, email)

VALUES ('Jerry', '[email protected]'), ('George', 'george

Let’s make sure that the information above

was correctly added by getting all entries in
users :

api=> SELECT * FROM users;

id | name | email
----+--------+--------------------
1 | Jerry | [email protected]
2 | George | [email protected]

Now, we have a user, database, table, and some

data. We can begin building our Node.js
RESTful API to connect to this data, stored in
a PostgreSQL database.

At this point, we’re finished with all of our

PostgreSQL tasks, and we can begin setting up
our Node.js app and Express server.

Setting up an Express
server

To set up a Node.js app and Express server,

first create a directory for the project to live in:

mkdir node-api-postgres
cd node-api-postgres

You can either run npm init -y to create a

package.json file, or copy the code below
into a package.json file:

{
"name": "node-api-postgres",
"version": "1.0.0",
"description": "RESTful API with Node.js, Express, and Po
"main": "index.js",
"license": "MIT"
}

We’ll want to install Express for the server and

node-postgres to connect to PostgreSQL:

npm i express pg

Now, we have our dependencies loaded into

node_modules and package.json .

Create an index.js file, which we’ll use as

the entry point for our server. At the top, we’ll
require the express module, the built-in
body-parser middleware, and we’ll set our
app and port variables:

const express = require('express')

const bodyParser = require('body-parser')
const app = express()
const port = 3000

app.use(bodyParser.json())
app.use(
bodyParser.urlencoded({
extended: true,
})
)

We’ll tell a route to look for a GET request on

the root / URL and return some JSON:

app.get('/', (request, response) => {

response.json({ info: 'Node.js, Express, and Postgres API
})

Now, set the app to listen on the port you set:

app.listen(port, () => {
console.log(`App running on port ${port}.`)
})

From the command line, we can start the

server by hitting index.js :

node index.js
App running on port 3000.

Go to http://localhost:3000 in the URL

bar of your browser, and you’ll see the JSON
we set earlier:

{
info: "Node.js, Express, and Postgres API"
}

The Express server is running now, but it’s

only sending some static JSON data that we
created. The next step is to connect to
PostgreSQL from Node.js to be able to make
dynamic queries.

Connecting to a
Postgres database using
a Client

A popular client for accessing Postgres

databases is the pgAdmin client. The pgAdmin
application is available for various platforms.
If you want to have a graphical user interface
for your Postgres databases, you can go to the
download page and download the necessary
package.

Creating and querying your database using

pgAdmin is simple. You need to click on the
Object option available on the top menu,
select Create, and choose Database to create a
new connection. All the databases are available
on the side menu. You can query or run SQL
queries e!ciently by selecting the proper
database:

Connecting to a
Postgres database from
Node.js

We’ll use the node-postgres module to create a

pool of connections. Therefore, we don’t have
to open and close a client each time we make a
query.

A popular option for production pooling

would be to use [pgBouncer]

(https://pgbouncer.github.io/) ,a
lightweight connection pooler for
PostgreSQL.

const Pool = require('pg').Pool

const pool = new Pool({
user: 'me',
host: 'localhost',
database: 'api',
password: 'password',
port: 5432,
})

In a production environment, you would want

to put your configuration details in a separate
file with restrictive permissions so that it is
not accessible from version control. But, for
the simplicity of this tutorial, we’ll keep it in
the same file as the queries.

The aim of this tutorial is to allow CRUD

operations — GET , POST , PUT , and
DELETE — on the API, which will run the
corresponding database commands. To do so,
we’ll set up a route for each endpoint and a
function corresponding to each query.

Creating routes for

CRUD operations

We’ll create six functions for six routes, as

shown below. First, create all the functions for
each route. Then, export the functions so
they’re accessible:

GET : / | displayHome()

GET : /users | getUsers()

GET : /users/:id | getUserById()

POST : /users | createUser()

PUT : /users/:id | updateUser()

DELETE : /users/:id |
deleteUser()

In index.js , we made an app.get() for

the root endpoint with a function in it. Now,
in queries.js , we’ll create endpoints that
will display all users, display a single user,
create a new user, update an existing user, and
delete a user.

GET all users

Our first endpoint will be a GET request. We

can put the raw SQL that will touch the api

database inside the pool.query() . We’ll

SELECT all users and order by ID.

const getUsers = (request, response)

pool.query('SELECT * FROM users ORDER BY id ASC'
if (error) {
throw error
}
response.status(200).json(results
})
}

GET a single user by ID

For our /users/:id request, we’ll get the

custom id parameter by the URL and use a
WHERE clause to display the result.

In the SQL query, we’re looking for id=$1 .

In this instance, $1 is a numbered
placeholder that PostgreSQL uses natively
instead of the ? placeholder that you may
recognize from other variations of SQL:

const getUserById = (request, response

const id = parseInt(request.params

pool.query('SELECT * FROM users WHERE id = $1'

if (error) {
throw error
}
response.status(200).json(results
})
}

POST a new user

The API will take a GET and POST request

to the /users endpoint. In the POST

request, we’ll add a new user. In this function,

we’re extracting the name and email

properties from the request body and inserting

the values with INSERT :

const createUser = (request, response

const { name, email } = request.body

pool.query('INSERT INTO users (name, email) VALUES ($1, $

if (error) {
throw error
}
response.status(201).send(`User added
})
}

PUT updated data in an

existing user

The /users/:id endpoint will also take two

HTTP requests, the GET we created for
getUserById and a PUT to modify an
existing user. For this query, we’ll combine
what we learned in GET and POST to use the
UPDATE clause.

It’s worth noting that PUT is idempotent,

meaning the exact same call can be made over
and over and will produce the same result.
PUT is di"erent than POST , in which the
exact same call repeated will continuously
make new users with the same data:

const updateUser = (request, response

const id = parseInt(request.params
const { name, email } = request.body

pool.query(
'UPDATE users SET name = $1, email = $2 WHERE id = $3'
[name, email, id],
(error, results) => {
if (error) {
throw error
}
response.status(200).send(`User
}
)
}

DELETE a user

Finally, we’ll use the DELETE clause on

/users/:id to delete a specific user by ID.
This call is very similar to our
getUserById() function:

const deleteUser = (request, response

const id = parseInt(request.params

pool.query('DELETE FROM users WHERE id = $1'

if (error) {
throw error
}
response.status(200).send(`User deleted
})
}

Exporting CRUD
functions in a REST API

To access these functions from index.js ,

we’ll need to export them. We can do so with
module.exports , creating an object of
functions. Since we’re using the ES6 syntax,
we can write getUsers instead of
getUsers:getUsers and so on:

module.exports = {
getUsers,
getUserById,
createUser,
updateUser,
deleteUser,
}

Our complete queries.js file is below:

const Pool = require('pg').Pool

const pool = new Pool({
user: 'me',
host: 'localhost',
database: 'api',
password: 'password',
port: 5432,
})
const getUsers = (request, response)
pool.query('SELECT * FROM users ORDER BY id ASC'
if (error) {
throw error
}
response.status(200).json(results
})
}

const getUserById = (request, response

const id = parseInt(request.params

pool.query('SELECT * FROM users WHERE id = $1'

if (error) {
throw error
}
response.status(200).json(results
})
}

const createUser = (request, response

const { name, email } = request.body

pool.query('INSERT INTO users (name, email) VALUES ($1, $

if (error) {
throw error
}
response.status(201).send(`User added
})
}

const updateUser = (request, response

const id = parseInt(request.params
const { name, email } = request.body

pool.query(
'UPDATE users SET name = $1, email = $2 WHERE id = $3'
[name, email, id],
(error, results) => {
if (error) {
throw error
}
response.status(200).send(`User
}
)
}

const deleteUser = (request, response

const id = parseInt(request.params

pool.query('DELETE FROM users WHERE id = $1'

if (error) {
throw error
}
response.status(200).send(`User deleted
})
}

module.exports = {
getUsers,
getUserById,
createUser,
updateUser,
deleteUser,
}

Setting up CRUD
functions in a REST API

Now that we have all of our queries, we need

to pull them into the index.js file and make
endpoint routes for all the query functions we
created.

To get all the exported functions from

queries.js , we’ll require the file and
assign it to a variable:

const db = require('./queries')

Now, for each endpoint, we’ll set the HTTP

request method, the endpoint URL path, and
the relevant function:

app.get('/users', db.getUsers)
app.get('/users/:id', db.getUserById)
app.post('/users', db.createUser)
app.put('/users/:id', db.updateUser)
app.delete('/users/:id', db.deleteUser)

Below is our complete index.js file, the

entry point of the API server:

const express = require('express')

const bodyParser = require('body-parser'
const app = express()
const db = require('./queries')
const port = 3000

app.use(bodyParser.json())
app.use(
bodyParser.urlencoded({
extended: true,
})
)

app.get('/', (request, response) =>

response.json({ info: 'Node.js, Express, and Postgres API
})

app.get('/users', db.getUsers)
app.get('/users/:id', db.getUserById
app.post('/users', db.createUser)
app.put('/users/:id', db.updateUser)
app.delete('/users/:id', db.deleteUser

app.listen(port, () => {
console.log(`App running on port $
})

With just these two files, we have a server,

database, and our API all set up. You can start
 up the server by hitting index.js again:

node index.js
App running on port 3000.

Now, if you go to
http://localhost:3000/users or
http://localhost:3000/users/1 , you’ll
see the JSON response of the two GET

requests.

To test our POST , PUT , and DELETE

requests, we can use a tool like Postman or a

VS Code extension like Thunder Client to
send the HTTP requests. You can also use curl,
a command-line tool that is already available
on your terminal.

Using a tool like Postman or Thunder Client

makes it simple to query endpoints with
di"erent HTTP methods. Simply enter your
URL, choose the specific HTTP method, insert
the JSON value if the endpoint is a PUT or
POST route, and hit Send:

The example above shows sending a POST

request to the specified route. The POST

option suggests that it is a POST request. The

URL beside the method is the API endpoint,
and the JSON content is the data to be sent to
the endpoint. You can hit the di"erent routes
similarly.

Here’s an example of sending a POST request

to the specified route to create a new user
using Postman:

Here’s an example of sending a PUT request

to the specified route to modify a user by its
ID:

Here’s an example of sending a GET request

to the specified route to retrieve a user by its
ID:

Here’s an example of sending a GET request

to the specified route to retrieve all users:

Finally, here’s an example of sending a

DELETE request to the specified route to
delete a user by its ID:

Solutions to common
issues encountered
while developing APIs

Developing APIs can come with various

challenges. Let’s go over the solutions to two
common issues encountered during API
development: CORS issues and unhandled
errors due to middleware order.

Handling CORS issues

Browser security policies can block requests

from di"erent origins. To address this issue,
use the cors middleware in Express to
handle cross-origin resource sharing (CORS).

Run the following command to install cors :

npm install cors

To use it, do the following:

var express = require('express')

var cors = require('cors')
var app = express()

app.use(cors())

This will enable CORS for all origins.

Middleware order and error

handling

Middleware order can a"ect error handling,

leading to unhandled errors. To address this
issue, place error-handling middleware at the
end of your middleware stack and use
next(err) to pass errors to the error-
handling middleware:

app.use((req, res, next) => {

const error = new Error('Something went wrong'
next(error);
});
// Error-handling Middleware
app.use((err, req, res, next) => {
console.error('Error:', err.message
res.status(500).send('Internal Server Error'
});

Securing the API

When it comes to securing APIs, we need to

implement various mechanisms to ensure the
confidentiality, and integrity of the application
and its data. Let’s go over a few of these
mechanisms now.

Authentication

You can implement strong authentication

mechanisms, such as JSON Web Tokens
(JWT) or OAuth, to verify the identity of
clients. Ensure that only authenticated and
authorized users can access certain routes —
in our case, the POST , PUT , and DELETE

methods.

I will recommend the Passport middleware for

Node.js, which makes it easy to implement
authentication and authorization. Here’s an
example of how to use Passport:

const passport = require('passport');

const LocalStrategy = require('passport-local').Strategy;

passport.use(new LocalStrategy(
function(username, password, done) {
// Verify username and password
// Call done(null, user) if authentication is succe
}
));

Authorization

It’s important to enforce proper access

controls to restrict access to specific routes or
resources based on the user’s role or
permissions. For example, you can check if the
user making a request has admin privileges
before allowing or denying them permission
to proceed with the request:

function isAdmin(req, res, next) {

if (req.user && req.user.role ===
return next();
} else {
return res.status(403).json({
}
}

You can apply the isAdmin middleware

defined above to any protected routes, thus
restricting access to those routes.

Input validation

Validate and sanitize user inputs to prevent

SQL injection, XSS, and other security
vulnerabilities. For example:

const { body, validationResult } = require

app.post('/users', [
// add validation rules
], (req, res) => {
const errors = validationResult(
if (!errors.isEmpty()) {
return res.status(422).json({
}
// Process the request
});

The code above allows you to specify

validation rules for POST requests to the
/users endpoint. If the validation fails, it
sends a response with the validation errors. If
the incoming data is correct and safe, it
proceeds with processing the request.

Helmet middleware

You can use the Helmet middleware to set

various HTTP headers for enhanced security:

const helmet = require('helmet');

app.use(helmet());

Configuring HTTP headers with Helmet helps

protect your app from security issues like XSS
attacks, CSP vulnerabilities, and more.

Additional notes and

suggestions

You can build on this tutorial by implementing

the following suggestions:

Integration with frontend

frameworks: Choose a frontend
framework or library (e.g., React,
Angular, Vue.js) to build a user interface
for your application. Then, implement
API calls from the frontend to interact
with the backend CRUD operations.
You can consider state management
solutions (e.g., Redux, Vuex) for
managing the state of your frontend
application

Containerizing the API: Write a

Dockerfile to define the environment
and dependencies needed to run your
Node.js app. Create a docker-

compose.yml file for managing

multiple containers, such as the Node.js
app and PostgreSQL database. This will
make your Node.js application easier to
deploy and set up on other machines

Implementing unit/integration tests:

Write unit tests for individual functions
and components of your application to
ensure that they work as expected. Use
testing frameworks like Mocha, Jest, or
Jasmine for writing and running tests.
Implement integration tests to verify the
interactions between di"erent
components in your front-end
application and the overall functionality
of your API

Continuous integration/deployment
(CI/CD): Set up CI/CD pipelines to
automate the testing and deployment
processes. Use tools like Jenkins, Travis
CI, or GitHub Actions to streamline the
development/deployment workflow

While actually implementing these next steps

is beyond the scope of this tutorial, you can
use these ideas to apply what we’ve discussed
to a real use case.

Conclusion

You should now have a functioning API server

that runs on Node.js and is hooked up to an
active PostgreSQL database.

In this tutorial, we learned how to install and

set up PostgreSQL in the command line, create
users, databases, and tables, and run SQL
commands. We also learned how to create an
Express server that can handle multiple HTTP
methods and use the pg module to connect
to PostgreSQL from Node.js.

With this knowledge, you should be able to

build on this API and utilize it for your own
personal or professional development projects.

Share this:

#node #postgresql

Stop guessing about

your digital
experience with
LogRocket

Get started for

free

Recent posts:

How to use CSS variables like a pro

By building these four simple projects, you’ll learn
how CSS variables can help you write reusable,
elegant code and streamline the way you build
websites.

Idorenyin Obong
Feb 15, 2024 ⋅ 15 min read

How to build a component library with

React and TypeScript
In this article, we’ll learn what a component library is
and how to build our component library with React
and TypeScript.

Yan Sun
Feb 15, 2024 ⋅ 13 min read

Chakra UI adoption guide: Overview,

examples, and alternatives
Chakra UI has emerged as a highly relevant design
library. Let’s discuss what makes Chakra UI a great
choice for modern applications.

Isaac Okoro
Feb 13, 2024 ⋅ 8 min read

Leader Spotlight: Finding people

solutions with Brant Snow
Brant Snow is the Vice President of Technology at
Extensiv, an omnichannel software solutions provider
for warehouse, inventory, and order […]

Jessica Srinivas
Feb 12, 2024 ⋅ 7 min read

View all posts

UD REST API with Node.js, Express, and PostgreSQL"

: Reply
t 10:08 pm

Reader says: Reply

20 at 12:28 pm
ul article! Thank you for this!

Reply
t 6:49 am
t i’ve been looking for. great start that can be easily expanded by
.

t says: Reply
t 4:19 pm

h localhost -U me
se I got
not connect to server: FATAL: Peer authentication failed for

t says: Reply
t 4:41 pm
ctly what I was looking for. Note there is an error in the POST
ults’ should be ‘result’.

t says: Reply
t 4:50 pm
true.

t says: Reply
t 4:51 pm
Thanks for the help!

mon says: Reply

0 at 11:02 pm
ch. this is all what i want

says: Reply
at 11:51 am
rything works except why would there be a json response on
ers ? I don’t see anything there. Am I supposed have a

alvo says: Reply

at 10:39 pm

h for your very clear and concise example. I followed it closely.

problem I ran into, which is when creating a user, I could not
ted ID.
nd for PosrgreSQL, there is a di"erent way in which the id is
insert, as follows:
= (request, response) => {
email } = request.body;

sers (username, email) VALUES ($1,$2) RETURNING id”,

],
>{

01).send(`User added with ID:${results.rows[0].id} `);

ing the SQL statement correctly, with the “RETURNING id” bit

ll help others if they find the same problem.

909 says: Reply

11:27 pm
ou so much, was on the verge of tearing my hair out here…

says: Reply
at 4:54 pm
while to figure it out. thanks

Reply
1 at 10:59 am
ught it was the apostrophe formatting, I actually had the
part but couldnt get the results.rows piece – thank you!

Reply
5:42 pm
anks for the work, it is very easy to follow and works like a

Reply
4:58 pm
ng this error when I run node index.js at the end: error:
ication failed for user “testuser”
his?

bis says: Reply

t 5:58 am

Amrut Kamble says: Reply

10:29 pm
h

Reply
1:25 pm
files completely and when I try and localhost:3000/users it just
y way to trace the error?

ays: Reply
21 at 4:20 pm
ERT entries via $request.body, I had to use $request.query and
dy else had this issue
0].id thing isn’t working for me either

ays: Reply
t 12:11 am
ad the issue with $request.body as well and changing it to
fixed it.
results.rows[0] thing though, that one works on my machine.

: Reply
21 at 8:55 am
between the headlines “Installation” and “PostgreSQL command
sleading. I’m using Windows and it is unlear to me which of
e releveant to my OS and whether I have to run any brew-based
similar ones in npm after downloading the Windows installer
bviously, though not mentioned) and passin on to the
mand prompt section. Clarifications would be appreciated.

Reply
t 6:14 am
you so much

Reply
:03 pm
ex.js”? How do I run this?

ar Rathod says: Reply

:40 am

rner says: Reply

2:06 pm
y accomplished React & C# & Python software engineer but am
wn project now. I was all set to have a Python back-end, like is
hen learned about Express.js. Thank you SO MUCH for your
mprehensive article. It served as the template for building the
ver evolving application.
uilt both front-end and back-end with TypeScript so upgraded
ode to TypeScript. Feel free to contact me and I will gladly share
in case you want to update this article or follow-up with

ys: Reply
2 at 9:47 am
share your TypeScripit prject.

Reply
6 am
ve a problem with createUser, change code into:
01).send(`User added with ID: ${results.rows[0][“id”]}`)

Reply
at 9:35 am
e record in users table but both name and email has null values.
undefined. Any help appreciated.

says: Reply
3 at 2:23 pm
ut this could work for others.
dyParser should solve this problem
arser.json())

encoded({

s: Reply
t 4:18 pm
mebrew required a version for postgresql.

resql
g https://formulae.brew.sh/api/formula.jws.json
##########################################################

g https://formulae.brew.sh/api/cask.jws.json
##########################################################

ilable formula with the name “postgresql”. Did you mean

ostgresql@12, postgresql@11, postgresql@15, postgresql@10,
[email protected], [email protected], postgrest or qt-postgresql?
existing databases on upgrade without human intervention.
c version to install with:
rep postgresql@

me:

resql@15

« Previous 1 2 Next »