daniel/deepdrft
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 13 Wiki Activity

Backend Services Split into separate projects for reference from other front ends

Browse Source
This commit is contained in:
daniel-c-harvey
2025-09-07 12:56:52 -04:00
parent a5b7ab041e
commit b16bcfc6cd
47 changed files with 153 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files
DeepDrftContent/FileDatabase/Services/FileDatabase.cs
-190
View File
@@ -1,190 +0,0 @@
using DeepDrftContent.FileDatabase.Models;
using DeepDrftContent.FileDatabase.Utils;
using IndexType = DeepDrftContent.FileDatabase.Services.IndexType;
namespace DeepDrftContent.FileDatabase.Services;
/// <summary>
/// Main file database class that orchestrates multiple media vaults
/// </summary>
public class FileDatabase : DirectoryIndexDirectory
{
private readonly StructuralMap<string, MediaVault> _vaults;
/// <summary>
/// Factory method to create a FileDatabase instance
/// </summary>
public static async Task<FileDatabase?> FromAsync(string rootPath)
{
var factoryService = new IndexFactoryService();
var rootIndex = await factoryService.LoadOrCreateDirectoryIndexAsync(rootPath);
if (rootIndex != null)
{
var db = new FileDatabase(rootPath, (DirectoryIndex)rootIndex);
await db.InitVaultsAsync();
return db;
}
return null;
}
private FileDatabase(string rootPath, DirectoryIndex index) : base(rootPath, index)
{
_vaults = new StructuralMap<string, MediaVault>();
}
/// <summary>
/// Initializes all vaults found in the index
/// </summary>
private async Task InitVaultsAsync()
{
foreach (var vaultId in GetIndexEntries())
{
var vaultType = await GetVaultTypeFromIndex(vaultId);
if (vaultType.HasValue)
{
await InitVaultAsync(vaultId, vaultType.Value);
}
}
}
/// <summary>
/// Initializes a specific vault
/// </summary>
private async Task InitVaultAsync(string vaultId, MediaVaultType vaultType)
{
var path = Path.Combine(RootPath, vaultId);
var directoryVault = await MediaVaultFactory.From(path, vaultType);
if (directoryVault != null)
{
_vaults.Set(vaultId, directoryVault);
}
}
/// <summary>
/// Gets vault type from the vault's index file
/// </summary>
private async Task<MediaVaultType?> GetVaultTypeFromIndex(string vaultId)
{
try
{
var factoryService = new IndexFactoryService();
var vaultPath = Path.Combine(RootPath, vaultId);
var index = await factoryService.LoadIndexAsync(IndexType.Vault, vaultPath);
if (index is VaultIndex vaultIndex)
{
return vaultIndex.VaultType;
}
}
catch
{
// If we can't load the index, we can't determine the vault type
// This might happen for legacy vaults or corrupted indexes
}
return null;
}
/// <summary>
/// Checks if a vault exists for the given vault ID
/// </summary>
public bool HasVault(string vaultId)
{
return _vaults.Has(vaultId);
}
/// <summary>
/// Gets a vault by vault ID
/// </summary>
public MediaVault? GetVault(string vaultId)
{
return HasVault(vaultId) ? _vaults.Get(vaultId) : null;
}
/// <summary>
/// Creates a new vault
/// </summary>
public async Task CreateVaultAsync(string vaultId, MediaVaultType vaultType)
{
try
{
var path = Path.Combine(RootPath, vaultId);
var directoryVault = await MediaVaultFactory.From(path, vaultType);
if (directoryVault != null)
{
_vaults.Set(vaultId, directoryVault);
// Now using string-based index
await AddToIndexAsync(vaultId);
}
}
catch
{
throw;
}
}
/// <summary>
/// Loads a resource from a specific vault (MediaVaultType inferred from T)
/// </summary>
public async Task<T?> LoadResourceAsync<T>(string vaultId, string entryId)
where T : FileBinary
{
try
{
var vault = _vaults.Get(vaultId);
if (vault != null)
{
return await vault.GetEntryAsync<T>(entryId);
}
}
catch
{
// Swallow exceptions and return null, matching TypeScript behavior
}
return null;
}
/// <summary>
/// Registers a resource in a specific vault (MediaVaultType inferred from media type)
/// </summary>
public async Task<bool> RegisterResourceAsync(string vaultId, string entryId, FileBinary media)
{
try
{
var directoryVault = _vaults.Get(vaultId);
if (directoryVault != null)
{
await directoryVault.AddEntryAsync(entryId, media);
return true;
}
}
catch
{
// Swallow exceptions and return false, matching TypeScript behavior
}
return false;
}
/// <summary>
/// Gets all vault IDs managed by this database
/// </summary>
public IReadOnlyList<string> GetVaultIds()
{
return _vaults.Keys.ToList().AsReadOnly();
}
/// <summary>
/// Gets the total number of vaults
/// </summary>
public int GetVaultCount()
{
return _vaults.Size;
}
}
DeepDrftContent/FileDatabase/Services/IndexFactoryService.cs
-126
View File
@@ -1,126 +0,0 @@
using DeepDrftContent.FileDatabase.Abstractions;
using DeepDrftContent.FileDatabase.Models;
using DeepDrftContent.FileDatabase.Utils;
using IndexType = DeepDrftContent.FileDatabase.Services.IndexType;
namespace DeepDrftContent.FileDatabase.Services;
/// <summary>
/// Factory service for creating and managing indexes
/// </summary>
public class IndexFactoryService : IIndexFactory, IIndexDataFactory
{
private readonly Dictionary<IndexType, Func<object, IIndex>> _indexFromDataCreators;
private readonly Dictionary<IndexType, Func<IIndex, object>> _indexDataCreators;
public IndexFactoryService()
{
_indexFromDataCreators = new Dictionary<IndexType, Func<object, IIndex>>
{
{ IndexType.Directory, data => new DirectoryIndex((DirectoryIndexData)data) },
{ IndexType.Vault, data => new VaultIndex((VaultIndexData)data) }
};
_indexDataCreators = new Dictionary<IndexType, Func<IIndex, object>>
{
{ IndexType.Directory, index => DirectoryIndexData.FromIndex((DirectoryIndex)index) },
{ IndexType.Vault, index => VaultIndexData.FromIndex((VaultIndex)index) }
};
}
public async Task<IDirectoryIndex?> CreateDirectoryIndexAsync(string rootPath)
{
var indexData = new DirectoryIndexData(Path.GetFileName(rootPath));
var index = new DirectoryIndex(indexData);
// Ensure directory exists and save the index
await FileUtils.MakeVaultDirectoryAsync(rootPath);
await SaveIndexAsync(rootPath, IndexType.Directory, index);
return index;
}
public async Task<IIndex?> LoadIndexAsync(IndexType type, string rootPath)
{
if (!_indexFromDataCreators.TryGetValue(type, out var creator))
{
throw new ArgumentException($"Unknown index type: {type}");
}
var indexPath = Path.Combine(rootPath, "index");
object indexData = type switch
{
IndexType.Directory => await FileUtils.FetchObjectAsync<DirectoryIndexData>(indexPath),
IndexType.Vault => await FileUtils.FetchObjectAsync<VaultIndexData>(indexPath),
_ => throw new ArgumentException($"Unknown index type: {type}")
};
return creator(indexData);
}
public async Task<IDirectoryIndex?> LoadOrCreateDirectoryIndexAsync(string rootPath)
{
try
{
var index = await LoadIndexAsync(IndexType.Directory, rootPath);
return index as IDirectoryIndex;
}
catch
{
return await CreateDirectoryIndexAsync(rootPath);
}
}
public async Task<IVaultIndex?> CreateVaultIndexAsync(string rootPath, MediaVaultType vaultType)
{
var vaultIndexData = new VaultIndexData(Path.GetFileName(rootPath), vaultType);
var index = new VaultIndex(vaultIndexData);
// Ensure directory exists and save the index
await FileUtils.MakeVaultDirectoryAsync(rootPath);
await SaveIndexAsync(rootPath, IndexType.Vault, index);
return index;
}
public async Task<IVaultIndex?> LoadOrCreateVaultIndexAsync(string rootPath, MediaVaultType vaultType)
{
try
{
var index = await LoadIndexAsync(IndexType.Vault, rootPath);
return index as IVaultIndex;
}
catch
{
return await CreateVaultIndexAsync(rootPath, vaultType);
}
}
public object CreateIndexData(IndexType type, IIndex index)
{
if (!_indexDataCreators.TryGetValue(type, out var creator))
{
throw new ArgumentException($"Unknown index type: {type}");
}
return creator(index);
}
public IIndex CreateIndexFromData(IndexType type, object indexData)
{
if (!_indexFromDataCreators.TryGetValue(type, out var creator))
{
throw new ArgumentException($"Unknown index type: {type}");
}
return creator(indexData);
}
private async Task SaveIndexAsync(string rootPath, IndexType type, IIndex index)
{
var indexPath = Path.Combine(rootPath, "index");
var indexData = CreateIndexData(type, index);
await FileUtils.PutObjectAsync(indexPath, indexData);
}
}
DeepDrftContent/FileDatabase/Services/IndexSystem.cs
-101
View File
@@ -1,101 +0,0 @@
using DeepDrftContent.FileDatabase.Abstractions;
using DeepDrftContent.FileDatabase.Models;
using DeepDrftContent.FileDatabase.Utils;
namespace DeepDrftContent.FileDatabase.Services;
/// <summary>
/// Enum representing different types of indexes
/// </summary>
public enum IndexType
{
Directory,
Vault
}
/// <summary>
/// Abstract base class for index containers
/// </summary>
public abstract class AbstractIndexContainer
{
protected IndexType Type { get; }
public string RootPath { get; }
private readonly IIndexDataFactory _indexDataFactory;
protected AbstractIndexContainer(string path, IndexType type, IIndexDataFactory? indexDataFactory = null)
{
RootPath = path;
Type = type;
_indexDataFactory = indexDataFactory ?? new IndexFactoryService();
}
public string GetKey() => Path.GetFileName(RootPath);
protected async Task SaveIndexAsync<T>(T index) where T : IIndex
{
var indexPath = Path.Combine(RootPath, "index");
var indexData = _indexDataFactory.CreateIndexData(Type, index);
await FileUtils.PutObjectAsync(indexPath, indexData);
}
}
/// <summary>
/// Abstract base class for directory containers that manage indexes
/// </summary>
public abstract class IndexDirectory : AbstractIndexContainer
{
protected IEntryQueryable Index { get; }
protected IndexDirectory(string rootPath, IndexType type, IEntryQueryable index, IIndexDataFactory? indexDataFactory = null)
: base(rootPath, type, indexDataFactory)
{
Index = index;
}
protected IReadOnlyList<string> GetIndexEntries() => Index.GetEntries();
public int GetIndexSize() => Index.GetEntriesSize();
public bool HasIndexEntry(string entryId) => Index.HasEntry(entryId);
}
/// <summary>
/// Directory index directory implementation
/// </summary>
public class DirectoryIndexDirectory : IndexDirectory
{
private readonly IDirectoryIndex _directoryIndex;
public DirectoryIndexDirectory(string rootPath, IDirectoryIndex index, IIndexDataFactory? indexDataFactory = null)
: base(rootPath, IndexType.Directory, index, indexDataFactory)
{
_directoryIndex = index;
}
protected async Task AddToIndexAsync(string entryId)
{
_directoryIndex.PutEntry(entryId);
await SaveIndexAsync(_directoryIndex);
}
}
/// <summary>
/// Vault index directory implementation
/// </summary>
public class VaultIndexDirectory : IndexDirectory
{
private readonly IVaultIndex _vaultIndex;
public VaultIndexDirectory(string rootPath, IVaultIndex index, IIndexDataFactory? indexDataFactory = null)
: base(rootPath, IndexType.Vault, index, indexDataFactory)
{
_vaultIndex = index;
}
protected async Task AddToIndexAsync(string entryId, MetaData metaData)
{
_vaultIndex.PutEntry(entryId, metaData);
await SaveIndexAsync(_vaultIndex);
}
}
DeepDrftContent/FileDatabase/Services/MediaVault.cs
-144
View File
@@ -1,144 +0,0 @@
using System.Text.RegularExpressions;
using DeepDrftContent.FileDatabase.Models;
using DeepDrftContent.FileDatabase.Utils;
namespace DeepDrftContent.FileDatabase.Services;
/// <summary>
/// Abstract base class for media vaults that store and manage media files
/// </summary>
public abstract class MediaVault : VaultIndexDirectory
{
protected MediaVault(string rootPath, VaultIndex index) : base(rootPath, index) { }
/// <summary>
/// Generates a media key from an entry key by sanitizing special characters
/// </summary>
protected string GetMediaKey(string entryKey, string extension)
{
var sanitized = Regex.Replace(entryKey, @"[^a-zA-Z0-9]", "-");
return $"{sanitized}{extension}";
}
/// <summary>
/// Gets the full file path for a media file from an entry key
/// </summary>
protected string GetMediaPathFromEntryKey(string entryKey, string extension)
{
return Path.Combine(RootPath, GetMediaKey(entryKey, extension));
}
/// <summary>
/// Gets the full file path for a media file from a media key
/// </summary>
protected string GetMediaPathFromMediaKey(string mediaKey)
{
return Path.Combine(RootPath, mediaKey);
}
/// <summary>
/// Adds a new entry to the vault with the specified media data (MediaVaultType inferred from media type)
/// </summary>
public async Task AddEntryAsync(string entryId, FileBinary media)
{
// Extract properties from media object based on type
var (buffer, extension) = ExtractMediaProperties(media);
// Infer MediaVaultType from the media object type
var vaultType = MediaVaultTypeMap.GetVaultType(media.GetType());
var mediaPath = GetMediaPathFromEntryKey(entryId, extension);
var metaData = MetaDataFactory.CreateFromMedia(vaultType, entryId, extension, media);
// Use string-based index operations
await AddToIndexAsync(entryId, metaData);
await FileUtils.PutFileAsync(mediaPath, buffer);
}
/// <summary>
/// Retrieves an entry from the vault (MediaVaultType inferred from T)
/// </summary>
public async Task<T?> GetEntryAsync<T>(string entryId) where T : FileBinary
{
// Infer MediaVaultType from the generic type T
var vaultType = MediaVaultTypeMap.GetVaultType<T>();
if (!HasIndexEntry(entryId))
return null;
if (Index is not VaultIndex vaultIndex)
return null;
var metaData = vaultIndex.GetEntry(entryId);
if (metaData == null)
return null;
var mediaPath = GetMediaPathFromEntryKey(metaData.MediaKey, metaData.Extension);
if (!FileUtils.FileExists(mediaPath))
return null;
var fileBinary = await FileUtils.FetchFileAsync(mediaPath);
var parameters = MediaParamsFactory.Create(vaultType, fileBinary, metaData);
var result = FileBinaryFactory.Create(vaultType, parameters);
return (T)result;
}
/// <summary>
/// Extracts buffer and extension from a media binary
/// </summary>
private static (byte[] buffer, string extension) ExtractMediaProperties(FileBinary media)
{
return media switch
{
ImageBinary imageBinary => (imageBinary.Buffer, imageBinary.Extension),
AudioBinary audioBinary => (audioBinary.Buffer, audioBinary.Extension),
MediaBinary mediaBinary => (mediaBinary.Buffer, mediaBinary.Extension),
FileBinary fileBinary => throw new ArgumentException($"FileBinary must be a specific media type (ImageBinary, AudioBinary, or MediaBinary), not base FileBinary"),
_ => throw new ArgumentException($"Unsupported media type: {media.GetType()}")
};
}
}
/// <summary>
/// Concrete implementation of MediaVault for image storage
/// </summary>
public class ImageVault : MediaVault
{
private ImageVault(string rootPath, VaultIndex index) : base(rootPath, index) { }
/// <summary>
/// Factory method to create an ImageVault instance
/// </summary>
public static async Task<ImageVault?> FromAsync(string rootPath)
{
var factoryService = new IndexFactoryService();
var index = await factoryService.LoadOrCreateVaultIndexAsync(rootPath, MediaVaultType.Image);
if (index != null)
{
return new ImageVault(rootPath, (VaultIndex)index);
}
return null;
}
}
public class AudioVault : MediaVault
{
private AudioVault(string rootPath, VaultIndex index) : base(rootPath, index) { }
public static async Task<AudioVault?> FromAsync(string rootPath)
{
var factoryService = new IndexFactoryService();
var index = await factoryService.LoadOrCreateVaultIndexAsync(rootPath, MediaVaultType.Audio);
if (index != null)
{
return new AudioVault(rootPath, (VaultIndex)index);
}
return null;
}
}
DeepDrftContent/FileDatabase/Services/MediaVaultFactory.cs
-17
View File
@@ -1,17 +0,0 @@
using DeepDrftContent.FileDatabase.Abstractions;
using DeepDrftContent.FileDatabase.Models;
namespace DeepDrftContent.FileDatabase.Services;
/// <summary>
/// Factory for creating media vaults
/// </summary>
public static class MediaVaultFactory
{
private static readonly IMediaTypeRegistry _registry = new SimpleMediaTypeRegistry();
public static async Task<MediaVault?> From(string rootPath, MediaVaultType mediaType)
{
return await _registry.CreateVaultAsync(mediaType, rootPath);
}
}
DeepDrftContent/FileDatabase/Services/SimpleMediaTypeRegistry.cs
-173
View File
@@ -1,173 +0,0 @@
using DeepDrftContent.FileDatabase.Abstractions;
using DeepDrftContent.FileDatabase.Models;
namespace DeepDrftContent.FileDatabase.Services;
/// <summary>
/// Simple dictionary-based registry for media type factories
/// </summary>
public class SimpleMediaTypeRegistry : IMediaTypeRegistry
{
private readonly Dictionary<MediaVaultType, Func<object, FileBinary>> _binaryFactories = new();
private readonly Dictionary<MediaVaultType, Func<object, FileBinary>> _binaryFromDtoFactories = new();
private readonly Dictionary<MediaVaultType, Func<FileBinary, FileBinaryDto>> _dtoFactories = new();
private readonly Dictionary<MediaVaultType, Func<string, string, object, MetaData>> _metaDataFromMediaFactories = new();
private readonly Dictionary<MediaVaultType, Func<FileBinary, MetaData, object>> _paramsFactories = new();
private readonly Dictionary<MediaVaultType, Func<string, Task<MediaVault?>>> _vaultFactories = new();
private readonly Dictionary<MediaVaultType, Type> _binaryTypes = new();
private readonly Dictionary<MediaVaultType, Type> _dtoTypes = new();
private readonly Dictionary<MediaVaultType, Type> _paramsTypes = new();
private readonly Dictionary<MediaVaultType, Type> _metaDataTypes = new();
// Reverse mapping: Type -> MediaVaultType
private readonly Dictionary<Type, MediaVaultType> _typeToVaultType = new();
public SimpleMediaTypeRegistry()
{
// Clean one-line registrations with generics - no reflection!
RegisterType<MediaBinary, MediaBinaryParams, MediaBinaryDto, MetaData>(
MediaVaultType.Media,
p => new MediaBinary(p),
dto => MediaBinary.From(dto),
binary => new MediaBinaryDto(binary),
(key, ext, _) => new MetaData(key, ext),
(binary, meta) => new MediaBinaryParams(binary.Buffer, binary.Size, meta.Extension));
RegisterType<ImageBinary, ImageBinaryParams, ImageBinaryDto, ImageMetaData>(
MediaVaultType.Image,
p => new ImageBinary(p),
dto => ImageBinary.From(dto),
binary => new ImageBinaryDto(binary),
(key, ext, media) => media is ImageBinary img ? new ImageMetaData(key, ext, img.AspectRatio) : new MetaData(key, ext),
(binary, meta) => meta is ImageMetaData imgMeta
? new ImageBinaryParams(binary.Buffer, binary.Size, meta.Extension, imgMeta.AspectRatio)
: throw new ArgumentException("ImageBinary requires ImageMetaData"),
async path => await ImageVault.FromAsync(path));
RegisterType<AudioBinary, AudioBinaryParams, AudioBinaryDto, AudioMetaData>(
MediaVaultType.Audio,
p => new AudioBinary(p),
dto => AudioBinary.From(dto),
binary => new AudioBinaryDto(binary),
(key, ext, media) => media is AudioBinary audio ? new AudioMetaData(key, ext, audio.Duration, audio.Bitrate) : new MetaData(key, ext),
(binary, meta) => meta is AudioMetaData audioMeta
? new AudioBinaryParams(binary.Buffer, binary.Size, meta.Extension, audioMeta.Duration, audioMeta.Bitrate)
: throw new ArgumentException("AudioBinary requires AudioMetaData"),
async path => await AudioVault.FromAsync(path));
}
private void RegisterType<TBinary, TParams, TDto, TMetaData>(
MediaVaultType vaultType,
Func<TParams, TBinary> binaryFactory,
Func<TDto, TBinary> binaryFromDtoFactory,
Func<TBinary, TDto> dtoFactory,
Func<string, string, object, MetaData> metaDataFactory,
Func<FileBinary, MetaData, object> paramsFactory,
Func<string, Task<MediaVault?>>? vaultFactory = null)
where TBinary : FileBinary
where TParams : FileBinaryParams
where TDto : FileBinaryDto
where TMetaData : MetaData
{
_binaryFactories[vaultType] = p => binaryFactory((TParams)p);
_binaryFromDtoFactories[vaultType] = dto => binaryFromDtoFactory((TDto)dto);
_dtoFactories[vaultType] = binary => dtoFactory((TBinary)binary);
_metaDataFromMediaFactories[vaultType] = metaDataFactory;
_paramsFactories[vaultType] = paramsFactory;
_binaryTypes[vaultType] = typeof(TBinary);
_dtoTypes[vaultType] = typeof(TDto);
_paramsTypes[vaultType] = typeof(TParams);
_metaDataTypes[vaultType] = typeof(TMetaData);
// Populate reverse mapping
_typeToVaultType[typeof(TBinary)] = vaultType;
if (vaultFactory != null)
_vaultFactories[vaultType] = vaultFactory;
}
// Public interface implementation - allows external registration
public void RegisterMediaType<TBinary, TParams, TDto, TMetaData, TVault>(MediaVaultType vaultType)
where TBinary : FileBinary
where TParams : FileBinaryParams
where TDto : FileBinaryDto
where TMetaData : MetaData
{
// For now, we can't auto-generate the factories without reflection
// This would need to be implemented if external registration is needed
throw new NotImplementedException("Use RegisterType method for internal registration. External registration not yet implemented.");
}
public FileBinary CreateBinary(MediaVaultType vaultType, object parameters)
{
return _binaryFactories.TryGetValue(vaultType, out var factory)
? factory(parameters)
: throw new ArgumentException($"Unknown vault type: {vaultType}");
}
public FileBinary CreateBinaryFromDto(MediaVaultType vaultType, object dto)
{
return _binaryFromDtoFactories.TryGetValue(vaultType, out var factory)
? factory(dto)
: throw new ArgumentException($"Unknown vault type: {vaultType}");
}
public FileBinaryDto CreateDto(MediaVaultType vaultType, FileBinary binary)
{
return _dtoFactories.TryGetValue(vaultType, out var factory)
? factory(binary)
: throw new ArgumentException($"Unknown vault type: {vaultType}");
}
public MetaData CreateMetaDataFromMedia(MediaVaultType vaultType, string entryKey, string extension, object media)
{
return _metaDataFromMediaFactories.TryGetValue(vaultType, out var factory)
? factory(entryKey, extension, media)
: throw new ArgumentException($"Unknown vault type: {vaultType}");
}
public object CreateParams(MediaVaultType vaultType, FileBinary fileBinary, MetaData metaData)
{
return _paramsFactories.TryGetValue(vaultType, out var factory)
? factory(fileBinary, metaData)
: throw new ArgumentException($"Unknown vault type: {vaultType}");
}
public async Task<MediaVault?> CreateVaultAsync(MediaVaultType vaultType, string rootPath)
{
return _vaultFactories.TryGetValue(vaultType, out var factory)
? await factory(rootPath)
: null;
}
public Type GetBinaryType(MediaVaultType vaultType) =>
_binaryTypes.TryGetValue(vaultType, out var type) ? type : throw new ArgumentException($"Unknown vault type: {vaultType}");
public Type GetDtoType(MediaVaultType vaultType) =>
_dtoTypes.TryGetValue(vaultType, out var type) ? type : throw new ArgumentException($"Unknown vault type: {vaultType}");
public Type GetParamsType(MediaVaultType vaultType) =>
_paramsTypes.TryGetValue(vaultType, out var type) ? type : throw new ArgumentException($"Unknown vault type: {vaultType}");
public Type GetMetaDataType(MediaVaultType vaultType) =>
_metaDataTypes.TryGetValue(vaultType, out var type) ? type : throw new ArgumentException($"Unknown vault type: {vaultType}");
public MediaVaultType GetVaultType(Type binaryType)
{
if (_typeToVaultType.TryGetValue(binaryType, out var vaultType))
return vaultType;
// Check inheritance hierarchy for derived types
foreach (var kvp in _typeToVaultType)
{
if (kvp.Key.IsAssignableFrom(binaryType))
return kvp.Value;
}
throw new ArgumentException($"Cannot infer MediaVaultType for {binaryType.Name}. Type not registered.");
}
public MediaVaultType GetVaultType<T>() where T : FileBinary
=> GetVaultType(typeof(T));
}