<h3>🔀 What are Relationships in TypeORM</h3>
Relationships help you work easily with related entities. There are several types:
<ul>
<li><code>@OneToOne</code>: One to one.</li>
<li><code>@ManyToOne</code>: Many to one.</li>
<li><code>@OneToMany</code>: One to many.</li>
<li><code>@ManyToMany</code>: Many to many.</li>
</ul>
<hr>
<h3>📚 Options in Relationships</h3>
There are several options you can specify:
<ul>
<li><code>eager: boolean</code>: If set to true, the relationship will always be loaded with the main entity when using <code>find()</code> or <code>QueryBuilder</code>.</li>
<li><code>cascade: boolean | (&quot;insert&quot; | &quot;update&quot;)[]</code>: If set to true, the related object will be inserted and updated in the database.</li>
<li><code>onDelete: &quot;RESTRICT&quot;|&quot;CASCADE&quot;|&quot;SET NULL&quot;</code>: Specifies how the foreign key should behave when the referenced object is deleted.</li>
<li><code>nullable: boolean</code>: Indicates if the column for this relationship can be null or not. By default, it is false.</li>
<li><code>orphanedRowAction: &quot;nullify&quot; | &quot;delete&quot; | &quot;soft-delete&quot; | &quot;disable&quot;</code>: When a parent is saved (cascade enabled) without a child(ren) that still exists in the database, this will control what happens to them.
<ul>
<li><code>nullify</code>: Will remove the relationship key.</li>
<li><code>delete</code>: Will remove those children from the database.</li>
<li><code>soft-delete</code>: Will mark the children as softly deleted.</li>
<li><code>disable</code>: Will keep the relationship intact.</li>
</ul>
</li>
</ul>
<hr>
<h3>Using @JoinColumn</h3>
The <code>@JoinColumn</code> not only specifies which side of the relationship contains the join column with a foreign key but also allows you to customize the name of the join column and the referenced column name.
When we define <code>@JoinColumn</code>, it automatically creates a column in the database named <code>propertyName + referencedColumnName</code>. For example:
<pre><code class="language-tsx">@OneToOne(type =&gt; Post)
@JoinColumn()
post: Post;
</code></pre>
This code will create a column named <code>postId</code> in the database. If you want to change this name, you can specify a custom name:
<pre><code class="language-tsx">@OneToOne(type =&gt; Post)
@JoinColumn({ name: &quot;card_id&quot; })
post: Post;
</code></pre>
Join columns are always a reference to some other columns (using a foreign key). By default, your relationship always refers to the primary column of the related entity. If you want to create a relationship with other columns of the related entity - you can also specify them in <code>@JoinColumn</code>:
<pre><code class="language-tsx">@OneToMany(type =&gt; Post)
@JoinColumn({ referencedColumnName: &quot;title&quot; })
post: Post;
</code></pre>
The relationship now refers to title instead of id. The column name for this relationship will become <code>postTitle</code>.
You can also join multiple columns. Note that they do not reference the primary column of the related entity by default: you must provide the referenced column name.
<pre><code class="language-tsx">@ManyToOne(type =&gt; Post)
@JoinColumn([
 { name: &quot;post_id&quot;, referencedColumnName: &quot;id&quot; },
 { name: &quot;author_id&quot;, referencedColumnName: &quot;author_id&quot; }
])
post: Post;
</code></pre>
<hr>
<h3>Using @JoinTable</h3>
The <code>@JoinTable</code> is used for <code>@ManyToMany</code> relationships and describes the join columns of the “junction” table. A junction table is a separate, special table automatically created by TypeORM with columns that refer to the related entities. You can change the names of the columns within the join tables and their referenced columns with <code>@JoinColumn</code>: You can also change the name of the generated “junction” table.
<pre><code class="language-tsx">@ManyToMany(type =&gt; Post)
@JoinTable({
 name: &quot;question_post&quot;,
 joinColumn: {
 name: &quot;question&quot;,
 referencedColumnName: &quot;id&quot;
 },
 inverseJoinColumn: {
 name: &quot;post&quot;,
 referencedColumnName: &quot;id&quot;
 }
})
post: Post[];
</code></pre>
If the target table has composite primary keys, an array of properties must be sent to <code>@JoinTable</code>.
<hr>
<h3>🔗 References</h3>
<ul>
<li><a href="https://typeorm.io/" target="_blank" rel="noopener nofollow">https://typeorm.io/</a></li>
</ul>
<hr>

News, updates, and discussions about everything happening in and around the Node.js runtime.

Node.js developers

Learn about relationships in TypeORM, including the types of relationships, options for relationships, and how to use @JoinColumn and @JoinTable.

Master Relationships in TypeORM with These Tips

<a href="https://app.daily.dev/henriqueschroeder" data-mention-id="aFt1DMnysFHqwCJsjr5PI" data-mention-username="henriqueschroeder">@henriqueschroeder</a> Nice article 👏🏻. It’s a simple way to understand TypeORM relationships.

Love these kind of posts. They look like someone put a lot of effort into it. Rather than a bot linking some articles haha. Good post! Very interesting.