How to do cascading inserts with tables having auto increment id columns in TypeORM

In TypeORM, cascading inserts refer to automatically inserting related entities when an entity is inserted. This is particularly useful when working with tables that have foreign key relationships. The following example demonstrates how to implement cascading inserts on tables with auto-increment ID columns.

Suppose we have two entities: User and Profile, where a user (User) has a one-to-one relationship with its profile (Profile). We want to automatically create the corresponding profile when creating a new user. Here, User is the primary entity with an auto-increment ID column, and Profile is the related entity with a foreign key referencing User.

First, we need to define these two entities:

typescript
import {
  Entity,
  PrimaryGeneratedColumn,
  Column,
  OneToOne,
  JoinColumn
} from 'typeorm';
import { Profile } from './Profile';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  username: string;

  @OneToOne(() => Profile, profile => profile.user, {
    cascade: true
  })
  @JoinColumn()
  profile: Profile;
}

@Entity()
export class Profile {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  bio: string;

  @OneToOne(() => User, user => user.profile)
  user: User;
}

In this example, the profile property in the User entity uses the @OneToOne decorator to specify the one-to-one relationship with the Profile entity, and the cascade: true option enables cascading inserts. This means that when we create and save a User entity, the associated Profile entity is automatically created and saved.

Next, we can write a function to create a new user and its profile:

typescript
import { createConnection, getRepository } from 'typeorm';
import { User } from './User';
import { Profile } from './Profile';

async function createUser() {
  const connection = await createConnection(/* database configuration */);
  const userRepository = getRepository(User);

  const user = new User();
  user.username = 'john_doe';
  
  const profile = new Profile();
  profile.bio = 'John Doe bio';
  
  // Associate the profile with the user
  user.profile = profile;
  
  // Save the user, which cascades the profile save
  await userRepository.save(user);

  console.log('New user and profile created:', user);

  await connection.close();
}

createUser().catch(console.error);

In this function, we first create a User entity and a Profile entity, and assign the Profile entity to the User entity's profile property. Due to the enabled cascading inserts, calling userRepository.save(user) not only saves the User entity but also saves the Profile entity.

This is how to implement cascading inserts on tables with auto-increment ID columns in TypeORM. By correctly configuring entity relationships and cascade options, we can simplify the creation and maintenance of complex data structures.