Self-aggregating DetermineAction emitter drops implicit event-constructor Create when ShouldDelete is present

[bugs-wkettlitz]

Symptom

For a self-aggregating type that uses an implicit constructor as its "Create" handler (rather than a named static Create(...) method) and also declares ShouldDelete, the generated DetermineAction dispatcher silently omits the Create event from its switch. No diagnostic, no compile error — the code compiles fine, but the constructor is never invoked. Once any subsequent Apply-only event arrives, the aggregate is built via RuntimeHelpers.GetUninitializedObject(typeof(T)) instead, so every field the constructor would have set (including things like collection-initialized properties) stays at its CLR default. In our repro this manifested as a NullReferenceException inside a subsequent Apply method that assumed a list property was initialized, and in general silently produces a wrong/blank aggregate.

Root cause

src/JasperFx.Events.SourceGenerator/EvolverCodeEmitter.cs:

• EmitSelfAggregatingEvolve / EmitSelfAggregatingEvolveAsync (used when the aggregate has no ShouldDelete) build allEventTypes via:

  info.Methods.Select(m => m.EventType)
      .Concat(info.EventConstructors.Select(c => c.EventType))
      .Distinct<ITypeSymbol>(SymbolEqualityComparer.Default)

  — correctly folding in constructor-based Create handlers from info.EventConstructors.

• EmitSelfAggregatingDetermineAction (used when the aggregate does declare ShouldDelete) builds its switch purely from info.Methods (i.e., named Create/Apply/ShouldDelete methods) and never references info.EventConstructors at all. Any event type whose only handler is an implicit constructor is entirely missing from the emitted switch's case arms.

Repro

public static class TempGuidEvents
{
    public sealed record Created(Guid Id, string Name);
    public sealed record TagAdded(Guid Id, string Tag);
    public sealed record Deleted(Guid Id);
}

public sealed class TempGuidAggregate
{
    public Guid Id { get; set; }
    public string Name { get; set; } = "";
    public List<string> Tags { get; set; } = [];

    // implicit constructor-based Create
    public TempGuidAggregate(TempGuidEvents.Created @event)
    {
        Id = @event.Id;
        Name = @event.Name;
    }

    public void Apply(TempGuidEvents.TagAdded @event)
    {
        Tags.Add(@event.Tag); // NRE at runtime: Tags is never initialized
    }

    public bool ShouldDelete(TempGuidEvents.Deleted _) => true;
}

Registered with options.Snapshot<TempGuidAggregate>(SnapshotLifecycle.Inline) (Marten 9.30.0 / JasperFx.Events 2.56.0). Starting a stream with Created then appending TagAdded throws:

JasperFx.Events.Daemon.ApplyEventException: Failure to apply event #0 Id(...)
 ---> System.NullReferenceException: Object reference not set to an instance of an object.
   at TempGuidAggregate.Apply(TagAdded @event)
   at <generated>.TempGuidAggregateEvolver.DetermineAction(...)

The emitted evolver's EventTypes / switch only lists TagAdded and Deleted — Created is entirely absent, confirmed by inspecting the generated .g.cs (via EmitCompilerGeneratedFiles):

public global::System.Type[] EventTypes => [typeof(TagAdded), typeof(Deleted)];

public (TempGuidAggregate?, ActionType) DetermineAction(TempGuidAggregate? snapshot, Guid id, IReadOnlyList<IEvent> events)
{
    var exists = snapshot != null;
    foreach (var e in events)
    {
        switch (e.Data)
        {
            case Deleted data:
                if (snapshot != null && snapshot.ShouldDelete(data)) snapshot = null;
                break;
            case TagAdded data:
                snapshot ??= (TempGuidAggregate)RuntimeHelpers.GetUninitializedObject(typeof(TempGuidAggregate));
                snapshot.Apply(data);
                break;
            // no case for Created at all
        }
    }
    ...
}

Confirmed independent of the aggregate's Id type (reproduces identically for Guid and for a custom value-type Id struct) — the trigger is purely "constructor-based Create" + "ShouldDelete present", nothing to do with identity typing.

Suggested fix

EmitSelfAggregatingDetermineAction should fold info.EventConstructors into its dispatch the same way the Evolve emitters already do, e.g. building the Create-eligible event set from info.Methods.Where(m => m.MethodName is "Create" or "Apply").Select(...).Concat(info.EventConstructors.Select(c => c.EventType)), and emitting a case arm per constructor that calls new T(data) guarded by snapshot == null (mirroring the existing Methods-based Create arm shape).

Workaround

Convert the implicit constructor to an explicit static T Create(TEvent @event) method — this routes through info.Methods discovery, which EmitSelfAggregatingDetermineAction does consult, and produces correct output.

Versions

• JasperFx.Events 2.56.0
• JasperFx.Events.SourceGenerator (bundled with Marten 9.30.0)
• .NET 10 preview SDK

[bugs-wkettlitz]

Other workaround:

Register Delete event in projection settings instead:

options.Snapshot<MyProjection>(
    SnapshotLifecycle.Inline,
    x =>
    {
        var projection = (SingleStreamProjection<MyProjection, MyProjectionId>)x;
        projection.DeleteEvent<Deleted>();
    }
);

[jeremydmiller]

@bugs-wkettlitz Good times. Fix coming soon.

[jeremydmiller]

Fixed in JasperFx 2.61.0, published to nuget.org just now. Your diagnosis was exactly right — thank you for the emitted .g.cs, it made this a very short investigation.

EmitSelfAggregatingDetermineAction now folds info.EventConstructors into its dispatch the way the Evolve emitters already did, with a snapshot = new T(data); arm under the same snapshot == null guard (#735).

Two things beyond the literal report, both found while fixing it:

1. EmitSelfAggregatingCreateApplyStatements had the same gap for an event covered by both an event constructor and a ShouldDelete predicate that returns false — that body belongs in the delete arm's else, and the constructor was missing from it.
2. EmitEventTypesProperty dropped constructor event types from the generated EventTypes on every self-aggregating path, not just the ShouldDelete one. So an aggregate with a constructor Create and no ShouldDelete — which dispatched correctly — was still advertising an incomplete event list. That is fixed too.

Both of your workarounds can be reverted on this version.

Verified end-to-end against Marten rather than only in the generator's own tests: your shape fails 4/4 on 2.60.x (inline, async and live aggregation) with the ApplyEventException -> NullReferenceException you reported, and passes 4/4 on 2.61.0. Marten's EventSourcingTests (2002) and DaemonTests (319) are green on the bump. The Marten-side regression test is JasperFx/marten#5322.