One-to-one is a relational database design pattern where entity A contains only one instance of entity B, and vice versa, ensuring a bijective mapping. In a Nest.js application with TypeORM, this might manifest as a user entity having a one-to-one relation with an artist entity, meaning a user can become an artist, and an artist can have only a single user profile. This design is governed by the Single Responsibility Principle, as each entity is responsible for a distinct set of attributes and behaviors, thereby simplifying database management and application logic.

import { User } from "src/users/user.entity";
import { Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn } from "typeorm";

@Entity("artists")
export class Artist {
  @PrimaryGeneratedColumn()
  id: number;
}

 entity starting with one field, using the 

 decorator to map it to a database table. Extend the entity by adding more columns or fields as needed, guided by the application's requirements and domain model. This flexibility allows you to tailor the entity to fit various use cases.

---
title: One-to-One Relation
privateVideoUrl: https://fullstack.wistia.com/medias/09jqcvwtjw
isPublicLesson: true
---

## One to One Relation

One-to-one is a relational database design pattern where entity A contains only one instance of entity B, and vice versa, ensuring a bijective mapping. In a Nest.js application with TypeORM, this might manifest as a user entity having a one-to-one relation with an artist entity, meaning a user can become an artist, and an artist can have only a single user profile. This design is governed by the Single Responsibility Principle, as each entity is responsible for a distinct set of attributes and behaviors, thereby simplifying database management and application logic.

## Create Artist Entity

```ts
import { User } from "src/users/user.entity";
import { Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn } from "typeorm";

@Entity("artists")
export class Artist {
  @PrimaryGeneratedColumn()
  id: number;
}
```

Define the `Artist` entity starting with one field, using the `@Entity` decorator to map it to a database table. Extend the entity by adding more columns or fields as needed, guided by the application's requirements and domain model. This flexibility allows you to tailor the entity to fit various use cases.

Haider Malik

One-to-One Relation

In this video, I'm going to teach you how to build one-to-one relationship

One-to-one relation where A entity contains only one instance of B and B

Let's take an example, a user can become an artist or an artist can have only

So, there is a one-to-one relationship between user and the artist.

We don't have an artist model or artist entity.

First of all, you've got to create artist entity with primary key and then you

create the user entity because we're going to make one-to-one relationship

I'm going to have IT field or first-column, first-name column, last-name column

column and the password column for user entity.

Now we're going to add one-to-one relationship.

Type-one and provides one-to-one decorator to add relationship between two

In the first argument, use to specify the relation type.

I would like to make a relationship with user entity.

This is the type of the relation you specify the relation entity type by

syntax, arrow function and this join column will create the reference key or a

key of the user entity inside the artist entity.

So, we will have a user ID as a foreign key inside the artist.

And finally, you have to register the user and artist entity inside the app

Now we're going to implement these steps.

So I'm going to create a new artist entity.

If you like, you can use CLI command to generate a new entity.

So I'm going to say artist.entity.as file.

You already learned how to create an entity.

So I'm going to create a new entity user.entity.as.

We have ID field first name, last name, email and the password.

And now we're going to make a one to one relationship.

I would like to store the user ID inside the artist model.

If you want to store artist ID inside the user, you can also do that.

Specify the type of relationship by following this syntax.

We like to make a relationship with user.

And here we will have the user and the user.

And now find a model user.entity.as file.

And now we have to register these entities inside the app model.

Please convert these entities into tables.

Our last step is to test the application.

So it has successfully let me check my schema, which is 45.1.

Inside the tables, we have the artist and the user's table.

And inside the users, we have for columns or ID first name, last name, email

This is how you will make one to one relationship between two entities.

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Masterclasses

Tutorials

Fullstack React with TypeScript