Skip to content

Releases

v7.1.1

Choose a tag to compare

@github-actions github-actions released this 15 Nov 14:56

7.1.1 (2026-11-15)

Bug Fixes

  • deps: the Entity Framework family without known vulnerabilities (#9) (ad1ee75), closes #8

v7.1.0

Choose a tag to compare

@github-actions github-actions released this 15 Nov 14:15

7.1.0 (2026-11-15)

Features

  • move to eQuantic.Core.Data 7.1 and the Entity Framework family on it (#7) (78572f0), closes #6

v7.0.0

Choose a tag to compare

@github-actions github-actions released this 14 Nov 23:20

7.0.0 (2026-11-14)

⚠ BREAKING CHANGES

  • a project that calls ApplyDataModelConventions, HasJsonData or DataModelConventionOptions with only eQuantic.Core.Persistence referenced now needs eQuantic.Core.Persistence.EntityFramework (a provider package brings it). A project that used Lamar through eQuantic.Core.Application, or Humanizer through eQuantic.Core.Persistence, references it itself.

Features

  • the aggregate seam without Entity Framework, and Application without Lamar (#5) (1c2b88a)

v6.0.0

Choose a tag to compare

@github-actions github-actions released this 14 Nov 19:58

6.0.0 (2026-11-14)

⚠ BREAKING CHANGES

  • core-ddd now depends on eQuantic.Core.Data 7.0, whose repositories change what some existing calls do (a duplicate key surfaces as DuplicateKeyException at commit, among others). Applications get that behaviour through core-ddd, and must reference the 7.0 line of eQuantic.Core.Data and its EF family.

Features

  • move to eQuantic.Core.Data 7.0 and publish through trusted publishing (#3) (9d05ae6)

v5.0.1

Choose a tag to compare

@github-actions github-actions released this 25 Jul 19:50

5.0.1 (2026-07-25)

Bug Fixes

  • resolve build warnings and refresh the README for v5.0.0 (31e5451)

v5.0.0

Choose a tag to compare

@github-actions github-actions released this 24 Jul 19:56

v5.0.0 — the tactical DDD release

The domain layer stops being a bag of base classes with an Id and becomes the set of blocks a DDD model actually needs. Persistence gains the seam that stores those blocks without letting the domain leak into it.

🧩 Domain — the tactical blocks

Pure domain types. They know nothing about persistence, and nothing about your database.

  • ValueObject — structural equality from the components you declare. Two Money(10, "USD") are the same value; a Money is never equal to a Weight with the same number.
  • AggregateRoot<TKey> — the consistency boundary and the source of domain events, built on eQuantic.Core.DomainEvents. It raises events, exposes them, and is identified by its key.
  • EntityBase<TKey> — now compares by identity: same type + same non-default key means the same entity. An entity whose key is still the default is transient and compares by reference, because it has no identity yet.
public sealed class Order : AggregateRoot<Guid>
{
    public static Order Place(Guid id, string customer)
    {
        var order = new Order(id, customer);
        order.RaiseDomainEvent(new OrderPlaced(id));
        return order;
    }
}

🔌 Persistence — the seam, without the leak

The domain and the DataModel stay separate types with a mapper between them: IDomainEntity belongs to the domain, IEntity to the DataModel, and neither borrows the other's contract.

  • AggregateRepository<TAggregate, TData, TKey> maps an aggregate to its DataModel with eQuantic.Mapper and hands the DataModel to the repository. Your application code speaks Order; storage only ever sees OrderData.
  • DomainUnitOfWork drains the written aggregates' domain events into the outbox in the same transaction as the write — the aggregate and its events commit together, or neither does. No event is lost to a crash between "saved" and "published".
  • Audit conventions resolve the acting user from IApplicationContext, so CreatedById/UpdatedById/DeletedById are stamped alongside the timestamps.
await orders.AddAsync(Order.Place(id, "acme"));   // domain in
await unitOfWork.CommitAsync();                   // DataModel + its events, one transaction

🔎 Application — the query string reaches the store typed

PagedListRequest<T>.ToQueryOptions() and .ToPageRequest() turn a bound HTTP request — filterBy=total:gt(100)&orderBy=total:desc — into the query options the engine executes. Both sides are built on eQuantic.Linq, so the filter compiles to the same predicate and the sorts pass straight through.


⚠️ Breaking change

EntityBase<TKey> now compares by identity instead of by reference. Sets, dictionaries and Distinct() treat two instances carrying the same key as one entity. If your code relied on reference equality for entities — deduplicating by instance, or keying a dictionary by object identity — that behaviour changes silently. Review those spots before upgrading.


Full changelog: v4.0.0...v5.0.0