♻️ Move the realm service from sphere to the pass

DysonNetwork.Pass/AppDatabase.cs

@@ -38,6 +38,9 @@ public class AppDatabase(
     public DbSet<SnAuthChallenge> AuthChallenges { get; set; } = null!;
     public DbSet<SnAuthClient> AuthClients { get; set; } = null!;
     public DbSet<SnApiKey> ApiKeys { get; set; } = null!;
+    
+    public DbSet<SnRealm> Realms { get; set; } = null!;
+    public DbSet<SnRealmMember> RealmMembers { get; set; } = null!;
 
     public DbSet<SnWallet> Wallets { get; set; } = null!;
     public DbSet<SnWalletPocket> WalletPockets { get; set; } = null!;
@@ -127,6 +130,14 @@ public class AppDatabase(
             .HasOne(r => r.Related)
             .WithMany(a => a.IncomingRelationships)
             .HasForeignKey(r => r.RelatedId);
+        
+        modelBuilder.Entity<SnRealmMember>()
+            .HasKey(pm => new { pm.RealmId, pm.AccountId });
+        modelBuilder.Entity<SnRealmMember>()
+            .HasOne(pm => pm.Realm)
+            .WithMany(p => p.Members)
+            .HasForeignKey(pm => pm.RealmId)
+            .OnDelete(DeleteBehavior.Cascade);
 
         // Automatically apply soft-delete filter to all entities inheriting BaseModel
         foreach (var entityType in modelBuilder.Model.GetEntityTypes())

DysonNetwork.Pass/Migrations/20251021153439_AddRealmFromSphere.cs

@@ -0,0 +1,160 @@
+using System;
+using DysonNetwork.Shared.Models;
+using Microsoft.EntityFrameworkCore.Migrations;
+using NodaTime;
+
+#nullable disable
+
+namespace DysonNetwork.Pass.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddRealmFromSphere : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "realms",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    slug = table.Column<string>(type: "character varying(1024)", maxLength: 1024, nullable: false),
+                    name = table.Column<string>(type: "character varying(1024)", maxLength: 1024, nullable: false),
+                    description = table.Column<string>(type: "character varying(4096)", maxLength: 4096, nullable: false),
+                    is_community = table.Column<bool>(type: "boolean", nullable: false),
+                    is_public = table.Column<bool>(type: "boolean", nullable: false),
+                    picture_id = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: true),
+                    background_id = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: true),
+                    picture = table.Column<SnCloudFileReferenceObject>(type: "jsonb", nullable: true),
+                    background = table.Column<SnCloudFileReferenceObject>(type: "jsonb", nullable: true),
+                    verification = table.Column<SnVerificationMark>(type: "jsonb", nullable: true),
+                    account_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_realms", x => x.id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "realm_members",
+                columns: table => new
+                {
+                    realm_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    account_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    role = table.Column<int>(type: "integer", nullable: false),
+                    joined_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    leave_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_realm_members", x => new { x.realm_id, x.account_id });
+                    table.ForeignKey(
+                        name: "fk_realm_members_realms_realm_id",
+                        column: x => x.realm_id,
+                        principalTable: "realms",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "sn_chat_room",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    name = table.Column<string>(type: "character varying(1024)", maxLength: 1024, nullable: true),
+                    description = table.Column<string>(type: "character varying(4096)", maxLength: 4096, nullable: true),
+                    type = table.Column<int>(type: "integer", nullable: false),
+                    is_community = table.Column<bool>(type: "boolean", nullable: false),
+                    is_public = table.Column<bool>(type: "boolean", nullable: false),
+                    picture_id = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: true),
+                    background_id = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: true),
+                    picture = table.Column<SnCloudFileReferenceObject>(type: "jsonb", nullable: true),
+                    background = table.Column<SnCloudFileReferenceObject>(type: "jsonb", nullable: true),
+                    realm_id = table.Column<Guid>(type: "uuid", nullable: true),
+                    sn_realm_id = table.Column<Guid>(type: "uuid", nullable: true),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_sn_chat_room", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_sn_chat_room_realms_sn_realm_id",
+                        column: x => x.sn_realm_id,
+                        principalTable: "realms",
+                        principalColumn: "id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "sn_chat_member",
+                columns: table => new
+                {
+                    id = table.Column<Guid>(type: "uuid", nullable: false),
+                    chat_room_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    account_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    nick = table.Column<string>(type: "character varying(1024)", maxLength: 1024, nullable: true),
+                    role = table.Column<int>(type: "integer", nullable: false),
+                    notify = table.Column<int>(type: "integer", nullable: false),
+                    last_read_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    joined_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    leave_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    is_bot = table.Column<bool>(type: "boolean", nullable: false),
+                    break_until = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    timeout_until = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    timeout_cause = table.Column<ChatTimeoutCause>(type: "jsonb", nullable: true),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_sn_chat_member", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_sn_chat_member_sn_chat_room_chat_room_id",
+                        column: x => x.chat_room_id,
+                        principalTable: "sn_chat_room",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "ix_realms_slug",
+                table: "realms",
+                column: "slug",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ix_sn_chat_member_chat_room_id",
+                table: "sn_chat_member",
+                column: "chat_room_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_sn_chat_room_sn_realm_id",
+                table: "sn_chat_room",
+                column: "sn_realm_id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "realm_members");
+
+            migrationBuilder.DropTable(
+                name: "sn_chat_member");
+
+            migrationBuilder.DropTable(
+                name: "sn_chat_room");
+
+            migrationBuilder.DropTable(
+                name: "realms");
+        }
+    }
+}

DysonNetwork.Pass/Migrations/AppDatabaseModelSnapshot.cs

@@ -954,6 +954,159 @@ namespace DysonNetwork.Pass.Migrations
                     b.ToTable("auth_sessions", (string)null);
                 });
 
+            modelBuilder.Entity("DysonNetwork.Shared.Models.SnChatMember", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("account_id");
+
+                    b.Property<Instant?>("BreakUntil")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("break_until");
+
+                    b.Property<Guid>("ChatRoomId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("chat_room_id");
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<bool>("IsBot")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_bot");
+
+                    b.Property<Instant?>("JoinedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("joined_at");
+
+                    b.Property<Instant?>("LastReadAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_read_at");
+
+                    b.Property<Instant?>("LeaveAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("leave_at");
+
+                    b.Property<string>("Nick")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)")
+                        .HasColumnName("nick");
+
+                    b.Property<int>("Notify")
+                        .HasColumnType("integer")
+                        .HasColumnName("notify");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer")
+                        .HasColumnName("role");
+
+                    b.Property<ChatTimeoutCause>("TimeoutCause")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("timeout_cause");
+
+                    b.Property<Instant?>("TimeoutUntil")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("timeout_until");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("Id")
+                        .HasName("pk_sn_chat_member");
+
+                    b.HasIndex("ChatRoomId")
+                        .HasDatabaseName("ix_sn_chat_member_chat_room_id");
+
+                    b.ToTable("sn_chat_member", (string)null);
+                });
+
+            modelBuilder.Entity("DysonNetwork.Shared.Models.SnChatRoom", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<SnCloudFileReferenceObject>("Background")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("background");
+
+                    b.Property<string>("BackgroundId")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)")
+                        .HasColumnName("background_id");
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("description");
+
+                    b.Property<bool>("IsCommunity")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_community");
+
+                    b.Property<bool>("IsPublic")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_public");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)")
+                        .HasColumnName("name");
+
+                    b.Property<SnCloudFileReferenceObject>("Picture")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("picture");
+
+                    b.Property<string>("PictureId")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)")
+                        .HasColumnName("picture_id");
+
+                    b.Property<Guid?>("RealmId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("realm_id");
+
+                    b.Property<Guid?>("SnRealmId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("sn_realm_id");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer")
+                        .HasColumnName("type");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("Id")
+                        .HasName("pk_sn_chat_room");
+
+                    b.HasIndex("SnRealmId")
+                        .HasDatabaseName("ix_sn_chat_room_sn_realm_id");
+
+                    b.ToTable("sn_chat_room", (string)null);
+                });
+
             modelBuilder.Entity("DysonNetwork.Shared.Models.SnCheckInResult", b =>
                 {
                     b.Property<Guid>("Id")
@@ -1252,6 +1405,127 @@ namespace DysonNetwork.Pass.Migrations
                     b.ToTable("permission_nodes", (string)null);
                 });
 
+            modelBuilder.Entity("DysonNetwork.Shared.Models.SnRealm", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("account_id");
+
+                    b.Property<SnCloudFileReferenceObject>("Background")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("background");
+
+                    b.Property<string>("BackgroundId")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)")
+                        .HasColumnName("background_id");
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("description");
+
+                    b.Property<bool>("IsCommunity")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_community");
+
+                    b.Property<bool>("IsPublic")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_public");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)")
+                        .HasColumnName("name");
+
+                    b.Property<SnCloudFileReferenceObject>("Picture")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("picture");
+
+                    b.Property<string>("PictureId")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)")
+                        .HasColumnName("picture_id");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)")
+                        .HasColumnName("slug");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.Property<SnVerificationMark>("Verification")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("verification");
+
+                    b.HasKey("Id")
+                        .HasName("pk_realms");
+
+                    b.HasIndex("Slug")
+                        .IsUnique()
+                        .HasDatabaseName("ix_realms_slug");
+
+                    b.ToTable("realms", (string)null);
+                });
+
+            modelBuilder.Entity("DysonNetwork.Shared.Models.SnRealmMember", b =>
+                {
+                    b.Property<Guid>("RealmId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("realm_id");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("account_id");
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Instant?>("JoinedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("joined_at");
+
+                    b.Property<Instant?>("LeaveAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("leave_at");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer")
+                        .HasColumnName("role");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("RealmId", "AccountId")
+                        .HasName("pk_realm_members");
+
+                    b.ToTable("realm_members", (string)null);
+                });
+
             modelBuilder.Entity("DysonNetwork.Shared.Models.SnSocialCreditRecord", b =>
                 {
                     b.Property<Guid>("Id")
@@ -2089,6 +2363,26 @@ namespace DysonNetwork.Pass.Migrations
                     b.Navigation("Challenge");
                 });
 
+            modelBuilder.Entity("DysonNetwork.Shared.Models.SnChatMember", b =>
+                {
+                    b.HasOne("DysonNetwork.Shared.Models.SnChatRoom", "ChatRoom")
+                        .WithMany("Members")
+                        .HasForeignKey("ChatRoomId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_sn_chat_member_sn_chat_room_chat_room_id");
+
+                    b.Navigation("ChatRoom");
+                });
+
+            modelBuilder.Entity("DysonNetwork.Shared.Models.SnChatRoom", b =>
+                {
+                    b.HasOne("DysonNetwork.Shared.Models.SnRealm", null)
+                        .WithMany("ChatRooms")
+                        .HasForeignKey("SnRealmId")
+                        .HasConstraintName("fk_sn_chat_room_realms_sn_realm_id");
+                });
+
             modelBuilder.Entity("DysonNetwork.Shared.Models.SnCheckInResult", b =>
                 {
                     b.HasOne("DysonNetwork.Shared.Models.SnAccount", "Account")
@@ -2145,6 +2439,18 @@ namespace DysonNetwork.Pass.Migrations
                     b.Navigation("Group");
                 });
 
+            modelBuilder.Entity("DysonNetwork.Shared.Models.SnRealmMember", b =>
+                {
+                    b.HasOne("DysonNetwork.Shared.Models.SnRealm", "Realm")
+                        .WithMany("Members")
+                        .HasForeignKey("RealmId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_realm_members_realms_realm_id");
+
+                    b.Navigation("Realm");
+                });
+
             modelBuilder.Entity("DysonNetwork.Shared.Models.SnSocialCreditRecord", b =>
                 {
                     b.HasOne("DysonNetwork.Shared.Models.SnAccount", "Account")
@@ -2329,6 +2635,11 @@ namespace DysonNetwork.Pass.Migrations
                     b.Navigation("Sessions");
                 });
 
+            modelBuilder.Entity("DysonNetwork.Shared.Models.SnChatRoom", b =>
+                {
+                    b.Navigation("Members");
+                });
+
             modelBuilder.Entity("DysonNetwork.Shared.Models.SnPermissionGroup", b =>
                 {
                     b.Navigation("Members");
@@ -2336,6 +2647,13 @@ namespace DysonNetwork.Pass.Migrations
                     b.Navigation("Nodes");
                 });
 
+            modelBuilder.Entity("DysonNetwork.Shared.Models.SnRealm", b =>
+                {
+                    b.Navigation("ChatRooms");
+
+                    b.Navigation("Members");
+                });
+
             modelBuilder.Entity("DysonNetwork.Shared.Models.SnWallet", b =>
                 {
                     b.Navigation("Pockets");

DysonNetwork.Pass/Realm/RealmController.cs

@@ -0,0 +1,779 @@
+using System.ComponentModel.DataAnnotations;
+using DysonNetwork.Shared.Models;
+using DysonNetwork.Shared.Proto;
+using DysonNetwork.Shared.Registry;
+using Google.Protobuf.WellKnownTypes;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using NodaTime;
+
+namespace DysonNetwork.Pass.Realm;
+
+[ApiController]
+[Route("/api/realms")]
+public class RealmController(
+    AppDatabase db,
+    RealmService rs,
+    FileService.FileServiceClient files,
+    FileReferenceService.FileReferenceServiceClient fileRefs,
+    ActionLogService.ActionLogServiceClient als,
+    AccountService.AccountServiceClient accounts,
+    RemoteAccountService remoteAccountsHelper
+) : Controller
+{
+    [HttpGet("{slug}")]
+    public async Task<ActionResult<SnRealm>> GetRealm(string slug)
+    {
+        var realm = await db.Realms
+            .Where(e => e.Slug == slug)
+            .FirstOrDefaultAsync();
+        if (realm is null) return NotFound();
+
+        return Ok(realm);
+    }
+
+    [HttpGet]
+    [Authorize]
+    public async Task<ActionResult<List<SnRealm>>> ListJoinedRealms()
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+        var accountId = Guid.Parse(currentUser.Id);
+
+        var members = await db.RealmMembers
+            .Where(m => m.AccountId == accountId)
+            .Where(m => m.JoinedAt != null && m.LeaveAt == null)
+            .Include(e => e.Realm)
+            .Select(m => m.Realm)
+            .ToListAsync();
+
+        return members.ToList();
+    }
+
+    [HttpGet("invites")]
+    [Authorize]
+    public async Task<ActionResult<List<SnRealmMember>>> ListInvites()
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+        var accountId = Guid.Parse(currentUser.Id);
+
+        var members = await db.RealmMembers
+            .Where(m => m.AccountId == accountId)
+            .Where(m => m.JoinedAt == null && m.LeaveAt == null)
+            .Include(e => e.Realm)
+            .ToListAsync();
+
+        return await rs.LoadMemberAccounts(members);
+    }
+
+    public class RealmMemberRequest
+    {
+        [Required] public Guid RelatedUserId { get; set; }
+        [Required] public int Role { get; set; }
+    }
+
+    [HttpPost("invites/{slug}")]
+    [Authorize]
+    public async Task<ActionResult<SnRealmMember>> InviteMember(string slug,
+        [FromBody] RealmMemberRequest request)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+        var accountId = Guid.Parse(currentUser.Id);
+
+        var relatedUser =
+            await accounts.GetAccountAsync(new GetAccountRequest { Id = request.RelatedUserId.ToString() });
+        if (relatedUser == null) return BadRequest("Related user was not found");
+
+        var hasBlocked = await accounts.HasRelationshipAsync(new GetRelationshipRequest()
+        {
+            AccountId = currentUser.Id,
+            RelatedId = request.RelatedUserId.ToString(),
+            Status = -100
+        });
+        if (hasBlocked?.Value ?? false)
+            return StatusCode(403, "You cannot invite a user that blocked you.");
+
+        var realm = await db.Realms
+            .Where(p => p.Slug == slug)
+            .FirstOrDefaultAsync();
+        if (realm is null) return NotFound();
+
+        if (!await rs.IsMemberWithRole(realm.Id, accountId, request.Role))
+            return StatusCode(403, "You cannot invite member has higher permission than yours.");
+
+        var existingMember = await db.RealmMembers
+            .Where(m => m.AccountId == Guid.Parse(relatedUser.Id))
+            .Where(m => m.RealmId == realm.Id)
+            .FirstOrDefaultAsync();
+        if (existingMember != null)
+        {
+            if (existingMember.LeaveAt == null)
+                return BadRequest("This user already in the realm cannot be invited again.");
+
+            existingMember.LeaveAt = null;
+            existingMember.JoinedAt = null;
+            db.RealmMembers.Update(existingMember);
+            await db.SaveChangesAsync();
+            await rs.SendInviteNotify(existingMember);
+
+            _ = als.CreateActionLogAsync(new CreateActionLogRequest
+            {
+                Action = "realms.members.invite",
+                Meta =
+            {
+                { "realm_id", Value.ForString(realm.Id.ToString()) },
+                { "account_id", Value.ForString(existingMember.AccountId.ToString()) },
+                { "role", Value.ForNumber(request.Role) }
+            },
+                AccountId = currentUser.Id,
+                UserAgent = Request.Headers.UserAgent.ToString(),
+                IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+            });
+
+            return Ok(existingMember);
+        }
+
+        var member = new SnRealmMember
+        {
+            AccountId = Guid.Parse(relatedUser.Id),
+            RealmId = realm.Id,
+            Role = request.Role,
+        };
+
+        db.RealmMembers.Add(member);
+        await db.SaveChangesAsync();
+
+        _ = als.CreateActionLogAsync(new CreateActionLogRequest
+        {
+            Action = "realms.members.invite",
+            Meta =
+            {
+                { "realm_id", Value.ForString(realm.Id.ToString()) },
+                { "account_id", Value.ForString(member.AccountId.ToString()) },
+                { "role", Value.ForNumber(request.Role) }
+            },
+            AccountId = currentUser.Id,
+            UserAgent = Request.Headers.UserAgent.ToString(),
+            IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+        });
+
+        member.AccountId = Guid.Parse(relatedUser.Id);
+        member.Realm = realm;
+        await rs.SendInviteNotify(member);
+
+        return Ok(member);
+    }
+
+    [HttpPost("invites/{slug}/accept")]
+    [Authorize]
+    public async Task<ActionResult<SnRealm>> AcceptMemberInvite(string slug)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+        var accountId = Guid.Parse(currentUser.Id);
+
+        var member = await db.RealmMembers
+            .Where(m => m.AccountId == accountId)
+            .Where(m => m.Realm.Slug == slug)
+            .Where(m => m.JoinedAt == null)
+            .FirstOrDefaultAsync();
+        if (member is null) return NotFound();
+
+        member.JoinedAt = NodaTime.Instant.FromDateTimeUtc(DateTime.UtcNow);
+        db.Update(member);
+        await db.SaveChangesAsync();
+
+        _ = als.CreateActionLogAsync(new CreateActionLogRequest
+        {
+            Action = "realms.members.join",
+            Meta =
+            {
+                { "realm_id", Value.ForString(member.RealmId.ToString()) },
+                { "account_id", Value.ForString(member.AccountId.ToString()) }
+            },
+            AccountId = currentUser.Id,
+            UserAgent = Request.Headers.UserAgent.ToString(),
+            IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+        });
+
+        return Ok(member);
+    }
+
+    [HttpPost("invites/{slug}/decline")]
+    [Authorize]
+    public async Task<ActionResult> DeclineMemberInvite(string slug)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+        var accountId = Guid.Parse(currentUser.Id);
+
+        var member = await db.RealmMembers
+            .Where(m => m.AccountId == accountId)
+            .Where(m => m.Realm.Slug == slug)
+            .Where(m => m.JoinedAt == null)
+            .FirstOrDefaultAsync();
+        if (member is null) return NotFound();
+
+        member.LeaveAt = SystemClock.Instance.GetCurrentInstant();
+        await db.SaveChangesAsync();
+
+        _ = als.CreateActionLogAsync(new CreateActionLogRequest
+        {
+            Action = "realms.members.decline_invite",
+            Meta =
+            {
+                { "realm_id", Value.ForString(member.RealmId.ToString()) },
+                { "account_id", Value.ForString(member.AccountId.ToString()) },
+                { "decliner_id", Value.ForString(currentUser.Id) }
+            },
+            AccountId = currentUser.Id,
+            UserAgent = Request.Headers.UserAgent.ToString(),
+            IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+        });
+
+        return NoContent();
+    }
+
+
+    [HttpGet("{slug}/members")]
+    public async Task<ActionResult<List<SnRealmMember>>> ListMembers(
+        string slug,
+        [FromQuery] int offset = 0,
+        [FromQuery] int take = 20,
+        [FromQuery] bool withStatus = false
+    )
+    {
+        var realm = await db.Realms
+            .Where(r => r.Slug == slug)
+            .FirstOrDefaultAsync();
+        if (realm is null) return NotFound();
+
+        if (!realm.IsPublic)
+        {
+            if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+            if (!await rs.IsMemberWithRole(realm.Id, Guid.Parse(currentUser.Id), RealmMemberRole.Normal))
+                return StatusCode(403, "You must be a member to view this realm's members.");
+        }
+
+        var query = db.RealmMembers
+            .Where(m => m.RealmId == realm.Id)
+            .Where(m => m.JoinedAt != null && m.LeaveAt == null);
+
+        if (withStatus)
+        {
+            var members = await query
+                .OrderBy(m => m.JoinedAt)
+                .ToListAsync();
+
+            var memberStatuses = await remoteAccountsHelper.GetAccountStatusBatch(
+                members.Select(m => m.AccountId).ToList()
+            );
+
+            members = members
+                .Select(m =>
+                {
+                    m.Status = memberStatuses.TryGetValue(m.AccountId, out var s) ? s : null;
+                    return m;
+                })
+                .OrderByDescending(m => m.Status?.IsOnline ?? false)
+                .ToList();
+
+            var total = members.Count;
+            Response.Headers.Append("X-Total", total.ToString());
+
+            var result = members.Skip(offset).Take(take).ToList();
+
+            members = await rs.LoadMemberAccounts(result);
+
+            return Ok(members.Where(m => m.Account is not null).ToList());
+        }
+        else
+        {
+            var total = await query.CountAsync();
+            Response.Headers["X-Total"] = total.ToString();
+
+            var members = await query
+                .OrderBy(m => m.CreatedAt)
+                .Skip(offset)
+                .Take(take)
+                .ToListAsync();
+            members = await rs.LoadMemberAccounts(members);
+
+            return Ok(members.Where(m => m.Account is not null).ToList());
+        }
+    }
+
+
+    [HttpGet("{slug}/members/me")]
+    [Authorize]
+    public async Task<ActionResult<SnRealmMember>> GetCurrentIdentity(string slug)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+        var accountId = Guid.Parse(currentUser.Id);
+
+        var member = await db.RealmMembers
+            .Where(m => m.AccountId == accountId)
+            .Where(m => m.Realm.Slug == slug)
+            .Where(m => m.JoinedAt != null && m.LeaveAt == null)
+            .FirstOrDefaultAsync();
+
+        if (member is null) return NotFound();
+        return Ok(await rs.LoadMemberAccount(member));
+    }
+
+    [HttpDelete("{slug}/members/me")]
+    [Authorize]
+    public async Task<ActionResult> LeaveRealm(string slug)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+        var accountId = Guid.Parse(currentUser.Id);
+
+        var member = await db.RealmMembers
+            .Where(m => m.AccountId == accountId)
+            .Where(m => m.Realm.Slug == slug)
+            .Where(m => m.JoinedAt != null && m.LeaveAt == null)
+            .FirstOrDefaultAsync();
+        if (member is null) return NotFound();
+
+        if (member.Role == RealmMemberRole.Owner)
+            return StatusCode(403, "Owner cannot leave their own realm.");
+
+        member.LeaveAt = SystemClock.Instance.GetCurrentInstant();
+        await db.SaveChangesAsync();
+
+        _ = als.CreateActionLogAsync(new CreateActionLogRequest
+        {
+            Action = "realms.members.leave",
+            Meta =
+            {
+                { "realm_id", Value.ForString(member.RealmId.ToString()) },
+                { "account_id", Value.ForString(member.AccountId.ToString()) },
+                { "leaver_id", Value.ForString(currentUser.Id) }
+            },
+            AccountId = currentUser.Id,
+            UserAgent = Request.Headers.UserAgent.ToString(),
+            IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+        });
+
+        return NoContent();
+    }
+
+    public class RealmRequest
+    {
+        [MaxLength(1024)] public string? Slug { get; set; }
+        [MaxLength(1024)] public string? Name { get; set; }
+        [MaxLength(4096)] public string? Description { get; set; }
+        public string? PictureId { get; set; }
+        public string? BackgroundId { get; set; }
+        public bool? IsCommunity { get; set; }
+        public bool? IsPublic { get; set; }
+    }
+
+    [HttpPost]
+    [Authorize]
+    public async Task<ActionResult<SnRealm>> CreateRealm(RealmRequest request)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+        if (string.IsNullOrWhiteSpace(request.Name)) return BadRequest("You cannot create a realm without a name.");
+        if (string.IsNullOrWhiteSpace(request.Slug)) return BadRequest("You cannot create a realm without a slug.");
+
+        var slugExists = await db.Realms.AnyAsync(r => r.Slug == request.Slug);
+        if (slugExists) return BadRequest("Realm with this slug already exists.");
+
+        var realm = new SnRealm
+        {
+            Name = request.Name!,
+            Slug = request.Slug!,
+            Description = request.Description!,
+            AccountId = Guid.Parse(currentUser.Id),
+            IsCommunity = request.IsCommunity ?? false,
+            IsPublic = request.IsPublic ?? false,
+            Members = new List<SnRealmMember>
+            {
+                new()
+                {
+                    Role = RealmMemberRole.Owner,
+                    AccountId = Guid.Parse(currentUser.Id),
+                    JoinedAt = NodaTime.Instant.FromDateTimeUtc(DateTime.UtcNow)
+                }
+            }
+        };
+
+        if (request.PictureId is not null)
+        {
+            var pictureResult = await files.GetFileAsync(new GetFileRequest { Id = request.PictureId });
+            if (pictureResult is null) return BadRequest("Invalid picture id, unable to find the file on cloud.");
+            realm.Picture = SnCloudFileReferenceObject.FromProtoValue(pictureResult);
+        }
+
+        if (request.BackgroundId is not null)
+        {
+            var backgroundResult = await files.GetFileAsync(new GetFileRequest { Id = request.BackgroundId });
+            if (backgroundResult is null) return BadRequest("Invalid background id, unable to find the file on cloud.");
+            realm.Background = SnCloudFileReferenceObject.FromProtoValue(backgroundResult);
+        }
+
+        db.Realms.Add(realm);
+        await db.SaveChangesAsync();
+
+        _ = als.CreateActionLogAsync(new CreateActionLogRequest
+        {
+            Action = "realms.create",
+            Meta =
+            {
+                { "realm_id", Value.ForString(realm.Id.ToString()) },
+                { "name", Value.ForString(realm.Name) },
+                { "slug", Value.ForString(realm.Slug) },
+                { "is_community", Value.ForBool(realm.IsCommunity) },
+                { "is_public", Value.ForBool(realm.IsPublic) }
+            },
+            AccountId = currentUser.Id,
+            UserAgent = Request.Headers.UserAgent.ToString(),
+            IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+        });
+
+        var realmResourceId = $"realm:{realm.Id}";
+
+        if (realm.Picture is not null)
+        {
+            await fileRefs.CreateReferenceAsync(new CreateReferenceRequest
+            {
+                FileId = realm.Picture.Id,
+                Usage = "realm.picture",
+                ResourceId = realmResourceId
+            });
+        }
+
+        if (realm.Background is not null)
+        {
+            await fileRefs.CreateReferenceAsync(new CreateReferenceRequest
+            {
+                FileId = realm.Background.Id,
+                Usage = "realm.background",
+                ResourceId = realmResourceId
+            });
+        }
+
+        return Ok(realm);
+    }
+
+    [HttpPatch("{slug}")]
+    [Authorize]
+    public async Task<ActionResult<SnRealm>> Update(string slug, [FromBody] RealmRequest request)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+
+        var realm = await db.Realms
+            .Where(r => r.Slug == slug)
+            .FirstOrDefaultAsync();
+        if (realm is null) return NotFound();
+
+        var accountId = Guid.Parse(currentUser.Id);
+        var member = await db.RealmMembers
+            .Where(m => m.AccountId == accountId && m.RealmId == realm.Id && m.JoinedAt != null && m.LeaveAt == null)
+            .FirstOrDefaultAsync();
+        if (member is null || member.Role < RealmMemberRole.Moderator)
+            return StatusCode(403, "You do not have permission to update this realm.");
+
+        if (request.Slug is not null && request.Slug != realm.Slug)
+        {
+            var slugExists = await db.Realms.AnyAsync(r => r.Slug == request.Slug);
+            if (slugExists) return BadRequest("Realm with this slug already exists.");
+            realm.Slug = request.Slug;
+        }
+
+        if (request.Name is not null)
+            realm.Name = request.Name;
+        if (request.Description is not null)
+            realm.Description = request.Description;
+        if (request.IsCommunity is not null)
+            realm.IsCommunity = request.IsCommunity.Value;
+        if (request.IsPublic is not null)
+            realm.IsPublic = request.IsPublic.Value;
+
+        if (request.PictureId is not null)
+        {
+            var pictureResult = await files.GetFileAsync(new GetFileRequest { Id = request.PictureId });
+            if (pictureResult is null) return BadRequest("Invalid picture id, unable to find the file on cloud.");
+
+            // Remove old references for the realm picture
+            if (realm.Picture is not null)
+            {
+                await fileRefs.DeleteResourceReferencesAsync(new DeleteResourceReferencesRequest
+                {
+                    ResourceId = realm.ResourceIdentifier
+                });
+            }
+
+            realm.Picture = SnCloudFileReferenceObject.FromProtoValue(pictureResult);
+
+            // Create a new reference
+            await fileRefs.CreateReferenceAsync(new CreateReferenceRequest
+            {
+                FileId = realm.Picture.Id,
+                Usage = "realm.picture",
+                ResourceId = realm.ResourceIdentifier
+            });
+        }
+
+        if (request.BackgroundId is not null)
+        {
+            var backgroundResult = await files.GetFileAsync(new GetFileRequest { Id = request.BackgroundId });
+            if (backgroundResult is null) return BadRequest("Invalid background id, unable to find the file on cloud.");
+
+            // Remove old references for the realm background
+            if (realm.Background is not null)
+            {
+                await fileRefs.DeleteResourceReferencesAsync(new DeleteResourceReferencesRequest
+                {
+                    ResourceId = realm.ResourceIdentifier
+                });
+            }
+
+            realm.Background = SnCloudFileReferenceObject.FromProtoValue(backgroundResult);
+
+            // Create a new reference
+            await fileRefs.CreateReferenceAsync(new CreateReferenceRequest
+            {
+                FileId = realm.Background.Id,
+                Usage = "realm.background",
+                ResourceId = realm.ResourceIdentifier
+            });
+        }
+
+        db.Realms.Update(realm);
+        await db.SaveChangesAsync();
+
+        _ = als.CreateActionLogAsync(new CreateActionLogRequest
+        {
+            Action = "realms.update",
+            Meta =
+            {
+                { "realm_id", Value.ForString(realm.Id.ToString()) },
+                { "name_updated", Value.ForBool(request.Name != null) },
+                { "slug_updated", Value.ForBool(request.Slug != null) },
+                { "description_updated", Value.ForBool(request.Description != null) },
+                { "picture_updated", Value.ForBool(request.PictureId != null) },
+                { "background_updated", Value.ForBool(request.BackgroundId != null) },
+                { "is_community_updated", Value.ForBool(request.IsCommunity != null) },
+                { "is_public_updated", Value.ForBool(request.IsPublic != null) }
+            },
+            AccountId = currentUser.Id,
+            UserAgent = Request.Headers.UserAgent.ToString(),
+            IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+        });
+
+        return Ok(realm);
+    }
+
+    [HttpPost("{slug}/members/me")]
+    [Authorize]
+    public async Task<ActionResult<SnRealmMember>> JoinRealm(string slug)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+
+        var realm = await db.Realms
+            .Where(r => r.Slug == slug)
+            .FirstOrDefaultAsync();
+        if (realm is null) return NotFound();
+
+        if (!realm.IsCommunity)
+            return StatusCode(403, "Only community realms can be joined without invitation.");
+
+        var existingMember = await db.RealmMembers
+            .Where(m => m.AccountId == Guid.Parse(currentUser.Id) && m.RealmId == realm.Id)
+            .FirstOrDefaultAsync();
+        if (existingMember is not null)
+        {
+            if (existingMember.LeaveAt == null)
+                return BadRequest("You are already a member of this realm.");
+
+            existingMember.LeaveAt = null;
+            existingMember.JoinedAt = SystemClock.Instance.GetCurrentInstant();
+
+            db.Update(existingMember);
+            await db.SaveChangesAsync();
+
+            _ = als.CreateActionLogAsync(new CreateActionLogRequest
+            {
+                Action = "realms.members.join",
+                Meta =
+            {
+                { "realm_id", Value.ForString(realm.Id.ToString()) },
+                { "account_id", Value.ForString(currentUser.Id) },
+                { "is_community", Value.ForBool(realm.IsCommunity) }
+            },
+                AccountId = currentUser.Id,
+                UserAgent = Request.Headers.UserAgent.ToString(),
+                IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+            });
+
+            return Ok(existingMember);
+        }
+
+        var member = new SnRealmMember
+        {
+            AccountId = Guid.Parse(currentUser.Id),
+            RealmId = realm.Id,
+            Role = RealmMemberRole.Normal,
+            JoinedAt = NodaTime.Instant.FromDateTimeUtc(DateTime.UtcNow)
+        };
+
+        db.RealmMembers.Add(member);
+        await db.SaveChangesAsync();
+
+        _ = als.CreateActionLogAsync(new CreateActionLogRequest
+        {
+            Action = "realms.members.join",
+            Meta =
+            {
+                { "realm_id", Value.ForString(realm.Id.ToString()) },
+                { "account_id", Value.ForString(currentUser.Id) },
+                { "is_community", Value.ForBool(realm.IsCommunity) }
+            },
+            AccountId = currentUser.Id,
+            UserAgent = Request.Headers.UserAgent.ToString(),
+            IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+        });
+
+        return Ok(member);
+    }
+
+    [HttpDelete("{slug}/members/{memberId:guid}")]
+    [Authorize]
+    public async Task<ActionResult> RemoveMember(string slug, Guid memberId)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+
+        var realm = await db.Realms
+            .Where(r => r.Slug == slug)
+            .FirstOrDefaultAsync();
+        if (realm is null) return NotFound();
+
+        var member = await db.RealmMembers
+            .Where(m => m.AccountId == memberId && m.RealmId == realm.Id && m.JoinedAt != null && m.LeaveAt == null)
+            .FirstOrDefaultAsync();
+        if (member is null) return NotFound();
+
+        if (!await rs.IsMemberWithRole(realm.Id, Guid.Parse(currentUser.Id), RealmMemberRole.Moderator, member.Role))
+            return StatusCode(403, "You do not have permission to remove members from this realm.");
+
+        member.LeaveAt = SystemClock.Instance.GetCurrentInstant();
+        await db.SaveChangesAsync();
+
+        _ = als.CreateActionLogAsync(new CreateActionLogRequest
+        {
+            Action = "realms.members.kick",
+            Meta =
+            {
+                { "realm_id", Value.ForString(realm.Id.ToString()) },
+                { "account_id", Value.ForString(memberId.ToString()) },
+                { "kicker_id", Value.ForString(currentUser.Id) }
+            },
+            AccountId = currentUser.Id,
+            UserAgent = Request.Headers.UserAgent.ToString(),
+            IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+        });
+
+        return NoContent();
+    }
+
+    [HttpPatch("{slug}/members/{memberId:guid}/role")]
+    [Authorize]
+    public async Task<ActionResult<SnRealmMember>> UpdateMemberRole(string slug, Guid memberId, [FromBody] int newRole)
+    {
+        if (newRole >= RealmMemberRole.Owner) return BadRequest("Unable to set realm member to owner or greater role.");
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+
+        var realm = await db.Realms
+            .Where(r => r.Slug == slug)
+            .FirstOrDefaultAsync();
+        if (realm is null) return NotFound();
+
+        var member = await db.RealmMembers
+            .Where(m => m.AccountId == memberId && m.RealmId == realm.Id && m.JoinedAt != null && m.LeaveAt == null)
+            .FirstOrDefaultAsync();
+        if (member is null) return NotFound();
+
+        if (!await rs.IsMemberWithRole(realm.Id, Guid.Parse(currentUser.Id), RealmMemberRole.Moderator, member.Role,
+                newRole))
+            return StatusCode(403, "You do not have permission to update member roles in this realm.");
+
+        member.Role = newRole;
+        db.RealmMembers.Update(member);
+        await db.SaveChangesAsync();
+
+        _ = als.CreateActionLogAsync(new CreateActionLogRequest
+        {
+            Action = "realms.members.role_update",
+            Meta =
+            {
+                { "realm_id", Value.ForString(realm.Id.ToString()) },
+                { "account_id", Value.ForString(memberId.ToString()) },
+                { "new_role", Value.ForNumber(newRole) },
+                { "updater_id", Value.ForString(currentUser.Id) }
+            },
+            AccountId = currentUser.Id,
+            UserAgent = Request.Headers.UserAgent.ToString(),
+            IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+        });
+
+        return Ok(member);
+    }
+
+    [HttpDelete("{slug}")]
+    [Authorize]
+    public async Task<ActionResult> Delete(string slug)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Shared.Proto.Account currentUser) return Unauthorized();
+
+        var transaction = await db.Database.BeginTransactionAsync();
+
+        var realm = await db.Realms
+            .Where(r => r.Slug == slug)
+            .FirstOrDefaultAsync();
+        if (realm is null) return NotFound();
+
+        if (!await rs.IsMemberWithRole(realm.Id, Guid.Parse(currentUser.Id), RealmMemberRole.Owner))
+            return StatusCode(403, "Only the owner can delete this realm.");
+
+        try
+        {
+            db.Realms.Remove(realm);
+            await db.SaveChangesAsync();
+
+            var now = SystemClock.Instance.GetCurrentInstant();
+            await db.RealmMembers
+                .Where(m => m.RealmId == realm.Id)
+                .ExecuteUpdateAsync(m => m.SetProperty(m => m.DeletedAt, now));
+            await db.SaveChangesAsync();
+            await transaction.CommitAsync();
+        }
+        catch (Exception)
+        {
+            await transaction.RollbackAsync();
+            throw;
+        }
+
+        _ = als.CreateActionLogAsync(new CreateActionLogRequest
+        {
+            Action = "realms.delete",
+            Meta =
+            {
+                { "realm_id", Value.ForString(realm.Id.ToString()) },
+                { "realm_name", Value.ForString(realm.Name) },
+                { "realm_slug", Value.ForString(realm.Slug) }
+            },
+            AccountId = currentUser.Id,
+            UserAgent = Request.Headers.UserAgent.ToString(),
+            IpAddress = Request.HttpContext.Connection.RemoteIpAddress?.ToString() ?? ""
+        });
+
+        // Delete all file references for this realm
+        var realmResourceId = $"realm:{realm.Id}";
+        await fileRefs.DeleteResourceReferencesAsync(new DeleteResourceReferencesRequest
+        {
+            ResourceId = realmResourceId
+        });
+
+        return NoContent();
+    }
+}

DysonNetwork.Pass/Realm/RealmService.cs

@@ -0,0 +1,104 @@
+using DysonNetwork.Pass.Localization;
+using DysonNetwork.Shared;
+using DysonNetwork.Shared.Cache;
+using DysonNetwork.Shared.Models;
+using DysonNetwork.Shared.Proto;
+using DysonNetwork.Shared.Registry;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Localization;
+
+namespace DysonNetwork.Pass.Realm;
+
+public class RealmService(
+    AppDatabase db,
+    RingService.RingServiceClient pusher,
+    IStringLocalizer<NotificationResource> localizer,
+    ICacheService cache
+)
+{
+    private const string CacheKeyPrefix = "account:realms:";
+    
+    public async Task<List<Guid>> GetUserRealms(Guid accountId)
+    {
+        var cacheKey = $"{CacheKeyPrefix}{accountId}";
+        var (found, cachedRealms) = await cache.GetAsyncWithStatus<List<Guid>>(cacheKey);
+        if (found && cachedRealms != null)
+            return cachedRealms;
+
+        var realms = await db.RealmMembers
+            .Include(m => m.Realm)
+            .Where(m => m.AccountId == accountId)
+            .Where(m => m.JoinedAt != null && m.LeaveAt == null)
+            .Select(m => m.Realm!.Id)
+            .ToListAsync();
+
+        // Cache the result for 5 minutes
+        await cache.SetAsync(cacheKey, realms, TimeSpan.FromMinutes(5));
+        
+        return realms;
+    }
+    
+    public async Task SendInviteNotify(SnRealmMember member)
+    {
+        var account = await db.Accounts
+            .Include(a => a.Profile)
+            .FirstOrDefaultAsync(a => a.Id == member.AccountId);
+        
+        if (account == null) throw new InvalidOperationException("Account not found");
+        
+        CultureService.SetCultureInfo(account.Language);
+
+        await pusher.SendPushNotificationToUserAsync(
+            new SendPushNotificationToUserRequest
+            {
+                UserId = account.Id.ToString(),
+                Notification = new PushNotification
+                {
+                    Topic = "invites.realms",
+                    Title = localizer["RealmInviteTitle"],
+                    Body = localizer["RealmInviteBody", member.Realm.Name],
+                    ActionUri = "/realms",
+                    IsSavable = true
+                }
+            }
+        );
+    }
+
+    public async Task<bool> IsMemberWithRole(Guid realmId, Guid accountId, params int[] requiredRoles)
+    {
+        if (requiredRoles.Length == 0)
+            return false;
+
+        var maxRequiredRole = requiredRoles.Max();
+        var member = await db.RealmMembers
+            .Where(m => m.RealmId == realmId && m.AccountId == accountId && m.JoinedAt != null && m.LeaveAt == null)
+            .FirstOrDefaultAsync();
+        return member?.Role >= maxRequiredRole;
+    }
+
+    public async Task<SnRealmMember> LoadMemberAccount(SnRealmMember member)
+    {
+        var account = await db.Accounts
+            .Include(a => a.Profile)
+            .FirstOrDefaultAsync(a => a.Id == member.AccountId);
+        if (account != null)
+            member.Account = account;
+        return member;
+    }
+
+    public async Task<List<SnRealmMember>> LoadMemberAccounts(ICollection<SnRealmMember> members)
+    {
+        var accountIds = members.Select(m => m.AccountId).ToList();
+        var accountsDict = await db.Accounts
+            .Include(a => a.Profile)
+            .Where(a => accountIds.Contains(a.Id))
+            .ToDictionaryAsync(a => a.Id, a => a);
+
+        return members.Select(m =>
+        {
+            if (accountsDict.TryGetValue(m.AccountId, out var account))
+                m.Account = account;
+            return m;
+        }).ToList();
+    }
+}

DysonNetwork.Pass/Realm/RealmServiceGrpc.cs

@@ -0,0 +1,140 @@
+using DysonNetwork.Shared.Proto;
+using Google.Protobuf.WellKnownTypes;
+using Grpc.Core;
+using Microsoft.EntityFrameworkCore;
+using DysonNetwork.Pass.Localization;
+using DysonNetwork.Shared;
+using DysonNetwork.Shared.Cache;
+using Microsoft.Extensions.Localization;
+
+namespace DysonNetwork.Pass.Realm;
+
+public class RealmServiceGrpc(
+    AppDatabase db,
+    RingService.RingServiceClient pusher,
+    IStringLocalizer<NotificationResource> localizer,
+    ICacheService cache
+)
+    : Shared.Proto.RealmService.RealmServiceBase
+{
+    private const string CacheKeyPrefix = "account:realms:";
+
+    public override async Task<Shared.Proto.Realm> GetRealm(GetRealmRequest request, ServerCallContext context)
+    {
+        var realm = request.QueryCase switch
+        {
+            GetRealmRequest.QueryOneofCase.Id when !string.IsNullOrWhiteSpace(request.Id) => await db.Realms.FindAsync(
+                Guid.Parse(request.Id)),
+            GetRealmRequest.QueryOneofCase.Slug when !string.IsNullOrWhiteSpace(request.Slug) => await db.Realms
+                .FirstOrDefaultAsync(r => r.Slug == request.Slug),
+            _ => throw new RpcException(new Status(StatusCode.InvalidArgument, "Must provide either id or slug"))
+        };
+
+        return realm == null
+            ? throw new RpcException(new Status(StatusCode.NotFound, "Realm not found"))
+            : realm.ToProtoValue();
+    }
+
+    public override async Task<GetUserRealmsResponse> GetUserRealms(GetUserRealmsRequest request,
+        ServerCallContext context)
+    {
+        var accountId = Guid.Parse(request.AccountId);
+        var cacheKey = $"{CacheKeyPrefix}{accountId}";
+        var (found, cachedRealms) = await cache.GetAsyncWithStatus<List<Guid>>(cacheKey);
+        if (found && cachedRealms != null)
+            return new GetUserRealmsResponse { RealmIds = { cachedRealms.Select(g => g.ToString()) } };
+
+        var realms = await db.RealmMembers
+            .Include(m => m.Realm)
+            .Where(m => m.AccountId == accountId)
+            .Where(m => m.JoinedAt != null && m.LeaveAt == null)
+            .Select(m => m.Realm!.Id)
+            .ToListAsync();
+
+        // Cache the result for 5 minutes
+        await cache.SetAsync(cacheKey, realms, TimeSpan.FromMinutes(5));
+
+        return new GetUserRealmsResponse { RealmIds = { realms.Select(g => g.ToString()) } };
+    }
+
+    public override async Task<Empty> SendInviteNotify(SendInviteNotifyRequest request, ServerCallContext context)
+    {
+        var member = request.Member;
+        var account = await db.Accounts
+            .AsNoTracking()
+            .Include(a => a.Profile)
+            .FirstOrDefaultAsync(a => a.Id == Guid.Parse(member.AccountId));
+        
+        if (account == null) throw new RpcException(new Status(StatusCode.NotFound, "Account not found"));
+        
+        CultureService.SetCultureInfo(account.Language);
+
+        await pusher.SendPushNotificationToUserAsync(
+            new SendPushNotificationToUserRequest
+            {
+                UserId = account.Id.ToString(),
+                Notification = new PushNotification
+                {
+                    Topic = "invites.realms",
+                    Title = localizer["RealmInviteTitle"],
+                    Body = localizer["RealmInviteBody", member.Realm?.Name ?? "Unknown Realm"],
+                    ActionUri = "/realms",
+                    IsSavable = true
+                }
+            }
+        );
+
+        return new Empty();
+    }
+
+    public override async Task<BoolValue> IsMemberWithRole(IsMemberWithRoleRequest request, ServerCallContext context)
+    {
+        if (request.RequiredRoles.Count == 0)
+            return new BoolValue { Value = false };
+
+        var maxRequiredRole = request.RequiredRoles.Max();
+        var member = await db.RealmMembers
+            .Where(m => m.RealmId == Guid.Parse(request.RealmId) && m.AccountId == Guid.Parse(request.AccountId) &&
+                        m.JoinedAt != null && m.LeaveAt == null)
+            .FirstOrDefaultAsync();
+        return new BoolValue { Value = member?.Role >= maxRequiredRole };
+    }
+
+    public override async Task<RealmMember> LoadMemberAccount(LoadMemberAccountRequest request,
+        ServerCallContext context)
+    {
+        var member = request.Member;
+        var account = await db.Accounts
+            .AsNoTracking()
+            .Include(a => a.Profile)
+            .FirstOrDefaultAsync(a => a.Id == Guid.Parse(member.AccountId));
+        
+        var response = new RealmMember(member) { Account = account?.ToProtoValue() };
+        return response;
+    }
+
+    public override async Task<LoadMemberAccountsResponse> LoadMemberAccounts(LoadMemberAccountsRequest request,
+        ServerCallContext context)
+    {
+        var accountIds = request.Members.Select(m => Guid.Parse(m.AccountId)).ToList();
+        var accounts = await db.Accounts
+            .AsNoTracking()
+            .Include(a => a.Profile)
+            .Where(a => accountIds.Contains(a.Id))
+            .ToDictionaryAsync(a => a.Id, a => a.ToProtoValue());
+
+        var response = new LoadMemberAccountsResponse();
+        foreach (var member in request.Members)
+        {
+            var updatedMember = new RealmMember(member);
+            if (accounts.TryGetValue(Guid.Parse(member.AccountId), out var account))
+            {
+                updatedMember.Account = account;
+            }
+
+            response.Members.Add(updatedMember);
+        }
+
+        return response;
+    }
+}

DysonNetwork.Pass/Startup/ApplicationConfiguration.cs

@@ -3,6 +3,7 @@ using DysonNetwork.Pass.Auth;
 using DysonNetwork.Pass.Credit;
 using DysonNetwork.Pass.Leveling;
 using DysonNetwork.Pass.Permission;
+using DysonNetwork.Pass.Realm;
 using DysonNetwork.Pass.Wallet;
 using DysonNetwork.Shared.Http;
 using Prometheus;
@@ -42,6 +43,7 @@ public static class ApplicationConfiguration
         app.MapGrpcService<BotAccountReceiverGrpc>();
         app.MapGrpcService<WalletServiceGrpc>();
         app.MapGrpcService<PaymentServiceGrpc>();
+        app.MapGrpcService<RealmServiceGrpc>();
 
         return app;
     }

DysonNetwork.Pass/Startup/ServiceCollectionExtensions.cs

@@ -17,6 +17,7 @@ using DysonNetwork.Pass.Credit;
 using DysonNetwork.Pass.Handlers;
 using DysonNetwork.Pass.Leveling;
 using DysonNetwork.Pass.Mailer;
+using DysonNetwork.Pass.Realm;
 using DysonNetwork.Pass.Safety;
 using DysonNetwork.Pass.Wallet.PaymentHandlers;
 using DysonNetwork.Shared.Cache;
@@ -152,6 +153,7 @@ public static class ServiceCollectionExtensions
         services.AddScoped<SafetyService>();
         services.AddScoped<SocialCreditService>();
         services.AddScoped<ExperienceService>();
+        services.AddScoped<RealmService>();
         
         services.Configure<OidcProviderOptions>(configuration.GetSection("OidcProvider"));
         services.AddScoped<OidcProviderService>();