Unique indexes, one username space, and entity maps warmed before use

Infrastructure/Data/Indexes runs at every start, after the migrations:
unique on Post/DmPost ObjectURI, ForeignAvatar ActorURI, the Follower
triple, RootToAvatar, RootUser UserName and ReservedName; plain indexes on
the lookups the services actually make (PublicKeyId, author and group
post listings, ParticipantsKey, the delivery queue).

Migration _001 runs first and removes the duplicates the races could
already have left (keeping the newest actor row, the oldest post, the
accepted follower), then fills ReservedName from every avatar and group.

ReservedName is one username space for personas, groups and the instance:
a name is reserved by an insert the unique index arbitrates, before the
avatar or group is saved, so two simultaneous sign-ups cannot both get it.
A short list of names (admin, support, abuse, postmaster, ...) is never
available.

EntityMaps.Warm touches every entity's collection one at a time before
anything else runs. MongoDB.Entities maps the Entity base class on first
touch, and two types mapped at once throw "An item with the same key has
already been added" and stay broken for the life of the process; the
parallel test run hit it, and the delivery worker racing a request could
have too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012CzABvBkbcFqoHdmi8b9WB

PrivaPub/Infrastructure/Data/Indexes.cs

@@ -0,0 +1,72 @@
+using MongoDB.Bson;
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.Models.Federation;
+using PrivaPub.Models.Group;
+using PrivaPub.Models.Post;
+using PrivaPub.Models.User;
+
+namespace PrivaPub.Infrastructure.Data
+{
+	public static class Indexes
+	{
+		public static async Task Create(CancellationToken token = default)
+		{
+			await Unique<Post>(p => p.ObjectURI, Builders<Post>.Filter.Type(p => p.ObjectURI, BsonType.String), token);
+			await Plain<Post>(token, p => p.GroupUserId, p => p.ID);
+			await Plain<Post>(token, p => p.GroupId, p => p.ID);
+			await Plain<Post>(token, p => p.ActorURI);
+
+			await Unique<DmPost>(p => p.ObjectURI, Builders<DmPost>.Filter.Type(p => p.ObjectURI, BsonType.String), token);
+			await Plain<DmPost>(token, p => p.GroupId, p => p.ID);
+
+			await Unique<ForeignAvatar>(a => a.ActorURI, Builders<ForeignAvatar>.Filter.Type(a => a.ActorURI, BsonType.String), token);
+			await Plain<ForeignAvatar>(token, a => a.PublicKeyId);
+
+			await DB.Default.Index<Follower>()
+				.Key(f => f.LocalActorId, KeyType.Ascending)
+				.Key(f => f.LocalActorKind, KeyType.Ascending)
+				.Key(f => f.ActorURI, KeyType.Ascending)
+				.Option(o => o.Unique = true)
+				.CreateAsync(token);
+			await Plain<Follower>(token, f => f.ActorURI);
+
+			await DB.Default.Index<RootToAvatar>()
+				.Key(r => r.RootId, KeyType.Ascending)
+				.Key(r => r.AvatarId, KeyType.Ascending)
+				.Option(o => o.Unique = true)
+				.CreateAsync(token);
+			await Plain<RootToAvatar>(token, r => r.AvatarId);
+
+			await Unique<ReservedName>(r => r.Name, Builders<ReservedName>.Filter.Type(r => r.Name, BsonType.String), token);
+			await Unique<RootUser>(u => u.UserName, Builders<RootUser>.Filter.Type(u => u.UserName, BsonType.String), token);
+			await Plain<Avatar>(token, a => a.UserName);
+			await Plain<Group>(token, g => g.UserName);
+			await Plain<Group>(token, g => g.InvitationCode);
+
+			await Plain<DmGroup>(token, g => g.ParticipantsKey);
+
+			await Plain<Delivery>(token, d => d.DeliveredAt, d => d.AbandonedAt, d => d.NextAttemptAt);
+		}
+
+		static async Task Unique<T>(System.Linq.Expressions.Expression<Func<T, object>> key, FilterDefinition<T> partial,
+			CancellationToken token) where T : IEntity =>
+			await DB.Default.Index<T>()
+				.Key(key, KeyType.Ascending)
+				.Option(o =>
+				{
+					o.Unique = true;
+					o.PartialFilterExpression = partial;
+				})
+				.CreateAsync(token);
+
+		static async Task Plain<T>(CancellationToken token, params System.Linq.Expressions.Expression<Func<T, object>>[] keys) where T : IEntity
+		{
+			var index = DB.Default.Index<T>();
+			foreach (var key in keys)
+				index.Key(key, KeyType.Ascending);
+			await index.CreateAsync(token);
+		}
+	}
+}