Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
//-----------------------------------------------------------------------
// <copyright file="AliasServerDbContext.cs" company="aliasvault">
// Copyright (c) aliasvault. All rights reserved.
// Licensed under the AGPLv3 license. See LICENSE.md file in the project root for full license information.
// </copyright>
//-----------------------------------------------------------------------
namespace AliasServerDb;
using AliasVault.Shared.Models.Enums;
using AliasVault.WorkerStatus.Database;
using Microsoft.AspNetCore.DataProtection.EntityFrameworkCore;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using Microsoft.Extensions.Configuration;
/// <summary>
/// The AliasServerDbContext class. Note: we are using DbContext instead of IdentityDbContext because
/// we have two separate user objects, one for the admin panel and one for the vault. We manually
/// define the Identity tables in the OnModelCreating method.
/// </summary>
public class AliasServerDbContext : WorkerStatusDbContext, IDataProtectionKeyContext
{
/// <summary>
/// Initializes a new instance of the <see cref="AliasServerDbContext"/> class.
/// </summary>
public AliasServerDbContext()
{
}
/// <summary>
/// Initializes a new instance of the <see cref="AliasServerDbContext"/> class.
/// </summary>
/// <param name="options">DbContextOptions.</param>
public AliasServerDbContext(DbContextOptions<AliasServerDbContext> options)
: base(options)
{
}
/// <summary>
/// Gets or sets the DataProtectionKeys DbSet.
/// </summary>
public DbSet<DataProtectionKey> DataProtectionKeys { get; set; }
/// <summary>
/// Gets or sets the AliasVaultUser DbSet.
/// </summary>
public DbSet<AliasVaultUser> AliasVaultUsers { get; set; }
/// <summary>
/// Gets or sets the UserClaims DbSet. Not written by AliasVault itself, but ASP.NET Identity reads it
/// whenever it materializes a ClaimsPrincipal, so the table must exist.
/// </summary>
public DbSet<IdentityUserClaim<string>> UserClaims { get; set; }
/// <summary>
/// Gets or sets the UserTokens DbSet.
/// </summary>
public DbSet<IdentityUserToken<string>> UserTokens { get; set; }
/// <summary>
/// Gets or sets the UserRefreshTokens DbSet.
/// </summary>
public DbSet<AliasVaultUserRefreshToken> AliasVaultUserRefreshTokens { get; set; }
/// <summary>
/// Gets or sets the AdminUser DbSet.
/// </summary>
public DbSet<AdminUser> AdminUsers { get; set; }
/// <summary>
/// Gets or sets the VaultManifests DbSet. Exactly one row per logical manifest, holding its current revision.
/// Superseded revisions live in <see cref="VaultManifestsHistory"/>.
/// </summary>
public DbSet<VaultManifest> VaultManifests { get; set; }
/// <summary>
/// Gets or sets the VaultManifestsHistory DbSet. Superseded manifest revisions kept for backup/rollback,
/// pruned by the retention policy.
/// </summary>
public DbSet<VaultManifestsHistory> VaultManifestsHistory { get; set; }
/// <summary>
/// Gets or sets the Emails DbSet.
/// </summary>
public DbSet<Email> Emails { get; set; }
/// <summary>
/// Gets or sets the EmailAttachments DbSet. Deprecated and read-only since 0.31.0, see <see cref="EmailAttachment"/>.
/// </summary>
public DbSet<EmailAttachment> EmailAttachments { get; set; }
/// <summary>
/// Gets or sets the EmailClaims DbSet.
/// </summary>
public DbSet<EmailClaim> EmailClaims { get; set; }
/// <summary>
/// Gets or sets the EmailDecryptionKeys DbSet.
/// </summary>
public DbSet<EmailDecryptionKey> EmailDecryptionKeys { get; set; }
/// <summary>
/// Gets or sets the EmailParts DbSet.
/// </summary>
public DbSet<EmailPart> EmailParts { get; set; }
/// <summary>
/// Gets or sets the Groups DbSet.
/// </summary>
public DbSet<Group> Groups { get; set; }
/// <summary>
/// Gets or sets the GroupMembers DbSet.
/// </summary>
public DbSet<GroupMember> GroupMembers { get; set; }
/// <summary>
/// Gets or sets the VaultManifestInvitations DbSet.
/// </summary>
public DbSet<VaultManifestInvitation> VaultManifestInvitations { get; set; }
/// <summary>
/// Gets or sets the VaultManifestShareDetails DbSet.
/// </summary>
public DbSet<VaultManifestShareDetails> VaultManifestShareDetails { get; set; }
/// <summary>
/// Gets or sets the VaultManifestDeliveryKeys DbSet.
/// </summary>
public DbSet<VaultManifestDeliveryKey> VaultManifestDeliveryKeys { get; set; }
/// <summary>
/// Gets or sets the Logs DbSet.
/// </summary>
public DbSet<Log> Logs { get; set; }
/// <summary>
/// Gets or sets the AuthLogs DbSet.
/// </summary>
public DbSet<AuthLog> AuthLogs { get; set; }
/// <summary>
/// Gets or sets the ServerSettings DbSet.
/// </summary>
public DbSet<ServerSetting> ServerSettings { get; set; } = null!;
/// <summary>
/// Gets or sets the TaskRunnerJobs DbSet.
/// </summary>
public DbSet<TaskRunnerJob> TaskRunnerJobs { get; set; }
/// <summary>
/// Gets or sets the MobileLoginRequests DbSet.
/// </summary>
public DbSet<MobileLoginRequest> MobileLoginRequests { get; set; }
/// <summary>
/// Gets or sets the BlockedIpRanges DbSet.
/// </summary>
public DbSet<BlockedIpRange> BlockedIpRanges { get; set; }
/// <summary>
/// Gets or sets the RegistrationInvites DbSet.
/// </summary>
public DbSet<RegistrationInvite> RegistrationInvites { get; set; }
/// <summary>
/// Gets or sets the VaultDataBuckets DbSet. These represent separately-syncable per-manifest, per-kind sync buckets. Separate from the manifest blob itself.
/// </summary>
public DbSet<VaultDataBucket> VaultDataBuckets { get; set; }
/// <summary>
/// Gets or sets the VaultDataBucketsHistory DbSet. Superseded bucket revisions kept for backup/rollback,
/// pruned by the bucket retention policy.
/// </summary>
public DbSet<VaultDataBucketsHistory> VaultDataBucketsHistory { get; set; }
/// <summary>
/// Gets or sets the VaultBlobObjects DbSet. These represent encrypted blobs referenced by one or more vault revisions.
/// </summary>
public DbSet<VaultBlobObject> VaultBlobObjects { get; set; }
/// <summary>
/// Gets or sets the VaultBlobReferences DbSet. These represent references from vaults to encrypted blobs.
/// </summary>
public DbSet<VaultBlobReference> VaultBlobReferences { get; set; }
/// <summary>
/// Gets or sets the RateLimits DbSet.
/// </summary>
public DbSet<RateLimit> RateLimits { get; set; }
/// <summary>
/// Gets or sets the CapabilityRules DbSet.
/// </summary>
public DbSet<CapabilityRule> CapabilityRules { get; set; }
/// <summary>
/// Gets or sets the UserUnlockMethods DbSet.
/// </summary>
public DbSet<UserUnlockMethod> UserUnlockMethods { get; set; }
/// <summary>
/// Gets or sets the UserUnlockMethodsHistory DbSet.
/// </summary>
public DbSet<UserUnlockMethodsHistory> UserUnlockMethodsHistory { get; set; }
/// <summary>
/// Gets or sets the UserGrantKeys DbSet.
/// </summary>
public DbSet<UserGrantKey> UserGrantKeys { get; set; }
/// <summary>
/// Gets or sets the UserSigningKeys DbSet.
/// </summary>
public DbSet<UserSigningKey> UserSigningKeys { get; set; }
/// <summary>
/// Gets or sets the UserKeyCertifications DbSet.
/// </summary>
public DbSet<UserKeyCertification> UserKeyCertifications { get; set; }
/// <summary>
/// Gets or sets the VaultManifestAccessKeys DbSet.
/// </summary>
public DbSet<VaultManifestAccessKey> VaultManifestAccessKeys { get; set; }
/// <summary>
/// Sets up the connection string if it is not already configured.
/// </summary>
/// <param name="optionsBuilder">DbContextOptionsBuilder instance.</param>
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
if (optionsBuilder.IsConfigured)
{
return;
}
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.Build();
// Add SQLite connection with enhanced settings
var connectionString = configuration.GetConnectionString("AliasServerDbContext");
optionsBuilder
.UseNpgsql(connectionString, options => options.CommandTimeout(60))
.UseLazyLoadingProxies();
}
/// <summary>
/// The OnModelCreating method.
/// </summary>
/// <param name="modelBuilder">ModelBuilder instance.</param>
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
/*
* All DateTime properties are configured to use 'timestamp with time zone' in UTC and are returned as Kind.Utc.
* Avoid using ToUniversalTime() inside EF projections, as this bypasses the read converter and results in Kind.Local.
*/
foreach (var entityType in modelBuilder.Model.GetEntityTypes())
{
foreach (var property in entityType.GetProperties())
{
if (property.ClrType == typeof(DateTime) || property.ClrType == typeof(DateTime?))
{
property.SetColumnType("timestamp with time zone");
// Add value converter for DateTime properties
var converter = new ValueConverter<DateTime, DateTime>(
v => v.ToUniversalTime(),
v => v.ToUniversalTime());
property.SetValueConverter(converter);
}
}
}
/*
* Configure the AspNetIdentity tables manually. Only the tables that ASP.NET Identity actually
* touches in AliasVault are mapped: UserClaims (read on every ClaimsPrincipal creation) and
* UserTokens (2FA authenticator keys and recovery codes). Roles, role claims and external
* logins are not used, so those tables are intentionally absent.
*/
modelBuilder.Entity<IdentityUserClaim<string>>(entity =>
{
entity.HasKey(c => c.Id);
entity.ToTable("UserClaims");
});
modelBuilder.Entity<IdentityUserToken<string>>(entity =>
{
entity.HasKey(t => new { t.UserId, t.LoginProvider, t.Name });
entity.ToTable("UserTokens");
});
// Configure Log entity
modelBuilder.Entity<Log>(builder =>
{
builder.ToTable("Logs");
builder.Property(e => e.Application).HasMaxLength(50).IsRequired();
builder.Property(e => e.Message);
builder.Property(e => e.MessageTemplate);
builder.Property(e => e.Level).HasMaxLength(128);
builder.Property(e => e.TimeStamp);
builder.Property(e => e.Exception);
builder.Property(e => e.Properties);
builder.Property(e => e.LogEvent);
// Indexes for faster querying
builder.HasIndex(e => e.TimeStamp);
builder.HasIndex(e => e.Application);
});
/*
* Configure the user's personal group reference.
*/
modelBuilder.Entity<AliasVaultUser>(builder =>
{
builder.HasOne(e => e.PersonalGroup)
.WithOne()
.HasForeignKey<AliasVaultUser>(e => e.PersonalGroupId)
.OnDelete(DeleteBehavior.Restrict);
builder.HasIndex(e => e.PersonalGroupId).IsUnique().HasDatabaseName("UX_AliasVaultUsers_PersonalGroupId");
builder.HasIndex(e => e.NormalizedUserName).IsUnique().HasDatabaseName("UX_AliasVaultUsers_NormalizedUserName");
builder.HasIndex(e => e.SrpIdentity).IsUnique().HasDatabaseName("UX_AliasVaultUsers_SrpIdentity");
});
modelBuilder.Entity<Group>(builder =>
{
builder.Property(e => e.AnonymizedEmailAliasSenderCounts)
.HasDefaultValueSql("array_fill(0, ARRAY[64])");
builder.Property(e => e.Type).HasConversion<string>().HasMaxLength(20);
});
// Configure GroupMember, who may be granted access to the group's shared manifests.
modelBuilder.Entity<GroupMember>(builder =>
{
builder.HasOne(e => e.Group)
.WithMany(g => g.Members)
.HasForeignKey(e => e.GroupId)
.OnDelete(DeleteBehavior.Cascade);
// Deleting a user removes their memberships everywhere, of their own group and other possibly joined groups.
builder.HasOne(e => e.User)
.WithMany()
.HasForeignKey(e => e.UserId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasIndex(e => e.UserId);
builder.Property(e => e.Role).HasConversion<string>().HasMaxLength(20);
});
// Configure VaultManifestInvitation, an offer of access to a shared manifest.
modelBuilder.Entity<VaultManifestInvitation>(builder =>
{
builder.HasOne(e => e.Group)
.WithMany()
.HasForeignKey(e => e.GroupId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasOne(e => e.Inviter)
.WithMany()
.HasForeignKey(e => e.InviterUserId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasOne(e => e.Invitee)
.WithMany()
.HasForeignKey(e => e.InviteeUserId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasIndex(e => new { e.VaultManifestId, e.InviteeUserId }).IsUnique().HasFilter("\"State\" = 'Pending'").HasDatabaseName("UX_VaultManifestInvitations_Manifest_Invitee_Pending");
builder.Property(e => e.State).HasConversion<string>().HasMaxLength(20);
builder.Property(e => e.Role).HasConversion<string>().HasMaxLength(20);
builder.Property(e => e.Algorithm).HasConversion(v => VaultKeyAlgorithms.ToToken(v), v => VaultKeyAlgorithms.Parse(v));
// Losing the keypair the vault key was encrypted to leaves an invitation nobody could ever decrypt.
builder.HasOne(e => e.UserGrantKey)
.WithMany()
.HasForeignKey(e => e.UserGrantKeyId)
.OnDelete(DeleteBehavior.SetNull);
});
// Configure VaultManifest: one row per logical manifest (current revision), keyed by ManifestId.
modelBuilder.Entity<VaultManifest>(builder =>
{
builder.HasKey(e => e.ManifestId);
builder.HasOne(e => e.OwnerGroup)
.WithMany()
.HasForeignKey(e => e.OwnerGroupId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasIndex(e => e.OwnerGroupId);
builder.HasOne(e => e.UpdatedByUser)
.WithMany()
.HasForeignKey(e => e.UpdatedByUserId)
.OnDelete(DeleteBehavior.SetNull);
});
// Configure VaultManifestsHistory - superseded revisions, composite key (ManifestId, RevisionNumber).
modelBuilder.Entity<VaultManifestsHistory>(builder =>
{
builder.ToTable("VaultManifestsHistory");
builder.HasKey(e => new { e.ManifestId, e.RevisionNumber });
builder.HasOne(e => e.Manifest)
.WithMany()
.HasForeignKey(e => e.ManifestId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasOne(e => e.UpdatedByUser)
.WithMany()
.HasForeignKey(e => e.UpdatedByUserId)
.OnDelete(DeleteBehavior.SetNull);
});
// Configure VaultManifestAccessKey: a per-(holder, manifest) encrypted-VEK access path (AccountKey row or grant).
modelBuilder.Entity<VaultManifestAccessKey>(builder =>
{
builder.HasOne(e => e.User)
.WithMany(u => u.VaultManifestAccessKeys)
.HasForeignKey(e => e.UserId)
.OnDelete(DeleteBehavior.Cascade);
// One access path per (holder, type, manifest) per VEK version: a rotation adds a row rather than
// replacing one, so the retired VEK stays retrievable for the history revisions it encrypted.
builder.HasIndex(e => new { e.UserId, e.Type, e.VaultManifestId, e.KeyVersion }).IsUnique().HasDatabaseName("UX_VaultManifestAccessKeys_UserId_Type_Manifest_Version");
builder.HasIndex(e => e.VaultManifestId).HasDatabaseName("IX_VaultManifestAccessKeys_VaultManifestId");
builder.Property(e => e.Metadata).HasColumnType("jsonb");
builder.Property(e => e.Type).HasConversion(v => ManifestKeyTypes.ToToken(v), v => ManifestKeyTypes.Parse(v));
builder.Property(e => e.Algorithm).HasConversion(v => VaultKeyAlgorithms.ToToken(v), v => VaultKeyAlgorithms.Parse(v));
builder.HasOne(e => e.UserGrantKey)
.WithMany()
.HasForeignKey(e => e.UserGrantKeyId)
.OnDelete(DeleteBehavior.SetNull);
});
// Configure CapabilityRule.
modelBuilder.Entity<CapabilityRule>(builder =>
{
builder.HasOne(e => e.User)
.WithMany()
.HasForeignKey(e => e.UserId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasOne(e => e.Group)
.WithMany()
.HasForeignKey(e => e.GroupId)
.OnDelete(DeleteBehavior.Cascade);
builder.Property(e => e.Kind).HasConversion<string>().HasMaxLength(20);
builder.Property(e => e.Tier).HasConversion<string>().HasMaxLength(20);
});
// Configure UserUnlockMethod: one row per enrolled unlock method, each encrypting the user's Account Key.
modelBuilder.Entity<UserUnlockMethod>(builder =>
{
builder.HasOne(e => e.User)
.WithMany()
.HasForeignKey(e => e.UserId)
.OnDelete(DeleteBehavior.Cascade);
// Label is part of the key so a user can enroll several methods of one type (two hardware keys, say)
// while methods that must stay single, the password above all, keep it empty and so stay unique per type.
builder.HasIndex(e => new { e.UserId, e.Type, e.Label }).IsUnique().HasDatabaseName("UX_UserUnlockMethods_UserId_Type_Label");
builder.Property(e => e.Metadata).HasColumnType("jsonb");
builder.Property(e => e.Type).HasConversion(v => UnlockMethodTypes.ToToken(v), v => UnlockMethodTypes.Parse(v));
builder.Property(e => e.Algorithm).HasConversion(v => VaultKeyAlgorithms.ToToken(v), v => VaultKeyAlgorithms.Parse(v));
});
// Configure UserUnlockMethodsHistory: superseded unlock methods, retained briefly so a password change can be reverted.
modelBuilder.Entity<UserUnlockMethodsHistory>(builder =>
{
builder.ToTable("UserUnlockMethodsHistory");
builder.HasOne(e => e.User)
.WithMany()
.HasForeignKey(e => e.UserId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasIndex(e => new { e.UserId, e.Type, e.ArchivedAt }).HasDatabaseName("IX_UserUnlockMethodsHistory_UserId_Type_ArchivedAt");
builder.HasIndex(e => e.ArchivedAt).HasDatabaseName("IX_UserUnlockMethodsHistory_ArchivedAt");
builder.Property(e => e.Metadata).HasColumnType("jsonb");
builder.Property(e => e.Type).HasConversion(v => UnlockMethodTypes.ToToken(v), v => UnlockMethodTypes.Parse(v));
builder.Property(e => e.Algorithm).HasConversion(v => VaultKeyAlgorithms.ToToken(v), v => VaultKeyAlgorithms.Parse(v));
});
// Configure UserGrantKey: the account-level keypair for grant encryption; one primary per user.
modelBuilder.Entity<UserGrantKey>(builder =>
{
builder.HasOne(e => e.User)
.WithMany()
.HasForeignKey(e => e.UserId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasIndex(e => e.UserId).IsUnique().HasFilter("\"IsPrimary\"").HasDatabaseName("UX_UserGrantKeys_User_Primary");
builder.Property(e => e.Algorithm).HasConversion(v => VaultKeyAlgorithms.ToToken(v), v => VaultKeyAlgorithms.Parse(v));
});
// Configure UserSigningKey: the account signing keypair; one primary per user.
modelBuilder.Entity<UserSigningKey>(builder =>
{
builder.HasOne(e => e.User)
.WithMany()
.HasForeignKey(e => e.UserId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasIndex(e => e.UserId).IsUnique().HasFilter("\"IsPrimary\"").HasDatabaseName("UX_UserSigningKeys_User_Primary");
builder.HasIndex(e => e.Fingerprint).HasDatabaseName("IX_UserSigningKeys_Fingerprint");
builder.Property(e => e.Algorithm).HasConversion(v => SigningKeyAlgorithms.ToToken(v), v => SigningKeyAlgorithms.Parse(v));
});
// Configure UserKeyCertification, one certification per certifier and subject, replaced when the subject's key changes.
modelBuilder.Entity<UserKeyCertification>(builder =>
{
builder.HasOne(e => e.Certifier)
.WithMany()
.HasForeignKey(e => e.CertifierUserId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasOne(e => e.Subject)
.WithMany()
.HasForeignKey(e => e.SubjectUserId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasIndex(e => new { e.CertifierUserId, e.SubjectUserId }).IsUnique().HasDatabaseName("UX_UserKeyCertifications_Certifier_Subject");
});
/*
* Configure EmailClaim - one owning manifest per address.
*/
modelBuilder.Entity<EmailClaim>(builder =>
{
// Stored as its name rather than an ordinal: every query here reads "is this claim still Removed", which
// is worth being able to answer from a raw SQL prompt without a lookup table in your head.
builder.Property(c => c.State).HasConversion<string>().HasMaxLength(20);
// Deleting the owning manifest leaves the claim behind as a tombstone, so the address is never handed out again.
builder.HasOne(c => c.VaultManifest)
.WithMany()
.HasForeignKey(c => c.VaultManifestId)
.OnDelete(DeleteBehavior.SetNull);
builder.HasIndex(c => new { c.VaultManifestId, c.State });
builder.HasIndex(c => new { c.VaultManifestId, c.CreatedAt });
});
/*
* Configure EmailDecryptionKey - one encrypted symmetric key per (email, delivery key).
*/
modelBuilder.Entity<EmailDecryptionKey>(builder =>
{
builder.HasKey(d => new { d.EmailId, d.VaultManifestDeliveryKeyId });
builder.HasOne(d => d.Email)
.WithMany(e => e.DecryptionKeys)
.HasForeignKey(d => d.EmailId)
.OnDelete(DeleteBehavior.Cascade);
builder.HasOne(d => d.VaultManifestDeliveryKey)
.WithMany(k => k.DecryptionKeys)
.HasForeignKey(d => d.VaultManifestDeliveryKeyId)
.HasConstraintName("FK_EmailDecryptionKeys_VaultManifestDeliveryKeys_DeliveryKeyId")
.OnDelete(DeleteBehavior.Cascade);
// The mailbox queries filter emails by the set of keys the caller holds.
builder.HasIndex(d => new { d.VaultManifestDeliveryKeyId, d.EmailId });
});
modelBuilder.Entity<VaultManifestShareDetails>(builder =>
{
// The details are removed with the shared manifest they describe.
builder.HasOne(d => d.VaultManifest)
.WithOne()
.HasForeignKey<VaultManifestShareDetails>(d => d.ManifestId)
.OnDelete(DeleteBehavior.Cascade);
});
modelBuilder.Entity<VaultManifestDeliveryKey>(builder =>
{
// A key is removed with its manifest: for a folder that is the folder's delivery keys, for a
// personal manifest the user's personal keys (personal manifests only disappear with the account).
builder.HasOne(k => k.VaultManifest)
.WithMany()
.HasForeignKey(k => k.VaultManifestId)
.OnDelete(DeleteBehavior.Cascade);
// Delivery resolves the primary key for a manifest on every inbound mail, so index the lookup.
builder.HasIndex(k => new { k.VaultManifestId, k.IsPrimary });
// One active delivery key per manifest.
builder.HasIndex(k => k.VaultManifestId).IsUnique().HasFilter("\"IsPrimary\"").HasDatabaseName("UX_VaultManifestDeliveryKeys_Manifest_Primary");
builder.Property(k => k.Algorithm).HasConversion(v => VaultKeyAlgorithms.ToToken(v), v => VaultKeyAlgorithms.Parse(v));
});
// Configure MobileLoginRequest - AliasVaultUser relationship
modelBuilder.Entity<MobileLoginRequest>(builder =>
{
builder.HasOne(m => m.User)
.WithMany()
.HasForeignKey(m => m.UserId)
.OnDelete(DeleteBehavior.Cascade);
builder.Property(m => m.Algorithm).HasConversion(v => VaultKeyAlgorithms.ToToken(v), v => VaultKeyAlgorithms.Parse(v));
});
// Configure VaultDataBucket.
modelBuilder.Entity<VaultDataBucket>(builder =>
{
builder.HasKey(e => new { e.ManifestId, e.Category });
builder.Property(e => e.Category).HasConversion<string>().HasMaxLength(50);
builder.HasOne(e => e.Manifest)
.WithMany()
.HasForeignKey(e => e.ManifestId)
.OnDelete(DeleteBehavior.Cascade);
});
// Configure VaultDataBucketsHistory - superseded bucket revisions, pruned by the bucket retention policy.
modelBuilder.Entity<VaultDataBucketsHistory>(builder =>
{
builder.HasKey(e => new { e.ManifestId, e.Category, e.RevisionNumber });
builder.Property(e => e.Category).HasConversion<string>().HasMaxLength(50);
builder.HasOne(e => e.Bucket)
.WithMany()
.HasForeignKey(e => new { e.ManifestId, e.Category })
.OnDelete(DeleteBehavior.Cascade);
});
// Configure VaultBlobObject - composite key (ManifestId, Hash). Cascades with the manifest.
modelBuilder.Entity<VaultBlobObject>(builder =>
{
builder.HasKey(e => new { e.ManifestId, e.Hash });
builder.HasOne(e => e.Manifest)
.WithMany()
.HasForeignKey(e => e.ManifestId)
.OnDelete(DeleteBehavior.Cascade);
});
// Configure VaultBlobReference - composite key (ManifestId, RevisionNumber, BlobHash). Cascades with the
// manifest; retention deletes references of pruned history revisions explicitly.
modelBuilder.Entity<VaultBlobReference>(builder =>
{
builder.HasKey(e => new { e.ManifestId, e.RevisionNumber, e.BlobHash });
builder.HasOne(e => e.Manifest)
.WithMany()
.HasForeignKey(e => e.ManifestId)
.OnDelete(DeleteBehavior.Cascade);
});
// Configure RateLimit - Group relationship: quotas are charged to the group that owns the content.
modelBuilder.Entity<RateLimit>()
.HasOne(r => r.Group)
.WithMany()
.HasForeignKey(r => r.GroupId)
.OnDelete(DeleteBehavior.Cascade);
}
}