Angular and PostgreSQL: Build a Full-Stack App
This guide explains how to structure an Angular and PostgreSQL application with a real backend boundary, database migrations, authentication, validation, and release-ready architecture.
Quick Answer
A practical Angular and PostgreSQL app has three clear layers: an Angular frontend, a backend API, and PostgreSQL as the system of record. Angular should handle routing, forms, validation, UI state, and API calls. The backend should own authentication, authorization, input validation, SQL access, background jobs, and secret management.
Use the official Angular documentation for framework structure and the node-postgres documentation when the backend is Node.js. Keep database credentials on the server, use migrations for schema changes, and avoid sending SQL directly from the browser.
Dopebase focuses on reusable app foundations across web and mobile. If this stack is part of a larger product, connect it with custom app development so the mobile app, dashboard, backend, and database contracts are designed together.
Production Checklist
- Define the database schema before building screens.
- Put all PostgreSQL access behind backend services.
- Validate inputs on both frontend and backend.
- Use role-based authorization for private records.
- Add seed data and integration tests for important flows.
- Configure backups, migrations, logging, and environment variables before launch.
Introduction
Angular is a popular JavaScript framework for building web applications, while PostgreSQL is a powerful open-source relational database management system. By combining these two technologies, we can create a robust and scalable full-stack application. In this tutorial, we will cover the entire development process, from setting up the environment to deploying and testing the app.
What is Angular?
Angular is a JavaScript framework developed by Google for building web applications. It follows the Model-View-Controller (MVC) architectural pattern and provides a range of features for building dynamic and responsive user interfaces. With Angular, you can easily manage data binding, handle user input, and implement complex UI components.
What is PostgreSQL?
PostgreSQL is an open-source object-relational database management system. It provides advanced features such as support for JSON, full-text search, and spatial data. PostgreSQL is known for its stability, scalability, and extensibility, making it a popular choice for building data-driven applications.
Why use Angular and PostgreSQL together?
By combining Angular and PostgreSQL, we can create a full-stack application with a seamless integration between the frontend and the backend. Angular provides a powerful framework for building the user interface and handling user interactions, while PostgreSQL offers a robust and scalable database solution. Together, they enable us to build a complete and efficient application.
Setting up the Development Environment
Before we start building our full-stack app, we need to set up the development environment. This involves installing Angular CLI and PostgreSQL, as well as creating a new Angular project and setting up a PostgreSQL database.
Installing Angular CLI
Angular CLI is a command-line interface that allows us to scaffold, develop, and deploy Angular applications. To install Angular CLI, open your terminal and run the following command:
npm install -g @angular/cli
This will install Angular CLI globally on your machine. You can verify the installation by running the following command:
ng version
This should display the version of Angular CLI installed on your machine.
Installing PostgreSQL
To install PostgreSQL, visit the official PostgreSQL website and download the appropriate version for your operating system. Follow the installation instructions provided by the installer.
Creating a new Angular project
To create a new Angular project, open your terminal and navigate to the directory where you want to create the project. Then, run the following command:
ng new my-app
This will create a new directory called my-app with a basic Angular project structure. Navigate to the project directory by running the following command:
cd my-app
Setting up a PostgreSQL database
To set up a PostgreSQL database, open your terminal and run the following command to start the PostgreSQL command-line interface:
psql -U your_username
Replace your_username with your actual PostgreSQL username. If you're using the default installation, you can use postgres as the username. Once you're in the PostgreSQL command-line interface, run the following command to create a new database:
CREATE DATABASE my_database;
Replace my_database with the name you want to give to your database. You can now exit the PostgreSQL command-line interface by running the following command:
\q
Building the Backend
In this section, we will build the backend of our full-stack app using Node.js and PostgreSQL. We will create a Node.js server, establish a connection to PostgreSQL, define API endpoints, and implement CRUD (Create, Read, Update, Delete) operations.
Creating a Node.js server
To create a Node.js server, navigate to the root directory of your Angular project and run the following command to install the necessary dependencies:
npm install express pg
Once the dependencies are installed, create a new file called server.js in the root directory of your project. Open the file and add the following code:
const express = require('express');
const app = express();
const port = process.env.PORT || 3000;
app.listen(port, () => {
console.log(`Server is running on port ${port}`);
});
This code creates a simple Express server that listens on port 3000. You can change the port number if needed. To start the server, run the following command:
node server.js
You should see the message "Server is running on port 3000" in the terminal.
Establishing a connection to PostgreSQL
To establish a connection to PostgreSQL, we will use the pg module. In the server.js file, add the following code below the server initialization code:
const { Pool } = require('pg');
const pool = new Pool({
user: 'your_username',
host: 'localhost',
database: 'my_database',
password: 'your_password',
port: 5432,
});
pool.connect((err) => {
if (err) {
console.error('Error connecting to PostgreSQL:', err);
} else {
console.log('Connected to PostgreSQL');
}
});
Replace your_username, your_password, and my_database with your actual PostgreSQL credentials and database name. This code creates a connection pool to manage database connections and connects to the PostgreSQL server.
Defining API endpoints
Now that we have established a connection to PostgreSQL, let's define some API endpoints for our app. In the server.js file, add the following code below the connection initialization code:
app.get('/api/items', (req, res) => {
pool.query('SELECT * FROM items', (err, result) => {
if (err) {
console.error('Error executing query:', err);
res.status(500).json({ error: 'Internal Server Error' });
} else {
res.json(result.rows);
}
});
});
app.post('/api/items', (req, res) => {
const { name, description } = req.body;
pool.query(
'INSERT INTO items (name, description) VALUES ($1, $2) RETURNING *',
[name, description],
(err, result) => {
if (err) {
console.error('Error executing query:', err);
res.status(500).json({ error: 'Internal Server Error' });
} else {
res.json(result.rows[0]);
}
}
);
});
These code snippets define two API endpoints: /api/items for retrieving all items from the database and /api/items for creating a new item. The pool.query function is used to execute SQL queries and handle the results.
Implementing CRUD operations
To implement CRUD operations, we need to define additional API endpoints for updating and deleting items. In the server.js file, add the following code below the previous API endpoint definitions:
app.put('/api/items/:id', (req, res) => {
const { id } = req.params;
const { name, description } = req.body;
pool.query(
'UPDATE items SET name = $1, description = $2 WHERE id = $3 RETURNING *',
[name, description, id],
(err, result) => {
if (err) {
console.error('Error executing query:', err);
res.status(500).json({ error: 'Internal Server Error' });
} else if (result.rows.length === 0) {
res.status(404).json({ error: 'Item not found' });
} else {
res.json(result.rows[0]);
}
}
);
});
app.delete('/api/items/:id', (req, res) => {
const { id } = req.params;
pool.query(
'DELETE FROM items WHERE id = $1 RETURNING *',
[id],
(err, result) => {
if (err) {
console.error('Error executing query:', err);
res.status(500).json({ error: 'Internal Server Error' });
} else if (result.rows.length === 0) {
res.status(404).json({ error: 'Item not found' });
} else {
res.json(result.rows[0]);
}
}
);
});
These code snippets define API endpoints for updating and deleting items. The :id parameter in the URL is used to specify the ID of the item to be updated or deleted.
Building the Frontend
Now that we have built the backend of our full-stack app, let's move on to building the frontend using Angular. We will create Angular components, implement data binding, handle user input, and display data from the backend.
Creating Angular components
To create a new Angular component, navigate to the root directory of your Angular project and run the following command:
ng generate component my-component
This will generate a new directory called my-component with the necessary files for the component. Open the generated component file (e.g., my-component.component.ts) and add the following code:
import { Component, OnInit } from '@angular/core';
@Component({
selector: 'app-my-component',
templateUrl: './my-component.component.html',
styleUrls: ['./my-component.component.css']
})
export class MyComponentComponent implements OnInit {
constructor() { }
ngOnInit(): void {
}
}
This code defines a new Angular component called MyComponentComponent and exports it as a module. The ngOnInit method is a lifecycle hook that is called when the component is initialized.
Implementing data binding
Data binding is a powerful feature of Angular that allows us to bind data between the component and the template. To implement data binding, open the component file and add the following code:
export class MyComponentComponent implements OnInit {
message: string = 'Hello, Angular!';
constructor() { }
ngOnInit(): void {
}
}
In this example, we have defined a property called message and assigned it a value of 'Hello, Angular!'. To display this message in the template, open the corresponding template file (e.g., my-component.component.html) and add the following code:
<p>{{ message }}</p>
This code uses interpolation ({{ }}) to bind the value of the message property to the paragraph element. When the component is rendered, the message will be displayed as "Hello, Angular!".
Handling user input
To handle user input, we can use event binding in Angular. Let's add an input field and a button to our component template. Open the template file and add the following code:
<input type="text" [(ngModel)]="inputValue">
<button (click)="showMessage()">Show Message</button>
<p>{{ message }}</p>
In the component file, add the following code to define the inputValue and showMessage methods:
export class MyComponentComponent implements OnInit {
inputValue: string = '';
constructor() { }
ngOnInit(): void {
}
showMessage(): void {
this.message = this.inputValue;
}
}
In this example, we have defined an input field and bound its value to the inputValue property using two-way data binding ([(ngModel)]). The showMessage method is called when the button is clicked, and it updates the message property with the value of inputValue.
Displaying data from the backend
To display data from the backend, we need to make a HTTP request to the API endpoint we defined earlier. Let's add a method to our component that sends a GET request to retrieve the items from the backend. In the component file, add the following code:
import { HttpClient } from '@angular/common/http';
export class MyComponentComponent implements OnInit {
items: any[] = [];
constructor(private http: HttpClient) { }
ngOnInit(): void {
this.getItems();
}
getItems(): void {
this.http.get<any[]>('/api/items').subscribe(
(response) => {
this.items = response;
},
(error) => {
console.error('Error:', error);
}
);
}
}
In this example, we have imported the HttpClient module from @angular/common/http and injected it into the component's constructor. The getItems method sends a GET request to the /api/items endpoint and stores the response in the items property.
To display the items in the template, open the template file and add the following code:
<ul>
<li *ngFor="let item of items">{{ item.name }}</li>
</ul>
This code uses the *ngFor directive to iterate over the items array and display each item's name in a list.
Authentication and Authorization
In this section, we will implement authentication and authorization in our full-stack app. We will create user registration and login forms, secure the API endpoints, and restrict access to certain routes.
Implementing user registration
To implement user registration, we need to create a registration form and send a POST request to a registration API endpoint. Let's create a new component called RegistrationComponent and add the necessary code.
First, generate a new component using the Angular CLI:
ng generate component registration
Open the generated component file (e.g., registration.component.ts) and add the following code:
import { Component, OnInit } from '@angular/core';
import { HttpClient } from '@angular/common/http';
@Component({
selector: 'app-registration',
templateUrl: './registration.component.html',
styleUrls: ['./registration.component.css']
})
export class RegistrationComponent implements OnInit {
username: string = '';
password: string = '';
constructor(private http: HttpClient) { }
ngOnInit(): void {
}
register(): void {
this.http.post<any>('/api/register', { username: this.username, password: this.password }).subscribe(
(response) => {
console.log('Registration successful:', response);
},
(error) => {
console.error('Error:', error);
}
);
}
}
In this code, we have defined two properties (username and password) and the register method, which sends a POST request to the /api/register endpoint with the username and password as the request body.
Next, open the generated template file (e.g., registration.component.html) and add the following code:
<form (submit)="register()">
<div>
<label for="username">Username:</label>
<input type="text" id="username" [(ngModel)]="username">
</div>
<div>
<label for="password">Password:</label>
<input type="password" id="password" [(ngModel)]="password">
</div>
<button type="submit">Register</button>
</form>
This code creates a registration form with input fields for the username and password. The (submit) event is bound to the register method, which is called when the form is submitted.
Implementing user login
To implement user login, we can follow a similar approach as user registration. Let's create a new component called LoginComponent and add the necessary code.
Generate a new component using the Angular CLI:
ng generate component login
Open the generated component file (e.g., login.component.ts) and add the following code:
import { Component, OnInit } from '@angular/core';
import { HttpClient } from '@angular/common/http';
@Component({
selector: 'app-login',
templateUrl: './login.component.html',
styleUrls: ['./login.component.css']
})
export class LoginComponent implements OnInit {
username: string = '';
password: string = '';
constructor(private http: HttpClient) { }
ngOnInit(): void {
}
login(): void {
this.http.post<any>('/api/login', { username: this.username, password: this.password }).subscribe(
(response) => {
console.log('Login successful:', response);
},
(error) => {
console.error('Error:', error);
}
);
}
}
In this code, we have defined two properties (username and password) and the login method, which sends a POST request to the /api/login endpoint with the username and password as the request body.
Next, open the generated template file (e.g., login.component.html) and add the following code:
<form (submit)="login()">
<div>
<label for="username">Username:</label>
<input type="text" id="username" [(ngModel)]="username">
</div>
<div>
<label for="password">Password:</label>
<input type="password" id="password" [(ngModel)]="password">
</div>
<button type="submit">Login</button>
</form>
This code creates a login form with input fields for the username and password. The (submit) event is bound to the login method, which is called when the form is submitted.
Securing API endpoints
To secure the API endpoints, we can use JSON Web Tokens (JWT) for authentication. When a user logs in or registers, the server generates a JWT and sends it to the client. The client includes the JWT in the Authorization header for subsequent requests.
To implement JWT authentication, we need to install the necessary dependencies. In the root directory of your Angular project, run the following command:
npm install jsonwebtoken passport passport-jwt bcrypt
Next, create a new file called auth.js in the root directory of your project. Open the file and add the following code:
const passport = require('passport');
const { Strategy: JwtStrategy, ExtractJwt } = require('passport-jwt');
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');
const secretKey = 'your_secret_key';
const generateJwtToken = (user) => {
const payload = {
id: user.id,
username: user.username,
};
return jwt.sign(payload, secretKey, { expiresIn: '1h' });
};
passport.use(
new JwtStrategy(
{
jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
secretOrKey: secretKey,
},
(payload, done) => {
// TODO: Implement user lookup and validation
done(null, false);
}
)
);
const authenticateJwt = (req, res, next) => {
passport.authenticate('jwt', { session: false }, (err, user) => {
if (err) {
console.error('Error authenticating JWT:', err);
res.status(500).json({ error: 'Internal Server Error' });
} else if (!user) {
res.status(401).json({ error: 'Unauthorized' });
} else {
req.user = user;
next();
}
})(req, res, next);
};
const encryptPassword = async (password) => {
const saltRounds = 10;
const salt = await bcrypt.genSalt(saltRounds);
const hash = await bcrypt.hash(password, salt);
return hash;
};
const comparePassword = async (password, hash) => {
return await bcrypt.compare(password, hash);
};
module.exports = {
generateJwtToken,
authenticateJwt,
encryptPassword,
comparePassword,
};
In this code, we have defined functions for generating a JWT token, authenticating a JWT token, encrypting a password, and comparing a password with a hash. The secretKey variable should be replaced with your actual secret key.
Restricting access to certain routes
To restrict access to certain routes, we can use the authenticateJwt middleware we defined earlier. Let's modify the API endpoint definitions in the server.js file to include the authenticateJwt middleware for authentication.
app.get('/api/items', authenticateJwt, (req, res) => {
// Handle the request
});
app.post('/api/items', authenticateJwt, (req, res) => {
// Handle the request
});
app.put('/api/items/:id', authenticateJwt, (req, res) => {
// Handle the request
});
app.delete('/api/items/:id', authenticateJwt, (req, res) => {
// Handle the request
});
By including the authenticateJwt middleware as the second argument of the API endpoint definitions, we ensure that only authenticated users can access these routes.
Deployment and Testing
In this section, we will cover the deployment and testing of our full-stack app. We will deploy the app to a hosting provider, test its functionality, perform load testing, and monitor and optimize its performance.
Deploying the app to a hosting provider
To deploy the app to a hosting provider, we need to build the frontend and deploy both the backend and frontend to a server. Let's start by building the frontend.
In the root directory of your Angular project, run the following command to build the frontend:
ng build --prod
This will generate a dist directory with the built frontend assets. Copy the contents of the dist directory to the server where you want to deploy the app.
Next, deploy the backend to the server. This involves copying the entire backend directory to the server and installing the necessary dependencies using npm install.
Once the backend and frontend are deployed to the server, start the backend server by running the following command in the backend directory:
node server.js
The app should now be accessible at the server's URL.
Testing the app's functionality
To test the functionality of the app, open a web browser and navigate to the app's URL. Verify that you can register a new user, login with the registered user, and perform CRUD operations on the items.
To test the API endpoints, you can use tools like cURL or Postman to send HTTP requests and verify the responses. Make sure to include the JWT token in the Authorization header for authenticated requests.
Performing load testing
To perform load testing, we can use tools like Apache JMeter or artillery.io to simulate multiple concurrent users and measure the app's performance under heavy load. Configure the load testing tool to send a high volume of requests to the API endpoints and monitor the server's response time and throughput.
During load testing, monitor the server's resource usage (CPU, memory, and network) to identify any bottlenecks or performance issues. Optimize the app's performance by tuning the server configuration, optimizing database queries, or implementing caching mechanisms.
Monitoring and optimizing performance
To monitor and optimize the performance of the app, we can use tools like New Relic, Datadog, or Google Analytics. These tools provide insights into the app's performance metrics, such as response time, throughput, and error rate.
Monitor the app's performance regularly and identify any performance bottlenecks or areas for optimization. Make incremental improvements to the app's code, database queries, server configuration, or caching mechanisms to optimize its performance.
Conclusion
In this tutorial, we have covered the entire process of building a full-stack app using Angular and PostgreSQL. We started by setting up the development environment, including installing Angular CLI and PostgreSQL. Then, we built the backend using Node.js and PostgreSQL, and the frontend using Angular. We implemented authentication and authorization, deployed the app, and performed testing and optimization. By following this tutorial, you should now have a good understanding of how to build a full-stack app using Angular and PostgreSQL.