Inserting a dependent entity while inserting the principal entity with Entity Framework

Firstly, these are my entities.

public class Restaurant : Entity
{
public string Name { get; set; }
public int OwnerId { get; set; }
public virtual Owner Owner { get; set; }
public virtual Menu Menu { get; set; }
public Restaurant()
{
Menu = new Menu();
}
}
public class Menu : Entity
{
public int RestaurantId { get; set; }
public virtual ICollection<Campaign> Campaigns { get; set; }
public virtual ICollection<Category> Categories { get; set; }
public virtual Restaurant Resturant { get; set; }
public Menu()
{
Campaigns = new HashSet<Campaign>();
Categories = new HashSet<Category>();
}
}

Also they have one to one relationship. Declared as:

modelBuilder.Entity<Restaurant>(r =>
{
r.HasOne(r => r.Owner)
.WithMany()
.HasForeignKey(r =>r.OwnerId);
r.HasOne(r => r.Menu)
.WithOne(m => m.Resturant)
.HasForeignKey<Menu>(m => m.RestaurantId);
});
modelBuilder.Entity<Menu>(m =>
{
m.HasMany(m => m.Campaigns)
.WithOne(c => c.Menu)
.HasForeignKey(x => x.MenuId);
m.HasMany(m => m.Categories)
.WithOne(c => c.Menu)
.HasForeignKey(c => c.MenuId);
m.HasOne(m => m.Resturant)
.WithOne(r => r.Menu);
});

The problem is I am creating a Restaurant when I get the CreateRestourantCommand request. Inside of it:

public class CreateRestaurantCommandHandler : IRequestHandler<CreateRestaurantCommand, CreatedRestaurantResponseDto>
{
private readonly IRestaurantRepository _restaurantRepository;
private readonly RestaurantBusinessRules _restaurantBusinessRules;
public CreateRestaurantCommandHandler(IRestaurantRepository restaurantRepository, RestaurantBusinessRules restaurantBusinessRules)
{
_restaurantRepository = restaurantRepository;
_restaurantBusinessRules = restaurantBusinessRules;
}
public async Task<CreatedRestaurantResponseDto> Handle(CreateRestaurantCommand request, CancellationToken cancellationToken)
{
await _restaurantBusinessRules.DoesOwnerExistAndHaveRestaurantWithSameName(request.OwnerId, request.RestaurantName);
Restaurant restaurant = new()
{
Name = request.RestaurantName,
OwnerId = request.OwnerId,
};
Restaurant createdRestaurant = await _restaurantRepository.CreateAsync(restaurant);
CreatedRestaurantResponseDto response = new()
{
Id = createdRestaurant.Id,
Name = createdRestaurant.Name,
OwnerId = createdRestaurant.OwnerId
};
return response;
}
}

Everythink works perfect. However the created Menu inside of the restaurant's constructor is not pushed to the db.

This my CreateAsync method.

public async Task<TEntity> CreateAsync(TEntity entity)
{
Context.Entry(entity).State = EntityState.Added;
await Context.SaveChangesAsync();
return entity;
}

I have tried empty constructor creating the menu inside of curly brackets and changing the configuration made in dbcontext but these didn't solve the problem.

The short answer is that EntityState = EntityState.Added does not set the state of related entities, it associates them but leaves them Unmodified. Use Context.Set<TEntity>().Add(entity) to ensure the entity and related are treated as additions. This Will likely cause you issues down the road because in adding entities there will likely be times where you want to Add new related entities, but other times you want to Associate related entities. Unless those associated entities are tracked by the DbContext this can result in duplicate index violations as EF tries to insert them, or inserting duplicate data with new PKs.

public async Task<TEntity> CreateAsync(TEntity entity)
{
Context.Set<TEntity>.Add(entity);
await Context.SaveChangesAsync();
return entity;
}

I do not recommend using Generic Repositories, but instead strongly typed ones so you can deal with specific relationships as you need, and provide base functionality like Factory methods rather than having calling code constructing entities.