Upcasters

src/Marten/Events/EventDocumentStorage.cs

@@ -32,7 +32,7 @@ namespace Marten.Events
     /// mapping for the event store in a running system. The actual implementation of this
     /// base type is generated and compiled at runtime by Marten
     /// </summary>
-    public abstract class EventDocumentStorage : IEventStorage
+    public abstract class EventDocumentStorage: IEventStorage
     {
         private readonly EventQueryMapping _mapping;
         private readonly ISerializer _serializer;
@@ -103,6 +103,7 @@ public IDeletion HardDeleteForDocument(IEvent document, string tenantId)
 
         public string FromObject { get; }
         public Type SelectedType => typeof(IEvent);
+
         public void WriteSelectClause(CommandBuilder sql)
         {
             sql.Append(_selectClause);
@@ -118,7 +119,8 @@ public ISelector BuildSelector(IMartenSession session)
             return this;
         }
 
-        public IQueryHandler<T> BuildHandler<T>(IMartenSession session, Statement topStatement, Statement currentStatement)
+        public IQueryHandler<T> BuildHandler<T>(IMartenSession session, Statement topStatement,
+            Statement currentStatement)
         {
             return LinqHandlerBuilder.BuildHandler<IEvent, T>(this, topStatement);
         }
@@ -130,6 +132,7 @@ public ISelectClause UseStatistics(QueryStatistics statistics)
 
         public Type SourceType => typeof(IEvent);
         public IFieldMapping Fields { get; }
+
         public ISqlFragment FilterDocuments(QueryModel model, ISqlFragment query)
         {
             var shouldBeTenanted = Events.TenancyStyle == TenancyStyle.Conjoined && !query.SpecifiesTenant();
@@ -157,10 +160,11 @@ public ISqlFragment DefaultWhereFragment()
 
         public object IdentityFor(IEvent document)
         {
-            return Events.StreamIdentity == StreamIdentity.AsGuid ? (object) document.Id : document.StreamKey;
+            return Events.StreamIdentity == StreamIdentity.AsGuid ? (object)document.Id : document.StreamKey;
         }
 
         public Type IdType { get; }
+
         public Guid? VersionFor(IEvent document, IMartenSession session)
         {
             return null;
@@ -201,7 +205,9 @@ public IStorageOperation Overwrite(IEvent document, IMartenSession session, stri
             throw new NotSupportedException();
         }
 
-        public abstract IStorageOperation AppendEvent(EventGraph events, IMartenSession session, StreamAction stream, IEvent e);
+        public abstract IStorageOperation AppendEvent(EventGraph events, IMartenSession session, StreamAction stream,
+            IEvent e);
+
         public abstract IStorageOperation InsertStream(StreamAction stream);
         public abstract IQueryHandler<StreamState> QueryForStream(StreamAction stream);
         public abstract IStorageOperation UpdateStreamVersion(StreamAction stream);
@@ -213,18 +219,11 @@ public IEvent Resolve(DbDataReader reader)
             if (mapping == null)
             {
                 var dotnetTypeName = reader.GetFieldValue<string>(2);
-                if (dotnetTypeName.IsEmpty())
-                {
-                    throw new UnknownEventTypeException(eventTypeName);
-                }
 
-                var type = Events.TypeForDotNetName(dotnetTypeName);
-                mapping = Events.EventMappingFor(type);
+                mapping = eventMappingForDotNetTypeName(dotnetTypeName, eventTypeName);
             }
 
-            var data = _serializer.FromJson(mapping.DocumentType, reader, 0).As<object>();
-
-            var @event = mapping.Wrap(data);
+            var @event = deserializeEvent(mapping, reader);
 
             ApplyReaderDataToEvent(reader, @event);
 
@@ -240,25 +239,11 @@ public async Task<IEvent> ResolveAsync(DbDataReader reader, CancellationToken to
             if (mapping == null)
             {
                 var dotnetTypeName = await reader.GetFieldValueAsync<string>(2, token).ConfigureAwait(false);
-                if (dotnetTypeName.IsEmpty())
-                {
-                    throw new UnknownEventTypeException(eventTypeName);
-                }
-                Type type;
-                try
-                {
-                    type = Events.TypeForDotNetName(dotnetTypeName);
-                }
-                catch (ArgumentNullException)
-                {
-                    throw new UnknownEventTypeException(dotnetTypeName);
-                }
-                mapping = Events.EventMappingFor(type);
-            }
 
-            var data = await _serializer.FromJsonAsync(mapping.DocumentType, reader, 0, token).ConfigureAwait(false);
+                mapping = eventMappingForDotNetTypeName(dotnetTypeName, eventTypeName);
+            }
 
-            var @event = mapping.Wrap(data);
+            var @event = await deserializeEventAsync(mapping, reader, token).ConfigureAwait(false);
 
             await ApplyReaderDataToEventAsync(reader, @event, token).ConfigureAwait(false);
 
@@ -267,6 +252,43 @@ public async Task<IEvent> ResolveAsync(DbDataReader reader, CancellationToken to
 
         public abstract Task ApplyReaderDataToEventAsync(DbDataReader reader, IEvent e, CancellationToken token);
 
+        private EventMapping eventMappingForDotNetTypeName(string dotnetTypeName, string eventTypeName)
+        {
+            if (dotnetTypeName.IsEmpty())
+            {
+                throw new UnknownEventTypeException(eventTypeName);
+            }
+
+            Type type;
+            try
+            {
+                type = Events.TypeForDotNetName(dotnetTypeName);
+            }
+            catch (ArgumentNullException)
+            {
+                throw new UnknownEventTypeException(dotnetTypeName);
+            }
+
+            return Events.EventMappingFor(type);
+        }
+
+        private IEvent deserializeEvent(EventMapping mapping, DbDataReader reader)
+        {
+            var data = mapping.Transformation != null?
+                mapping.Transformation.FromDbDataReader(_serializer, reader, 0)
+                : _serializer.FromJson(mapping.DocumentType, reader, 0);
+
+            return mapping.Wrap(data);
+        }
 
+        private async ValueTask<IEvent> deserializeEventAsync(EventMapping mapping, DbDataReader reader,
+            CancellationToken token)
+        {
+            var data = mapping.Transformation != null ?
+                await mapping.Transformation.FromDbDataReaderAsync(_serializer, reader, 0, token).ConfigureAwait(false)
+                : await _serializer.FromJsonAsync(mapping.DocumentType, reader, 0, token).ConfigureAwait(false);
+
+            return mapping.Wrap(data);
+        }
     }
 }

src/Marten/Events/EventGraph.cs

@@ -1,19 +1,20 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Baseline;
 using Baseline.ImTools;
 using Marten.Events.Daemon;
-using Marten.Events.Operations;
 using Marten.Events.Projections;
 using Marten.Events.Schema;
 using Marten.Exceptions;
 using Marten.Internal;
+using Marten.Services.Json.Transformations;
 using Marten.Storage;
 using Marten.Util;
 using NpgsqlTypes;
 using Weasel.Core;
-using Weasel.Postgresql;
 
 namespace Marten.Events
 {
@@ -30,7 +31,6 @@ public partial class EventGraph: IEventStoreOptions, IReadOnlyEventStoreOptions
 
         private readonly Lazy<IProjection[]> _inlineProjections;
 
-
         private readonly Ref<ImHashMap<string, Type>> _nameToType = Ref.Of(ImHashMap<string, Type>.Empty);
 
         private string _databaseSchemaName;
@@ -130,6 +130,86 @@ public void MapEventType(Type eventType, string eventTypeName)
             eventMapping.EventTypeName = eventTypeName;
         }
 
+        public IEventStoreOptions Upcast<TEvent>(
+            string eventTypeName,
+            JsonTransformation jsonTransformation = null
+        ) where TEvent : class =>
+            Upcast(typeof(TEvent), eventTypeName, jsonTransformation);
+
+        public IEventStoreOptions Upcast(
+            Type eventType,
+            string eventTypeName,
+            JsonTransformation jsonTransformation = null
+        )
+        {
+            var eventMapping = EventMappingFor(eventType);
+            eventMapping.EventTypeName = eventTypeName;
+            eventMapping.Transformation = jsonTransformation;
+
+            return this;
+        }
+
+        public IEventStoreOptions Upcast<TOldEvent, TEvent>(
+            string eventTypeName,
+            Func<TOldEvent, TEvent> upcast
+        ) where TOldEvent : class where TEvent : class
+        {
+            var eventMapping = EventMappingFor<TEvent>();
+            eventMapping.EventTypeName = eventTypeName;
+            eventMapping.Transformation = JsonTransformations.Upcast(upcast);
+
+            return this;
+        }
+
+        public IEventStoreOptions Upcast<TOldEvent, TEvent>(
+            Func<TOldEvent, TEvent> upcast
+        ) where TOldEvent : class where TEvent : class =>
+            Upcast(typeof(TOldEvent).GetEventTypeName(), upcast);
+
+        public IEventStoreOptions Upcast<TOldEvent, TEvent>(
+            string eventTypeName,
+            Func<TOldEvent, CancellationToken, Task<TEvent>> upcastAsync
+        ) where TOldEvent : class where TEvent : class
+        {
+            var eventMapping = EventMappingFor<TEvent>();
+            eventMapping.EventTypeName = eventTypeName;
+            eventMapping.Transformation = JsonTransformations.Upcast(upcastAsync);
+
+            return this;
+        }
+
+        public IEventStoreOptions Upcast<TOldEvent, TEvent>(
+            Func<TOldEvent, CancellationToken, Task<TEvent>> upcastAsync
+        ) where TOldEvent : class where TEvent : class =>
+            Upcast(typeof(TOldEvent).GetEventTypeName(), upcastAsync);
+
+        public IEventStoreOptions Upcast(params IEventUpcaster[] upcasters)
+        {
+            foreach (var upcaster in upcasters)
+            {
+                Upcast(
+                    upcaster.EventType,
+                    upcaster.EventTypeName,
+                    new JsonTransformation(upcaster.FromDbDataReader, upcaster.FromDbDataReaderAsync)
+                );
+            }
+
+            return this;
+        }
+
+        public IEventStoreOptions Upcast<TUpcaster>() where TUpcaster : IEventUpcaster, new()
+        {
+            var upcaster = new TUpcaster();
+
+            Upcast(
+                upcaster.EventType,
+                upcaster.EventTypeName,
+                new JsonTransformation(upcaster.FromDbDataReader, upcaster.FromDbDataReaderAsync)
+            );
+
+            return this;
+        }
+
         /// <summary>
         ///     Override the database schema name for event related tables. By default this
         ///     is the same schema as the document storage
@@ -207,7 +287,6 @@ internal string AggregateAliasFor(Type aggregateType)
             return alias;
         }
 
-
         internal string GetStreamIdDBType()
         {
             return StreamIdentity == StreamIdentity.AsGuid ? "uuid" : "varchar";
@@ -256,7 +335,6 @@ internal IEventStorage EnsureAsGuidStorage(IMartenSession session)
             return session.EventStorage();
         }
 
-
         internal IEvent BuildEvent(object eventData)
         {
             if (eventData == null)

src/Marten/Events/EventMapping.cs

@@ -6,7 +6,6 @@
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
-using Baseline;
 using LamarCodeGeneration;
 using Marten.Events.Archiving;
 using Marten.Internal;
@@ -22,6 +21,7 @@
 using Weasel.Postgresql;
 using Marten.Schema;
 using Marten.Services;
+using Marten.Services.Json.Transformations;
 using Marten.Storage;
 using Marten.Util;
 using NpgsqlTypes;
@@ -52,7 +52,7 @@ protected EventMapping(EventGraph parent, Type eventType)
             _parent = parent;
             DocumentType = eventType;
 
-            EventTypeName = eventType.IsGenericType ? eventType.ShortNameInCode() : DocumentType.Name.ToTableAlias();
+            EventTypeName = eventType.GetEventTypeName();
             IdMember = DocumentType.GetProperty(nameof(IEvent.Id));
 
             _inner = new DocumentMapping(eventType, parent.Options);
@@ -65,14 +65,14 @@ protected EventMapping(EventGraph parent, Type eventType)
                 filter = filter.CombineAnd(CurrentTenantFilter.Instance);
             }
 
-
             _defaultWhereFragment = filter;
         }
 
         Type IEventType.EventType => DocumentType;
 
         public string DotNetTypeName { get; set; }
 
+        public JsonTransformation? Transformation { get; set; }
 
         IDocumentMapping IDocumentMapping.Root => this;
         public Type DocumentType { get; }
@@ -301,4 +301,10 @@ public override IEvent Wrap(object data)
             };
         }
     }
+
+    internal static class EventMappingExtensions
+    {
+        internal static string GetEventTypeName(this Type eventType) =>
+            eventType.IsGenericType ? eventType.ShortNameInCode() : eventType.Name.ToTableAlias();
+    }
 }