Build a User Management App with Angular

This tutorial demonstrates how to build a basic user management app. The app authenticates and identifies the user, stores their profile information in the database, and allows the user to log in, update their profile details, and upload a profile photo. The app uses:

Supabase Database - a Postgres database for storing your user data and Row Level Security so data is protected and users can only access their own information.
Supabase Auth - allow users to sign up and log in.
Supabase Storage - users can upload a profile photo.

Supabase User Management example

If you get stuck while working through this guide, refer to the full example on GitHub.

Project setup

Before you start building you need to set up the Database and API. You can do this by starting a new Project in Supabase and then creating a "schema" inside the database.

Create a project

Create a new project in the Supabase Dashboard.
Enter your project details.
Wait for the new database to launch.

Set up the database schema

Now set up the database schema. You can use the "User Management Starter" quickstart in the SQL Editor, or you can copy/paste the SQL from below and run it.

Go to the SQL Editor page in the Dashboard.
Click User Management Starter.
Click Run.

You can pull the database schema down to your local project by running the db pull command. Read the local development docs for detailed instructions.

1
2
3
supabase link --project-ref <project-id># You can get <project-id> from your project's dashboard URL: https://supabase.com/dashboard/project/<project-id>supabase db pull

Get the API keys

Now that you've created some database tables, you are ready to insert data using the auto-generated API.

To do this, you need to get the Project URL and anon key from the API settings.

Go to the API Settings page in the Dashboard.
Find your Project URL, anon, and service_role keys on this page.

Building the app

Start with building the Angular app from scratch.

Initialize an Angular app

You can use the Angular CLI to initialize an app called supabase-angular. The command sets some defaults, that you change to suit your needs:

1
2
npx ng new supabase-angular --routing false --style css --standalone false --zoneless true --ssr falsecd supabase-angular

Then, install the only additional dependency: supabase-js

1
npm install @supabase/supabase-js

Finally, save the environment variables in the src/environments/environment.ts file. All you need are the API URL and the anon key that you copied earlier. The application exposes these variables in the browser, and that's fine as you have Row Level Security enabled on the Database.

1
2
3
4
5
export const  = {  : false,  : 'YOUR_SUPABASE_URL',  : 'YOUR_SUPABASE_KEY',}

Now you have the API credentials in place, create a SupabaseService with ng g s supabase and add the following code to initialize the Supabase client and implement functions to communicate with the Supabase API.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
import { Injectable } from '@angular/core'import {  AuthChangeEvent,  AuthSession,  createClient,  Session,  SupabaseClient,  User,} from '@supabase/supabase-js'import { environment } from '../environments/environment'export interface Profile {  id?: string  username: string  website: string  avatar_url: string}@Injectable({  providedIn: 'root',})export class SupabaseService {  private supabase: SupabaseClient  _session: AuthSession | null = null  constructor() {    this.supabase = createClient(environment.supabaseUrl, environment.supabaseKey)  }  get session() {    this.supabase.auth.getSession().then(({ data }) => {      this._session = data.session    })    return this._session  }  profile(user: User) {    return this.supabase      .from('profiles')      .select(`username, website, avatar_url`)      .eq('id', user.id)      .single()  }  authChanges(callback: (event: AuthChangeEvent, session: Session | null) => void) {    return this.supabase.auth.onAuthStateChange(callback)  }  signIn(email: string) {    return this.supabase.auth.signInWithOtp({ email })  }  signOut() {    return this.supabase.auth.signOut()  }  updateProfile(profile: Profile) {    const update = {      ...profile,      updated_at: new Date(),    }    return this.supabase.from('profiles').upsert(update)  }  downLoadImage(path: string) {    return this.supabase.storage.from('avatars').download(path)  }  uploadAvatar(filePath: string, file: File) {    return this.supabase.storage.from('avatars').upload(filePath, file)  }}

Optionally, update src/styles.css with the following styles to style the app.

Next, set up an Angular component to manage logins and sign ups. The component uses Magic Links, so users can sign in with their email without using passwords.

Create an AuthComponent with the ng g c auth Angular CLI command and add the following code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import { Component } from '@angular/core'import { FormBuilder, FormGroup } from '@angular/forms'import { SupabaseService } from '../supabase.service'@Component({  selector: 'app-auth',  templateUrl: './auth.html',  styleUrls: ['./auth.css'],  standalone: false,})export class AuthComponent {  signInForm!: FormGroup  constructor(    private readonly supabase: SupabaseService,    private readonly formBuilder: FormBuilder  ) {}  loading = false  ngOnInit() {    this.signInForm = this.formBuilder.group({      email: '',    })  }  async onSubmit(): Promise<void> {    try {      this.loading = true      const email = this.signInForm.value.email as string      const { error } = await this.supabase.signIn(email)      if (error) throw error      alert('Check your email for the login link!')    } catch (error) {      if (error instanceof Error) {        alert(error.message)      }    } finally {      this.signInForm.reset()      this.loading = false    }  }}

Account page

Users also need a way to edit their profile details and manage their accounts after signing in. Create an AccountComponent with the ng g c account Angular CLI command and add the following code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
import { Component, Input, OnInit } from '@angular/core'import { FormBuilder, FormGroup } from '@angular/forms'import { AuthSession } from '@supabase/supabase-js'import { Profile, SupabaseService } from '../supabase.service'@Component({  selector: 'app-account',  templateUrl: './account.html',  styleUrls: ['./account.css'],  standalone: false,})export class AccountComponent implements OnInit {  loading = false  profile!: Profile  updateProfileForm!: FormGroup  get avatarUrl() {    return this.updateProfileForm.value.avatar_url as string  }  async updateAvatar(event: string): Promise<void> {    this.updateProfileForm.patchValue({      avatar_url: event,    })    await this.updateProfile()  }  @Input()  session!: AuthSession  constructor(    private readonly supabase: SupabaseService,    private formBuilder: FormBuilder  ) {    this.updateProfileForm = this.formBuilder.group({      username: '',      website: '',      avatar_url: '',    })  }  async ngOnInit(): Promise<void> {    await this.getProfile()    const { username, website, avatar_url } = this.profile    this.updateProfileForm.patchValue({      username,      website,      avatar_url,    })  }  async getProfile() {    try {      this.loading = true      const { user } = this.session      const { data: profile, error, status } = await this.supabase.profile(user)      if (error && status !== 406) {        throw error      }      if (profile) {        this.profile = profile      }    } catch (error) {      if (error instanceof Error) {        alert(error.message)      }    } finally {      this.loading = false    }  }  async updateProfile(): Promise<void> {    try {      this.loading = true      const { user } = this.session      const username = this.updateProfileForm.value.username as string      const website = this.updateProfileForm.value.website as string      const avatar_url = this.updateProfileForm.value.avatar_url as string      const { error } = await this.supabase.updateProfile({        id: user.id,        username,        website,        avatar_url,      })      if (error) throw error    } catch (error) {      if (error instanceof Error) {        alert(error.message)      }    } finally {      this.loading = false    }  }  async signOut() {    await this.supabase.signOut()  }}

Launch!

Now you have all the components in place, update AppComponent:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import { Component, OnInit } from '@angular/core'import { SupabaseService } from './supabase.service'@Component({  selector: 'app-root',  templateUrl: './app.html',  styleUrls: ['./app.css'],  standalone: false,})export class AppComponent implements OnInit {  constructor(private readonly supabase: SupabaseService) {}  title = 'angular-user-management'  session: any  ngOnInit() {    this.session = this.supabase.session    this.supabase.authChanges((_, session) => (this.session = session))  }}

You also need to change app.module.ts to include the ReactiveFormsModule from the @angular/forms package.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import { NgModule } from '@angular/core'import { BrowserModule } from '@angular/platform-browser'import { AppComponent } from './app'import { AuthComponent } from './auth/auth'import { AccountComponent } from './account/account'import { ReactiveFormsModule } from '@angular/forms'import { AvatarComponent } from './avatar/avatar'@NgModule({  declarations: [AppComponent, AuthComponent, AccountComponent, AvatarComponent],  imports: [BrowserModule, ReactiveFormsModule],  providers: [],  bootstrap: [AppComponent],  exports: [AppComponent, AuthComponent, AccountComponent, AvatarComponent],})export class AppModule {}

Once that's done, run the application in a terminal:

1
npm run start

Open the browser to localhost:4200 and you should see the completed app.

Screenshot of the Supabase Angular application running in a browser

Bonus: Profile photos

Every Supabase project is configured with Storage for managing large files like photos and videos.

Create an avatar for the user so that they can upload a profile photo. Create an AvatarComponent with ng g c avatar Angular CLI command and add the following code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
import { Component, EventEmitter, Input, Output } from '@angular/core'import { SafeResourceUrl, DomSanitizer } from '@angular/platform-browser'import { SupabaseService } from '../supabase.service'@Component({  selector: 'app-avatar',  templateUrl: './avatar.html',  styleUrls: ['./avatar.css'],  standalone: false,})export class AvatarComponent {  _avatarUrl: SafeResourceUrl | undefined  uploading = false  @Input()  set avatarUrl(url: string | null) {    if (url) {      this.downloadImage(url)    }  }  @Output() upload = new EventEmitter<string>()  constructor(    private readonly supabase: SupabaseService,    private readonly dom: DomSanitizer  ) {}  async downloadImage(path: string) {    try {      const { data } = await this.supabase.downLoadImage(path)      if (data instanceof Blob) {        this._avatarUrl = this.dom.bypassSecurityTrustResourceUrl(URL.createObjectURL(data))      }    } catch (error) {      if (error instanceof Error) {        console.error('Error downloading image: ', error.message)      }    }  }  async uploadAvatar(event: any) {    try {      this.uploading = true      if (!event.target.files || event.target.files.length === 0) {        throw new Error('You must select an image to upload.')      }      const file = event.target.files[0]      const fileExt = file.name.split('.').pop()      const filePath = `${Math.random()}.${fileExt}`      await this.supabase.uploadAvatar(filePath, file)      this.upload.emit(filePath)    } catch (error) {      if (error instanceof Error) {        alert(error.message)      }    } finally {      this.uploading = false    }  }}

And then we can add the widget on top of the AccountComponent HTML template:

1
2
3
4
<form [formGroup]="updateProfileForm" (ngSubmit)="updateProfile()" class="form-widget">  <app-avatar [avatarUrl]="this.avatarUrl" (upload)="updateAvatar($event)"></app-avatar>  <!-- input fields --></form>

And add an updateAvatar function along with an avatarUrl getter to the AccountComponent typescript file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Component({  selector: 'app-account',  templateUrl: './account.html',  styleUrls: ['./account.css'],})export class AccountComponent implements OnInit {  // ...  get avatarUrl() {    return this.updateProfileForm.value.avatar_url as string  }  async updateAvatar(event: string): Promise<void> {    this.updateProfileForm.patchValue({      avatar_url: event,    })    await this.updateProfile()  }  // ...}

At this stage you have a fully functional application!

Build a User Management App with Angular

Project setup

Create a project

Set up the database schema

Get the API keys

Building the app

Initialize an Angular app

Account page

Launch!

Bonus: Profile photos

Create an upload widget

Add the new widget

Is this helpful?

Build a User Management App with Angular

Project setup#

Create a project#

Set up the database schema#

Get the API keys#

Building the app#

Initialize an Angular app#

Set up a login component#

Account page#

Launch!#

Bonus: Profile photos#

Create an upload widget#

Add the new widget#

Is this helpful?

Project setup

Create a project

Set up the database schema

Get the API keys

Building the app

Initialize an Angular app

Set up a login component

Account page

Launch!

Bonus: Profile photos

Create an upload widget

Add the new widget