Swarm/DysonNetwork.Sphere/AppDatabase.cs

using DysonNetwork.Common.Models;
using DysonNetwork.Sphere.Permission;
using DysonNetwork.Sphere.Realm;
using DysonNetwork.Sphere.Sticker;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Query;

namespace DysonNetwork.Sphere;

public class AppDatabase(
    DbContextOptions<AppDatabase> options,
    IConfiguration configuration
) : DbContext(options)
{
    public DbSet<CloudFile> Files { get; set; }
    public DbSet<CloudFileReference> FileReferences { get; set; }

    public DbSet<Common.Models.Publisher> Publishers { get; set; }
    
    public DbSet<PublisherFeature> PublisherFeatures { get; set; }

    public DbSet<Common.Models.Post> Posts { get; set; }
    public DbSet<PostReaction> PostReactions { get; set; }
    public DbSet<PostTag> PostTags { get; set; }
    public DbSet<PostCategory> PostCategories { get; set; }
    public DbSet<PostCollection> PostCollections { get; set; }

    public DbSet<Common.Models.Realm> Realms { get; set; }
    public DbSet<RealmMember> RealmMembers { get; set; }
    public DbSet<Tag> Tags { get; set; }
    public DbSet<RealmTag> RealmTags { get; set; }

    public DbSet<ChatRoom> ChatRooms { get; set; }
    public DbSet<ChatMember> ChatMembers { get; set; }
    public DbSet<Message> ChatMessages { get; set; }
    public DbSet<RealtimeCall> ChatRealtimeCall { get; set; }
    public DbSet<MessageReaction> ChatReactions { get; set; }

    public DbSet<Sticker.Sticker> Stickers { get; set; }
    public DbSet<StickerPack> StickerPacks { get; set; }

    public DbSet<Common.Models.Wallet> Wallets { get; set; }
    public DbSet<WalletPocket> WalletPockets { get; set; }
    public DbSet<Order> PaymentOrders { get; set; }
    public DbSet<Transaction> PaymentTransactions { get; set; }

    public DbSet<CustomApp> CustomApps { get; set; }
    public DbSet<CustomAppSecret> CustomAppSecrets { get; set; }

    public DbSet<Subscription> WalletSubscriptions { get; set; }
    public DbSet<Coupon> WalletCoupons { get; set; }
    public DbSet<Connection.WebReader.WebArticle> WebArticles { get; set; }
    public DbSet<Connection.WebReader.WebFeed> WebFeeds { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseNpgsql(
            configuration.GetConnectionString("App"),
            opt => opt
                .ConfigureDataSource(optSource => optSource.EnableDynamicJson())
                .UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery)
                .UseNetTopologySuite()
                .UseNodaTime()
        ).UseSnakeCaseNamingConvention();

        

        base.OnConfiguring(optionsBuilder);
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        
        modelBuilder.Entity<PublisherMember>()
            .HasKey(pm => new { pm.PublisherId, pm.AccountId });
        modelBuilder.Entity<PublisherMember>()
            .HasOne(pm => pm.Publisher)
            .WithMany(p => p.Members)
            .HasForeignKey(pm => pm.PublisherId)
            .OnDelete(DeleteBehavior.Cascade);

        modelBuilder.Entity<Common.Models.Post>()
            .HasGeneratedTsVectorColumn(p => p.SearchVector, "simple", p => new { p.Title, p.Description, p.Content })
            .HasIndex(p => p.SearchVector)
            .HasMethod("GIN");

        modelBuilder.Entity<CustomAppSecret>()
            .HasIndex(s => s.Secret)
            .IsUnique();
            
        modelBuilder.Entity<CustomApp>()
            .HasMany(c => c.Secrets)
            .WithOne(s => s.App)
            .HasForeignKey(s => s.AppId)
            .OnDelete(DeleteBehavior.Cascade);

        modelBuilder.Entity<Common.Models.Post>()
            .HasOne(p => p.RepliedPost)
            .WithMany()
            .HasForeignKey(p => p.RepliedPostId)
            .OnDelete(DeleteBehavior.Restrict);
        modelBuilder.Entity<Common.Models.Post>()
            .HasOne(p => p.ForwardedPost)
            .WithMany()
            .HasForeignKey(p => p.ForwardedPostId)
            .OnDelete(DeleteBehavior.Restrict);
        modelBuilder.Entity<Common.Models.Post>()
            .HasMany(p => p.Tags)
            .WithMany(t => t.Posts)
            .UsingEntity(j => j.ToTable("post_tag_links"));
        modelBuilder.Entity<Common.Models.Post>()
            .HasMany(p => p.Categories)
            .WithMany(c => c.Posts)
            .UsingEntity(j => j.ToTable("post_category_links"));
        modelBuilder.Entity<Common.Models.Post>()
            .HasMany(p => p.Collections)
            .WithMany(c => c.Posts)
            .UsingEntity(j => j.ToTable("post_collection_links"));

        modelBuilder.Entity<ChatMember>()
            .HasKey(pm => new { pm.Id });
        modelBuilder.Entity<ChatMember>()
            .HasAlternateKey(pm => new { pm.ChatRoomId, pm.AccountId });
        
        
        modelBuilder.Entity<Message>()
            .HasOne(m => m.ForwardedMessage)
            .WithMany()
            .HasForeignKey(m => m.ForwardedMessageId)
            .OnDelete(DeleteBehavior.Restrict);
        modelBuilder.Entity<Message>()
            .HasOne(m => m.RepliedMessage)
            .WithMany()
            .HasForeignKey(m => m.RepliedMessageId)
            .OnDelete(DeleteBehavior.Restrict);
        
        

        modelBuilder.Entity<Connection.WebReader.WebFeed>()
            .HasIndex(f => f.Url)
            .IsUnique();

        modelBuilder.Entity<Connection.WebReader.WebArticle>()
            .HasIndex(a => a.Url)
            .IsUnique();

        

public static class OptionalQueryExtensions
{
    public static IQueryable<T> If<T>(
        this IQueryable<T> source,
        bool condition,
        Func<IQueryable<T>, IQueryable<T>> transform
    )
    {
        return condition ? transform(source) : source;
    }

    public static IQueryable<T> If<T, TP>(
        this IIncludableQueryable<T, TP> source,
        bool condition,
        Func<IIncludableQueryable<T, TP>, IQueryable<T>> transform
    )
        where T : class
    {
        return condition ? transform(source) : source;
    }

    public static IQueryable<T> If<T, TP>(
        this IIncludableQueryable<T, IEnumerable<TP>> source,
        bool condition,
        Func<IIncludableQueryable<T, IEnumerable<TP>>, IQueryable<T>> transform
    )
        where T : class
    {
        return condition ? transform(source) : source;
    }
}