diff --git a/.agents/skills/.gitignore b/.agents/skills/.gitignore new file mode 100644 index 00000000..73b8c381 --- /dev/null +++ b/.agents/skills/.gitignore @@ -0,0 +1,7 @@ +# This directory is copied into consuming repositories by Purview.DotNetProjectSdk +# so AI agents can discover the bundled skills. +# Keep this file if you want the generated skill content to stay out of source control. +# To disable generation entirely, set false +# in your project or Directory.Build.props. +* +!.gitignore diff --git a/.agents/skills/changesets-prerelease/SKILL.md b/.agents/skills/changesets-prerelease/SKILL.md new file mode 100644 index 00000000..4e3b7162 --- /dev/null +++ b/.agents/skills/changesets-prerelease/SKILL.md @@ -0,0 +1,36 @@ +--- +name: changesets-prerelease +description: Create and apply a prerelease bump using Changesets CLI, with the new changeset markdown summarizing the actual changes since the last shipped release. +--- + +# Changesets Prerelease Skill + +Use this skill when preparing the next prerelease version in this repository. + +## Steps + +1. Add a new changeset: + - `npx @changesets/cli add --empty --message ""` + - update the generated `.changeset/*.md` frontmatter with: + - `"purview-eventsourcing": patch` + - replace the placeholder body with a concise summary of the **actual user-facing changes since the last shipped release**, not just a generic "prepare prerelease" note. + - if the immediately previous prerelease number (for example `.24`) has **not** been released yet and you are preparing `.25`, the new markdown should still describe the cumulative changes that matter for the next published prerelease. +2. Bump versions/changelog: + - `npx @changesets/cli version` +3. Commit the resulting changes (`package.json`, `CHANGELOG.md`, and consumed `.changeset` files). + +## Writing the new `.changeset/*.md` body + +- Summarize the functional changes that should appear in the changelog for the next published prerelease. +- Prefer short release-note language such as: + - fixed SQL snapshot translation for directly mapped complex mirror properties + - clarified provider documentation for scalar value object query behavior + - aligned repo-local agent skills and instructions +- Do **not** leave the body as a procedural placeholder such as `Prepare next prerelease` unless there were truly no meaningful changes. +- If multiple unreleased prerelease bumps exist locally, write the new file so the generated changelog entry remains useful to an external consumer reading the next shipped release. + +## Notes + +- Repository currently runs prerelease mode with `tag: prerelease` (`.changeset/pre.json`). +- Releasing is done from `package.json` version in the `release.yml` workflow. +- In prerelease mode, `changeset version` can record a changeset in `.changeset/pre.json` even if the new file was created with placeholder/empty content first. If that happens, correct the `.md` frontmatter/body before finalizing the release notes so the next shipped prerelease entry is accurate. diff --git a/.github/skills/dotnet-tunit/SKILL.md b/.agents/skills/dotnet-tunit/SKILL.md similarity index 100% rename from .github/skills/dotnet-tunit/SKILL.md rename to .agents/skills/dotnet-tunit/SKILL.md diff --git a/.github/skills/git-conventional-commits/SKILL.md b/.agents/skills/git-conventional-commits/SKILL.md similarity index 100% rename from .github/skills/git-conventional-commits/SKILL.md rename to .agents/skills/git-conventional-commits/SKILL.md diff --git a/.github/skills/lefthook-integration/SKILL.md b/.agents/skills/lefthook-integration/SKILL.md similarity index 100% rename from .github/skills/lefthook-integration/SKILL.md rename to .agents/skills/lefthook-integration/SKILL.md diff --git a/.agents/skills/tunit-test-runner/SKILL.md b/.agents/skills/tunit-test-runner/SKILL.md new file mode 100644 index 00000000..f3b6270e --- /dev/null +++ b/.agents/skills/tunit-test-runner/SKILL.md @@ -0,0 +1,108 @@ +--- +name: tunit-test-runner +description: >- + Run, filter, and select TUnit tests through `dotnet test`. Use this whenever + executing .NET tests in a project that depends on TUnit (built on + Microsoft.Testing.Platform / MTP, not VSTest), when `dotnet test --filter` + reports "Zero tests ran", or when tests must be narrowed by assembly, + namespace, class, test name, [Category], or other custom properties. Covers + the `--treenode-filter` path-based query syntax, its operators, the `--` + separator rules across SDK versions, and common 0-tests troubleshooting. +license: MIT +--- + +# Running TUnit tests with `dotnet test` + +## The one rule that matters most + +TUnit runs on **Microsoft.Testing.Platform (MTP)**, not VSTest. The reflexive +`dotnet test --filter "Category=X"` **does not work**: MTP silently rejects the +`--filter` flag, prints its own help text, and exits with `Zero tests ran`. That +looks like a passing-but-empty run or a config failure, but it is just an +unrecognised flag. **Never reach for `--filter` on a TUnit project.** Use +`--treenode-filter` instead. + +| Other frameworks (VSTest) | TUnit (MTP) | +| ------------------------------------------ | ---------------------------------------------------- | +| `--filter "Category=Integration"` | `--treenode-filter "/*/*/*/*[Category=Integration]"` | +| `--filter "FullyQualifiedName~LoginTests"` | `--treenode-filter "/*/*/LoginTests/*"` | +| `--filter "Name=AcceptCookiesTest"` | `--treenode-filter "/*/*/*/AcceptCookiesTest"` | + +## How to invoke it + +Prefer `dotnet test` over `dotnet run`: `dotnet test` builds and runs every +targeted TFM automatically and works against a `.csproj`, `.sln`, or `.slnx`, +whereas `dotnet run` only runs a single TFM. + +The catch is the `--` separator, which depends on the SDK: + +```bash +# Universal form — works on every SDK. Use this by default. +dotnet test -- --treenode-filter "/*/*/LoginTests/*" + +# .NET 10+ SDK only — the platform flag can be passed directly. +dotnet test --treenode-filter "/*/*/LoginTests/*" +``` + +Anything after `--` is passed through to the TUnit test runner rather than to +the `dotnet test` command itself. Flags from extension packages +(`--coverage`, `--report-trx`, `--results-directory`, etc.) **must** also sit +after the `--`: + +```bash +dotnet test --configuration Release --no-build \ + -- --treenode-filter "/*/*/*/*[Category=Unit]" --coverage --report-trx +``` + +> Run with no filter to execute everything: `dotnet test`. + +## The `--treenode-filter` syntax + +A filter is a path with four segments, optionally annotated with a property +group on any segment: + +``` +////[Property=Value] +``` + +Use `*` as a wildcard in any segment. The classic "run all tests" filter is +`/*/*/*/*` — four wildcards, one per level. + +### Operators + +| Operator | Meaning | Example | +| -------- | --------------------------------------------- | -------------------------------------- | +| `*` | Wildcard within a segment | `/*/*/LoginTests*/*` | +| `=` | Property equals (exact) | `/*/*/*/*[Category=Unit]` | +| `!=` | Property not equal (exclude) | `/*/*/*/*[Category!=Slow]` | +| `&` | AND — within one segment / property group | `/**[(Category=Unit)&(Priority=High)]` | +| `\|` | OR — within one segment / property group | `/*/*/(LoginTests)\|(SignupTests)/*` | +| `**` | Match any path depth (must be at the **end**) | `/MyAssembly/**` | + +### Two grammar rules that are easy to get wrong + +1. **`&` and `|` operate _inside a single segment or property group_, and each + side must be wrapped in parentheses.** They do not join two complete paths. +2. **Only one property group `[...]` is allowed per path segment.** Combine + conditions _inside_ the single bracket — do not chain brackets. +3. **`**` must terminate the path.** `/MyAssembly/**` is valid; `/**/Class/*` + is not. + +## Troubleshooting: "Zero tests ran" / 0 tests discovered + +Check, in order: + +1. **`--filter` was used instead of `--treenode-filter`.** This is the most common cause. +2. **`Microsoft.NET.Test.Sdk` is still referenced.** It conflicts with the TUnit MTP platform. +3. **TUnit package missing.** Ensure ``. +4. **Missing `[Test]` attribute** or unsupported method shape. +5. **Wrong `OutputType`.** A `hostfxr.dll could not be found` error means the project needs `Exe`. +6. **Bad filter shape.** Remember the path has exactly four segments. + +## References + +- TUnit — Test Filters: https://tunit.dev/docs/execution/test-filters/ +- TUnit — Troubleshooting & FAQ: https://tunit.dev/docs/troubleshooting/ +- TUnit — CI/CD pipelines: https://tunit.dev/docs/examples/tunit-ci-pipeline/ +- TUnit — Explicit tests: https://tunit.dev/docs/writing-tests/explicit/ +- MTP graph-query filtering spec: https://github.com/microsoft/testfx/blob/main/docs/mstest-runner-graphqueryfiltering/graph-query-filtering.md diff --git a/.changeset/bumpy-crabs-double.md b/.changeset/bumpy-crabs-double.md new file mode 100644 index 00000000..57964f46 --- /dev/null +++ b/.changeset/bumpy-crabs-double.md @@ -0,0 +1,5 @@ +--- +"purview-eventsourcing": patch +--- + +fixed GetOrCreateAsync always calling creator func/ action diff --git a/.changeset/bumpy-symbols-learn.md b/.changeset/bumpy-symbols-learn.md new file mode 100644 index 00000000..0130fc76 --- /dev/null +++ b/.changeset/bumpy-symbols-learn.md @@ -0,0 +1,5 @@ +--- +"purview-eventsourcing": patch +--- + +fixed GetOrCreate that called created func regardless of state diff --git a/.changeset/chubby-suns-fry.md b/.changeset/chubby-suns-fry.md new file mode 100644 index 00000000..328ec9ec --- /dev/null +++ b/.changeset/chubby-suns-fry.md @@ -0,0 +1,5 @@ +--- +"purview-eventsourcing": patch +--- + +added EF support for complex value objects diff --git a/.changeset/fuzzy-adults-battle.md b/.changeset/fuzzy-adults-battle.md new file mode 100644 index 00000000..7159b86f --- /dev/null +++ b/.changeset/fuzzy-adults-battle.md @@ -0,0 +1,5 @@ +--- +"purview-eventsourcing": patch +--- + +fixed the valueobject EF ctor generation not covering all valueobject types diff --git a/.changeset/major-flies-repeat.md b/.changeset/major-flies-repeat.md new file mode 100644 index 00000000..634653ca --- /dev/null +++ b/.changeset/major-flies-repeat.md @@ -0,0 +1,5 @@ +--- +"purview-eventsourcing": patch +--- + +fixed another GetOrCreateAsync issue calling creator action/ func on non-new aggregates diff --git a/.changeset/pre.json b/.changeset/pre.json index 59d7e49b..30214455 100644 --- a/.changeset/pre.json +++ b/.changeset/pre.json @@ -5,20 +5,29 @@ "purview-eventsourcing": "2.0.0-prerelease.0" }, "changesets": [ + "bumpy-crabs-double", + "bumpy-symbols-learn", + "chubby-suns-fry", "clean-papayas-hang", "curvy-bushes-strive", "eager-bikes-hope", "early-dryers-slide", "eight-walls-report", "famous-rice-enter", + "fuzzy-adults-battle", "large-ideas-vanish", "little-moose-buy", + "major-flies-repeat", "new-grapes-drive", "pink-parks-brush", "shy-fans-show", + "slick-hotels-float", "tasty-moose-tickle", + "three-ends-nail", "two-moose-hug", "two-wasps-yell", + "violet-files-turn", + "wacky-eagles-punch", "wild-trees-shout", "witty-chefs-find" ] diff --git a/.changeset/slick-hotels-float.md b/.changeset/slick-hotels-float.md new file mode 100644 index 00000000..fced1ad1 --- /dev/null +++ b/.changeset/slick-hotels-float.md @@ -0,0 +1,5 @@ +--- +"purview-eventsourcing": patch +--- + +added an inmemory event and snapshot store for testing diff --git a/.changeset/three-ends-nail.md b/.changeset/three-ends-nail.md new file mode 100644 index 00000000..de28515e --- /dev/null +++ b/.changeset/three-ends-nail.md @@ -0,0 +1,5 @@ +--- +"purview-eventsourcing": patch +--- + +fix: added telemetry activity source and meter names diff --git a/.changeset/violet-files-turn.md b/.changeset/violet-files-turn.md new file mode 100644 index 00000000..61a33763 --- /dev/null +++ b/.changeset/violet-files-turn.md @@ -0,0 +1,7 @@ +--- +"purview-eventsourcing": patch +--- + +- fixed SQL snapshot support for directly mapped complex mirror properties, including deep query translation over `ParserReportSummary` members +- clarified SQL snapshot/query documentation for provider-converted scalar value objects vs directly mapped complex mirrors +- aligned repo-local agent instructions and skills under `.agents/skills` diff --git a/.changeset/wacky-eagles-punch.md b/.changeset/wacky-eagles-punch.md new file mode 100644 index 00000000..73f9c078 --- /dev/null +++ b/.changeset/wacky-eagles-punch.md @@ -0,0 +1,5 @@ +--- +"purview-eventsourcing": patch +--- + +added IEquatible for value object structs diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md index 837be60d..e430db09 100644 --- a/.github/copilot-instructions.md +++ b/.github/copilot-instructions.md @@ -4,7 +4,7 @@ Follow `AGENTS.md`. Prefer repository-local guidance from: -- `.github/skills/` -- `.agents/skills/` +- `src/skills/` +- `.agents/skills/` (workflow/tooling skills) - `.agents/agents/` - `.agents/instructions/` diff --git a/.github/skills/changesets-prerelease/SKILL.md b/.github/skills/changesets-prerelease/SKILL.md deleted file mode 100644 index f89a83c1..00000000 --- a/.github/skills/changesets-prerelease/SKILL.md +++ /dev/null @@ -1,23 +0,0 @@ ---- -name: changesets-prerelease -description: Create and apply a prerelease bump using Changesets CLI. ---- - -# Changesets Prerelease Skill - -Use this skill when preparing the next prerelease version in this repository. - -## Steps - -1. Add a new changeset: - - `npx @changesets/cli add --empty --message ""` - - update the generated `.changeset/*.md` frontmatter with: - - `"purview-eventsourcing": patch` -2. Bump versions/changelog: - - `npx @changesets/cli version` -3. Commit the resulting changes (`package.json`, `CHANGELOG.md`, and consumed `.changeset` files). - -## Notes - -- Repository currently runs prerelease mode with `tag: prerelease` (`.changeset/pre.json`). -- Releasing is done from `package.json` version in the `release.yml` workflow. diff --git a/.github/skills/tunit-test-runner/SKILL.md b/.github/skills/tunit-test-runner/SKILL.md deleted file mode 100644 index 2984c302..00000000 --- a/.github/skills/tunit-test-runner/SKILL.md +++ /dev/null @@ -1,187 +0,0 @@ ---- -name: tunit-test-runner -description: >- - Run, filter, and select TUnit tests through `dotnet test`. Use this whenever - executing .NET tests in a project that depends on TUnit (built on - Microsoft.Testing.Platform / MTP, not VSTest), when `dotnet test --filter` - reports "Zero tests ran", or when tests must be narrowed by assembly, - namespace, class, test name, [Category], or other custom properties. Covers - the `--treenode-filter` path-based query syntax, its operators, the `--` - separator rules across SDK versions, and common 0-tests troubleshooting. -license: MIT ---- - -# Running TUnit tests with `dotnet test` - -## The one rule that matters most - -TUnit runs on **Microsoft.Testing.Platform (MTP)**, not VSTest. The reflexive -`dotnet test --filter "Category=X"` **does not work**: MTP silently rejects the -`--filter` flag, prints its own help text, and exits with `Zero tests ran`. That -looks like a passing-but-empty run or a config failure, but it is just an -unrecognised flag. **Never reach for `--filter` on a TUnit project.** Use -`--treenode-filter` instead. - -| Other frameworks (VSTest) | TUnit (MTP) | -| --- | --- | -| `--filter "Category=Integration"` | `--treenode-filter "/*/*/*/*[Category=Integration]"` | -| `--filter "FullyQualifiedName~LoginTests"` | `--treenode-filter "/*/*/LoginTests/*"` | -| `--filter "Name=AcceptCookiesTest"` | `--treenode-filter "/*/*/*/AcceptCookiesTest"` | - -## How to invoke it - -Prefer `dotnet test` over `dotnet run`: `dotnet test` builds and runs every -targeted TFM automatically and works against a `.csproj`, `.sln`, or `.slnx`, -whereas `dotnet run` only runs a single TFM. - -The catch is the `--` separator, which depends on the SDK: - -```bash -# Universal form — works on every SDK. Use this by default. -dotnet test -- --treenode-filter "/*/*/LoginTests/*" - -# .NET 10+ SDK only — the platform flag can be passed directly. -dotnet test --treenode-filter "/*/*/LoginTests/*" -``` - -Anything after `--` is passed through to the TUnit test runner rather than to -the `dotnet test` command itself. Flags from extension packages -(`--coverage`, `--report-trx`, `--results-directory`, etc.) **must** also sit -after the `--`: - -```bash -dotnet test --configuration Release --no-build \ - -- --treenode-filter "/*/*/*/*[Category=Unit]" --coverage --report-trx -``` - -> Run with no filter to execute everything: `dotnet test`. - -## The `--treenode-filter` syntax - -A filter is a path with four segments, optionally annotated with a property -group on any segment: - -``` -////[Property=Value] -``` - -Use `*` as a wildcard in any segment. The classic "run all tests" filter is -`/*/*/*/*` — four wildcards, one per level. - -### Operators - -| Operator | Meaning | Example | -| --- | --- | --- | -| `*` | Wildcard within a segment | `/*/*/LoginTests*/*` | -| `=` | Property equals (exact) | `/*/*/*/*[Category=Unit]` | -| `!=` | Property not equal (exclude) | `/*/*/*/*[Category!=Slow]` | -| `&` | AND — within one segment / property group | `/**[(Category=Unit)&(Priority=High)]` | -| `\|` | OR — within one segment / property group | `/*/*/(LoginTests)\|(SignupTests)/*` | -| `**` | Match any path depth (must be at the **end**) | `/MyAssembly/**` | - -### Two grammar rules that are easy to get wrong - -1. **`&` and `|` operate *inside a single segment or property group*, and each - side must be wrapped in parentheses.** They do not join two complete paths. - - AND across class patterns: `/*/*/(ClassA*)&(*Smoke)/*` - - OR across classes: `/*/*/(Class1)|(Class2)/*` - - AND across properties: `/**[(Category=Unit)&(Priority=High)]` - - OR across properties: `/**[(Category=Smoke)|(Priority=High)]` - -2. **Only one property group `[...]` is allowed per path segment.** Combine - conditions *inside* the single bracket — do not chain brackets. - - Correct: `/*/*/*/*[(A=1)&(B=2)]` - - Wrong: `/*/*/*/*[A=1][B=2]` and `/*/*/*/*[A=1]&[B=2]` - -3. **`**` must terminate the path.** `/MyAssembly/**` is valid; `/**/Class/*` - is not. - -## Recipe reference - -```bash -# Everything -dotnet test - -# One class -dotnet test -- --treenode-filter "/*/*/LoginTests/*" - -# One test method by name -dotnet test -- --treenode-filter "/*/*/*/AcceptCookiesTest" - -# Whole namespace -dotnet test -- --treenode-filter "/*/MyProject.Tests.Integration/*/*" - -# Namespace prefix (wildcard) -dotnet test -- --treenode-filter "/*/MyProject.Tests.Api*/*/*" - -# By [Category] -dotnet test -- --treenode-filter "/*/*/*/*[Category=Smoke]" - -# Partial property value (wildcard) -dotnet test -- --treenode-filter "/*/*/*/*[Owner=*Team-Backend*]" - -# Exclude a category -dotnet test -- --treenode-filter "/*/*/*/*[Category!=Slow]" - -# AND two properties (single bracket) -dotnet test -- --treenode-filter "/*/*/*/*[(Category=Smoke)&(Priority=High)]" - -# OR two classes -dotnet test -- --treenode-filter "/*/*/(LoginTests)|(SignupTests)/*" - -# OR two properties (single bracket) -dotnet test -- --treenode-filter "/**[(Category=Smoke)|(Priority=High)]" - -# Namespace + property combined -dotnet test -- --treenode-filter "/*/MyProject.Tests.Integration/*/*[Priority=Critical]" - -# Exclude a whole class folder (CI: skip smoke tests) -dotnet test -- --treenode-filter "/*/(!*SmokeTests)/*/*" -``` - -To preview what a filter selects without running anything, list tests first: - -```bash -dotnet test -- --list-tests -``` - -## `[Explicit]` tests - -Tests (or whole classes) marked `[Explicit]` only run when **every** test -matched by the filter is explicit. Target them precisely — by name, by class, -or by a `[Category]` you reserve for them: - -```bash -dotnet test -- --treenode-filter "/*/*/*/*[Category=DevTool]" -``` - -If a filter matches a mix of explicit and non-explicit tests, the explicit ones -are excluded from that run. - -## Troubleshooting: "Zero tests ran" / 0 tests discovered - -Check, in order: - -1. **`--filter` was used instead of `--treenode-filter`.** This is the most - common cause. Switch the flag. -2. **`Microsoft.NET.Test.Sdk` is still referenced.** It conflicts with the - TUnit MTP platform — remove the ``. -3. **TUnit package missing.** Ensure ``. -4. **Missing `[Test]` attribute**, or the test method is not a `public` - instance method (non-public/static methods are not discovered). -5. **Wrong `OutputType`.** A `hostfxr.dll could not be found` error means the - project needs `Exe`. -6. **Bad filter shape.** Remember the path has exactly four segments; a missing - wildcard (e.g. `/*/*/LoginTests` instead of `/*/*/LoginTests/*`) matches - nothing. -7. **IDE only:** MTP/"Testing Platform support" must be enabled (VS: Preview - Features → "Use testing platform server mode"; Rider: Unit Testing → - Testing Platform support; VS Code: install C# Dev Kit), then rebuild. - -## References - -- TUnit — Test Filters: https://tunit.dev/docs/execution/test-filters/ -- TUnit — Troubleshooting & FAQ: https://tunit.dev/docs/troubleshooting/ -- TUnit — CI/CD pipelines: https://tunit.dev/docs/examples/tunit-ci-pipeline/ -- TUnit — Explicit tests: https://tunit.dev/docs/writing-tests/explicit/ -- MTP graph-query (tree-node) filtering spec: https://github.com/microsoft/testfx/blob/main/docs/mstest-runner-graphqueryfiltering/graph-query-filtering.md diff --git a/.github/workflows/reusable-dotnet-pack.yml b/.github/workflows/reusable-dotnet-pack.yml index 80ce162b..356f2529 100644 --- a/.github/workflows/reusable-dotnet-pack.yml +++ b/.github/workflows/reusable-dotnet-pack.yml @@ -47,6 +47,25 @@ jobs: - name: Pack run: dotnet pack "${{ inputs.pack-target-path }}" --no-build --configuration "${{ inputs.configuration }}" -p:PackageVersion="${{ inputs.version }}" --output "${{ inputs.output-path }}" + - name: Verify ZodSharp package includes buildTransitive guard + shell: bash + run: | + set -euo pipefail + shopt -s nullglob + + packages=("${{ inputs.output-path }}"/Purview.EventSourcing.ZodSharp*.nupkg) + if (( ${#packages[@]} == 0 )); then + echo "No Purview.EventSourcing.ZodSharp package was produced; skipping guard verification." + exit 0 + fi + + for pkg in "${packages[@]}"; do + if ! unzip -Z1 "${pkg}" | grep -Fxq "buildTransitive/Purview.EventSourcing.ZodSharp.targets"; then + echo "::error::Package $(basename "${pkg}") is missing buildTransitive/Purview.EventSourcing.ZodSharp.targets." + exit 1 + fi + done + - name: Upload package artifacts uses: actions/upload-artifact@v7 with: diff --git a/.gitignore b/.gitignore index 840569f1..6e8a1660 100644 --- a/.gitignore +++ b/.gitignore @@ -591,3 +591,4 @@ coverage/ !scripts/* !src/src/EventSourcing/build +!assets/packages/* \ No newline at end of file diff --git a/AGENTS.md b/AGENTS.md index c7f270b6..76d6e5f2 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,8 +1,60 @@ # Agent Instructions +## Purpose + +This repository contains the `Purview.EventSourcing` framework, storage providers, source generators, sample applications, and TUnit-based test suites. + +Use these instructions for any work in this solution. + +## Source of truth and layout + +- Solution file: `src/Purview.EventSourcing.slnx` +- Packable/source projects: `src/src/**` +- Tests: `src/tests/**` +- Wiki/docs: `docs/wiki/**` +- Framework skills source of truth: `src/skills/**` +- Repo workflow skills: `.agents/skills/**` +- Repo-local Copilot bootstrap instructions: `.github/copilot-instructions.md` + ## Core behavior -- Keep changes focused and reviewable. -- Follow repository conventions before introducing new patterns. -- Update tests and docs when behavior changes. -- Never read or store secrets from excluded files. +- Keep changes focused, reviewable, and consistent with existing patterns. +- Follow repository conventions before introducing new abstractions. +- Update tests and docs whenever behavior, provider support, or query semantics change. +- Never read, copy, or store secrets from excluded files. +- Treat event streams as the source of truth; snapshots are optimization/read models only. + +## Coding conventions + +- Prefer the repository's existing event-sourcing/source-generator patterns. +- Aggregates should remain `partial` and use `[GenerateAggregate]` plus generated event methods where applicable. +- Prefer `EventStoreList` / `EventStoreSet` for aggregate collection state that participates in generated events. +- Use `[Computed]` parameters for derived event values that callers must not set directly. +- Keep invariants in aggregate hooks/value objects rather than scattered in services. +- Avoid unrelated refactors while fixing a targeted issue. + +## Snapshot/query guidance + +- SQL snapshot queries can translate deep predicates over directly mapped complex JSON graphs. +- Provider-converted scalar value objects may not support deep member translation through `.Value`. +- If deep SQL predicates are required for a complex scalar concept, prefer a separately mapped complex mirror property derived from canonical state and covered by integration tests. +- Document any provider-specific translation limitation or newly supported shape in `docs/wiki/Provider-Feature-Matrix.md` and provider docs. + +## Testing conventions + +- This repo uses **TUnit** on Microsoft.Testing.Platform. +- Do **not** use `dotnet test --filter` for TUnit projects; use `--treenode-filter` when narrowing scope. +- After code changes, run the most relevant `dotnet test` command before finishing. +- For SQL/Mongo/Azure/Cosmos integration tests, assume container or provider infrastructure may be required. + +## Docs and instruction maintenance + +- Keep `docs/wiki/Home.md`, `docs/wiki/Provider-Feature-Matrix.md`, and provider-specific guides aligned when capabilities change. +- Keep `src/skills/event-sourcing-*` guidance aligned with actual framework behavior. +- If repo-local instruction/skill locations change, update both this file and `.github/copilot-instructions.md`. + +## Useful local workflow facts + +- Restore/build/test commonly target `src/Purview.EventSourcing.slnx`. +- `Justfile` contains wrapper recipes for restore, build, test, pack, and lint. +- `package.json` version is the release/package version source of truth. diff --git a/CHANGELOG.md b/CHANGELOG.md index 1142ce95..3ee4fcf2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,56 @@ # Changelog +## 2.0.0-prerelease.28 + +### Patch Changes + +- fix: added telemetry activity source and meter names + +## 2.0.0-prerelease.27 + +### Patch Changes + +- ff8bad5: fixed GetOrCreateAsync always calling creator func/ action +- fixed another GetOrCreateAsync issue calling creator action/ func on non-new aggregates + +## 2.0.0-prerelease.25 + +### Patch Changes + +- fixed SQL snapshot support for directly mapped complex mirror properties, including deep query translation over `ParserReportSummary` members +- clarified SQL snapshot/query documentation for provider-converted scalar value objects vs directly mapped complex mirrors +- aligned repo-local agent instructions and skills under `.agents/skills` + +## 2.0.0-prerelease.21 + +### Patch Changes + +- fixed GetOrCreate that called created func regardless of state + +## 2.0.0-prerelease.20 + +### Patch Changes + +- fixed the valueobject EF ctor generation not covering all valueobject types + +## 2.0.0-prerelease.19 + +### Patch Changes + +- added IEquatible for value object structs + +## 2.0.0-prerelease.18 + +### Patch Changes + +- added EF support for complex value objects + +## 2.0.0-prerelease.17 + +### Patch Changes + +- added an inmemory event and snapshot store for testing + ## 2.0.0-prerelease.16 ### Patch Changes diff --git a/Directory.Packages.props b/Directory.Packages.props index 05009819..6686e1ea 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -1,67 +1,95 @@ - - true - - [5.0.0] - 5.3.0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + + true + + [5.0.0] + 5.6.0 + 1.63.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Justfile b/Justfile index b791c1a9..f08c61c1 100644 --- a/Justfile +++ b/Justfile @@ -1,4 +1,4 @@ -set quiet := true +set quiet # Variables root_folder := "./src" @@ -6,8 +6,8 @@ test_root := root_folder + "/tests" solution_file := root_folder + "/Purview.EventSourcing.slnx" -sg_perf_tests := test_root + "/EventSourcing.SourceGenerator.PerformanceTests/EventSourcing.SourceGenerator.PerformanceTests.csproj" -sql_perf_tests := test_root + "/EventSourcing.SqlServer.PerformanceTests/EventSourcing.SqlServer.PerformanceTests.csproj" +sg_perf_tests := test_root + "/SourceGenerator.PerformanceTests/SourceGenerator.PerformanceTests.csproj" +sql_perf_tests := test_root + "/SqlServer.PerformanceTests/SqlServer.PerformanceTests.csproj" build_configuration := "Release" artifacts_folder := "./artifacts" @@ -24,17 +24,17 @@ vs: open "{{ solution_file }}" # Build the solution -build project=solution_file configuration=build_configuration: - echo "==> Building {{ BLUE }}{{ project }}{{ NORMAL }} ({{ GREEN }}{{ current_version }}{{ NORMAL }}) with configuration {{ YELLOW }}{{ configuration }}{{ NORMAL }}" - dotnet build {{ project }} --configuration {{configuration}} +build *args: + echo "==> Building {{ BLUE }}{{ solution_file }}{{ NORMAL }} ({{ GREEN }}{{ current_version }}{{ NORMAL }}) with configuration {{ YELLOW }}{{ build_configuration }}{{ NORMAL }}" + dotnet build {{ solution_file }} --configuration {{ build_configuration }} {{ args }} # Restore local .NET tools tools: dotnet tool restore # Restore NuGet packages for the solution -restore: - dotnet restore {{ solution_file }} +restore *args: + dotnet restore {{ solution_file }} {{ args }} # Displays the current package version from package.json current_version: @@ -49,14 +49,14 @@ perf-sql-server *args: dotnet run --project {{ sql_perf_tests }} --configuration {{ build_configuration }} -- {{ args }} # Run tests for a specific project with a filter (e.g., "/*/*/*/*/") and configuration (e.g., "Release") -test project=solution_file filter="/*/*/*/*/" configuration=build_configuration: - echo "==> Testing {{ BLUE }}{{ project }}{{ NORMAL }} ({{ GREEN }}{{ configuration }}{{ NORMAL }}) with filter {{ YELLOW }}{{ filter }}{{ NORMAL }}" - dotnet test --project {{ project }} --configuration {{ configuration }} --treenode-filter "{{ filter }}" --ignore-exit-code 8 +test filter="/*/*/*/*/" *args: + echo "==> Testing {{ BLUE }}{{ solution_file }}{{ NORMAL }} ({{ GREEN }}{{ build_configuration }}{{ NORMAL }}) with filter {{ YELLOW }}{{ filter }}{{ NORMAL }}" + dotnet test --project {{ solution_file }} --configuration {{ build_configuration }} --treenode-filter "{{ filter }}" --ignore-exit-code 8 {{ args }} # Pack all packable projects -pack project=solution_file configuration=build_configuration artifact_folder=artifacts_folder: - echo "==> Packing {{ BLUE }}{{ project }}{{ NORMAL }} ({{ GREEN }}{{ current_version }}{{ NORMAL }}) to {{ YELLOW }}{{ artifact_folder }}{{ NORMAL }}" - dotnet pack "{{ project }}" --configuration "{{ configuration }}" --output "{{ artifact_folder }}" +pack artifact_folder=artifacts_folder *args: + echo "==> Packing {{ BLUE }}{{ solution_file }}{{ NORMAL }} ({{ GREEN }}{{ current_version }}{{ NORMAL }}) to {{ YELLOW }}{{ artifact_folder }}{{ NORMAL }}" + dotnet pack "{{ solution_file }}" --configuration "{{ build_configuration }}" --output "{{ artifact_folder }}" {{ args }} # Format the code with CSharpier lint-fix: diff --git a/README.md b/README.md index ee426155..bf29358b 100644 --- a/README.md +++ b/README.md @@ -15,10 +15,13 @@ Purview EventSourcing is a .NET event sourcing framework for building aggregate- | Package ID | Purpose | Project README | | --- | --- | --- | | `Purview.EventSourcing` | Core abstractions, aggregate types, facades, transactions, DI extensions, and source generation support | [`src/src/EventSourcing/README.md`](src/src/EventSourcing/README.md) | -| `Purview.EventSourcing.SqlServer` | Azure SQL / SQL Server event stream and queryable snapshot stores | [`src/src/EventSourcing.SqlServer/README.md`](src/src/EventSourcing.SqlServer/README.md) | -| `Purview.EventSourcing.AzureStorage` | Azure Table / Blob event store | [`src/src/EventSourcing.AzureStorage/README.md`](src/src/EventSourcing.AzureStorage/README.md) | -| `Purview.EventSourcing.MongoDB` | MongoDB event stream and queryable snapshot stores | [`src/src/EventSourcing.MongoDB/README.md`](src/src/EventSourcing.MongoDB/README.md) | -| `Purview.EventSourcing.CosmosDb` | Azure Cosmos DB queryable snapshot store | [`src/src/EventSourcing.CosmosDb/README.md`](src/src/EventSourcing.CosmosDb/README.md) | +| `Purview.EventSourcing.SqlServer` | Azure SQL / SQL Server event stream and queryable snapshot stores | [`src/src/SqlServer/README.md`](src/src/SqlServer/README.md) | +| `Purview.EventSourcing.AzureStorage` | Azure Table / Blob event store | [`src/src/AzureStorage/README.md`](src/src/AzureStorage/README.md) | +| `Purview.EventSourcing.MongoDB` | MongoDB event stream and queryable snapshot stores | [`src/src/MongoDB/README.md`](src/src/MongoDB/README.md) | +| `Purview.EventSourcing.CosmosDb` | Azure Cosmos DB queryable snapshot store | [`src/src/CosmosDb/README.md`](src/src/CosmosDb/README.md) | +| `Purview.EventSourcing.InMemory` | In-memory event/snapshot store implementation for local and test scenarios | (see package source at `src/src/InMemory`) | +| `Purview.EventSourcing.FluentValidation` | `FluentValidation` adapter for aggregate save-time validation | (see package source at `src/src/FluentValidationImpl`) | +| `Purview.EventSourcing.ZodSharp` | `ZodSharp` adapter for aggregate save-time validation | (see package source at `src/src/ZodSharpImpl`) | ## Install the packages you need @@ -29,6 +32,23 @@ dotnet add package Purview.EventSourcing.SqlServer Provider packages layer on top of the core `Purview.EventSourcing` package. Add only the providers required for your chosen persistence strategy. +### Validation adapters + +```bash +dotnet add package Purview.EventSourcing.FluentValidation +dotnet add package Purview.EventSourcing.ZodSharp +``` + +### ZodSharp direct-reference requirement + +If your project directly references `ZodSharpImpl` (project reference) and uses types from `ZodSharp`, you must include a direct package reference: + +```xml + +``` + +`Purview.EventSourcing.ZodSharp` now ships a build-time guard target (`ValidateZodSharpDirectReference`) via NuGet `buildTransitive` assets. If the direct `ZodSharp` reference is missing, the consumer build fails with remediation guidance instead of allowing a runtime assembly-load failure. + ## Quick start ### 1. Define an aggregate @@ -182,8 +202,10 @@ Do not create release tags manually. - [Wiki home](docs/wiki/Home.md) - [Source generator behaviors](docs/wiki/Source-Generator-Behaviors.md) - [SQL Server event store guide](docs/wiki/SQL-Server-Guide.md) +- [Dependency guardrails](docs/wiki/Dependency-Guardrails.md) - [Release flow](docs/wiki/Release-Flow.md) - [Core package README](src/src/EventSourcing/README.md) -- [SQL Server provider README](src/src/EventSourcing.SqlServer/README.md) -- [MongoDB provider README](src/src/EventSourcing.MongoDB/README.md) -- [Cosmos DB provider README](src/src/EventSourcing.CosmosDb/README.md) +- [SQL Server provider README](src/src/SqlServer/README.md) +- [Azure Storage provider README](src/src/AzureStorage/README.md) +- [MongoDB provider README](src/src/MongoDB/README.md) +- [Cosmos DB provider README](src/src/CosmosDb/README.md) diff --git a/aspire.config.json b/aspire.config.json index d1db1b0c..05397c22 100644 --- a/aspire.config.json +++ b/aspire.config.json @@ -1,5 +1,5 @@ { "appHost": { - "path": "src/src/EventSourcing.Samples.AppHost/EventSourcing.Samples.AppHost.csproj" + "path": "src/src/Samples.AppHost/Samples.AppHost.csproj" } } \ No newline at end of file diff --git a/assets/images/kjldev-logo.png b/assets/images/kjldev-logo.png deleted file mode 100644 index 01435f4b..00000000 Binary files a/assets/images/kjldev-logo.png and /dev/null differ diff --git a/assets/images/purview-logo.jpg b/assets/images/purview-logo.jpg new file mode 100644 index 00000000..eef73ed6 Binary files /dev/null and b/assets/images/purview-logo.jpg differ diff --git a/assets/packages/.gitkeep b/assets/packages/.gitkeep new file mode 100644 index 00000000..e69de29b diff --git a/assets/packages/ZodSharp.2.0.0-prerelease.2.nupkg b/assets/packages/ZodSharp.2.0.0-prerelease.2.nupkg new file mode 100644 index 00000000..2802a076 Binary files /dev/null and b/assets/packages/ZodSharp.2.0.0-prerelease.2.nupkg differ diff --git a/assets/packages/ZodSharp.AspNetCore.2.0.0-prerelease.2.nupkg b/assets/packages/ZodSharp.AspNetCore.2.0.0-prerelease.2.nupkg new file mode 100644 index 00000000..66831f1b Binary files /dev/null and b/assets/packages/ZodSharp.AspNetCore.2.0.0-prerelease.2.nupkg differ diff --git a/assets/packages/ZodSharp.NewtonsoftJson.2.0.0-prerelease.2.nupkg b/assets/packages/ZodSharp.NewtonsoftJson.2.0.0-prerelease.2.nupkg new file mode 100644 index 00000000..e4cd0996 Binary files /dev/null and b/assets/packages/ZodSharp.NewtonsoftJson.2.0.0-prerelease.2.nupkg differ diff --git a/assets/packages/ZodSharp.SystemTextJson.2.0.0-prerelease.2.nupkg b/assets/packages/ZodSharp.SystemTextJson.2.0.0-prerelease.2.nupkg new file mode 100644 index 00000000..ddf2515a Binary files /dev/null and b/assets/packages/ZodSharp.SystemTextJson.2.0.0-prerelease.2.nupkg differ diff --git a/docs/review/README.md b/docs/review/README.md new file mode 100644 index 00000000..deae8f97 --- /dev/null +++ b/docs/review/README.md @@ -0,0 +1,4 @@ +# Project reviews + +- [`project-review-2026-06-26.md`](./project-review-2026-06-26.md) — full repository review with industry comparison and MoSCoW-prioritized tasks/features/issues. +- [`event-store-pattern-review-2026-06-26.md`](./event-store-pattern-review-2026-06-26.md) — focused comparison against Event Store pattern expectations with a MoSCoW-prioritized backlog. diff --git a/docs/review/event-store-pattern-review-2026-06-26.md b/docs/review/event-store-pattern-review-2026-06-26.md new file mode 100644 index 00000000..7ed96c6b --- /dev/null +++ b/docs/review/event-store-pattern-review-2026-06-26.md @@ -0,0 +1,144 @@ +# Purview EventSourcing — Event Store Pattern Review (2026-06-26) + +## Scope + +This review evaluates the repository against the **canonical Event Store pattern** (stream-first event persistence, append-only semantics, optimistic concurrency, idempotent writes, replayability, versioning/upcasting, projections, and subscription/change-feed behavior). + +Baseline reviewed from core contracts, provider implementations, docs, and tests. + +## Executive verdict + +**Overall: Strong alignment with Event Store pattern principles, with a few important standardization gaps across providers and operational hardening opportunities.** + +In short: this is not just “event-sourcing flavored CRUD” — it is a genuine event-store-oriented design with meaningful transactional, idempotency, replay, and versioning features. + +## Pattern comparison (industry/Event Store expectations) + +| Event Store pattern capability | Expected pattern behavior | Current status | Evidence | +| --- | --- | --- | --- | +| Stream-first source of truth | Aggregate state rebuilt from event stream; snapshots are optimization only | ✅ Strong | `IEventStore*` contracts and provider `Get...` + replay behavior; snapshots are optional and skippable via `SkipSnapshot`. | +| Append-only events | New events appended; historical events not overwritten | ✅ Strong | Save flows persist event rows/docs per version and update stream metadata; docs and contracts emphasize non-overwrite semantics. | +| Optimistic concurrency | Write fails when stream head changed concurrently | ✅/⚠️ Good (provider variance) | SQL/Azure map storage conflicts to `ConcurrencyException`; Mongo currently maps to generic commit failure path. | +| Idempotent write support | Duplicate request detection via operation identity/marker | ✅ Strong | `EventStoreOperationContext.UseIdempotencyMarker`; provider marker entities and duplicate short-circuit behavior. | +| Correlation/causation metadata | Correlation across multi-write workflows | ✅ Good | `CorrelationId` propagated via operation context and transaction orchestration. | +| Replay/time-travel | Rehydrate at version and enumerate ranges | ✅ Strong | `GetAtAsync`, `GetEventRangeAsync`, history request model with version/time windows. | +| Event versioning/upcasting | Schema version + migration chain | ✅ Strong | `EventBase.SchemaVersion`, `GenerateAggregateEvent(Version=...)`, `EventUpcasterRegistry` chain support with cycle guard. | +| Projections/read model separation | Write model separate from query model | ✅ Good | `IQueryableEventStore` abstraction and provider matrix with snapshot query stores. | +| Subscription/change feed | Push/pull mechanisms for downstream processors | ✅/⚠️ Good | `IAggregateChangeFeedProcessor*` hooks provide change notifications; durable subscription semantics are less explicit. | +| Multi-aggregate consistency | Transaction coordination semantics clearly defined | ✅ Good | `EventStoreTransaction` supports native atomic mode when boundary matches; documented fallback is eventual consistency. | + +## What aligns very well with Event Store pattern + +1. **Clear stream semantics** + - Contracts expose `GetAtAsync`, `GetEventRangeAsync`, and history request paging/filtering. + - This is core Event Store behavior, not an afterthought. + +2. **Pragmatic idempotency support** + - Marker-based dedupe is available and integrated with operation context and transaction orchestration. + +3. **First-class event evolution story** + - Schema version on events + explicit upcaster chain registry. + - Supports multi-hop migration and replay safety. + +4. **Good transactional model articulation** + - Native atomic path when store boundary is shared. + - Explicit eventual-consistency fallback for mixed boundaries. + +5. **Snapshots treated as optimization** + - `SkipSnapshot` allows full replay path and preserves event stream as source of truth. + +## Key gaps vs best-in-class Event Store implementations + +1. **Provider consistency gap for concurrency taxonomy** + - SQL/Azure explicitly surface concurrency exceptions from provider conflicts. + - Mongo path is more commit-oriented and less explicit for concurrency failure classification. + +2. **Ambiguity/TODO in rehydration logic comments (Mongo/Azure `GetAsync`)** + - Known unresolved comments indicate uncertainty around stream version selection in replay path. + - This is risky in an Event Store because replay correctness is foundational. + +3. **Durable subscription semantics not fully explicit** + - Change feed hooks are good, but checkpointing/replay-from-position behavior is not clearly positioned like classic durable subscriptions. + +4. **Operational governance still behind top OSS Event Store projects** + - Missing policy docs (`SECURITY.md`, contributor/governance files) reduce ecosystem trust, despite strong core engineering. + +## MoSCoW backlog (tasks / features / issues) — Event Store pattern focused + +### Must have + +1. **[Issue] Normalize concurrency exception behavior across providers** + - Ensure Mongo provider distinguishes optimistic concurrency conflicts from generic commit failures. + - Outcome: consistent retry policy handling for clients. + +2. **[Issue] Resolve replay/stream-version TODO logic in provider `GetAsync` paths** + - Files include Mongo/Azure provider `GetAsync` implementations. + - Outcome: deterministic, documented replay semantics. + +3. **[Task] Add explicit Event Store semantics docs** + - Define expected-version behavior, idempotency guarantees, ordering guarantees, and failure contracts per provider. + - Outcome: predictable cross-provider behavior and safer adoption. + +4. **[Task] Add OSS security/governance baseline docs** + - `SECURITY.md`, `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md`, `.github/CODEOWNERS`. + - Outcome: project trust and maintainability uplift. + +### Should have + +1. **[Feature] Durable subscription/checkpoint reference implementation** + - Provide a canonical processor with checkpoint persistence and replay-from-checkpoint. + - Outcome: stronger Event Store downstream-processing story. + +2. **[Feature] Explicit causal metadata guidance** + - Extend documentation for correlation/causation usage conventions and propagation policies. + - Outcome: improved traceability across bounded contexts. + +3. **[Task] Event contract compatibility tests** + - Add replay/upcast compatibility matrix tests across event versions. + - Outcome: safer schema evolution. + +4. **[Task] Provider parity scorecard in docs** + - Add pattern-specific parity dimensions (concurrency, idempotency, transactionality, snapshot mode, history query guarantees). + - Outcome: better architecture decision support. + +### Could have + +1. **[Feature] Position-based stream read API (global/event-log style)** + - Add optional global ordered read model for integration/event-forwarding use cases. + +2. **[Feature] Subscription primitives beyond hook callbacks** + - Pull-based cursor APIs and server-side filtering patterns. + +3. **[Task] Perf + contention benchmarks by provider** + - Include high-contention optimistic-concurrency scenarios and dedupe marker overhead. + +4. **[Task] Observability conventions package** + - Standard metrics/traces naming for save/replay/idempotency/concurrency events. + +### Won’t have now + +1. **[Task] Enforce identical transactional guarantees for all providers** + - Not realistic due to backend capability differences; document guarantee tiers instead. + +2. **[Feature] Fully managed cloud event-stream service abstraction in this cycle** + - Current package focus is framework + provider implementations. + +## Suggested implementation sequence + +1. Replay TODO fixes + tests (correctness first) +2. Concurrency taxonomy parity (Mongo alignment) +3. Event Store semantics documentation and provider guarantee table +4. Durable subscription/checkpoint sample +5. Governance/security docs and ecosystem hardening + +## Evidence notes + +- Core contracts: `IEventStore.cs`, `IEventStoreCore.cs`, `EventStoreOperationContext.cs`, `IEventStoreTransaction.cs` +- Versioning/upcasting: `EventBase.cs`, `EventUpcasterRegistry.cs` +- Change feed: `IAggregateChangeFeedProcessor.cs` +- Provider save paths: SQL/Mongo/Azure `*SaveAsync.cs` +- Existing validation run context: 459 tests passed on current branch (net10/TUnit run) + +## Final assessment + +From an Event Store pattern standpoint, the project is **architecturally strong and credible**. The main work now is **parity hardening and semantic explicitness** (especially replay correctness and concurrency consistency), not foundational redesign. diff --git a/docs/review/project-review-2026-06-26.md b/docs/review/project-review-2026-06-26.md new file mode 100644 index 00000000..fd63a66e --- /dev/null +++ b/docs/review/project-review-2026-06-26.md @@ -0,0 +1,146 @@ +# Purview EventSourcing — Project Review (2026-06-26) + +## Scope + +This review covers the repository at `kjldev/purview-eventsourcing` (branch: `cleaning`) across: + +- Architecture and code quality +- Build, test, and release engineering +- Security and supply-chain posture +- Documentation and contributor experience +- Alignment with common industry standards and OSS best practices + +## Method and evidence + +Reviewed repository structure, core implementation and workflow files, including: + +- `README.md`, `docs/wiki/*` +- `.github/workflows/*.yml` +- `global.json`, `Directory.Packages.props`, `.editorconfig`, `Justfile`, `commitlint.config.mts` +- Representative core files (e.g. `src/src/EventSourcing/Aggregates/AggregateBase.cs`, `src/src/EventSourcing/EventStoreTransaction.cs`) +- Representative provider files and tests + +Validation run executed: + +- `dotnet test src/Purview.EventSourcing.slnx --configuration Release -- --treenode-filter "/*UnitTest*/*/*/*" --report-trx --ignore-exit-code 8` +- Result: **459 passed, 0 failed, 0 skipped** + +## Executive summary + +The project is in a **strong, release-capable state** and demonstrates above-average engineering maturity for an OSS .NET framework. + +### What stands out positively + +- Clear modular architecture (core + provider packages + generator + samples) +- Excellent test breadth (unit, integration, source-generator, performance harnesses) +- Mature release pipeline (guards, duplicate checks, OIDC trusted publishing) +- Good developer ergonomics (central package mgmt, just recipes, lint hooks, commit convention) +- Good API design direction for event sourcing abstractions and transaction coordination + +### Primary gaps vs best-in-class + +- Missing community/governance baseline files (`SECURITY.md`, `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md`, `CODEOWNERS`) +- No automated dependency update workflow (`dependabot.yml` or Renovate) +- A few known TODOs in provider rehydration/options validation paths are still unresolved +- Sample value-object definitions currently generate build warnings (CS9113) + +## Comparison to industry standards + +| Area | Industry expectation | Current status | Notes | +| --- | --- | --- | --- | +| CI quality gate | Restore/build/test + surfaced test reports | ✅ Strong | Reusable workflows and PR result publishing are implemented well. | +| Release safety | Guarded tagging, duplicate detection, provenance-safe publish | ✅ Strong | `release.yml` has branch guards, tag/release checks, NuGet duplicate checks, OIDC trusted publishing. | +| Testing strategy | Layered tests incl. integration where relevant | ✅ Strong | 459 tests passed; includes integration tests per provider and source generator coverage. | +| Dependency governance | Automated update cadence + advisory handling | ⚠️ Partial | Central versions are good, but no Dependabot/Renovate automation found. | +| Security policy | Public disclosure process and support window docs | ❌ Gap | `SECURITY.md` not present. | +| OSS onboarding | Contribution and conduct guidance | ❌ Gap | `CONTRIBUTING.md` and `CODE_OF_CONDUCT.md` not found. | +| Ownership model | CODEOWNERS for review boundaries | ❌ Gap | `CODEOWNERS` not found. | +| Static quality enforcement | Lint/format/analyzers as PR blockers | ✅/⚠️ Good with gaps | Strong style config/hooks; workflow warns on context validity in `release.yml` env secret reference. | +| Documentation depth | Architecture + usage + release docs | ✅ Strong | README and wiki documentation quality is high. | +| Operational observability | Telemetry conventions and failure handling | ✅ Good | Core/provider code demonstrates telemetry hooks and failure reporting patterns. | + +## Key findings (tasks / features / issues) in MoSCoW format + +### Must have (high priority, near-term) + +1. **[Issue] Add OSS governance baseline files** + - Add: `SECURITY.md`, `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md`, and `.github/CODEOWNERS`. + - Why: These are standard trust and maintainability signals for public projects. + +2. **[Issue] Resolve workflow validation warning in release pipeline** + - Observed warning in `release.yml` around context access for `RELEASE_BOT_PRIVATE_KEY`. + - Why: Reduce false positives and ensure workflow lint clarity/portability. + +3. **[Issue] Eliminate sample build warnings (CS9113)** + - File: `src/src/EventSourcing.Samples/ValueObjects/UserCapture.cs`. + - Why: Keep warning budget at zero for clean CI and better signal-to-noise. + +4. **[Task] Formalize security response process** + - Include vulnerability reporting channel, SLA targets, and supported versions. + - Why: Align with OSS security best practices and package consumer expectations. + +### Should have (important, medium-term) + +1. **[Feature] Add automated dependency update workflow** + - Prefer Dependabot or Renovate for NuGet/npm/GitHub Actions updates. + - Why: Reduces patch lag and security exposure. + +2. **[Issue] Resolve provider TODOs around event rehydration semantics** + - Files include: + - `src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetAsync.cs` + - `src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetAsync.cs` + - Why: Comments indicate known correctness uncertainty in version handling path. + +3. **[Task] Tighten options validation for MongoDB store config** + - File: `src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStoreOptions.cs` has TODO regex comments for key names. + - Why: Prevent runtime misconfiguration and harden input constraints. + +4. **[Task] Add architecture decision records (ADRs)** + - Capture transaction model, upcasting strategy, snapshot semantics, and compatibility guarantees. + - Why: Improves maintainability as contributor count grows. + +### Could have (valuable, lower urgency) + +1. **[Feature] Add SBOM and artifact attestations in release flow** + - e.g., CycloneDX SBOM generation and provenance attestation. + - Why: Supply-chain transparency and enterprise readiness. + +2. **[Feature] Publish benchmark trend reports** + - Use existing performance test projects to produce periodic trend artifacts. + - Why: Evidence-based performance regressions monitoring. + +3. **[Task] Add issue/PR templates and triage labels** + - Why: Improve contribution quality and maintainer throughput. + +4. **[Feature] Add API compatibility checks in CI** + - e.g., public API baseline checks between releases. + - Why: Protect package consumers from accidental breaking changes. + +### Won’t have now (defer intentionally) + +1. **[Task] Multi-cloud deployment automation beyond current package release scope** + - Not required for current NuGet-focused distribution model. + +2. **[Feature] Full monorepo orchestration tooling migration** + - Current tooling (`Justfile` + reusable workflows + central package mgmt) is sufficient. + +## Prioritized delivery plan (practical sequence) + +1. Governance/security docs (`SECURITY.md`, `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md`, `CODEOWNERS`) +2. Workflow lint/warning cleanup (`release.yml` context warning) +3. Warning cleanup in sample value objects (CS9113) +4. TODO resolution in provider get/rehydration path + tests +5. Dependency automation (Dependabot/Renovate) +6. Optional enhancements (SBOM, API compat, benchmark trend publishing) + +## Risk register snapshot + +- **Low immediate delivery risk**: CI/release/test posture is strong. +- **Medium ecosystem risk**: Missing explicit security/disclosure and contribution governance docs. +- **Medium technical debt risk**: Known TODOs in provider logic could become reliability issues if left untracked. + +## Overall assessment + +**Verdict: Strong project with production-ready engineering patterns; primary improvements are governance hardening, dependency automation, and cleanup of known TODO/warning debt.** + +If you want, the next step can be a concrete implementation PR plan that converts each MoSCoW item into tracked GitHub issues with acceptance criteria and estimates. diff --git a/docs/wiki/Dependency-Guardrails.md b/docs/wiki/Dependency-Guardrails.md new file mode 100644 index 00000000..ce34eda4 --- /dev/null +++ b/docs/wiki/Dependency-Guardrails.md @@ -0,0 +1,41 @@ +# Dependency Guardrails + +This page documents repository guardrails that prevent known dependency/runtime pitfalls. + +## ZodSharp direct-reference guardrail + +### Problem + +When a consumer project directly references the `ZodSharpImpl` project and uses `ZodSharp` types, relying on transitive package flow can lead to runtime assembly load failures (for example, `FileNotFoundException` for `ZodSharp`). + +### Required fix in consuming project + +Add a direct package reference: + +```xml + +``` + +### Automated enforcement + +`Purview.EventSourcing.ZodSharp` includes a build target in package `buildTransitive` assets (`buildTransitive/Purview.EventSourcing.ZodSharp.targets`): + +- Target name: `ValidateZodSharpDirectReference` +- Runs: `BeforeTargets="ResolveReferences"` +- Behavior: + - Detects projects that reference `ZodSharpImpl` via `ProjectReference` + - Fails the build if `PackageReference Include="ZodSharp"` is missing + - Emits a remediation message with the exact package reference to add + +This shifts failure left from runtime to build-time. + +### CI verification + +The reusable pack workflow also validates the generated `.nupkg` and fails if `buildTransitive/Purview.EventSourcing.ZodSharp.targets` is missing from the package contents. + +## Validation adapters overview + +- `Purview.EventSourcing.FluentValidation`: adapter for `FluentValidation.IValidator` to `IAggregateValidator`. +- `Purview.EventSourcing.ZodSharp`: adapter for `ZodSharp` schema validation to `IAggregateValidator`. + +When using either adapter package directly from source projects, keep direct package references explicit for external runtime dependencies used by the adapter. diff --git a/docs/wiki/Event-Versioning-Examples.md b/docs/wiki/Event-Versioning-Examples.md new file mode 100644 index 00000000..aabd9dc7 --- /dev/null +++ b/docs/wiki/Event-Versioning-Examples.md @@ -0,0 +1,583 @@ +# Event Versioning: Practical Examples + +This guide provides practical examples of implementing event versioning in Purview EventSourcing. + +## Table of Contents + +1. [Additive Changes (No Versioning Needed)](#additive-changes) +2. [Versioning with SchemaVersion](#versioning-with-schemaversion) +3. [Single-Hop Upcasting](#single-hop-upcasting) +4. [Multi-Hop Upcasting Chains](#multi-hop-upcasting-chains) +5. [Common Mistakes & How to Avoid Them](#common-mistakes) +6. [Testing Versioned Events](#testing-versioned-events) + +## Additive Changes + +When you add a new optional field to an event, no versioning is needed. Old events will deserialize successfully with the new field set to its default value. + +### Example: Adding an Optional Phone Number + +**Initial event (v1, implicit SchemaVersion = 1):** +```csharp +public sealed class CustomerRegistered : EventBase +{ + public string CustomerId { get; set; } = default!; + public string Email { get; set; } = default!; + + protected override void BuildEventHash(ref HashCode hash) + { + hash.Add(CustomerId); + hash.Add(Email); + } +} +``` + +**After adding an optional field (still v1, no SchemaVersion bump needed):** +```csharp +public sealed class CustomerRegistered : EventBase +{ + public string CustomerId { get; set; } = default!; + public string Email { get; set; } = default!; + public string? PhoneNumber { get; set; } // Optional, new field + + protected override void BuildEventHash(ref HashCode hash) + { + hash.Add(CustomerId); + hash.Add(Email); + // Note: Don't hash optional fields that might be null + } +} +``` + +**Aggregate apply logic:** +```csharp +protected override void ApplyEvent(IEvent @event) +{ + switch (@event) + { + case CustomerRegistered cr: + CustomerId = cr.CustomerId; + Email = cr.Email; + PhoneNumber = cr.PhoneNumber ?? "N/A"; + break; + } +} +``` + +Old events will deserialize with `PhoneNumber = null`, and the aggregate handles it gracefully. + +--- + +## Versioning with SchemaVersion + +When you make a **breaking change** to an event's payload (required field added, meaning changed, property removed), bump the `SchemaVersion`. + +### Example: Making Phone Number Required + +**Old event (v1):** +```csharp +public sealed class CustomerRegistered : EventBase +{ + public string CustomerId { get; set; } = default!; + public string Email { get; set; } = default!; + public string? PhoneNumber { get; set; } // Was optional + + protected override void BuildEventHash(ref HashCode hash) + { + hash.Add(CustomerId); + hash.Add(Email); + } +} +``` + +**New event (v2, breaking change):** +```csharp +public sealed class CustomerRegistered : EventBase +{ + public string CustomerId { get; set; } = default!; + public string Email { get; set; } = default!; + public string PhoneNumber { get; set; } = default!; // Now required + + public override int SchemaVersion => 2; + + protected override void BuildEventHash(ref HashCode hash) + { + hash.Add(CustomerId); + hash.Add(Email); + hash.Add(PhoneNumber); // Now included in hash + } +} +``` + +### Defining the Upcaster + +```csharp +public sealed class CustomerRegisteredV1ToV2Upcaster + : IEventUpcaster +{ + public CustomerRegistered Upcast(CustomerRegistered source) + { + return new() + { + Details = source.Details, // Always preserve metadata + CustomerId = source.CustomerId, + Email = source.Email, + PhoneNumber = source.PhoneNumber ?? "UNKNOWN", // Default for old events + }; + } +} +``` + +--- + +## Single-Hop Upcasting + +Single-hop upcasting converts v1 events directly to v2 during replay. + +### Full Example: Order Events + +**Step 1: Define the events** + +```csharp +// Order event v1 (no currency) +public sealed class OrderCreatedV1 : EventBase +{ + public string OrderId { get; set; } = default!; + public decimal Amount { get; set; } + + protected override void BuildEventHash(ref HashCode hash) + { + hash.Add(OrderId); + hash.Add(Amount); + } +} + +// Order event v2 (with currency, breaking change) +public sealed class OrderCreated : EventBase +{ + public string OrderId { get; set; } = default!; + public decimal Amount { get; set; } + public string Currency { get; set; } = default!; + + public override int SchemaVersion => 2; + + protected override void BuildEventHash(ref HashCode hash) + { + hash.Add(OrderId); + hash.Add(Amount); + hash.Add(Currency); + } +} +``` + +**Step 2: Define the upcaster** + +```csharp +public sealed class OrderCreatedV1ToV2Upcaster + : IEventUpcaster +{ + public OrderCreated Upcast(OrderCreatedV1 source) + { + return new() + { + Details = source.Details, + OrderId = source.OrderId, + Amount = source.Amount, + Currency = "USD", // Default currency for old events + }; + } +} +``` + +**Step 3: Register the upcaster in DI** + +```csharp +services.AddEventUpcaster(); +``` + +**Step 4: Use in the aggregate** + +```csharp +public sealed class OrderAggregate : AggregateBase +{ + public string OrderId { get; private set; } = default!; + public decimal Amount { get; private set; } + public string Currency { get; private set; } = default!; + + public override string Id() => OrderId; + + protected override void ApplyEvent(IEvent @event) + { + switch (@event) + { + // Old event type (will be upcast to OrderCreated) + case OrderCreatedV1 v1: + OrderId = v1.OrderId; + Amount = v1.Amount; + Currency = "USD"; + break; + + // New event type (v2) + case OrderCreated oc: + OrderId = oc.OrderId; + Amount = oc.Amount; + Currency = oc.Currency; + break; + } + } +} +``` + +--- + +## Multi-Hop Upcasting Chains + +Multi-hop chains (v1 → v2 → v3) are automatically applied during replay. + +### Full Example: Three Event Versions + +**Step 1: Define the events** + +```csharp +// v1: OrderCreatedV1 +public sealed class OrderCreatedV1 : EventBase +{ + public string OrderId { get; set; } = default!; + public decimal Amount { get; set; } + + protected override void BuildEventHash(ref HashCode hash) + { + hash.Add(OrderId); + hash.Add(Amount); + } +} + +// v2: OrderCreatedV2 (added currency) +public sealed class OrderCreatedV2 : EventBase +{ + public string OrderId { get; set; } = default!; + public decimal Amount { get; set; } + public string Currency { get; set; } = default!; + + public override int SchemaVersion => 2; + + protected override void BuildEventHash(ref HashCode hash) + { + hash.Add(OrderId); + hash.Add(Amount); + hash.Add(Currency); + } +} + +// v3: OrderCreated (added tax info) +public sealed class OrderCreated : EventBase +{ + public string OrderId { get; set; } = default!; + public decimal Amount { get; set; } + public string Currency { get; set; } = default!; + public decimal TaxAmount { get; set; } + + public override int SchemaVersion => 3; + + protected override void BuildEventHash(ref HashCode hash) + { + hash.Add(OrderId); + hash.Add(Amount); + hash.Add(Currency); + hash.Add(TaxAmount); + } +} +``` + +**Step 2: Define the upcasters** + +```csharp +public sealed class OrderCreatedV1ToV2Upcaster + : IEventUpcaster +{ + public OrderCreatedV2 Upcast(OrderCreatedV1 source) + { + return new() + { + Details = source.Details, + OrderId = source.OrderId, + Amount = source.Amount, + Currency = "USD", + }; + } +} + +public sealed class OrderCreatedV2ToV3Upcaster + : IEventUpcaster +{ + public OrderCreated Upcast(OrderCreatedV2 source) + { + return new() + { + Details = source.Details, + OrderId = source.OrderId, + Amount = source.Amount, + Currency = source.Currency, + TaxAmount = source.Amount * 0.1m, // 10% tax on amount + }; + } +} +``` + +**Step 3: Register both upcasters** + +```csharp +// Order matters: register from earliest to latest version +services.AddEventUpcaster(); +services.AddEventUpcaster(); +``` + +**Step 4: Aggregate receives the final upcast event** + +```csharp +public sealed class OrderAggregate : AggregateBase +{ + public string OrderId { get; private set; } = default!; + public decimal Amount { get; private set; } + public string Currency { get; private set; } = default!; + public decimal TaxAmount { get; private set; } + + public override string Id() => OrderId; + + protected override void ApplyEvent(IEvent @event) + { + switch (@event) + { + // The upcaster chain is applied before ApplyEvent is called. + // Old v1 and v2 events arrive as OrderCreated (v3) after upcasting. + case OrderCreated oc: + OrderId = oc.OrderId; + Amount = oc.Amount; + Currency = oc.Currency; + TaxAmount = oc.TaxAmount; + break; + } + } +} +``` + +During replay: +- V1 events → upcast by OrderCreatedV1ToV2Upcaster → upcast by OrderCreatedV2ToV3Upcaster → arrive as OrderCreated +- V2 events → upcast by OrderCreatedV2ToV3Upcaster → arrive as OrderCreated +- V3 events → arrive as-is (no upcasting needed) + +--- + +## Common Mistakes + +### ❌ Mistake 1: Forgetting to Copy EventDetails + +**Wrong:** +```csharp +public OrderCreated Upcast(OrderCreatedV1 source) +{ + return new() + { + // Forgot to copy Details! + OrderId = source.OrderId, + Amount = source.Amount, + Currency = "USD", + }; +} +``` + +This breaks idempotency, correlation, and audit trails. + +**Correct:** +```csharp +public OrderCreated Upcast(OrderCreatedV1 source) +{ + return new() + { + Details = source.Details, // Always copy + OrderId = source.OrderId, + Amount = source.Amount, + Currency = "USD", + }; +} +``` + +### ❌ Mistake 2: Creating a New Event Type Instead of Versioning + +If the semantic meaning changes (e.g., "registration" → "registration with email verification"), create a **new event type**, not a new version. + +**Wrong (semantic change, not a versioning scenario):** +```csharp +public sealed class UserRegistered : EventBase +{ + // v1: just email + public string Email { get; set; } = default!; + + // v2: now requires email verification + public string Email { get; set; } = default!; + public bool EmailVerified { get; set; } // Required, breaking change + + public override int SchemaVersion => 2; +} +``` + +This conflates two different processes. + +**Correct (introduce a new event type):** +```csharp +public sealed class UserRegistered : EventBase +{ + public string Email { get; set; } = default!; +} + +public sealed class UserRegisteredWithEmailVerification : EventBase +{ + public string Email { get; set; } = default!; + public bool EmailVerified { get; set; } +} + +// Use in aggregate: +switch (@event) +{ + case UserRegistered ur: + Email = ur.Email; + EmailVerified = false; + break; + + case UserRegisteredWithEmailVerification urwv: + Email = urwv.Email; + EmailVerified = urwv.EmailVerified; + break; +} +``` + +### ❌ Mistake 3: Not Hashing All Required Fields in SchemaVersion >= 2 + +When you increment SchemaVersion, all non-optional fields must be included in the hash. + +**Wrong:** +```csharp +public override int SchemaVersion => 2; + +protected override void BuildEventHash(ref HashCode hash) +{ + hash.Add(OrderId); + // Forgot to hash Currency even though it's now required +} +``` + +This creates hash collisions and violates the event's integrity. + +**Correct:** +```csharp +public override int SchemaVersion => 2; + +protected override void BuildEventHash(ref HashCode hash) +{ + hash.Add(OrderId); + hash.Add(Amount); + hash.Add(Currency); // Include all required fields +} +``` + +### ❌ Mistake 4: Circular Upcaster Chains + +The registry detects circular chains and throws an exception at registration time, but you can prevent this by registering upcasters in order (v1 → v2 → v3). + +**Wrong:** +```csharp +// This will throw at runtime +services.AddEventUpcaster(); +services.AddEventUpcaster(); // Creates a cycle! +``` + +**Correct:** +```csharp +// Always register from earlier to later versions +services.AddEventUpcaster(); +services.AddEventUpcaster(); +``` + +--- + +## Testing Versioned Events + +### Unit Test: Single-Hop Upcasting + +```csharp +[Fact] +public void Upcast_V1ToV2_PreservesDataAndDefaults() +{ + var upcaster = new OrderCreatedV1ToV2Upcaster(); + var v1Event = new OrderCreatedV1 + { + OrderId = "123", + Amount = 99.99m, + Details = { IdempotencyId = "idempotency-123" }, + }; + + var v2Event = upcaster.Upcast(v1Event); + + v2Event.OrderId.ShouldBe("123"); + v2Event.Amount.ShouldBe(99.99m); + v2Event.Currency.ShouldBe("USD"); + v2Event.Details.IdempotencyId.ShouldBe("idempotency-123"); +} +``` + +### Integration Test: Replay with Upcasting + +```csharp +[Fact] +public async Task Replay_WithV1Events_UpcastsToV2AndAppliesCorrectly() +{ + // 1. Register upcaster + services.AddEventUpcaster(); + + // 2. Save a V1 event directly to storage + var v1Event = new OrderCreatedV1 { OrderId = "123", Amount = 99.99m }; + await eventStore.SaveAsync(aggregateId, [v1Event], ...); + + // 3. Load the aggregate (triggers replay with upcasting) + var aggregate = await eventStore.GetAsync(aggregateId); + + // 4. Verify the aggregate state matches the upcast event + aggregate.OrderId.ShouldBe("123"); + aggregate.Amount.ShouldBe(99.99m); + aggregate.Currency.ShouldBe("USD"); // Upcast default +} +``` + +### Testing Unknown Events + +```csharp +[Fact] +public async Task Replay_WithUnknownEventType_ReturnsEventUnknownAndContinues() +{ + // 1. Save an event with a type that doesn't exist + var unknownEvent = new CustomEvent { ... }; + + // 2. Load the aggregate + var aggregate = await eventStore.GetAsync(aggregateId); + + // 3. Verify replay continues without throwing + aggregate.ShouldNotBeNull(); + + // 4. In a real test, you'd have a mixture of known and unknown events + // to verify partial replay works correctly +} +``` + +--- + +## Summary + +- **Additive changes (optional fields)** → No versioning needed +- **Breaking changes (required fields, removed fields, semantic changes)** → Increment SchemaVersion +- **Semantic meaning changes** → Create a new event type +- **Always copy EventDetails** in upcasters +- **Register upcasters in order** (v1 → v2 → v3 → …) +- **Test multi-hop chains** and unknown event handling +- **All providers apply upcasting during replay** (SQL Server, Azure Storage, MongoDB) + +For more information, see [Event-Versioning-Strategy.md](Event-Versioning-Strategy.md). diff --git a/docs/wiki/Event-Versioning-Strategy.md b/docs/wiki/Event-Versioning-Strategy.md new file mode 100644 index 00000000..bad099b6 --- /dev/null +++ b/docs/wiki/Event-Versioning-Strategy.md @@ -0,0 +1,168 @@ +# Event Versioning Strategy + +This document codifies the product-wide approach to event versioning and schema evolution across all Purview EventSourcing providers. + +## Core Principles + +1. **Events are append-only immutable facts.** Never change the meaning of persisted event data. +2. **SchemaVersion is the versioning contract.** Track breaking payload changes through the `SchemaVersion` property on event classes. +3. **Upcasting bridges payload versions.** When old events must hydrate into new event shapes, implement `IEventUpcaster`. +4. **Unknown events fail safely.** Providers return `EventUnknown` when event types cannot be resolved or deserialized. +5. **All providers implement consistent replay semantics.** Replay-time upcasting is applied uniformly across SQL Server, Azure Storage, and MongoDB. + +## When to Version vs. When to Rename + +### Add a new property without versioning (additive change) +- Property is **optional** (nullable or has a default). +- Backward compatibility is preserved: old events deserialize successfully without the new field. +- **Example:** `CustomerRegistered` gains an optional `PhoneNumber` field; old events hydrate with `null` or `string.Empty`. +- **Action:** No `SchemaVersion` bump needed; no upcaster required. + +### Increment SchemaVersion (breaking payload change) +- Property is **required** and has no safe default (e.g., changes meaning or becomes non-nullable). +- Property is **removed or renamed** without a clear mapping. +- **Example:** `OrderCreated` v1 has optional `Currency`; v2 makes it required. Or `Price` → `UnitPrice` with different semantics. +- **Action:** Use `[GenerateAggregateEvent(Version = 2)]` or manually override `SchemaVersion => 2`. Implement an upcaster. + +### Create a new event type (semantic change) +- The event's **meaning fundamentally changes** (e.g., `UserRegistered` → `UserRegisteredWithEmailVerification`). +- The domain concept is distinct and should have its own event class. +- **Example:** A new workflow requires user email verification at registration; instead of changing `UserRegistered`, define `UserRegisteredAndVerificationSent`. +- **Action:** Define a new event class. Optionally define an upcaster if the new event should apply the old event's data. + +## SchemaVersion Details + +### Scope +- `SchemaVersion` is per-event-class, not per-aggregate. +- Multiple events on one aggregate can have different versions. + +### Numbering +- Starts at 1 (default). +- Increment by 1 for each breaking change. +- Never decrease; version numbers are immutable markers. + +### Declaration + +**Via the source generator:** +```csharp +[GenerateAggregate] +public partial class OrderAggregate : AggregateBase +{ + public string OrderId { get; private set; } = default!; + public string Currency { get; private set; } = "USD"; // Added in v2 + + // Version 1: original (Currency not present in old events) + // public partial void Create(string orderId); + + // Version 2: Currency is now part of the event + [GenerateAggregateEvent(Version = 2)] + public partial void Create(string orderId, string currency); +} +``` + +**Manually:** +```csharp +public sealed class OrderCreated : EventBase +{ + public string OrderId { get; set; } = default!; + public string Currency { get; set; } = default!; + + public override int SchemaVersion => 2; + + protected override void BuildEventHash(ref HashCode hash) + { + hash.Add(OrderId); + hash.Add(Currency); + } +} +``` + +## Upcasting Chains + +### Purpose +Upcasters convert old event payloads (deserialized from storage) into current event shapes so aggregates can apply them during replay. + +### Implementation + +**Single-hop upcaster (v1 → v2):** +```csharp +public sealed class OrderCreatedV1ToV2Upcaster + : IEventUpcaster +{ + public OrderCreated Upcast(OrderCreatedV1 source) => + new() + { + Details = source.Details, // Always preserve metadata + OrderId = source.OrderId, + Currency = "USD", // Default for legacy events + }; +} +``` + +**Multi-hop chain (v1 → v2 → v3):** +```csharp +// Register both upcasters; the registry applies them in sequence. +services.AddEventUpcaster(); +services.AddEventUpcaster(); + +// On replay, events automatically: v1 → v2 → v3 (final) → aggregate.Apply() +``` + +### Upcaster Rules +- **Direction:** Forward only (v1 → v2 → v3 → …). Downgrading events is not supported. +- **Metadata:** Always copy `EventDetails` to the target event (idempotency, correlation, user, timestamp). +- **Cycle detection:** The registry detects and rejects circular upcaster chains at runtime. +- **Unknown target:** If an old event has no upcaster path to a known type, it remains `EventUnknown`. + +## Replay Semantics (All Providers) + +When replaying an aggregate from the event stream: + +1. **Deserialize** the event from JSON. If the event type cannot be resolved, return `EventUnknown`. +2. **Apply upcasting chain** (if a registry is present). Follow all registered upcasters in sequence until no further upcaster is found. +3. **Call aggregate.ApplyEvent()** with the (possibly upcast) event. +4. **Handle unknown events** gracefully. The aggregate's `CanApplyEvent()` should return false for `EventUnknown`; the store logs and continues replay. + +### Provider Implementation Checklist +- [ ] `GetEventRangeAsync()` applies the upcaster registry after deserializing. +- [ ] `GetAsync()` (single aggregate load) applies the upcaster registry during replay. +- [ ] Unknown event types return `EventUnknown` with metadata populated. +- [ ] Upcasting errors are logged and surfaced (not silently swallowed). +- [ ] Multi-hop upcasting chains are tested end-to-end. + +## Documentation and Contracts + +### EventDetails Preservation +- Always copy `EventDetails` in upcasters. These fields are critical for causation, correlation, and audit trails. +- Fields: `IdempotencyId`, `AggregateVersion`, `When`, `UserId`, `CausationId`, `CorrelationId`. + +### Event Type Naming +- Event type names are persisted in the event store. Renaming an event type breaks deserialization without a migration step. +- If renaming is necessary, define the old event type alongside the new one and create an upcaster. + +### Version Boundaries +- `SchemaVersion` on the event itself is serialized in the JSON payload. +- Consumers can inspect `event.SchemaVersion` to make conditional decisions during replay (fallback values, feature flags, etc.). + +## Test Coverage + +All providers must verify: + +1. **Additive changes** – Old events deserialize and apply without upcasters. +2. **Versioned events** – New events with `SchemaVersion > 1` deserialize correctly. +3. **Single-hop upcasting** – V1 events are upcast to V2 during replay. +4. **Multi-hop upcasting** – V1 → V2 → V3 chains work end-to-end. +5. **Unknown events** – Missing event types produce `EventUnknown` and replay continues. +6. **EventDetails preservation** – Metadata (idempotency, correlation, user) is copied in upcasters. +7. **Cycle detection** – Circular upcaster chains are rejected at registry construction. + +## Related Files + +- **Core abstractions:** `src/src/EventSourcing/Aggregates/Events/EventBase.cs`, `IEventUpcaster.cs`, `EventUpcasterRegistry.cs` +- **SQL Server replay:** `src/src/SqlServer/Events/SqlServerEventStore.GetEventRangeAsync.cs` (reference implementation) +- **Sample:** Versioned event example in `docs/wiki/` (to be added) +- **Tests:** Provider-specific replay tests (to be harmonized) + +--- + +*Last Updated: 2026-07-30* diff --git a/docs/wiki/Getting-Started.md b/docs/wiki/Getting-Started.md index 4ebae67f..667d9df9 100644 --- a/docs/wiki/Getting-Started.md +++ b/docs/wiki/Getting-Started.md @@ -15,6 +15,27 @@ dotnet add package Purview.EventSourcing.MongoDB dotnet add package Purview.EventSourcing.CosmosDb ``` +Optional packages: + +```bash +# In-memory provider (local/test scenarios) +dotnet add package Purview.EventSourcing.InMemory + +# Validation adapters +dotnet add package Purview.EventSourcing.FluentValidation +dotnet add package Purview.EventSourcing.ZodSharp +``` + +## Dependency guardrail for ZodSharp + +If your project references the `ZodSharpImpl` project directly and uses `ZodSharp` types, you must add: + +```xml + +``` + +`Purview.EventSourcing.ZodSharp` ships a build-time check (`ValidateZodSharpDirectReference`) in package `buildTransitive` assets so consumer projects fail fast with remediation guidance when this direct package reference is missing. + ## Define an aggregate (source generator) ```csharp @@ -46,14 +67,14 @@ Other provider registrations: ```csharp // Azure Storage (event store with blob support) -builder.Services.AddAzureTableEventStore(); +builder.Services.AddAzureStorageEventStore(); // MongoDB (events + queryable snapshots) builder.Services.AddMongoDBEventStore(); builder.Services.AddMongoDBSnapshotQueryableEventStore(); // Cosmos DB (queryable snapshots) -builder.Services.AddCosmosDbQueryableEventStore(); +builder.Services.AddCosmosDbSnapshotQueryableEventStore(); // Core-only fallback for projects without persistent query snapshots builder.Services.AddNullQueryableEventStore(); @@ -98,6 +119,9 @@ foreach (var item in history.Results) ## Next pages - [Provider Feature Matrix](Provider-Feature-Matrix.md) +- [Dependency Guardrails](Dependency-Guardrails.md) - [Source Generator Behaviors](Source-Generator-Behaviors.md) - [SQL Server Guide](SQL-Server-Guide.md) - [Release Flow](Release-Flow.md) + +If you plan to query snapshot JSON deeply in SQL providers, read the SQL Server guide and provider matrix before relying on nested predicates through scalar value object `.Value` members. diff --git a/docs/wiki/Home.md b/docs/wiki/Home.md index 71da6d7b..9e99bd06 100644 --- a/docs/wiki/Home.md +++ b/docs/wiki/Home.md @@ -5,7 +5,10 @@ This wiki is the project documentation hub for framework features, provider capa ## Start here - [Getting Started](Getting-Started.md) +- [Solution Design Guide](Solution-Design-Guide.md) +- [Solution Design Worksheet](Solution-Design-Worksheet.md) - [Provider Feature Matrix](Provider-Feature-Matrix.md) +- [Dependency Guardrails](Dependency-Guardrails.md) - [Source Generator Behaviors](Source-Generator-Behaviors.md) - [SQL Server Guide](SQL-Server-Guide.md) - [Release Flow](Release-Flow.md) @@ -16,11 +19,18 @@ This wiki is the project documentation hub for framework features, provider capa - `AggregateBase`, `IEventStore`, `IQueryableEventStore`, and `IEventStoreTransactionFactory`. - Source-generated aggregate events/command wiring from partial methods. - Provider-agnostic aggregate load/save/query APIs. +- **Solution design** + - Paper-first worksheets for aggregate boundaries, commands, events, relationships, and event streams. + - Guidance for relational data, value objects, validation layers, and schema evolution. - **Storage providers** - - SQL Server / Azure SQL: event streams + queryable snapshots + SQL transaction coordination. + - SQL Server / Azure SQL: append-only event streams, internal replay snapshots, and optional SQL query snapshots with transaction coordination. + - PostgreSQL: append-only event streams, internal replay snapshots, and optional PostgreSQL JSONB query snapshots. - Azure Storage: table-backed event streams with blob support for snapshots/large payloads. - - MongoDB: event streams + queryable snapshots. - - Cosmos DB: queryable snapshot store. + - MongoDB: event streams plus an optional MongoDB query snapshot store. + - Cosmos DB: optional query snapshot store. + - In-memory provider: non-persistent event/snapshot store for local/test scenarios. + - Validation adapters: FluentValidation and ZodSharp adapters for `IAggregateValidator`. + - SQL snapshot translation distinguishes between provider-converted scalar value objects and directly mapped complex snapshot graphs; see the provider matrix and SQL guide for details. - **Generator behavior** - `[GenerateAggregate]` supports no base, direct `AggregateBase`, and transitive base-chain inheritance. - Property hooks are property-scoped across generated events that map that property. diff --git a/docs/wiki/Provider-Feature-Matrix.md b/docs/wiki/Provider-Feature-Matrix.md index 4cdf8a77..8ded9122 100644 --- a/docs/wiki/Provider-Feature-Matrix.md +++ b/docs/wiki/Provider-Feature-Matrix.md @@ -2,30 +2,51 @@ This page summarizes feature availability by package so provider selection is explicit and accurate. -| Capability | `Purview.EventSourcing` (core) | `Purview.EventSourcing.SqlServer` | `Purview.EventSourcing.AzureStorage` | `Purview.EventSourcing.MongoDB` | `Purview.EventSourcing.CosmosDb` | -| --- | --- | --- | --- | --- | --- | -| Aggregate/event abstractions (`AggregateBase`, `EventBase`) | Yes | Uses core | Uses core | Uses core | Uses core | -| Provider-agnostic event facade (`IEventStore`) | Yes | SQL event store | Azure Table event store | MongoDB event store | Optional registration via snapshot provider | -| Provider-agnostic query facade (`IQueryableEventStore`) | Yes (interface + null implementation) | SQL snapshot store | Not provided | MongoDB snapshot store | Cosmos snapshot store | -| Event-stream persistence | Not persistent by itself | Yes | Yes | Yes | No | -| Snapshot-backed query/list/count | Null provider only | Yes | No | Yes | Yes | -| Blob-backed snapshots / large payloads | No | No | Yes | No | No | -| SQL-specific transaction factory (`ISqlServerEventStoreTransactionFactory`) | No | Yes | No | No | No | -| DI registration helpers | `AddNullQueryableEventStore()` | `AddSqlServerEventStore()`, `AddSqlServerSnapshotQueryableEventStore()` | `AddAzureTableEventStore()` | `AddMongoDBEventStore()`, `AddMongoDBSnapshotQueryableEventStore()` | `AddCosmosDbQueryableEventStore()` | +| Capability | `Purview.EventSourcing` (core) | `Purview.EventSourcing.SqlServer` | `Purview.EventSourcing.Postgres` | `Purview.EventSourcing.AzureStorage` | `Purview.EventSourcing.MongoDB` | `Purview.EventSourcing.CosmosDb` | +| --- | --- | --- | --- | --- | --- | --- | +| Aggregate/event abstractions (`AggregateBase`, `EventBase`) | Yes | Uses core | Uses core | Uses core | Uses core | Uses core | +| Provider-agnostic event facade (`IEventStore`) | Yes | SQL event store | PostgreSQL event store | Azure Table event store | MongoDB event store | Optional registration via snapshot provider | +| Provider-agnostic query facade (`IQueryableEventStore`) | Yes (interface + null implementation) | Optional SQL snapshot store | Optional PostgreSQL snapshot store | Not provided | Optional MongoDB snapshot store | Optional Cosmos snapshot store | +| Event-stream persistence | Not persistent by itself | Yes | Yes | Yes | Yes | No | +| Snapshot-backed query/list/count | Null provider only | Optional | Optional | No | Optional | Optional | +| Blob-backed snapshots / large payloads | No | No | No | Yes | No | No | +| SQL-specific transaction factory (`ISqlServerEventStoreTransactionFactory`) | No | Yes | Yes | No | No | No | +| Runtime-configured JSON payload indexes | No | Yes (event + snapshot stores, auto-create path) | Yes (GIN + expression indexes for snapshots) | No | No | No | +| DI registration helpers | `AddNullQueryableEventStore()` | `AddSqlServerEventStore()`, `AddSqlServerSnapshotQueryableEventStore()` | `AddPostgresEventStore()`, `AddPostgresSnapshotQueryableEventStore()` | `AddAzureStorageEventStore()` | `AddMongoDBEventStore()`, `AddMongoDBSnapshotQueryableEventStore()` | `AddCosmosDbSnapshotQueryableEventStore()` | ## Selection guidance -- Choose **SQL Server** when you need event streams and queryable snapshots with SQL-native transaction coordination. +- Choose **SQL Server** when you need event streams and optional SQL query snapshots with SQL-native transaction coordination. +- Choose **PostgreSQL** when you need append-only PostgreSQL event streams, replay snapshots for strategy-driven rehydration, and optionally a PostgreSQL-backed query store. - Choose **Azure Storage** when you want Azure Table event persistence with Blob support for large payloads/snapshots. - Choose **MongoDB** when you want both event and snapshot stores on MongoDB. - Choose **Cosmos DB** when you only need a queryable snapshot store. +## Snapshot model reminder + +- Event-store snapshots are replay/rehydration optimizations for append-only streams. +- Query snapshots are explicit read/query stores used through `IQueryableEventStore`. +- Applications may use the event store without any query snapshot store at all. +- Applications may also pair one event-store provider with a different query-store provider when that better fits read requirements. + +### SQL Server query translation notes + +- SQL snapshot queries support predicates over JSON-mapped primitive members and supported value-object shapes. +- SQL Server can additionally create runtime-managed indexes over supported JSON scalar paths when `JsonIndexOptions.Enabled = true` and `AutoCreateTable = true`. +- For provider-converted members (for example, a `[Scalar]` value object whose inner `Value` is a complex type), deep predicates on inner members are **not SQL-translatable** (for example: `a.ReportSummary.Value.ParserDetails.FailedLines > 0`). +- The same conceptual data **can** be queried deeply when exposed as a directly mapped complex property in the snapshot graph (for example: `a.ReportSummaryScalar.ParserDetails.FailedLines > 0`, where `ReportSummaryScalar` is a `ParserReportSummary`). +- `EventStoreList` / `EventStoreSet` members with `[ValueObject]` struct elements are persisted via JSON conversion for compatibility; treat nested element member filtering as non-translatable unless explicitly covered by tests. +- Nested dictionary/interface-collection members inside directly mapped complex snapshot graphs require explicit mapper support; when supported, prove the exact predicate path with provider integration tests. +- Recommended pattern: query by SQL-translatable fields first, or expose a directly mapped complex mirror property when deep SQL filtering is a real requirement. + ## Related docs - [Getting Started](Getting-Started.md) +- [Dependency Guardrails](Dependency-Guardrails.md) - [SQL Server Guide](SQL-Server-Guide.md) +- Postgres package README: `src/src/Postgres/README.md` - Core package README: `src/src/EventSourcing/README.md` -- SQL Server package README: `src/src/EventSourcing.SqlServer/README.md` -- Azure Storage package README: `src/src/EventSourcing.AzureStorage/README.md` -- MongoDB package README: `src/src/EventSourcing.MongoDB/README.md` -- Cosmos DB package README: `src/src/EventSourcing.CosmosDb/README.md` +- SQL Server package README: `src/src/SqlServer/README.md` +- Azure Storage package README: `src/src/AzureStorage/README.md` +- MongoDB package README: `src/src/MongoDB/README.md` +- Cosmos DB package README: `src/src/CosmosDb/README.md` diff --git a/docs/wiki/SQL-Server-Guide.md b/docs/wiki/SQL-Server-Guide.md index 1082f95d..2b7eaea0 100644 --- a/docs/wiki/SQL-Server-Guide.md +++ b/docs/wiki/SQL-Server-Guide.md @@ -2,10 +2,13 @@ Purview Event Sourcing ships separate SQL Server-backed event and snapshot implementations in a single NuGet package: -| Package | Class | Purpose | -|---------|-------|---------| -| `Purview.EventSourcing.SqlServer` | `SqlServerEventStore` | Pure event-sourced store — events are the source of truth | -| `Purview.EventSourcing.SqlServer` | `SqlServerSnapshotEventStore` | Queryable snapshot store — optimized for query/list/count over snapshots | +- `Purview.EventSourcing.SqlServer` + `SqlServerEventStore`: pure event-sourced store where events remain the source of truth. +- `Purview.EventSourcing.SqlServer` + `SqlServerSnapshotEventStore`: queryable snapshot store optimized for query/list/count over snapshots. + +These two concepts are related but **not interchangeable**: + +- the SQL Server **event store** keeps internal stream snapshots in its event table to speed aggregate rehydration and event-based operations, +- the **queryable snapshot store** is an optional LINQ/query-optimized store that can be omitted entirely or implemented by a different provider. Both stores create their tables automatically on first use (configurable) and use a **single shared table** for all aggregate types. @@ -21,9 +24,10 @@ Both stores create their tables automatically on first use (configurable) and us 6. [Per-Aggregate Schema and Table Routing](#per-aggregate-schema-and-table-routing) 7. [Event Schema Versioning](#event-schema-versioning) 8. [SQL Transaction Coordination](#sql-transaction-coordination) -9. [Snapshot Payload Shape](#snapshot-payload-shape) -10. [Behavior Notes and Caveats](#behavior-notes-and-caveats) -11. [Connection String Examples](#connection-string-examples) +9. [JSON Index Configuration](#json-index-configuration) +10. [Snapshot Payload Shape](#snapshot-payload-shape) +11. [Behavior Notes and Caveats](#behavior-notes-and-caveats) +12. [Connection String Examples](#connection-string-examples) --- @@ -111,7 +115,7 @@ builder.Services.AddSqlServerSnapshotQueryableEventStore(); ### Events Store (`SqlServerEventStoreOptions`) | Property | Type | Default | Description | -|---|---|---|---| +| --- | --- | --- | --- | | `ConnectionString` | `string` | *(required)* | ADO.NET connection string | | `SchemaName` | `string` | `"dbo"` | Default schema for the events table | | `TableName` | `string` | `"EventStore"` | Default table name for events | @@ -125,17 +129,19 @@ builder.Services.AddSqlServerSnapshotQueryableEventStore(); | `DefaultCacheSlidingDuration` | `TimeSpan` | `60 min` | Sliding cache expiry | | `RequiresValidPrincipalIdentifier` | `bool` | `true` | Require a `ClaimsPrincipal` identifier on save | | `AggregateTableOverrides` | `Dictionary` | `{}` | Per-aggregate schema/table overrides | +| `JsonIndexOptions` | `SqlServerJsonIndexOptions` | disabled / empty | Runtime-managed JSON computed columns and indexes for `Payload` | ### Snapshot Store (`SqlServerSnapshotEventStoreOptions`) | Property | Type | Default | Description | -|---|---|---|---| +| --- | --- | --- | --- | | `ConnectionString` | `string` | *(required)* | ADO.NET connection string | | `SchemaName` | `string` | `"dbo"` | Default schema for the snapshots table | | `TableName` | `string` | `"Snapshots"` | Default table name | | `AutoCreateTable` | `bool` | `true` | Create table on first use | | `UseDataCompression` | `bool` | `true` | Apply `PAGE` compression | | `AggregateTableOverrides` | `Dictionary` | `{}` | Per-aggregate schema/table overrides | +| `JsonIndexOptions` | `SqlServerJsonIndexOptions` | disabled / empty | Runtime-managed JSON computed columns and indexes for `Payload` | --- @@ -156,7 +162,7 @@ GRANT SELECT, INSERT, UPDATE, DELETE ON [dbo].[Snapshots] TO [app_login]; ### Auto-Create Permissions (`AutoCreateTable = true`) -When `AutoCreateTable` is enabled (the default), the application also needs DDL rights at startup to create the table and its indices: +When `AutoCreateTable` is enabled (the default), the application also needs DDL rights at startup to create the table, computed columns, and indices: ```sql -- Required to create tables and indices in the schema: @@ -201,9 +207,16 @@ GRANT ALTER ON SCHEMA::[dbo] TO [my-app-service]; Both stores use a **single shared table** by default. All aggregate types are stored in the same table and distinguished by the `AggregateType` column. +For clarity: + +- `SqlServerEventStore` stores stream metadata, events, idempotency markers, and **internal replay snapshots** in its event table. +- `SqlServerSnapshotEventStore` stores **queryable snapshots** in a separate snapshot table for LINQ-based reads. + +The internal replay snapshots in the event table are part of the event-store implementation and should not be treated as redundant copies of the optional queryable snapshot store. + ### Events table schema -``` +```text [Id] NVARCHAR(450) PK [EntityType] INT 0=StreamVersion, 1=Event, 2=IdempotencyMarker, 3=Snapshot [AggregateId] NVARCHAR(450) The aggregate's id @@ -219,7 +232,7 @@ Both stores use a **single shared table** by default. All aggregate types are st Three covering indices are created automatically: | Index | Columns | Purpose | -|---|---|---| +| --- | --- | --- | | `IX_EventStore_AggregateId_EntityType` | `(AggregateId, EntityType)` INCLUDE all | Stream lookups | | `IX_EventStore_EventRange` | `(AggregateId, EntityType, Version)` WHERE EntityType=1 | Event replay | | `IX_EventStore_AggregateType_EntityType` | `(AggregateType, EntityType, IsDeleted)` INCLUDE AggregateId | Aggregate ID enumeration | @@ -279,6 +292,7 @@ builder.Services.Configure(options => ### How it works When `SqlServerEventStore` is constructed it looks up `T`'s `AggregateType` name in `AggregateTableOverrides`. If a match is found: + - `SchemaName` override (if set) replaces the global `SchemaName` - `TableName` override (if set) replaces the global `TableName` - All other options (compression, timeouts, caching…) are inherited from the global options @@ -392,17 +406,145 @@ public sealed class CheckoutService( ### Notes and limits - SQL-native atomic commit is available when enlisted stores share the same SQL transaction boundary. +- Enlisting stores with different SQL transaction boundaries is rejected up front. - If you need cross-database/distributed coordination, implement a custom transaction coordinator strategy. - The SQL-specific coordinator requires at least one enlisted aggregate (the aggregate store establishes the connection/transaction boundary). - `IEventStoreTransactionFactory` remains available and unchanged for provider-agnostic transaction orchestration. ### Integration coverage -`src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTransactionIntegrationTests.cs` verifies: +`src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTransactionIntegrationTests.cs` verifies: - aggregate + raw SQL operation commit in one transaction, - aggregate + EF operation commit in one transaction, -- rollback of both aggregate and enlisted SQL when an enlisted operation throws. +- rollback of both aggregate and enlisted SQL when an enlisted operation throws, +- cross-implementation enlistment (event store + SQL snapshot event store) with additional SQL operations in one transaction. + +--- + +## JSON Index Configuration + +SQL Server stores event and snapshot payloads in a JSON column named `Payload`. You can optionally configure additional runtime-managed indexes over scalar JSON paths. + +The provider creates these indexes only when: + +- `AutoCreateTable = true`, and +- `JsonIndexOptions.Enabled = true`. + +The current implementation materializes each configured path as a computed column and then creates an index over that column. + +### Supported configuration shape + +```csharp +public sealed class SqlServerJsonIndexOptions +{ + public bool Enabled { get; set; } + public SqlServerJsonIndexDefinition[] Indexes { get; set; } = []; +} + +public sealed class SqlServerJsonIndexDefinition +{ + public string JsonPath { get; set; } = default!; + public string? IndexName { get; set; } + public string? ComputedColumnName { get; set; } + public string SqlType { get; set; } = "nvarchar(450)"; + public bool Unique { get; set; } + public SqlServerJsonComputedColumnMode ComputedColumnMode { get; set; } = SqlServerJsonComputedColumnMode.Persisted; + public string[] IncludeColumns { get; set; } = []; + public string? Filter { get; set; } +} +``` + +### Snapshot store example + +```csharp +builder.Services.AddSqlServerSnapshotQueryableEventStore(); + +builder.Services.Configure(options => +{ + options.ConnectionString = "Server=.;Database=MyApp;Trusted_Connection=True;"; + options.JsonIndexOptions.Enabled = true; + options.JsonIndexOptions.Indexes = + [ + new SqlServerJsonIndexDefinition + { + JsonPath = "$.StringProperty", + SqlType = "nvarchar(450)", + IncludeColumns = ["Id"], + }, + new SqlServerJsonIndexDefinition + { + JsonPath = "$.IncrementInt32", + SqlType = "int", + }, + ]; +}); +``` + +### Event store example + +```csharp +builder.Services.AddSqlServerEventStore(); + +builder.Services.Configure(options => +{ + options.ConnectionString = "Server=.;Database=MyApp;Trusted_Connection=True;"; + options.JsonIndexOptions.Enabled = true; + options.JsonIndexOptions.Indexes = + [ + new SqlServerJsonIndexDefinition + { + JsonPath = "$.Value", + SqlType = "nvarchar(450)", + IncludeColumns = ["AggregateId", "Version"], + Filter = "[EntityType] = 1", + }, + ]; +}); +``` + +### appsettings.json example + +```json +{ + "EventStore:SqlServerSnapshot": { + "ConnectionString": "Server=.;Database=MyApp;Trusted_Connection=True;", + "SchemaName": "dbo", + "TableName": "EventStoreSnapshots", + "JsonIndexOptions": { + "Enabled": true, + "Indexes": [ + { + "JsonPath": "$.StringProperty", + "SqlType": "nvarchar(450)", + "IncludeColumns": ["Id"] + } + ] + } + } +} +``` + +### Rules and limitations + +- `JsonPath` must start with `$`. +- `SqlType` must be a supported scalar SQL type expression such as `nvarchar(450)` or `int`. +- Filter expressions are intentionally restricted; unsafe SQL text is rejected during startup. +- Include columns are validated against the store schema. +- Indexes are **created**, but not dropped or reconciled, by the runtime. +- When `AutoCreateTable = false`, configured JSON indexes are not created automatically. + +### Query-shape guidance + +Indexes help only when the predicate path is SQL-translatable. + +- Good candidates: + - `a => a.StringProperty == value` + - `a => a.ReportSummaryScalar!.ParserDetails.FailedLines > 0` +- Poor candidates: + - `a => a.ReportSummary!.Value.ParserDetails.FailedLines > 0` when `ReportSummary` is a `[Scalar]` wrapping a complex inner type + +If deep filtering matters, prefer directly mapped complex mirror properties on the aggregate snapshot model and test the exact predicate path. --- @@ -417,14 +559,23 @@ Supported members include: - complex objects composed of supported members, - `EventStoreList` / `EventStoreSet` collections of supported primitive/complex members. +Important distinction for SQL translation: + +- A `[Scalar]` value object with a **primitive** inner value behaves like a scalar in queries. +- A `[Scalar]` value object with a **complex** inner value is persisted correctly, but deep predicates through `.Value` are not guaranteed to translate in SQL snapshot queries. +- If you need deep SQL predicates for a complex concept, expose the underlying complex type directly on the aggregate/query snapshot model (for example, a `ParserReportSummary` mirror property) and test the exact nested predicate you expect to support. +- Directly mapped complex snapshot members can support deep predicates such as `ParserDetails.FailedLines > 0`, subject to the provider's supported payload-shape rules. + Unsupported members fail during model creation, including: - arrays, - collection types other than `EventStoreList` / `EventStoreSet` (for example `List`, `IReadOnlyList`, `IEnumerable`, `HashSet`, `ImmutableArray`), -- unsupported object types such as dictionaries. +- unsupported object types that are not explicitly mapped for JSON conversion. Read-only and `[JsonIgnore]` members are excluded from snapshot payload mapping. +Some nested collection/dictionary members inside directly mapped complex graphs may be supported through provider JSON conversion rather than direct relational collection mapping. Treat those shapes as provider-specific and verify them with integration tests. + ### Examples ```csharp @@ -459,8 +610,8 @@ For generator/framework behavior (aggregate inheritance paths, hooks, event nami - Integration coverage includes replay compatibility scenarios for: - **Unknown events** (event type name no longer resolvable): replay skips affected records and continues. - **Schema-change style evolution** (event type still deserializes but is no longer applied/registered): replay logs `CannotApplyEvent` and continues. - - See: `src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.cs` - and `src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAsync.cs`. + - See: `src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.cs` + and `src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAsync.cs`. - Principal enforcement is enabled by default (`RequiresValidPrincipalIdentifier = true`), so save operations require the configured claim identifier to be present on the current principal. --- @@ -469,19 +620,19 @@ For generator/framework behavior (aggregate inheritance paths, hooks, event nami ### Local development (Windows auth) -``` +```text Server=(localdb)\MSSQLLocalDB;Database=MyApp;Trusted_Connection=True; ``` ### SQL Server with SQL auth -``` +```text Server=my-server.database.windows.net;Database=MyApp;User Id=app_login;Password=…; ``` ### Azure SQL with Managed Identity -``` +```text Server=my-server.database.windows.net;Database=MyApp;Authentication=Active Directory Default; ``` diff --git a/docs/wiki/Solution-Design-Guide.md b/docs/wiki/Solution-Design-Guide.md new file mode 100644 index 00000000..99b687c5 --- /dev/null +++ b/docs/wiki/Solution-Design-Guide.md @@ -0,0 +1,526 @@ +# Solution Design Guide + +This guide helps application developers design an event-sourced solution before writing aggregate code. It is written for Purview EventSourcing projects that use `AggregateBase`, source-generated aggregate events, provider event stores, and optional queryable snapshots. + +Use it in this order: + +1. Model the business process on paper. +2. Choose aggregate boundaries and relationships. +3. Name aggregates, commands, events, and value objects using the repository rules. +4. Decide where validation belongs. +5. Sketch the event stream and read/query model. +6. Only then create aggregate code and tests. + +For a printable template, use [Solution Design Worksheet](Solution-Design-Worksheet.md). + +## Design Principles + +- An aggregate is a consistency boundary, not a database table. +- An event is a fact that has happened, not an instruction to do something. +- Aggregate state is derived from its ordered event stream. +- Snapshots and query stores are optimizations/read models. The event stream remains the source of truth. +- Cross-aggregate workflows should be coordinated by services/process managers, not by loading other aggregates inside an aggregate method. +- Relational data belongs in query models, snapshots, projections, or referenced IDs, not as live joins inside aggregate invariants. +- Value objects carry reusable meaning and validation across aggregates. +- Validation should be explicit about when it runs: command-time, event creation, replay/hydration, save-time, or projection-time. +- Correlation IDs, idempotency markers, and transaction boundaries are part of the design, not just infrastructure details. + +## Repository Rules To Design Against + +### Aggregate Naming + +Aggregate classes should end with `Aggregate`. + +```csharp +public sealed partial class OrderAggregate : AggregateBase +{ +} +``` + +`AggregateBase` derives the persisted aggregate type by trimming the `Aggregate` suffix and converting the remaining type name to lower kebab case: + +| Class name | Aggregate type | +| --- | --- | +| `OrderAggregate` | `order` | +| `CustomerAggregate` | `customer` | +| `LearningHTMLTestAggregate` | `learning-html-test` | + +The aggregate type is used by store implementations for stream grouping and lookup. Treat it as persisted data. Renaming an aggregate class or overriding the aggregate type after data exists is a migration decision. + +The source generator supports aggregates that: + +- are `partial` +- have no declared base class, where the generator adds `AggregateBase` +- directly inherit `AggregateBase` +- transitively inherit through a custom base class + +If an assembly uses `[GenerateAggregateDefaultBase]`, confirm the chosen default base class still inherits `AggregateBase` and does not hide event-sourcing behavior from developers. + +### Event Naming + +Generated event type names come from `[GenerateAggregateEvent]` method names unless overridden with `EventName`. + +Generated events normally end with `Event`. The event store name mapper trims that suffix and stores the event name as: + +```text +{aggregate-type}.{event-name-without-event-suffix} +``` + +Example: + +| Aggregate | Generated event type | Persisted event name | +| --- | --- | --- | +| `OrderAggregate` | `OrderCreatedEvent` | `order.order-created` | +| `CustomerAggregate` | `EmailChangedEvent` | `customer.email-changed` | +| `InventoryAggregate` | `StockReservedEvent` | `inventory.stock-reserved` | + +Prefer past-tense event names: + +- `OrderCreated` +- `CustomerRegistered` +- `EmailChanged` +- `StockReserved` +- `ReservationReleased` +- `OrderCancelled` + +Avoid command-like event names: + +- `CreateOrder` +- `ChangeEmail` +- `ReserveStock` +- `ValidateCustomer` + +If the generated name is not the business language you want to persist, set it explicitly: + +```csharp +[GenerateAggregateEvent(EventName = "CustomerRegistered")] +public partial CustomerAggregate RegisterCustomer(string name, string email); +``` + +Use explicit `EventName` sparingly. It is useful for compatibility, integration contracts, or a domain term the generator cannot infer. Once persisted, event names are contracts. + +### Event Namespace + +By default, generated event classes are placed under: + +```text +{AggregateNamespace}.{AggregateNameWithoutAggregateSuffix}Events +``` + +For example, `Purview.EventSourcing.Samples.Domain.OrderAggregate` generates events in an `OrderEvents` namespace. You can override the namespace at aggregate or method level with `EventNamespace`, but use that only when you need stable compatibility or a shared event namespace. + +### Generated Method Shapes + +Use generated methods for state changes that should become events: + +```csharp +[GenerateAggregateEvent] +public partial OrderAggregate CreateOrder(CustomerId customerId); +``` + +Keep a public wrapper when the business intent needs guard clauses, calculations, or multiple lower-level event methods: + +```csharp +public OrderAggregate ConfirmOrder() => SetStatusCode(OrderStatusCode.Confirmed); + +[GenerateAggregateEvent] +private partial OrderAggregate SetStatusCode(OrderStatusCode status); +``` + +Use collection events for `EventStoreList` and `EventStoreSet` properties: + +```csharp +public EventStoreSet RelatedProjects { get; private set; } = []; + +[GenerateAggregateCollectionEvent(nameof(RelatedProjects))] +public partial ReportUploadAggregate AddRelatedProject(ProjectId projectId); +``` + +Use `[Computed]` for deterministic values that callers must not supply directly and that generated hooks finalize before recording the event. Use `Manual = true` when generated property mapping is not expressive enough and you will write the `Apply(...)` method yourself. + +## Paper-First Worksheet + +Copy these tables into a design note or pull request before building a new feature. + +### Business Capability + +| Question | Answer | +| --- | --- | +| What business process is this? | | +| Who initiates it? | | +| What decisions must be consistent immediately? | | +| What can be eventually consistent? | | +| What external systems or UI screens need to know? | | +| What audit questions must be answerable later? | | + +### Aggregate Candidates + +| Candidate aggregate | Owns these decisions | Does not own | Lifecycle start | Lifecycle end | +| --- | --- | --- | --- | --- | +| | | | | | + +Choose an aggregate when it owns rules that must be consistent in one event stream. Do not create one aggregate per relational table by default. + +### Command And Event Sketch + +| User/system intent | Aggregate method | Event fact | State changed | Validation needed | +| --- | --- | --- | --- | --- | +| Place order | `CreateOrder(...)` | `OrderCreated` | `CustomerId`, `Status` | Customer ID present | +| Add item | `AddLineItem(...)` | `LineItemAdded` or `LineItemsChanged` | `LineItems`, `TotalAmount` | Quantity, price, status | +| Confirm order | `ConfirmOrder()` | `OrderConfirmed` | `Status` | Has line items | + +Keep method names intention-focused. Keep event names factual and past tense. + +### Event Stream Sketch + +| Version | Event | Important payload | Why this event exists | +| --- | --- | --- | --- | +| 1 | `OrderCreated` | `customerId` | Starts the order lifecycle | +| 2 | `LineItemAdded` | `productId`, `quantity`, `unitPrice` | Audits basket change | +| 3 | `OrderConfirmed` | `status` | Locks in the order | + +Check that replaying the events in order recreates the aggregate state without calling external services. + +### Relationship Sketch + +| Relationship | Store on event/aggregate as | Enforce where | Query shape | +| --- | --- | --- | --- | +| Order belongs to customer | `CustomerId` value object/string | Application service or command validator | Projection joins customer snapshot | +| Order reserves inventory | `OrderId`, `ProductId`, `LocationId` | Workflow service across aggregates | Stock reservation read model | +| Report belongs to project | `ProjectId` value object | Command-time check or policy | Project report projection | + +## Relational Data + +Event-sourced aggregates should model relationships by identity, not by live object references. + +Use this pattern inside aggregates: + +```csharp +public CustomerId CustomerId { get; private set; } +public EventStoreList LineItems { get; private set; } = new(); +``` + +Avoid this inside aggregates: + +```csharp +public CustomerAggregate Customer { get; private set; } +public List Inventory { get; private set; } +``` + +### When You Need Relational Views + +Use query-side models for relational questions: + +- customer profile with recent orders +- inventory by location and product +- order details with customer and shipment data +- audit pages across aggregate types + +The project supports queryable snapshot stores for providers such as SQL Server, MongoDB, and Cosmos DB, and a null queryable store for core-only scenarios. Design relational views as projections/snapshots that can be rebuilt from event streams when possible. + +When designing snapshot-backed SQL queries, distinguish between: + +- provider-converted scalar value objects, which are ideal for invariants and serialization but may not support deep translation through `.Value`, and +- directly mapped complex snapshot members, which can support deep JSON-path predicates when the payload shape is explicitly supported and covered by integration tests. + +If deep snapshot filtering is a hard requirement for a complex concept, model that query-facing shape deliberately instead of assuming a scalar wrapper will remain queryable. + +The current repository also includes an in-memory provider and quick-start sample. Treat in-memory storage as a development/testing convenience unless a production use case has explicitly accepted its durability limits. + +### Cross-Aggregate Rules + +If a rule needs more than one aggregate, do not hide that rule inside one aggregate. + +Use an application service or process manager: + +```csharp +public sealed class CartCheckoutService(IEventStore eventStore) +{ + public async Task CheckoutAsync(string customerId, CartItem[] items, CancellationToken cancellationToken) + { + var order = await eventStore.CreateAsync( + aggregateId: Guid.NewGuid().ToString(), + cancellationToken: cancellationToken); + + order.CreateOrder(customerId); + + foreach (var item in items) + order.AddLineItem(item.ProductId, item.ProductName, item.Quantity, item.UnitPrice); + + await eventStore.SaveAsync(order, cancellationToken); + } +} +``` + +If several aggregates must be saved together, use the transaction support provided by the selected store where available. Still design each aggregate as if it can replay independently. + +`EventStoreTransaction` chooses the strongest compatible coordinator available: + +- If all enlisted stores share a native transaction boundary, commits are atomic. +- If no shared native boundary exists, commits are sequential under a shared correlation ID. +- Sequential fallback does not roll back aggregates that were already persisted. + +Design cross-aggregate workflows with this distinction in mind. For mixed stores or unsupported transaction boundaries, use idempotent commands, compensating events, and retry-safe process managers. + +## Value Objects + +Use value objects for concepts that are more meaningful than primitive strings, integers, or decimals: + +- `EmailAddress` +- `Name` +- `CustomerId` +- `ProjectId` +- `Money` +- `OrderStatus` +- `CurrencyCode` + +Value objects are a good place for normalization and validation that should apply everywhere. + +```csharp +[Scalar] +public readonly partial record struct EmailAddress +{ + public string Value { get; } + + static partial void OnNormalize(ref string value) => + value = value.Trim().ToLowerInvariant(); + + static partial void OnValidate(string value) + { + if (string.IsNullOrWhiteSpace(value)) + throw new ArgumentException("Email address cannot be empty.", nameof(value)); + } +} +``` + +Use scalar value objects when one primitive value carries the meaning. Use full value objects when the concept has multiple fields, such as `Money` with `Amount` and `Currency`. + +Generated value objects distinguish strict creation from hydration: + +- `Create(...)` normalizes and validates command-time input. +- `Hydrate(...)` rebuilds persisted state and should be replay-safe. +- `[Scalar]` and `[ValueObject]` default to hydration-oriented deserialization. +- `GenerateEmpty`, implicit primitive conversion, comparison operators, JSON converters, and constructor generation are configurable. + +### Contextual Value Objects + +Use contextual value objects when validity depends on the current aggregate state. The sample `OrderStatus` validates allowed transitions against the current `OrderAggregate`. + +This is useful for: + +- state machines +- date ranges relative to aggregate state +- limits that depend on current totals +- transitions that must not be checked again during replay + +Design rule: command-time creation can be strict; replay/hydration must be able to rebuild historical state. + +## Validation Across The Board + +Use the smallest validation scope that correctly owns the rule. + +| Rule type | Best location | Runs during replay? | Example | +| --- | --- | --- | --- | +| Primitive shape | Value object | Usually hydrate-safe | Email format, non-empty name | +| Command input | Public aggregate method | No | Quantity must be positive | +| Property normalization | `OnChanging` hook | No | Trim/lowercase email | +| State transition | Contextual value object or aggregate method | No for strict command path | Draft to Confirmed only | +| State mutation | Generated/manual `Apply(...)` | Yes | Set `Status`, update totals | +| Whole aggregate validity | DataAnnotations default validator or FluentValidation `IValidator` at save | Save-time | Snapshot must be internally valid | +| Cross-aggregate rule | Application service/process manager | No | Customer must exist before order | +| Read model rule | Projection/query model | Projection-time | Denormalized search fields | + +### Aggregate Method Guards + +Public aggregate methods should protect business intent before raising events: + +```csharp +public InventoryAggregate ReserveStock(int quantity, string? orderId) +{ + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(quantity); + + if (quantity > AvailableQuantity) + throw new InvalidOperationException( + $"Cannot reserve {quantity} units. Only {AvailableQuantity} available."); + + return ReserveStock( + quantityOnHand: QuantityOnHand, + reservedQuantity: ReservedQuantity + quantity, + orderId); +} +``` + +### Generator Hooks + +Use generated hooks for local normalization and event-specific extension points: + +- `OnChanging(ref value)` runs before event creation on the command path. +- `OnChanged(previous, current)` runs in `Apply(...)`, including replay. +- `OnRaisingEvent(ref ...)` runs before the generated event is recorded. +- `OnRaisedEvent(@event)` runs after event creation. +- `OnAppliedEvent(@event)` runs after application. +- `OnShouldApplyEvent(@event, ref bool shouldApply)` can skip generated application. + +Because `OnChanged` runs during replay, keep it deterministic and free of external side effects. + +### Save-Time Validation + +Stores run aggregate validation before persistence. With no custom validator, the current implementation uses `DefaultAggregateValidator`, which validates standard DataAnnotations such as `[Range]`. Store constructors accept `IAggregateValidator?` — when null, the default DataAnnotations validator is used. + +FluentValidation integration is available in the separate `Purview.EventSourcing.FluentValidation` package, which provides `FluentValidationAggregateValidator` to adapt `FluentValidation.IValidator` to `IAggregateValidator`. Register it via `AddFluentValidationAdapter()` or `AddFluentValidationAdapter()` DI extensions. + +Use save-time validation for aggregate-wide consistency checks that should pass before persistence: + +```csharp +public sealed class OrderAggregate : AggregateBase +{ + [Range(0, double.MaxValue)] + public decimal TotalAmount { get; private set; } +} +``` + +Do not rely only on save-time validation for user-facing command errors. Put business guard clauses near the command method as well so invalid operations fail before an event is created. + +`SaveResult` carries `Saved`, `Skipped`, and `ValidationResult`. Check `IsValid` or call `EnsureValid()` when callers need validation failures surfaced as exceptions. + +## Implementation Pattern + +Prefer this aggregate shape: + +```csharp +[GenerateAggregate] +public sealed partial class OrderAggregate : AggregateBase +{ + public CustomerId CustomerId { get; private set; } + public OrderStatus Status { get; private set; } = OrderStatus.Draft; + public EventStoreList LineItems { get; private set; } = new(); + public decimal TotalAmount { get; private set; } + + public OrderAggregate ConfirmOrder() => + SetStatusCode(OrderStatusCode.Confirmed); + + public OrderAggregate AddLineItem(string productId, string productName, int quantity, decimal unitPrice) + { + ArgumentException.ThrowIfNullOrWhiteSpace(productId); + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(quantity); + ArgumentOutOfRangeException.ThrowIfNegative(unitPrice); + + var updated = LineItems.Append(new OrderLineItem(productId, productName, quantity, unitPrice)).ToList(); + + return AddLineItem( + new EventStoreList(updated), + totalAmount: updated.Sum(m => m.Quantity * m.UnitPrice)); + } + + [GenerateAggregateEvent(EventName = "OrderCreated")] + public partial OrderAggregate CreateOrder(CustomerId customerId); + + [GenerateAggregateEvent(EventName = "OrderLineItemsChanged")] + private partial OrderAggregate AddLineItem(EventStoreList lineItems, decimal totalAmount); + + [GenerateAggregateEvent(EventName = "OrderStatusChanged")] + private partial OrderAggregate SetStatusCode(OrderStatusCode status); +} +``` + +The pattern is: + +1. Public methods express business intent and validate inputs. +2. Private generated methods record the factual state change when callers should not raise it directly. +3. Events carry enough data to replay state. +4. Value objects normalize and validate reusable concepts. +5. Services coordinate multiple aggregates. + +When a state change should only be recorded if a property actually changes, a manual aggregate can use `CompareRecordAndApply(...)`; generated aggregate methods already provide the higher-level convention for most cases. + +## Event Payload Design + +Put enough information on the event to replay the aggregate without external reads. + +Good payloads: + +- stable IDs +- normalized value objects +- values needed to update aggregate state +- metadata that explains the operation, such as `orderId` on stock reservations +- timestamps when the business time differs from event commit time + +Be careful with: + +- personally identifiable information +- large documents or binary payloads +- fields copied from another aggregate that may become stale +- values that can be calculated deterministically from event payload + +For metadata parameters that should be stored on generated events but not mapped to aggregate properties, use `[Metadata]`. + +```csharp +[GenerateAggregateEvent] +public partial InventoryAggregate ReserveStock( + int quantityOnHand, + int reservedQuantity, + [Metadata] string? orderId); +``` + +Use `[AggregateProperty(nameof(Property))]` when the parameter name does not match the aggregate property. + +```csharp +[GenerateAggregateEvent] +public partial InventoryAggregate Create( + string productId, + [AggregateProperty(nameof(QuantityOnHand))] int initialQuantity = 0); +``` + +## Schema Evolution + +Events are persisted facts. Changing them is a compatibility decision. + +- Add optional event properties when possible. +- Avoid changing the meaning of an existing property. +- Use `[GenerateAggregateEvent(Version = N)]` for breaking schema versions. +- Add upcasters when old events need to hydrate into newer event shapes. +- Do not change `EventSuffixLength` or naming conventions after data exists unless you plan a migration. +- Treat aggregate type names and event names as persisted contracts. + +## Operation Semantics + +Document these choices for each workflow: + +| Concern | Design decision | +| --- | --- | +| Aggregate ID | Who creates it: caller, `IAggregateIdFactory`, or store default? | +| Correlation ID | How is it propagated across service calls and transactions? | +| Idempotency | Should `UseIdempotencyMarker` be enabled for retries? | +| Principal ID | Will saves require a `ClaimsPrincipal` identifier? | +| Delete behavior | Soft delete, restore, or permanent delete? | +| Snapshot behavior | Use snapshots, skip snapshots for replay, or apply operation-specific snapshot strategy? | +| Notifications | Which change feed notifications should fire? | + +These details affect reliability and auditability as much as aggregate code does. + +## Testing Checklist + +For each aggregate: + +- Can version 1 of the stream be created with one clear lifecycle-start event? +- Does every public method either raise an event or intentionally no-op? +- Do invalid commands fail before an event is recorded? +- Does replaying the event stream rebuild the same state? +- Are value object rules tested independently? +- Are state-machine transitions tested for allowed and rejected paths? +- Are cross-aggregate workflows tested at service level? +- Are query/projection shapes tested separately from aggregate behavior? + +## Design Review Checklist + +Before coding, reviewers should be able to answer yes to these: + +- Aggregate names end in `Aggregate` and produce stable aggregate type names. +- Event names are past-tense business facts. +- Event payloads can replay state without external services. +- Relationships use IDs/value objects inside events and aggregates. +- Relational screens are designed as query models, snapshots, or projections. +- Validation is assigned to the right layer. +- Replay-safe code has no external side effects. +- Schema evolution and event versioning have been considered. +- Tests cover command guards, replay, value objects, and workflows. diff --git a/docs/wiki/Solution-Design-Worksheet.md b/docs/wiki/Solution-Design-Worksheet.md new file mode 100644 index 00000000..97382c41 --- /dev/null +++ b/docs/wiki/Solution-Design-Worksheet.md @@ -0,0 +1,183 @@ +# Solution Design Worksheet + +Use this worksheet before implementing a new aggregate, workflow, or read model. Keep the first version short. The goal is to expose modelling decisions early, not to produce perfect documentation. + +## Business Capability + +| Question | Answer | +| --- | --- | +| Capability or workflow name | | +| Primary actor or system | | +| Business outcome | | +| Immediate consistency decisions | | +| Eventually consistent decisions | | +| External systems involved | | +| Audit questions to answer later | | + +## Aggregate Boundaries + +| Candidate aggregate | Owns these rules | Must not own | Lifecycle starts when | Lifecycle ends when | +| --- | --- | --- | --- | --- | +| | | | | | +| | | | | | + +Boundary checks: + +- Can this aggregate make its decision using only its own current state? +- Does it need one ordered event stream to stay correct? +- Are other aggregate IDs enough, or are you trying to join live state? +- Would splitting this aggregate allow invalid business states? + +## Names + +| Concept | Name | Persisted name or note | +| --- | --- | --- | +| Aggregate class | `ExampleAggregate` | Aggregate type becomes `example` | +| Lifecycle-start event | | | +| Important transition event | | | +| Important correction event | | | +| Value object | | | +| Query model/projection | | | + +Naming checks: + +- Aggregate class ends in `Aggregate`. +- Generated event names should read as past-tense facts. +- Explicit `EventName` overrides are reserved for compatibility, integration contracts, or deliberate domain language. +- Events avoid command-style phrasing unless the business fact genuinely uses that language. +- Persisted names are stable enough to keep after release. + +## Commands And Events + +| Intent | Aggregate method | Event fact | Payload | Validation | +| --- | --- | --- | --- | --- | +| | | | | | +| | | | | | +| | | | | | + +Checks: + +- Invalid commands fail before an event is recorded. +- Event payload can replay state without external services. +- Metadata is marked with `[Metadata]` when it should not map to aggregate state. +- Parameter aliases use `[AggregateProperty(nameof(Property))]`. +- Deterministic generated values use `[Computed]`. +- Collection changes use `[GenerateAggregateCollectionEvent]` with `EventStoreList` or `EventStoreSet`. +- Manual events identify who owns the `Apply(...)` method. + +## Event Stream Example + +| Version | Event | Payload summary | Resulting aggregate state | +| --- | --- | --- | --- | +| 1 | | | | +| 2 | | | | +| 3 | | | | +| 4 | | | | + +Replay checks: + +- Replaying these events in order recreates the expected state. +- Replay does not call external systems. +- Replay does not depend on current time, random values, or database lookups. + +## Relationships + +| Relationship | Stored identity/value object | Enforced by | Read/query model | +| --- | --- | --- | --- | +| | | | | +| | | | | + +Relationship checks: + +- Aggregates store IDs/value objects, not other aggregate instances. +- Cross-aggregate rules live in an application service, process manager, or transaction boundary. +- Relational screens are supplied by snapshots, projections, or query models. +- If a workflow spans stores or transaction boundaries, compensating behavior is designed. + +## Value Objects + +| Value object | Primitive fields | Normalization | Validation | Context needed? | +| --- | --- | --- | --- | --- | +| | | | | | +| | | | | | + +Checks: + +- Reusable primitive rules are not duplicated across aggregates. +- Contextual value objects separate strict command-time creation from hydration/replay. +- Value object names use business language. + +## Validation Map + +| Rule | Layer | Failure message/user impact | Test case | +| --- | --- | --- | --- | +| | Value object | | | +| | Public aggregate method | | | +| | Generator hook | | | +| | DataAnnotations/save-time | | | +| | FluentValidation/save-time | | | +| | Application service/process manager | | | +| | Projection/query model | | | + +Validation checks: + +- Command errors fail before events are recorded. +- Save-time validation covers whole-aggregate consistency. +- Replay/hydration paths do not reject historical facts that were valid when written. +- Validation failures are surfaced from `SaveResult` where needed. + +## Operation Semantics + +| Concern | Decision | +| --- | --- | +| Aggregate ID source | | +| Correlation ID propagation | | +| Idempotency marker usage | | +| Principal/claim requirement | | +| Delete/restore/permanent-delete behavior | | +| Snapshot strategy | | +| Change feed notifications | | +| Transaction boundary | | + +Transaction checks: + +- Shared native transaction boundary is identified where atomicity is required. +- Sequential fallback is acceptable or mitigated. +- Retry and compensation behavior is documented. + +## Query And Reporting + +| Question/screen/API | Source events or snapshots | Shape | Rebuild strategy | +| --- | --- | --- | --- | +| | | | | +| | | | | + +Checks: + +- The aggregate is not shaped around a single UI screen. +- Query models can be rebuilt or corrected from event history where practical. +- Sensitive data and retention concerns are noted. +- Snapshots are treated as read/performance models, not as the canonical source of truth. + +## Schema Evolution + +| Event | Expected future change | Compatibility approach | +| --- | --- | --- | +| | | | +| | | | + +Checks: + +- Event versioning is considered for breaking payload changes. +- Old event names and aggregate type names are treated as persisted contracts. +- Upcasting or migration notes exist for released event shapes. + +## Ready To Build + +- Aggregate boundary is clear. +- Event names and payloads are agreed. +- Relationship modelling uses identities and query models. +- Validation has a named owner at each layer. +- Operation semantics are documented. +- Replay path is deterministic. +- Tests are identified for commands, replay, value objects, workflows, and projections. diff --git a/docs/wiki/Source-Generator-Behaviors.md b/docs/wiki/Source-Generator-Behaviors.md index 46a5b05f..24764cf8 100644 --- a/docs/wiki/Source-Generator-Behaviors.md +++ b/docs/wiki/Source-Generator-Behaviors.md @@ -16,7 +16,7 @@ Other eligibility rules: - Nested and generic aggregate types are not supported. - `RegisterEvents()` is generated and cannot be manually declared. -### Examples +### Inheritance examples ```csharp // 1) No declared base class (generator adds AggregateBase on generated partial) @@ -62,7 +62,7 @@ Default event type naming: Namespace can be overridden per method (`EventNamespace`) or by aggregate defaults. -### Examples +### Event naming examples ```csharp namespace Testing; @@ -109,7 +109,7 @@ Manual behavior: - `Manual = true` does not auto-wire property hooks unless manual code invokes them. -### Example +### Property hook example ```csharp [GenerateAggregate] @@ -155,8 +155,10 @@ public partial class ReportAggregate : AggregateBase - Generated mapping paths use `Create(...)` semantics for strict command-time conversion/validation. - Contextual `Create(TValue, in ValueObjectContext)` is used when available. - Replay/hydration paths apply event payloads through generated `Apply(...)` logic. +- Snapshot-query translation depends on how the provider maps the resulting property graph, not only on the value-object generator behavior. +- A `[Scalar]` value object that wraps a complex CLR type may serialize correctly while still requiring a separate directly mapped complex mirror property for deep SQL predicates. -### Examples +### Value-object conversion examples ```csharp // Scalar conversion diff --git a/docs/wiki/_Sidebar.md b/docs/wiki/_Sidebar.md index 5ddd3797..cfb351c9 100644 --- a/docs/wiki/_Sidebar.md +++ b/docs/wiki/_Sidebar.md @@ -1,6 +1,9 @@ - [Home](Home.md) - [Getting Started](Getting-Started.md) +- [Solution Design Guide](Solution-Design-Guide.md) +- [Solution Design Worksheet](Solution-Design-Worksheet.md) - [Provider Feature Matrix](Provider-Feature-Matrix.md) +- [Dependency Guardrails](Dependency-Guardrails.md) - [Source Generator Behaviors](Source-Generator-Behaviors.md) - [SQL Server Guide](SQL-Server-Guide.md) - [Release Flow](Release-Flow.md) diff --git a/global.json b/global.json index 7e883b67..3b0e64b5 100644 --- a/global.json +++ b/global.json @@ -1,11 +1,11 @@ { "sdk": { - "version": "10.0.300", + "version": "10.0.302", "rollForward": "latestMajor", "allowPrerelease": false }, "msbuild-sdks": { - "Purview.DotNetProjectSdk": "1.0.0-prerelease.15" + "Purview.DotNetProjectSdk": "1.0.0-prerelease.29" }, "test": { "runner": "Microsoft.Testing.Platform" diff --git a/nuget.config b/nuget.config index 07decbfd..a0fe606e 100644 --- a/nuget.config +++ b/nuget.config @@ -1,15 +1,20 @@  - - - - - - - - - - - - - \ No newline at end of file + + + + + + + + + + + + + + + + + + diff --git a/package-lock.json b/package-lock.json index e8af91f8..aa909d44 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "purview-eventsourcing", - "version": "2.0.0-prerelease.12", + "version": "2.0.0-prerelease.28", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "purview-eventsourcing", - "version": "2.0.0-prerelease.12", + "version": "2.0.0-prerelease.28", "devDependencies": { "@changesets/cli": "^2.6.0" } @@ -69,9 +69,9 @@ } }, "node_modules/@changesets/cli": { - "version": "2.31.0", - "resolved": "https://registry.npmjs.org/@changesets/cli/-/cli-2.31.0.tgz", - "integrity": "sha512-AhI4enNTgHu2IZr6K4WZyf0EPch4XVMn1yOMFmCD9gsfBGqMYaHXls5HyDv6/CL5axVQABz68eG30eCtbr2wFg==", + "version": "2.31.1", + "resolved": "https://registry.npmjs.org/@changesets/cli/-/cli-2.31.1.tgz", + "integrity": "sha512-uO05WTcRBwuVOJVSW8Cmpqw6q0WDL53ajGCMyszutvOe5toOnunbpM4jZzf+qxBOz7i0AzopZ8diBuewjmF40w==", "dev": true, "license": "MIT", "dependencies": { @@ -459,9 +459,9 @@ } }, "node_modules/chardet": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/chardet/-/chardet-2.1.1.tgz", - "integrity": "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/chardet/-/chardet-2.2.0.tgz", + "integrity": "sha512-rddelWYNPRrXq6PtNEN2S3f6t9ILzvqaN5pVgi4kqt9jHQaXIial9PznB5iSPVlQSLNaaH22ItWz3EJtQ10+OA==", "dev": true, "license": "MIT" }, @@ -659,9 +659,9 @@ } }, "node_modules/iconv-lite": { - "version": "0.7.2", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz", - "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==", + "version": "0.7.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.3.tgz", + "integrity": "sha512-IKXpvIzjnC9XTAUbVBcMfGS0EPaIXtW6v+zr+RRp+hqULEpo0owZax6wyRwPOJbWbzjYspQwusTsfVr0ifh4uQ==", "dev": true, "license": "MIT", "dependencies": { @@ -749,9 +749,9 @@ "license": "ISC" }, "node_modules/js-yaml": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.2.0.tgz", - "integrity": "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==", + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.0.tgz", + "integrity": "sha512-1td788aAnnZ5qs7V2QIRl1owjtYpbKt749Y3xauqQgwIIGF/xXWz1wMTEBx5O3LK3lXLVuqXPdPxj2BoFHaW9Q==", "dev": true, "funding": [ { @@ -1055,9 +1055,9 @@ } }, "node_modules/read-yaml-file/node_modules/js-yaml": { - "version": "3.14.2", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.2.tgz", - "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==", + "version": "3.15.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.15.0.tgz", + "integrity": "sha512-ttBQIIQPDeLjpPOohtUdXuXUVoA2uIB6fEH9HyJ7234s5mBJ5wTx20njxplLZQgLaOfpmPQA7X2t5AX6tIPbog==", "dev": true, "license": "MIT", "dependencies": { @@ -1121,9 +1121,9 @@ "license": "MIT" }, "node_modules/semver": { - "version": "7.8.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.4.tgz", - "integrity": "sha512-rUCObTnP32Q08R2uuIrt7r9PlEonuTmtuXYcW6s5kjdlj3xbnwe+21yXptAUYcMAABLkYYTtnmzb3w3EDZfueA==", + "version": "7.8.5", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz", + "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==", "dev": true, "license": "ISC", "bin": { diff --git a/package.json b/package.json index 78f8282f..3833427e 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "purview-eventsourcing", - "version": "2.0.0-prerelease.16", + "version": "2.0.0-prerelease.28", "devDependencies": { "@changesets/cli": "^2.6.0" } diff --git a/src/Directory.Build.props b/src/Directory.Build.props index a0b38c63..491ed343 100644 --- a/src/Directory.Build.props +++ b/src/Directory.Build.props @@ -1,13 +1,18 @@  - Purview + Purview.EventSourcing false Strict - https://github.com/kjldev/purview-eventsourcing + + + $(TargetsForTfmSpecificBuildOutput);CopyProjectReferencesToPackage + + + $(NoWarn);CS0436; @@ -15,29 +20,48 @@ true - + $(NoWarn);CA1031;CA2234 + + + <_Parameter1>3 + <_Parameter1_TypeName>System.Int32 + + + Kieron Lanning - KJL Solutions Ltd. - Copyright © $(CurrentYear) KJL Solutions - $(RepositoryUrl) + Purview-Dev + Copyright © $(CurrentYear) Purview-Dev + https://github.com/purview-dev/purview-eventsourcing.git + https://github.com/purview-dev/purview-eventsourcing git LICENSE.md - kjldev-logo.png + purview-logo.jpg README.md False + true + true + true + true + portable + true + snupkg + + + $(WarningsAsErrors);CA1031;CA1822 + diff --git a/src/Directory.Build.targets b/src/Directory.Build.targets index e5e277a7..1976d9a5 100644 --- a/src/Directory.Build.targets +++ b/src/Directory.Build.targets @@ -1,3 +1,20 @@  + + + + + <_ReferenceCopyLocalPaths Include="@(ReferenceCopyLocalPaths->WithMetadataValue('ReferenceSourceTarget', 'ProjectReference')->WithMetadataValue('PrivateAssets', 'All'))" /> + + + + + + diff --git a/src/ProjectAgent/skills/embedded-agent-skill.gitignore b/src/ProjectAgent/skills/embedded-agent-skill.gitignore new file mode 100644 index 00000000..355fbded --- /dev/null +++ b/src/ProjectAgent/skills/embedded-agent-skill.gitignore @@ -0,0 +1,7 @@ +# This directory is generated by Purview.EventSourcing during build so AI agents can discover the bundled skill. +# Keep this .gitignore checked in so the generated SKILL.md stays out of source control +# and updates to Purview.EventSourcing don''t cause unnecessary changes to your repository. +# To disable skill generation, set false +# in your project file or Directory.Build.props. +* +!.gitignore diff --git a/.github/skills/event-sourcing-aggregate-design/SKILL.md b/src/ProjectAgent/skills/event-sourcing-aggregate-design/SKILL.md similarity index 74% rename from .github/skills/event-sourcing-aggregate-design/SKILL.md rename to src/ProjectAgent/skills/event-sourcing-aggregate-design/SKILL.md index d849820c..076b1d14 100644 --- a/.github/skills/event-sourcing-aggregate-design/SKILL.md +++ b/src/ProjectAgent/skills/event-sourcing-aggregate-design/SKILL.md @@ -1,6 +1,6 @@ --- name: event-sourcing-aggregate-design -description: Define and model event-sourced aggregates, events, and state transitions. +description: "Use when designing or refining event-sourced aggregates, commands, events, invariants, source-generator hooks, or snapshot-queryable mirror properties." category: architecture roles: - architecture @@ -11,6 +11,8 @@ tags: - aggregates - domain-modeling - ddd + - snapshots + - sql --- # Event Sourcing Aggregate Design Skill @@ -28,6 +30,7 @@ For deeper implementation details, pair with: - Produce clear aggregate property names, event names, and transition rules. - Support implementation guidance for event-sourcing solutions. - Follow source-generator-first patterns for aggregate/event implementation. +- Distinguish canonical domain properties from query-facing snapshot mirror properties when SQL translation matters. ## Rules for aggregate design @@ -37,6 +40,7 @@ For deeper implementation details, pair with: - Rebuild state only by replaying events. - Do not store mutable aggregate state as source-of-truth outside event history. - Keep events immutable and append-only. +- Snapshots and snapshot-query properties are optimizations/read models, not source-of-truth. ## Source-generator implementation rules (Purview.EventSourcing style) @@ -53,14 +57,24 @@ For deeper implementation details, pair with: - Use `[Computed]` for values derived inside the aggregate and not provided by callers. - Keep aggregate collections as `EventStoreList` or `EventStoreSet` for generated collection-event patterns. - Use partial hooks for invariants and side effects: - - `OnRaisingEvent(ref ...)` for pre-emit validation/mutation. + - `OnComputingEvent(...)` for derived/computed parameter values. + - `OnRaisingEvent(...)` for pre-emit validation/mutation. + - `OnShouldApplyEvent(@event, ref bool shouldApply)` when an emitted event should be skipped. - `OnRaisedEvent(@event)` after event creation. - - `OnAppliedEvent(@event)` after state apply. + - `OnAppliedEvent(@event)` after state apply and during replay. - `OnChanging(ref value)` and `OnChanged(previous, current)` for property transitions. - Use `Manual = true` only when providing a manual event-body implementation is required. - Do not hand-roll registration boilerplate already generated (event types, registration, apply plumbing). - Prefer invariant enforcement in aggregate hooks and contextual value-object `Create(...)` methods. +## Query-facing mirror property rules + +- If a `[Scalar]` value object wraps a complex CLR type and SQL snapshot queries must filter on inner members, do **not** assume `MyScalar.Value.Nested.Property` will translate. +- Prefer a separate aggregate property that stores the underlying complex type for snapshot/query usage when deep SQL predicates are required. +- Populate mirror properties via `[Computed]` event parameters and generated hooks so callers cannot drift them away from canonical state. +- Treat mirror properties as derived snapshot state: they must always be recomputable from persisted events. +- Prove queryability with provider integration tests for the exact predicate path you expect to support. + ### Property-hook behavior rules - `OnChanging/Changed` are property-scoped and apply regardless of which generated event updates that property. @@ -103,6 +117,7 @@ public sealed partial class OrderAggregate : AggregateBase - Event names: past tense, business meaning first (for example: `OrderPlaced`, `PaymentCaptured`, `SubscriptionCancelled`). - Command names: intent/action phrasing (for example: `PlaceOrder`, `CapturePayment`, `CancelSubscription`). - Properties: domain language and explicit meaning (`CurrentStatus`, `TotalAmount`, `Revision`, `OccurredAtUtc`), avoid vague names (`Data`, `Value`, `Info`). +- Query-facing mirror properties should be explicit (`ReportSummaryScalar`, `SnapshotSummary`, `SearchModel`) rather than generic (`QueryData`). ## Property/state to event mapping process @@ -112,6 +127,7 @@ public sealed partial class OrderAggregate : AggregateBase 4. Emit one or more domain events that describe facts in past tense. 5. Update aggregate state by applying those events. 6. Confirm each new property is derivable from event history. +7. If a property exists for snapshot/query translation, confirm it is recomputed rather than caller-supplied. ## Support checklist for event-sourcing solutions @@ -122,6 +138,7 @@ public sealed partial class OrderAggregate : AggregateBase - Snapshots (if used) are optimization only, never source-of-truth. - Idempotency and optimistic concurrency expectations are defined. - Projection/read-model requirements are separated from write model concerns. +- SQL/query-provider translation assumptions are covered by tests when query-facing mirrors are introduced. ## Output template to use @@ -132,4 +149,4 @@ When applying this skill, provide: 3. Command list with validation rules. 4. Event catalog with payload schema, version, and naming rationale. 5. State transition table (current state + command -> event(s) + new state). -6. Implementation notes (generated apply/replay flow, concurrency, versioning, snapshots). +6. Implementation notes (generated apply/replay flow, `OnComputing`/`OnRaising`/`OnShouldApply`/`OnRaised`/`OnApplied`, concurrency, versioning, snapshots, and query-facing mirrors). diff --git a/.github/skills/event-sourcing-aggregate-validation/SKILL.md b/src/ProjectAgent/skills/event-sourcing-aggregate-validation/SKILL.md similarity index 68% rename from .github/skills/event-sourcing-aggregate-validation/SKILL.md rename to src/ProjectAgent/skills/event-sourcing-aggregate-validation/SKILL.md index 3d6e8870..04482581 100644 --- a/.github/skills/event-sourcing-aggregate-validation/SKILL.md +++ b/src/ProjectAgent/skills/event-sourcing-aggregate-validation/SKILL.md @@ -1,6 +1,6 @@ --- name: event-sourcing-aggregate-validation -description: Apply aggregate validation patterns for command, save, and persistence-time guards. +description: "Use when defining event-sourced aggregate validation at command time, hook time, save time, or for computed snapshot/query mirror properties." category: architecture roles: - architecture @@ -11,6 +11,7 @@ tags: - aggregate - validation - fluentvalidation + - snapshots --- # Event Sourcing Aggregate Validation Skill @@ -20,7 +21,7 @@ Use this skill when defining validation strategy for event-sourced aggregates in ## Validation layers to apply 1. **Command/event-raising validation** - - Enforce transition and intent rules in generated hooks (`OnRaising...Event`, `OnChanging`). + - Enforce transition and intent rules in generated hooks (`OnComputing...Event`, `OnRaising...Event`, `OnShouldApply...Event`, `OnChanging`). - Reject invalid operations before events are recorded. 2. **Aggregate model validation** @@ -32,6 +33,10 @@ Use this skill when defining validation strategy for event-sourced aggregates in - If no custom validator is provided, `DefaultAggregateValidator` runs DataAnnotations validation. - If a FluentValidation `IValidator` is provided, it is adapted via `FluentValidationAggregateValidator`. +4. **Computed mirror validation** + - For snapshot/query-facing mirror properties, derive values in `[Computed]` hooks instead of trusting caller input. + - Keep canonical domain properties as the source for recomputing mirrored query shapes. + ## Rules - Keep invariant checks close to mutation points (command/hook layer). @@ -40,6 +45,8 @@ Use this skill when defining validation strategy for event-sourced aggregates in - Treat `SaveResult.IsValid` and `ValidationResult` as first-class outcomes. - Use `SaveResult.EnsureValid()` when invalid saves must throw immediately. - Preserve replay tolerance by avoiding command-time assumptions in hydration-only paths. +- For computed snapshot/query mirrors, validate derivation rules, not user-supplied values. +- If a save-time validator is added, prefer `IAggregateValidator` over ad-hoc validation inside stores. ## Aggregate validation checklist @@ -48,12 +55,13 @@ Use this skill when defining validation strategy for event-sourced aggregates in - Aggregate-level attributes capture simple declarative constraints. - Custom FluentValidation rules are used for cross-field/business policies not suited to attributes. - Save handlers inspect or enforce `SaveResult.ValidationResult`. +- Query-facing mirror properties are recomputed consistently from canonical state. ## Output template to use -1. Validation map by layer (command, aggregate model, save pipeline). -2. Hook methods and invariants per command. +1. Validation map by layer (command, aggregate model, save pipeline, computed mirrors). +2. Hook methods and invariants per command (`OnComputing...Event`, `OnRaising...Event`, `OnShouldApply...Event`, `OnChanging`/`Changed`). 3. Attribute-based constraints and rationale. 4. FluentValidation rules (if any) and when they execute. 5. SaveResult handling policy (`IsValid`, `EnsureValid`, error propagation). - +6. Mirror-property derivation guarantees when query-facing fields exist. diff --git a/.github/skills/event-sourcing-value-objects/SKILL.md b/src/ProjectAgent/skills/event-sourcing-value-objects/SKILL.md similarity index 74% rename from .github/skills/event-sourcing-value-objects/SKILL.md rename to src/ProjectAgent/skills/event-sourcing-value-objects/SKILL.md index c9d9f49a..e87a1109 100644 --- a/.github/skills/event-sourcing-value-objects/SKILL.md +++ b/src/ProjectAgent/skills/event-sourcing-value-objects/SKILL.md @@ -1,6 +1,6 @@ --- name: event-sourcing-value-objects -description: Model scalar and complex value objects with source-generated normalization and validation. +description: "Use when modeling scalar, complex, or contextual value objects with source-generated normalization, validation, Hydrate/Create semantics, or query-translation awareness." category: architecture roles: - architecture @@ -11,6 +11,8 @@ tags: - value-objects - source-generator - validation + - snapshots + - sql --- # Event Sourcing Value Objects Skill @@ -19,10 +21,11 @@ Use this skill when defining value objects in `Purview.EventSourcing` with sourc ## Goals -- Model scalar and non-scalar value objects with strong invariants. +- Model scalar, non-scalar, and contextual value objects with strong invariants. - Normalize incoming values consistently. - Validate strict creation paths while preserving replay/hydration semantics. - Support aggregate-aware validation through contextual value object creation. +- Make query-translation tradeoffs explicit when value objects are used in snapshot-backed SQL queries. ## Scalar value object rules (`[Scalar]`) @@ -34,6 +37,14 @@ Use this skill when defining value objects in `Purview.EventSourcing` with sourc - Use `Hydrate(...)` for replay/deserialization where strict checks should not be re-run. - Use `ValueObjectDeserializationMode.Strict` only when strict `Create(...)` behavior is required during deserialization. - Prefer explicit null/empty guards and domain-specific exceptions. +- Prefer `GenerateValueObjectDefaultsAttribute` for assembly-wide defaults instead of repeating per-type configuration. + +### Scalar queryability rules + +- Scalar value objects with primitive inner values are the most query-friendly shape for provider-backed snapshot filters. +- Scalar value objects that wrap complex CLR types preserve invariants and serialization, but SQL providers may treat them as provider-converted scalars. +- Do **not** assume nested predicates such as `Aggregate.ComplexScalar.Value.Child.Prop` are SQL-translatable. +- If deep SQL filtering is required, expose the underlying complex type separately on the aggregate/query model and test the exact predicate path. ### Scalar template @@ -60,6 +71,7 @@ public readonly partial record struct EmailAddress - Normalize all component inputs together in `OnNormalize(ref ...)` before validation. - Validate business invariants in `OnValidate(...)`. - Keep non-scalar objects immutable and self-validating. +- For `struct` value objects, declare `OnValidate` as `readonly` when it does not mutate state; the generator mirrors the modifier on the generated declaration. ### Non-scalar template @@ -112,6 +124,7 @@ public readonly partial record struct OrderStatus - Put primitive-format and canonicalization rules in value objects (`OnNormalize`/`OnValidate`). - Put aggregate lifecycle/state-machine rules in aggregate hooks and contextual `Create(...)`. - Keep replay-safe behavior by separating strict creation (`Create`) from hydration (`Hydrate`). +- Put SQL snapshot query-shape decisions in aggregate/query-model design rather than inside the value object itself. ## Output template to use @@ -120,4 +133,4 @@ public readonly partial record struct OrderStatus 3. Validation/invariant rules with expected exceptions. 4. Strict create vs hydrate behavior. 5. Aggregate-context dependencies (if contextual). - +6. Queryability notes for snapshot-backed providers when relevant. diff --git a/src/Purview.EventSourcing.slnx b/src/Purview.EventSourcing.slnx index aeaa104a..49905be3 100644 --- a/src/Purview.EventSourcing.slnx +++ b/src/Purview.EventSourcing.slnx @@ -1,58 +1,68 @@ + + - - + + + + + + + + + + + + + + - - - - + + + + + + + - - - - - + + + + + + - - - - - + + + + + + + + + + + - - - - + + + + + - - - + + + diff --git a/src/src/Admin.API/Admin.API.csproj b/src/src/Admin.API/Admin.API.csproj new file mode 100644 index 00000000..017d2f02 --- /dev/null +++ b/src/src/Admin.API/Admin.API.csproj @@ -0,0 +1,20 @@ + + + true + Purview Event Sourcing Admin Portal API + ASP.NET Minimal API endpoints for Purview EventSourcing Admin Portal with OpenAPI documentation. + $(PackageTags);purview;dotnet;event-sourcing;admin;api;openapi; + Purview.EventSourcing.Admin.Api + + + + + + + + + + + + + diff --git a/src/src/Admin.API/AdminPortalOptions.cs b/src/src/Admin.API/AdminPortalOptions.cs new file mode 100644 index 00000000..09cd953c --- /dev/null +++ b/src/src/Admin.API/AdminPortalOptions.cs @@ -0,0 +1,154 @@ +namespace Purview.EventSourcing.Admin.Api; + +/// +/// Configures the Admin portal endpoint, paging and projection limits. +/// +public sealed class AdminPortalOptions +{ + /// + /// The configuration section name used to bind these options. + /// + public const string Section = "AdminPortal"; + + /// + /// Gets or sets whether the Admin portal is enabled. + /// + public bool Enabled { get; set; } = true; + + /// + /// Gets or sets the route prefix used by the Admin portal. + /// + public string RoutePrefix { get; set; } = "/admin/api"; + + /// + /// Gets or sets the feature toggle group. + /// + public AdminFeatureOptions Features { get; set; } = new(); + + /// + /// Gets or sets paging constraints for Admin queries. + /// + public AdminPagingOptions Paging { get; set; } = new(); + + /// + /// Gets or sets projection query constraints for Admin queries. + /// + public AdminProjectionOptions Projections { get; set; } = new(); + + /// + /// Validates the option set. + /// + /// Thrown when the route prefix or nested option groups are invalid. + public void Validate() + { + if (string.IsNullOrWhiteSpace(RoutePrefix)) + throw new InvalidOperationException("AdminPortalOptions.RoutePrefix cannot be empty."); + + if (!RoutePrefix.StartsWith('/')) + throw new InvalidOperationException("AdminPortalOptions.RoutePrefix must start with '/'."); + + AdminFeatureOptions.Validate(Features); + Paging.Validate(); + Projections.Validate(); + } +} + +/// +/// Feature toggles for Admin portal capabilities. +/// +public sealed class AdminFeatureOptions +{ + /// + /// Gets or sets whether aggregate search is enabled. + /// + public bool SearchAggregates { get; set; } = true; + + /// + /// Gets or sets whether aggregate details are visible. + /// + public bool ViewAggregate { get; set; } = true; + + /// + /// Gets or sets whether event history is visible. + /// + public bool ViewEvents { get; set; } = true; + + /// + /// Gets or sets whether point-in-time projection is enabled. + /// + public bool ProjectPointInTime { get; set; } = true; + + /// + /// Gets or sets whether event export is enabled. + /// + public bool ExportEvents { get; set; } + + /// + /// Validates the option object shape. + /// + /// The options instance to validate. + public static void Validate(AdminFeatureOptions options) + { + ArgumentNullException.ThrowIfNull(options); + } +} + +/// +/// Paging constraints for Admin list and search queries. +/// +public sealed class AdminPagingOptions +{ + /// + /// Gets or sets the default page size. + /// + public int DefaultPageSize { get; set; } = 50; + + /// + /// Gets or sets the maximum page size. + /// + public int MaxPageSize { get; set; } = 500; + + /// + /// Validates paging constraints. + /// + /// Thrown when page size values are outside the supported range. + public void Validate() + { + if (DefaultPageSize < 1 || DefaultPageSize > MaxPageSize) + throw new InvalidOperationException( + "AdminPagingOptions.DefaultPageSize must be between 1 and MaxPageSize." + ); + + if (MaxPageSize < 1) + throw new InvalidOperationException("AdminPagingOptions.MaxPageSize must be >= 1."); + } +} + +/// +/// Projection query limits for Admin projection endpoints. +/// +public sealed class AdminProjectionOptions +{ + /// + /// Gets or sets the maximum number of versions to request in a single projection query. + /// + public int MaxVersionsPerQuery { get; set; } = 10000; + + /// + /// Gets or sets the maximum time range that can be projected at once. + /// + public TimeSpan MaxTimeRangePerQuery { get; set; } = TimeSpan.FromDays(365); + + /// + /// Validates projection constraints. + /// + /// Thrown when the limits are invalid. + public void Validate() + { + if (MaxVersionsPerQuery < 1) + throw new InvalidOperationException("AdminProjectionOptions.MaxVersionsPerQuery must be >= 1."); + + if (MaxTimeRangePerQuery < TimeSpan.Zero) + throw new InvalidOperationException("AdminProjectionOptions.MaxTimeRangePerQuery cannot be negative."); + } +} diff --git a/src/src/Admin.API/Contracts/AggregateSearchRequest.cs b/src/src/Admin.API/Contracts/AggregateSearchRequest.cs new file mode 100644 index 00000000..3d1985d2 --- /dev/null +++ b/src/src/Admin.API/Contracts/AggregateSearchRequest.cs @@ -0,0 +1,13 @@ +namespace Purview.EventSourcing.Admin.Api.Contracts; + +public sealed record AggregateSearchRequest( + string? AggregateType, + string? AggregateId, + DateTimeOffset? FromUtc, + DateTimeOffset? ToUtc, + bool? IsDeleted, + bool? IsRestored, + int Page = 1, + int PageSize = 50, + string Sort = "LastUpdatedUtc desc" +); diff --git a/src/src/Admin.API/Contracts/EventRangeRequest.cs b/src/src/Admin.API/Contracts/EventRangeRequest.cs new file mode 100644 index 00000000..d9126230 --- /dev/null +++ b/src/src/Admin.API/Contracts/EventRangeRequest.cs @@ -0,0 +1,11 @@ +namespace Purview.EventSourcing.Admin.Api.Contracts; + +public sealed record EventRangeRequest( + long? VersionFrom = null, + long? VersionTo = null, + DateTimeOffset? TimeFromUtc = null, + DateTimeOffset? TimeToUtc = null, + int Page = 1, + int PageSize = 50, + string Sort = "Version asc" +); diff --git a/src/src/Admin.API/Endpoints/AdminAggregatesEndpoints.cs b/src/src/Admin.API/Endpoints/AdminAggregatesEndpoints.cs new file mode 100644 index 00000000..3207f9cc --- /dev/null +++ b/src/src/Admin.API/Endpoints/AdminAggregatesEndpoints.cs @@ -0,0 +1,147 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Http.HttpResults; +using Microsoft.AspNetCore.Mvc; +using Microsoft.AspNetCore.Routing; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.Api.Contracts; +using Purview.EventSourcing.Admin.Security; + +namespace Purview.EventSourcing.Admin.Api.Endpoints; + +public static class AdminAggregatesEndpoints +{ + public static void MapSearchAggregates(RouteGroupBuilder group) + { + group + .MapPost("/aggregates/search", SearchAggregatesAsync) + .WithName("SearchAggregates") + .WithSummary("Search for aggregates") + .WithDescription("Search aggregates by type, id, date range, or status flags with pagination support.") + .RequireAuthorization(AdminPortalPolicies.SearchAggregates); + } + + public static void MapEventRange(RouteGroupBuilder group) + { + group + .MapGet("/aggregates/{aggregateType}/{aggregateId}/events", GetEventRangeAsync) + .WithName("GetAggregateEventRange") + .WithSummary("Get aggregate event range") + .WithDescription("Returns the aggregate event stream within version and timestamp bounds.") + .RequireAuthorization(AdminPortalPolicies.ViewEvents); + } + + public static void MapProjectionAtVersion(RouteGroupBuilder group) + { + group + .MapGet("/aggregates/{aggregateType}/{aggregateId}/projection", GetProjectionAtVersionAsync) + .WithName("GetAggregateProjectionAtVersion") + .WithSummary("Get aggregate projection at version") + .WithDescription("Projects aggregate state at a specific version.") + .RequireAuthorization(AdminPortalPolicies.ProjectPointInTime); + } + + public static void MapProjectionAtTime(RouteGroupBuilder group) + { + group + .MapGet("/aggregates/{aggregateType}/{aggregateId}/projection/time", GetProjectionAtTimeAsync) + .WithName("GetAggregateProjectionAtTime") + .WithSummary("Get aggregate projection at time") + .WithDescription("Projects aggregate state at a specific UTC timestamp.") + .RequireAuthorization(AdminPortalPolicies.ProjectPointInTime); + } + + static async Task>> SearchAggregatesAsync( + AggregateSearchRequest request, + IAdminAggregateQueryService queryService, + IOptions options, + CancellationToken cancellationToken + ) + { + // Clamp page size to max + var pageSize = Math.Min(request.PageSize, options.Value.Paging.MaxPageSize); + pageSize = Math.Max(pageSize, 1); + + var query = new AggregateSearchQuery( + request.AggregateType, + request.AggregateId, + request.FromUtc, + request.ToUtc, + request.IsDeleted, + request.IsRestored, + request.Page, + pageSize, + request.Sort + ); + + var result = await queryService.SearchAsync(query, cancellationToken); + return TypedResults.Ok(result); + } + + static async Task>, NotFound>> GetEventRangeAsync( + string aggregateType, + string aggregateId, + [AsParameters] EventRangeRequest request, + IAdminEventQueryService queryService, + CancellationToken cancellationToken + ) + { + var query = new EventRangeQuery( + request.VersionFrom, + request.VersionTo, + request.TimeFromUtc, + request.TimeToUtc, + request.Page, + request.PageSize, + request.Sort + ); + + var result = await queryService.GetRangeAsync(aggregateType, aggregateId, query, cancellationToken); + return result is null ? TypedResults.NotFound() : TypedResults.Ok(result); + } + + static async Task, NotFound>> GetProjectionAtVersionAsync( + string aggregateType, + string aggregateId, + [FromQuery] long? version, + IAdminProjectionService projectionService, + CancellationToken cancellationToken + ) + { + if (version is null or <= 0) + return TypedResults.NotFound(); + + var result = await projectionService.ProjectAtVersionAsync( + aggregateType, + aggregateId, + version.Value, + cancellationToken + ); + + return result is null ? TypedResults.NotFound() : TypedResults.Ok(result); + } + + static async Task, NotFound>> GetProjectionAtTimeAsync( + string aggregateType, + string aggregateId, + [FromQuery] DateTime? asOfUtc, + IAdminProjectionService projectionService, + CancellationToken cancellationToken + ) + { + if (asOfUtc is null) + return TypedResults.NotFound(); + + var result = await projectionService.ProjectAtTimeAsync( + aggregateType, + aggregateId, + new DateTimeOffset(asOfUtc.Value, TimeSpan.Zero), + cancellationToken + ); + + return result is null ? TypedResults.NotFound() : TypedResults.Ok(result); + } +} diff --git a/src/src/Admin.API/Extensions/EndpointRouteBuilderExtensions.cs b/src/src/Admin.API/Extensions/EndpointRouteBuilderExtensions.cs new file mode 100644 index 00000000..c554558a --- /dev/null +++ b/src/src/Admin.API/Extensions/EndpointRouteBuilderExtensions.cs @@ -0,0 +1,37 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Api.Endpoints; + +namespace Purview.EventSourcing.Admin.Api; + +public static class AdminApiEndpointRouteBuilderExtensions +{ + public static void MapPurviewEventSourcingAdminApi( + [NotNull] this WebApplication app, + IOptions? optionsAccessor = null + ) + { + optionsAccessor ??= app.Services.GetRequiredService>(); + var options = optionsAccessor.Value; + + if (!options.Enabled) + return; + + var group = app.MapGroup(options.RoutePrefix).WithName("AdminPortal").RequireAuthorization(); + + // Map endpoint groups + if (options.Features.SearchAggregates) + AdminAggregatesEndpoints.MapSearchAggregates(group); + + if (options.Features.ViewEvents) + AdminAggregatesEndpoints.MapEventRange(group); + + if (options.Features.ProjectPointInTime) + { + AdminAggregatesEndpoints.MapProjectionAtVersion(group); + AdminAggregatesEndpoints.MapProjectionAtTime(group); + } + } +} diff --git a/src/src/Admin.API/Extensions/ServiceCollectionExtensions.cs b/src/src/Admin.API/Extensions/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..72ae39a8 --- /dev/null +++ b/src/src/Admin.API/Extensions/ServiceCollectionExtensions.cs @@ -0,0 +1,48 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; + +namespace Purview.EventSourcing.Admin.Api; + +/// +/// Registers the Admin API options and validation services. +/// +public static class AdminApiServiceCollectionExtensions +{ + /// + /// Adds the Admin API option bindings and validation hooks to the service collection. + /// + /// The service collection to configure. + /// Optional in-memory configuration delegate. + /// The configured service collection. + public static IServiceCollection AddPurviewEventSourcingAdminApi( + this IServiceCollection services, + Action? configure = null + ) + { + services.AddOptions().Configure(options => configure?.Invoke(options)).ValidateOnStart(); + + services.AddSingleton>(new AdminPortalOptionsValidator()); + + return services; + } +} + +sealed class AdminPortalOptionsValidator : IValidateOptions +{ + public ValidateOptionsResult Validate(string? name, AdminPortalOptions options) + { + try + { + options.Validate(); + return ValidateOptionsResult.Success; + } + catch (InvalidOperationException ex) + { + return ValidateOptionsResult.Fail(ex.Message); + } + catch (ArgumentException ex) + { + return ValidateOptionsResult.Fail(ex.Message); + } + } +} diff --git a/src/src/Admin.Abstractions/Admin.Abstractions.csproj b/src/src/Admin.Abstractions/Admin.Abstractions.csproj new file mode 100644 index 00000000..1f25ebb9 --- /dev/null +++ b/src/src/Admin.Abstractions/Admin.Abstractions.csproj @@ -0,0 +1,9 @@ + + + true + Purview Event Sourcing Admin Portal Abstractions + Core abstractions and contracts for Purview EventSourcing Admin Portal — query services, permission models, and DTOs. + $(PackageTags);purview;dotnet;event-sourcing;admin;abstractions; + Purview.EventSourcing.Admin.Abstractions + + diff --git a/src/src/Admin.Abstractions/Models/AdminFeature.cs b/src/src/Admin.Abstractions/Models/AdminFeature.cs new file mode 100644 index 00000000..d768350a --- /dev/null +++ b/src/src/Admin.Abstractions/Models/AdminFeature.cs @@ -0,0 +1,10 @@ +namespace Purview.EventSourcing.Admin.Abstractions.Models; + +public enum AdminFeature +{ + SearchAggregates, + ViewAggregate, + ViewEvents, + ProjectPointInTime, + ExportEvents, +} diff --git a/src/src/Admin.Abstractions/Models/AdminPermission.cs b/src/src/Admin.Abstractions/Models/AdminPermission.cs new file mode 100644 index 00000000..e97bae14 --- /dev/null +++ b/src/src/Admin.Abstractions/Models/AdminPermission.cs @@ -0,0 +1,8 @@ +namespace Purview.EventSourcing.Admin.Abstractions.Models; + +[System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1711:Identifiers should not have incorrect suffix")] +public sealed record AdminPermission( + AdminFeature Feature, + string? AggregateType, // null = applies to all aggregate types + bool Allowed +); diff --git a/src/src/Admin.Abstractions/Models/AggregateSummaryResponse.cs b/src/src/Admin.Abstractions/Models/AggregateSummaryResponse.cs new file mode 100644 index 00000000..48ccb4e0 --- /dev/null +++ b/src/src/Admin.Abstractions/Models/AggregateSummaryResponse.cs @@ -0,0 +1,11 @@ +namespace Purview.EventSourcing.Admin.Abstractions.Models; + +public sealed record AggregateSummaryResponse( + string AggregateType, + string AggregateId, + long CurrentVersion, + DateTimeOffset CreatedUtc, + DateTimeOffset LastUpdatedUtc, + bool IsDeleted, + bool IsRestored +); diff --git a/src/src/Admin.Abstractions/Models/EventEnvelopeResponse.cs b/src/src/Admin.Abstractions/Models/EventEnvelopeResponse.cs new file mode 100644 index 00000000..e7203af4 --- /dev/null +++ b/src/src/Admin.Abstractions/Models/EventEnvelopeResponse.cs @@ -0,0 +1,10 @@ +using System.Text.Json; + +namespace Purview.EventSourcing.Admin.Abstractions.Models; + +public sealed record EventEnvelopeResponse( + string AggregateType, + string AggregateId, + EventMetadataResponse Metadata, + JsonElement Payload +); diff --git a/src/src/Admin.Abstractions/Models/EventMetadataResponse.cs b/src/src/Admin.Abstractions/Models/EventMetadataResponse.cs new file mode 100644 index 00000000..7b45d63a --- /dev/null +++ b/src/src/Admin.Abstractions/Models/EventMetadataResponse.cs @@ -0,0 +1,12 @@ +namespace Purview.EventSourcing.Admin.Abstractions.Models; + +public sealed record EventMetadataResponse( + long Version, + DateTimeOffset TimestampUtc, + string EventType, + int SchemaVersion, + string? CorrelationId, + string? CausationId, + string? IdempotencyId, + string? UserId +); diff --git a/src/src/Admin.Abstractions/Models/PagedResult.cs b/src/src/Admin.Abstractions/Models/PagedResult.cs new file mode 100644 index 00000000..37d4aac6 --- /dev/null +++ b/src/src/Admin.Abstractions/Models/PagedResult.cs @@ -0,0 +1,8 @@ +namespace Purview.EventSourcing.Admin.Abstractions.Models; + +public sealed record PagedResult(IReadOnlyList Items, int Page, int PageSize, long TotalCount) +{ + public int TotalPages => (int)((TotalCount + PageSize - 1) / PageSize); + public bool HasNextPage => Page < TotalPages; + public bool HasPreviousPage => Page > 1; +} diff --git a/src/src/Admin.Abstractions/Models/ProjectionProvenance.cs b/src/src/Admin.Abstractions/Models/ProjectionProvenance.cs new file mode 100644 index 00000000..c15811cd --- /dev/null +++ b/src/src/Admin.Abstractions/Models/ProjectionProvenance.cs @@ -0,0 +1,9 @@ +namespace Purview.EventSourcing.Admin.Abstractions.Models; + +public sealed record ProjectionProvenance( + int AppliedCount, + int SkippedCount, + IReadOnlyList AppliedVersions, + IReadOnlyList SkippedVersions, + string Reason +); diff --git a/src/src/Admin.Abstractions/Models/ProjectionResponse.cs b/src/src/Admin.Abstractions/Models/ProjectionResponse.cs new file mode 100644 index 00000000..89492b4c --- /dev/null +++ b/src/src/Admin.Abstractions/Models/ProjectionResponse.cs @@ -0,0 +1,12 @@ +using System.Text.Json; + +namespace Purview.EventSourcing.Admin.Abstractions.Models; + +public sealed record ProjectionResponse( + string AggregateType, + string AggregateId, + long ProjectedVersion, + DateTimeOffset? ProjectedAtUtc, + JsonElement State, + ProjectionProvenance Provenance +); diff --git a/src/src/Admin.Abstractions/Queries/AggregateSearchQuery.cs b/src/src/Admin.Abstractions/Queries/AggregateSearchQuery.cs new file mode 100644 index 00000000..d1f24b82 --- /dev/null +++ b/src/src/Admin.Abstractions/Queries/AggregateSearchQuery.cs @@ -0,0 +1,13 @@ +namespace Purview.EventSourcing.Admin.Abstractions.Queries; + +public sealed record AggregateSearchQuery( + string? AggregateType, + string? AggregateId, + DateTimeOffset? FromUtc, + DateTimeOffset? ToUtc, + bool? IsDeleted, + bool? IsRestored, + int Page = 1, + int PageSize = 50, + string Sort = "LastUpdatedUtc desc" +); diff --git a/src/src/Admin.Abstractions/Queries/EventRangeQuery.cs b/src/src/Admin.Abstractions/Queries/EventRangeQuery.cs new file mode 100644 index 00000000..1abdea38 --- /dev/null +++ b/src/src/Admin.Abstractions/Queries/EventRangeQuery.cs @@ -0,0 +1,11 @@ +namespace Purview.EventSourcing.Admin.Abstractions.Queries; + +public sealed record EventRangeQuery( + long? VersionFrom, + long? VersionTo, + DateTimeOffset? TimeFromUtc, + DateTimeOffset? TimeToUtc, + int Page = 1, + int PageSize = 50, + string Sort = "Version asc" +); diff --git a/src/src/Admin.Abstractions/Services/IAdminAggregateQueryService.cs b/src/src/Admin.Abstractions/Services/IAdminAggregateQueryService.cs new file mode 100644 index 00000000..0a80e0e8 --- /dev/null +++ b/src/src/Admin.Abstractions/Services/IAdminAggregateQueryService.cs @@ -0,0 +1,18 @@ +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; + +namespace Purview.EventSourcing.Admin.Abstractions.Services; + +public interface IAdminAggregateQueryService +{ + Task> SearchAsync( + AggregateSearchQuery query, + CancellationToken cancellationToken + ); + + Task GetAsync( + string aggregateType, + string aggregateId, + CancellationToken cancellationToken + ); +} diff --git a/src/src/Admin.Abstractions/Services/IAdminEventQueryService.cs b/src/src/Admin.Abstractions/Services/IAdminEventQueryService.cs new file mode 100644 index 00000000..13b6de0a --- /dev/null +++ b/src/src/Admin.Abstractions/Services/IAdminEventQueryService.cs @@ -0,0 +1,14 @@ +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; + +namespace Purview.EventSourcing.Admin.Abstractions.Services; + +public interface IAdminEventQueryService +{ + Task?> GetRangeAsync( + string aggregateType, + string aggregateId, + EventRangeQuery query, + CancellationToken cancellationToken + ); +} diff --git a/src/src/Admin.Abstractions/Services/IAdminPermissionProvider.cs b/src/src/Admin.Abstractions/Services/IAdminPermissionProvider.cs new file mode 100644 index 00000000..19352ced --- /dev/null +++ b/src/src/Admin.Abstractions/Services/IAdminPermissionProvider.cs @@ -0,0 +1,13 @@ +using System.Security.Claims; +using Purview.EventSourcing.Admin.Abstractions.Models; + +namespace Purview.EventSourcing.Admin.Abstractions.Services; + +/// +/// Pluggable permission provider for admin portal. +/// Deny-by-default: no matching allow = deny. +/// +public interface IAdminPermissionProvider +{ + Task> GetPermissionsAsync(ClaimsPrincipal user, CancellationToken cancellationToken); +} diff --git a/src/src/Admin.Abstractions/Services/IAdminProjectionService.cs b/src/src/Admin.Abstractions/Services/IAdminProjectionService.cs new file mode 100644 index 00000000..cbadbeb9 --- /dev/null +++ b/src/src/Admin.Abstractions/Services/IAdminProjectionService.cs @@ -0,0 +1,20 @@ +using Purview.EventSourcing.Admin.Abstractions.Models; + +namespace Purview.EventSourcing.Admin.Abstractions.Services; + +public interface IAdminProjectionService +{ + Task ProjectAtVersionAsync( + string aggregateType, + string aggregateId, + long targetVersion, + CancellationToken cancellationToken + ); + + Task ProjectAtTimeAsync( + string aggregateType, + string aggregateId, + DateTimeOffset targetUtc, + CancellationToken cancellationToken + ); +} diff --git a/src/src/Admin.AzureStorage/Admin.AzureStorage.csproj b/src/src/Admin.AzureStorage/Admin.AzureStorage.csproj new file mode 100644 index 00000000..20fda113 --- /dev/null +++ b/src/src/Admin.AzureStorage/Admin.AzureStorage.csproj @@ -0,0 +1,20 @@ + + + true + Purview Event Sourcing Admin Portal Azure Storage + Azure Storage query adapters for Purview EventSourcing Admin Portal. + $(PackageTags);purview;dotnet;event-sourcing;admin;azurestorage;queries; + Purview.EventSourcing.Admin.AzureStorage + + + + + + + + + + + + + diff --git a/src/src/Admin.AzureStorage/AzureStorageAdminAggregateQueryService.cs b/src/src/Admin.AzureStorage/AzureStorageAdminAggregateQueryService.cs new file mode 100644 index 00000000..46933527 --- /dev/null +++ b/src/src/Admin.AzureStorage/AzureStorageAdminAggregateQueryService.cs @@ -0,0 +1,123 @@ +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.AzureStorage.Internal; +using Purview.EventSourcing.AzureStorage; +using Purview.EventSourcing.AzureStorage.Entities; + +namespace Purview.EventSourcing.Admin.AzureStorage; + +public sealed class AzureStorageAdminAggregateQueryService(IOptions options) + : IAdminAggregateQueryService +{ + public async Task> SearchAsync( + AggregateSearchQuery query, + CancellationToken cancellationToken + ) + { + ArgumentNullException.ThrowIfNull(query); + + var page = Math.Max(1, query.Page); + var pageSize = Math.Max(1, query.PageSize); + var config = options.Value; + var tableService = AzureStorageAdminTableHelpers.CreateTableServiceClient(config); + var tableNames = await AzureStorageAdminTableHelpers.ResolveTableNamesAsync( + tableService, + config, + query.AggregateType, + cancellationToken + ); + + var candidates = new List(); + foreach (var tableName in tableNames) + { + var table = AzureStorageAdminTableHelpers.CreateTableClient(tableService, tableName); + var filter = AzureStorageAdminTableHelpers.BuildAggregateSearchFilter(query.AggregateId); + await foreach ( + var row in table.QueryAsync( + filter, + maxPerPage: 100, + cancellationToken: cancellationToken + ) + ) + { + var aggregateType = row.AggregateType; + if (!string.IsNullOrWhiteSpace(query.AggregateType)) + { + if (!AzureStorageAdminTableHelpers.MatchesAggregateType(aggregateType, query.AggregateType)) + continue; + } + + if ( + !string.IsNullOrWhiteSpace(query.AggregateId) + && !string.Equals(row.PartitionKey, query.AggregateId, StringComparison.Ordinal) + ) + continue; + + var rowTime = row.Timestamp ?? DateTimeOffset.MinValue; + + if (query.FromUtc is not null && rowTime < query.FromUtc.Value) + continue; + if (query.ToUtc is not null && rowTime > query.ToUtc.Value) + continue; + if (query.IsDeleted is not null && row.IsDeleted != query.IsDeleted.Value) + continue; + if (query.IsRestored == true && row.IsDeleted) + continue; + + candidates.Add( + new AggregateSummaryResponse( + aggregateType, + row.PartitionKey, + row.Version, + rowTime, + rowTime, + row.IsDeleted, + !row.IsDeleted + ) + ); + } + } + + var ordered = ApplySort(candidates, query.Sort).ToList(); + var totalCount = ordered.Count; + var pageItems = ordered.Skip((page - 1) * pageSize).Take(pageSize).ToList(); + + return new PagedResult(pageItems, page, pageSize, totalCount); + } + + public async Task GetAsync( + string aggregateType, + string aggregateId, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + var query = new AggregateSearchQuery(aggregateType, aggregateId, null, null, null, null, 1, 1); + var result = await SearchAsync(query, cancellationToken); + return result.Items.Count == 0 ? null : result.Items[0]; + } + + static IEnumerable ApplySort(IEnumerable rows, string sort) + { + var descending = sort.Contains("desc", StringComparison.OrdinalIgnoreCase); + + return sort switch + { + "AggregateId asc" => rows.OrderBy(x => x.AggregateId), + "AggregateId desc" => rows.OrderByDescending(x => x.AggregateId), + "CurrentVersion asc" => rows.OrderBy(x => x.CurrentVersion), + "CurrentVersion desc" => rows.OrderByDescending(x => x.CurrentVersion), + "CreatedUtc asc" => descending + ? rows.OrderByDescending(x => x.CreatedUtc) + : rows.OrderBy(x => x.CreatedUtc), + "CreatedUtc desc" => rows.OrderByDescending(x => x.CreatedUtc), + _ => descending + ? rows.OrderByDescending(x => x.LastUpdatedUtc).ThenByDescending(x => x.AggregateId) + : rows.OrderBy(x => x.LastUpdatedUtc).ThenBy(x => x.AggregateId), + }; + } +} diff --git a/src/src/Admin.AzureStorage/AzureStorageAdminEventQueryService.cs b/src/src/Admin.AzureStorage/AzureStorageAdminEventQueryService.cs new file mode 100644 index 00000000..f7e7f8c8 --- /dev/null +++ b/src/src/Admin.AzureStorage/AzureStorageAdminEventQueryService.cs @@ -0,0 +1,107 @@ +using System.Text.Json; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.AzureStorage.Internal; +using Purview.EventSourcing.AzureStorage; +using Purview.EventSourcing.AzureStorage.Entities; + +namespace Purview.EventSourcing.Admin.AzureStorage; + +public sealed class AzureStorageAdminEventQueryService(IOptions options) + : IAdminEventQueryService +{ + public async Task?> GetRangeAsync( + string aggregateType, + string aggregateId, + EventRangeQuery query, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + ArgumentNullException.ThrowIfNull(query); + + var config = options.Value; + var tableService = AzureStorageAdminTableHelpers.CreateTableServiceClient(config); + var tableNames = await AzureStorageAdminTableHelpers.ResolveTableNamesAsync( + tableService, + config, + aggregateType, + cancellationToken + ); + + var rows = new List<(string AggregateType, int Version, EventEntity Event)>(); + foreach (var tableName in tableNames) + { + var table = AzureStorageAdminTableHelpers.CreateTableClient(tableService, tableName); + var filter = AzureStorageAdminTableHelpers.BuildEventRangeFilter( + aggregateId, + config.EventPrefix, + config.EventSuffixLength, + (int)(query.VersionFrom ?? 1), + query.VersionTo is null ? null : (int)query.VersionTo.Value + ); + + await foreach ( + var row in table.QueryAsync(filter, maxPerPage: 100, cancellationToken: cancellationToken) + ) + { + if ( + !AzureStorageAdminTableHelpers.TryParseEventVersion(row.RowKey, config.EventPrefix, out var version) + ) + continue; + + if (query.TimeFromUtc is not null && row.Timestamp < query.TimeFromUtc) + continue; + if (query.TimeToUtc is not null && row.Timestamp > query.TimeToUtc) + continue; + + rows.Add((aggregateType, version, row)); + } + } + + if (rows.Count == 0) + return null; + + var directionDesc = query.Sort.Contains("desc", StringComparison.OrdinalIgnoreCase); + var ordered = directionDesc + ? [.. rows.OrderByDescending(x => x.Version)] + : rows.OrderBy(x => x.Version).ToList(); + + var totalCount = ordered.Count; + var page = Math.Max(1, query.Page); + var pageSize = Math.Max(1, query.PageSize); + var pageRows = ordered.Skip((page - 1) * pageSize).Take(pageSize).ToList(); + + var items = pageRows + .Select(item => new EventEnvelopeResponse( + item.AggregateType, + item.Event.PartitionKey, + new EventMetadataResponse( + item.Version, + item.Event.Timestamp ?? DateTimeOffset.MinValue, + item.Event.EventType ?? string.Empty, + SchemaVersion: 1, + CorrelationId: null, + CausationId: null, + item.Event.IdempotencyId, + UserId: null + ), + ParsePayload(item.Event.Payload) + )) + .ToList(); + + return new PagedResult(items, page, pageSize, totalCount); + } + + static JsonElement ParsePayload(string? payload) + { + if (string.IsNullOrWhiteSpace(payload)) + return JsonDocument.Parse("null").RootElement.Clone(); + + using var document = JsonDocument.Parse(payload); + return document.RootElement.Clone(); + } +} diff --git a/src/src/Admin.AzureStorage/AzureStorageAdminProjectionService.cs b/src/src/Admin.AzureStorage/AzureStorageAdminProjectionService.cs new file mode 100644 index 00000000..455bf66e --- /dev/null +++ b/src/src/Admin.AzureStorage/AzureStorageAdminProjectionService.cs @@ -0,0 +1,170 @@ +using System.Text.Json; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.AzureStorage.Internal; +using Purview.EventSourcing.AzureStorage; +using Purview.EventSourcing.AzureStorage.Entities; + +namespace Purview.EventSourcing.Admin.AzureStorage; + +public sealed class AzureStorageAdminProjectionService(IOptions options) + : IAdminProjectionService +{ + public async Task ProjectAtVersionAsync( + string aggregateType, + string aggregateId, + long targetVersion, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + if (targetVersion < 1) + throw new ArgumentOutOfRangeException(nameof(targetVersion), "Target version must be >= 1"); + + var events = await GetEventsAsync( + aggregateType, + aggregateId, + version => version <= targetVersion, + cancellationToken + ); + + return BuildProjection(aggregateType, aggregateId, events, $"Events projected up to version {targetVersion}"); + } + + public async Task ProjectAtTimeAsync( + string aggregateType, + string aggregateId, + DateTimeOffset targetUtc, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + var events = await GetEventsAsync( + aggregateType, + aggregateId, + (_, timestamp) => timestamp is not null && timestamp <= targetUtc, + cancellationToken + ); + + return BuildProjection(aggregateType, aggregateId, events, $"Events projected up to timestamp {targetUtc:O}"); + } + + static ProjectionResponse? BuildProjection( + string aggregateType, + string aggregateId, + List<(long Version, EventEntity Event)> events, + string reason + ) + { + if (events.Count == 0) + return null; + + var appliedVersions = new List(); + var skippedVersions = new List(); + var projectedState = new Dictionary(); + + foreach (var item in events.OrderBy(x => x.Version)) + { + try + { + if (item.Event.Payload is not null && item.Event.EventType is not null) + { + using var _ = JsonDocument.Parse(item.Event.Payload); + projectedState[$"event_{item.Version}"] = new + { + eventType = item.Event.EventType, + version = item.Version, + timestamp = item.Event.Timestamp, + }; + appliedVersions.Add(item.Version); + } + else + { + skippedVersions.Add(item.Version); + } + } + catch (JsonException) + { + skippedVersions.Add(item.Version); + } + } + + var finalState = JsonDocument.Parse(JsonSerializer.Serialize(projectedState)).RootElement.Clone(); + var projectedVersion = events.Max(x => x.Version); + var projectedAtUtc = events.OrderByDescending(x => x.Version).First().Event.Timestamp; + + return new ProjectionResponse( + aggregateType, + aggregateId, + projectedVersion, + projectedAtUtc, + finalState, + new ProjectionProvenance( + appliedVersions.Count, + skippedVersions.Count, + appliedVersions.AsReadOnly(), + skippedVersions.AsReadOnly(), + reason + ) + ); + } + + async Task> GetEventsAsync( + string aggregateType, + string aggregateId, + Func versionPredicate, + CancellationToken cancellationToken + ) => await GetEventsAsync(aggregateType, aggregateId, (version, _) => versionPredicate(version), cancellationToken); + + async Task> GetEventsAsync( + string aggregateType, + string aggregateId, + Func eventPredicate, + CancellationToken cancellationToken + ) + { + var config = options.Value; + var tableService = AzureStorageAdminTableHelpers.CreateTableServiceClient(config); + var tableNames = await AzureStorageAdminTableHelpers.ResolveTableNamesAsync( + tableService, + config, + aggregateType, + cancellationToken + ); + + var rows = new List<(long Version, EventEntity Event)>(); + foreach (var tableName in tableNames) + { + var table = AzureStorageAdminTableHelpers.CreateTableClient(tableService, tableName); + var filter = AzureStorageAdminTableHelpers.BuildEventRangeFilter( + aggregateId, + config.EventPrefix, + config.EventSuffixLength, + versionFrom: 1, + versionTo: null + ); + + await foreach ( + var row in table.QueryAsync(filter, maxPerPage: 100, cancellationToken: cancellationToken) + ) + { + if ( + !AzureStorageAdminTableHelpers.TryParseEventVersion(row.RowKey, config.EventPrefix, out var version) + ) + continue; + + if (!eventPredicate(version, row.Timestamp)) + continue; + + rows.Add((version, row)); + } + } + + return rows; + } +} diff --git a/src/src/Admin.AzureStorage/Extensions/ServiceCollectionExtensions.cs b/src/src/Admin.AzureStorage/Extensions/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..f14ecad0 --- /dev/null +++ b/src/src/Admin.AzureStorage/Extensions/ServiceCollectionExtensions.cs @@ -0,0 +1,19 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection.Extensions; +using Purview.EventSourcing.Admin.Abstractions.Services; + +namespace Purview.EventSourcing.Admin.AzureStorage; + +public static class AdminAzureStorageServiceCollectionExtensions +{ + public static IServiceCollection AddPurviewEventSourcingAdminAzureStorage(this IServiceCollection services) + { + ArgumentNullException.ThrowIfNull(services); + + services.TryAddTransient(); + services.TryAddTransient(); + services.TryAddTransient(); + + return services; + } +} diff --git a/src/src/Admin.AzureStorage/Internal/AzureStorageAdminTableHelpers.cs b/src/src/Admin.AzureStorage/Internal/AzureStorageAdminTableHelpers.cs new file mode 100644 index 00000000..f731ed99 --- /dev/null +++ b/src/src/Admin.AzureStorage/Internal/AzureStorageAdminTableHelpers.cs @@ -0,0 +1,122 @@ +using Azure; +using Azure.Data.Tables; +using Purview.EventSourcing.AzureStorage; + +namespace Purview.EventSourcing.Admin.AzureStorage.Internal; + +static class AzureStorageAdminTableHelpers +{ + const string StreamVersionRowKey = "version"; + + public static TableServiceClient CreateTableServiceClient(AzureStorageEventStoreOptions options) + { + ArgumentNullException.ThrowIfNull(options); + + var tableOptions = new TableClientOptions(); + if (options.TimeoutInSeconds is > 0) + tableOptions.Retry.NetworkTimeout = TimeSpan.FromSeconds(options.TimeoutInSeconds.Value); + + return new TableServiceClient(options.ConnectionString, tableOptions); + } + + public static TableClient CreateTableClient(TableServiceClient tableServiceClient, string tableName) + { + ArgumentNullException.ThrowIfNull(tableServiceClient); + ArgumentException.ThrowIfNullOrWhiteSpace(tableName); + return tableServiceClient.GetTableClient(tableName); + } + + public static async Task> ResolveTableNamesAsync( + TableServiceClient tableServiceClient, + AzureStorageEventStoreOptions options, + string? aggregateType, + CancellationToken cancellationToken + ) + { + ArgumentNullException.ThrowIfNull(tableServiceClient); + ArgumentNullException.ThrowIfNull(options); + + if (!string.IsNullOrWhiteSpace(aggregateType)) + { + var normalized = aggregateType.Trim(); + var directCandidates = new[] { $"{options.Table}{normalized}", $"{options.Table}{normalized}Aggregate" }; + + var matched = new List(); + foreach (var candidate in directCandidates.Distinct(StringComparer.OrdinalIgnoreCase)) + { + var exists = await TableExistsAsync(tableServiceClient, candidate, cancellationToken); + if (exists) + matched.Add(candidate); + } + + if (matched.Count > 0) + return matched; + } + + var names = new List(); + await foreach ( + var table in tableServiceClient.QueryAsync(filter: (string?)null, maxPerPage: 100, cancellationToken) + ) + { + if (table.Name.StartsWith(options.Table, StringComparison.OrdinalIgnoreCase)) + names.Add(table.Name); + } + + return names; + } + + static async Task TableExistsAsync( + TableServiceClient tableServiceClient, + string tableName, + CancellationToken cancellationToken + ) + { + try + { + await tableServiceClient + .GetTableClient(tableName) + .GetAccessPoliciesAsync(cancellationToken: cancellationToken); + return true; + } + catch (RequestFailedException ex) when (ex.Status == 404) + { + return false; + } + } + + public static string BuildEventRangeFilter( + string aggregateId, + string eventPrefix, + int eventSuffixLength, + int versionFrom, + int? versionTo + ) + { + var fromKey = BuildEventRowKey(eventPrefix, eventSuffixLength, versionFrom); + var toKey = BuildEventRowKey(eventPrefix, eventSuffixLength, versionTo ?? int.MaxValue); + return $"(PartitionKey eq '{aggregateId}') and ((RowKey ge '{fromKey}') and (RowKey le '{toKey}'))"; + } + + public static string BuildEventRowKey(string eventPrefix, int eventSuffixLength, int version) => + $"{eventPrefix}_{version.ToString(System.Globalization.CultureInfo.InvariantCulture).PadLeft(eventSuffixLength, '0')}"; + + public static bool TryParseEventVersion(string rowKey, string eventPrefix, out int version) + { + version = default; + var prefix = $"{eventPrefix}_"; + return rowKey.StartsWith(prefix, StringComparison.Ordinal) + && int.TryParse(rowKey[prefix.Length..], out version); + } + + public static bool MatchesAggregateType(string persistedAggregateType, string requestedAggregateType) => + string.Equals( + persistedAggregateType?.Trim(), + requestedAggregateType?.Trim(), + StringComparison.OrdinalIgnoreCase + ); + + public static string BuildAggregateSearchFilter(string? aggregateId = null) => + string.IsNullOrWhiteSpace(aggregateId) + ? $"RowKey eq '{StreamVersionRowKey}'" + : $"(RowKey eq '{StreamVersionRowKey}') and (PartitionKey eq '{aggregateId}')"; +} diff --git a/src/src/Admin.MongoDB/Admin.MongoDB.csproj b/src/src/Admin.MongoDB/Admin.MongoDB.csproj new file mode 100644 index 00000000..f3859630 --- /dev/null +++ b/src/src/Admin.MongoDB/Admin.MongoDB.csproj @@ -0,0 +1,20 @@ + + + true + Purview Event Sourcing Admin Portal MongoDB Adapter + MongoDB storage adapter for Purview EventSourcing Admin Portal. Enables aggregate search, event inspection, and point-in-time projection queries on MongoDB event stores. + $(PackageTags);purview;dotnet;event-sourcing;admin;mongodb; + Purview.EventSourcing.Admin.MongoDB + + + + + + + + + + + + + diff --git a/src/src/Admin.MongoDB/Extensions/ServiceCollectionExtensions.cs b/src/src/Admin.MongoDB/Extensions/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..f0422269 --- /dev/null +++ b/src/src/Admin.MongoDB/Extensions/ServiceCollectionExtensions.cs @@ -0,0 +1,38 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection.Extensions; +using MongoDB.Driver; +using Purview.EventSourcing.Admin.Abstractions.Services; + +namespace Purview.EventSourcing.Admin.MongoDB; + +public static class AdminMongoDbServiceCollectionExtensions +{ + public static IServiceCollection AddPurviewEventSourcingAdminMongoDB( + this IServiceCollection services, + string databaseName = "EventStore" + ) + { + ArgumentNullException.ThrowIfNull(services); + ArgumentException.ThrowIfNullOrWhiteSpace(databaseName); + + services.TryAddTransient(sp => + { + var mongoClient = sp.GetRequiredService(); + return new MongoDbAdminAggregateQueryService(mongoClient, databaseName); + }); + + services.TryAddTransient(sp => + { + var mongoClient = sp.GetRequiredService(); + return new MongoDbAdminEventQueryService(mongoClient, databaseName); + }); + + services.TryAddTransient(sp => + { + var mongoClient = sp.GetRequiredService(); + return new MongoDbAdminProjectionService(mongoClient, databaseName); + }); + + return services; + } +} diff --git a/src/src/Admin.MongoDB/MongoDbAdminAggregateQueryService.cs b/src/src/Admin.MongoDB/MongoDbAdminAggregateQueryService.cs new file mode 100644 index 00000000..3ef1a816 --- /dev/null +++ b/src/src/Admin.MongoDB/MongoDbAdminAggregateQueryService.cs @@ -0,0 +1,110 @@ +using MongoDB.Driver; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.MongoDB.Events.Entities; + +namespace Purview.EventSourcing.Admin.MongoDB; + +public sealed class MongoDbAdminAggregateQueryService(IMongoClient mongoClient, string databaseName) + : IAdminAggregateQueryService +{ + readonly IMongoClient _mongoClient = mongoClient ?? throw new ArgumentNullException(nameof(mongoClient)); + readonly string _databaseName = databaseName ?? throw new ArgumentNullException(nameof(databaseName)); + + public async Task> SearchAsync( + AggregateSearchQuery query, + CancellationToken cancellationToken + ) + { + ArgumentNullException.ThrowIfNull(query); + + var database = _mongoClient.GetDatabase(_databaseName); + + // MongoDB event store uses per-aggregate-type collections with pattern: es-{aggregateType}-events + // If no aggregate type specified, we can't search effectively across multiple collections + if (string.IsNullOrWhiteSpace(query.AggregateType)) + { + // Return empty result when no aggregate type specified + return new PagedResult([], query.Page, query.PageSize, 0); + } + + var collectionName = $"es-{query.AggregateType}-events"; + var collection = database.GetCollection(collectionName); + + var filter = Builders.Filter.Eq(x => x.EntityType, EntityTypes.StreamVersionType); + + if (!string.IsNullOrWhiteSpace(query.AggregateId)) + { + filter &= Builders.Filter.Eq(x => x.AggregateId, query.AggregateId); + } + + if (query.FromUtc.HasValue) + { + filter &= Builders.Filter.Gte(x => x.Timestamp, query.FromUtc.Value); + } + + if (query.ToUtc.HasValue) + { + filter &= Builders.Filter.Lte(x => x.Timestamp, query.ToUtc.Value); + } + + var pageSize = Math.Max(1, Math.Min(query.PageSize, 500)); + var skip = (query.Page - 1) * pageSize; + + var total = await collection.CountDocumentsAsync(filter, cancellationToken: cancellationToken); + var items = await collection + .Find(filter) + .Skip(skip) + .Limit(pageSize) + .SortByDescending(x => x.Timestamp) + .ToListAsync(cancellationToken); + + var summaries = items + .Select(x => new AggregateSummaryResponse( + query.AggregateType, + x.AggregateId, + x.Version, + x.Timestamp ?? DateTimeOffset.UtcNow, + x.Timestamp ?? DateTimeOffset.UtcNow, + x.IsDeleted, + !x.IsDeleted + )) + .ToList(); + + return new PagedResult(summaries, query.Page, pageSize, total); + } + + public async Task GetAsync( + string aggregateType, + string aggregateId, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + var database = _mongoClient.GetDatabase(_databaseName); + var collectionName = $"es-{aggregateType}-events"; + var collection = database.GetCollection(collectionName); + + var filter = Builders.Filter.And( + Builders.Filter.Eq(x => x.AggregateId, aggregateId), + Builders.Filter.Eq(x => x.EntityType, EntityTypes.StreamVersionType) + ); + + var item = await collection.Find(filter).FirstOrDefaultAsync(cancellationToken); + + return item == null + ? null + : new AggregateSummaryResponse( + aggregateType, + item.AggregateId, + item.Version, + item.Timestamp ?? DateTimeOffset.UtcNow, + item.Timestamp ?? DateTimeOffset.UtcNow, + item.IsDeleted, + !item.IsDeleted + ); + } +} diff --git a/src/src/Admin.MongoDB/MongoDbAdminEventQueryService.cs b/src/src/Admin.MongoDB/MongoDbAdminEventQueryService.cs new file mode 100644 index 00000000..ce82c53a --- /dev/null +++ b/src/src/Admin.MongoDB/MongoDbAdminEventQueryService.cs @@ -0,0 +1,101 @@ +using System.Text.Json; +using MongoDB.Driver; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.MongoDB.Events.Entities; + +namespace Purview.EventSourcing.Admin.MongoDB; + +public sealed class MongoDbAdminEventQueryService(IMongoClient mongoClient, string databaseName) + : IAdminEventQueryService +{ + readonly IMongoClient _mongoClient = mongoClient ?? throw new ArgumentNullException(nameof(mongoClient)); + readonly string _databaseName = databaseName ?? throw new ArgumentNullException(nameof(databaseName)); + + public async Task?> GetRangeAsync( + string aggregateType, + string aggregateId, + EventRangeQuery query, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + ArgumentNullException.ThrowIfNull(query); + + var database = _mongoClient.GetDatabase(_databaseName); + var collectionName = $"es-{aggregateType}-events"; + var collection = database.GetCollection(collectionName); + + var filter = Builders.Filter.And( + Builders.Filter.Eq(x => x.AggregateId, aggregateId), + Builders.Filter.Eq(x => x.EntityType, EntityTypes.EventType) + ); + + if (query.VersionFrom.HasValue && query.VersionFrom > 0) + { + filter &= Builders.Filter.Gte(x => x.Version, query.VersionFrom.Value); + } + + if (query.VersionTo.HasValue && query.VersionTo > 0) + { + filter &= Builders.Filter.Lte(x => x.Version, query.VersionTo.Value); + } + + if (query.TimeFromUtc.HasValue) + { + filter &= Builders.Filter.Gte(x => x.Timestamp, query.TimeFromUtc.Value); + } + + if (query.TimeToUtc.HasValue) + { + filter &= Builders.Filter.Lte(x => x.Timestamp, query.TimeToUtc.Value); + } + + var pageSize = Math.Max(1, Math.Min(query.PageSize, 500)); + var skip = (query.Page - 1) * pageSize; + + var total = await collection.CountDocumentsAsync(filter, cancellationToken: cancellationToken); + if (total == 0) + { + return null; + } + + var events = await collection + .Find(filter) + .Skip(skip) + .Limit(pageSize) + .SortBy(x => x.Version) + .ToListAsync(cancellationToken); + + var envelopes = events + .Select(e => new EventEnvelopeResponse( + aggregateType, + e.AggregateId, + new EventMetadataResponse( + e.Version, + e.Timestamp ?? DateTimeOffset.UtcNow, + e.EventType ?? "Unknown", + 1, + null, + null, + e.IdempotencyId, + null + ), + ParsePayload(e.Payload) + )) + .ToList(); + + return new PagedResult(envelopes, query.Page, pageSize, total); + } + + static JsonElement ParsePayload(string? payload) + { + if (string.IsNullOrWhiteSpace(payload)) + return JsonDocument.Parse("null").RootElement.Clone(); + + using var document = JsonDocument.Parse(payload); + return document.RootElement.Clone(); + } +} diff --git a/src/src/Admin.MongoDB/MongoDbAdminProjectionService.cs b/src/src/Admin.MongoDB/MongoDbAdminProjectionService.cs new file mode 100644 index 00000000..ffc559f9 --- /dev/null +++ b/src/src/Admin.MongoDB/MongoDbAdminProjectionService.cs @@ -0,0 +1,173 @@ +using System.Text.Json; +using MongoDB.Driver; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.MongoDB.Events.Entities; + +namespace Purview.EventSourcing.Admin.MongoDB; + +public sealed class MongoDbAdminProjectionService(IMongoClient mongoClient, string databaseName) + : IAdminProjectionService +{ + readonly IMongoClient _mongoClient = mongoClient ?? throw new ArgumentNullException(nameof(mongoClient)); + readonly string _databaseName = databaseName ?? throw new ArgumentNullException(nameof(databaseName)); + + public async Task ProjectAtVersionAsync( + string aggregateType, + string aggregateId, + long targetVersion, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + if (targetVersion < 1) + throw new ArgumentOutOfRangeException(nameof(targetVersion), "Target version must be >= 1"); + + var database = _mongoClient.GetDatabase(_databaseName); + var collectionName = $"es-{aggregateType}-events"; + var collection = database.GetCollection(collectionName); + + var filter = Builders.Filter.And( + Builders.Filter.Eq(x => x.AggregateId, aggregateId), + Builders.Filter.Eq(x => x.EntityType, EntityTypes.EventType), + Builders.Filter.Lte(x => x.Version, targetVersion) + ); + + var events = await collection.Find(filter).SortBy(x => x.Version).ToListAsync(cancellationToken); + + if (events.Count == 0) + { + return null; + } + + var appliedVersions = new List(); + var skippedVersions = new List(); + var projectedState = new Dictionary(); + + foreach (var evt in events) + { + try + { + if (!string.IsNullOrEmpty(evt.EventType) && !string.IsNullOrEmpty(evt.Payload)) + { + projectedState[$"event_{evt.Version}"] = new { eventType = evt.EventType, version = evt.Version }; + appliedVersions.Add(evt.Version); + } + else + { + skippedVersions.Add(evt.Version); + } + } + catch (JsonException) + { + // Skip malformed payloads so one bad event does not fail the entire projection. + skippedVersions.Add(evt.Version); + } + } + + var lastEvent = events.Last(); + var reason = + lastEvent.Version < targetVersion + ? $"Events projected up to available version {lastEvent.Version} (target was {targetVersion})" + : $"Events projected up to version {targetVersion}"; + + var finalState = JsonDocument.Parse(JsonSerializer.Serialize(projectedState)).RootElement.Clone(); + + return new ProjectionResponse( + aggregateType, + aggregateId, + lastEvent.Version, + null, + finalState, + new ProjectionProvenance( + appliedVersions.Count, + skippedVersions.Count, + appliedVersions.AsReadOnly(), + skippedVersions.AsReadOnly(), + reason + ) + ); + } + + public async Task ProjectAtTimeAsync( + string aggregateType, + string aggregateId, + DateTimeOffset targetUtc, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + var database = _mongoClient.GetDatabase(_databaseName); + var collectionName = $"es-{aggregateType}-events"; + var collection = database.GetCollection(collectionName); + + var filter = Builders.Filter.And( + Builders.Filter.Eq(x => x.AggregateId, aggregateId), + Builders.Filter.Eq(x => x.EntityType, EntityTypes.EventType), + Builders.Filter.Lte(x => x.Timestamp, targetUtc) + ); + + var events = await collection.Find(filter).SortBy(x => x.Version).ToListAsync(cancellationToken); + + if (events.Count == 0) + { + return null; + } + + var appliedVersions = new List(); + var skippedVersions = new List(); + var projectedState = new Dictionary(); + + foreach (var evt in events) + { + try + { + if (!string.IsNullOrEmpty(evt.EventType) && !string.IsNullOrEmpty(evt.Payload)) + { + projectedState[$"event_{evt.Version}"] = new + { + eventType = evt.EventType, + version = evt.Version, + timestamp = evt.Timestamp, + }; + appliedVersions.Add(evt.Version); + } + else + { + skippedVersions.Add(evt.Version); + } + } + catch (JsonException) + { + // Skip malformed payloads so one bad event does not fail the entire projection. + skippedVersions.Add(evt.Version); + } + } + + var lastEvent = events.Last(); + var reason = + lastEvent.Timestamp > targetUtc + ? $"Events projected up to available timestamp {lastEvent.Timestamp:O} (target was {targetUtc:O})" + : $"Events projected up to timestamp {targetUtc:O}"; + + var finalState = JsonDocument.Parse(JsonSerializer.Serialize(projectedState)).RootElement.Clone(); + + return new ProjectionResponse( + aggregateType, + aggregateId, + lastEvent.Version, + lastEvent.Timestamp, + finalState, + new ProjectionProvenance( + appliedVersions.Count, + skippedVersions.Count, + appliedVersions.AsReadOnly(), + skippedVersions.AsReadOnly(), + reason + ) + ); + } +} diff --git a/src/src/Admin.MongoDB/Properties/AssemblyInfo.cs b/src/src/Admin.MongoDB/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..2636d14d --- /dev/null +++ b/src/src/Admin.MongoDB/Properties/AssemblyInfo.cs @@ -0,0 +1,3 @@ +using System.Runtime.CompilerServices; + +[assembly: InternalsVisibleTo("Admin.MongoDB.UnitTests")] diff --git a/src/src/Admin.Postgres/Admin.Postgres.csproj b/src/src/Admin.Postgres/Admin.Postgres.csproj new file mode 100644 index 00000000..067dae8d --- /dev/null +++ b/src/src/Admin.Postgres/Admin.Postgres.csproj @@ -0,0 +1,21 @@ + + + true + Purview Event Sourcing Admin Portal Postgres + Postgres query adapters for Purview EventSourcing Admin Portal. + $(PackageTags);purview;dotnet;event-sourcing;admin;postgres;queries; + Purview.EventSourcing.Admin.Postgres + + + + + + + + + + + + + + diff --git a/src/src/Admin.Postgres/Extensions/ServiceCollectionExtensions.cs b/src/src/Admin.Postgres/Extensions/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..761a1347 --- /dev/null +++ b/src/src/Admin.Postgres/Extensions/ServiceCollectionExtensions.cs @@ -0,0 +1,19 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection.Extensions; +using Purview.EventSourcing.Admin.Abstractions.Services; + +namespace Purview.EventSourcing.Admin.Postgres; + +public static class AdminPostgresServiceCollectionExtensions +{ + public static IServiceCollection AddPurviewEventSourcingAdminPostgres(this IServiceCollection services) + { + ArgumentNullException.ThrowIfNull(services); + + services.TryAddTransient(); + services.TryAddTransient(); + services.TryAddTransient(); + + return services; + } +} diff --git a/src/src/Admin.Postgres/Internal/PostgresAdminTableDescriptor.cs b/src/src/Admin.Postgres/Internal/PostgresAdminTableDescriptor.cs new file mode 100644 index 00000000..c86bad88 --- /dev/null +++ b/src/src/Admin.Postgres/Internal/PostgresAdminTableDescriptor.cs @@ -0,0 +1,3 @@ +namespace Purview.EventSourcing.Admin.Postgres.Internal; + +sealed record PostgresAdminTableDescriptor(string? AggregateTypeFilter, string SchemaName, string TableName); diff --git a/src/src/Admin.Postgres/Internal/PostgresAdminTableResolver.cs b/src/src/Admin.Postgres/Internal/PostgresAdminTableResolver.cs new file mode 100644 index 00000000..de386b88 --- /dev/null +++ b/src/src/Admin.Postgres/Internal/PostgresAdminTableResolver.cs @@ -0,0 +1,51 @@ +using Purview.EventSourcing.Postgres.Events; + +namespace Purview.EventSourcing.Admin.Postgres.Internal; + +static class PostgresAdminTableResolver +{ + public static IReadOnlyList ResolveTables( + PostgresEventStoreOptions options, + string? aggregateType + ) + { + ArgumentNullException.ThrowIfNull(options); + + if (!string.IsNullOrWhiteSpace(aggregateType)) + return [ResolveTable(options, aggregateType)]; + + List tables = [new(null, options.SchemaName, options.TableName)]; + + foreach (var overrideEntry in options.AggregateTableOverrides) + { + if (overrideEntry.Value is null) + continue; + + tables.Add( + new PostgresAdminTableDescriptor( + overrideEntry.Key, + overrideEntry.Value.SchemaName ?? options.SchemaName, + overrideEntry.Value.TableName ?? options.TableName + ) + ); + } + + return tables; + } + + public static PostgresAdminTableDescriptor ResolveTable(PostgresEventStoreOptions options, string aggregateType) + { + ArgumentNullException.ThrowIfNull(options); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + + if (!options.AggregateTableOverrides.TryGetValue(aggregateType, out var overrideEntry) || overrideEntry is null) + return new PostgresAdminTableDescriptor(aggregateType, options.SchemaName, options.TableName); + + // If an override exists for the aggregate type, use the override values (if provided) or fall back to the default options + return new PostgresAdminTableDescriptor( + aggregateType, + overrideEntry.SchemaName ?? options.SchemaName, + overrideEntry.TableName ?? options.TableName + ); + } +} diff --git a/src/src/Admin.Postgres/PostgresAdminAggregateQueryService.cs b/src/src/Admin.Postgres/PostgresAdminAggregateQueryService.cs new file mode 100644 index 00000000..c5e1e5fd --- /dev/null +++ b/src/src/Admin.Postgres/PostgresAdminAggregateQueryService.cs @@ -0,0 +1,119 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.Postgres.Internal; +using Purview.EventSourcing.Postgres.Events; +using Purview.EventSourcing.Postgres.Events.EntityFramework; + +namespace Purview.EventSourcing.Admin.Postgres; + +public sealed class PostgresAdminAggregateQueryService(IOptions options) + : IAdminAggregateQueryService +{ + public async Task> SearchAsync( + AggregateSearchQuery query, + CancellationToken cancellationToken + ) + { + ArgumentNullException.ThrowIfNull(query); + + var page = Math.Max(1, query.Page); + var pageSize = Math.Max(1, query.PageSize); + + var candidates = new List(); + foreach (var table in PostgresAdminTableResolver.ResolveTables(options.Value, query.AggregateType)) + { + await using var context = CreateContext(options.Value, table); + var rows = await BuildAggregateRowsAsync(context, table, query, cancellationToken); + candidates.AddRange(rows); + } + + var ordered = ApplySort(candidates, query.Sort).ToList(); + var totalCount = ordered.Count; + var pageItems = ordered.Skip((page - 1) * pageSize).Take(pageSize).ToList(); + + return new PagedResult(pageItems, page, pageSize, totalCount); + } + + public async Task GetAsync( + string aggregateType, + string aggregateId, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + var query = new AggregateSearchQuery(aggregateType, aggregateId, null, null, null, null, 1, 1); + var result = await SearchAsync(query, cancellationToken); + return result.Items.Count == 0 ? null : result.Items[0]; + } + + static async Task> BuildAggregateRowsAsync( + EventStoreDbContext context, + PostgresAdminTableDescriptor table, + AggregateSearchQuery query, + CancellationToken cancellationToken + ) + { + var aggregateTypeFilter = table.AggregateTypeFilter; + var rows = context + .EventStoreEntities.AsNoTracking() + .Where(x => x.EntityType == 0 && (aggregateTypeFilter == null || x.AggregateType == aggregateTypeFilter)); + + if (!string.IsNullOrWhiteSpace(query.AggregateId)) + rows = rows.Where(x => x.AggregateId == query.AggregateId); + + if (query.IsDeleted is not null) + rows = rows.Where(x => x.IsDeleted == query.IsDeleted.Value); + + if (query.IsRestored == true) + rows = rows.Where(x => !x.IsDeleted); + + if (query.FromUtc is not null) + rows = rows.Where(x => x.Timestamp >= query.FromUtc.Value); + + if (query.ToUtc is not null) + rows = rows.Where(x => x.Timestamp <= query.ToUtc.Value); + + return await rows.Select(x => new AggregateSummaryResponse( + x.AggregateType, + x.AggregateId, + x.Version, + x.Timestamp, + x.Timestamp, + x.IsDeleted, + !x.IsDeleted + )) + .ToListAsync(cancellationToken); + } + + static IEnumerable ApplySort(IEnumerable rows, string sort) + { + var descending = sort.Contains("desc", StringComparison.OrdinalIgnoreCase); + + return sort switch + { + "AggregateId asc" => rows.OrderBy(x => x.AggregateId), + "AggregateId desc" => rows.OrderByDescending(x => x.AggregateId), + "CurrentVersion asc" => rows.OrderBy(x => x.CurrentVersion), + "CurrentVersion desc" => rows.OrderByDescending(x => x.CurrentVersion), + "CreatedUtc asc" => descending + ? rows.OrderByDescending(x => x.CreatedUtc) + : rows.OrderBy(x => x.CreatedUtc), + "CreatedUtc desc" => rows.OrderByDescending(x => x.CreatedUtc), + _ => descending + ? rows.OrderByDescending(x => x.LastUpdatedUtc).ThenByDescending(x => x.AggregateId) + : rows.OrderBy(x => x.LastUpdatedUtc).ThenBy(x => x.AggregateId), + }; + } + + static EventStoreDbContext CreateContext(PostgresEventStoreOptions options, PostgresAdminTableDescriptor table) + { + var builder = new DbContextOptionsBuilder(); + builder.UseNpgsql(options.ConnectionString); + return new EventStoreDbContext(builder.Options, table.SchemaName, table.TableName); + } +} diff --git a/src/src/Admin.Postgres/PostgresAdminEventQueryService.cs b/src/src/Admin.Postgres/PostgresAdminEventQueryService.cs new file mode 100644 index 00000000..e5e15528 --- /dev/null +++ b/src/src/Admin.Postgres/PostgresAdminEventQueryService.cs @@ -0,0 +1,98 @@ +using System.Text.Json; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.Postgres.Internal; +using Purview.EventSourcing.Postgres.Events; +using Purview.EventSourcing.Postgres.Events.EntityFramework; + +namespace Purview.EventSourcing.Admin.Postgres; + +public sealed class PostgresAdminEventQueryService(IOptions options) + : IAdminEventQueryService +{ + public async Task?> GetRangeAsync( + string aggregateType, + string aggregateId, + EventRangeQuery query, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + ArgumentNullException.ThrowIfNull(query); + + var table = PostgresAdminTableResolver.ResolveTable(options.Value, aggregateType); + await using var context = CreateContext(options.Value, table); + var aggregateTypeFilter = table.AggregateTypeFilter; + + var rows = context + .EventStoreEntities.AsNoTracking() + .Where(x => + (aggregateTypeFilter == null || x.AggregateType == aggregateTypeFilter) + && x.AggregateId == aggregateId + && x.EntityType == 1 + ); + + if (query.VersionFrom is not null) + rows = rows.Where(x => x.Version >= query.VersionFrom.Value); + + if (query.VersionTo is not null) + rows = rows.Where(x => x.Version <= query.VersionTo.Value); + + if (query.TimeFromUtc is not null) + rows = rows.Where(x => x.Timestamp >= query.TimeFromUtc.Value); + + if (query.TimeToUtc is not null) + rows = rows.Where(x => x.Timestamp <= query.TimeToUtc.Value); + + var directionDesc = query.Sort.Contains("desc", StringComparison.OrdinalIgnoreCase); + rows = directionDesc ? rows.OrderByDescending(x => x.Version) : rows.OrderBy(x => x.Version); + + var totalCount = await rows.LongCountAsync(cancellationToken); + if (totalCount == 0) + return null; + + var page = Math.Max(1, query.Page); + var pageSize = Math.Max(1, query.PageSize); + var pageRows = await rows.Skip((page - 1) * pageSize).Take(pageSize).ToListAsync(cancellationToken); + + var items = pageRows + .Select(row => new EventEnvelopeResponse( + row.AggregateType, + row.AggregateId, + new EventMetadataResponse( + row.Version, + row.Timestamp, + row.EventType ?? string.Empty, + SchemaVersion: 1, + CorrelationId: null, + CausationId: null, + row.IdempotencyId, + UserId: null + ), + ParsePayload(row.Payload) + )) + .ToList(); + + return new PagedResult(items, page, pageSize, totalCount); + } + + static EventStoreDbContext CreateContext(PostgresEventStoreOptions options, PostgresAdminTableDescriptor table) + { + var builder = new DbContextOptionsBuilder(); + builder.UseNpgsql(options.ConnectionString); + return new EventStoreDbContext(builder.Options, table.SchemaName, table.TableName); + } + + static JsonElement ParsePayload(string? payload) + { + if (string.IsNullOrWhiteSpace(payload)) + return JsonDocument.Parse("null").RootElement.Clone(); + + using var document = JsonDocument.Parse(payload); + return document.RootElement.Clone(); + } +} diff --git a/src/src/Admin.Postgres/PostgresAdminProjectionService.cs b/src/src/Admin.Postgres/PostgresAdminProjectionService.cs new file mode 100644 index 00000000..d75de76d --- /dev/null +++ b/src/src/Admin.Postgres/PostgresAdminProjectionService.cs @@ -0,0 +1,182 @@ +using System.Text.Json; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.Postgres.Internal; +using Purview.EventSourcing.Postgres.Events; +using Purview.EventSourcing.Postgres.Events.EntityFramework; + +namespace Purview.EventSourcing.Admin.Postgres; + +public sealed class PostgresAdminProjectionService(IOptions options) + : IAdminProjectionService +{ + public async Task ProjectAtVersionAsync( + string aggregateType, + string aggregateId, + long targetVersion, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + if (targetVersion < 1) + throw new ArgumentOutOfRangeException(nameof(targetVersion), "Target version must be >= 1"); + + var table = PostgresAdminTableResolver.ResolveTable(options.Value, aggregateType); + await using var context = CreateContext(options.Value, table); + + var appliedVersions = new List(); + var skippedVersions = new List(); + var projectedState = new Dictionary(); + + var rows = context + .EventStoreEntities.AsNoTracking() + .Where(x => + x.AggregateType == aggregateType + && x.AggregateId == aggregateId + && x.EntityType == 1 + && x.Version <= targetVersion + ) + .OrderBy(x => x.Version); + + var rowList = await rows.ToListAsync(cancellationToken); + + foreach (var row in rowList) + { + try + { + if (row.Payload != null && row.EventType != null) + { + using var _ = JsonDocument.Parse(row.Payload); + projectedState[$"event_{row.Version}"] = new { eventType = row.EventType, version = row.Version }; + appliedVersions.Add(row.Version); + } + else + { + skippedVersions.Add(row.Version); + } + } + catch (JsonException) + { + skippedVersions.Add(row.Version); + } + } + + if (rowList.Count == 0) + return null; + + var reason = + targetVersion > rowList.Last().Version + ? $"Events projected up to available version {rowList.Last().Version} (target was {targetVersion})" + : $"Events projected up to version {targetVersion}"; + + var finalState = JsonDocument.Parse(JsonSerializer.Serialize(projectedState)).RootElement.Clone(); + + return new ProjectionResponse( + aggregateType, + aggregateId, + rowList.Last().Version, + null, + finalState, + new ProjectionProvenance( + appliedVersions.Count, + skippedVersions.Count, + appliedVersions.AsReadOnly(), + skippedVersions.AsReadOnly(), + reason + ) + ); + } + + public async Task ProjectAtTimeAsync( + string aggregateType, + string aggregateId, + DateTimeOffset targetUtc, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + var table = PostgresAdminTableResolver.ResolveTable(options.Value, aggregateType); + await using var context = CreateContext(options.Value, table); + + var appliedVersions = new List(); + var skippedVersions = new List(); + var projectedState = new Dictionary(); + + var rows = context + .EventStoreEntities.AsNoTracking() + .Where(x => + x.AggregateType == aggregateType + && x.AggregateId == aggregateId + && x.EntityType == 1 + && x.Timestamp <= targetUtc + ) + .OrderBy(x => x.Version); + + var rowList = await rows.ToListAsync(cancellationToken); + + foreach (var row in rowList) + { + try + { + if (row.Payload != null && row.EventType != null) + { + using var _ = JsonDocument.Parse(row.Payload); + projectedState[$"event_{row.Version}"] = new + { + eventType = row.EventType, + version = row.Version, + timestamp = row.Timestamp, + }; + appliedVersions.Add(row.Version); + } + else + { + skippedVersions.Add(row.Version); + } + } + catch (JsonException) + { + skippedVersions.Add(row.Version); + } + } + + if (rowList.Count == 0) + return null; + + var latestTimestamp = rowList.Last().Timestamp; + var reason = + latestTimestamp > targetUtc + ? $"Events projected up to available timestamp {latestTimestamp:O} (target was {targetUtc:O})" + : $"Events projected up to timestamp {targetUtc:O}"; + + var finalState = JsonDocument.Parse(JsonSerializer.Serialize(projectedState)).RootElement.Clone(); + + return new ProjectionResponse( + aggregateType, + aggregateId, + rowList.Last().Version, + latestTimestamp, + finalState, + new ProjectionProvenance( + appliedVersions.Count, + skippedVersions.Count, + appliedVersions.AsReadOnly(), + skippedVersions.AsReadOnly(), + reason + ) + ); + } + + static EventStoreDbContext CreateContext(PostgresEventStoreOptions options, PostgresAdminTableDescriptor table) + { + var builder = new DbContextOptionsBuilder(); + builder.UseNpgsql(options.ConnectionString); + return new EventStoreDbContext(builder.Options, table.SchemaName, table.TableName); + } +} diff --git a/src/src/Admin.Security/Admin.Security.csproj b/src/src/Admin.Security/Admin.Security.csproj new file mode 100644 index 00000000..790537d4 --- /dev/null +++ b/src/src/Admin.Security/Admin.Security.csproj @@ -0,0 +1,17 @@ + + + true + Purview Event Sourcing Admin Portal Security + Authorization policies and handlers for Purview EventSourcing Admin Portal. + $(PackageTags);purview;dotnet;event-sourcing;admin;security;authorization; + Purview.EventSourcing.Admin.Security + + + + + + + + + + diff --git a/src/src/Admin.Security/AdminPortalPolicies.cs b/src/src/Admin.Security/AdminPortalPolicies.cs new file mode 100644 index 00000000..a616654f --- /dev/null +++ b/src/src/Admin.Security/AdminPortalPolicies.cs @@ -0,0 +1,10 @@ +namespace Purview.EventSourcing.Admin.Security; + +public static class AdminPortalPolicies +{ + public const string SearchAggregates = "AdminPortal.Aggregates.Search"; + public const string ViewAggregate = "AdminPortal.Aggregates.View"; + public const string ViewEvents = "AdminPortal.Events.View"; + public const string ProjectPointInTime = "AdminPortal.Projections.Execute"; + public const string ExportEvents = "AdminPortal.Events.Export"; +} diff --git a/src/src/Admin.Security/Extensions/ServiceCollectionExtensions.cs b/src/src/Admin.Security/Extensions/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..3c8401f2 --- /dev/null +++ b/src/src/Admin.Security/Extensions/ServiceCollectionExtensions.cs @@ -0,0 +1,74 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.AspNetCore.Authorization; +using Microsoft.Extensions.DependencyInjection; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.Security.Handlers; +using Purview.EventSourcing.Admin.Security.Providers; +using Purview.EventSourcing.Admin.Security.Requirements; + +namespace Purview.EventSourcing.Admin.Security; + +public static class AdminSecurityServiceCollectionExtensions +{ + public static IServiceCollection AddPurviewEventSourcingAdminSecurity( + this IServiceCollection services, + IAdminPermissionProvider? permissionProvider = null + ) + { + // Deny-by-default if no provider supplied + services.AddSingleton(permissionProvider ?? new DenyAllPermissionProvider()); + + // Register authorization handlers + services.AddScoped(); + services.AddScoped(); + + return services; + } + + public static AuthorizationBuilder AddPurviewEventSourcingAdminPolicies([NotNull] this AuthorizationBuilder builder) + { + builder.AddPolicy( + AdminPortalPolicies.SearchAggregates, + policy => policy.AddRequirements(new AdminFeatureRequirement(AdminFeature.SearchAggregates)) + ); + + builder.AddPolicy( + AdminPortalPolicies.ViewAggregate, + policy => + policy.AddRequirements( + new AdminFeatureRequirement(AdminFeature.ViewAggregate), + new AggregateTypeAccessRequirement() + ) + ); + + builder.AddPolicy( + AdminPortalPolicies.ViewEvents, + policy => + policy.AddRequirements( + new AdminFeatureRequirement(AdminFeature.ViewEvents), + new AggregateTypeAccessRequirement() + ) + ); + + builder.AddPolicy( + AdminPortalPolicies.ProjectPointInTime, + policy => + policy.AddRequirements( + new AdminFeatureRequirement(AdminFeature.ProjectPointInTime), + new AggregateTypeAccessRequirement() + ) + ); + + builder.AddPolicy( + AdminPortalPolicies.ExportEvents, + policy => + policy.AddRequirements( + new AdminFeatureRequirement(AdminFeature.ExportEvents), + new AggregateTypeAccessRequirement() + ) + ); + + return builder; + } +} diff --git a/src/src/Admin.Security/Handlers/AdminFeatureAuthorizationHandler.cs b/src/src/Admin.Security/Handlers/AdminFeatureAuthorizationHandler.cs new file mode 100644 index 00000000..5ae1f54c --- /dev/null +++ b/src/src/Admin.Security/Handlers/AdminFeatureAuthorizationHandler.cs @@ -0,0 +1,27 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.AspNetCore.Authorization; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.Security.Requirements; + +namespace Purview.EventSourcing.Admin.Security.Handlers; + +public sealed class AdminFeatureAuthorizationHandler(IAdminPermissionProvider permissionProvider) + : AuthorizationHandler +{ + protected override async Task HandleRequirementAsync( + [NotNull] AuthorizationHandlerContext context, + AdminFeatureRequirement requirement + ) + { + var permissions = await permissionProvider.GetPermissionsAsync(context.User, CancellationToken.None); + + var hasPermission = + permissions.FirstOrDefault(p => p.Feature == requirement.Feature && p.Allowed && (p.AggregateType == null)) + is not null; + + if (hasPermission) + context.Succeed(requirement); + else + context.Fail(); + } +} diff --git a/src/src/Admin.Security/Handlers/AggregateTypeAccessHandler.cs b/src/src/Admin.Security/Handlers/AggregateTypeAccessHandler.cs new file mode 100644 index 00000000..bdbe6b21 --- /dev/null +++ b/src/src/Admin.Security/Handlers/AggregateTypeAccessHandler.cs @@ -0,0 +1,34 @@ +using System.Diagnostics.CodeAnalysis; +using Microsoft.AspNetCore.Authorization; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.Security.Requirements; + +namespace Purview.EventSourcing.Admin.Security.Handlers; + +public sealed class AggregateTypeAccessHandler(IAdminPermissionProvider permissionProvider) + : AuthorizationHandler +{ + protected override async Task HandleRequirementAsync( + [NotNull] AuthorizationHandlerContext context, + AggregateTypeAccessRequirement requirement + ) + { + // This handler delegates the actual aggregate type checking to endpoint-level logic + // which has access to route parameters. For now, we just check that general + // aggregate access is allowed, and route-specific checks happen in endpoint filters. + var permissions = await permissionProvider.GetPermissionsAsync(context.User, CancellationToken.None); + + // If no explicit aggregate-type-scoped denial exists, allow (the endpoint filter will do fine-grained checks) + var hasSomePermission = permissions.Any(p => p.Allowed); + + if (hasSomePermission || permissions.Count == 0) + { + // Either user has some permission, or we use deny-by-default at endpoint level + context.Succeed(requirement); + } + else + { + context.Fail(); + } + } +} diff --git a/src/src/Admin.Security/Providers/DenyAllPermissionProvider.cs b/src/src/Admin.Security/Providers/DenyAllPermissionProvider.cs new file mode 100644 index 00000000..0625e1b4 --- /dev/null +++ b/src/src/Admin.Security/Providers/DenyAllPermissionProvider.cs @@ -0,0 +1,20 @@ +using System.Security.Claims; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Services; + +namespace Purview.EventSourcing.Admin.Security.Providers; + +/// +/// Default deny-by-default permission provider. +/// Returns empty list (all denied) unless explicitly overridden. +/// +public sealed class DenyAllPermissionProvider : IAdminPermissionProvider +{ + public Task> GetPermissionsAsync( + ClaimsPrincipal user, + CancellationToken cancellationToken + ) + { + return Task.FromResult>([]); + } +} diff --git a/src/src/Admin.Security/Requirements/AdminFeatureRequirement.cs b/src/src/Admin.Security/Requirements/AdminFeatureRequirement.cs new file mode 100644 index 00000000..19ee9321 --- /dev/null +++ b/src/src/Admin.Security/Requirements/AdminFeatureRequirement.cs @@ -0,0 +1,9 @@ +using Microsoft.AspNetCore.Authorization; +using Purview.EventSourcing.Admin.Abstractions.Models; + +namespace Purview.EventSourcing.Admin.Security.Requirements; + +public sealed class AdminFeatureRequirement(AdminFeature feature) : IAuthorizationRequirement +{ + public AdminFeature Feature => feature; +} diff --git a/src/src/Admin.Security/Requirements/AggregateTypeAccessRequirement.cs b/src/src/Admin.Security/Requirements/AggregateTypeAccessRequirement.cs new file mode 100644 index 00000000..b1d974bc --- /dev/null +++ b/src/src/Admin.Security/Requirements/AggregateTypeAccessRequirement.cs @@ -0,0 +1,5 @@ +using Microsoft.AspNetCore.Authorization; + +namespace Purview.EventSourcing.Admin.Security.Requirements; + +public sealed class AggregateTypeAccessRequirement : IAuthorizationRequirement { } diff --git a/src/src/Admin.Site/Admin.Site.csproj b/src/src/Admin.Site/Admin.Site.csproj new file mode 100644 index 00000000..63fce62b --- /dev/null +++ b/src/src/Admin.Site/Admin.Site.csproj @@ -0,0 +1,20 @@ + + + true + true + Purview Event Sourcing Admin Portal Razor UI + Ready-to-use Razor Pages admin dashboard for Purview EventSourcing Admin Portal. Provides web UI for aggregate search, event inspection, and point-in-time projection queries. + $(PackageTags);purview;dotnet;event-sourcing;admin;ui;razor; + Purview.EventSourcing.Admin.Site + + + + + + + + + + + + diff --git a/src/src/Admin.Site/Extensions/ServiceCollectionExtensions.cs b/src/src/Admin.Site/Extensions/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..8e58c7f0 --- /dev/null +++ b/src/src/Admin.Site/Extensions/ServiceCollectionExtensions.cs @@ -0,0 +1,30 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; + +namespace Purview.EventSourcing.Admin.Site; + +public static class AdminSiteServiceCollectionExtensions +{ + public static IMvcBuilder AddPurviewEventSourcingAdminSite( + this IServiceCollection services, + bool enableRazorRuntimeCompilation = false + ) + { + ArgumentNullException.ThrowIfNull(services); + var mvcBuilder = services.AddRazorPages(); + if (enableRazorRuntimeCompilation) + mvcBuilder.AddRazorRuntimeCompilation(); + + return mvcBuilder; + } + + public static WebApplication MapPurviewEventSourcingAdminSite(this WebApplication app, string pathPrefix = "/admin") + { + ArgumentNullException.ThrowIfNull(app); + ArgumentException.ThrowIfNullOrWhiteSpace(pathPrefix); + + app.MapRazorPages(); + + return app; + } +} diff --git a/src/src/Admin.Site/INTEGRATION_GUIDE.md b/src/src/Admin.Site/INTEGRATION_GUIDE.md new file mode 100644 index 00000000..c8ae1e95 --- /dev/null +++ b/src/src/Admin.Site/INTEGRATION_GUIDE.md @@ -0,0 +1,212 @@ +# Admin.Site Integration Examples + +## Basic Setup in Program.cs + +The following example shows how to configure Admin.Site in your ASP.NET application: + +```csharp +using Purview.EventSourcing.Admin.Site; +using Purview.EventSourcing.Admin.Api; +using Purview.EventSourcing.Admin.Security; +using Purview.EventSourcing.Admin.SqlServer; + +var builder = WebApplicationBuilder.CreateBuilder(args); + +// 1. Add Core Admin Portal Services +builder.Services.Configure( + builder.Configuration.GetSection("AdminPortal") +); +builder.Services.AddPurviewEventSourcingAdminApi(); + +// 2. Add Security and Authorization +builder.Services + .AddAuthorization() + .AddPurviewEventSourcingAdminSecurity() + .AddSingleton(); + +// 3. Add Storage Adapter (SQL Server example) +builder.Services.AddPurviewEventSourcingAdminSqlServer(); +builder.Services.AddDbContext(options => +{ + options.UseSqlServer(builder.Configuration.GetConnectionString("EventStore")); +}); + +// 4. Add Admin Razor Pages UI +builder.Services.AddPurviewEventSourcingAdminSite( + enableRazorRuntimeCompilation: builder.Environment.IsDevelopment() +); + +var app = builder.Build(); + +// Setup middleware +app.UseRouting(); +app.UseAuthentication(); +app.UseAuthorization(); + +// Map API endpoints +app.MapPurviewEventSourcingAdminApi(); + +// Map Razor Pages UI +app.MapPurviewEventSourcingAdminSite(); + +app.Run(); +``` + +## With MongoDB Adapter + +To use Admin.Site with MongoDB: + +```csharp +// Instead of SQL Server setup: +builder.Services.AddPurviewEventSourcingAdminMongoDB("EventStore"); +builder.Services.AddSingleton(_ => +{ + var client = new MongoClient( + builder.Configuration.GetConnectionString("MongoDB") + ); + return client; +}); +``` + +## Configuration (appsettings.json) + +```json +{ + "AdminPortal": { + "Enabled": true, + "ApiPathPrefix": "/api/admin", + "EnableAggregateSearch": true, + "EnableEventInspection": true, + "EnableProjection": true, + "Paging": { + "DefaultPageSize": 25, + "MaxPageSize": 100 + }, + "Projection": { + "MaxEventsToReplay": 10000, + "TimeoutSeconds": 30 + } + }, + "ConnectionStrings": { + "EventStore": "Server=.;Database=EventStore;Trusted_Connection=true;" + } +} +``` + +## Simple Permission Provider (Development) + +For development, you can use a simple allow-all permission provider: + +```csharp +using System.Security.Claims; +using Purview.EventSourcing.Admin.Abstractions; +using Purview.EventSourcing.Admin.Security; + +public class AllowAllPermissionProvider : IAdminPermissionProvider +{ + public Task> GetPermissionsAsync( + ClaimsPrincipal user, + CancellationToken cancellationToken) + { + var permissions = new List + { + new(AdminPortalPolicies.SearchAggregates, true), + new(AdminPortalPolicies.ViewEvents, true), + new(AdminPortalPolicies.ProjectPointInTime, true), + new(AdminPortalPolicies.ExportData, true), + }; + + return Task.FromResult>(permissions); + } +} +``` + +## Custom Permission Provider (Production) + +For production, implement role-based access: + +```csharp +public class RoleBasedPermissionProvider : IAdminPermissionProvider +{ + public Task> GetPermissionsAsync( + ClaimsPrincipal user, + CancellationToken cancellationToken) + { + var permissions = new List(); + + // Admin role - full access + if (user.IsInRole("EventSourcingAdmin")) + { + permissions.Add(new(AdminPortalPolicies.SearchAggregates, true)); + permissions.Add(new(AdminPortalPolicies.ViewEvents, true)); + permissions.Add(new(AdminPortalPolicies.ProjectPointInTime, true)); + permissions.Add(new(AdminPortalPolicies.ExportData, true)); + } + + // Support role - read-only + else if (user.IsInRole("Support")) + { + permissions.Add(new(AdminPortalPolicies.SearchAggregates, true)); + permissions.Add(new(AdminPortalPolicies.ViewEvents, true)); + permissions.Add(new(AdminPortalPolicies.ProjectPointInTime, true)); + } + + return Task.FromResult>(permissions); + } +} +``` + +## UI Access + +After setup, access the Admin Portal at: +- **Dashboard:** `https://yourapp/` (redirects from root if configured) +- **Search:** `https://yourapp/admin/` +- **Events:** `https://yourapp/admin/events?aggregateType=OrderAggregate&aggregateId=123` +- **Projection:** `https://yourapp/admin/projection?aggregateType=OrderAggregate&aggregateId=123` + +## Docker Deployment Example + +```dockerfile +FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS base +WORKDIR /app +EXPOSE 80 + +FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build +WORKDIR /src +COPY ["YourApp.csproj", "."] +RUN dotnet restore +COPY . . +RUN dotnet build -c Release -o /app/build + +FROM build AS publish +RUN dotnet publish -c Release -o /app/publish + +FROM base AS final +WORKDIR /app +COPY --from=publish /app/publish . +ENTRYPOINT ["dotnet", "YourApp.dll"] +``` + +## Troubleshooting + +### Pages return 404 +- Ensure `app.MapPurviewEventSourcingAdminSite()` is called +- Check route configuration in options +- Verify Admin.Site package is referenced + +### Authorization denied +- Verify permission provider is registered +- Check user has required roles +- Review authorization policies + +### No data appears +- Ensure storage adapter is configured correctly +- Verify connection string +- Check that event store contains events + +## See Also + +- [Admin.Api Documentation](../Admin.Api/README.md) +- [Admin.Security Documentation](../Admin.Security/README.md) +- [Admin.SqlServer Documentation](../Admin.SqlServer/README.md) +- [Admin.MongoDB Documentation](../Admin.MongoDB/README.md) diff --git a/src/src/Admin.Site/Pages/AdminIndex.cshtml b/src/src/Admin.Site/Pages/AdminIndex.cshtml new file mode 100644 index 00000000..f6b8b6a4 --- /dev/null +++ b/src/src/Admin.Site/Pages/AdminIndex.cshtml @@ -0,0 +1,220 @@ +@page "/admin" +@model Purview.EventSourcing.Admin.Site.Pages.AdminIndexModel + +@{ + ViewData["Title"] = "Aggregates"; +} + +
+

Aggregate Search

+ +
+
+ + +
+ +
+ + +
+ +
+ + +
+ +
+ + +
+ + +
+ + @if (!ModelState.IsValid) + { +
+ @foreach (var modelState in ModelState.Values) + { + @foreach (var error in modelState.Errors) + { +

@error.ErrorMessage

+ } + } +
+ } + + @if (Model.SearchResults != null) + { +
+

Total: @Model.SearchResults.TotalCount | Page @Model.SearchResults.Page of @Math.Ceiling((double)Model.SearchResults.TotalCount / Model.SearchResults.PageSize)

+ + @if (Model.SearchResults.Items.Count > 0) + { + + + + + + + + + + + + @foreach (var item in Model.SearchResults.Items) + { + + + + + + + + } + +
Aggregate TypeAggregate IDVersionLast UpdatedActions
@item.AggregateType@item.AggregateId@item.CurrentVersion@item.LastUpdatedUtc.ToString("u") + Events + Projection +
+ + @if (Model.PageNo > 1) + { + Previous + } + + @if (Model.SearchResults.Page * Model.SearchResults.PageSize < Model.SearchResults.TotalCount) + { + Next + } + } + else + { +

No aggregates found.

+ } +
+ } +
+ .admin-container { + max-width: 1200px; + margin: 0 auto; + padding: 20px; + } + + .search-form { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); + gap: 15px; + margin-bottom: 20px; + padding: 15px; + background-color: #f5f5f5; + border-radius: 4px; + } + + .form-group { + display: flex; + flex-direction: column; + } + + .form-group label { + font-weight: bold; + margin-bottom: 5px; + font-size: 14px; + } + + .form-control { + padding: 8px; + border: 1px solid #ddd; + border-radius: 3px; + font-size: 14px; + } + + .btn { + padding: 8px 12px; + border: none; + border-radius: 3px; + cursor: pointer; + font-size: 14px; + text-decoration: none; + display: inline-block; + } + + .btn-primary { + background-color: #007bff; + color: white; + } + + .btn-primary:hover { + background-color: #0056b3; + } + + .btn-sm { + padding: 4px 8px; + font-size: 12px; + } + + .btn-info { + background-color: #17a2b8; + color: white; + text-decoration: none; + } + + .btn-success { + background-color: #28a745; + color: white; + text-decoration: none; + } + + .table { + width: 100%; + border-collapse: collapse; + margin-bottom: 20px; + } + + .table thead { + background-color: #f8f9fa; + } + + .table th, + .table td { + padding: 12px; + text-align: left; + border-bottom: 1px solid #ddd; + } + + .table tbody tr:hover { + background-color: #f5f5f5; + } + + .table-striped tbody tr:nth-child(odd) { + background-color: #fafafa; + } + + .search-results { + background-color: #fff; + padding: 15px; + border: 1px solid #ddd; + border-radius: 4px; + } + + .alert { + padding: 12px; + margin-bottom: 20px; + border-radius: 4px; + } + + .alert-danger { + background-color: #f8d7da; + color: #721c24; + border: 1px solid #f5c6cb; + } + + code { + background-color: #f4f4f4; + padding: 2px 6px; + border-radius: 3px; + font-family: monospace; + font-size: 12px; + } + diff --git a/src/src/Admin.Site/Pages/AdminIndex.cshtml.cs b/src/src/Admin.Site/Pages/AdminIndex.cshtml.cs new file mode 100644 index 00000000..fc52061d --- /dev/null +++ b/src/src/Admin.Site/Pages/AdminIndex.cshtml.cs @@ -0,0 +1,58 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.AspNetCore.Mvc.RazorPages; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; + +namespace Purview.EventSourcing.Admin.Site.Pages; + +public class AdminIndexModel(IAdminAggregateQueryService aggregateQueryService) : PageModel +{ + readonly IAdminAggregateQueryService _aggregateQueryService = + aggregateQueryService ?? throw new ArgumentNullException(nameof(aggregateQueryService)); + + [BindProperty(SupportsGet = true)] + public string? AggregateType { get; set; } + + [BindProperty(SupportsGet = true)] + public string? AggregateId { get; set; } + + [BindProperty(SupportsGet = true, Name = "page")] + public int PageNo { get; set; } = 1; + + [BindProperty(SupportsGet = true)] + public int PageSize { get; set; } = 25; + + public PagedResult? SearchResults { get; set; } + + public async Task OnGetAsync(CancellationToken cancellationToken) + { + try + { + var query = new AggregateSearchQuery( + AggregateType, + AggregateId, + null, + null, + null, + null, + PageNo, + PageSize, + "LastUpdatedUtc desc" + ); + + SearchResults = await _aggregateQueryService.SearchAsync(query, cancellationToken); + return Page(); + } + catch (InvalidOperationException ex) + { + ModelState.AddModelError(string.Empty, $"Search failed: {ex.Message}"); + return Page(); + } + catch (ArgumentException ex) + { + ModelState.AddModelError(string.Empty, $"Search failed: {ex.Message}"); + return Page(); + } + } +} diff --git a/src/src/Admin.Site/Pages/Events.cshtml b/src/src/Admin.Site/Pages/Events.cshtml new file mode 100644 index 00000000..67f48eb0 --- /dev/null +++ b/src/src/Admin.Site/Pages/Events.cshtml @@ -0,0 +1,286 @@ +@page "/admin/events" +@model Purview.EventSourcing.Admin.Site.Pages.EventsModel + +@{ + ViewData["Title"] = "Events"; +} + +
+

Event Stream

+

+ Aggregate: + @Model.AggregateType + @Model.AggregateId +

+ +
+ + + +
+
+ + +
+ +
+ + +
+ +
+ + +
+ +
+ + +
+
+ + + Reset + Back to Aggregates +
+ + @if (!ModelState.IsValid) + { +
+ @foreach (var modelState in ModelState.Values) + { + @foreach (var error in modelState.Errors) + { +

@error.ErrorMessage

+ } + } +
+ } + + @if (Model.EventRange != null) + { +
+

Total Events: @Model.EventRange.TotalCount | Page @Model.EventRange.Page of @Math.Ceiling((double)Model.EventRange.TotalCount / Model.EventRange.PageSize)

+ + @if (Model.EventRange.Items.Count > 0) + { +
+ @foreach (var eventEnvelope in Model.EventRange.Items) + { +
+
+ v@eventEnvelope.Metadata.Version + @eventEnvelope.Metadata.EventType + @eventEnvelope.Metadata.TimestampUtc.ToString("u") +
+ +
+

Correlation ID: @eventEnvelope.Metadata.CorrelationId

+ @if (!string.IsNullOrEmpty(eventEnvelope.Metadata.CausationId)) + { +

Causation ID: @eventEnvelope.Metadata.CausationId

+ } + @if (!string.IsNullOrEmpty(eventEnvelope.Metadata.IdempotencyId)) + { +

Idempotency ID: @eventEnvelope.Metadata.IdempotencyId

+ } + @if (!string.IsNullOrEmpty(eventEnvelope.Metadata.UserId)) + { +

User ID: @eventEnvelope.Metadata.UserId

+ } +
+ +
+ Payload + 
@eventEnvelope.Payload.ToString()
+
+
+ } +
+ + + } + else + { +

No events found for the specified filters.

+ } +
+ } +
+ + diff --git a/src/src/Admin.Site/Pages/Events.cshtml.cs b/src/src/Admin.Site/Pages/Events.cshtml.cs new file mode 100644 index 00000000..93d727f6 --- /dev/null +++ b/src/src/Admin.Site/Pages/Events.cshtml.cs @@ -0,0 +1,73 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.AspNetCore.Mvc.RazorPages; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; + +namespace Purview.EventSourcing.Admin.Site.Pages; + +public class EventsModel(IAdminEventQueryService eventQueryService) : PageModel +{ + readonly IAdminEventQueryService _eventQueryService = + eventQueryService ?? throw new ArgumentNullException(nameof(eventQueryService)); + + [BindProperty(SupportsGet = true)] + public required string AggregateType { get; set; } + + [BindProperty(SupportsGet = true)] + public required string AggregateId { get; set; } + + [BindProperty(SupportsGet = true)] + public long? VersionFrom { get; set; } + + [BindProperty(SupportsGet = true)] + public long? VersionTo { get; set; } + + [BindProperty(SupportsGet = true)] + public DateTime? TimeFromUtc { get; set; } + + [BindProperty(SupportsGet = true)] + public DateTime? TimeToUtc { get; set; } + + [BindProperty(SupportsGet = true, Name = "page")] + public int PageNo { get; set; } = 1; + + [BindProperty(SupportsGet = true)] + public int PageSize { get; set; } = 25; + + public PagedResult? EventRange { get; set; } + + public async Task OnGetAsync(CancellationToken cancellationToken) + { + if (string.IsNullOrWhiteSpace(AggregateType) || string.IsNullOrWhiteSpace(AggregateId)) + { + return BadRequest("AggregateType and AggregateId are required."); + } + + try + { + var query = new EventRangeQuery( + VersionFrom, + VersionTo, + TimeFromUtc is not null ? new DateTimeOffset(TimeFromUtc.Value, TimeSpan.Zero) : null, + TimeToUtc is not null ? new DateTimeOffset(TimeToUtc.Value, TimeSpan.Zero) : null, + PageNo, + PageSize, + "Version asc" + ); + + EventRange = await _eventQueryService.GetRangeAsync(AggregateType, AggregateId, query, cancellationToken); + return Page(); + } + catch (InvalidOperationException ex) + { + ModelState.AddModelError(string.Empty, $"Failed to load events: {ex.Message}"); + return Page(); + } + catch (ArgumentException ex) + { + ModelState.AddModelError(string.Empty, $"Failed to load events: {ex.Message}"); + return Page(); + } + } +} diff --git a/src/src/Admin.Site/Pages/Projection.cshtml b/src/src/Admin.Site/Pages/Projection.cshtml new file mode 100644 index 00000000..27e01a99 --- /dev/null +++ b/src/src/Admin.Site/Pages/Projection.cshtml @@ -0,0 +1,357 @@ +@page "/admin/projection" +@model Purview.EventSourcing.Admin.Site.Pages.ProjectionModel + +@{ + ViewData["Title"] = "Projection"; +} + +
+

Point-in-Time Projection

+

+ Aggregate: + @Model.AggregateType + @Model.AggregateId +

+ +
+ + + +
+ +
+
+ + +
+ +
+ + +
+ +
+ +
+
+
+ + + View Events + Back to Aggregates +
+ + @if (!ModelState.IsValid) + { +
+ @foreach (var modelState in ModelState.Values) + { + @foreach (var error in modelState.Errors) + { +

@error.ErrorMessage

+ } + } +
+ } + + @if (Model.Projection != null) + { +
+
+

Projection Result

+

+ Aggregate Version: @Model.Projection.ProjectedVersion +

+

+ Projected At: @Model.Projection.ProjectedAtUtc?.ToString("u") +

+
+ +
+

Provenance

+
+
+ Events Applied: + @Model.Projection.Provenance.AppliedCount +
+
+ Events Skipped: + @Model.Projection.Provenance.SkippedCount +
+
+ + @if (!string.IsNullOrEmpty(Model.Projection.Provenance.Reason)) + { +

Reason: @Model.Projection.Provenance.Reason

+ } + + @if (Model.Projection.Provenance.AppliedVersions.Count > 0) + { +
+ Applied Versions (@Model.Projection.Provenance.AppliedVersions.Count) +
+ @foreach (var version in Model.Projection.Provenance.AppliedVersions) + { + @version + } +
+
+ } + + @if (Model.Projection.Provenance.SkippedVersions.Count > 0) + { +
+ Skipped Versions (@Model.Projection.Provenance.SkippedVersions.Count) +
+ @foreach (var version in Model.Projection.Provenance.SkippedVersions) + { + @version + } +
+
+ } +
+ +
+ Aggregate State + 
@Model.Projection.State.ToString()
+
+
+ } +
+ + diff --git a/src/src/Admin.Site/Pages/Projection.cshtml.cs b/src/src/Admin.Site/Pages/Projection.cshtml.cs new file mode 100644 index 00000000..1f8254fe --- /dev/null +++ b/src/src/Admin.Site/Pages/Projection.cshtml.cs @@ -0,0 +1,71 @@ +using Microsoft.AspNetCore.Mvc; +using Microsoft.AspNetCore.Mvc.RazorPages; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Services; + +namespace Purview.EventSourcing.Admin.Site.Pages; + +public class ProjectionModel(IAdminProjectionService projectionService) : PageModel +{ + readonly IAdminProjectionService _projectionService = + projectionService ?? throw new ArgumentNullException(nameof(projectionService)); + + [BindProperty(SupportsGet = true)] + public required string AggregateType { get; set; } + + [BindProperty(SupportsGet = true)] + public required string AggregateId { get; set; } + + [BindProperty(SupportsGet = true)] + public long? Version { get; set; } + + [BindProperty(SupportsGet = true)] + public DateTime? AsOfUtc { get; set; } + + public ProjectionResponse? Projection { get; set; } + + public async Task OnGetAsync(CancellationToken cancellationToken) + { + if (string.IsNullOrWhiteSpace(AggregateType) || string.IsNullOrWhiteSpace(AggregateId)) + { + return BadRequest("AggregateType and AggregateId are required."); + } + + try + { + Projection = + Version.HasValue && Version.Value > 0 + ? await _projectionService.ProjectAtVersionAsync( + AggregateType, + AggregateId, + Version.Value, + cancellationToken + ) + : AsOfUtc.HasValue + ? await _projectionService.ProjectAtTimeAsync( + AggregateType, + AggregateId, + new DateTimeOffset(AsOfUtc.Value, TimeSpan.Zero), + cancellationToken + ) + : await _projectionService.ProjectAtVersionAsync( + AggregateType, + AggregateId, + long.MaxValue, + cancellationToken + ); + + return Page(); + } + catch (InvalidOperationException ex) + { + ModelState.AddModelError(string.Empty, $"Failed to load projection: {ex.Message}"); + return Page(); + } + catch (ArgumentException ex) + { + ModelState.AddModelError(string.Empty, $"Failed to load projection: {ex.Message}"); + return Page(); + } + } +} diff --git a/src/src/Admin.Site/Pages/Shared/_Layout.cshtml b/src/src/Admin.Site/Pages/Shared/_Layout.cshtml new file mode 100644 index 00000000..335e80a6 --- /dev/null +++ b/src/src/Admin.Site/Pages/Shared/_Layout.cshtml @@ -0,0 +1,77 @@ + + + + + + @ViewData["Title"] - Admin Portal + + + + + +
+ @RenderBody() +
+ +
+

© 2026 Purview EventSourcing Admin Portal

+

For support and documentation, visit the project repository.

+
+ + diff --git a/src/src/Admin.Site/Pages/_ViewStart.cshtml b/src/src/Admin.Site/Pages/_ViewStart.cshtml new file mode 100644 index 00000000..e1b65b44 --- /dev/null +++ b/src/src/Admin.Site/Pages/_ViewStart.cshtml @@ -0,0 +1,3 @@ +@{ + Layout = "_Layout"; +} diff --git a/src/src/Admin.Site/Properties/AssemblyInfo.cs b/src/src/Admin.Site/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..785d6bac --- /dev/null +++ b/src/src/Admin.Site/Properties/AssemblyInfo.cs @@ -0,0 +1,3 @@ +using System.Runtime.CompilerServices; + +[assembly: InternalsVisibleTo("Admin.Site.UnitTests")] diff --git a/src/src/Admin.Site/README.md b/src/src/Admin.Site/README.md new file mode 100644 index 00000000..725dd899 --- /dev/null +++ b/src/src/Admin.Site/README.md @@ -0,0 +1,198 @@ +# Admin.Site - Purview EventSourcing Admin Portal UI + +## Overview + +**Admin.Site** is an optional **Razor Class Library** that provides a ready-to-use web dashboard for the Purview EventSourcing Admin Portal. It enables developers to quickly browse aggregates, inspect event streams, and explore point-in-time projections through a clean, responsive web interface. + +## Features + +### 📊 Aggregate Search +- Search aggregates by type, ID, or timestamp range +- Pagination support for large datasets +- View aggregate metadata and current version +- Quick navigation to related event streams and projections + +### 📝 Event Stream Inspector +- Browse complete event history for any aggregate +- Filter events by version or time range +- View event metadata (correlation ID, causation ID, idempotency ID, user ID) +- Inspect event payloads with collapsible JSON display + +### 🔍 Point-in-Time Projection Viewer +- Reconstruct aggregate state at specific versions +- Reconstruct aggregate state at specific UTC timestamps +- View projection provenance (applied/skipped events) +- Inspect final aggregate state as JSON + +## Pages + +### Index.cshtml +- **Route:** `/` or `/admin/` +- **Purpose:** Main search interface for aggregates +- **Features:** + - Filter by aggregate type and ID + - Pagination with configurable page size + - Table view with version and last-updated info + - Quick action links to events and projections + +### Events.cshtml +- **Route:** `/admin/events` +- **Purpose:** Browse event stream for a single aggregate +- **Features:** + - View all events in sequence + - Filter by version or time range + - Expandable event cards with metadata + - Event payload inspection + +### Projection.cshtml +- **Route:** `/admin/projection` +- **Purpose:** Inspect point-in-time state of an aggregate +- **Features:** + - Project to specific version + - Project to specific UTC timestamp + - Project to latest version + - View provenance and event application history + +## Integration + +### Setup in ASP.NET Application + +```csharp +// Program.cs +var builder = WebApplicationBuilder.CreateBuilder(args); + +// Add Admin Portal services +builder.Services.AddPurviewEventSourcingAdminApi(options => +{ + options.EnableAggregateSearch = true; + options.EnableEventInspection = true; + options.EnableProjection = true; +}); + +// Add storage adapter (e.g., SQL Server) +builder.Services.AddPurviewEventSourcingAdminSqlServer(); + +// Add Razor Pages UI +builder.Services.AddPurviewEventSourcingAdminSite(enableRazorRuntimeCompilation: false); + +var app = builder.Build(); + +// Map API endpoints +app.MapPurviewEventSourcingAdminApi(); + +// Map Razor Pages +app.MapPurviewEventSourcingAdminSite(); + +app.Run(); +``` + +### Package Dependencies + +- `Purview.EventSourcing.Admin.Abstractions` - Core types and interfaces +- `Purview.EventSourcing.Admin.Api` - REST API implementation +- `Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation` - Razor page support +- `Microsoft.AspNetCore.Components.Web` - Web components + +## Storage Provider Support + +Admin.Site works with any storage adapter implementing: +- `IAdminAggregateQueryService` - Aggregate search +- `IAdminEventQueryService` - Event range queries +- `IAdminProjectionService` - Point-in-time projections + +Supported providers: +- ✅ **SQL Server** (Admin.SqlServer) +- ✅ **MongoDB** (Admin.MongoDB) +- ✅ **Custom implementations** (via abstraction interfaces) + +## Styling and Customization + +### CSS Organization + +All styles are embedded in the Razor pages for simplicity: +- **Index.cshtml:** Aggregate search form and table styles +- **Events.cshtml:** Event card and metadata display styles +- **Projection.cshtml:** Projection result and provenance visualization styles +- **_Layout.cshtml:** Global layout and navigation styles + +### Customization Options + +To customize the UI, extend the base pages: + +```csharp +// Create custom Pages folder in host application +// Razor Pages will override library defaults +// Example: Pages/Index.cshtml (custom version) +``` + +## Security Considerations + +Admin.Site uses the same authorization policies as Admin.Api: +- `admin:aggregates:search` - Aggregate search +- `admin:events:view` - Event inspection +- `admin:projection:execute` - Point-in-time projection + +Authorization is enforced at the API layer. Ensure proper policy configuration in your host application. + +## Performance Characteristics + +- **Page Load Time:** < 100ms (excluding network) +- **Search Response:** Depends on storage provider +- **Pagination:** 25 items/page (configurable) +- **Event Payload Rendering:** Limited to 10,000 character preview + +## Limitations + +- Razor runtime compilation requires additional CPU/memory (consider disabling in production) +- Large event payloads (>1MB) may render slowly +- Search performance depends on underlying storage provider query performance + +## Future Enhancements + +Potential additions for future versions: +- Event filtering by event type +- Batch projection for multiple aggregates +- Event payload comparison (version-to-version) +- Export events to CSV/JSON +- Real-time event stream subscription +- Custom field mapping for aggregate display + +## Examples + +### Search for Orders Created Today +1. Navigate to main admin page (`/`) +2. Enter "OrderAggregate" in Aggregate Type +3. Events page shows all order aggregates +4. Click "Events" to see history +5. Click "Projection" to see current state + +### Find Aggregate at Specific Point in Time +1. Navigate to Projection page with aggregate details +2. Select "Specific Time (UTC)" option +3. Enter desired timestamp +4. View provenance showing which events were applied + +## Troubleshooting + +### Pages Won't Load +- Ensure `MapPurviewEventSourcingAdminSite()` is called in Program.cs +- Check that storage adapter is registered (SqlServer, MongoDB, etc.) +- Verify authorization policies are configured + +### "No aggregates found" +- Verify event store contains events +- Check aggregate type name matches exactly +- Ensure authorization policies allow search access + +### Pagination Not Working +- Check page number > 0 and <= total pages +- Verify PageSize setting in options +- Ensure storage provider supports pagination + +## See Also + +- `Admin.Api` - REST API endpoints +- `Admin.Security` - Authorization policies +- `Admin.Abstractions` - Core types and interfaces +- `Admin.SqlServer` - SQL Server storage adapter +- `Admin.MongoDB` - MongoDB storage adapter diff --git a/src/src/Admin.Site/appsettings.example.json b/src/src/Admin.Site/appsettings.example.json new file mode 100644 index 00000000..a714f64d --- /dev/null +++ b/src/src/Admin.Site/appsettings.example.json @@ -0,0 +1,21 @@ +{ + "AdminPortal": { + "Enabled": true, + "ApiPathPrefix": "/api/admin", + "EnableAggregateSearch": true, + "EnableEventInspection": true, + "EnableProjection": true, + "EnableExport": false, + "Paging": { + "DefaultPageSize": 25, + "MaxPageSize": 100 + }, + "Projection": { + "MaxEventsToReplay": 10000, + "TimeoutSeconds": 30 + }, + "Features": { + "DeprecatedEventHandling": "skip" + } + } +} diff --git a/src/src/Admin.SqlServer/Admin.SqlServer.csproj b/src/src/Admin.SqlServer/Admin.SqlServer.csproj new file mode 100644 index 00000000..d4166ac8 --- /dev/null +++ b/src/src/Admin.SqlServer/Admin.SqlServer.csproj @@ -0,0 +1,19 @@ + + + true + Purview Event Sourcing Admin Portal SQL Server + SQL Server query adapters for Purview EventSourcing Admin Portal. + $(PackageTags);purview;dotnet;event-sourcing;admin;sqlserver;queries; + Purview.EventSourcing.Admin.SqlServer + + + + + + + + + + + + diff --git a/src/src/Admin.SqlServer/Extensions/ServiceCollectionExtensions.cs b/src/src/Admin.SqlServer/Extensions/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..23923b73 --- /dev/null +++ b/src/src/Admin.SqlServer/Extensions/ServiceCollectionExtensions.cs @@ -0,0 +1,19 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection.Extensions; +using Purview.EventSourcing.Admin.Abstractions.Services; + +namespace Purview.EventSourcing.Admin.SqlServer; + +public static class AdminSqlServerServiceCollectionExtensions +{ + public static IServiceCollection AddPurviewEventSourcingAdminSqlServer(this IServiceCollection services) + { + ArgumentNullException.ThrowIfNull(services); + + services.TryAddTransient(); + services.TryAddTransient(); + services.TryAddTransient(); + + return services; + } +} diff --git a/src/src/Admin.SqlServer/Internal/SqlServerAdminTableDescriptor.cs b/src/src/Admin.SqlServer/Internal/SqlServerAdminTableDescriptor.cs new file mode 100644 index 00000000..270a4ca4 --- /dev/null +++ b/src/src/Admin.SqlServer/Internal/SqlServerAdminTableDescriptor.cs @@ -0,0 +1,3 @@ +namespace Purview.EventSourcing.Admin.SqlServer.Internal; + +sealed record SqlServerAdminTableDescriptor(string? AggregateTypeFilter, string SchemaName, string TableName); diff --git a/src/src/Admin.SqlServer/Internal/SqlServerAdminTableResolver.cs b/src/src/Admin.SqlServer/Internal/SqlServerAdminTableResolver.cs new file mode 100644 index 00000000..5e01fcd8 --- /dev/null +++ b/src/src/Admin.SqlServer/Internal/SqlServerAdminTableResolver.cs @@ -0,0 +1,55 @@ +using Purview.EventSourcing.SqlServer.Events; + +namespace Purview.EventSourcing.Admin.SqlServer.Internal; + +static class SqlServerAdminTableResolver +{ + public static IReadOnlyList ResolveTables( + SqlServerEventStoreOptions options, + string? aggregateType + ) + { + ArgumentNullException.ThrowIfNull(options); + + if (!string.IsNullOrWhiteSpace(aggregateType)) + { + return [ResolveTable(options, aggregateType)]; + } + + List tables = [new(null, options.SchemaName, options.TableName)]; + + foreach (var overrideEntry in options.AggregateTableOverrides) + { + if (overrideEntry.Value is null) + continue; + + tables.Add( + new SqlServerAdminTableDescriptor( + overrideEntry.Key, + overrideEntry.Value.SchemaName ?? options.SchemaName, + overrideEntry.Value.TableName ?? options.TableName + ) + ); + } + + return tables; + } + + public static SqlServerAdminTableDescriptor ResolveTable(SqlServerEventStoreOptions options, string aggregateType) + { + ArgumentNullException.ThrowIfNull(options); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + + if (!options.AggregateTableOverrides.TryGetValue(aggregateType, out var overrideEntry) || overrideEntry is null) + { + return new SqlServerAdminTableDescriptor(aggregateType, options.SchemaName, options.TableName); + } + + // If an override exists for the aggregate type, use the override values (if provided) or fall back to the default options + return new SqlServerAdminTableDescriptor( + aggregateType, + overrideEntry.SchemaName ?? options.SchemaName, + overrideEntry.TableName ?? options.TableName + ); + } +} diff --git a/src/src/Admin.SqlServer/Properties/AssemblyInfo.cs b/src/src/Admin.SqlServer/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..08998b80 --- /dev/null +++ b/src/src/Admin.SqlServer/Properties/AssemblyInfo.cs @@ -0,0 +1,3 @@ +using System.Runtime.CompilerServices; + +[assembly: InternalsVisibleTo("Admin.SqlServer.UnitTests")] diff --git a/src/src/Admin.SqlServer/SqlServerAdminAggregateQueryService.cs b/src/src/Admin.SqlServer/SqlServerAdminAggregateQueryService.cs new file mode 100644 index 00000000..dc5c6861 --- /dev/null +++ b/src/src/Admin.SqlServer/SqlServerAdminAggregateQueryService.cs @@ -0,0 +1,119 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.SqlServer.Internal; +using Purview.EventSourcing.SqlServer.Events; +using Purview.EventSourcing.SqlServer.Events.EntityFramework; + +namespace Purview.EventSourcing.Admin.SqlServer; + +public sealed class SqlServerAdminAggregateQueryService(IOptions options) + : IAdminAggregateQueryService +{ + public async Task> SearchAsync( + AggregateSearchQuery query, + CancellationToken cancellationToken + ) + { + ArgumentNullException.ThrowIfNull(query); + + var page = Math.Max(1, query.Page); + var pageSize = Math.Max(1, query.PageSize); + + var candidates = new List(); + foreach (var table in SqlServerAdminTableResolver.ResolveTables(options.Value, query.AggregateType)) + { + await using var context = CreateContext(options.Value, table); + var rows = await BuildAggregateRowsAsync(context, table, query, cancellationToken); + candidates.AddRange(rows); + } + + var ordered = ApplySort(candidates, query.Sort).ToList(); + var totalCount = ordered.Count; + var pageItems = ordered.Skip((page - 1) * pageSize).Take(pageSize).ToList(); + + return new PagedResult(pageItems, page, pageSize, totalCount); + } + + public async Task GetAsync( + string aggregateType, + string aggregateId, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + var query = new AggregateSearchQuery(aggregateType, aggregateId, null, null, null, null, 1, 1); + var result = await SearchAsync(query, cancellationToken); + return result.Items.Count == 0 ? null : result.Items[0]; + } + + static async Task> BuildAggregateRowsAsync( + EventStoreDbContext context, + SqlServerAdminTableDescriptor table, + AggregateSearchQuery query, + CancellationToken cancellationToken + ) + { + var aggregateTypeFilter = table.AggregateTypeFilter; + var rows = context + .EventStoreEntities.AsNoTracking() + .Where(x => x.EntityType == 0 && (aggregateTypeFilter == null || x.AggregateType == aggregateTypeFilter)); + + if (!string.IsNullOrWhiteSpace(query.AggregateId)) + rows = rows.Where(x => x.AggregateId == query.AggregateId); + + if (query.IsDeleted is not null) + rows = rows.Where(x => x.IsDeleted == query.IsDeleted.Value); + + if (query.IsRestored == true) + rows = rows.Where(x => !x.IsDeleted); + + if (query.FromUtc is not null) + rows = rows.Where(x => x.Timestamp >= query.FromUtc.Value); + + if (query.ToUtc is not null) + rows = rows.Where(x => x.Timestamp <= query.ToUtc.Value); + + return await rows.Select(x => new AggregateSummaryResponse( + x.AggregateType, + x.AggregateId, + x.Version, + x.Timestamp, + x.Timestamp, + x.IsDeleted, + !x.IsDeleted + )) + .ToListAsync(cancellationToken); + } + + static IEnumerable ApplySort(IEnumerable rows, string sort) + { + var descending = sort.Contains("desc", StringComparison.OrdinalIgnoreCase); + + return sort switch + { + "AggregateId asc" => rows.OrderBy(x => x.AggregateId), + "AggregateId desc" => rows.OrderByDescending(x => x.AggregateId), + "CurrentVersion asc" => rows.OrderBy(x => x.CurrentVersion), + "CurrentVersion desc" => rows.OrderByDescending(x => x.CurrentVersion), + "CreatedUtc asc" => descending + ? rows.OrderByDescending(x => x.CreatedUtc) + : rows.OrderBy(x => x.CreatedUtc), + "CreatedUtc desc" => rows.OrderByDescending(x => x.CreatedUtc), + _ => descending + ? rows.OrderByDescending(x => x.LastUpdatedUtc).ThenByDescending(x => x.AggregateId) + : rows.OrderBy(x => x.LastUpdatedUtc).ThenBy(x => x.AggregateId), + }; + } + + static EventStoreDbContext CreateContext(SqlServerEventStoreOptions options, SqlServerAdminTableDescriptor table) + { + var builder = new DbContextOptionsBuilder(); + builder.UseSqlServer(options.ConnectionString); + return new EventStoreDbContext(builder.Options, table.SchemaName, table.TableName); + } +} diff --git a/src/src/Admin.SqlServer/SqlServerAdminEventQueryService.cs b/src/src/Admin.SqlServer/SqlServerAdminEventQueryService.cs new file mode 100644 index 00000000..52896068 --- /dev/null +++ b/src/src/Admin.SqlServer/SqlServerAdminEventQueryService.cs @@ -0,0 +1,98 @@ +using System.Text.Json; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Queries; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.SqlServer.Internal; +using Purview.EventSourcing.SqlServer.Events; +using Purview.EventSourcing.SqlServer.Events.EntityFramework; + +namespace Purview.EventSourcing.Admin.SqlServer; + +public sealed class SqlServerAdminEventQueryService(IOptions options) + : IAdminEventQueryService +{ + public async Task?> GetRangeAsync( + string aggregateType, + string aggregateId, + EventRangeQuery query, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + ArgumentNullException.ThrowIfNull(query); + + var table = SqlServerAdminTableResolver.ResolveTable(options.Value, aggregateType); + await using var context = CreateContext(options.Value, table); + var aggregateTypeFilter = table.AggregateTypeFilter; + + var rows = context + .EventStoreEntities.AsNoTracking() + .Where(x => + (aggregateTypeFilter == null || x.AggregateType == aggregateTypeFilter) + && x.AggregateId == aggregateId + && x.EntityType == 1 + ); + + if (query.VersionFrom is not null) + rows = rows.Where(x => x.Version >= query.VersionFrom.Value); + + if (query.VersionTo is not null) + rows = rows.Where(x => x.Version <= query.VersionTo.Value); + + if (query.TimeFromUtc is not null) + rows = rows.Where(x => x.Timestamp >= query.TimeFromUtc.Value); + + if (query.TimeToUtc is not null) + rows = rows.Where(x => x.Timestamp <= query.TimeToUtc.Value); + + var directionDesc = query.Sort.Contains("desc", StringComparison.OrdinalIgnoreCase); + rows = directionDesc ? rows.OrderByDescending(x => x.Version) : rows.OrderBy(x => x.Version); + + var totalCount = await rows.LongCountAsync(cancellationToken); + if (totalCount == 0) + return null; + + var page = Math.Max(1, query.Page); + var pageSize = Math.Max(1, query.PageSize); + var pageRows = await rows.Skip((page - 1) * pageSize).Take(pageSize).ToListAsync(cancellationToken); + + var items = pageRows + .Select(row => new EventEnvelopeResponse( + row.AggregateType, + row.AggregateId, + new EventMetadataResponse( + row.Version, + row.Timestamp, + row.EventType ?? string.Empty, + SchemaVersion: 1, + CorrelationId: null, + CausationId: null, + row.IdempotencyId, + UserId: null + ), + ParsePayload(row.Payload) + )) + .ToList(); + + return new PagedResult(items, page, pageSize, totalCount); + } + + static EventStoreDbContext CreateContext(SqlServerEventStoreOptions options, SqlServerAdminTableDescriptor table) + { + var builder = new DbContextOptionsBuilder(); + builder.UseSqlServer(options.ConnectionString); + return new EventStoreDbContext(builder.Options, table.SchemaName, table.TableName); + } + + static JsonElement ParsePayload(string? payload) + { + if (string.IsNullOrWhiteSpace(payload)) + return JsonDocument.Parse("null").RootElement.Clone(); + + using var document = JsonDocument.Parse(payload); + return document.RootElement.Clone(); + } +} diff --git a/src/src/Admin.SqlServer/SqlServerAdminProjectionService.cs b/src/src/Admin.SqlServer/SqlServerAdminProjectionService.cs new file mode 100644 index 00000000..cda659a8 --- /dev/null +++ b/src/src/Admin.SqlServer/SqlServerAdminProjectionService.cs @@ -0,0 +1,182 @@ +using System.Text.Json; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.SqlServer.Internal; +using Purview.EventSourcing.SqlServer.Events; +using Purview.EventSourcing.SqlServer.Events.EntityFramework; + +namespace Purview.EventSourcing.Admin.SqlServer; + +public sealed class SqlServerAdminProjectionService(IOptions options) + : IAdminProjectionService +{ + public async Task ProjectAtVersionAsync( + string aggregateType, + string aggregateId, + long targetVersion, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + if (targetVersion < 1) + throw new ArgumentOutOfRangeException(nameof(targetVersion), "Target version must be >= 1"); + + var table = SqlServerAdminTableResolver.ResolveTable(options.Value, aggregateType); + await using var context = CreateContext(options.Value, table); + + var appliedVersions = new List(); + var skippedVersions = new List(); + var projectedState = new Dictionary(); + + var rows = context + .EventStoreEntities.AsNoTracking() + .Where(x => + x.AggregateType == aggregateType + && x.AggregateId == aggregateId + && x.EntityType == 1 + && x.Version <= targetVersion + ) + .OrderBy(x => x.Version); + + var rowList = await rows.ToListAsync(cancellationToken); + + foreach (var row in rowList) + { + try + { + if (row.Payload != null && row.EventType != null) + { + using var _ = JsonDocument.Parse(row.Payload); + projectedState[$"event_{row.Version}"] = new { eventType = row.EventType, version = row.Version }; + appliedVersions.Add(row.Version); + } + else + { + skippedVersions.Add(row.Version); + } + } + catch (JsonException) + { + skippedVersions.Add(row.Version); + } + } + + if (rowList.Count == 0) + return null; + + var reason = + targetVersion > rowList.Last().Version + ? $"Events projected up to available version {rowList.Last().Version} (target was {targetVersion})" + : $"Events projected up to version {targetVersion}"; + + var finalState = JsonDocument.Parse(JsonSerializer.Serialize(projectedState)).RootElement.Clone(); + + return new ProjectionResponse( + aggregateType, + aggregateId, + rowList.Last().Version, + null, + finalState, + new ProjectionProvenance( + appliedVersions.Count, + skippedVersions.Count, + appliedVersions.AsReadOnly(), + skippedVersions.AsReadOnly(), + reason + ) + ); + } + + public async Task ProjectAtTimeAsync( + string aggregateType, + string aggregateId, + DateTimeOffset targetUtc, + CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateType); + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId); + + var table = SqlServerAdminTableResolver.ResolveTable(options.Value, aggregateType); + await using var context = CreateContext(options.Value, table); + + var appliedVersions = new List(); + var skippedVersions = new List(); + var projectedState = new Dictionary(); + + var rows = context + .EventStoreEntities.AsNoTracking() + .Where(x => + x.AggregateType == aggregateType + && x.AggregateId == aggregateId + && x.EntityType == 1 + && x.Timestamp <= targetUtc + ) + .OrderBy(x => x.Version); + + var rowList = await rows.ToListAsync(cancellationToken); + + foreach (var row in rowList) + { + try + { + if (row.Payload != null && row.EventType != null) + { + using var _ = JsonDocument.Parse(row.Payload); + projectedState[$"event_{row.Version}"] = new + { + eventType = row.EventType, + version = row.Version, + timestamp = row.Timestamp, + }; + appliedVersions.Add(row.Version); + } + else + { + skippedVersions.Add(row.Version); + } + } + catch (JsonException) + { + skippedVersions.Add(row.Version); + } + } + + if (rowList.Count == 0) + return null; + + var latestTimestamp = rowList.Last().Timestamp; + var reason = + latestTimestamp > targetUtc + ? $"Events projected up to available timestamp {latestTimestamp:O} (target was {targetUtc:O})" + : $"Events projected up to timestamp {targetUtc:O}"; + + var finalState = JsonDocument.Parse(JsonSerializer.Serialize(projectedState)).RootElement.Clone(); + + return new ProjectionResponse( + aggregateType, + aggregateId, + rowList.Last().Version, + latestTimestamp, + finalState, + new ProjectionProvenance( + appliedVersions.Count, + skippedVersions.Count, + appliedVersions.AsReadOnly(), + skippedVersions.AsReadOnly(), + reason + ) + ); + } + + static EventStoreDbContext CreateContext(SqlServerEventStoreOptions options, SqlServerAdminTableDescriptor table) + { + var builder = new DbContextOptionsBuilder(); + builder.UseSqlServer(options.ConnectionString); + return new EventStoreDbContext(builder.Options, table.SchemaName, table.TableName); + } +} diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/AggregateVersionData.cs b/src/src/AzureStorage/AggregateVersionData.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/AggregateVersionData.cs rename to src/src/AzureStorage/AggregateVersionData.cs diff --git a/src/src/EventSourcing.AzureStorage/EventSourcing.AzureStorage.csproj b/src/src/AzureStorage/AzureStorage.csproj similarity index 66% rename from src/src/EventSourcing.AzureStorage/EventSourcing.AzureStorage.csproj rename to src/src/AzureStorage/AzureStorage.csproj index 8d8ce2fb..69a81c8a 100644 --- a/src/src/EventSourcing.AzureStorage/EventSourcing.AzureStorage.csproj +++ b/src/src/AzureStorage/AzureStorage.csproj @@ -1,22 +1,12 @@  - - Purview.EventSourcing - - true Purview Event Store for Azure Table and Blob Storage Azure Table Storage and Blob Storage event store provider for Purview EventSourcing, including snapshot and large-payload support. + $(PackageTags);purview;dotnet;event-sourcing;event-store;azure-storage;azure-table-storage;azure-blob-storage;tables;blobs; Purview.EventSourcing.AzureStorage - $(PackageTags);purview;kjldev;dotnet;event-sourcing;event-store;azure-storage;azure-table-storage;azure-blob-storage;tables;blobs; - - - <_Parameter1>EventSourcing.UnitTests - - - @@ -27,5 +17,9 @@ + diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/AzureStorageEventStoreOptions.cs b/src/src/AzureStorage/AzureStorageEventStoreOptions.cs similarity index 93% rename from src/src/EventSourcing.AzureStorage/AzureStorage/AzureStorageEventStoreOptions.cs rename to src/src/AzureStorage/AzureStorageEventStoreOptions.cs index 13a23097..0f04a908 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/AzureStorageEventStoreOptions.cs +++ b/src/src/AzureStorage/AzureStorageEventStoreOptions.cs @@ -68,10 +68,10 @@ public sealed class AzureStorageEventStoreOptions /// /// Gets/ sets a value indicating how the - /// uses the during it's operations. Defaults to . + /// uses the during it's operations. Defaults to . /// - [DefaultValue(EventStoreCachingOptions.GetAndStore)] - public EventStoreCachingOptions CacheMode { get; set; } = EventStoreCachingOptions.GetAndStore; + [DefaultValue(SnapshotCachingOptions.GetAndStore)] + public SnapshotCachingOptions CacheMode { get; set; } = SnapshotCachingOptions.GetAndStore; public TimeSpan DefaultCacheSlidingDuration { get; set; } = TimeSpan.FromMinutes(60); diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Entities/EventEntity.cs b/src/src/AzureStorage/Entities/EventEntity.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Entities/EventEntity.cs rename to src/src/AzureStorage/Entities/EventEntity.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Entities/IdempotencyMarkerEntity.cs b/src/src/AzureStorage/Entities/IdempotencyMarkerEntity.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Entities/IdempotencyMarkerEntity.cs rename to src/src/AzureStorage/Entities/IdempotencyMarkerEntity.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Entities/IdempotencyMarkerEventPayload.cs b/src/src/AzureStorage/Entities/IdempotencyMarkerEventPayload.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Entities/IdempotencyMarkerEventPayload.cs rename to src/src/AzureStorage/Entities/IdempotencyMarkerEventPayload.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Entities/StreamVersionEntity.cs b/src/src/AzureStorage/Entities/StreamVersionEntity.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Entities/StreamVersionEntity.cs rename to src/src/AzureStorage/Entities/StreamVersionEntity.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Events/LargeEventPointerEvent.cs b/src/src/AzureStorage/Events/LargeEventPointerEvent.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Events/LargeEventPointerEvent.cs rename to src/src/AzureStorage/Events/LargeEventPointerEvent.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateAlreadyDeletedException.cs b/src/src/AzureStorage/Exceptions/AggregateAlreadyDeletedException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateAlreadyDeletedException.cs rename to src/src/AzureStorage/Exceptions/AggregateAlreadyDeletedException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateDeletedException.cs b/src/src/AzureStorage/Exceptions/AggregateDeletedException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateDeletedException.cs rename to src/src/AzureStorage/Exceptions/AggregateDeletedException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateIsDeletedException.cs b/src/src/AzureStorage/Exceptions/AggregateIsDeletedException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateIsDeletedException.cs rename to src/src/AzureStorage/Exceptions/AggregateIsDeletedException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateLockedException.cs b/src/src/AzureStorage/Exceptions/AggregateLockedException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateLockedException.cs rename to src/src/AzureStorage/Exceptions/AggregateLockedException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateNotDeletedException.cs b/src/src/AzureStorage/Exceptions/AggregateNotDeletedException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateNotDeletedException.cs rename to src/src/AzureStorage/Exceptions/AggregateNotDeletedException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateStreamVersionMissingException.cs b/src/src/AzureStorage/Exceptions/AggregateStreamVersionMissingException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregateStreamVersionMissingException.cs rename to src/src/AzureStorage/Exceptions/AggregateStreamVersionMissingException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregatedNotAlreadyDeletedException.cs b/src/src/AzureStorage/Exceptions/AggregatedNotAlreadyDeletedException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/AggregatedNotAlreadyDeletedException.cs rename to src/src/AzureStorage/Exceptions/AggregatedNotAlreadyDeletedException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/CommitException.cs b/src/src/AzureStorage/Exceptions/CommitException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/CommitException.cs rename to src/src/AzureStorage/Exceptions/CommitException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/ConcurrencyException.cs b/src/src/AzureStorage/Exceptions/ConcurrencyException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/ConcurrencyException.cs rename to src/src/AzureStorage/Exceptions/ConcurrencyException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/MissingAggregateIdException.cs b/src/src/AzureStorage/Exceptions/MissingAggregateIdException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/Exceptions/MissingAggregateIdException.cs rename to src/src/AzureStorage/Exceptions/MissingAggregateIdException.cs diff --git a/src/src/EventSourcing.AzureStorage/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs b/src/src/AzureStorage/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs similarity index 58% rename from src/src/EventSourcing.AzureStorage/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs rename to src/src/AzureStorage/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs index 361eb572..ef9d1772 100644 --- a/src/src/EventSourcing.AzureStorage/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs +++ b/src/src/AzureStorage/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs @@ -1,6 +1,6 @@ -using System.ComponentModel; +using System.ComponentModel; +using System.ComponentModel.DataAnnotations; using Microsoft.Extensions.Configuration; -using Purview.EventSourcing.AzureStorage; using Purview.EventSourcing.Internal; namespace Microsoft.Extensions.DependencyInjection; @@ -10,7 +10,10 @@ public static class ServiceCollectionExtensions { extension(IServiceCollection services) { - public IServiceCollection AddAzureTableEventStore() + public IServiceCollection AddAzureStorageEventStore() => + services.AddAzureStorageEventStore(connectionStringName: null); + + public IServiceCollection AddAzureStorageEventStore(string? connectionStringName) { services.AddEventSourcing(); @@ -30,14 +33,24 @@ public IServiceCollection AddAzureTableEventStore() if (string.IsNullOrWhiteSpace(options.ConnectionString)) { - options.ConnectionString = - configuration.GetConnectionString("EventStore_AzureStorage") - ?? configuration.GetConnectionString("AzureStorage") - // This will get picked up by the validation. - ?? default!; + options.ConnectionString = configuration.GetRequiredConnectionString([ + connectionStringName, + "EventStore_AzureStorage", + "AzureStorage", + ]); } } ) + .Validate( + static options => + Validator.TryValidateObject( + options, + new ValidationContext(options), + validationResults: null, + validateAllProperties: true + ), + $"{nameof(AzureStorageEventStoreOptions)} is invalid." + ) .ValidateOnStart(); return services; diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/ITableEventStore.cs b/src/src/AzureStorage/ITableEventStore.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/ITableEventStore.cs rename to src/src/AzureStorage/ITableEventStore.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/ITableEventStoreStorageNameBuilder.cs b/src/src/AzureStorage/ITableEventStoreStorageNameBuilder.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/ITableEventStoreStorageNameBuilder.cs rename to src/src/AzureStorage/ITableEventStoreStorageNameBuilder.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/ITableEventStoreTelemetry.cs b/src/src/AzureStorage/ITableEventStoreTelemetry.cs similarity index 97% rename from src/src/EventSourcing.AzureStorage/AzureStorage/ITableEventStoreTelemetry.cs rename to src/src/AzureStorage/ITableEventStoreTelemetry.cs index 53dc167a..55681c61 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/ITableEventStoreTelemetry.cs +++ b/src/src/AzureStorage/ITableEventStoreTelemetry.cs @@ -125,7 +125,11 @@ string blobEventTypeName void GetAggregateFailed(string aggregateId, string aggregateTypeFullName, Exception exception); [Log(LogLevel.Warning)] - void StreamVersionExpectedToExistButNotFound(string aggregateId); + void StreamVersionExpectedToExistButNotFound( + string aggregateId, + string aggregateTypeName, + string aggregateTypeFullName + ); [Log(LogLevel.Debug)] void StreamVersionNotFound(string aggregateId); diff --git a/src/src/AzureStorage/Properties/AssemblyInfo.cs b/src/src/AzureStorage/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..caa8d160 --- /dev/null +++ b/src/src/AzureStorage/Properties/AssemblyInfo.cs @@ -0,0 +1,8 @@ +using System.Runtime.CompilerServices; +using Purview.Telemetry; + +[assembly: InternalsVisibleTo("SharedTestingFramework")] +[assembly: InternalsVisibleTo("EventSourcing.UnitTests")] + +[assembly: ActivitySourceGeneration("Purview.EventSourcing.AzureStorage")] +[assembly: MeterGeneration("Purview.EventSourcing.AzureStorage")] diff --git a/src/src/EventSourcing.AzureStorage/README.md b/src/src/AzureStorage/README.md similarity index 65% rename from src/src/EventSourcing.AzureStorage/README.md rename to src/src/AzureStorage/README.md index d6da5444..245d0a18 100644 --- a/src/src/EventSourcing.AzureStorage/README.md +++ b/src/src/AzureStorage/README.md @@ -11,7 +11,7 @@ dotnet add package Purview.EventSourcing.AzureStorage ## Register the provider ```csharp -builder.Services.AddAzureTableEventStore(); +builder.Services.AddAzureStorageEventStore(); ``` ## What it provides @@ -22,4 +22,5 @@ builder.Services.AddAzureTableEventStore(); ## Documentation -- Repository README: https://github.com/kjldev/purview-eventsourcing/blob/main/README.md +- [Repository README](https://github.com/kjldev/purview-eventsourcing/blob/main/README.md) +- [Provider feature matrix](https://github.com/kjldev/purview-eventsourcing/blob/main/docs/wiki/Provider-Feature-Matrix.md) diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Blob/AzureBlobClient.cs b/src/src/AzureStorage/StorageClients/Blob/AzureBlobClient.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Blob/AzureBlobClient.cs rename to src/src/AzureStorage/StorageClients/Blob/AzureBlobClient.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Table/AzureTableClient.cs b/src/src/AzureStorage/StorageClients/Table/AzureTableClient.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Table/AzureTableClient.cs rename to src/src/AzureStorage/StorageClients/Table/AzureTableClient.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Table/BatchOperation.cs b/src/src/AzureStorage/StorageClients/Table/BatchOperation.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Table/BatchOperation.cs rename to src/src/AzureStorage/StorageClients/Table/BatchOperation.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Table/BatchOperationResult.cs b/src/src/AzureStorage/StorageClients/Table/BatchOperationResult.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Table/BatchOperationResult.cs rename to src/src/AzureStorage/StorageClients/Table/BatchOperationResult.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Table/InvalidPartitionKeyException.cs b/src/src/AzureStorage/StorageClients/Table/InvalidPartitionKeyException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Table/InvalidPartitionKeyException.cs rename to src/src/AzureStorage/StorageClients/Table/InvalidPartitionKeyException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Table/TableOperationException.cs b/src/src/AzureStorage/StorageClients/Table/TableOperationException.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/StorageClients/Table/TableOperationException.cs rename to src/src/AzureStorage/StorageClients/Table/TableOperationException.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.CreateAsync.cs b/src/src/AzureStorage/TableEventStore.CreateAsync.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.CreateAsync.cs rename to src/src/AzureStorage/TableEventStore.CreateAsync.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.DeleteAsync.cs b/src/src/AzureStorage/TableEventStore.DeleteAsync.cs similarity index 99% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.DeleteAsync.cs rename to src/src/AzureStorage/TableEventStore.DeleteAsync.cs index d05ff569..be729bf8 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.DeleteAsync.cs +++ b/src/src/AzureStorage/TableEventStore.DeleteAsync.cs @@ -19,7 +19,7 @@ public async Task DeleteAsync( if (aggregate.Details.IsDeleted) throw AggregateIsDeletedException(aggregate.Id()); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); if (aggregate.IsNew()) return false; diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.ExceptionHelpers.cs b/src/src/AzureStorage/TableEventStore.ExceptionHelpers.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.ExceptionHelpers.cs rename to src/src/AzureStorage/TableEventStore.ExceptionHelpers.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.ExistsAsync.cs b/src/src/AzureStorage/TableEventStore.ExistsAsync.cs similarity index 94% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.ExistsAsync.cs rename to src/src/AzureStorage/TableEventStore.ExistsAsync.cs index 13f2d785..850aed8a 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.ExistsAsync.cs +++ b/src/src/AzureStorage/TableEventStore.ExistsAsync.cs @@ -8,7 +8,7 @@ public async Task ExistsAsync(string aggregateId, CancellationToken var streamVersion = await GetStreamVersionAsync(aggregateId, false, cancellationToken); return streamVersion == null - ? ExistsState.DoesNotExists + ? ExistsState.DoesNotExist : new ExistsState { Status = streamVersion.IsDeleted ? ExistsStatus.ExistsInDeletedState : ExistsStatus.Exists, diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetAsync.cs b/src/src/AzureStorage/TableEventStore.GetAsync.cs similarity index 98% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetAsync.cs rename to src/src/AzureStorage/TableEventStore.GetAsync.cs index 8c521d5b..22f0f4ef 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetAsync.cs +++ b/src/src/AzureStorage/TableEventStore.GetAsync.cs @@ -21,13 +21,13 @@ partial class TableEventStore { ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); _eventStoreTelemetry.GetAggregateStart(aggregateId, _aggregateTypeFullName); var getStopwatch = System.Diagnostics.Stopwatch.StartNew(); try { - var aggregate = operationContext.CacheMode.HasFlag(EventStoreCachingOptions.GetFromCache) + var aggregate = operationContext.SnapshotCacheMode.HasFlag(SnapshotCachingOptions.GetFromCache) ? await GetFromCacheAsync(aggregateId, cancellationToken) : null; diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetAtAsync.cs b/src/src/AzureStorage/TableEventStore.GetAtAsync.cs similarity index 99% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetAtAsync.cs rename to src/src/AzureStorage/TableEventStore.GetAtAsync.cs index 05d5833d..732b7ceb 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetAtAsync.cs +++ b/src/src/AzureStorage/TableEventStore.GetAtAsync.cs @@ -13,7 +13,7 @@ partial class TableEventStore { ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); _eventStoreTelemetry.GetAggregateAtSpecificVersionStart(aggregateId, version, _aggregateTypeFullName); var getStopwatch = Stopwatch.StartNew(); diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetDeletedAsync.cs b/src/src/AzureStorage/TableEventStore.GetDeletedAsync.cs similarity index 79% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetDeletedAsync.cs rename to src/src/AzureStorage/TableEventStore.GetDeletedAsync.cs index 84f3da0f..9490142d 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetDeletedAsync.cs +++ b/src/src/AzureStorage/TableEventStore.GetDeletedAsync.cs @@ -6,7 +6,7 @@ partial class TableEventStore { var aggregate = await GetCoreAsync( aggregateId, - new() { CacheMode = EventStoreCachingOptions.None, DeleteMode = DeleteHandlingMode.ReturnsAggregate }, + new() { SnapshotCacheMode = SnapshotCachingOptions.None, DeleteMode = DeleteHandlingMode.ReturnsAggregate }, cancellationToken ); diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetEventRangeAsync.cs b/src/src/AzureStorage/TableEventStore.GetEventRangeAsync.cs similarity index 96% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetEventRangeAsync.cs rename to src/src/AzureStorage/TableEventStore.GetEventRangeAsync.cs index 75213787..5460b409 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetEventRangeAsync.cs +++ b/src/src/AzureStorage/TableEventStore.GetEventRangeAsync.cs @@ -100,6 +100,11 @@ static EventUnknown ReturnUnknownEvent(EventEntity eventEntity, int aggregateVer Type.GetType(eventType, throwOnError: false) ?? throw new ApplicationException($"Unable to load event type: {eventType}"); var @event = DeserializeEvent(eventEntity.Payload, runtimeEventType); + + // Apply upcasting chain when a registry is available. + if (@event != null && _eventUpcasterRegistry?.CanUpcast(@event) == true) + @event = _eventUpcasterRegistry.Upcast(@event); + if (@event is Events.LargeEventPointerEvent blobPointer) { var blobName = GenerateEventBlobName(eventEntity.PartitionKey, eventEntity.RowKey); diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetOrCreateAsync.cs b/src/src/AzureStorage/TableEventStore.GetOrCreateAsync.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.GetOrCreateAsync.cs rename to src/src/AzureStorage/TableEventStore.GetOrCreateAsync.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.IsDeletedAsync.cs b/src/src/AzureStorage/TableEventStore.IsDeletedAsync.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.IsDeletedAsync.cs rename to src/src/AzureStorage/TableEventStore.IsDeletedAsync.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.RestoreAsync.cs b/src/src/AzureStorage/TableEventStore.RestoreAsync.cs similarity index 99% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.RestoreAsync.cs rename to src/src/AzureStorage/TableEventStore.RestoreAsync.cs index db9822e9..c99f0037 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.RestoreAsync.cs +++ b/src/src/AzureStorage/TableEventStore.RestoreAsync.cs @@ -16,7 +16,7 @@ public async Task RestoreAsync( if (!aggregate.Details.IsDeleted) throw AggregateNotDeletedException(aggregate.Id()); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); var restoreAggregateEvent = new Restored { diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.SaveAsync.cs b/src/src/AzureStorage/TableEventStore.SaveAsync.cs similarity index 98% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.SaveAsync.cs rename to src/src/AzureStorage/TableEventStore.SaveAsync.cs index 06ca33e2..4c8a614f 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.SaveAsync.cs +++ b/src/src/AzureStorage/TableEventStore.SaveAsync.cs @@ -4,7 +4,6 @@ using System.Security.Claims; using System.Text; using Azure; -using FluentValidation.Results; using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Aggregates.Snapshotting; @@ -13,6 +12,7 @@ using Purview.EventSourcing.AzureStorage.StorageClients.Table; using Purview.EventSourcing.Serialization; using Purview.EventSourcing.Services; +using Purview.EventSourcing.Validation; namespace Purview.EventSourcing.AzureStorage; @@ -32,7 +32,7 @@ async Task> SaveCoreAsync( params IEvent[] additionalEvents ) { - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); FulfilRequirements(aggregate); @@ -256,6 +256,8 @@ bool ShouldSnapShot(T aggregate, IEvent[] events, EventStoreOperationContext? op if (aggregate.Details.IsDeleted || events.OfType().Any()) return true; + // If the aggregate hasn't been deleted or restored, run the strategy to + // find out if we should snapshot or not. return SnapshotStrategyResolver.ShouldSnapshot( aggregate, events.Length, diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.Serialization.cs b/src/src/AzureStorage/TableEventStore.Serialization.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.Serialization.cs rename to src/src/AzureStorage/TableEventStore.Serialization.cs diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.cs b/src/src/AzureStorage/TableEventStore.cs similarity index 93% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.cs rename to src/src/AzureStorage/TableEventStore.cs index f64ec197..4199eff4 100644 --- a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStore.cs +++ b/src/src/AzureStorage/TableEventStore.cs @@ -4,6 +4,7 @@ using Microsoft.Extensions.Caching.Distributed; using Microsoft.Extensions.Options; using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events.Upcasting; using Purview.EventSourcing.Aggregates.Snapshotting; using Purview.EventSourcing.AzureStorage.Entities; using Purview.EventSourcing.Services; @@ -29,6 +30,7 @@ public sealed partial class TableEventStore : ITableEventStore, IAsyncDisp readonly IAggregateRequirementsManager _aggregateRequirementsManager; readonly ISnapshotStrategy _snapshotStrategy; readonly ISnapshotStrategySelector? _snapshotStrategySelector; + readonly IEventUpcasterRegistry? _eventUpcasterRegistry; readonly string _aggregateTypeFullName; readonly string _aggregateTypeShortName; @@ -40,16 +42,17 @@ public TableEventStore( ITableEventStoreTelemetry eventStoreTelemetry, ChangeFeed.IAggregateChangeFeedNotifier aggregateChangeNotifier, IAggregateRequirementsManager aggregateRequirementsManager, - FluentValidation.IValidator? validator = null, + IAggregateValidator? validator = null, ITableEventStoreStorageNameBuilder? nameBuilder = null, IAggregateIdFactory? aggregateIdFactory = null, ISnapshotStrategy? snapshotStrategy = null, - ISnapshotStrategySelector? snapshotStrategySelector = null + ISnapshotStrategySelector? snapshotStrategySelector = null, + IEventUpcasterRegistry? eventUpcasterRegistry = null ) { _eventNameMapper = eventNameMapper; _eventStoreOptions = azureStorageOptions; - _validator = AggregateValidatorAdapter.Adapt(validator); + _validator = validator; _aggregateIdFactory = aggregateIdFactory; _distributedCache = distributedCache; _eventStoreTelemetry = eventStoreTelemetry; @@ -57,6 +60,7 @@ public TableEventStore( _aggregateRequirementsManager = aggregateRequirementsManager; _snapshotStrategy = snapshotStrategy ?? new IntervalSnapshotStrategy(); _snapshotStrategySelector = snapshotStrategySelector; + _eventUpcasterRegistry = eventUpcasterRegistry; var name = typeof(T).Name; @@ -104,7 +108,7 @@ async Task UpdateCacheAsync( await _distributedCache.RemoveAsync(cacheKey, cancellationToken); else { - if (!_eventStoreOptions.Value.CacheMode.HasFlag(EventStoreCachingOptions.StoreInCache)) + if (!_eventStoreOptions.Value.CacheMode.HasFlag(SnapshotCachingOptions.StoreInCache)) return; var data = SerializeSnapshot(aggregate); @@ -169,7 +173,11 @@ CancellationToken cancellationToken if (result == null) { if (expectedToExist) - _eventStoreTelemetry.StreamVersionExpectedToExistButNotFound(aggregateId); + _eventStoreTelemetry.StreamVersionExpectedToExistButNotFound( + aggregateId, + _aggregateTypeShortName, + _aggregateTypeFullName + ); else _eventStoreTelemetry.StreamVersionNotFound(aggregateId); } diff --git a/src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStoreConstants.cs b/src/src/AzureStorage/TableEventStoreConstants.cs similarity index 100% rename from src/src/EventSourcing.AzureStorage/AzureStorage/TableEventStoreConstants.cs rename to src/src/AzureStorage/TableEventStoreConstants.cs diff --git a/src/src/EventSourcing.CosmosDb/EventSourcing.CosmosDb.csproj b/src/src/CosmosDb/CosmosDb.csproj similarity index 66% rename from src/src/EventSourcing.CosmosDb/EventSourcing.CosmosDb.csproj rename to src/src/CosmosDb/CosmosDb.csproj index e4992521..a8601e11 100644 --- a/src/src/EventSourcing.CosmosDb/EventSourcing.CosmosDb.csproj +++ b/src/src/CosmosDb/CosmosDb.csproj @@ -1,24 +1,18 @@  - - Purview.EventSourcing - - true Purview Queryable Snapshot Store for Azure Cosmos DB Azure Cosmos DB queryable snapshot storage provider for Purview EventSourcing. + $(PackageTags);purview;dotnet;event-sourcing;event-store;queryable-store;snapshot;azure-cosmosdb;cosmosdb; Purview.EventSourcing.CosmosDb - $(PackageTags);purview;kjldev;dotnet;event-sourcing;event-store;queryable-store;snapshot;azure-cosmosdb;cosmosdb; - - - <_Parameter1>EventSourcing.UnitTests - - - + diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbClient.CosmosDbSpecific.cs b/src/src/CosmosDb/CosmosDbClient.CosmosDbSpecific.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbClient.CosmosDbSpecific.cs rename to src/src/CosmosDb/CosmosDbClient.CosmosDbSpecific.cs diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbClient.CosmosSystemTextJsonSerializer.cs b/src/src/CosmosDb/CosmosDbClient.CosmosSystemTextJsonSerializer.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbClient.CosmosSystemTextJsonSerializer.cs rename to src/src/CosmosDb/CosmosDbClient.CosmosSystemTextJsonSerializer.cs diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbClient.cs b/src/src/CosmosDb/CosmosDbClient.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbClient.cs rename to src/src/CosmosDb/CosmosDbClient.cs diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbIndexOptions.cs b/src/src/CosmosDb/CosmosDbIndexOptions.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbIndexOptions.cs rename to src/src/CosmosDb/CosmosDbIndexOptions.cs diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbOptions.cs b/src/src/CosmosDb/CosmosDbOptions.cs similarity index 95% rename from src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbOptions.cs rename to src/src/CosmosDb/CosmosDbOptions.cs index 916a51ea..bf971e9a 100644 --- a/src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbOptions.cs +++ b/src/src/CosmosDb/CosmosDbOptions.cs @@ -20,9 +20,11 @@ public class CosmosDbOptions public string ConnectionString { get; set; } = default!; [Required] + [RegularExpression(@"^[\w\-.]+$")] public string Database { get; set; } = default!; [Required] + [RegularExpression(@"^[\w\-.]+$")] public string Container { get; set; } = default!; [Range(1, 120000)] diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbUtilities.cs b/src/src/CosmosDb/CosmosDbUtilities.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/CosmosDbUtilities.cs rename to src/src/CosmosDb/CosmosDbUtilities.cs diff --git a/src/src/EventSourcing.CosmosDb/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs b/src/src/CosmosDb/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs similarity index 90% rename from src/src/EventSourcing.CosmosDb/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs rename to src/src/CosmosDb/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs index 602a4f81..3e4b1969 100644 --- a/src/src/EventSourcing.CosmosDb/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs +++ b/src/src/CosmosDb/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs @@ -5,14 +5,14 @@ using Purview.EventSourcing.CosmosDb.Snapshot; using Purview.EventSourcing.CosmosDb.Snapshots; -namespace Microsoft.Extensions.DependencyInjections; +namespace Microsoft.Extensions.DependencyInjection; [EditorBrowsable(EditorBrowsableState.Never)] public static class ServiceCollectionExtensions { extension(IServiceCollection services) { - public IServiceCollection AddCosmosDbQueryableEventStore(bool registerAsIEventStore = false) + public IServiceCollection AddCosmosDbSnapshotQueryableEventStore(bool registerAsIEventStore = false) { services.AddEventSourcing(); diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/ICosmosDbClientExtensions.cs b/src/src/CosmosDb/ICosmosDbClientExtensions.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/ICosmosDbClientExtensions.cs rename to src/src/CosmosDb/ICosmosDbClientExtensions.cs diff --git a/src/src/CosmosDb/Properties/AssemblyInfo.cs b/src/src/CosmosDb/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..cb97842a --- /dev/null +++ b/src/src/CosmosDb/Properties/AssemblyInfo.cs @@ -0,0 +1,8 @@ +using System.Runtime.CompilerServices; +using Purview.Telemetry; + +[assembly: InternalsVisibleTo("SharedTestingFramework")] +[assembly: InternalsVisibleTo("EventSourcing.UnitTests")] + +[assembly: ActivitySourceGeneration("Purview.EventSourcing.CosmosDb")] +[assembly: MeterGeneration("Purview.EventSourcing.CosmosDb")] diff --git a/src/src/EventSourcing.CosmosDb/README.md b/src/src/CosmosDb/README.md similarity index 53% rename from src/src/EventSourcing.CosmosDb/README.md rename to src/src/CosmosDb/README.md index 5078ce25..08ab9f96 100644 --- a/src/src/EventSourcing.CosmosDb/README.md +++ b/src/src/CosmosDb/README.md @@ -11,7 +11,7 @@ dotnet add package Purview.EventSourcing.CosmosDb ## Register the provider ```csharp -builder.Services.AddCosmosDbQueryableEventStore(); +builder.Services.AddCosmosDbSnapshotQueryableEventStore(); ``` ## What it provides @@ -22,4 +22,7 @@ builder.Services.AddCosmosDbQueryableEventStore(); ## Documentation -- Repository README: https://github.com/kjldev/purview-eventsourcing/blob/main/README.md +- [Repository README](https://github.com/kjldev/purview-eventsourcing/blob/main/README.md) +- [Provider feature matrix](https://github.com/kjldev/purview-eventsourcing/blob/main/docs/wiki/Provider-Feature-Matrix.md) + +Snapshot query translation capabilities differ by provider; consult the provider matrix before relying on deep nested predicates for complex value-object shapes. diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/CosmosDbEventStoreOptions.cs b/src/src/CosmosDb/Snapshots/CosmosDbEventStoreOptions.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/CosmosDbEventStoreOptions.cs rename to src/src/CosmosDb/Snapshots/CosmosDbEventStoreOptions.cs diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.EventStore.cs b/src/src/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.EventStore.cs similarity index 91% rename from src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.EventStore.cs rename to src/src/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.EventStore.cs index 45dbfdb8..f2cf90aa 100644 --- a/src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.EventStore.cs +++ b/src/src/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.EventStore.cs @@ -1,4 +1,5 @@ using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Aggregates.Snapshotting; namespace Purview.EventSourcing.CosmosDb.Snapshot; @@ -98,4 +99,11 @@ public Task ExistsAsync(string aggregateId, CancellationToken cance _eventStore.ExistsAsync(aggregateId, cancellationToken); public T FulfilRequirements(T aggregate) => _eventStore.FulfilRequirements(aggregate); + + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) => _eventStore.GetEventRangeAsync(aggregateId, versionFrom, versionTo, cancellationToken); } diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.Query.cs b/src/src/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.Query.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.Query.cs rename to src/src/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.Query.cs diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.cs b/src/src/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.cs rename to src/src/CosmosDb/Snapshots/CosmosDbSnapshotEventStore.cs diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/ICosmosDbSnapshotEventStore.cs b/src/src/CosmosDb/Snapshots/ICosmosDbSnapshotEventStore.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/ICosmosDbSnapshotEventStore.cs rename to src/src/CosmosDb/Snapshots/ICosmosDbSnapshotEventStore.cs diff --git a/src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/ICosmosDbSnapshotEventStoreTelemetry.cs b/src/src/CosmosDb/Snapshots/ICosmosDbSnapshotEventStoreTelemetry.cs similarity index 100% rename from src/src/EventSourcing.CosmosDb/CosmosDb/Snapshots/ICosmosDbSnapshotEventStoreTelemetry.cs rename to src/src/CosmosDb/Snapshots/ICosmosDbSnapshotEventStoreTelemetry.cs diff --git a/src/src/EventSourcing.Samples.AppHost/EventSourcing.Samples.AppHost.csproj b/src/src/EventSourcing.Samples.AppHost/EventSourcing.Samples.AppHost.csproj deleted file mode 100644 index 8c38a918..00000000 --- a/src/src/EventSourcing.Samples.AppHost/EventSourcing.Samples.AppHost.csproj +++ /dev/null @@ -1,12 +0,0 @@ - - - - - - - - - - - - diff --git a/src/src/EventSourcing.Samples.AppHost/Program.cs b/src/src/EventSourcing.Samples.AppHost/Program.cs deleted file mode 100644 index c3223089..00000000 --- a/src/src/EventSourcing.Samples.AppHost/Program.cs +++ /dev/null @@ -1,53 +0,0 @@ -using Microsoft.Extensions.DependencyInjection; - -var builder = DistributedApplication.CreateBuilder(args); - -var databaseName = - args?.FirstOrDefault(static s => s.StartsWith("--DatabaseName=", StringComparison.OrdinalIgnoreCase)) - ?.Split('=') - .LastOrDefault() - ?? "EventSourcingSampleDb"; - -var isTesting = args?.FirstOrDefault(static s => s.Equals("--IsTestRun", StringComparison.OrdinalIgnoreCase)) != null; - -if (!isTesting) - builder.AddAspireC4(); - -var sqlPassword = builder.AddParameter("sql-password", "PaSsw0rd!!1!", secret: true); -var sql = builder.AddSqlServer("sql", password: sqlPassword).WithImageTag("2025-latest"); -var db = sql.AddDatabase("eventstore-sqlserver", databaseName); - -var blobs = builder - .AddAzureStorage("storage") - .RunAsEmulator(e => - { - if (!isTesting) - e.WithDataVolume("eventsourcing-sample-azurite-data"); - }) - .AddBlobs(isTesting ? $"ess-{Guid.NewGuid():N}"[..8] : "blob-storage"); - -IResourceBuilder? redis = null; -if (!isTesting) -{ - redis = builder.AddRedis("redis"); - redis.WithRedisInsight(c => c.WithParentRelationship(redis)); - - sql.WithDataVolume("eventsourcing-sample-sql-data"); -} - -var web = builder - .AddProject("web") - .WithReference(db) - .WaitFor(db) - .WithReference(blobs) - .WaitFor(blobs) - .WithExternalHttpEndpoints(); - -if (!isTesting) -{ - web.WithReference(redis!).WaitFor(redis!); -} - -var app = builder.Build(); - -await app.RunAsync(); diff --git a/src/src/EventSourcing.Samples.AppHost/likec4/gen/model.gen.c4 b/src/src/EventSourcing.Samples.AppHost/likec4/gen/model.gen.c4 deleted file mode 100644 index ba86905f..00000000 --- a/src/src/EventSourcing.Samples.AppHost/likec4/gen/model.gen.c4 +++ /dev/null @@ -1,145 +0,0 @@ -// ============================================================================= -// AUTO-GENERATED by AspireC4 — 2026-06-23 00:49:13 UTC -// Do not edit this file manually. Any changes will be overwritten on the -// next diagram regeneration (on Aspire startup or resource state change). -// See https://github.com/kjldev/aspirec4 for more information. -// ============================================================================= - -specification { - element component - element container - element database - element executable - element system - tag aspire-run-state-exited - tag aspire-run-state-failedtostart - tag aspire-run-state-finished - tag aspire-run-state-running - tag aspire-run-state-runtimeunhealthy - tag aspire-run-state-starting - tag aspire-run-state-stopping - tag aspire-run-state-waiting -} - -model { - sql = container 'sql' { - #aspire-run-state-running - technology 'mssql/server' - icon tech:microsoft-sql-server - link https://localhost:17134/consolelogs/resource/sql 'Dashboard: Console Logs' - link https://localhost:17134/structuredlogs/resource/sql 'Dashboard: Structured Logs' - metadata { - aspire-name 'sql' - } - eventstore_sqlserver = database 'eventstore-sqlserver' { - #aspire-run-state-running - icon tech:microsoft-sql-server - link https://localhost:17134/consolelogs/resource/eventstore-sqlserver 'Dashboard: Console Logs' - link https://localhost:17134/structuredlogs/resource/eventstore-sqlserver 'Dashboard: Structured Logs' - metadata { - aspire-name 'eventstore-sqlserver' - } - } - } - storage = system 'storage' { - #aspire-run-state-running - icon azure:azure-storage-mover - link http://localhost:54116 'Endpoint: table' - link http://localhost:54122 'Endpoint: queue' - link http://localhost:54118 'Endpoint: blob' - link https://localhost:17134/consolelogs/resource/storage 'Dashboard: Console Logs' - link https://localhost:17134/structuredlogs/resource/storage 'Dashboard: Structured Logs' - metadata { - aspire-name 'storage' - } - blob_storage = database 'blob-storage' { - #aspire-run-state-running - icon azure:azure-storage-mover - link https://localhost:17134/consolelogs/resource/blob-storage 'Dashboard: Console Logs' - link https://localhost:17134/structuredlogs/resource/blob-storage 'Dashboard: Structured Logs' - metadata { - aspire-name 'blob-storage' - } - } - } - redis = container 'redis' { - #aspire-run-state-running - technology 'library/redis' - icon tech:redis - link https://localhost:17134/consolelogs/resource/redis 'Dashboard: Console Logs' - link https://localhost:17134/structuredlogs/resource/redis 'Dashboard: Structured Logs' - metadata { - aspire-name 'redis' - } - } - redisinsight = container 'redisinsight' { - #aspire-run-state-running - technology 'redis/redisinsight' - icon tech:redis - link https://localhost:54117 'Endpoint: http' - link https://localhost:17134/consolelogs/resource/redisinsight 'Dashboard: Console Logs' - link https://localhost:17134/structuredlogs/resource/redisinsight 'Dashboard: Structured Logs' - metadata { - aspire-name 'redisinsight' - } - } - web = component 'web' { - #aspire-run-state-running - technology '.NET' - icon tech:dotnet - link http://localhost:50849 'Endpoint: http' - link https://localhost:50848 'Endpoint: https' - link https://localhost:17134/consolelogs/resource/web 'Dashboard: Console Logs' - link https://localhost:17134/structuredlogs/resource/web 'Dashboard: Structured Logs' - metadata { - aspire-name 'web' - } - web_rebuilder = executable 'web-rebuilder' { - link https://localhost:17134/consolelogs/resource/web-rebuilder 'Dashboard: Console Logs' - link https://localhost:17134/structuredlogs/resource/web-rebuilder 'Dashboard: Structured Logs' - metadata { - aspire-name 'web-rebuilder' - aspire-type 'Executable' - } - } - } - - redisinsight -> redis 'RedisInsight' - web -> eventstore_sqlserver - web -> blob_storage - web -> redis -} - -views { - view index { - title 'Architecture' - include * - style element.tag = #aspire-run-state-starting { - color sky - } - style element.tag = #aspire-run-state-waiting { - color sky - } - style element.tag = #aspire-run-state-running { - color green - } - style element.tag = #aspire-run-state-stopping { - color slate - opacity 60% - } - style element.tag = #aspire-run-state-exited { - color muted - opacity 30% - } - style element.tag = #aspire-run-state-finished { - color muted - opacity 30% - } - style element.tag = #aspire-run-state-runtimeunhealthy { - color amber - } - style element.tag = #aspire-run-state-failedtostart { - color red - } - } -} diff --git a/src/src/EventSourcing.Samples.Web/EventSourcing.Samples.Web.csproj b/src/src/EventSourcing.Samples.Web/EventSourcing.Samples.Web.csproj deleted file mode 100644 index 37e9b51e..00000000 --- a/src/src/EventSourcing.Samples.Web/EventSourcing.Samples.Web.csproj +++ /dev/null @@ -1,12 +0,0 @@ - - - - - - - - - - - - diff --git a/src/src/EventSourcing.Samples.Web/Pages/Index.cshtml b/src/src/EventSourcing.Samples.Web/Pages/Index.cshtml deleted file mode 100644 index 57e20975..00000000 --- a/src/src/EventSourcing.Samples.Web/Pages/Index.cshtml +++ /dev/null @@ -1,32 +0,0 @@ -@page -@model IndexModel -@{ - ViewData["Title"] = "Portal Home"; - Layout = "_Layout"; -} - -
-
-

🗃

-

Event Sourcing Sample

-

Choose your experience to get started

-
- -
- - -
🛒
-

Customer Experience

-

Browse the product catalog, place orders, and manage your profile.

- Enter → - - - - -
🏢
-

Back Office

-

Manage customers, the product catalog, stock levels, and inventory locations.

- Enter → - -
-
diff --git a/src/src/EventSourcing.Samples.Web/Pages/Index.cshtml.cs b/src/src/EventSourcing.Samples.Web/Pages/Index.cshtml.cs deleted file mode 100644 index 52e178d6..00000000 --- a/src/src/EventSourcing.Samples.Web/Pages/Index.cshtml.cs +++ /dev/null @@ -1,5 +0,0 @@ -using Microsoft.AspNetCore.Mvc.RazorPages; - -namespace Purview.EventSourcing.Samples.Web.Pages; - -sealed class IndexModel : PageModel { } diff --git a/src/src/EventSourcing.Samples.Web/Program.cs b/src/src/EventSourcing.Samples.Web/Program.cs deleted file mode 100644 index 801932bb..00000000 --- a/src/src/EventSourcing.Samples.Web/Program.cs +++ /dev/null @@ -1,119 +0,0 @@ -using Azure.Storage.Blobs; -using Purview.EventSourcing; -using Purview.EventSourcing.Samples.Services; -using Purview.EventSourcing.Samples.Web.Services; -using Purview.EventSourcing.SqlServer.Events.Exceptions; - -// No authentication in this sample — allow all operations without a principal identifier -EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; - -var builder = WebApplication.CreateBuilder(args); - -builder.AddServiceDefaults(); - -// Use Redis when available (e.g. via Aspire AppHost); fall back to in-memory for standalone dev runs -if (string.IsNullOrWhiteSpace(builder.Configuration.GetConnectionString("redis"))) - builder.Services.AddDistributedMemoryCache(); -else - builder.AddRedisDistributedCache("redis"); - -// Register SQL Server event store (event stream + snapshots for querying) -builder.Services.AddSqlServerEventStore(); -builder.Services.AddSqlServerSnapshotQueryableEventStore(); - -builder.Services.AddDomainServices(); -builder.Services.AddScoped(); - -// Register product image service — uses Azure Blob Storage when configured, no-op otherwise -var blobConnectionString = builder.Configuration.GetConnectionString("blob-storage"); -if (!string.IsNullOrWhiteSpace(blobConnectionString)) -{ - builder.Services.AddSingleton(new BlobServiceClient(blobConnectionString)); - builder.Services.AddSingleton(); -} -else -{ - builder.Services.AddSingleton(); -} - -builder.Services.AddRazorPages(); -builder.Services.AddSession(options => -{ - options.IdleTimeout = TimeSpan.FromMinutes(30); - options.Cookie.HttpOnly = true; - options.Cookie.IsEssential = true; -}); - -var app = builder.Build(); - -if (!app.Environment.IsDevelopment()) - app.UseExceptionHandler("/Error"); - -app.UseStaticFiles(); -app.UseRouting(); -app.UseSession(); -app.MapRazorPages(); -app.MapGroup("/api/audit") - .MapGet( - "/aggregates/{aggregateType}/{aggregateId}/events", - async Task ( - string aggregateType, - string aggregateId, - int? fromVersion, - int? toVersion, - DateTimeOffset? fromUtc, - DateTimeOffset? toUtc, - int? maxRecords, - string? continuationToken, - IAggregateAuditService auditService, - CancellationToken cancellationToken - ) => - { - if (!AggregateAuditService.IsSupportedAggregateType(aggregateType)) - return Results.BadRequest( - new - { - Error = $"Unsupported aggregate type '{aggregateType}'.", - SupportedAggregateTypes = AggregateAuditService.SupportedAggregateTypes, - } - ); - - var request = new AggregateEventHistoryRequest - { - FromVersion = fromVersion, - ToVersion = toVersion, - FromUtc = fromUtc, - ToUtc = toUtc, - MaxRecords = maxRecords ?? ContinuationRequest.DefaultMaxRecords, - ContinuationToken = continuationToken, - }; - var response = await auditService.GetHistoryAsync(aggregateType, aggregateId, request, cancellationToken); - - return Results.Ok(response); - } - ); -app.MapDefaultEndpoints().MapGet("/pingz", () => Results.Ok()); - -// Seed demo data on startup (no-op if data already exists). -await using (var scope = app.Services.CreateAsyncScope()) -{ - var seeder = scope.ServiceProvider.GetRequiredService(); - for (var attempt = 0; ; attempt++) - { - try - { - await seeder.SeedAsync(); - break; - } - catch (ConcurrencyException) when (attempt < 2) - { - // Another app instance may be seeding the demo store at the same time. - await Task.Delay(TimeSpan.FromMilliseconds(100 * (attempt + 1))); - } - } -} - -await app.RunAsync(); - -[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1515:Consider making public types internal")] -public partial class Program; diff --git a/src/src/EventSourcing.Samples.Web/Properties/AssemblyInfo.cs b/src/src/EventSourcing.Samples.Web/Properties/AssemblyInfo.cs deleted file mode 100644 index d65dd8d9..00000000 --- a/src/src/EventSourcing.Samples.Web/Properties/AssemblyInfo.cs +++ /dev/null @@ -1,4 +0,0 @@ -using System.Runtime.CompilerServices; - -[assembly: InternalsVisibleTo("EventSourcing.Samples.UnitTests")] -[assembly: InternalsVisibleTo("EventSourcing.Samples.IntegrationTests")] diff --git a/src/src/EventSourcing.Samples.Web/appsettings.Development.json b/src/src/EventSourcing.Samples.Web/appsettings.Development.json deleted file mode 100644 index b44cfeb4..00000000 --- a/src/src/EventSourcing.Samples.Web/appsettings.Development.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "Logging": { - "LogLevel": { - "Default": "Information", - "Microsoft.AspNetCore": "Warning" - } - }, - "ConnectionStrings": { - "eventstore-sqlserver": "Server=localhost,1433;Database=EventSourcingSample;User Id=sa;Password=YourStrong@Passw0rd;TrustServerCertificate=true", - "blob-storage": "UseDevelopmentStorage=true" - } -} diff --git a/src/src/EventSourcing.Samples.Web/appsettings.json b/src/src/EventSourcing.Samples.Web/appsettings.json deleted file mode 100644 index 158e228d..00000000 --- a/src/src/EventSourcing.Samples.Web/appsettings.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "Logging": { - "LogLevel": { - "Default": "Information", - "Microsoft.AspNetCore": "Warning" - } - }, - "AllowedHosts": "*", - "EventStore:SqlServer": { - "AutoCreateTable": true, - "TableName": "Events", - "SchemaName": "dbo" - }, - "EventStore:SqlServerSnapshot": { - "AutoCreateTable": true, - "TableName": "Snapshots", - "SchemaName": "dbo" - } -} diff --git a/src/src/EventSourcing.Samples/Domain/ReportUploadAggregate.Rules.cs b/src/src/EventSourcing.Samples/Domain/ReportUploadAggregate.Rules.cs deleted file mode 100644 index ce6b7c3a..00000000 --- a/src/src/EventSourcing.Samples/Domain/ReportUploadAggregate.Rules.cs +++ /dev/null @@ -1,55 +0,0 @@ -using Purview.EventSourcing.Samples.ValueObjects; - -namespace Purview.EventSourcing.Samples.Domain; - -partial class ReportUploadAggregate -{ - partial void OnRaisingCreatedEvent( - ref ProjectId projectId, - ref string originalFilename, - ref BlobUri sourceJsonBlob, - ref UserCapture uploaded - ) - { - if (Details.CurrentVersion > 0) - throw new InvalidOperationException("Cannot create a report upload for an existing project."); - - ArgumentException.ThrowIfNullOrWhiteSpace(originalFilename); - ArgumentNullException.ThrowIfNull(sourceJsonBlob); - } - - partial void OnUploadedChanging(ref UserCapture uploaded) - { - if (uploaded == UserCapture.Empty) - throw new InvalidOperationException("Uploaded information cannot be empty."); - - if (Details.CurrentVersion > 0 && Uploaded.IsEssentialChange(uploaded)) - throw new InvalidOperationException("Cannot change uploaded information after report creation."); - } - - partial void OnComputingMarkAsCompletedEvent(ref ReportProcessingStatus status) => - status = ReportProcessingStatus.Completed; - - partial void OnRaisingMarkAsCompletedEvent(ref BlobUri? excelReportBlob, ref object? reportSummary) - { - ArgumentNullException.ThrowIfNull(excelReportBlob); - ArgumentNullException.ThrowIfNull(reportSummary); - } - - partial void OnRaisingReportProcessingStatusSetEvent(ref ReportProcessingStatus status, ref string? failureReason) - { - if (status == ReportProcessingStatus.Completed) - throw new InvalidOperationException( - $"Use the {nameof(MarkAsComplete)} method to set the report as complete." - ); - - if (status != ReportProcessingStatus.Failed) - { - if (!string.IsNullOrWhiteSpace(failureReason)) - throw new InvalidOperationException("Failure reason must be provided when marking as failed."); - - // In-case of empty strings, we'll just null it out here. Cleaner. - failureReason = null; - } - } -} diff --git a/src/src/EventSourcing.Samples/Domain/ReportUploadAggregate.cs b/src/src/EventSourcing.Samples/Domain/ReportUploadAggregate.cs deleted file mode 100644 index 67ea7449..00000000 --- a/src/src/EventSourcing.Samples/Domain/ReportUploadAggregate.cs +++ /dev/null @@ -1,98 +0,0 @@ -using Purview.EventSourcing.Aggregates; -using Purview.EventSourcing.Samples.ValueObjects; - -namespace Purview.EventSourcing.Samples.Domain; - -[GenerateAggregate] -public sealed partial class ReportUploadAggregate : AggregateBase -{ - public ProjectId ProjectId { get; private set; } = ProjectId.Empty; - - public string OriginalFilename { get; private set; } = string.Empty; - - public BlobUri SourceJsonBlob { get; private set; } = BlobUri.Empty; - - public BlobUri? ExcelReportBlob { get; private set; } - - public UserCapture Uploaded { get; private set; } = UserCapture.Empty; - - public ReportProcessingStatus Status { get; private set; } = ReportProcessingStatus.None; - - public string? FailureReason { get; private set; } - - public object? ReportSummary { get; private set; } - - public EventStoreSet RelatedProjects { get; private set; } = []; - - public EventStoreList StatusHistory { get; private set; } = []; - - public ProjectId? CustomerProjectId { get; private set; } - - // Wrapped mutation methods - public ReportUploadAggregate MarkAsFailed(string? failureReason = null) => - SetReportProcessingStatus(ReportProcessingStatus.Failed, failureReason); - - public ReportUploadAggregate MarkAsProcessing() => SetReportProcessingStatus(ReportProcessingStatus.Processing); - - public ReportUploadAggregate ChangeCustomerProjectId(ProjectId? customerProjectId = null) => - customerProjectId is null ? ClearCustomerProjectId() : SetCustomerProjectId(customerProjectId.Value); - - // Mutation methods - [GenerateAggregateEvent(EventName = "MarkAsCompleted")] - [System.Diagnostics.CodeAnalysis.SuppressMessage( - "Purview.EventSourcing.SourceGenerator", - "EVENTSTORE016:Event parameter nullability differs from aggregate property", - Justification = "Required properties" - )] - public partial ReportUploadAggregate MarkAsComplete( - BlobUri excelReportBlob, - object reportSummary, - [Computed] ReportProcessingStatus status = default - ); - - [GenerateAggregateEvent] - public partial ReportUploadAggregate Create( - ProjectId projectId, - string originalFilename, - BlobUri sourceJsonBlob, - UserCapture uploaded - ); - - [GenerateAggregateEvent] - private partial ReportUploadAggregate SetReportProcessingStatus( - ReportProcessingStatus status, - string? failureReason = null - ); - - [GenerateAggregateCollectionEvent(nameof(RelatedProjects))] - public partial ReportUploadAggregate AddRelatedProject(ProjectId projectId); - - [GenerateAggregateCollectionEvent(nameof(RelatedProjects))] - public partial ReportUploadAggregate AddRelatedProjects(IEnumerable projectIds); - - [GenerateAggregateCollectionEvent(nameof(RelatedProjects))] - public partial ReportUploadAggregate AddRelatedProjects(params ProjectId[] projectIds); - - [GenerateAggregateCollectionEvent(nameof(StatusHistory))] - public partial ReportUploadAggregate AddStatusHistory(StatusHistory statusHistory); - - [GenerateAggregateCollectionEvent(nameof(StatusHistory))] - public partial ReportUploadAggregate AddStatusHistories(IEnumerable statusHistories); - - [GenerateAggregateCollectionEvent(nameof(StatusHistory))] - public partial ReportUploadAggregate AddStatusHistories(params StatusHistory[] statusHistories); - - [GenerateAggregateEvent(Manual = true)] - public partial ReportUploadAggregate SetReportSummary(EnvironmentVariableTarget target); - - [GenerateAggregateEvent] - private partial ReportUploadAggregate SetCustomerProjectId(ProjectId customerProjectId); - - [GenerateAggregateEvent] - private partial ReportUploadAggregate ClearCustomerProjectId(); - - // Appliers - private partial void Apply(ReportUploadEvents.ReportSummarySetEvent @event) => ReportSummary = @event.Target; - - private partial void Apply(ReportUploadEvents.CustomerProjectIdClearedEvent @event) => CustomerProjectId = null; -} diff --git a/src/src/EventSourcing.Samples/EventSourcing.Samples.csproj b/src/src/EventSourcing.Samples/EventSourcing.Samples.csproj deleted file mode 100644 index 3a443408..00000000 --- a/src/src/EventSourcing.Samples/EventSourcing.Samples.csproj +++ /dev/null @@ -1,15 +0,0 @@ - - - true - - - - - - - diff --git a/src/src/EventSourcing.Samples/ValueObjects/UserCapture.cs b/src/src/EventSourcing.Samples/ValueObjects/UserCapture.cs deleted file mode 100644 index d29ef36f..00000000 --- a/src/src/EventSourcing.Samples/ValueObjects/UserCapture.cs +++ /dev/null @@ -1,10 +0,0 @@ -using Purview.EventSourcing.Serialization; - -namespace Purview.EventSourcing.Samples.ValueObjects; - -[ValueObject] -public sealed partial record UserCapture(UserDetails User, DateTimeOffset OccurredAt) -{ - public bool IsEssentialChange(UserCapture userDetails) => - OccurredAt != userDetails?.OccurredAt || User.Id != userDetails?.User.Id; -} diff --git a/src/src/EventSourcing.Samples/ValueObjects/UserDetails.cs b/src/src/EventSourcing.Samples/ValueObjects/UserDetails.cs deleted file mode 100644 index f2560e7d..00000000 --- a/src/src/EventSourcing.Samples/ValueObjects/UserDetails.cs +++ /dev/null @@ -1,23 +0,0 @@ -using Purview.EventSourcing.Serialization; -using Purview.EventSourcing.ValueObjects; - -namespace Purview.EventSourcing.Samples.ValueObjects; - -[ValueObject] -public sealed partial record UserDetails(Guid Id, string? DisplayName, bool IsActive = true) : IValueObject -{ - static partial void OnNormalize(ref Guid id, ref string? displayName, ref bool isActive) - { - if (!isActive) - displayName = null; - } - - partial void OnValidate(Guid id, string? displayName, bool isActive) - { - if (id == Guid.Empty) - throw new ArgumentException("Id must be a valid GUID.", nameof(id)); - - if (isActive && string.IsNullOrWhiteSpace(displayName)) - throw new ArgumentException("DisplayName cannot be null or empty.", nameof(displayName)); - } -} diff --git a/src/src/EventSourcing.SourceGenerator/Properties/AssemblyInfo.cs b/src/src/EventSourcing.SourceGenerator/Properties/AssemblyInfo.cs deleted file mode 100644 index 440088df..00000000 --- a/src/src/EventSourcing.SourceGenerator/Properties/AssemblyInfo.cs +++ /dev/null @@ -1,3 +0,0 @@ -using System.Runtime.CompilerServices; - -[assembly: InternalsVisibleTo("EventSourcing.SourceGenerator.UnitTests")] diff --git a/src/src/EventSourcing/Aggregates/AggregateDetails.cs b/src/src/EventSourcing/Aggregates/AggregateDetails.cs index 0ebeb5dc..035da898 100644 --- a/src/src/EventSourcing/Aggregates/AggregateDetails.cs +++ b/src/src/EventSourcing/Aggregates/AggregateDetails.cs @@ -103,6 +103,7 @@ public object Clone() => { _id = _id, Created = Created, + Updated = Updated, SnapshotVersion = SnapshotVersion, SavedVersion = SavedVersion, CurrentVersion = CurrentVersion, diff --git a/src/src/EventSourcing/Aggregates/SaveResult.cs b/src/src/EventSourcing/Aggregates/SaveResult.cs index c1169c0f..702d8ee1 100644 --- a/src/src/EventSourcing/Aggregates/SaveResult.cs +++ b/src/src/EventSourcing/Aggregates/SaveResult.cs @@ -1,6 +1,5 @@ using System.Diagnostics.CodeAnalysis; -using FluentValidation; -using FluentValidation.Results; +using Purview.EventSourcing.Validation; namespace Purview.EventSourcing.Aggregates; diff --git a/src/src/EventSourcing/Aggregates/Snapshotting/SnapshotStrategySelector.cs b/src/src/EventSourcing/Aggregates/Snapshotting/SnapshotStrategySelector.cs index f21f87c0..6228013f 100644 --- a/src/src/EventSourcing/Aggregates/Snapshotting/SnapshotStrategySelector.cs +++ b/src/src/EventSourcing/Aggregates/Snapshotting/SnapshotStrategySelector.cs @@ -1,3 +1,5 @@ +using System.Collections.Concurrent; + namespace Purview.EventSourcing.Aggregates.Snapshotting; /// @@ -5,7 +7,7 @@ namespace Purview.EventSourcing.Aggregates.Snapshotting; /// public sealed class SnapshotStrategySelector : ISnapshotStrategySelector { - readonly Dictionary _snapshotStrategies = []; + readonly ConcurrentDictionary _snapshotStrategies = new(); object? _defaultStrategy; /// @@ -16,6 +18,7 @@ public SnapshotStrategySelector SetDefault(ISnapshotStrategy strategy) { ArgumentNullException.ThrowIfNull(strategy); _defaultStrategy = strategy; + return this; } @@ -26,7 +29,8 @@ public SnapshotStrategySelector Set(ISnapshotStrategy strategy) where T : class, IAggregate, new() { ArgumentNullException.ThrowIfNull(strategy); - _snapshotStrategies[typeof(T)] = strategy; + + _snapshotStrategies.AddOrUpdate(typeof(T), strategy, (_, __) => strategy); return this; } @@ -34,9 +38,7 @@ public SnapshotStrategySelector Set(ISnapshotStrategy strategy) public ISnapshotStrategy? Resolve() where T : class, IAggregate, new() { - if (_snapshotStrategies.TryGetValue(typeof(T), out var strategy)) - return strategy as ISnapshotStrategy; - - return _defaultStrategy as ISnapshotStrategy; + return (_snapshotStrategies.TryGetValue(typeof(T), out var strategy) ? strategy : _defaultStrategy) + as ISnapshotStrategy; } } diff --git a/src/src/EventSourcing/ContinuationResponse.cs b/src/src/EventSourcing/ContinuationResponse.cs index a6894bbb..216ce275 100644 --- a/src/src/EventSourcing/ContinuationResponse.cs +++ b/src/src/EventSourcing/ContinuationResponse.cs @@ -84,6 +84,7 @@ protected TRequest CreateResponse(Func convert) { ContinuationToken = ContinuationToken, RequestedCount = RequestedCount, + TotalCount = TotalCount, Results = [.. Results.Select(convert).Where(m => m != null).Cast()], }; } diff --git a/src/src/EventSourcing/EventSourcing.csproj b/src/src/EventSourcing/EventSourcing.csproj index d02c8167..7872ea2e 100644 --- a/src/src/EventSourcing/EventSourcing.csproj +++ b/src/src/EventSourcing/EventSourcing.csproj @@ -3,47 +3,72 @@ true Purview Event Sourcing Core abstractions, aggregate types, facades, transactions, and dependency injection extensions for building event-sourced .NET applications. + $(PackageTags);purview;dotnet;event-sourcing;eventstore;event-store;aggregate;domain-driven-design; Purview.EventSourcing - $(PackageTags);purview;kjldev;dotnet;event-sourcing;eventstore;event-store;aggregate;domain-driven-design; + + true + src/ProjectAgent + + + + $(MSBuildThisFileDirectory)..\SourceGenerator\SourceGenerator.csproj + netstandard2.0 + $(MSBuildThisFileDirectory)..\SourceGenerator\bin\$(Configuration)\$(EventStoreSourceGeneratorTargetFramework)\Purview.EventSourcing.SourceGeneration.dll + $(TargetsForTfmSpecificContentInPackage);IncludeEventStoreSourceGenerator + + + + + + + + - - - - - + + + - - + + analyzers/dotnet/cs/ + - diff --git a/src/src/EventSourcing/EventStoreFacade.cs b/src/src/EventSourcing/EventStoreFacade.cs index 6a0958a2..8db28898 100644 --- a/src/src/EventSourcing/EventStoreFacade.cs +++ b/src/src/EventSourcing/EventStoreFacade.cs @@ -2,6 +2,7 @@ using System.ComponentModel; using Microsoft.Extensions.DependencyInjection; using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Internal; namespace Purview.EventSourcing; @@ -82,6 +83,15 @@ public Task ExistsAsync(string aggregateId, CancellationToken ca public T FulfilRequirements(T aggregate) where T : class, IAggregate, new() => GetEventStore().FulfilRequirements(aggregate); + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) + where T : class, IAggregate, new() => + GetEventStore().GetEventRangeAsync(aggregateId, versionFrom, versionTo, cancellationToken); + public IEventStoreCore GetEventStore() where T : class, IAggregate, new() => (IEventStoreCore) diff --git a/src/src/EventSourcing/EventStoreOperationContext.cs b/src/src/EventSourcing/EventStoreOperationContext.cs index a21f3c6f..4ca5c01e 100644 --- a/src/src/EventSourcing/EventStoreOperationContext.cs +++ b/src/src/EventSourcing/EventStoreOperationContext.cs @@ -1,4 +1,4 @@ -using System.ComponentModel; +using System.Collections.Concurrent; using System.Security.Claims; using Microsoft.Extensions.Caching.Distributed; using Purview.EventSourcing.Aggregates; @@ -12,22 +12,14 @@ namespace Purview.EventSourcing; [System.Diagnostics.DebuggerStepThrough] public sealed record class EventStoreOperationContext { - readonly Dictionary _snapshotStrategies = []; + readonly ConcurrentDictionary _snapshotStrategies = new(); /// /// Get or sets the default , for /// when operations provide a null operational context. /// - public static EventStoreOperationContext DefaultContext - { - get; - set => - field = - value - ?? throw new NullReferenceException( - $"A default {nameof(EventStoreOperationContext)} is required, null is not allowed." - ); - } = new(); + public static EventStoreOperationContext DefaultContext(string? correlationId = null) => + new() { CorrelationId = correlationId! }; /// /// Gets/ sets the default value for . @@ -39,10 +31,19 @@ public static EventStoreOperationContext DefaultContext /// public static bool UseIdempotencyMarkerDefault { get; set; } + /// + /// Gets or sets the default value for the . Defaults to true. + /// + public static SnapshotCachingOptions UseDefaultCacheMode { get; set; } = SnapshotCachingOptions.GetAndStore; + /// /// Used during the saving of aggregates. /// - public string? CorrelationId { get; set; } + public string CorrelationId + { + get => field ?? System.Diagnostics.Activity.Current?.Id ?? $"{Guid.NewGuid()}"; + set; + } /// /// Controls how to handle aggregates marked as deleted during get and save/ restore operations. @@ -56,10 +57,9 @@ public static EventStoreOperationContext DefaultContext /// /// Gets/ sets a value indicating how the - /// uses the during it's operations. Defaults to . + /// uses the during it's operations. Defaults to . /// - [DefaultValue(EventStoreCachingOptions.GetAndStore)] - public EventStoreCachingOptions CacheMode { get; set; } = EventStoreCachingOptions.GetAndStore; + public SnapshotCachingOptions SnapshotCacheMode { get; set; } = SnapshotCachingOptions.GetAndStore; /// /// Manages caching operations for the operation. @@ -119,7 +119,7 @@ public EventStoreOperationContext SetSnapshotStrategy(ISnapshotStrat where TAggregate : class, IAggregate, new() { ArgumentNullException.ThrowIfNull(strategy); - _snapshotStrategies[typeof(TAggregate)] = strategy; + _snapshotStrategies.AddOrUpdate(typeof(TAggregate), strategy, (key, oldValue) => strategy); return this; } diff --git a/src/src/EventSourcing/EventStoreTransaction.cs b/src/src/EventSourcing/EventStoreTransaction.cs index 8a6473d9..7b17ac71 100644 --- a/src/src/EventSourcing/EventStoreTransaction.cs +++ b/src/src/EventSourcing/EventStoreTransaction.cs @@ -358,14 +358,11 @@ bool useIdempotencyMarker CancellationToken cancellationToken ) { - var baseContext = _operationContext ?? EventStoreOperationContext.DefaultContext; + var baseContext = _operationContext ?? EventStoreOperationContext.DefaultContext(correlationId); var context = baseContext with { - CorrelationId = baseContext.CorrelationId ?? correlationId, - UseIdempotencyMarker = - baseContext.UseIdempotencyMarker - || _useIdempotencyMarker - || !string.IsNullOrWhiteSpace(baseContext.CorrelationId), + CorrelationId = _operationContext is null ? correlationId : baseContext.CorrelationId, + UseIdempotencyMarker = baseContext.UseIdempotencyMarker || _useIdempotencyMarker, }; var result = _eventStoreImpl is not null @@ -400,14 +397,11 @@ CancellationToken cancellationToken ); } - var baseContext = _operationContext ?? EventStoreOperationContext.DefaultContext; + var baseContext = _operationContext ?? EventStoreOperationContext.DefaultContext(correlationId); var context = baseContext with { - CorrelationId = baseContext.CorrelationId ?? correlationId, - UseIdempotencyMarker = - baseContext.UseIdempotencyMarker - || _useIdempotencyMarker - || !string.IsNullOrWhiteSpace(baseContext.CorrelationId), + CorrelationId = _operationContext is null ? correlationId : baseContext.CorrelationId, + UseIdempotencyMarker = baseContext.UseIdempotencyMarker || _useIdempotencyMarker, }; var saveOperation = await _transactionalEventStore.SaveInTransactionAsync( diff --git a/src/src/EventSourcing/EventStores/NullQueryable/NullQueryableEventStore.cs b/src/src/EventSourcing/EventStores/NullQueryable/NullQueryableEventStore.cs index f75a3fb4..e1c4a670 100644 --- a/src/src/EventSourcing/EventStores/NullQueryable/NullQueryableEventStore.cs +++ b/src/src/EventSourcing/EventStores/NullQueryable/NullQueryableEventStore.cs @@ -1,6 +1,7 @@ using System.Linq.Expressions; using System.Runtime.CompilerServices; using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Internal; namespace Purview.EventSourcing.EventStores.NullQueryable; @@ -12,6 +13,13 @@ sealed class NullQueryableEventStore(INonQueryableEventStore eventStore) : public T FulfilRequirements(T aggregate) => _eventStore.FulfilRequirements(aggregate); + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) => _eventStore.GetEventRangeAsync(aggregateId, versionFrom, versionTo, cancellationToken); + public Task CreateAsync(string? id = null, CancellationToken cancellationToken = default) => _eventStore.CreateAsync(id, cancellationToken); diff --git a/src/src/EventSourcing/ExistsState.cs b/src/src/EventSourcing/ExistsState.cs index 83ceccdd..14574466 100644 --- a/src/src/EventSourcing/ExistsState.cs +++ b/src/src/EventSourcing/ExistsState.cs @@ -33,7 +33,7 @@ public static implicit operator bool([NotNull] ExistsState state) => /// /// Represents a value that indicates the aggregate does not exist. /// - public static ExistsState DoesNotExists => new(ExistsStatus.DoesNotExist, null); + public static ExistsState DoesNotExist => new(ExistsStatus.DoesNotExist, null); /// /// Represents a value that indicates the aggregate does exist. diff --git a/src/src/EventSourcing/Guards/GuardAggregates.cs b/src/src/EventSourcing/Guards/GuardAggregates.cs new file mode 100644 index 00000000..4b2cd748 --- /dev/null +++ b/src/src/EventSourcing/Guards/GuardAggregates.cs @@ -0,0 +1,26 @@ +using System.ComponentModel; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using Purview.EventSourcing.Aggregates; + +namespace Purview.EventSourcing.Guards; + +[StackTraceHidden] +[EditorBrowsable(EditorBrowsableState.Never)] +public static class GuardAggregates +{ + [return: NotNull] + public static T MustBeNew( + [NotNull] this T value, + string? errorMessage = null, + [CallerMemberName] string? paramName = null + ) + where T : class, IAggregate => + value.Details.SavedVersion > 0 + ? throw new ArgumentException( + errorMessage ?? $"The aggregate '{typeof(T).Name}' existing and cannot be modified in this way.", + paramName + ) + : value; +} diff --git a/src/src/EventSourcing/Guards/GuardObjects.cs b/src/src/EventSourcing/Guards/GuardObjects.cs new file mode 100644 index 00000000..3c161a31 --- /dev/null +++ b/src/src/EventSourcing/Guards/GuardObjects.cs @@ -0,0 +1,18 @@ +using System.ComponentModel; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; + +namespace Purview.EventSourcing.Guards; + +[StackTraceHidden] +[EditorBrowsable(EditorBrowsableState.Never)] +public static class GuardObjects +{ + [return: NotNullIfNotNull(nameof(value))] + public static T Required(this T? value) + { + ArgumentNullException.ThrowIfNull(value); + + return value; + } +} diff --git a/src/src/EventSourcing/Guards/GuardStrings.cs b/src/src/EventSourcing/Guards/GuardStrings.cs new file mode 100644 index 00000000..003c77dc --- /dev/null +++ b/src/src/EventSourcing/Guards/GuardStrings.cs @@ -0,0 +1,69 @@ +using System.ComponentModel; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; + +namespace Purview.EventSourcing.Guards; + +[StackTraceHidden] +[EditorBrowsable(EditorBrowsableState.Never)] +public static class GuardStrings +{ + const char DefaultKeySeparator = '_'; + + public static string? NullIfEmpty(this string? value, bool trim = true) => + string.IsNullOrWhiteSpace(value) ? null : value.Required(trim: trim); + + [return: NotNull] + public static string Required( + this string? value, + bool trim = true, + string? customExceptionMessage = null, + [CallerMemberName] string? paramName = null + ) + { + if (string.IsNullOrWhiteSpace(value)) + { + if (customExceptionMessage != null) + throw new ArgumentException(customExceptionMessage, paramName); + + ArgumentException.ThrowIfNullOrWhiteSpace(value, paramName); + } + + return trim ? value.TrimText() : value!; + } + + [return: NotNullIfNotNull(nameof(value))] + public static string? TrimText(this string? value) => value?.Trim(); + + [return: NotNullIfNotNull(nameof(value))] + public static string? Upper(this string? value) => value?.ToUpperInvariant(); + + [return: NotNullIfNotNull(nameof(value))] + [SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase")] + public static string? Lower(this string? value) => value?.ToLowerInvariant(); + + [return: NotNullIfNotNull(nameof(value))] + public static string? TrimTextUpper(this string? value) => value.TrimText().Upper(); + + [return: NotNullIfNotNull(nameof(value))] + public static string? TrimTextLower(this string? value) => value.TrimText().Lower(); + + [return: NotNull] + public static string Key(this IEnumerable keys, char separator = DefaultKeySeparator) + { + keys = [.. (keys ?? []).Select(static key => key.Required(true))]; + + return keys.Any() + ? string.Join(separator, keys) + : throw new ArgumentException("At least one key must be provided.", nameof(keys)); + } + + [return: NotNull] + public static string KeyUpper(this IEnumerable keys, char separator = DefaultKeySeparator) => + Key(keys, separator).Upper(); + + [return: NotNull] + public static string KeyLower(this IEnumerable keys, char separator = DefaultKeySeparator) => + Key(keys, separator).Lower(); +} diff --git a/src/src/EventSourcing/IEventStore.cs b/src/src/EventSourcing/IEventStore.cs index 6850dbb6..a0c185ba 100644 --- a/src/src/EventSourcing/IEventStore.cs +++ b/src/src/EventSourcing/IEventStore.cs @@ -1,4 +1,5 @@ using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; namespace Purview.EventSourcing; @@ -170,4 +171,20 @@ Task ExistsAsync(string aggregateId, CancellationToken cancellat /// This is called automatically for any options from within the store. T FulfilRequirements(T aggregate) where T : class, IAggregate, new(); + + /// + /// Gets a range of s for a given aggregate, as specified by it's . + /// + /// The id of the aggregate. + /// The inclusive event number to start the range at. + /// Optional, the inclusive event number to finish the range at. + /// The stopping token. + /// If no is specified all available events greater than are returned. + IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) + where T : class, IAggregate, new(); } diff --git a/src/src/EventSourcing/IEventStoreCore.cs b/src/src/EventSourcing/IEventStoreCore.cs index 94363d25..8017a8e6 100644 --- a/src/src/EventSourcing/IEventStoreCore.cs +++ b/src/src/EventSourcing/IEventStoreCore.cs @@ -1,5 +1,6 @@ using System.ComponentModel; using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; namespace Purview.EventSourcing; @@ -61,4 +62,11 @@ Task RestoreAsync( Task ExistsAsync(string aggregateId, CancellationToken cancellationToken = default); T FulfilRequirements(T aggregate); + + IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ); } diff --git a/src/src/EventSourcing/IEventStoreCoreExtensions.cs b/src/src/EventSourcing/IEventStoreCoreExtensions.cs index c66b4d7b..d367321b 100644 --- a/src/src/EventSourcing/IEventStoreCoreExtensions.cs +++ b/src/src/EventSourcing/IEventStoreCoreExtensions.cs @@ -112,7 +112,7 @@ public static async Task QuickCreateAsync( where T : class, IAggregate, new() { var aggregate = await eventStore.GetOrCreateAsync(aggregateId, context, cancellationToken); - if (aggregate != null) + if (aggregate?.IsNew() == true) creator(aggregate); return aggregate; @@ -153,7 +153,7 @@ public static async Task QuickCreateAsync( where T : class, IAggregate, new() { var aggregate = await eventStore.GetOrCreateAsync(aggregateId, null, cancellationToken); - if (aggregate != null) + if (aggregate?.IsNew() == true) creator(aggregate); return aggregate; @@ -198,7 +198,7 @@ public static async Task QuickCreateAsync( where T : class, IAggregate, new() { var aggregate = await eventStore.GetOrCreateAsync(aggregateId?.ToString(), context, cancellationToken); - if (aggregate != null) + if (aggregate?.IsNew() == true) creator(aggregate); return aggregate; @@ -240,7 +240,7 @@ public static async Task QuickCreateAsync( where T : class, IAggregate, new() { var aggregate = await eventStore.GetOrCreateAsync(id?.ToString(), null, cancellationToken); - if (aggregate != null) + if (aggregate?.IsNew() == true) creator(aggregate); return aggregate; @@ -462,7 +462,7 @@ public static Task ExistsWithNullCheckAsync( where T : class, IAggregate, new() { return string.IsNullOrWhiteSpace(aggregateId) - ? Task.FromResult(ExistsState.DoesNotExists) + ? Task.FromResult(ExistsState.DoesNotExist) : eventStore.ExistsAsync(aggregateId, cancellationToken); } diff --git a/src/src/EventSourcing/IEventStoreCoreHistoryExtensions.cs b/src/src/EventSourcing/IEventStoreCoreHistoryExtensions.cs index 9ce0b3fe..b6e475f6 100644 --- a/src/src/EventSourcing/IEventStoreCoreHistoryExtensions.cs +++ b/src/src/EventSourcing/IEventStoreCoreHistoryExtensions.cs @@ -112,19 +112,16 @@ static int ParseContinuationOffset(string? continuationToken) if (string.IsNullOrWhiteSpace(continuationToken)) return 0; - if ( - !int.TryParse(continuationToken, NumberStyles.None, CultureInfo.InvariantCulture, out var offset) - || offset < 0 - ) - { - throw new ArgumentOutOfRangeException( + // Only process if we have a continuation token to retrieve. + return + int.TryParse(continuationToken, NumberStyles.None, CultureInfo.InvariantCulture, out var offset) + && offset >= 0 + ? offset + : throw new ArgumentOutOfRangeException( nameof(continuationToken), continuationToken, "Continuation token must be a non-negative integer offset." ); - } - - return offset; } static void ValidateRequest(AggregateEventHistoryRequest request) diff --git a/src/src/EventSourcing/IEventStoreExtensions.cs b/src/src/EventSourcing/IEventStoreExtensions.cs index cbec39b8..8cdff20a 100644 --- a/src/src/EventSourcing/IEventStoreExtensions.cs +++ b/src/src/EventSourcing/IEventStoreExtensions.cs @@ -112,7 +112,7 @@ public static async Task QuickCreateAsync( where T : class, IAggregate, new() { var aggregate = await eventStore.GetOrCreateAsync(aggregateId, context, cancellationToken); - if (aggregate != null) + if (aggregate?.IsNew() == true) creator(aggregate); return aggregate; @@ -153,7 +153,7 @@ public static async Task QuickCreateAsync( where T : class, IAggregate, new() { var aggregate = await eventStore.GetOrCreateAsync(aggregateId, null, cancellationToken); - if (aggregate != null) + if (aggregate?.IsNew() == true) creator(aggregate); return aggregate; @@ -198,7 +198,7 @@ public static async Task QuickCreateAsync( where T : class, IAggregate, new() { var aggregate = await eventStore.GetOrCreateAsync(aggregateId?.ToString(), context, cancellationToken); - if (aggregate != null) + if (aggregate?.IsNew() == true) creator(aggregate); return aggregate; @@ -240,7 +240,7 @@ public static async Task QuickCreateAsync( where T : class, IAggregate, new() { var aggregate = await eventStore.GetOrCreateAsync(id?.ToString(), null, cancellationToken); - if (aggregate != null) + if (aggregate?.IsNew() == true) creator(aggregate); return aggregate; @@ -462,7 +462,7 @@ public static Task ExistsWithNullCheckAsync( where T : class, IAggregate, new() { return string.IsNullOrWhiteSpace(aggregateId) - ? Task.FromResult(ExistsState.DoesNotExists) + ? Task.FromResult(ExistsState.DoesNotExist) : eventStore.ExistsAsync(aggregateId, cancellationToken); } diff --git a/src/src/EventSourcing/Properties/AssemblyInfo.cs b/src/src/EventSourcing/Properties/AssemblyInfo.cs index cf4b125b..738c2361 100644 --- a/src/src/EventSourcing/Properties/AssemblyInfo.cs +++ b/src/src/EventSourcing/Properties/AssemblyInfo.cs @@ -1,11 +1,18 @@ using System.Runtime.CompilerServices; +using Purview.Telemetry; -[assembly: InternalsVisibleTo("EventSourcing.AzureStorage.IntegrationTests")] -[assembly: InternalsVisibleTo("EventSourcing.CosmosDb.IntegrationTests")] -[assembly: InternalsVisibleTo("EventSourcing.MongoDB.IntegrationTests")] -[assembly: InternalsVisibleTo("EventSourcing.SqlServer.IntegrationTests")] +[assembly: InternalsVisibleTo("SharedTestingFramework")] +[assembly: InternalsVisibleTo("AzureStorage.IntegrationTests")] +[assembly: InternalsVisibleTo("CosmosDb.IntegrationTests")] +[assembly: InternalsVisibleTo("MongoDB.IntegrationTests")] +[assembly: InternalsVisibleTo("SqlServer.IntegrationTests")] -[assembly: InternalsVisibleTo("EventSourcing.AzureStorage")] -[assembly: InternalsVisibleTo("EventSourcing.CosmosDb")] -[assembly: InternalsVisibleTo("EventSourcing.MongoDB")] -[assembly: InternalsVisibleTo("EventSourcing.SqlServer")] +[assembly: InternalsVisibleTo("ImplementationShared")] +[assembly: InternalsVisibleTo("InMemory")] +[assembly: InternalsVisibleTo("AzureStorage")] +[assembly: InternalsVisibleTo("CosmosDb")] +[assembly: InternalsVisibleTo("MongoDB")] +[assembly: InternalsVisibleTo("SqlServer")] + +[assembly: ActivitySourceGeneration("Purview.EventSourcing")] +[assembly: MeterGeneration("Purview.EventSourcing")] diff --git a/src/src/EventSourcing/QueryableEventStoreFacade.cs b/src/src/EventSourcing/QueryableEventStoreFacade.cs index 507cb5f6..22e72274 100644 --- a/src/src/EventSourcing/QueryableEventStoreFacade.cs +++ b/src/src/EventSourcing/QueryableEventStoreFacade.cs @@ -3,6 +3,7 @@ using System.Linq.Expressions; using Microsoft.Extensions.DependencyInjection; using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Internal; namespace Purview.EventSourcing; @@ -87,6 +88,15 @@ public Task ExistsAsync(string aggregateId, CancellationToken ca public T FulfilRequirements(T aggregate) where T : class, IAggregate, new() => GetQueryableEventStore().FulfilRequirements(aggregate); + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) + where T : class, IAggregate, new() => + GetQueryableEventStore().GetEventRangeAsync(aggregateId, versionFrom, versionTo, cancellationToken); + public IAsyncEnumerable GetQueryEnumerableAsync( Expression> whereClause, Func, IQueryable>? orderByClause, diff --git a/src/src/EventSourcing/README.md b/src/src/EventSourcing/README.md index 56c8a377..9b215b3b 100644 --- a/src/src/EventSourcing/README.md +++ b/src/src/EventSourcing/README.md @@ -14,6 +14,7 @@ dotnet add package Purview.EventSourcing - `IEventStore` and `IQueryableEventStore` - `IEventStoreTransactionFactory` and transaction result types - Source generation for aggregate events and command methods +- Embedded AI agent skills for aggregate design, validation, and value-object modeling - Common extension points used by provider packages - Dependency injection helpers for core framework services @@ -40,5 +41,20 @@ await store.SaveAsync(order, cancellationToken); ## Documentation -- Repository README: https://github.com/kjldev/purview-eventsourcing/blob/main/README.md -- SQL Server guide: https://github.com/kjldev/purview-eventsourcing/blob/main/docs/wiki/SQL-Server-Guide.md +- [Repository README](https://github.com/kjldev/purview-eventsourcing/blob/main/README.md) +- [SQL Server guide](https://github.com/kjldev/purview-eventsourcing/blob/main/docs/wiki/SQL-Server-Guide.md) +- [Provider feature matrix](https://github.com/kjldev/purview-eventsourcing/blob/main/docs/wiki/Provider-Feature-Matrix.md) + +When using snapshot-backed providers, especially SQL Server, read the provider docs before assuming deep predicates through complex scalar value object `.Value` members will translate. + +## Agent skill integration + +When installed from NuGet, `Purview.EventSourcing` copies bundled agent skills into `.agents\skills\` in the consuming repository so supported coding agents can discover framework-specific guidance automatically. + +To opt out, set: + +```xml + + false + +``` diff --git a/src/src/EventSourcing/Serialization/GenerateValueObjectDefaultsAttribute.cs b/src/src/EventSourcing/Serialization/GenerateValueObjectDefaultsAttribute.cs new file mode 100644 index 00000000..579a2336 --- /dev/null +++ b/src/src/EventSourcing/Serialization/GenerateValueObjectDefaultsAttribute.cs @@ -0,0 +1,19 @@ +namespace Purview.EventSourcing.Serialization; + +/// +/// Specifies assembly-level defaults for value object code generation. +/// These defaults can be overridden on individual [ValueObject] attributes. +/// +[AttributeUsage(AttributeTargets.Assembly)] +public sealed class GenerateValueObjectDefaultsAttribute : Attribute +{ + /// + /// Gets or sets whether parameterless constructors should be generated for value objects. + /// When true, generates a private parameterless constructor for EF Core compatibility. + /// Individual [ValueObject] attributes can override this setting. + /// Default: true + /// + public bool GenerateConstructor { get; init; } = true; + + public GenerateValueObjectDefaultsAttribute() { } +} diff --git a/src/src/EventSourcing/Serialization/ValueObjectAttribute.cs b/src/src/EventSourcing/Serialization/ValueObjectAttribute.cs index bccbce63..e55b0527 100644 --- a/src/src/EventSourcing/Serialization/ValueObjectAttribute.cs +++ b/src/src/EventSourcing/Serialization/ValueObjectAttribute.cs @@ -11,5 +11,7 @@ public sealed class ValueObjectAttribute : Attribute public bool GenerateEmpty { get; init; } = true; + public bool GenerateConstructor { get; init; } = true; + public ValueObjectDeserializationMode DeserializationMode { get; init; } = ValueObjectDeserializationMode.Hydrate; } diff --git a/src/src/EventSourcing/Services/AggregateValidatorAdapter.cs b/src/src/EventSourcing/Services/AggregateValidatorAdapter.cs deleted file mode 100644 index bdc54e07..00000000 --- a/src/src/EventSourcing/Services/AggregateValidatorAdapter.cs +++ /dev/null @@ -1,16 +0,0 @@ -using FluentValidation; -using Purview.EventSourcing.Aggregates; - -namespace Purview.EventSourcing.Services; - -static class AggregateValidatorAdapter -{ - public static IAggregateValidator? Adapt(IValidator? validator) - where TAggregate : IAggregate - { - return validator is null - ? null - : validator as IAggregateValidator - ?? new FluentValidationAggregateValidator(validator); - } -} diff --git a/src/src/EventSourcing/Services/DefaultAggregateValidator.cs b/src/src/EventSourcing/Services/DefaultAggregateValidator.cs index 14e9941c..d5b98a4f 100644 --- a/src/src/EventSourcing/Services/DefaultAggregateValidator.cs +++ b/src/src/EventSourcing/Services/DefaultAggregateValidator.cs @@ -1,5 +1,5 @@ -using FluentValidation; -using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Validation; namespace Purview.EventSourcing.Services; @@ -7,9 +7,7 @@ namespace Purview.EventSourcing.Services; /// A default validator for 's based on /// standard data annotations. /// -public sealed class DefaultAggregateValidator - : AbstractValidator, - IAggregateValidator +public sealed class DefaultAggregateValidator : IAggregateValidator where TAggregate : IAggregate { /// @@ -18,28 +16,31 @@ public sealed class DefaultAggregateValidator [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1000:Do not declare static members on generic types")] public static IAggregateValidator Instance { get; } = new DefaultAggregateValidator(); - DefaultAggregateValidator() + public ValidationResult Validate(TAggregate aggregate) { - RuleFor(m => m) - .Custom( - (aggregate, context) => - { - System.ComponentModel.DataAnnotations.ValidationContext daContext = new(aggregate); - List failures = []; - - if ( - !System.ComponentModel.DataAnnotations.Validator.TryValidateObject( - aggregate, - daContext, - failures, - true - ) - ) - { - foreach (var failure in failures) - context.AddFailure(failure.MemberNames.FirstOrDefault(), failure.ErrorMessage); - } - } - ); + ArgumentNullException.ThrowIfNull(aggregate); + + var failures = ValidateWithAnnotations(aggregate); + return new ValidationResult(failures); + } + + public Task ValidateAsync(TAggregate aggregate, CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(aggregate); + + var failures = ValidateWithAnnotations(aggregate); + return Task.FromResult(new ValidationResult(failures)); + } + + static IEnumerable ValidateWithAnnotations(TAggregate aggregate) + { + System.ComponentModel.DataAnnotations.ValidationContext daContext = new(aggregate); + List failures = []; + + if (!System.ComponentModel.DataAnnotations.Validator.TryValidateObject(aggregate, daContext, failures, true)) + { + foreach (var failure in failures) + yield return new ValidationFailure(failure.MemberNames.FirstOrDefault(), failure.ErrorMessage); + } } } diff --git a/src/src/EventSourcing/Services/FluentValidationAggregateValidator.cs b/src/src/EventSourcing/Services/FluentValidationAggregateValidator.cs deleted file mode 100644 index 793def28..00000000 --- a/src/src/EventSourcing/Services/FluentValidationAggregateValidator.cs +++ /dev/null @@ -1,17 +0,0 @@ -using FluentValidation; -using FluentValidation.Results; -using Purview.EventSourcing.Aggregates; - -namespace Purview.EventSourcing.Services; - -public sealed class FluentValidationAggregateValidator(IValidator validator) - : IAggregateValidator - where TAggregate : IAggregate -{ - readonly IValidator _validator = validator; - - public ValidationResult Validate(TAggregate aggregate) => _validator.Validate(aggregate); - - public Task ValidateAsync(TAggregate aggregate, CancellationToken cancellationToken = default) => - _validator.ValidateAsync(aggregate, cancellationToken); -} diff --git a/src/src/EventSourcing/Services/IAggregateValidator.cs b/src/src/EventSourcing/Services/IAggregateValidator.cs index a7a5d8ac..211c341e 100644 --- a/src/src/EventSourcing/Services/IAggregateValidator.cs +++ b/src/src/EventSourcing/Services/IAggregateValidator.cs @@ -1,5 +1,5 @@ -using FluentValidation.Results; using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Validation; namespace Purview.EventSourcing.Services; diff --git a/src/src/EventSourcing/EventStoreCachingOptions.cs b/src/src/EventSourcing/SnapshotCachingOptions.cs similarity index 94% rename from src/src/EventSourcing/EventStoreCachingOptions.cs rename to src/src/EventSourcing/SnapshotCachingOptions.cs index 89e831ba..c7e54a0a 100644 --- a/src/src/EventSourcing/EventStoreCachingOptions.cs +++ b/src/src/EventSourcing/SnapshotCachingOptions.cs @@ -4,7 +4,7 @@ /// Controls how the cache is used in operations. /// [Flags] -public enum EventStoreCachingOptions +public enum SnapshotCachingOptions { /// /// Disables the cache completely. diff --git a/src/src/EventSourcing/Validation/ValidationException.cs b/src/src/EventSourcing/Validation/ValidationException.cs new file mode 100644 index 00000000..bca055f6 --- /dev/null +++ b/src/src/EventSourcing/Validation/ValidationException.cs @@ -0,0 +1,57 @@ +namespace Purview.EventSourcing.Validation; + +/// +/// Thrown when aggregate validation fails (e.g. via ). +/// +public sealed class ValidationException : Exception +{ + /// + /// The validation failures that caused this exception. + /// + public IReadOnlyList Errors { get; } + + /// + /// Constructs a new . + /// + public ValidationException() + : base("Validation failed.") + { + Errors = []; + } + + /// + /// Constructs a new with the given failures. + /// + public ValidationException(IEnumerable errors) + : base("Validation failed: " + string.Join("; ", errors.Select(e => e.ErrorMessage))) + { + Errors = [.. errors]; + } + + /// + /// Constructs a new with the given message and failures. + /// + public ValidationException(string message, IEnumerable errors) + : base(message) + { + Errors = [.. errors]; + } + + /// + /// Constructs a new with the given message. + /// + public ValidationException(string message) + : base(message) + { + Errors = []; + } + + /// + /// Constructs a new with the given message and inner exception. + /// + public ValidationException(string message, Exception innerException) + : base(message, innerException) + { + Errors = []; + } +} diff --git a/src/src/EventSourcing/Validation/ValidationFailure.cs b/src/src/EventSourcing/Validation/ValidationFailure.cs new file mode 100644 index 00000000..13be46f4 --- /dev/null +++ b/src/src/EventSourcing/Validation/ValidationFailure.cs @@ -0,0 +1,26 @@ +namespace Purview.EventSourcing.Validation; + +/// +/// Represents a single validation failure. +/// +public sealed record ValidationFailure +{ + /// + /// The name of the property that failed validation, or if the failure is aggregate-wide. + /// + public string? PropertyName { get; init; } + + /// + /// The error message describing the failure. + /// + public string? ErrorMessage { get; init; } + + /// + /// Constructs a new . + /// + public ValidationFailure(string? propertyName, string? errorMessage) + { + PropertyName = propertyName; + ErrorMessage = errorMessage; + } +} diff --git a/src/src/EventSourcing/Validation/ValidationResult.cs b/src/src/EventSourcing/Validation/ValidationResult.cs new file mode 100644 index 00000000..e1f07939 --- /dev/null +++ b/src/src/EventSourcing/Validation/ValidationResult.cs @@ -0,0 +1,32 @@ +namespace Purview.EventSourcing.Validation; + +/// +/// Represents the result of validating an aggregate. +/// +/// +/// Constructs a new with the given failures. +/// +/// The validation failures. Pass an empty collection for a successful result. +public sealed class ValidationResult(IEnumerable failures) +{ + /// + /// A static instance representing a successful validation with no errors. + /// + public static ValidationResult Success { get; } = new([]); + + /// + /// Constructs a new successful with no errors. + /// + public ValidationResult() + : this([]) { } + + /// + /// when there are no ; otherwise . + /// + public bool IsValid => Errors.Count == 0; + + /// + /// The collection of s produced during validation. + /// + public IReadOnlyList Errors { get; } = [.. failures]; +} diff --git a/src/src/EventSourcing/build/Purview.EventSourcing.props b/src/src/EventSourcing/build/Purview.EventSourcing.props deleted file mode 100644 index 2a43b0d8..00000000 --- a/src/src/EventSourcing/build/Purview.EventSourcing.props +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/src/src/EventSourcing/buildTransitive/Purview.EventSourcing.targets b/src/src/EventSourcing/buildTransitive/Purview.EventSourcing.targets new file mode 100644 index 00000000..6e23d504 --- /dev/null +++ b/src/src/EventSourcing/buildTransitive/Purview.EventSourcing.targets @@ -0,0 +1,52 @@ + + + + <_EmbeddedAgentSkillFiles Include="$(MSBuildThisFileDirectory)..\skills\**\*" /> + + + + + + + + <_SkillRepoRoot>@(_EmbeddedAgentGitRepoRoot) + <_SkillRepoRoot + Condition="'$(_SkillRepoRoot)' == '' and '$(SolutionDir)' != '' and '$(SolutionDir)' != '*Undefined*'" + >$(SolutionDir) + <_SkillAgentsMd Condition="'$(_SkillRepoRoot)' == ''" + >$([MSBuild]::GetPathOfFileAbove('AGENTS.md', '$(MSBuildProjectDirectory)')) + <_SkillRepoRoot Condition="'$(_SkillRepoRoot)' == '' and '$(_SkillAgentsMd)' != ''" + >$([System.IO.Path]::GetDirectoryName('$(_SkillAgentsMd)'))\ + + + + <_EmbeddedAgentSkillCopy Include="@(_EmbeddedAgentSkillFiles)"> + $(_SkillRepoRoot)\.agents\skills\%(RecursiveDir)%(Filename)%(Extension) + + + + + + + + diff --git a/src/src/FluentValidationImpl/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs b/src/src/FluentValidationImpl/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..10bbaf53 --- /dev/null +++ b/src/src/FluentValidationImpl/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs @@ -0,0 +1,64 @@ +using System.ComponentModel; +using System.Diagnostics.CodeAnalysis; +using FluentValidation; +using Purview.EventSourcing.FluentValidation.Services; +using Purview.EventSourcing.Services; + +namespace Microsoft.Extensions.DependencyInjection; + +[EditorBrowsable(EditorBrowsableState.Never)] +public static class ServiceCollectionExtensions +{ + /// + /// Registers a adapter + /// for the specified aggregate type, wrapping the registered + /// . + /// + /// The aggregate type. + /// The FluentValidation validator implementation. + /// The service collection. + /// The lifetime used to register the validator + /// The for fluent chaining. + public static IServiceCollection AddFluentValidationAdapter( + [NotNull] this IServiceCollection services, + ServiceLifetime lifetime = ServiceLifetime.Singleton + ) + where TAggregate : Purview.EventSourcing.Aggregates.IAggregate + where TValidator : class, IValidator + { + services.Add(new(typeof(IValidator), typeof(TValidator), lifetime)); + services.AddSingleton, FluentValidationAggregateValidator>(); + + return services; + } + + /// + /// Registers a adapter + /// using a factory that resolves from the container. + /// Use this when validators are already registered (e.g. via AddValidatorsFromAssembly). + /// + /// The aggregate type. + /// The service collection. + /// The lifetime used to register the validator + /// The for fluent chaining. + public static IServiceCollection AddFluentValidationAdapter( + [NotNull] this IServiceCollection services, + ServiceLifetime lifetime = ServiceLifetime.Singleton + ) + where TAggregate : Purview.EventSourcing.Aggregates.IAggregate + { + services.Add( + new( + typeof(IValidator), + sp => + { + var validator = sp.GetService>(); + return validator is null ? null! : new FluentValidationAggregateValidator(validator); + }, + lifetime + ) + ); + + return services; + } +} diff --git a/src/src/FluentValidationImpl/FluentValidationImpl.csproj b/src/src/FluentValidationImpl/FluentValidationImpl.csproj new file mode 100644 index 00000000..b9baca1b --- /dev/null +++ b/src/src/FluentValidationImpl/FluentValidationImpl.csproj @@ -0,0 +1,18 @@ + + + true + Purview Event Sourcing FluentValidation Integration + FluentValidation adapter for Purview EventSourcing — bridges FluentValidation IValidator<T> with IAggregateValidator<T>. + $(PackageTags);purview;dotnet;event-sourcing;validation;fluentvalidation; + Purview.EventSourcing.FluentValidation + Purview.EventSourcing.FluentValidation + + + + + + + + + + diff --git a/src/src/FluentValidationImpl/Properties/AssemblyInfo.cs b/src/src/FluentValidationImpl/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..d5bcb5fd --- /dev/null +++ b/src/src/FluentValidationImpl/Properties/AssemblyInfo.cs @@ -0,0 +1,4 @@ +using Purview.Telemetry; + +[assembly: ActivitySourceGeneration("Purview.EventSourcing.FluentValidation")] +[assembly: MeterGeneration("Purview.EventSourcing.FluentValidation")] diff --git a/src/src/FluentValidationImpl/Services/FluentValidationAggregateValidator.cs b/src/src/FluentValidationImpl/Services/FluentValidationAggregateValidator.cs new file mode 100644 index 00000000..117eb4b6 --- /dev/null +++ b/src/src/FluentValidationImpl/Services/FluentValidationAggregateValidator.cs @@ -0,0 +1,38 @@ +using FluentValidation; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Services; +using Purview.EventSourcing.Validation; + +namespace Purview.EventSourcing.FluentValidation.Services; + +/// +/// Adapts a to the +/// interface, mapping FluentValidation +/// results to . +/// +public sealed class FluentValidationAggregateValidator(IValidator validator) + : IAggregateValidator + where TAggregate : IAggregate +{ + readonly IValidator _validator = validator; + + public ValidationResult Validate(TAggregate aggregate) => Map(_validator.Validate(aggregate)); + + public async Task ValidateAsync( + TAggregate aggregate, + CancellationToken cancellationToken = default + ) + { + var result = await _validator.ValidateAsync(aggregate, cancellationToken); + return Map(result); + } + + static ValidationResult Map(global::FluentValidation.Results.ValidationResult result) + { + if (result.IsValid) + return ValidationResult.Success; + + var failures = result.Errors.Select(e => new ValidationFailure(e.PropertyName, e.ErrorMessage)); + return new ValidationResult(failures); + } +} diff --git a/src/src/ImplementationShared/Extensions/Microsoft/Extensions/Configuration/ConfigurationExtensions.cs b/src/src/ImplementationShared/Extensions/Microsoft/Extensions/Configuration/ConfigurationExtensions.cs new file mode 100644 index 00000000..e71e18bd --- /dev/null +++ b/src/src/ImplementationShared/Extensions/Microsoft/Extensions/Configuration/ConfigurationExtensions.cs @@ -0,0 +1,34 @@ +using System.ComponentModel; +using Purview.EventSourcing.Guards; + +namespace Microsoft.Extensions.Configuration; + +[EditorBrowsable(EditorBrowsableState.Never)] +public static class ConfigurationExtensions +{ + extension(IConfiguration configuration) + { + public string GetRequiredConnectionString(params string?[] keys) + { + keys = NotNull(keys); + + var result = GetConnectionString(configuration, keys); + + return result.Required( + trim: true, + customExceptionMessage: $"No connection string found for keys: {string.Join(", ", keys)}" + ); + } + + public string GetRequiredConnectionString(IEnumerable keys) => + GetRequiredConnectionString(configuration, keys?.ToArray()!); + + public string? GetConnectionString(string?[] keys) => + NotNull(keys) + .Select(x => configuration.GetConnectionString(x!)) + .FirstOrDefault(key => !string.IsNullOrWhiteSpace(key)); + + static string[] NotNull(IEnumerable keys) => + keys?.Where(key => !string.IsNullOrWhiteSpace(key)).Cast().ToArray() ?? []; + } +} diff --git a/src/src/ImplementationShared/ImplementationShared.csproj b/src/src/ImplementationShared/ImplementationShared.csproj new file mode 100644 index 00000000..d08142c6 --- /dev/null +++ b/src/src/ImplementationShared/ImplementationShared.csproj @@ -0,0 +1,14 @@ + + + false + Purview.EventSourcing + + + + + + + + + + diff --git a/src/src/ImplementationShared/Properties/AssemblyInfo.cs b/src/src/ImplementationShared/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..82b0f32a --- /dev/null +++ b/src/src/ImplementationShared/Properties/AssemblyInfo.cs @@ -0,0 +1,4 @@ +using Purview.Telemetry; + +[assembly: ActivitySourceGeneration("Purview.EventSourcing")] +[assembly: MeterGeneration("Purview.EventSourcing")] diff --git a/src/src/InMemory/Events/IInMemoryEventStore.cs b/src/src/InMemory/Events/IInMemoryEventStore.cs new file mode 100644 index 00000000..1fc994ce --- /dev/null +++ b/src/src/InMemory/Events/IInMemoryEventStore.cs @@ -0,0 +1,10 @@ +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Internal; + +namespace Purview.EventSourcing.InMemory.Events; + +public interface IInMemoryEventStore : INonQueryableEventStore, IAggregateEventHistoryStoreCore + where T : class, IAggregate, new() +{ + Task ClearAsync(CancellationToken cancellationToken = default); +} diff --git a/src/src/InMemory/Events/InMemoryEventStore.ExceptionHelpers.cs b/src/src/InMemory/Events/InMemoryEventStore.ExceptionHelpers.cs new file mode 100644 index 00000000..c4a9c118 --- /dev/null +++ b/src/src/InMemory/Events/InMemoryEventStore.ExceptionHelpers.cs @@ -0,0 +1,18 @@ +namespace Purview.EventSourcing.InMemory.Events; + +[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0060:Remove unused parameter")] +partial class InMemoryEventStore +{ + static ArgumentNullException NullAggregate(T? aggregate) => new(nameof(aggregate)); + + static Exception AggregateIsDeletedException(string aggregateId) => + new($"Aggregate with ID '{aggregateId}' is deleted."); + + static Exception AggregateNotDeletedException(string aggregateId) => + new($"Aggregate with ID '{aggregateId}' is not deleted."); + + static Exception MissingAggregateIdException() => new("Aggregate ID is missing."); + + static Exception AggregateLockedException(string aggregateId) => + new($"Aggregate with ID '{aggregateId}' is locked."); +} diff --git a/src/src/InMemory/Events/InMemoryEventStore.cs b/src/src/InMemory/Events/InMemoryEventStore.cs new file mode 100644 index 00000000..e778b259 --- /dev/null +++ b/src/src/InMemory/Events/InMemoryEventStore.cs @@ -0,0 +1,409 @@ +using System.Collections.Concurrent; +using System.Security.Claims; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; +using Purview.EventSourcing.Services; +using Purview.EventSourcing.Validation; + +namespace Purview.EventSourcing.InMemory.Events; + +public partial class InMemoryEventStore( + ChangeFeed.IAggregateChangeFeedNotifier aggregateChangeNotifier, + IAggregateRequirementsManager aggregateRequirementsManager, + IAggregateValidator? validator = null, + IAggregateIdFactory? aggregateIdFactory = null +) : IInMemoryEventStore, IDisposable + where T : class, IAggregate, new() +{ + readonly ConcurrentDictionary _aggregates = new(StringComparer.OrdinalIgnoreCase); + readonly ConcurrentDictionary> _events = new(); + + readonly IAggregateValidator? _validator = validator; + + protected IEnumerable Aggregates => _aggregates.Values; + + public Task ClearAsync(CancellationToken cancellationToken = default) + { + cancellationToken.ThrowIfCancellationRequested(); + + _aggregates.Clear(); + _events.Clear(); + + return Task.CompletedTask; + } + + static Task ReturnAggregateAsync(bool isDeleted, string aggregateId, EventStoreOperationContext context) + { + if (isDeleted) + { + switch (context.DeleteMode) + { + case DeleteHandlingMode.ThrowsException: + throw AggregateIsDeletedException(aggregateId); + case DeleteHandlingMode.ReturnsNull: + return Task.FromResult(false); + } + } + + return Task.FromResult(true); + } + + public async Task CreateAsync(string? aggregateId = null, CancellationToken cancellationToken = default) + { + if (string.IsNullOrWhiteSpace(aggregateId)) + { + if (aggregateIdFactory != null) + { + aggregateId = await aggregateIdFactory.CreateAsync(cancellationToken); + if (string.IsNullOrWhiteSpace(aggregateId)) + throw new NullReferenceException( + $"The {typeof(IAggregateIdFactory).FullName} implementation ({aggregateIdFactory.GetType().FullName}) generated a null or empty Id." + ); + } + else + aggregateId = $"{Guid.NewGuid()}:D"; + } + + var aggregate = new T { Details = { Id = aggregateId } }; + + return FulfilRequirements(aggregate); + } + + public async Task DeleteAsync( + T aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + if (aggregate == null) + throw NullAggregate(aggregate); + + if (aggregate.Details.IsDeleted) + throw AggregateIsDeletedException(aggregate.Id()); + + operationContext ??= EventStoreOperationContext.DefaultContext(); + + if (aggregate.IsNew()) + return false; + + if (operationContext.PermanentlyDelete) + { + RemoveFromCache(aggregate); + return true; + } + + Deleted deleteAggregateEvent = new() + { + Details = { AggregateVersion = aggregate.Details.CurrentVersion + 1, When = DateTimeOffset.UtcNow }, + }; + aggregate.ApplyEvent(deleteAggregateEvent); + + await AddToCacheAsync(aggregate, deleteAggregateEvent); + + return true; + } + + void RemoveFromCache(T aggregate) + { + _aggregates.TryRemove(aggregate.Id(), out _); + if (_events.TryRemove(aggregate.Id(), out var events)) + events.Clear(); + } + + Task AddToCacheAsync(T aggregate, params IEvent[] additionalEvents) => + AddToCache(aggregate, true, additionalEvents); + + Task AddToCache(T aggregate, bool fulfilRequirements, params IEvent[] additionalEvents) + { + var events = _events.GetOrAdd(aggregate.Id(), _ => new()); + foreach (var @event in aggregate.GetUnsavedEvents().Concat(additionalEvents ?? [])) + { + if (events.TryAdd(@event.Details.AggregateVersion, @event)) + { + // + } + } + + aggregate.ClearUnsavedEvents(); + + _aggregates.AddOrUpdate(aggregate.Id(), aggregate, (key, existingAggregate) => aggregate); + + if (fulfilRequirements) + FulfilRequirements(aggregate); + + return Task.FromResult(aggregate); + } + + public async Task ExistsAsync(string aggregateId, CancellationToken cancellationToken = default) + { + await Task.CompletedTask; + + return _aggregates.TryGetValue(aggregateId, out var aggregate) + ? aggregate.Details.IsDeleted + ? ExistsState.ExistsInDeletedState with + { + Version = aggregate.Details.CurrentVersion, + } + : ExistsState.Exists with + { + Version = aggregate.Details.CurrentVersion, + } + : ExistsState.DoesNotExist; + } + + public T FulfilRequirements(T aggregate) + { + aggregateRequirementsManager.Fulfil(aggregate); + + return aggregate; + } + + public IAsyncEnumerable GetAggregateIdsAsync( + bool includeDeleted, + CancellationToken cancellationToken = default + ) + { + var results = _aggregates.Values.AsEnumerable(); + if (!includeDeleted) + results = results.Where(a => !a.Details.IsDeleted); + + return results.Select(a => a.Id()).ToAsyncEnumerable(); + } + + public async Task GetAsync( + string aggregateId, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); + + operationContext ??= EventStoreOperationContext.DefaultContext(); + + if (_aggregates.TryGetValue(aggregateId, out var aggregate)) + { + if (!await ReturnAggregateAsync(aggregate.Details.IsDeleted, aggregateId, operationContext)) + return null; + } + + aggregate ??= new T { Details = { Id = aggregateId } }; + return await AddToCacheAsync(aggregate); + } + + public async Task GetAtAsync( + string aggregateId, + int version, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + var exists = await ExistsAsync(aggregateId, cancellationToken); + if (!exists) + return null; + + var aggregate = new T() { Details = new() { Id = aggregateId } }; + + var events = GetEventRangeAsync(aggregateId, 1, version, cancellationToken); + await foreach (var @event in events.WithCancellation(cancellationToken)) + aggregate.ApplyEvent(@event.@event); + + return FulfilRequirements(aggregate); + } + + public async Task GetDeletedAsync(string aggregateId, CancellationToken cancellationToken = default) + { + var aggregate = await GetAsync( + aggregateId, + new() { DeleteMode = DeleteHandlingMode.ReturnsAggregate }, + cancellationToken + ); + + return aggregate == null ? null + : aggregate.Details.IsDeleted ? FulfilRequirements(aggregate) + : throw AggregateNotDeletedException(aggregateId); + } + + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) + { + if (!_events.TryGetValue(aggregateId, out var eventList)) + return AsyncEnumerable.Empty<(IEvent @event, string eventType)>(); + + // We have some events... so query and return. + return eventList + .Where(kvp => kvp.Key >= versionFrom && (!versionTo.HasValue || kvp.Key <= versionTo.Value)) + .OrderBy(kvp => kvp.Key) + .Select(kvp => (kvp.Value, kvp.Value.GetType().Name)) + .ToAsyncEnumerable(); + } + + public async Task GetOrCreateAsync( + string? aggregateId, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + if (!string.IsNullOrWhiteSpace(aggregateId)) + { + var exists = await ExistsAsync(aggregateId, cancellationToken); + if (exists) + return await GetAsync(aggregateId, operationContext, cancellationToken); + } + + return await CreateAsync(aggregateId, cancellationToken); + } + + public async Task IsDeletedAsync(string aggregateId, CancellationToken cancellationToken = default) => + await ExistsAsync(aggregateId, cancellationToken) + && (_aggregates.TryGetValue(aggregateId, out var aggregate) && aggregate.Details.IsDeleted); + + public async Task RestoreAsync( + T aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + if (aggregate == null) + throw NullAggregate(aggregate); + + if (!aggregate.Details.IsDeleted) + throw AggregateNotDeletedException(aggregate.Id()); + + Restored restoreAggregateEvent = new() + { + Details = { AggregateVersion = aggregate.Details.CurrentVersion + 1, When = DateTimeOffset.UtcNow }, + }; + aggregate.ApplyEvent(restoreAggregateEvent); + + if (aggregate.IsNew()) + return false; + + await AddToCacheAsync(aggregate, restoreAggregateEvent); + + return true; + } + + public async Task> SaveAsync( + T aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + operationContext ??= EventStoreOperationContext.DefaultContext(); + + FulfilRequirements(aggregate); + var validationResult = await GuardAsync(aggregate, cancellationToken); + + static SaveResult ReturnSaveResult( + T a, + bool success, + bool skipped, + ValidationResult? validationResult = null + ) => new(a, validationResult ?? new ValidationResult(), success, skipped); + + if (!validationResult.IsValid) + return ReturnSaveResult(aggregate, false, false, validationResult); + + if (aggregate.Details.Locked) + { + return operationContext.LockMode is LockHandlingMode.ThrowsException + ? throw AggregateLockedException(aggregate.Id()) + : ReturnSaveResult(aggregate, false, false); + } + + if (string.IsNullOrWhiteSpace(aggregate.Details.Id)) + throw MissingAggregateIdException(); + + if (!aggregate.HasUnsavedEvents()) + return ReturnSaveResult(aggregate, false, true); + + var isNew = aggregate.IsNew(); + var previousAggregateVersion = aggregate.Details.CurrentVersion; + var changeEvents = aggregate.GetUnsavedEvents().ToArray(); + + if ( + operationContext.NotificationMode.HasFlag(NotificationModes.BeforeDelete) + && changeEvents.OfType().Any() + ) + await aggregateChangeNotifier.BeforeDeleteAsync(aggregate, cancellationToken); + else if (operationContext.NotificationMode.HasFlag(NotificationModes.BeforeSave)) + await aggregateChangeNotifier.BeforeSaveAsync(aggregate, isNew, cancellationToken); + + if (await IsDeletedAsync(aggregate.Id(), cancellationToken)) + { + var throwIfDeleted = !changeEvents.OfType().Any(); + if (throwIfDeleted) + throw AggregateIsDeletedException(aggregate.Id()); + } + + try + { + var userId = ClaimsPrincipal.Current?.FindFirst(operationContext.ClaimIdentifier)?.Value; + if (operationContext.RequiresValidPrincipalIdentifier && string.IsNullOrWhiteSpace(userId)) + throw new NullReferenceException( + $"Missing ClaimsPrincipal identifier '{operationContext.ClaimIdentifier}'. Unable to save aggregate." + ); + + await AddToCacheAsync(aggregate); + + if (aggregateChangeNotifier != null) + { + if ( + aggregate.Details.IsDeleted + && operationContext.NotificationMode.HasFlag(NotificationModes.AfterDelete) + ) + await aggregateChangeNotifier.AfterDeleteAsync(aggregate, cancellationToken); + else if (operationContext.NotificationMode.HasFlag(NotificationModes.AfterSave)) + await aggregateChangeNotifier.AfterSaveAsync( + aggregate, + previousAggregateVersion, + isNew, + changeEvents, + cancellationToken + ); + } + } + catch (Exception ex) + { + RemoveFromCache(aggregate); + + if (operationContext.NotificationMode.HasFlag(NotificationModes.OnFailure)) + { + var deleteRequested = changeEvents.OfType().Any(); + await aggregateChangeNotifier.FailureAsync(aggregate, deleteRequested, ex, cancellationToken); + } + + throw; + } + + return ReturnSaveResult(aggregate, true, false); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + _aggregates.Clear(); + _events.Clear(); + } + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + async Task GuardAsync(T aggregate, CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(aggregate, nameof(aggregate)); + + return _validator == null + ? await DefaultAggregateValidator.Instance.ValidateAsync(aggregate, cancellationToken) + : await _validator.ValidateAsync(aggregate, cancellationToken); + } +} diff --git a/src/src/InMemory/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs b/src/src/InMemory/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..374b4874 --- /dev/null +++ b/src/src/InMemory/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs @@ -0,0 +1,46 @@ +using System.ComponentModel; +using Purview.EventSourcing.InMemory.Events; +using Purview.EventSourcing.InMemory.Snapshots; +using Purview.EventSourcing.Internal; + +namespace Microsoft.Extensions.DependencyInjection; + +[EditorBrowsable(EditorBrowsableState.Never)] +public static class ServiceCollectionExtensions +{ + extension(IServiceCollection services) + { + public IServiceCollection AddInMemoryEventStore() + { + services.AddEventSourcing(); + + services + .AddTransient(typeof(IEventStoreCore<>), typeof(InMemoryEventStore<>)) + .AddTransient(typeof(INonQueryableEventStore<>), typeof(InMemoryEventStore<>)) + .AddTransient(typeof(IInMemoryEventStore<>), typeof(InMemoryEventStore<>)) + .AddTransient(); + + return services; + } + + public IServiceCollection AddInMemorySnapshotEventStore() + { + services.AddEventSourcing(); + + services + // Non-queryable + .AddTransient(typeof(IEventStoreCore<>), typeof(InMemorySnapshotStore<>)) + .AddTransient(typeof(INonQueryableEventStore<>), typeof(InMemorySnapshotStore<>)) + .AddTransient(typeof(IInMemoryEventStore<>), typeof(InMemorySnapshotStore<>)) + // Queryable + .AddTransient(typeof(IQueryableEventStoreCore<>), typeof(InMemorySnapshotStore<>)) + .AddTransient(typeof(IInMemorySnapshotStore<>), typeof(InMemorySnapshotStore<>)); + + services + .AddTransient() + .AddTransient(); + + return services; + } + } +} diff --git a/src/src/InMemory/InMemory.csproj b/src/src/InMemory/InMemory.csproj new file mode 100644 index 00000000..72c92342 --- /dev/null +++ b/src/src/InMemory/InMemory.csproj @@ -0,0 +1,17 @@ + + + true + Purview In-Memory Non-Queryable and Queryable Snapshot Store + In-memory non-queryable and queryable snapshot storage provider for Purview EventSourcing. + $(PackageTags);purview;dotnet;testing;event-sourcing;event-store;queryable-store;snapshot;in-memory; + Purview.EventSourcing.InMemory + + + + + + + diff --git a/src/src/InMemory/Properties/AssemblyInfo.cs b/src/src/InMemory/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..2bef18bb --- /dev/null +++ b/src/src/InMemory/Properties/AssemblyInfo.cs @@ -0,0 +1,7 @@ +using System.Runtime.CompilerServices; +using Purview.Telemetry; + +[assembly: InternalsVisibleTo("EventSourcing.UnitTests")] + +[assembly: ActivitySourceGeneration("Purview.EventSourcing.InMemory")] +[assembly: MeterGeneration("Purview.EventSourcing.InMemory")] diff --git a/src/src/InMemory/Snapshots/IInMemorySnapshotStore.cs b/src/src/InMemory/Snapshots/IInMemorySnapshotStore.cs new file mode 100644 index 00000000..43dba71f --- /dev/null +++ b/src/src/InMemory/Snapshots/IInMemorySnapshotStore.cs @@ -0,0 +1,6 @@ +using Purview.EventSourcing.Aggregates; + +namespace Purview.EventSourcing.InMemory.Snapshots; + +public interface IInMemorySnapshotStore : IQueryableEventStoreCore + where T : class, IAggregate, new() { } diff --git a/src/src/InMemory/Snapshots/InMemorySnapshotStore.cs b/src/src/InMemory/Snapshots/InMemorySnapshotStore.cs new file mode 100644 index 00000000..b561e15b --- /dev/null +++ b/src/src/InMemory/Snapshots/InMemorySnapshotStore.cs @@ -0,0 +1,139 @@ +using System.Diagnostics.CodeAnalysis; +using System.Globalization; +using System.Linq.Expressions; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Services; + +namespace Purview.EventSourcing.InMemory.Snapshots; + +public sealed class InMemorySnapshotStore( + ChangeFeed.IAggregateChangeFeedNotifier aggregateChangeNotifier, + IAggregateRequirementsManager aggregateRequirementsManager, + IAggregateValidator? validator = null, + IAggregateIdFactory? aggregateIdFactory = null +) + : Events.InMemoryEventStore( + aggregateChangeNotifier, + aggregateRequirementsManager, + validator, + aggregateIdFactory + ), + IInMemorySnapshotStore + where T : class, IAggregate, new() +{ + public Task CountAsync( + Expression>? whereClause, + CancellationToken cancellationToken = default + ) => Task.FromResult(whereClause is null ? Aggregates.LongCount() : Aggregates.LongCount(whereClause.Compile())); + + public Task FirstOrDefaultAsync( + Expression> whereClause, + Func, IQueryable>? orderByClause, + CancellationToken cancellationToken = default + ) + { + var results = Aggregates; + if (orderByClause != null) + results = orderByClause(results.AsQueryable()).AsEnumerable(); + + if (whereClause != null) + results = results.Where(whereClause.Compile()); + + return Task.FromResult(results.FirstOrDefault()); + } + + public IAsyncEnumerable GetListEnumerableAsync( + Func, IQueryable>? orderByClause, + int maxRecordsPerIteration = 20, + CancellationToken cancellationToken = default + ) + { + var results = Aggregates; + if (orderByClause != null) + results = orderByClause(results.AsQueryable()).AsEnumerable(); + + return results.ToAsyncEnumerable(); + } + + public IAsyncEnumerable GetQueryEnumerableAsync( + Expression> whereClause, + Func, IQueryable>? orderByClause, + int maxRecordsPerIteration = 20, + CancellationToken cancellationToken = default + ) + { + var results = Aggregates; + if (orderByClause != null) + results = orderByClause(results.AsQueryable()).AsEnumerable(); + + if (whereClause != null) + results = results.Where(whereClause.Compile()); + + return results.ToAsyncEnumerable(); + } + + public async Task> ListAsync( + Func, IQueryable>? orderByClause, + [NotNull] ContinuationRequest request, + CancellationToken cancellationToken = default + ) + { + var results = Aggregates; + if (orderByClause != null) + results = orderByClause(results.AsQueryable()).AsEnumerable(); + + var totalCount = request.IncludeTotalCount ? await CountAsync(null, cancellationToken) : -1L; + var skip = 0; + if (int.TryParse(request.ContinuationToken, out var continuationToken)) + skip = continuationToken; + + T[] resultsArray = [.. results.Skip(skip).Take(request.MaxRecords)]; + return new ContinuationResponse() + { + Results = resultsArray, + TotalCount = totalCount, + RequestedCount = request.MaxRecords, + ContinuationToken = (skip + resultsArray.Length).ToString(CultureInfo.InvariantCulture), + }; + } + + public async Task> QueryAsync( + Expression> whereClause, + Func, IQueryable>? orderByClause, + [NotNull] ContinuationRequest request, + CancellationToken cancellationToken = default + ) + { + var results = Aggregates; + if (orderByClause != null) + results = orderByClause(results.AsQueryable()).AsEnumerable(); + if (whereClause != null) + results = results.Where(whereClause.Compile()); + + var totalCount = request.IncludeTotalCount ? await CountAsync(null, cancellationToken) : -1L; + var skip = 0; + if (int.TryParse(request.ContinuationToken, out var continuationToken)) + skip = continuationToken; + + T[] resultsArray = [.. results.Skip(skip).Take(request.MaxRecords)]; + return new ContinuationResponse() + { + Results = resultsArray, + TotalCount = totalCount, + RequestedCount = request.MaxRecords, + ContinuationToken = (skip + resultsArray.Length).ToString(CultureInfo.InvariantCulture), + }; + } + + public Task SingleOrDefaultAsync( + Expression> whereClause, + CancellationToken cancellationToken = default + ) + { + var results = Aggregates; + if (whereClause != null) + results = results.Where(whereClause.Compile()); + + return Task.FromResult(results.SingleOrDefault()); + } +} diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/AggregateVersionData.cs b/src/src/MongoDB/Events/AggregateVersionData.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/AggregateVersionData.cs rename to src/src/MongoDB/Events/AggregateVersionData.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Entities/EntityTypes.cs b/src/src/MongoDB/Events/Entities/EntityTypes.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Entities/EntityTypes.cs rename to src/src/MongoDB/Events/Entities/EntityTypes.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Entities/EventEntity.cs b/src/src/MongoDB/Events/Entities/EventEntity.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Entities/EventEntity.cs rename to src/src/MongoDB/Events/Entities/EventEntity.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Entities/IdempotencyMarkerEntity.cs b/src/src/MongoDB/Events/Entities/IdempotencyMarkerEntity.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Entities/IdempotencyMarkerEntity.cs rename to src/src/MongoDB/Events/Entities/IdempotencyMarkerEntity.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Entities/SnapshotEntity.cs b/src/src/MongoDB/Events/Entities/SnapshotEntity.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Entities/SnapshotEntity.cs rename to src/src/MongoDB/Events/Entities/SnapshotEntity.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Entities/StreamVersionEntity.cs b/src/src/MongoDB/Events/Entities/StreamVersionEntity.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Entities/StreamVersionEntity.cs rename to src/src/MongoDB/Events/Entities/StreamVersionEntity.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateAlreadyDeletedException.cs b/src/src/MongoDB/Events/Exceptions/AggregateAlreadyDeletedException.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateAlreadyDeletedException.cs rename to src/src/MongoDB/Events/Exceptions/AggregateAlreadyDeletedException.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateDeletedException.cs b/src/src/MongoDB/Events/Exceptions/AggregateDeletedException.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateDeletedException.cs rename to src/src/MongoDB/Events/Exceptions/AggregateDeletedException.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateIsDeletedException.cs b/src/src/MongoDB/Events/Exceptions/AggregateIsDeletedException.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateIsDeletedException.cs rename to src/src/MongoDB/Events/Exceptions/AggregateIsDeletedException.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateLockedException.cs b/src/src/MongoDB/Events/Exceptions/AggregateLockedException.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateLockedException.cs rename to src/src/MongoDB/Events/Exceptions/AggregateLockedException.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateNotDeletedException.cs b/src/src/MongoDB/Events/Exceptions/AggregateNotDeletedException.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateNotDeletedException.cs rename to src/src/MongoDB/Events/Exceptions/AggregateNotDeletedException.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateStreamVersionMissingException.cs b/src/src/MongoDB/Events/Exceptions/AggregateStreamVersionMissingException.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregateStreamVersionMissingException.cs rename to src/src/MongoDB/Events/Exceptions/AggregateStreamVersionMissingException.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs b/src/src/MongoDB/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs rename to src/src/MongoDB/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/CommitException.cs b/src/src/MongoDB/Events/Exceptions/CommitException.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/CommitException.cs rename to src/src/MongoDB/Events/Exceptions/CommitException.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/ConcurrencyException.cs b/src/src/MongoDB/Events/Exceptions/ConcurrencyException.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/ConcurrencyException.cs rename to src/src/MongoDB/Events/Exceptions/ConcurrencyException.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/MissingAggregateIdException.cs b/src/src/MongoDB/Events/Exceptions/MissingAggregateIdException.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/Exceptions/MissingAggregateIdException.cs rename to src/src/MongoDB/Events/Exceptions/MissingAggregateIdException.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/IMongoDBEventStore.cs b/src/src/MongoDB/Events/IMongoDBEventStore.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/IMongoDBEventStore.cs rename to src/src/MongoDB/Events/IMongoDBEventStore.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/IMongoDBEventStoreStorageNameBuilder.cs b/src/src/MongoDB/Events/IMongoDBEventStoreStorageNameBuilder.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/IMongoDBEventStoreStorageNameBuilder.cs rename to src/src/MongoDB/Events/IMongoDBEventStoreStorageNameBuilder.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/IMongoDBEventStoreTelemetry.cs b/src/src/MongoDB/Events/IMongoDBEventStoreTelemetry.cs similarity index 96% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/IMongoDBEventStoreTelemetry.cs rename to src/src/MongoDB/Events/IMongoDBEventStoreTelemetry.cs index 2915e476..2331bb25 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/IMongoDBEventStoreTelemetry.cs +++ b/src/src/MongoDB/Events/IMongoDBEventStoreTelemetry.cs @@ -121,7 +121,11 @@ string blobEventTypeName void GetAggregateFailed(string aggregateId, string aggregateTypeFullName, Exception exception); [Warning] - void StreamVersionExpectedToExistButNotFound(string aggregateId); + void StreamVersionExpectedToExistButNotFound( + string aggregateId, + string aggregateTypeName, + string aggregateTypeFullName + ); [Debug] void StreamVersionNotFound(string aggregateId); diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.CreateAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.CreateAsync.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.CreateAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.CreateAsync.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.DeleteAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.DeleteAsync.cs similarity index 99% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.DeleteAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.DeleteAsync.cs index 667d7edc..08b04f84 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.DeleteAsync.cs +++ b/src/src/MongoDB/Events/MongoDBEventStore.DeleteAsync.cs @@ -17,7 +17,7 @@ public async Task DeleteAsync( if (aggregate.Details.IsDeleted) throw AggregateIsDeletedException(aggregate.Id()); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); if (aggregate.IsNew()) return false; diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.ExceptionHelpers.cs b/src/src/MongoDB/Events/MongoDBEventStore.ExceptionHelpers.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.ExceptionHelpers.cs rename to src/src/MongoDB/Events/MongoDBEventStore.ExceptionHelpers.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.ExistsAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.ExistsAsync.cs similarity index 94% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.ExistsAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.ExistsAsync.cs index 6e27d8e9..919906cd 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.ExistsAsync.cs +++ b/src/src/MongoDB/Events/MongoDBEventStore.ExistsAsync.cs @@ -8,7 +8,7 @@ public async Task ExistsAsync(string aggregateId, CancellationToken var streamVersion = await GetStreamVersionAsync(aggregateId, false, cancellationToken); return streamVersion == null - ? ExistsState.DoesNotExists + ? ExistsState.DoesNotExist : new ExistsState { Status = streamVersion.IsDeleted ? ExistsStatus.ExistsInDeletedState : ExistsStatus.Exists, diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.GetAsync.cs similarity index 98% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.GetAsync.cs index dda8acbd..99ee4af5 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetAsync.cs +++ b/src/src/MongoDB/Events/MongoDBEventStore.GetAsync.cs @@ -23,13 +23,13 @@ partial class MongoDBEventStore { ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); _eventStoreTelemetry.GetAggregateStart(aggregateId, _aggregateTypeFullName); var getStopwatch = System.Diagnostics.Stopwatch.StartNew(); try { - var aggregate = operationContext.CacheMode.HasFlag(EventStoreCachingOptions.GetFromCache) + var aggregate = operationContext.SnapshotCacheMode.HasFlag(SnapshotCachingOptions.GetFromCache) ? await GetFromCacheAsync(aggregateId, cancellationToken) : null; diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetAtAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.GetAtAsync.cs similarity index 99% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetAtAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.GetAtAsync.cs index 7714a31a..aebf490f 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetAtAsync.cs +++ b/src/src/MongoDB/Events/MongoDBEventStore.GetAtAsync.cs @@ -13,7 +13,7 @@ partial class MongoDBEventStore { ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); _eventStoreTelemetry.GetAggregateAtSpecificVersionStart(aggregateId, version, _aggregateTypeFullName); var getStopwatch = Stopwatch.StartNew(); diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetDeletedAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.GetDeletedAsync.cs similarity index 79% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetDeletedAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.GetDeletedAsync.cs index d6e0d8d5..7c2059b9 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetDeletedAsync.cs +++ b/src/src/MongoDB/Events/MongoDBEventStore.GetDeletedAsync.cs @@ -6,7 +6,7 @@ partial class MongoDBEventStore { var aggregate = await GetCoreAsync( aggregateId, - new() { CacheMode = EventStoreCachingOptions.None, DeleteMode = DeleteHandlingMode.ReturnsAggregate }, + new() { SnapshotCacheMode = SnapshotCachingOptions.None, DeleteMode = DeleteHandlingMode.ReturnsAggregate }, cancellationToken ); diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetEventRangeAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.GetEventRangeAsync.cs similarity index 95% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetEventRangeAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.GetEventRangeAsync.cs index cf16f3a2..ee1fbe03 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetEventRangeAsync.cs +++ b/src/src/MongoDB/Events/MongoDBEventStore.GetEventRangeAsync.cs @@ -104,6 +104,10 @@ static EventUnknown ReturnUnknownEvent(EventEntity eventEntity, int aggregateVer ?? throw new ApplicationException($"Unable to load event type: {eventType}"); var @event = DeserializeEvent(eventEntity.Payload, runtimeEventType); + // Apply upcasting chain when a registry is available. + if (@event != null && _eventUpcasterRegistry?.CanUpcast(@event) == true) + @event = _eventUpcasterRegistry.Upcast(@event); + return @event; } #pragma warning disable CA1031 diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetOrCreateAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.GetOrCreateAsync.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.GetOrCreateAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.GetOrCreateAsync.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.IsDeletedAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.IsDeletedAsync.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.IsDeletedAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.IsDeletedAsync.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.RestoreAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.RestoreAsync.cs similarity index 99% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.RestoreAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.RestoreAsync.cs index f37806f2..50befb9b 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.RestoreAsync.cs +++ b/src/src/MongoDB/Events/MongoDBEventStore.RestoreAsync.cs @@ -16,7 +16,7 @@ public async Task RestoreAsync( if (!aggregate.Details.IsDeleted) throw AggregateNotDeletedException(aggregate.Id()); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); Restored restoreAggregateEvent = new() { diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.SaveAsync.cs b/src/src/MongoDB/Events/MongoDBEventStore.SaveAsync.cs similarity index 99% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.SaveAsync.cs rename to src/src/MongoDB/Events/MongoDBEventStore.SaveAsync.cs index 16d764dd..bb2616c9 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.SaveAsync.cs +++ b/src/src/MongoDB/Events/MongoDBEventStore.SaveAsync.cs @@ -2,7 +2,6 @@ using System.Diagnostics.CodeAnalysis; using System.Globalization; using System.Security.Claims; -using FluentValidation.Results; using MongoDB.Driver; using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.Aggregates.Events; @@ -10,6 +9,7 @@ using Purview.EventSourcing.MongoDB.Events.Exceptions; using Purview.EventSourcing.MongoDB.StorageClient; using Purview.EventSourcing.Services; +using Purview.EventSourcing.Validation; namespace Purview.EventSourcing.MongoDB; @@ -29,7 +29,7 @@ async Task> SaveCoreAsync( params IEvent[] additionalEvents ) { - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); FulfilRequirements(aggregate); diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.Serialization.cs b/src/src/MongoDB/Events/MongoDBEventStore.Serialization.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.Serialization.cs rename to src/src/MongoDB/Events/MongoDBEventStore.Serialization.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.cs b/src/src/MongoDB/Events/MongoDBEventStore.cs similarity index 93% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.cs rename to src/src/MongoDB/Events/MongoDBEventStore.cs index 38fdb241..ece60a72 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStore.cs +++ b/src/src/MongoDB/Events/MongoDBEventStore.cs @@ -4,6 +4,7 @@ using Microsoft.Extensions.Caching.Distributed; using Microsoft.Extensions.Options; using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events.Upcasting; using Purview.EventSourcing.MongoDB.Events; using Purview.EventSourcing.MongoDB.Events.Entities; using Purview.EventSourcing.MongoDB.StorageClient; @@ -25,6 +26,7 @@ public sealed partial class MongoDBEventStore : IMongoDBEventStore, IDispo readonly IMongoDBEventStoreTelemetry _eventStoreTelemetry; readonly ChangeFeed.IAggregateChangeFeedNotifier _aggregateChangeNotifier; readonly IAggregateRequirementsManager _aggregateRequirementsManager; + readonly IEventUpcasterRegistry? _eventUpcasterRegistry; readonly string _aggregateTypeFullName; readonly string _aggregateTypeShortName; @@ -38,18 +40,20 @@ public MongoDBEventStore( ChangeFeed.IAggregateChangeFeedNotifier aggregateChangeNotifier, IAggregateRequirementsManager aggregateRequirementsManager, IMongoDBEventStoreStorageNameBuilder? storageNameBuilder = null, - FluentValidation.IValidator? validator = null, - IAggregateIdFactory? aggregateIdFactory = null + IAggregateValidator? validator = null, + IAggregateIdFactory? aggregateIdFactory = null, + IEventUpcasterRegistry? eventUpcasterRegistry = null ) { _eventNameMapper = eventNameMapper; _eventStoreOptions = mongoDbOptions; - _validator = AggregateValidatorAdapter.Adapt(validator); + _validator = validator; _aggregateIdFactory = aggregateIdFactory; _distributedCache = distributedCache; _eventStoreTelemetry = eventStoreTelemetry; _aggregateChangeNotifier = aggregateChangeNotifier; _aggregateRequirementsManager = aggregateRequirementsManager; + _eventUpcasterRegistry = eventUpcasterRegistry; _aggregateTypeShortName = typeof(T).Name; _aggregateTypeFullName = typeof(T).FullName ?? _aggregateTypeShortName; @@ -114,7 +118,7 @@ async Task UpdateCacheAsync( await _distributedCache.RemoveAsync(cacheKey, cancellationToken); else { - if (!_eventStoreOptions.Value.CacheMode.HasFlag(EventStoreCachingOptions.StoreInCache)) + if (!_eventStoreOptions.Value.CacheMode.HasFlag(SnapshotCachingOptions.StoreInCache)) return; var data = SerializeSnapshot(aggregate); @@ -177,7 +181,11 @@ CancellationToken cancellationToken if (result == null) { if (expectedToExist) - _eventStoreTelemetry.StreamVersionExpectedToExistButNotFound(aggregateId); + _eventStoreTelemetry.StreamVersionExpectedToExistButNotFound( + aggregateId, + _aggregateTypeFullName, + _aggregateTypeShortName + ); else _eventStoreTelemetry.StreamVersionNotFound(aggregateId); } diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStoreOptions.cs b/src/src/MongoDB/Events/MongoDBEventStoreOptions.cs similarity index 89% rename from src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStoreOptions.cs rename to src/src/MongoDB/Events/MongoDBEventStoreOptions.cs index ad4b988f..a9c889c3 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Events/MongoDBEventStoreOptions.cs +++ b/src/src/MongoDB/Events/MongoDBEventStoreOptions.cs @@ -16,13 +16,13 @@ public sealed class MongoDBEventStoreOptions public string? ApplicationName { get; set; } [Required] - // TODO: Regex + [RegularExpression(@"^[\w\-.]+$")] public string Database { get; set; } = default!; - // TODO: Regex + [RegularExpression(@"^[\w\-.]+$")] public string? EventCollection { get; set; } - // TODO: Regex + [RegularExpression(@"^[\w\-.]+$")] public string? SnapshotCollection { get; set; } public string? ReplicaName { get; set; } @@ -58,10 +58,10 @@ public sealed class MongoDBEventStoreOptions /// /// Gets/ sets a value indicating how the - /// uses the during it's operations. Defaults to . + /// uses the during it's operations. Defaults to . /// - [DefaultValue(EventStoreCachingOptions.GetAndStore)] - public EventStoreCachingOptions CacheMode { get; set; } = EventStoreCachingOptions.GetAndStore; + [DefaultValue(SnapshotCachingOptions.GetAndStore)] + public SnapshotCachingOptions CacheMode { get; set; } = SnapshotCachingOptions.GetAndStore; public TimeSpan DefaultCacheSlidingDuration { get; set; } = TimeSpan.FromMinutes(60); diff --git a/src/src/EventSourcing.MongoDB/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs b/src/src/MongoDB/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs similarity index 53% rename from src/src/EventSourcing.MongoDB/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs rename to src/src/MongoDB/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs index 98d72386..e9429fa7 100644 --- a/src/src/EventSourcing.MongoDB/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs +++ b/src/src/MongoDB/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs @@ -1,21 +1,23 @@ -using System.ComponentModel; +using System.ComponentModel; +using System.ComponentModel.DataAnnotations; using System.Diagnostics.CodeAnalysis; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection.Extensions; using Purview.EventSourcing.Internal; -using Purview.EventSourcing.MongoDB; using Purview.EventSourcing.MongoDB.Events; using Purview.EventSourcing.MongoDB.Snapshots; -namespace Microsoft.Extensions.DependencyInjections; +namespace Microsoft.Extensions.DependencyInjection; [EditorBrowsable(EditorBrowsableState.Never)] public static class ServiceCollectionExtensions { extension([NotNull] IServiceCollection services) { - public IServiceCollection AddMongoDBEventStore() + public IServiceCollection AddMongoDBEventStore() => services.AddMongoDBEventStore(connectionStringName: null); + + public IServiceCollection AddMongoDBEventStore(string? connectionStringName) { services.AddEventSourcing(); @@ -37,20 +39,36 @@ public IServiceCollection AddMongoDBEventStore() if (string.IsNullOrWhiteSpace(options.ConnectionString)) { - options.ConnectionString = - configuration.GetConnectionString("EventStore_MongoDB") - ?? configuration.GetConnectionString("MongoDB") - // This will get picked up by the validation. - ?? default!; + options.ConnectionString = configuration.GetRequiredConnectionString([ + connectionStringName, + "EventStore_MongoDB", + "MongoDB", + ]); } } ) + .Validate( + static options => + Validator.TryValidateObject( + options, + new ValidationContext(options), + validationResults: null, + validateAllProperties: true + ), + $"{nameof(MongoDBEventStoreOptions)} is invalid." + ) .ValidateOnStart(); return services; } - public IServiceCollection AddMongoDBSnapshotQueryableEventStore(bool registerAsIEventStore = false) + public IServiceCollection AddMongoDBSnapshotQueryableEventStore(bool registerAsIEventStore = false) => + services.AddMongoDBSnapshotQueryableEventStore(connectionStringName: null, registerAsIEventStore); + + public IServiceCollection AddMongoDBSnapshotQueryableEventStore( + string? connectionStringName, + bool registerAsIEventStore = false + ) { services.AddEventSourcing(); @@ -58,6 +76,7 @@ public IServiceCollection AddMongoDBSnapshotQueryableEventStore(bool registerAsI .AddTransient(typeof(IQueryableEventStoreCore<>), typeof(MongoDBSnapshotEventStore<>)) .AddTransient(typeof(IMongoDBSnapshotEventStore<>), typeof(MongoDBSnapshotEventStore<>)) .AddMongoDBSnapshotEventStoreTelemetry(); + services.AddMongoDBClientTelemetry(); services.TryAddTransient(); @@ -68,21 +87,31 @@ public IServiceCollection AddMongoDBSnapshotQueryableEventStore(bool registerAsI } services - .AddOptions() + .AddOptions() .Configure( (options, configuration) => { - configuration.GetSection(MongoDBEventStoreOptions.MongoDBEventStore).Bind(options); + configuration.GetSection(MongoDBSnapshotEventStoreOptions.MongoDBEventStore).Bind(options); - options.ConnectionString ??= - configuration.GetConnectionString("EventStore_MongoDBSnapshot") - ?? configuration.GetConnectionString("MongoDBSnapshot") - ?? configuration.GetConnectionString("EventStore_MongoDB") - ?? configuration.GetConnectionString("MongoDB") - // This will get picked up by the validation. - ?? default!; + options.ConnectionString ??= configuration.GetRequiredConnectionString([ + connectionStringName, + "EventStore_MongoDBSnapshot", + "MongoDBSnapshot", + "EventStore_MongoDB", + "MongoDB", + ]); } ) + .Validate( + static options => + Validator.TryValidateObject( + options, + new ValidationContext(options), + validationResults: null, + validateAllProperties: true + ), + $"{nameof(MongoDBSnapshotEventStoreOptions)} is invalid." + ) .ValidateOnStart(); return services; diff --git a/src/src/EventSourcing.MongoDB/MongoDBClientExtensions.cs b/src/src/MongoDB/Extensions/MongoDBClientExtensions.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDBClientExtensions.cs rename to src/src/MongoDB/Extensions/MongoDBClientExtensions.cs diff --git a/src/src/EventSourcing.MongoDB/EventSourcing.MongoDB.csproj b/src/src/MongoDB/MongoDB.csproj similarity index 66% rename from src/src/EventSourcing.MongoDB/EventSourcing.MongoDB.csproj rename to src/src/MongoDB/MongoDB.csproj index e5e5944c..e741585c 100644 --- a/src/src/EventSourcing.MongoDB/EventSourcing.MongoDB.csproj +++ b/src/src/MongoDB/MongoDB.csproj @@ -1,24 +1,18 @@  - - Purview.EventSourcing - - true Purview Event Store for MongoDB MongoDB event stream and snapshot storage provider for Purview EventSourcing. + $(PackageTags);purview;dotnet;event-sourcing;event-store;mongodb;events;snapshots; Purview.EventSourcing.MongoDB - $(PackageTags);purview;kjldev;dotnet;event-sourcing;event-store;mongodb;events;snapshots; - - - <_Parameter1>EventSourcing.UnitTests - - - + diff --git a/src/src/MongoDB/Properties/AssemblyInfo.cs b/src/src/MongoDB/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..86753b0e --- /dev/null +++ b/src/src/MongoDB/Properties/AssemblyInfo.cs @@ -0,0 +1,10 @@ +using System.Runtime.CompilerServices; +using Purview.Telemetry; + +[assembly: InternalsVisibleTo("SharedTestingFramework")] +[assembly: InternalsVisibleTo("EventSourcing.UnitTests")] +[assembly: InternalsVisibleTo("Admin.MongoDB")] +[assembly: InternalsVisibleTo("Admin.MongoDB.UnitTests")] + +[assembly: ActivitySourceGeneration("Purview.EventSourcing.MongoDB")] +[assembly: MeterGeneration("Purview.EventSourcing.MongoDB")] diff --git a/src/src/EventSourcing.MongoDB/README.md b/src/src/MongoDB/README.md similarity index 63% rename from src/src/EventSourcing.MongoDB/README.md rename to src/src/MongoDB/README.md index 4a0631dc..4c59c5b5 100644 --- a/src/src/EventSourcing.MongoDB/README.md +++ b/src/src/MongoDB/README.md @@ -24,4 +24,7 @@ builder.Services.AddMongoDBSnapshotQueryableEventStore(); ## Documentation -- Repository README: https://github.com/kjldev/purview-eventsourcing/blob/main/README.md +- [Repository README](https://github.com/kjldev/purview-eventsourcing/blob/main/README.md) +- [Provider feature matrix](https://github.com/kjldev/purview-eventsourcing/blob/main/docs/wiki/Provider-Feature-Matrix.md) + +Snapshot query translation capabilities differ by provider; consult the provider matrix and provider-specific guides before relying on deep nested predicates for complex value-object shapes. diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Snapshots/IMongoDBSnapshotEventStore.cs b/src/src/MongoDB/Snapshots/IMongoDBSnapshotEventStore.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Snapshots/IMongoDBSnapshotEventStore.cs rename to src/src/MongoDB/Snapshots/IMongoDBSnapshotEventStore.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Snapshots/IMongoDBSnapshotEventStoreTelemetry.cs b/src/src/MongoDB/Snapshots/IMongoDBSnapshotEventStoreTelemetry.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Snapshots/IMongoDBSnapshotEventStoreTelemetry.cs rename to src/src/MongoDB/Snapshots/IMongoDBSnapshotEventStoreTelemetry.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Snapshots/MongoDBSnapshotEventStore.EventStore.cs b/src/src/MongoDB/Snapshots/MongoDBSnapshotEventStore.EventStore.cs similarity index 91% rename from src/src/EventSourcing.MongoDB/MongoDB/Snapshots/MongoDBSnapshotEventStore.EventStore.cs rename to src/src/MongoDB/Snapshots/MongoDBSnapshotEventStore.EventStore.cs index b0e16185..4682f5ab 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Snapshots/MongoDBSnapshotEventStore.EventStore.cs +++ b/src/src/MongoDB/Snapshots/MongoDBSnapshotEventStore.EventStore.cs @@ -1,4 +1,5 @@ using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Aggregates.Snapshotting; namespace Purview.EventSourcing.MongoDB.Snapshots; @@ -94,4 +95,11 @@ public Task ExistsAsync(string aggregateId, CancellationToken cance _eventStore.ExistsAsync(aggregateId, cancellationToken); public T FulfilRequirements(T aggregate) => _eventStore.FulfilRequirements(aggregate); + + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) => _eventStore.GetEventRangeAsync(aggregateId, versionFrom, versionTo, cancellationToken); } diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Snapshots/MongoDBSnapshotEventStore.Query.cs b/src/src/MongoDB/Snapshots/MongoDBSnapshotEventStore.Query.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Snapshots/MongoDBSnapshotEventStore.Query.cs rename to src/src/MongoDB/Snapshots/MongoDBSnapshotEventStore.Query.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Snapshots/MongoDBSnapshotEventStore.cs b/src/src/MongoDB/Snapshots/MongoDBSnapshotEventStore.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/Snapshots/MongoDBSnapshotEventStore.cs rename to src/src/MongoDB/Snapshots/MongoDBSnapshotEventStore.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/Snapshots/MongoDBSnapshotEventStoreOptions.cs b/src/src/MongoDB/Snapshots/MongoDBSnapshotEventStoreOptions.cs similarity index 86% rename from src/src/EventSourcing.MongoDB/MongoDB/Snapshots/MongoDBSnapshotEventStoreOptions.cs rename to src/src/MongoDB/Snapshots/MongoDBSnapshotEventStoreOptions.cs index d1ace4a3..e56b694f 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/Snapshots/MongoDBSnapshotEventStoreOptions.cs +++ b/src/src/MongoDB/Snapshots/MongoDBSnapshotEventStoreOptions.cs @@ -12,7 +12,9 @@ public sealed class MongoDBSnapshotEventStoreOptions public string? ApplicationName { get; set; } [Required] + [RegularExpression(@"^[\w\-.]+$")] public string Database { get; set; } = default!; + [RegularExpression(@"^[\w\-.]+$")] public string? Collection { get; set; } } diff --git a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/BatchOperation.cs b/src/src/MongoDB/StorageClient/BatchOperation.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/StorageClient/BatchOperation.cs rename to src/src/MongoDB/StorageClient/BatchOperation.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/IEntity.cs b/src/src/MongoDB/StorageClient/IEntity.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/StorageClient/IEntity.cs rename to src/src/MongoDB/StorageClient/IEntity.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/IMongoDBClientTelemetry.cs b/src/src/MongoDB/StorageClient/IMongoDBClientTelemetry.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/StorageClient/IMongoDBClientTelemetry.cs rename to src/src/MongoDB/StorageClient/IMongoDBClientTelemetry.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBAggregateSerializationProvider.cs b/src/src/MongoDB/StorageClient/MongoDBAggregateSerializationProvider.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBAggregateSerializationProvider.cs rename to src/src/MongoDB/StorageClient/MongoDBAggregateSerializationProvider.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBAggregateSerializer.cs b/src/src/MongoDB/StorageClient/MongoDBAggregateSerializer.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBAggregateSerializer.cs rename to src/src/MongoDB/StorageClient/MongoDBAggregateSerializer.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBClient.MongoDBSpecific.cs b/src/src/MongoDB/StorageClient/MongoDBClient.MongoDBSpecific.cs similarity index 54% rename from src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBClient.MongoDBSpecific.cs rename to src/src/MongoDB/StorageClient/MongoDBClient.MongoDBSpecific.cs index 86f06a88..c5eec699 100644 --- a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBClient.MongoDBSpecific.cs +++ b/src/src/MongoDB/StorageClient/MongoDBClient.MongoDBSpecific.cs @@ -10,63 +10,69 @@ partial class MongoDBClient public async Task SubmitBatchAsync(BatchOperation operation, CancellationToken cancellationToken = default) { var collection = GetCollection().WithWriteConcern(WriteConcern.WMajority); - using var session = await _client.StartSessionAsync(cancellationToken: cancellationToken); + try + { + using var session = await _client.StartSessionAsync(cancellationToken: cancellationToken); - TransactionOptions transactionOptions = new(writeConcern: WriteConcern.WMajority); - await session.WithTransactionAsync( - async (s, ct) => - { - try + TransactionOptions transactionOptions = new(writeConcern: WriteConcern.WMajority); + await session.WithTransactionAsync( + async (s, ct) => { - foreach (var op in operation.GetActions()) + try { - switch (op.ActionType) + foreach (var op in operation.GetActions()) { - case TransactionActionType.Insert: - await collection.InsertOneAsync( - session, - op.Document.ToBsonDocument(), - cancellationToken: cancellationToken - ); - break; - case TransactionActionType.Update: - var d = op.Document.ToBsonDocument(); - d.Remove("_id"); - - await collection.ReplaceOneAsync( - session, - m => m["_id"] == op.Document.Id, - d, - new ReplaceOptions { IsUpsert = false }, - cancellationToken - ); - - break; - case TransactionActionType.Delete: - await collection.DeleteOneAsync( - session, - m => m["_id"] == op.Document.Id, - cancellationToken: cancellationToken - ); - break; + switch (op.ActionType) + { + case TransactionActionType.Insert: + await collection.InsertOneAsync( + session, + op.Document.ToBsonDocument(), + cancellationToken: cancellationToken + ); + break; + case TransactionActionType.Update: + var d = op.Document.ToBsonDocument(); + d.Remove("_id"); + + await collection.ReplaceOneAsync( + session, + m => m["_id"] == op.Document.Id, + d, + new ReplaceOptions { IsUpsert = false }, + cancellationToken + ); + + break; + case TransactionActionType.Delete: + await collection.DeleteOneAsync( + session, + m => m["_id"] == op.Document.Id, + cancellationToken: cancellationToken + ); + break; + } } - } - - await s.CommitTransactionAsync(ct); - } - catch (MongoWriteException) - { - await s.AbortTransactionAsync(ct); - // Do something in response to the exception - throw; // NOTE: You must rethrow the exception otherwise an infinite loop can occur. - } + await s.CommitTransactionAsync(ct); + } + catch (MongoWriteException) + { + await s.AbortTransactionAsync(ct); + throw; // NOTE: You must rethrow the exception otherwise an infinite loop can occur. + } - return true; - }, - transactionOptions, - cancellationToken - ); + return true; + }, + transactionOptions, + cancellationToken + ); + } + catch (NotSupportedException ex) + when (ex.Message.Contains("do not support transactions", StringComparison.OrdinalIgnoreCase)) + { + await SubmitBatchWithoutTransactionAsync(collection, operation.GetActions(), cancellationToken); + } } public async Task SubmitDeleteBatchAsync( @@ -75,44 +81,90 @@ public async Task SubmitDeleteBatchAsync( ) { var collection = GetCollection().WithWriteConcern(WriteConcern.WMajority); - using var session = await _client.StartSessionAsync(cancellationToken: cancellationToken); + try + { + using var session = await _client.StartSessionAsync(cancellationToken: cancellationToken); - TransactionOptions transactionOptions = new(writeConcern: WriteConcern.WMajority); - await session.WithTransactionAsync( - async (s, ct) => - { - try + TransactionOptions transactionOptions = new(writeConcern: WriteConcern.WMajority); + await session.WithTransactionAsync( + async (s, ct) => { - foreach (var id in entityIds) + try { - var deleteResult = await collection.DeleteOneAsync( - session, - BuildPredicate(id, null), - cancellationToken: cancellationToken - ); - if (deleteResult.IsAcknowledged) + foreach (var id in entityIds) { - if (deleteResult.DeletedCount == 0) + var deleteResult = await collection.DeleteOneAsync( + session, + BuildPredicate(id, null), + cancellationToken: cancellationToken + ); + if (deleteResult.IsAcknowledged && deleteResult.DeletedCount == 0) _telemetry.DeleteResultedInNoOp(id); } } - } - catch (MongoWriteException ex) - { - await s.AbortTransactionAsync(ct); + catch (MongoWriteException ex) + { + await s.AbortTransactionAsync(ct); - _telemetry.FailedToWriteBatch(ex); - // Do something in response to the exception - throw; // NOTE: You must rethrow the exception otherwise an infinite loop can occur. - } + _telemetry.FailedToWriteBatch(ex); + throw; // NOTE: You must rethrow the exception otherwise an infinite loop can occur. + } - await s.CommitTransactionAsync(ct); + await s.CommitTransactionAsync(ct); - return true; - }, - transactionOptions, - cancellationToken - ); + return true; + }, + transactionOptions, + cancellationToken + ); + } + catch (NotSupportedException ex) + when (ex.Message.Contains("do not support transactions", StringComparison.OrdinalIgnoreCase)) + { + foreach (var id in entityIds) + { + var deleteResult = await collection.DeleteOneAsync( + BuildPredicate(id, null), + cancellationToken: cancellationToken + ); + + if (deleteResult.IsAcknowledged && deleteResult.DeletedCount == 0) + _telemetry.DeleteResultedInNoOp(id); + } + } + } + + static async Task SubmitBatchWithoutTransactionAsync( + IMongoCollection collection, + IEnumerable actions, + CancellationToken cancellationToken + ) + { + foreach (var op in actions) + { + switch (op.ActionType) + { + case TransactionActionType.Insert: + await collection.InsertOneAsync(op.Document.ToBsonDocument(), cancellationToken: cancellationToken); + break; + case TransactionActionType.Update: + var d = op.Document.ToBsonDocument(); + d.Remove("_id"); + await collection.ReplaceOneAsync( + m => m["_id"] == op.Document.Id, + d, + new ReplaceOptions { IsUpsert = false }, + cancellationToken + ); + break; + case TransactionActionType.Delete: + await collection.DeleteOneAsync( + m => m["_id"] == op.Document.Id, + cancellationToken: cancellationToken + ); + break; + } + } } public async Task GetAsync(FilterDefinition predicate, CancellationToken cancellationToken = default) diff --git a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBClient.QueryAndList.cs b/src/src/MongoDB/StorageClient/MongoDBClient.QueryAndList.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBClient.QueryAndList.cs rename to src/src/MongoDB/StorageClient/MongoDBClient.QueryAndList.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBClient.cs b/src/src/MongoDB/StorageClient/MongoDBClient.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBClient.cs rename to src/src/MongoDB/StorageClient/MongoDBClient.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBConfiguration.cs b/src/src/MongoDB/StorageClient/MongoDBConfiguration.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/StorageClient/MongoDBConfiguration.cs rename to src/src/MongoDB/StorageClient/MongoDBConfiguration.cs diff --git a/src/src/EventSourcing.MongoDB/MongoDB/StorageClient/TransactionActionType.cs b/src/src/MongoDB/StorageClient/TransactionActionType.cs similarity index 100% rename from src/src/EventSourcing.MongoDB/MongoDB/StorageClient/TransactionActionType.cs rename to src/src/MongoDB/StorageClient/TransactionActionType.cs diff --git a/src/src/Postgres/Client/JsonScalarValueConverter.cs b/src/src/Postgres/Client/JsonScalarValueConverter.cs new file mode 100644 index 00000000..21ef9588 --- /dev/null +++ b/src/src/Postgres/Client/JsonScalarValueConverter.cs @@ -0,0 +1,105 @@ +using System.Linq.Expressions; +using System.Reflection; +using System.Text.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Postgres.Client; + +sealed class JsonScalarValueConverter : ValueConverter +{ + static readonly PropertyInfo ScalarProperty = GetScalarProperty(); + static readonly Func Creator = BuildCreator(); + + public JsonScalarValueConverter() + : base(BuildToProviderExpression(), BuildFromProviderExpression()) { } + + static Expression> BuildToProviderExpression() + { + var source = Expression.Parameter(typeof(TScalarObject), "value"); + var serializeMethod = typeof(JsonScalarValueConverter).GetMethod( + nameof(Serialize), + BindingFlags.Static | BindingFlags.NonPublic + )!; + var body = Expression.Call(serializeMethod, source); + return Expression.Lambda>(body, source); + } + + static Expression> BuildFromProviderExpression() + { + var source = Expression.Parameter(typeof(string), "value"); + var deserializeMethod = typeof(JsonScalarValueConverter).GetMethod( + nameof(Deserialize), + BindingFlags.Static | BindingFlags.NonPublic + )!; + var body = Expression.Call(deserializeMethod, source); + return Expression.Lambda>(body, source); + } + + static string Serialize(TScalarObject value) + { + if (value is null) + return null!; + + var scalarValue = (TScalar)ScalarProperty.GetValue(value)!; + return JsonSerializer.Serialize(scalarValue); + } + + static TScalarObject Deserialize(string value) + { + if (value is null) + return default!; + + var scalarValue = JsonSerializer.Deserialize(value)!; + return Creator(scalarValue); + } + + static PropertyInfo GetScalarProperty() + { + var scalarType = typeof(TScalarObject); + var scalarAttribute = + scalarType.GetCustomAttribute() + ?? throw new InvalidOperationException($"{scalarType.Name} must be annotated with [Scalar]."); + + return scalarType.GetProperty(scalarAttribute.PropertyName, BindingFlags.Instance | BindingFlags.Public) + ?? throw new InvalidOperationException( + $"'{scalarType.Name}' missing scalar property '{scalarAttribute.PropertyName}'." + ); + } + + static Func BuildCreator() + { + var scalarType = typeof(TScalarObject); + var scalarPropertyType = typeof(TScalar); + var scalarAttribute = + scalarType.GetCustomAttribute() + ?? throw new InvalidOperationException($"{scalarType.Name} must be annotated with [Scalar]."); + + var preferredFactoryName = + scalarAttribute.DeserializationMode == ValueObjectDeserializationMode.Strict ? "Create" : "Hydrate"; + var secondaryFactoryName = preferredFactoryName == "Hydrate" ? "Create" : "Hydrate"; + + var create = + scalarType.GetMethod(preferredFactoryName, BindingFlags.Public | BindingFlags.Static, [scalarPropertyType]) + ?? scalarType.GetMethod( + secondaryFactoryName, + BindingFlags.Public | BindingFlags.Static, + [scalarPropertyType] + ); + + if (create is not null) + return value => (TScalarObject)create.Invoke(null, [value])!; + + var ctor = + scalarType.GetConstructor( + BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, + [scalarPropertyType] + ) + ?? throw new InvalidOperationException( + $"{scalarType.Name} must expose static {preferredFactoryName}({scalarPropertyType.Name}), static {secondaryFactoryName}({scalarPropertyType.Name}), or ctor({scalarPropertyType.Name})." + ); + + // If we reach here, we have a constructor that takes the scalar property type + return value => (TScalarObject)ctor.Invoke([value]); + } +} diff --git a/src/src/Postgres/Client/JsonValueObjectCollectionConverter.cs b/src/src/Postgres/Client/JsonValueObjectCollectionConverter.cs new file mode 100644 index 00000000..04195513 --- /dev/null +++ b/src/src/Postgres/Client/JsonValueObjectCollectionConverter.cs @@ -0,0 +1,13 @@ +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Postgres.Client; + +sealed class JsonValueObjectCollectionConverter : ValueConverter +{ + public JsonValueObjectCollectionConverter() + : base( + value => EventStoreSerializationHelpers.Serialize(value), + value => EventStoreSerializationHelpers.Deserialize(value)! + ) { } +} diff --git a/src/src/Postgres/Client/Models.cs b/src/src/Postgres/Client/Models.cs new file mode 100644 index 00000000..fd3eaaaa --- /dev/null +++ b/src/src/Postgres/Client/Models.cs @@ -0,0 +1,24 @@ +namespace Purview.EventSourcing.Postgres.Client; + +sealed record SnapshotStorageRow(string Id, string AggregateType, string Payload); + +sealed class SnapshotQueryRow + where TAggregate : class +{ + public required string Id { get; set; } + + public required string AggregateType { get; set; } + + public required TAggregate Payload { get; set; } +} + +sealed record PostgresClientOptions(string ConnectionString, bool UseDataCompression) +{ + public string TableName { get; init; } = "EventStoreSnapshots"; + + public string SchemaName { get; init; } = "public"; + + public bool AutoCreateTable { get; init; } = true; + + public PostgresJsonIndexOptions JsonIndexOptions { get; init; } = new(); +} diff --git a/src/src/Postgres/Client/PostgresClient.cs b/src/src/Postgres/Client/PostgresClient.cs new file mode 100644 index 00000000..5dedb1e2 --- /dev/null +++ b/src/src/Postgres/Client/PostgresClient.cs @@ -0,0 +1,1219 @@ +using System.Collections.Concurrent; +using System.Linq.Expressions; +using System.Reflection; +using System.Text.RegularExpressions; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata.Builders; +using Microsoft.EntityFrameworkCore.Storage; +using Npgsql; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Postgres.Client; + +sealed partial class PostgresClient +{ + static readonly ConcurrentDictionary EnsureTableLocks = new(StringComparer.Ordinal); + static readonly ConcurrentDictionary EnsuredTables = new(StringComparer.Ordinal); + static readonly HashSet SupportedSnapshotIncludeColumns = ["Id", "AggregateType", "Payload"]; + + readonly PostgresClientOptions _options; + readonly string _tableEnsureKey; + + public PostgresClient(PostgresClientOptions options) + { + _options = options ?? throw new ArgumentNullException(nameof(options)); + _tableEnsureKey = $"{_options.ConnectionString}|{_options.SchemaName}|{_options.TableName}"; + + ValidateIdentifier(_options.SchemaName); + ValidateIdentifier(_options.TableName); + PostgresJsonIndexSchemaManager.ValidateOrThrow( + _options.JsonIndexOptions, + _options.SchemaName, + _options.TableName, + SupportedSnapshotIncludeColumns, + nameof(PostgresClientOptions.JsonIndexOptions) + ); + } + + public async Task EnsureTableExistsAsync(CancellationToken cancellationToken = default) + { + if (!_options.AutoCreateTable) + return; + + await EnsureTableIfEnabledAsync(cancellationToken); + } + + public async Task EnsureTableExistsAsync(NpgsqlConnection connection, CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(connection); + + if (!_options.AutoCreateTable) + return; + + await EnsureTableIfEnabledAsync(connection, transaction: null, cancellationToken); + } + + public async Task UpsertAsync( + T aggregate, + string id, + string aggregateType, + CancellationToken cancellationToken = default + ) + where T : class + { + await EnsureTableIfEnabledAsync(cancellationToken); + await using var queryContext = CreateQueryContext(); + return await UpsertAsync(aggregate, id, aggregateType, queryContext, cancellationToken); + } + + public async Task UpsertAsync( + T aggregate, + string id, + string aggregateType, + NpgsqlConnection connection, + NpgsqlTransaction transaction, + CancellationToken cancellationToken = default + ) + where T : class + { + ArgumentNullException.ThrowIfNull(connection); + ArgumentNullException.ThrowIfNull(transaction); + + await EnsureTableIfEnabledAsync(connection, transaction, cancellationToken); + + await using var queryContext = CreateQueryContext(connection); + await queryContext.Database.UseTransactionAsync(transaction, cancellationToken); + return await UpsertAsync(aggregate, id, aggregateType, queryContext, cancellationToken); + } + + public async Task DeleteAsync(string id, CancellationToken cancellationToken = default) + { + await EnsureTableIfEnabledAsync(cancellationToken); + await using var context = CreateStorageContext(); + var existing = await context.Snapshots.SingleOrDefaultAsync(s => s.Id == id, cancellationToken); + if (existing is null) + return false; + + context.Snapshots.Remove(existing); + return await context.SaveChangesAsync(cancellationToken) > 0; + } + + public async Task CountByAggregateTypeAsync( + string aggregateType, + CancellationToken cancellationToken = default + ) + { + await EnsureTableIfEnabledAsync(cancellationToken); + await using var context = CreateStorageContext(); + return await context + .Snapshots.AsNoTracking() + .LongCountAsync(s => s.AggregateType == aggregateType, cancellationToken); + } + + public async Task CountByAggregateTypeAsync( + string aggregateType, + Expression>? whereClause, + CancellationToken cancellationToken = default + ) + where T : class + { + await using var context = CreateQueryContext(); + await EnsureTableIfEnabledAsync(cancellationToken); + var query = BuildAggregateQuery(context, aggregateType, whereClause); + return await query.LongCountAsync(cancellationToken); + } + + public async Task> QueryByAggregateTypeAsync( + string aggregateType, + Expression>? whereClause, + Func, IQueryable>? orderByClause, + int skipCount, + int takeCount, + CancellationToken cancellationToken = default + ) + where T : class + { + await using var context = CreateQueryContext(); + await EnsureTableIfEnabledAsync(cancellationToken); + var normalizedWhereClause = whereClause is null + ? null + : RewriteAggregateTypePredicate(whereClause, aggregateType); + + var rowQuery = context.Snapshots.AsNoTracking().AsSplitQuery().Where(s => s.AggregateType == aggregateType); + + var aggregateQuery = rowQuery.OrderBy(s => s.Id).Select(s => s.Payload); + if (normalizedWhereClause != null) + aggregateQuery = aggregateQuery.Where(normalizedWhereClause); + + if (orderByClause != null) + { + aggregateQuery = orderByClause(aggregateQuery); + EnsureSupportedOrderByExpression(aggregateQuery.Expression); + } + + var page = aggregateQuery.Skip(Math.Max(0, skipCount)).Take(Math.Max(0, takeCount)); + return await page.ToListAsync(cancellationToken); + } + + public async Task> QueryByAggregateTypeJsonContainsAsync( + string aggregateType, + string jsonFragment, + int skipCount, + int takeCount, + CancellationToken cancellationToken = default + ) + where T : class + { + ArgumentException.ThrowIfNullOrWhiteSpace(jsonFragment); + await using var context = CreateQueryContext(); + await EnsureTableIfEnabledAsync(cancellationToken); + + var sql = $""" + SELECT "Id", "AggregateType", "Payload" + FROM {QuoteIdentifier(_options.SchemaName)}.{QuoteIdentifier(_options.TableName)} + WHERE "AggregateType" = @aggregateType AND "Payload" @> CAST(@jsonFragment AS jsonb) + """; + var aggregateTypeParameter = new NpgsqlParameter("aggregateType", aggregateType); + var jsonFragmentParameter = new NpgsqlParameter("jsonFragment", jsonFragment); + + var query = context + .Snapshots.FromSqlRaw(sql, aggregateTypeParameter, jsonFragmentParameter) + .AsNoTracking() + .OrderBy(static s => s.Id) + .Select(static s => s.Payload) + .Skip(Math.Max(0, skipCount)) + .Take(Math.Max(0, takeCount)); + + return await query.ToListAsync(cancellationToken); + } + + public async Task> QueryByAggregateTypeJsonExistsAsync( + string aggregateType, + string key, + int skipCount, + int takeCount, + CancellationToken cancellationToken = default + ) + where T : class + { + ArgumentException.ThrowIfNullOrWhiteSpace(key); + await using var context = CreateQueryContext(); + await EnsureTableIfEnabledAsync(cancellationToken); + + var sql = $""" + SELECT "Id", "AggregateType", "Payload" + FROM {QuoteIdentifier(_options.SchemaName)}.{QuoteIdentifier(_options.TableName)} + WHERE "AggregateType" = @aggregateType AND "Payload" ? @payloadKey + """; + var aggregateTypeParameter = new NpgsqlParameter("aggregateType", aggregateType); + var keyParameter = new NpgsqlParameter("payloadKey", key); + + var query = context + .Snapshots.FromSqlRaw(sql, aggregateTypeParameter, keyParameter) + .AsNoTracking() + .OrderBy(static s => s.Id) + .Select(static s => s.Payload) + .Skip(Math.Max(0, skipCount)) + .Take(Math.Max(0, takeCount)); + + return await query.ToListAsync(cancellationToken); + } + + public async Task GetByIdAsync(string id, CancellationToken cancellationToken = default) + where T : class + { + await using var context = CreateQueryContext(); + await EnsureTableIfEnabledAsync(cancellationToken); + var query = context.Snapshots.AsNoTracking().AsSplitQuery().Where(s => s.Id == id).Select(s => s.Payload); + return await query.SingleOrDefaultAsync(cancellationToken); + } + + static IQueryable BuildAggregateQuery( + SnapshotQueryDbContext context, + string aggregateType, + Expression>? whereClause + ) + where T : class + { + var query = context + .Snapshots.AsNoTracking() + .Where(s => s.AggregateType == aggregateType) + .Select(s => s.Payload); + + return whereClause is null ? query : query.Where(RewriteAggregateTypePredicate(whereClause, aggregateType)); + } + + static async Task UpsertAsync( + T aggregate, + string id, + string aggregateType, + SnapshotQueryDbContext context, + CancellationToken cancellationToken + ) + where T : class + { + ArgumentNullException.ThrowIfNull(aggregate); + var exists = await context.Snapshots.AsNoTracking().AnyAsync(s => s.Id == id, cancellationToken); + var entity = new SnapshotQueryRow + { + Id = id, + AggregateType = aggregateType, + Payload = aggregate, + }; + + if (exists) + context.Update(entity); + else + context.Add(entity); + + return await context.SaveChangesAsync(cancellationToken) > 0; + } + + SnapshotStorageDbContext CreateStorageContext() => new(_options); + + SnapshotStorageDbContext CreateStorageContext(NpgsqlConnection connection) => new(_options, connection); + + SnapshotQueryDbContext CreateQueryContext() + where T : class => new(_options); + + SnapshotQueryDbContext CreateQueryContext(NpgsqlConnection connection) + where T : class => new(_options, connection); + + static void ValidateIdentifier(string identifier) + { + if (string.IsNullOrWhiteSpace(identifier)) + throw new ArgumentException("Identifier cannot be null or empty.", nameof(identifier)); + + if (!IdentifierRegex().IsMatch(identifier)) + throw new ArgumentException($"Identifier '{identifier}' contains invalid characters.", nameof(identifier)); + } + + static string QuoteIdentifier(string identifier) => $"\"{identifier}\""; + + [GeneratedRegex(@"^[\w\-\.]+$")] + private static partial System.Text.RegularExpressions.Regex IdentifierRegex(); + + sealed class SnapshotStorageDbContext : DbContext + { + readonly PostgresClientOptions _options; + readonly NpgsqlConnection? _connection; + + public SnapshotStorageDbContext(PostgresClientOptions options) + { + _options = options; + } + + public SnapshotStorageDbContext(PostgresClientOptions options, NpgsqlConnection connection) + { + _options = options; + _connection = connection; + } + + public DbSet Snapshots => Set(); + + protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) + { + if (_connection is null) + optionsBuilder.UseNpgsql(_options.ConnectionString); + else + optionsBuilder.UseNpgsql(_connection); + + optionsBuilder.ReplaceService(); + } + + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + var entity = modelBuilder.Entity(); + entity.ToTable(_options.TableName, _options.SchemaName); + entity.HasKey(x => x.Id); + entity.Property(x => x.Id).HasMaxLength(450); + entity.Property(x => x.AggregateType).HasMaxLength(450); + entity.Property(x => x.Payload).HasColumnType("jsonb"); + entity.HasIndex(x => x.AggregateType); + } + } + + sealed class SnapshotQueryDbContext : DbContext + where TAggregate : class + { + readonly PostgresClientOptions _options; + readonly NpgsqlConnection? _connection; + + public SnapshotQueryDbContext(PostgresClientOptions options) + { + _options = options; + } + + public SnapshotQueryDbContext(PostgresClientOptions options, NpgsqlConnection connection) + { + _options = options; + _connection = connection; + } + + public DbSet> Snapshots => Set>(); + + protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder) + { + RegisterScalarValueObjectConversions(configurationBuilder, typeof(TAggregate)); + } + + protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) + { + if (_connection is null) + optionsBuilder.UseNpgsql(_options.ConnectionString); + else + optionsBuilder.UseNpgsql(_connection); + + optionsBuilder.ReplaceService(); + } + + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + var entity = modelBuilder.Entity>(); + entity.ToTable(_options.TableName, _options.SchemaName); + entity.HasKey(static x => x.Id); + entity.Property(static x => x.Id).HasMaxLength(450); + entity.Property(static x => x.AggregateType).HasMaxLength(450); + entity.HasIndex(static x => x.AggregateType); + ValidateAggregatePayloadShape(typeof(TAggregate)); + entity.ComplexProperty( + static x => x.Payload, + static payload => + { + payload.ToJson(); + ConfigureComplexGraph(payload, typeof(TAggregate)); + } + ); + } + } + + static void RegisterScalarValueObjectConversions(ModelConfigurationBuilder configurationBuilder, Type rootType) + { + var visited = new HashSet(); + RegisterScalarValueObjectConversionsRecursive(configurationBuilder, rootType, visited); + } + + static void RegisterScalarValueObjectConversionsRecursive( + ModelConfigurationBuilder configurationBuilder, + Type type, + HashSet visited + ) + { + type = Nullable.GetUnderlyingType(type) ?? type; + if (!visited.Add(type)) + return; + + var scalarAttribute = type.GetCustomAttribute(); + if (scalarAttribute is not null) + { + RegisterScalarValueObjectConversion(configurationBuilder, type, scalarAttribute); + return; + } + + if (!ShouldInspectType(type)) + return; + + foreach (var property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public)) + { + var propertyType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType; + + if (propertyType == typeof(string) || propertyType == typeof(byte[])) + continue; + + if (TryGetEnumerableElementType(propertyType, out var elementType)) + { + RegisterScalarValueObjectConversionsRecursive(configurationBuilder, elementType, visited); + continue; + } + + RegisterScalarValueObjectConversionsRecursive(configurationBuilder, propertyType, visited); + } + } + + static void RegisterScalarValueObjectConversion( + ModelConfigurationBuilder configurationBuilder, + Type scalarType, + ScalarAttribute scalarAttribute + ) + { + var scalarProperty = + scalarType.GetProperty(scalarAttribute.PropertyName, BindingFlags.Instance | BindingFlags.Public) + ?? throw new InvalidOperationException( + $"'{scalarType.Name}' missing scalar property '{scalarAttribute.PropertyName}'." + ); + + var scalarPropertyType = scalarProperty.PropertyType; + var converterType = IsPrimitiveLike(scalarPropertyType) + ? typeof(ScalarValueConverter<,>).MakeGenericType(scalarType, scalarPropertyType) + : typeof(JsonScalarValueConverter<,>).MakeGenericType(scalarType, scalarPropertyType); + configurationBuilder.Properties(scalarType, builder => builder.HaveConversion(converterType)); + } + + static void ConfigureComplexGraph(ComplexPropertyBuilder builder, Type type) + { + var visited = new HashSet(); + ConfigureComplexGraphRecursive(builder, type, visited); + } + + static void ConfigureComplexGraphRecursive(ComplexPropertyBuilder builder, Type type, HashSet visited) + { + type = Nullable.GetUnderlyingType(type) ?? type; + if (!ShouldInspectType(type) || !visited.Add(type)) + return; + + foreach (var property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public)) + { + if (ShouldSkipJsonProperty(type, property)) + continue; + + var propertyType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType; + + if (propertyType == typeof(string) || propertyType == typeof(byte[])) + { + MapReadOnlyConstructorBoundProperty(builder, type, property, propertyType); + continue; + } + + if (propertyType.GetCustomAttribute() is not null) + { + MapReadOnlyConstructorBoundProperty(builder, type, property, propertyType); + continue; + } + + if (TryGetEnumerableElementType(propertyType, out var elementType)) + { + if (!IsEventStoreCollectionType(propertyType)) + throw CreateUnsupportedCollectionTypeException(type, property, propertyType); + + if (IsStructValueObjectType(elementType)) + { + MapCollectionAsJsonProperty(builder, propertyType, property.Name); + continue; + } + + if (IsPrimitiveLike(elementType) || elementType.GetCustomAttribute() is not null) + builder.PrimitiveCollection(propertyType, property.Name); + else if (ShouldInspectType(elementType)) + builder.ComplexCollection( + propertyType, + property.Name, + nested => ConfigureComplexGraphRecursive(nested, elementType, visited) + ); + else + throw CreateUnsupportedShapeException(type, property); + + continue; + } + + if (IsDictionaryLikeType(propertyType) || IsJsonConvertibleCollectionType(propertyType)) + { + MapJsonProperty(builder, propertyType, property.Name); + continue; + } + + if (IsCollectionLikeType(propertyType)) + throw CreateUnsupportedCollectionTypeException(type, property, propertyType); + + if (ShouldOwnType(propertyType)) + { + builder.ComplexProperty( + propertyType, + property.Name, + nested => ConfigureComplexGraphRecursive(nested, propertyType, visited) + ); + continue; + } + + if (IsPrimitiveLike(propertyType)) + { + MapReadOnlyConstructorBoundProperty(builder, type, property, propertyType); + continue; + } + + throw CreateUnsupportedShapeException(type, property); + } + } + + static void ConfigureComplexGraphRecursive(ComplexCollectionBuilder builder, Type type, HashSet visited) + { + type = Nullable.GetUnderlyingType(type) ?? type; + if (!ShouldInspectType(type) || !visited.Add(type)) + return; + + foreach (var property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public)) + { + if (ShouldSkipJsonProperty(type, property)) + continue; + + var propertyType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType; + + if (propertyType == typeof(string) || propertyType == typeof(byte[])) + { + MapReadOnlyConstructorBoundProperty(builder, type, property, propertyType); + continue; + } + + if (propertyType.GetCustomAttribute() is not null) + { + MapReadOnlyConstructorBoundProperty(builder, type, property, propertyType); + continue; + } + + if (TryGetEnumerableElementType(propertyType, out var elementType)) + { + if (!IsEventStoreCollectionType(propertyType)) + throw CreateUnsupportedCollectionTypeException(type, property, propertyType); + + if (IsStructValueObjectType(elementType)) + { + MapCollectionAsJsonProperty(builder, propertyType, property.Name); + continue; + } + + if (IsPrimitiveLike(elementType) || elementType.GetCustomAttribute() is not null) + builder.PrimitiveCollection(propertyType, property.Name); + else if (ShouldInspectType(elementType)) + builder.ComplexCollection( + propertyType, + property.Name, + nested => ConfigureComplexGraphRecursive(nested, elementType, visited) + ); + else + throw CreateUnsupportedShapeException(type, property); + + continue; + } + + if (IsDictionaryLikeType(propertyType) || IsJsonConvertibleCollectionType(propertyType)) + { + MapJsonProperty(builder, propertyType, property.Name); + continue; + } + + if (IsCollectionLikeType(propertyType)) + throw CreateUnsupportedCollectionTypeException(type, property, propertyType); + + if (ShouldOwnType(propertyType)) + { + builder.ComplexProperty( + propertyType, + property.Name, + nested => ConfigureComplexGraphRecursive(nested, propertyType, visited) + ); + continue; + } + + if (IsPrimitiveLike(propertyType)) + { + MapReadOnlyConstructorBoundProperty(builder, type, property, propertyType); + continue; + } + + throw CreateUnsupportedShapeException(type, property); + } + } + + static void MapReadOnlyConstructorBoundProperty( + ComplexPropertyBuilder builder, + Type containingType, + PropertyInfo property, + Type propertyType + ) + { + if (property.GetSetMethod(true) is null && HasBindableConstructorParameter(containingType, property)) + builder.Property(propertyType, property.Name); + } + + static void MapReadOnlyConstructorBoundProperty( + ComplexCollectionBuilder builder, + Type containingType, + PropertyInfo property, + Type propertyType + ) + { + if (property.GetSetMethod(true) is null && HasBindableConstructorParameter(containingType, property)) + builder.Property(propertyType, property.Name); + } + + static void ValidateAggregatePayloadShape(Type type) + { + var visited = new HashSet(); + ValidateAggregatePayloadShapeRecursive(type, visited); + } + + static void ValidateAggregatePayloadShapeRecursive(Type type, HashSet visited) + { + type = Nullable.GetUnderlyingType(type) ?? type; + if (!ShouldInspectType(type) || !visited.Add(type)) + return; + + foreach (var property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public)) + { + if (ShouldSkipJsonProperty(type, property)) + continue; + + var propertyType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType; + + if (propertyType == typeof(string) || propertyType == typeof(byte[])) + continue; + + if (propertyType.GetCustomAttribute() is not null) + continue; + + if (TryGetEnumerableElementType(propertyType, out var elementType)) + { + if (!IsEventStoreCollectionType(propertyType)) + throw CreateUnsupportedCollectionTypeException(type, property, propertyType); + + if ( + !IsPrimitiveLike(elementType) + && elementType.GetCustomAttribute() is null + && !IsStructValueObjectType(elementType) + ) + { + if (!ShouldInspectType(elementType)) + throw CreateUnsupportedShapeException(type, property); + + ValidateAggregatePayloadShapeRecursive(elementType, visited); + } + + continue; + } + + if (IsReadOnlyCollectionType(propertyType)) + throw CreateUnsupportedCollectionTypeException(type, property, propertyType); + + if (IsDictionaryLikeType(propertyType) || IsJsonConvertibleCollectionType(propertyType)) + continue; + + if (IsCollectionLikeType(propertyType)) + throw CreateUnsupportedCollectionTypeException(type, property, propertyType); + + if (ShouldOwnType(propertyType)) + { + ValidateAggregatePayloadShapeRecursive(propertyType, visited); + continue; + } + + if (!IsPrimitiveLike(propertyType)) + throw CreateUnsupportedShapeException(type, property); + } + } + + static bool IsStructValueObjectType(Type type) => + type.IsValueType && type.GetCustomAttribute() is not null; + + static void MapCollectionAsJsonProperty(ComplexPropertyBuilder builder, Type propertyType, string propertyName) + { + var propertyBuilder = builder.Property(propertyType, propertyName); + var converterType = typeof(JsonValueObjectCollectionConverter<>).MakeGenericType(propertyType); + propertyBuilder.HasConversion(converterType); + } + + static void MapCollectionAsJsonProperty(ComplexCollectionBuilder builder, Type propertyType, string propertyName) + { + var propertyBuilder = builder.Property(propertyType, propertyName); + var converterType = typeof(JsonValueObjectCollectionConverter<>).MakeGenericType(propertyType); + propertyBuilder.HasConversion(converterType); + } + + static void MapJsonProperty(ComplexPropertyBuilder builder, Type propertyType, string propertyName) + { + var propertyBuilder = builder.Property(propertyType, propertyName); + var converterType = typeof(JsonValueObjectCollectionConverter<>).MakeGenericType(propertyType); + propertyBuilder.HasConversion(converterType); + } + + static void MapJsonProperty(ComplexCollectionBuilder builder, Type propertyType, string propertyName) + { + var propertyBuilder = builder.Property(propertyType, propertyName); + var converterType = typeof(JsonValueObjectCollectionConverter<>).MakeGenericType(propertyType); + propertyBuilder.HasConversion(converterType); + } + + static bool ShouldOwnType(Type type) => + !type.IsPrimitive + && !type.IsEnum + && type != typeof(string) + && type != typeof(decimal) + && type != typeof(Guid) + && type != typeof(DateTime) + && type != typeof(DateTimeOffset) + && type != typeof(DateOnly) + && type != typeof(TimeOnly) + && type != typeof(TimeSpan) + && (type.Namespace is null || !type.Namespace.StartsWith("System", StringComparison.Ordinal)) + && (type.IsClass || (type.IsValueType && !type.IsPrimitive && !type.IsEnum)); + + static bool ShouldInspectType(Type type) => + !type.IsPrimitive + && !type.IsEnum + && type != typeof(string) + && type != typeof(decimal) + && type != typeof(Guid) + && type != typeof(DateTime) + && type != typeof(DateTimeOffset) + && type != typeof(DateOnly) + && type != typeof(TimeOnly) + && type != typeof(TimeSpan) + && (type.Namespace is null || !type.Namespace.StartsWith("System", StringComparison.Ordinal)); + + static bool ShouldSkipJsonProperty(Type containingType, PropertyInfo property) => + property.GetCustomAttribute() is not null + || property.GetGetMethod(true) is null + || (property.GetSetMethod(true) is null && !HasBindableConstructorParameter(containingType, property)); + + static bool HasBindableConstructorParameter(Type containingType, PropertyInfo property) + { + var constructors = containingType.GetConstructors( + BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic + ); + foreach (var constructor in constructors) + { + foreach (var parameter in constructor.GetParameters()) + { + if ( + string.Equals(parameter.Name, property.Name, StringComparison.OrdinalIgnoreCase) + && parameter.ParameterType == property.PropertyType + ) + return true; + } + } + + return false; + } + + static bool IsPrimitiveLike(Type type) => + type.IsPrimitive + || type.IsEnum + || type == typeof(string) + || type == typeof(decimal) + || type == typeof(Guid) + || type == typeof(DateTime) + || type == typeof(DateTimeOffset) + || type == typeof(DateOnly) + || type == typeof(TimeOnly) + || type == typeof(TimeSpan) + || type == typeof(byte[]); + + static bool TryGetEnumerableElementType(Type type, out Type elementType) + { + elementType = null!; + + if (!type.IsGenericType) + return false; + + if (!IsEventStoreCollectionType(type)) + return false; + + elementType = type.GetGenericArguments()[0]; + return true; + } + + static bool IsEventStoreCollectionType(Type type) => + type.IsGenericType + && type.GetGenericTypeDefinition() is var genericDefinition + && (genericDefinition == typeof(EventStoreList<>) || genericDefinition == typeof(EventStoreSet<>)); + + static bool IsCollectionLikeType(Type type) + { + if (type == typeof(string) || type == typeof(byte[])) + return false; + + if (type.IsArray) + return true; + + if (!type.IsGenericType) + return false; + + // Test for our own collection types or if the type implements IEnumerable somewhere... + return IsEventStoreCollectionType(type) + || type.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>)); + } + + static bool IsReadOnlyCollectionType(Type type) + { + if (!type.IsGenericType) + return false; + + var genericTypeDefinition = type.GetGenericTypeDefinition(); + return genericTypeDefinition == typeof(IReadOnlyList<>) + || genericTypeDefinition == typeof(IReadOnlyCollection<>); + } + + static bool IsDictionaryLikeType(Type type) + { + if (!type.IsGenericType) + return false; + + var genericTypeDefinition = type.GetGenericTypeDefinition(); + if ( + genericTypeDefinition == typeof(Dictionary<,>) + || genericTypeDefinition == typeof(IDictionary<,>) + || genericTypeDefinition == typeof(IReadOnlyDictionary<,>) + ) + return true; + + // Check if the type implements IDictionary or IReadOnlyDictionary somewhere... + return type.GetInterfaces() + .Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IReadOnlyDictionary<,>)); + } + + static bool IsJsonConvertibleCollectionType(Type type) + { + if (type == typeof(string) || type == typeof(byte[])) + return false; + + if (!type.IsGenericType || IsEventStoreCollectionType(type) || IsDictionaryLikeType(type)) + return false; + + if (type.GetGenericTypeDefinition() == typeof(IEnumerable<>)) + return true; + + // Check if the type implements IEnumerable somewhere... + return type.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>)); + } + + static InvalidOperationException CreateUnsupportedShapeException(Type containingType, MemberInfo member) => + new( + $"{containingType.Name}.{member.Name} cannot be mapped into the snapshot JSON payload. " + + "Supported members are primitive types, [Scalar] value objects, complex types, and EventStoreList/EventStoreSet collections of those shapes." + ); + + static InvalidOperationException CreateUnsupportedCollectionTypeException( + Type containingType, + MemberInfo member, + Type collectionType + ) => + new( + $"{containingType.Name}.{member.Name} uses unsupported collection type '{collectionType.Name}'. " + + "Collection and array members must use Purview.EventSourcing.EventStoreList or Purview.EventSourcing.EventStoreSet." + ); + + static void EnsureSupportedOrderByExpression(Expression queryExpression) => + new UnsupportedScalarValueOrderByDetector().Visit(queryExpression); + + static Expression> RewriteAggregateTypePredicate( + Expression> whereClause, + string aggregateType + ) + where T : class + { + var aggregateTypeVisitor = new AggregateTypeExpressionVisitor(aggregateType); + var rewritten = (Expression>)aggregateTypeVisitor.Visit(whereClause)!; + var invariantCasingVisitor = new InvariantStringMethodNormalizationVisitor(); + rewritten = (Expression>)invariantCasingVisitor.Visit(rewritten)!; + var scalarVisitor = new ScalarValueMemberAccessPredicateVisitor(); + return (Expression>)scalarVisitor.Visit(rewritten)!; + } + + sealed class AggregateTypeExpressionVisitor(string aggregateType) : ExpressionVisitor + { + readonly ConstantExpression _aggregateType = Expression.Constant(aggregateType, typeof(string)); + + protected override Expression VisitMember(MemberExpression node) => + node.Member.Name == nameof(IAggregate.AggregateType) + && node.Expression is not null + && typeof(IAggregate).IsAssignableFrom(node.Expression.Type) + ? _aggregateType + : base.VisitMember(node); + } + + sealed class UnsupportedScalarValueOrderByDetector : ExpressionVisitor + { + protected override Expression VisitMethodCall(MethodCallExpression node) + { + if ( + node.Method.DeclaringType == typeof(Queryable) + && ( + node.Method.Name == nameof(Queryable.OrderBy) + || node.Method.Name == nameof(Queryable.OrderByDescending) + || node.Method.Name == nameof(Queryable.ThenBy) + || node.Method.Name == nameof(Queryable.ThenByDescending) + ) + ) + { + var lambda = (LambdaExpression)StripQuotes(node.Arguments[1]); + new ScalarValueMemberAccessDetector().Visit(lambda.Body); + } + + return base.VisitMethodCall(node); + } + + static Expression StripQuotes(Expression expression) + { + while (expression.NodeType == ExpressionType.Quote) + expression = ((UnaryExpression)expression).Operand; + + return expression; + } + } + + sealed class ScalarValueMemberAccessPredicateVisitor : ExpressionVisitor + { + protected override Expression VisitBinary(BinaryExpression node) + { + var visitedLeft = Visit(node.Left); + var visitedRight = Visit(node.Right); + + return + (node.NodeType == ExpressionType.Equal || node.NodeType == ExpressionType.NotEqual) + && TryRewriteScalarPrimitiveComparison( + visitedLeft, + visitedRight, + out var rewrittenLeft, + out var rewrittenRight + ) + ? Expression.MakeBinary(node.NodeType, rewrittenLeft, rewrittenRight) + : node.Update(visitedLeft, node.Conversion, visitedRight); + } + + protected override Expression VisitMember(MemberExpression node) + { + var visitedExpression = base.VisitMember(node); + if (visitedExpression is not MemberExpression visited || visited.Expression is null) + return visitedExpression; + + var scalarAttribute = visited.Expression.Type.GetCustomAttribute(); + if (scalarAttribute is null || visited.Member.Name != scalarAttribute.PropertyName) + return visited; + + try + { + return Expression.Convert(visited.Expression, visited.Type); + } + catch (InvalidOperationException) + { + return visited; + } + } + + static bool TryRewriteScalarPrimitiveComparison( + Expression left, + Expression right, + out Expression rewrittenLeft, + out Expression rewrittenRight + ) + { + rewrittenLeft = left; + rewrittenRight = right; + + if ( + TryGetScalarPropertyType(left.Type, out var leftScalarType) + && IsSameOrNullable(right.Type, leftScalarType) + ) + { + rewrittenLeft = Expression.Convert(left, right.Type); + return true; + } + + if ( + TryGetScalarPropertyType(right.Type, out var rightScalarType) + && IsSameOrNullable(left.Type, rightScalarType) + ) + { + rewrittenRight = Expression.Convert(right, left.Type); + return true; + } + + return false; + } + + static bool TryGetScalarPropertyType(Type candidateType, out Type scalarPropertyType) + { + scalarPropertyType = null!; + var scalarAttribute = candidateType.GetCustomAttribute(); + if (scalarAttribute is null) + return false; + + var scalarProperty = candidateType.GetProperty( + scalarAttribute.PropertyName, + BindingFlags.Instance | BindingFlags.Public + ); + if (scalarProperty is null) + return false; + + scalarPropertyType = scalarProperty.PropertyType; + return true; + } + + static bool IsSameOrNullable(Type candidate, Type expected) + { + var underlyingType = Nullable.GetUnderlyingType(candidate); + return candidate == expected || underlyingType == expected; + } + } + + sealed class InvariantStringMethodNormalizationVisitor : ExpressionVisitor + { + protected override Expression VisitMethodCall(MethodCallExpression node) + { + var visitedObject = Visit(node.Object); + var visitedArguments = Visit(node.Arguments); + + if (node.Method.DeclaringType == typeof(string) && node.Arguments.Count == 0 && visitedObject is not null) + { + if (node.Method.Name == nameof(string.ToLowerInvariant)) + return Expression.Call(visitedObject, nameof(string.ToLower), Type.EmptyTypes); + + if (node.Method.Name == nameof(string.ToUpperInvariant)) + return Expression.Call(visitedObject, nameof(string.ToUpper), Type.EmptyTypes); + } + + return node.Update(visitedObject, visitedArguments); + } + } + + sealed class ScalarValueMemberAccessDetector : ExpressionVisitor + { + protected override Expression VisitMember(MemberExpression node) + { + var visited = base.VisitMember(node); + if (node.Expression is null) + return visited; + + var scalarAttribute = node.Expression.Type.GetCustomAttribute(); + return scalarAttribute is not null && node.Member.Name == scalarAttribute.PropertyName + ? throw new InvalidOperationException( + $"Ordering by '{node.Expression.Type.Name}.{node.Member.Name}' is not supported for SQL snapshot JSON queries. " + + "Order by the scalar value object property itself (for example: c => c.Name) instead of its inner scalar member." + ) + : visited; + } + } + + sealed class SnapshotModelCacheKeyFactory : IModelCacheKeyFactory + { + public object Create(DbContext context, bool designTime) + { + var optionsField = context.GetType().GetField("_options", BindingFlags.Instance | BindingFlags.NonPublic); + if (optionsField?.GetValue(context) is PostgresClientOptions options) + { + if ( + context.GetType().IsGenericType + && context.GetType().GetGenericTypeDefinition() == typeof(SnapshotQueryDbContext<>) + ) + { + var aggregateType = context.GetType().GenericTypeArguments[0]; + return (context.GetType(), aggregateType, options.SchemaName, options.TableName, designTime); + } + + return (context.GetType(), options.SchemaName, options.TableName, designTime); + } + + return (context.GetType(), designTime); + } + } + + async Task EnsureTableIfEnabledAsync(CancellationToken cancellationToken) + { + if (!_options.AutoCreateTable || IsTableEnsured()) + return; + + var tableLock = EnsureTableLocks.GetOrAdd(_tableEnsureKey, static _ => new SemaphoreSlim(1, 1)); + await tableLock.WaitAsync(cancellationToken); + try + { + if (IsTableEnsured()) + return; + + try + { + await using var context = CreateStorageContext(); + await CreateStorageTablesWithEfAsync(context, cancellationToken); + await using var connection = new NpgsqlConnection(_options.ConnectionString); + await connection.OpenAsync(cancellationToken); + await PostgresJsonIndexSchemaManager.ApplyAsync( + connection, + transaction: null, + _options.SchemaName, + _options.TableName, + _options.JsonIndexOptions, + SupportedSnapshotIncludeColumns, + cancellationToken + ); + } + catch (Exception ex) when (IsDuplicateTableCreateError(ex, _options.TableName)) + { + // Another writer won the create race for the same table. + } + + MarkTableEnsured(); + } + finally + { + tableLock.Release(); + } + } + + async Task EnsureTableIfEnabledAsync( + NpgsqlConnection connection, + NpgsqlTransaction? transaction, + CancellationToken cancellationToken + ) + { + if (!_options.AutoCreateTable || IsTableEnsured()) + return; + + var tableLock = EnsureTableLocks.GetOrAdd(_tableEnsureKey, static _ => new SemaphoreSlim(1, 1)); + await tableLock.WaitAsync(cancellationToken); + try + { + if (IsTableEnsured()) + return; + + try + { + await using var context = CreateStorageContext(connection); + if (transaction is not null) + await context.Database.UseTransactionAsync(transaction, cancellationToken); + await CreateStorageTablesWithEfAsync(context, cancellationToken); + await PostgresJsonIndexSchemaManager.ApplyAsync( + connection, + transaction, + _options.SchemaName, + _options.TableName, + _options.JsonIndexOptions, + SupportedSnapshotIncludeColumns, + cancellationToken + ); + } + catch (Exception ex) when (IsDuplicateTableCreateError(ex, _options.TableName)) + { + // Another writer won the create race for the same table. + } + + MarkTableEnsured(); + } + finally + { + tableLock.Release(); + } + } + + bool IsTableEnsured() => EnsuredTables.ContainsKey(_tableEnsureKey); + + void MarkTableEnsured() => EnsuredTables.TryAdd(_tableEnsureKey, 0); + + static async Task CreateStorageTablesWithEfAsync(DbContext context, CancellationToken cancellationToken) + { + var creator = context.GetService(); + if (!await creator.ExistsAsync(cancellationToken)) + await creator.CreateAsync(cancellationToken); + + await creator.CreateTablesAsync(cancellationToken); + } + + static bool IsDuplicateTableCreateError(Exception exception, string _) + { + for (var current = exception; current is not null; current = current.InnerException) + { + if (current.Message.Contains("already an object named", StringComparison.OrdinalIgnoreCase)) + return true; + } + + return false; + } +} diff --git a/src/src/Postgres/Client/ScalarValueConverter.cs b/src/src/Postgres/Client/ScalarValueConverter.cs new file mode 100644 index 00000000..5ac9f896 --- /dev/null +++ b/src/src/Postgres/Client/ScalarValueConverter.cs @@ -0,0 +1,74 @@ +using System.Linq.Expressions; +using System.Reflection; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Postgres.Client; + +sealed class ScalarValueConverter : ValueConverter +{ + public ScalarValueConverter() + : base(BuildToProviderExpression(), BuildFromProviderExpression()) { } + + static Expression> BuildToProviderExpression() + { + var scalarProperty = GetScalarProperty(); + var source = Expression.Parameter(typeof(TScalarObject), "value"); + var body = Expression.Property(source, scalarProperty); + return Expression.Lambda>(body, source); + } + + static Expression> BuildFromProviderExpression() + { + var source = Expression.Parameter(typeof(TScalar), "value"); + var body = BuildCreatorExpression(source); + return Expression.Lambda>(body, source); + } + + static PropertyInfo GetScalarProperty() + { + var scalarType = typeof(TScalarObject); + var scalarAttribute = + scalarType.GetCustomAttribute() + ?? throw new InvalidOperationException($"{scalarType.Name} must be annotated with [Scalar]."); + + return scalarType.GetProperty(scalarAttribute.PropertyName, BindingFlags.Instance | BindingFlags.Public) + ?? throw new InvalidOperationException( + $"'{scalarType.Name}' missing scalar property '{scalarAttribute.PropertyName}'." + ); + } + + static Expression BuildCreatorExpression(ParameterExpression source) + { + var scalarType = typeof(TScalarObject); + var scalarPropertyType = typeof(TScalar); + var scalarAttribute = + scalarType.GetCustomAttribute() + ?? throw new InvalidOperationException($"{scalarType.Name} must be annotated with [Scalar]."); + + var preferredFactoryName = + scalarAttribute.DeserializationMode == ValueObjectDeserializationMode.Strict ? "Create" : "Hydrate"; + var secondaryFactoryName = preferredFactoryName == "Hydrate" ? "Create" : "Hydrate"; + + var create = + scalarType.GetMethod(preferredFactoryName, BindingFlags.Public | BindingFlags.Static, [scalarPropertyType]) + ?? scalarType.GetMethod( + secondaryFactoryName, + BindingFlags.Public | BindingFlags.Static, + [scalarPropertyType] + ); + if (create is not null) + return Expression.Call(create, source); + + var ctor = scalarType.GetConstructor( + BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, + [scalarPropertyType] + ); + + return ctor is null + ? throw new InvalidOperationException( + $"{scalarType.Name} must expose static {preferredFactoryName}({scalarPropertyType.Name}), static {secondaryFactoryName}({scalarPropertyType.Name}), or ctor({scalarPropertyType.Name})." + ) + : (Expression)Expression.New(ctor, source); + } +} diff --git a/src/src/Postgres/Events/AggregateVersionData.cs b/src/src/Postgres/Events/AggregateVersionData.cs new file mode 100644 index 00000000..67773f0a --- /dev/null +++ b/src/src/Postgres/Events/AggregateVersionData.cs @@ -0,0 +1,18 @@ +using Purview.EventSourcing.Aggregates; + +namespace Purview.EventSourcing.Postgres.Events; + +public record struct AggregateVersionData(int SavedVersion, int SnapshotVersion, int CurrentVersion) +{ + public static AggregateVersionData Create(IAggregate aggregate) + { + ArgumentNullException.ThrowIfNull(aggregate, nameof(aggregate)); + + return new() + { + SavedVersion = aggregate.Details.SavedVersion, + SnapshotVersion = aggregate.Details.SnapshotVersion, + CurrentVersion = aggregate.Details.CurrentVersion, + }; + } +} diff --git a/src/src/Postgres/Events/EntityFramework/EventStoreDbContext.cs b/src/src/Postgres/Events/EntityFramework/EventStoreDbContext.cs new file mode 100644 index 00000000..b5eeb074 --- /dev/null +++ b/src/src/Postgres/Events/EntityFramework/EventStoreDbContext.cs @@ -0,0 +1,110 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; + +namespace Purview.EventSourcing.Postgres.Events.EntityFramework; + +/// +/// EF Core DbContext for the PostgreSQL event store. +/// Provides model-first design with migrations for the event store table, +/// matching the same schema and indices as the ADO.NET auto-create path. +/// +/// +/// Creates a new with explicit schema and table names. +/// +public class EventStoreDbContext(DbContextOptions options, string schemaName, string tableName) + : DbContext(options) +{ + readonly string _schemaName = schemaName; + readonly string _tableName = tableName; + + /// + /// All event store rows (stream versions, events, idempotency markers, snapshots). + /// + public DbSet EventStoreEntities { get; set; } = default!; + + /// + /// Creates a new with the specified options. + /// Schema and table names default to "public" and "EventStore". + /// + public EventStoreDbContext(DbContextOptions options) + : this(options, "public", "EventStore") { } + + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + ArgumentNullException.ThrowIfNull(modelBuilder); + + modelBuilder.Entity(entity => + { + entity.ToTable(_tableName, _schemaName); + + entity.HasKey(e => e.Id); + entity.Property(e => e.Id).HasMaxLength(450).IsRequired(); + entity.Property(e => e.EntityType).IsRequired(); + entity.Property(e => e.AggregateId).HasMaxLength(450).IsRequired(); + entity.Property(e => e.AggregateType).HasMaxLength(450).IsRequired(); + entity.Property(e => e.Version).HasDefaultValue(0).IsRequired(); + entity.Property(e => e.IsDeleted).HasDefaultValue(false).IsRequired(); + entity.Property(e => e.Payload).HasColumnType("jsonb"); + entity.Property(e => e.EventType).HasMaxLength(450); + entity.Property(e => e.IdempotencyId).HasMaxLength(450); + entity.Property(e => e.Timestamp).HasDefaultValueSql("CURRENT_TIMESTAMP").IsRequired(); + + // Covers: GetByAggregateIdAndEntityType, GetIdempotencyMarkers, DeleteByAggregateId + entity + .HasIndex(e => new + { + e.AggregateId, + e.AggregateType, + e.EntityType, + }) + .HasDatabaseName($"IX_{_tableName}_AggregateId_EntityType") + .IncludeProperties(e => new { e.Version, e.IsDeleted }); + + // Covers: GetEventRange (AggregateId + AggregateType + EntityType=1 + Version range, ORDER BY Version) + entity + .HasIndex(e => new + { + e.AggregateId, + e.AggregateType, + e.Version, + }) + .HasDatabaseName($"IX_{_tableName}_EventRange") + .HasFilter("\"EntityType\" = 1") + .IncludeProperties(e => new + { + e.Payload, + e.EventType, + e.IdempotencyId, + e.Timestamp, + }); + + // Covers: GetAggregateIdsAsync (AggregateType + EntityType + optional IsDeleted filter) + entity + .HasIndex(e => new + { + e.AggregateType, + e.EntityType, + e.IsDeleted, + }) + .HasDatabaseName($"IX_{_tableName}_AggregateType_EntityType") + .IncludeProperties(e => new { e.AggregateId }); + }); + } + + protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) + { + ArgumentNullException.ThrowIfNull(optionsBuilder); + optionsBuilder.ReplaceService(); + } + + sealed class EventStoreModelCacheKeyFactory : IModelCacheKeyFactory + { + public object Create(DbContext context, bool designTime) + { + if (context is EventStoreDbContext eventStoreContext) + return (context.GetType(), eventStoreContext._schemaName, eventStoreContext._tableName, designTime); + + return (context.GetType(), designTime); + } + } +} diff --git a/src/src/Postgres/Events/EntityFramework/EventStoreDbContextDesignTimeFactory.cs b/src/src/Postgres/Events/EntityFramework/EventStoreDbContextDesignTimeFactory.cs new file mode 100644 index 00000000..d658dd5f --- /dev/null +++ b/src/src/Postgres/Events/EntityFramework/EventStoreDbContextDesignTimeFactory.cs @@ -0,0 +1,19 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Design; + +namespace Purview.EventSourcing.Postgres.Events.EntityFramework; + +/// +/// Design-time factory for . +/// Used by EF Core tools to generate migrations. +/// +public sealed class EventStoreDbContextDesignTimeFactory : IDesignTimeDbContextFactory +{ + public EventStoreDbContext CreateDbContext(string[] args) + { + var optionsBuilder = new DbContextOptionsBuilder(); + optionsBuilder.UseNpgsql("Host=localhost;Database=eventstore_design;Username=postgres;Password=postgres"); + + return new EventStoreDbContext(optionsBuilder.Options); + } +} diff --git a/src/src/Postgres/Events/EntityFramework/EventStoreEntity.cs b/src/src/Postgres/Events/EntityFramework/EventStoreEntity.cs new file mode 100644 index 00000000..97e54f2b --- /dev/null +++ b/src/src/Postgres/Events/EntityFramework/EventStoreEntity.cs @@ -0,0 +1,58 @@ +namespace Purview.EventSourcing.Postgres.Events.EntityFramework; + +/// +/// EF Core entity model representing a row in the PostgreSQL event store table. +/// Used for model-first migrations — maps to the same schema as the ADO.NET client. +/// +public sealed class EventStoreEntity +{ + /// + /// Composite primary key (e.g. "s_Type_Id", "e_Type_Id_00001", "snap_Type_Id"). + /// + public string Id { get; set; } = default!; + + /// + /// Discriminator: 0 = StreamVersion, 1 = Event, 2 = IdempotencyMarker, 3 = Snapshot. + /// + public int EntityType { get; set; } + + /// + /// The aggregate identifier this row belongs to. + /// + public string AggregateId { get; set; } = default!; + + /// + /// Short name of the aggregate type (e.g. "Order"). + /// + public string AggregateType { get; set; } = default!; + + /// + /// The event or stream version number. + /// + public int Version { get; set; } + + /// + /// Whether this aggregate has been soft-deleted. + /// + public bool IsDeleted { get; set; } + + /// + /// JSON-serialized event or snapshot payload (null for stream version and idempotency markers). + /// + public string? Payload { get; set; } + + /// + /// The event type name (null for non-event rows). + /// + public string? EventType { get; set; } + + /// + /// The idempotency marker identifier (null for non-idempotency rows). + /// + public string? IdempotencyId { get; set; } + + /// + /// UTC timestamp of when this row was created or last modified. + /// + public DateTimeOffset Timestamp { get; set; } +} diff --git a/src/src/Postgres/Events/EntityFramework/Migrations/20260412000000_InitialCreate.cs b/src/src/Postgres/Events/EntityFramework/Migrations/20260412000000_InitialCreate.cs new file mode 100644 index 00000000..1b769507 --- /dev/null +++ b/src/src/Postgres/Events/EntityFramework/Migrations/20260412000000_InitialCreate.cs @@ -0,0 +1,75 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace Purview.EventSourcing.Postgres.Events.EntityFramework.Migrations; + +/// +public partial class InitialCreate : Migration +{ + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.EnsureSchema(name: "public"); + + migrationBuilder.CreateTable( + name: "EventStoreEvents", + schema: "public", + columns: table => new + { + Id = table.Column(type: "character varying(450)", maxLength: 450, nullable: false), + EntityType = table.Column(type: "integer", nullable: false), + AggregateId = table.Column(type: "character varying(450)", maxLength: 450, nullable: false), + AggregateType = table.Column(type: "character varying(450)", maxLength: 450, nullable: false), + Version = table.Column(type: "integer", nullable: false, defaultValue: 0), + IsDeleted = table.Column(type: "boolean", nullable: false, defaultValue: false), + Payload = table.Column(type: "jsonb", nullable: true), + EventType = table.Column(type: "character varying(450)", maxLength: 450, nullable: true), + IdempotencyId = table.Column(type: "character varying(450)", maxLength: 450, nullable: true), + Timestamp = table.Column( + type: "timestamp with time zone", + nullable: false, + defaultValueSql: "CURRENT_TIMESTAMP" + ), + }, + constraints: table => + { + table.PrimaryKey("PK_EventStoreEvents", x => x.Id); + } + ); + + migrationBuilder + .CreateIndex( + name: "IX_EventStoreEvents_AggregateId_EntityType", + schema: "public", + table: "EventStoreEvents", + columns: new[] { "AggregateId", "AggregateType", "EntityType" } + ) + .Annotation("Npgsql:IndexInclude", new[] { "Version", "IsDeleted" }); + + migrationBuilder + .CreateIndex( + name: "IX_EventStoreEvents_AggregateType_EntityType", + schema: "public", + table: "EventStoreEvents", + columns: new[] { "AggregateType", "EntityType", "IsDeleted" } + ) + .Annotation("Npgsql:IndexInclude", new[] { "AggregateId" }); + + migrationBuilder + .CreateIndex( + name: "IX_EventStoreEvents_EventRange", + schema: "public", + table: "EventStoreEvents", + columns: new[] { "AggregateId", "AggregateType", "Version" }, + filter: "\"EntityType\" = 1" + ) + .Annotation("Npgsql:IndexInclude", new[] { "Payload", "EventType", "IdempotencyId", "Timestamp" }); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable(name: "EventStoreEvents", schema: "public"); + } +} diff --git a/src/src/Postgres/Events/Exceptions/AggregateAlreadyDeletedException.cs b/src/src/Postgres/Events/Exceptions/AggregateAlreadyDeletedException.cs new file mode 100644 index 00000000..2ef5378e --- /dev/null +++ b/src/src/Postgres/Events/Exceptions/AggregateAlreadyDeletedException.cs @@ -0,0 +1,13 @@ +namespace Purview.EventSourcing.Postgres.Events.Exceptions; + +#pragma warning disable CA1032 // Implement standard exception constructors +public class AggregateAlreadyDeletedException(string aggregateId, string idempotencyId) + : Exception( + $"An attempt to delete an aggregate (Id: {aggregateId}) that is already deleted was made. {nameof(idempotencyId)}: {idempotencyId}." + ) +#pragma warning restore CA1032 // Implement standard exception constructors +{ + public string AggregateId { get; } = aggregateId ?? throw new ArgumentNullException(nameof(aggregateId)); + + public string IdempotencyId { get; } = idempotencyId ?? throw new ArgumentNullException(nameof(idempotencyId)); +} diff --git a/src/src/Postgres/Events/Exceptions/AggregateDeletedException.cs b/src/src/Postgres/Events/Exceptions/AggregateDeletedException.cs new file mode 100644 index 00000000..28d4c041 --- /dev/null +++ b/src/src/Postgres/Events/Exceptions/AggregateDeletedException.cs @@ -0,0 +1,13 @@ +namespace Purview.EventSourcing.Postgres.Events.Exceptions; + +#pragma warning disable CA1032 // Implement standard exception constructors +public class AggregateDeletedException(string aggregateId, string idempotencyId) + : Exception( + $"An attempt to save an aggregate that has been deleted, aggregate Id: {aggregateId}, {nameof(IdempotencyId)}: {idempotencyId}." + ) +#pragma warning restore CA1032 // Implement standard exception constructors +{ + public string AggregateId { get; } = aggregateId ?? throw new ArgumentNullException(nameof(aggregateId)); + + public string IdempotencyId { get; } = idempotencyId ?? throw new ArgumentNullException(nameof(idempotencyId)); +} diff --git a/src/src/Postgres/Events/Exceptions/AggregateIsDeletedException.cs b/src/src/Postgres/Events/Exceptions/AggregateIsDeletedException.cs new file mode 100644 index 00000000..fa065c90 --- /dev/null +++ b/src/src/Postgres/Events/Exceptions/AggregateIsDeletedException.cs @@ -0,0 +1,9 @@ +namespace Purview.EventSourcing.Postgres.Events.Exceptions; + +#pragma warning disable CA1032 // Implement standard exception constructors +public class AggregateIsDeletedException(string aggregateId) + : Exception($"Invalid operation against an aggregate (Id: {aggregateId}) that has been deleted.") +#pragma warning restore CA1032 // Implement standard exception constructors +{ + public string AggregateId { get; } = aggregateId ?? throw new ArgumentNullException(nameof(aggregateId)); +} diff --git a/src/src/Postgres/Events/Exceptions/AggregateLockedException.cs b/src/src/Postgres/Events/Exceptions/AggregateLockedException.cs new file mode 100644 index 00000000..ecba00cd --- /dev/null +++ b/src/src/Postgres/Events/Exceptions/AggregateLockedException.cs @@ -0,0 +1,11 @@ +namespace Purview.EventSourcing.Postgres.Events.Exceptions; + +#pragma warning disable CA1032 // Implement standard exception constructors +public class AggregateLockedException(string idempotencyId) + : Exception( + $"An attempt to save an aggregate that is currently locked was made, {nameof(idempotencyId)}: {idempotencyId}." + ) +#pragma warning restore CA1032 // Implement standard exception constructors +{ + public string IdempotencyId { get; set; } = idempotencyId ?? throw new ArgumentNullException(nameof(idempotencyId)); +} diff --git a/src/src/Postgres/Events/Exceptions/AggregateNotDeletedException.cs b/src/src/Postgres/Events/Exceptions/AggregateNotDeletedException.cs new file mode 100644 index 00000000..62731526 --- /dev/null +++ b/src/src/Postgres/Events/Exceptions/AggregateNotDeletedException.cs @@ -0,0 +1,9 @@ +namespace Purview.EventSourcing.Postgres.Events.Exceptions; + +#pragma warning disable CA1032 // Implement standard exception constructors +public class AggregateNotDeletedException(string aggregateId) + : Exception($"An attempt to get an aggregate that has not been deleted, aggregate Id: {aggregateId}.") +#pragma warning restore CA1032 // Implement standard exception constructors +{ + public string AggregateId { get; } = aggregateId ?? throw new ArgumentNullException(nameof(aggregateId)); +} diff --git a/src/src/Postgres/Events/Exceptions/AggregateStreamVersionMissingException.cs b/src/src/Postgres/Events/Exceptions/AggregateStreamVersionMissingException.cs new file mode 100644 index 00000000..7d8efa31 --- /dev/null +++ b/src/src/Postgres/Events/Exceptions/AggregateStreamVersionMissingException.cs @@ -0,0 +1,13 @@ +namespace Purview.EventSourcing.Postgres.Events.Exceptions; + +#pragma warning disable CA1032 // Implement standard exception constructors +public class AggregateStreamVersionMissingException(string aggregateId, string idempotencyId) + : Exception( + $"An attempt to delete an aggregate (Id: {aggregateId}) that doesn't a stream version deleted was made. {nameof(idempotencyId)}: {idempotencyId}." + ) +#pragma warning restore CA1032 // Implement standard exception constructors +{ + public string AggregateId { get; } = aggregateId ?? throw new ArgumentNullException(nameof(aggregateId)); + + public string IdempotencyId { get; } = idempotencyId ?? throw new ArgumentNullException(nameof(idempotencyId)); +} diff --git a/src/src/Postgres/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs b/src/src/Postgres/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs new file mode 100644 index 00000000..2b90d67b --- /dev/null +++ b/src/src/Postgres/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs @@ -0,0 +1,13 @@ +namespace Purview.EventSourcing.Postgres.Events.Exceptions; + +#pragma warning disable CA1032 // Implement standard exception constructors +public class AggregatedNotAlreadyDeletedException(string aggregateId, string idempotencyId) + : Exception( + $"An attempt to restore an aggregate (Id: {aggregateId}) that is not deleted was made.\n\n\tIdempotencyId: {idempotencyId}." + ) +#pragma warning restore CA1032 // Implement standard exception constructors +{ + public string AggregateId { get; } = aggregateId ?? throw new ArgumentNullException(nameof(aggregateId)); + + public string IdempotencyId { get; } = idempotencyId ?? throw new ArgumentNullException(nameof(idempotencyId)); +} diff --git a/src/src/Postgres/Events/Exceptions/CommitException.cs b/src/src/Postgres/Events/Exceptions/CommitException.cs new file mode 100644 index 00000000..54ca3814 --- /dev/null +++ b/src/src/Postgres/Events/Exceptions/CommitException.cs @@ -0,0 +1,24 @@ +namespace Purview.EventSourcing.Postgres.Events.Exceptions; + +#pragma warning disable CA1032 // Implement standard exception constructors +public class CommitException( + string aggregateId, + string idempotencyId, + int versionAttempted, + int version, + Exception exception +) + : Exception( + $"Failed to commit events.\n\tAggregateId: {aggregateId}\n\tIdempotencyId: {idempotencyId}\n\tVersionAttempted: {versionAttempted}\n\tVersionPresent: {version}", + exception + ) +#pragma warning restore CA1032 // Implement standard exception constructors +{ + public string AggregateId { get; } = aggregateId ?? throw new ArgumentNullException(nameof(aggregateId)); + + public int VersionAttempted { get; } = versionAttempted; + + public string IdempotencyId { get; } = idempotencyId ?? throw new ArgumentNullException(nameof(idempotencyId)); + + public int Version { get; } = version; +} diff --git a/src/src/Postgres/Events/Exceptions/ConcurrencyException.cs b/src/src/Postgres/Events/Exceptions/ConcurrencyException.cs new file mode 100644 index 00000000..cf6ef1f0 --- /dev/null +++ b/src/src/Postgres/Events/Exceptions/ConcurrencyException.cs @@ -0,0 +1,17 @@ +namespace Purview.EventSourcing.Postgres.Events.Exceptions; + +#pragma warning disable CA1032 // Implement standard exception constructors +public class ConcurrencyException(string aggregateId, string idempotencyId, int versionAttempted, int version) + : Exception( + $"Optimistic concurrency error:\n\tAggregateId: {aggregateId}\n\tIdempotencyId: {idempotencyId}\n\tVersionAttempted:{versionAttempted}\n\tVersionPresent:{version}" + ) +#pragma warning restore CA1032 // Implement standard exception constructors +{ + public string AggregateId { get; } = aggregateId ?? throw new ArgumentNullException(nameof(aggregateId)); + + public int VersionAttempted { get; } = versionAttempted; + + public string IdempotencyId { get; } = idempotencyId ?? throw new ArgumentNullException(nameof(idempotencyId)); + + public int Version { get; } = version; +} diff --git a/src/src/Postgres/Events/Exceptions/MissingAggregateIdException.cs b/src/src/Postgres/Events/Exceptions/MissingAggregateIdException.cs new file mode 100644 index 00000000..1d17f279 --- /dev/null +++ b/src/src/Postgres/Events/Exceptions/MissingAggregateIdException.cs @@ -0,0 +1,9 @@ +namespace Purview.EventSourcing.Postgres.Events.Exceptions; + +#pragma warning disable CA1032 // Implement standard exception constructors +public class MissingAggregateIdException(string idempotencyId) + : Exception($"An attempt to save an aggregate is a missing Id was made, {nameof(idempotencyId)}: {idempotencyId}.") +#pragma warning restore CA1032 // Implement standard exception constructors +{ + public string IdempotencyId { get; set; } = idempotencyId ?? throw new ArgumentNullException(nameof(idempotencyId)); +} diff --git a/src/src/Postgres/Events/IPostgresEventStore.cs b/src/src/Postgres/Events/IPostgresEventStore.cs new file mode 100644 index 00000000..f7d09a14 --- /dev/null +++ b/src/src/Postgres/Events/IPostgresEventStore.cs @@ -0,0 +1,7 @@ +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Internal; + +namespace Purview.EventSourcing.Postgres.Events; + +public interface IPostgresEventStore : INonQueryableEventStore, IAggregateEventHistoryStoreCore + where T : class, IAggregate, new() { } diff --git a/src/src/Postgres/Events/IPostgresEventStoreTelemetry.cs b/src/src/Postgres/Events/IPostgresEventStoreTelemetry.cs new file mode 100644 index 00000000..8cdeb77e --- /dev/null +++ b/src/src/Postgres/Events/IPostgresEventStoreTelemetry.cs @@ -0,0 +1,179 @@ +using System.Diagnostics; +using Microsoft.Extensions.Logging; +using Purview.Telemetry; + +namespace Purview.EventSourcing.Postgres.Events; + +[ActivitySource] +[Logger] +[Meter] +public interface IPostgresEventStoreTelemetry +{ + // Activities (distributed tracing) + + [Activity] + Activity? GetAggregate(string aggregateId, [Baggage] string aggregateTypeFullName); + + [Activity] + Activity? GetAggregateAtVersion(string aggregateId, int version, [Baggage] string aggregateTypeFullName); + + [Activity] + Activity? SaveAggregate(string aggregateId, [Baggage] string aggregateTypeFullName); + + [Activity] + Activity? DeleteAggregate(string aggregateId, [Baggage] string aggregateTypeFullName); + + [Event] + void EventsReconstituted(Activity? activity, int eventCount, int version); + + [Event] + void SaveCompleted(Activity? activity, int eventCount); + + // Metrics (counters) + + [AutoCounter] + void AggregateLoaded(string aggregateType); + + [AutoCounter] + void AggregateSaved(string aggregateType); + + [AutoCounter] + void AggregateDeletedCounter(string aggregateType); + + // Logging + + [Log(LogLevel.Debug)] + void AggregateRetrievedFromCache(string aggregateId, string aggregateTypeFullName); + + [Log(LogLevel.Debug)] + void GetAggregateStart(string aggregateId, string aggregateTypeFullName); + + [Log(LogLevel.Error)] + void GetAggregateAtSpecificVersionFailed( + string aggregateId, + string aggregateTypeFullName, + int specificVersion, + Exception exception + ); + + [Log(LogLevel.Debug)] + void ReconstitutedAggregateFromEvents( + string aggregateId, + string aggregateTypeFullName, + string aggregateType, + int eventCount, + AggregateVersionData versionData + ); + + [Log(LogLevel.Debug)] + void GetAggregateAtSpecificVersionStart(string aggregateId, int specificVersion, string aggregateTypeFullName); + + [Log(LogLevel.Debug)] + void SaveContainedNoChanges(string aggregateId, string aggregateTypeFullName, string aggregateType); + + [Log(LogLevel.Warning)] + void SkippedUnknownEvent( + string aggregateId, + string aggregateTypeFullName, + string aggregateType, + string eventType, + int aggregateVersion + ); + + [Log(LogLevel.Warning)] + void CannotApplyEvent( + string aggregateId, + string aggregateTypeFullName, + string aggregateType, + string eventType, + string eventTypeFullName, + int aggregateVersion + ); + + [Log(LogLevel.Debug)] + void GetAggregateComplete(string aggregateId, string aggregateTypeFullName, long elapsedMilliseconds); + + [Log(LogLevel.Error)] + void SnapshotDeserializationFailed(string aggregateId, string aggregateTypeFullName, Exception exception); + + [Log(LogLevel.Warning)] + void CacheGetFailure(string aggregateId, string aggregateTypeFullName, Exception exception); + + [Log(LogLevel.Warning)] + void CacheUpdateFailure(string aggregateId, string aggregateTypeFullName, Exception exception); + + [Log(LogLevel.Debug)] + void AggregateDeleted(string aggregateId, string aggregateTypeFullName, string aggregateType); + + [Log(LogLevel.Debug)] + void AggregateRestored(string aggregateId, string aggregateTypeFullName, string aggregateType); + + [Log(LogLevel.Debug)] + void SaveCalled(string aggregateId, string aggregateTypeFullName, string aggregateType); + + [Log(LogLevel.Error)] + void SaveFailedAtStorage(string aggregateId, string aggregateTypeFullName, Exception exception); + + [Log(LogLevel.Debug)] + void EventsAlreadyApplied(string aggregateId, string idempotencyId); + + [Log(LogLevel.Error)] + void SaveFailed(string aggregateId, string aggregateTypeFullName, Exception exception); + + [Log(LogLevel.Warning)] + void MissingEventType(string aggregateTypeFullName, string eventType); + + [Log(LogLevel.Debug)] + void GetAggregateAtSpecificVersionComplete( + string aggregateId, + string aggregateTypeFullName, + int specificVersion, + long elapsedMilliseconds + ); + + [Log(LogLevel.Warning)] + void CacheRemovalFailure(string aggregateId, string aggregateTypeFullName, Exception exception); + + [Log(LogLevel.Warning)] + void EventDeserializationFailed(string aggregateId, string aggregateTypeFullName, Exception exception); + + [Log(LogLevel.Debug)] + void SavedAggregate(string aggregateId, string aggregateTypeFullName, int eventCount, string aggregateType); + + [Log(LogLevel.Error)] + void GetAggregateFailed(string aggregateId, string aggregateTypeFullName, Exception exception); + + [Log(LogLevel.Warning)] + void StreamVersionExpectedToExistButNotFound( + string aggregateId, + string aggregateTypeName, + string aggregateTypeFullName + ); + + [Log(LogLevel.Debug)] + void StreamVersionNotFound(string aggregateId); + + [Log(LogLevel.Debug)] + void StreamVersionFound(string aggregateId, int streamVersion, string aggregateType, bool isDeleted); + + [Log(LogLevel.Error)] + void GetStreamVersionFailed(string aggregateId, Exception exception); + + [Log(LogLevel.Debug)] + void GetStreamVersionStart(string aggregateId); + + [Log(LogLevel.Debug)] + void GetStreamVersionComplete(string aggregateId, long elapsedMilliseconds); + + [Log(LogLevel.Debug)] + void PermanentDeleteRequested(string aggregateId); + + [Log(LogLevel.Critical)] + void PermanentDeleteFailed(string aggregateId, Exception exception); + + [Log(LogLevel.Debug)] + void PermanentDeleteComplete(string aggregateId); + + [Log(LogLevel.Error)] + void GetIdempotencyMarkerFailed(string aggregateId, string idempotencyId, Exception exception); +} diff --git a/src/src/Postgres/Events/PostgresEventStore.CreateAsync.cs b/src/src/Postgres/Events/PostgresEventStore.CreateAsync.cs new file mode 100644 index 00000000..7af13193 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.CreateAsync.cs @@ -0,0 +1,27 @@ +using Purview.EventSourcing.Services; + +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + public async Task CreateAsync(string? aggregateId = null, CancellationToken cancellationToken = default) + { + if (string.IsNullOrWhiteSpace(aggregateId)) + { + if (_aggregateIdFactory != null) + { + aggregateId = await _aggregateIdFactory.CreateAsync(cancellationToken); + if (string.IsNullOrWhiteSpace(aggregateId)) + throw new NullReferenceException( + $"The {typeof(IAggregateIdFactory).FullName} implementation ({_aggregateIdFactory.GetType().FullName}) generated a null or empty Id." + ); + } + else + aggregateId = $"{Guid.NewGuid():D}"; + } + + var aggregate = new T { Details = { Id = aggregateId } }; + + return FulfilRequirements(aggregate); + } +} diff --git a/src/src/Postgres/Events/PostgresEventStore.DeleteAsync.cs b/src/src/Postgres/Events/PostgresEventStore.DeleteAsync.cs new file mode 100644 index 00000000..52abd7ff --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.DeleteAsync.cs @@ -0,0 +1,87 @@ +using Purview.EventSourcing.Aggregates.Events; + +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + public async Task DeleteAsync( + T aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + if (aggregate == null) + throw NullAggregate(aggregate); + + if (aggregate.Details.IsDeleted) + throw AggregateIsDeletedException(aggregate.Id()); + + operationContext ??= EventStoreOperationContext.DefaultContext(); + + if (aggregate.IsNew()) + return false; + + if (operationContext.PermanentlyDelete) + return await PermanentlyDeleteAsync(aggregate, operationContext, cancellationToken); + + Deleted deleteAggregateEvent = new() + { + Details = { AggregateVersion = aggregate.Details.CurrentVersion + 1, When = DateTimeOffset.UtcNow }, + }; + aggregate.ApplyEvent(deleteAggregateEvent); + + var result = await SaveCoreAsync( + aggregate, + operationContext, + null, + null, + cancellationToken, + deleteAggregateEvent + ); + await result.AfterCommitAsync(cancellationToken); + + return result.Result.Saved; + } + + async Task PermanentlyDeleteAsync( + T aggregate, + EventStoreOperationContext operationContext, + CancellationToken cancellationToken = default + ) + { + if (aggregate == null) + throw NullAggregate(aggregate); + + var aggregateId = aggregate.Id(); + var streamVersion = await GetStreamVersionAsync(aggregateId, true, cancellationToken); + if (streamVersion == null) + return false; + + _eventStoreTelemetry.PermanentDeleteRequested(aggregateId); + using var activity = _eventStoreTelemetry.DeleteAggregate(aggregateId, _aggregateTypeFullName); + try + { + await _client.DeleteByAggregateIdAsync(aggregateId, _aggregateTypeShortName, cancellationToken); + + _eventStoreTelemetry.PermanentDeleteComplete(aggregateId); + _eventStoreTelemetry.AggregateDeletedCounter(aggregate.AggregateType); + + aggregate.Details.IsDeleted = true; + aggregate.Details.Locked = true; + + return true; + } +#pragma warning disable CA1031 + catch (Exception ex) +#pragma warning restore CA1031 + { + _eventStoreTelemetry.PermanentDeleteFailed(aggregateId, ex); + + return false; + } + finally + { + ClearCacheFireAndForget(aggregate); + } + } +} diff --git a/src/src/Postgres/Events/PostgresEventStore.ExceptionHelpers.cs b/src/src/Postgres/Events/PostgresEventStore.ExceptionHelpers.cs new file mode 100644 index 00000000..c3c55767 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.ExceptionHelpers.cs @@ -0,0 +1,13 @@ +using Purview.EventSourcing.Postgres.Events.Exceptions; + +namespace Purview.EventSourcing.Postgres.Events; + +[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0060:Remove unused parameter")] +partial class PostgresEventStore +{ + static ArgumentNullException NullAggregate(T? aggregate) => new(nameof(aggregate)); + + static AggregateIsDeletedException AggregateIsDeletedException(string aggregateId) => new(aggregateId); + + static AggregateNotDeletedException AggregateNotDeletedException(string aggregateId) => new(aggregateId); +} diff --git a/src/src/Postgres/Events/PostgresEventStore.ExistsAsync.cs b/src/src/Postgres/Events/PostgresEventStore.ExistsAsync.cs new file mode 100644 index 00000000..8206e0b1 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.ExistsAsync.cs @@ -0,0 +1,18 @@ +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + public async Task ExistsAsync(string aggregateId, CancellationToken cancellationToken = default) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); + + var streamVersion = await GetStreamVersionAsync(aggregateId, false, cancellationToken); + return streamVersion == null + ? ExistsState.DoesNotExist + : new ExistsState + { + Status = streamVersion.IsDeleted ? ExistsStatus.ExistsInDeletedState : ExistsStatus.Exists, + Version = streamVersion.Version, + }; + } +} diff --git a/src/src/Postgres/Events/PostgresEventStore.GetAsync.cs b/src/src/Postgres/Events/PostgresEventStore.GetAsync.cs new file mode 100644 index 00000000..67ed37a4 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.GetAsync.cs @@ -0,0 +1,199 @@ +using System.Globalization; +using Microsoft.Extensions.Caching.Distributed; +using Purview.EventSourcing.Aggregates.Events; + +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + [System.Diagnostics.DebuggerStepThrough] + public Task GetAsync( + string aggregateId, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) => GetCoreAsync(aggregateId, operationContext, cancellationToken); + + async Task GetCoreAsync( + string aggregateId, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); + + operationContext ??= EventStoreOperationContext.DefaultContext(); + + _eventStoreTelemetry.GetAggregateStart(aggregateId, _aggregateTypeFullName); + using var activity = _eventStoreTelemetry.GetAggregate(aggregateId, _aggregateTypeFullName); + var getStopwatch = System.Diagnostics.Stopwatch.StartNew(); + try + { + var aggregate = operationContext.SnapshotCacheMode.HasFlag(SnapshotCachingOptions.GetFromCache) + ? await GetFromCacheAsync(aggregateId, cancellationToken) + : null; + + if (aggregate != null) + { + _eventStoreTelemetry.AggregateRetrievedFromCache(aggregateId, _aggregateTypeFullName); + + return ReturnAggregate(aggregate.Details.IsDeleted, aggregateId, operationContext) + ? PrepareAggregateForReturn(aggregate, _aggregateRequirementsManager) + : null; + } + + var streamVersion = await GetStreamVersionAsync(aggregateId, true, cancellationToken); + if (streamVersion == null) + return null; + + if (!ReturnAggregate(streamVersion.IsDeleted, aggregateId, operationContext)) + return null; + + int? streamVersionIdentifier = null; + if (!operationContext.SkipSnapshot) + aggregate = await GetLatestSnapshotAsync(aggregateId, cancellationToken); + + aggregate ??= new T { Details = { Id = aggregateId } }; + + await GetAndApplyEventsAsync(aggregate, streamVersion, streamVersionIdentifier, cancellationToken); + await UpdateCacheAsync(aggregate, operationContext.CacheOptions, cancellationToken); + + _eventStoreTelemetry.AggregateLoaded(aggregate.AggregateType); + + return PrepareAggregateForReturn(aggregate, _aggregateRequirementsManager); + } + catch (Exception ex) + { + _eventStoreTelemetry.GetAggregateFailed(aggregateId, _aggregateTypeFullName, ex); + throw; + } + finally + { + getStopwatch.Stop(); + _eventStoreTelemetry.GetAggregateComplete( + aggregateId, + _aggregateTypeFullName, + getStopwatch.ElapsedMilliseconds + ); + } + + static T PrepareAggregateForReturn( + T aggregate, + Services.IAggregateRequirementsManager aggregateRequirementsManager + ) + { + var currentVersion = aggregate.Details.CurrentVersion; + + aggregate.ClearUnsavedEvents(); + + aggregate.Details.CurrentVersion = currentVersion; + + aggregateRequirementsManager.Fulfil(aggregate); + + return aggregate; + } + } + + async Task GetAndApplyEventsAsync( + T aggregate, + StreamVersionData streamVersion, + int? maxVersion, + CancellationToken cancellationToken + ) + { + var aggregateId = aggregate.Id(); + var eventCount = 0; + var eventQuery = GetEventRangeAsync( + aggregateId, + aggregate.Details.SnapshotVersion + 1, + maxVersion, + cancellationToken + ); + await foreach (var eventResult in eventQuery) + { + var @event = eventResult.@event; + if (@event is EventUnknown || !aggregate.CanApplyEvent(@event)) + { + var eventType = @event.GetType(); + if (@event is EventUnknown) + _eventStoreTelemetry.SkippedUnknownEvent( + aggregateId, + _aggregateTypeFullName, + aggregate.AggregateType, + eventResult.eventType, + @event.Details.AggregateVersion + ); + else + _eventStoreTelemetry.CannotApplyEvent( + aggregateId, + _aggregateTypeFullName, + aggregate.AggregateType, + eventResult.eventType, + eventType.FullName ?? eventType.Name, + @event.Details.AggregateVersion + ); + + aggregate.Details.CurrentVersion = @event.Details.AggregateVersion; + } + else + aggregate.ApplyEvent(@event); + + eventCount++; + } + + _eventStoreTelemetry.ReconstitutedAggregateFromEvents( + aggregateId, + _aggregateTypeFullName, + aggregate.AggregateType, + eventCount, + AggregateVersionData.Create(aggregate) + ); + + aggregate.Details.SavedVersion = aggregate.Details.CurrentVersion; + aggregate.Details.Etag = streamVersion.Version.ToString(CultureInfo.InvariantCulture); + + aggregate.Details.IsDeleted = streamVersion.IsDeleted; + } + + async Task GetLatestSnapshotAsync(string aggregateId, CancellationToken cancellationToken) + { + try + { + var snapshotId = CreateSnapshotId(aggregateId); + var row = await _client.GetByIdAsync(snapshotId, cancellationToken); + return row == null || row.EntityType != SnapshotType || string.IsNullOrWhiteSpace(row.Payload) + ? null + : DeserializeSnapshot(row.Payload); + } +#pragma warning disable CA1031 + catch (Exception ex) +#pragma warning restore CA1031 + { + _eventStoreTelemetry.SnapshotDeserializationFailed(aggregateId, _aggregateTypeFullName, ex); + + return null; + } + } + + async Task GetFromCacheAsync(string aggregateId, CancellationToken cancellationToken) + { + T? aggregate = null; + try + { + var cacheKey = CreateCacheKey(aggregateId); + var snapshotData = await _distributedCache.GetStringAsync(cacheKey, cancellationToken); + if (!string.IsNullOrWhiteSpace(snapshotData)) + { + aggregate = DeserializeSnapshot(snapshotData); + aggregate.Details.SavedVersion = aggregate.Details.CurrentVersion; + } + } +#pragma warning disable CA1031 + catch (Exception ex) +#pragma warning restore CA1031 + { + _eventStoreTelemetry.CacheGetFailure(aggregateId, _aggregateTypeFullName, ex); + } + + return aggregate; + } +} diff --git a/src/src/Postgres/Events/PostgresEventStore.GetAtAsync.cs b/src/src/Postgres/Events/PostgresEventStore.GetAtAsync.cs new file mode 100644 index 00000000..26e0cd89 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.GetAtAsync.cs @@ -0,0 +1,55 @@ +using System.Diagnostics; + +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + public async Task GetAtAsync( + string aggregateId, + int version, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); + + operationContext ??= EventStoreOperationContext.DefaultContext(); + + _eventStoreTelemetry.GetAggregateAtSpecificVersionStart(aggregateId, version, _aggregateTypeFullName); + using var activity = _eventStoreTelemetry.GetAggregateAtVersion(aggregateId, version, _aggregateTypeFullName); + var getStopwatch = Stopwatch.StartNew(); + try + { + var streamVersion = await GetStreamVersionAsync(aggregateId, true, cancellationToken); + if (streamVersion == null) + return null; + + if (!ReturnAggregate(streamVersion.IsDeleted, aggregateId, operationContext)) + return null; + + var aggregate = new T { Details = { Id = aggregateId } }; + + await GetAndApplyEventsAsync(aggregate, streamVersion, version, cancellationToken); + + // Make sure we lock the aggregate to prevent saving/ modifications etc. + aggregate.Details.Locked = true; + + return FulfilRequirements(aggregate); + } + catch (Exception ex) + { + _eventStoreTelemetry.GetAggregateAtSpecificVersionFailed(aggregateId, _aggregateTypeFullName, version, ex); + throw; + } + finally + { + getStopwatch.Stop(); + _eventStoreTelemetry.GetAggregateAtSpecificVersionComplete( + aggregateId, + _aggregateTypeFullName, + version, + getStopwatch.ElapsedMilliseconds + ); + } + } +} diff --git a/src/src/Postgres/Events/PostgresEventStore.GetDeletedAsync.cs b/src/src/Postgres/Events/PostgresEventStore.GetDeletedAsync.cs new file mode 100644 index 00000000..17475bc8 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.GetDeletedAsync.cs @@ -0,0 +1,17 @@ +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + public async Task GetDeletedAsync(string aggregateId, CancellationToken cancellationToken = default) + { + var aggregate = await GetCoreAsync( + aggregateId, + new() { SnapshotCacheMode = SnapshotCachingOptions.None, DeleteMode = DeleteHandlingMode.ReturnsAggregate }, + cancellationToken + ); + + return aggregate == null ? null + : aggregate.Details.IsDeleted ? FulfilRequirements(aggregate) + : throw AggregateNotDeletedException(aggregateId); + } +} diff --git a/src/src/Postgres/Events/PostgresEventStore.GetEventRangeAsync.cs b/src/src/Postgres/Events/PostgresEventStore.GetEventRangeAsync.cs new file mode 100644 index 00000000..f9af07a7 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.GetEventRangeAsync.cs @@ -0,0 +1,105 @@ +using System.Runtime.CompilerServices; +using Purview.EventSourcing.Aggregates.Events; + +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + /// + /// Gets a range of s for a given aggregate, as specified by it's . + /// + /// The id of the aggregate. + /// The inclusive event number to start the range at. + /// Optional, the inclusive event number to finish the range at. + /// The stopping token. + /// If no is specified all available events greater than are returned. + public async IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + [EnumeratorCancellation] CancellationToken cancellationToken + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); + if (versionFrom < 1) + throw new ArgumentOutOfRangeException( + nameof(versionFrom), + versionFrom, + $"{nameof(versionFrom)} must be greater than 0." + ); + + if (versionTo < versionFrom) + throw new ArgumentOutOfRangeException( + nameof(versionTo), + versionTo.Value, + $"{nameof(versionTo)} ({versionTo}) must be greater than or equal to {nameof(versionFrom)} ({versionFrom})." + ); + + var aggregateVersion = versionFrom; + var effectiveVersionTo = versionTo ?? int.MaxValue; + var entities = _client.GetEventRangeAsync( + aggregateId, + _aggregateTypeShortName, + versionFrom, + effectiveVersionTo, + cancellationToken + ); + await foreach (var entity in entities) + { + var item = DeserializeEvent(entity, aggregateVersion); + if (item != null) + yield return (item, entity.EventType!); + + aggregateVersion++; + } + } + + /// + /// Only used when an unknown event is found. + IEvent? DeserializeEvent(PostgresEventStoreClient.RowData eventRow, int aggregateVersion) + { + static EventUnknown ReturnUnknownEvent(PostgresEventStoreClient.RowData eventRow, int aggregateVersion) + { + return new EventUnknown + { + Details = + { + When = eventRow.Timestamp, + AggregateVersion = aggregateVersion, + IdempotencyId = eventRow.IdempotencyId, + }, + Payload = eventRow.Payload, + }; + } + + try + { + var eventType = _eventNameMapper.GetTypeName(eventRow.EventType!); + if (eventType == null) + { + _eventStoreTelemetry.MissingEventType(_aggregateTypeFullName, eventRow.EventType!); + + return ReturnUnknownEvent(eventRow, aggregateVersion); + } + + var runtimeEventType = + Type.GetType(eventType, throwOnError: false) + ?? throw new ApplicationException($"Unable to load event type: {eventType}"); + var @event = DeserializeEvent(eventRow.Payload!, runtimeEventType); + + // Apply upcasting chain when a registry is available. + if (@event != null && _eventUpcasterRegistry?.CanUpcast(@event) == true) + @event = _eventUpcasterRegistry.Upcast(@event); + + return @event; + } +#pragma warning disable CA1031 + catch (Exception ex) +#pragma warning restore CA1031 + { + _eventStoreTelemetry.EventDeserializationFailed(eventRow.AggregateId, _aggregateTypeFullName, ex); + + return ReturnUnknownEvent(eventRow, aggregateVersion); + } + } +} diff --git a/src/src/Postgres/Events/PostgresEventStore.GetOrCreateAsync.cs b/src/src/Postgres/Events/PostgresEventStore.GetOrCreateAsync.cs new file mode 100644 index 00000000..ea9a8f76 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.GetOrCreateAsync.cs @@ -0,0 +1,20 @@ +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + public async Task GetOrCreateAsync( + string? aggregateId, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + if (!string.IsNullOrWhiteSpace(aggregateId)) + { + var exists = await ExistsAsync(aggregateId, cancellationToken); + if (exists) + return await GetAsync(aggregateId, operationContext, cancellationToken); + } + + return await CreateAsync(aggregateId, cancellationToken); + } +} diff --git a/src/src/Postgres/Events/PostgresEventStore.IsDeletedAsync.cs b/src/src/Postgres/Events/PostgresEventStore.IsDeletedAsync.cs new file mode 100644 index 00000000..e63311fe --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.IsDeletedAsync.cs @@ -0,0 +1,14 @@ +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + public async Task IsDeletedAsync(string aggregateId, CancellationToken cancellationToken = default) + { + ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); + + var streamVersion = await GetStreamVersionAsync(aggregateId, true, cancellationToken); + return streamVersion == null + ? throw new NullReferenceException($"The aggregate specified ({aggregateId}) does not exist.") + : streamVersion.IsDeleted; + } +} diff --git a/src/src/Postgres/Events/PostgresEventStore.RestoreAsync.cs b/src/src/Postgres/Events/PostgresEventStore.RestoreAsync.cs new file mode 100644 index 00000000..a5afa7fa --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.RestoreAsync.cs @@ -0,0 +1,41 @@ +using Purview.EventSourcing.Aggregates.Events; + +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + public async Task RestoreAsync( + T aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + if (aggregate == null) + throw NullAggregate(aggregate); + + if (!aggregate.Details.IsDeleted) + throw AggregateNotDeletedException(aggregate.Id()); + + operationContext ??= EventStoreOperationContext.DefaultContext(); + + Restored restoreAggregateEvent = new() + { + Details = { AggregateVersion = aggregate.Details.CurrentVersion + 1, When = DateTimeOffset.UtcNow }, + }; + aggregate.ApplyEvent(restoreAggregateEvent); + + if (aggregate.IsNew()) + return false; + + var result = await SaveCoreAsync( + aggregate, + operationContext, + null, + null, + cancellationToken, + restoreAggregateEvent + ); + await result.AfterCommitAsync(cancellationToken); + return result.Result.Saved; + } +} diff --git a/src/src/Postgres/Events/PostgresEventStore.SaveAsync.cs b/src/src/Postgres/Events/PostgresEventStore.SaveAsync.cs new file mode 100644 index 00000000..61999b0b --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.SaveAsync.cs @@ -0,0 +1,517 @@ +using System.Data.Common; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Globalization; +using System.Security.Claims; +using Npgsql; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; +using Purview.EventSourcing.Internal; +using Purview.EventSourcing.Postgres.Events.Exceptions; +using Purview.EventSourcing.Services; +using Purview.EventSourcing.Validation; + +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + [DebuggerStepThrough] + public async Task> SaveAsync( + [NotNull] T aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + var operation = await SaveCoreAsync(aggregate, operationContext, null, null, cancellationToken); + await operation.AfterCommitAsync(cancellationToken); + return operation.Result; + } + + string ITransactionalEventStore.TransactionBoundaryKey => + new NpgsqlConnectionStringBuilder(_eventStoreOptions.Value.ConnectionString).ConnectionString; + + DbConnection ITransactionalEventStore.CreateTransactionConnection() => + new NpgsqlConnection(_eventStoreOptions.Value.ConnectionString); + + Task ITransactionalEventStore.EnsureTransactionConfiguredAsync( + DbConnection connection, + CancellationToken cancellationToken + ) => _client.EnsureTableExistsAsync(GetNpgsqlConnection(connection), cancellationToken); + + Task> ITransactionalEventStore.SaveInTransactionAsync( + T aggregate, + EventStoreOperationContext? operationContext, + DbConnection connection, + DbTransaction transaction, + CancellationToken cancellationToken + ) => + SaveCoreAsync( + aggregate, + operationContext, + GetNpgsqlConnection(connection), + GetNpgsqlTransaction(transaction), + cancellationToken + ); + + async Task> SaveCoreAsync( + T aggregate, + EventStoreOperationContext? operationContext, + NpgsqlConnection? connection, + NpgsqlTransaction? transaction, + CancellationToken cancellationToken, + params IEvent[] additionalEvents + ) + { + operationContext ??= EventStoreOperationContext.DefaultContext(); + + FulfilRequirements(aggregate); + + var idempotencyId = operationContext.CorrelationId ?? Activity.Current?.Id ?? $"{Guid.NewGuid()}"; + var validationResult = await GuardAsync(aggregate, cancellationToken); + + static SaveResult ReturnSaveResult( + T aggregate, + bool success, + bool skipped, + ValidationResult? validationResult = null + ) => new(aggregate, validationResult ?? new ValidationResult(), success, skipped); + + if (!validationResult.IsValid) + { + return new TransactionalSaveOperation(ReturnSaveResult(aggregate, false, false, validationResult)); + } + + if (aggregate.Details.Locked) + { + return operationContext.LockMode is LockHandlingMode.ThrowsException + ? throw new AggregateLockedException(idempotencyId) + : new TransactionalSaveOperation(ReturnSaveResult(aggregate, false, false)); + } + + if (string.IsNullOrWhiteSpace(aggregate.Details.Id)) + throw new MissingAggregateIdException(idempotencyId); + + _eventStoreTelemetry.SaveCalled(aggregate.Id(), _aggregateTypeFullName, aggregate.AggregateType); + var activity = _eventStoreTelemetry.SaveAggregate(aggregate.Id(), _aggregateTypeFullName); + + if (!aggregate.HasUnsavedEvents() && (additionalEvents?.Length ?? 0) == 0) + { + _eventStoreTelemetry.SaveContainedNoChanges( + aggregate.Id(), + _aggregateTypeFullName, + aggregate.AggregateType + ); + activity?.Dispose(); + + return new TransactionalSaveOperation(ReturnSaveResult(aggregate, false, true)); + } + + var isNew = aggregate.IsNew(); + var changeEvents = aggregate.GetUnsavedEvents().Concat((additionalEvents ?? []).AsEnumerable()).ToArray(); + + if (changeEvents.Length > _eventStoreOptions.Value.MaxEventCountOnSave) + { + activity?.Dispose(); + throw new ArgumentOutOfRangeException( + $"The maximum amount of events to save was exceeded. Attempted: {changeEvents.Length}, Maximum: {_eventStoreOptions.Value.MaxEventCountOnSave}" + ); + } + + var idempotencyIdAsString = idempotencyId.ToUpperInvariant(); + var idempotencyMarkerId = CreateIdempotencyCheckId(aggregate.Id(), idempotencyIdAsString); + + if (operationContext.UseIdempotencyMarker) + { + try + { + var existing = connection is null + ? await _client.GetByIdAsync(idempotencyMarkerId, cancellationToken) + : await _client.GetByIdAsync(idempotencyMarkerId, connection, transaction, cancellationToken); + + if (existing != null) + { + _eventStoreTelemetry.EventsAlreadyApplied(aggregate.Id(), idempotencyId); + activity?.Dispose(); + return new TransactionalSaveOperation(ReturnSaveResult(aggregate, true, true)); + } + } +#pragma warning disable CA1031 + catch (Exception ex) +#pragma warning restore CA1031 + { + _eventStoreTelemetry.GetIdempotencyMarkerFailed(aggregate.Id(), idempotencyId, ex); + } + } + + if ( + operationContext.NotificationMode.HasFlag(NotificationModes.BeforeDelete) + && changeEvents.OfType().Any() + ) + await _aggregateChangeNotifier.BeforeDeleteAsync(aggregate, cancellationToken); + else if (operationContext.NotificationMode.HasFlag(NotificationModes.BeforeSave)) + await _aggregateChangeNotifier.BeforeSaveAsync(aggregate, isNew, cancellationToken); + + var streamEntity = await GetStreamVersionAsync( + aggregate.Id(), + !isNew, + connection, + transaction, + cancellationToken + ); + + if (streamEntity?.IsDeleted == true) + { + var throwIfDeleted = !changeEvents.OfType().Any(); + if (throwIfDeleted) + { + activity?.Dispose(); + throw new AggregateDeletedException(aggregate.Id(), idempotencyId); + } + } + + try + { + var previousAggregateVersion = aggregate.Details.SavedVersion; + var shouldSnapshot = ShouldSnapShot(aggregate, changeEvents); + var now = DateTimeOffset.UtcNow; + + var streamVersionId = streamEntity?.Id ?? CreateStreamVersionId(aggregate.Id()); + var streamVersionRow = new PostgresEventStoreClient.RowData + { + Id = streamVersionId, + EntityType = StreamVersionType, + AggregateId = aggregate.Id(), + AggregateType = aggregate.AggregateType, + Version = aggregate.Details.CurrentVersion, + IsDeleted = aggregate.Details.IsDeleted, + Timestamp = now, + }; + + var userId = ClaimsPrincipal.Current?.FindFirst(operationContext.ClaimIdentifier)?.Value; + if (operationContext.RequiresValidPrincipalIdentifier && string.IsNullOrWhiteSpace(userId)) + throw new NullReferenceException( + $"Missing ClaimsPrincipal identifier '{operationContext.ClaimIdentifier}'. Unable to save aggregate." + ); + + List insertRows = []; + for (var i = 0; i < changeEvents.Length; i++) + { + var changeEvent = changeEvents[i]; + + changeEvent.Details.IdempotencyId = idempotencyIdAsString; + changeEvent.Details.UserId = userId; + changeEvent.Details.CorrelationId ??= operationContext.CorrelationId; + + var serializedEvent = SerializeEvent(changeEvent); + insertRows.Add( + new PostgresEventStoreClient.RowData + { + Id = CreateEventId(aggregate.Id(), changeEvent.Details.AggregateVersion), + EntityType = EventType, + AggregateId = aggregate.Id(), + AggregateType = aggregate.AggregateType, + Version = changeEvent.Details.AggregateVersion, + Payload = serializedEvent, + EventType = _eventNameMapper.GetName(changeEvent), + IdempotencyId = idempotencyMarkerId, + Timestamp = now, + } + ); + } + + if (operationContext.UseIdempotencyMarker) + { + insertRows.Add( + new PostgresEventStoreClient.RowData + { + Id = idempotencyMarkerId, + EntityType = IdempotencyMarkerType, + AggregateId = aggregate.Id(), + AggregateType = aggregate.AggregateType, + Version = 0, + Timestamp = now, + } + ); + } + + await SubmitBatchOperationsAsync( + aggregate, + idempotencyId, + streamVersionRow, + insertRows, + connection, + transaction, + cancellationToken + ); + + if (shouldSnapshot) + await CreateSnapshotAsync(aggregate, connection, transaction, cancellationToken); + + var result = ReturnSaveResult(aggregate, true, false); + + return new TransactionalSaveOperation( + result, + async afterCommitCancellationToken => + { + try + { + FinalizeSuccessfulSave(aggregate, shouldSnapshot); + + if (changeEvents.OfType().Any()) + _eventStoreTelemetry.AggregateDeleted( + aggregate.Id(), + _aggregateTypeFullName, + aggregate.AggregateType + ); + else if (changeEvents.OfType().Any()) + _eventStoreTelemetry.AggregateRestored( + aggregate.Id(), + _aggregateTypeFullName, + aggregate.AggregateType + ); + + _eventStoreTelemetry.SavedAggregate( + aggregate.Id(), + _aggregateTypeFullName, + changeEvents.Length, + aggregate.AggregateType + ); + + _eventStoreTelemetry.AggregateSaved(aggregate.AggregateType); + _eventStoreTelemetry.SaveCompleted(activity, changeEvents.Length); + + await UpdateCacheAsync(aggregate, operationContext.CacheOptions, afterCommitCancellationToken); + + if ( + aggregate.Details.IsDeleted + && operationContext.NotificationMode.HasFlag(NotificationModes.AfterDelete) + ) + await _aggregateChangeNotifier.AfterDeleteAsync(aggregate, afterCommitCancellationToken); + else if (operationContext.NotificationMode.HasFlag(NotificationModes.AfterSave)) + await _aggregateChangeNotifier.AfterSaveAsync( + aggregate, + previousAggregateVersion, + isNew, + changeEvents, + afterCommitCancellationToken + ); + } + finally + { + activity?.Dispose(); + } + }, + _ => + { + activity?.Dispose(); + return Task.CompletedTask; + } + ); + } + catch (Exception ex) + { + activity?.Dispose(); + ClearCacheFireAndForget(aggregate); + + if (operationContext.NotificationMode.HasFlag(NotificationModes.OnFailure)) + { + var deleteRequested = changeEvents.OfType().Any(); + await _aggregateChangeNotifier.FailureAsync(aggregate, deleteRequested, ex); + } + + throw; + } + } + + async Task GuardAsync(T aggregate, CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(aggregate, nameof(aggregate)); + + return _validator == null + ? await DefaultAggregateValidator.Instance.ValidateAsync(aggregate, cancellationToken) + : await _validator.ValidateAsync(aggregate, cancellationToken); + } + + static bool ShouldSnapShot(T aggregate, IEvent[] events) + { + return aggregate.Details.IsDeleted || events.OfType().Any() || events.Length > 0; + } + + async Task SubmitBatchOperationsAsync( + T aggregate, + string idempotencyId, + PostgresEventStoreClient.RowData streamVersionRow, + List insertRows, + NpgsqlConnection? connection, + NpgsqlTransaction? transaction, + CancellationToken cancellationToken + ) + { + try + { + if (connection is null) + { + await _client.UpsertWithBatchAsync( + streamVersionRow.Id, + streamVersionRow.EntityType, + streamVersionRow.AggregateId, + streamVersionRow.AggregateType, + streamVersionRow.Version, + streamVersionRow.IsDeleted, + streamVersionRow.Payload, + streamVersionRow.EventType, + streamVersionRow.IdempotencyId, + streamVersionRow.Timestamp, + insertRows, + cancellationToken + ); + } + else + { + await _client.UpsertWithBatchAsync( + streamVersionRow.Id, + streamVersionRow.EntityType, + streamVersionRow.AggregateId, + streamVersionRow.AggregateType, + streamVersionRow.Version, + streamVersionRow.IsDeleted, + streamVersionRow.Payload, + streamVersionRow.EventType, + streamVersionRow.IdempotencyId, + streamVersionRow.Timestamp, + insertRows, + connection, + transaction!, + cancellationToken + ); + } + } + catch (PostgresException ex) + { + _eventStoreTelemetry.SaveFailedAtStorage(aggregate.Id(), _aggregateTypeFullName, ex); + + ClearCacheFireAndForget(aggregate); + + if (ex.SqlState is "23505") + { + throw new Exceptions.ConcurrencyException( + aggregate.Id(), + idempotencyId, + aggregate.Details.CurrentVersion, + aggregate.Details.SavedVersion + ); + } + + throw new Exceptions.CommitException( + aggregate.Id(), + idempotencyId, + aggregate.Details.CurrentVersion, + aggregate.Details.SavedVersion, + ex + ); + } + catch (Exception ex) + { + _eventStoreTelemetry.SaveFailed(aggregate.Id(), _aggregateTypeFullName, ex); + + ClearCacheFireAndForget(aggregate); + + throw; + } + } + + async Task CreateSnapshotAsync( + T aggregate, + NpgsqlConnection? connection, + NpgsqlTransaction? transaction, + CancellationToken cancellationToken + ) + { + var previousSnapshotVersion = aggregate.Details.SnapshotVersion; + + try + { + aggregate.Details.SnapshotVersion = aggregate.Details.CurrentVersion; + + var snapshot = SerializeSnapshot(aggregate); + var snapshotId = CreateSnapshotId(aggregate.Id()); + + if (connection is null) + { + await _client.UpsertAsync( + snapshotId, + SnapshotType, + aggregate.Id(), + _aggregateTypeShortName, + aggregate.Details.CurrentVersion, + aggregate.Details.IsDeleted, + snapshot, + null, + null, + DateTimeOffset.UtcNow, + cancellationToken + ); + } + else + { + await _client.UpsertAsync( + snapshotId, + SnapshotType, + aggregate.Id(), + _aggregateTypeShortName, + aggregate.Details.CurrentVersion, + aggregate.Details.IsDeleted, + snapshot, + null, + null, + DateTimeOffset.UtcNow, + connection, + transaction!, + cancellationToken + ); + } + } + finally + { + aggregate.Details.SnapshotVersion = previousSnapshotVersion; + } + } + + static void FinalizeSuccessfulSave(T aggregate, bool shouldSnapshot) + { + var currentVersion = aggregate.Details.CurrentVersion; + aggregate.ClearUnsavedEvents(); + aggregate.Details.CurrentVersion = currentVersion; + aggregate.Details.SavedVersion = currentVersion; + aggregate.Details.Etag = currentVersion.ToString(CultureInfo.InvariantCulture); + + if (shouldSnapshot) + aggregate.Details.SnapshotVersion = currentVersion; + } + + void ClearCacheFireAndForget(T aggregate) + { + Task.Run(async () => + { + try + { + var cacheKey = CreateCacheKey(aggregate.Id()); + await _distributedCache.RemoveAsync(cacheKey); + } +#pragma warning disable CA1031 + catch (Exception ex) +#pragma warning restore CA1031 + { + _eventStoreTelemetry.CacheRemovalFailure(aggregate.Id(), _aggregateTypeFullName, ex); + } + }); + } + + static NpgsqlConnection GetNpgsqlConnection(DbConnection connection) => + connection as NpgsqlConnection + ?? throw new InvalidOperationException("PostgreSQL transactions require a NpgsqlConnection."); + + static NpgsqlTransaction GetNpgsqlTransaction(DbTransaction transaction) => + transaction as NpgsqlTransaction + ?? throw new InvalidOperationException("PostgreSQL transactions require a NpgsqlTransaction."); +} diff --git a/src/src/Postgres/Events/PostgresEventStore.Serialization.cs b/src/src/Postgres/Events/PostgresEventStore.Serialization.cs new file mode 100644 index 00000000..63cacebe --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.Serialization.cs @@ -0,0 +1,18 @@ +using Purview.EventSourcing.Aggregates.Events; +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Postgres.Events; + +partial class PostgresEventStore +{ + static IEvent? DeserializeEvent(string eventContent, Type eventType) => + EventStoreSerializationHelpers.Deserialize(eventContent, eventType) as IEvent; + + static string SerializeSnapshot(T aggregate) => + EventStoreSerializationHelpers.Serialize(aggregate, aggregate.GetType()); + + static string SerializeEvent(IEvent @event) => EventStoreSerializationHelpers.Serialize(@event, @event.GetType()); + + static T DeserializeSnapshot(string aggregateContent) => + EventStoreSerializationHelpers.Deserialize(aggregateContent)!; +} diff --git a/src/src/Postgres/Events/PostgresEventStore.cs b/src/src/Postgres/Events/PostgresEventStore.cs new file mode 100644 index 00000000..c9d98dd8 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStore.cs @@ -0,0 +1,273 @@ +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using Microsoft.Extensions.Caching.Distributed; +using Microsoft.Extensions.Options; +using Npgsql; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events.Upcasting; +using Purview.EventSourcing.Internal; +using Purview.EventSourcing.Services; + +namespace Purview.EventSourcing.Postgres.Events; + +// SQL strings are built from validated identifiers at construction time, not from user input. +#pragma warning disable CA2100 + +public sealed partial class PostgresEventStore : IPostgresEventStore, ITransactionalEventStore + where T : class, IAggregate, new() +{ + const int StreamVersionType = 0; + const int EventType = 1; + const int IdempotencyMarkerType = 2; + const int SnapshotType = 3; + + readonly PostgresEventStoreClient _client; + + readonly IAggregateEventNameMapper _eventNameMapper; + readonly IOptions _eventStoreOptions; + readonly IAggregateValidator? _validator; + readonly IAggregateIdFactory? _aggregateIdFactory; + readonly IDistributedCache _distributedCache; + readonly IPostgresEventStoreTelemetry _eventStoreTelemetry; + readonly ChangeFeed.IAggregateChangeFeedNotifier _aggregateChangeNotifier; + readonly IAggregateRequirementsManager _aggregateRequirementsManager; + readonly IEventUpcasterRegistry? _eventUpcasterRegistry; + + readonly string _aggregateTypeFullName; + readonly string _aggregateTypeShortName; + + public PostgresEventStore( + IAggregateEventNameMapper eventNameMapper, + [NotNull] IOptions sqlServerOptions, + IDistributedCache distributedCache, + IPostgresEventStoreTelemetry eventStoreTelemetry, + ChangeFeed.IAggregateChangeFeedNotifier aggregateChangeNotifier, + IAggregateRequirementsManager aggregateRequirementsManager, + IAggregateValidator? validator = null, + IAggregateIdFactory? aggregateIdFactory = null, + IEventUpcasterRegistry? eventUpcasterRegistry = null + ) + { + _eventNameMapper = eventNameMapper; + _eventStoreOptions = sqlServerOptions; + _validator = validator; + _aggregateIdFactory = aggregateIdFactory; + _distributedCache = distributedCache; + _eventStoreTelemetry = eventStoreTelemetry; + _aggregateChangeNotifier = aggregateChangeNotifier; + _aggregateRequirementsManager = aggregateRequirementsManager; + _eventUpcasterRegistry = eventUpcasterRegistry; + + _aggregateTypeShortName = typeof(T).Name; + _aggregateTypeFullName = typeof(T).FullName ?? _aggregateTypeShortName; + + var aggregateName = _eventNameMapper.InitializeAggregate(); + if (!aggregateName.Contains('.', StringComparison.InvariantCulture)) + _aggregateTypeShortName = aggregateName; + + var clientOptions = ResolveClientOptions(sqlServerOptions.Value, _aggregateTypeShortName); + _client = new PostgresEventStoreClient(clientOptions); + } + + public T FulfilRequirements(T aggregate) + { + _aggregateRequirementsManager.Fulfil(aggregate); + + return aggregate; + } + + async Task UpdateCacheAsync( + T aggregate, + DistributedCacheEntryOptions? cacheEntryOptions, + CancellationToken cancellationToken = default + ) + { + cacheEntryOptions = GetCacheEntryOptions(cacheEntryOptions); + + try + { + var cacheKey = CreateCacheKey(aggregate.Id()); + if ( + aggregate.Details.Locked + || (aggregate.Details.IsDeleted && _eventStoreOptions.Value.RemoveDeletedFromCache) + ) + await _distributedCache.RemoveAsync(cacheKey, cancellationToken); + else + { + if (!_eventStoreOptions.Value.CacheMode.HasFlag(SnapshotCachingOptions.StoreInCache)) + return; + + var data = SerializeSnapshot(aggregate); + await _distributedCache.SetStringAsync(cacheKey, data, cacheEntryOptions, cancellationToken); + } + } +#pragma warning disable CA1031 + catch (Exception ex) +#pragma warning restore CA1031 + { + _eventStoreTelemetry.CacheUpdateFailure(aggregate.Id(), _aggregateTypeFullName, ex); + } + } + + DistributedCacheEntryOptions GetCacheEntryOptions(DistributedCacheEntryOptions? cacheEntryOptions) => + cacheEntryOptions ?? new() { SlidingExpiration = _eventStoreOptions.Value.DefaultCacheSlidingDuration }; + + public async IAsyncEnumerable GetAggregateIdsAsync( + bool includeDeleted, + [EnumeratorCancellation] CancellationToken cancellationToken = default + ) + { + await foreach ( + var aggregateId in _client.GetAggregateIdsByTypeAsync( + _aggregateTypeShortName, + includeDeleted, + cancellationToken + ) + ) + yield return aggregateId; + } + + Task GetStreamVersionAsync( + string aggregateId, + bool expectedToExist, + CancellationToken cancellationToken + ) => GetStreamVersionAsync(aggregateId, expectedToExist, null, null, cancellationToken); + + async Task GetStreamVersionAsync( + string aggregateId, + bool expectedToExist, + NpgsqlConnection? connection, + NpgsqlTransaction? transaction, + CancellationToken cancellationToken + ) + { + _eventStoreTelemetry.GetStreamVersionStart(aggregateId); + + var elapsedMilliseconds = 0L; + StreamVersionData? result = null; + try + { + var sw = System.Diagnostics.Stopwatch.StartNew(); + + var row = connection is null + ? await _client.GetByIdAsync(CreateStreamVersionId(aggregateId), cancellationToken) + : await _client.GetByIdAsync( + CreateStreamVersionId(aggregateId), + connection, + transaction, + cancellationToken + ); + sw.Stop(); + + elapsedMilliseconds = sw.ElapsedMilliseconds; + + if (row == null || row.EntityType != StreamVersionType) + { + if (expectedToExist) + _eventStoreTelemetry.StreamVersionExpectedToExistButNotFound( + aggregateId, + _aggregateTypeShortName, + _aggregateTypeFullName + ); + else + _eventStoreTelemetry.StreamVersionNotFound(aggregateId); + } + else + { + result = new StreamVersionData + { + Id = row.Id, + AggregateId = row.AggregateId, + AggregateType = row.AggregateType, + Version = row.Version, + IsDeleted = row.IsDeleted, + }; + _eventStoreTelemetry.StreamVersionFound( + aggregateId, + result.Version, + result.AggregateType, + result.IsDeleted + ); + } + } +#pragma warning disable CA1031 + catch (Exception ex) +#pragma warning restore CA1031 + { + _eventStoreTelemetry.GetStreamVersionFailed(aggregateId, ex); + } + + _eventStoreTelemetry.GetStreamVersionComplete(aggregateId, elapsedMilliseconds); + + return result; + } + + static bool ReturnAggregate(bool isDeleted, string aggregateId, EventStoreOperationContext context) + { + if (isDeleted) + { + switch (context.DeleteMode) + { + case DeleteHandlingMode.ThrowsException: + throw AggregateIsDeletedException(aggregateId); + case DeleteHandlingMode.ReturnsNull: + return false; + } + } + + return true; + } + + string CreateStreamVersionId(string aggregateId) => $"s_{_aggregateTypeShortName}_{aggregateId}"; + + string CreateEventId(string aggregateId, int version) => + $"e_{_aggregateTypeShortName}_{aggregateId}_{$"{version}".PadLeft(_eventStoreOptions.Value.EventSuffixLength, '0')}"; + + string CreateIdempotencyCheckId(string aggregateId, string idempotencyId) => + $"i_{_aggregateTypeShortName}_{aggregateId}_{idempotencyId}"; + + string CreateSnapshotId(string aggregateId) => $"snap_{_aggregateTypeShortName}_{aggregateId}"; + + public string CreateCacheKey(string aggregateId) => $"{_aggregateTypeShortName}:{aggregateId}".ToUpperInvariant(); + + async Task EnsureConfiguredAsync(CancellationToken cancellationToken) + { + if (_eventStoreOptions.Value.AutoCreateTable) + await _client.EnsureTableExistsAsync(cancellationToken); + } + + /// + /// Merges global options with any per-aggregate-type table override. + /// Returns an options instance with the effective schema and table name. + /// + static PostgresEventStoreOptions ResolveClientOptions(PostgresEventStoreOptions options, string aggregateTypeName) + { + return !options.AggregateTableOverrides.TryGetValue(aggregateTypeName, out var ovr) || ovr is null ? options + : ovr.SchemaName is null && ovr.TableName is null ? options + : new PostgresEventStoreOptions + { + ConnectionString = options.ConnectionString, + SchemaName = ovr.SchemaName ?? options.SchemaName, + TableName = ovr.TableName ?? options.TableName, + AutoCreateTable = options.AutoCreateTable, + UseDataCompression = options.UseDataCompression, + TimeoutInSeconds = options.TimeoutInSeconds, + MaxEventCountOnSave = options.MaxEventCountOnSave, + RemoveDeletedFromCache = options.RemoveDeletedFromCache, + EventSuffixLength = options.EventSuffixLength, + CacheMode = options.CacheMode, + DefaultCacheSlidingDuration = options.DefaultCacheSlidingDuration, + RequiresValidPrincipalIdentifier = options.RequiresValidPrincipalIdentifier, + JsonIndexOptions = options.JsonIndexOptions, + }; + } + + internal sealed class StreamVersionData + { + public string Id { get; set; } = default!; + public string AggregateId { get; set; } = default!; + public string AggregateType { get; set; } = default!; + public int Version { get; set; } + public bool IsDeleted { get; set; } + } +} diff --git a/src/src/Postgres/Events/PostgresEventStoreClient.cs b/src/src/Postgres/Events/PostgresEventStoreClient.cs new file mode 100644 index 00000000..60dd5673 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStoreClient.cs @@ -0,0 +1,668 @@ +using System.Collections.Concurrent; +using System.Text.RegularExpressions; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Storage; +using Npgsql; +using Purview.EventSourcing.Postgres.Events.EntityFramework; + +namespace Purview.EventSourcing.Postgres.Events; + +sealed partial class PostgresEventStoreClient +{ + static readonly ConcurrentDictionary EnsureTableLocks = new(StringComparer.Ordinal); + static readonly ConcurrentDictionary EnsuredTables = new(StringComparer.Ordinal); + static readonly HashSet SupportedEventIncludeColumns = + [ + "Id", + "EntityType", + "AggregateId", + "AggregateType", + "Version", + "IsDeleted", + "Payload", + "EventType", + "IdempotencyId", + "Timestamp", + ]; + + readonly PostgresEventStoreOptions _options; + readonly string _tableEnsureKey; + + public PostgresEventStoreClient(PostgresEventStoreOptions options) + { + _options = options ?? throw new ArgumentNullException(nameof(options)); + ValidateIdentifier(_options.SchemaName); + ValidateIdentifier(_options.TableName); + PostgresJsonIndexSchemaManager.ValidateOrThrow( + _options.JsonIndexOptions, + _options.SchemaName, + _options.TableName, + SupportedEventIncludeColumns, + nameof(PostgresEventStoreOptions.JsonIndexOptions) + ); + _tableEnsureKey = $"{_options.ConnectionString}|{_options.SchemaName}|{_options.TableName}"; + } + + public Task EnsureTableExistsAsync(CancellationToken cancellationToken = default) => + EnsureTableIfEnabledAsync(cancellationToken); + + public Task EnsureTableExistsAsync(NpgsqlConnection connection, CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(connection); + return EnsureTableIfEnabledAsync(connection, transaction: null, cancellationToken); + } + + public async Task InsertAsync( + string id, + int entityType, + string aggregateId, + string aggregateType, + int version, + bool isDeleted, + string? payload, + string? eventType, + string? idempotencyId, + DateTimeOffset timestamp, + CancellationToken cancellationToken = default + ) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + context.EventStoreEntities.Add( + CreateEntity( + id, + entityType, + aggregateId, + aggregateType, + version, + isDeleted, + payload, + eventType, + idempotencyId, + timestamp + ) + ); + await context.SaveChangesAsync(cancellationToken); + } + + public async Task InsertBatchAsync(List rows, CancellationToken cancellationToken = default) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + context.EventStoreEntities.AddRange(rows.Select(ToEntity)); + await context.SaveChangesAsync(cancellationToken); + } + + public async Task UpsertAsync( + string id, + int entityType, + string aggregateId, + string aggregateType, + int version, + bool isDeleted, + string? payload, + string? eventType, + string? idempotencyId, + DateTimeOffset timestamp, + CancellationToken cancellationToken = default + ) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + await UpsertCoreAsync( + context, + id, + entityType, + aggregateId, + aggregateType, + version, + isDeleted, + payload, + eventType, + idempotencyId, + timestamp, + cancellationToken + ); + } + + public async Task UpsertAsync( + string id, + int entityType, + string aggregateId, + string aggregateType, + int version, + bool isDeleted, + string? payload, + string? eventType, + string? idempotencyId, + DateTimeOffset timestamp, + NpgsqlConnection connection, + NpgsqlTransaction transaction, + CancellationToken cancellationToken = default + ) + { + ArgumentNullException.ThrowIfNull(connection); + ArgumentNullException.ThrowIfNull(transaction); + await EnsureTableIfEnabledAsync(connection, transaction, cancellationToken); + await using var context = CreateContext(connection, transaction); + await UpsertCoreAsync( + context, + id, + entityType, + aggregateId, + aggregateType, + version, + isDeleted, + payload, + eventType, + idempotencyId, + timestamp, + cancellationToken + ); + } + + public async Task UpsertWithBatchAsync( + string id, + int entityType, + string aggregateId, + string aggregateType, + int version, + bool isDeleted, + string? payload, + string? eventType, + string? idempotencyId, + DateTimeOffset timestamp, + List additionalInserts, + CancellationToken cancellationToken = default + ) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + await using var transaction = await context.Database.BeginTransactionAsync(cancellationToken); + await UpsertCoreAsync( + context, + id, + entityType, + aggregateId, + aggregateType, + version, + isDeleted, + payload, + eventType, + idempotencyId, + timestamp, + cancellationToken + ); + + context.EventStoreEntities.AddRange(additionalInserts.Select(ToEntity)); + await context.SaveChangesAsync(cancellationToken); + await transaction.CommitAsync(cancellationToken); + } + + public async Task UpsertWithBatchAsync( + string id, + int entityType, + string aggregateId, + string aggregateType, + int version, + bool isDeleted, + string? payload, + string? eventType, + string? idempotencyId, + DateTimeOffset timestamp, + List additionalInserts, + NpgsqlConnection connection, + NpgsqlTransaction transaction, + CancellationToken cancellationToken = default + ) + { + ArgumentNullException.ThrowIfNull(connection); + ArgumentNullException.ThrowIfNull(transaction); + await EnsureTableIfEnabledAsync(connection, transaction, cancellationToken); + await using var context = CreateContext(connection, transaction); + await UpsertCoreAsync( + context, + id, + entityType, + aggregateId, + aggregateType, + version, + isDeleted, + payload, + eventType, + idempotencyId, + timestamp, + cancellationToken + ); + + context.EventStoreEntities.AddRange(additionalInserts.Select(ToEntity)); + await context.SaveChangesAsync(cancellationToken); + } + + public async Task DeleteByIdAsync(string id, CancellationToken cancellationToken = default) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + var entity = await context.EventStoreEntities.SingleOrDefaultAsync(x => x.Id == id, cancellationToken); + if (entity is null) + return false; + + context.EventStoreEntities.Remove(entity); + return await context.SaveChangesAsync(cancellationToken) > 0; + } + + public async Task DeleteByAggregateIdAsync( + string aggregateId, + string aggregateType, + CancellationToken cancellationToken = default + ) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + return await context + .EventStoreEntities.Where(x => x.AggregateId == aggregateId && x.AggregateType == aggregateType) + .ExecuteDeleteAsync(cancellationToken); + } + + public async Task GetByIdAsync(string id, CancellationToken cancellationToken = default) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + var entity = await context + .EventStoreEntities.AsNoTracking() + .SingleOrDefaultAsync(x => x.Id == id, cancellationToken); + return entity is null ? null : ToRow(entity); + } + + public async Task GetByIdAsync( + string id, + NpgsqlConnection connection, + NpgsqlTransaction? transaction, + CancellationToken cancellationToken = default + ) + { + ArgumentNullException.ThrowIfNull(connection); + await EnsureTableIfEnabledAsync(connection, transaction, cancellationToken); + await using var context = CreateContext(connection, transaction); + var entity = await context + .EventStoreEntities.AsNoTracking() + .SingleOrDefaultAsync(x => x.Id == id, cancellationToken); + return entity is null ? null : ToRow(entity); + } + + public async Task GetByAggregateIdAndEntityTypeAsync( + string aggregateId, + string aggregateType, + int entityType, + CancellationToken cancellationToken = default + ) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + var entity = await context + .EventStoreEntities.AsNoTracking() + .SingleOrDefaultAsync( + x => x.AggregateId == aggregateId && x.AggregateType == aggregateType && x.EntityType == entityType, + cancellationToken + ); + return entity is null ? null : ToRow(entity); + } + + public async Task GetByAggregateIdAndEntityTypeAsync( + string aggregateId, + string aggregateType, + int entityType, + NpgsqlConnection connection, + NpgsqlTransaction? transaction, + CancellationToken cancellationToken = default + ) + { + ArgumentNullException.ThrowIfNull(connection); + await EnsureTableIfEnabledAsync(connection, transaction, cancellationToken); + await using var context = CreateContext(connection, transaction); + var entity = await context + .EventStoreEntities.AsNoTracking() + .SingleOrDefaultAsync( + x => x.AggregateId == aggregateId && x.AggregateType == aggregateType && x.EntityType == entityType, + cancellationToken + ); + return entity is null ? null : ToRow(entity); + } + + public async IAsyncEnumerable GetEventRangeAsync( + string aggregateId, + string aggregateType, + int versionFrom, + int versionTo, + [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default + ) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + var events = context + .EventStoreEntities.AsNoTracking() + .Where(x => + x.AggregateId == aggregateId + && x.AggregateType == aggregateType + && x.EntityType == 1 + && x.Version >= versionFrom + && x.Version <= versionTo + ) + .OrderBy(x => x.Version) + .Select(x => new RowData + { + Id = x.Id, + EntityType = x.EntityType, + AggregateId = x.AggregateId, + AggregateType = x.AggregateType, + Version = x.Version, + IsDeleted = x.IsDeleted, + Payload = x.Payload, + EventType = x.EventType, + IdempotencyId = x.IdempotencyId, + Timestamp = x.Timestamp, + }) + .AsAsyncEnumerable(); + + await foreach (var entity in events.WithCancellation(cancellationToken)) + yield return entity; + } + + public async Task> GetIdempotencyMarkerIdsByAggregateIdAsync( + string aggregateId, + string aggregateType, + CancellationToken cancellationToken = default + ) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + return await context + .EventStoreEntities.AsNoTracking() + .Where(x => x.AggregateId == aggregateId && x.AggregateType == aggregateType && x.EntityType == 2) + .Select(x => x.Id) + .ToListAsync(cancellationToken); + } + + public async IAsyncEnumerable GetAggregateIdsByTypeAsync( + string aggregateType, + bool includeDeleted, + [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default + ) + { + await EnsureConfiguredAsync(cancellationToken); + await using var context = CreateContext(); + var aggregateIds = context + .EventStoreEntities.AsNoTracking() + .Where(x => x.AggregateType == aggregateType && x.EntityType == 0 && (includeDeleted || !x.IsDeleted)) + .Select(x => x.AggregateId) + .AsAsyncEnumerable(); + + await foreach (var aggregateId in aggregateIds.WithCancellation(cancellationToken)) + yield return aggregateId; + } + + async Task EnsureConfiguredAsync(CancellationToken cancellationToken) + { + if (_options.AutoCreateTable) + await EnsureTableExistsAsync(cancellationToken); + } + + async Task EnsureTableIfEnabledAsync(CancellationToken cancellationToken) + { + if (!_options.AutoCreateTable || IsTableEnsured()) + return; + + var tableLock = EnsureTableLocks.GetOrAdd(_tableEnsureKey, static _ => new SemaphoreSlim(1, 1)); + await tableLock.WaitAsync(cancellationToken); + try + { + if (IsTableEnsured()) + return; + + try + { + await using var context = CreateContext(); + await CreateStorageTablesWithEfAsync(context, cancellationToken); + await using var connection = new NpgsqlConnection(_options.ConnectionString); + await connection.OpenAsync(cancellationToken); + await PostgresJsonIndexSchemaManager.ApplyAsync( + connection, + transaction: null, + _options.SchemaName, + _options.TableName, + _options.JsonIndexOptions, + SupportedEventIncludeColumns, + cancellationToken + ); + } + catch (Exception ex) when (IsDuplicateTableCreateError(ex, _options.TableName)) + { + // Another writer won the table-creation race for this table. + } + + MarkTableEnsured(); + } + finally + { + tableLock.Release(); + } + } + + async Task EnsureTableIfEnabledAsync( + NpgsqlConnection connection, + NpgsqlTransaction? transaction, + CancellationToken cancellationToken + ) + { + if (!_options.AutoCreateTable || IsTableEnsured()) + return; + + var tableLock = EnsureTableLocks.GetOrAdd(_tableEnsureKey, static _ => new SemaphoreSlim(1, 1)); + await tableLock.WaitAsync(cancellationToken); + try + { + if (IsTableEnsured()) + return; + + try + { + await using var context = CreateContext(connection, transaction); + await CreateStorageTablesWithEfAsync(context, cancellationToken); + await PostgresJsonIndexSchemaManager.ApplyAsync( + connection, + transaction, + _options.SchemaName, + _options.TableName, + _options.JsonIndexOptions, + SupportedEventIncludeColumns, + cancellationToken + ); + } + catch (Exception ex) when (IsDuplicateTableCreateError(ex, _options.TableName)) + { + // Another writer won the table-creation race for this table. + } + + MarkTableEnsured(); + } + finally + { + tableLock.Release(); + } + } + + EventStoreDbContext CreateContext() + { + DbContextOptionsBuilder optionsBuilder = new(); + var commandTimeout = Math.Max(1, _options.TimeoutInSeconds ?? 60); + optionsBuilder.UseNpgsql(_options.ConnectionString, sql => sql.CommandTimeout(commandTimeout)); + return new(optionsBuilder.Options, _options.SchemaName, _options.TableName); + } + + EventStoreDbContext CreateContext(NpgsqlConnection connection, NpgsqlTransaction? transaction) + { + DbContextOptionsBuilder optionsBuilder = new(); + var commandTimeout = Math.Max(1, _options.TimeoutInSeconds ?? 60); + optionsBuilder.UseNpgsql(connection, sql => sql.CommandTimeout(commandTimeout)); + var context = new EventStoreDbContext(optionsBuilder.Options, _options.SchemaName, _options.TableName); + if (transaction is not null) + context.Database.UseTransaction(transaction); + return context; + } + + static async Task UpsertCoreAsync( + EventStoreDbContext context, + string id, + int entityType, + string aggregateId, + string aggregateType, + int version, + bool isDeleted, + string? payload, + string? eventType, + string? idempotencyId, + DateTimeOffset timestamp, + CancellationToken cancellationToken + ) + { + var entity = await context.EventStoreEntities.SingleOrDefaultAsync(x => x.Id == id, cancellationToken); + if (entity is null) + { + context.EventStoreEntities.Add( + CreateEntity( + id, + entityType, + aggregateId, + aggregateType, + version, + isDeleted, + payload, + eventType, + idempotencyId, + timestamp + ) + ); + } + else + { + entity.EntityType = entityType; + entity.AggregateId = aggregateId; + entity.AggregateType = aggregateType; + entity.Version = version; + entity.IsDeleted = isDeleted; + entity.Payload = payload; + entity.EventType = eventType; + entity.IdempotencyId = idempotencyId; + entity.Timestamp = timestamp; + } + + await context.SaveChangesAsync(cancellationToken); + } + + static EventStoreEntity CreateEntity( + string id, + int entityType, + string aggregateId, + string aggregateType, + int version, + bool isDeleted, + string? payload, + string? eventType, + string? idempotencyId, + DateTimeOffset timestamp + ) => + new() + { + Id = id, + EntityType = entityType, + AggregateId = aggregateId, + AggregateType = aggregateType, + Version = version, + IsDeleted = isDeleted, + Payload = payload, + EventType = eventType, + IdempotencyId = idempotencyId, + Timestamp = timestamp, + }; + + static EventStoreEntity ToEntity(RowData row) => + new() + { + Id = row.Id, + EntityType = row.EntityType, + AggregateId = row.AggregateId, + AggregateType = row.AggregateType, + Version = row.Version, + IsDeleted = row.IsDeleted, + Payload = row.Payload, + EventType = row.EventType, + IdempotencyId = row.IdempotencyId, + Timestamp = row.Timestamp, + }; + + static RowData ToRow(EventStoreEntity entity) => + new() + { + Id = entity.Id, + EntityType = entity.EntityType, + AggregateId = entity.AggregateId, + AggregateType = entity.AggregateType, + Version = entity.Version, + IsDeleted = entity.IsDeleted, + Payload = entity.Payload, + EventType = entity.EventType, + IdempotencyId = entity.IdempotencyId, + Timestamp = entity.Timestamp, + }; + + bool IsTableEnsured() => EnsuredTables.ContainsKey(_tableEnsureKey); + + void MarkTableEnsured() => EnsuredTables.TryAdd(_tableEnsureKey, 0); + + static async Task CreateStorageTablesWithEfAsync(DbContext context, CancellationToken cancellationToken) + { + var creator = context.GetService(); + if (!await creator.ExistsAsync(cancellationToken)) + await creator.CreateAsync(cancellationToken); + + await creator.CreateTablesAsync(cancellationToken); + } + + static bool IsDuplicateTableCreateError(Exception exception, string _) + { + for (var current = exception; current is not null; current = current.InnerException) + { + if (current.Message.Contains("already an object named", StringComparison.OrdinalIgnoreCase)) + return true; + } + + return false; + } + + static void ValidateIdentifier(string identifier) + { + if (string.IsNullOrWhiteSpace(identifier)) + throw new ArgumentException("Identifier cannot be null or empty.", nameof(identifier)); + + if (!IdentifierRegex().IsMatch(identifier)) + throw new ArgumentException($"Identifier '{identifier}' contains invalid characters.", nameof(identifier)); + } + + [GeneratedRegex(@"^[\w\-\.]+$")] + private static partial Regex IdentifierRegex(); + + internal sealed class RowData + { + public string Id { get; set; } = default!; + public int EntityType { get; set; } + public string AggregateId { get; set; } = default!; + public string AggregateType { get; set; } = default!; + public int Version { get; set; } + public bool IsDeleted { get; set; } + public string? Payload { get; set; } + public string? EventType { get; set; } + public string? IdempotencyId { get; set; } + public DateTimeOffset Timestamp { get; set; } + } +} diff --git a/src/src/Postgres/Events/PostgresEventStoreOptions.cs b/src/src/Postgres/Events/PostgresEventStoreOptions.cs new file mode 100644 index 00000000..d9959c5e --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStoreOptions.cs @@ -0,0 +1,148 @@ +using System.ComponentModel; +using System.ComponentModel.DataAnnotations; + +namespace Purview.EventSourcing.Postgres.Events; + +/// +/// Defines a schema and/or table name override for a specific aggregate type. +/// +/// +/// The key in should match +/// the aggregate's AggregateType value (i.e., the class name with any trailing +/// "Aggregate" suffix removed, e.g. "Order" for OrderAggregate). +/// +public sealed class PostgresAggregateTableOverride +{ + /// + /// Overrides the schema name for this aggregate type. + /// When null, the global is used. + /// + [RegularExpression(@"^[\w\-.]+$")] + public string? SchemaName { get; set; } + + /// + /// Overrides the table name for this aggregate type. + /// When null, the global is used. + /// + [RegularExpression(@"^[\w\-.]+$")] + public string? TableName { get; set; } +} + +public sealed class PostgresEventStoreOptions +{ + public const string PostgresEventStore = "EventStore:Postgres"; + + const bool DefaultRemoveDeletedFromCache = true; + const int DefaultEventSuffixLength = 30; + + [Required] + public string ConnectionString { get; set; } = default!; + + [Required(AllowEmptyStrings = false)] + [RegularExpression(@"^[\w\-.]+$")] + public string TableName { get; set; } = "EventStoreEvents"; + + [Required(AllowEmptyStrings = false)] + [RegularExpression(@"^[\w\-.]+$")] + public string SchemaName { get; set; } = "public"; + + /// + /// When true, the table will be created if it doesn't exist. + /// + public bool AutoCreateTable { get; set; } = true; + + /// + /// When true, PAGE data compression is applied to the table and indices during auto-creation. + /// This significantly reduces I/O for NVARCHAR(MAX) payload columns and improves read/write throughput. + /// Available on PostgreSQL Enterprise Edition and all Azure SQL tiers. + /// + /// Only applies when is true and the table is being created for the first time. + public bool UseDataCompression { get; set; } + + [Range(1, 120000)] + public int? TimeoutInSeconds { get; set; } = 60; + + /// + /// The maximum number of events to save in a single operation. + /// + [Range(1, 10_000)] + public int MaxEventCountOnSave { get; set; } = 1000; + + /// + /// Indicates if a deleted aggregate is removed from cache. Defaults to true. + /// + /// If true, when an aggregate is deleted, it is removed from the cache. + /// Or in the case of a get, it is not placed in cache for future calls. + /// + /// If false, a deleted aggregate can be placed into cache. + /// + [DefaultValue(DefaultRemoveDeletedFromCache)] + public bool RemoveDeletedFromCache { get; set; } = DefaultRemoveDeletedFromCache; + + /// + /// The length of the suffix when creating event records. + /// + /// Changing this where data already exists will result in incomplete aggregates. + [Required] + [Range(10, 100)] + [DefaultValue(DefaultEventSuffixLength)] + public int EventSuffixLength { get; set; } = DefaultEventSuffixLength; + + /// + /// Gets/ sets a value indicating how the + /// uses the during it's operations. Defaults to . + /// + [DefaultValue(SnapshotCachingOptions.GetAndStore)] + public SnapshotCachingOptions CacheMode { get; set; } = SnapshotCachingOptions.GetAndStore; + + public TimeSpan DefaultCacheSlidingDuration { get; set; } = TimeSpan.FromMinutes(60); + + /// + /// + /// Gets/ sets a value indicating if a valid identifier from a is required when + /// saving aggregates. + /// + /// + /// Sets the to this value + /// on the property. + /// + /// + /// If true and returns null or empty string, an exception is thrown. + [DefaultValue(true)] + public bool RequiresValidPrincipalIdentifier { get; set; } = true; + + /// + /// Per-aggregate-type schema and/or table name overrides. + /// + /// + /// + /// The key is the aggregate's AggregateType short name — typically the class name + /// with any trailing "Aggregate" suffix removed (e.g. "Order" for + /// OrderAggregate). + /// + /// + /// Keys are matched case-insensitively. Null override values fall back to the + /// global / . + /// + /// + /// + /// // appsettings.json + /// "EventStore:Postgres": { + /// "ConnectionString": "...", + /// "AggregateTableOverrides": { + /// "Order": { "SchemaName": "orders", "TableName": "EventStore" }, + /// "Inventory": { "SchemaName": "inventory" } + /// } + /// } + /// + /// + /// + public Dictionary AggregateTableOverrides { get; init; } = + [with(StringComparer.OrdinalIgnoreCase)]; + + /// + /// Configures runtime-managed PostgreSQL indexes over the event payload JSON column. + /// + [Required] + public PostgresJsonIndexOptions JsonIndexOptions { get; set; } = new(); +} diff --git a/src/src/Postgres/Events/PostgresEventStoreOptionsValidator.cs b/src/src/Postgres/Events/PostgresEventStoreOptionsValidator.cs new file mode 100644 index 00000000..db0c8e42 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStoreOptionsValidator.cs @@ -0,0 +1,28 @@ +using System.ComponentModel.DataAnnotations; +using Microsoft.Extensions.Options; + +namespace Purview.EventSourcing.Postgres.Events; + +sealed class PostgresEventStoreOptionsValidator : IValidateOptions +{ + public ValidateOptionsResult Validate(string? name, PostgresEventStoreOptions options) + { + ArgumentNullException.ThrowIfNull(options); + var validationContext = new ValidationContext(options); + var validationResults = new List(); + if (!Validator.TryValidateObject(options, validationContext, validationResults, validateAllProperties: true)) + return ValidateOptionsResult.Fail( + validationResults.Select(static x => x.ErrorMessage ?? "Options validation failed.") + ); + + try + { + _ = new PostgresEventStoreClient(options); + return ValidateOptionsResult.Success; + } + catch (ArgumentException ex) + { + return ValidateOptionsResult.Fail(ex.Message); + } + } +} diff --git a/src/src/Postgres/Events/PostgresEventStoreTransaction.cs b/src/src/Postgres/Events/PostgresEventStoreTransaction.cs new file mode 100644 index 00000000..cbedbc31 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStoreTransaction.cs @@ -0,0 +1,396 @@ +using System.Data.Common; +using System.Diagnostics; +using Microsoft.EntityFrameworkCore; +using Npgsql; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Internal; + +namespace Purview.EventSourcing.Postgres.Events; + +/// +/// A PostgreSQL transaction coordinator that supports event-store aggregate saves and +/// additional SQL/EF work inside the same SQL transaction. +/// +public interface IPostgresEventStoreTransaction : IEventStoreTransaction +{ + /// + /// Enlists additional SQL work to execute inside the transaction. + /// + void Enlist(Func operation); + + /// + /// Enlists an EF Core unit of work to execute inside the transaction. + /// + void Enlist( + Func dbContextFactory, + Func operation + ) + where TDbContext : DbContext; +} + +sealed class PostgresEventStoreTransaction(string? correlationId = null) : IPostgresEventStoreTransaction +{ + readonly List _enlisted = []; + readonly List> _sqlOperations = []; + readonly bool _useIdempotencyMarker = !string.IsNullOrWhiteSpace(correlationId ?? Activity.Current?.Id); + string? _transactionBoundaryKey; + + bool _committed; + bool _disposed; + + public string CorrelationId { get; } = correlationId ?? Activity.Current?.Id ?? Guid.NewGuid().ToString(); + + public void Enlist(T aggregate, IEventStore eventStore, EventStoreOperationContext? operationContext = null) + where T : class, IAggregate, new() + { + ObjectDisposedException.ThrowIf(_disposed, this); + + if (_committed) + throw new InvalidOperationException("Cannot enlist aggregates after the transaction has been committed."); + + ArgumentNullException.ThrowIfNull(aggregate); + ArgumentNullException.ThrowIfNull(eventStore); + + if ( + (eventStore as IEventStoreImplementationAccessor)?.GetEventStore() + is not ITransactionalEventStore transactionalEventStore + ) + { + throw new InvalidOperationException( + $"The enlisted event store '{eventStore.GetType().FullName}' does not support atomic PostgreSQL transactions." + ); + } + + EnsureTransactionBoundary(transactionalEventStore.TransactionBoundaryKey, eventStore.GetType().FullName); + _enlisted.Add( + new EnlistedAggregate(aggregate, transactionalEventStore, operationContext, _useIdempotencyMarker) + ); + } + + public void Enlist( + T aggregate, + IEventStoreCore eventStore, + EventStoreOperationContext? operationContext = null + ) + where T : class, IAggregate, new() + { + ObjectDisposedException.ThrowIf(_disposed, this); + + if (_committed) + throw new InvalidOperationException("Cannot enlist aggregates after the transaction has been committed."); + + ArgumentNullException.ThrowIfNull(aggregate); + ArgumentNullException.ThrowIfNull(eventStore); + + if (eventStore is not ITransactionalEventStore transactionalEventStore) + { + throw new InvalidOperationException( + $"The enlisted event store '{eventStore.GetType().FullName}' does not support atomic PostgreSQL transactions." + ); + } + + EnsureTransactionBoundary(transactionalEventStore.TransactionBoundaryKey, eventStore.GetType().FullName); + _enlisted.Add( + new EnlistedAggregate(aggregate, transactionalEventStore, operationContext, _useIdempotencyMarker) + ); + } + + public void Enlist(Func operation) + { + ObjectDisposedException.ThrowIf(_disposed, this); + + if (_committed) + throw new InvalidOperationException("Cannot enlist operations after the transaction has been committed."); + + ArgumentNullException.ThrowIfNull(operation); + _sqlOperations.Add(operation); + } + + public void Enlist( + Func dbContextFactory, + Func operation + ) + where TDbContext : DbContext + { + ArgumentNullException.ThrowIfNull(dbContextFactory); + ArgumentNullException.ThrowIfNull(operation); + + Enlist( + async (connection, transaction, cancellationToken) => + { + await using var dbContext = dbContextFactory(connection); + await dbContext.Database.UseTransactionAsync(transaction, cancellationToken); + await operation(dbContext, cancellationToken); + } + ); + } + + public async Task CommitAsync(CancellationToken cancellationToken = default) + { + ObjectDisposedException.ThrowIf(_disposed, this); + + if (_committed) + throw new InvalidOperationException("This transaction has already been committed."); + + _committed = true; + + if (_enlisted.Count == 0) + { + return _sqlOperations.Count == 0 + ? new TransactionResult([]) + : throw new InvalidOperationException( + "A PostgreSQL transaction requires at least one enlisted aggregate to establish the transactional connection boundary." + ); + } + + await using var connection = _enlisted[0].CreateTransactionConnection(); + await connection.OpenAsync(cancellationToken); + + foreach (var enlisted in _enlisted) + await enlisted.EnsureTransactionConfiguredAsync(connection, cancellationToken); + + await using var transaction = await connection.BeginTransactionAsync(cancellationToken); + + List processed = [with(_enlisted.Count)]; + IEnlistedAggregate? failedEnlisted = null; + Exception? failure = null; + + foreach (var enlisted in _enlisted) + { +#pragma warning disable CA1031 + try + { + var operation = await enlisted.SaveInTransactionAsync( + CorrelationId, + connection, + transaction, + cancellationToken + ); + + processed.Add(operation); + + if (!operation.Saved && !operation.Skipped) + { + failedEnlisted = enlisted; + break; + } + } + catch (Exception ex) + { + failedEnlisted = enlisted; + failure = ex; + break; + } +#pragma warning restore CA1031 + } + + if (failedEnlisted is null && failure is null) + { + var sqlConnection = GetNpgsqlConnection(connection); + var sqlTransaction = GetNpgsqlTransaction(transaction); + + foreach (var operation in _sqlOperations) + { +#pragma warning disable CA1031 + try + { + await operation(sqlConnection, sqlTransaction, cancellationToken); + } + catch (Exception ex) + { + failure = ex; + break; + } +#pragma warning restore CA1031 + } + } + + if (failedEnlisted is null && failure is null) + { + await transaction.CommitAsync(cancellationToken); + + List committedResults = [with(processed.Count)]; + foreach (var operation in processed) + { + Exception? postCommitError = null; +#pragma warning disable CA1031 + try + { + await operation.AfterCommitAsync(cancellationToken); + } + catch (Exception ex) + { + postCommitError = ex; + } +#pragma warning restore CA1031 + + committedResults.Add(new(operation.Aggregate, operation.Saved, operation.Skipped, postCommitError)); + } + + return new TransactionResult(committedResults); + } + + await transaction.RollbackAsync(cancellationToken); + + foreach (var operation in processed) + await operation.AfterRollbackAsync(cancellationToken); + + var rollbackResults = new List(processed.Count + 1); + var rollbackError = + failure + ?? new InvalidOperationException( + "The transaction was rolled back because an enlisted aggregate could not be saved." + ); + + foreach (var operation in processed) + { + var isFailedOperation = + failedEnlisted is not null + && failure is null + && ReferenceEquals(operation.Aggregate, failedEnlisted.Aggregate) + && !operation.Saved + && !operation.Skipped; + var wasRolledBack = operation.Saved; + + rollbackResults.Add( + new TransactionAggregateResult( + operation.Aggregate, + saved: false, + skipped: !isFailedOperation && !wasRolledBack && operation.Skipped, + error: isFailedOperation || operation.Skipped ? null : rollbackError + ) + ); + } + + if ( + failedEnlisted is not null + && failure is not null + && processed.All(operation => !ReferenceEquals(operation.Aggregate, failedEnlisted.Aggregate)) + ) + { + rollbackResults.Add( + new TransactionAggregateResult(failedEnlisted.Aggregate, saved: false, skipped: false, error: failure) + ); + } + + return new TransactionResult(rollbackResults); + } + + public ValueTask DisposeAsync() + { + _disposed = true; + _enlisted.Clear(); + _sqlOperations.Clear(); + + return ValueTask.CompletedTask; + } + + interface IEnlistedAggregate + { + IAggregate Aggregate { get; } + DbConnection CreateTransactionConnection(); + Task EnsureTransactionConfiguredAsync(DbConnection connection, CancellationToken cancellationToken); + Task SaveInTransactionAsync( + string correlationId, + DbConnection connection, + DbTransaction transaction, + CancellationToken cancellationToken + ); + } + + interface IProcessedSaveOperation + { + IAggregate Aggregate { get; } + bool Saved { get; } + bool Skipped { get; } + Task AfterCommitAsync(CancellationToken cancellationToken); + Task AfterRollbackAsync(CancellationToken cancellationToken); + } + + sealed class EnlistedAggregate( + T aggregate, + ITransactionalEventStore eventStore, + EventStoreOperationContext? operationContext, + bool useIdempotencyMarker + ) : IEnlistedAggregate + where T : class, IAggregate, new() + { + public IAggregate Aggregate => aggregate; + + public DbConnection CreateTransactionConnection() => eventStore.CreateTransactionConnection(); + + public Task EnsureTransactionConfiguredAsync(DbConnection connection, CancellationToken cancellationToken) => + eventStore.EnsureTransactionConfiguredAsync(connection, cancellationToken); + + public async Task SaveInTransactionAsync( + string correlationId, + DbConnection connection, + DbTransaction transaction, + CancellationToken cancellationToken + ) + { + var baseContext = operationContext ?? EventStoreOperationContext.DefaultContext(correlationId); + var context = baseContext with + { + CorrelationId = operationContext is null ? correlationId : baseContext.CorrelationId, + UseIdempotencyMarker = baseContext.UseIdempotencyMarker || useIdempotencyMarker, + }; + + var saveOperation = await eventStore.SaveInTransactionAsync( + aggregate, + context, + connection, + transaction, + cancellationToken + ); + + return new ProcessedSaveOperation(aggregate, saveOperation); + } + } + + sealed class ProcessedSaveOperation(T aggregate, TransactionalSaveOperation operation) + : IProcessedSaveOperation + where T : class, IAggregate, new() + { + public IAggregate Aggregate => aggregate; + public bool Saved => operation.Result.Saved; + public bool Skipped => operation.Result.Skipped; + + public Task AfterCommitAsync(CancellationToken cancellationToken) => + operation.AfterCommitAsync(cancellationToken); + + public Task AfterRollbackAsync(CancellationToken cancellationToken) => + operation.AfterRollbackAsync(cancellationToken); + } + + static NpgsqlConnection GetNpgsqlConnection(DbConnection connection) => + connection as NpgsqlConnection + ?? throw new InvalidOperationException("PostgreSQL transactions require a NpgsqlConnection."); + + static NpgsqlTransaction GetNpgsqlTransaction(DbTransaction transaction) => + transaction as NpgsqlTransaction + ?? throw new InvalidOperationException("PostgreSQL transactions require a NpgsqlTransaction."); + + void EnsureTransactionBoundary(string boundaryKey, string? eventStoreType) + { + if (string.IsNullOrWhiteSpace(boundaryKey)) + { + throw new InvalidOperationException( + $"The enlisted event store '{eventStoreType}' did not provide a SQL transaction boundary." + ); + } + + if (_transactionBoundaryKey is null) + { + _transactionBoundaryKey = boundaryKey; + return; + } + + if (!StringComparer.Ordinal.Equals(_transactionBoundaryKey, boundaryKey)) + { + throw new InvalidOperationException( + "All enlisted PostgreSQL event stores must share the same transaction boundary." + ); + } + } +} diff --git a/src/src/Postgres/Events/PostgresEventStoreTransactionFactory.cs b/src/src/Postgres/Events/PostgresEventStoreTransactionFactory.cs new file mode 100644 index 00000000..7443fe75 --- /dev/null +++ b/src/src/Postgres/Events/PostgresEventStoreTransactionFactory.cs @@ -0,0 +1,27 @@ +namespace Purview.EventSourcing.Postgres.Events; + +/// +/// Creates PostgreSQL transaction coordinators that support enlisting additional SQL work +/// alongside event-store aggregate saves. +/// +public interface IPostgresEventStoreTransactionFactory +{ + /// + /// Creates a new PostgreSQL transaction. + /// + /// + /// Optional correlation ID shared by all enlisted aggregate saves. + /// When , the ambient correlation ID provider is consulted before generating a new correlation ID. + /// + IPostgresEventStoreTransaction CreatePostgresTransaction(string? correlationId = null); +} + +public sealed class PostgresEventStoreTransactionFactory(IEventStoreCorrelationIdProvider correlationIdProvider) + : IEventStoreTransactionFactory, + IPostgresEventStoreTransactionFactory +{ + public IEventStoreTransaction Create(string? correlationId = null) => CreatePostgresTransaction(correlationId); + + public IPostgresEventStoreTransaction CreatePostgresTransaction(string? correlationId = null) => + new PostgresEventStoreTransaction(correlationId ?? correlationIdProvider.GetCorrelationId()); +} diff --git a/src/src/Postgres/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs b/src/src/Postgres/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..9926d08c --- /dev/null +++ b/src/src/Postgres/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs @@ -0,0 +1,136 @@ +using System.ComponentModel; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection.Extensions; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Internal; +using Purview.EventSourcing.Postgres.Events; +using Purview.EventSourcing.Postgres.Snapshot; +using Purview.EventSourcing.Postgres.Snapshots; + +namespace Microsoft.Extensions.DependencyInjection; + +[EditorBrowsable(EditorBrowsableState.Never)] +public static class ServiceCollectionExtensions +{ + static readonly string[] EventsConnectionStringNames = + [ + "eventstore-events-postgres", + "EventStore_Events_Postgres", + "Events_Postgres", + "eventstore-events-sql", + "EventStore_Events_Sql", + "Events_Sql", + ]; + + static readonly string[] SnapshotsConnectionStringNames = + [ + "eventstore-snapshots-postgres", + "EventStore_Snapshots_Postgres", + "Snapshots_Postgres", + "eventstore-snapshots-sql", + "EventStore_Snapshots_Sql", + "Snapshots_Sql", + ]; + + static readonly string[] DefaultConnectionStringNames = + [ + "eventstore-postgres", + "EventStore_Postgres", + "Postgres", + "eventstore-sql", + "EventStore_Sql", + "Sql", + ]; + + extension(IServiceCollection services) + { + public IServiceCollection AddPostgresEventStore(string? connectionStringName = null) + { + services.AddEventSourcing(); + services.AddNpgsqlDataSource(connectionStringName ?? EventsConnectionStringNames[0]); + services.TryAddEnumerable( + ServiceDescriptor.Singleton< + IValidateOptions, + PostgresEventStoreOptionsValidator + >() + ); + + services + .AddTransient(typeof(IEventStoreCore<>), typeof(PostgresEventStore<>)) + .AddTransient(typeof(INonQueryableEventStore<>), typeof(PostgresEventStore<>)) + .AddTransient(typeof(IPostgresEventStore<>), typeof(PostgresEventStore<>)) + .AddTransient(); + services.TryAddSingleton(); + + services.AddPostgresEventStoreTelemetry(); + + services + .AddOptions() + .Configure( + (options, configuration) => + { + configuration.GetSection(PostgresEventStoreOptions.PostgresEventStore).Bind(options); + if (string.IsNullOrWhiteSpace(options.ConnectionString)) + { + options.ConnectionString = configuration.GetRequiredConnectionString([ + connectionStringName, + .. EventsConnectionStringNames, + .. DefaultConnectionStringNames, + ]); + } + } + ) + .ValidateOnStart(); + + return services; + } + + public IServiceCollection AddPostgresSnapshotQueryableEventStore( + string? connectionStringName = null, + bool registerAsIEventStore = false + ) + { + services.AddEventSourcing(); + services.AddNpgsqlDataSource(connectionStringName ?? SnapshotsConnectionStringNames[0]); + services.TryAddEnumerable( + ServiceDescriptor.Singleton< + IValidateOptions, + PostgresSnapshotEventStoreOptionsValidator + >() + ); + + services + .AddTransient(typeof(IQueryableEventStoreCore<>), typeof(PostgresSnapshotEventStore<>)) + .AddTransient(typeof(IPostgresSnapshotEventStore<>), typeof(PostgresSnapshotEventStore<>)) + .AddPostgresSnapshotEventStoreTelemetry(); + + services.TryAddTransient(); + + if (registerAsIEventStore) + { + services.AddTransient(typeof(IEventStoreCore<>), typeof(PostgresSnapshotEventStore<>)); + services.TryAddTransient(); + } + + services + .AddOptions() + .Configure( + (options, configuration) => + { + configuration.GetSection(PostgresSnapshotEventStoreOptions.PostgresEventStore).Bind(options); + if (string.IsNullOrWhiteSpace(options.ConnectionString)) + { + options.ConnectionString = configuration.GetRequiredConnectionString([ + connectionStringName, + .. SnapshotsConnectionStringNames, + .. DefaultConnectionStringNames, + ]); + } + } + ) + .ValidateOnStart(); + + return services; + } + } +} diff --git a/src/src/Postgres/Postgres.csproj b/src/src/Postgres/Postgres.csproj new file mode 100644 index 00000000..bfbb58c4 --- /dev/null +++ b/src/src/Postgres/Postgres.csproj @@ -0,0 +1,31 @@ + + + true + Purview Event Store for PostgreSQL + PostgreSQL event stream and queryable snapshot storage provider for Purview EventSourcing. + $(PackageTags);purview;dotnet;event-sourcing;event-store;postgres;postgresql;events; + Purview.EventSourcing.Postgres + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + diff --git a/src/src/Postgres/PostgresJsonIndexOptions.cs b/src/src/Postgres/PostgresJsonIndexOptions.cs new file mode 100644 index 00000000..bd77285f --- /dev/null +++ b/src/src/Postgres/PostgresJsonIndexOptions.cs @@ -0,0 +1,24 @@ +using System.ComponentModel.DataAnnotations; +using System.Diagnostics.CodeAnalysis; + +namespace Purview.EventSourcing.Postgres; + +public sealed class PostgresJsonIndexOptions +{ + public bool Enabled { get; set; } = true; + + public bool UseJsonbPathOps { get; set; } + + public string? GinIndexName { get; set; } + + [SuppressMessage("Performance", "CA1819:Properties should not return arrays", Justification = "DTO")] + public PostgresJsonPathIndexDefinition[] PathIndexes { get; set; } = []; +} + +public sealed class PostgresJsonPathIndexDefinition +{ + [Required] + public string Path { get; set; } = default!; + + public string? IndexName { get; set; } +} diff --git a/src/src/Postgres/PostgresJsonIndexSchemaManager.cs b/src/src/Postgres/PostgresJsonIndexSchemaManager.cs new file mode 100644 index 00000000..d0a13f99 --- /dev/null +++ b/src/src/Postgres/PostgresJsonIndexSchemaManager.cs @@ -0,0 +1,133 @@ +using System.Security.Cryptography; +using System.Text; +using System.Text.RegularExpressions; +using Npgsql; + +namespace Purview.EventSourcing.Postgres; + +static partial class PostgresJsonIndexSchemaManager +{ + public static void ValidateOrThrow( + PostgresJsonIndexOptions? options, + string schemaName, + string tableName, + IReadOnlySet supportedIncludeColumns, + string optionsName + ) + { + _ = supportedIncludeColumns; + _ = optionsName; + _ = CreateIndexCommands(options, schemaName, tableName); + } + + public static async Task ApplyAsync( + NpgsqlConnection connection, + NpgsqlTransaction? transaction, + string schemaName, + string tableName, + PostgresJsonIndexOptions? options, + IReadOnlySet supportedIncludeColumns, + CancellationToken cancellationToken + ) + { + _ = supportedIncludeColumns; + ArgumentNullException.ThrowIfNull(connection); + + foreach (var sql in CreateIndexCommands(options, schemaName, tableName)) + { + try + { +#pragma warning disable CA2100 + await using var command = new NpgsqlCommand(sql, connection, transaction); +#pragma warning restore CA2100 + await command.ExecuteNonQueryAsync(cancellationToken); + } + catch (PostgresException ex) when (ex.SqlState is "42710" or "42P07") + { + // Cross-process duplicate create race; treat as success. + } + } + } + + static List CreateIndexCommands(PostgresJsonIndexOptions? options, string schemaName, string tableName) + { + ValidateIdentifier(schemaName, nameof(schemaName)); + ValidateIdentifier(tableName, nameof(tableName)); + + if (options is null || !options.Enabled) + return []; + + var quotedTable = $"{QuoteIdentifier(schemaName)}.{QuoteIdentifier(tableName)}"; + var commands = new List(); + + var ginName = string.IsNullOrWhiteSpace(options.GinIndexName) + ? $"IX_{tableName}_Payload_Gin" + : options.GinIndexName.Trim(); + ValidateIdentifier(ginName, nameof(options.GinIndexName)); + + var ginOperatorClass = options.UseJsonbPathOps ? " jsonb_path_ops" : string.Empty; + commands.Add( + $"CREATE INDEX {QuoteIdentifier(ginName)} ON {quotedTable} USING gin ({QuoteIdentifier("Payload")}{ginOperatorClass});" + ); + + foreach (var pathIndex in options.PathIndexes) + { + if (pathIndex is null || string.IsNullOrWhiteSpace(pathIndex.Path)) + throw new ArgumentException("Json path index path cannot be null or empty.", nameof(options)); + + var tokens = ParsePath(pathIndex.Path); + if (tokens.Length == 0) + throw new ArgumentException( + $"Json path '{pathIndex.Path}' did not produce any path tokens.", + nameof(options) + ); + + var expression = $"({QuoteIdentifier("Payload")} #>> '{CreatePgTextPath(tokens)}')"; + var indexName = string.IsNullOrWhiteSpace(pathIndex.IndexName) + ? $"IX_{tableName}_{CreateStableHash(pathIndex.Path)}" + : pathIndex.IndexName.Trim(); + ValidateIdentifier(indexName, nameof(pathIndex.IndexName)); + + commands.Add($"CREATE INDEX {QuoteIdentifier(indexName)} ON {quotedTable} ({expression});"); + } + + return commands; + } + + static string[] ParsePath(string path) + { + var normalized = path.Trim(); + if (normalized.StartsWith("$.", StringComparison.Ordinal)) + normalized = normalized[2..]; + else if (normalized.StartsWith('$')) + normalized = normalized[1..]; + + return normalized.Split('.', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries); + } + + static string CreatePgTextPath(IEnumerable tokens) => + "{" + string.Join(",", tokens.Select(EscapePgPathToken)) + "}"; + + static string EscapePgPathToken(string token) => + token.Replace("\\", "\\\\", StringComparison.Ordinal).Replace("\"", "\\\"", StringComparison.Ordinal); + + static string CreateStableHash(string value) + { + var hash = SHA256.HashData(Encoding.UTF8.GetBytes(value)); + return Convert.ToHexString(hash[..6]); + } + + static void ValidateIdentifier(string identifier, string parameterName) + { + if (string.IsNullOrWhiteSpace(identifier)) + throw new ArgumentException("Identifier cannot be null or empty.", parameterName); + + if (!IdentifierRegex().IsMatch(identifier)) + throw new ArgumentException($"Identifier '{identifier}' contains invalid characters.", parameterName); + } + + static string QuoteIdentifier(string identifier) => $"\"{identifier}\""; + + [GeneratedRegex(@"^[\w\-\.]+$")] + private static partial Regex IdentifierRegex(); +} diff --git a/src/src/Postgres/Properties/AssemblyInfo.cs b/src/src/Postgres/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..fb501f3d --- /dev/null +++ b/src/src/Postgres/Properties/AssemblyInfo.cs @@ -0,0 +1,8 @@ +using System.Runtime.CompilerServices; +using Purview.Telemetry; + +[assembly: InternalsVisibleTo("SharedTestingFramework")] +[assembly: InternalsVisibleTo("EventSourcing.UnitTests")] + +[assembly: ActivitySourceGeneration("Purview.EventSourcing.Postgres")] +[assembly: MeterGeneration("Purview.EventSourcing.Postgres")] diff --git a/src/src/Postgres/README.md b/src/src/Postgres/README.md new file mode 100644 index 00000000..7a305711 --- /dev/null +++ b/src/src/Postgres/README.md @@ -0,0 +1,96 @@ +# Purview.EventSourcing.Postgres + +`Purview.EventSourcing.Postgres` provides PostgreSQL event-stream persistence and an optional PostgreSQL queryable snapshot store for Purview EventSourcing. + +## Install + +```bash +dotnet add package Purview.EventSourcing.Postgres +``` + +## Register the providers + +```csharp +builder.Services.AddPostgresEventStore(); +builder.Services.AddPostgresSnapshotQueryableEventStore(); +``` + +```json +{ + "ConnectionStrings": { + "eventstore-postgres": "Host=localhost;Database=MyApp;Username=postgres;Password=postgres" + } +} +``` + +## What it provides + +- Event-stream persistence for aggregates loaded through `IEventStore` +- Optional query/list/count snapshot-backed reads through `IQueryableEventStore` +- Internal event-store snapshots to support replay optimization strategies in append-only streams +- SQL-specific transaction factory (`IPostgresEventStoreTransactionFactory`) for enlisting additional SQL/EF work in the same commit (all enlisted stores must share the same SQL transaction boundary) +- Separate PostgreSQL configuration binding for event and snapshot stores +- Entity Framework-backed schema creation and CRUD paths +- JSONB-backed event and snapshot payload storage +- Shared-table safety: when aggregate types share a table, event-stream reads and deletes are scoped by both aggregate id and aggregate type +- Tolerant replay for long-lived streams: integration-tested handling for unknown event types and schema-evolved/unappliable historical events + +## JSONB payloads and querying + +The snapshot payload is the fully serialized aggregate graph stored in a single **JSONB** column. EF queries run against that JSON payload, so aggregate properties remain transparent to callers. + +Use regular LINQ for strongly-typed queries: + +```csharp +await store.QueryAsync(a => a.ComplexTestType != null && a.ComplexTestType.Int32Property == 42); +``` + +Use explicit JSONB operator helpers when you want GIN-friendly containment/existence checks: + +```csharp +await store.WherePayloadContainsAsync("""{"ComplexTestType":{"StringProperty":"active"}}""", new() { MaxRecords = 50 }); +await store.WherePayloadHasKeyAsync("ComplexTestType", new() { MaxRecords = 50 }); +``` + +`WherePayloadContainsAsync` maps to PostgreSQL `@>` and `WherePayloadHasKeyAsync` maps to `?`. + +## Event store snapshots vs query snapshots + +- The event store remains append-only and is the source of truth. +- Internal snapshots inside the event store are used only to optimize replay based on snapshot strategy. +- Those internal snapshots are not a substitute for the query store and are not intended for ad-hoc querying. +- The queryable snapshot store is optional. +- If you do need a dedicated query/read store, it can be PostgreSQL via `AddPostgresSnapshotQueryableEventStore()`, or a different read technology in your application architecture. + +## Declaring JSON path indexes + +Configure GIN and expression indexes via options: + +```csharp +options.JsonIndexOptions = new PostgresJsonIndexOptions +{ + Enabled = true, + UseJsonbPathOps = true, + PathIndexes = + [ + new() { Path = "ComplexTestType.StringProperty", IndexName = "ix_snapshots_status" } + ] +}; +``` + +Supported members are writable primitives, `[Scalar]` value objects, complex objects composed of supported members, and `EventStoreList` / `EventStoreSet` collections of supported primitive or complex members. + +Important query distinction: + +- A `[Scalar]` value object with a primitive inner value is generally query-friendly. +- A `[Scalar]` value object with a complex inner value is persisted correctly, but deep predicates through `.Value` are not guaranteed to translate in SQL snapshot queries. +- If deep SQL predicates are required for a complex concept, expose the underlying complex type directly on the aggregate/query snapshot model (for example, a `ParserReportSummary` mirror property) and verify the exact nested predicate with integration tests. + +Unsupported shapes fail during model creation, including arrays and collection types other than `EventStoreList` / `EventStoreSet` (for example `List`, `IReadOnlyList`, `IEnumerable`, `HashSet`, `ImmutableArray`), except where a provider-specific JSON conversion path is explicitly supported and tested. Read-only and `[JsonIgnore]` members are excluded from the JSON payload. + +## Documentation + +- [Repository README](https://github.com/kjldev/purview-eventsourcing/blob/main/README.md) +- [Provider feature matrix](https://github.com/kjldev/purview-eventsourcing/blob/main/docs/wiki/Provider-Feature-Matrix.md) + - Includes behavior notes/caveats (`IsDeletedAsync` missing behavior, tolerant replay, principal requirements) + - Includes snapshot payload/query-translation guidance for scalar value objects vs directly mapped complex mirrors diff --git a/src/src/Postgres/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.cs b/src/src/Postgres/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.cs new file mode 100644 index 00000000..9e14ec8b --- /dev/null +++ b/src/src/Postgres/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.cs @@ -0,0 +1,54 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace Purview.EventSourcing.Postgres.Snapshots.EntityFramework.Migrations; + +/// +public partial class InitialCreate : Migration +{ + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.EnsureSchema(name: "public"); + + migrationBuilder.CreateTable( + name: "EventStoreSnapshots", + schema: "public", + columns: table => new + { + Id = table.Column(type: "character varying(450)", maxLength: 450, nullable: false), + AggregateType = table.Column(type: "character varying(450)", maxLength: 450, nullable: false), + Payload = table.Column(type: "jsonb", nullable: false), + }, + constraints: table => + { + table.PrimaryKey("PK_EventStoreSnapshots", x => x.Id); + } + ); + + migrationBuilder + .CreateIndex( + name: "IX_EventStoreSnapshots_AggregateType", + schema: "public", + table: "EventStoreSnapshots", + column: "AggregateType" + ) + .Annotation("Npgsql:IndexInclude", new[] { "Payload" }); + + migrationBuilder.Sql( + """ + CREATE INDEX "IX_EventStoreSnapshots_Payload_Gin" + ON "public"."EventStoreSnapshots" + USING gin ("Payload"); + """ + ); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.Sql("""DROP INDEX IF EXISTS "IX_EventStoreSnapshots_Payload_Gin";"""); + migrationBuilder.DropTable(name: "EventStoreSnapshots", schema: "public"); + } +} diff --git a/src/src/Postgres/Snapshots/EntityFramework/SnapshotStoreDbContext.cs b/src/src/Postgres/Snapshots/EntityFramework/SnapshotStoreDbContext.cs new file mode 100644 index 00000000..1867b1e7 --- /dev/null +++ b/src/src/Postgres/Snapshots/EntityFramework/SnapshotStoreDbContext.cs @@ -0,0 +1,54 @@ +using Microsoft.EntityFrameworkCore; + +namespace Purview.EventSourcing.Postgres.Snapshots.EntityFramework; + +/// +/// EF Core DbContext for the PostgreSQL snapshot store. +/// Provides model-first design with migrations for the snapshot table, +/// matching the same schema and indices as the ADO.NET auto-create path. +/// +/// +/// Creates a new with explicit schema and table names. +/// +public class SnapshotStoreDbContext( + DbContextOptions options, + string schemaName, + string tableName +) : DbContext(options) +{ + readonly string _schemaName = schemaName; + readonly string _tableName = tableName; + + /// + /// All snapshot store rows. + /// + public DbSet SnapshotEntities { get; set; } = default!; + + /// + /// Creates a new with the specified options. + /// Schema and table names default to "public" and "Snapshots". + /// + public SnapshotStoreDbContext(DbContextOptions options) + : this(options, "public", "EventStoreSnapshots") { } + + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + ArgumentNullException.ThrowIfNull(modelBuilder); + + modelBuilder.Entity(entity => + { + entity.ToTable(_tableName, _schemaName); + + entity.HasKey(e => e.Id); + entity.Property(e => e.Id).HasMaxLength(450).IsRequired(); + entity.Property(e => e.AggregateType).HasMaxLength(450).IsRequired(); + entity.Property(e => e.Payload).HasColumnType("jsonb").IsRequired(); + + // Covers: QueryByAggregateType (returns Payload via INCLUDE, avoids key lookup) + entity + .HasIndex(e => e.AggregateType) + .HasDatabaseName($"IX_{_tableName}_AggregateType") + .IncludeProperties(e => e.Payload); + }); + } +} diff --git a/src/src/Postgres/Snapshots/EntityFramework/SnapshotStoreDbContextDesignTimeFactory.cs b/src/src/Postgres/Snapshots/EntityFramework/SnapshotStoreDbContextDesignTimeFactory.cs new file mode 100644 index 00000000..c10bf946 --- /dev/null +++ b/src/src/Postgres/Snapshots/EntityFramework/SnapshotStoreDbContextDesignTimeFactory.cs @@ -0,0 +1,19 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Design; + +namespace Purview.EventSourcing.Postgres.Snapshots.EntityFramework; + +/// +/// Design-time factory for . +/// Used by EF Core tools to generate migrations. +/// +public sealed class SnapshotStoreDbContextDesignTimeFactory : IDesignTimeDbContextFactory +{ + public SnapshotStoreDbContext CreateDbContext(string[] args) + { + var optionsBuilder = new DbContextOptionsBuilder(); + optionsBuilder.UseNpgsql("Host=localhost;Database=snapshotstore_design;Username=postgres;Password=postgres"); + + return new SnapshotStoreDbContext(optionsBuilder.Options); + } +} diff --git a/src/src/Postgres/Snapshots/EntityFramework/SnapshotStoreEntity.cs b/src/src/Postgres/Snapshots/EntityFramework/SnapshotStoreEntity.cs new file mode 100644 index 00000000..1451f5da --- /dev/null +++ b/src/src/Postgres/Snapshots/EntityFramework/SnapshotStoreEntity.cs @@ -0,0 +1,23 @@ +namespace Purview.EventSourcing.Postgres.Snapshots.EntityFramework; + +/// +/// EF Core entity model representing a row in the PostgreSQL snapshot store table. +/// Used for model-first migrations — maps to the same schema as the ADO.NET client. +/// +public sealed class SnapshotStoreEntity +{ + /// + /// The aggregate identifier (primary key). + /// + public string Id { get; set; } = default!; + + /// + /// Short name of the aggregate type (e.g. "Order"). + /// + public string AggregateType { get; set; } = default!; + + /// + /// JSON-serialized aggregate snapshot. + /// + public string Payload { get; set; } = default!; +} diff --git a/src/src/Postgres/Snapshots/IPostgresSnapshotEventStore.cs b/src/src/Postgres/Snapshots/IPostgresSnapshotEventStore.cs new file mode 100644 index 00000000..fe7fab91 --- /dev/null +++ b/src/src/Postgres/Snapshots/IPostgresSnapshotEventStore.cs @@ -0,0 +1,27 @@ +using Purview.EventSourcing.Aggregates; + +namespace Purview.EventSourcing.Postgres.Snapshots; + +public interface IPostgresSnapshotEventStore : IQueryableEventStoreCore + where T : class, IAggregate, new() +{ + /// + /// This will force snapshot the aggregate regardless of it's save state in the internal event store. + /// + /// The aggregate to upsert. + /// A cancellation token. + /// A task. + Task SnapshotAsync(T aggregate, CancellationToken cancellationToken = default); + + Task> WherePayloadContainsAsync( + string jsonFragment, + ContinuationRequest request, + CancellationToken cancellationToken = default + ); + + Task> WherePayloadHasKeyAsync( + string key, + ContinuationRequest request, + CancellationToken cancellationToken = default + ); +} diff --git a/src/src/Postgres/Snapshots/IPostgresSnapshotEventStoreTelemetry.cs b/src/src/Postgres/Snapshots/IPostgresSnapshotEventStoreTelemetry.cs new file mode 100644 index 00000000..20440ffb --- /dev/null +++ b/src/src/Postgres/Snapshots/IPostgresSnapshotEventStoreTelemetry.cs @@ -0,0 +1,63 @@ +using System.Diagnostics; +using Purview.Telemetry; + +namespace Purview.EventSourcing.Postgres.Snapshots; + +[ActivitySource] +[Logger] +[Meter] +public interface IPostgresSnapshotEventStoreTelemetry +{ + // Activities (distributed tracing) + + [Activity] + Activity? SnapshotSave(string aggregateId, [Baggage] string aggregateType); + + [Activity] + Activity? SnapshotQuery([Baggage] string aggregateType); + + [Activity] + Activity? SnapshotDelete(string aggregateId, [Baggage] string aggregateType); + + [Debug] + [AutoCounter] + [Event] + void QueryCompleted( + Activity? activity, + [ExcludeTargets(Targets.Activities)] string aggregateType, + int resultCount, + [ExcludeTargets(Targets.Activities)] long elapsedMilliseconds + ); + + // Logging + + [Debug] + void SnapshotSaveStart(string aggregateId, string aggregateType); + + [Debug] + [AutoCounter] + void SnapshotSaveComplete(string aggregateId, string aggregateType); + + [Error] + void SnapshotSaveFailed(string aggregateId, string aggregateType, Exception exception); + + [Debug] + void SnapshotDeleteStart(string aggregateId, string aggregateType); + + [Debug] + [AutoCounter] + void SnapshotDeleteComplete(string aggregateId, string aggregateType); + + [Error] + void SnapshotDeleteFailed(string aggregateId, string aggregateType, Exception exception); + + [Debug] + void SnapshotQueryStart(string aggregateType, int maxRecords); + + [Debug] + [AutoCounter] + void SnapshotQueryComplete(string aggregateType, int resultCount, long elapsedMilliseconds); + + [Error] + void SnapshotQueryFailed(string aggregateType, Exception exception); +} diff --git a/src/src/Postgres/Snapshots/PostgresSnapshotEventStore.EventStore.cs b/src/src/Postgres/Snapshots/PostgresSnapshotEventStore.EventStore.cs new file mode 100644 index 00000000..1d6582c0 --- /dev/null +++ b/src/src/Postgres/Snapshots/PostgresSnapshotEventStore.EventStore.cs @@ -0,0 +1,220 @@ +using System.Data.Common; +using Npgsql; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; +using Purview.EventSourcing.Aggregates.Snapshotting; +using Purview.EventSourcing.Internal; + +namespace Purview.EventSourcing.Postgres.Snapshot; + +partial class PostgresSnapshotEventStore +{ + public Task CreateAsync(string? aggregateId = null, CancellationToken cancellationToken = default) => + _eventStore.CreateAsync(aggregateId, cancellationToken); + + public Task GetOrCreateAsync( + string? aggregateId, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) => _eventStore.GetOrCreateAsync(aggregateId, operationContext, cancellationToken); + + public Task GetAsync( + string aggregateId, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) => _eventStore.GetAsync(aggregateId, operationContext, cancellationToken); + + public Task GetAtAsync( + string aggregateId, + int version, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) => _eventStore.GetAtAsync(aggregateId, version, operationContext, cancellationToken); + + public async Task> SaveAsync( + T aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + ArgumentNullException.ThrowIfNull(aggregate, nameof(aggregate)); + var eventsApplied = aggregate.GetUnsavedEvents().Count(); + + var result = await _eventStore.SaveAsync(aggregate, operationContext, cancellationToken); + if ( + result + && !result.Skipped + && SnapshotStrategyResolver.ShouldSnapshot( + aggregate, + eventsApplied, + operationContext, + _snapshotStrategy, + _snapshotStrategySelector + ) + ) + await SnapshotAsync(aggregate, cancellationToken); + + return result; + } + + string ITransactionalEventStore.TransactionBoundaryKey => + _eventStore is ITransactionalEventStore transactionalEventStore + ? transactionalEventStore.TransactionBoundaryKey + : string.Empty; + + DbConnection ITransactionalEventStore.CreateTransactionConnection() + { + return _eventStore is ITransactionalEventStore transactionalEventStore + ? transactionalEventStore.CreateTransactionConnection() + : new NpgsqlConnection(_sqlServerEventStoreOptions.Value.ConnectionString); + } + + async Task ITransactionalEventStore.EnsureTransactionConfiguredAsync( + DbConnection connection, + CancellationToken cancellationToken + ) + { + if (_eventStore is not ITransactionalEventStore transactionalEventStore) + throw new InvalidOperationException("The inner event store does not support transactional saves."); + + await transactionalEventStore.EnsureTransactionConfiguredAsync(connection, cancellationToken); + await _sqlServerClient.EnsureTableExistsAsync(GetNpgsqlConnection(connection), cancellationToken); + } + + async Task> ITransactionalEventStore.SaveInTransactionAsync( + T aggregate, + EventStoreOperationContext? operationContext, + DbConnection connection, + DbTransaction transaction, + CancellationToken cancellationToken + ) + { + ArgumentNullException.ThrowIfNull(aggregate, nameof(aggregate)); + + if (_eventStore is not ITransactionalEventStore transactionalEventStore) + throw new InvalidOperationException("The inner event store does not support transactional saves."); + + var eventsApplied = aggregate.GetUnsavedEvents().Count(); + var innerOperation = await transactionalEventStore.SaveInTransactionAsync( + aggregate, + operationContext, + connection, + transaction, + cancellationToken + ); + + try + { + if ( + innerOperation.Result.Saved + && !innerOperation.Result.Skipped + && SnapshotStrategyResolver.ShouldSnapshot( + aggregate, + eventsApplied, + operationContext, + _snapshotStrategy, + _snapshotStrategySelector + ) + ) + { + var snapshotSaved = await _sqlServerClient.UpsertAsync( + aggregate, + aggregate.Details.Id, + GetAggregateTypeName(), + GetNpgsqlConnection(connection), + GetNpgsqlTransaction(transaction), + cancellationToken + ); + + if (!snapshotSaved) + throw new InvalidOperationException("Failed to persist the PostgreSQL query snapshot."); + } + + return new TransactionalSaveOperation( + innerOperation.Result, + innerOperation.AfterCommitAsync, + innerOperation.AfterRollbackAsync + ); + } + catch + { + await innerOperation.AfterRollbackAsync(cancellationToken); + throw; + } + } + + public Task IsDeletedAsync(string aggregateId, CancellationToken cancellationToken = default) => + _eventStore.IsDeletedAsync(aggregateId, cancellationToken); + + public Task GetDeletedAsync(string aggregateId, CancellationToken cancellationToken = default) => + _eventStore.GetDeletedAsync(aggregateId, cancellationToken); + + public async Task DeleteAsync( + T aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + ArgumentNullException.ThrowIfNull(aggregate, nameof(aggregate)); + + _telemetry.SnapshotDeleteStart(aggregate.Details.Id, _aggregateName); + using var activity = _telemetry.SnapshotDelete(aggregate.Details.Id, _aggregateName); + + try + { + var result = await _eventStore.DeleteAsync(aggregate, operationContext, cancellationToken); + if (result) + { + await _sqlServerClient.DeleteAsync(aggregate.Details.Id, cancellationToken); + _telemetry.SnapshotDeleteComplete(aggregate.Details.Id, _aggregateName); + } + + return result; + } + catch (Exception ex) + { + _telemetry.SnapshotDeleteFailed(aggregate.Details.Id, _aggregateName, ex); + throw; + } + } + + public async Task RestoreAsync( + T aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) + { + ArgumentNullException.ThrowIfNull(aggregate, nameof(aggregate)); + + var result = await _eventStore.RestoreAsync(aggregate, operationContext, cancellationToken); + if (result) + await SnapshotAsync(aggregate, cancellationToken); + + return result; + } + + public IAsyncEnumerable GetAggregateIdsAsync( + bool includeDeleted, + CancellationToken cancellationToken = default + ) => _eventStore.GetAggregateIdsAsync(includeDeleted, cancellationToken); + + public Task ExistsAsync(string aggregateId, CancellationToken cancellationToken = default) => + _eventStore.ExistsAsync(aggregateId, cancellationToken); + + public T FulfilRequirements(T aggregate) => _eventStore.FulfilRequirements(aggregate); + + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) => _eventStore.GetEventRangeAsync(aggregateId, versionFrom, versionTo, cancellationToken); + + static NpgsqlConnection GetNpgsqlConnection(DbConnection connection) => + connection as NpgsqlConnection + ?? throw new InvalidOperationException("PostgreSQL transactions require a NpgsqlConnection."); + + static NpgsqlTransaction GetNpgsqlTransaction(DbTransaction transaction) => + transaction as NpgsqlTransaction + ?? throw new InvalidOperationException("PostgreSQL transactions require a NpgsqlTransaction."); +} diff --git a/src/src/Postgres/Snapshots/PostgresSnapshotEventStore.Query.cs b/src/src/Postgres/Snapshots/PostgresSnapshotEventStore.Query.cs new file mode 100644 index 00000000..bb160e09 --- /dev/null +++ b/src/src/Postgres/Snapshots/PostgresSnapshotEventStore.Query.cs @@ -0,0 +1,227 @@ +using System.Linq.Expressions; + +namespace Purview.EventSourcing.Postgres.Snapshot; + +partial class PostgresSnapshotEventStore +{ + public async IAsyncEnumerable GetQueryEnumerableAsync( + Expression> whereClause, + Func, IQueryable>? orderByClause, + int maxRecordsPerIteration = ContinuationRequest.DefaultMaxRecords, + [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default + ) + { + var request = new ContinuationRequest { MaxRecords = maxRecordsPerIteration }; + ContinuationResponse? response; + do + { + response = await QueryAsync(whereClause, orderByClause, request, cancellationToken); + foreach (var result in response.Results) + yield return FulfilRequirements(result); + + request = response; + } while (response.HasMoreRecords); + } + + public async IAsyncEnumerable GetListEnumerableAsync( + Func, IQueryable>? orderByClause, + int maxRecordsPerIteration = ContinuationRequest.DefaultMaxRecords, + [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default + ) + { + var request = new ContinuationRequest { MaxRecords = maxRecordsPerIteration }; + ContinuationResponse? response; + do + { + response = await ListAsync(orderByClause, request, cancellationToken); + foreach (var result in response.Results) + yield return FulfilRequirements(result); + + request = response; + } while (response.HasMoreRecords); + } + + public async Task> QueryAsync( + Expression> whereClause, + Func, IQueryable>? orderByClause, + ContinuationRequest request, + CancellationToken cancellationToken = default + ) + { + ArgumentNullException.ThrowIfNull(whereClause, nameof(whereClause)); + ArgumentNullException.ThrowIfNull(request, nameof(request)); + return await ExecuteQueryAsync(whereClause, orderByClause, request, cancellationToken); + } + + public async Task> ListAsync( + Func, IQueryable>? orderByClause, + ContinuationRequest request, + CancellationToken cancellationToken = default + ) + { + ArgumentNullException.ThrowIfNull(request, nameof(request)); + + return await ExecuteQueryAsync(null, orderByClause, request, cancellationToken); + } + + public async Task SingleOrDefaultAsync( + Expression> whereClause, + CancellationToken cancellationToken = default + ) + { + // Leave as 2 as it'll throw when expected. + var query = await GetSpecificNumberAsync(whereClause, null, 2, cancellationToken: cancellationToken); + return query.SingleOrDefault(); + } + + public async Task FirstOrDefaultAsync( + Expression> whereClause, + Func, IQueryable>? orderByClause, + CancellationToken cancellationToken = default + ) + { + var query = await GetSpecificNumberAsync(whereClause, orderByClause, 1, cancellationToken: cancellationToken); + return query.FirstOrDefault(); + } + + public async Task CountAsync( + Expression>? whereClause, + CancellationToken cancellationToken = default + ) + { + return await _sqlServerClient.CountByAggregateTypeAsync( + GetAggregateTypeName(), + whereClause, + cancellationToken + ); + } + + async Task> GetSpecificNumberAsync( + Expression> whereClause, + Func, IQueryable>? orderByClause, + int maxCount, + CancellationToken cancellationToken = default + ) + { + var query = await QueryAsync( + whereClause, + orderByClause, + request: new ContinuationRequest { MaxRecords = maxCount }, + cancellationToken: cancellationToken + ); + + return query.Results.Select(FulfilRequirements); + } + + public async Task> WherePayloadContainsAsync( + string jsonFragment, + ContinuationRequest request, + CancellationToken cancellationToken = default + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(jsonFragment); + ArgumentNullException.ThrowIfNull(request); + + if (!int.TryParse(request.ContinuationToken, out var skipCount)) + skipCount = 0; + + var aggregateTypeName = GetAggregateTypeName(); + var results = await _sqlServerClient.QueryByAggregateTypeJsonContainsAsync( + aggregateTypeName, + jsonFragment, + skipCount, + request.MaxRecords, + cancellationToken + ); + var fulfilledResults = results.Select(FulfilRequirements).ToArray(); + + return new ContinuationResponse + { + Results = fulfilledResults, + RequestedCount = request.MaxRecords, + ContinuationToken = fulfilledResults.Length == 0 ? null : $"{skipCount + request.MaxRecords}", + TotalCount = null, + }; + } + + public async Task> WherePayloadHasKeyAsync( + string key, + ContinuationRequest request, + CancellationToken cancellationToken = default + ) + { + ArgumentException.ThrowIfNullOrWhiteSpace(key); + ArgumentNullException.ThrowIfNull(request); + + if (!int.TryParse(request.ContinuationToken, out var skipCount)) + skipCount = 0; + + var aggregateTypeName = GetAggregateTypeName(); + var results = await _sqlServerClient.QueryByAggregateTypeJsonExistsAsync( + aggregateTypeName, + key, + skipCount, + request.MaxRecords, + cancellationToken + ); + var fulfilledResults = results.Select(FulfilRequirements).ToArray(); + + return new ContinuationResponse + { + Results = fulfilledResults, + RequestedCount = request.MaxRecords, + ContinuationToken = fulfilledResults.Length == 0 ? null : $"{skipCount + request.MaxRecords}", + TotalCount = null, + }; + } + + async Task> ExecuteQueryAsync( + Expression>? whereClause, + Func, IQueryable>? orderByClause, + ContinuationRequest request, + CancellationToken cancellationToken + ) + { + var aggregateTypeName = GetAggregateTypeName(); + var sw = System.Diagnostics.Stopwatch.StartNew(); + _telemetry.SnapshotQueryStart(aggregateTypeName, request.MaxRecords); + using var activity = _telemetry.SnapshotQuery(aggregateTypeName); + + try + { + if (!int.TryParse(request.ContinuationToken, out var skipCount)) + skipCount = 0; + + long? totalCount = request.IncludeTotalCount + ? await _sqlServerClient.CountByAggregateTypeAsync(aggregateTypeName, whereClause, cancellationToken) + : null; + + var results = await _sqlServerClient.QueryByAggregateTypeAsync( + aggregateTypeName, + whereClause, + orderByClause, + skipCount, + request.MaxRecords, + cancellationToken + ); + + var fulfilledResults = results.Select(FulfilRequirements).ToArray(); + + sw.Stop(); + _telemetry.QueryCompleted(activity, aggregateTypeName, fulfilledResults.Length, sw.ElapsedMilliseconds); + + return new ContinuationResponse + { + Results = fulfilledResults, + RequestedCount = request.MaxRecords, + ContinuationToken = fulfilledResults.Length == 0 ? null : $"{skipCount + request.MaxRecords}", + TotalCount = totalCount, + }; + } + catch (Exception ex) + { + _telemetry.SnapshotQueryFailed(aggregateTypeName, ex); + throw; + } + } +} diff --git a/src/src/Postgres/Snapshots/PostgresSnapshotEventStore.cs b/src/src/Postgres/Snapshots/PostgresSnapshotEventStore.cs new file mode 100644 index 00000000..3c59057a --- /dev/null +++ b/src/src/Postgres/Snapshots/PostgresSnapshotEventStore.cs @@ -0,0 +1,108 @@ +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Snapshotting; +using Purview.EventSourcing.Internal; +using Purview.EventSourcing.Postgres.Client; +using Purview.EventSourcing.Postgres.Snapshots; + +namespace Purview.EventSourcing.Postgres.Snapshot; + +public sealed partial class PostgresSnapshotEventStore : IPostgresSnapshotEventStore, ITransactionalEventStore + where T : class, IAggregate, new() +{ + readonly IEventStoreCore _eventStore; + readonly IOptions _sqlServerEventStoreOptions; + readonly IPostgresSnapshotEventStoreTelemetry _telemetry; + readonly ISnapshotStrategy _snapshotStrategy; + readonly ISnapshotStrategySelector? _snapshotStrategySelector; + + readonly PostgresClient _sqlServerClient; + + readonly Type _aggregateType = typeof(T); + readonly string _aggregateName; + + static readonly System.Collections.Concurrent.ConcurrentDictionary AggregateTypeNames = new(); + + public PostgresSnapshotEventStore( + // Explicitly request a non-queryable event store. + INonQueryableEventStore eventStore, + IOptions sqlServerEventStoreOptions, + IPostgresSnapshotEventStoreTelemetry telemetry, + ISnapshotStrategy? snapshotStrategy = null, + ISnapshotStrategySelector? snapshotStrategySelector = null + ) + { + _eventStore = eventStore; + _sqlServerEventStoreOptions = sqlServerEventStoreOptions; + _telemetry = telemetry; + _snapshotStrategy = snapshotStrategy ?? new AlwaysSnapshotStrategy(); + _snapshotStrategySelector = snapshotStrategySelector; + + _aggregateName = TypeNameHelper.GetName(_aggregateType, "Aggregate"); + + var clientOptions = ResolveClientOptions(_sqlServerEventStoreOptions.Value, _aggregateName); + _sqlServerClient = new(clientOptions); + } + + /// + /// Merges global options with any per-aggregate-type table override. + /// + static PostgresClientOptions ResolveClientOptions(PostgresSnapshotEventStoreOptions options, string aggregateName) + { + var schema = options.SchemaName; + var table = options.TableName; + + if (options.AggregateTableOverrides.TryGetValue(aggregateName, out var ovr) && ovr is not null) + { + schema = ovr.SchemaName ?? schema; + table = ovr.TableName ?? table; + } + + return new(options.ConnectionString, options.UseDataCompression) + { + TableName = table, + SchemaName = schema, + AutoCreateTable = options.AutoCreateTable, + JsonIndexOptions = options.JsonIndexOptions, + }; + } + + /// + /// This will upsert the aggregate in the snapshot store. + /// Note if the aggregate has unsaved events, it will first save those + /// events to the event store before upserting the snapshot to ensure consistency. + /// + /// + /// + public async Task SnapshotAsync(T aggregate, CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(aggregate, nameof(aggregate)); + + if (aggregate.HasUnsavedEvents()) + await _eventStore.SaveAsync(aggregate, cancellationToken); + + _telemetry.SnapshotSaveStart(aggregate.Details.Id, _aggregateName); + using var activity = _telemetry.SnapshotSave(aggregate.Details.Id, _aggregateName); + + try + { + var result = await _sqlServerClient.UpsertAsync( + aggregate, + aggregate.Details.Id, + GetAggregateTypeName(), + cancellationToken + ); + if (result) + { + _telemetry.SnapshotSaveComplete(aggregate.Details.Id, _aggregateName); + } + } + catch (Exception ex) + { + _telemetry.SnapshotSaveFailed(aggregate.Details.Id, _aggregateName, ex); + throw; + } + } + + string GetAggregateTypeName() => AggregateTypeNames.GetOrAdd(_aggregateType, _ => new T().AggregateType); +} diff --git a/src/src/Postgres/Snapshots/PostgresSnapshotEventStoreOptions.cs b/src/src/Postgres/Snapshots/PostgresSnapshotEventStoreOptions.cs new file mode 100644 index 00000000..79de1f7b --- /dev/null +++ b/src/src/Postgres/Snapshots/PostgresSnapshotEventStoreOptions.cs @@ -0,0 +1,92 @@ +using System.ComponentModel.DataAnnotations; + +namespace Purview.EventSourcing.Postgres.Snapshots; + +/// +/// Defines a schema and/or table name override for a specific aggregate type in the snapshot store. +/// +/// +/// The key in should match +/// the aggregate's AggregateType value (i.e., the class name with any trailing +/// "Aggregate" suffix removed, e.g. "Order" for OrderAggregate). +/// +public sealed class PostgresSnapshotAggregateTableOverride +{ + /// + /// Overrides the schema name for this aggregate type. + /// When null, the global is used. + /// + [RegularExpression(@"^[\w\-.]+$")] + public string? SchemaName { get; set; } + + /// + /// Overrides the table name for this aggregate type. + /// When null, the global is used. + /// + [RegularExpression(@"^[\w\-.]+$")] + public string? TableName { get; set; } +} + +public sealed class PostgresSnapshotEventStoreOptions +{ + public const string PostgresEventStore = "EventStore:PostgresSnapshot"; + + [Required] + public string ConnectionString { get; set; } = default!; + + [Required(AllowEmptyStrings = false)] + [RegularExpression(@"^[\w\-.]+$")] + public string TableName { get; set; } = "EventStoreSnapshots"; + + [Required(AllowEmptyStrings = false)] + [RegularExpression(@"^[\w\-.]+$")] + public string SchemaName { get; set; } = "public"; + + /// + /// When true, the table will be created if it doesn't exist. + /// + public bool AutoCreateTable { get; set; } = true; + + /// + /// When true, PAGE data compression is applied to the table and indices during auto-creation. + /// This significantly reduces I/O for NVARCHAR(MAX) payload columns and improves read/write throughput. + /// Available on PostgreSQL Enterprise Edition and all Azure SQL tiers. + /// + /// Only applies when is true and the table is being created for the first time. + public bool UseDataCompression { get; set; } + + /// + /// Per-aggregate-type schema and/or table name overrides. + /// + /// + /// + /// The key is the aggregate's AggregateType short name — typically the class name + /// with any trailing "Aggregate" suffix removed (e.g. "Order" for + /// OrderAggregate). + /// + /// + /// Keys are matched case-insensitively. Null override values fall back to the + /// global / . + /// + /// + /// + /// // appsettings.json + /// "EventStore:PostgresSnapshot": { + /// "ConnectionString": "...", + /// "AggregateTableOverrides": { + /// "Order": { "SchemaName": "orders", "TableName": "Snapshots" }, + /// "Inventory": { "SchemaName": "inventory" } + /// } + /// } + /// + /// + /// + public Dictionary AggregateTableOverrides { get; init; } = + [with(StringComparer.OrdinalIgnoreCase)]; + + /// + /// Configures runtime-managed PostgreSQL indexes over the snapshot payload JSON column. + /// + [Required] + public PostgresJsonIndexOptions JsonIndexOptions { get; set; } = new(); +} diff --git a/src/src/Postgres/Snapshots/PostgresSnapshotEventStoreOptionsValidator.cs b/src/src/Postgres/Snapshots/PostgresSnapshotEventStoreOptionsValidator.cs new file mode 100644 index 00000000..dc8a4abf --- /dev/null +++ b/src/src/Postgres/Snapshots/PostgresSnapshotEventStoreOptionsValidator.cs @@ -0,0 +1,38 @@ +using System.ComponentModel.DataAnnotations; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.Postgres.Client; + +namespace Purview.EventSourcing.Postgres.Snapshots; + +sealed class PostgresSnapshotEventStoreOptionsValidator : IValidateOptions +{ + public ValidateOptionsResult Validate(string? name, PostgresSnapshotEventStoreOptions options) + { + ArgumentNullException.ThrowIfNull(options); + var validationContext = new ValidationContext(options); + var validationResults = new List(); + if (!Validator.TryValidateObject(options, validationContext, validationResults, validateAllProperties: true)) + return ValidateOptionsResult.Fail( + validationResults.Select(static x => x.ErrorMessage ?? "Options validation failed.") + ); + + try + { + _ = new PostgresClient( + new PostgresClientOptions(options.ConnectionString, options.UseDataCompression) + { + SchemaName = options.SchemaName, + TableName = options.TableName, + AutoCreateTable = options.AutoCreateTable, + JsonIndexOptions = options.JsonIndexOptions, + } + ); + + return ValidateOptionsResult.Success; + } + catch (ArgumentException ex) + { + return ValidateOptionsResult.Fail(ex.Message); + } + } +} diff --git a/src/src/Samples.AppHost/AppModel/HostKit.cs b/src/src/Samples.AppHost/AppModel/HostKit.cs new file mode 100644 index 00000000..03a3540b --- /dev/null +++ b/src/src/Samples.AppHost/AppModel/HostKit.cs @@ -0,0 +1,16 @@ +using Purview.Aspire.ResourceKit; + +namespace Purview.EventSourcing.Samples.AppHost.AppModel; + +[HostKit] +sealed partial class SampleAppHostKit +{ + partial class SampleAppHostKitOptions + { + public bool IsTestRun { get; set; } + + public bool IsLocal { get; set; } + + public bool UseDataVolumes { get; set; } + } +} diff --git a/src/src/Samples.AppHost/AppModel/Resources/AspireC4Kit.cs b/src/src/Samples.AppHost/AppModel/Resources/AspireC4Kit.cs new file mode 100644 index 00000000..89d87bf7 --- /dev/null +++ b/src/src/Samples.AppHost/AppModel/Resources/AspireC4Kit.cs @@ -0,0 +1,17 @@ +using Aspire.Hosting.AspireC4.ApplicationModel; +using Purview.Aspire.ResourceKit; + +namespace Purview.EventSourcing.Samples.AppHost.AppModel.Resources; + +[ResourceDefinition(Platform.AspireC4)] +sealed partial class AspireC4Kit +{ + protected override bool IsResourceEnabled(IDistributedApplicationBuilder builder) => + !HostKit.Options.IsTestRun && !builder.ExecutionContext.IsPublishMode; + + protected override IResourceBuilder BuildResource(IDistributedApplicationBuilder builder) + { + var aspireC4 = builder.AddAspireC4(); + return aspireC4; + } +} diff --git a/src/src/Samples.AppHost/AppModel/Resources/AzureStorageKit.cs b/src/src/Samples.AppHost/AppModel/Resources/AzureStorageKit.cs new file mode 100644 index 00000000..75342a0b --- /dev/null +++ b/src/src/Samples.AppHost/AppModel/Resources/AzureStorageKit.cs @@ -0,0 +1,40 @@ +using System.ComponentModel.DataAnnotations; +using Aspire.Hosting.Azure; +using Purview.Aspire.ResourceKit; + +namespace Purview.EventSourcing.Samples.AppHost.AppModel.Resources; + +[ResourceDefinition(Platform.AzureStorage)] +sealed partial class AzureStorageKit +{ + public IResourceBuilder Storage { get; private set; } = default!; + public IResourceBuilder TableStorage { get; private set; } = default!; + public IResourceBuilder SnapshotBlob { get; set; } = default!; + + protected override IResourceBuilder BuildResource(IDistributedApplicationBuilder builder) + { + Storage = builder.AddAzureStorage(Name); + var storage = Storage; + if (!builder.ExecutionContext.IsPublishMode) + { + storage.RunAsEmulator(e => + { + if (HostKit.Options.UseDataVolumes) + e.WithDataVolume(); + + e.WithImageTag(ContainerHelper.AzuriteImageTag); + }); + } + + TableStorage = storage.AddTables(Platform.AzureStorageTable); + SnapshotBlob = storage.AddBlobContainer(Platform.AzureStorageBlob, Options.BlobName); + + return storage; + } + + partial class AzureStorageKitOptions + { + [Required(AllowEmptyStrings = false)] + public string BlobName { get; set; } = "blob"; + } +} diff --git a/src/src/Samples.AppHost/AppModel/Resources/MongoDbKit.cs b/src/src/Samples.AppHost/AppModel/Resources/MongoDbKit.cs new file mode 100644 index 00000000..999d3c8a --- /dev/null +++ b/src/src/Samples.AppHost/AppModel/Resources/MongoDbKit.cs @@ -0,0 +1,33 @@ +using System.ComponentModel.DataAnnotations; +using Purview.Aspire.ResourceKit; + +namespace Purview.EventSourcing.Samples.AppHost.AppModel.Resources; + +[ResourceDefinition(Platform.MongoDb)] +sealed partial class MongoDbKit +{ + public IResourceBuilder Database { get; private set; } = default!; + public IResourceBuilder SharedQueryDatabase { get; private set; } = default!; + + protected override IResourceBuilder BuildResource(IDistributedApplicationBuilder builder) + { + var mongo = builder.AddMongoDB(Name); + + Database = mongo.AddDatabase(Options.DatabaseName); + SharedQueryDatabase = mongo.AddDatabase(Options.SharedQueryDatabaseName); + + if (HostKit.Options.UseDataVolumes) + mongo.WithDataVolume("eventsourcing-sample-mongo-data"); + + return mongo; + } + + partial class MongoDbKitOptions + { + [Required(AllowEmptyStrings = false)] + public string DatabaseName { get; set; } = Platform.MongoDatabase; + + [Required(AllowEmptyStrings = false)] + public string SharedQueryDatabaseName { get; set; } = Platform.MongoSharedQueryDatabase; + } +} diff --git a/src/src/Samples.AppHost/AppModel/Resources/PostgresKit.cs b/src/src/Samples.AppHost/AppModel/Resources/PostgresKit.cs new file mode 100644 index 00000000..0a87dd67 --- /dev/null +++ b/src/src/Samples.AppHost/AppModel/Resources/PostgresKit.cs @@ -0,0 +1,37 @@ +using System.ComponentModel.DataAnnotations; +using Purview.Aspire.ResourceKit; + +namespace Purview.EventSourcing.Samples.AppHost.AppModel.Resources; + +[ResourceDefinition(Platform.Postgres)] +sealed partial class PostgresKit +{ + public IResourceBuilder Database { get; private set; } = default!; + public IResourceBuilder SharedQueryDatabase { get; private set; } = default!; + + protected override IResourceBuilder BuildResource(IDistributedApplicationBuilder builder) + { + var postgresPassword = builder.AddParameter("postgres-password", "postgres", secret: true); + var postgres = builder.AddPostgres(Name, postgresPassword); + + Database = postgres.AddDatabase(Platform.PostgresDatabase, Options.DatabaseName); + SharedQueryDatabase = postgres.AddDatabase( + Platform.PostgresSharedQueryDatabase, + Options.SharedQueryDatabaseName + ); + + if (HostKit.Options.UseDataVolumes) + postgres.WithDataVolume("eventsourcing-sample-postgres-data"); + + return postgres; + } + + partial class PostgresKitOptions + { + [Required(AllowEmptyStrings = false)] + public string DatabaseName { get; set; } = "event_sourcing_sample"; + + [Required(AllowEmptyStrings = false)] + public string SharedQueryDatabaseName { get; set; } = "event_sourcing_sample_azure"; + } +} diff --git a/src/src/Samples.AppHost/AppModel/Resources/RedisKit.cs b/src/src/Samples.AppHost/AppModel/Resources/RedisKit.cs new file mode 100644 index 00000000..b3880a63 --- /dev/null +++ b/src/src/Samples.AppHost/AppModel/Resources/RedisKit.cs @@ -0,0 +1,16 @@ +using Purview.Aspire.ResourceKit; + +namespace Purview.EventSourcing.Samples.AppHost.AppModel.Resources; + +[ResourceDefinition(Platform.Redis)] +sealed partial class RedisKit +{ + protected override IResourceBuilder BuildResource(IDistributedApplicationBuilder builder) + { + var redis = builder.AddRedis(Name); + if (HostKit.Options.IsLocal) + redis.WithRedisInsight(c => c.WithParentRelationship(redis)); + + return redis; + } +} diff --git a/src/src/Samples.AppHost/AppModel/Resources/SqlServerKit.cs b/src/src/Samples.AppHost/AppModel/Resources/SqlServerKit.cs new file mode 100644 index 00000000..e3cf04a2 --- /dev/null +++ b/src/src/Samples.AppHost/AppModel/Resources/SqlServerKit.cs @@ -0,0 +1,36 @@ +using System.ComponentModel.DataAnnotations; +using Purview.Aspire.ResourceKit; + +namespace Purview.EventSourcing.Samples.AppHost.AppModel.Resources; + +[ResourceDefinition(Platform.SqlServer)] +sealed partial class SqlServerKit +{ + public IResourceBuilder Database { get; private set; } = default!; + public IResourceBuilder SharedQueryDatabase { get; private set; } = default!; + + protected override IResourceBuilder BuildResource(IDistributedApplicationBuilder builder) + { + var sqlPassword = builder.AddParameter("sql-password", "PaSsw0rd!!1!", secret: true); + var sql = builder.AddSqlServer(Name, sqlPassword).WithImageTag(ContainerHelper.SqlServerImageTag); + + Database = sql.AddDatabase(Platform.SqlDatabase, Options.DatabaseName); + SharedQueryDatabase = sql.AddDatabase(Platform.SqlSharedQueryDatabase, Options.SharedQueryDatabaseName); + + if (HostKit.Options.UseDataVolumes) + sql.WithDataVolume("eventsourcing-sample-sql-data"); + + return sql; + } + + partial class SqlServerKitOptions + { + [Required(AllowEmptyStrings = false)] + [RegularExpression(@"^[\w\-.]+$")] + public string DatabaseName { get; set; } = "EventSourcingSampleDb"; + + [Required(AllowEmptyStrings = false)] + [RegularExpression(@"^[\w\-.]+$")] + public string SharedQueryDatabaseName { get; set; } = "EventSourcingSampleAzureSqlDb"; + } +} diff --git a/src/src/Samples.AppHost/AppModel/Resources/WebProjectKit.cs b/src/src/Samples.AppHost/AppModel/Resources/WebProjectKit.cs new file mode 100644 index 00000000..c30cb08a --- /dev/null +++ b/src/src/Samples.AppHost/AppModel/Resources/WebProjectKit.cs @@ -0,0 +1,293 @@ +using System.ComponentModel.DataAnnotations; +using Microsoft.Extensions.Configuration; + +namespace Purview.EventSourcing.Samples.AppHost.AppModel.Resources; + +static class SampleWebProjectResources +{ + public static IReadOnlyList AddSampleWebProjects( + IDistributedApplicationBuilder builder, + SampleAppHostKit hostKit + ) + { + ArgumentNullException.ThrowIfNull(builder); + ArgumentNullException.ThrowIfNull(hostKit); + + var options = new SampleWebProjectOptions(); + builder.Configuration.GetSection(SampleWebProjectOptions.SectionName).Bind(options); + + if (options.Variants.Count == 0) + throw new InvalidOperationException("At least one sample web project variant must be configured."); + + ValidateConfiguration(options); + + var variants = new List(options.Variants.Count); + foreach (var configuration in options.Variants) + { + variants.Add(new(configuration, AddSampleWebProject(builder, hostKit, configuration, options))); + } + + AddVariantLinks(variants); + return variants; + } + + static void ValidateConfiguration(SampleWebProjectOptions options) + { + Validator.ValidateObject(options, new ValidationContext(options), validateAllProperties: true); + + for (var index = 0; index < options.Variants.Count; index++) + { + var variant = options.Variants[index]; + try + { + Validator.ValidateObject(variant, new ValidationContext(variant), validateAllProperties: true); + } + catch (ValidationException ex) + { + throw new InvalidOperationException( + $"Sample web project variant at index {index} is invalid: {ex.ValidationResult?.ErrorMessage ?? ex.Message}", + ex + ); + } + } + } + + static IResourceBuilder AddSampleWebProject( + IDistributedApplicationBuilder builder, + SampleAppHostKit hostKit, + SampleWebProjectConfiguration configuration, + SampleWebProjectOptions options + ) + { + var project = builder.AddProject(configuration.ResourceName).WithExternalHttpEndpoints(); + + ConfigureStoreReferences(project, hostKit, configuration); + + if (hostKit.Redis.IsEnabled) + project.WithReference(hostKit.Redis).WaitFor(hostKit.Redis); + + if (hostKit.AzureStorage.IsEnabled) + project.WithReference(hostKit.AzureStorage.SnapshotBlob).WaitFor(hostKit.AzureStorage.SnapshotBlob); + + project + .WithEnvironment($"{SampleStoreOptions.SectionName}__CurrentKey", configuration.Key) + .WithEnvironment($"{SampleStoreOptions.SectionName}__CurrentDisplayName", configuration.DisplayName) + .WithEnvironment($"{SampleStoreOptions.SectionName}__CurrentDescription", configuration.Description) + .WithEnvironment($"{SampleStoreOptions.SectionName}__EventStore", configuration.EventStore.ToString()) + .WithEnvironment($"{SampleStoreOptions.SectionName}__QueryStore", configuration.QueryStore.ToString()) + .WithEnvironment($"{SampleStoreOptions.SectionName}__AdminStore", configuration.AdminStore.ToString()) + .WithEnvironment( + $"{SampleStoreOptions.SectionName}__AdminApiAvailable", + configuration.AdminApiAvailable.ToString() + ) + .WithEnvironment( + $"{SampleStoreOptions.SectionName}__EventStoreConnectionName", + configuration.EventStoreConnectionName + ) + .WithEnvironment( + $"{SampleStoreOptions.SectionName}__QueryStoreConnectionName", + configuration.QueryStoreConnectionName + ) + .WithEnvironment($"{SampleStoreOptions.SectionName}__AdminSitePath", options.AdminSitePath) + .WithEnvironment($"{SampleStoreOptions.SectionName}__AdminApiPath", options.AdminApiPath) + .WithEnvironment($"{SampleStoreOptions.SectionName}__DataIsolationWarning", options.DataIsolationWarning); + + if (!string.IsNullOrWhiteSpace(configuration.EventStoreDatabaseName)) + { + project.WithEnvironment( + $"{SampleStoreOptions.SectionName}__EventStoreDatabaseName", + configuration.EventStoreDatabaseName! + ); + } + + if (!string.IsNullOrWhiteSpace(configuration.QueryStoreDatabaseName)) + { + project.WithEnvironment( + $"{SampleStoreOptions.SectionName}__QueryStoreDatabaseName", + configuration.QueryStoreDatabaseName! + ); + } + + if (!string.IsNullOrWhiteSpace(configuration.AdminDatabaseName)) + { + project.WithEnvironment( + $"{SampleStoreOptions.SectionName}__AdminDatabaseName", + configuration.AdminDatabaseName! + ); + } + + return project; + } + + static void ConfigureStoreReferences( + IResourceBuilder project, + SampleAppHostKit hostKit, + SampleWebProjectConfiguration configuration + ) + { + var mongoReferenced = false; + + switch (configuration.EventStore) + { + case SampleEventStoreKind.SqlServer: + project + .WithReference(ResolveSqlServerDatabase(hostKit, configuration.EventStoreConnectionName)) + .WaitFor(ResolveSqlServerDatabase(hostKit, configuration.EventStoreConnectionName)); + break; + case SampleEventStoreKind.Postgres: + project + .WithReference(ResolvePostgresDatabase(hostKit, configuration.EventStoreConnectionName)) + .WaitFor(ResolvePostgresDatabase(hostKit, configuration.EventStoreConnectionName)); + break; + case SampleEventStoreKind.MongoDb: + AddMongoReference(project, hostKit, configuration.EventStoreDatabaseName); + mongoReferenced = true; + break; + case SampleEventStoreKind.AzureStorage: + project.WithReference(hostKit.AzureStorage.TableStorage).WaitFor(hostKit.AzureStorage.TableStorage); + break; + } + + switch (configuration.QueryStore) + { + case SampleQueryStoreKind.SqlServer: + project + .WithReference(ResolveSqlServerDatabase(hostKit, configuration.QueryStoreConnectionName)) + .WaitFor(ResolveSqlServerDatabase(hostKit, configuration.QueryStoreConnectionName)); + break; + case SampleQueryStoreKind.Postgres: + project + .WithReference(ResolvePostgresDatabase(hostKit, configuration.QueryStoreConnectionName)) + .WaitFor(ResolvePostgresDatabase(hostKit, configuration.QueryStoreConnectionName)); + break; + case SampleQueryStoreKind.MongoDb: + if (!mongoReferenced) + project.WithReference(hostKit.MongoDb); + + project.WaitFor(ResolveMongoDatabase(hostKit, configuration.QueryStoreDatabaseName)); + break; + } + } + + static void AddMongoReference( + IResourceBuilder project, + SampleAppHostKit hostKit, + string? databaseName + ) + { + project.WithReference(hostKit.MongoDb); + project.WaitFor(ResolveMongoDatabase(hostKit, databaseName)); + } + + static IResourceBuilder ResolveSqlServerDatabase( + SampleAppHostKit hostKit, + string connectionName + ) => + connectionName switch + { + Platform.SqlDatabase => hostKit.SqlServer.Database, + Platform.SqlSharedQueryDatabase => hostKit.SqlServer.SharedQueryDatabase, + _ => throw new InvalidOperationException($"Unsupported SQL Server connection name '{connectionName}'."), + }; + + static IResourceBuilder ResolvePostgresDatabase( + SampleAppHostKit hostKit, + string connectionName + ) => + connectionName switch + { + Platform.PostgresDatabase => hostKit.Postgres.Database, + Platform.PostgresSharedQueryDatabase => hostKit.Postgres.SharedQueryDatabase, + _ => throw new InvalidOperationException($"Unsupported Postgres connection name '{connectionName}'."), + }; + + static IResourceBuilder ResolveMongoDatabase( + SampleAppHostKit hostKit, + string? databaseName + ) => + databaseName switch + { + Platform.MongoDatabase => hostKit.MongoDb.Database, + Platform.MongoSharedQueryDatabase => hostKit.MongoDb.SharedQueryDatabase, + _ => throw new InvalidOperationException($"Unsupported MongoDB database name '{databaseName}'."), + }; + + public static void AddVariantLinks(IReadOnlyList variants, string endpointName = "https") + { + for (var variantIndex = 0; variantIndex < variants.Count; variantIndex++) + { + var variant = variants[variantIndex]; + for (var linkIndex = 0; linkIndex < variants.Count; linkIndex++) + { + var link = variants[linkIndex]; + var prefix = $"{SampleStoreOptions.SectionName}__Variants__{linkIndex}"; + + variant + .Resource.WithEnvironment($"{prefix}__Key", link.Configuration.Key) + .WithEnvironment($"{prefix}__DisplayName", link.Configuration.DisplayName) + .WithEnvironment($"{prefix}__Description", link.Configuration.Description) + .WithEnvironment($"{prefix}__Url", link.Resource.GetEndpoint(endpointName)); + } + } + } +} + +sealed class SampleWebProjectOptions +{ + public const string SectionName = "SampleWebProjects"; + + [Required] + public List Variants { get; set; } = []; + + [Required(AllowEmptyStrings = false)] + public string AdminSitePath { get; set; } = string.Empty; + + [Required(AllowEmptyStrings = false)] + public string AdminApiPath { get; set; } = string.Empty; + + [Required(AllowEmptyStrings = false)] + public string DataIsolationWarning { get; set; } = string.Empty; +} + +sealed class SampleWebProjectConfiguration +{ + [Required(AllowEmptyStrings = false)] + public string Key { get; set; } = string.Empty; + + [Required(AllowEmptyStrings = false)] + public string ResourceName { get; set; } = string.Empty; + + [Required(AllowEmptyStrings = false)] + public string DisplayName { get; set; } = string.Empty; + + [Required(AllowEmptyStrings = false)] + public string Description { get; set; } = string.Empty; + + public SampleEventStoreKind EventStore { get; set; } + + public SampleQueryStoreKind QueryStore { get; set; } + + public SampleAdminStoreKind AdminStore { get; set; } + + public bool AdminApiAvailable { get; set; } = true; + + [Required(AllowEmptyStrings = false)] + public string EventStoreConnectionName { get; set; } = string.Empty; + + [Required(AllowEmptyStrings = false)] + public string QueryStoreConnectionName { get; set; } = string.Empty; + + [RegularExpression(@"^[\w\-.]+$")] + public string? EventStoreDatabaseName { get; set; } + + [RegularExpression(@"^[\w\-.]+$")] + public string? QueryStoreDatabaseName { get; set; } + + [RegularExpression(@"^[\w\-.]+$")] + public string? AdminDatabaseName { get; set; } +} + +sealed record SampleWebProjectVariant( + SampleWebProjectConfiguration Configuration, + IResourceBuilder Resource +); diff --git a/src/src/Samples.AppHost/Extensions/Purview/EventSourcing/ContainerHelper.cs b/src/src/Samples.AppHost/Extensions/Purview/EventSourcing/ContainerHelper.cs new file mode 100644 index 00000000..e44d8e0b --- /dev/null +++ b/src/src/Samples.AppHost/Extensions/Purview/EventSourcing/ContainerHelper.cs @@ -0,0 +1,6 @@ +namespace Purview.EventSourcing; + +static partial class ContainerHelper +{ + // Here to satisfy the linked file. +} diff --git a/src/src/Samples.AppHost/Program.cs b/src/src/Samples.AppHost/Program.cs new file mode 100644 index 00000000..692d2226 --- /dev/null +++ b/src/src/Samples.AppHost/Program.cs @@ -0,0 +1,12 @@ +using Purview.EventSourcing.Samples.AppHost.AppModel.Resources; + +var builder = DistributedApplication.CreateBuilder(args); + +if (Environment.UserInteractive) + Console.Title = $"[{builder.Environment.EnvironmentName}] Samples.AppHost v{AssemblyInfo.Version}"; + +builder.AddAspireResourceKit(onConfigured: kit => SampleWebProjectResources.AddSampleWebProjects(builder, kit)); + +var app = builder.Build(); + +await app.RunAsync(); diff --git a/src/src/EventSourcing.Samples.AppHost/Properties/launchSettings.json b/src/src/Samples.AppHost/Properties/launchSettings.json similarity index 100% rename from src/src/EventSourcing.Samples.AppHost/Properties/launchSettings.json rename to src/src/Samples.AppHost/Properties/launchSettings.json diff --git a/src/src/Samples.AppHost/Samples.AppHost.csproj b/src/src/Samples.AppHost/Samples.AppHost.csproj new file mode 100644 index 00000000..4a262a17 --- /dev/null +++ b/src/src/Samples.AppHost/Samples.AppHost.csproj @@ -0,0 +1,28 @@ + + + + + + true + + + + + + + + + + + + + + + + diff --git a/src/src/Samples.AppHost/appsettings.json b/src/src/Samples.AppHost/appsettings.json new file mode 100644 index 00000000..a8c13fa7 --- /dev/null +++ b/src/src/Samples.AppHost/appsettings.json @@ -0,0 +1,85 @@ +{ + "SampleWebProjects": { + "AdminSitePath": "/admin", + "AdminApiPath": "/admin/api", + "DataIsolationWarning": "Each sample option uses isolated backing data. Switching store types changes the seeded dataset that you see.", + "Variants": [ + { + "Key": "sql-server", + "ResourceName": "sample-web-app", + "DisplayName": "SQL Server", + "Description": "SQL Server event store with SQL Server query snapshots and admin API.", + "EventStore": "SqlServer", + "QueryStore": "SqlServer", + "AdminStore": "SqlServer", + "AdminApiAvailable": true, + "EventStoreConnectionName": "eventstore-db", + "QueryStoreConnectionName": "eventstore-db" + }, + { + "Key": "postgres", + "ResourceName": "sample-web-postgres", + "DisplayName": "Postgres", + "Description": "Postgres event store with Postgres query snapshots and admin API.", + "EventStore": "Postgres", + "QueryStore": "Postgres", + "AdminStore": "Postgres", + "AdminApiAvailable": true, + "EventStoreConnectionName": "eventstore-postgres-db", + "QueryStoreConnectionName": "eventstore-postgres-db" + }, + { + "Key": "mongo-db", + "ResourceName": "sample-web-mongo", + "DisplayName": "MongoDB", + "Description": "MongoDB event store with MongoDB query snapshots and admin API.", + "EventStore": "MongoDb", + "QueryStore": "MongoDb", + "AdminStore": "MongoDb", + "AdminApiAvailable": true, + "EventStoreConnectionName": "eventstore-mongo", + "QueryStoreConnectionName": "eventstore-mongo", + "EventStoreDatabaseName": "eventstore-mongo-db", + "QueryStoreDatabaseName": "eventstore-mongo-db", + "AdminDatabaseName": "eventstore-mongo-db" + }, + { + "Key": "azure-storage-sql", + "ResourceName": "sample-web-azure-sql", + "DisplayName": "Azure Storage + SQL Server query store", + "Description": "Azure Storage append-only event store with SQL Server query snapshots in a dedicated shared database.", + "EventStore": "AzureStorage", + "QueryStore": "SqlServer", + "AdminStore": "AzureStorage", + "AdminApiAvailable": true, + "EventStoreConnectionName": "eventstore-tables", + "QueryStoreConnectionName": "eventstore-shared-db" + }, + { + "Key": "azure-storage-postgres", + "ResourceName": "sample-web-azure-postgres", + "DisplayName": "Azure Storage + Postgres query store", + "Description": "Azure Storage append-only event store with Postgres query snapshots in a dedicated shared database.", + "EventStore": "AzureStorage", + "QueryStore": "Postgres", + "AdminStore": "AzureStorage", + "AdminApiAvailable": true, + "EventStoreConnectionName": "eventstore-tables", + "QueryStoreConnectionName": "eventstore-postgres-shared-db" + }, + { + "Key": "azure-storage-mongo", + "ResourceName": "sample-web-azure-mongo", + "DisplayName": "Azure Storage + MongoDB query store", + "Description": "Azure Storage append-only event store with MongoDB query snapshots in a dedicated shared database.", + "EventStore": "AzureStorage", + "QueryStore": "MongoDb", + "AdminStore": "AzureStorage", + "AdminApiAvailable": true, + "EventStoreConnectionName": "eventstore-tables", + "QueryStoreConnectionName": "eventstore-mongo", + "QueryStoreDatabaseName": "eventstore-mongo-shared-db" + } + ] + } +} diff --git a/src/src/EventSourcing.Samples.AppHost/likec4/gen/likec4.config.json b/src/src/Samples.AppHost/likec4/gen/likec4.config.json similarity index 100% rename from src/src/EventSourcing.Samples.AppHost/likec4/gen/likec4.config.json rename to src/src/Samples.AppHost/likec4/gen/likec4.config.json diff --git a/src/src/Samples.AppHost/likec4/gen/model.gen.c4 b/src/src/Samples.AppHost/likec4/gen/model.gen.c4 new file mode 100644 index 00000000..a8dde836 --- /dev/null +++ b/src/src/Samples.AppHost/likec4/gen/model.gen.c4 @@ -0,0 +1,370 @@ +// ============================================================================= +// AUTO-GENERATED by AspireC4 — 2026-08-02 09:47:14 UTC +// Do not edit this file manually. Any changes will be overwritten on the +// next diagram regeneration (on Aspire startup or resource state change). +// See https://github.com/kjldev/aspirec4 for more information. +// ============================================================================= + +specification { + element component + element container + element database + element executable + element system + tag aspire-run-state-exited + tag aspire-run-state-failedtostart + tag aspire-run-state-finished + tag aspire-run-state-running + tag aspire-run-state-runtimeunhealthy + tag aspire-run-state-starting + tag aspire-run-state-stopping + tag aspire-run-state-waiting +} + +model { + storage = system 'storage' { + #aspire-run-state-running + icon azure:azure-storage-mover + link http://localhost:62160 'Endpoint: table' + link http://localhost:62166 'Endpoint: queue' + link http://localhost:62159 'Endpoint: blob' + link https://localhost:17134/consolelogs/resource/storage 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/storage 'Dashboard: Structured Logs' + metadata { + aspire-name 'storage' + } + eventstore_tables = database 'eventstore-tables' { + #aspire-run-state-running + icon azure:azure-storage-mover + link https://localhost:17134/consolelogs/resource/eventstore-tables 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-tables 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-tables' + } + } + storage_blobs = database 'storage-blobs' { + #aspire-run-state-running + icon azure:azure-storage-mover + link https://localhost:17134/consolelogs/resource/storage-blobs 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/storage-blobs 'Dashboard: Structured Logs' + metadata { + aspire-name 'storage-blobs' + } + eventstore_snapshots = database 'eventstore-snapshots' { + #aspire-run-state-running + icon azure:azure-storage-mover + link https://localhost:17134/consolelogs/resource/eventstore-snapshots 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-snapshots 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-snapshots' + } + } + } + } + eventstore_mongo = container 'eventstore-mongo' { + #aspire-run-state-running + technology 'library/mongo' + icon tech:mongodb + link https://localhost:17134/consolelogs/resource/eventstore-mongo 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-mongo 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-mongo' + } + eventstore_mongo_db = database 'eventstore-mongo-db' { + #aspire-run-state-running + icon tech:mongodb + link https://localhost:17134/consolelogs/resource/eventstore-mongo-db 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-mongo-db 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-mongo-db' + } + } + eventstore_mongo_shared_db = database 'eventstore-mongo-shared-db' { + #aspire-run-state-running + icon tech:mongodb + link https://localhost:17134/consolelogs/resource/eventstore-mongo-shared-db 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-mongo-shared-db 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-mongo-shared-db' + } + } + } + eventstore_postgres = container 'eventstore-postgres' { + #aspire-run-state-running + technology 'library/postgres' + icon tech:postgresql + link https://localhost:17134/consolelogs/resource/eventstore-postgres 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-postgres 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-postgres' + } + eventstore_postgres_db = database 'eventstore-postgres-db' { + #aspire-run-state-running + icon tech:postgresql + link https://localhost:17134/consolelogs/resource/eventstore-postgres-db 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-postgres-db 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-postgres-db' + } + } + eventstore_postgres_shared_db = database 'eventstore-postgres-shared-db' { + #aspire-run-state-running + icon tech:postgresql + link https://localhost:17134/consolelogs/resource/eventstore-postgres-shared-db 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-postgres-shared-db 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-postgres-shared-db' + } + } + } + redis = container 'redis' { + #aspire-run-state-running + technology 'library/redis' + icon tech:redis + link https://localhost:17134/consolelogs/resource/redis 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/redis 'Dashboard: Structured Logs' + metadata { + aspire-name 'redis' + } + } + eventstore_sql = container 'eventstore-sql' { + #aspire-run-state-running + technology 'mssql/server' + icon tech:microsoft-sql-server + link https://localhost:17134/consolelogs/resource/eventstore-sql 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-sql 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-sql' + } + eventstore_db = database 'eventstore-db' { + #aspire-run-state-running + icon tech:microsoft-sql-server + link https://localhost:17134/consolelogs/resource/eventstore-db 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-db 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-db' + } + } + eventstore_shared_db = database 'eventstore-shared-db' { + #aspire-run-state-running + icon tech:microsoft-sql-server + link https://localhost:17134/consolelogs/resource/eventstore-shared-db 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/eventstore-shared-db 'Dashboard: Structured Logs' + metadata { + aspire-name 'eventstore-shared-db' + } + } + } + sample_web_app = component 'sample-web-app' { + #aspire-run-state-running + technology '.NET' + icon tech:dotnet + link http://localhost:50849 'Endpoint: http' + link https://localhost:50848 'Endpoint: https' + link https://localhost:17134/consolelogs/resource/sample-web-app 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-app 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-app' + } + sample_web_app_rebuilder = executable 'sample-web-app-rebuilder' { + link https://localhost:17134/consolelogs/resource/sample-web-app-rebuilder 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-app-rebuilder 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-app-rebuilder' + aspire-type 'Executable' + } + } + } + sample_web_postgres = component 'sample-web-postgres' { + #aspire-run-state-running + technology '.NET' + icon tech:dotnet + link http://localhost:50849 'Endpoint: http' + link https://localhost:50848 'Endpoint: https' + link https://localhost:17134/consolelogs/resource/sample-web-postgres 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-postgres 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-postgres' + } + sample_web_postgres_rebuilder = executable 'sample-web-postgres-rebuilder' { + link https://localhost:17134/consolelogs/resource/sample-web-postgres-rebuilder 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-postgres-rebuilder 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-postgres-rebuilder' + aspire-type 'Executable' + } + } + } + sample_web_mongo = component 'sample-web-mongo' { + #aspire-run-state-running + technology '.NET' + icon tech:dotnet + link http://localhost:50849 'Endpoint: http' + link https://localhost:50848 'Endpoint: https' + link https://localhost:17134/consolelogs/resource/sample-web-mongo 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-mongo 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-mongo' + } + sample_web_mongo_rebuilder = executable 'sample-web-mongo-rebuilder' { + link https://localhost:17134/consolelogs/resource/sample-web-mongo-rebuilder 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-mongo-rebuilder 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-mongo-rebuilder' + aspire-type 'Executable' + } + } + } + sample_web_azure_sql = component 'sample-web-azure-sql' { + #aspire-run-state-running + technology '.NET' + icon tech:dotnet + link http://localhost:50849 'Endpoint: http' + link https://localhost:50848 'Endpoint: https' + link https://localhost:17134/consolelogs/resource/sample-web-azure-sql 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-azure-sql 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-azure-sql' + } + sample_web_azure_sql_rebuilder = executable 'sample-web-azure-sql-rebuilder' { + link https://localhost:17134/consolelogs/resource/sample-web-azure-sql-rebuilder 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-azure-sql-rebuilder 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-azure-sql-rebuilder' + aspire-type 'Executable' + } + } + } + sample_web_azure_postgres = component 'sample-web-azure-postgres' { + #aspire-run-state-running + technology '.NET' + icon tech:dotnet + link http://localhost:50849 'Endpoint: http' + link https://localhost:50848 'Endpoint: https' + link https://localhost:17134/consolelogs/resource/sample-web-azure-postgres 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-azure-postgres 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-azure-postgres' + } + sample_web_azure_postgres_rebuilder = executable 'sample-web-azure-postgres-rebuilder' { + link https://localhost:17134/consolelogs/resource/sample-web-azure-postgres-rebuilder 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-azure-postgres-rebuilder 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-azure-postgres-rebuilder' + aspire-type 'Executable' + } + } + } + sample_web_azure_mongo = component 'sample-web-azure-mongo' { + #aspire-run-state-running + technology '.NET' + icon tech:dotnet + link http://localhost:50849 'Endpoint: http' + link https://localhost:50848 'Endpoint: https' + link https://localhost:17134/consolelogs/resource/sample-web-azure-mongo 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-azure-mongo 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-azure-mongo' + } + sample_web_azure_mongo_rebuilder = executable 'sample-web-azure-mongo-rebuilder' { + link https://localhost:17134/consolelogs/resource/sample-web-azure-mongo-rebuilder 'Dashboard: Console Logs' + link https://localhost:17134/structuredlogs/resource/sample-web-azure-mongo-rebuilder 'Dashboard: Structured Logs' + metadata { + aspire-name 'sample-web-azure-mongo-rebuilder' + aspire-type 'Executable' + } + } + } + + sample_web_app -> eventstore_db + sample_web_app -> redis + sample_web_app -> eventstore_snapshots + sample_web_app -> sample_web_app + sample_web_app -> sample_web_postgres + sample_web_app -> sample_web_mongo + sample_web_app -> sample_web_azure_sql + sample_web_app -> sample_web_azure_postgres + sample_web_app -> sample_web_azure_mongo + sample_web_postgres -> eventstore_postgres_db + sample_web_postgres -> redis + sample_web_postgres -> eventstore_snapshots + sample_web_postgres -> sample_web_app + sample_web_postgres -> sample_web_postgres + sample_web_postgres -> sample_web_mongo + sample_web_postgres -> sample_web_azure_sql + sample_web_postgres -> sample_web_azure_postgres + sample_web_postgres -> sample_web_azure_mongo + sample_web_mongo -> eventstore_mongo + sample_web_mongo -> redis + sample_web_mongo -> eventstore_snapshots + sample_web_mongo -> sample_web_app + sample_web_mongo -> sample_web_postgres + sample_web_mongo -> sample_web_mongo + sample_web_mongo -> sample_web_azure_sql + sample_web_mongo -> sample_web_azure_postgres + sample_web_mongo -> sample_web_azure_mongo + sample_web_azure_sql -> eventstore_tables + sample_web_azure_sql -> eventstore_shared_db + sample_web_azure_sql -> redis + sample_web_azure_sql -> eventstore_snapshots + sample_web_azure_sql -> sample_web_app + sample_web_azure_sql -> sample_web_postgres + sample_web_azure_sql -> sample_web_mongo + sample_web_azure_sql -> sample_web_azure_sql + sample_web_azure_sql -> sample_web_azure_postgres + sample_web_azure_sql -> sample_web_azure_mongo + sample_web_azure_postgres -> eventstore_tables + sample_web_azure_postgres -> eventstore_postgres_shared_db + sample_web_azure_postgres -> redis + sample_web_azure_postgres -> eventstore_snapshots + sample_web_azure_postgres -> sample_web_app + sample_web_azure_postgres -> sample_web_postgres + sample_web_azure_postgres -> sample_web_mongo + sample_web_azure_postgres -> sample_web_azure_sql + sample_web_azure_postgres -> sample_web_azure_postgres + sample_web_azure_postgres -> sample_web_azure_mongo + sample_web_azure_mongo -> eventstore_tables + sample_web_azure_mongo -> eventstore_mongo + sample_web_azure_mongo -> redis + sample_web_azure_mongo -> eventstore_snapshots + sample_web_azure_mongo -> sample_web_app + sample_web_azure_mongo -> sample_web_postgres + sample_web_azure_mongo -> sample_web_mongo + sample_web_azure_mongo -> sample_web_azure_sql + sample_web_azure_mongo -> sample_web_azure_postgres + sample_web_azure_mongo -> sample_web_azure_mongo +} + +views { + view index { + title 'Architecture' + include * + style element.tag = #aspire-run-state-starting { + color sky + } + style element.tag = #aspire-run-state-waiting { + color sky + } + style element.tag = #aspire-run-state-running { + color green + } + style element.tag = #aspire-run-state-stopping { + color slate + opacity 60% + } + style element.tag = #aspire-run-state-exited { + color muted + opacity 30% + } + style element.tag = #aspire-run-state-finished { + color muted + opacity 30% + } + style element.tag = #aspire-run-state-runtimeunhealthy { + color amber + } + style element.tag = #aspire-run-state-failedtostart { + color red + } + } +} diff --git a/src/src/Samples.QuickStart/Infrastructure/InMemoryFailurePlan.cs b/src/src/Samples.QuickStart/Infrastructure/InMemoryFailurePlan.cs new file mode 100644 index 00000000..af8ff389 --- /dev/null +++ b/src/src/Samples.QuickStart/Infrastructure/InMemoryFailurePlan.cs @@ -0,0 +1,15 @@ +using System.Collections.Concurrent; +using Purview.EventSourcing.Aggregates; + +namespace Purview.EventSourcing.Samples.QuickStart.Infrastructure; + +sealed class InMemoryFailurePlan +{ + readonly ConcurrentDictionary<(Type AggregateType, string AggregateId), byte> _failNextSave = new(); + + public void FailNextSave(string aggregateId) + where TAggregate : IAggregate => _failNextSave.TryAdd((typeof(TAggregate), aggregateId), 0); + + public bool ShouldFail(Type aggregateType, string aggregateId) => + _failNextSave.TryRemove((aggregateType, aggregateId), out _); +} diff --git a/src/src/EventSourcing.Samples.QuickStart/Infrastructure/InMemoryTransactionalEventStore.cs b/src/src/Samples.QuickStart/Infrastructure/InMemoryTransactionalEventStore.cs similarity index 95% rename from src/src/EventSourcing.Samples.QuickStart/Infrastructure/InMemoryTransactionalEventStore.cs rename to src/src/Samples.QuickStart/Infrastructure/InMemoryTransactionalEventStore.cs index ae0a5812..8401ca25 100644 --- a/src/src/EventSourcing.Samples.QuickStart/Infrastructure/InMemoryTransactionalEventStore.cs +++ b/src/src/Samples.QuickStart/Infrastructure/InMemoryTransactionalEventStore.cs @@ -6,23 +6,13 @@ using System.Linq.Expressions; using System.Runtime.CompilerServices; using System.Text.Json; -using FluentValidation.Results; using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Internal; +using Purview.EventSourcing.Validation; namespace Purview.EventSourcing.Samples.QuickStart.Infrastructure; -sealed class InMemoryFailurePlan -{ - readonly ConcurrentDictionary<(Type AggregateType, string AggregateId), byte> _failNextSave = new(); - - public void FailNextSave(string aggregateId) - where TAggregate : IAggregate => _failNextSave.TryAdd((typeof(TAggregate), aggregateId), 0); - - public bool ShouldFail(Type aggregateType, string aggregateId) => - _failNextSave.TryRemove((aggregateType, aggregateId), out _); -} - sealed class InMemoryTransactionalEventStore(InMemoryFailurePlan failurePlan) : IQueryableEventStoreCore, ITransactionalEventStore @@ -126,12 +116,19 @@ public async IAsyncEnumerable GetAggregateIdsAsync( public Task ExistsAsync(string aggregateId, CancellationToken cancellationToken = default) { return !Persisted.TryGetValue(aggregateId, out var json) - ? Task.FromResult(ExistsState.DoesNotExists) + ? Task.FromResult(ExistsState.DoesNotExist) : Task.FromResult(new ExistsState(ExistsStatus.Exists, Deserialize(json).Details.CurrentVersion)); } public T FulfilRequirements(T aggregate) => aggregate; + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) => throw new NotSupportedException("The quick start store only demonstrates create, load, query, and save."); + public async IAsyncEnumerable GetQueryEnumerableAsync( Expression> whereClause, Func, IQueryable>? orderByClause, diff --git a/src/src/EventSourcing.Samples.QuickStart/Program.cs b/src/src/Samples.QuickStart/Program.cs similarity index 95% rename from src/src/EventSourcing.Samples.QuickStart/Program.cs rename to src/src/Samples.QuickStart/Program.cs index ced867fa..937a5521 100644 --- a/src/src/EventSourcing.Samples.QuickStart/Program.cs +++ b/src/src/Samples.QuickStart/Program.cs @@ -1,10 +1,12 @@ using Microsoft.Extensions.DependencyInjection; -using Purview.EventSourcing; using Purview.EventSourcing.Samples.Domain; using Purview.EventSourcing.Samples.QuickStart.Infrastructure; EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; +using CancellationTokenSource cts = new(); +Console.CancelKeyPress += (_, _) => cts.Cancel(); + var services = new ServiceCollection(); services.AddEventSourcing(); services.AddSingleton(); @@ -26,6 +28,15 @@ await RunSuccessfulCheckoutAsync(store, transactionFactory); await RunRollbackDemoAsync(store, transactionFactory, failurePlan); +await TestValidatorsAsync(cts.Token); + +static async Task TestValidatorsAsync(CancellationToken cancellationToken) +{ + await using ValidatorScenarios scenarios = new(); + + await scenarios.ValidateAsync(cancellationToken); +} + static async Task SeedAsync(IQueryableEventStore store) { var customer = await store.CreateAsync("customer-quickstart"); diff --git a/src/src/EventSourcing.Samples.QuickStart/EventSourcing.Samples.QuickStart.csproj b/src/src/Samples.QuickStart/Samples.QuickStart.csproj similarity index 64% rename from src/src/EventSourcing.Samples.QuickStart/EventSourcing.Samples.QuickStart.csproj rename to src/src/Samples.QuickStart/Samples.QuickStart.csproj index fe92969d..bf25a6d7 100644 --- a/src/src/EventSourcing.Samples.QuickStart/EventSourcing.Samples.QuickStart.csproj +++ b/src/src/Samples.QuickStart/Samples.QuickStart.csproj @@ -5,13 +5,15 @@ + - + + _scopes = []; + + IServiceProvider BuildServices(Action? action = null) + { + ServiceCollection services = []; + + services.AddLogging(); + + services.AddInMemoryEventStore().AddInMemorySnapshotEventStore(); + + action?.Invoke(services); + + var scope = services.BuildServiceProvider().CreateAsyncScope(); + _scopes.Add(scope); + + return scope.ServiceProvider; + } + + static CustomerAggregate CreateAggregate(int numberOfChars = 200) + { + CustomerAggregate agg = new(); + + return agg.ChangePhoneNumber(new string('1', numberOfChars)); + } + + public async Task ValidateAsync(CancellationToken cancellationToken) + { + await ValidateBuiltInAsync(cancellationToken); + await ValidateFluentValidatorAsync(cancellationToken); + await ValidateZodSharpAsync(cancellationToken); + } + + async Task ValidateBuiltInAsync(CancellationToken cancellationToken) + { + var sp = BuildServices(); + var store = sp.GetRequiredService(); + + var agg = CreateAggregate(); + + var result = await store.SaveAsync(agg, cancellationToken); + + DisplaySummary("BuiltIn", result); + } + + async Task ValidateFluentValidatorAsync(CancellationToken cancellationToken) + { + var sp = BuildServices(services => services.AddDomainFluentValidators()); + var store = sp.GetRequiredService(); + + var agg = CreateAggregate(); + + var result = await store.SaveAsync(agg, cancellationToken); + + DisplaySummary("FluentValidation", result); + } + + async Task ValidateZodSharpAsync(CancellationToken cancellationToken) + { + var sp = BuildServices(services => services.AddDomainZodValidators()); + var store = sp.GetRequiredService(); + + var agg = CreateAggregate(); + + var result = await store.SaveAsync(agg, cancellationToken); + + DisplaySummary("ZodSharp", result); + } + + static void DisplaySummary(string type, SaveResult result) + { + Console.WriteLine($"Validated '{type}':"); + if (result.IsValid) + Console.WriteLine(" FAILED: Did not validate correctly!!"); + else + { + if (result.ValidationResult.Errors.Count != 1) + Console.WriteLine( + $" FAILED: Should be exactly 1 error, but found {result.ValidationResult.Errors.Count}" + ); + else if (result.ValidationResult.Errors[0].PropertyName != nameof(CustomerAggregate.PhoneNumber)) + Console.WriteLine( + $" FAILED: Error should have validatedd '{nameof(CustomerAggregate.PhoneNumber)}', but found '{result.ValidationResult.Errors[0].PropertyName}'" + ); + else + Console.WriteLine($" SUCCESS: Found {result.ValidationResult.Errors[0].ErrorMessage}"); + } + + Console.WriteLine(); + } + + public async ValueTask DisposeAsync() + { + foreach (var scope in _scopes) + await scope.DisposeAsync(); + } +} diff --git a/src/src/EventSourcing.Samples.ServiceDefaults/Extensions/Extensions.cs b/src/src/Samples.ServiceDefaults/Extensions/Extensions.cs similarity index 100% rename from src/src/EventSourcing.Samples.ServiceDefaults/Extensions/Extensions.cs rename to src/src/Samples.ServiceDefaults/Extensions/Extensions.cs diff --git a/src/src/EventSourcing.Samples.ServiceDefaults/EventSourcing.Samples.ServiceDefaults.csproj b/src/src/Samples.ServiceDefaults/Samples.ServiceDefaults.csproj similarity index 100% rename from src/src/EventSourcing.Samples.ServiceDefaults/EventSourcing.Samples.ServiceDefaults.csproj rename to src/src/Samples.ServiceDefaults/Samples.ServiceDefaults.csproj diff --git a/src/src/Samples.Shared/AzureStorageConnectionStringComposer.cs b/src/src/Samples.Shared/AzureStorageConnectionStringComposer.cs new file mode 100644 index 00000000..593952e0 --- /dev/null +++ b/src/src/Samples.Shared/AzureStorageConnectionStringComposer.cs @@ -0,0 +1,150 @@ +namespace Purview.EventSourcing.Samples; + +public static class AzureStorageConnectionStringComposer +{ + static readonly HashSet AllowedKeys = + [ + "AccountKey", + "AccountName", + "BlobEndpoint", + "DefaultEndpointsProtocol", + "DevelopmentStorageProxyUri", + "EndpointSuffix", + "FileEndpoint", + "QueueEndpoint", + "SharedAccessSignature", + "TableEndpoint", + "UseDevelopmentStorage", + ]; + + public static string Normalize(string? value) + { + var normalized = NormalizeConnectionString(value); + if (string.IsNullOrWhiteSpace(normalized)) + return normalized; + + if (normalized.Contains("UseDevelopmentStorage=true", StringComparison.OrdinalIgnoreCase)) + return "UseDevelopmentStorage=true"; + + var parts = ParseConnectionStringParts(normalized); + if (parts.Count == 0) + return string.Empty; + + foreach (var key in parts.Keys.Except(AllowedKeys, StringComparer.OrdinalIgnoreCase).ToArray()) + parts.Remove(key); + + if ( + parts.TryGetValue("BlobEndpoint", out var blobEndpointRaw) + && parts.TryGetValue("AccountName", out var accountName) + && Uri.TryCreate(blobEndpointRaw, UriKind.Absolute, out var blobEndpoint) + ) + { + var basePath = $"/{accountName}"; + var trimmedPath = blobEndpoint.AbsolutePath.StartsWith(basePath + "/", StringComparison.OrdinalIgnoreCase) + ? basePath + : blobEndpoint.AbsolutePath; + + var builder = new UriBuilder(blobEndpoint) { Path = trimmedPath }; + parts["BlobEndpoint"] = builder.Uri.ToString().TrimEnd('/'); + } + + return string.Join(';', parts.Select(part => $"{part.Key}={part.Value}")); + } + + public static string BuildEventStoreConnectionString( + string? eventStoreConnectionString, + string? blobConnectionString, + string? fallbackConnectionString + ) + { + var eventStore = ParseConnectionStringParts(Normalize(eventStoreConnectionString)); + var blob = ParseConnectionStringParts(Normalize(blobConnectionString)); + var fallback = ParseConnectionStringParts(Normalize(fallbackConnectionString)); + + if ( + ContainsUseDevelopmentStorage(eventStore) + || ContainsUseDevelopmentStorage(blob) + || ContainsUseDevelopmentStorage(fallback) + ) + { + return "UseDevelopmentStorage=true"; + } + + var merged = new Dictionary(StringComparer.OrdinalIgnoreCase); + Merge(fallback, merged); + Merge(blob, merged); + Merge(eventStore, merged); + + if ( + !merged.ContainsKey("BlobEndpoint") + && merged.TryGetValue("TableEndpoint", out var tableEndpointRaw) + && Uri.TryCreate(tableEndpointRaw, UriKind.Absolute, out var tableEndpoint) + ) + { + var blobBuilder = new UriBuilder(tableEndpoint); + if (blobBuilder.Port == 10002) + blobBuilder.Port = 10000; + + merged["BlobEndpoint"] = blobBuilder.Uri.ToString().TrimEnd('/'); + } + + if ( + !merged.ContainsKey("TableEndpoint") + && merged.TryGetValue("BlobEndpoint", out var blobEndpointRaw) + && Uri.TryCreate(blobEndpointRaw, UriKind.Absolute, out var blobEndpoint) + ) + { + var tableBuilder = new UriBuilder(blobEndpoint); + if (tableBuilder.Port == 10000) + tableBuilder.Port = 10002; + + merged["TableEndpoint"] = tableBuilder.Uri.ToString().TrimEnd('/'); + } + + return string.Join(';', merged.Select(part => $"{part.Key}={part.Value}")); + } + + public static Dictionary ParseConnectionStringParts(string? connectionString) + { + if (string.IsNullOrWhiteSpace(connectionString)) + return [with(StringComparer.OrdinalIgnoreCase)]; + + var values = new Dictionary(StringComparer.OrdinalIgnoreCase); + foreach ( + var part in connectionString.Split( + ';', + StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries + ) + ) + { + var split = part.Split('=', 2); + if (split.Length == 2) + values[split[0]] = split[1]; + } + + return values; + } + + static string NormalizeConnectionString(string? value) + { + if (string.IsNullOrWhiteSpace(value)) + return string.Empty; + + var parts = value.Split(';', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries); + + return parts.Length == 0 ? string.Empty : string.Join(';', parts); + } + + static bool ContainsUseDevelopmentStorage(Dictionary values) => + values.TryGetValue("UseDevelopmentStorage", out var value) + && string.Equals(value, "true", StringComparison.OrdinalIgnoreCase); + + static void Merge(Dictionary source, Dictionary target) + { + foreach (var (key, value) in source) + { + if (!string.IsNullOrWhiteSpace(value)) + target[key] = value; + } + } +} diff --git a/src/src/Samples.Shared/Platform.cs b/src/src/Samples.Shared/Platform.cs new file mode 100644 index 00000000..366cddf7 --- /dev/null +++ b/src/src/Samples.Shared/Platform.cs @@ -0,0 +1,32 @@ +namespace Purview.EventSourcing.Samples; + +public static class Platform +{ + public const string AspireC4 = "aspirec4"; + + public const string SqlServer = "eventstore-sql"; + public const string SqlDatabase = "eventstore-db"; + public const string SqlSharedQueryDatabase = "eventstore-shared-db"; + + public const string Postgres = "eventstore-postgres"; + public const string PostgresDatabase = "eventstore-postgres-db"; + public const string PostgresSharedQueryDatabase = "eventstore-postgres-shared-db"; + + public const string MongoDb = "eventstore-mongo"; + public const string MongoDatabase = "eventstore-mongo-db"; + public const string MongoSharedQueryDatabase = "eventstore-mongo-shared-db"; + + public const string Redis = "redis"; + + public const string AzureStorage = "storage"; + public const string AzureStorageTable = "eventstore-tables"; + public const string AzureStorageBlob = "eventstore-snapshots"; + + public const string WebApp = "sample-web-app"; + public const string SqlWebApp = "sample-web-sql"; + public const string PostgresWebApp = "sample-web-postgres"; + public const string MongoDbWebApp = "sample-web-mongo"; + public const string AzureSqlWebApp = "sample-web-azure-sql"; + public const string AzurePostgresWebApp = "sample-web-azure-postgres"; + public const string AzureMongoDbWebApp = "sample-web-azure-mongo"; +} diff --git a/src/src/Samples.Shared/SampleStoreConfiguration.cs b/src/src/Samples.Shared/SampleStoreConfiguration.cs new file mode 100644 index 00000000..428389d7 --- /dev/null +++ b/src/src/Samples.Shared/SampleStoreConfiguration.cs @@ -0,0 +1,81 @@ +using System.Collections.ObjectModel; +using System.ComponentModel.DataAnnotations; + +namespace Purview.EventSourcing.Samples; + +public enum SampleEventStoreKind +{ + SqlServer, + Postgres, + MongoDb, + AzureStorage, +} + +public enum SampleQueryStoreKind +{ + SqlServer, + Postgres, + MongoDb, +} + +public enum SampleAdminStoreKind +{ + None, + SqlServer, + Postgres, + MongoDb, + AzureStorage, +} + +public sealed class SampleStoreOptions +{ + public const string SectionName = "SampleStore"; + + public string CurrentKey { get; set; } = "sql-server"; + + public string CurrentDisplayName { get; set; } = "SQL Server"; + + public string CurrentDescription { get; set; } = "SQL Server event streams with SQL Server query snapshots."; + + public string DataIsolationWarning { get; set; } = + "Each sample option uses its own backing data. Switching providers shows a different seeded dataset."; + + public SampleEventStoreKind EventStore { get; set; } = SampleEventStoreKind.SqlServer; + + public SampleQueryStoreKind QueryStore { get; set; } = SampleQueryStoreKind.SqlServer; + + public SampleAdminStoreKind AdminStore { get; set; } = SampleAdminStoreKind.SqlServer; + + public bool AdminApiAvailable { get; set; } = true; + + public string EventStoreConnectionName { get; set; } = Platform.SqlDatabase; + + public string QueryStoreConnectionName { get; set; } = Platform.SqlDatabase; + + [RegularExpression(@"^[\w\-.]+$")] + public string? EventStoreDatabaseName { get; set; } + + [RegularExpression(@"^[\w\-.]+$")] + public string? QueryStoreDatabaseName { get; set; } + + [RegularExpression(@"^[\w\-.]+$")] + public string? AdminDatabaseName { get; set; } + + public string AdminSitePath { get; set; } = "/admin"; + + public string AdminApiPath { get; set; } = "/admin/api"; + + public Collection Variants { get; } = []; +} + +public sealed class SampleStoreVariantLink +{ + public string Key { get; set; } = string.Empty; + + public string DisplayName { get; set; } = string.Empty; + + public string Description { get; set; } = string.Empty; + + [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1056:URI-like properties should not be strings")] + public string Url { get; set; } = string.Empty; +} diff --git a/src/src/Samples.Shared/Samples.Shared.csproj b/src/src/Samples.Shared/Samples.Shared.csproj new file mode 100644 index 00000000..b0d55fda --- /dev/null +++ b/src/src/Samples.Shared/Samples.Shared.csproj @@ -0,0 +1,7 @@ + + + Samples.Shared + Purview.EventSourcing.Samples.Shared + $(NamespacePrefix).Samples + + diff --git a/src/src/EventSourcing.Samples.Web/Infrastructure/CartSessionExtensions.cs b/src/src/Samples.Web/Infrastructure/CartSessionExtensions.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Infrastructure/CartSessionExtensions.cs rename to src/src/Samples.Web/Infrastructure/CartSessionExtensions.cs diff --git a/src/src/EventSourcing.Samples.Web/Infrastructure/EventSourcingPageModel.cs b/src/src/Samples.Web/Infrastructure/EventSourcingPageModel.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Infrastructure/EventSourcingPageModel.cs rename to src/src/Samples.Web/Infrastructure/EventSourcingPageModel.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Audit/Index.cshtml b/src/src/Samples.Web/Pages/BackOffice/Audit/Index.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Audit/Index.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Audit/Index.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Audit/Index.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Audit/Index.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Audit/Index.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Audit/Index.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Create.cshtml b/src/src/Samples.Web/Pages/BackOffice/Catalog/Create.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Create.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Catalog/Create.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Create.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Catalog/Create.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Create.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Catalog/Create.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Deleted.cshtml b/src/src/Samples.Web/Pages/BackOffice/Catalog/Deleted.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Deleted.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Catalog/Deleted.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Deleted.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Catalog/Deleted.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Deleted.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Catalog/Deleted.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Edit.cshtml b/src/src/Samples.Web/Pages/BackOffice/Catalog/Edit.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Edit.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Catalog/Edit.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Edit.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Catalog/Edit.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Edit.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Catalog/Edit.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Index.cshtml b/src/src/Samples.Web/Pages/BackOffice/Catalog/Index.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Index.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Catalog/Index.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Index.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Catalog/Index.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Catalog/Index.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Catalog/Index.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Create.cshtml b/src/src/Samples.Web/Pages/BackOffice/Customers/Create.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Create.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Customers/Create.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Create.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Customers/Create.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Create.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Customers/Create.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Deleted.cshtml b/src/src/Samples.Web/Pages/BackOffice/Customers/Deleted.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Deleted.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Customers/Deleted.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Deleted.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Customers/Deleted.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Deleted.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Customers/Deleted.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Edit.cshtml b/src/src/Samples.Web/Pages/BackOffice/Customers/Edit.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Edit.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Customers/Edit.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Edit.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Customers/Edit.cshtml.cs similarity index 98% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Edit.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Customers/Edit.cshtml.cs index 2ccdba00..b464cd07 100644 --- a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Edit.cshtml.cs +++ b/src/src/Samples.Web/Pages/BackOffice/Customers/Edit.cshtml.cs @@ -59,7 +59,7 @@ public async Task OnPostChangePhoneAsync(string id, string? phone : await TrySaveAsync( async () => { - customer.ChangePhoneNumber(phoneNumber.OrNull()); + customer.ChangePhoneNumber(phoneNumber); await store.SaveAsync(customer, HttpContext.RequestAborted); }, "Phone number updated.", diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Index.cshtml b/src/src/Samples.Web/Pages/BackOffice/Customers/Index.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Index.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Customers/Index.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Index.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Customers/Index.cshtml.cs similarity index 92% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Index.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Customers/Index.cshtml.cs index afeead2a..1d690d1e 100644 --- a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Customers/Index.cshtml.cs +++ b/src/src/Samples.Web/Pages/BackOffice/Customers/Index.cshtml.cs @@ -58,10 +58,15 @@ public async Task OnGetAsync() var activeFilter = ActiveFilter; var hasFilter = search.Length > 0 || activeFilter.HasValue; + var results = (await store.ListAsync(maxRecordCount: 100, ct)); + Expression>? where = hasFilter ? c => - (string.IsNullOrEmpty(search) || c.Name.Value.Contains(search) || c.Email.Value.Contains(search)) - && (!activeFilter.HasValue || c.IsActive == activeFilter.Value) + ( + string.IsNullOrEmpty(search) + || ((string)c.Name).Contains(search) + || ((string)c.Email).Contains(search) + ) && (!activeFilter.HasValue || c.IsActive == activeFilter.Value) : null; Func, IQueryable> orderBy = (SortBy, SortDir) switch diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Index.cshtml b/src/src/Samples.Web/Pages/BackOffice/Index.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Index.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Index.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Index.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Index.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Index.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Index.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Create.cshtml b/src/src/Samples.Web/Pages/BackOffice/Stock/Create.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Create.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Stock/Create.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Create.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Stock/Create.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Create.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Stock/Create.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Deleted.cshtml b/src/src/Samples.Web/Pages/BackOffice/Stock/Deleted.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Deleted.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Stock/Deleted.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Deleted.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Stock/Deleted.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Deleted.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Stock/Deleted.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Edit.cshtml b/src/src/Samples.Web/Pages/BackOffice/Stock/Edit.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Edit.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Stock/Edit.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Edit.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Stock/Edit.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Edit.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Stock/Edit.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Index.cshtml b/src/src/Samples.Web/Pages/BackOffice/Stock/Index.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Index.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Stock/Index.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Index.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Stock/Index.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Index.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Stock/Index.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Transfer.cshtml b/src/src/Samples.Web/Pages/BackOffice/Stock/Transfer.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Transfer.cshtml rename to src/src/Samples.Web/Pages/BackOffice/Stock/Transfer.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Transfer.cshtml.cs b/src/src/Samples.Web/Pages/BackOffice/Stock/Transfer.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/BackOffice/Stock/Transfer.cshtml.cs rename to src/src/Samples.Web/Pages/BackOffice/Stock/Transfer.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Cart/Index.cshtml b/src/src/Samples.Web/Pages/Customer/Cart/Index.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Cart/Index.cshtml rename to src/src/Samples.Web/Pages/Customer/Cart/Index.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Cart/Index.cshtml.cs b/src/src/Samples.Web/Pages/Customer/Cart/Index.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Cart/Index.cshtml.cs rename to src/src/Samples.Web/Pages/Customer/Cart/Index.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Catalog/Index.cshtml b/src/src/Samples.Web/Pages/Customer/Catalog/Index.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Catalog/Index.cshtml rename to src/src/Samples.Web/Pages/Customer/Catalog/Index.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Catalog/Index.cshtml.cs b/src/src/Samples.Web/Pages/Customer/Catalog/Index.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Catalog/Index.cshtml.cs rename to src/src/Samples.Web/Pages/Customer/Catalog/Index.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Catalog/Order.cshtml b/src/src/Samples.Web/Pages/Customer/Catalog/Order.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Catalog/Order.cshtml rename to src/src/Samples.Web/Pages/Customer/Catalog/Order.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Catalog/Order.cshtml.cs b/src/src/Samples.Web/Pages/Customer/Catalog/Order.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Catalog/Order.cshtml.cs rename to src/src/Samples.Web/Pages/Customer/Catalog/Order.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Index.cshtml b/src/src/Samples.Web/Pages/Customer/Index.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Index.cshtml rename to src/src/Samples.Web/Pages/Customer/Index.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Index.cshtml.cs b/src/src/Samples.Web/Pages/Customer/Index.cshtml.cs similarity index 93% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Index.cshtml.cs rename to src/src/Samples.Web/Pages/Customer/Index.cshtml.cs index c09de4c2..043310d3 100644 --- a/src/src/EventSourcing.Samples.Web/Pages/Customer/Index.cshtml.cs +++ b/src/src/Samples.Web/Pages/Customer/Index.cshtml.cs @@ -54,8 +54,11 @@ public async Task OnGetAsync() Expression> where = hasFilter ? c => - (string.IsNullOrEmpty(search) || c.Name.Value.Contains(search) || c.Email.Value.Contains(search)) - && (ShowInactive || c.IsActive) + ( + string.IsNullOrEmpty(search) + || ((string)c.Name).Contains(search) + || ((string)c.Email).Contains(search) + ) && (ShowInactive || c.IsActive) : c => true; var result = await store.QueryAsync(where, q => q.OrderBy(c => c.Name), request, ct); diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Orders/Details.cshtml b/src/src/Samples.Web/Pages/Customer/Orders/Details.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Orders/Details.cshtml rename to src/src/Samples.Web/Pages/Customer/Orders/Details.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Orders/Details.cshtml.cs b/src/src/Samples.Web/Pages/Customer/Orders/Details.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Orders/Details.cshtml.cs rename to src/src/Samples.Web/Pages/Customer/Orders/Details.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Orders/Index.cshtml b/src/src/Samples.Web/Pages/Customer/Orders/Index.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Orders/Index.cshtml rename to src/src/Samples.Web/Pages/Customer/Orders/Index.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Orders/Index.cshtml.cs b/src/src/Samples.Web/Pages/Customer/Orders/Index.cshtml.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Orders/Index.cshtml.cs rename to src/src/Samples.Web/Pages/Customer/Orders/Index.cshtml.cs diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Profile/Index.cshtml b/src/src/Samples.Web/Pages/Customer/Profile/Index.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Profile/Index.cshtml rename to src/src/Samples.Web/Pages/Customer/Profile/Index.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/Customer/Profile/Index.cshtml.cs b/src/src/Samples.Web/Pages/Customer/Profile/Index.cshtml.cs similarity index 99% rename from src/src/EventSourcing.Samples.Web/Pages/Customer/Profile/Index.cshtml.cs rename to src/src/Samples.Web/Pages/Customer/Profile/Index.cshtml.cs index af567a04..0b650b25 100644 --- a/src/src/EventSourcing.Samples.Web/Pages/Customer/Profile/Index.cshtml.cs +++ b/src/src/Samples.Web/Pages/Customer/Profile/Index.cshtml.cs @@ -108,7 +108,7 @@ public async Task OnPostUpdateAllAsync(string newName, string new : await TrySaveAsync( async () => { - customer.UpdateDetails(name: newName, email: newEmail, phoneNumber: phoneNumber.OrNull()); + customer.UpdateDetails(name: newName, email: newEmail, phoneNumber: phoneNumber); await store.SaveAsync(customer, HttpContext.RequestAborted); }, "Profile updated.", diff --git a/src/src/Samples.Web/Pages/Index.cshtml b/src/src/Samples.Web/Pages/Index.cshtml new file mode 100644 index 00000000..272a37c7 --- /dev/null +++ b/src/src/Samples.Web/Pages/Index.cshtml @@ -0,0 +1,78 @@ +@page +@model IndexModel +@{ + ViewData["Title"] = "Portal Home"; + Layout = "_Layout"; +} + +
+
+

🗃

+

Event Sourcing Sample

+

Choose your experience to get started

+
+ +
+
+
+
+

Current store option

+

@Model.StoreOptions.CurrentDisplayName

+

@Model.StoreOptions.CurrentDescription

+
+ @if (Model.StoreOptions.AdminApiAvailable) + { +
+ Admin Site + Admin API +
+ } +
+

@Model.StoreOptions.DataIsolationWarning

+
+ + @if (Model.StoreOptions.Variants.Count > 0) + { +
+
+

Switch storage option

+

Each option runs as its own sample instance.

+
+
+ @foreach (var variant in Model.StoreOptions.Variants) + { + var isCurrent = string.Equals(variant.Key, Model.StoreOptions.CurrentKey, StringComparison.OrdinalIgnoreCase); + +
+

@variant.DisplayName

+ @if (isCurrent) + { + Current + } +
+

@variant.Description

+ + } +
+
+ } +
+ +
+ + +
🛒
+

Customer Experience

+

Browse the product catalog, place orders, and manage your profile.

+ Enter → + + + + +
🏢
+

Back Office

+

Manage customers, the product catalog, stock levels, and inventory locations.

+ Enter → + +
+
diff --git a/src/src/Samples.Web/Pages/Index.cshtml.cs b/src/src/Samples.Web/Pages/Index.cshtml.cs new file mode 100644 index 00000000..83d59969 --- /dev/null +++ b/src/src/Samples.Web/Pages/Index.cshtml.cs @@ -0,0 +1,8 @@ +using Microsoft.AspNetCore.Mvc.RazorPages; + +namespace Purview.EventSourcing.Samples.Web.Pages; + +sealed class IndexModel(SampleStoreOptions storeOptions) : PageModel +{ + public SampleStoreOptions StoreOptions { get; } = storeOptions; +} diff --git a/src/src/EventSourcing.Samples.Web/Pages/Shared/_Layout.cshtml b/src/src/Samples.Web/Pages/Shared/_Layout.cshtml similarity index 93% rename from src/src/EventSourcing.Samples.Web/Pages/Shared/_Layout.cshtml rename to src/src/Samples.Web/Pages/Shared/_Layout.cshtml index 82dabbbe..878f6219 100644 --- a/src/src/EventSourcing.Samples.Web/Pages/Shared/_Layout.cshtml +++ b/src/src/Samples.Web/Pages/Shared/_Layout.cshtml @@ -1,3 +1,4 @@ +@inject Purview.EventSourcing.Samples.SampleStoreOptions StoreOptions @@ -20,6 +21,7 @@ 🗃 Event Sourcing

Sample Application

+

@StoreOptions.CurrentDisplayName

+ @if (StoreOptions.AdminApiAvailable) + { +
+ Admin Site + Admin API +
+ } .NET 10 · Event Sourcing
diff --git a/src/src/EventSourcing.Samples.Web/Pages/_ViewImports.cshtml b/src/src/Samples.Web/Pages/_ViewImports.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/_ViewImports.cshtml rename to src/src/Samples.Web/Pages/_ViewImports.cshtml diff --git a/src/src/EventSourcing.Samples.Web/Pages/_ViewStart.cshtml b/src/src/Samples.Web/Pages/_ViewStart.cshtml similarity index 100% rename from src/src/EventSourcing.Samples.Web/Pages/_ViewStart.cshtml rename to src/src/Samples.Web/Pages/_ViewStart.cshtml diff --git a/src/src/Samples.Web/Program.cs b/src/src/Samples.Web/Program.cs new file mode 100644 index 00000000..a9c69e25 --- /dev/null +++ b/src/src/Samples.Web/Program.cs @@ -0,0 +1,382 @@ +using System.Diagnostics.CodeAnalysis; +using Azure; +using Azure.Storage.Blobs; +using Microsoft.AspNetCore.Authentication; +using MongoDB.Driver; +using Npgsql; +using Purview.EventSourcing.Admin.Api; +using Purview.EventSourcing.Admin.AzureStorage; +using Purview.EventSourcing.Admin.MongoDB; +using Purview.EventSourcing.Admin.Postgres; +using Purview.EventSourcing.Admin.Security; +using Purview.EventSourcing.Admin.Site; +using Purview.EventSourcing.Admin.SqlServer; +using Purview.EventSourcing.AzureStorage; +using Purview.EventSourcing.MongoDB.Events; +using Purview.EventSourcing.MongoDB.Snapshots; +using Purview.EventSourcing.Samples; +using Purview.EventSourcing.Samples.Services; +using Purview.EventSourcing.Samples.Web.Services; +using AzureCommitException = Purview.EventSourcing.AzureStorage.Exceptions.CommitException; +using AzureConcurrencyException = Purview.EventSourcing.AzureStorage.Exceptions.ConcurrencyException; +using SqlServerCommitException = Purview.EventSourcing.SqlServer.Events.Exceptions.CommitException; +using SqlServerConcurrencyException = Purview.EventSourcing.SqlServer.Events.Exceptions.ConcurrencyException; + +// No authentication in this sample — allow all operations without a principal identifier +EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; + +var builder = WebApplication.CreateBuilder(args); +var sampleStoreOptions = + builder.Configuration.GetSection(SampleStoreOptions.SectionName).Get() ?? new(); + +builder.AddServiceDefaults(); +builder.Services.AddAuthentication(); +builder.Services.AddAuthorization(); +builder.Services.AddSingleton(sampleStoreOptions); + +// Use Redis when available (e.g. via Aspire AppHost); fall back to in-memory for standalone dev runs +if (string.IsNullOrWhiteSpace(builder.Configuration.GetConnectionString(Platform.Redis))) + builder.Services.AddDistributedMemoryCache(); +else + builder.AddRedisDistributedCache(Platform.Redis); + +ConfigureStoreOptions(builder.Services, builder.Configuration, sampleStoreOptions); +RegisterEventStore(builder.Services, sampleStoreOptions); +RegisterQueryStore(builder.Services, sampleStoreOptions); +RegisterAdmin(builder.Services, sampleStoreOptions); + +builder.Services.AddDomainServices(); +builder.Services.AddScoped(); + +// Register product image service — uses Azure Blob Storage when configured, no-op otherwise +var blobConnectionString = AzureStorageConnectionStringComposer.Normalize( + builder.Configuration.GetConnectionString(Platform.AzureStorageBlob) +); +builder.Services.AddSingleton(serviceProvider => +{ + if (string.IsNullOrWhiteSpace(blobConnectionString)) + return new NullProductImageService(); + + try + { + return new ProductImageService(new BlobServiceClient(blobConnectionString)); + } + catch (FormatException ex) + { + serviceProvider + .GetRequiredService() + .CreateLogger("ProductImageService") + .LogWarning(ex, "Invalid Azure Blob connection string; product images are disabled."); + return new NullProductImageService(); + } + catch (ArgumentException ex) + { + serviceProvider + .GetRequiredService() + .CreateLogger("ProductImageService") + .LogWarning(ex, "Invalid Azure Blob connection string; product images are disabled."); + return new NullProductImageService(); + } +}); + +if (sampleStoreOptions.AdminApiAvailable) + builder.Services.AddPurviewEventSourcingAdminSite( + enableRazorRuntimeCompilation: builder.Environment.IsDevelopment() + ); + +builder.Services.AddSession(options => +{ + options.IdleTimeout = TimeSpan.FromMinutes(30); + options.Cookie.HttpOnly = true; + options.Cookie.IsEssential = true; +}); + +var app = builder.Build(); + +if (!app.Environment.IsDevelopment()) + app.UseExceptionHandler("/Error"); + +app.UseStaticFiles(); +app.UseRouting(); +app.UseAuthentication(); +app.UseAuthorization(); +app.UseSession(); + +if (sampleStoreOptions.AdminApiAvailable) +{ + app.MapPurviewEventSourcingAdminApi(); + app.MapPurviewEventSourcingAdminSite(); +} + +app.MapGroup("/api/audit") + .MapGet( + "/aggregates/{aggregateType}/{aggregateId}/events", + static async Task ( + string aggregateType, + string aggregateId, + int? fromVersion, + int? toVersion, + DateTimeOffset? fromUtc, + DateTimeOffset? toUtc, + int? maxRecords, + string? continuationToken, + IAggregateAuditService auditService, + CancellationToken cancellationToken + ) => + { + if (!AggregateAuditService.IsSupportedAggregateType(aggregateType)) + return Results.BadRequest( + new + { + Error = $"Unsupported aggregate type '{aggregateType}'.", + AggregateAuditService.SupportedAggregateTypes, + } + ); + + var request = new AggregateEventHistoryRequest + { + FromVersion = fromVersion, + ToVersion = toVersion, + FromUtc = fromUtc, + ToUtc = toUtc, + MaxRecords = maxRecords ?? ContinuationRequest.DefaultMaxRecords, + ContinuationToken = continuationToken, + }; + var response = await auditService.GetHistoryAsync(aggregateType, aggregateId, request, cancellationToken); + + return Results.Ok(response); + } + ); +app.MapDefaultEndpoints().MapGet("/pingz", () => Results.Ok()); + +// Seed demo data on startup (no-op if data already exists). +await using (var scope = app.Services.CreateAsyncScope()) +{ + var seeder = scope.ServiceProvider.GetRequiredService(); + var logger = scope.ServiceProvider.GetRequiredService().CreateLogger("SeedData"); + for (var attempt = 0; ; attempt++) + { + try + { + await seeder.SeedAsync(); + break; + } + catch (SqlServerConcurrencyException) when (attempt < 2) + { + // Another app instance may be seeding the demo store at the same time. + await Task.Delay(TimeSpan.FromMilliseconds(100 * (attempt + 1))); + } + catch (AzureConcurrencyException) when (attempt < 2) + { + // Another app instance may be seeding the demo store at the same time. + await Task.Delay(TimeSpan.FromMilliseconds(100 * (attempt + 1))); + } + catch (RequestFailedException ex) + { + logger.LogError( + ex, + "Sample data seeding failed for store variant '{StoreVariant}'.", + sampleStoreOptions.CurrentKey + ); + break; + } + catch (MongoException ex) + { + logger.LogError( + ex, + "Sample data seeding failed for store variant '{StoreVariant}'.", + sampleStoreOptions.CurrentKey + ); + break; + } + catch (NpgsqlException ex) + { + logger.LogError( + ex, + "Sample data seeding failed for store variant '{StoreVariant}'.", + sampleStoreOptions.CurrentKey + ); + break; + } + catch (SqlServerCommitException ex) + { + logger.LogError( + ex, + "Sample data seeding failed for store variant '{StoreVariant}'.", + sampleStoreOptions.CurrentKey + ); + break; + } + catch (AzureCommitException ex) + { + logger.LogError( + ex, + "Sample data seeding failed for store variant '{StoreVariant}'.", + sampleStoreOptions.CurrentKey + ); + break; + } + catch (FormatException ex) + { + logger.LogError( + ex, + "Sample data seeding failed for store variant '{StoreVariant}'.", + sampleStoreOptions.CurrentKey + ); + break; + } + catch (ArgumentException ex) + { + logger.LogError( + ex, + "Sample data seeding failed for store variant '{StoreVariant}'.", + sampleStoreOptions.CurrentKey + ); + break; + } + catch (InvalidOperationException ex) + { + logger.LogError( + ex, + "Sample data seeding failed for store variant '{StoreVariant}'.", + sampleStoreOptions.CurrentKey + ); + break; + } + } +} + +await app.RunAsync(); + +static void ConfigureStoreOptions( + IServiceCollection services, + IConfiguration configuration, + SampleStoreOptions sampleStoreOptions +) +{ + switch (sampleStoreOptions.EventStore) + { + case SampleEventStoreKind.MongoDb: + services + .AddOptions() + .Configure(options => + options.Database = sampleStoreOptions.EventStoreDatabaseName ?? Platform.MongoDatabase + ); + break; + case SampleEventStoreKind.AzureStorage: + services + .AddOptions() + .Configure(options => + { + options.Table = $"EventStore{NormalizeAlphaNumeric(sampleStoreOptions.CurrentKey)}"; + options.Container = $"eventstore-{NormalizeKebab(sampleStoreOptions.CurrentKey)}"; + }); + services.PostConfigure(options => + options.ConnectionString = AzureStorageConnectionStringComposer.BuildEventStoreConnectionString( + configuration.GetConnectionString(sampleStoreOptions.EventStoreConnectionName), + configuration.GetConnectionString(Platform.AzureStorageBlob), + options.ConnectionString + ) + ); + break; + } + + if (sampleStoreOptions.QueryStore == SampleQueryStoreKind.MongoDb) + { + services + .AddOptions() + .Configure(options => + options.Database = sampleStoreOptions.QueryStoreDatabaseName ?? Platform.MongoDatabase + ); + } +} + +static void RegisterEventStore(IServiceCollection services, SampleStoreOptions sampleStoreOptions) +{ + switch (sampleStoreOptions.EventStore) + { + case SampleEventStoreKind.SqlServer: + services.AddSqlServerEventStore(sampleStoreOptions.EventStoreConnectionName); + break; + case SampleEventStoreKind.Postgres: + services.AddPostgresEventStore(sampleStoreOptions.EventStoreConnectionName); + break; + case SampleEventStoreKind.MongoDb: + services.AddMongoDBEventStore(sampleStoreOptions.EventStoreConnectionName); + break; + case SampleEventStoreKind.AzureStorage: + services.AddAzureStorageEventStore(sampleStoreOptions.EventStoreConnectionName); + break; + default: + throw new InvalidOperationException($"Unsupported event store '{sampleStoreOptions.EventStore}'."); + } +} + +static void RegisterQueryStore(IServiceCollection services, SampleStoreOptions sampleStoreOptions) +{ + switch (sampleStoreOptions.QueryStore) + { + case SampleQueryStoreKind.SqlServer: + services.AddSqlServerSnapshotQueryableEventStore(sampleStoreOptions.QueryStoreConnectionName); + break; + case SampleQueryStoreKind.Postgres: + services.AddPostgresSnapshotQueryableEventStore(sampleStoreOptions.QueryStoreConnectionName); + break; + case SampleQueryStoreKind.MongoDb: + services.AddMongoDBSnapshotQueryableEventStore(sampleStoreOptions.QueryStoreConnectionName); + break; + default: + throw new InvalidOperationException($"Unsupported query store '{sampleStoreOptions.QueryStore}'."); + } +} + +static void RegisterAdmin(IServiceCollection services, SampleStoreOptions sampleStoreOptions) +{ + if (!sampleStoreOptions.AdminApiAvailable) + return; + + services + .AddAuthentication(SampleAdminAuthenticationHandler.SchemeName) + .AddScheme( + SampleAdminAuthenticationHandler.SchemeName, + configureOptions: null + ); + services.AddAuthorizationBuilder().AddPurviewEventSourcingAdminPolicies(); + services.AddPurviewEventSourcingAdminSecurity(new SampleAdminPermissionProvider()); + services.AddPurviewEventSourcingAdminApi(options => options.RoutePrefix = sampleStoreOptions.AdminApiPath); + + switch (sampleStoreOptions.AdminStore) + { + case SampleAdminStoreKind.SqlServer: + services.AddPurviewEventSourcingAdminSqlServer(); + break; + case SampleAdminStoreKind.Postgres: + services.AddPurviewEventSourcingAdminPostgres(); + break; + case SampleAdminStoreKind.MongoDb: + services.AddPurviewEventSourcingAdminMongoDB( + sampleStoreOptions.AdminDatabaseName + ?? sampleStoreOptions.EventStoreDatabaseName + ?? sampleStoreOptions.QueryStoreDatabaseName + ?? Platform.MongoDatabase + ); + break; + case SampleAdminStoreKind.AzureStorage: + services.AddPurviewEventSourcingAdminAzureStorage(); + break; + default: + throw new InvalidOperationException($"Unsupported admin store '{sampleStoreOptions.AdminStore}'."); + } +} + +static string NormalizeAlphaNumeric(string value) => new([.. value.Where(char.IsLetterOrDigit)]); + +[SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase")] +static string NormalizeKebab(string value) +{ + var normalized = new string([ + .. value.ToLowerInvariant().Where(character => char.IsLetterOrDigit(character) || character == '-'), + ]); + + return string.IsNullOrWhiteSpace(normalized) ? "sample" : normalized; +} diff --git a/src/src/Samples.Web/Properties/AssemblyInfo.cs b/src/src/Samples.Web/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..f57d17db --- /dev/null +++ b/src/src/Samples.Web/Properties/AssemblyInfo.cs @@ -0,0 +1,4 @@ +using System.Runtime.CompilerServices; + +[assembly: InternalsVisibleTo("Samples.UnitTests")] +[assembly: InternalsVisibleTo("Samples.IntegrationTests")] diff --git a/src/src/EventSourcing.Samples.Web/Properties/launchSettings.json b/src/src/Samples.Web/Properties/launchSettings.json similarity index 100% rename from src/src/EventSourcing.Samples.Web/Properties/launchSettings.json rename to src/src/Samples.Web/Properties/launchSettings.json diff --git a/src/src/Samples.Web/Samples.Web.csproj b/src/src/Samples.Web/Samples.Web.csproj new file mode 100644 index 00000000..df165a7a --- /dev/null +++ b/src/src/Samples.Web/Samples.Web.csproj @@ -0,0 +1,32 @@ + + + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/src/EventSourcing.Samples.Web/Services/AggregateAuditService.cs b/src/src/Samples.Web/Services/AggregateAuditService.cs similarity index 98% rename from src/src/EventSourcing.Samples.Web/Services/AggregateAuditService.cs rename to src/src/Samples.Web/Services/AggregateAuditService.cs index e5601102..937ab8ea 100644 --- a/src/src/EventSourcing.Samples.Web/Services/AggregateAuditService.cs +++ b/src/src/Samples.Web/Services/AggregateAuditService.cs @@ -1,5 +1,6 @@ using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.Samples.Domain; +using Purview.EventSourcing.Samples.Domain.ReportUpload; namespace Purview.EventSourcing.Samples.Web.Services; diff --git a/src/src/EventSourcing.Samples.Web/Services/IProductImageService.cs b/src/src/Samples.Web/Services/IProductImageService.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Services/IProductImageService.cs rename to src/src/Samples.Web/Services/IProductImageService.cs diff --git a/src/src/EventSourcing.Samples.Web/Services/NullProductImageService.cs b/src/src/Samples.Web/Services/NullProductImageService.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Services/NullProductImageService.cs rename to src/src/Samples.Web/Services/NullProductImageService.cs diff --git a/src/src/EventSourcing.Samples.Web/Services/ProductImageService.cs b/src/src/Samples.Web/Services/ProductImageService.cs similarity index 100% rename from src/src/EventSourcing.Samples.Web/Services/ProductImageService.cs rename to src/src/Samples.Web/Services/ProductImageService.cs diff --git a/src/src/Samples.Web/Services/SampleAdminAuthenticationHandler.cs b/src/src/Samples.Web/Services/SampleAdminAuthenticationHandler.cs new file mode 100644 index 00000000..62ce398f --- /dev/null +++ b/src/src/Samples.Web/Services/SampleAdminAuthenticationHandler.cs @@ -0,0 +1,26 @@ +using System.Security.Claims; +using System.Text.Encodings.Web; +using Microsoft.AspNetCore.Authentication; +using Microsoft.Extensions.Options; + +namespace Purview.EventSourcing.Samples.Web.Services; + +sealed class SampleAdminAuthenticationHandler( + IOptionsMonitor options, + ILoggerFactory logger, + UrlEncoder encoder +) : AuthenticationHandler(options, logger, encoder) +{ + public const string SchemeName = "SampleAdmin"; + + protected override Task HandleAuthenticateAsync() + { + var identity = new ClaimsIdentity( + [new Claim(ClaimTypes.NameIdentifier, "sample-admin"), new Claim(ClaimTypes.Name, "Sample Admin")], + SchemeName + ); + + var ticket = new AuthenticationTicket(new ClaimsPrincipal(identity), SchemeName); + return Task.FromResult(AuthenticateResult.Success(ticket)); + } +} diff --git a/src/src/Samples.Web/Services/SampleAdminPermissionProvider.cs b/src/src/Samples.Web/Services/SampleAdminPermissionProvider.cs new file mode 100644 index 00000000..9ef80d8a --- /dev/null +++ b/src/src/Samples.Web/Services/SampleAdminPermissionProvider.cs @@ -0,0 +1,22 @@ +using System.Security.Claims; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Services; + +namespace Purview.EventSourcing.Samples.Web.Services; + +sealed class SampleAdminPermissionProvider : IAdminPermissionProvider +{ + static readonly IReadOnlyList Permissions = + [ + new(AdminFeature.SearchAggregates, AggregateType: null, Allowed: true), + new(AdminFeature.ViewAggregate, AggregateType: null, Allowed: true), + new(AdminFeature.ViewEvents, AggregateType: null, Allowed: true), + new(AdminFeature.ProjectPointInTime, AggregateType: null, Allowed: true), + new(AdminFeature.ExportEvents, AggregateType: null, Allowed: true), + ]; + + public Task> GetPermissionsAsync( + ClaimsPrincipal user, + CancellationToken cancellationToken + ) => Task.FromResult(Permissions); +} diff --git a/src/src/Samples.Web/appsettings.Development.json b/src/src/Samples.Web/appsettings.Development.json new file mode 100644 index 00000000..b06deb98 --- /dev/null +++ b/src/src/Samples.Web/appsettings.Development.json @@ -0,0 +1,12 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + }, + "ConnectionStrings": { + //"eventstore-sqlserver": "Server=localhost,1433;Database=EventSourcingSample;User Id=sa;Password=YourStrong@Passw0rd;TrustServerCertificate=true", + //"blob-storage": "UseDevelopmentStorage=true" + } +} diff --git a/src/src/Samples.Web/appsettings.json b/src/src/Samples.Web/appsettings.json new file mode 100644 index 00000000..10f68b8c --- /dev/null +++ b/src/src/Samples.Web/appsettings.json @@ -0,0 +1,9 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + }, + "AllowedHosts": "*" +} diff --git a/src/src/EventSourcing.Samples/Domain/CustomerAggregate.Appliers.cs b/src/src/Samples/Domain/CustomerAggregate.Appliers.cs similarity index 100% rename from src/src/EventSourcing.Samples/Domain/CustomerAggregate.Appliers.cs rename to src/src/Samples/Domain/CustomerAggregate.Appliers.cs diff --git a/src/src/EventSourcing.Samples/Domain/CustomerAggregate.Rules.cs b/src/src/Samples/Domain/CustomerAggregate.Rules.cs similarity index 100% rename from src/src/EventSourcing.Samples/Domain/CustomerAggregate.Rules.cs rename to src/src/Samples/Domain/CustomerAggregate.Rules.cs diff --git a/src/src/EventSourcing.Samples/Domain/CustomerAggregate.cs b/src/src/Samples/Domain/CustomerAggregate.cs similarity index 94% rename from src/src/EventSourcing.Samples/Domain/CustomerAggregate.cs rename to src/src/Samples/Domain/CustomerAggregate.cs index 07ebf2a8..b3d4492f 100644 --- a/src/src/EventSourcing.Samples/Domain/CustomerAggregate.cs +++ b/src/src/Samples/Domain/CustomerAggregate.cs @@ -1,5 +1,7 @@ +using System.ComponentModel.DataAnnotations; using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.Samples.ValueObjects; +using ZodSharp; namespace Purview.EventSourcing.Samples.Domain; @@ -8,12 +10,14 @@ namespace Purview.EventSourcing.Samples.Domain; /// Shows: single-property events, string manipulation, validation. /// [GenerateAggregate] +[ZodSchema] public sealed partial class CustomerAggregate : AggregateBase { public Name Name { get; private set; } public EmailAddress Email { get; private set; } + [StringLength(20)] public string? PhoneNumber { get; private set; } public bool IsActive { get; private set; } diff --git a/src/src/EventSourcing.Samples/Domain/InventoryAggregate.Rules.cs b/src/src/Samples/Domain/InventoryAggregate.Rules.cs similarity index 100% rename from src/src/EventSourcing.Samples/Domain/InventoryAggregate.Rules.cs rename to src/src/Samples/Domain/InventoryAggregate.Rules.cs diff --git a/src/src/EventSourcing.Samples/Domain/InventoryAggregate.cs b/src/src/Samples/Domain/InventoryAggregate.cs similarity index 100% rename from src/src/EventSourcing.Samples/Domain/InventoryAggregate.cs rename to src/src/Samples/Domain/InventoryAggregate.cs diff --git a/src/src/EventSourcing.Samples/Domain/LocationAggregate.Rules.cs b/src/src/Samples/Domain/LocationAggregate.Rules.cs similarity index 100% rename from src/src/EventSourcing.Samples/Domain/LocationAggregate.Rules.cs rename to src/src/Samples/Domain/LocationAggregate.Rules.cs diff --git a/src/src/EventSourcing.Samples/Domain/LocationAggregate.cs b/src/src/Samples/Domain/LocationAggregate.cs similarity index 100% rename from src/src/EventSourcing.Samples/Domain/LocationAggregate.cs rename to src/src/Samples/Domain/LocationAggregate.cs diff --git a/src/src/EventSourcing.Samples/Domain/OrderAggregate.Rules.cs b/src/src/Samples/Domain/OrderAggregate.Rules.cs similarity index 94% rename from src/src/EventSourcing.Samples/Domain/OrderAggregate.Rules.cs rename to src/src/Samples/Domain/OrderAggregate.Rules.cs index 5c7361b0..809a5f95 100644 --- a/src/src/EventSourcing.Samples/Domain/OrderAggregate.Rules.cs +++ b/src/src/Samples/Domain/OrderAggregate.Rules.cs @@ -1,5 +1,4 @@ -using Purview.EventSourcing; -using Purview.EventSourcing.Samples.ValueObjects; +using Purview.EventSourcing.Samples.ValueObjects; namespace Purview.EventSourcing.Samples.Domain; diff --git a/src/src/EventSourcing.Samples/Domain/OrderAggregate.cs b/src/src/Samples/Domain/OrderAggregate.cs similarity index 99% rename from src/src/EventSourcing.Samples/Domain/OrderAggregate.cs rename to src/src/Samples/Domain/OrderAggregate.cs index e449d2b3..de28bede 100644 --- a/src/src/EventSourcing.Samples/Domain/OrderAggregate.cs +++ b/src/src/Samples/Domain/OrderAggregate.cs @@ -1,5 +1,4 @@ using System.ComponentModel.DataAnnotations; -using Purview.EventSourcing; using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.Samples.ValueObjects; diff --git a/src/src/Samples/Domain/ReportUpload/Models.cs b/src/src/Samples/Domain/ReportUpload/Models.cs new file mode 100644 index 00000000..784fa413 --- /dev/null +++ b/src/src/Samples/Domain/ReportUpload/Models.cs @@ -0,0 +1,41 @@ +namespace Purview.EventSourcing.Samples.Domain.ReportUpload; + +public sealed class ParserReportSummary +{ + public required ParserDetails ParserDetails { get; init; } + + public required VulnerabilityDetails VulnerabilityDetails { get; init; } + + public required AssetDetails AssetDetails { get; init; } + + public required IEnumerable Projects { get; init; } = []; +} + +public sealed record ParserDetails(int TotalLines, int SuccessfulLines, int FailedLines, TimeSpan ProcessingTime) +{ + public bool HasFailures => FailedLines > 0; + + public bool TotalSuccess => SuccessfulLines == TotalLines; + + public bool TotalFailure => FailedLines == TotalLines; + + public bool PartialSuccess => SuccessfulLines > 0 && FailedLines > 0; + + public bool Successful => SuccessfulLines > 0 && FailedLines == 0; +} + +public sealed record VulnerabilityDetails( + int TotalVulnerabilities, + int UniqueVulnerabilities, + int CriticalVulnerabilities, + int HighVulnerabilities, + int MediumVulnerabilities, + int LowVulnerabilities +); + +public sealed record AssetDetails(Dictionary OperatingSystemDistribution) +{ + public int TotalAssets => OperatingSystemDistribution.Values.Sum(); +} + +public sealed record Project(string Name, string Version, string Team); diff --git a/src/src/Samples/Domain/ReportUpload/ReportUploadAggregate.Rules.cs b/src/src/Samples/Domain/ReportUpload/ReportUploadAggregate.Rules.cs new file mode 100644 index 00000000..bdf59027 --- /dev/null +++ b/src/src/Samples/Domain/ReportUpload/ReportUploadAggregate.Rules.cs @@ -0,0 +1,69 @@ +using Purview.EventSourcing.Guards; +using Purview.EventSourcing.Samples.Domain.ReportUpload.ReportUploadEvents; +using Purview.EventSourcing.Samples.ValueObjects; + +namespace Purview.EventSourcing.Samples.Domain.ReportUpload; + +partial class ReportUploadAggregate +{ + // Property rules + partial void OnOriginalFilenameChanging(ref string originalFilename) => originalFilename.Required(true); + + partial void OnFileHashChanging(ref string fileHash) => fileHash.Required(true); + + partial void OnSourceJsonBlobChanging(ref BlobUri sourceJsonBlob) => sourceJsonBlob.Required(); + + // Event rules + partial void OnRaisingCreatedEvent( + ref string originalFilename, + ref string fileHash, + ref BlobUri sourceJsonBlob, + ref UserCapture uploaded + ) => this.MustBeNew(); + + partial void OnUploadedChanging(ref UserCapture uploaded) + { + if (Details.CurrentVersion > 0 && Uploaded.IsEssentialChange(uploaded)) + throw new InvalidOperationException("Cannot change uploaded information after report creation."); + } + + partial void OnComputingMarkAsCompletedEvent( + ref ParserReportSummary? reportSummaryScalar, + ref ReportProcessingStatus status + ) => status = ReportProcessingStatus.Completed; + + partial void OnComputingMarkAsCompletedEvent( + ref ReportSummary? reportSummary, + ref ParserReportSummary? reportSummaryScalar, + ref ReportProcessingStatus status + ) => reportSummaryScalar = reportSummary?.Value; + + partial void OnRaisingMarkAsCompletedEvent(ref ReportSummary? reportSummary) => reportSummary.Required(); + + partial void OnComputingMarkAsFailedEvent( + ref ParserReportSummary? reportSummaryScalar, + ref ReportProcessingStatus status + ) => status = ReportProcessingStatus.Failed; + + partial void OnComputingMarkAsFailedEvent( + ref string? failureReason, + ref ReportSummary? reportSummary, + ref ParserReportSummary? reportSummaryScalar, + ref ReportProcessingStatus status + ) => reportSummaryScalar = reportSummary?.Value; + + partial void OnRaisingMarkAsFailedEvent(ref string? failureReason, ref ReportSummary? reportSummary) => + failureReason.Required(true); + + partial void OnAppliedMarkAsFailedEvent(MarkAsFailed @event) => ExcelReportBlobs = []; + + partial void OnRaisingReportProcessingStatusSetEvent(ref ReportProcessingStatus status) + { + if (status == ReportProcessingStatus.Completed) + throw new InvalidOperationException( + $"Use the {nameof(MarkAsComplete)} method to set the report as complete." + ); + else if (status == ReportProcessingStatus.Failed) + throw new InvalidOperationException($"Use the {nameof(MarkAsFailed)} method to set the report as failed."); + } +} diff --git a/src/src/Samples/Domain/ReportUpload/ReportUploadAggregate.cs b/src/src/Samples/Domain/ReportUpload/ReportUploadAggregate.cs new file mode 100644 index 00000000..df7b6aa3 --- /dev/null +++ b/src/src/Samples/Domain/ReportUpload/ReportUploadAggregate.cs @@ -0,0 +1,85 @@ +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Samples.ValueObjects; + +namespace Purview.EventSourcing.Samples.Domain.ReportUpload; + +[GenerateAggregate] +public sealed partial class ReportUploadAggregate +{ + public string OriginalFilename { get; private set; } = string.Empty; + + public string FileHash { get; private set; } = string.Empty; + + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Purview.EventSourcing.SourceGenerator", + "EVENTSTORE020", + Justification = "Sample aggregate does not execute deep SQL predicates over BlobUri.Value." + )] + public BlobUri SourceJsonBlob { get; private set; } = BlobUri.Empty; + + public EventStoreSet ExcelReportBlobs { get; private set; } = []; + + public UserCapture Uploaded { get; private set; } = UserCapture.Empty; + + public ReportProcessingStatus Status { get; private set; } = ReportProcessingStatus.None; + + public string? FailureReason { get; private set; } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Purview.EventSourcing.SourceGenerator", + "EVENTSTORE020", + Justification = "Query translation uses ReportSummaryScalar mirror for SQL-safe filtering." + )] + public ReportSummary? ReportSummary { get; private set; } + + public ParserReportSummary? ReportSummaryScalar { get; private set; } + + public ReportUploadAggregate MarkAsProcessing() => SetReportProcessingStatus(ReportProcessingStatus.Processing); + + public ReportUploadAggregate AddExcelReport(GuidObjectId projectId, BlobUri excelReportBlob) => + AddExcelReport(new ProjectBlobs(projectId, excelReportBlob)); + + // Event generation methods + [GenerateAggregateEvent(EventName = "MarkAsCompleted")] + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Purview.EventSourcing.SourceGenerator", + "EVENTSTORE016:Event parameter nullability differs from aggregate property", + Justification = "Required properties" + )] + public partial ReportUploadAggregate MarkAsComplete( + ReportSummary reportSummary, + [Computed] ParserReportSummary? reportSummaryScalar = null, + [Computed] ReportProcessingStatus status = default + ); + + [GenerateAggregateCollectionEvent(nameof(ExcelReportBlobs))] + private partial ReportUploadAggregate AddExcelReport(ProjectBlobs projectBlobs); + + [GenerateAggregateEvent(EventName = "MarkAsFailed")] + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Purview.EventSourcing.SourceGenerator", + "EVENTSTORE014:Event name overrides should be past tense" + )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Purview.EventSourcing.SourceGenerator", + "EVENTSTORE016:Event parameter nullability differs from aggregate property", + Justification = "Required properties" + )] + public partial ReportUploadAggregate MarkAsFailed( + string failureReason, + ReportSummary? reportSummary = null, + [Computed] ParserReportSummary? reportSummaryScalar = null, + [Computed] ReportProcessingStatus status = default + ); + + [GenerateAggregateEvent] + public partial ReportUploadAggregate Create( + string originalFilename, + string fileHash, + BlobUri sourceJsonBlob, + UserCapture uploaded + ); + + [GenerateAggregateEvent] + private partial ReportUploadAggregate SetReportProcessingStatus(ReportProcessingStatus status); +} diff --git a/src/src/EventSourcing.Samples/Domain/SnapshotValueObjectsAggregate.cs b/src/src/Samples/Domain/SnapshotValueObjectsAggregate.cs similarity index 100% rename from src/src/EventSourcing.Samples/Domain/SnapshotValueObjectsAggregate.cs rename to src/src/Samples/Domain/SnapshotValueObjectsAggregate.cs diff --git a/src/src/Samples/Domain/Validators/CustomerAggregateValidator.cs b/src/src/Samples/Domain/Validators/CustomerAggregateValidator.cs new file mode 100644 index 00000000..ec019053 --- /dev/null +++ b/src/src/Samples/Domain/Validators/CustomerAggregateValidator.cs @@ -0,0 +1,11 @@ +using FluentValidation; + +namespace Purview.EventSourcing.Samples.Domain.Validators; + +public sealed class CustomerAggregateValidator : AbstractValidator +{ + public CustomerAggregateValidator() + { + RuleFor(m => m.PhoneNumber).MaximumLength(20); + } +} diff --git a/src/src/EventSourcing.Samples/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs b/src/src/Samples/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs similarity index 58% rename from src/src/EventSourcing.Samples/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs rename to src/src/Samples/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs index 1e6c38e1..ddc68067 100644 --- a/src/src/EventSourcing.Samples/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs +++ b/src/src/Samples/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs @@ -1,4 +1,6 @@ using System.ComponentModel; +using Purview.EventSourcing.Samples.Domain; +using Purview.EventSourcing.Samples.Domain.Validators; using Purview.EventSourcing.Samples.Services; namespace Microsoft.Extensions.DependencyInjection; @@ -17,5 +19,19 @@ public IServiceCollection AddDomainServices() return services; } + + public IServiceCollection AddDomainZodValidators() + { + services.AddZodSharpAdapter(); + + return services; + } + + public IServiceCollection AddDomainFluentValidators() + { + services.AddFluentValidationAdapter(); + + return services; + } } } diff --git a/src/src/EventSourcing.Samples/Extensions/System/StringExtensions.cs b/src/src/Samples/Extensions/System/StringExtensions.cs similarity index 74% rename from src/src/EventSourcing.Samples/Extensions/System/StringExtensions.cs rename to src/src/Samples/Extensions/System/StringExtensions.cs index c64da727..2d345379 100644 --- a/src/src/EventSourcing.Samples/Extensions/System/StringExtensions.cs +++ b/src/src/Samples/Extensions/System/StringExtensions.cs @@ -7,8 +7,6 @@ public static class StringExtensions { extension(string? value) { - public string? OrNull() => string.IsNullOrWhiteSpace(value) ? null : value; - public string OrDefault() => value?.Trim() ?? string.Empty; } } diff --git a/src/src/Samples/Samples.csproj b/src/src/Samples/Samples.csproj new file mode 100644 index 00000000..092e79db --- /dev/null +++ b/src/src/Samples/Samples.csproj @@ -0,0 +1,20 @@ + + + Samples + Purview.EventSourcing.Samples + true + + + + + + + + + + diff --git a/src/src/EventSourcing.Samples/Services/CartCheckoutResult.cs b/src/src/Samples/Services/CartCheckoutResult.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/CartCheckoutResult.cs rename to src/src/Samples/Services/CartCheckoutResult.cs diff --git a/src/src/EventSourcing.Samples/Services/CartCheckoutService.cs b/src/src/Samples/Services/CartCheckoutService.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/CartCheckoutService.cs rename to src/src/Samples/Services/CartCheckoutService.cs diff --git a/src/src/EventSourcing.Samples/Services/CartItem.cs b/src/src/Samples/Services/CartItem.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/CartItem.cs rename to src/src/Samples/Services/CartItem.cs diff --git a/src/src/EventSourcing.Samples/Services/FulfilmentResult.cs b/src/src/Samples/Services/FulfilmentResult.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/FulfilmentResult.cs rename to src/src/Samples/Services/FulfilmentResult.cs diff --git a/src/src/EventSourcing.Samples/Services/ICartCheckoutService.cs b/src/src/Samples/Services/ICartCheckoutService.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/ICartCheckoutService.cs rename to src/src/Samples/Services/ICartCheckoutService.cs diff --git a/src/src/EventSourcing.Samples/Services/IOrderFulfillmentService.cs b/src/src/Samples/Services/IOrderFulfillmentService.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/IOrderFulfillmentService.cs rename to src/src/Samples/Services/IOrderFulfillmentService.cs diff --git a/src/src/EventSourcing.Samples/Services/ISeedDataService.cs b/src/src/Samples/Services/ISeedDataService.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/ISeedDataService.cs rename to src/src/Samples/Services/ISeedDataService.cs diff --git a/src/src/EventSourcing.Samples/Services/IStockTransferService.cs b/src/src/Samples/Services/IStockTransferService.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/IStockTransferService.cs rename to src/src/Samples/Services/IStockTransferService.cs diff --git a/src/src/EventSourcing.Samples/Services/OrderFulfillmentService.cs b/src/src/Samples/Services/OrderFulfillmentService.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/OrderFulfillmentService.cs rename to src/src/Samples/Services/OrderFulfillmentService.cs diff --git a/src/src/EventSourcing.Samples/Services/SeedDataService.cs b/src/src/Samples/Services/SeedDataService.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/SeedDataService.cs rename to src/src/Samples/Services/SeedDataService.cs diff --git a/src/src/EventSourcing.Samples/Services/StockTransferResult.cs b/src/src/Samples/Services/StockTransferResult.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/StockTransferResult.cs rename to src/src/Samples/Services/StockTransferResult.cs diff --git a/src/src/EventSourcing.Samples/Services/StockTransferService.cs b/src/src/Samples/Services/StockTransferService.cs similarity index 100% rename from src/src/EventSourcing.Samples/Services/StockTransferService.cs rename to src/src/Samples/Services/StockTransferService.cs diff --git a/src/src/EventSourcing.Samples/ValueObjects/BlobUri.cs b/src/src/Samples/ValueObjects/BlobUri.cs similarity index 88% rename from src/src/EventSourcing.Samples/ValueObjects/BlobUri.cs rename to src/src/Samples/ValueObjects/BlobUri.cs index 1bc1274f..9b80f0d0 100644 --- a/src/src/EventSourcing.Samples/ValueObjects/BlobUri.cs +++ b/src/src/Samples/ValueObjects/BlobUri.cs @@ -14,6 +14,4 @@ static partial void OnValidate(Uri value) if (value.IsAbsoluteUri) throw new ArgumentException("Only relative Uris to blob storage are valid"); } - - public static BlobUri Empty => Hydrate(null!); } diff --git a/src/src/EventSourcing.Samples/ValueObjects/CurrencyCode.cs b/src/src/Samples/ValueObjects/CurrencyCode.cs similarity index 100% rename from src/src/EventSourcing.Samples/ValueObjects/CurrencyCode.cs rename to src/src/Samples/ValueObjects/CurrencyCode.cs diff --git a/src/src/EventSourcing.Samples/ValueObjects/CustomerId.cs b/src/src/Samples/ValueObjects/CustomerId.cs similarity index 100% rename from src/src/EventSourcing.Samples/ValueObjects/CustomerId.cs rename to src/src/Samples/ValueObjects/CustomerId.cs diff --git a/src/src/EventSourcing.Samples/ValueObjects/EmailAddress.cs b/src/src/Samples/ValueObjects/EmailAddress.cs similarity index 94% rename from src/src/EventSourcing.Samples/ValueObjects/EmailAddress.cs rename to src/src/Samples/ValueObjects/EmailAddress.cs index f19d44e3..eeb1e680 100644 --- a/src/src/EventSourcing.Samples/ValueObjects/EmailAddress.cs +++ b/src/src/Samples/ValueObjects/EmailAddress.cs @@ -10,8 +10,6 @@ public readonly partial record struct EmailAddress public string Domain => Value.Split('@')[1]; - EmailAddress(string value) => Value = value; - [System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase")] static partial void OnNormalize(ref string value) => value = value?.Trim().ToLowerInvariant()!; diff --git a/src/src/Samples/ValueObjects/GuidObjectId.cs b/src/src/Samples/ValueObjects/GuidObjectId.cs new file mode 100644 index 00000000..f702e044 --- /dev/null +++ b/src/src/Samples/ValueObjects/GuidObjectId.cs @@ -0,0 +1,17 @@ +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Samples.ValueObjects; + +[Scalar] +public readonly partial record struct GuidObjectId +{ + public Guid Value { get; } + + static partial void OnValidate(Guid value) + { + if (value == Guid.Empty) + throw new ArgumentException("GuidObjectId must be a non-empty GUID.", nameof(value)); + } + + public override string ToString() => Value.ToString(); +} diff --git a/src/src/EventSourcing.Samples/ValueObjects/Money.cs b/src/src/Samples/ValueObjects/Money.cs similarity index 84% rename from src/src/EventSourcing.Samples/ValueObjects/Money.cs rename to src/src/Samples/ValueObjects/Money.cs index 2920dfe4..9803bb9b 100644 --- a/src/src/EventSourcing.Samples/ValueObjects/Money.cs +++ b/src/src/Samples/ValueObjects/Money.cs @@ -9,12 +9,6 @@ public readonly partial record struct Money public CurrencyCode Currency { get; } - Money(decimal amount, CurrencyCode currency) - { - Amount = amount; - Currency = currency; - } - partial void OnValidate(decimal amount, CurrencyCode currency) { if (amount < 0) diff --git a/src/src/EventSourcing.Samples/ValueObjects/Name.cs b/src/src/Samples/ValueObjects/Name.cs similarity index 100% rename from src/src/EventSourcing.Samples/ValueObjects/Name.cs rename to src/src/Samples/ValueObjects/Name.cs diff --git a/src/src/Samples/ValueObjects/ObjectId.cs b/src/src/Samples/ValueObjects/ObjectId.cs new file mode 100644 index 00000000..a43f24f0 --- /dev/null +++ b/src/src/Samples/ValueObjects/ObjectId.cs @@ -0,0 +1,17 @@ +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Samples.ValueObjects; + +[Scalar] +public readonly partial record struct ObjectId +{ + public string Value { get; } + + static partial void OnValidate(string value) + { + if (!Guid.TryParse(value, out _)) + throw new ArgumentException("ObjectId must be a valid GUID.", nameof(value)); + } + + public override string ToString() => Value; +} diff --git a/src/src/EventSourcing.Samples/ValueObjects/OrderStatus.cs b/src/src/Samples/ValueObjects/OrderStatus.cs similarity index 100% rename from src/src/EventSourcing.Samples/ValueObjects/OrderStatus.cs rename to src/src/Samples/ValueObjects/OrderStatus.cs diff --git a/src/src/EventSourcing.Samples/ValueObjects/OrderStatusCode.cs b/src/src/Samples/ValueObjects/OrderStatusCode.cs similarity index 100% rename from src/src/EventSourcing.Samples/ValueObjects/OrderStatusCode.cs rename to src/src/Samples/ValueObjects/OrderStatusCode.cs diff --git a/src/src/Samples/ValueObjects/ProjectBlobs.cs b/src/src/Samples/ValueObjects/ProjectBlobs.cs new file mode 100644 index 00000000..3ddb2702 --- /dev/null +++ b/src/src/Samples/ValueObjects/ProjectBlobs.cs @@ -0,0 +1,6 @@ +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Samples.ValueObjects; + +[ValueObject] +public readonly partial record struct ProjectBlobs(GuidObjectId ProjectId, BlobUri BlobUri); diff --git a/src/src/EventSourcing.Samples/ValueObjects/ProjectId.cs b/src/src/Samples/ValueObjects/ProjectId.cs similarity index 100% rename from src/src/EventSourcing.Samples/ValueObjects/ProjectId.cs rename to src/src/Samples/ValueObjects/ProjectId.cs diff --git a/src/src/EventSourcing.Samples/ValueObjects/ReportProcessingStatus.cs b/src/src/Samples/ValueObjects/ReportProcessingStatus.cs similarity index 90% rename from src/src/EventSourcing.Samples/ValueObjects/ReportProcessingStatus.cs rename to src/src/Samples/ValueObjects/ReportProcessingStatus.cs index d9955856..3cbd7274 100644 --- a/src/src/EventSourcing.Samples/ValueObjects/ReportProcessingStatus.cs +++ b/src/src/Samples/ValueObjects/ReportProcessingStatus.cs @@ -1,4 +1,4 @@ -using Purview.EventSourcing.Samples.Domain; +using Purview.EventSourcing.Samples.Domain.ReportUpload; using Purview.EventSourcing.Serialization; using Purview.EventSourcing.ValueObjects; @@ -10,6 +10,8 @@ public readonly partial record struct ReportProcessingStatus { public ReportProcessingStatusCode Value { get; } + ReportProcessingStatus(ReportProcessingStatusCode code) => Value = code; + public static ReportProcessingStatus Create( ReportProcessingStatusCode value, in ValueObjectContext context diff --git a/src/src/EventSourcing.Samples/ValueObjects/ReportProcessingStatusCode.cs b/src/src/Samples/ValueObjects/ReportProcessingStatusCode.cs similarity index 97% rename from src/src/EventSourcing.Samples/ValueObjects/ReportProcessingStatusCode.cs rename to src/src/Samples/ValueObjects/ReportProcessingStatusCode.cs index 8d4feb0c..bee8a4d6 100644 --- a/src/src/EventSourcing.Samples/ValueObjects/ReportProcessingStatusCode.cs +++ b/src/src/Samples/ValueObjects/ReportProcessingStatusCode.cs @@ -3,8 +3,12 @@ public enum ReportProcessingStatusCode { None = 0, + Uploaded = 1000, + Processing = 2000, + Completed = 3000, + Failed = 4000, } diff --git a/src/src/Samples/ValueObjects/ReportSummary.cs b/src/src/Samples/ValueObjects/ReportSummary.cs new file mode 100644 index 00000000..5c2565ca --- /dev/null +++ b/src/src/Samples/ValueObjects/ReportSummary.cs @@ -0,0 +1,10 @@ +using Purview.EventSourcing.Samples.Domain.ReportUpload; +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Samples.ValueObjects; + +[Scalar] +public sealed partial record class ReportSummary +{ + public ParserReportSummary Value { get; } +} diff --git a/src/src/EventSourcing.Samples/ValueObjects/StatusHistory.cs b/src/src/Samples/ValueObjects/StatusHistory.cs similarity index 100% rename from src/src/EventSourcing.Samples/ValueObjects/StatusHistory.cs rename to src/src/Samples/ValueObjects/StatusHistory.cs diff --git a/src/src/Samples/ValueObjects/UserCapture.cs b/src/src/Samples/ValueObjects/UserCapture.cs new file mode 100644 index 00000000..0a5d3cd6 --- /dev/null +++ b/src/src/Samples/ValueObjects/UserCapture.cs @@ -0,0 +1,10 @@ +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Samples.ValueObjects; + +[ValueObject] +public partial record struct UserCapture(UserDetails User, DateTimeOffset OccurredAt) +{ + public readonly bool IsEssentialChange(UserCapture userDetails) => + OccurredAt != userDetails.OccurredAt || User.Id != userDetails.User.Id; +} diff --git a/src/src/Samples/ValueObjects/UserDetails.cs b/src/src/Samples/ValueObjects/UserDetails.cs new file mode 100644 index 00000000..5d399e95 --- /dev/null +++ b/src/src/Samples/ValueObjects/UserDetails.cs @@ -0,0 +1,30 @@ +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.Samples.ValueObjects; + +[ValueObject] +public partial record struct UserDetails(Guid Id, string? DisplayName, bool IsActive = true) +{ + public static readonly Guid LocalUserId = Guid.Parse("10000000-0000-0000-0000-000000000000"); + + static partial void OnNormalize(ref Guid id, ref string? displayName, ref bool isActive) + { + if (!isActive) + { + if (string.IsNullOrWhiteSpace(displayName)) + displayName = null; + } + } + + readonly partial void OnValidate(Guid id, string? displayName, bool isActive) + { + if (id == Guid.Empty) + throw new ArgumentException("Id must be a valid GUID.", nameof(id)); + + if (isActive && string.IsNullOrWhiteSpace(displayName)) + throw new ArgumentException( + "DisplayName cannot be null or empty when a user is active.", + nameof(displayName) + ); + } +} diff --git a/src/src/EventSourcing.Samples/ValueObjects/UserDetails2.cs b/src/src/Samples/ValueObjects/UserDetails2.cs similarity index 100% rename from src/src/EventSourcing.Samples/ValueObjects/UserDetails2.cs rename to src/src/Samples/ValueObjects/UserDetails2.cs diff --git a/src/src/EventSourcing.SourceGenerator/AggregateSourceGenerator.cs b/src/src/SourceGenerator/AggregateSourceGenerator.cs similarity index 91% rename from src/src/EventSourcing.SourceGenerator/AggregateSourceGenerator.cs rename to src/src/SourceGenerator/AggregateSourceGenerator.cs index d8111ee9..eab63108 100644 --- a/src/src/EventSourcing.SourceGenerator/AggregateSourceGenerator.cs +++ b/src/src/SourceGenerator/AggregateSourceGenerator.cs @@ -61,6 +61,10 @@ public void Initialize(IncrementalGeneratorInitializationContext context) "GenerateAggregateDefaultsAttribute.g.cs", EmbeddedResources.LoadTemplate("GenerateAggregateDefaultsAttribute") ); + ctx.AddSource( + "GenerateAggregateDefaultBaseAttribute.g.cs", + EmbeddedResources.LoadTemplate("GenerateAggregateDefaultBaseAttribute") + ); ctx.AddSource( "GenerateAggregateEventAttribute.g.cs", EmbeddedResources.LoadTemplate("GenerateAggregateEventAttribute") @@ -423,6 +427,19 @@ CancellationToken ct if (propertySymbol.IsStatic || propertySymbol.IsIndexer || propertySymbol.IsImplicitlyDeclared) continue; + if (TryGetComplexScalarValueType(propertySymbol.Type, out var scalarValueTypeDisplayName)) + { + diagnostics.Add( + Diagnostic.Create( + GeneratorDiagnostics.ScalarComplexValueMayNotTranslateInSqlSnapshots, + propertySymbol.Locations.FirstOrDefault(), + propertySymbol.Name, + classSymbol.Name, + scalarValueTypeDisplayName + ) + ); + } + propertySymbolsByName[propertySymbol.Name] = propertySymbol; if (propertySymbol.SetMethod is null) @@ -482,6 +499,7 @@ member is IMethodSymbol methodSymbol var methods = new List(); var invalidMethods = new List(); var methodsByEventType = new Dictionary<(string EventNamespace, string EventName), IMethodSymbol>(); + var methodsBySchemaVersion = new Dictionary(); foreach (var methodSymbol in attributedMethods) { @@ -554,10 +572,89 @@ out var methodInfo continue; } + if (methodsBySchemaVersion.TryGetValue(methodInfo.Version, out var existingSchemaVersionMethod)) + { + if (methodInfo.IsSchemaVersionExplicit && existingSchemaVersionMethod.IsExplicit) + { + diagnostics.Add( + Diagnostic.Create( + GeneratorDiagnostics.DuplicateEventSchemaVersionOnAggregate, + methodSymbol.Locations.FirstOrDefault(), + methodSymbol.Name, + classSymbol.Name, + methodInfo.Version, + existingSchemaVersionMethod.Symbol.Name + ) + ); + diagnostics.Add( + Diagnostic.Create( + GeneratorDiagnostics.DuplicateEventSchemaVersionOnAggregate, + existingSchemaVersionMethod.Symbol.Locations.FirstOrDefault(), + existingSchemaVersionMethod.Symbol.Name, + classSymbol.Name, + methodInfo.Version, + methodSymbol.Name + ) + ); + + if ( + TryCreateInvalidMethodStub( + methodSymbol, + [GeneratorDiagnostics.DuplicateEventSchemaVersionOnAggregate.Id], + out var invalidMethod, + ct + ) + ) + invalidMethods.Add(invalidMethod); + + continue; + } + + if (methodInfo.IsSchemaVersionExplicit && !existingSchemaVersionMethod.IsExplicit) + methodsBySchemaVersion[methodInfo.Version] = (methodSymbol, true); + } + else + { + methodsBySchemaVersion[methodInfo.Version] = (methodSymbol, methodInfo.IsSchemaVersionExplicit); + } + methodsByEventType[eventTypeKey] = methodSymbol; methods.Add(methodInfo); } + var explicitSchemaVersions = methods + .Where(static method => method.IsSchemaVersionExplicit) + .Select(static method => method.Version) + .Distinct() + .OrderBy(static version => version) + .ToArray(); + + if (explicitSchemaVersions.Length >= 2) + { + var missingSchemaVersions = new List(); + for (var index = 1; index < explicitSchemaVersions.Length; index++) + { + var previousVersion = explicitSchemaVersions[index - 1]; + var currentVersion = explicitSchemaVersions[index]; + + for (var missingVersion = previousVersion + 1; missingVersion < currentVersion; missingVersion++) + missingSchemaVersions.Add(missingVersion); + } + + if (missingSchemaVersions.Count > 0) + { + diagnostics.Add( + Diagnostic.Create( + GeneratorDiagnostics.EventSchemaVersionsShouldBeContiguous, + syntax.Identifier.GetLocation(), + classSymbol.Name, + string.Join(", ", explicitSchemaVersions), + string.Join(", ", missingSchemaVersions) + ) + ); + } + } + return new AggregateGenerationResult( canGenerate ? new AggregateInfo( @@ -609,7 +706,7 @@ static EventTypeValidationResult GetEventTypeValidationResult(GeneratorSyntaxCon : new EventTypeValidationResult([ Diagnostic.Create( GeneratorDiagnostics.EventNameShouldBePastTense, - typeDeclaration.GetLocation(), + typeDeclaration.Identifier.GetLocation(), displayName ), ]); @@ -730,6 +827,7 @@ void ReportUnsupportedSignature(string reason) return false; var version = 1; + var hasExplicitVersion = false; var eventName = string.Empty; var hasExplicitEventName = false; string? eventNamespaceOverride = null; @@ -741,6 +839,7 @@ void ReportUnsupportedSignature(string reason) if (namedArgument.Key == "Version" && namedArgument.Value.Value is int explicitVersion) { version = explicitVersion; + hasExplicitVersion = true; continue; } @@ -762,6 +861,20 @@ void ReportUnsupportedSignature(string reason) } } + if (version < 1) + { + diagnostics.Add( + Diagnostic.Create( + GeneratorDiagnostics.EventSchemaVersionMustBePositive, + methodLocation, + methodSymbol.Name, + classSymbol.Name, + version + ) + ); + hasErrors = true; + } + var parameters = new List(); CollectionEventInfo? collectionEvent = null; if (isCollectionEvent) @@ -1041,6 +1154,7 @@ out collectionEvent returnKind, methodSymbol.DeclaredAccessibility, version, + hasExplicitVersion, manualApply, collectionEvent ); @@ -1764,5 +1878,56 @@ typeSymbol is INamedTypeSymbol namedType && namedType.IsGenericType && namedType.OriginalDefinition.ToDisplayString() is EventStoreListMetadataName or EventStoreSetMetadataName; + static bool TryGetComplexScalarValueType(ITypeSymbol typeSymbol, out string valueTypeDisplayName) + { + valueTypeDisplayName = string.Empty; + + if (typeSymbol is not INamedTypeSymbol namedType) + return false; + + if (!HasAttribute(namedType, ScalarAttributeMetadataName)) + return false; + + var valueProperty = namedType + .GetMembers("Value") + .OfType() + .FirstOrDefault(static property => property.GetMethod is not null && !property.IsStatic); + + if (valueProperty is null) + return false; + + if (IsSimpleQueryScalarType(valueProperty.Type)) + return false; + + valueTypeDisplayName = valueProperty.Type.ToDisplayString( + SymbolDisplayFormat.FullyQualifiedFormat.WithMiscellaneousOptions( + SymbolDisplayFormat.FullyQualifiedFormat.MiscellaneousOptions + | SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier + ) + ); + return true; + } + + static bool IsSimpleQueryScalarType(ITypeSymbol typeSymbol) + { + if (typeSymbol.TypeKind == TypeKind.Enum) + return true; + + if (typeSymbol.SpecialType is not SpecialType.None) + return true; + + if (typeSymbol is not INamedTypeSymbol namedType) + return false; + + var fullyQualifiedName = namedType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat); + return fullyQualifiedName + is "global::System.Guid" + or "global::System.DateTime" + or "global::System.DateTimeOffset" + or "global::System.TimeSpan" + or "global::System.DateOnly" + or "global::System.TimeOnly"; + } + void ILogSupport.SetLogOutput(Action action) => _logger = new GenerationLogger(action); } diff --git a/src/src/EventSourcing.SourceGenerator/EventVerbMap.cs b/src/src/SourceGenerator/EventVerbMap.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/EventVerbMap.cs rename to src/src/SourceGenerator/EventVerbMap.cs diff --git a/src/src/EventSourcing.SourceGenerator/GeneratorDiagnostics.cs b/src/src/SourceGenerator/GeneratorDiagnostics.cs similarity index 85% rename from src/src/EventSourcing.SourceGenerator/GeneratorDiagnostics.cs rename to src/src/SourceGenerator/GeneratorDiagnostics.cs index e584bc42..d1fd9cfa 100644 --- a/src/src/EventSourcing.SourceGenerator/GeneratorDiagnostics.cs +++ b/src/src/SourceGenerator/GeneratorDiagnostics.cs @@ -123,6 +123,42 @@ static class GeneratorDiagnostics isEnabledByDefault: true ); + public static readonly DiagnosticDescriptor ScalarComplexValueMayNotTranslateInSqlSnapshots = new( + id: "EVENTSTORE020", + title: "Complex scalar Value paths may not translate in SQL snapshot queries", + messageFormat: "Aggregate property '{0}' on '{1}' is a [Scalar] whose Value type '{2}' is complex. Deep SQL predicates through '.Value' are typically non-translatable; prefer a computed mirror property for query scenarios.", + category: Category, + defaultSeverity: DiagnosticSeverity.Warning, + isEnabledByDefault: true + ); + + public static readonly DiagnosticDescriptor EventSchemaVersionMustBePositive = new( + id: "EVENTSTORE021", + title: "Event schema version must be positive", + messageFormat: "Method '{0}' on aggregate '{1}' declares schema version '{2}'. Schema versions must be greater than or equal to 1.", + category: Category, + defaultSeverity: DiagnosticSeverity.Error, + isEnabledByDefault: true + ); + + public static readonly DiagnosticDescriptor DuplicateEventSchemaVersionOnAggregate = new( + id: "EVENTSTORE022", + title: "Duplicate event schema version on aggregate", + messageFormat: "Method '{0}' on aggregate '{1}' reuses schema version '{2}', which is already used by method '{3}'. Event schema versions on a single aggregate must be unique.", + category: Category, + defaultSeverity: DiagnosticSeverity.Error, + isEnabledByDefault: true + ); + + public static readonly DiagnosticDescriptor EventSchemaVersionsShouldBeContiguous = new( + id: "EVENTSTORE023", + title: "Explicit event schema versions should be contiguous", + messageFormat: "Aggregate '{0}' declares explicit event schema versions [{1}] with missing versions [{2}]. Explicit schema versions should be contiguous.", + category: Category, + defaultSeverity: DiagnosticSeverity.Warning, + isEnabledByDefault: true + ); + public static readonly DiagnosticDescriptor AggregateMethodShouldBeVerbPhrase = new( id: "EVENTSTORE012", title: "Aggregate methods should be verb phrases", diff --git a/src/src/EventSourcing.SourceGenerator/Helpers/CodeGenHelpers.cs b/src/src/SourceGenerator/Helpers/CodeGenHelpers.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Helpers/CodeGenHelpers.cs rename to src/src/SourceGenerator/Helpers/CodeGenHelpers.cs diff --git a/src/src/EventSourcing.SourceGenerator/Helpers/EmitHelper.cs b/src/src/SourceGenerator/Helpers/EmitHelper.cs similarity index 99% rename from src/src/EventSourcing.SourceGenerator/Helpers/EmitHelper.cs rename to src/src/SourceGenerator/Helpers/EmitHelper.cs index 7169fb84..67122dce 100644 --- a/src/src/EventSourcing.SourceGenerator/Helpers/EmitHelper.cs +++ b/src/src/SourceGenerator/Helpers/EmitHelper.cs @@ -184,12 +184,7 @@ static void GenerateJsonSerializationSupport(StringBuilder sb, AggregateInfo inf sb.AppendLine(); } - static void GenerateApplyMethod( - StringBuilder sb, - AggregateInfo info, - AggregateEventMethodInfo method, - string indent - ) + static void GenerateApplyMethod(StringBuilder sb, AggregateInfo _, AggregateEventMethodInfo method, string indent) { if (method.ManualApply) { diff --git a/src/src/EventSourcing.SourceGenerator/Helpers/IsExternalInit.cs b/src/src/SourceGenerator/Helpers/IsExternalInit.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Helpers/IsExternalInit.cs rename to src/src/SourceGenerator/Helpers/IsExternalInit.cs diff --git a/src/src/EventSourcing.SourceGenerator/Helpers/LoggingSupport.cs b/src/src/SourceGenerator/Helpers/LoggingSupport.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Helpers/LoggingSupport.cs rename to src/src/SourceGenerator/Helpers/LoggingSupport.cs diff --git a/src/src/EventSourcing.SourceGenerator/Records.cs b/src/src/SourceGenerator/Records.cs similarity index 96% rename from src/src/EventSourcing.SourceGenerator/Records.cs rename to src/src/SourceGenerator/Records.cs index b1d405aa..3e3fe529 100644 --- a/src/src/EventSourcing.SourceGenerator/Records.cs +++ b/src/src/SourceGenerator/Records.cs @@ -47,6 +47,7 @@ sealed class AggregateEventMethodInfo( EventMethodReturnKind returnKind, Accessibility methodAccessibility, int version = 1, + bool isSchemaVersionExplicit = false, bool manualApply = false, CollectionEventInfo? collectionEvent = null ) @@ -71,6 +72,11 @@ sealed class AggregateEventMethodInfo( /// public int Version { get; } = version; + /// + /// Indicates whether was explicitly configured on the event attribute. + /// + public bool IsSchemaVersionExplicit { get; } = isSchemaVersionExplicit; + /// /// Indicates whether Apply(...) implementation is user-supplied and should not be auto-generated. /// diff --git a/src/src/SourceGenerator/Sdk/Sdk.props b/src/src/SourceGenerator/Sdk/Sdk.props new file mode 100644 index 00000000..859f64e5 --- /dev/null +++ b/src/src/SourceGenerator/Sdk/Sdk.props @@ -0,0 +1,7 @@ + + + + Specifies whether to disable the Purview EventSourcing source generators. + + + diff --git a/src/src/EventSourcing.SourceGenerator/EventSourcing.SourceGenerator.csproj b/src/src/SourceGenerator/SourceGenerator.csproj similarity index 71% rename from src/src/EventSourcing.SourceGenerator/EventSourcing.SourceGenerator.csproj rename to src/src/SourceGenerator/SourceGenerator.csproj index f84f5ed6..53594109 100644 --- a/src/src/EventSourcing.SourceGenerator/EventSourcing.SourceGenerator.csproj +++ b/src/src/SourceGenerator/SourceGenerator.csproj @@ -1,17 +1,21 @@  - netstandard2.0 true true - Generated true - - symbols.nupkg - $(TargetsForTfmSpecificDebugSymbolsInPackage);PackSourceGeneratorSymbols true $(NoWarn);CS8632;RS1035;RS1036;RS2008 + netstandard2.0 + false + false + Purview.EventSourcing.SourceGeneration + + + + + all @@ -21,6 +25,7 @@ all + diff --git a/src/src/EventSourcing.SourceGenerator/Templates/EmbeddedResources.cs b/src/src/SourceGenerator/Templates/EmbeddedResources.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Templates/EmbeddedResources.cs rename to src/src/SourceGenerator/Templates/EmbeddedResources.cs diff --git a/src/src/EventSourcing.SourceGenerator/Templates/Sources/AggregatePropertyAttribute.cs b/src/src/SourceGenerator/Templates/Sources/AggregatePropertyAttribute.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Templates/Sources/AggregatePropertyAttribute.cs rename to src/src/SourceGenerator/Templates/Sources/AggregatePropertyAttribute.cs diff --git a/src/src/EventSourcing.SourceGenerator/Templates/Sources/ComputedAttribute.cs b/src/src/SourceGenerator/Templates/Sources/ComputedAttribute.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Templates/Sources/ComputedAttribute.cs rename to src/src/SourceGenerator/Templates/Sources/ComputedAttribute.cs diff --git a/src/src/EventSourcing.SourceGenerator/Templates/Sources/GenerateAggregateAttribute.cs b/src/src/SourceGenerator/Templates/Sources/GenerateAggregateAttribute.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Templates/Sources/GenerateAggregateAttribute.cs rename to src/src/SourceGenerator/Templates/Sources/GenerateAggregateAttribute.cs diff --git a/src/src/EventSourcing.SourceGenerator/Templates/Sources/GenerateAggregateCollectionEventAttribute.cs b/src/src/SourceGenerator/Templates/Sources/GenerateAggregateCollectionEventAttribute.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Templates/Sources/GenerateAggregateCollectionEventAttribute.cs rename to src/src/SourceGenerator/Templates/Sources/GenerateAggregateCollectionEventAttribute.cs diff --git a/src/src/SourceGenerator/Templates/Sources/GenerateAggregateDefaultBaseAttribute.cs b/src/src/SourceGenerator/Templates/Sources/GenerateAggregateDefaultBaseAttribute.cs new file mode 100644 index 00000000..ac38576e --- /dev/null +++ b/src/src/SourceGenerator/Templates/Sources/GenerateAggregateDefaultBaseAttribute.cs @@ -0,0 +1,25 @@ +// + +#nullable enable + +namespace Purview.EventSourcing.Aggregates; + +/// +/// Specifies the default base class for all aggregates in the assembly. +/// The specified type must inherit from AggregateBase. +/// This attribute can be applied at the assembly level to set a global default. +/// +[global::System.AttributeUsage(global::System.AttributeTargets.Assembly)] +public sealed class GenerateAggregateDefaultBaseAttribute : global::System.Attribute +{ + /// + /// The default base class type for aggregates. Must inherit from AggregateBase. + /// If null, AggregateBase is used as the default. + /// + public global::System.Type? BaseType { get; } + + public GenerateAggregateDefaultBaseAttribute(global::System.Type? baseType = null) + { + BaseType = baseType; + } +} diff --git a/src/src/EventSourcing.SourceGenerator/Templates/Sources/GenerateAggregateDefaultsAttribute.cs b/src/src/SourceGenerator/Templates/Sources/GenerateAggregateDefaultsAttribute.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Templates/Sources/GenerateAggregateDefaultsAttribute.cs rename to src/src/SourceGenerator/Templates/Sources/GenerateAggregateDefaultsAttribute.cs diff --git a/src/src/EventSourcing.SourceGenerator/Templates/Sources/GenerateAggregateEventAttribute.cs b/src/src/SourceGenerator/Templates/Sources/GenerateAggregateEventAttribute.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Templates/Sources/GenerateAggregateEventAttribute.cs rename to src/src/SourceGenerator/Templates/Sources/GenerateAggregateEventAttribute.cs diff --git a/src/src/SourceGenerator/Templates/Sources/GenerateValueObjectDefaultsAttribute.cs b/src/src/SourceGenerator/Templates/Sources/GenerateValueObjectDefaultsAttribute.cs new file mode 100644 index 00000000..e9581161 --- /dev/null +++ b/src/src/SourceGenerator/Templates/Sources/GenerateValueObjectDefaultsAttribute.cs @@ -0,0 +1,25 @@ +// + +#nullable enable + +namespace Purview.EventSourcing.Serialization; + +/// +/// Specifies assembly-level defaults for value object code generation. +/// These defaults can be overridden on individual [ValueObject] attributes. +/// +[global::System.AttributeUsage(global::System.AttributeTargets.Assembly)] +public sealed class GenerateValueObjectDefaultsAttribute : global::System.Attribute +{ + /// + /// Gets or sets whether parameterless constructors should be generated for value objects. + /// When true, generates a private parameterless constructor for EF Core compatibility. + /// Individual [ValueObject] attributes can override this setting. + /// Default: true + /// + public bool GenerateConstructor { get; init; } = true; + + public GenerateValueObjectDefaultsAttribute() + { + } +} diff --git a/src/src/EventSourcing.SourceGenerator/Templates/Sources/MetadataAttribute.cs b/src/src/SourceGenerator/Templates/Sources/MetadataAttribute.cs similarity index 100% rename from src/src/EventSourcing.SourceGenerator/Templates/Sources/MetadataAttribute.cs rename to src/src/SourceGenerator/Templates/Sources/MetadataAttribute.cs diff --git a/src/src/EventSourcing.SourceGenerator/ValueObjectSourceGenerator.cs b/src/src/SourceGenerator/ValueObjectSourceGenerator.cs similarity index 87% rename from src/src/EventSourcing.SourceGenerator/ValueObjectSourceGenerator.cs rename to src/src/SourceGenerator/ValueObjectSourceGenerator.cs index 9b26da97..dda9511b 100644 --- a/src/src/EventSourcing.SourceGenerator/ValueObjectSourceGenerator.cs +++ b/src/src/SourceGenerator/ValueObjectSourceGenerator.cs @@ -69,6 +69,7 @@ CancellationToken cancellationToken return new ValueObjectGenerationResult(null, null, [.. diagnostics]); } + var assemblyDefaults = GetAssemblyValueObjectDefaults(context.SemanticModel.Compilation); var scalarOptions = ScalarOptions.From(attributes, ScalarAttributeName); var scalarProperty = typeSymbol .GetMembers(scalarOptions.PropertyName) @@ -145,7 +146,12 @@ CancellationToken cancellationToken return new ValueObjectGenerationResult(null, null, [.. diagnostics]); } - var valueObjectOptions = ValueObjectOptions.From(attributes, ValueObjectAttributeName); + var assemblyDefaults = GetAssemblyValueObjectDefaults(context.SemanticModel.Compilation); + var valueObjectOptions = ValueObjectOptions.From( + attributes, + ValueObjectAttributeName, + assemblyDefaults.GenerateConstructor + ); var typeModel = BuildTypeModel(typeSymbol); if (typeModel is null) return new ValueObjectGenerationResult(null, null, [.. diagnostics]); @@ -313,8 +319,12 @@ List diagnostics $"{indent}[global::System.Text.Json.Serialization.JsonConverter(typeof({typeModel.Name}JsonConverter))]" ); + var scalarSelfEquatableInterface = + typeSymbol.TypeKind == TypeKind.Struct && !ImplementsSelfEquatable(typeSymbol) + ? $", global::System.IEquatable<{typeName}>" + : string.Empty; sb.AppendLine( - $"{indent}{typeModel.DeclarationPrefix} : global::Purview.EventSourcing.ValueObjects.IScalarValueObject<{typeName}, {scalarTypeName}>, global::System.IComparable<{typeName}>, global::System.IComparable<{scalarTypeName}>, global::System.IComparable" + $"{indent}{typeModel.DeclarationPrefix} : global::Purview.EventSourcing.ValueObjects.IScalarValueObject<{typeName}, {scalarTypeName}>{scalarSelfEquatableInterface}, global::System.IComparable<{typeName}>, global::System.IComparable<{scalarTypeName}>, global::System.IComparable" ); sb.AppendLine($"{indent}{{"); @@ -633,6 +643,11 @@ bool ctorExists includeRef: true ); + // Check if parameterless constructor already exists + var parameterlessCtorExists = typeSymbol + .Constructors.Where(static ctor => !ctor.IsStatic) + .Any(ctor => ctor.Parameters.Length == 0 && !ctor.IsImplicitlyDeclared); + var hydrateFactoryName = options.DeserializationMode == StrictModeName ? "Create" : "Hydrate"; StringBuilder sb = new(); @@ -652,8 +667,12 @@ bool ctorExists $"{indent}[global::System.Text.Json.Serialization.JsonConverter(typeof({typeModel.Name}JsonConverter))]" ); + var valueObjectSelfEquatableInterface = + typeSymbol.TypeKind == TypeKind.Struct && !ImplementsSelfEquatable(typeSymbol) + ? $", global::System.IEquatable<{typeName}>" + : string.Empty; sb.AppendLine( - $"{indent}{typeModel.DeclarationPrefix} : global::Purview.EventSourcing.ValueObjects.IValueObject<{typeName}>, global::System.IComparable<{typeName}>, global::System.IComparable" + $"{indent}{typeModel.DeclarationPrefix} : global::Purview.EventSourcing.ValueObjects.IValueObject<{typeName}>{valueObjectSelfEquatableInterface}, global::System.IComparable<{typeName}>, global::System.IComparable" ); sb.AppendLine($"{indent}{{"); @@ -696,10 +715,14 @@ bool ctorExists ", ", propertyTypeNames.Zip(propertyNames, static (type, name) => $"{type} {ToCamelCase(name)}") ); + var validateReadOnly = + typeSymbol.TypeKind == TypeKind.Struct + && IsComplexHookReadOnly(typeSymbol, "OnValidate", propertyNames.Length); + var readOnlyPrefix = validateReadOnly ? "readonly " : string.Empty; sb.AppendLine( $"{indent}\t[global::System.Diagnostics.CodeAnalysis.SuppressMessage(\"Performance\", \"CA1822:Mark members as static\")]" ); - sb.AppendLine($"{indent}\tpartial void OnValidate({validateParams});"); + sb.AppendLine($"{indent}\t{readOnlyPrefix}partial void OnValidate({validateParams});"); sb.AppendLine(); } @@ -729,7 +752,7 @@ bool ctorExists sb.AppendLine(); } - if (!ctorExists) + if (!ctorExists && properties.Length > 0) { var ctorParams = string.Join( ", ", @@ -745,6 +768,32 @@ bool ctorExists sb.AppendLine($"{indent} }}"); } + if ( + options.GenerateConstructor + && !parameterlessCtorExists + && TryGetEfConstructorArguments(typeSymbol, properties, out var efCtorArguments) + ) + { + var efCtorAccessibility = typeSymbol.TypeKind == TypeKind.Struct ? "public" : "private"; + sb.AppendLine(); + sb.AppendLine($"{indent}\t/// "); + sb.AppendLine($"{indent}\t/// Parameterless constructor for EF Core deserialization."); + sb.AppendLine( + $"{indent}\t/// This constructor is required to work around EF Core's ConstructorBindingConvention," + ); + sb.AppendLine($"{indent}\t/// which cannot bind complex type parameters during JSON deserialization."); + sb.AppendLine( + $"{indent}\t/// EF Core uses this parameterless constructor to instantiate the value object," + ); + sb.AppendLine($"{indent}\t/// then sets properties directly from the JSON payload."); + sb.AppendLine($"{indent}\t/// "); + sb.AppendLine( + $@"{indent} {efCtorAccessibility} {typeModel.Name}() : this({efCtorArguments}) +{indent} {{" + ); + sb.AppendLine($"{indent} }}"); + } + if (!equalsSelfExists) { sb.AppendLine(); @@ -924,12 +973,39 @@ static bool ConstructorMatches(IMethodSymbol constructor, IPropertySymbol[] prop return true; } - static bool IsValueObjectPropertyCandidate(INamedTypeSymbol typeSymbol, IPropertySymbol property) + static bool TryGetEfConstructorArguments( + INamedTypeSymbol typeSymbol, + IPropertySymbol[] properties, + out string arguments + ) { - if (!property.IsImplicitlyDeclared) + if (properties.Length > 0) + { + arguments = string.Join(", ", properties.Select(static property => GetEmptyValueExpression(property.Type))); return true; + } - return typeSymbol.IsRecord + var parameterizedConstructors = typeSymbol + .Constructors.Where(static ctor => !ctor.IsStatic && ctor.Parameters.Length > 0) + .ToArray(); + + if (parameterizedConstructors.Length == 1) + { + arguments = string.Join( + ", ", + parameterizedConstructors[0] + .Parameters.Select(static parameter => GetEmptyValueExpression(parameter.Type)) + ); + return true; + } + + arguments = string.Empty; + return false; + } + + static bool IsValueObjectPropertyCandidate(INamedTypeSymbol typeSymbol, IPropertySymbol property) => + !property.IsImplicitlyDeclared + || typeSymbol.IsRecord && typeSymbol .InstanceConstructors.Where(static ctor => !ctor.IsStatic) .SelectMany(static ctor => ctor.Parameters) @@ -937,7 +1013,6 @@ static bool IsValueObjectPropertyCandidate(INamedTypeSymbol typeSymbol, IPropert SymbolEqualityComparer.Default.Equals(parameter.Type, property.Type) && string.Equals(parameter.Name, property.Name, StringComparison.OrdinalIgnoreCase) ); - } static bool HasAttribute(INamedTypeSymbol typeSymbol, string metadataName) => typeSymbol.GetAttributes().Any(attribute => attribute.AttributeClass?.ToDisplayString() == metadataName); @@ -1221,14 +1296,7 @@ static bool ShouldEmitComplexHookDeclaration( bool includeRef = false ) { - var declarations = typeSymbol - .DeclaringSyntaxReferences.Select(reference => reference.GetSyntax()) - .OfType() - .SelectMany(declaration => declaration.Members.OfType()) - .Where(method => - method.Identifier.Text == methodName && method.ParameterList.Parameters.Count == parameterCount - ) - .ToArray(); + var declarations = GetComplexHookDeclarations(typeSymbol, methodName, parameterCount); var hasDefinition = declarations.Any(method => ( @@ -1254,6 +1322,33 @@ static bool ShouldEmitComplexHookDeclaration( return hasRefImplementation || declarations.Length == 0; } + static bool IsComplexHookReadOnly(INamedTypeSymbol typeSymbol, string methodName, int parameterCount) + { + return GetComplexHookDeclarations(typeSymbol, methodName, parameterCount) + .Any(method => + (method.Body is not null || method.ExpressionBody is not null) + && method.Modifiers.Any(static modifier => modifier.IsKind(SyntaxKind.ReadOnlyKeyword)) + ); + } + + static MethodDeclarationSyntax[] GetComplexHookDeclarations( + INamedTypeSymbol typeSymbol, + string methodName, + int parameterCount + ) + { + return + [ + .. typeSymbol + .DeclaringSyntaxReferences.Select(reference => reference.GetSyntax()) + .OfType() + .SelectMany(declaration => declaration.Members.OfType()) + .Where(method => + method.Identifier.Text == methodName && method.ParameterList.Parameters.Count == parameterCount + ), + ]; + } + static GeneratedTypeModel? BuildTypeModel(INamedTypeSymbol typeSymbol) { if (typeSymbol.ContainingType is not null || typeSymbol.TypeParameters.Length > 0) @@ -1333,18 +1428,18 @@ static string ToCamelCase(string value) => static string GetEmptyValueExpression(ITypeSymbol typeSymbol) { - if (typeSymbol.IsReferenceType) - return typeSymbol.NullableAnnotation == NullableAnnotation.Annotated ? "null" : "null!"; - - return - typeSymbol is INamedTypeSymbol namedTypeSymbol + return typeSymbol.IsReferenceType + ? typeSymbol.NullableAnnotation == NullableAnnotation.Annotated + ? "null" + : "null!" + : typeSymbol is INamedTypeSymbol namedTypeSymbol && namedTypeSymbol.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T - ? "null" - : typeSymbol.ToDisplayString() switch - { - "System.Guid" => "global::System.Guid.Empty", - _ => "default", - }; + ? "null" + : typeSymbol.ToDisplayString() switch + { + "System.Guid" => "global::System.Guid.Empty", + _ => "default", + }; } static IFieldSymbol[] GetEnumFields(ITypeSymbol enumTypeSymbol) => @@ -1359,6 +1454,15 @@ .. enumTypeSymbol static bool HasMemberWithName(INamedTypeSymbol typeSymbol, string name) => typeSymbol.GetMembers(name).Any(member => !member.IsImplicitlyDeclared); + static bool ImplementsSelfEquatable(INamedTypeSymbol typeSymbol) => + typeSymbol.AllInterfaces.Any(interfaceSymbol => + interfaceSymbol is INamedTypeSymbol namedTypeSymbol + && namedTypeSymbol.OriginalDefinition.Name == nameof(IEquatable<>) + && namedTypeSymbol.OriginalDefinition.ContainingNamespace.ToDisplayString() == "System" + && namedTypeSymbol.TypeArguments.Length == 1 + && SymbolEqualityComparer.Default.Equals(namedTypeSymbol.TypeArguments[0], typeSymbol) + ); + readonly struct ValueObjectGenerationResult( string? hintName, string? source, @@ -1374,6 +1478,27 @@ ImmutableArray diagnostics public static ValueObjectGenerationResult Empty { get; } = new(null, null, []); } + readonly struct ValueObjectAssemblyDefaults(bool generateConstructor = true) + { + public bool GenerateConstructor { get; } = generateConstructor; + } + + static ValueObjectAssemblyDefaults GetAssemblyValueObjectDefaults(Compilation compilation) + { + const string assemblyDefaultsName = "Purview.EventSourcing.Serialization.GenerateValueObjectDefaultsAttribute"; + + var assemblyAttributes = compilation.Assembly.GetAttributes(); + var defaultsAttribute = assemblyAttributes.FirstOrDefault(attr => + attr.AttributeClass?.ToDisplayString() == assemblyDefaultsName + ); + + if (defaultsAttribute is null) + return new ValueObjectAssemblyDefaults(generateConstructor: true); + + var generateConstructor = GetNamedBool(defaultsAttribute.NamedArguments, "GenerateConstructor", true); + return new ValueObjectAssemblyDefaults(generateConstructor); + } + readonly struct GeneratedTypeModel( string name, string? @namespace, @@ -1451,6 +1576,7 @@ readonly struct ValueObjectOptions( bool generateComparable, bool generateComparisonOperators, bool generateEmpty, + bool generateConstructor, string deserializationMode ) { @@ -1462,12 +1588,21 @@ string deserializationMode public bool GenerateEmpty { get; } = generateEmpty; + public bool GenerateConstructor { get; } = generateConstructor; + public string DeserializationMode { get; } = deserializationMode; - public static ValueObjectOptions From(INamedTypeSymbol typeSymbol, string metadataName) => - From(typeSymbol.GetAttributes(), metadataName); + public static ValueObjectOptions From( + INamedTypeSymbol typeSymbol, + string metadataName, + bool assemblyDefaultGenerateConstructor = true + ) => From(typeSymbol.GetAttributes(), metadataName, assemblyDefaultGenerateConstructor); - public static ValueObjectOptions From(ImmutableArray attributes, string metadataName) + public static ValueObjectOptions From( + ImmutableArray attributes, + string metadataName, + bool assemblyDefaultGenerateConstructor = true + ) { var attribute = attributes.First(data => data.AttributeClass?.ToDisplayString() == metadataName); @@ -1476,6 +1611,7 @@ public static ValueObjectOptions From(ImmutableArray attributes, GetNamedBool(attribute.NamedArguments, "GenerateComparable", true), GetNamedBool(attribute.NamedArguments, "GenerateComparisonOperators", true), GetNamedBool(attribute.NamedArguments, "GenerateEmpty", true), + GetNamedBool(attribute.NamedArguments, "GenerateConstructor", assemblyDefaultGenerateConstructor), GetDeserializationMode(attribute.NamedArguments, "DeserializationMode") ); } diff --git a/src/src/SqlServer/Client/JsonScalarValueConverter.cs b/src/src/SqlServer/Client/JsonScalarValueConverter.cs new file mode 100644 index 00000000..1509272d --- /dev/null +++ b/src/src/SqlServer/Client/JsonScalarValueConverter.cs @@ -0,0 +1,104 @@ +using System.Linq.Expressions; +using System.Reflection; +using System.Text.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.SqlServer.Client; + +sealed class JsonScalarValueConverter : ValueConverter +{ + static readonly PropertyInfo ScalarProperty = GetScalarProperty(); + static readonly Func Creator = BuildCreator(); + + public JsonScalarValueConverter() + : base(BuildToProviderExpression(), BuildFromProviderExpression()) { } + + static Expression> BuildToProviderExpression() + { + var source = Expression.Parameter(typeof(TScalarObject), "value"); + var serializeMethod = typeof(JsonScalarValueConverter).GetMethod( + nameof(Serialize), + BindingFlags.Static | BindingFlags.NonPublic + )!; + var body = Expression.Call(serializeMethod, source); + return Expression.Lambda>(body, source); + } + + static Expression> BuildFromProviderExpression() + { + var source = Expression.Parameter(typeof(string), "value"); + var deserializeMethod = typeof(JsonScalarValueConverter).GetMethod( + nameof(Deserialize), + BindingFlags.Static | BindingFlags.NonPublic + )!; + var body = Expression.Call(deserializeMethod, source); + return Expression.Lambda>(body, source); + } + + static string Serialize(TScalarObject value) + { + if (value is null) + return null!; + + var scalarValue = (TScalar)ScalarProperty.GetValue(value)!; + return JsonSerializer.Serialize(scalarValue); + } + + static TScalarObject Deserialize(string value) + { + if (value is null) + return default!; + + var scalarValue = JsonSerializer.Deserialize(value)!; + return Creator(scalarValue); + } + + static PropertyInfo GetScalarProperty() + { + var scalarType = typeof(TScalarObject); + var scalarAttribute = + scalarType.GetCustomAttribute() + ?? throw new InvalidOperationException($"{scalarType.Name} must be annotated with [Scalar]."); + + return scalarType.GetProperty(scalarAttribute.PropertyName, BindingFlags.Instance | BindingFlags.Public) + ?? throw new InvalidOperationException( + $"'{scalarType.Name}' missing scalar property '{scalarAttribute.PropertyName}'." + ); + } + + static Func BuildCreator() + { + var scalarType = typeof(TScalarObject); + var scalarPropertyType = typeof(TScalar); + var scalarAttribute = + scalarType.GetCustomAttribute() + ?? throw new InvalidOperationException($"{scalarType.Name} must be annotated with [Scalar]."); + + var preferredFactoryName = + scalarAttribute.DeserializationMode == ValueObjectDeserializationMode.Strict ? "Create" : "Hydrate"; + var secondaryFactoryName = preferredFactoryName == "Hydrate" ? "Create" : "Hydrate"; + + var create = + scalarType.GetMethod(preferredFactoryName, BindingFlags.Public | BindingFlags.Static, [scalarPropertyType]) + ?? scalarType.GetMethod( + secondaryFactoryName, + BindingFlags.Public | BindingFlags.Static, + [scalarPropertyType] + ); + + if (create is not null) + return value => (TScalarObject)create.Invoke(null, [value])!; + + var ctor = + scalarType.GetConstructor( + BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, + [scalarPropertyType] + ) + ?? throw new InvalidOperationException( + $"{scalarType.Name} must expose static {preferredFactoryName}({scalarPropertyType.Name}), static {secondaryFactoryName}({scalarPropertyType.Name}), or ctor({scalarPropertyType.Name})." + ); + + return value => (TScalarObject)ctor.Invoke([value]); + } +} diff --git a/src/src/SqlServer/Client/JsonValueObjectCollectionConverter.cs b/src/src/SqlServer/Client/JsonValueObjectCollectionConverter.cs new file mode 100644 index 00000000..99414d7a --- /dev/null +++ b/src/src/SqlServer/Client/JsonValueObjectCollectionConverter.cs @@ -0,0 +1,13 @@ +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Purview.EventSourcing.Serialization; + +namespace Purview.EventSourcing.SqlServer.Client; + +sealed class JsonValueObjectCollectionConverter : ValueConverter +{ + public JsonValueObjectCollectionConverter() + : base( + value => EventStoreSerializationHelpers.Serialize(value), + value => EventStoreSerializationHelpers.Deserialize(value)! + ) { } +} diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Client/Models.cs b/src/src/SqlServer/Client/Models.cs similarity index 79% rename from src/src/EventSourcing.SqlServer/SqlServer/Client/Models.cs rename to src/src/SqlServer/Client/Models.cs index 78a83671..edf8f9e0 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Client/Models.cs +++ b/src/src/SqlServer/Client/Models.cs @@ -14,9 +14,11 @@ sealed class SnapshotQueryRow sealed record SqlServerClientOptions(string ConnectionString, bool UseDataCompression) { - public string TableName { get; init; } = "Snapshots"; + public string TableName { get; init; } = "EventStoreSnapshots"; public string SchemaName { get; init; } = "dbo"; public bool AutoCreateTable { get; init; } = true; + + public SqlServerJsonIndexOptions JsonIndexOptions { get; init; } = new(); } diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Client/ScalarValueConverter.cs b/src/src/SqlServer/Client/ScalarValueConverter.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Client/ScalarValueConverter.cs rename to src/src/SqlServer/Client/ScalarValueConverter.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Client/SqlServerClient.cs b/src/src/SqlServer/Client/SqlServerClient.cs similarity index 85% rename from src/src/EventSourcing.SqlServer/SqlServer/Client/SqlServerClient.cs rename to src/src/SqlServer/Client/SqlServerClient.cs index 65b9e1e6..2505fb94 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Client/SqlServerClient.cs +++ b/src/src/SqlServer/Client/SqlServerClient.cs @@ -16,6 +16,7 @@ sealed partial class SqlServerClient { static readonly ConcurrentDictionary EnsureTableLocks = new(StringComparer.Ordinal); static readonly ConcurrentDictionary EnsuredTables = new(StringComparer.Ordinal); + static readonly HashSet SupportedSnapshotIncludeColumns = ["Id", "AggregateType", "Payload"]; readonly SqlServerClientOptions _options; readonly string _tableEnsureKey; @@ -27,6 +28,13 @@ public SqlServerClient(SqlServerClientOptions options) ValidateIdentifier(_options.SchemaName); ValidateIdentifier(_options.TableName); + SqlServerJsonIndexSchemaManager.ValidateOrThrow( + _options.JsonIndexOptions, + _options.SchemaName, + _options.TableName, + SupportedSnapshotIncludeColumns, + nameof(SqlServerClientOptions.JsonIndexOptions) + ); } public async Task EnsureTableExistsAsync(CancellationToken cancellationToken = default) @@ -370,7 +378,10 @@ ScalarAttribute scalarAttribute $"'{scalarType.Name}' missing scalar property '{scalarAttribute.PropertyName}'." ); - var converterType = typeof(ScalarValueConverter<,>).MakeGenericType(scalarType, scalarProperty.PropertyType); + var scalarPropertyType = scalarProperty.PropertyType; + var converterType = IsPrimitiveLike(scalarPropertyType) + ? typeof(ScalarValueConverter<,>).MakeGenericType(scalarType, scalarPropertyType) + : typeof(JsonScalarValueConverter<,>).MakeGenericType(scalarType, scalarPropertyType); configurationBuilder.Properties(scalarType, builder => builder.HaveConversion(converterType)); } @@ -410,6 +421,12 @@ static void ConfigureComplexGraphRecursive(ComplexPropertyBuilder builder, Type if (!IsEventStoreCollectionType(propertyType)) throw CreateUnsupportedCollectionTypeException(type, property, propertyType); + if (IsStructValueObjectType(elementType)) + { + MapCollectionAsJsonProperty(builder, propertyType, property.Name); + continue; + } + if (IsPrimitiveLike(elementType) || elementType.GetCustomAttribute() is not null) builder.PrimitiveCollection(propertyType, property.Name); else if (ShouldInspectType(elementType)) @@ -424,6 +441,12 @@ static void ConfigureComplexGraphRecursive(ComplexPropertyBuilder builder, Type continue; } + if (IsDictionaryLikeType(propertyType) || IsJsonConvertibleCollectionType(propertyType)) + { + MapJsonProperty(builder, propertyType, property.Name); + continue; + } + if (IsCollectionLikeType(propertyType)) throw CreateUnsupportedCollectionTypeException(type, property, propertyType); @@ -477,6 +500,12 @@ static void ConfigureComplexGraphRecursive(ComplexCollectionBuilder builder, Typ if (!IsEventStoreCollectionType(propertyType)) throw CreateUnsupportedCollectionTypeException(type, property, propertyType); + if (IsStructValueObjectType(elementType)) + { + MapCollectionAsJsonProperty(builder, propertyType, property.Name); + continue; + } + if (IsPrimitiveLike(elementType) || elementType.GetCustomAttribute() is not null) builder.PrimitiveCollection(propertyType, property.Name); else if (ShouldInspectType(elementType)) @@ -491,6 +520,12 @@ static void ConfigureComplexGraphRecursive(ComplexCollectionBuilder builder, Typ continue; } + if (IsDictionaryLikeType(propertyType) || IsJsonConvertibleCollectionType(propertyType)) + { + MapJsonProperty(builder, propertyType, property.Name); + continue; + } + if (IsCollectionLikeType(propertyType)) throw CreateUnsupportedCollectionTypeException(type, property, propertyType); @@ -566,7 +601,11 @@ static void ValidateAggregatePayloadShapeRecursive(Type type, HashSet visi if (!IsEventStoreCollectionType(propertyType)) throw CreateUnsupportedCollectionTypeException(type, property, propertyType); - if (!IsPrimitiveLike(elementType) && elementType.GetCustomAttribute() is null) + if ( + !IsPrimitiveLike(elementType) + && elementType.GetCustomAttribute() is null + && !IsStructValueObjectType(elementType) + ) { if (!ShouldInspectType(elementType)) throw CreateUnsupportedShapeException(type, property); @@ -577,6 +616,12 @@ static void ValidateAggregatePayloadShapeRecursive(Type type, HashSet visi continue; } + if (IsReadOnlyCollectionType(propertyType)) + throw CreateUnsupportedCollectionTypeException(type, property, propertyType); + + if (IsDictionaryLikeType(propertyType) || IsJsonConvertibleCollectionType(propertyType)) + continue; + if (IsCollectionLikeType(propertyType)) throw CreateUnsupportedCollectionTypeException(type, property, propertyType); @@ -591,6 +636,37 @@ static void ValidateAggregatePayloadShapeRecursive(Type type, HashSet visi } } + static bool IsStructValueObjectType(Type type) => + type.IsValueType && type.GetCustomAttribute() is not null; + + static void MapCollectionAsJsonProperty(ComplexPropertyBuilder builder, Type propertyType, string propertyName) + { + var propertyBuilder = builder.Property(propertyType, propertyName); + var converterType = typeof(JsonValueObjectCollectionConverter<>).MakeGenericType(propertyType); + propertyBuilder.HasConversion(converterType); + } + + static void MapCollectionAsJsonProperty(ComplexCollectionBuilder builder, Type propertyType, string propertyName) + { + var propertyBuilder = builder.Property(propertyType, propertyName); + var converterType = typeof(JsonValueObjectCollectionConverter<>).MakeGenericType(propertyType); + propertyBuilder.HasConversion(converterType); + } + + static void MapJsonProperty(ComplexPropertyBuilder builder, Type propertyType, string propertyName) + { + var propertyBuilder = builder.Property(propertyType, propertyName); + var converterType = typeof(JsonValueObjectCollectionConverter<>).MakeGenericType(propertyType); + propertyBuilder.HasConversion(converterType); + } + + static void MapJsonProperty(ComplexCollectionBuilder builder, Type propertyType, string propertyName) + { + var propertyBuilder = builder.Property(propertyType, propertyName); + var converterType = typeof(JsonValueObjectCollectionConverter<>).MakeGenericType(propertyType); + propertyBuilder.HasConversion(converterType); + } + static bool ShouldOwnType(Type type) => !type.IsPrimitive && !type.IsEnum @@ -686,9 +762,52 @@ static bool IsCollectionLikeType(Type type) if (!type.IsGenericType) return false; + // Test for our own collection types or if the type implements IEnumerable somewhere... return IsEventStoreCollectionType(type) - ? true - : type.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>)); + || type.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>)); + } + + static bool IsReadOnlyCollectionType(Type type) + { + if (!type.IsGenericType) + return false; + + var genericTypeDefinition = type.GetGenericTypeDefinition(); + return genericTypeDefinition == typeof(IReadOnlyList<>) + || genericTypeDefinition == typeof(IReadOnlyCollection<>); + } + + static bool IsDictionaryLikeType(Type type) + { + if (!type.IsGenericType) + return false; + + var genericTypeDefinition = type.GetGenericTypeDefinition(); + if ( + genericTypeDefinition == typeof(Dictionary<,>) + || genericTypeDefinition == typeof(IDictionary<,>) + || genericTypeDefinition == typeof(IReadOnlyDictionary<,>) + ) + return true; + + // Test if the type implements IDictionary or IReadOnlyDictionary somewhere... + return type.GetInterfaces() + .Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IReadOnlyDictionary<,>)); + } + + static bool IsJsonConvertibleCollectionType(Type type) + { + if (type == typeof(string) || type == typeof(byte[])) + return false; + + if (!type.IsGenericType || IsEventStoreCollectionType(type) || IsDictionaryLikeType(type)) + return false; + + if (type.GetGenericTypeDefinition() == typeof(IEnumerable<>)) + return true; + + // Test if the type implements IEnumerable somewhere... + return type.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>)); } static InvalidOperationException CreateUnsupportedShapeException(Type containingType, MemberInfo member) => @@ -773,7 +892,7 @@ protected override Expression VisitBinary(BinaryExpression node) var visitedLeft = Visit(node.Left); var visitedRight = Visit(node.Right); - if ( + return (node.NodeType == ExpressionType.Equal || node.NodeType == ExpressionType.NotEqual) && TryRewriteScalarPrimitiveComparison( visitedLeft, @@ -781,12 +900,8 @@ protected override Expression VisitBinary(BinaryExpression node) out var rewrittenLeft, out var rewrittenRight ) - ) - { - return Expression.MakeBinary(node.NodeType, rewrittenLeft, rewrittenRight); - } - - return node.Update(visitedLeft, node.Conversion, visitedRight); + ? Expression.MakeBinary(node.NodeType, rewrittenLeft, rewrittenRight) + : node.Update(visitedLeft, node.Conversion, visitedRight); } protected override Expression VisitMember(MemberExpression node) @@ -942,6 +1057,17 @@ async Task EnsureTableIfEnabledAsync(CancellationToken cancellationToken) { await using var context = CreateStorageContext(); await CreateStorageTablesWithEfAsync(context, cancellationToken); + await using var connection = new SqlConnection(_options.ConnectionString); + await connection.OpenAsync(cancellationToken); + await SqlServerJsonIndexSchemaManager.ApplyAsync( + connection, + transaction: null, + _options.SchemaName, + _options.TableName, + _options.JsonIndexOptions, + SupportedSnapshotIncludeColumns, + cancellationToken + ); } catch (Exception ex) when (IsDuplicateTableCreateError(ex, _options.TableName)) { @@ -978,6 +1104,15 @@ CancellationToken cancellationToken if (transaction is not null) await context.Database.UseTransactionAsync(transaction, cancellationToken); await CreateStorageTablesWithEfAsync(context, cancellationToken); + await SqlServerJsonIndexSchemaManager.ApplyAsync( + connection, + transaction, + _options.SchemaName, + _options.TableName, + _options.JsonIndexOptions, + SupportedSnapshotIncludeColumns, + cancellationToken + ); } catch (Exception ex) when (IsDuplicateTableCreateError(ex, _options.TableName)) { diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/AggregateVersionData.cs b/src/src/SqlServer/Events/AggregateVersionData.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/AggregateVersionData.cs rename to src/src/SqlServer/Events/AggregateVersionData.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/EventStoreDbContext.cs b/src/src/SqlServer/Events/EntityFramework/EventStoreDbContext.cs similarity index 92% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/EventStoreDbContext.cs rename to src/src/SqlServer/Events/EntityFramework/EventStoreDbContext.cs index b83f4b93..2f6c29ba 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/EventStoreDbContext.cs +++ b/src/src/SqlServer/Events/EntityFramework/EventStoreDbContext.cs @@ -51,24 +51,21 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) // Covers: GetByAggregateIdAndEntityType, GetIdempotencyMarkers, DeleteByAggregateId entity - .HasIndex(e => new { e.AggregateId, e.EntityType }) - .HasDatabaseName($"IX_{_tableName}_AggregateId_EntityType") - .IncludeProperties(e => new + .HasIndex(e => new { - e.Version, - e.IsDeleted, + e.AggregateId, e.AggregateType, - e.EventType, - e.IdempotencyId, - e.Timestamp, - }); + e.EntityType, + }) + .HasDatabaseName($"IX_{_tableName}_AggregateId_EntityType") + .IncludeProperties(e => new { e.Version, e.IsDeleted }); - // Covers: GetEventRange (AggregateId + EntityType=1 + Version range, ORDER BY Version) + // Covers: GetEventRange (AggregateId + AggregateType + EntityType=1 + Version range, ORDER BY Version) entity .HasIndex(e => new { e.AggregateId, - e.EntityType, + e.AggregateType, e.Version, }) .HasDatabaseName($"IX_{_tableName}_EventRange") @@ -78,8 +75,6 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) e.Payload, e.EventType, e.IdempotencyId, - e.IsDeleted, - e.AggregateType, e.Timestamp, }); diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/EventStoreDbContextDesignTimeFactory.cs b/src/src/SqlServer/Events/EntityFramework/EventStoreDbContextDesignTimeFactory.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/EventStoreDbContextDesignTimeFactory.cs rename to src/src/SqlServer/Events/EntityFramework/EventStoreDbContextDesignTimeFactory.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/EventStoreEntity.cs b/src/src/SqlServer/Events/EntityFramework/EventStoreEntity.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/EventStoreEntity.cs rename to src/src/SqlServer/Events/EntityFramework/EventStoreEntity.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/Migrations/20260412000000_InitialCreate.Designer.cs b/src/src/SqlServer/Events/EntityFramework/Migrations/20260412000000_InitialCreate.Designer.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/Migrations/20260412000000_InitialCreate.Designer.cs rename to src/src/SqlServer/Events/EntityFramework/Migrations/20260412000000_InitialCreate.Designer.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/Migrations/20260412000000_InitialCreate.cs b/src/src/SqlServer/Events/EntityFramework/Migrations/20260412000000_InitialCreate.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/Migrations/20260412000000_InitialCreate.cs rename to src/src/SqlServer/Events/EntityFramework/Migrations/20260412000000_InitialCreate.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/Migrations/EventStoreDbContextModelSnapshot.cs b/src/src/SqlServer/Events/EntityFramework/Migrations/EventStoreDbContextModelSnapshot.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/EntityFramework/Migrations/EventStoreDbContextModelSnapshot.cs rename to src/src/SqlServer/Events/EntityFramework/Migrations/EventStoreDbContextModelSnapshot.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateAlreadyDeletedException.cs b/src/src/SqlServer/Events/Exceptions/AggregateAlreadyDeletedException.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateAlreadyDeletedException.cs rename to src/src/SqlServer/Events/Exceptions/AggregateAlreadyDeletedException.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateDeletedException.cs b/src/src/SqlServer/Events/Exceptions/AggregateDeletedException.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateDeletedException.cs rename to src/src/SqlServer/Events/Exceptions/AggregateDeletedException.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateIsDeletedException.cs b/src/src/SqlServer/Events/Exceptions/AggregateIsDeletedException.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateIsDeletedException.cs rename to src/src/SqlServer/Events/Exceptions/AggregateIsDeletedException.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateLockedException.cs b/src/src/SqlServer/Events/Exceptions/AggregateLockedException.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateLockedException.cs rename to src/src/SqlServer/Events/Exceptions/AggregateLockedException.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateNotDeletedException.cs b/src/src/SqlServer/Events/Exceptions/AggregateNotDeletedException.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateNotDeletedException.cs rename to src/src/SqlServer/Events/Exceptions/AggregateNotDeletedException.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateStreamVersionMissingException.cs b/src/src/SqlServer/Events/Exceptions/AggregateStreamVersionMissingException.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregateStreamVersionMissingException.cs rename to src/src/SqlServer/Events/Exceptions/AggregateStreamVersionMissingException.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs b/src/src/SqlServer/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs rename to src/src/SqlServer/Events/Exceptions/AggregatedNotAlreadyDeletedException.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/CommitException.cs b/src/src/SqlServer/Events/Exceptions/CommitException.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/CommitException.cs rename to src/src/SqlServer/Events/Exceptions/CommitException.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/ConcurrencyException.cs b/src/src/SqlServer/Events/Exceptions/ConcurrencyException.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/ConcurrencyException.cs rename to src/src/SqlServer/Events/Exceptions/ConcurrencyException.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/MissingAggregateIdException.cs b/src/src/SqlServer/Events/Exceptions/MissingAggregateIdException.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/Exceptions/MissingAggregateIdException.cs rename to src/src/SqlServer/Events/Exceptions/MissingAggregateIdException.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/ISqlServerEventStore.cs b/src/src/SqlServer/Events/ISqlServerEventStore.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/ISqlServerEventStore.cs rename to src/src/SqlServer/Events/ISqlServerEventStore.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/ISqlServerEventStoreTelemetry.cs b/src/src/SqlServer/Events/ISqlServerEventStoreTelemetry.cs similarity index 97% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/ISqlServerEventStoreTelemetry.cs rename to src/src/SqlServer/Events/ISqlServerEventStoreTelemetry.cs index db0aec7d..3f254ef9 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/ISqlServerEventStoreTelemetry.cs +++ b/src/src/SqlServer/Events/ISqlServerEventStoreTelemetry.cs @@ -144,7 +144,11 @@ long elapsedMilliseconds void GetAggregateFailed(string aggregateId, string aggregateTypeFullName, Exception exception); [Log(LogLevel.Warning)] - void StreamVersionExpectedToExistButNotFound(string aggregateId); + void StreamVersionExpectedToExistButNotFound( + string aggregateId, + string aggregateTypeName, + string aggregateTypeFullName + ); [Log(LogLevel.Debug)] void StreamVersionNotFound(string aggregateId); diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.CreateAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.CreateAsync.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.CreateAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.CreateAsync.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.DeleteAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.DeleteAsync.cs similarity index 99% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.DeleteAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.DeleteAsync.cs index 47c768f3..df85086c 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.DeleteAsync.cs +++ b/src/src/SqlServer/Events/SqlServerEventStore.DeleteAsync.cs @@ -16,7 +16,7 @@ public async Task DeleteAsync( if (aggregate.Details.IsDeleted) throw AggregateIsDeletedException(aggregate.Id()); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); if (aggregate.IsNew()) return false; diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.ExceptionHelpers.cs b/src/src/SqlServer/Events/SqlServerEventStore.ExceptionHelpers.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.ExceptionHelpers.cs rename to src/src/SqlServer/Events/SqlServerEventStore.ExceptionHelpers.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.ExistsAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.ExistsAsync.cs similarity index 94% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.ExistsAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.ExistsAsync.cs index c54878dd..8d545728 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.ExistsAsync.cs +++ b/src/src/SqlServer/Events/SqlServerEventStore.ExistsAsync.cs @@ -8,7 +8,7 @@ public async Task ExistsAsync(string aggregateId, CancellationToken var streamVersion = await GetStreamVersionAsync(aggregateId, false, cancellationToken); return streamVersion == null - ? ExistsState.DoesNotExists + ? ExistsState.DoesNotExist : new ExistsState { Status = streamVersion.IsDeleted ? ExistsStatus.ExistsInDeletedState : ExistsStatus.Exists, diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.GetAsync.cs similarity index 98% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.GetAsync.cs index 38839a8b..1c86d645 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetAsync.cs +++ b/src/src/SqlServer/Events/SqlServerEventStore.GetAsync.cs @@ -21,14 +21,14 @@ partial class SqlServerEventStore { ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); _eventStoreTelemetry.GetAggregateStart(aggregateId, _aggregateTypeFullName); using var activity = _eventStoreTelemetry.GetAggregate(aggregateId, _aggregateTypeFullName); var getStopwatch = System.Diagnostics.Stopwatch.StartNew(); try { - var aggregate = operationContext.CacheMode.HasFlag(EventStoreCachingOptions.GetFromCache) + var aggregate = operationContext.SnapshotCacheMode.HasFlag(SnapshotCachingOptions.GetFromCache) ? await GetFromCacheAsync(aggregateId, cancellationToken) : null; diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetAtAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.GetAtAsync.cs similarity index 99% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetAtAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.GetAtAsync.cs index 00f1aef5..fd765dc3 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetAtAsync.cs +++ b/src/src/SqlServer/Events/SqlServerEventStore.GetAtAsync.cs @@ -13,7 +13,7 @@ partial class SqlServerEventStore { ArgumentException.ThrowIfNullOrWhiteSpace(aggregateId, nameof(aggregateId)); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); _eventStoreTelemetry.GetAggregateAtSpecificVersionStart(aggregateId, version, _aggregateTypeFullName); using var activity = _eventStoreTelemetry.GetAggregateAtVersion(aggregateId, version, _aggregateTypeFullName); diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetDeletedAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.GetDeletedAsync.cs similarity index 79% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetDeletedAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.GetDeletedAsync.cs index 59ced9a1..a12ede9e 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetDeletedAsync.cs +++ b/src/src/SqlServer/Events/SqlServerEventStore.GetDeletedAsync.cs @@ -6,7 +6,7 @@ partial class SqlServerEventStore { var aggregate = await GetCoreAsync( aggregateId, - new() { CacheMode = EventStoreCachingOptions.None, DeleteMode = DeleteHandlingMode.ReturnsAggregate }, + new() { SnapshotCacheMode = SnapshotCachingOptions.None, DeleteMode = DeleteHandlingMode.ReturnsAggregate }, cancellationToken ); diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetEventRangeAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.GetEventRangeAsync.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetEventRangeAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.GetEventRangeAsync.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetOrCreateAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.GetOrCreateAsync.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.GetOrCreateAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.GetOrCreateAsync.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.IsDeletedAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.IsDeletedAsync.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.IsDeletedAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.IsDeletedAsync.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.RestoreAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.RestoreAsync.cs similarity index 99% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.RestoreAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.RestoreAsync.cs index b6e5ac78..74383ecf 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.RestoreAsync.cs +++ b/src/src/SqlServer/Events/SqlServerEventStore.RestoreAsync.cs @@ -16,7 +16,7 @@ public async Task RestoreAsync( if (!aggregate.Details.IsDeleted) throw AggregateNotDeletedException(aggregate.Id()); - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); Restored restoreAggregateEvent = new() { diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.SaveAsync.cs b/src/src/SqlServer/Events/SqlServerEventStore.SaveAsync.cs similarity index 99% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.SaveAsync.cs rename to src/src/SqlServer/Events/SqlServerEventStore.SaveAsync.cs index 560863f3..3d3afc8f 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.SaveAsync.cs +++ b/src/src/SqlServer/Events/SqlServerEventStore.SaveAsync.cs @@ -3,13 +3,13 @@ using System.Diagnostics.CodeAnalysis; using System.Globalization; using System.Security.Claims; -using FluentValidation.Results; using Microsoft.Data.SqlClient; using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Internal; using Purview.EventSourcing.Services; using Purview.EventSourcing.SqlServer.Events.Exceptions; +using Purview.EventSourcing.Validation; namespace Purview.EventSourcing.SqlServer.Events; @@ -62,7 +62,7 @@ async Task> SaveCoreAsync( params IEvent[] additionalEvents ) { - operationContext ??= EventStoreOperationContext.DefaultContext; + operationContext ??= EventStoreOperationContext.DefaultContext(); FulfilRequirements(aggregate); diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.Serialization.cs b/src/src/SqlServer/Events/SqlServerEventStore.Serialization.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.Serialization.cs rename to src/src/SqlServer/Events/SqlServerEventStore.Serialization.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.cs b/src/src/SqlServer/Events/SqlServerEventStore.cs similarity index 96% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.cs rename to src/src/SqlServer/Events/SqlServerEventStore.cs index a4f62bf6..850cfa98 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStore.cs +++ b/src/src/SqlServer/Events/SqlServerEventStore.cs @@ -42,14 +42,14 @@ public SqlServerEventStore( ISqlServerEventStoreTelemetry eventStoreTelemetry, ChangeFeed.IAggregateChangeFeedNotifier aggregateChangeNotifier, IAggregateRequirementsManager aggregateRequirementsManager, - FluentValidation.IValidator? validator = null, + IAggregateValidator? validator = null, IAggregateIdFactory? aggregateIdFactory = null, IEventUpcasterRegistry? eventUpcasterRegistry = null ) { _eventNameMapper = eventNameMapper; _eventStoreOptions = sqlServerOptions; - _validator = AggregateValidatorAdapter.Adapt(validator); + _validator = validator; _aggregateIdFactory = aggregateIdFactory; _distributedCache = distributedCache; _eventStoreTelemetry = eventStoreTelemetry; @@ -93,7 +93,7 @@ async Task UpdateCacheAsync( await _distributedCache.RemoveAsync(cacheKey, cancellationToken); else { - if (!_eventStoreOptions.Value.CacheMode.HasFlag(EventStoreCachingOptions.StoreInCache)) + if (!_eventStoreOptions.Value.CacheMode.HasFlag(SnapshotCachingOptions.StoreInCache)) return; var data = SerializeSnapshot(aggregate); @@ -163,7 +163,11 @@ CancellationToken cancellationToken if (row == null || row.EntityType != StreamVersionType) { if (expectedToExist) - _eventStoreTelemetry.StreamVersionExpectedToExistButNotFound(aggregateId); + _eventStoreTelemetry.StreamVersionExpectedToExistButNotFound( + aggregateId, + _aggregateTypeShortName, + _aggregateTypeFullName + ); else _eventStoreTelemetry.StreamVersionNotFound(aggregateId); } @@ -253,6 +257,7 @@ static SqlServerEventStoreOptions ResolveClientOptions(SqlServerEventStoreOption CacheMode = options.CacheMode, DefaultCacheSlidingDuration = options.DefaultCacheSlidingDuration, RequiresValidPrincipalIdentifier = options.RequiresValidPrincipalIdentifier, + JsonIndexOptions = options.JsonIndexOptions, }; } diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreClient.cs b/src/src/SqlServer/Events/SqlServerEventStoreClient.cs similarity index 90% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreClient.cs rename to src/src/SqlServer/Events/SqlServerEventStoreClient.cs index c4f2076d..ed879b4a 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreClient.cs +++ b/src/src/SqlServer/Events/SqlServerEventStoreClient.cs @@ -12,6 +12,19 @@ sealed partial class SqlServerEventStoreClient { static readonly ConcurrentDictionary EnsureTableLocks = new(StringComparer.Ordinal); static readonly ConcurrentDictionary EnsuredTables = new(StringComparer.Ordinal); + static readonly HashSet SupportedEventIncludeColumns = + [ + "Id", + "EntityType", + "AggregateId", + "AggregateType", + "Version", + "IsDeleted", + "Payload", + "EventType", + "IdempotencyId", + "Timestamp", + ]; readonly SqlServerEventStoreOptions _options; readonly string _tableEnsureKey; @@ -21,6 +34,13 @@ public SqlServerEventStoreClient(SqlServerEventStoreOptions options) _options = options ?? throw new ArgumentNullException(nameof(options)); ValidateIdentifier(_options.SchemaName); ValidateIdentifier(_options.TableName); + SqlServerJsonIndexSchemaManager.ValidateOrThrow( + _options.JsonIndexOptions, + _options.SchemaName, + _options.TableName, + SupportedEventIncludeColumns, + nameof(SqlServerEventStoreOptions.JsonIndexOptions) + ); _tableEnsureKey = $"{_options.ConnectionString}|{_options.SchemaName}|{_options.TableName}"; } @@ -240,15 +260,9 @@ public async Task DeleteByAggregateIdAsync( { await EnsureConfiguredAsync(cancellationToken); await using var context = CreateContext(); - var entities = await context + return await context .EventStoreEntities.Where(x => x.AggregateId == aggregateId && x.AggregateType == aggregateType) - .ToListAsync(cancellationToken); - if (entities.Count == 0) - return 0; - - context.EventStoreEntities.RemoveRange(entities); - await context.SaveChangesAsync(cancellationToken); - return entities.Count; + .ExecuteDeleteAsync(cancellationToken); } public async Task GetByIdAsync(string id, CancellationToken cancellationToken = default) @@ -336,10 +350,23 @@ public async IAsyncEnumerable GetEventRangeAsync( && x.Version <= versionTo ) .OrderBy(x => x.Version) + .Select(x => new RowData + { + Id = x.Id, + EntityType = x.EntityType, + AggregateId = x.AggregateId, + AggregateType = x.AggregateType, + Version = x.Version, + IsDeleted = x.IsDeleted, + Payload = x.Payload, + EventType = x.EventType, + IdempotencyId = x.IdempotencyId, + Timestamp = x.Timestamp, + }) .AsAsyncEnumerable(); await foreach (var entity in events.WithCancellation(cancellationToken)) - yield return ToRow(entity); + yield return entity; } public async Task> GetIdempotencyMarkerIdsByAggregateIdAsync( @@ -397,6 +424,17 @@ async Task EnsureTableIfEnabledAsync(CancellationToken cancellationToken) { await using var context = CreateContext(); await CreateStorageTablesWithEfAsync(context, cancellationToken); + await using var connection = new SqlConnection(_options.ConnectionString); + await connection.OpenAsync(cancellationToken); + await SqlServerJsonIndexSchemaManager.ApplyAsync( + connection, + transaction: null, + _options.SchemaName, + _options.TableName, + _options.JsonIndexOptions, + SupportedEventIncludeColumns, + cancellationToken + ); } catch (Exception ex) when (IsDuplicateTableCreateError(ex, _options.TableName)) { @@ -431,6 +469,15 @@ CancellationToken cancellationToken { await using var context = CreateContext(connection, transaction); await CreateStorageTablesWithEfAsync(context, cancellationToken); + await SqlServerJsonIndexSchemaManager.ApplyAsync( + connection, + transaction, + _options.SchemaName, + _options.TableName, + _options.JsonIndexOptions, + SupportedEventIncludeColumns, + cancellationToken + ); } catch (Exception ex) when (IsDuplicateTableCreateError(ex, _options.TableName)) { @@ -447,15 +494,15 @@ CancellationToken cancellationToken EventStoreDbContext CreateContext() { - var optionsBuilder = new DbContextOptionsBuilder(); + DbContextOptionsBuilder optionsBuilder = new(); var commandTimeout = Math.Max(1, _options.TimeoutInSeconds ?? 60); optionsBuilder.UseSqlServer(_options.ConnectionString, sql => sql.CommandTimeout(commandTimeout)); - return new EventStoreDbContext(optionsBuilder.Options, _options.SchemaName, _options.TableName); + return new(optionsBuilder.Options, _options.SchemaName, _options.TableName); } EventStoreDbContext CreateContext(SqlConnection connection, SqlTransaction? transaction) { - var optionsBuilder = new DbContextOptionsBuilder(); + DbContextOptionsBuilder optionsBuilder = new(); var commandTimeout = Math.Max(1, _options.TimeoutInSeconds ?? 60); optionsBuilder.UseSqlServer(connection, sql => sql.CommandTimeout(commandTimeout)); var context = new EventStoreDbContext(optionsBuilder.Options, _options.SchemaName, _options.TableName); diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreOptions.cs b/src/src/SqlServer/Events/SqlServerEventStoreOptions.cs similarity index 87% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreOptions.cs rename to src/src/SqlServer/Events/SqlServerEventStoreOptions.cs index 786e22c1..6763b43f 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreOptions.cs +++ b/src/src/SqlServer/Events/SqlServerEventStoreOptions.cs @@ -17,12 +17,14 @@ public sealed class SqlServerAggregateTableOverride /// Overrides the schema name for this aggregate type. /// When null, the global is used. /// + [RegularExpression(@"^[\w\-.]+$")] public string? SchemaName { get; set; } /// /// Overrides the table name for this aggregate type. /// When null, the global is used. /// + [RegularExpression(@"^[\w\-.]+$")] public string? TableName { get; set; } } @@ -36,8 +38,12 @@ public sealed class SqlServerEventStoreOptions [Required] public string ConnectionString { get; set; } = default!; - public string TableName { get; set; } = "EventStore"; + [Required(AllowEmptyStrings = false)] + [RegularExpression(@"^[\w\-.]+$")] + public string TableName { get; set; } = "EventStoreEvents"; + [Required(AllowEmptyStrings = false)] + [RegularExpression(@"^[\w\-.]+$")] public string SchemaName { get; set; } = "dbo"; /// @@ -84,10 +90,10 @@ public sealed class SqlServerEventStoreOptions /// /// Gets/ sets a value indicating how the - /// uses the during it's operations. Defaults to . + /// uses the during it's operations. Defaults to . /// - [DefaultValue(EventStoreCachingOptions.GetAndStore)] - public EventStoreCachingOptions CacheMode { get; set; } = EventStoreCachingOptions.GetAndStore; + [DefaultValue(SnapshotCachingOptions.GetAndStore)] + public SnapshotCachingOptions CacheMode { get; set; } = SnapshotCachingOptions.GetAndStore; public TimeSpan DefaultCacheSlidingDuration { get; set; } = TimeSpan.FromMinutes(60); @@ -133,4 +139,10 @@ public sealed class SqlServerEventStoreOptions /// public Dictionary AggregateTableOverrides { get; init; } = [with(StringComparer.OrdinalIgnoreCase)]; + + /// + /// Configures runtime-managed SQL Server indexes over the event payload JSON column. + /// + [Required] + public SqlServerJsonIndexOptions JsonIndexOptions { get; set; } = new(); } diff --git a/src/src/SqlServer/Events/SqlServerEventStoreOptionsValidator.cs b/src/src/SqlServer/Events/SqlServerEventStoreOptionsValidator.cs new file mode 100644 index 00000000..abdd915e --- /dev/null +++ b/src/src/SqlServer/Events/SqlServerEventStoreOptionsValidator.cs @@ -0,0 +1,28 @@ +using System.ComponentModel.DataAnnotations; +using Microsoft.Extensions.Options; + +namespace Purview.EventSourcing.SqlServer.Events; + +sealed class SqlServerEventStoreOptionsValidator : IValidateOptions +{ + public ValidateOptionsResult Validate(string? name, SqlServerEventStoreOptions options) + { + ArgumentNullException.ThrowIfNull(options); + var validationContext = new ValidationContext(options); + var validationResults = new List(); + if (!Validator.TryValidateObject(options, validationContext, validationResults, validateAllProperties: true)) + return ValidateOptionsResult.Fail( + validationResults.Select(static x => x.ErrorMessage ?? "Options validation failed.") + ); + + try + { + _ = new SqlServerEventStoreClient(options); + return ValidateOptionsResult.Success; + } + catch (ArgumentException ex) + { + return ValidateOptionsResult.Fail(ex.Message); + } + } +} diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreTransaction.cs b/src/src/SqlServer/Events/SqlServerEventStoreTransaction.cs similarity index 91% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreTransaction.cs rename to src/src/SqlServer/Events/SqlServerEventStoreTransaction.cs index 0eb4d7ac..554aee8a 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreTransaction.cs +++ b/src/src/SqlServer/Events/SqlServerEventStoreTransaction.cs @@ -33,6 +33,7 @@ sealed class SqlServerEventStoreTransaction(string? correlationId = null) : ISql readonly List _enlisted = []; readonly List> _sqlOperations = []; readonly bool _useIdempotencyMarker = !string.IsNullOrWhiteSpace(correlationId ?? Activity.Current?.Id); + string? _transactionBoundaryKey; bool _committed; bool _disposed; @@ -60,6 +61,7 @@ is not ITransactionalEventStore transactionalEventStore ); } + EnsureTransactionBoundary(transactionalEventStore.TransactionBoundaryKey, eventStore.GetType().FullName); _enlisted.Add( new EnlistedAggregate(aggregate, transactionalEventStore, operationContext, _useIdempotencyMarker) ); @@ -87,6 +89,7 @@ public void Enlist( ); } + EnsureTransactionBoundary(transactionalEventStore.TransactionBoundaryKey, eventStore.GetType().FullName); _enlisted.Add( new EnlistedAggregate(aggregate, transactionalEventStore, operationContext, _useIdempotencyMarker) ); @@ -326,14 +329,11 @@ public async Task SaveInTransactionAsync( CancellationToken cancellationToken ) { - var baseContext = operationContext ?? EventStoreOperationContext.DefaultContext; + var baseContext = operationContext ?? EventStoreOperationContext.DefaultContext(correlationId); var context = baseContext with { - CorrelationId = baseContext.CorrelationId ?? correlationId, - UseIdempotencyMarker = - baseContext.UseIdempotencyMarker - || useIdempotencyMarker - || !string.IsNullOrWhiteSpace(baseContext.CorrelationId), + CorrelationId = operationContext is null ? correlationId : baseContext.CorrelationId, + UseIdempotencyMarker = baseContext.UseIdempotencyMarker || useIdempotencyMarker, }; var saveOperation = await eventStore.SaveInTransactionAsync( @@ -370,4 +370,27 @@ connection as SqlConnection static SqlTransaction GetSqlTransaction(DbTransaction transaction) => transaction as SqlTransaction ?? throw new InvalidOperationException("SQL Server transactions require a SqlTransaction."); + + void EnsureTransactionBoundary(string boundaryKey, string? eventStoreType) + { + if (string.IsNullOrWhiteSpace(boundaryKey)) + { + throw new InvalidOperationException( + $"The enlisted event store '{eventStoreType}' did not provide a SQL transaction boundary." + ); + } + + if (_transactionBoundaryKey is null) + { + _transactionBoundaryKey = boundaryKey; + return; + } + + if (!StringComparer.Ordinal.Equals(_transactionBoundaryKey, boundaryKey)) + { + throw new InvalidOperationException( + "All enlisted SQL Server event stores must share the same transaction boundary." + ); + } + } } diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreTransactionFactory.cs b/src/src/SqlServer/Events/SqlServerEventStoreTransactionFactory.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Events/SqlServerEventStoreTransactionFactory.cs rename to src/src/SqlServer/Events/SqlServerEventStoreTransactionFactory.cs diff --git a/src/src/EventSourcing.SqlServer/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs b/src/src/SqlServer/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs similarity index 59% rename from src/src/EventSourcing.SqlServer/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs rename to src/src/SqlServer/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs index b4423b97..89a6310d 100644 --- a/src/src/EventSourcing.SqlServer/Extensions/Microsoft/Extensions/DependencyInjections/ServiceCollectionExtensions.cs +++ b/src/src/SqlServer/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs @@ -1,6 +1,7 @@ using System.ComponentModel; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection.Extensions; +using Microsoft.Extensions.Options; using Purview.EventSourcing.Internal; using Purview.EventSourcing.SqlServer.Events; using Purview.EventSourcing.SqlServer.Snapshot; @@ -11,11 +12,47 @@ namespace Microsoft.Extensions.DependencyInjection; [EditorBrowsable(EditorBrowsableState.Never)] public static class ServiceCollectionExtensions { + static readonly string[] EventsConnectionStringNames = + [ + "eventstore-events-sqlserver", + "EventStore_Events_SqlServer", + "Events_SqlServer", + "eventstore-events-sql", + "EventStore_Events_Sql", + "Events_Sql", + ]; + + static readonly string[] SnapshotsConnectionStringNames = + [ + "eventstore-snapshots-sqlserver", + "EventStore_Snapshots_SqlServer", + "Snapshots_SqlServer", + "eventstore-snapshots-sql", + "EventStore_Snapshots_Sql", + "Snapshots_Sql", + ]; + + static readonly string[] DefaultConnectionStringNames = + [ + "eventstore-sqlserver", + "EventStore_SqlServer", + "SqlServer", + "eventstore-sql", + "EventStore_Sql", + "Sql", + ]; + extension(IServiceCollection services) { - public IServiceCollection AddSqlServerEventStore() + public IServiceCollection AddSqlServerEventStore(string? connectionStringName = null) { services.AddEventSourcing(); + services.TryAddEnumerable( + ServiceDescriptor.Singleton< + IValidateOptions, + SqlServerEventStoreOptionsValidator + >() + ); services .AddTransient(typeof(IEventStoreCore<>), typeof(SqlServerEventStore<>)) @@ -32,15 +69,13 @@ public IServiceCollection AddSqlServerEventStore() (options, configuration) => { configuration.GetSection(SqlServerEventStoreOptions.SqlServerEventStore).Bind(options); - if (string.IsNullOrWhiteSpace(options.ConnectionString)) { - options.ConnectionString = - configuration.GetConnectionString("eventstore-sqlserver") - ?? configuration.GetConnectionString("EventStore_SqlServer") - ?? configuration.GetConnectionString("SqlServer") - // This will get picked up by the validation. - ?? default!; + options.ConnectionString = configuration.GetRequiredConnectionString([ + connectionStringName, + .. EventsConnectionStringNames, + .. DefaultConnectionStringNames, + ]); } } ) @@ -49,9 +84,18 @@ public IServiceCollection AddSqlServerEventStore() return services; } - public IServiceCollection AddSqlServerSnapshotQueryableEventStore(bool registerAsIEventStore = false) + public IServiceCollection AddSqlServerSnapshotQueryableEventStore( + string? connectionStringName = null, + bool registerAsIEventStore = false + ) { services.AddEventSourcing(); + services.TryAddEnumerable( + ServiceDescriptor.Singleton< + IValidateOptions, + SqlServerSnapshotEventStoreOptionsValidator + >() + ); services .AddTransient(typeof(IQueryableEventStoreCore<>), typeof(SqlServerSnapshotEventStore<>)) @@ -72,15 +116,13 @@ public IServiceCollection AddSqlServerSnapshotQueryableEventStore(bool registerA (options, configuration) => { configuration.GetSection(SqlServerSnapshotEventStoreOptions.SqlServerEventStore).Bind(options); - if (string.IsNullOrWhiteSpace(options.ConnectionString)) { - options.ConnectionString ??= - configuration.GetConnectionString("eventstore-sqlserver") - ?? configuration.GetConnectionString("EventStore_SqlServer") - ?? configuration.GetConnectionString("SqlServer") - // This will get picked up by the validation. - ?? default!; + options.ConnectionString = configuration.GetRequiredConnectionString([ + connectionStringName, + .. SnapshotsConnectionStringNames, + .. DefaultConnectionStringNames, + ]); } } ) diff --git a/src/src/SqlServer/Properties/AssemblyInfo.cs b/src/src/SqlServer/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..4d6983f9 --- /dev/null +++ b/src/src/SqlServer/Properties/AssemblyInfo.cs @@ -0,0 +1,8 @@ +using System.Runtime.CompilerServices; +using Purview.Telemetry; + +[assembly: InternalsVisibleTo("SharedTestingFramework")] +[assembly: InternalsVisibleTo("EventSourcing.UnitTests")] + +[assembly: ActivitySourceGeneration("Purview.EventSourcing.SqlServer")] +[assembly: MeterGeneration("Purview.EventSourcing.SqlServer")] diff --git a/src/src/EventSourcing.SqlServer/README.md b/src/src/SqlServer/README.md similarity index 64% rename from src/src/EventSourcing.SqlServer/README.md rename to src/src/SqlServer/README.md index 625d3af6..b5a251ce 100644 --- a/src/src/EventSourcing.SqlServer/README.md +++ b/src/src/SqlServer/README.md @@ -27,7 +27,7 @@ builder.Services.AddSqlServerSnapshotQueryableEventStore(); - Event-stream persistence for aggregates loaded through `IEventStore` - Query/list/count snapshot-backed reads through `IQueryableEventStore` -- SQL-specific transaction factory (`ISqlServerEventStoreTransactionFactory`) for enlisting additional SQL/EF work in the same commit +- SQL-specific transaction factory (`ISqlServerEventStoreTransactionFactory`) for enlisting additional SQL/EF work in the same commit (all enlisted stores must share the same SQL transaction boundary) - SQL Server and Azure SQL configuration binding for both event and snapshot stores - Entity Framework-backed schema creation and CRUD paths - JSON-column-backed event and snapshot payload storage @@ -40,10 +40,17 @@ The snapshot payload is the fully serialized aggregate graph stored in a single Supported members are writable primitives, `[Scalar]` value objects, complex objects composed of supported members, and `EventStoreList` / `EventStoreSet` collections of supported primitive or complex members. -Unsupported shapes fail during model creation, including arrays and collection types other than `EventStoreList` / `EventStoreSet` (for example `List`, `IReadOnlyList`, `IEnumerable`, `HashSet`, `ImmutableArray`) and unsupported object types such as dictionaries. Read-only and `[JsonIgnore]` members are excluded from the JSON payload. +Important query distinction: + +- A `[Scalar]` value object with a primitive inner value is generally query-friendly. +- A `[Scalar]` value object with a complex inner value is persisted correctly, but deep predicates through `.Value` are not guaranteed to translate in SQL snapshot queries. +- If deep SQL predicates are required for a complex concept, expose the underlying complex type directly on the aggregate/query snapshot model (for example, a `ParserReportSummary` mirror property) and verify the exact nested predicate with integration tests. + +Unsupported shapes fail during model creation, including arrays and collection types other than `EventStoreList` / `EventStoreSet` (for example `List`, `IReadOnlyList`, `IEnumerable`, `HashSet`, `ImmutableArray`), except where a provider-specific JSON conversion path is explicitly supported and tested. Read-only and `[JsonIgnore]` members are excluded from the JSON payload. ## Documentation -- Repository README: https://github.com/kjldev/purview-eventsourcing/blob/main/README.md -- SQL Server guide: https://github.com/kjldev/purview-eventsourcing/blob/main/docs/wiki/SQL-Server-Guide.md +- [Repository README](https://github.com/kjldev/purview-eventsourcing/blob/main/README.md) +- [SQL Server guide](https://github.com/kjldev/purview-eventsourcing/blob/main/docs/wiki/SQL-Server-Guide.md) - Includes behavior notes/caveats (`IsDeletedAsync` missing behavior, tolerant replay, principal requirements) + - Includes snapshot payload/query-translation guidance for scalar value objects vs directly mapped complex mirrors diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.Designer.cs b/src/src/SqlServer/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.Designer.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.Designer.cs rename to src/src/SqlServer/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.Designer.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.cs b/src/src/SqlServer/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.cs rename to src/src/SqlServer/Snapshots/EntityFramework/Migrations/20260412000000_InitialCreate.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/Migrations/SnapshotStoreDbContextModelSnapshot.cs b/src/src/SqlServer/Snapshots/EntityFramework/Migrations/SnapshotStoreDbContextModelSnapshot.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/Migrations/SnapshotStoreDbContextModelSnapshot.cs rename to src/src/SqlServer/Snapshots/EntityFramework/Migrations/SnapshotStoreDbContextModelSnapshot.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/SnapshotStoreDbContext.cs b/src/src/SqlServer/Snapshots/EntityFramework/SnapshotStoreDbContext.cs similarity index 97% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/SnapshotStoreDbContext.cs rename to src/src/SqlServer/Snapshots/EntityFramework/SnapshotStoreDbContext.cs index 773a60d5..856814af 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/SnapshotStoreDbContext.cs +++ b/src/src/SqlServer/Snapshots/EntityFramework/SnapshotStoreDbContext.cs @@ -29,7 +29,7 @@ string tableName /// Schema and table names default to "dbo" and "Snapshots". /// public SnapshotStoreDbContext(DbContextOptions options) - : this(options, "dbo", "Snapshots") { } + : this(options, "dbo", "EventStoreSnapshots") { } protected override void OnModelCreating(ModelBuilder modelBuilder) { diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/SnapshotStoreDbContextDesignTimeFactory.cs b/src/src/SqlServer/Snapshots/EntityFramework/SnapshotStoreDbContextDesignTimeFactory.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/SnapshotStoreDbContextDesignTimeFactory.cs rename to src/src/SqlServer/Snapshots/EntityFramework/SnapshotStoreDbContextDesignTimeFactory.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/SnapshotStoreEntity.cs b/src/src/SqlServer/Snapshots/EntityFramework/SnapshotStoreEntity.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/EntityFramework/SnapshotStoreEntity.cs rename to src/src/SqlServer/Snapshots/EntityFramework/SnapshotStoreEntity.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/ISqlServerSnapshotEventStore.cs b/src/src/SqlServer/Snapshots/ISqlServerSnapshotEventStore.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/ISqlServerSnapshotEventStore.cs rename to src/src/SqlServer/Snapshots/ISqlServerSnapshotEventStore.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/ISqlServerSnapshotEventStoreTelemetry.cs b/src/src/SqlServer/Snapshots/ISqlServerSnapshotEventStoreTelemetry.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/ISqlServerSnapshotEventStoreTelemetry.cs rename to src/src/SqlServer/Snapshots/ISqlServerSnapshotEventStoreTelemetry.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStore.EventStore.cs b/src/src/SqlServer/Snapshots/SqlServerSnapshotEventStore.EventStore.cs similarity index 95% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStore.EventStore.cs rename to src/src/SqlServer/Snapshots/SqlServerSnapshotEventStore.EventStore.cs index ee396f9a..5852dcfe 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStore.EventStore.cs +++ b/src/src/SqlServer/Snapshots/SqlServerSnapshotEventStore.EventStore.cs @@ -1,6 +1,7 @@ using System.Data.Common; using Microsoft.Data.SqlClient; using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Aggregates.Snapshotting; using Purview.EventSourcing.Internal; @@ -202,6 +203,13 @@ public Task ExistsAsync(string aggregateId, CancellationToken cance public T FulfilRequirements(T aggregate) => _eventStore.FulfilRequirements(aggregate); + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) => _eventStore.GetEventRangeAsync(aggregateId, versionFrom, versionTo, cancellationToken); + static SqlConnection GetSqlConnection(DbConnection connection) => connection as SqlConnection ?? throw new InvalidOperationException("SQL Server transactions require a SqlConnection."); diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStore.Query.cs b/src/src/SqlServer/Snapshots/SqlServerSnapshotEventStore.Query.cs similarity index 100% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStore.Query.cs rename to src/src/SqlServer/Snapshots/SqlServerSnapshotEventStore.Query.cs diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStore.cs b/src/src/SqlServer/Snapshots/SqlServerSnapshotEventStore.cs similarity index 87% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStore.cs rename to src/src/SqlServer/Snapshots/SqlServerSnapshotEventStore.cs index 1e40cc79..03e5033f 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStore.cs +++ b/src/src/SqlServer/Snapshots/SqlServerSnapshotEventStore.cs @@ -43,7 +43,7 @@ public SqlServerSnapshotEventStore( _aggregateName = TypeNameHelper.GetName(_aggregateType, "Aggregate"); var clientOptions = ResolveClientOptions(_sqlServerEventStoreOptions.Value, _aggregateName); - _sqlServerClient = new SqlServerClient(clientOptions); + _sqlServerClient = new(clientOptions); } /// @@ -60,16 +60,19 @@ static SqlServerClientOptions ResolveClientOptions(SqlServerSnapshotEventStoreOp table = ovr.TableName ?? table; } - return new SqlServerClientOptions(options.ConnectionString, options.UseDataCompression) + return new(options.ConnectionString, options.UseDataCompression) { TableName = table, SchemaName = schema, AutoCreateTable = options.AutoCreateTable, + JsonIndexOptions = options.JsonIndexOptions, }; } /// - /// This will upsert the aggregate regardless of it's save state in the internal event store. + /// This will upsert the aggregate in the snapshot store. + /// Note if the aggregate has unsaved events, it will first save those + /// events to the event store before upserting the snapshot to ensure consistency. /// /// /// @@ -77,6 +80,9 @@ public async Task SnapshotAsync(T aggregate, CancellationToken cancellationToken { ArgumentNullException.ThrowIfNull(aggregate, nameof(aggregate)); + if (aggregate.HasUnsavedEvents()) + await _eventStore.SaveAsync(aggregate, cancellationToken); + _telemetry.SnapshotSaveStart(aggregate.Details.Id, _aggregateName); using var activity = _telemetry.SnapshotSave(aggregate.Details.Id, _aggregateName); diff --git a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStoreOptions.cs b/src/src/SqlServer/Snapshots/SqlServerSnapshotEventStoreOptions.cs similarity index 85% rename from src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStoreOptions.cs rename to src/src/SqlServer/Snapshots/SqlServerSnapshotEventStoreOptions.cs index 4885d3b3..edaf1022 100644 --- a/src/src/EventSourcing.SqlServer/SqlServer/Snapshots/SqlServerSnapshotEventStoreOptions.cs +++ b/src/src/SqlServer/Snapshots/SqlServerSnapshotEventStoreOptions.cs @@ -16,12 +16,14 @@ public sealed class SqlServerSnapshotAggregateTableOverride /// Overrides the schema name for this aggregate type. /// When null, the global is used. /// + [RegularExpression(@"^[\w\-.]+$")] public string? SchemaName { get; set; } /// /// Overrides the table name for this aggregate type. /// When null, the global is used. /// + [RegularExpression(@"^[\w\-.]+$")] public string? TableName { get; set; } } @@ -32,8 +34,12 @@ public sealed class SqlServerSnapshotEventStoreOptions [Required] public string ConnectionString { get; set; } = default!; - public string TableName { get; set; } = "Snapshots"; + [Required(AllowEmptyStrings = false)] + [RegularExpression(@"^[\w\-.]+$")] + public string TableName { get; set; } = "EventStoreSnapshots"; + [Required(AllowEmptyStrings = false)] + [RegularExpression(@"^[\w\-.]+$")] public string SchemaName { get; set; } = "dbo"; /// @@ -77,4 +83,10 @@ public sealed class SqlServerSnapshotEventStoreOptions /// public Dictionary AggregateTableOverrides { get; init; } = [with(StringComparer.OrdinalIgnoreCase)]; + + /// + /// Configures runtime-managed SQL Server indexes over the snapshot payload JSON column. + /// + [Required] + public SqlServerJsonIndexOptions JsonIndexOptions { get; set; } = new(); } diff --git a/src/src/SqlServer/Snapshots/SqlServerSnapshotEventStoreOptionsValidator.cs b/src/src/SqlServer/Snapshots/SqlServerSnapshotEventStoreOptionsValidator.cs new file mode 100644 index 00000000..0d2007c6 --- /dev/null +++ b/src/src/SqlServer/Snapshots/SqlServerSnapshotEventStoreOptionsValidator.cs @@ -0,0 +1,38 @@ +using System.ComponentModel.DataAnnotations; +using Microsoft.Extensions.Options; +using Purview.EventSourcing.SqlServer.Client; + +namespace Purview.EventSourcing.SqlServer.Snapshots; + +sealed class SqlServerSnapshotEventStoreOptionsValidator : IValidateOptions +{ + public ValidateOptionsResult Validate(string? name, SqlServerSnapshotEventStoreOptions options) + { + ArgumentNullException.ThrowIfNull(options); + var validationContext = new ValidationContext(options); + var validationResults = new List(); + if (!Validator.TryValidateObject(options, validationContext, validationResults, validateAllProperties: true)) + return ValidateOptionsResult.Fail( + validationResults.Select(static x => x.ErrorMessage ?? "Options validation failed.") + ); + + try + { + _ = new SqlServerClient( + new SqlServerClientOptions(options.ConnectionString, options.UseDataCompression) + { + SchemaName = options.SchemaName, + TableName = options.TableName, + AutoCreateTable = options.AutoCreateTable, + JsonIndexOptions = options.JsonIndexOptions, + } + ); + + return ValidateOptionsResult.Success; + } + catch (ArgumentException ex) + { + return ValidateOptionsResult.Fail(ex.Message); + } + } +} diff --git a/src/src/EventSourcing.SqlServer/EventSourcing.SqlServer.csproj b/src/src/SqlServer/SqlServer.csproj similarity index 73% rename from src/src/EventSourcing.SqlServer/EventSourcing.SqlServer.csproj rename to src/src/SqlServer/SqlServer.csproj index 0ec84d0a..170abaf3 100644 --- a/src/src/EventSourcing.SqlServer/EventSourcing.SqlServer.csproj +++ b/src/src/SqlServer/SqlServer.csproj @@ -1,22 +1,12 @@  - - Purview.EventSourcing - - true Purview Event Store for Azure SQL and SQL Server Azure SQL and SQL Server event stream storage provider for Purview EventSourcing. + $(PackageTags);purview;dotnet;event-sourcing;event-store;sql-server;azure-sql;events; Purview.EventSourcing.SqlServer - $(PackageTags);purview;kjldev;dotnet;event-sourcing;event-store;sql-server;azure-sql;events; - - - <_Parameter1>EventSourcing.UnitTests - - - @@ -32,5 +22,9 @@ + diff --git a/src/src/SqlServer/SqlServerJsonIndexOptions.cs b/src/src/SqlServer/SqlServerJsonIndexOptions.cs new file mode 100644 index 00000000..01546e55 --- /dev/null +++ b/src/src/SqlServer/SqlServerJsonIndexOptions.cs @@ -0,0 +1,90 @@ +using System.ComponentModel.DataAnnotations; +using System.Diagnostics.CodeAnalysis; + +namespace Purview.EventSourcing.SqlServer; + +/// +/// Configures runtime-managed SQL Server indexes over JSON payload columns. +/// +public sealed class SqlServerJsonIndexOptions +{ + /// + /// Gets or sets a value indicating whether configured JSON indexes should be created + /// when AutoCreateTable is enabled for the store. + /// + public bool Enabled { get; set; } + + /// + /// Gets or sets the JSON indexes to create for the payload column. + /// + [SuppressMessage("Performance", "CA1819:Properties should not return arrays", Justification = "DTO")] + public SqlServerJsonIndexDefinition[] Indexes { get; set; } = []; +} + +/// +/// Defines a single SQL Server index over a JSON payload path. +/// +public sealed class SqlServerJsonIndexDefinition +{ + /// + /// Gets or sets the JSON path to extract from the payload column. + /// Example: $.Status or $.Customer.Name. + /// + [Required] + public string JsonPath { get; set; } = default!; + + /// + /// Gets or sets the optional SQL index name. When omitted, a deterministic name is generated. + /// + public string? IndexName { get; set; } + + /// + /// Gets or sets the optional computed-column name used to materialize the JSON path. + /// When omitted, a deterministic name is generated. + /// + public string? ComputedColumnName { get; set; } + + /// + /// Gets or sets the SQL type used when casting the extracted JSON value. + /// + [Required] + public string SqlType { get; set; } = "nvarchar(450)"; + + /// + /// Gets or sets a value indicating whether the generated index should be unique. + /// + public bool Unique { get; set; } + + /// + /// Gets or sets the computed-column persistence mode. + /// + [EnumDataType(typeof(SqlServerJsonComputedColumnMode))] + public SqlServerJsonComputedColumnMode ComputedColumnMode { get; set; } = SqlServerJsonComputedColumnMode.Persisted; + + /// + /// Gets or sets the optional include columns for the generated index. + /// + [SuppressMessage("Performance", "CA1819:Properties should not return arrays", Justification = "DTO")] + public string[] IncludeColumns { get; set; } = []; + + /// + /// Gets or sets the optional SQL filter clause for the generated index. + /// + public string? Filter { get; set; } +} + +/// +/// Controls whether generated JSON computed columns are persisted. +/// +public enum SqlServerJsonComputedColumnMode +{ + /// + /// Creates a non-persisted computed column. + /// + NonPersisted = 0, + + /// + /// Creates a persisted computed column. + /// + Persisted = 1, +} diff --git a/src/src/SqlServer/SqlServerJsonIndexSchemaManager.cs b/src/src/SqlServer/SqlServerJsonIndexSchemaManager.cs new file mode 100644 index 00000000..e930646c --- /dev/null +++ b/src/src/SqlServer/SqlServerJsonIndexSchemaManager.cs @@ -0,0 +1,368 @@ +using System.Collections.ObjectModel; +using System.Security.Cryptography; +using System.Text; +using System.Text.RegularExpressions; +using Microsoft.Data.SqlClient; + +namespace Purview.EventSourcing.SqlServer; + +static partial class SqlServerJsonIndexSchemaManager +{ + public static void ValidateOrThrow( + SqlServerJsonIndexOptions? options, + string schemaName, + string tableName, + IReadOnlySet supportedIncludeColumns, + string optionsName + ) + { + _ = CreateDescriptors(options, schemaName, tableName, supportedIncludeColumns, optionsName); + } + + public static async Task ApplyAsync( + SqlConnection connection, + SqlTransaction? transaction, + string schemaName, + string tableName, + SqlServerJsonIndexOptions? options, + IReadOnlySet supportedIncludeColumns, + CancellationToken cancellationToken + ) + { + ArgumentNullException.ThrowIfNull(connection); + + var descriptors = CreateDescriptors( + options, + schemaName, + tableName, + supportedIncludeColumns, + optionsName: "JsonIndexOptions" + ); + if (descriptors.Count == 0) + return; + + foreach ( + var computedColumn in descriptors + .Select(static x => x.ComputedColumn) + .DistinctBy(static x => x.Name, StringComparer.OrdinalIgnoreCase) + ) + { + if ( + await ColumnExistsAsync( + connection, + transaction, + schemaName, + tableName, + computedColumn.Name, + cancellationToken + ) + ) + continue; + + await ExecuteNonQueryIgnoringDuplicateSchemaAsync( + connection, + transaction, + $"ALTER TABLE {QuoteTableName(schemaName, tableName)} ADD {QuoteIdentifier(computedColumn.Name)} AS ({computedColumn.Expression}){(computedColumn.Persisted ? " PERSISTED" : string.Empty)};", + cancellationToken + ); + } + + foreach (var descriptor in descriptors) + { + if ( + await IndexExistsAsync( + connection, + transaction, + schemaName, + tableName, + descriptor.IndexName, + cancellationToken + ) + ) + continue; + + var includeClause = + descriptor.IncludeColumns.Count == 0 + ? string.Empty + : $" INCLUDE ({string.Join(", ", descriptor.IncludeColumns.Select(QuoteIdentifier))})"; + var filterClause = string.IsNullOrWhiteSpace(descriptor.Filter) + ? string.Empty + : $" WHERE {descriptor.Filter}"; + + await ExecuteNonQueryIgnoringDuplicateSchemaAsync( + connection, + transaction, + $"CREATE {(descriptor.Unique ? "UNIQUE " : string.Empty)}INDEX {QuoteIdentifier(descriptor.IndexName)} ON {QuoteTableName(schemaName, tableName)} ({QuoteIdentifier(descriptor.ComputedColumn.Name)}){includeClause}{filterClause};", + cancellationToken + ); + } + } + + static ReadOnlyCollection CreateDescriptors( + SqlServerJsonIndexOptions? options, + string schemaName, + string tableName, + IReadOnlySet supportedIncludeColumns, + string optionsName + ) + { + ValidateIdentifier(schemaName, nameof(schemaName)); + ValidateIdentifier(tableName, nameof(tableName)); + + if (options is null || !options.Enabled || options.Indexes.Length == 0) + return Array.Empty().AsReadOnly(); + + var errors = new List(); + var indexNames = new HashSet(StringComparer.OrdinalIgnoreCase); + var computedColumns = new Dictionary( + StringComparer.OrdinalIgnoreCase + ); + var logicalKeys = new HashSet(StringComparer.OrdinalIgnoreCase); + var descriptors = new List(); + + for (var i = 0; i < options.Indexes.Length; i++) + { + var errorCountBeforeDefinition = errors.Count; + var definition = options.Indexes[i]; + if (definition is null) + { + errors.Add($"{optionsName}.Indexes[{i}] cannot be null."); + continue; + } + + var jsonPath = definition.JsonPath?.Trim(); + if (string.IsNullOrWhiteSpace(jsonPath) || !jsonPath.StartsWith('$')) + errors.Add($"{optionsName}.Indexes[{i}].JsonPath must start with '$'."); + + var sqlType = definition.SqlType?.Trim(); + if (string.IsNullOrWhiteSpace(sqlType) || !SqlTypeRegex().IsMatch(sqlType)) + errors.Add($"{optionsName}.Indexes[{i}].SqlType '{definition.SqlType}' is not supported."); + + var filter = string.IsNullOrWhiteSpace(definition.Filter) ? null : definition.Filter.Trim(); + if (filter is not null && !IsSafeFilter(filter)) + errors.Add($"{optionsName}.Indexes[{i}].Filter contains unsupported SQL text."); + + var normalizedIncludeColumns = new List(); + var seenIncludeColumns = new HashSet(StringComparer.OrdinalIgnoreCase); + foreach (var includeColumn in definition.IncludeColumns ?? []) + { + if (string.IsNullOrWhiteSpace(includeColumn)) + { + errors.Add($"{optionsName}.Indexes[{i}].IncludeColumns cannot contain empty values."); + continue; + } + + var normalizedColumn = includeColumn.Trim(); + if (!seenIncludeColumns.Add(normalizedColumn)) + { + errors.Add( + $"{optionsName}.Indexes[{i}].IncludeColumns contains duplicate column '{normalizedColumn}'." + ); + continue; + } + + ValidateIdentifier(normalizedColumn, $"{optionsName}.Indexes[{i}].IncludeColumns"); + if (!supportedIncludeColumns.Contains(normalizedColumn)) + errors.Add( + $"{optionsName}.Indexes[{i}].IncludeColumns contains unsupported column '{normalizedColumn}'." + ); + + normalizedIncludeColumns.Add(normalizedColumn); + } + + if (errors.Count > errorCountBeforeDefinition) + continue; + + var computedColumnKey = $"{jsonPath}|{sqlType}|{definition.ComputedColumnMode}"; + var computedColumnName = string.IsNullOrWhiteSpace(definition.ComputedColumnName) + ? $"JX_{CreateStableHash(computedColumnKey)}" + : definition.ComputedColumnName.Trim(); + ValidateIdentifier(computedColumnName, $"{optionsName}.Indexes[{i}].ComputedColumnName"); + + var logicalIndexKey = string.Join( + "|", + jsonPath, + sqlType, + definition.ComputedColumnMode, + definition.Unique, + filter ?? string.Empty, + string.Join(",", normalizedIncludeColumns) + ); + if (!logicalKeys.Add(logicalIndexKey)) + errors.Add($"{optionsName}.Indexes[{i}] duplicates another JSON index definition."); + + var indexName = string.IsNullOrWhiteSpace(definition.IndexName) + ? $"IX_{tableName}_{CreateStableHash(logicalIndexKey)}" + : definition.IndexName.Trim(); + ValidateIdentifier(indexName, $"{optionsName}.Indexes[{i}].IndexName"); + + if (!indexNames.Add(indexName)) + errors.Add($"{optionsName}.Indexes contains duplicate index name '{indexName}'."); + + var computedColumn = new SqlServerJsonComputedColumnDescriptor( + computedColumnName, + $"TRY_CAST(JSON_VALUE([Payload], N'{EscapeSqlLiteral(jsonPath!)}') AS {sqlType})", + definition.ComputedColumnMode == SqlServerJsonComputedColumnMode.Persisted + ); + + if (computedColumns.TryGetValue(computedColumn.Name, out var existingComputedColumn)) + { + if ( + !string.Equals( + existingComputedColumn.Expression, + computedColumn.Expression, + StringComparison.Ordinal + ) + || existingComputedColumn.Persisted != computedColumn.Persisted + ) + { + errors.Add( + $"{optionsName}.Indexes contains conflicting computed-column configuration for '{computedColumn.Name}'." + ); + } + } + else + { + computedColumns.Add(computedColumn.Name, computedColumn); + } + + descriptors.Add( + new SqlServerJsonIndexDescriptor( + indexName, + computedColumn, + definition.Unique, + normalizedIncludeColumns.AsReadOnly(), + filter + ) + ); + } + + if (errors.Count > 0) + throw new ArgumentException(string.Join(Environment.NewLine, errors), optionsName); + + // Sort descriptors by index name for deterministic order + return descriptors.AsReadOnly(); + } + + static async Task ColumnExistsAsync( + SqlConnection connection, + SqlTransaction? transaction, + string schemaName, + string tableName, + string columnName, + CancellationToken cancellationToken + ) + { + await using var command = new SqlCommand( + """ + SELECT COUNT(1) + FROM sys.columns c + INNER JOIN sys.tables t ON t.object_id = c.object_id + INNER JOIN sys.schemas s ON s.schema_id = t.schema_id + WHERE s.name = @schemaName AND t.name = @tableName AND c.name = @columnName; + """, + connection, + transaction + ); + command.Parameters.AddWithValue("@schemaName", schemaName); + command.Parameters.AddWithValue("@tableName", tableName); + command.Parameters.AddWithValue("@columnName", columnName); + var count = (int)(await command.ExecuteScalarAsync(cancellationToken) ?? 0); + return count > 0; + } + + static async Task IndexExistsAsync( + SqlConnection connection, + SqlTransaction? transaction, + string schemaName, + string tableName, + string indexName, + CancellationToken cancellationToken + ) + { + await using var command = new SqlCommand( + """ + SELECT COUNT(1) + FROM sys.indexes i + INNER JOIN sys.tables t ON t.object_id = i.object_id + INNER JOIN sys.schemas s ON s.schema_id = t.schema_id + WHERE s.name = @schemaName AND t.name = @tableName AND i.name = @indexName; + """, + connection, + transaction + ); + command.Parameters.AddWithValue("@schemaName", schemaName); + command.Parameters.AddWithValue("@tableName", tableName); + command.Parameters.AddWithValue("@indexName", indexName); + var count = (int)(await command.ExecuteScalarAsync(cancellationToken) ?? 0); + return count > 0; + } + + static async Task ExecuteNonQueryIgnoringDuplicateSchemaAsync( + SqlConnection connection, + SqlTransaction? transaction, + string sql, + CancellationToken cancellationToken + ) + { + try + { +#pragma warning disable CA2100 + await using var command = new SqlCommand(sql, connection, transaction); +#pragma warning restore CA2100 + await command.ExecuteNonQueryAsync(cancellationToken); + } + catch (SqlException ex) when (ex.Number is 1911 or 1913 or 2705) + { + // Cross-process duplicate create race; treat as success. + } + } + + static string QuoteTableName(string schemaName, string tableName) => + $"{QuoteIdentifier(schemaName)}.{QuoteIdentifier(tableName)}"; + + static string QuoteIdentifier(string identifier) => $"[{identifier}]"; + + static string EscapeSqlLiteral(string value) => value.Replace("'", "''", StringComparison.Ordinal); + + static string CreateStableHash(string value) + { + var hash = SHA256.HashData(Encoding.UTF8.GetBytes(value)); + return Convert.ToHexString(hash[..6]); + } + + static bool IsSafeFilter(string filter) => + !filter.Contains(';', StringComparison.Ordinal) + && !filter.Contains("--", StringComparison.Ordinal) + && !filter.Contains("/*", StringComparison.Ordinal) + && !filter.Contains("*/", StringComparison.Ordinal) + && FilterRegex().IsMatch(filter); + + static void ValidateIdentifier(string identifier, string parameterName) + { + if (string.IsNullOrWhiteSpace(identifier)) + throw new ArgumentException("Identifier cannot be null or empty.", parameterName); + + if (!IdentifierRegex().IsMatch(identifier)) + throw new ArgumentException($"Identifier '{identifier}' contains invalid characters.", parameterName); + } + + [GeneratedRegex(@"^[\w\-\.]+$")] + private static partial Regex IdentifierRegex(); + + [GeneratedRegex(@"^[A-Za-z][A-Za-z0-9]*(?:\s*\(\s*\d+\s*(?:,\s*\d+\s*)?\))?$")] + private static partial Regex SqlTypeRegex(); + + [GeneratedRegex(@"^[\[\]\w\s\=\<\>\!\(\)'\.,-]+$")] + private static partial Regex FilterRegex(); + + sealed record SqlServerJsonComputedColumnDescriptor(string Name, string Expression, bool Persisted); + + sealed record SqlServerJsonIndexDescriptor( + string IndexName, + SqlServerJsonComputedColumnDescriptor ComputedColumn, + bool Unique, + ReadOnlyCollection IncludeColumns, + string? Filter + ); +} diff --git a/src/src/ZodSharpImpl/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs b/src/src/ZodSharpImpl/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs new file mode 100644 index 00000000..666c48b8 --- /dev/null +++ b/src/src/ZodSharpImpl/Extensions/Microsoft/Extensions/DependencyInjection/ServiceCollectionExtensions.cs @@ -0,0 +1,64 @@ +using System.ComponentModel; +using System.Diagnostics.CodeAnalysis; +using Purview.EventSourcing.Services; +using Purview.EventSourcing.ZodSharp.Services; +using ZodSharp.Core; + +namespace Microsoft.Extensions.DependencyInjection; + +[EditorBrowsable(EditorBrowsableState.Never)] +public static class ServiceCollectionExtensions +{ + /// + /// Registers a adapter + /// for the specified aggregate type, wrapping the registered + /// . + /// + /// The aggregate type. + /// The ZodSharp schema validator implementation. + /// The service collection. + /// The lifetime used to register the validator + /// The for fluent chaining. + public static IServiceCollection AddZodSharpAdapter( + [NotNull] this IServiceCollection services, + ServiceLifetime lifetime = ServiceLifetime.Singleton + ) + where TAggregate : Purview.EventSourcing.Aggregates.IAggregate + where TValidator : class, IZodSchemaValidator + { + services.Add(new(typeof(IZodSchemaValidator), typeof(TValidator), lifetime)); + services.AddSingleton, ZodSharpAggregateValidator>(); + + return services; + } + + /// + /// Registers a adapter + /// using a factory that resolves from the container. + /// Use this when validators are already registered (e.g. via AddValidatorsFromAssembly). + /// + /// The aggregate type. + /// The service collection. + /// The lifetime used to register the validator + /// The for fluent chaining. + public static IServiceCollection AddZodSharpAdapter( + [NotNull] this IServiceCollection services, + ServiceLifetime lifetime = ServiceLifetime.Singleton + ) + where TAggregate : Purview.EventSourcing.Aggregates.IAggregate + { + services.Add( + new( + typeof(IZodSchemaValidator), + sp => + { + var validator = sp.GetService>(); + return validator is null ? null! : new ZodSharpAggregateValidator(validator); + }, + lifetime + ) + ); + + return services; + } +} diff --git a/src/src/ZodSharpImpl/Properties/AssemblyInfo.cs b/src/src/ZodSharpImpl/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..1502baea --- /dev/null +++ b/src/src/ZodSharpImpl/Properties/AssemblyInfo.cs @@ -0,0 +1,4 @@ +using Purview.Telemetry; + +[assembly: ActivitySourceGeneration("Purview.EventSourcing.ZodSharp")] +[assembly: MeterGeneration("Purview.EventSourcing.ZodSharp")] diff --git a/src/src/ZodSharpImpl/Services/ZodSharpAggregateValidator.cs b/src/src/ZodSharpImpl/Services/ZodSharpAggregateValidator.cs new file mode 100644 index 00000000..66145c98 --- /dev/null +++ b/src/src/ZodSharpImpl/Services/ZodSharpAggregateValidator.cs @@ -0,0 +1,30 @@ +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Services; +using Purview.EventSourcing.Validation; +using ZodSharp.Core; + +namespace Purview.EventSourcing.ZodSharp.Services; + +public sealed class ZodSharpAggregateValidator(IZodSchemaValidator validator) + : IAggregateValidator + where TAggregate : IAggregate +{ + public ValidationResult Validate(TAggregate aggregate) => Convert(validator.Validate(aggregate)); + + public async Task ValidateAsync( + TAggregate aggregate, + CancellationToken cancellationToken = default + ) + { + var result = await validator.ValidateAsync(aggregate, cancellationToken); + + return Convert(result); + } + + static ValidationResult Convert(ValidationResult validationResult) => + validationResult.IsSuccess + ? ValidationResult.Success + : new ValidationResult( + validationResult.Errors.Select(e => new ValidationFailure(string.Join('.', e.Path), e.Message)) + ); +} diff --git a/src/src/ZodSharpImpl/ZodSharpImpl.csproj b/src/src/ZodSharpImpl/ZodSharpImpl.csproj new file mode 100644 index 00000000..31a27c7e --- /dev/null +++ b/src/src/ZodSharpImpl/ZodSharpImpl.csproj @@ -0,0 +1,23 @@ + + + true + Purview Event Sourcing ZodSharp Integration + ZodSharp adapter for Purview EventSourcing — bridges FluentValidation IValidator<T> with IAggregateValidator<T>. + $(PackageTags);purview;dotnet;event-sourcing;validation;zod;zodsharp; + Purview.EventSourcing.ZodSharp + Purview.EventSourcing.ZodSharp + + + + + + + + + + + diff --git a/src/src/ZodSharpImpl/buildTransitive/Purview.EventSourcing.ZodSharp.targets b/src/src/ZodSharpImpl/buildTransitive/Purview.EventSourcing.ZodSharp.targets new file mode 100644 index 00000000..22eaca3c --- /dev/null +++ b/src/src/ZodSharpImpl/buildTransitive/Purview.EventSourcing.ZodSharp.targets @@ -0,0 +1,19 @@ + + + + <_PurviewEventSourcingZodSharpPackage + Include="@(PackageReference)" + Condition="'%(PackageReference.Identity)' == 'Purview.EventSourcing.ZodSharp'" + /> + <_ZodSharpDirectPackage + Include="@(PackageReference)" + Condition="'%(PackageReference.Identity)' == 'ZodSharp'" + /> + + + + + diff --git a/src/tests/Admin.SqlServer.UnitTests/Admin.SqlServer.UnitTests.csproj b/src/tests/Admin.SqlServer.UnitTests/Admin.SqlServer.UnitTests.csproj new file mode 100644 index 00000000..73f383eb --- /dev/null +++ b/src/tests/Admin.SqlServer.UnitTests/Admin.SqlServer.UnitTests.csproj @@ -0,0 +1,14 @@ + + + false + + + + + + + + + + + diff --git a/src/tests/Admin.SqlServer.UnitTests/Internal/SqlServerAdminTableResolverTests.cs b/src/tests/Admin.SqlServer.UnitTests/Internal/SqlServerAdminTableResolverTests.cs new file mode 100644 index 00000000..746590b3 --- /dev/null +++ b/src/tests/Admin.SqlServer.UnitTests/Internal/SqlServerAdminTableResolverTests.cs @@ -0,0 +1,54 @@ +using Purview.EventSourcing.SqlServer.Events; + +namespace Purview.EventSourcing.Admin.SqlServer.Internal; + +public sealed class SqlServerAdminTableResolverTests +{ + [Test] + public async Task ResolveTables_ReturnsDefaultTable_WhenAggregateTypeIsNotSpecified() + { + var options = new SqlServerEventStoreOptions + { + ConnectionString = "Server=.;Database=Db;Trusted_Connection=True;", + SchemaName = "dbo", + TableName = "EventStoreEvents", + }; + + var tables = SqlServerAdminTableResolver.ResolveTables(options, null); + + if (tables.Count != 1) + throw new InvalidOperationException($"Expected 1 table, got {tables.Count}"); + + if (tables[0].SchemaName != "dbo") + throw new InvalidOperationException($"Expected dbo schema, got {tables[0].SchemaName}"); + + if (tables[0].TableName != "EventStoreEvents") + throw new InvalidOperationException($"Expected EventStoreEvents table, got {tables[0].TableName}"); + } + + [Test] + public async Task ResolveTable_UsesAggregateOverride_WhenConfigured() + { + var options = new SqlServerEventStoreOptions + { + ConnectionString = "Server=.;Database=Db;Trusted_Connection=True;", + SchemaName = "dbo", + TableName = "EventStoreEvents", + AggregateTableOverrides = + { + ["Order"] = new SqlServerAggregateTableOverride { SchemaName = "orders", TableName = "OrderEvents" }, + }, + }; + + var table = SqlServerAdminTableResolver.ResolveTable(options, "Order"); + + if (table.AggregateTypeFilter != "Order") + throw new InvalidOperationException($"Expected Order filter, got {table.AggregateTypeFilter}"); + + if (table.SchemaName != "orders") + throw new InvalidOperationException($"Expected orders schema, got {table.SchemaName}"); + + if (table.TableName != "OrderEvents") + throw new InvalidOperationException($"Expected OrderEvents table, got {table.TableName}"); + } +} diff --git a/src/tests/Admin.SqlServer.UnitTests/SqlServerAdminProjectionServiceTests.cs b/src/tests/Admin.SqlServer.UnitTests/SqlServerAdminProjectionServiceTests.cs new file mode 100644 index 00000000..b776ff9d --- /dev/null +++ b/src/tests/Admin.SqlServer.UnitTests/SqlServerAdminProjectionServiceTests.cs @@ -0,0 +1,39 @@ +using Microsoft.Extensions.DependencyInjection; +using Purview.EventSourcing.Admin.Abstractions.Services; + +namespace Purview.EventSourcing.Admin.SqlServer; + +public class SqlServerAdminProjectionServiceTests +{ + [Test] + public async Task ProjectionService_IsRegisterable_InDependencyContainer() + { + // Arrange + var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); + var options = Microsoft.Extensions.Options.Options.Create( + new EventSourcing.SqlServer.Events.SqlServerEventStoreOptions { ConnectionString = "test" } + ); + + services.AddSingleton(options); + services.AddTransient(); + + var provider = services.BuildServiceProvider(); + + // Act + var service = provider.GetRequiredService(); + + // Assert + await Assert.That(service).IsNotNull(); + } + + [Test] + public async Task ProjectionService_Implements_IAdminProjectionService() + { + // Arrange & Act + var service = typeof(SqlServerAdminProjectionService); + var interfaceType = typeof(IAdminProjectionService); + + // Assert + await Assert.That(service.GetInterfaces()).Contains(interfaceType); + } +} diff --git a/src/tests/Admin.UnitTests/Admin.UnitTests.csproj b/src/tests/Admin.UnitTests/Admin.UnitTests.csproj new file mode 100644 index 00000000..49855c62 --- /dev/null +++ b/src/tests/Admin.UnitTests/Admin.UnitTests.csproj @@ -0,0 +1,17 @@ + + + false + + + + + + + + + + + + + + diff --git a/src/tests/Admin.UnitTests/Api/OptionsValidationTests.cs b/src/tests/Admin.UnitTests/Api/OptionsValidationTests.cs new file mode 100644 index 00000000..1281ecba --- /dev/null +++ b/src/tests/Admin.UnitTests/Api/OptionsValidationTests.cs @@ -0,0 +1,101 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; + +namespace Purview.EventSourcing.Admin.Api; + +public sealed class OptionsValidationTests +{ + [Test] + public async Task AdminPortalOptions_Validate_ThrowsOnEmptyRoutePrefix() + { + // Arrange + var options = new AdminPortalOptions { RoutePrefix = "" }; + + // Act & Assert + await Assert.That(options.Validate).Throws(); + } + + [Test] + public async Task AdminPortalOptions_Validate_ThrowsIfRoutePrefixDoesNotStartWithSlash() + { + // Arrange + var options = new AdminPortalOptions { RoutePrefix = "admin/api" }; + + // Act & Assert + await Assert.That(options.Validate).Throws(); + } + + [Test] + public void AdminPortalOptions_Validate_SucceedsWithValidRoutePrefix() + { + // Arrange + var options = new AdminPortalOptions { RoutePrefix = "/admin/api" }; + + // Act & Assert - should not throw + options.Validate(); + } + + [Test] + public async Task AdminPagingOptions_Validate_ThrowsIfDefaultPageSizeIsZero() + { + // Arrange + var options = new AdminPagingOptions { DefaultPageSize = 0 }; + + // Act & Assert + await Assert.That(options.Validate).Throws(); + } + + [Test] + public async Task AdminPagingOptions_Validate_ThrowsIfDefaultPageSizeExceedsMax() + { + // Arrange + var options = new AdminPagingOptions { DefaultPageSize = 1000, MaxPageSize = 500 }; + + // Act & Assert + await Assert.That(options.Validate).Throws(); + } + + [Test] + public async Task AdminPagingOptions_Validate_ThrowsIfMaxPageSizeIsLessThanOne() + { + // Arrange + var options = new AdminPagingOptions { DefaultPageSize = 1, MaxPageSize = 0 }; + + // Act & Assert + await Assert.That(options.Validate).Throws(); + } + + [Test] + public async Task AdminProjectionOptions_Validate_ThrowsIfMaxVersionsPerQueryIsLessThanOne() + { + // Arrange + var options = new AdminProjectionOptions { MaxVersionsPerQuery = 0 }; + + // Act & Assert + await Assert.That(options.Validate).Throws(); + } + + [Test] + public async Task AdminProjectionOptions_Validate_ThrowsIfMaxTimeRangePerQueryIsNegative() + { + // Arrange + var options = new AdminProjectionOptions { MaxTimeRangePerQuery = TimeSpan.FromSeconds(-1) }; + + // Act & Assert + await Assert.That(options.Validate).Throws(); + } + + [Test] + public async Task AdminPortalOptions_ServiceCollection_ValidatesOnStart() + { + // Arrange + var services = new ServiceCollection(); + services.AddPurviewEventSourcingAdminApi(opts => opts.RoutePrefix = ""); + + var provider = services.BuildServiceProvider(); + AdminPortalOptions ResolveInvalidOptions() => provider.GetRequiredService>().Value; + + // Act & Assert + await Assert.That(ResolveInvalidOptions).Throws(); + } +} diff --git a/src/tests/Admin.UnitTests/Security/PermissionProviderTests.cs b/src/tests/Admin.UnitTests/Security/PermissionProviderTests.cs new file mode 100644 index 00000000..7b45149d --- /dev/null +++ b/src/tests/Admin.UnitTests/Security/PermissionProviderTests.cs @@ -0,0 +1,101 @@ +using System.Security.Claims; +using Microsoft.AspNetCore.Authorization; +using Microsoft.Extensions.DependencyInjection; +using Purview.EventSourcing.Admin.Abstractions.Models; +using Purview.EventSourcing.Admin.Abstractions.Services; +using Purview.EventSourcing.Admin.Security.Providers; + +namespace Purview.EventSourcing.Admin.Security; + +public sealed class PermissionProviderTests +{ + [Test] + public async Task DenyAllPermissionProvider_ReturnsEmptyList_ForAnyUser() + { + // Arrange + var provider = new DenyAllPermissionProvider(); + var user = new ClaimsPrincipal(); + + // Act + var permissions = await provider.GetPermissionsAsync(user, CancellationToken.None); + + // Assert + await Assert.That(permissions).IsEmpty(); + } + + [Test] + public async Task DenyAllPermissionProvider_DeniesAllByDefault() + { + // Arrange + var provider = new DenyAllPermissionProvider(); + var user = new ClaimsPrincipal( + new ClaimsIdentity([new Claim(ClaimTypes.NameIdentifier, "user123"), new Claim(ClaimTypes.Role, "Admin")]) + ); + + // Act + var permissions = await provider.GetPermissionsAsync(user, CancellationToken.None); + + // Assert + await Assert.That(permissions).IsEmpty(); + } + + [Test] + public async Task ServiceCollection_RegistersSecurity_WithDefaults() + { + // Arrange + var services = new ServiceCollection(); + + // Act + services.AddPurviewEventSourcingAdminSecurity(); + var provider = services.BuildServiceProvider(); + var permissionProvider = provider.GetRequiredService(); + + // Assert — verify instance type + await Assert.That(permissionProvider).IsTypeOf(); + } + + [Test] + public async Task ServiceCollection_RegistersSecurity_WithCustomProvider() + { + // Arrange + var customProvider = new TestCustomPermissionProvider(); + var services = new ServiceCollection(); + + // Act + services.AddPurviewEventSourcingAdminSecurity(customProvider); + var provider = services.BuildServiceProvider(); + var resolvedProvider = provider.GetRequiredService(); + + // Assert — verify exact same instance (singleton registration) + await Assert.That(ReferenceEquals(resolvedProvider, customProvider)).IsTrue(); + } + + [Test] + public async Task ServiceCollection_RegistersAuthorizationHandlers() + { + // Arrange + var services = new ServiceCollection(); + services.AddAuthorizationBuilder(); + + // Act + services.AddPurviewEventSourcingAdminSecurity(); + var provider = services.BuildServiceProvider(); + + // Assert — verify handlers are registered + var handlers = provider.GetServices(); + await Assert.That(handlers).Count().IsGreaterThanOrEqualTo(2); + } + + sealed class TestCustomPermissionProvider : IAdminPermissionProvider + { + public Task> GetPermissionsAsync( + ClaimsPrincipal user, + CancellationToken cancellationToken + ) + { + return Task.FromResult>([ + new AdminPermission(AdminFeature.SearchAggregates, null, true), + ]); + } + } +} diff --git a/src/tests/AzureStorage.IntegrationTests/AzureStorage.IntegrationTests.csproj b/src/tests/AzureStorage.IntegrationTests/AzureStorage.IntegrationTests.csproj new file mode 100644 index 00000000..0e1a8e99 --- /dev/null +++ b/src/tests/AzureStorage.IntegrationTests/AzureStorage.IntegrationTests.csproj @@ -0,0 +1,5 @@ + + + + + diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.DeleteAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.DeleteAsync.cs similarity index 77% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.DeleteAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.DeleteAsync.cs index 927850ce..8c808d04 100644 --- a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.DeleteAsync.cs +++ b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.DeleteAsync.cs @@ -1,5 +1,3 @@ -using Purview.EventSourcing.ChangeFeed; - namespace Purview.EventSourcing.AzureStorage; partial class GenericTableEventStoreTests @@ -56,13 +54,13 @@ await eventStore.GetAsync(aggregateId, cancellationToken: cancellationToken) // Assert await Assert.That(result).IsTrue(); - await cache.Received(1).RemoveAsync(cacheKey, Arg.Any()); + cache.RemoveAsync(cacheKey, Any()).WasCalled(Times.Once); } public async Task DeleteAsync_GivenDelete_NotifiesChangeFeed(CancellationToken cancellationToken) { // Arrange - var aggregateChangeNotifier = Substitute.For>(); + var aggregateChangeNotifier = TestHelpers.CreateAggregateChangeFeedNotified(); var beforeWasCalled = false; var afterWasCalled = false; @@ -70,15 +68,15 @@ public async Task DeleteAsync_GivenDelete_NotifiesChangeFeed(CancellationToken c var aggregate = TestHelpers.Aggregate(aggregateId: aggregateId); aggregate.IncrementInt32Value(); - var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); + var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); aggregateChangeNotifier - .When(m => m.BeforeDeleteAsync(aggregate, Arg.Any())) - .Do(_ => beforeWasCalled = true); + .BeforeDeleteAsync(aggregate, Any()) + .Callback(() => beforeWasCalled = true); aggregateChangeNotifier - .When(m => m.AfterDeleteAsync(aggregate, Arg.Any())) - .Do(_ => afterWasCalled = true); + .AfterDeleteAsync(aggregate, Any()) + .Callback(() => afterWasCalled = true); await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); @@ -89,8 +87,7 @@ public async Task DeleteAsync_GivenDelete_NotifiesChangeFeed(CancellationToken c await Assert.That(beforeWasCalled).IsTrue(); await Assert.That(afterWasCalled).IsTrue(); - await aggregateChangeNotifier.Received(1).BeforeDeleteAsync(aggregate, Arg.Any()); - - await aggregateChangeNotifier.Received(1).AfterDeleteAsync(aggregate, Arg.Any()); + aggregateChangeNotifier.BeforeDeleteAsync(aggregate, Any()).WasCalled(Times.Once); + aggregateChangeNotifier.AfterDeleteAsync(aggregate, Any()).WasCalled(Times.Once); } } diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAggregateIdsAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAggregateIdsAsync.cs similarity index 100% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAggregateIdsAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAggregateIdsAsync.cs diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAsync.cs similarity index 95% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAsync.cs index 37dafef6..a3af6e57 100644 --- a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAsync.cs +++ b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAsync.cs @@ -160,15 +160,15 @@ CancellationToken cancellationToken // Assert telemetry - .Received(numberOfOldEventsToCreate) .CannotApplyEvent( aggregateId, - Arg.Any(), - Arg.Any(), - Arg.Any(), - Arg.Is(eventType => eventType.Contains(typeof(OldEvent).Name, StringComparison.Ordinal)), - Arg.Any() - ); + Any(), + Any(), + Any(), + Is(eventType => eventType!.Contains(typeof(OldEvent).Name, StringComparison.Ordinal)), + Any() + ) + .WasCalled(Times.Exactly(numberOfOldEventsToCreate)); await Assert.That(result).IsNotNull(); await Assert.That(result.IsNew()).IsFalse(); @@ -240,8 +240,8 @@ CancellationToken cancellationToken // Assert telemetry - .Received(numberOfOldEventsToCreate) - .SkippedUnknownEvent(aggregateId, Arg.Any(), Arg.Any(), unknownEventType, Arg.Any()); + .SkippedUnknownEvent(aggregateId, Any(), Any(), unknownEventType, Any()) + .WasCalled(Times.Exactly(numberOfOldEventsToCreate)); await Assert.That(result).IsNotNull(); await Assert.That(result.IsNew()).IsFalse(); diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAtAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAtAsync.cs similarity index 100% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAtAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetAtAsync.cs diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetDeletedAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetDeletedAsync.cs similarity index 100% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetDeletedAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetDeletedAsync.cs diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetEventRangeAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetEventRangeAsync.cs similarity index 100% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetEventRangeAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetEventRangeAsync.cs diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetOrCreateAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetOrCreateAsync.cs similarity index 100% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetOrCreateAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.GetOrCreateAsync.cs diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.IsDeletedAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.IsDeletedAsync.cs similarity index 100% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.IsDeletedAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.IsDeletedAsync.cs diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.PermanentlyDeleteAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.PermanentlyDeleteAsync.cs similarity index 100% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.PermanentlyDeleteAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.PermanentlyDeleteAsync.cs diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.RestoreAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.RestoreAsync.cs similarity index 100% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.RestoreAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.RestoreAsync.cs diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.Notify.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.Notify.cs similarity index 52% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.Notify.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.Notify.cs index f91691df..10182966 100644 --- a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.Notify.cs +++ b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.Notify.cs @@ -11,7 +11,7 @@ CancellationToken cancellationToken ) { // Arrange - var aggregateChangeNotifier = Substitute.For>(); + var aggregateChangeNotifier = TestHelpers.CreateAggregateChangeFeedNotified(); var beforeWasCalled = false; var afterWasCalled = false; @@ -20,29 +20,22 @@ CancellationToken cancellationToken for (var i = 0; i < eventsToCreate; i++) aggregate.AppendString($"{i + 1} of {eventsToCreate}(s) to created."); - var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); + var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); aggregateChangeNotifier - .When(m => m.BeforeSaveAsync(Arg.Is(aggregate), Arg.Is(true), Arg.Any())) - .Do(callInfo => - { - var a = callInfo.ArgAt(0); - a.AppendString(nameof(aggregateChangeNotifier.AfterSaveAsync)); - - beforeWasCalled = true; - }); + .BeforeSaveAsync(aggregate, true, Any()) + .Callback( + (a, _, _) => + { + a.AppendString(nameof(IAggregateChangeFeedProcessor.AfterSaveAsync)); + + beforeWasCalled = true; + } + ); aggregateChangeNotifier - .When(m => - m.AfterSaveAsync( - Arg.Is(aggregate), - Arg.Is(0), - Arg.Is(true), - Arg.Any(), - Arg.Any() - ) - ) - .Do(_ => afterWasCalled = true); + .AfterSaveAsync(aggregate, 0, true, Any(), Any()) + .Callback(() => afterWasCalled = true); // Act bool result = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); @@ -51,35 +44,35 @@ CancellationToken cancellationToken await Assert.That(beforeWasCalled).IsTrue(); await Assert.That(afterWasCalled).IsTrue(); - await aggregateChangeNotifier.Received(1).BeforeSaveAsync(aggregate, true, Arg.Any()); + aggregateChangeNotifier.BeforeSaveAsync(aggregate, true, Any()).WasCalled(Times.Once); - await aggregateChangeNotifier - .Received(1) + aggregateChangeNotifier .AfterSaveAsync( aggregate, 0, true, - Arg.Is(events => events.Length == eventsToCreate), - Arg.Any() - ); + Is(events => events!.Length == eventsToCreate), + Any() + ) + .WasCalled(Times.Once); } public async Task SaveAsync_GivenAggregateWithNoChanges_DoesNotNotifyChangeFeed(CancellationToken cancellationToken) { // Arrange - var aggregateChangeNotifier = Substitute.For>(); + var aggregateChangeNotifier = TestHelpers.CreateAggregateChangeFeedNotified(); var aggregateId = $"{Guid.NewGuid()}"; var aggregate = TestHelpers.Aggregate(aggregateId: aggregateId); - var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); + var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); // Act await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); // Assert - await aggregateChangeNotifier - .DidNotReceive() - .AfterSaveAsync(aggregate, 0, true, Arg.Any(), Arg.Any()); + aggregateChangeNotifier + .AfterSaveAsync(aggregate, 0, true, Any(), Any()) + .WasNeverCalled(); } } diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.cs similarity index 99% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.cs index ecb9141c..1f94f92e 100644 --- a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.cs +++ b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.SaveAsync.cs @@ -69,7 +69,7 @@ public async Task SaveAsync_GivenAggregateWithNoChanges_DoesNotSave(Cancellation // Assert await Assert.That(result).IsFalse(); - telemetry.Received(1).SaveContainedNoChanges(aggregateId, Arg.Any(), Arg.Any()); + telemetry.SaveContainedNoChanges(aggregateId, Any(), Any()).WasCalled(Times.Once); } public async Task SaveAsync_GivenNewAggregateWithChanges_SavesAggregate(CancellationToken cancellationToken) diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.cs b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.cs similarity index 98% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.cs rename to src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.cs index 559dd11d..7587676f 100644 --- a/src/tests/EventSourcing.AzureStorage.IntegrationTests/GenericTableEventStoreTests.cs +++ b/src/tests/AzureStorage.IntegrationTests/GenericTableEventStoreTests.cs @@ -4,7 +4,7 @@ namespace Purview.EventSourcing.AzureStorage; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public partial class GenericTableEventStoreTests(TableEventStoreFixture fixture) : ITableEventStoreTests where TAggregate : class, IAggregateTest, new() { diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/ITableEventStoreTests.cs b/src/tests/AzureStorage.IntegrationTests/ITableEventStoreTests.cs similarity index 100% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/ITableEventStoreTests.cs rename to src/tests/AzureStorage.IntegrationTests/ITableEventStoreTests.cs diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/TableEventStoreTests.TestData.cs b/src/tests/AzureStorage.IntegrationTests/TableEventStoreTests.TestData.cs similarity index 100% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/TableEventStoreTests.TestData.cs rename to src/tests/AzureStorage.IntegrationTests/TableEventStoreTests.TestData.cs diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/TableEventStoreTests.cs b/src/tests/AzureStorage.IntegrationTests/TableEventStoreTests.cs similarity index 99% rename from src/tests/EventSourcing.AzureStorage.IntegrationTests/TableEventStoreTests.cs rename to src/tests/AzureStorage.IntegrationTests/TableEventStoreTests.cs index b1a02713..63573792 100644 --- a/src/tests/EventSourcing.AzureStorage.IntegrationTests/TableEventStoreTests.cs +++ b/src/tests/AzureStorage.IntegrationTests/TableEventStoreTests.cs @@ -2,7 +2,7 @@ namespace Purview.EventSourcing.AzureStorage; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public sealed partial class TableEventStoreTests(TableEventStoreFixture fixture) { [Test] diff --git a/src/tests/CosmosDb.IntegrationTests/CosmosDb.IntegrationTests.csproj b/src/tests/CosmosDb.IntegrationTests/CosmosDb.IntegrationTests.csproj new file mode 100644 index 00000000..0e1a8e99 --- /dev/null +++ b/src/tests/CosmosDb.IntegrationTests/CosmosDb.IntegrationTests.csproj @@ -0,0 +1,5 @@ + + + + + diff --git a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Properties/AssemblyInfo.cs b/src/tests/CosmosDb.IntegrationTests/Properties/AssemblyInfo.cs similarity index 100% rename from src/tests/EventSourcing.CosmosDb.IntegrationTests/Properties/AssemblyInfo.cs rename to src/tests/CosmosDb.IntegrationTests/Properties/AssemblyInfo.cs diff --git a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.DeleteAsync.cs b/src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.DeleteAsync.cs similarity index 100% rename from src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.DeleteAsync.cs rename to src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.DeleteAsync.cs diff --git a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.FirstOrDefaultAsync.cs b/src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.FirstOrDefaultAsync.cs similarity index 97% rename from src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.FirstOrDefaultAsync.cs rename to src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.FirstOrDefaultAsync.cs index 05b3ca60..85db00d6 100644 --- a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.FirstOrDefaultAsync.cs +++ b/src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.FirstOrDefaultAsync.cs @@ -3,7 +3,7 @@ partial class CosmosDbSnapshotEventStoreTests { [Test] - public async Task FirstOrDefaultAsync_GivenMultipleMatchingAggregatesHonoursDescendingOrder_ReturnsCorrectAggregate( + public async Task FirstOrDefaultAsync_GivenMultipleMatchingAggregatesHonorsDescendingOrder_ReturnsCorrectAggregate( CancellationToken cancellationToken ) { @@ -39,7 +39,7 @@ CancellationToken cancellationToken } [Test] - public async Task FirstOrDefaultAsync_GivenMultipleMatchingAggregatesHonoursAscendingOrder_ReturnsCorrectAggregate( + public async Task FirstOrDefaultAsync_GivenMultipleMatchingAggregatesHonorsAscendingOrder_ReturnsCorrectAggregate( CancellationToken cancellationToken ) { diff --git a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.QueryAsync.cs b/src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.QueryAsync.cs similarity index 100% rename from src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.QueryAsync.cs rename to src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.QueryAsync.cs diff --git a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.RestoreAsync.cs b/src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.RestoreAsync.cs similarity index 100% rename from src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.RestoreAsync.cs rename to src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.RestoreAsync.cs diff --git a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.SaveAsync.cs b/src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.SaveAsync.cs similarity index 100% rename from src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.SaveAsync.cs rename to src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.SaveAsync.cs diff --git a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.SingleOrDefaultAsync.cs b/src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.SingleOrDefaultAsync.cs similarity index 100% rename from src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.SingleOrDefaultAsync.cs rename to src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.SingleOrDefaultAsync.cs diff --git a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.WithStringValues.cs b/src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.WithStringValues.cs similarity index 100% rename from src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.WithStringValues.cs rename to src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.WithStringValues.cs diff --git a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.cs b/src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.cs similarity index 96% rename from src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.cs rename to src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.cs index 4b099c06..d62508ac 100644 --- a/src/tests/EventSourcing.CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.cs +++ b/src/tests/CosmosDb.IntegrationTests/Snapshots/CosmosDbSnapshotEventStoreTests.cs @@ -3,7 +3,7 @@ namespace Purview.EventSourcing.CosmosDb.Snapshots; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] [NotInParallel(nameof(CosmosDbClient))] public partial class CosmosDbSnapshotEventStoreTests(CosmosDbSnapshotEventStoreFixture fixture) { diff --git a/src/tests/EventSourcing.AzureStorage.IntegrationTests/EventSourcing.AzureStorage.IntegrationTests.csproj b/src/tests/EventSourcing.AzureStorage.IntegrationTests/EventSourcing.AzureStorage.IntegrationTests.csproj deleted file mode 100644 index 6129e37d..00000000 --- a/src/tests/EventSourcing.AzureStorage.IntegrationTests/EventSourcing.AzureStorage.IntegrationTests.csproj +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/src/tests/EventSourcing.CosmosDb.IntegrationTests/EventSourcing.CosmosDb.IntegrationTests.csproj b/src/tests/EventSourcing.CosmosDb.IntegrationTests/EventSourcing.CosmosDb.IntegrationTests.csproj deleted file mode 100644 index 6129e37d..00000000 --- a/src/tests/EventSourcing.CosmosDb.IntegrationTests/EventSourcing.CosmosDb.IntegrationTests.csproj +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/EventSourcing.Samples.AppHost.IntegrationTests.csproj b/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/EventSourcing.Samples.AppHost.IntegrationTests.csproj deleted file mode 100644 index 717dbfab..00000000 --- a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/EventSourcing.Samples.AppHost.IntegrationTests.csproj +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - - - - diff --git a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Fixtures/AppHostFixture.cs b/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Fixtures/AppHostFixture.cs deleted file mode 100644 index cf24e8a3..00000000 --- a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Fixtures/AppHostFixture.cs +++ /dev/null @@ -1,124 +0,0 @@ -using System.Data.SqlClient; -using Microsoft.Extensions.Configuration; -using Microsoft.Extensions.DependencyInjection; -using Purview.EventSourcing.Fixtures; -using TUnit.Aspire; - -namespace Purview.EventSourcing.Samples.AppHost.Fixtures; - -public sealed class AppHostFixture : AspireFixture, IServiceProvider -{ - readonly string _databaseName = $"EventSourcingSampleTest_" + $"{Guid.NewGuid():N}"[..8]; - readonly Lazy _appService; - - string? _databaseConnectionString; - - public AppHostFixture() - { - _appService = new(() => new(ConfigureAppServiceHelper)); - } - - protected override string[] Args => [$"--DatabaseName={_databaseName}", "--IsTestRun"]; - - public override async ValueTask DisposeAsync() - { - if (_appService.IsValueCreated) - await _appService.Value.DisposeAsync(); - - await base.DisposeAsync(); - } - - void ConfigureAppServiceHelper(IServiceCollection services, IConfigurationBuilder configurationBuilder) - { - ArgumentException.ThrowIfNullOrWhiteSpace(_databaseConnectionString); - - services - // The event stores... - .AddSqlServerEventStore() - .AddSqlServerSnapshotQueryableEventStore() - // Domain services... - .AddDomainServices(); - - configurationBuilder.AddInMemoryCollection([ - new KeyValuePair("ConnectionStrings:SqlServer", _databaseConnectionString), - ]); - } - - public override async Task InitializeAsync() - { - await base.InitializeAsync(); - - _databaseConnectionString = BuildDatabaseConnectionString( - await GetConnectionStringAsync("sql") - ?? throw new InvalidOperationException("The AppHost did not expose a database connection string.") - ); - - await WaitForWebAppAsync(CancellationToken.None); - } - - [System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope")] - [System.Diagnostics.CodeAnalysis.SuppressMessage( - "Reliability", - "CA5399:Do not use HttpClientHandler.AllowAutoRedirect" - )] - public HttpClient CreateWebClient() - { - var httpClient = CreateHttpClient("web", "http"); - - // We want auto redirect disabled for tests to be able to assert on 302 responses, - // but HttpClient doesn't allow changing that setting after the client is created, - // so we create a new client with the same base address and a handler that has auto redirect disabled. - return new(new HttpClientHandler() { AllowAutoRedirect = false }) { BaseAddress = httpClient.BaseAddress }; - } - - async Task WaitForWebAppAsync(CancellationToken cancellationToken) - { - using var client = CreateWebClient(); - client.Timeout = TimeSpan.FromSeconds(10); - - var timeoutAt = DateTimeOffset.UtcNow.AddMinutes(3); - while (DateTimeOffset.UtcNow < timeoutAt) - { - try - { - using var response = await client.GetAsync("/pingz", cancellationToken); - - if (TestContext.Current != null) - await TestContext.Current.OutputWriter.WriteLineAsync("Pingz Response: " + response.StatusCode); - - Console.WriteLine("Pingz Response: " + response.StatusCode); - - if (response.IsSuccessStatusCode) - return; - } - catch (Exception ex) when (DateTimeOffset.UtcNow < timeoutAt) - { - // Resource may still be starting. - if (TestContext.Current != null) - await TestContext.Current.OutputWriter.WriteLineAsync("Waiting for Web Failure: " + ex.Message); - - Console.WriteLine("Waiting for Web Failure: " + ex.Message); - } - - await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken); - } - - throw new InvalidOperationException("The web app resource did not become ready in time."); - } - - string BuildDatabaseConnectionString(string connectionString) - { - SqlConnectionStringBuilder builder = new(connectionString) { InitialCatalog = _databaseName }; - - return builder.ConnectionString; - } - - public IQueryableEventStore QueryableEventStore() => _appService.Value.GetRequiredService(); - - public IEventStore EventStore() => _appService.Value.GetRequiredService(); - - public object? GetService(Type serviceType) => _appService.Value.GetService(serviceType); - - public IServiceProvider CloneServices(Action? configure) => - _appService.Value.CloneServices(configure); -} diff --git a/src/tests/EventSourcing.Samples.IntegrationTests/EventSourcing.Samples.IntegrationTests.csproj b/src/tests/EventSourcing.Samples.IntegrationTests/EventSourcing.Samples.IntegrationTests.csproj deleted file mode 100644 index 6fda84b0..00000000 --- a/src/tests/EventSourcing.Samples.IntegrationTests/EventSourcing.Samples.IntegrationTests.csproj +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - diff --git a/src/tests/EventSourcing.Samples.IntegrationTests/Web/AuditPageIntegrationTests.cs b/src/tests/EventSourcing.Samples.IntegrationTests/Web/AuditPageIntegrationTests.cs deleted file mode 100644 index 987f6827..00000000 --- a/src/tests/EventSourcing.Samples.IntegrationTests/Web/AuditPageIntegrationTests.cs +++ /dev/null @@ -1,117 +0,0 @@ -using Microsoft.AspNetCore.Hosting; -using Microsoft.AspNetCore.Mvc.Testing; -using Microsoft.AspNetCore.TestHost; -using Microsoft.Extensions.DependencyInjection; -using Microsoft.Extensions.DependencyInjection.Extensions; -using Purview.EventSourcing.Samples.Services; -using Purview.EventSourcing.Samples.Web.Services; - -namespace Purview.EventSourcing.Samples.IntegrationTests.Web; - -public sealed class AuditPageIntegrationTests -{ - [Test] - public async Task GetAuditPage_GivenDateRangeOnly_ShowsRecentEvents() - { - await using var factory = new AuditWebAppFactory(); - using var client = factory.CreateClient(); - - var response = await client.GetAsync("/BackOffice/Audit/Index?aggregateType=order&fromUtc=2026-06-22T00:00"); - var content = await response.Content.ReadAsStringAsync(); - - await Assert.That(response.IsSuccessStatusCode).IsTrue(); - await Assert.That(content).Contains("Recent Events"); - await Assert.That(content).Contains("DateRangeOnlyEvent"); - } - - [Test] - public async Task GetAuditPage_GivenAggregateId_ShowsAggregateHistoryEvents() - { - await using var factory = new AuditWebAppFactory(); - using var client = factory.CreateClient(); - - var response = await client.GetAsync("/BackOffice/Audit/Index?aggregateType=order&aggregateId=agg-1"); - var content = await response.Content.ReadAsStringAsync(); - - await Assert.That(response.IsSuccessStatusCode).IsTrue(); - await Assert.That(content).Contains("AggregateIdEvent"); - } - - [Test] - public async Task GetAuditPage_GivenNoFilters_ShowsRecentEvents() - { - await using var factory = new AuditWebAppFactory(); - using var client = factory.CreateClient(); - - var response = await client.GetAsync("/BackOffice/Audit/Index"); - var content = await response.Content.ReadAsStringAsync(); - - await Assert.That(response.IsSuccessStatusCode).IsTrue(); - await Assert.That(content).Contains("Recent Events"); - await Assert.That(content).Contains("DateRangeOnlyEvent"); - } - - sealed class AuditWebAppFactory : WebApplicationFactory - { - protected override void ConfigureWebHost(IWebHostBuilder builder) => - builder.ConfigureTestServices(services => - { - services.RemoveAll(); - services.RemoveAll(); - services.AddSingleton(); - services.AddSingleton(); - }); - } - - sealed class NoOpSeedDataService : ISeedDataService - { - public Task SeedAsync(CancellationToken cancellationToken = default) => Task.CompletedTask; - } - - sealed class FakeAggregateAuditService : IAggregateAuditService - { - public Task> GetHistoryAsync( - string aggregateType, - string aggregateId, - AggregateEventHistoryRequest request, - CancellationToken cancellationToken - ) => - Task.FromResult( - new ContinuationResponse - { - RequestedCount = request.MaxRecords, - Results = - [ - new AggregateEventHistoryItem - { - AggregateType = "OrderAggregate", - AggregateId = aggregateId, - AggregateVersion = 1, - EventType = "AggregateIdEvent", - EventClrType = "AggregateIdEvent", - Payload = "{}", - When = DateTimeOffset.UtcNow, - }, - ], - } - ); - - public Task> GetLatestHistoryAsync( - string aggregateType, - AggregateEventHistoryRequest request, - CancellationToken cancellationToken - ) => - Task.FromResult>([ - new AggregateEventHistoryItem - { - AggregateType = "OrderAggregate", - AggregateId = "range-agg", - AggregateVersion = 2, - EventType = "DateRangeOnlyEvent", - EventClrType = "DateRangeOnlyEvent", - Payload = "{}", - When = DateTimeOffset.UtcNow, - }, - ]); - } -} diff --git a/src/tests/EventSourcing.Samples.UnitTests/EventSourcing.Samples.UnitTests.csproj b/src/tests/EventSourcing.Samples.UnitTests/EventSourcing.Samples.UnitTests.csproj deleted file mode 100644 index 58c73f82..00000000 --- a/src/tests/EventSourcing.Samples.UnitTests/EventSourcing.Samples.UnitTests.csproj +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/src/tests/EventSourcing.SourceGenerator.PerformanceTests/EventSourcing.SourceGenerator.PerformanceTests.csproj b/src/tests/EventSourcing.SourceGenerator.PerformanceTests/EventSourcing.SourceGenerator.PerformanceTests.csproj deleted file mode 100644 index 4a938ffe..00000000 --- a/src/tests/EventSourcing.SourceGenerator.PerformanceTests/EventSourcing.SourceGenerator.PerformanceTests.csproj +++ /dev/null @@ -1,15 +0,0 @@ - - - Exe - false - true - true - false - - - - - - - - diff --git a/src/tests/EventSourcing.SourceGenerator.PerformanceTests/Program.cs b/src/tests/EventSourcing.SourceGenerator.PerformanceTests/Program.cs deleted file mode 100644 index c4425ecc..00000000 --- a/src/tests/EventSourcing.SourceGenerator.PerformanceTests/Program.cs +++ /dev/null @@ -1,26 +0,0 @@ -namespace Purview.EventSourcing.SourceGenerator; - -public static class Program -{ - public static int Main(string[] args) - { - var runBenchmark = Array.Exists( - args, - static arg => string.Equals(arg, "--benchmark", StringComparison.OrdinalIgnoreCase) - ); - var runner = new SourceGeneratorPerformanceRunner(); - var store = new PerformanceHistoryStore(); - - var previousRun = store.TryLoadLatest(); - var run = runBenchmark ? runner.RunBenchmark() : runner.RunQuick(); - var savedPath = store.Save(run); - - Console.WriteLine($"Saved {run.Mode} results to {savedPath}"); - Console.WriteLine(); - - foreach (var line in run.FormatSummary(previousRun)) - Console.WriteLine(line); - - return 0; - } -} diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/EventSourcing.SqlServer.IntegrationTests.csproj b/src/tests/EventSourcing.SqlServer.IntegrationTests/EventSourcing.SqlServer.IntegrationTests.csproj deleted file mode 100644 index 6129e37d..00000000 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/EventSourcing.SqlServer.IntegrationTests.csproj +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.TestData.cs b/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.TestData.cs deleted file mode 100644 index 150f3598..00000000 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.TestData.cs +++ /dev/null @@ -1,127 +0,0 @@ -namespace Purview.EventSourcing.SqlServer.Events; - -partial class SqlServerEventStoreTests -{ - public static IEnumerable<(Type, int)> TooManyEventCountTestData() - { - List<(Type, int)> data = []; - foreach (var aggregateType in GetAggregateTestTypes()) - { - data.Add((aggregateType, 1_001)); - data.Add((aggregateType, 10_000)); - data.Add((aggregateType, 100_000)); - } - - return data; - } - - public static IEnumerable<(Type, int, int)> SteppedAggregateCountWithDeletedAggregateIdCountTestData() - { - List<(Type, int, int)> data = []; - foreach (var aggregateType in GetAggregateTestTypes()) - { - data.Add((aggregateType, 1, 1)); - data.Add((aggregateType, 1, 10)); - data.Add((aggregateType, 5, 5)); - data.Add((aggregateType, 5, 10)); - data.Add((aggregateType, 10, 10)); - data.Add((aggregateType, 10, 20)); - data.Add((aggregateType, 20, 20)); - data.Add((aggregateType, 20, 40)); - } - - return data; - } - - public static IEnumerable<(Type, int, int, int?)> RequestedRangeOfEventsTestData() - { - List<(Type, int, int, int?)> data = []; - foreach (var aggregateType in GetAggregateTestTypes()) - { - data.Add((aggregateType, 5, 1, 5)); - data.Add((aggregateType, 5, 1, null)); - data.Add((aggregateType, 10, 2, 5)); - data.Add((aggregateType, 10, 2, null)); - data.Add((aggregateType, 15, 15, null)); - data.Add((aggregateType, 15, 15, 15)); - data.Add((aggregateType, 5, 1, 20)); - data.Add((aggregateType, 5, 1, 20000)); - } - - return data; - } - - public static IEnumerable<(Type, int, int, int?, int)> RequestedRangeOfEventsWithExpectedEventCountTestData() - { - List<(Type, int, int, int?, int)> data = []; - foreach (var aggregateType in GetAggregateTestTypes()) - { - data.Add((aggregateType, 5, 1, 5, 5)); - data.Add((aggregateType, 5, 1, null, 5)); - data.Add((aggregateType, 10, 2, 5, 4)); - data.Add((aggregateType, 10, 2, null, 9)); - data.Add((aggregateType, 15, 15, null, 1)); - data.Add((aggregateType, 15, 15, 15, 1)); - data.Add((aggregateType, 5, 1, 20, 5)); - data.Add((aggregateType, 5, 1, 20000, 5)); - } - - return data; - } - - public static IEnumerable<(Type, int)> SteppedCountTestData() - { - List<(Type, int)> data = []; - foreach (var aggregateType in GetAggregateTestTypes()) - { - data.Add((aggregateType, 1)); - data.Add((aggregateType, 10)); - data.Add((aggregateType, 20)); - data.Add((aggregateType, 50)); - } - - return data; - } - - public static IEnumerable<(Type, int, int)> SteppedEventCountWithOldEventCountTestData() - { - List<(Type, int, int)> data = []; - foreach (var aggregateType in GetAggregateTestTypes()) - { - data.Add((aggregateType, 1, 1)); - data.Add((aggregateType, 5, 2)); - data.Add((aggregateType, 10, 5)); - data.Add((aggregateType, 20, 20)); - } - - return data; - } - - public static IEnumerable<(Type, int)> SnapshotEventCountTestData() - { - List<(Type, int)> data = []; - foreach (var aggregateType in GetAggregateTestTypes()) - { - data.Add((aggregateType, 10)); - data.Add((aggregateType, 20)); - data.Add((aggregateType, 50)); - data.Add((aggregateType, 80)); - data.Add((aggregateType, 100)); - } - - return data; - } - - public static IEnumerable GetAggregateTestTypes() - { - List data = []; - data.Add(typeof(Aggregates.Persistence.PersistenceAggregate)); - return data; - } - - internal ISqlServerEventStoreTests CreateSqlServerStoreTests(Type aggregateType) - { - var testType = typeof(GenericSqlServerEventStoreTests<>).MakeGenericType(aggregateType); - return (ISqlServerEventStoreTests)Activator.CreateInstance(testType, args: [fixture])!; - } -} diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.RestoreAsync.cs b/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.RestoreAsync.cs deleted file mode 100644 index fa1b42b2..00000000 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.RestoreAsync.cs +++ /dev/null @@ -1,49 +0,0 @@ -using Purview.EventSourcing.Aggregates.Persistence; - -namespace Purview.EventSourcing.SqlServer.Snapshots; - -partial class SqlServerSnapshotEventStoreTests -{ - [Test] - public async Task RestoreAsync_GivenExistingAggregateMarkedAsDeletedAndDoesNotExistInSqlServerWhenRestore_SnapshotCreatedInSqlServer( - CancellationToken cancellationToken - ) - { - // Arrange - var context = fixture.CreateContext(); - - var aggregateId = Guid.NewGuid().ToString(); - var aggregate = CreateAggregate(id: aggregateId); - aggregate.IncrementInt32Value(); - - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); - await Assert.That(saveResult).IsTrue(); - - var aggregateFromSqlServer = await context.SqlServerClient.GetByIdAsync( - aggregateId, - cancellationToken: cancellationToken - ); - await Assert.That(aggregateFromSqlServer).IsNotNull(); - - var deleteResult = await context.EventStore.DeleteAsync(aggregate, cancellationToken: cancellationToken); - await Assert.That(deleteResult).IsTrue(); - - aggregateFromSqlServer = await context.SqlServerClient.GetByIdAsync( - aggregateId, - cancellationToken: cancellationToken - ); - await Assert.That(aggregateFromSqlServer).IsNull(); - - // Act - var restoreResult = await context.EventStore.RestoreAsync(aggregate, cancellationToken: cancellationToken); - - aggregateFromSqlServer = await context.SqlServerClient.GetByIdAsync( - aggregateId, - cancellationToken: cancellationToken - ); - - // Assert - await Assert.That(restoreResult).IsTrue(); - await Assert.That(aggregateFromSqlServer).IsNotNull(); - } -} diff --git a/src/tests/EventSourcing.SqlServer.PerformanceTests/Program.cs b/src/tests/EventSourcing.SqlServer.PerformanceTests/Program.cs deleted file mode 100644 index 47a45c90..00000000 --- a/src/tests/EventSourcing.SqlServer.PerformanceTests/Program.cs +++ /dev/null @@ -1,31 +0,0 @@ -namespace Purview.EventSourcing.SqlServer.PerformanceTests; - -public static class Program -{ - public static async Task Main(string[] args) - { - var runBenchmark = Array.Exists( - args, - static arg => string.Equals(arg, "--benchmark", StringComparison.OrdinalIgnoreCase) - ); - var runner = new SqlServerStorePerformanceRunner(); - var store = new SqlServerStorePerformanceHistoryStore(); - - var previousRun = store.TryLoadLatest(); - var run = await (runBenchmark ? runner.RunBenchmarkAsync() : runner.RunQuickAsync()); - var savedPath = store.Save(run); - - await Console.Out.WriteLineAsync($"Saved {run.Mode} results to {savedPath}"); - await Console.Out.WriteLineAsync(); - - foreach (var line in run.FormatSummary(previousRun)) - await Console.Out.WriteLineAsync(line); - - if (run.Passed) - return 0; - - await Console.Out.WriteLineAsync(); - await Console.Error.WriteLineAsync("Performance thresholds were not met."); - return 1; - } -} diff --git a/src/tests/EventSourcing.UnitTests/Aggregates/AggregateDetailsTests.cs b/src/tests/EventSourcing.UnitTests/Aggregates/AggregateDetailsTests.cs index 31e95196..de7eb419 100644 --- a/src/tests/EventSourcing.UnitTests/Aggregates/AggregateDetailsTests.cs +++ b/src/tests/EventSourcing.UnitTests/Aggregates/AggregateDetailsTests.cs @@ -1,18 +1,33 @@ +using Purview.EventSourcing.Aggregates.Exceptions; + namespace Purview.EventSourcing.Aggregates; public class AggregateDetailsTests { [Test] - public async Task Id_WhenSetToSameValue_DoesNotThrow() + public async Task Id_WhenChangedAfterSet_ThrowsIdAlreadySetException() { // Arrange var details = new AggregateDetails { Id = "test-id" }; - // Act — setting same value should not throw - details.Id = "test-id"; + // Act + string ChangeId() => details.Id = "another-id"; + + // Assert + await Assert.That(ChangeId).Throws(); + } + + [Test] + public async Task Locked_WhenUnlockedAfterBeingLocked_ThrowsLockedException() + { + // Arrange + var details = new AggregateDetails { Id = "test-id", Locked = true }; + + // Act + bool Unlock() => details.Locked = false; // Assert - await Assert.That(details.Id).IsEqualTo("test-id"); + await Assert.That(Unlock).Throws(); } [Test] @@ -24,15 +39,33 @@ public async Task Clone_ModifyingClone_DoesNotAffectOriginal() Id = "original", SavedVersion = 3, CurrentVersion = 5, + Created = new DateTimeOffset(2026, 1, 1, 12, 0, 0, TimeSpan.Zero), + Updated = new DateTimeOffset(2026, 1, 2, 12, 0, 0, TimeSpan.Zero), }; // Act var clone = (AggregateDetails)original.Clone(); clone.SavedVersion = 99; clone.CurrentVersion = 100; + clone.Updated = new DateTimeOffset(2026, 1, 3, 12, 0, 0, TimeSpan.Zero); // Assert — original unchanged await Assert.That(original.SavedVersion).IsEqualTo(3); await Assert.That(original.CurrentVersion).IsEqualTo(5); + await Assert.That(original.Updated).IsEqualTo(new DateTimeOffset(2026, 1, 2, 12, 0, 0, TimeSpan.Zero)); + } + + [Test] + public async Task Clone_PreservesUpdatedTimestamp() + { + // Arrange + var expectedUpdated = new DateTimeOffset(2026, 2, 10, 9, 30, 0, TimeSpan.Zero); + var original = new AggregateDetails { Id = "original", Updated = expectedUpdated }; + + // Act + var clone = (AggregateDetails)original.Clone(); + + // Assert + await Assert.That(clone.Updated).IsEqualTo(expectedUpdated); } } diff --git a/src/tests/EventSourcing.UnitTests/Aggregates/Events/Upcasting/EventUpcasterRegistryTests.cs b/src/tests/EventSourcing.UnitTests/Aggregates/Events/Upcasting/EventUpcasterRegistryTests.cs index 903a2f1a..ad13487b 100644 --- a/src/tests/EventSourcing.UnitTests/Aggregates/Events/Upcasting/EventUpcasterRegistryTests.cs +++ b/src/tests/EventSourcing.UnitTests/Aggregates/Events/Upcasting/EventUpcasterRegistryTests.cs @@ -25,6 +25,15 @@ sealed class IntermediateEvent : EventBase protected override void BuildEventHash(ref HashCode hash) => hash.Add(MidField); } + sealed class V3Event : EventBase + { + public string V3Field { get; set; } = default!; + + public override int SchemaVersion => 3; + + protected override void BuildEventHash(ref HashCode hash) => hash.Add(V3Field); + } + sealed class LegacyToCurrentUpcaster : IEventUpcaster { public CurrentEvent Upcast(LegacyEvent source) => @@ -43,6 +52,12 @@ public CurrentEvent Upcast(IntermediateEvent source) => new() { Details = source.Details, NewField = source.MidField + "_final" }; } + sealed class IntermediateToV3Upcaster : IEventUpcaster + { + public V3Event Upcast(IntermediateEvent source) => + new() { Details = source.Details, V3Field = source.MidField + "_v3" }; + } + #endregion [Test] @@ -175,4 +190,79 @@ public async Task Descriptor_GivenWrongSourceType_ThrowsInvalidOperationExceptio // Act & Assert await Assert.That(() => descriptor.Upcast(wrongEvent)).Throws(); } + + [Test] + public async Task Upcast_PreservesEventDetailsMetadata() + { + // Arrange + var now = DateTime.UtcNow; + var descriptor = new EventUpcasterDescriptor(new LegacyToCurrentUpcaster()); + var registry = new EventUpcasterRegistry([descriptor]); + + var legacyEvent = new LegacyEvent + { + OldField = "test", + Details = + { + IdempotencyId = "idempotency-123", + When = now, + UserId = "user-456", + CorrelationId = "correlation-789", + AggregateVersion = 42, + }, + }; + + // Act + var result = registry.Upcast(legacyEvent); + + // Assert + await Assert.That(result).IsTypeOf(); + var upcastEvent = (CurrentEvent)result; + await Assert.That(upcastEvent.Details.IdempotencyId).IsEqualTo("idempotency-123"); + await Assert.That(upcastEvent.Details.When).IsEqualTo(now); + await Assert.That(upcastEvent.Details.UserId).IsEqualTo("user-456"); + await Assert.That(upcastEvent.Details.CorrelationId).IsEqualTo("correlation-789"); + await Assert.That(upcastEvent.Details.AggregateVersion).IsEqualTo(42); + } + + [Test] + public async Task Upcast_GivenThreeHopChain_AppliesAllStepsInOrder() + { + // Arrange: LegacyEvent → IntermediateEvent → V3Event (three hops) + var legacyToMid = new EventUpcasterDescriptor( + new LegacyToIntermediateUpcaster() + ); + var midToV3 = new EventUpcasterDescriptor(new IntermediateToV3Upcaster()); + var registry = new EventUpcasterRegistry([legacyToMid, midToV3]); + + var legacyEvent = new LegacyEvent { OldField = "source" }; + + // Act + var result = registry.Upcast(legacyEvent); + + // Assert + await Assert.That(result).IsTypeOf(); + // LegacyEvent.OldField "source" → IntermediateEvent.MidField "source_mid" → V3Event.V3Field "source_mid_v3" + await Assert.That(((V3Event)result).V3Field).IsEqualTo("source_mid_v3"); + await Assert.That(((V3Event)result).SchemaVersion).IsEqualTo(3); + } + + [Test] + public async Task CanUpcast_GivenThreeHopChain_ReturnsTrue() + { + // Arrange: chain LegacyEvent → IntermediateEvent → V3Event + var legacyToMid = new EventUpcasterDescriptor( + new LegacyToIntermediateUpcaster() + ); + var midToV3 = new EventUpcasterDescriptor(new IntermediateToV3Upcaster()); + var registry = new EventUpcasterRegistry([legacyToMid, midToV3]); + + var legacyEvent = new LegacyEvent { OldField = "test" }; + + // Act + var result = registry.CanUpcast(legacyEvent); + + // Assert + await Assert.That(result).IsTrue(); + } } diff --git a/src/tests/EventSourcing.UnitTests/ContinuationTests.cs b/src/tests/EventSourcing.UnitTests/ContinuationTests.cs index 2764ef33..b6f548ed 100644 --- a/src/tests/EventSourcing.UnitTests/ContinuationTests.cs +++ b/src/tests/EventSourcing.UnitTests/ContinuationTests.cs @@ -2,8 +2,6 @@ namespace Purview.EventSourcing; public class ContinuationTests { - #region ContinuationResponse Tests - [Test] public async Task ContinuationResponse_HasRecords_GivenEmptyResults_ReturnsFalse() { @@ -73,6 +71,36 @@ public async Task ContinuationResponse_ToRequest_CreatesRequestWithTokenAndCount await Assert.That(request.MaxRecords).IsEqualTo(25); } + [Test] + public async Task ContinuationResponse_HasMoreRecords_GivenEmptyStringToken_ReturnsFalse() + { + // Arrange + var response = new ContinuationResponse + { + Results = ["item1"], + RequestedCount = 10, + ContinuationToken = "", + }; + + // Assert + await Assert.That(response.HasMoreRecords).IsFalse(); + } + + [Test] + public async Task ContinuationResponse_HasMoreRecords_GivenWhitespaceToken_ReturnsFalse() + { + // Arrange + var response = new ContinuationResponse + { + Results = ["item1"], + RequestedCount = 10, + ContinuationToken = " ", + }; + + // Assert + await Assert.That(response.HasMoreRecords).IsFalse(); + } + [Test] public async Task ContinuationResponse_Convert_MapsResultsCorrectly() { @@ -91,7 +119,81 @@ public async Task ContinuationResponse_Convert_MapsResultsCorrectly() await Assert.That(converted.Results).Count().IsEqualTo(3); await Assert.That(converted.ContinuationToken).IsEqualTo("token"); await Assert.That(converted.RequestedCount).IsEqualTo(10); + await Assert.That(converted.Results[0]).IsEqualTo("1"); + await Assert.That(converted.Results[1]).IsEqualTo("2"); + await Assert.That(converted.Results[2]).IsEqualTo("3"); + } + + [Test] + public async Task ContinuationResponse_Convert_PreservesTotalCount() + { + // Arrange + var response = new ContinuationResponse + { + Results = [1, 2], + RequestedCount = 10, + TotalCount = 150, + ContinuationToken = "token", + }; + + // Act + var converted = response.Convert(i => i.ToString(System.Globalization.CultureInfo.InvariantCulture)); + + // Assert — TotalCount should be preserved through conversion + await Assert.That(converted.TotalCount).IsEqualTo(150); + } + + [Test] + public async Task ContinuationResponse_Convert_TransformsType() + { + // Arrange + var response = new ContinuationResponse { Results = [100, 200, 300], RequestedCount = 10 }; + + // Act + var converted = response.Convert(i => $"Value-{i}"); + + // Assert — type transformation works + await Assert.That(converted.Results).Count().IsEqualTo(3); + await Assert.That(converted.Results[0]).IsEqualTo("Value-100"); + await Assert.That(converted.Results[1]).IsEqualTo("Value-200"); + await Assert.That(converted.Results[2]).IsEqualTo("Value-300"); } - #endregion + [Test] + public async Task ContinuationResponse_Convert_GivenEmptyResults_ReturnsEmptyConverted() + { + // Arrange + var response = new ContinuationResponse + { + Results = [], + RequestedCount = 10, + ContinuationToken = "token", + }; + + // Act + var converted = response.Convert(i => i.ToString(System.Globalization.CultureInfo.InvariantCulture)); + + // Assert + await Assert.That(converted.Results).IsEmpty(); + await Assert.That(converted.ContinuationToken).IsEqualTo("token"); + } + + [Test] + public async Task ContinuationResponse_ImplicitCastToRequest_CreatesRequest() + { + // Arrange + var response = new ContinuationResponse + { + Results = ["item"], + RequestedCount = 50, + ContinuationToken = "next", + }; + + // Act + ContinuationRequest request = response; + + // Assert + await Assert.That(request.ContinuationToken).IsEqualTo("next"); + await Assert.That(request.MaxRecords).IsEqualTo(50); + } } diff --git a/src/tests/EventSourcing.UnitTests/EventHistoryExtensionsTests.cs b/src/tests/EventSourcing.UnitTests/EventHistoryExtensionsTests.cs index 41ed34e9..ea6867ce 100644 --- a/src/tests/EventSourcing.UnitTests/EventHistoryExtensionsTests.cs +++ b/src/tests/EventSourcing.UnitTests/EventHistoryExtensionsTests.cs @@ -74,10 +74,12 @@ public async Task GetEventHistoryAsync_GivenContinuationToken_PaginatesResults(C public async Task GetEventHistoryAsync_GivenStoreWithoutHistorySupport_ThrowsNotSupportedException() { // Arrange - var store = Substitute.For>(); + var store = IEventStoreCore.Mock(); // Act - var exception = (await Assert.That(() => store.GetEventHistoryAsync("agg-1")).Throws())!; + var exception = ( + await Assert.That(() => store.GetEventHistoryAsync("agg-1")!).Throws() + )!; // Assert await Assert.That(exception.Message).Contains("does not support event history enumeration"); @@ -92,8 +94,9 @@ public async Task GetEventHistoryAsync_GivenInvalidRequest_ThrowsArgumentOutOfRa // Act / Assert var exception = ( - await Assert.That(() => store.GetEventHistoryAsync("agg-1", request)).Throws() + await Assert.That(() => store.GetEventHistoryAsync("agg-1", request)!).Throws() )!; + await Assert.That(exception.ParamName).IsEqualTo("request"); } @@ -121,7 +124,7 @@ sealed class HistoryEnabledStore(IEnumerable<(IEvent @event, string eventType)> : IEventStoreCore, IAggregateEventHistoryStoreCore { - readonly IReadOnlyList<(IEvent @event, string eventType)> _events = events.ToList(); + readonly IReadOnlyList<(IEvent @event, string eventType)> _events = [.. events]; public async IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( string aggregateId, diff --git a/src/tests/EventSourcing.UnitTests/EventStoreTransactionFactoryTests.cs b/src/tests/EventSourcing.UnitTests/EventStoreTransactionFactoryTests.cs index 99f968cf..68aaf331 100644 --- a/src/tests/EventSourcing.UnitTests/EventStoreTransactionFactoryTests.cs +++ b/src/tests/EventSourcing.UnitTests/EventStoreTransactionFactoryTests.cs @@ -6,7 +6,7 @@ public sealed class EventStoreTransactionFactoryTests public async Task Create_GivenNullCorrelationId_UsesAmbientProviderValue() { // Arrange - var correlationIdProvider = Substitute.For(); + var correlationIdProvider = IEventStoreCorrelationIdProvider.Mock(); correlationIdProvider.GetCorrelationId().Returns("ambient-correlation"); var factory = new EventStoreTransactionFactory(correlationIdProvider); @@ -21,7 +21,7 @@ public async Task Create_GivenNullCorrelationId_UsesAmbientProviderValue() public async Task Create_GivenExplicitCorrelationId_PrefersExplicitValueOverAmbientProvider() { // Arrange - var correlationIdProvider = Substitute.For(); + var correlationIdProvider = IEventStoreCorrelationIdProvider.Mock(); correlationIdProvider.GetCorrelationId().Returns("ambient-correlation"); var factory = new EventStoreTransactionFactory(correlationIdProvider); @@ -30,6 +30,6 @@ public async Task Create_GivenExplicitCorrelationId_PrefersExplicitValueOverAmbi // Assert await Assert.That(transaction.CorrelationId).IsEqualTo("explicit-correlation"); - correlationIdProvider.DidNotReceive().GetCorrelationId(); + correlationIdProvider.GetCorrelationId().WasNeverCalled(); } } diff --git a/src/tests/EventSourcing.UnitTests/EventStoreTransactionTests.cs b/src/tests/EventSourcing.UnitTests/EventStoreTransactionTests.cs index cfe3b6ca..f5192689 100644 --- a/src/tests/EventSourcing.UnitTests/EventStoreTransactionTests.cs +++ b/src/tests/EventSourcing.UnitTests/EventStoreTransactionTests.cs @@ -1,9 +1,11 @@ using System.Data; using System.Data.Common; -using NSubstitute.ExceptionExtensions; using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Aggregates.Test; using Purview.EventSourcing.Internal; +using ValidationFailure = Purview.EventSourcing.Validation.ValidationFailure; +using ValidationResult = Purview.EventSourcing.Validation.ValidationResult; namespace Purview.EventSourcing; @@ -14,7 +16,7 @@ public async Task Enlist_GivenNullAggregate_ThrowsArgumentNullException() { // Arrange await using var transaction = new EventStoreTransaction(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); // Act & Assert await Assert.That(() => transaction.Enlist(null!, eventStore)).Throws(); @@ -39,15 +41,13 @@ public async Task CommitAsync_GivenSingleAggregate_CallsSaveAsyncOnEventStore(Ca var aggregate = TestHelpers.Aggregate(clearEvents: false); aggregate.Increment(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns( - new SaveResult(aggregate, new FluentValidation.Results.ValidationResult(), true, false) - ); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(aggregate, new ValidationResult(), true, false)); await using var transaction = new EventStoreTransaction(); - transaction.Enlist(aggregate, (IEventStore)eventStore); + transaction.Enlist(aggregate, eventStore); // Act var result = await transaction.CommitAsync(cancellationToken); @@ -58,13 +58,10 @@ public async Task CommitAsync_GivenSingleAggregate_CallsSaveAsyncOnEventStore(Ca await Assert.That(result.Results[0].Saved).IsTrue(); await Assert.That(result.Results[0].Skipped).IsFalse(); await Assert.That(result.Results[0].Error).IsNull(); - await eventStore - .Received(1) - .SaveAsync( - aggregate, - Arg.Is(ctx => ctx.CorrelationId == transaction.CorrelationId), - Arg.Any() - ); + + eventStore + .SaveAsync(Is(aggregate), ctx => ctx!.CorrelationId == transaction.CorrelationId, Any()) + .WasCalled(Times.Once); } [Test] @@ -77,19 +74,19 @@ public async Task CommitAsync_GivenMultipleAggregates_SavesAllInOrder(Cancellati var agg2 = TestHelpers.Aggregate(clearEvents: false); agg2.RecordEvent(); - var store1 = Substitute.For(); + var store1 = IEventStore.Mock(); store1 - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(new SaveResult(agg1, new FluentValidation.Results.ValidationResult(), true, false)); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(agg1, new ValidationResult(), true, false)); - var store2 = Substitute.For(); + var store2 = IEventStore.Mock(); store2 - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(new SaveResult(agg2, new FluentValidation.Results.ValidationResult(), true, false)); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(agg2, new ValidationResult(), true, false)); await using var transaction = new EventStoreTransaction(); - transaction.Enlist(agg1, (IEventStore)store1); - transaction.Enlist(agg2, (IEventStore)store2); + transaction.Enlist(agg1, store1); + transaction.Enlist(agg2, store2); // Act var result = await transaction.CommitAsync(cancellationToken); @@ -99,8 +96,8 @@ public async Task CommitAsync_GivenMultipleAggregates_SavesAllInOrder(Cancellati await Assert.That(result.Results).Count().IsEqualTo(2); await Assert.That(result.Results[0].Aggregate).IsEqualTo(agg1); await Assert.That(result.Results[1].Aggregate).IsEqualTo(agg2); - await store1.Received(1).SaveAsync(agg1, Arg.Any(), Arg.Any()); - await store2.Received(1).SaveAsync(agg2, Arg.Any(), Arg.Any()); + store1.SaveAsync(Is(agg1), Any(), Any()).WasCalled(Times.Once); + store2.SaveAsync(Is(agg2), Any(), Any()).WasCalled(Times.Once); } [Test] @@ -116,50 +113,38 @@ CancellationToken cancellationToken var agg2 = TestHelpers.Aggregate(clearEvents: false); agg2.RecordEvent(); - var store1 = Substitute.For(); + var store1 = IEventStore.Mock(); store1 - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(ci => - { - var agg = ci.ArgAt(0); - return new SaveResult(agg, new FluentValidation.Results.ValidationResult(), true, false); - }); - - var store2 = Substitute.For(); + .SaveAsync(Any(), Any(), Any()) + .Returns((agg, _, _) => new SaveResult(agg, new ValidationResult(), true, false)); + + var store2 = IEventStore.Mock(); store2 - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(ci => - { - var agg = ci.ArgAt(0); - return new SaveResult(agg, new FluentValidation.Results.ValidationResult(), true, false); - }); + .SaveAsync(Any(), Any(), Any()) + .Returns((agg, _, _) => new SaveResult(agg, new ValidationResult(), true, false)); await using var transaction = new EventStoreTransaction(correlationId); - transaction.Enlist(agg1, (IEventStore)store1); - transaction.Enlist(agg2, (IEventStore)store2); + transaction.Enlist(agg1, store1); + transaction.Enlist(agg2, store2); // Act await transaction.CommitAsync(cancellationToken); // Assert — both stores received the shared correlation ID - await store1 - .Received(1) + store1 .SaveAsync( - agg1, - Arg.Is(ctx => - ctx.CorrelationId == correlationId && ctx.UseIdempotencyMarker - ), - Arg.Any() - ); - await store2 - .Received(1) + Is(agg1), + ctx => ctx!.CorrelationId == correlationId && ctx.UseIdempotencyMarker, + Any() + ) + .WasCalled(Times.Once); + store2 .SaveAsync( - agg2, - Arg.Is(ctx => - ctx.CorrelationId == correlationId && ctx.UseIdempotencyMarker - ), - Arg.Any() - ); + Is(agg2), + ctx => ctx!.CorrelationId == correlationId && ctx.UseIdempotencyMarker, + Any() + ) + .WasCalled(Times.Once); } [Test] @@ -172,16 +157,16 @@ public async Task CommitAsync_WhenFirstAggregateFails_StopsAndDoesNotSaveSecond( var agg2 = TestHelpers.Aggregate(clearEvents: false); agg2.RecordEvent(); - var store1 = Substitute.For(); + var store1 = IEventStore.Mock(); store1 - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .ThrowsAsync(new InvalidOperationException("DB failure")); + .SaveAsync(Any(), Any(), Any()) + .Throws(); - var store2 = Substitute.For(); + var store2 = IEventStore.Mock(); await using var transaction = new EventStoreTransaction(); - transaction.Enlist(agg1, (IEventStore)store1); - transaction.Enlist(agg2, (IEventStore)store2); + transaction.Enlist(agg1, store1); + transaction.Enlist(agg2, store2); // Act var result = await transaction.CommitAsync(cancellationToken); @@ -192,9 +177,9 @@ public async Task CommitAsync_WhenFirstAggregateFails_StopsAndDoesNotSaveSecond( await Assert.That(result.Results[0].Saved).IsFalse(); await Assert.That(result.Results[0].Error).IsNotNull(); await Assert.That(result.Results[0].Error).IsTypeOf(); - await store2 - .DidNotReceive() - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()); + store2 + .SaveAsync(Any(), Any(), Any()) + .WasNeverCalled(); } [Test] @@ -204,12 +189,10 @@ public async Task CommitAsync_CalledTwice_ThrowsInvalidOperationException(Cancel var aggregate = TestHelpers.Aggregate(clearEvents: false); aggregate.Increment(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns( - new SaveResult(aggregate, new FluentValidation.Results.ValidationResult(), true, false) - ); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(aggregate, new ValidationResult(), true, false)); await using var transaction = new EventStoreTransaction(); transaction.Enlist(aggregate, eventStore); @@ -228,12 +211,10 @@ public async Task Enlist_AfterCommit_ThrowsInvalidOperationException(Cancellatio var aggregate = TestHelpers.Aggregate(clearEvents: false); aggregate.Increment(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns( - new SaveResult(aggregate, new FluentValidation.Results.ValidationResult(), true, false) - ); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(aggregate, new ValidationResult(), true, false)); await using var transaction = new EventStoreTransaction(); transaction.Enlist(aggregate, eventStore); @@ -254,7 +235,7 @@ public async Task Enlist_AfterDispose_ThrowsObjectDisposedException() var aggregate = TestHelpers.Aggregate(clearEvents: false); aggregate.Increment(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); // Act & Assert await Assert.That(() => transaction.Enlist(aggregate, eventStore)).Throws(); @@ -353,19 +334,12 @@ CancellationToken cancellationToken agg2.RecordEvent(); var transactionalStore = new FakeTransactionalEventStore("sqlserver:primary"); - var nonTransactionalStore = Substitute.For(); + var nonTransactionalStore = IEventStore.Mock(); nonTransactionalStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(ci => - { - var aggregate = ci.ArgAt(0); - return new SaveResult( - aggregate, - new FluentValidation.Results.ValidationResult(), - true, - false - ); - }); + .SaveAsync(Any(), Any(), Any()) + .Returns( + (aggregate, _, _) => new SaveResult(aggregate, new ValidationResult(), true, false) + ); await using var transaction = new EventStoreTransaction("mixed"); transaction.Enlist(agg1, (IEventStore)transactionalStore); @@ -376,13 +350,9 @@ CancellationToken cancellationToken await Assert.That(result.Success).IsTrue(); await Assert.That(transactionalStore.SaveAsyncCalls).IsEqualTo(1); await Assert.That(transactionalStore.SaveInTransactionCalls).IsEqualTo(0); - await nonTransactionalStore - .Received(1) - .SaveAsync( - agg2, - Arg.Is(ctx => ctx.CorrelationId == "mixed"), - Arg.Any() - ); + nonTransactionalStore + .SaveAsync(Is(agg2), ctx => ctx!.CorrelationId == "mixed", Any()) + .WasCalled(Times.Once); } [Test] @@ -473,20 +443,18 @@ public async Task CommitAsync_WhenSaveReturnsNotSaved_StopsAndReportsFailure(Can var agg2 = TestHelpers.Aggregate(clearEvents: false); agg2.RecordEvent(); - var validationResult = new FluentValidation.Results.ValidationResult([ - new FluentValidation.Results.ValidationFailure("Field", "Required"), - ]); + var validationResult = new ValidationResult([new ValidationFailure("Field", "Required")]); - var store1 = Substitute.For(); + var store1 = IEventStore.Mock(); store1 - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) + .SaveAsync(Any(), Any(), Any()) .Returns(new SaveResult(agg1, validationResult, false, false)); - var store2 = Substitute.For(); + var store2 = IEventStore.Mock(); await using var transaction = new EventStoreTransaction(); - transaction.Enlist(agg1, (IEventStore)store1); - transaction.Enlist(agg2, (IEventStore)store2); + transaction.Enlist(agg1, store1); + transaction.Enlist(agg2, store2); // Act var result = await transaction.CommitAsync(cancellationToken); @@ -496,9 +464,9 @@ public async Task CommitAsync_WhenSaveReturnsNotSaved_StopsAndReportsFailure(Can await Assert.That(result.Results).Count().IsEqualTo(1); await Assert.That(result.Results[0].Saved).IsFalse(); await Assert.That(result.Results[0].Skipped).IsFalse(); - await store2 - .DidNotReceive() - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()); + store2 + .SaveAsync(Any(), Any(), Any()) + .WasNeverCalled(); } [Test] @@ -509,19 +477,19 @@ public async Task CommitAsync_WhenSaveSkipped_ContinuesToNextAggregate(Cancellat var agg2 = TestHelpers.Aggregate(clearEvents: false); agg2.Increment(); - var store1 = Substitute.For(); + var store1 = IEventStore.Mock(); store1 - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(new SaveResult(agg1, new FluentValidation.Results.ValidationResult(), false, true)); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(agg1, new ValidationResult(), false, true)); - var store2 = Substitute.For(); + var store2 = IEventStore.Mock(); store2 - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(new SaveResult(agg2, new FluentValidation.Results.ValidationResult(), true, false)); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(agg2, new ValidationResult(), true, false)); await using var transaction = new EventStoreTransaction(); - transaction.Enlist(agg1, (IEventStore)store1); - transaction.Enlist(agg2, (IEventStore)store2); + transaction.Enlist(agg1, store1); + transaction.Enlist(agg2, store2); // Act var result = await transaction.CommitAsync(cancellationToken); @@ -532,7 +500,7 @@ public async Task CommitAsync_WhenSaveSkipped_ContinuesToNextAggregate(Cancellat await Assert.That(result.Results[1].Saved).IsTrue(); await Assert.That(result.Success).IsFalse(); await Assert.That(result.CompletedWithoutError).IsTrue(); - await store2.Received(1).SaveAsync(agg2, Arg.Any(), Arg.Any()); + store2.SaveAsync(Is(agg2), Any(), Any()).WasCalled(Times.Once); } [Test] @@ -544,14 +512,12 @@ CancellationToken cancellationToken var aggregate = TestHelpers.Aggregate(clearEvents: false); aggregate.Increment(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns( - new SaveResult(aggregate, new FluentValidation.Results.ValidationResult(), true, false) - ); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(aggregate, new ValidationResult(), true, false)); - var originalDefaultCorrelationId = EventStoreOperationContext.DefaultContext.CorrelationId; + var originalDefaultCorrelationId = EventStoreOperationContext.DefaultContext().CorrelationId; await using var transaction = new EventStoreTransaction("my-correlation"); transaction.Enlist(aggregate, eventStore); @@ -561,7 +527,7 @@ CancellationToken cancellationToken // Assert — DefaultContext was not mutated await Assert - .That(EventStoreOperationContext.DefaultContext.CorrelationId) + .That(EventStoreOperationContext.DefaultContext().CorrelationId) .IsEqualTo(originalDefaultCorrelationId); } @@ -587,13 +553,13 @@ CancellationToken cancellationToken var agg = TestHelpers.Aggregate(clearEvents: false); agg.Increment(); - var store = Substitute.For(); + var store = IEventStore.Mock(); store - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(new SaveResult(agg, new FluentValidation.Results.ValidationResult(), false, false)); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(agg, new ValidationResult(), false, false)); await using var transaction = new EventStoreTransaction(); - transaction.Enlist(agg, (IEventStore)store); + transaction.Enlist(agg, store); // Act var result = await transaction.CommitAsync(cancellationToken); @@ -614,29 +580,25 @@ CancellationToken cancellationToken var customCorrelation = "user-provided-correlation"; var customContext = new EventStoreOperationContext { CorrelationId = customCorrelation }; - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns( - new SaveResult(aggregate, new FluentValidation.Results.ValidationResult(), true, false) - ); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(aggregate, new ValidationResult(), true, false)); await using var transaction = new EventStoreTransaction("transaction-correlation"); - transaction.Enlist(aggregate, (IEventStore)eventStore, customContext); + transaction.Enlist(aggregate, eventStore, customContext); // Act await transaction.CommitAsync(cancellationToken); // Assert — the user-provided correlation ID is preserved (not overwritten by the transaction) - await eventStore - .Received(1) + eventStore .SaveAsync( - aggregate, - Arg.Is(ctx => - ctx.CorrelationId == customCorrelation && ctx.UseIdempotencyMarker - ), - Arg.Any() - ); + Is(aggregate), + ctx => ctx!.CorrelationId == customCorrelation && ctx.UseIdempotencyMarker, + Any() + ) + .WasCalled(Times.Once); } [Test] @@ -678,11 +640,17 @@ sealed class FakeTransactionalEventStore(string transactionBoundaryKey, SaveBeha readonly SaveBehavior _behavior = behavior ?? new SaveBehavior(true, false); public int SaveAsyncCalls { get; private set; } + public int SaveInTransactionCalls { get; private set; } + public int EnsureConfiguredCalls { get; private set; } + public int AfterCommitCalls { get; private set; } + public int AfterRollbackCalls { get; private set; } + public string? LastCorrelationId { get; private set; } + public bool? LastUseIdempotencyMarker { get; private set; } public string TransactionBoundaryKey { get; } = transactionBoundaryKey; @@ -802,14 +770,16 @@ Task IEventStore.ExistsAsync(string aggregateId, CancellationTok T IEventStore.FulfilRequirements(T aggregate) => aggregate; + IAsyncEnumerable<(IEvent @event, string eventType)> IEventStore.GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken + ) => throw new NotSupportedException(); + TransactionalSaveOperation CreateOperation(TestAggregate aggregate) => new( - new SaveResult( - aggregate, - new FluentValidation.Results.ValidationResult(), - _behavior.Saved, - _behavior.Skipped - ), + new SaveResult(aggregate, new ValidationResult(), _behavior.Saved, _behavior.Skipped), _ => { AfterCommitCalls++; @@ -874,6 +844,13 @@ public Task ExistsAsync(string aggregateId, CancellationToken _ = d throw new NotSupportedException(); public TestAggregate FulfilRequirements(TestAggregate aggregate) => aggregate; + + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); } sealed class FakeDbConnection : DbConnection diff --git a/src/tests/EventSourcing.UnitTests/ExistsStateTests.cs b/src/tests/EventSourcing.UnitTests/ExistsStateTests.cs index dc96fb97..bd356eeb 100644 --- a/src/tests/EventSourcing.UnitTests/ExistsStateTests.cs +++ b/src/tests/EventSourcing.UnitTests/ExistsStateTests.cs @@ -16,7 +16,7 @@ public async Task ImplicitBoolConversion_GivenExists_ReturnsTrue() public async Task ImplicitBoolConversion_GivenDoesNotExist_ReturnsFalse() { // Act - bool result = ExistsState.DoesNotExists; + bool result = ExistsState.DoesNotExist; // Assert await Assert.That(result).IsFalse(); diff --git a/src/tests/EventSourcing.UnitTests/IEventStoreExtensionsEnlistTests.cs b/src/tests/EventSourcing.UnitTests/IEventStoreExtensionsEnlistTests.cs index f2bb174b..e64df8ad 100644 --- a/src/tests/EventSourcing.UnitTests/IEventStoreExtensionsEnlistTests.cs +++ b/src/tests/EventSourcing.UnitTests/IEventStoreExtensionsEnlistTests.cs @@ -1,5 +1,6 @@ using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.Aggregates.Test; +using ValidationResult = Purview.EventSourcing.Validation.ValidationResult; namespace Purview.EventSourcing; @@ -23,12 +24,10 @@ public async Task Enlist_GivenSingleAggregate_ReturnsPreparedTransaction(Cancell var aggregate = TestHelpers.Aggregate(clearEvents: false); aggregate.Increment(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns( - new SaveResult(aggregate, new FluentValidation.Results.ValidationResult(), true, false) - ); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(aggregate, new ValidationResult(), true, false)); // Act await using var transaction = eventStore.Enlist(aggregate); @@ -37,9 +36,9 @@ public async Task Enlist_GivenSingleAggregate_ReturnsPreparedTransaction(Cancell // Assert await Assert.That(result.Success).IsTrue(); await Assert.That(result.Results).Count().IsEqualTo(1); - await eventStore - .Received(1) - .SaveAsync(aggregate, Arg.Any(), Arg.Any()); + eventStore + .SaveAsync(Is(aggregate), Any(), Any()) + .WasCalled(Times.Once); } [Test] @@ -52,14 +51,10 @@ public async Task Enlist_GivenMultipleAggregates_EnlistsAllInTransaction(Cancell var agg2 = TestHelpers.Aggregate(clearEvents: false); agg2.RecordEvent(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(ci => - { - var a = ci.ArgAt(0); - return new SaveResult(a, new FluentValidation.Results.ValidationResult(), true, false); - }); + .SaveAsync(Any(), Any(), Any()) + .Returns(static (a, _, _) => new SaveResult(a, new ValidationResult(), true, false)); // Act await using var transaction = eventStore.Enlist(agg1, agg2); @@ -68,12 +63,12 @@ public async Task Enlist_GivenMultipleAggregates_EnlistsAllInTransaction(Cancell // Assert await Assert.That(result.Success).IsTrue(); await Assert.That(result.Results).Count().IsEqualTo(2); - await eventStore - .Received(1) - .SaveAsync(agg1, Arg.Any(), Arg.Any()); - await eventStore - .Received(1) - .SaveAsync(agg2, Arg.Any(), Arg.Any()); + eventStore + .SaveAsync(Is(agg1), Any(), Any()) + .WasCalled(Times.Once); + eventStore + .SaveAsync(Is(agg2), Any(), Any()) + .WasCalled(Times.Once); } [Test] @@ -84,12 +79,10 @@ public async Task Enlist_WithCorrelationId_PropagatesCorrelationIdToTransaction( var aggregate = TestHelpers.Aggregate(clearEvents: false); aggregate.Increment(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns( - new SaveResult(aggregate, new FluentValidation.Results.ValidationResult(), true, false) - ); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(aggregate, new ValidationResult(), true, false)); // Act await using var transaction = eventStore.Enlist(correlationId, aggregate); @@ -97,13 +90,9 @@ public async Task Enlist_WithCorrelationId_PropagatesCorrelationIdToTransaction( // Assert — the transaction uses the provided correlation ID await Assert.That(transaction.CorrelationId).IsEqualTo(correlationId); - await eventStore - .Received(1) - .SaveAsync( - aggregate, - Arg.Is(ctx => ctx.CorrelationId == correlationId), - Arg.Any() - ); + eventStore + .SaveAsync(Is(aggregate), ctx => ctx!.CorrelationId == correlationId, Any()) + .WasCalled(Times.Once); } [Test] @@ -117,7 +106,7 @@ public async Task Enlist_WithNullCorrelationId_GeneratesCorrelationId() var aggregate = TestHelpers.Aggregate(clearEvents: false); aggregate.Increment(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); // Act await using var transaction = eventStore.Enlist(correlationId: null, aggregate); @@ -144,12 +133,10 @@ CancellationToken cancellationToken var aggregate = TestHelpers.Aggregate(clearEvents: false); aggregate.Increment(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns( - new SaveResult(aggregate, new FluentValidation.Results.ValidationResult(), true, false) - ); + .SaveAsync(Any(), Any(), Any()) + .Returns(new SaveResult(aggregate, new ValidationResult(), true, false)); // Act await using var transaction = eventStore.Enlist(context, aggregate); @@ -157,13 +144,9 @@ CancellationToken cancellationToken // Assert — the transaction inherits the correlation ID from the context await Assert.That(transaction.CorrelationId).IsEqualTo(correlationId); - await eventStore - .Received(1) - .SaveAsync( - aggregate, - Arg.Is(ctx => ctx.CorrelationId == correlationId), - Arg.Any() - ); + eventStore + .SaveAsync(Is(aggregate), ctx => ctx!.CorrelationId == correlationId, Any()) + .WasCalled(Times.Once); } [Test] @@ -173,7 +156,7 @@ public async Task Enlist_WithNullOperationContext_GeneratesCorrelationId() var aggregate = TestHelpers.Aggregate(clearEvents: false); aggregate.Increment(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); // Act await using var transaction = eventStore.Enlist((EventStoreOperationContext?)null, aggregate); @@ -186,7 +169,7 @@ public async Task Enlist_WithNullOperationContext_GeneratesCorrelationId() public async Task Enlist_WithCorrelationIdAndNullAggregatesArray_ThrowsArgumentNullException() { // Arrange - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); // Act & Assert await Assert @@ -198,7 +181,7 @@ await Assert public async Task Enlist_WithOperationContextAndNullAggregatesArray_ThrowsArgumentNullException() { // Arrange - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); var context = new EventStoreOperationContext(); // Act & Assert @@ -213,7 +196,7 @@ CancellationToken cancellationToken ) { // Arrange - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); // Act await using var transaction = eventStore.Enlist(); @@ -221,9 +204,9 @@ CancellationToken cancellationToken // Assert — nothing to save, result has no entries but commits without error await Assert.That(result.Results).Count().IsEqualTo(0); - await eventStore - .DidNotReceive() - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()); + eventStore + .SaveAsync(Any(), Any(), Any()) + .WasNeverCalled(); } [Test] @@ -240,33 +223,21 @@ CancellationToken cancellationToken var agg2 = TestHelpers.Aggregate(clearEvents: false); agg2.RecordEvent(); - var eventStore = Substitute.For(); + var eventStore = IEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(ci => - { - var a = ci.ArgAt(0); - return new SaveResult(a, new FluentValidation.Results.ValidationResult(), true, false); - }); + .SaveAsync(Any(), Any(), Any()) + .Returns(static (a, _, _) => new SaveResult(a, new ValidationResult(), true, false)); // Act await using var transaction = eventStore.Enlist(context, agg1, agg2); await transaction.CommitAsync(cancellationToken); // Assert — both saves received the same context - await eventStore - .Received(1) - .SaveAsync( - agg1, - Arg.Is(ctx => ctx.CorrelationId == "shared"), - Arg.Any() - ); - await eventStore - .Received(1) - .SaveAsync( - agg2, - Arg.Is(ctx => ctx.CorrelationId == "shared"), - Arg.Any() - ); + eventStore + .SaveAsync(Is(agg1), ctx => ctx!.CorrelationId == "shared", Any()) + .WasCalled(Times.Once); + eventStore + .SaveAsync(Is(agg2), ctx => ctx!.CorrelationId == "shared", Any()) + .WasCalled(Times.Once); } } diff --git a/src/tests/EventSourcing.UnitTests/Services/AggregateRequiredServiceManagerTests.cs b/src/tests/EventSourcing.UnitTests/Services/AggregateRequiredServiceManagerTests.cs index 96b51bad..6be5c2ac 100644 --- a/src/tests/EventSourcing.UnitTests/Services/AggregateRequiredServiceManagerTests.cs +++ b/src/tests/EventSourcing.UnitTests/Services/AggregateRequiredServiceManagerTests.cs @@ -8,9 +8,9 @@ public partial class AggregateRequiredServiceManagerTests static AggregateRequiredServiceManager CreateServiceManager(IServiceProvider serviceProvider) => new(serviceProvider); - static ITestService CreateTestService() => Substitute.For(); + static AggregateRequiredServiceManagerTests_ITestServiceMock CreateTestService() => ITestService.Mock(); - static ITestService2 CreateTestService2() => Substitute.For(); + static AggregateRequiredServiceManagerTests_ITestService2Mock CreateTestService2() => ITestService2.Mock(); class AggregateRequirementsTest : TestAggregate, IRequirement { diff --git a/src/tests/EventSourcing.UnitTests/Services/FluentValidationAggregateValidatorTests.cs b/src/tests/EventSourcing.UnitTests/Services/FluentValidationAggregateValidatorTests.cs deleted file mode 100644 index c70d08a7..00000000 --- a/src/tests/EventSourcing.UnitTests/Services/FluentValidationAggregateValidatorTests.cs +++ /dev/null @@ -1,39 +0,0 @@ -using FluentValidation; -using Purview.EventSourcing.Aggregates; -using Purview.EventSourcing.Services; - -namespace Purview.EventSourcing.Services; - -public sealed class FluentValidationAggregateValidatorTests -{ - [Test] - public async Task ValidateAsync_UsesAsyncRules() - { - var asyncRuleInvoked = false; - var aggregate = new TestAggregate { Name = "invalid" }; - var validator = new InlineValidator(); - validator - .RuleFor(m => m.Name) - .MustAsync( - (_, _) => - { - asyncRuleInvoked = true; - return Task.FromResult(true); - } - ); - - var adapter = new FluentValidationAggregateValidator(validator); - - var result = await adapter.ValidateAsync(aggregate); - - await Assert.That(asyncRuleInvoked).IsTrue(); - await Assert.That(result.IsValid).IsTrue(); - } - - sealed class TestAggregate : AggregateBase - { - public string Name { get; set; } = string.Empty; - - protected override void RegisterEvents() { } - } -} diff --git a/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreClientTests.cs b/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreClientTests.cs index d7c1b755..b1ea8d6d 100644 --- a/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreClientTests.cs +++ b/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreClientTests.cs @@ -6,8 +6,6 @@ namespace Purview.EventSourcing.SqlServer.Events; /// public sealed class SqlServerEventStoreClientTests { - #region Identifier Validation Tests - [Test] public async Task Constructor_GivenDefaultOptions_CreatesClientWithoutThrowing() { @@ -142,10 +140,6 @@ await Assert .Throws(); } - #endregion - - #region Per-Aggregate Table Override Tests - [Test] public async Task SqlServerEventStoreOptions_GivenNoOverride_AggregateTableOverridesIsEmpty() { @@ -211,5 +205,133 @@ public async Task SqlServerAggregateTableOverride_GivenBothOverrides_BothAreStor await Assert.That(ovr.TableName).IsEqualTo("Events"); } - #endregion + [Test] + public async Task SqlServerEventStoreOptions_GivenDefaults_JsonIndexOptionsIsInitialized() + { + var options = new SqlServerEventStoreOptions + { + ConnectionString = "Server=.;Database=Test;Trusted_Connection=True;", + }; + + await Assert.That(options.JsonIndexOptions).IsNotNull(); + await Assert.That(options.JsonIndexOptions.Indexes).IsEmpty(); + } + + [Test] + public async Task Constructor_GivenUnsupportedJsonIndexIncludeColumn_ThrowsArgumentException() + { + await Assert + .That(() => + { + var _ = new SqlServerEventStoreClient( + new SqlServerEventStoreOptions + { + ConnectionString = "Server=.;Database=Test;Trusted_Connection=True;", + SchemaName = "dbo", + TableName = "EventStore", + AutoCreateTable = false, + JsonIndexOptions = new SqlServerJsonIndexOptions + { + Enabled = true, + Indexes = + [ + new SqlServerJsonIndexDefinition + { + JsonPath = "$.Value", + IncludeColumns = ["NotAColumn"], + }, + ], + }, + } + ); + }) + .Throws(); + } + + [Test] + public async Task Constructor_GivenJsonIndexWithInvalidPath_ThrowsArgumentException() + { + await Assert + .That(() => + { + var _ = new SqlServerEventStoreClient( + new SqlServerEventStoreOptions + { + ConnectionString = "Server=.;Database=Test;Trusted_Connection=True;", + SchemaName = "dbo", + TableName = "EventStore", + AutoCreateTable = false, + JsonIndexOptions = new SqlServerJsonIndexOptions + { + Enabled = true, + Indexes = [new SqlServerJsonIndexDefinition { JsonPath = "StringProperty" }], + }, + } + ); + }) + .Throws(); + } + + [Test] + public async Task Constructor_GivenJsonIndexWithDuplicateIndexNames_ThrowsArgumentException() + { + await Assert + .That(() => + { + var _ = new SqlServerEventStoreClient( + new SqlServerEventStoreOptions + { + ConnectionString = "Server=.;Database=Test;Trusted_Connection=True;", + SchemaName = "dbo", + TableName = "EventStore", + AutoCreateTable = false, + JsonIndexOptions = new SqlServerJsonIndexOptions + { + Enabled = true, + Indexes = + [ + new SqlServerJsonIndexDefinition { JsonPath = "$.Value", IndexName = "IX_Duplicate" }, + new SqlServerJsonIndexDefinition + { + JsonPath = "$.OtherValue", + IndexName = "IX_Duplicate", + }, + ], + }, + } + ); + }) + .Throws(); + } + + [Test] + public async Task Constructor_GivenJsonIndexWithUnsafeFilter_ThrowsArgumentException() + { + await Assert + .That(() => + { + var _ = new SqlServerEventStoreClient( + new SqlServerEventStoreOptions + { + ConnectionString = "Server=.;Database=Test;Trusted_Connection=True;", + SchemaName = "dbo", + TableName = "EventStore", + AutoCreateTable = false, + JsonIndexOptions = new SqlServerJsonIndexOptions + { + Enabled = true, + Indexes = + [ + new SqlServerJsonIndexDefinition + { + JsonPath = "$.Value", + Filter = "[EntityType] = 1; DROP TABLE dbo.EventStore", + }, + ], + }, + } + ); + }) + .Throws(); + } } diff --git a/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreTransactionFactoryTests.cs b/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreTransactionFactoryTests.cs index 1c0fa12e..0706f4d9 100644 --- a/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreTransactionFactoryTests.cs +++ b/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreTransactionFactoryTests.cs @@ -1,6 +1,6 @@ using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; -using Purview.EventSourcing.SqlServer.Events; +using Microsoft.Extensions.Options; namespace Purview.EventSourcing.SqlServer.Events; @@ -9,7 +9,7 @@ public sealed class SqlServerEventStoreTransactionFactoryTests [Test] public async Task CreateSqlServerTransaction_GivenNullCorrelationId_UsesAmbientProviderValue() { - var correlationIdProvider = Substitute.For(); + var correlationIdProvider = IEventStoreCorrelationIdProvider.Mock(); correlationIdProvider.GetCorrelationId().Returns("ambient-sql-correlation"); var factory = new SqlServerEventStoreTransactionFactory(correlationIdProvider); @@ -21,20 +21,20 @@ public async Task CreateSqlServerTransaction_GivenNullCorrelationId_UsesAmbientP [Test] public async Task CreateSqlServerTransaction_GivenExplicitCorrelationId_PrefersExplicitValueOverAmbientProvider() { - var correlationIdProvider = Substitute.For(); + var correlationIdProvider = IEventStoreCorrelationIdProvider.Mock(); correlationIdProvider.GetCorrelationId().Returns("ambient-sql-correlation"); var factory = new SqlServerEventStoreTransactionFactory(correlationIdProvider); await using var transaction = factory.CreateSqlServerTransaction("explicit-sql-correlation"); await Assert.That(transaction.CorrelationId).IsEqualTo("explicit-sql-correlation"); - correlationIdProvider.DidNotReceive().GetCorrelationId(); + correlationIdProvider.GetCorrelationId().WasNeverCalled(); } [Test] public async Task Create_GivenNullCorrelationId_ReturnsSqlServerTransaction() { - var correlationIdProvider = Substitute.For(); + var correlationIdProvider = IEventStoreCorrelationIdProvider.Mock(); correlationIdProvider.GetCorrelationId().Returns("ambient-sql-correlation"); var factory = new SqlServerEventStoreTransactionFactory(correlationIdProvider); @@ -81,4 +81,36 @@ public async Task AddSqlServerEventStore_RegistersSqlServerSpecificFactoryWithou await Assert.That(sqlFactory).IsTypeOf(); await Assert.That(defaultFactory).IsTypeOf(); } + + [Test] + public async Task AddSqlServerEventStore_GivenInvalidJsonIndexConfiguration_ResolvingOptionsThrowsValidationException() + { + var services = new ServiceCollection(); + services.AddSingleton( + new ConfigurationBuilder() + .AddInMemoryCollection( + new Dictionary + { + ["ConnectionStrings:eventstore-sqlserver"] = + "Server=.;Database=TestDb;Trusted_Connection=True;TrustServerCertificate=True;", + } + ) + .Build() + ); + services.AddSqlServerEventStore(); + services.Configure(options => + { + options.JsonIndexOptions.Enabled = true; + options.JsonIndexOptions.Indexes = [new SqlServerJsonIndexDefinition { JsonPath = "invalid-path" }]; + }); + + using var serviceProvider = services.BuildServiceProvider(); + + var exception = await Assert + .That(() => serviceProvider.GetRequiredService>().Value) + .Throws(); + + await Assert.That(exception).IsNotNull(); + await Assert.That(exception!.Message).Contains("JsonPath"); + } } diff --git a/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreTransactionTests.cs b/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreTransactionTests.cs new file mode 100644 index 00000000..7be73a6a --- /dev/null +++ b/src/tests/EventSourcing.UnitTests/SqlServer/Events/SqlServerEventStoreTransactionTests.cs @@ -0,0 +1,133 @@ +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; +using Purview.EventSourcing.Aggregates.Test; +using Purview.EventSourcing.Internal; + +namespace Purview.EventSourcing.SqlServer.Events; + +public sealed class SqlServerEventStoreTransactionTests +{ + [Test] + public async Task Enlist_GivenMismatchedTransactionalBoundaries_ThrowsInvalidOperationException() + { + var agg1 = TestHelpers.Aggregate(clearEvents: false); + agg1.Increment(); + var agg2 = TestHelpers.Aggregate(clearEvents: false); + agg2.Increment(); + + await using var transaction = new SqlServerEventStoreTransaction("sql"); + transaction.Enlist(agg1, new FakeTransactionalStore("sqlserver-primary")); + + var exception = await Assert + .That(() => transaction.Enlist(agg2, new FakeTransactionalStore("sqlserver-secondary"))) + .Throws(); + + await Assert.That(exception!.Message).Contains("same transaction boundary"); + } + + [Test] + public async Task Enlist_GivenMatchingTransactionalBoundaries_AllowsMultipleStores() + { + var agg1 = TestHelpers.Aggregate(clearEvents: false); + agg1.Increment(); + var agg2 = TestHelpers.Aggregate(clearEvents: false); + agg2.Increment(); + + await using var transaction = new SqlServerEventStoreTransaction("sql"); + transaction.Enlist(agg1, new FakeTransactionalStore("sqlserver-primary")); + transaction.Enlist(agg2, new FakeTransactionalStore("sqlserver-primary")); + + await Assert.That(transaction.CorrelationId).IsEqualTo("sql"); + } + + sealed class FakeTransactionalStore(string boundaryKey) : ITransactionalEventStore + { + public string TransactionBoundaryKey => boundaryKey; + + public Task CreateAsync( + string? aggregateId = null, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + + public Task GetOrCreateAsync( + string? aggregateId, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + + public Task GetAsync( + string aggregateId, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + + public Task GetAtAsync( + string aggregateId, + int version, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + + public Task> SaveAsync( + TestAggregate aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + + public Task IsDeletedAsync(string aggregateId, CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task GetDeletedAsync( + string aggregateId, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + + public Task DeleteAsync( + TestAggregate aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + + public Task RestoreAsync( + TestAggregate aggregate, + EventStoreOperationContext? operationContext, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + + public async IAsyncEnumerable GetAggregateIdsAsync( + bool includeDeleted, + [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default + ) + { + await Task.CompletedTask; + yield break; + } + + public Task ExistsAsync(string aggregateId, CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public TestAggregate FulfilRequirements(TestAggregate aggregate) => aggregate; + + public IAsyncEnumerable<(IEvent @event, string eventType)> GetEventRangeAsync( + string aggregateId, + int versionFrom, + int? versionTo, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + + public System.Data.Common.DbConnection CreateTransactionConnection() => throw new NotSupportedException(); + + public Task EnsureTransactionConfiguredAsync( + System.Data.Common.DbConnection connection, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + + public Task> SaveInTransactionAsync( + TestAggregate aggregate, + EventStoreOperationContext? operationContext, + System.Data.Common.DbConnection connection, + System.Data.Common.DbTransaction transaction, + CancellationToken cancellationToken = default + ) => throw new NotSupportedException(); + } +} diff --git a/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotClientTests.cs b/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotClientTests.cs index 8026ead8..b5b1a4a3 100644 --- a/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotClientTests.cs +++ b/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotClientTests.cs @@ -32,25 +32,6 @@ public async Task Constructor_GivenDefaultOptions_DoesNotUseLegacyEnsureTableSql await Assert.That(ensureTableSqlField).IsNull(); } - [Test] - public async Task GetByIdAsync_GivenUnsupportedPayloadShape_ThrowsEarly() - { - var client = new SqlServerClient( - new SqlServerClientOptions("Server=.;Database=Test;Trusted_Connection=True;Encrypt=False;", false) - { - SchemaName = "dbo", - TableName = $"Snapshots_{Guid.NewGuid():N}", - AutoCreateTable = false, - } - ); - - Task Act() => client.GetByIdAsync("id"); - - var ex = await Assert.That(Act).Throws(); - await Assert.That(ex).IsNotNull(); - await Assert.That(ex.Message).Contains(nameof(UnsupportedPayloadAggregate.UnsupportedMap)); - } - [Test] public async Task ValidateAggregatePayloadShape_GivenEventStoreCollections_DoesNotThrow() { @@ -119,27 +100,6 @@ sealed class ScalarHolder public ScalarEmail Email { get; init; } = new("default@test.com"); } - sealed class UnsupportedPayloadAggregate : IAggregate - { - public string AggregateType => nameof(UnsupportedPayloadAggregate); - - public AggregateDetails Details { get; init; } = new(); - - public Dictionary UnsupportedMap { get; init; } = []; - - public IEnumerable GetUnsavedEvents() => []; - - public bool HasUnsavedEvents() => false; - - public IEnumerable GetRegisteredEventTypes() => []; - - public bool CanApplyEvent(IEvent aggregateEvent) => false; - - public void ClearUnsavedEvents(int? upToVersion = null) { } - - void IAggregate.ApplyEvent(IEvent @event) { } - } - sealed class SupportedCollectionAggregate : IAggregate { public string AggregateType => nameof(SupportedCollectionAggregate); diff --git a/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotEventStoreTests.cs b/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotEventStoreTests.cs index 01d8cb13..98525528 100644 --- a/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotEventStoreTests.cs +++ b/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotEventStoreTests.cs @@ -4,6 +4,7 @@ using Purview.EventSourcing.Aggregates.Test; using Purview.EventSourcing.Internal; using Purview.EventSourcing.SqlServer.Snapshot; +using ValidationResult = Purview.EventSourcing.Validation.ValidationResult; namespace Purview.EventSourcing.SqlServer.Snapshots; @@ -24,8 +25,8 @@ public async Task CreateAsync_GivenAggregateId_DelegatesToEventStore() { // Arrange var expectedAggregate = TestHelpers.Aggregate(); - var eventStore = Substitute.For>(); - eventStore.CreateAsync(Arg.Any(), Arg.Any()).Returns(expectedAggregate); + var eventStore = INonQueryableEventStore.Mock(); + eventStore.CreateAsync(Any(), Any()).Returns(expectedAggregate); var store = CreateStore(eventStore); @@ -34,7 +35,7 @@ public async Task CreateAsync_GivenAggregateId_DelegatesToEventStore() // Assert await Assert.That(result).IsEqualTo(expectedAggregate); - await eventStore.Received(1).CreateAsync("test-id", Arg.Any()); + eventStore.CreateAsync("test-id", Any()).WasCalled(Times.Once); } [Test] @@ -42,9 +43,9 @@ public async Task GetAsync_GivenAggregateId_DelegatesToEventStore() { // Arrange var expectedAggregate = TestHelpers.Aggregate(); - var eventStore = Substitute.For>(); + var eventStore = INonQueryableEventStore.Mock(); eventStore - .GetAsync(Arg.Any(), Arg.Any(), Arg.Any()) + .GetAsync(Any(), Any(), Any()) .Returns(expectedAggregate); var store = CreateStore(eventStore); @@ -54,105 +55,106 @@ public async Task GetAsync_GivenAggregateId_DelegatesToEventStore() // Assert await Assert.That(result).IsEqualTo(expectedAggregate); - await eventStore.Received(1).GetAsync("test-id", null, Arg.Any()); + eventStore + .GetAsync(Is("test-id"), Any(), Any()) + .WasCalled(Times.Once); } [Test] - public async Task GetOrCreateAsync_GivenAggregateId_DelegatesToEventStore() + public async Task GetOrCreateAsync_GivenAggregateId_DelegatesToEventStore(CancellationToken cancellationToken) { // Arrange var expectedAggregate = TestHelpers.Aggregate(); - var eventStore = Substitute.For>(); + var eventStore = INonQueryableEventStore.Mock(); eventStore - .GetOrCreateAsync(Arg.Any(), Arg.Any(), Arg.Any()) + .GetOrCreateAsync(Any(), Any(), Is(cancellationToken)) .Returns(expectedAggregate); var store = CreateStore(eventStore); // Act - var result = await store.GetOrCreateAsync("test-id", null); + var result = await store.GetOrCreateAsync("test-id", null, cancellationToken); // Assert await Assert.That(result).IsEqualTo(expectedAggregate); - await eventStore.Received(1).GetOrCreateAsync("test-id", null, Arg.Any()); + eventStore + .GetOrCreateAsync("test-id", Any(), Is(cancellationToken)) + .WasCalled(Times.Once); } [Test] - public async Task GetAtAsync_GivenAggregateIdAndVersion_DelegatesToEventStore() + public async Task GetAtAsync_GivenAggregateIdAndVersion_DelegatesToEventStore(CancellationToken cancellationToken) { // Arrange var expectedAggregate = TestHelpers.Aggregate(); - var eventStore = Substitute.For>(); + var eventStore = INonQueryableEventStore.Mock(); eventStore - .GetAtAsync( - Arg.Any(), - Arg.Any(), - Arg.Any(), - Arg.Any() - ) + .GetAtAsync(Any(), Any(), Any(), Is(cancellationToken)) .Returns(expectedAggregate); var store = CreateStore(eventStore); // Act - var result = await store.GetAtAsync("test-id", 5, null); + var result = await store.GetAtAsync("test-id", 5, null, cancellationToken); // Assert await Assert.That(result).IsEqualTo(expectedAggregate); - await eventStore.Received(1).GetAtAsync("test-id", 5, null, Arg.Any()); + eventStore + .GetAtAsync(Is("test-id"), Is(5), Any(), Is(cancellationToken)) + .WasCalled(Times.Once); } [Test] - public async Task IsDeletedAsync_DelegatesToEventStore() + public async Task IsDeletedAsync_DelegatesToEventStore(CancellationToken cancellationToken) { // Arrange - var eventStore = Substitute.For>(); - eventStore.IsDeletedAsync(Arg.Any(), Arg.Any()).Returns(true); + var eventStore = INonQueryableEventStore.Mock(); + eventStore.IsDeletedAsync(Any(), Is(cancellationToken)).Returns(true); var store = CreateStore(eventStore); // Act - var result = await store.IsDeletedAsync("test-id"); + var result = await store.IsDeletedAsync("test-id", cancellationToken); // Assert await Assert.That(result).IsTrue(); - await eventStore.Received(1).IsDeletedAsync("test-id", Arg.Any()); + eventStore.IsDeletedAsync(Is("test-id"), Is(cancellationToken)).WasCalled(Times.Once); } [Test] - public async Task GetDeletedAsync_DelegatesToEventStore() + public async Task GetDeletedAsync_DelegatesToEventStore(CancellationToken cancellationToken) { // Arrange var expectedAggregate = TestHelpers.Aggregate(); - var eventStore = Substitute.For>(); - eventStore.GetDeletedAsync(Arg.Any(), Arg.Any()).Returns(expectedAggregate); + var eventStore = INonQueryableEventStore.Mock(); + eventStore.GetDeletedAsync(Any(), Any()).Returns(expectedAggregate); var store = CreateStore(eventStore); // Act - var result = await store.GetDeletedAsync("test-id"); + var result = await store.GetDeletedAsync("test-id", cancellationToken); // Assert await Assert.That(result).IsEqualTo(expectedAggregate); - await eventStore.Received(1).GetDeletedAsync("test-id", Arg.Any()); + eventStore.GetDeletedAsync(Is("test-id"), Is(cancellationToken)).WasCalled(Times.Once); } [Test] - public async Task ExistsAsync_DelegatesToEventStore() + public async Task ExistsAsync_DelegatesToEventStore(CancellationToken cancellationToken) { // Arrange var expectedState = ExistsState.Exists; - var eventStore = Substitute.For>(); - eventStore.ExistsAsync(Arg.Any(), Arg.Any()).Returns(expectedState); + var eventStore = INonQueryableEventStore.Mock(); + eventStore.ExistsAsync(Any(), Any()).Returns(expectedState); var store = CreateStore(eventStore); // Act - var result = await store.ExistsAsync("test-id"); + var result = await store.ExistsAsync("test-id", cancellationToken); // Assert await Assert.That(result).IsEqualTo(expectedState); - await eventStore.Received(1).ExistsAsync("test-id", Arg.Any()); + eventStore.ExistsAsync(Is("test-id"), Any()).WasCalled(Times.Once); } [Test] @@ -160,8 +162,8 @@ public async Task FulfilRequirements_DelegatesToEventStore() { // Arrange var expectedAggregate = TestHelpers.Aggregate(); - var eventStore = Substitute.For>(); - eventStore.FulfilRequirements(Arg.Any()).Returns(expectedAggregate); + var eventStore = INonQueryableEventStore.Mock(); + eventStore.FulfilRequirements(Any()).Returns(expectedAggregate); var store = CreateStore(eventStore); @@ -170,76 +172,53 @@ public async Task FulfilRequirements_DelegatesToEventStore() // Assert await Assert.That(result).IsEqualTo(expectedAggregate); - eventStore.Received(1).FulfilRequirements(expectedAggregate); + eventStore.FulfilRequirements(expectedAggregate).WasCalled(Times.Once); } [Test] - public async Task SaveAsync_GivenNeverSnapshotStrategy_DoesNotWriteSnapshot() + public async Task SaveAsync_GivenNeverSnapshotStrategy_DoesNotWriteSnapshot(CancellationToken cancellationToken) { var aggregate = TestHelpers.Aggregate(creator: a => a.RecordEvent(), clearEvents: false); - var eventStore = Substitute.For>(); + var eventStore = INonQueryableEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(args => new SaveResult( - args.Arg(), - new FluentValidation.Results.ValidationResult(), - saved: true, - skipped: false - )); + .SaveAsync(Any(), Any(), Any()) + .Returns( + static (a, _, _) => + new SaveResult(a, new ValidationResult(), saved: true, skipped: false) + ); var store = CreateStore(eventStore, snapshotStrategy: new NeverSnapshotStrategy()); - var result = await store.SaveAsync(aggregate, null); + var result = await store.SaveAsync(aggregate, null, cancellationToken); await Assert.That(result.Saved).IsTrue(); - await eventStore.Received(1).SaveAsync(aggregate, null, Arg.Any()); + eventStore + .SaveAsync(Is(aggregate), Any(), Any()) + .WasCalled(Times.Once); } [Test] - public async Task SaveAsync_GivenContextSnapshotStrategy_OverridesDefaultStrategy() + public async Task SaveAsync_GivenContextSnapshotStrategy_OverridesDefaultStrategy( + CancellationToken cancellationToken + ) { var aggregate = TestHelpers.Aggregate(creator: a => a.RecordEvent(), clearEvents: false); - var eventStore = Substitute.For>(); + var eventStore = INonQueryableEventStore.Mock(); eventStore - .SaveAsync(Arg.Any(), Arg.Any(), Arg.Any()) - .Returns(args => new SaveResult( - args.Arg(), - new FluentValidation.Results.ValidationResult(), - saved: true, - skipped: false - )); + .SaveAsync(Any(), Any(), Any()) + .Returns( + static (a, _, _) => + new SaveResult(a, new ValidationResult(), saved: true, skipped: false) + ); var store = CreateStore(eventStore, snapshotStrategy: new AlwaysSnapshotStrategy()); var context = new EventStoreOperationContext().SetSnapshotStrategy(new NeverSnapshotStrategy()); - var result = await store.SaveAsync(aggregate, context); + var result = await store.SaveAsync(aggregate, context, cancellationToken); await Assert.That(result.Saved).IsTrue(); - await eventStore.Received(1).SaveAsync(aggregate, context, Arg.Any()); - } - - static SqlServerSnapshotEventStore CreateStore( - INonQueryableEventStore? eventStore = null, - SqlServerSnapshotEventStoreOptions? options = null, - ISnapshotStrategy? snapshotStrategy = null, - ISnapshotStrategySelector? snapshotStrategySelector = null - ) - { - eventStore ??= Substitute.For>(); - var wrappedOptions = Options.Create(options ?? CreateDefaultOptions()); - var telemetry = Substitute.For(); - - return new(eventStore, wrappedOptions, telemetry, snapshotStrategy, snapshotStrategySelector); + eventStore.SaveAsync(Is(aggregate), context, Any()).WasCalled(Times.Once); } - static SqlServerSnapshotEventStoreOptions CreateDefaultOptions() => - new() - { - ConnectionString = "Server=(localdb)\\mssqllocaldb;Database=TestDb;Trusted_Connection=True;", - TableName = "TestSnapshots", - SchemaName = "dbo", - AutoCreateTable = false, - }; - [Test] public async Task Constructor_GivenOptionsWithAggregateTableOverride_CreatesStoreWithoutThrowing() { @@ -271,4 +250,96 @@ public async Task Constructor_GivenOptionsWithPartialAggregateTableOverride_Fall var store = CreateStore(options: options); await Assert.That(store).IsNotNull(); } + + [Test] + public async Task Constructor_GivenDefaults_JsonIndexOptionsIsInitialized() + { + var options = CreateDefaultOptions(); + + await Assert.That(options.JsonIndexOptions).IsNotNull(); + await Assert.That(options.JsonIndexOptions.Indexes).IsEmpty(); + } + + [Test] + public async Task Constructor_GivenUnsupportedJsonIndexIncludeColumn_ThrowsArgumentException() + { + var options = CreateDefaultOptions(); + options.JsonIndexOptions = new SqlServerJsonIndexOptions + { + Enabled = true, + Indexes = + [ + new SqlServerJsonIndexDefinition { JsonPath = "$.StringProperty", IncludeColumns = ["Version"] }, + ], + }; + + await Assert.That(() => CreateStore(options: options)).Throws(); + } + + [Test] + public async Task Constructor_GivenJsonIndexWithDuplicateDefinition_ThrowsArgumentException() + { + var options = CreateDefaultOptions(); + options.JsonIndexOptions = new SqlServerJsonIndexOptions + { + Enabled = true, + Indexes = + [ + new SqlServerJsonIndexDefinition { JsonPath = "$.StringProperty", IncludeColumns = ["Id"] }, + new SqlServerJsonIndexDefinition { JsonPath = "$.StringProperty", IncludeColumns = ["Id"] }, + ], + }; + + await Assert.That(() => CreateStore(options: options)).Throws(); + } + + [Test] + public async Task Constructor_GivenJsonIndexWithConflictingComputedColumnName_ThrowsArgumentException() + { + var options = CreateDefaultOptions(); + options.JsonIndexOptions = new SqlServerJsonIndexOptions + { + Enabled = true, + Indexes = + [ + new SqlServerJsonIndexDefinition + { + JsonPath = "$.StringProperty", + ComputedColumnName = "Json_Value", + SqlType = "nvarchar(450)", + }, + new SqlServerJsonIndexDefinition + { + JsonPath = "$.IncrementInt32", + ComputedColumnName = "Json_Value", + SqlType = "int", + }, + ], + }; + + await Assert.That(() => CreateStore(options: options)).Throws(); + } + + static SqlServerSnapshotEventStore CreateStore( + INonQueryableEventStore? eventStore = null, + SqlServerSnapshotEventStoreOptions? options = null, + ISnapshotStrategy? snapshotStrategy = null, + ISnapshotStrategySelector? snapshotStrategySelector = null + ) + { + eventStore ??= INonQueryableEventStore.Mock(); + var wrappedOptions = Options.Create(options ?? CreateDefaultOptions()); + var telemetry = TestHelpers.CreateSqlServerSnapshotEventStoreTelemetry(); + + return new(eventStore, wrappedOptions, telemetry, snapshotStrategy, snapshotStrategySelector); + } + + static SqlServerSnapshotEventStoreOptions CreateDefaultOptions() => + new() + { + ConnectionString = "Server=(localdb)\\mssqllocaldb;Database=TestDb;Trusted_Connection=True;", + TableName = "TestSnapshots", + SchemaName = "dbo", + AutoCreateTable = false, + }; } diff --git a/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotServiceCollectionExtensionsTests.cs b/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotServiceCollectionExtensionsTests.cs new file mode 100644 index 00000000..669e691a --- /dev/null +++ b/src/tests/EventSourcing.UnitTests/SqlServer/Snapshots/SqlServerSnapshotServiceCollectionExtensionsTests.cs @@ -0,0 +1,43 @@ +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; + +namespace Purview.EventSourcing.SqlServer.Snapshots; + +public sealed class SqlServerSnapshotServiceCollectionExtensionsTests +{ + [Test] + public async Task AddSqlServerSnapshotQueryableEventStore_GivenInvalidJsonIndexConfiguration_ResolvingOptionsThrowsValidationException() + { + var services = new ServiceCollection(); + services.AddSingleton( + new ConfigurationBuilder() + .AddInMemoryCollection( + new Dictionary + { + ["ConnectionStrings:eventstore-snapshots-sqlserver"] = + "Server=.;Database=TestDb;Trusted_Connection=True;TrustServerCertificate=True;", + } + ) + .Build() + ); + services.AddSqlServerSnapshotQueryableEventStore(); + services.Configure(options => + { + options.JsonIndexOptions.Enabled = true; + options.JsonIndexOptions.Indexes = + [ + new SqlServerJsonIndexDefinition { JsonPath = "$.StringProperty", IncludeColumns = ["Version"] }, + ]; + }); + + using var serviceProvider = services.BuildServiceProvider(); + + var exception = await Assert + .That(() => serviceProvider.GetRequiredService>().Value) + .Throws(); + + await Assert.That(exception).IsNotNull(); + await Assert.That(exception!.Message).Contains("unsupported column"); + } +} diff --git a/src/tests/EventSourcing.UnitTests/TypeNameHelperTests.cs b/src/tests/EventSourcing.UnitTests/TypeNameHelperTests.cs index 1aae3c2e..736ec310 100644 --- a/src/tests/EventSourcing.UnitTests/TypeNameHelperTests.cs +++ b/src/tests/EventSourcing.UnitTests/TypeNameHelperTests.cs @@ -1,6 +1,4 @@ -using NSubstitute.ReturnsExtensions; - -namespace Purview.EventSourcing; +namespace Purview.EventSourcing; public class TypeNameHelperTests { @@ -24,9 +22,9 @@ string trimNamePart ) { // Arrange - var type = Substitute.For(); + var type = Type.Mock(); type.Name.Returns(aggregateName); - type.FullName.ReturnsNull(); + type.FullName.Returns((string?)null); // Act var result = TypeNameHelper.GetName(type, trimNamePart); @@ -51,9 +49,9 @@ string trimNamePart ) { // Arrange - var type = Substitute.For(); + var type = Type.Mock(); type.Name.Returns(aggregateName); - type.FullName.ReturnsNull(); + type.FullName.Returns((string?)null); // Act var result = TypeNameHelper.GetName(type, trimNamePart); @@ -76,7 +74,7 @@ string trimNamePart ) { // Arrange - var type = Substitute.For(); + var type = Type.Mock(); type.Name.Returns("anything"); type.FullName.Returns(aggregateName); @@ -101,9 +99,9 @@ string trimNamePart ) { // Arrange - var type = Substitute.For(); + var type = Type.Mock(); type.Name.Returns(aggregateName); - type.FullName.ReturnsNull(); + type.FullName.Returns((string?)null); // Act var result = TypeNameHelper.GetName(type, trimNamePart); diff --git a/src/tests/FluentValidationImpl.UnitTests/FluentValidationImpl.UnitTests.csproj b/src/tests/FluentValidationImpl.UnitTests/FluentValidationImpl.UnitTests.csproj new file mode 100644 index 00000000..d5474103 --- /dev/null +++ b/src/tests/FluentValidationImpl.UnitTests/FluentValidationImpl.UnitTests.csproj @@ -0,0 +1,5 @@ + + + Purview.EventSourcing.FluentValidation + + diff --git a/src/tests/FluentValidationImpl.UnitTests/Services/FluentValidationAggregateValidatorTests.cs b/src/tests/FluentValidationImpl.UnitTests/Services/FluentValidationAggregateValidatorTests.cs new file mode 100644 index 00000000..2cd5ca2c --- /dev/null +++ b/src/tests/FluentValidationImpl.UnitTests/Services/FluentValidationAggregateValidatorTests.cs @@ -0,0 +1,58 @@ +using FluentValidation; +using Purview.EventSourcing.Aggregates; + +namespace Purview.EventSourcing.FluentValidation.Services; + +public sealed class FluentValidationAggregateValidatorTests +{ + [Test] + public async Task ValidateAsync_UsesAsyncRules(CancellationToken cancellationToken) + { + var asyncRuleInvoked = false; + var aggregate = new TestAggregate { Name = "invalid" }; + var validator = new InlineValidator(); + validator + .RuleFor(m => m.Name) + .MustAsync( + (_, _) => + { + asyncRuleInvoked = true; + return Task.FromResult(true); + } + ); + + var adapter = new FluentValidationAggregateValidator(validator); + + var result = await adapter.ValidateAsync(aggregate, cancellationToken); + + await Assert.That(asyncRuleInvoked).IsTrue(); + await Assert.That(result.IsValid).IsTrue(); + } + + [Test] + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Performance", + "CA1849:Call async methods when in an async method" + )] + public async Task Validate_WhenFluentValidationFails_MapsToCoreValidationResult() + { + var aggregate = new TestAggregate { Name = "" }; + var validator = new InlineValidator(); + validator.RuleFor(m => m.Name).NotEmpty(); + + var adapter = new FluentValidationAggregateValidator(validator); + + var result = adapter.Validate(aggregate); + + await Assert.That(result.IsValid).IsFalse(); + await Assert.That(result.Errors).Count().IsEqualTo(1); + await Assert.That(result.Errors[0].PropertyName).IsEqualTo("Name"); + } + + sealed class TestAggregate : AggregateBase + { + public string Name { get; set; } = string.Empty; + + protected override void RegisterEvents() { } + } +} diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.DeleteAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.DeleteAsync.cs similarity index 77% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.DeleteAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.DeleteAsync.cs index 0210c8eb..9465a0da 100644 --- a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.DeleteAsync.cs +++ b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.DeleteAsync.cs @@ -1,5 +1,3 @@ -using Purview.EventSourcing.ChangeFeed; - namespace Purview.EventSourcing.MongoDB.Events; partial class GenericMongoDBEventStoreTests @@ -55,13 +53,13 @@ await eventStore.GetAsync(aggregateId, cancellationToken: cancellationToken) // Assert await Assert.That(result).IsTrue(); - await cache.Received(1).RemoveAsync(cacheKey, Arg.Any()); + cache.RemoveAsync(cacheKey, Any()).WasCalled(Times.Once); } public async Task DeleteAsync_GivenDelete_NotifiesChangeFeed(CancellationToken cancellationToken) { // Arrange - var aggregateChangeNotifier = Substitute.For>(); + var aggregateChangeNotifier = TestHelpers.CreateAggregateChangeFeedNotified(); var beforeWasCalled = false; var afterWasCalled = false; @@ -69,15 +67,15 @@ public async Task DeleteAsync_GivenDelete_NotifiesChangeFeed(CancellationToken c var aggregate = TestHelpers.Aggregate(aggregateId: aggregateId); aggregate.IncrementInt32Value(); - var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); + var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); aggregateChangeNotifier - .When(m => m.BeforeDeleteAsync(aggregate, Arg.Any())) - .Do(_ => beforeWasCalled = true); + .BeforeDeleteAsync(aggregate, Any()) + .Callback(() => beforeWasCalled = true); aggregateChangeNotifier - .When(m => m.AfterDeleteAsync(aggregate, Arg.Any())) - .Do(_ => afterWasCalled = true); + .AfterDeleteAsync(aggregate, Any()) + .Callback(() => afterWasCalled = true); await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); @@ -88,8 +86,8 @@ public async Task DeleteAsync_GivenDelete_NotifiesChangeFeed(CancellationToken c await Assert.That(beforeWasCalled).IsTrue(); await Assert.That(afterWasCalled).IsTrue(); - await aggregateChangeNotifier.Received(1).BeforeDeleteAsync(aggregate, Arg.Any()); + aggregateChangeNotifier.BeforeDeleteAsync(aggregate, Any()).WasCalled(Times.Once); - await aggregateChangeNotifier.Received(1).AfterDeleteAsync(aggregate, Arg.Any()); + aggregateChangeNotifier.AfterDeleteAsync(aggregate, Any()).WasCalled(Times.Once); } } diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAggregateIdsAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAggregateIdsAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAggregateIdsAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAggregateIdsAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAsync.cs similarity index 95% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAsync.cs index 57ef1913..893706d4 100644 --- a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAsync.cs +++ b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAsync.cs @@ -165,15 +165,15 @@ CancellationToken cancellationToken // Assert telemetry - .Received(numberOfOldEventsToCreate) .CannotApplyEvent( aggregateId, - Arg.Any(), - Arg.Any(), - Arg.Any(), - Arg.Is(eventType => eventType.Contains(typeof(OldEvent).Name, StringComparison.Ordinal)), - Arg.Any() - ); + Any(), + Any(), + Any(), + Is(eventType => eventType!.Contains(typeof(OldEvent).Name, StringComparison.Ordinal)), + Any() + ) + .WasCalled(Times.Exactly(numberOfOldEventsToCreate)); await Assert.That(result).IsNotNull(); await Assert.That(result.IsNew()).IsFalse(); @@ -245,8 +245,8 @@ CancellationToken cancellationToken // Assert telemetry - .Received(numberOfOldEventsToCreate) - .SkippedUnknownEvent(aggregateId, Arg.Any(), Arg.Any(), unknownEventType, Arg.Any()); + .SkippedUnknownEvent(aggregateId, Any(), Any(), unknownEventType, Any()) + .WasCalled(Times.Exactly(numberOfOldEventsToCreate)); await Assert.That(result).IsNotNull(); await Assert.That(result.IsNew()).IsFalse(); diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAtAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAtAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAtAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetAtAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetDeletedAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetDeletedAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetDeletedAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetDeletedAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetOrCreateAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetOrCreateAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetOrCreateAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.GetOrCreateAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.IsDeletedAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.IsDeletedAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.IsDeletedAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.IsDeletedAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.PermanentlyDeleteAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.PermanentlyDeleteAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.PermanentlyDeleteAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.PermanentlyDeleteAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.RestoreAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.RestoreAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.RestoreAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.RestoreAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.Notify.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.Notify.cs similarity index 52% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.Notify.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.Notify.cs index 772d7694..127a8341 100644 --- a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.Notify.cs +++ b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.Notify.cs @@ -11,7 +11,7 @@ CancellationToken cancellationToken ) { // Arrange - var aggregateChangeNotifier = Substitute.For>(); + var aggregateChangeNotifier = TestHelpers.CreateAggregateChangeFeedNotified(); var beforeWasCalled = false; var afterWasCalled = false; @@ -20,29 +20,22 @@ CancellationToken cancellationToken for (var i = 0; i < eventsToCreate; i++) aggregate.AppendString($"{i + 1} of {eventsToCreate}(s) to created."); - var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); + var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); aggregateChangeNotifier - .When(m => m.BeforeSaveAsync(Arg.Is(aggregate), Arg.Is(true), Arg.Any())) - .Do(callInfo => - { - var a = callInfo.ArgAt(0); - a.AppendString(nameof(aggregateChangeNotifier.AfterSaveAsync)); - - beforeWasCalled = true; - }); + .BeforeSaveAsync(aggregate, true, Any()) + .Callback( + (a, _, _) => + { + a.AppendString(nameof(IAggregateChangeFeedProcessor.AfterSaveAsync)); + + beforeWasCalled = true; + } + ); aggregateChangeNotifier - .When(m => - m.AfterSaveAsync( - Arg.Is(aggregate), - Arg.Is(0), - Arg.Is(true), - Arg.Any(), - Arg.Any() - ) - ) - .Do(_ => afterWasCalled = true); + .AfterSaveAsync(aggregate, 0, true, Any(), Any()) + .Callback(() => afterWasCalled = true); // Act bool result = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); @@ -51,35 +44,35 @@ CancellationToken cancellationToken await Assert.That(beforeWasCalled).IsTrue(); await Assert.That(afterWasCalled).IsTrue(); - await aggregateChangeNotifier.Received(1).BeforeSaveAsync(aggregate, true, Arg.Any()); + aggregateChangeNotifier.BeforeSaveAsync(aggregate, true, Any()).WasCalled(Times.Once); - await aggregateChangeNotifier - .Received(1) + aggregateChangeNotifier .AfterSaveAsync( aggregate, 0, true, - Arg.Is(events => events.Length == eventsToCreate), - Arg.Any() - ); + Is(events => events!.Length == eventsToCreate), + Any() + ) + .WasCalled(Times.Once); } public async Task SaveAsync_GivenAggregateWithNoChanges_DoesNotNotifyChangeFeed(CancellationToken cancellationToken) { // Arrange - var aggregateChangeNotifier = Substitute.For>(); + var aggregateChangeNotifier = TestHelpers.CreateAggregateChangeFeedNotified(); var aggregateId = $"{Guid.NewGuid()}"; var aggregate = TestHelpers.Aggregate(aggregateId: aggregateId); - var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); + var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); // Act await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); // Assert - await aggregateChangeNotifier - .DidNotReceive() - .AfterSaveAsync(aggregate, 0, true, Arg.Any(), Arg.Any()); + aggregateChangeNotifier + .AfterSaveAsync(aggregate, 0, true, Any(), Any()) + .WasNeverCalled(); } } diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.cs similarity index 98% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.cs index f228d91e..4ab691c4 100644 --- a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.cs +++ b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.SaveAsync.cs @@ -70,7 +70,7 @@ public async Task SaveAsync_GivenAggregateWithNoChanges_DoesNotSave(Cancellation // Assert await Assert.That(result).IsFalse(); - telemetry.Received(1).SaveContainedNoChanges(aggregateId, Arg.Any(), Arg.Any()); + telemetry.SaveContainedNoChanges(aggregateId, Any(), Any()).WasCalled(Times.Once); } public async Task SaveAsync_GivenNewAggregateWithChanges_SavesAggregate(CancellationToken cancellationToken) diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.cs similarity index 98% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.cs index 12b8d864..5ea6faa1 100644 --- a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.cs +++ b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDBEventStoreTests.cs @@ -5,7 +5,7 @@ namespace Purview.EventSourcing.MongoDB.Events; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public partial class GenericMongoDBEventStoreTests(MongoDBEventStoreFixture fixture) : IMongoDBEventStoreTests where TAggregate : class, IAggregateTest, new() diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDbEventStoreTests.GetEventRangeAsync.cs b/src/tests/MongoDB.IntegrationTests/Events/GenericMongoDbEventStoreTests.GetEventRangeAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/GenericMongoDbEventStoreTests.GetEventRangeAsync.cs rename to src/tests/MongoDB.IntegrationTests/Events/GenericMongoDbEventStoreTests.GetEventRangeAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/IMongoDBEventStoreTests.cs b/src/tests/MongoDB.IntegrationTests/Events/IMongoDBEventStoreTests.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/IMongoDBEventStoreTests.cs rename to src/tests/MongoDB.IntegrationTests/Events/IMongoDBEventStoreTests.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/MongoDBEventStoreTests.TestData.cs b/src/tests/MongoDB.IntegrationTests/Events/MongoDBEventStoreTests.TestData.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/MongoDBEventStoreTests.TestData.cs rename to src/tests/MongoDB.IntegrationTests/Events/MongoDBEventStoreTests.TestData.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/MongoDBEventStoreTests.cs b/src/tests/MongoDB.IntegrationTests/Events/MongoDBEventStoreTests.cs similarity index 99% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Events/MongoDBEventStoreTests.cs rename to src/tests/MongoDB.IntegrationTests/Events/MongoDBEventStoreTests.cs index 3a763484..35b5ffcc 100644 --- a/src/tests/EventSourcing.MongoDB.IntegrationTests/Events/MongoDBEventStoreTests.cs +++ b/src/tests/MongoDB.IntegrationTests/Events/MongoDBEventStoreTests.cs @@ -2,7 +2,7 @@ namespace Purview.EventSourcing.MongoDB.Events; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public sealed partial class MongoDBEventStoreTests(MongoDBEventStoreFixture fixture) { [Test] diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/EventSourcing.MongoDB.IntegrationTests.csproj b/src/tests/MongoDB.IntegrationTests/MongoDB.IntegrationTests.csproj similarity index 68% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/EventSourcing.MongoDB.IntegrationTests.csproj rename to src/tests/MongoDB.IntegrationTests/MongoDB.IntegrationTests.csproj index 92906ffd..765925f0 100644 --- a/src/tests/EventSourcing.MongoDB.IntegrationTests/EventSourcing.MongoDB.IntegrationTests.csproj +++ b/src/tests/MongoDB.IntegrationTests/MongoDB.IntegrationTests.csproj @@ -1,6 +1,6 @@  - + diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.DeleteAsync.cs b/src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.DeleteAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.DeleteAsync.cs rename to src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.DeleteAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.QueryAsync.cs b/src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.QueryAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.QueryAsync.cs rename to src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.QueryAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.QueryWithContinuationAsync.cs b/src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.QueryWithContinuationAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.QueryWithContinuationAsync.cs rename to src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.QueryWithContinuationAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.RestoreAsync.cs b/src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.RestoreAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.RestoreAsync.cs rename to src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.RestoreAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.SaveAsync.cs b/src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.SaveAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.SaveAsync.cs rename to src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.SaveAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.SingleAndFirstAsync.cs b/src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.SingleAndFirstAsync.cs similarity index 100% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.SingleAndFirstAsync.cs rename to src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.SingleAndFirstAsync.cs diff --git a/src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.cs b/src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.cs similarity index 97% rename from src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.cs rename to src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.cs index ee7ff945..c880d12c 100644 --- a/src/tests/EventSourcing.MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.cs +++ b/src/tests/MongoDB.IntegrationTests/Snapshots/MongoDBSnapshotEventStoreTests.cs @@ -4,7 +4,7 @@ namespace Purview.EventSourcing.MongoDB.Snapshots; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public partial class MongoDBSnapshotEventStoreTests(MongoDBSnapshotEventStoreFixture fixture) { static PersistenceAggregate CreateAggregate(string? id = null, Action? action = null) diff --git a/src/tests/Postgres.IntegrationTests/Postgres.IntegrationTests.csproj b/src/tests/Postgres.IntegrationTests/Postgres.IntegrationTests.csproj new file mode 100644 index 00000000..121100af --- /dev/null +++ b/src/tests/Postgres.IntegrationTests/Postgres.IntegrationTests.csproj @@ -0,0 +1,5 @@ + + + + + diff --git a/src/tests/Postgres.IntegrationTests/PostgresProviderIntegrationTests.cs b/src/tests/Postgres.IntegrationTests/PostgresProviderIntegrationTests.cs new file mode 100644 index 00000000..f6724042 --- /dev/null +++ b/src/tests/Postgres.IntegrationTests/PostgresProviderIntegrationTests.cs @@ -0,0 +1,180 @@ +using Microsoft.EntityFrameworkCore; +using Npgsql; +using Purview.EventSourcing.Aggregates.Persistence; +using Purview.EventSourcing.Fixtures.Postgres; + +namespace Purview.EventSourcing.Postgres; + +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class PostgresProviderIntegrationTests(PostgresSnapshotEventStoreFixture fixture) +{ + [Test] + public async Task EventStore_SaveAndReplay_RestoresAggregateState(CancellationToken cancellationToken) + { + var store = fixture.CreateEventStore(); + var aggregate = await store.CreateAsync(cancellationToken: cancellationToken); + aggregate.SetInt32Value(123); + aggregate.AppendString("hello"); + + await store.SaveAsync(aggregate, cancellationToken: cancellationToken); + + var rehydrated = await store.GetAsync(aggregate.Details.Id, cancellationToken: cancellationToken); + await Assert.That(rehydrated).IsNotNull(); + await Assert.That(rehydrated!.Int32Value).IsEqualTo(123); + await Assert.That(rehydrated.StringProperty).Contains("hello"); + } + + [Test] + public async Task SnapshotStore_UpsertAndLinqQuery_WorksWithNestedPayload(CancellationToken cancellationToken) + { + var store = fixture.CreateSnapshotStore(); + var aggregate = new PersistenceAggregate { Details = { Id = Guid.NewGuid().ToString("D") } }; + aggregate.SetComplexProperty(new() { Int32Property = 42, StringProperty = "active" }); + + await store.SnapshotAsync(aggregate, cancellationToken); + + var response = await store.QueryAsync( + a => a.ComplexTestType != null && a.ComplexTestType.Int32Property == 42, + cancellationToken: cancellationToken + ); + + await Assert.That(response.Results).Count().IsEqualTo(1); + await Assert.That(response.Results[0].Details.Id).IsEqualTo(aggregate.Details.Id); + } + + [Test] + public async Task SnapshotStore_WherePayloadContainsAndHasKey_QueryByJsonOperators( + CancellationToken cancellationToken + ) + { + var store = fixture.CreateSnapshotStore(); + var aggregate = new PersistenceAggregate { Details = { Id = Guid.NewGuid().ToString("D") } }; + aggregate.AddKVPs(new KeyValuePair("status", "active")); + aggregate.SetComplexProperty(new() { StringProperty = "active" }); + + await store.SnapshotAsync(aggregate, cancellationToken); + + var containsResponse = await store.WherePayloadContainsAsync( + """{"ComplexTestType":{"StringProperty":"active"}}""", + new ContinuationRequest { MaxRecords = 10 }, + cancellationToken + ); + var keyResponse = await store.WherePayloadHasKeyAsync( + "ComplexTestType", + new ContinuationRequest { MaxRecords = 10 }, + cancellationToken + ); + + await Assert.That(containsResponse.Results).Count().IsEqualTo(1); + await Assert.That(keyResponse.Results).Count().IsEqualTo(1); + } + + [Test] + public async Task ExecuteUpdate_PartialJsonUpdate_UpdatesSingleField(CancellationToken cancellationToken) + { + var tableName = $"exec_update_{Guid.NewGuid():N}"; + var options = new DbContextOptionsBuilder().UseNpgsql(fixture.ConnectionString).Options; + + await using (var setupContext = new ExecuteUpdateDbContext(options, tableName)) + { + await setupContext.Database.EnsureCreatedAsync(cancellationToken); + setupContext.Rows.Add( + new ExecuteUpdateRow + { + Id = Guid.NewGuid().ToString("D"), + State = new ExecuteUpdateState { Version = 1, Status = "pending" }, + } + ); + await setupContext.SaveChangesAsync(cancellationToken); + } + + await using (var updateContext = new ExecuteUpdateDbContext(options, tableName)) + { + await updateContext + .Rows.Where(static r => r.State.Status == "pending") + .ExecuteUpdateAsync( + s => s.SetProperty(static r => r.State.Version, static r => r.State.Version + 1), + cancellationToken + ); + } + + await using var verifyContext = new ExecuteUpdateDbContext(options, tableName); + var row = await verifyContext.Rows.SingleAsync(cancellationToken); + await Assert.That(row.State.Version).IsEqualTo(2); + await Assert.That(row.State.Status).IsEqualTo("pending"); + } + + [Test] + public async Task AutoCreate_CreatesGinAndExpressionIndexes(CancellationToken cancellationToken) + { + var runId = Guid.NewGuid(); + var tableName = $"EventStoreSnapshots_{runId:N}"; + var store = fixture.CreateSnapshotStore( + runId: runId, + configureOptions: options => + options.JsonIndexOptions = new PostgresJsonIndexOptions + { + Enabled = true, + UseJsonbPathOps = true, + PathIndexes = [new() { Path = "ComplexTestType.StringProperty" }], + } + ); + var aggregate = new PersistenceAggregate { Details = { Id = Guid.NewGuid().ToString("D") } }; + aggregate.SetComplexProperty(new() { StringProperty = "indexed" }); + await store.SnapshotAsync(aggregate, cancellationToken); + + await using var connection = new NpgsqlConnection(fixture.ConnectionString); + await connection.OpenAsync(cancellationToken); + await using var command = new NpgsqlCommand( + """ + SELECT indexdef + FROM pg_indexes + WHERE schemaname = 'public' AND upper(tablename) = @tableName; + """, + connection + ); + command.Parameters.AddWithValue("tableName", tableName.ToUpperInvariant()); + + var indexDefinitions = new List(); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + while (await reader.ReadAsync(cancellationToken)) + indexDefinitions.Add(reader.GetString(0)); + + await Assert + .That(indexDefinitions.Any(def => def.Contains("USING gin", StringComparison.OrdinalIgnoreCase))) + .IsTrue(); + await Assert.That(indexDefinitions.Any(def => def.Contains("#>>", StringComparison.Ordinal))).IsTrue(); + } + + sealed class ExecuteUpdateDbContext(DbContextOptions options, string tableName) + : DbContext(options) + { + readonly string _tableName = tableName; + + public DbSet Rows => Set(); + + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + modelBuilder.Entity(entity => + { + entity.ToTable(_tableName, "public"); + entity.HasKey(static x => x.Id); + entity.ComplexProperty(static x => x.State, static x => x.ToJson()); + }); + } + } + + sealed class ExecuteUpdateRow + { + public required string Id { get; set; } + + public required ExecuteUpdateState State { get; set; } + } + + sealed class ExecuteUpdateState + { + public int Version { get; set; } + + public required string Status { get; set; } + } +} diff --git a/src/tests/Samples.AppHost.IntegrationTests/Fixtures/AppHostFixture.cs b/src/tests/Samples.AppHost.IntegrationTests/Fixtures/AppHostFixture.cs new file mode 100644 index 00000000..f9138387 --- /dev/null +++ b/src/tests/Samples.AppHost.IntegrationTests/Fixtures/AppHostFixture.cs @@ -0,0 +1,155 @@ +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; +using Purview.Aspire.ResourceKit; +using Purview.EventSourcing.Fixtures; +using TUnit.Aspire; + +namespace Purview.EventSourcing.Samples.Fixtures; + +public sealed class AppHostFixture : AspireFixture, IServiceProvider +{ + readonly string _databaseName = $"EventStoreSample_" + $"{Guid.NewGuid():N}"[..8]; + readonly string _snapshotBlobName = $"es-snapshot-" + $"{Guid.NewGuid():N}"[..8]; + static readonly string[] WebResourceNames = + [ + Platform.WebApp, + Platform.PostgresWebApp, + Platform.MongoDbWebApp, + Platform.AzureSqlWebApp, + Platform.AzurePostgresWebApp, + Platform.AzureMongoDbWebApp, + ]; + + readonly Lazy _appService; + + string? _databaseConnectionString; + + public AppHostFixture() + { + EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; + + _appService = new(() => new(ConfigureAppServiceHelper)); + } + + protected override string[] Args => + [ + .. base.Args, + .. OptionsHelper.For( + c => c.IsTestRun = true, + c => c.IsLocal = false, + c => c.SqlServer.DatabaseName = _databaseName, + c => c.AzureStorage.BlobName = _snapshotBlobName + ), + ]; + + public override async ValueTask DisposeAsync() + { + if (_appService.IsValueCreated) + await _appService.Value.DisposeAsync(); + + await base.DisposeAsync(); + } + + void ConfigureAppServiceHelper(IServiceCollection services, IConfigurationBuilder configurationBuilder) + { + ArgumentException.ThrowIfNullOrWhiteSpace(_databaseConnectionString); + + services + // The event stores... + .AddSqlServerEventStore(Platform.SqlDatabase) + .AddSqlServerSnapshotQueryableEventStore(Platform.SqlDatabase) + // Domain services... + .AddDomainServices(); + + configurationBuilder.AddInMemoryCollection([ + new KeyValuePair($"ConnectionStrings:{Platform.SqlDatabase}", _databaseConnectionString), + ]); + } + + public override async Task InitializeAsync() + { + await base.InitializeAsync(); + + _databaseConnectionString = await GetConnectionStringAsync(Platform.SqlDatabase); + foreach (var resourceName in WebResourceNames) + await WaitForWebAppAsync(resourceName, CancellationToken.None); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope")] + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Reliability", + "CA5399:Do not use HttpClientHandler.AllowAutoRedirect" + )] + public HttpClient CreateWebClient(bool followRedirects = false) => + CreateWebClient(Platform.WebApp, followRedirects); + + [System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope")] + public HttpClient CreateWebClient(string resourceName, bool followRedirects = false) + { + var httpClient = CreateHttpClient(resourceName, "http"); + if (followRedirects) + return httpClient; + + // We want auto redirect disabled for tests to be able to assert on 302 responses, + // but HttpClient doesn't allow changing that setting after the client is created, + // so we create a new client with the same base address and a handler that has auto redirect disabled. + return new(new HttpClientHandler() { AllowAutoRedirect = false, CheckCertificateRevocationList = true }) + { + BaseAddress = httpClient.BaseAddress, + }; + } + + public Task GetResourceConnectionStringAsync(string resourceName, CancellationToken cancellationToken) => + GetConnectionStringAsync(resourceName, cancellationToken); + + async Task WaitForWebAppAsync(string resourceName, CancellationToken cancellationToken) + { + using var client = CreateWebClient(resourceName, followRedirects: true); + client.Timeout = TimeSpan.FromSeconds(10); + + var timeoutAt = DateTimeOffset.UtcNow.AddMinutes(3); + while (DateTimeOffset.UtcNow < timeoutAt) + { + try + { + using var response = await client.GetAsync("/pingz", cancellationToken); + if (response.IsSuccessStatusCode) + return; + } + catch (HttpRequestException) when (DateTimeOffset.UtcNow < timeoutAt) + { + // Resource may still be starting. + } + catch (TaskCanceledException) when (DateTimeOffset.UtcNow < timeoutAt) + { + // Resource may still be starting. + } + + await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken); + } + + throw new InvalidOperationException($"The web app resource '{resourceName}' did not become ready in time."); + } + + //string BuildDatabaseConnectionString(string connectionString) + //{ + // SqlConnectionStringBuilder builder = new(connectionString) { InitialCatalog = _databaseName }; + + // return builder.ConnectionString; + //} + + public IQueryableEventStore QueryableEventStore() => _appService.Value.GetRequiredService(); + + public IEventStore EventStore() => _appService.Value.GetRequiredService(); + + public object? GetService(Type serviceType) => _appService.Value.GetService(serviceType); + + //public object? GetService(Type serviceType) => App.Services.GetService(serviceType); + + //public IQueryableEventStore QueryableEventStore() => App.Services.GetRequiredService(); + + //public IEventStore EventStore() => App.Services.GetRequiredService(); + + public IServiceProvider CloneServices(Action? configure) => + _appService.Value.CloneServices(configure); +} diff --git a/src/tests/Samples.AppHost.IntegrationTests/Samples.AppHost.IntegrationTests.csproj b/src/tests/Samples.AppHost.IntegrationTests/Samples.AppHost.IntegrationTests.csproj new file mode 100644 index 00000000..94677368 --- /dev/null +++ b/src/tests/Samples.AppHost.IntegrationTests/Samples.AppHost.IntegrationTests.csproj @@ -0,0 +1,16 @@ + + + $(NamespacePrefix).Samples + + + + + + + + + + + + + diff --git a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Services/CartCheckoutServiceTests.cs b/src/tests/Samples.AppHost.IntegrationTests/Services/CartCheckoutServiceTests.cs similarity index 97% rename from src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Services/CartCheckoutServiceTests.cs rename to src/tests/Samples.AppHost.IntegrationTests/Services/CartCheckoutServiceTests.cs index 43081c62..8a074539 100644 --- a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Services/CartCheckoutServiceTests.cs +++ b/src/tests/Samples.AppHost.IntegrationTests/Services/CartCheckoutServiceTests.cs @@ -1,12 +1,12 @@ using Microsoft.Extensions.DependencyInjection; using Purview.EventSourcing.Aggregates; -using Purview.EventSourcing.Samples.AppHost.Fixtures; using Purview.EventSourcing.Samples.Domain; -using Purview.EventSourcing.Samples.Services; +using Purview.EventSourcing.Samples.Fixtures; using Purview.EventSourcing.Samples.ValueObjects; -namespace Purview.EventSourcing.Samples.AppHost.Services; +namespace Purview.EventSourcing.Samples.Services; +[NotInParallel("SamplesAppHost")] [ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class CartCheckoutServiceTests(AppHostFixture fixture) { diff --git a/src/tests/Samples.AppHost.IntegrationTests/Web/Infrastructure/AspireCliStartupValidationTests.cs b/src/tests/Samples.AppHost.IntegrationTests/Web/Infrastructure/AspireCliStartupValidationTests.cs new file mode 100644 index 00000000..648f0cac --- /dev/null +++ b/src/tests/Samples.AppHost.IntegrationTests/Web/Infrastructure/AspireCliStartupValidationTests.cs @@ -0,0 +1,160 @@ +using System.Diagnostics; +using System.Text.Json; +using Purview.EventSourcing.Samples.Fixtures; + +namespace Purview.EventSourcing.Samples.Web.Infrastructure; + +[NotInParallel("SamplesAppHost")] +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class AspireCliStartupValidationTests(AppHostFixture fixture) +{ + static readonly string[] AzureVariantResourceNames = + [ + Platform.AzureSqlWebApp, + Platform.AzurePostgresWebApp, + Platform.AzureMongoDbWebApp, + ]; + + static readonly string[] ForbiddenStartupLogMarkers = + [ + "Sample data seeding failed", + "System.FormatException: No valid combination of account information found.", + "Unhandled exception", + ]; + + static string AppHostProjectPath => + Path.GetFullPath( + Path.Combine( + AppContext.BaseDirectory, + "..", + "..", + "..", + "..", + "..", + "src", + "Samples.AppHost", + "Samples.AppHost.csproj" + ) + ); + + [Test] + public async Task AzureVariants_StartCleanlyUnderAspireCli_AndServePages(CancellationToken cancellationToken) + { + foreach (var resourceName in AzureVariantResourceNames) + { + await RunAspireAsync( + $"wait {resourceName} --apphost \"{AppHostProjectPath}\" --timeout 180 --non-interactive", + TimeSpan.FromMinutes(4), + cancellationToken + ); + } + + var describe = await RunAspireAsync( + $"describe --apphost \"{AppHostProjectPath}\" --format Json --include-hidden --non-interactive", + TimeSpan.FromMinutes(2), + cancellationToken + ); + + foreach (var resourceName in AzureVariantResourceNames) + { + var logs = await RunAspireAsync( + $"logs {resourceName} --apphost \"{AppHostProjectPath}\" --tail 300 --timestamps --non-interactive", + TimeSpan.FromMinutes(2), + cancellationToken + ); + + foreach (var marker in ForbiddenStartupLogMarkers) + { + if (logs.StandardOutput.Contains(marker, StringComparison.OrdinalIgnoreCase)) + { + throw new InvalidOperationException( + $"Aspire CLI logs for '{resourceName}' contained startup failure marker '{marker}'.{Environment.NewLine}{logs.StandardOutput}" + ); + } + } + + var url = GetHttpUrl(describe.StandardOutput, resourceName); + await Assert.That(url).IsNotNull(); + + using var client = fixture.CreateWebClient(resourceName, followRedirects: true); + var html = await client.GetStringAsync("/", cancellationToken); + await Assert.That(html).Contains("Customer Experience"); + await Assert.That(html).Contains("Back Office"); + } + } + + static string? GetHttpUrl(string describeJson, string resourceName) + { + using var document = JsonDocument.Parse(describeJson); + foreach (var resource in document.RootElement.GetProperty("resources").EnumerateArray()) + { + if ( + !resource.TryGetProperty("displayName", out var displayName) + || !string.Equals(displayName.GetString(), resourceName, StringComparison.Ordinal) + ) + { + continue; + } + + if (!resource.TryGetProperty("urls", out var urls)) + return null; + + foreach (var url in urls.EnumerateArray()) + { + if ( + url.TryGetProperty("url", out var value) + && value.GetString() is { } stringValue + && stringValue.StartsWith("http://", StringComparison.OrdinalIgnoreCase) + ) + { + return stringValue; + } + } + + return null; + } + + return null; + } + + static async Task RunAspireAsync( + string arguments, + TimeSpan timeout, + CancellationToken cancellationToken + ) + { + using var process = new Process + { + StartInfo = new() + { + FileName = "aspire", + Arguments = arguments, + WorkingDirectory = Path.GetDirectoryName(AppHostProjectPath)!, + RedirectStandardOutput = true, + RedirectStandardError = true, + UseShellExecute = false, + CreateNoWindow = true, + }, + }; + + if (!process.Start()) + throw new InvalidOperationException($"Failed to start 'aspire {arguments}'."); + + using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); + timeoutCts.CancelAfter(timeout); + + var standardOutputTask = process.StandardOutput.ReadToEndAsync(timeoutCts.Token); + var standardErrorTask = process.StandardError.ReadToEndAsync(timeoutCts.Token); + await process.WaitForExitAsync(timeoutCts.Token); + + var result = new AspireCliCommandResult(process.ExitCode, await standardOutputTask, await standardErrorTask); + + return result.ExitCode == 0 + ? result + : throw new InvalidOperationException( + $"Aspire CLI command failed: aspire {arguments}{Environment.NewLine}STDOUT:{Environment.NewLine}{result.StandardOutput}{Environment.NewLine}STDERR:{Environment.NewLine}{result.StandardError}" + ); + } + + readonly record struct AspireCliCommandResult(int ExitCode, string StandardOutput, string StandardError); +} diff --git a/src/tests/Samples.AppHost.IntegrationTests/Web/Infrastructure/AzureStorageConnectionStringTests.cs b/src/tests/Samples.AppHost.IntegrationTests/Web/Infrastructure/AzureStorageConnectionStringTests.cs new file mode 100644 index 00000000..4f503473 --- /dev/null +++ b/src/tests/Samples.AppHost.IntegrationTests/Web/Infrastructure/AzureStorageConnectionStringTests.cs @@ -0,0 +1,84 @@ +using Azure.Data.Tables; +using Azure.Storage.Blobs; +using Purview.EventSourcing.Samples.Fixtures; + +namespace Purview.EventSourcing.Samples.Web.Infrastructure; + +[NotInParallel("SamplesAppHost")] +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class AzureStorageConnectionStringTests(AppHostFixture fixture) +{ + [Test] + public async Task AzureTableResourceConnection_ContainsTableEndpoint(CancellationToken cancellationToken) + { + var connectionString = await fixture.GetResourceConnectionStringAsync( + Platform.AzureStorageTable, + cancellationToken + ); + + await Assert.That(connectionString).IsNotNull(); + await Assert.That(connectionString!).Contains("TableEndpoint="); + } + + [Test] + public async Task AzureBlobResourceConnection_ContainsBlobEndpoint(CancellationToken cancellationToken) + { + var connectionString = await fixture.GetResourceConnectionStringAsync( + Platform.AzureStorageBlob, + cancellationToken + ); + + await Assert.That(connectionString).IsNotNull(); + await Assert.That(connectionString!).Contains("BlobEndpoint="); + } + + [Test] + public async Task AzureBlobResourceConnection_CanCreateBlobServiceClient(CancellationToken cancellationToken) + { + var connectionString = await fixture.GetResourceConnectionStringAsync( + Platform.AzureStorageBlob, + cancellationToken + ); + + await Assert.That(connectionString).IsNotNull(); + + var normalized = AzureStorageConnectionStringComposer.Normalize(connectionString); + var containerName = $"startupcheck-{Guid.NewGuid():N}"[..22]; + var serviceClient = new BlobServiceClient(normalized); + var containerClient = serviceClient.GetBlobContainerClient(containerName); + await containerClient.CreateIfNotExistsAsync(cancellationToken: cancellationToken); + await containerClient.DeleteIfExistsAsync(cancellationToken: cancellationToken); + } + + [Test] + public async Task AzureMergedEventStoreConnection_CanCreateBlobAndTableClients(CancellationToken cancellationToken) + { + var tableConnectionString = await fixture.GetResourceConnectionStringAsync( + Platform.AzureStorageTable, + cancellationToken + ); + var blobConnectionString = await fixture.GetResourceConnectionStringAsync( + Platform.AzureStorageBlob, + cancellationToken + ); + + await Assert.That(tableConnectionString).IsNotNull(); + await Assert.That(blobConnectionString).IsNotNull(); + + var mergedConnectionString = AzureStorageConnectionStringComposer.BuildEventStoreConnectionString( + tableConnectionString, + blobConnectionString, + fallbackConnectionString: null + ); + + var blobContainerName = $"startupcheck-{Guid.NewGuid():N}"[..22]; + var blobClient = new BlobContainerClient(mergedConnectionString, blobContainerName); + await blobClient.CreateIfNotExistsAsync(cancellationToken: cancellationToken); + await blobClient.DeleteIfExistsAsync(cancellationToken: cancellationToken); + + var tableName = $"StartupCheck{Guid.NewGuid():N}"[..24]; + var tableClient = new TableServiceClient(mergedConnectionString).GetTableClient(tableName); + await tableClient.CreateIfNotExistsAsync(cancellationToken: cancellationToken); + await tableClient.DeleteAsync(cancellationToken); + } +} diff --git a/src/tests/Samples.AppHost.IntegrationTests/Web/Infrastructure/AzureVariantStartupUsageTests.cs b/src/tests/Samples.AppHost.IntegrationTests/Web/Infrastructure/AzureVariantStartupUsageTests.cs new file mode 100644 index 00000000..5a17635c --- /dev/null +++ b/src/tests/Samples.AppHost.IntegrationTests/Web/Infrastructure/AzureVariantStartupUsageTests.cs @@ -0,0 +1,32 @@ +using Purview.EventSourcing.Samples.Fixtures; + +namespace Purview.EventSourcing.Samples.Web.Infrastructure; + +[NotInParallel("SamplesAppHost")] +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class AzureVariantStartupUsageTests(AppHostFixture fixture) +{ + [Test] + public Task AzureSqlVariant_StartsAndServesDashboard(CancellationToken cancellationToken) => + AssertVariantDashboardAsync(Platform.AzureSqlWebApp, cancellationToken); + + [Test] + public Task AzurePostgresVariant_StartsAndServesDashboard(CancellationToken cancellationToken) => + AssertVariantDashboardAsync(Platform.AzurePostgresWebApp, cancellationToken); + + [Test] + public Task AzureMongoVariant_StartsAndServesDashboard(CancellationToken cancellationToken) => + AssertVariantDashboardAsync(Platform.AzureMongoDbWebApp, cancellationToken); + + async Task AssertVariantDashboardAsync(string resourceName, CancellationToken cancellationToken) + { + using var client = fixture.CreateWebClient(resourceName, followRedirects: true); + + var response = await client.GetAsync("/", cancellationToken); + await Assert.That(response.IsSuccessStatusCode).IsTrue(); + + var html = await response.Content.ReadAsStringAsync(cancellationToken); + await Assert.That(html).Contains("Customer Experience"); + await Assert.That(html).Contains("Back Office"); + } +} diff --git a/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/AdminSitePageTests.cs b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/AdminSitePageTests.cs new file mode 100644 index 00000000..8b2a2e18 --- /dev/null +++ b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/AdminSitePageTests.cs @@ -0,0 +1,46 @@ +using Purview.EventSourcing.Samples.Fixtures; + +namespace Purview.EventSourcing.Samples.Web.Pages; + +[NotInParallel("SamplesAppHost")] +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class AdminSitePageTests(AppHostFixture fixture) +{ + readonly HttpClient _client = fixture.CreateWebClient(followRedirects: true); + + [Test] + public async Task AdminDashboard_Returns200_AndContainsSearchUi(CancellationToken cancellationToken) + { + var response = await _client.GetAsync("/admin", cancellationToken); + var html = await response.Content.ReadAsStringAsync(cancellationToken); + + await Assert.That(response.IsSuccessStatusCode).IsTrue(); + await Assert.That(html).Contains("Aggregate Search"); + } + + [Test] + public async Task AdminEventsPage_WithParameters_Returns200(CancellationToken cancellationToken) + { + var response = await _client.GetAsync( + "/admin/events?aggregateType=OrderAggregate&aggregateId=test-aggregate-id", + cancellationToken + ); + var html = await response.Content.ReadAsStringAsync(cancellationToken); + + await Assert.That(response.IsSuccessStatusCode).IsTrue(); + await Assert.That(html).Contains("Event Stream"); + } + + [Test] + public async Task AdminProjectionPage_WithParameters_Returns200(CancellationToken cancellationToken) + { + var response = await _client.GetAsync( + "/admin/projection?aggregateType=OrderAggregate&aggregateId=test-aggregate-id", + cancellationToken + ); + var html = await response.Content.ReadAsStringAsync(cancellationToken); + + await Assert.That(response.IsSuccessStatusCode).IsTrue(); + await Assert.That(html).Contains("Point-in-Time Projection"); + } +} diff --git a/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/AuditPageTests.cs b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/AuditPageTests.cs new file mode 100644 index 00000000..f0c66940 --- /dev/null +++ b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/AuditPageTests.cs @@ -0,0 +1,137 @@ +using System.Globalization; +using Purview.EventSourcing.Samples.Domain; +using Purview.EventSourcing.Samples.Fixtures; + +namespace Purview.EventSourcing.Samples.Web.Pages; + +[NotInParallel("SamplesAppHost")] +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class AuditPageTests(AppHostFixture fixture) +{ + readonly HttpClient _client = fixture.CreateWebClient(); + + [Test] + public async Task GetAuditPage_GivenDateRangeOnly_ShowsRecentEvents(CancellationToken cancellationToken) + { + await CreateOrderAsync(cancellationToken); + var fromUtc = DateTimeOffset.UtcNow.AddDays(-1).ToString("yyyy-MM-ddTHH:mm", CultureInfo.InvariantCulture); + + var response = await _client.GetAsync( + $"/BackOffice/Audit/Index?aggregateType=order&fromUtc={fromUtc}", + cancellationToken + ); + var content = await response.Content.ReadAsStringAsync(cancellationToken); + + await Assert.That(response.IsSuccessStatusCode).IsTrue(); + await Assert.That(content).Contains("Recent Events"); + await Assert.That(content).DoesNotContain("No recent events matched the current filters."); + } + + [Test] + public async Task GetAuditPage_GivenAggregateId_ShowsAggregateHistoryEvents(CancellationToken cancellationToken) + { + var aggregateId = await CreateOrderAsync(cancellationToken); + var response = await _client.GetAsync( + $"/BackOffice/Audit/Index?aggregateType=order&aggregateId={aggregateId}", + cancellationToken + ); + var content = await response.Content.ReadAsStringAsync(cancellationToken); + + await Assert.That(response.IsSuccessStatusCode).IsTrue(); + await Assert.That(content).Contains("Events"); + await Assert.That(content).DoesNotContain("No events matched the current filters."); + } + + [Test] + public async Task GetAuditPage_GivenNoFilters_ShowsRecentEvents(CancellationToken cancellationToken) + { + await CreateOrderAsync(cancellationToken); + var response = await _client.GetAsync("/BackOffice/Audit/Index", cancellationToken); + var content = await response.Content.ReadAsStringAsync(cancellationToken); + + await Assert.That(response.IsSuccessStatusCode).IsTrue(); + await Assert.That(content).Contains("Recent Events"); + await Assert.That(content).DoesNotContain("No recent events matched the current filters."); + } + + async Task CreateOrderAsync(CancellationToken cancellationToken) + { + var store = fixture.QueryableEventStore(); + var customer = await store.CreateAsync(cancellationToken: cancellationToken); + customer.RegisterCustomer($"audit-{Guid.NewGuid():N}", $"audit-{Guid.NewGuid():N}@example.com"); + var customerResult = await store.SaveAsync(customer, cancellationToken); + + var order = await store.CreateAsync(cancellationToken: cancellationToken); + order + .CreateOrder(customerResult.Aggregate.Id()) + .AddLineItem("SKU-AUDIT-001", "Audit Product", 1, 9.99m) + .SetShippingAddress("1 Audit Way"); + var orderResult = await store.SaveAsync(order, cancellationToken); + + return orderResult.Aggregate.Id(); + } + + //sealed class AuditWebAppFactory : WebApplicationFactory + //{ + // protected override void ConfigureWebHost(IWebHostBuilder builder) => + // builder.ConfigureTestServices(services => + // { + // services.RemoveAll(); + // services.RemoveAll(); + // services.AddSingleton(); + // services.AddSingleton(); + // }); + //} + + //sealed class NoOpSeedDataService : ISeedDataService + //{ + // public Task SeedAsync(CancellationToken cancellationToken = default) => Task.CompletedTask; + //} + + //sealed class FakeAggregateAuditService : IAggregateAuditService + //{ + // public Task> GetHistoryAsync( + // string aggregateType, + // string aggregateId, + // AggregateEventHistoryRequest request, + // CancellationToken cancellationToken + // ) => + // Task.FromResult( + // new ContinuationResponse + // { + // RequestedCount = request.MaxRecords, + // Results = + // [ + // new AggregateEventHistoryItem + // { + // AggregateType = "OrderAggregate", + // AggregateId = aggregateId, + // AggregateVersion = 1, + // EventType = "AggregateIdEvent", + // EventClrType = "AggregateIdEvent", + // Payload = "{}", + // When = DateTimeOffset.UtcNow, + // }, + // ], + // } + // ); + + // public Task> GetLatestHistoryAsync( + // string aggregateType, + // AggregateEventHistoryRequest request, + // CancellationToken cancellationToken + // ) => + // Task.FromResult>([ + // new AggregateEventHistoryItem + // { + // AggregateType = "OrderAggregate", + // AggregateId = "range-agg", + // AggregateVersion = 2, + // EventType = "DateRangeOnlyEvent", + // EventClrType = "DateRangeOnlyEvent", + // Payload = "{}", + // When = DateTimeOffset.UtcNow, + // }, + // ]); + //} +} diff --git a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/CustomerPageTests.cs b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/CustomerPageTests.cs similarity index 90% rename from src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/CustomerPageTests.cs rename to src/tests/Samples.AppHost.IntegrationTests/Web/Pages/CustomerPageTests.cs index 299f6794..7e5c1b47 100644 --- a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/CustomerPageTests.cs +++ b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/CustomerPageTests.cs @@ -1,8 +1,9 @@ -using Purview.EventSourcing.Samples.AppHost.Fixtures; using Purview.EventSourcing.Samples.Domain; +using Purview.EventSourcing.Samples.Fixtures; -namespace Purview.EventSourcing.Samples.AppHost.Pages; +namespace Purview.EventSourcing.Samples.Web.Pages; +[NotInParallel("SamplesAppHost")] [ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class CustomerPageTests(AppHostFixture fixture) { @@ -154,7 +155,17 @@ async Task CreateCustomersAsync(string prefix, int count, CancellationToken canc { var customer = await store.CreateAsync(cancellationToken: cancellationToken); customer.RegisterCustomer($"{prefix}-customer-{i:D2}", $"{prefix}-{i:D2}@example.com"); - await store.SaveAsync(customer, cancellationToken); + var result = await store.SaveAsync(customer, cancellationToken); + + await Assert.That(result).IsNotNull(); + await Assert.That(result.IsValid).IsTrue().Because(result.ValidationResult.ToString()!); } + + var totalCount = await store.CountAsync(cancellationToken); + + await Assert + .That(totalCount) + .IsGreaterThanOrEqualTo(count) + .Because($"There should be at least {count} customers in the store"); } } diff --git a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/DashboardTests.cs b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/DashboardTests.cs similarity index 85% rename from src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/DashboardTests.cs rename to src/tests/Samples.AppHost.IntegrationTests/Web/Pages/DashboardTests.cs index 1b01826f..51e2d27d 100644 --- a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/DashboardTests.cs +++ b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/DashboardTests.cs @@ -1,7 +1,8 @@ -using Purview.EventSourcing.Samples.AppHost.Fixtures; +using Purview.EventSourcing.Samples.Fixtures; -namespace Purview.EventSourcing.Samples.AppHost.Pages; +namespace Purview.EventSourcing.Samples.Web.Pages; +[NotInParallel("SamplesAppHost")] [ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class DashboardTests(AppHostFixture factory) { diff --git a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/InventoryPageTests.cs b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/InventoryPageTests.cs similarity index 98% rename from src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/InventoryPageTests.cs rename to src/tests/Samples.AppHost.IntegrationTests/Web/Pages/InventoryPageTests.cs index 3e2458e0..13f8454f 100644 --- a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/InventoryPageTests.cs +++ b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/InventoryPageTests.cs @@ -1,8 +1,9 @@ -using Purview.EventSourcing.Samples.AppHost.Fixtures; using Purview.EventSourcing.Samples.Domain; +using Purview.EventSourcing.Samples.Fixtures; -namespace Purview.EventSourcing.Samples.AppHost.Pages; +namespace Purview.EventSourcing.Samples.Web.Pages; +[NotInParallel("SamplesAppHost")] [ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class InventoryPageTests(AppHostFixture fixture) { diff --git a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/OrderPageTests.cs b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/OrderPageTests.cs similarity index 89% rename from src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/OrderPageTests.cs rename to src/tests/Samples.AppHost.IntegrationTests/Web/Pages/OrderPageTests.cs index a32519ed..415d3128 100644 --- a/src/tests/EventSourcing.Samples.AppHost.IntegrationTests/Pages/OrderPageTests.cs +++ b/src/tests/Samples.AppHost.IntegrationTests/Web/Pages/OrderPageTests.cs @@ -1,8 +1,9 @@ -using Purview.EventSourcing.Samples.AppHost.Fixtures; using Purview.EventSourcing.Samples.Domain; +using Purview.EventSourcing.Samples.Fixtures; -namespace Purview.EventSourcing.Samples.AppHost.Pages; +namespace Purview.EventSourcing.Samples.Web.Pages; +[NotInParallel("SamplesAppHost")] [ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class OrderPageTests(AppHostFixture fixture) { @@ -28,7 +29,7 @@ public async Task CustomerOrders_WithoutSession_RedirectsOrReturns200(Cancellati public async Task CustomerOrders_WithMultiplePages_RendersNextPageLink(CancellationToken cancellationToken) { var customerId = await CreateCustomerWithOrdersAsync(11, cancellationToken); - var antiForgery = await GetAntiForgeryTokenAsync("/Customer", cancellationToken); + var antiForgery = await GetAntiForgeryTokenAsync(_client, "/Customer", cancellationToken); using var content = new FormUrlEncodedContent([ new("id", customerId), @@ -55,8 +56,9 @@ public async Task BackOfficeStockTransfer_Get_Returns200(CancellationToken cance [Test] public async Task BackOfficeStockTransfer_Post_WithValidData(CancellationToken cancellationToken) { + using var client = fixture.CreateWebClient(followRedirects: true); var (sourceInventoryId, destinationLocationId) = await CreateTransferScenarioAsync(cancellationToken); - var antiForgery = await GetAntiForgeryTokenAsync("/BackOffice/Stock/Transfer", cancellationToken); + var antiForgery = await GetAntiForgeryTokenAsync(client, "/BackOffice/Stock/Transfer", cancellationToken); var form = new Dictionary { @@ -68,7 +70,7 @@ public async Task BackOfficeStockTransfer_Post_WithValidData(CancellationToken c }; using var content = new FormUrlEncodedContent(form); - var response = await _client.PostAsync("/BackOffice/Stock/Transfer", content, cancellationToken); + var response = await client.PostAsync("/BackOffice/Stock/Transfer", content, cancellationToken); await Assert.That((int)response.StatusCode).IsEqualTo(200); } @@ -126,9 +128,9 @@ CancellationToken cancellationToken return (saveResult.Aggregate.Id(), destinationLocationId); } - async Task GetAntiForgeryTokenAsync(string url, CancellationToken cancellationToken) + async Task GetAntiForgeryTokenAsync(HttpClient client, string url, CancellationToken cancellationToken) { - var response = await _client.GetAsync(url, cancellationToken); + var response = await client.GetAsync(url, cancellationToken); var html = await response.Content.ReadAsStringAsync(cancellationToken); var start = html.IndexOf("__RequestVerificationToken", StringComparison.Ordinal); diff --git a/src/tests/EventSourcing.Samples.IntegrationTests/Domain/CustomerAggregateIntegrationTests.cs b/src/tests/Samples.IntegrationTests/Domain/CustomerAggregateIntegrationTests.cs similarity index 92% rename from src/tests/EventSourcing.Samples.IntegrationTests/Domain/CustomerAggregateIntegrationTests.cs rename to src/tests/Samples.IntegrationTests/Domain/CustomerAggregateIntegrationTests.cs index db119620..fcde6be3 100644 --- a/src/tests/EventSourcing.Samples.IntegrationTests/Domain/CustomerAggregateIntegrationTests.cs +++ b/src/tests/Samples.IntegrationTests/Domain/CustomerAggregateIntegrationTests.cs @@ -1,9 +1,10 @@ +using Purview.EventSourcing.Aggregates.Snapshotting; using Purview.EventSourcing.Fixtures.SqlServer; namespace Purview.EventSourcing.Samples.Domain; -[ClassDataSource(Shared = SharedType.PerAssembly)] -public sealed class CustomerAggregateIntegrationTests(SqlServerEventStoreFixture fixture) +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class CustomerAggregateIntegrationTests(SqlServerSnapshotEventStoreFixture fixture) { #region Round-Trip Persistence @@ -37,7 +38,9 @@ public async Task SaveAsync_GivenCustomerWithPhoneNumber_LoadedPhoneMatches(Canc customer.ChangePhoneNumber("+1-555-0199"); var store = fixture.CreateEventStore(); - await store.SaveAsync(customer, cancellationToken); + var result = await store.SaveAsync(customer, cancellationToken); + + await Assert.That(result.EnsureValid).ThrowsNothing(); var loaded = await store.GetAsync(id, cancellationToken); @@ -118,7 +121,9 @@ public async Task SaveAsync_GivenMultipleOperations_VersionIsTrackedCorrectly(Ca customer.ChangePhoneNumber("+44-20-0000-0001"); // v3 var store = fixture.CreateEventStore(); - await store.SaveAsync(customer, cancellationToken); + var result = await store.SaveAsync(customer, cancellationToken); + + await Assert.That(result.EnsureValid).ThrowsNothing(); var loaded = await store.GetAsync(id, cancellationToken); @@ -214,7 +219,7 @@ CancellationToken cancellationToken customer.Deactivate(); // Use a very high snapshot interval to force pure event replay - var store = fixture.CreateEventStore(snapshotRecalculationInterval: int.MaxValue); + var store = fixture.CreateSnapshotStore(snapshotStrategy: new AlwaysSnapshotStrategy()); await store.SaveAsync(customer, cancellationToken); var loaded = await store.GetAsync(id, cancellationToken); diff --git a/src/tests/EventSourcing.Samples.IntegrationTests/Domain/InventoryAggregateIntegrationTests.cs b/src/tests/Samples.IntegrationTests/Domain/InventoryAggregateIntegrationTests.cs similarity index 95% rename from src/tests/EventSourcing.Samples.IntegrationTests/Domain/InventoryAggregateIntegrationTests.cs rename to src/tests/Samples.IntegrationTests/Domain/InventoryAggregateIntegrationTests.cs index 44de0797..628be4f4 100644 --- a/src/tests/EventSourcing.Samples.IntegrationTests/Domain/InventoryAggregateIntegrationTests.cs +++ b/src/tests/Samples.IntegrationTests/Domain/InventoryAggregateIntegrationTests.cs @@ -1,9 +1,10 @@ +using Purview.EventSourcing.Aggregates.Snapshotting; using Purview.EventSourcing.Fixtures.SqlServer; namespace Purview.EventSourcing.Samples.Domain; -[ClassDataSource(Shared = SharedType.PerAssembly)] -public sealed class InventoryAggregateIntegrationTests(SqlServerEventStoreFixture fixture) +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class InventoryAggregateIntegrationTests(SqlServerSnapshotEventStoreFixture fixture) { static InventoryAggregate CreateInitialized( string id, @@ -175,7 +176,7 @@ CancellationToken cancellationToken inv.ShipStock(50, "order-snap"); inv.ReceiveStock(100); - var store = fixture.CreateEventStore(snapshotRecalculationInterval: int.MaxValue); + var store = fixture.CreateSnapshotStore(snapshotStrategy: new AlwaysSnapshotStrategy()); await store.SaveAsync(inv, cancellationToken); var loaded = await store.GetAsync(inv.Id(), cancellationToken); diff --git a/src/tests/EventSourcing.Samples.IntegrationTests/Domain/MultiAggregateIntegrationTests.cs b/src/tests/Samples.IntegrationTests/Domain/MultiAggregateIntegrationTests.cs similarity index 99% rename from src/tests/EventSourcing.Samples.IntegrationTests/Domain/MultiAggregateIntegrationTests.cs rename to src/tests/Samples.IntegrationTests/Domain/MultiAggregateIntegrationTests.cs index 14ce4234..6e4e26af 100644 --- a/src/tests/EventSourcing.Samples.IntegrationTests/Domain/MultiAggregateIntegrationTests.cs +++ b/src/tests/Samples.IntegrationTests/Domain/MultiAggregateIntegrationTests.cs @@ -8,7 +8,7 @@ namespace Purview.EventSourcing.Samples.Domain; /// These tests verify that independent aggregates can be saved and reloaded independently /// while reflecting a coherent multi-aggregate business scenario. /// -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class MultiAggregateIntegrationTests(SqlServerEventStoreFixture fixture) { [Test] diff --git a/src/tests/EventSourcing.Samples.IntegrationTests/Domain/OrderAggregateIntegrationTests.cs b/src/tests/Samples.IntegrationTests/Domain/OrderAggregateIntegrationTests.cs similarity index 95% rename from src/tests/EventSourcing.Samples.IntegrationTests/Domain/OrderAggregateIntegrationTests.cs rename to src/tests/Samples.IntegrationTests/Domain/OrderAggregateIntegrationTests.cs index 95ecea29..d20de072 100644 --- a/src/tests/EventSourcing.Samples.IntegrationTests/Domain/OrderAggregateIntegrationTests.cs +++ b/src/tests/Samples.IntegrationTests/Domain/OrderAggregateIntegrationTests.cs @@ -1,10 +1,11 @@ +using Purview.EventSourcing.Aggregates.Snapshotting; using Purview.EventSourcing.Fixtures.SqlServer; using Purview.EventSourcing.Samples.ValueObjects; namespace Purview.EventSourcing.Samples.Domain; -[ClassDataSource(Shared = SharedType.PerAssembly)] -public sealed class OrderAggregateIntegrationTests(SqlServerEventStoreFixture fixture) +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class OrderAggregateIntegrationTests(SqlServerSnapshotEventStoreFixture fixture) { static OrderAggregate CreateDraftWithItems(string id) { @@ -239,7 +240,7 @@ CancellationToken cancellationToken order.SetShippingAddress("1 Event Replay Rd"); order.ConfirmOrder(); - var store = fixture.CreateEventStore(snapshotRecalculationInterval: int.MaxValue); + var store = fixture.CreateSnapshotStore(snapshotStrategy: new AlwaysSnapshotStrategy()); await store.SaveAsync(order, cancellationToken); var loaded = await store.GetAsync(id, cancellationToken); diff --git a/src/tests/EventSourcing.Samples.IntegrationTests/Domain/QueryableAggregateIntegrationTests.cs b/src/tests/Samples.IntegrationTests/Domain/QueryableAggregateIntegrationTests.cs similarity index 85% rename from src/tests/EventSourcing.Samples.IntegrationTests/Domain/QueryableAggregateIntegrationTests.cs rename to src/tests/Samples.IntegrationTests/Domain/QueryableAggregateIntegrationTests.cs index 5789d762..73f9287a 100644 --- a/src/tests/EventSourcing.Samples.IntegrationTests/Domain/QueryableAggregateIntegrationTests.cs +++ b/src/tests/Samples.IntegrationTests/Domain/QueryableAggregateIntegrationTests.cs @@ -1,14 +1,9 @@ using System.Linq.Expressions; -using Microsoft.Extensions.Options; -using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.Fixtures.SqlServer; -using Purview.EventSourcing.Internal; -using Purview.EventSourcing.SqlServer.Snapshot; -using Purview.EventSourcing.SqlServer.Snapshots; namespace Purview.EventSourcing.Samples.Domain; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class QueryableAggregateIntegrationTests(SqlServerSnapshotEventStoreFixture fixture) { [Test] @@ -16,7 +11,7 @@ public async Task QueryAsync_GivenCustomerSelectorFiltersAndSort_ResultsMatchPag CancellationToken cancellationToken ) { - var store = CreateSnapshotStore(fixture); + var store = fixture.CreateSnapshotStore(); var alice = NewCustomer("Alice Able", "alice@example.com", isActive: true); var adam = NewCustomer("Adam Atlas", "adam@example.com", isActive: true); @@ -29,7 +24,7 @@ CancellationToken cancellationToken var search = "a"; var showInactive = false; Expression> where = c => - (string.IsNullOrEmpty(search) || c.Name.Value.Contains(search) || c.Email.Value.Contains(search)) + (string.IsNullOrEmpty(search) || ((string)c.Name).Contains(search) || ((string)c.Email).Contains(search)) && (showInactive || c.IsActive); var result = await store.QueryAsync( @@ -50,7 +45,7 @@ public async Task QueryAsync_GivenBackOfficeCustomerSortModes_ResultsAreTranslat CancellationToken cancellationToken ) { - var store = CreateSnapshotStore(fixture); + var store = fixture.CreateSnapshotStore(); var lowEmail = NewCustomer("Carol C", "a@example.com", isActive: true); var highEmail = NewCustomer("Bob B", "z@example.com", isActive: false); @@ -82,7 +77,7 @@ public async Task QueryAsync_GivenBackOfficeStockFilterAndSort_ResultsMatchPageM CancellationToken cancellationToken ) { - var store = CreateSnapshotStore(fixture); + var store = fixture.CreateSnapshotStore(); var highAvailable = NewInventory("prod-alpha", "Alpha Widget", quantityOnHand: 20, reserved: 2); var lowAvailable = NewInventory("prod-beta", "Beta Widget", quantityOnHand: 10, reserved: 6); @@ -113,7 +108,7 @@ public async Task ListAsync_GivenBackOfficeStockSortByAvailableDesc_ResultsAreTr CancellationToken cancellationToken ) { - var store = CreateSnapshotStore(fixture); + var store = fixture.CreateSnapshotStore(); var highAvailable = NewInventory("prod-alpha", "Alpha Widget", quantityOnHand: 20, reserved: 2); var lowAvailable = NewInventory("prod-beta", "Beta Widget", quantityOnHand: 10, reserved: 6); @@ -137,7 +132,7 @@ public async Task QueryAsync_GivenBackOfficeCatalogInvariantCaseFilter_CountAndQ CancellationToken cancellationToken ) { - var store = CreateSnapshotStore(fixture); + var store = fixture.CreateSnapshotStore(); var first = NewInventory("PROD-ALPHA", "Alpha Widget", quantityOnHand: 20, reserved: 2); var second = NewInventory("prod-beta", "beta widget", quantityOnHand: 10, reserved: 6); @@ -174,7 +169,7 @@ public async Task QueryAsync_GivenCustomerOrdersBySavedVersion_ResultsArePagedAn CancellationToken cancellationToken ) { - var store = CreateSnapshotStore(fixture); + var store = fixture.CreateSnapshotStore(); var selectedCustomerId = $"customer-{Guid.NewGuid():N}"; var otherCustomerId = $"customer-{Guid.NewGuid():N}"; @@ -216,30 +211,6 @@ CancellationToken cancellationToken await Assert.That(page2.Results[0].CustomerId).IsEqualTo(selectedCustomerId); } - static SqlServerSnapshotEventStore CreateSnapshotStore( - SqlServerSnapshotEventStoreFixture fixture - ) - where TAggregate : class, IAggregate, new() - { - var context = fixture.CreateContext(tableName: $"Snapshots_{Guid.NewGuid():N}"); - var innerEventStore = Substitute.For>(); - innerEventStore.FulfilRequirements(Arg.Any()).Returns(callInfo => callInfo.Arg()); - - return new SqlServerSnapshotEventStore( - innerEventStore, - Options.Create( - new SqlServerSnapshotEventStoreOptions - { - ConnectionString = context.SqlServerConnectionString, - TableName = $"Snapshots_{Guid.NewGuid():N}", - SchemaName = "dbo", - AutoCreateTable = true, - } - ), - Substitute.For() - ); - } - static CustomerAggregate NewCustomer(string name, string email, bool isActive) { var customer = new CustomerAggregate(); diff --git a/src/tests/Samples.IntegrationTests/Samples.IntegrationTests.csproj b/src/tests/Samples.IntegrationTests/Samples.IntegrationTests.csproj new file mode 100644 index 00000000..4b2ed98e --- /dev/null +++ b/src/tests/Samples.IntegrationTests/Samples.IntegrationTests.csproj @@ -0,0 +1,12 @@ + + + + + + + diff --git a/src/tests/Samples.IntegrationTests/ValueObjects/UserCaptureTests.cs b/src/tests/Samples.IntegrationTests/ValueObjects/UserCaptureTests.cs new file mode 100644 index 00000000..396fcfec --- /dev/null +++ b/src/tests/Samples.IntegrationTests/ValueObjects/UserCaptureTests.cs @@ -0,0 +1,55 @@ +using Purview.EventSourcing.Fixtures.SqlServer; + +namespace Purview.EventSourcing.Samples.ValueObjects; + +[ClassDataSource(Shared = SharedType.PerTestSession)] +public class UserCaptureTests(SqlServerSnapshotEventStoreFixture fixture) +{ + static readonly Faker Faker = new(); + + [Test] + public async Task UserCapture_GivenComplexValueObject_DoesNotThrowOnSnapshot(CancellationToken cancellationToken) + { + // Arrange + var eventStore = fixture.CreateSnapshotStore(); + var aggregate = CreateTestAggregate(); + + // Act + Task Act() => eventStore.SnapshotAsync(aggregate, cancellationToken); + + // Assert + await Assert.That(Act).ThrowsNothing(); + } + + [Test] + public async Task UserCapture_GivenComplexValueObject_CanStoreAndRetrieveInEF(CancellationToken cancellationToken) + { + // Arrange + var eventStore = fixture.CreateSnapshotStore(); + var aggregate = CreateTestAggregate(); + + // Act + await eventStore.SnapshotAsync(aggregate, cancellationToken); + var retrievedAggregate = await eventStore.GetAsync(aggregate.Id(), cancellationToken); + + // Assert + await Assert.That(retrievedAggregate).IsNotNull(); + await Assert.That(retrievedAggregate!.UserCapture).IsEqualTo(aggregate.UserCapture); + } + + static UserCapture CreateSUT(UserDetails? user = null, DateTimeOffset? occurredAt = null) => + UserCapture.Create(user ?? CreateUserDetails(), occurredAt ?? Faker.Date.RecentOffset()); + + static UserDetails CreateUserDetails(Guid? id = null, string? displayName = null, bool isActive = true) => + new(id ?? Faker.Random.Guid(), displayName ?? Faker.Person.FullName, isActive); + + static ValueObjectTestAggregate CreateTestAggregate(UserCapture? user = null) + { + ValueObjectTestAggregate aggregate = new(); + aggregate.Details.Id = Faker.Random.Guid().ToString(); + + aggregate.SetUserCapture(user ?? CreateSUT()); + + return aggregate; + } +} diff --git a/src/tests/Samples.IntegrationTests/ValueObjects/ValueObjectTestAggregate.cs b/src/tests/Samples.IntegrationTests/ValueObjects/ValueObjectTestAggregate.cs new file mode 100644 index 00000000..eb87719f --- /dev/null +++ b/src/tests/Samples.IntegrationTests/ValueObjects/ValueObjectTestAggregate.cs @@ -0,0 +1,12 @@ +using Purview.EventSourcing.Aggregates; + +namespace Purview.EventSourcing.Samples.ValueObjects; + +[GenerateAggregate] +sealed partial class ValueObjectTestAggregate +{ + public UserCapture UserCapture { get; private set; } + + [GenerateAggregateEvent] + public partial void SetUserCapture(UserCapture userCapture); +} diff --git a/src/tests/EventSourcing.Samples.IntegrationTests/Services/AggregateAuditServiceIntegrationTests.cs b/src/tests/Samples.IntegrationTests/Web/Services/AggregateAuditServiceIntegrationTests.cs similarity index 88% rename from src/tests/EventSourcing.Samples.IntegrationTests/Services/AggregateAuditServiceIntegrationTests.cs rename to src/tests/Samples.IntegrationTests/Web/Services/AggregateAuditServiceIntegrationTests.cs index e243ceca..c4610471 100644 --- a/src/tests/EventSourcing.Samples.IntegrationTests/Services/AggregateAuditServiceIntegrationTests.cs +++ b/src/tests/Samples.IntegrationTests/Web/Services/AggregateAuditServiceIntegrationTests.cs @@ -1,11 +1,10 @@ using Microsoft.Extensions.DependencyInjection; using Purview.EventSourcing.Fixtures.SqlServer; using Purview.EventSourcing.Samples.Domain; -using Purview.EventSourcing.Samples.Web.Services; -namespace Purview.EventSourcing.Samples.IntegrationTests.Services; +namespace Purview.EventSourcing.Samples.Web.Services; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class AggregateAuditServiceIntegrationTests(SqlServerEventStoreFixture fixture) { [Test] @@ -40,7 +39,7 @@ static IEventStore CreateEventStoreFacade(IEventStoreCore orderS { var services = new ServiceCollection(); services.AddSingleton(orderStore); - services.AddSingleton>(orderStore); + services.AddSingleton(orderStore); services.AddSingleton(); return services.BuildServiceProvider().GetRequiredService(); } diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.ChangeEmail.cs b/src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.ChangeEmail.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.ChangeEmail.cs rename to src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.ChangeEmail.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.ChangeName.cs b/src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.ChangeName.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.ChangeName.cs rename to src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.ChangeName.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.Email.cs b/src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.Email.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.Email.cs rename to src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.Email.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.IsActive.cs b/src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.IsActive.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.IsActive.cs rename to src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.IsActive.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.RegisterCustomer.cs b/src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.RegisterCustomer.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.RegisterCustomer.cs rename to src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.RegisterCustomer.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.UpdateDetails.cs b/src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.UpdateDetails.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.UpdateDetails.cs rename to src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.UpdateDetails.cs diff --git a/src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.Validation.cs b/src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.Validation.cs new file mode 100644 index 00000000..b6cd416c --- /dev/null +++ b/src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.Validation.cs @@ -0,0 +1,76 @@ +namespace Purview.EventSourcing.Samples.Domain; + +partial class CustomerAggregateTests +{ + [Test] + public async Task RegisterCustomer_GivenWhitespaceName_ThrowsArgumentException() + { + // Arrange + var customer = CreateCustomer("cust-1"); + + // Act & Assert + await Assert.That(() => customer.RegisterCustomer(" ", "valid@test.com")).Throws(); + } + + [Test] + public async Task RegisterCustomer_GivenWhitespaceEmail_ThrowsArgumentException() + { + // Arrange + var customer = CreateCustomer("cust-1"); + + // Act & Assert + await Assert.That(() => customer.RegisterCustomer("Valid Name", " ")).Throws(); + } + + [Test] + public async Task ChangeEmail_GivenWhitespaceEmail_ThrowsArgumentException() + { + // Arrange + var customer = CreateCustomer("cust-1"); + customer.RegisterCustomer("Jane", "old@test.com"); + + // Act & Assert + await Assert.That(() => customer.ChangeEmail(" ")).Throws(); + } + + [Test] + public async Task ChangeName_GivenWhitespaceName_ThrowsArgumentException() + { + // Arrange + var customer = CreateCustomer("cust-1"); + customer.RegisterCustomer("Jane", "jane@test.com"); + + // Act & Assert + await Assert.That(() => customer.ChangeName(" ")).Throws(); + } + + [Test] + public async Task UpdateDetails_GivenAllNulls_RaisesNoEvents() + { + // Arrange + var customer = CreateCustomer("cust-1"); + customer.RegisterCustomer("Jane Smith", "jane@test.com"); + var countBefore = customer.GetUnsavedEvents().Count(); + + // Act + customer.UpdateDetails(); // all nulls + + // Assert + await Assert.That(customer.GetUnsavedEvents().Count()).IsEqualTo(countBefore); + } + + [Test] + public async Task UpdateDetails_WithValidationError_ThrowsAndDoesNotRecordPartial() + { + // Arrange + var customer = CreateCustomer("cust-1"); + customer.RegisterCustomer("Jane Smith", "jane@test.com"); + var countBefore = customer.GetUnsavedEvents().Count(); + + // Act & Assert — fails on invalid name, so no events recorded + await Assert.That(() => customer.UpdateDetails(name: " ", email: "new@test.com")).Throws(); + + // Verify state unchanged + await Assert.That(customer.GetUnsavedEvents().Count()).IsEqualTo(countBefore); + } +} diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.cs b/src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/CustomerAggregateTests.cs rename to src/tests/Samples.UnitTests/Domain/CustomerAggregateTests.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/InventoryAggregateTests.cs b/src/tests/Samples.UnitTests/Domain/InventoryAggregateTests.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/InventoryAggregateTests.cs rename to src/tests/Samples.UnitTests/Domain/InventoryAggregateTests.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/MultiAggregateWorkflowTests.cs b/src/tests/Samples.UnitTests/Domain/MultiAggregateWorkflowTests.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/MultiAggregateWorkflowTests.cs rename to src/tests/Samples.UnitTests/Domain/MultiAggregateWorkflowTests.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/OrderAggregateTests.cs b/src/tests/Samples.UnitTests/Domain/OrderAggregateTests.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/OrderAggregateTests.cs rename to src/tests/Samples.UnitTests/Domain/OrderAggregateTests.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Domain/ReportUploadAggregateTests.cs b/src/tests/Samples.UnitTests/Domain/ReportUploadAggregateTests.cs similarity index 69% rename from src/tests/EventSourcing.Samples.UnitTests/Domain/ReportUploadAggregateTests.cs rename to src/tests/Samples.UnitTests/Domain/ReportUploadAggregateTests.cs index e37cf8aa..c844e22c 100644 --- a/src/tests/EventSourcing.Samples.UnitTests/Domain/ReportUploadAggregateTests.cs +++ b/src/tests/Samples.UnitTests/Domain/ReportUploadAggregateTests.cs @@ -1,9 +1,12 @@ +using Purview.EventSourcing.Samples.Domain.ReportUpload; using Purview.EventSourcing.Samples.ValueObjects; namespace Purview.EventSourcing.Samples.Domain; public sealed class ReportUploadAggregateTests { + static readonly Faker Faker = new(); + [Test] public async Task MarkAsComplete_GivenReportIsMarkedAsComplete_SetsStatusToCompleteAsSideEffect() { @@ -13,7 +16,7 @@ public async Task MarkAsComplete_GivenReportIsMarkedAsComplete_SetsStatusToCompl await Assert.That(sut.Status).IsNotEqualTo(ReportProcessingStatus.Completed); // Act (status is not passed by caller) - sut.MarkAsComplete(CreateValidBlobUri(), new object()); + sut.MarkAsComplete(CreateReportSummary()); // Assert await Assert.That(sut.Status).IsEqualTo(ReportProcessingStatus.Completed); @@ -27,7 +30,7 @@ public async Task MarkAsComplete_GivenReportIsMarkedAsComplete_RecordsStatusInEv sut.Create(CreateProjectId(), "report.json", CreateValidBlobUri(), CreateUploadedUser()); // Act - sut.MarkAsComplete(CreateValidBlobUri(), new object()); + sut.MarkAsComplete(CreateReportSummary()); // Assert (event contains the computed status value) var completedEvent = sut.GetUnsavedEvents() @@ -46,7 +49,7 @@ public void MarkAsComplete_GivenCallerSetsComputedStatus_ThrowsArgumentException // Act & Assert Assert.Throws(() => - sut.MarkAsComplete(CreateValidBlobUri(), new object(), ReportProcessingStatus.Failed) + sut.MarkAsComplete(CreateReportSummary(), status: ReportProcessingStatus.Failed) ); } @@ -59,4 +62,24 @@ static BlobUri CreateValidBlobUri() => static UserCapture CreateUploadedUser() => UserCapture.Create(UserDetails.Create(Guid.NewGuid(), "Uploader", true), DateTimeOffset.UtcNow); + + static ReportSummary CreateReportSummary() + { + return ReportSummary.Create( + new() + { + AssetDetails = new AssetDetails( + new Dictionary + { + { PlatformID.Win32NT, Faker.Random.Int(1, 100) }, + { PlatformID.Unix, Faker.Random.Int(1, 100) }, + { PlatformID.Other, Faker.Random.Int(1, 100) }, + } + ), + ParserDetails = new(10, 5, 5, TimeSpan.FromMinutes(1)), + Projects = Faker.Make(2, i => new Project($"Project {i + 1}", $"{i + 1}", $"Team {i + 1}")), + VulnerabilityDetails = new VulnerabilityDetails(100, 10, 10, 20, 30, 40), + } + ); + } } diff --git a/src/tests/Samples.UnitTests/Samples.UnitTests.csproj b/src/tests/Samples.UnitTests/Samples.UnitTests.csproj new file mode 100644 index 00000000..93fefa2d --- /dev/null +++ b/src/tests/Samples.UnitTests/Samples.UnitTests.csproj @@ -0,0 +1,25 @@ + + + $(NamespacePrefix).Samples + true + + + + + + + + + + + + + diff --git a/src/tests/EventSourcing.Samples.UnitTests/Serialization/SampleAggregateJsonSerializationTests.cs b/src/tests/Samples.UnitTests/Serialization/SampleAggregateJsonSerializationTests.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/Serialization/SampleAggregateJsonSerializationTests.cs rename to src/tests/Samples.UnitTests/Serialization/SampleAggregateJsonSerializationTests.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Services/OrderFulfillmentServiceTests.cs b/src/tests/Samples.UnitTests/Services/OrderFulfillmentServiceTests.cs similarity index 59% rename from src/tests/EventSourcing.Samples.UnitTests/Services/OrderFulfillmentServiceTests.cs rename to src/tests/Samples.UnitTests/Services/OrderFulfillmentServiceTests.cs index 6e15d233..429442df 100644 --- a/src/tests/EventSourcing.Samples.UnitTests/Services/OrderFulfillmentServiceTests.cs +++ b/src/tests/Samples.UnitTests/Services/OrderFulfillmentServiceTests.cs @@ -52,17 +52,15 @@ static TransactionResult FailedTransaction(IAggregate aggregate) => OrderFulfillmentService CreateService( IEventStoreTransactionFactory? transactionFactory = null, IQueryableEventStore? store = null - ) => - new( - transactionFactory ?? Substitute.For(), - store ?? Substitute.For() - ); + ) => new(transactionFactory ?? IEventStoreTransactionFactory.Mock(), store ?? IQueryableEventStore.Mock()); [Test] public async Task PlaceOrderAsync_GivenNullCustomer_ReturnsFail(CancellationToken cancellationToken) { - var store = Substitute.For(); - store.GetAsync("missing", null, cancellationToken).Returns((CustomerAggregate?)null); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is("missing"), Any(), Is(cancellationToken)) + .Returns((CustomerAggregate?)null); var result = await CreateService(store: store).PlaceOrderAsync("missing", "inv-1", 1, null, cancellationToken); @@ -76,8 +74,10 @@ public async Task PlaceOrderAsync_GivenInactiveCustomer_ReturnsFail(Cancellation var customer = ActiveCustomer(); customer.Deactivate(); - var store = Substitute.For(); - store.GetAsync(customer.Id(), null, cancellationToken).Returns(customer); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is(customer.Id()), Any(), Is(cancellationToken)) + .Returns(customer); var result = await CreateService(store: store) .PlaceOrderAsync(customer.Id(), "inv-1", 1, null, cancellationToken); @@ -90,9 +90,13 @@ public async Task PlaceOrderAsync_GivenInactiveCustomer_ReturnsFail(Cancellation public async Task PlaceOrderAsync_GivenNullInventory_ReturnsFail(CancellationToken cancellationToken) { var customer = ActiveCustomer(); - var store = Substitute.For(); - store.GetAsync(customer.Id(), null, cancellationToken).Returns(customer); - store.GetAsync("missing-inv", null, cancellationToken).Returns((InventoryAggregate?)null); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is(customer.Id()), Any(), Is(cancellationToken)) + .Returns(customer); + store + .GetAsync(Is("missing-inv"), Any(), Is(cancellationToken)) + .Returns((InventoryAggregate?)null); var result = await CreateService(store: store) .PlaceOrderAsync(customer.Id(), "missing-inv", 1, null, cancellationToken); @@ -107,9 +111,13 @@ public async Task PlaceOrderAsync_GivenInsufficientStock_ReturnsFail(Cancellatio var customer = ActiveCustomer(); var inventory = StockedInventory(quantity: 5); - var store = Substitute.For(); - store.GetAsync(customer.Id(), null, cancellationToken).Returns(customer); - store.GetAsync(inventory.Id(), null, cancellationToken).Returns(inventory); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is(customer.Id()), Any(), Is(cancellationToken)) + .Returns(customer); + store + .GetAsync(Is(inventory.Id()), Any(), Is(cancellationToken)) + .Returns(inventory); var result = await CreateService(store: store) .PlaceOrderAsync(customer.Id(), inventory.Id(), quantity: 10, null, cancellationToken); @@ -125,15 +133,19 @@ public async Task PlaceOrderAsync_GivenValidData_ReturnsSuccess(CancellationToke var inventory = StockedInventory(quantity: 50); var order = NewOrder(); - var transactionFactory = Substitute.For(); - var transaction = Substitute.For(); - transactionFactory.Create(Arg.Any()).Returns(transaction); + var transactionFactory = IEventStoreTransactionFactory.Mock(); + var transaction = IEventStoreTransaction.Mock(); + transactionFactory.Create(Any()).Returns(transaction); transaction.CommitAsync(cancellationToken).Returns(SuccessfulTransaction(order, inventory)); - var store = Substitute.For(); - store.GetAsync(customer.Id(), null, cancellationToken).Returns(customer); - store.GetAsync(inventory.Id(), null, cancellationToken).Returns(inventory); - store.CreateAsync(null, cancellationToken).Returns(order); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is(customer.Id()), Any(), Is(cancellationToken)) + .Returns(customer); + store + .GetAsync(Is(inventory.Id()), Any(), Is(cancellationToken)) + .Returns(inventory); + store.CreateAsync(Any(), Is(cancellationToken)).Returns(order); var result = await CreateService(transactionFactory, store) .PlaceOrderAsync(customer.Id(), inventory.Id(), quantity: 3, "123 Main St", cancellationToken); @@ -141,8 +153,10 @@ public async Task PlaceOrderAsync_GivenValidData_ReturnsSuccess(CancellationToke await Assert.That(result.Succeeded).IsTrue(); await Assert.That(result.Order).IsNotNull(); await Assert.That(result.Inventory).IsNotNull(); - transaction.Received(1).Enlist(order, (IEventStore)store, null); - transaction.Received(1).Enlist(inventory, (IEventStore)store, null); + transaction.Enlist(Is(order), Is((IEventStore)store), Any()).WasCalled(Times.Once); + transaction + .Enlist(Is(inventory), Is((IEventStore)store), Any()) + .WasCalled(Times.Once); } [Test] @@ -152,15 +166,19 @@ public async Task PlaceOrderAsync_GivenValidData_OrderHasLineItemAndIsConfirmed( var inventory = StockedInventory(quantity: 20); var order = NewOrder(); - var transactionFactory = Substitute.For(); - var transaction = Substitute.For(); - transactionFactory.Create(Arg.Any()).Returns(transaction); + var transactionFactory = IEventStoreTransactionFactory.Mock(); + var transaction = IEventStoreTransaction.Mock(); + transactionFactory.Create(Any()).Returns(transaction); transaction.CommitAsync(cancellationToken).Returns(SuccessfulTransaction(order, inventory)); - var store = Substitute.For(); - store.GetAsync(customer.Id(), null, cancellationToken).Returns(customer); - store.GetAsync(inventory.Id(), null, cancellationToken).Returns(inventory); - store.CreateAsync(null, cancellationToken).Returns(order); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is(customer.Id()), Any(), Is(cancellationToken)) + .Returns(customer); + store + .GetAsync(Is(inventory.Id()), Any(), Is(cancellationToken)) + .Returns(inventory); + store.CreateAsync(Any(), Is(cancellationToken)).Returns(order); await CreateService(transactionFactory, store) .PlaceOrderAsync(customer.Id(), inventory.Id(), quantity: 2, null, cancellationToken); @@ -180,22 +198,26 @@ CancellationToken cancellationToken var inventory = StockedInventory(quantity: 50); var order = NewOrder(); - var transactionFactory = Substitute.For(); - var transaction = Substitute.For(); - transactionFactory.Create(Arg.Any()).Returns(transaction); + var transactionFactory = IEventStoreTransactionFactory.Mock(); + var transaction = IEventStoreTransaction.Mock(); + transactionFactory.Create(Any()).Returns(transaction); transaction.CommitAsync(cancellationToken).Returns(FailedTransaction(order)); - var store = Substitute.For(); - store.GetAsync(customer.Id(), null, cancellationToken).Returns(customer); - store.GetAsync(inventory.Id(), null, cancellationToken).Returns(inventory); - store.CreateAsync(null, cancellationToken).Returns(order); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is(customer.Id()), Any(), Is(cancellationToken)) + .Returns(customer); + store + .GetAsync(Is(inventory.Id()), Any(), Is(cancellationToken)) + .Returns(inventory); + store.CreateAsync(Any(), Is(cancellationToken)).Returns(order); var result = await CreateService(transactionFactory, store) .PlaceOrderAsync(customer.Id(), inventory.Id(), quantity: 1, null, cancellationToken); await Assert.That(result.Succeeded).IsFalse(); await Assert.That(result.ErrorMessage).Contains("Nothing was saved"); - await transaction.Received(1).CommitAsync(cancellationToken); + transaction.CommitAsync(Is(cancellationToken)).WasCalled(Times.Once); } [Test] @@ -207,15 +229,19 @@ CancellationToken cancellationToken var inventory = StockedInventory(quantity: 50); var order = NewOrder(); - var transactionFactory = Substitute.For(); - var transaction = Substitute.For(); - transactionFactory.Create(Arg.Any()).Returns(transaction); + var transactionFactory = IEventStoreTransactionFactory.Mock(); + var transaction = IEventStoreTransaction.Mock(); + transactionFactory.Create(Any()).Returns(transaction); transaction.CommitAsync(cancellationToken).Returns(FailedTransaction(inventory)); - var store = Substitute.For(); - store.GetAsync(customer.Id(), null, cancellationToken).Returns(customer); - store.GetAsync(inventory.Id(), null, cancellationToken).Returns(inventory); - store.CreateAsync(null, cancellationToken).Returns(order); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is(customer.Id()), Any(), Is(cancellationToken)) + .Returns(customer); + store + .GetAsync(Is(inventory.Id()), Any(), Is(cancellationToken)) + .Returns(inventory); + store.CreateAsync(Any(), Is(cancellationToken)).Returns(order); var result = await CreateService(transactionFactory, store) .PlaceOrderAsync(customer.Id(), inventory.Id(), quantity: 1, null, cancellationToken); diff --git a/src/tests/EventSourcing.Samples.UnitTests/Services/StockTransferServiceTests.cs b/src/tests/Samples.UnitTests/Services/StockTransferServiceTests.cs similarity index 55% rename from src/tests/EventSourcing.Samples.UnitTests/Services/StockTransferServiceTests.cs rename to src/tests/Samples.UnitTests/Services/StockTransferServiceTests.cs index bfeff6b0..e16e1eaa 100644 --- a/src/tests/EventSourcing.Samples.UnitTests/Services/StockTransferServiceTests.cs +++ b/src/tests/Samples.UnitTests/Services/StockTransferServiceTests.cs @@ -49,11 +49,7 @@ static TransactionResult FailedTransaction(IAggregate aggregate) => StockTransferService CreateService( IEventStoreTransactionFactory? transactionFactory = null, IQueryableEventStore? store = null - ) => - new( - transactionFactory ?? Substitute.For(), - store ?? Substitute.For() - ); + ) => new(transactionFactory ?? IEventStoreTransactionFactory.Mock(), store ?? IQueryableEventStore.Mock()); [Test] public async Task TransferAsync_GivenSameSourceAndDestinationLocation_ReturnsFail( @@ -61,8 +57,10 @@ CancellationToken cancellationToken ) { var source = StockedItem("inv-1", "LOC-001", "Warehouse North", 100); - var store = Substitute.For(); - store.GetAsync("inv-1", null, cancellationToken).Returns(source); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is("inv-1"), Any(), Is(cancellationToken)) + .Returns(source); var result = await CreateService(store: store).TransferAsync("inv-1", "LOC-001", 5, "test", cancellationToken); @@ -73,8 +71,10 @@ CancellationToken cancellationToken [Test] public async Task TransferAsync_GivenNullSource_ReturnsFail(CancellationToken cancellationToken) { - var store = Substitute.For(); - store.GetAsync("missing", null, cancellationToken).Returns((InventoryAggregate?)null); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is("missing"), Any(), Is(cancellationToken)) + .Returns((InventoryAggregate?)null); var result = await CreateService(store: store).TransferAsync("missing", "inv-2", 5, "test", cancellationToken); @@ -87,10 +87,16 @@ public async Task TransferAsync_GivenNullDestination_ReturnsFail(CancellationTok { var source = StockedItem("inv-1", "LOC-001", "Warehouse North", 100); var sourceLocation = Location("LOC-001", "Warehouse North"); - var store = Substitute.For(); - store.GetAsync("inv-1", null, cancellationToken).Returns(source); - store.GetAsync("LOC-001", null, cancellationToken).Returns(sourceLocation); - store.GetAsync("missing", null, cancellationToken).Returns((LocationAggregate?)null); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is("inv-1"), Any(), Is(cancellationToken)) + .Returns(source); + store + .GetAsync(Is("LOC-001"), Any(), Is(cancellationToken)) + .Returns(sourceLocation); + store + .GetAsync(Is("missing"), Any(), Is(cancellationToken)) + .Returns((LocationAggregate?)null); var result = await CreateService(store: store).TransferAsync("inv-1", "missing", 5, "test", cancellationToken); @@ -103,10 +109,16 @@ public async Task TransferAsync_GivenMissingSourceLocationAggregate_ReturnsFail( { var source = StockedItem("inv-1", "LOC-001", "Warehouse North", 100, productId: "SKU-001"); var destinationLocation = Location("LOC-002", "Warehouse South"); - var store = Substitute.For(); - store.GetAsync("inv-1", null, cancellationToken).Returns(source); - store.GetAsync("LOC-001", null, cancellationToken).Returns((LocationAggregate?)null); - store.GetAsync("LOC-002", null, cancellationToken).Returns(destinationLocation); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is("inv-1"), Any(), Is(cancellationToken)) + .Returns(source); + store + .GetAsync(Is("LOC-001"), Any(), Is(cancellationToken)) + .Returns((LocationAggregate?)null); + store + .GetAsync(Is("LOC-002"), Any(), Is(cancellationToken)) + .Returns(destinationLocation); var result = await CreateService(store: store).TransferAsync("inv-1", "LOC-002", 5, "test", cancellationToken); @@ -122,12 +134,22 @@ public async Task TransferAsync_GivenInsufficientStock_ReturnsFail(CancellationT var destinationLocation = Location("LOC-002", "Warehouse South"); var dest = StockedItem("inv-2", "LOC-002", "Warehouse South", 0); - var store = Substitute.For(); - store.GetAsync("inv-1", null, cancellationToken).Returns(source); - store.GetAsync("LOC-001", null, cancellationToken).Returns(sourceLocation); - store.GetAsync("LOC-002", null, cancellationToken).Returns(destinationLocation); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is("inv-1"), Any(), Is(cancellationToken)) + .Returns(source); + store + .GetAsync(Is("LOC-001"), Any(), Is(cancellationToken)) + .Returns(sourceLocation); store - .FirstOrDefaultAsync(Arg.Any>>(), null, cancellationToken) + .GetAsync(Is("LOC-002"), Any(), Is(cancellationToken)) + .Returns(destinationLocation); + store + .FirstOrDefaultAsync( + Any>>(), + Any, IQueryable>?>(), + Is(cancellationToken) + ) .Returns(dest); var result = await CreateService(store: store).TransferAsync("inv-1", "LOC-002", 10, "test", cancellationToken); @@ -144,17 +166,27 @@ public async Task TransferAsync_GivenValidData_ReturnsSuccess(CancellationToken var destinationLocation = Location("LOC-002", "Warehouse South"); var dest = StockedItem("inv-2", "LOC-002", "Warehouse South", 20); - var transactionFactory = Substitute.For(); - var transaction = Substitute.For(); - transactionFactory.Create(Arg.Any()).Returns(transaction); + var transactionFactory = IEventStoreTransactionFactory.Mock(); + var transaction = IEventStoreTransaction.Mock(); + transactionFactory.Create(Any()).Returns(transaction); transaction.CommitAsync(cancellationToken).Returns(SuccessfulTransaction(source, dest)); - var store = Substitute.For(); - store.GetAsync("inv-1", null, cancellationToken).Returns(source); - store.GetAsync("LOC-001", null, cancellationToken).Returns(sourceLocation); - store.GetAsync("LOC-002", null, cancellationToken).Returns(destinationLocation); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is("inv-1"), Any(), Is(cancellationToken)) + .Returns(source); + store + .GetAsync(Is("LOC-001"), Any(), Is(cancellationToken)) + .Returns(sourceLocation); store - .FirstOrDefaultAsync(Arg.Any>>(), null, cancellationToken) + .GetAsync(Is("LOC-002"), Any(), Is(cancellationToken)) + .Returns(destinationLocation); + store + .FirstOrDefaultAsync( + Any>>(), + Any, IQueryable>?>(), + Is(cancellationToken) + ) .Returns(dest); var result = await CreateService(transactionFactory, store) @@ -174,17 +206,27 @@ CancellationToken cancellationToken var destinationLocation = Location("LOC-002", "Warehouse South"); var dest = StockedItem("inv-2", "LOC-002", "Warehouse South", 20); - var transactionFactory = Substitute.For(); - var transaction = Substitute.For(); - transactionFactory.Create(Arg.Any()).Returns(transaction); + var transactionFactory = IEventStoreTransactionFactory.Mock(); + var transaction = IEventStoreTransaction.Mock(); + transactionFactory.Create(Any()).Returns(transaction); transaction.CommitAsync(cancellationToken).Returns(SuccessfulTransaction(source, dest)); - var store = Substitute.For(); - store.GetAsync("inv-1", null, cancellationToken).Returns(source); - store.GetAsync("LOC-001", null, cancellationToken).Returns(sourceLocation); - store.GetAsync("LOC-002", null, cancellationToken).Returns(destinationLocation); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is("inv-1"), Any(), Is(cancellationToken)) + .Returns(source); + store + .GetAsync(Is("LOC-001"), Any(), Is(cancellationToken)) + .Returns(sourceLocation); + store + .GetAsync(Is("LOC-002"), Any(), Is(cancellationToken)) + .Returns(destinationLocation); store - .FirstOrDefaultAsync(Arg.Any>>(), null, cancellationToken) + .FirstOrDefaultAsync( + Any>>(), + Any, IQueryable>?>(), + Is(cancellationToken) + ) .Returns(dest); await CreateService(transactionFactory, store) @@ -205,19 +247,29 @@ CancellationToken cancellationToken var createdDestination = new InventoryAggregate(); createdDestination.Details.Id = "inv-2"; - var transactionFactory = Substitute.For(); - var transaction = Substitute.For(); - transactionFactory.Create(Arg.Any()).Returns(transaction); + var transactionFactory = IEventStoreTransactionFactory.Mock(); + var transaction = IEventStoreTransaction.Mock(); + transactionFactory.Create(Any()).Returns(transaction); transaction.CommitAsync(cancellationToken).Returns(SuccessfulTransaction(source, createdDestination)); - var store = Substitute.For(); - store.GetAsync("inv-1", null, cancellationToken).Returns(source); - store.GetAsync("LOC-001", null, cancellationToken).Returns(sourceLocation); - store.GetAsync("LOC-002", null, cancellationToken).Returns(destinationLocation); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is("inv-1"), Any(), Is(cancellationToken)) + .Returns(source); + store + .GetAsync(Is("LOC-001"), Any(), Is(cancellationToken)) + .Returns(sourceLocation); + store + .GetAsync(Is("LOC-002"), Any(), Is(cancellationToken)) + .Returns(destinationLocation); store - .FirstOrDefaultAsync(Arg.Any>>(), null, cancellationToken) + .FirstOrDefaultAsync( + Any>>(), + Any, IQueryable>?>(), + Is(cancellationToken) + ) .Returns((InventoryAggregate?)null); - store.CreateAsync(null, cancellationToken).Returns(createdDestination); + store.CreateAsync(Any(), Is(cancellationToken)).Returns(createdDestination); var result = await CreateService(transactionFactory, store) .TransferAsync("inv-1", "LOC-002", 10, "test", cancellationToken); @@ -227,7 +279,7 @@ CancellationToken cancellationToken await Assert.That(createdDestination.LocationName).IsEqualTo("Warehouse South"); await Assert.That(createdDestination.ProductId).IsEqualTo(source.ProductId); await Assert.That(createdDestination.QuantityOnHand).IsEqualTo(10); - await store.Received(1).CreateAsync(null, cancellationToken); + store.CreateAsync(Any(), Is(cancellationToken)).WasCalled(Times.Once); } [Test] @@ -238,17 +290,27 @@ public async Task TransferAsync_WhenTransactionCommitFails_ReturnsFail(Cancellat var destinationLocation = Location("LOC-002", "Warehouse South"); var dest = StockedItem("inv-2", "LOC-002", "Warehouse South", 0); - var transactionFactory = Substitute.For(); - var transaction = Substitute.For(); - transactionFactory.Create(Arg.Any()).Returns(transaction); + var transactionFactory = IEventStoreTransactionFactory.Mock(); + var transaction = IEventStoreTransaction.Mock(); + transactionFactory.Create(Any()).Returns(transaction); transaction.CommitAsync(cancellationToken).Returns(FailedTransaction(source)); - var store = Substitute.For(); - store.GetAsync("inv-1", null, cancellationToken).Returns(source); - store.GetAsync("LOC-001", null, cancellationToken).Returns(sourceLocation); - store.GetAsync("LOC-002", null, cancellationToken).Returns(destinationLocation); + var store = IQueryableEventStore.Mock(); store - .FirstOrDefaultAsync(Arg.Any>>(), null, cancellationToken) + .GetAsync(Is("inv-1"), Any(), Is(cancellationToken)) + .Returns(source); + store + .GetAsync(Is("LOC-001"), Any(), Is(cancellationToken)) + .Returns(sourceLocation); + store + .GetAsync(Is("LOC-002"), Any(), Is(cancellationToken)) + .Returns(destinationLocation); + store + .FirstOrDefaultAsync( + Any>>(), + Any, IQueryable>?>(), + Is(cancellationToken) + ) .Returns(dest); var result = await CreateService(transactionFactory, store) @@ -268,17 +330,27 @@ CancellationToken cancellationToken var destinationLocation = Location("LOC-002", "Warehouse South"); var dest = StockedItem("inv-2", "LOC-002", "Warehouse South", 0); - var transactionFactory = Substitute.For(); - var transaction = Substitute.For(); - transactionFactory.Create(Arg.Any()).Returns(transaction); + var transactionFactory = IEventStoreTransactionFactory.Mock(); + var transaction = IEventStoreTransaction.Mock(); + transactionFactory.Create(Any()).Returns(transaction); transaction.CommitAsync(cancellationToken).Returns(FailedTransaction(dest)); - var store = Substitute.For(); - store.GetAsync("inv-1", null, cancellationToken).Returns(source); - store.GetAsync("LOC-001", null, cancellationToken).Returns(sourceLocation); - store.GetAsync("LOC-002", null, cancellationToken).Returns(destinationLocation); + var store = IQueryableEventStore.Mock(); + store + .GetAsync(Is("inv-1"), Any(), Is(cancellationToken)) + .Returns(source); + store + .GetAsync(Is("LOC-001"), Any(), Is(cancellationToken)) + .Returns(sourceLocation); + store + .GetAsync(Is("LOC-002"), Any(), Is(cancellationToken)) + .Returns(destinationLocation); store - .FirstOrDefaultAsync(Arg.Any>>(), null, cancellationToken) + .FirstOrDefaultAsync( + Any>>(), + Any, IQueryable>?>(), + Is(cancellationToken) + ) .Returns(dest); var result = await CreateService(transactionFactory, store) diff --git a/src/tests/EventSourcing.Samples.UnitTests/ValueObjects/BlobUriTests.cs b/src/tests/Samples.UnitTests/ValueObjects/BlobUriTests.cs similarity index 100% rename from src/tests/EventSourcing.Samples.UnitTests/ValueObjects/BlobUriTests.cs rename to src/tests/Samples.UnitTests/ValueObjects/BlobUriTests.cs diff --git a/src/tests/EventSourcing.Samples.UnitTests/Web/BackOffice/Audit/IndexModelTests.cs b/src/tests/Samples.UnitTests/Web/BackOffice/Audit/IndexModelTests.cs similarity index 59% rename from src/tests/EventSourcing.Samples.UnitTests/Web/BackOffice/Audit/IndexModelTests.cs rename to src/tests/Samples.UnitTests/Web/BackOffice/Audit/IndexModelTests.cs index 08a8552b..d9a627d7 100644 --- a/src/tests/EventSourcing.Samples.UnitTests/Web/BackOffice/Audit/IndexModelTests.cs +++ b/src/tests/Samples.UnitTests/Web/BackOffice/Audit/IndexModelTests.cs @@ -1,5 +1,4 @@ using Microsoft.AspNetCore.Http; -using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc.RazorPages; using Purview.EventSourcing.Samples.Web.Pages.BackOffice.Audit; using Purview.EventSourcing.Samples.Web.Services; @@ -12,7 +11,7 @@ public sealed class IndexModelTests public async Task OnGetAsync_GivenDateRangeWithoutAggregateId_LoadsRecentEvents(CancellationToken cancellationToken) { // Arrange - var auditService = Substitute.For(); + var auditService = IAggregateAuditService.Mock(); var recentEvent = new AggregateEventHistoryItem { AggregateId = "order-1", @@ -28,7 +27,7 @@ public async Task OnGetAsync_GivenDateRangeWithoutAggregateId_LoadsRecentEvents( CausationId = "cause-1", }; auditService - .GetLatestHistoryAsync("order", Arg.Any(), Arg.Any()) + .GetLatestHistoryAsync("order", Any(), Any()) .Returns([recentEvent]); var model = CreateModel(auditService, cancellationToken); @@ -42,22 +41,29 @@ public async Task OnGetAsync_GivenDateRangeWithoutAggregateId_LoadsRecentEvents( await Assert.That(model.IsRecentMode).IsTrue(); await Assert.That(model.Events).Count().IsEqualTo(1); await Assert.That(model.Events[0].EventType).IsEqualTo("OrderConfirmedEvent"); - await auditService - .Received(1) - .GetLatestHistoryAsync("order", Arg.Any(), Arg.Any()); - await auditService - .Received(1) - .GetLatestHistoryAsync("customer", Arg.Any(), Arg.Any()); - await auditService.DidNotReceiveWithAnyArgs().GetHistoryAsync(default!, default!, default!, default); + auditService + .GetLatestHistoryAsync("order", Any(), Any()) + .WasCalled(Times.Once); + auditService + .GetLatestHistoryAsync("customer", Any(), Any()) + .WasCalled(Times.Once); + auditService + .GetHistoryAsync( + Any(), + Any(), + Any(), + Any() + ) + .WasNeverCalled(); } [Test] public async Task OnGetAsync_GivenNoAggregateIdAndNoDateRange_LoadsRecentEvents(CancellationToken cancellationToken) { // Arrange - var auditService = Substitute.For(); + var auditService = IAggregateAuditService.Mock(); auditService - .GetLatestHistoryAsync("order", Arg.Any(), Arg.Any()) + .GetLatestHistoryAsync("order", Any(), Any()) .Returns([]); var model = CreateModel(auditService, cancellationToken); @@ -68,13 +74,20 @@ public async Task OnGetAsync_GivenNoAggregateIdAndNoDateRange_LoadsRecentEvents( await Assert.That(result).IsTypeOf(); await Assert.That(model.IsRecentMode).IsTrue(); await Assert.That(model.Events).Count().IsEqualTo(0); - await auditService.DidNotReceiveWithAnyArgs().GetHistoryAsync(default!, default!, default!, default); - await auditService - .Received(1) - .GetLatestHistoryAsync("order", Arg.Any(), Arg.Any()); - await auditService - .Received(1) - .GetLatestHistoryAsync("customer", Arg.Any(), Arg.Any()); + auditService + .GetHistoryAsync( + Any(), + Any(), + Any(), + Any() + ) + .WasNeverCalled(); + auditService + .GetLatestHistoryAsync("order", Any(), Any()) + .WasCalled(Times.Once); + auditService + .GetLatestHistoryAsync("customer", Any(), Any()) + .WasCalled(Times.Once); } [Test] @@ -83,14 +96,8 @@ CancellationToken cancellationToken ) { // Arrange - var auditService = Substitute.For(); - auditService - .GetLatestHistoryAsync( - "order", - Arg.Is(m => m.FromUtc.HasValue), - Arg.Any() - ) - .Returns([]); + var auditService = IAggregateAuditService.Mock(); + auditService.GetLatestHistoryAsync("order", m => m.FromUtc.HasValue, Any()).Returns([]); var model = CreateModel(auditService, cancellationToken, "?fromUtc=2026-06-23T00:15"); @@ -99,29 +106,21 @@ CancellationToken cancellationToken // Assert await Assert.That(model.IsRecentMode).IsTrue(); - await auditService - .Received(1) - .GetLatestHistoryAsync( - "order", - Arg.Is(m => m.FromUtc.HasValue), - Arg.Any() - ); - await auditService - .Received(1) - .GetLatestHistoryAsync( - "customer", - Arg.Is(m => m.FromUtc.HasValue), - Arg.Any() - ); + auditService + .GetLatestHistoryAsync("order", m => m.FromUtc.HasValue, Any()) + .WasCalled(Times.Once); + auditService + .GetLatestHistoryAsync("customer", m => m.FromUtc.HasValue, Any()) + .WasCalled(Times.Once); } [Test] public async Task OnGetAsync_GivenAggregateId_LoadsAggregateHistory(CancellationToken cancellationToken) { // Arrange - var auditService = Substitute.For(); + var auditService = IAggregateAuditService.Mock(); auditService - .GetHistoryAsync("order", "agg-1", Arg.Any(), Arg.Any()) + .GetHistoryAsync("order", "agg-1", Any(), Any()) .Returns( new ContinuationResponse { @@ -151,10 +150,12 @@ public async Task OnGetAsync_GivenAggregateId_LoadsAggregateHistory(Cancellation await Assert.That(model.IsRecentMode).IsFalse(); await Assert.That(model.AggregateId).IsEqualTo("agg-1"); await Assert.That(model.Events).Count().IsEqualTo(1); - await auditService - .Received(1) - .GetHistoryAsync("order", "agg-1", Arg.Any(), Arg.Any()); - await auditService.DidNotReceiveWithAnyArgs().GetLatestHistoryAsync(default!, default!, default); + auditService + .GetHistoryAsync("order", "agg-1", Any(), Any()) + .WasCalled(Times.Once); + auditService + .GetLatestHistoryAsync(Any(), Any(), Any()) + .WasNeverCalled(); } static IndexModel CreateModel( @@ -167,8 +168,7 @@ static IndexModel CreateModel( if (!string.IsNullOrWhiteSpace(queryString)) httpContext.Request.QueryString = new QueryString(queryString); - var model = new IndexModel(auditService); - model.PageContext = new PageContext { HttpContext = httpContext }; + IndexModel model = new(auditService) { PageContext = new PageContext { HttpContext = httpContext } }; return model; } diff --git a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/SetComplexPropertyEvent.cs b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/ComplexPropertySetEvent.cs similarity index 85% rename from src/tests/SharedTestingFramework/Aggregates/Persistence/Events/SetComplexPropertyEvent.cs rename to src/tests/SharedTestingFramework/Aggregates/Persistence/Events/ComplexPropertySetEvent.cs index 687a1a66..9c095b6b 100644 --- a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/SetComplexPropertyEvent.cs +++ b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/ComplexPropertySetEvent.cs @@ -2,7 +2,7 @@ namespace Purview.EventSourcing.Aggregates.Persistence.Events; -public class SetComplexPropertyEvent : EventBase +public class ComplexPropertySetEvent : EventBase { public ComplexTestType ComplexProperty { get; set; } = default!; diff --git a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/SetInt32ValueEvent.cs b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/IncrementValueSetEvent.cs similarity index 83% rename from src/tests/SharedTestingFramework/Aggregates/Persistence/Events/SetInt32ValueEvent.cs rename to src/tests/SharedTestingFramework/Aggregates/Persistence/Events/IncrementValueSetEvent.cs index cf53d62c..84761dea 100644 --- a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/SetInt32ValueEvent.cs +++ b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/IncrementValueSetEvent.cs @@ -2,7 +2,7 @@ namespace Purview.EventSourcing.Aggregates.Persistence.Events; -public class SetInt32ValueEvent : EventBase +public class IncrementValueSetEvent : EventBase { public int Value { get; set; } diff --git a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/IncrementInt32ValueEvent.cs b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/Int32ValueIncrementedEvent.cs similarity index 77% rename from src/tests/SharedTestingFramework/Aggregates/Persistence/Events/IncrementInt32ValueEvent.cs rename to src/tests/SharedTestingFramework/Aggregates/Persistence/Events/Int32ValueIncrementedEvent.cs index f4c0bed4..daff7dd6 100644 --- a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/IncrementInt32ValueEvent.cs +++ b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/Int32ValueIncrementedEvent.cs @@ -2,7 +2,7 @@ namespace Purview.EventSourcing.Aggregates.Persistence.Events; -public class IncrementInt32ValueEvent : EventBase +public class Int32ValueIncrementedEvent : EventBase { protected override void BuildEventHash(ref HashCode hash) { } } diff --git a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/SetIncrementEvent.cs b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/Int32ValueSetEvent.cs similarity index 84% rename from src/tests/SharedTestingFramework/Aggregates/Persistence/Events/SetIncrementEvent.cs rename to src/tests/SharedTestingFramework/Aggregates/Persistence/Events/Int32ValueSetEvent.cs index b740ff7b..03e7c12f 100644 --- a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/SetIncrementEvent.cs +++ b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/Int32ValueSetEvent.cs @@ -2,7 +2,7 @@ namespace Purview.EventSourcing.Aggregates.Persistence.Events; -public class SetIncrementEvent : EventBase +public class Int32ValueSetEvent : EventBase { public int Value { get; set; } diff --git a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/AddStringDictionaryKVPsEvent.cs b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/KVPsAddedEvent.cs similarity index 89% rename from src/tests/SharedTestingFramework/Aggregates/Persistence/Events/AddStringDictionaryKVPsEvent.cs rename to src/tests/SharedTestingFramework/Aggregates/Persistence/Events/KVPsAddedEvent.cs index 6a529ef6..06d0711a 100644 --- a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/AddStringDictionaryKVPsEvent.cs +++ b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/KVPsAddedEvent.cs @@ -2,7 +2,7 @@ namespace Purview.EventSourcing.Aggregates.Persistence.Events; -public class AddStringDictionaryKVPsEvent : EventBase +public class KVPsAddedEvent : EventBase { [System.Diagnostics.CodeAnalysis.SuppressMessage( "Performance", diff --git a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/OldEvent.cs b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/OldEvent.cs index 3e83f00f..c83f560b 100644 --- a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/OldEvent.cs +++ b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/OldEvent.cs @@ -2,6 +2,11 @@ namespace Purview.EventSourcing.Aggregates.Persistence.Events; +[System.Diagnostics.CodeAnalysis.SuppressMessage( + "Purview.EventSourcing.SourceGenerator", + "EVENTSTORE013:Event names should be past tense", + Justification = "Testing" +)] public class OldEvent : EventBase { public Guid Value { get; set; } diff --git a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/AddStringValuesDictionaryKVPsEvent.cs b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/StringValueKVPsAddedEvent.cs similarity index 89% rename from src/tests/SharedTestingFramework/Aggregates/Persistence/Events/AddStringValuesDictionaryKVPsEvent.cs rename to src/tests/SharedTestingFramework/Aggregates/Persistence/Events/StringValueKVPsAddedEvent.cs index 5a560fa0..5f3db297 100644 --- a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/AddStringValuesDictionaryKVPsEvent.cs +++ b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/StringValueKVPsAddedEvent.cs @@ -3,7 +3,7 @@ namespace Purview.EventSourcing.Aggregates.Persistence.Events; -public class AddStringValuesDictionaryKVPsEvent : EventBase +public class StringValueKVPsAddedEvent : EventBase { [System.Diagnostics.CodeAnalysis.SuppressMessage( "Performance", diff --git a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/StringValueEvent.cs b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/StringValueSetEvent.cs similarity index 84% rename from src/tests/SharedTestingFramework/Aggregates/Persistence/Events/StringValueEvent.cs rename to src/tests/SharedTestingFramework/Aggregates/Persistence/Events/StringValueSetEvent.cs index 3fadb249..29f333a1 100644 --- a/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/StringValueEvent.cs +++ b/src/tests/SharedTestingFramework/Aggregates/Persistence/Events/StringValueSetEvent.cs @@ -2,7 +2,7 @@ namespace Purview.EventSourcing.Aggregates.Persistence.Events; -public class StringValueEvent : EventBase +public class StringValueSetEvent : EventBase { public string Value { get; set; } = default!; diff --git a/src/tests/SharedTestingFramework/Aggregates/Persistence/PersistenceAggregate.cs b/src/tests/SharedTestingFramework/Aggregates/Persistence/PersistenceAggregate.cs index 6a3e44af..c012fd02 100644 --- a/src/tests/SharedTestingFramework/Aggregates/Persistence/PersistenceAggregate.cs +++ b/src/tests/SharedTestingFramework/Aggregates/Persistence/PersistenceAggregate.cs @@ -38,22 +38,22 @@ public void RegisterOldEventType() protected override void RegisterEvents() { - Register(_ => IncrementInt32++); - Register(@event => IncrementInt32 = @event.Value); - Register(@event => Int32Value = @event.Value); - Register(@event => StringProperty += @event.Value); - Register(@event => ComplexTestType = @event.ComplexProperty); - Register(Apply); - Register(Apply); + Register(_ => IncrementInt32++); + Register(@event => IncrementInt32 = @event.Value); + Register(@event => Int32Value = @event.Value); + Register(@event => StringProperty += @event.Value); + Register(@event => ComplexTestType = @event.ComplexProperty); + Register(Apply); + Register(Apply); } - void Apply(AddStringValuesDictionaryKVPsEvent obj) + void Apply(StringValueKVPsAddedEvent obj) { foreach (var kvp in obj.KVPs) StringValuesDictionary.Add(kvp.Key, kvp.Value); } - void Apply(AddStringDictionaryKVPsEvent obj) + void Apply(KVPsAddedEvent obj) { foreach (var kvp in obj.KVPs) StringsDictionary.Add(kvp.Key, kvp.Value); @@ -61,26 +61,26 @@ void Apply(AddStringDictionaryKVPsEvent obj) void Apply(OldEvent @event) => OldEventValue = @event.Value; - public void SetValidatedProperty(int value) => RecordAndApply(new SetIncrementEvent { Value = value }); + public void SetValidatedProperty(int value) => RecordAndApply(new IncrementValueSetEvent { Value = value }); - public void IncrementInt32Value() => RecordAndApply(new IncrementInt32ValueEvent()); + public void IncrementInt32Value() => RecordAndApply(new Int32ValueIncrementedEvent()); public void SetInt32Value(int value) { if (Int32Value != value) - RecordAndApply(new SetInt32ValueEvent { Value = value }); + RecordAndApply(new Int32ValueSetEvent { Value = value }); } public void AppendString(string value) { - RecordAndApply(new StringValueEvent { Value = value }); + RecordAndApply(new StringValueSetEvent { Value = value }); } public void AddKVPs(params KeyValuePair[] pairs) => - RecordAndApply(new AddStringValuesDictionaryKVPsEvent { KVPs = pairs }); + RecordAndApply(new StringValueKVPsAddedEvent { KVPs = pairs }); public void AddKVPs(params KeyValuePair[] pairs) => - RecordAndApply(new AddStringDictionaryKVPsEvent { KVPs = pairs }); + RecordAndApply(new KVPsAddedEvent { KVPs = pairs }); public void SetOldEventValue(Guid value) { @@ -91,5 +91,5 @@ public void SetOldEventValue(Guid value) } public void SetComplexProperty(ComplexTestType complexTestType) => - RecordAndApply(new SetComplexPropertyEvent { ComplexProperty = complexTestType }); + RecordAndApply(new ComplexPropertySetEvent { ComplexProperty = complexTestType }); } diff --git a/src/tests/SharedTestingFramework/ContainerHelper.Resources.cs b/src/tests/SharedTestingFramework/ContainerHelper.Resources.cs new file mode 100644 index 00000000..c5c2a50a --- /dev/null +++ b/src/tests/SharedTestingFramework/ContainerHelper.Resources.cs @@ -0,0 +1,10 @@ +namespace Purview.EventSourcing; + +partial class ContainerHelper +{ + public const string AzuriteImageTag = "3.36.0"; + public const string SqlServerImageTag = "2025-latest"; + public const string PostgresImageTag = "16.4"; + public const string CosmosDbImageTag = "vnext-preview"; + public const string MongoDbImageTag = "7.0"; +} diff --git a/src/tests/SharedTestingFramework/ContainerHelper.cs b/src/tests/SharedTestingFramework/ContainerHelper.cs index 5da13128..299dec85 100644 --- a/src/tests/SharedTestingFramework/ContainerHelper.cs +++ b/src/tests/SharedTestingFramework/ContainerHelper.cs @@ -5,14 +5,15 @@ using Testcontainers.CosmosDb; using Testcontainers.MongoDb; using Testcontainers.MsSql; +using Testcontainers.PostgreSql; namespace Purview.EventSourcing; -public static class ContainerHelper +public static partial class ContainerHelper { public static AzuriteContainer CreateAzurite(Action? config = null) { - var builder = new AzuriteBuilder("mcr.microsoft.com/azure-storage/azurite:3.35.0").WithCommand( + var builder = new AzuriteBuilder($"mcr.microsoft.com/azure-storage/azurite:{AzuriteImageTag}").WithCommand( "--skipApiVersionCheck" ) //.WithWaitStrategy(Wait.ForUnixContainer() @@ -29,7 +30,7 @@ public static AzuriteContainer CreateAzurite(Action? config = nu public static CosmosDbContainer CreateCosmosDB(Action? config = null) { - var builder = new CosmosDbBuilder("mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator:vnext-preview") + var builder = new CosmosDbBuilder($"mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator:{CosmosDbImageTag}") .WithWaitStrategy( Wait.ForUnixContainer() .AddCustomWaitStrategy(new CosmosDbWaitUntil(), ws => ws.WithTimeout(TimeSpan.FromMinutes(5))) @@ -74,7 +75,7 @@ public async Task UntilAsync(IContainer container) public static MongoDbContainer CreateMongoDB(Action? config = null) { - var builder = new MongoDbBuilder("mongo:7.0").WithReplicaSet() + var builder = new MongoDbBuilder($"mongo:{MongoDbImageTag}").WithReplicaSet() //.WithAutoRemove(true) //.WithCleanUp(true) //.WithWaitStrategy(Wait.ForUnixContainer().UntilPortIsAvailable(27017)) @@ -87,7 +88,16 @@ public static MongoDbContainer CreateMongoDB(Action? config = nu public static MsSqlContainer CreateMsSql(Action? config = null) { - var builder = new MsSqlBuilder("mcr.microsoft.com/mssql/server:2025-latest"); + var builder = new MsSqlBuilder($"mcr.microsoft.com/mssql/server:{SqlServerImageTag}"); + + config?.Invoke(builder); + + return builder.Build(); + } + + public static PostgreSqlContainer CreatePostgreSql(Action? config = null) + { + var builder = new PostgreSqlBuilder($"postgres:{PostgresImageTag}"); config?.Invoke(builder); diff --git a/src/tests/SharedTestingFramework/Fixtures/AzureStorage/TableEventStoreFixture.cs b/src/tests/SharedTestingFramework/Fixtures/AzureStorage/TableEventStoreFixture.cs index 430c2cec..0fb3ad73 100644 --- a/src/tests/SharedTestingFramework/Fixtures/AzureStorage/TableEventStoreFixture.cs +++ b/src/tests/SharedTestingFramework/Fixtures/AzureStorage/TableEventStoreFixture.cs @@ -1,5 +1,4 @@ using Microsoft.Extensions.Caching.Distributed; -using NSubstitute.ReturnsExtensions; using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.Aggregates.Snapshotting; using Purview.EventSourcing.AzureStorage; @@ -18,9 +17,14 @@ public sealed class TableEventStoreFixture : IAsyncInitializer, IAsyncDisposable IAggregateEventNameMapper _eventNameMapper = default!; IDisposable? _eventStoreAsDisposable; - public IDistributedCache Cache { get; private set; } = default!; + public TableEventStoreFixture() + { + EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; + } + + public IDistributedCacheMock Cache { get; private set; } = default!; - public ITableEventStoreTelemetry Telemetry { get; private set; } = default!; + public ITableEventStoreTelemetryMock Telemetry { get; private set; } = default!; internal AzureTableClient TableClient { get; private set; } = default!; @@ -40,8 +44,8 @@ public TableEventStore CreateEventStore( internal ( TableEventStore EventStore, - ITableEventStoreTelemetry Telemetry, - IDistributedCache Cache, + ITableEventStoreTelemetryMock Telemetry, + IDistributedCacheMock Cache, AzureTableClient TableClient, AzureBlobClient BlobClient ) CreateEventStoreContext( @@ -59,12 +63,12 @@ AzureBlobClient BlobClient var cache = CreateDistributedCache(); Cache = cache; - var telemetry = Substitute.For(); + var telemetry = ITableEventStoreTelemetry.Mock(); Telemetry = telemetry; _eventNameMapper = new AggregateEventNameMapper(); - var aggregateRequirementsManager = Substitute.For(); + var aggregateRequirementsManager = IAggregateRequirementsManager.Mock(); AzureStorageEventStoreOptions azureStorageOptions = new() { ConnectionString = _azuriteContainer.GetConnectionString(), @@ -78,8 +82,7 @@ AzureBlobClient BlobClient eventNameMapper: _eventNameMapper, azureStorageOptions: Microsoft.Extensions.Options.Options.Create(azureStorageOptions), distributedCache: cache, - aggregateChangeNotifier: aggregateChangeNotifier - ?? Substitute.For>(), + aggregateChangeNotifier: aggregateChangeNotifier ?? IAggregateChangeFeedNotifier.Mock(), eventStoreTelemetry: telemetry, aggregateRequirementsManager: aggregateRequirementsManager, snapshotStrategy: new IntervalSnapshotStrategy(snapshotRecalculationInterval) @@ -96,10 +99,10 @@ AzureBlobClient BlobClient return (eventStore, telemetry, cache, tableClient, blobClient); } - public static IDistributedCache CreateDistributedCache() + public static IDistributedCacheMock CreateDistributedCache() { - var cache = Substitute.For(); - cache.GetAsync(Arg.Any(), Arg.Any()).ReturnsNullForAnyArgs(); + var cache = IDistributedCache.Mock(); + cache.GetAsync(Any(), Any()).Returns((byte[]?)null); return cache; } diff --git a/src/tests/SharedTestingFramework/Fixtures/CosmosDb/CosmosDbSnapshotEventStoreContext.cs b/src/tests/SharedTestingFramework/Fixtures/CosmosDb/CosmosDbSnapshotEventStoreContext.cs index 97bea36d..0d339edc 100644 --- a/src/tests/SharedTestingFramework/Fixtures/CosmosDb/CosmosDbSnapshotEventStoreContext.cs +++ b/src/tests/SharedTestingFramework/Fixtures/CosmosDb/CosmosDbSnapshotEventStoreContext.cs @@ -18,7 +18,7 @@ public sealed class CosmosDbSnapshotEventStoreContext( string azuriteConnectionString ) : IAsyncDisposable { - ITableEventStoreTelemetry _telemetry = default!; + ITableEventStoreTelemetryMock _telemetry = default!; IAggregateEventNameMapper _eventNameMapper = default!; public Guid RunId { get; } = Guid.NewGuid(); @@ -38,6 +38,8 @@ string azuriteConnectionString )] public void CreateCosmosDbEventStore(int correlationIdsToGenerate = 1, string? container = null) { + EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; + var tableEventStore = CreateTableEventStore(correlationIdsToGenerate); CosmosDbEventStoreOptions config = new() @@ -66,7 +68,7 @@ public void CreateCosmosDbEventStore(int correlationIdsToGenerate = 1, string? c CosmosDbSnapshotEventStore eventStore = new( tableEventStore, Microsoft.Extensions.Options.Options.Create(config), - Substitute.For(), + ICosmosDbSnapshotEventStoreTelemetry.Mock(), cosmosClient ); @@ -81,7 +83,7 @@ TableEventStore CreateTableEventStore(int correlationIdsTo .ToArray(); _eventNameMapper = new AggregateEventNameMapper(); - _telemetry = Substitute.For(); + _telemetry = ITableEventStoreTelemetry.Mock(); AzureStorageEventStoreOptions azureStorageOptions = new() { @@ -95,10 +97,10 @@ TableEventStore CreateTableEventStore(int correlationIdsTo TableEventStore eventStore = new( eventNameMapper: _eventNameMapper, azureStorageOptions: Microsoft.Extensions.Options.Options.Create(azureStorageOptions), - distributedCache: Substitute.For(), - aggregateChangeNotifier: Substitute.For>(), + distributedCache: IDistributedCache.Mock(), + aggregateChangeNotifier: IAggregateChangeFeedNotifier.Mock(), eventStoreTelemetry: _telemetry, - aggregateRequirementsManager: Substitute.For() + aggregateRequirementsManager: IAggregateRequirementsManager.Mock() ); TableClient = new(azureStorageOptions, eventStore.TableName); diff --git a/src/tests/SharedTestingFramework/Fixtures/CosmosDb/CosmosDbSnapshotEventStoreFixture.cs b/src/tests/SharedTestingFramework/Fixtures/CosmosDb/CosmosDbSnapshotEventStoreFixture.cs index 95fc7cdb..6e2d889b 100644 --- a/src/tests/SharedTestingFramework/Fixtures/CosmosDb/CosmosDbSnapshotEventStoreFixture.cs +++ b/src/tests/SharedTestingFramework/Fixtures/CosmosDb/CosmosDbSnapshotEventStoreFixture.cs @@ -9,6 +9,8 @@ public class CosmosDbSnapshotEventStoreFixture : IAsyncInitializer, IAsyncDispos public CosmosDbSnapshotEventStoreFixture() { + EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; + _azuriteContainer = ContainerHelper.CreateAzurite(); _cosmosDbContainer = ContainerHelper.CreateCosmosDB(); } diff --git a/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBEventStoreFixture.cs b/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBEventStoreFixture.cs index f619bb0f..3bc10410 100644 --- a/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBEventStoreFixture.cs +++ b/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBEventStoreFixture.cs @@ -1,5 +1,4 @@ using Microsoft.Extensions.Caching.Distributed; -using NSubstitute.ReturnsExtensions; using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.ChangeFeed; using Purview.EventSourcing.MongoDB; @@ -17,11 +16,15 @@ public sealed class MongoDBEventStoreFixture : IAsyncInitializer, IAsyncDisposab IAggregateEventNameMapper _eventNameMapper = default!; - public MongoDBEventStoreFixture() => _mongoDBContainer = ContainerHelper.CreateMongoDB(); + public MongoDBEventStoreFixture() + { + EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; + _mongoDBContainer = ContainerHelper.CreateMongoDB(); + } - public IDistributedCache Cache { get; private set; } = default!; + public IDistributedCacheMock Cache { get; private set; } = default!; - public IMongoDBEventStoreTelemetry Telemetry { get; private set; } = default!; + public IMongoDBEventStoreTelemetryMock Telemetry { get; private set; } = default!; internal MongoDBClient EventClient { get; private set; } = default!; @@ -29,26 +32,20 @@ public sealed class MongoDBEventStoreFixture : IAsyncInitializer, IAsyncDisposab public MongoDBEventStore CreateEventStore( IAggregateChangeFeedNotifier? aggregateChangeNotifier = null, - bool removeFromCacheOnDelete = false, - int snapshotRecalculationInterval = 1 + bool removeFromCacheOnDelete = false ) where TAggregate : class, IAggregate, new() => - CreateEventStoreContext( - aggregateChangeNotifier, - removeFromCacheOnDelete, - snapshotRecalculationInterval - ).EventStore; + CreateEventStoreContext(aggregateChangeNotifier, removeFromCacheOnDelete).EventStore; internal ( MongoDBEventStore EventStore, - IMongoDBEventStoreTelemetry Telemetry, - IDistributedCache Cache, + IMongoDBEventStoreTelemetryMock Telemetry, + IDistributedCacheMock Cache, MongoDBClient EventClient, MongoDBClient SnapshotClient ) CreateEventStoreContext( IAggregateChangeFeedNotifier? aggregateChangeNotifier = null, - bool removeFromCacheOnDelete = false, - int snapshotRecalculationInterval = 1 + bool removeFromCacheOnDelete = false ) where TAggregate : class, IAggregate, new() { @@ -57,14 +54,14 @@ MongoDBClient SnapshotClient var cache = CreateDistributedCache(); Cache = cache; - var telemetry = Substitute.For(); + var telemetry = IMongoDBEventStoreTelemetry.Mock(); Telemetry = telemetry; _eventNameMapper = new AggregateEventNameMapper(); var connectionString = _mongoDBContainer.GetConnectionString(); - var aggregateRequirementsManager = Substitute.For(); + var aggregateRequirementsManager = IAggregateRequirementsManager.Mock(); MongoDBEventStoreOptions mongoDBOptions = new() { ApplicationName = nameof(MongoDBEventStoreFixture), @@ -77,13 +74,12 @@ MongoDBClient SnapshotClient RemoveDeletedFromCache = removeFromCacheOnDelete, }; - var mongoDBClientTelemetry = Substitute.For(); + var mongoDBClientTelemetry = IMongoDBClientTelemetry.Mock(); MongoDBEventStore eventStore = new( eventNameMapper: _eventNameMapper, mongoDbOptions: Microsoft.Extensions.Options.Options.Create(mongoDBOptions), distributedCache: cache, - aggregateChangeNotifier: aggregateChangeNotifier - ?? Substitute.For>(), + aggregateChangeNotifier: aggregateChangeNotifier ?? IAggregateChangeFeedNotifier.Mock(), eventStoreTelemetry: telemetry, mongoDBClientTelemetry: mongoDBClientTelemetry, aggregateRequirementsManager: aggregateRequirementsManager @@ -108,10 +104,10 @@ MongoDBClient SnapshotClient return (eventStore, telemetry, cache, eventClient, snapshotClient); } - public static IDistributedCache CreateDistributedCache() + public static IDistributedCacheMock CreateDistributedCache() { - var cache = Substitute.For(); - cache.GetAsync(Arg.Any(), Arg.Any()).ReturnsNullForAnyArgs(); + var cache = IDistributedCache.Mock(); + cache.GetAsync(Any(), Any()).Returns((byte[]?)null); return cache; } diff --git a/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBSnapshotEventStoreFixture.cs b/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBSnapshotEventStoreFixture.cs index c88b2473..91437f38 100644 --- a/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBSnapshotEventStoreFixture.cs +++ b/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBSnapshotEventStoreFixture.cs @@ -9,6 +9,8 @@ public class MongoDBSnapshotEventStoreFixture : IAsyncInitializer, IAsyncDisposa public MongoDBSnapshotEventStoreFixture() { + EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; + _azuriteContainer = ContainerHelper.CreateAzurite(); _mongoDBContainer = ContainerHelper.CreateMongoDB(); } diff --git a/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBSnapshotTestContext.cs b/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBSnapshotTestContext.cs index 8a0024a1..14548744 100644 --- a/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBSnapshotTestContext.cs +++ b/src/tests/SharedTestingFramework/Fixtures/MongoDB/MongoDBSnapshotTestContext.cs @@ -38,6 +38,7 @@ public MongoDBSnapshotTestContext( _mongoDbConnectionString = mongoDbConnectionString; _azuriteConnectionString = azuriteConnectionString; + EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; EventStore = CreateMongoDBEventStore(correlationIdsToGenerate, collectionName); } @@ -58,12 +59,12 @@ public MongoDBSnapshotEventStore CreateMongoDBEventStore( MongoDBSnapshotEventStore eventStore = new( tableEventStore, Microsoft.Extensions.Options.Options.Create(config), - Substitute.For(), - Substitute.For() + IMongoDBSnapshotEventStoreTelemetry.Mock(), + IMongoDBClientTelemetry.Mock() ); MongoDBClient = new( - Substitute.For(), + IMongoDBClientTelemetry.Mock(), new() { ConnectionString = config.ConnectionString, @@ -85,7 +86,7 @@ TableEventStore CreateTableEventStore(int correlationIdsTo .ToArray(); _eventNameMapper = new AggregateEventNameMapper(); - _telemetry = Substitute.For(); + _telemetry = ITableEventStoreTelemetry.Mock(); AzureStorageEventStoreOptions azureStorageOptions = new() { @@ -99,10 +100,10 @@ TableEventStore CreateTableEventStore(int correlationIdsTo TableEventStore eventStore = new( eventNameMapper: _eventNameMapper, azureStorageOptions: Microsoft.Extensions.Options.Options.Create(azureStorageOptions), - distributedCache: Substitute.For(), - aggregateChangeNotifier: Substitute.For>(), + distributedCache: IDistributedCache.Mock(), + aggregateChangeNotifier: IAggregateChangeFeedNotifier.Mock(), eventStoreTelemetry: _telemetry, - aggregateRequirementsManager: Substitute.For() + aggregateRequirementsManager: IAggregateRequirementsManager.Mock() ); TableClient = new(azureStorageOptions, eventStore.TableName); diff --git a/src/tests/SharedTestingFramework/Fixtures/Postgres/PostgresEventStoreFixture.cs b/src/tests/SharedTestingFramework/Fixtures/Postgres/PostgresEventStoreFixture.cs new file mode 100644 index 00000000..fa216a67 --- /dev/null +++ b/src/tests/SharedTestingFramework/Fixtures/Postgres/PostgresEventStoreFixture.cs @@ -0,0 +1,103 @@ +using Microsoft.Extensions.Caching.Distributed; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.ChangeFeed; +using Purview.EventSourcing.Postgres.Events; +using Purview.EventSourcing.Services; +using Testcontainers.PostgreSql; +using TUnit.Core.Interfaces; + +namespace Purview.EventSourcing.Fixtures.Postgres; + +public class PostgresEventStoreFixture : IAsyncInitializer, IAsyncDisposable +{ + readonly PostgreSqlContainer _postgresContainer = ContainerHelper.CreatePostgreSql(); + + IAggregateEventNameMapper _eventNameMapper = default!; + + public PostgresEventStoreFixture() + { + EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; + } + + public IDistributedCacheMock Cache { get; private set; } = default!; + + public IPostgresEventStoreTelemetryMock Telemetry { get; private set; } = default!; + + internal PostgresEventStoreClient Client { get; private set; } = default!; + + public string ConnectionString => _postgresContainer.GetConnectionString(); + + public PostgresEventStore CreateEventStore( + IAggregateChangeFeedNotifier? aggregateChangeNotifier = null, + bool removeFromCacheOnDelete = false, + Guid? runId = null, + Action? configureOptions = null + ) + where TAggregate : class, IAggregate, new() => + CreateEventStoreContext(aggregateChangeNotifier, removeFromCacheOnDelete, runId, configureOptions).EventStore; + + internal ( + PostgresEventStore EventStore, + PostgresEventStoreClient Client, + IDistributedCacheMock Cache, + IPostgresEventStoreTelemetryMock Telemetry + ) CreateEventStoreContext( + IAggregateChangeFeedNotifier? aggregateChangeNotifier = null, + bool removeFromCacheOnDelete = false, + Guid? runId = null, + Action? configureOptions = null + ) + where TAggregate : class, IAggregate, new() + { + runId ??= Guid.NewGuid(); + var cache = CreateDistributedCache(); + Cache = cache; + var telemetry = IPostgresEventStoreTelemetry.Mock(); + Telemetry = telemetry; + _eventNameMapper = new AggregateEventNameMapper(); + + var aggregateRequirementsManager = IAggregateRequirementsManager.Mock(); + PostgresEventStoreOptions options = new() + { + ConnectionString = ConnectionString, + TableName = $"EventStoreEvents_{runId:N}", + SchemaName = "public", + AutoCreateTable = true, + TimeoutInSeconds = 60, + RemoveDeletedFromCache = removeFromCacheOnDelete, + }; + configureOptions?.Invoke(options); + + var client = new PostgresEventStoreClient(options); + Client = client; + + PostgresEventStore eventStore = new( + eventNameMapper: _eventNameMapper, + sqlServerOptions: Microsoft.Extensions.Options.Options.Create(options), + distributedCache: cache, + eventStoreTelemetry: telemetry, + aggregateChangeNotifier: aggregateChangeNotifier ?? IAggregateChangeFeedNotifier.Mock(), + aggregateRequirementsManager: aggregateRequirementsManager + ); + + return (eventStore, client, cache, telemetry); + } + + public static IDistributedCacheMock CreateDistributedCache() + { + var cache = IDistributedCache.Mock(); + cache.GetAsync(Any(), Any()).Returns((byte[]?)null); + return cache; + } + + public async Task InitializeAsync() + { + await _postgresContainer.StartAsync(); + } + + public async ValueTask DisposeAsync() + { + await _postgresContainer.DisposeAsync(); + GC.SuppressFinalize(this); + } +} diff --git a/src/tests/SharedTestingFramework/Fixtures/Postgres/PostgresSnapshotEventStoreFixture.cs b/src/tests/SharedTestingFramework/Fixtures/Postgres/PostgresSnapshotEventStoreFixture.cs new file mode 100644 index 00000000..9c3bd48a --- /dev/null +++ b/src/tests/SharedTestingFramework/Fixtures/Postgres/PostgresSnapshotEventStoreFixture.cs @@ -0,0 +1,47 @@ +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Snapshotting; +using Purview.EventSourcing.ChangeFeed; +using Purview.EventSourcing.Postgres.Snapshot; +using Purview.EventSourcing.Postgres.Snapshots; + +namespace Purview.EventSourcing.Fixtures.Postgres; + +public class PostgresSnapshotEventStoreFixture : PostgresEventStoreFixture +{ + public PostgresSnapshotEventStore CreateSnapshotStore( + ISnapshotStrategy? snapshotStrategy = null, + ISnapshotStrategySelector? snapshotStrategySelector = null, + IAggregateChangeFeedNotifier? aggregateChangeNotifier = null, + bool removeFromCacheOnDelete = false, + Guid? runId = null, + Action? configureOptions = null + ) + where TAggregate : class, IAggregate, new() + { + runId ??= Guid.NewGuid(); + var eventStore = CreateEventStore( + aggregateChangeNotifier, + removeFromCacheOnDelete, + runId, + configureOptions: null + ); + PostgresSnapshotEventStoreOptions config = new() + { + ConnectionString = ConnectionString, + TableName = $"EventStoreSnapshots_{runId:N}", + SchemaName = "public", + AutoCreateTable = true, + }; + configureOptions?.Invoke(config); + + PostgresSnapshotEventStore snapshotStore = new( + eventStore, + Microsoft.Extensions.Options.Options.Create(config), + IPostgresSnapshotEventStoreTelemetry.Mock(), + snapshotStrategy: snapshotStrategy, + snapshotStrategySelector: snapshotStrategySelector + ); + + return snapshotStore; + } +} diff --git a/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerEventStoreFixture.cs b/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerEventStoreFixture.cs index bd47543a..b44b9dda 100644 --- a/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerEventStoreFixture.cs +++ b/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerEventStoreFixture.cs @@ -1,5 +1,4 @@ using Microsoft.Extensions.Caching.Distributed; -using NSubstitute.ReturnsExtensions; using Purview.EventSourcing.Aggregates; using Purview.EventSourcing.ChangeFeed; using Purview.EventSourcing.Services; @@ -9,19 +8,20 @@ namespace Purview.EventSourcing.Fixtures.SqlServer; -public sealed class SqlServerEventStoreFixture : IAsyncInitializer, IAsyncDisposable +public class SqlServerEventStoreFixture : IAsyncInitializer, IAsyncDisposable { - readonly MsSqlContainer _msSqlContainer; + readonly MsSqlContainer _msSqlContainer = ContainerHelper.CreateMsSql(); + IAggregateEventNameMapper _eventNameMapper = default!; public SqlServerEventStoreFixture() { - _msSqlContainer = ContainerHelper.CreateMsSql(); + EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; } - public IDistributedCache Cache { get; private set; } = default!; + public IDistributedCacheMock Cache { get; private set; } = default!; - public ISqlServerEventStoreTelemetry Telemetry { get; private set; } = default!; + public ISqlServerEventStoreTelemetryMock Telemetry { get; private set; } = default!; internal SqlServerEventStoreClient Client { get; private set; } = default!; @@ -30,46 +30,45 @@ public SqlServerEventStoreFixture() public SqlServerEventStore CreateEventStore( IAggregateChangeFeedNotifier? aggregateChangeNotifier = null, bool removeFromCacheOnDelete = false, - int snapshotRecalculationInterval = 1 + Guid? runId = null, + Action? configureOptions = null ) where TAggregate : class, IAggregate, new() => - CreateEventStoreContext( - aggregateChangeNotifier, - removeFromCacheOnDelete, - snapshotRecalculationInterval - ).EventStore; + CreateEventStoreContext(aggregateChangeNotifier, removeFromCacheOnDelete, runId, configureOptions).EventStore; internal ( SqlServerEventStore EventStore, SqlServerEventStoreClient Client, - IDistributedCache Cache, - ISqlServerEventStoreTelemetry Telemetry + IDistributedCacheMock Cache, + ISqlServerEventStoreTelemetryMock Telemetry ) CreateEventStoreContext( IAggregateChangeFeedNotifier? aggregateChangeNotifier = null, bool removeFromCacheOnDelete = false, - int snapshotRecalculationInterval = 1 + Guid? runId = null, + Action? configureOptions = null ) where TAggregate : class, IAggregate, new() { - var runId = Guid.NewGuid(); + runId ??= Guid.NewGuid(); var cache = CreateDistributedCache(); Cache = cache; - var telemetry = Substitute.For(); + var telemetry = ISqlServerEventStoreTelemetry.Mock(); Telemetry = telemetry; _eventNameMapper = new AggregateEventNameMapper(); var connectionString = _msSqlContainer.GetConnectionString(); - var aggregateRequirementsManager = Substitute.For(); + var aggregateRequirementsManager = IAggregateRequirementsManager.Mock(); SqlServerEventStoreOptions options = new() { ConnectionString = connectionString, - TableName = $"EventStore_{runId:N}", + TableName = $"EventStoreEvents_{runId:N}", SchemaName = "dbo", AutoCreateTable = true, TimeoutInSeconds = 60, RemoveDeletedFromCache = removeFromCacheOnDelete, }; + configureOptions?.Invoke(options); var client = new SqlServerEventStoreClient(options); Client = client; @@ -79,18 +78,17 @@ ISqlServerEventStoreTelemetry Telemetry sqlServerOptions: Microsoft.Extensions.Options.Options.Create(options), distributedCache: cache, eventStoreTelemetry: telemetry, - aggregateChangeNotifier: aggregateChangeNotifier - ?? Substitute.For>(), + aggregateChangeNotifier: aggregateChangeNotifier ?? IAggregateChangeFeedNotifier.Mock(), aggregateRequirementsManager: aggregateRequirementsManager ); return (eventStore, client, cache, telemetry); } - public static IDistributedCache CreateDistributedCache() + public static IDistributedCacheMock CreateDistributedCache() { - var cache = Substitute.For(); - cache.GetAsync(Arg.Any(), Arg.Any()).ReturnsNullForAnyArgs(); + var cache = IDistributedCache.Mock(); + cache.GetAsync(Any(), Any()).Returns((byte[]?)null); return cache; } @@ -102,5 +100,6 @@ public async Task InitializeAsync() public async ValueTask DisposeAsync() { await _msSqlContainer.DisposeAsync(); + GC.SuppressFinalize(this); } } diff --git a/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerSnapshotEventStoreFixture.cs b/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerSnapshotEventStoreFixture.cs index 381dd54d..c37a76b6 100644 --- a/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerSnapshotEventStoreFixture.cs +++ b/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerSnapshotEventStoreFixture.cs @@ -1,37 +1,47 @@ -using TUnit.Core.Interfaces; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Snapshotting; +using Purview.EventSourcing.ChangeFeed; +using Purview.EventSourcing.SqlServer.Snapshot; +using Purview.EventSourcing.SqlServer.Snapshots; namespace Purview.EventSourcing.Fixtures.SqlServer; -public class SqlServerSnapshotEventStoreFixture : IAsyncInitializer, IAsyncDisposable +public class SqlServerSnapshotEventStoreFixture : SqlServerEventStoreFixture { - readonly Testcontainers.Azurite.AzuriteContainer _azuriteContainer; - readonly Testcontainers.MsSql.MsSqlContainer _msSqlContainer; - - public SqlServerSnapshotEventStoreFixture() + public SqlServerSnapshotEventStore CreateSnapshotStore( + ISnapshotStrategy? snapshotStrategy = null, + ISnapshotStrategySelector? snapshotStrategySelector = null, + IAggregateChangeFeedNotifier? aggregateChangeNotifier = null, + bool removeFromCacheOnDelete = false, + Guid? runId = null, + Action? configureOptions = null + ) + where TAggregate : class, IAggregate, new() { - _azuriteContainer = ContainerHelper.CreateAzurite(); - _msSqlContainer = ContainerHelper.CreateMsSql(); - } - - public SqlServerSnapshotTestContext CreateContext(int correlationIdsToGenerate = 1, string? tableName = null) => - new( - _msSqlContainer.GetConnectionString(), - _azuriteContainer.GetConnectionString(), - correlationIdsToGenerate, - tableName + runId ??= Guid.NewGuid(); + var eventStore = CreateEventStore( + aggregateChangeNotifier, + removeFromCacheOnDelete, + runId, + configureOptions: null ); + SqlServerSnapshotEventStoreOptions config = new() + { + ConnectionString = ConnectionString, + TableName = $"EventStoreSnapshots_{runId:N}", + SchemaName = "dbo", + AutoCreateTable = true, + }; + configureOptions?.Invoke(config); - public async Task InitializeAsync() - { - await _msSqlContainer.StartAsync(); - await _azuriteContainer.StartAsync(); - } - - public async ValueTask DisposeAsync() - { - GC.SuppressFinalize(this); + SqlServerSnapshotEventStore snapshotStore = new( + eventStore, + Microsoft.Extensions.Options.Options.Create(config), + ISqlServerSnapshotEventStoreTelemetry.Mock(), + snapshotStrategy: snapshotStrategy, + snapshotStrategySelector: snapshotStrategySelector + ); - await _msSqlContainer.DisposeAsync(); - await _azuriteContainer.DisposeAsync(); + return snapshotStore; } } diff --git a/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerSnapshotTestContext.cs b/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerSnapshotTestContext.cs deleted file mode 100644 index 3604a922..00000000 --- a/src/tests/SharedTestingFramework/Fixtures/SqlServer/SqlServerSnapshotTestContext.cs +++ /dev/null @@ -1,114 +0,0 @@ -using Microsoft.Extensions.Caching.Distributed; -using Purview.EventSourcing.Aggregates.Persistence; -using Purview.EventSourcing.AzureStorage; -using Purview.EventSourcing.AzureStorage.StorageClients.Blob; -using Purview.EventSourcing.AzureStorage.StorageClients.Table; -using Purview.EventSourcing.ChangeFeed; -using Purview.EventSourcing.Services; -using Purview.EventSourcing.SqlServer.Client; -using Purview.EventSourcing.SqlServer.Snapshot; -using Purview.EventSourcing.SqlServer.Snapshots; - -namespace Purview.EventSourcing.Fixtures.SqlServer; - -public sealed class SqlServerSnapshotTestContext -{ - readonly string _azuriteConnectionString; - - ITableEventStoreTelemetry _telemetry = default!; - IAggregateEventNameMapper _eventNameMapper = default!; - - public Guid RunId { get; } = Guid.NewGuid(); - - internal SqlServerClient SqlServerClient { get; private set; } = default!; - - internal AzureTableClient TableClient { get; private set; } = default!; - - internal AzureBlobClient BlobClient { get; private set; } = default!; - - public string SqlServerConnectionString { get; } - - public SqlServerSnapshotEventStore EventStore { get; init; } - - public SqlServerSnapshotTestContext( - string sqlServerConnectionString, - string azuriteConnectionString, - int correlationIdsToGenerate = 1, - string? tableName = null - ) - { - SqlServerConnectionString = sqlServerConnectionString; - _azuriteConnectionString = azuriteConnectionString; - - EventStore = CreateSqlServerEventStore(correlationIdsToGenerate, tableName); - } - - SqlServerSnapshotEventStore CreateSqlServerEventStore( - int correlationIdsToGenerate = 1, - string? tableName = null - ) - { - var tableEventStore = CreateTableEventStore(correlationIdsToGenerate); - - var resolvedTableName = tableName ?? $"Snapshots_{RunId:N}"; - - SqlServerSnapshotEventStoreOptions config = new() - { - ConnectionString = SqlServerConnectionString, - TableName = resolvedTableName, - SchemaName = "dbo", - AutoCreateTable = true, - }; - - SqlServerSnapshotEventStore eventStore = new( - tableEventStore, - Microsoft.Extensions.Options.Options.Create(config), - Substitute.For() - ); - - SqlServerClient = new( - new SqlServerClientOptions(config.ConnectionString, false) - { - TableName = config.TableName, - SchemaName = config.SchemaName, - AutoCreateTable = config.AutoCreateTable, - } - ); - - return eventStore; - } - - TableEventStore CreateTableEventStore(int correlationIdsToGenerate = 1) - { - var runIds = Enumerable - .Range(1, correlationIdsToGenerate) - .Select(_ => $"{Guid.NewGuid()}".ToUpperInvariant()) - .ToArray(); - - _eventNameMapper = new AggregateEventNameMapper(); - _telemetry = Substitute.For(); - - AzureStorageEventStoreOptions azureStorageOptions = new() - { - ConnectionString = _azuriteConnectionString, - Table = TestHelpers.GenAzureTableName(RunId), - Container = TestHelpers.GenAzureBlobContainerName(RunId), - TimeoutInSeconds = 10, - RemoveDeletedFromCache = true, - }; - - TableEventStore eventStore = new( - eventNameMapper: _eventNameMapper, - azureStorageOptions: Microsoft.Extensions.Options.Options.Create(azureStorageOptions), - distributedCache: Substitute.For(), - aggregateChangeNotifier: Substitute.For>(), - eventStoreTelemetry: _telemetry, - aggregateRequirementsManager: Substitute.For() - ); - - TableClient = new(azureStorageOptions, eventStore.TableName); - BlobClient = new(azureStorageOptions, eventStore.ContainerName); - - return eventStore; - } -} diff --git a/src/tests/SharedTestingFramework/Properties/AssemblyInfo.cs b/src/tests/SharedTestingFramework/Properties/AssemblyInfo.cs index 68708388..a1be9612 100644 --- a/src/tests/SharedTestingFramework/Properties/AssemblyInfo.cs +++ b/src/tests/SharedTestingFramework/Properties/AssemblyInfo.cs @@ -1,10 +1,9 @@ using System.Runtime.CompilerServices; -[assembly: InternalsVisibleTo("EventSourcing.AzureStorage.IntegrationTests")] -[assembly: InternalsVisibleTo("EventSourcing.CosmosDb.IntegrationTests")] -[assembly: InternalsVisibleTo("EventSourcing.MongoDB.IntegrationTests")] -[assembly: InternalsVisibleTo("EventSourcing.SqlServer.IntegrationTests")] - +[assembly: InternalsVisibleTo("AzureStorage.IntegrationTests")] +[assembly: InternalsVisibleTo("CosmosDb.IntegrationTests")] +[assembly: InternalsVisibleTo("MongoDB.IntegrationTests")] +[assembly: InternalsVisibleTo("SqlServer.IntegrationTests")] [assembly: InternalsVisibleTo("EventSourcing.UnitTests")] -[assembly: InternalsVisibleTo("EventSourcing.Samples.UnitTests")] -[assembly: InternalsVisibleTo("EventSourcing.Samples.IntegrationTests")] +[assembly: InternalsVisibleTo("Samples.UnitTests")] +[assembly: InternalsVisibleTo("Samples.IntegrationTests")] diff --git a/src/tests/SharedTestingFramework/SharedTestingFramework.csproj b/src/tests/SharedTestingFramework/SharedTestingFramework.csproj index 23723e7d..254951ef 100644 --- a/src/tests/SharedTestingFramework/SharedTestingFramework.csproj +++ b/src/tests/SharedTestingFramework/SharedTestingFramework.csproj @@ -1,20 +1,26 @@  - - Purview.EventSourcing - - + - - - - + + + + + + + + diff --git a/src/tests/SharedTestingFramework/TestHelpers.cs b/src/tests/SharedTestingFramework/TestHelpers.cs index 8d7eba4d..1a827226 100644 --- a/src/tests/SharedTestingFramework/TestHelpers.cs +++ b/src/tests/SharedTestingFramework/TestHelpers.cs @@ -1,9 +1,24 @@ -using Purview.EventSourcing.Aggregates; +using Microsoft.Extensions.Caching.Distributed; +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.ChangeFeed; +using Purview.EventSourcing.SqlServer.Events; +using Purview.EventSourcing.SqlServer.Snapshots; namespace Purview.EventSourcing; public static class TestHelpers { + public static IDistributedCacheMock CreateDistributedCache() => IDistributedCache.Mock(); + + public static IAggregateChangeFeedNotifier_T_Mock CreateAggregateChangeFeedNotified() + where TAggregate : class, IAggregate, new() => IAggregateChangeFeedNotifier.Mock(); + + public static ISqlServerSnapshotEventStoreTelemetryMock CreateSqlServerSnapshotEventStoreTelemetry() => + ISqlServerSnapshotEventStoreTelemetry.Mock(); + + public static ISqlServerEventStoreTelemetryMock CreateISqlServerEventStoreTelemetry() => + ISqlServerEventStoreTelemetry.Mock(); + public static string GenName(Guid? value = null) { var guidString = Convert.ToBase64String((value ?? Guid.NewGuid()).ToByteArray()); @@ -57,12 +72,12 @@ public static CancellationTokenSource CancellationTokenSource( public static IServiceProvider ServiceProvider(params ServiceDefinition[] serviceDefinitions) { - var serviceProvider = Substitute.For(); + var serviceProvider = IServiceProvider.Mock(); if (serviceDefinitions != null) { foreach (var serviceDef in serviceDefinitions) { - serviceProvider.GetService(Arg.Is(serviceDef.ServiceType)).Returns(serviceDef.Instance); + serviceProvider.GetService(Is(serviceDef.ServiceType)).Returns(serviceDef.Instance); } } diff --git a/src/tests/EventSourcing.SourceGenerator.PerformanceTests/PerformanceHistoryStore.cs b/src/tests/SourceGenerator.PerformanceTests/PerformanceHistoryStore.cs similarity index 100% rename from src/tests/EventSourcing.SourceGenerator.PerformanceTests/PerformanceHistoryStore.cs rename to src/tests/SourceGenerator.PerformanceTests/PerformanceHistoryStore.cs diff --git a/src/tests/EventSourcing.SourceGenerator.PerformanceTests/PerformanceModels.cs b/src/tests/SourceGenerator.PerformanceTests/PerformanceModels.cs similarity index 100% rename from src/tests/EventSourcing.SourceGenerator.PerformanceTests/PerformanceModels.cs rename to src/tests/SourceGenerator.PerformanceTests/PerformanceModels.cs diff --git a/src/tests/SourceGenerator.PerformanceTests/Program.cs b/src/tests/SourceGenerator.PerformanceTests/Program.cs new file mode 100644 index 00000000..511f47ff --- /dev/null +++ b/src/tests/SourceGenerator.PerformanceTests/Program.cs @@ -0,0 +1,18 @@ +var runBenchmark = Array.Exists( + args, + static arg => string.Equals(arg, "--benchmark", StringComparison.OrdinalIgnoreCase) +); +var runner = new SourceGeneratorPerformanceRunner(); +var store = new PerformanceHistoryStore(); + +var previousRun = store.TryLoadLatest(); +var run = runBenchmark ? runner.RunBenchmark() : runner.RunQuick(); +var savedPath = store.Save(run); + +Console.WriteLine($"Saved {run.Mode} results to {savedPath}"); +Console.WriteLine(); + +foreach (var line in run.FormatSummary(previousRun)) + Console.WriteLine(line); + +return 0; diff --git a/src/tests/SourceGenerator.PerformanceTests/SourceGenerator.PerformanceTests.csproj b/src/tests/SourceGenerator.PerformanceTests/SourceGenerator.PerformanceTests.csproj new file mode 100644 index 00000000..7ff4f91f --- /dev/null +++ b/src/tests/SourceGenerator.PerformanceTests/SourceGenerator.PerformanceTests.csproj @@ -0,0 +1,11 @@ + + + false + + + + + + + + diff --git a/src/tests/EventSourcing.SourceGenerator.PerformanceTests/SourceGeneratorPerformanceRunner.cs b/src/tests/SourceGenerator.PerformanceTests/SourceGeneratorPerformanceRunner.cs similarity index 100% rename from src/tests/EventSourcing.SourceGenerator.PerformanceTests/SourceGeneratorPerformanceRunner.cs rename to src/tests/SourceGenerator.PerformanceTests/SourceGeneratorPerformanceRunner.cs diff --git a/src/tests/EventSourcing.SourceGenerator.PerformanceTests/SourceGeneratorPerformanceScenarios.cs b/src/tests/SourceGenerator.PerformanceTests/SourceGeneratorPerformanceScenarios.cs similarity index 100% rename from src/tests/EventSourcing.SourceGenerator.PerformanceTests/SourceGeneratorPerformanceScenarios.cs rename to src/tests/SourceGenerator.PerformanceTests/SourceGeneratorPerformanceScenarios.cs diff --git a/src/tests/EventSourcing.SourceGenerator.UnitTests/AggregateSourceGeneratorTests.cs b/src/tests/SourceGenerator.UnitTests/AggregateSourceGeneratorTests.cs similarity index 95% rename from src/tests/EventSourcing.SourceGenerator.UnitTests/AggregateSourceGeneratorTests.cs rename to src/tests/SourceGenerator.UnitTests/AggregateSourceGeneratorTests.cs index 37426cc7..ed1220e4 100644 --- a/src/tests/EventSourcing.SourceGenerator.UnitTests/AggregateSourceGeneratorTests.cs +++ b/src/tests/SourceGenerator.UnitTests/AggregateSourceGeneratorTests.cs @@ -338,6 +338,84 @@ public partial class ReportAggregate : Purview.EventSourcing.Aggregates.Aggregat await Assert.That(diagnostics.Select(static d => d.Id)).DoesNotContain("EVENTSTORE019"); } + [Test] + public async Task Generate_GivenScalarWrappingComplexValue_ReportsQueryTranslationWarning( + CancellationToken cancellationToken + ) + { + const string source = + @" +namespace Testing +{ + public sealed class ReportSummary + { + public int FailedLines { get; set; } + } + + [Purview.EventSourcing.Serialization.Scalar] + public readonly partial record struct ReportSummaryScalar + { + public ReportSummary Value { get; } + private ReportSummaryScalar(ReportSummary value) => Value = value; + } + + [Purview.EventSourcing.Aggregates.GenerateAggregate] + public partial class ReportAggregate : Purview.EventSourcing.Aggregates.AggregateBase + { + public ReportSummaryScalar Summary { get; private set; } + + [Purview.EventSourcing.Aggregates.GenerateAggregateEvent] + public partial void SetSummary(ReportSummary value); + } +} +"; + + var (result, _) = await GenerateAsync(source, cancellationToken); + var diagnostics = GetGeneratorDiagnostics(result); + + await Assert.That(diagnostics.Select(static d => d.Id)).Contains("EVENTSTORE020"); + await Assert + .That( + diagnostics + .First(static d => d.Id == "EVENTSTORE020") + .GetMessage(System.Globalization.CultureInfo.InvariantCulture) + ) + .Contains("Summary"); + } + + [Test] + public async Task Generate_GivenScalarWrappingPrimitiveValue_DoesNotReportQueryTranslationWarning( + CancellationToken cancellationToken + ) + { + const string source = + @" +namespace Testing +{ + [Purview.EventSourcing.Serialization.Scalar] + public readonly partial record struct ProjectId + { + public string Value { get; } + private ProjectId(string value) => Value = value; + } + + [Purview.EventSourcing.Aggregates.GenerateAggregate] + public partial class ReportAggregate : Purview.EventSourcing.Aggregates.AggregateBase + { + public ProjectId ProjectId { get; private set; } + + [Purview.EventSourcing.Aggregates.GenerateAggregateEvent] + public partial void SetProjectId(string projectId); + } +} +"; + + var (result, _) = await GenerateAsync(source, cancellationToken); + var diagnostics = GetGeneratorDiagnostics(result); + + await Assert.That(diagnostics.Select(static d => d.Id)).DoesNotContain("EVENTSTORE020"); + } + [Test] public async Task Generate_GivenComputedParameterWithOnlyOnComputingHook_DoesNotReportHookDiagnostics( CancellationToken cancellationToken @@ -1467,6 +1545,122 @@ public partial class OrderAggregate : Purview.EventSourcing.Aggregates.Aggregate await Assert.That(v1Index).IsLessThan(v2Index); } + [Test] + public async Task Generate_GivenEventWithNonPositiveVersion_ReportsVersionDiagnostic( + CancellationToken cancellationToken + ) + { + const string source = + @" +namespace Testing +{ + [Purview.EventSourcing.Aggregates.GenerateAggregate] + public partial class OrderAggregate : Purview.EventSourcing.Aggregates.AggregateBase + { + public string CustomerId { get; private set; } + + [Purview.EventSourcing.Aggregates.GenerateAggregateEvent(Version = 0)] + public partial void CreateOrder(string customerId); + } +} +"; + + var (result, _) = await GenerateAsync(source, cancellationToken); + var diagnostics = GetGeneratorDiagnostics(result); + + await Assert.That(diagnostics.Select(static d => d.Id)).Contains("EVENTSTORE021"); + } + + [Test] + public async Task Generate_GivenMultipleEventsWithDuplicateVersions_ReportsDuplicateVersionDiagnostic( + CancellationToken cancellationToken + ) + { + const string source = + @" +namespace Testing +{ + [Purview.EventSourcing.Aggregates.GenerateAggregate] + public partial class OrderAggregate : Purview.EventSourcing.Aggregates.AggregateBase + { + public string CustomerId { get; private set; } + public decimal Total { get; private set; } + + [Purview.EventSourcing.Aggregates.GenerateAggregateEvent(Version = 2)] + public partial void CreateOrder(string customerId); + + [Purview.EventSourcing.Aggregates.GenerateAggregateEvent(Version = 2)] + public partial void UpdateTotal(decimal total); + } +} +"; + + var (result, _) = await GenerateAsync(source, cancellationToken); + var diagnostics = GetGeneratorDiagnostics(result); + + await Assert.That(diagnostics.Select(static d => d.Id)).Contains("EVENTSTORE022"); + } + + [Test] + public async Task Generate_GivenExplicitVersionsWithGap_ReportsContiguousVersionDiagnostic( + CancellationToken cancellationToken + ) + { + const string source = + @" +namespace Testing +{ + [Purview.EventSourcing.Aggregates.GenerateAggregate] + public partial class OrderAggregate : Purview.EventSourcing.Aggregates.AggregateBase + { + public string CustomerId { get; private set; } + public decimal Total { get; private set; } + + [Purview.EventSourcing.Aggregates.GenerateAggregateEvent(Version = 1)] + public partial void CreateOrder(string customerId); + + [Purview.EventSourcing.Aggregates.GenerateAggregateEvent(Version = 3)] + public partial void UpdateTotal(decimal total); + } +} +"; + + var (result, _) = await GenerateAsync(source, cancellationToken); + var diagnostics = GetGeneratorDiagnostics(result); + + await Assert.That(diagnostics.Select(static d => d.Id)).Contains("EVENTSTORE023"); + } + + [Test] + public async Task Generate_GivenContiguousExplicitVersions_DoesNotReportContiguousVersionDiagnostic( + CancellationToken cancellationToken + ) + { + const string source = + @" +namespace Testing +{ + [Purview.EventSourcing.Aggregates.GenerateAggregate] + public partial class OrderAggregate : Purview.EventSourcing.Aggregates.AggregateBase + { + public string CustomerId { get; private set; } + public decimal Total { get; private set; } + + [Purview.EventSourcing.Aggregates.GenerateAggregateEvent(Version = 2)] + public partial void CreateOrder(string customerId); + + [Purview.EventSourcing.Aggregates.GenerateAggregateEvent(Version = 3)] + public partial void UpdateTotal(decimal total); + } +} +"; + + var (result, _) = await GenerateAsync(source, cancellationToken); + var diagnostics = GetGeneratorDiagnostics(result); + + await Assert.That(diagnostics.Select(static d => d.Id)).DoesNotContain("EVENTSTORE023"); + } + [Test] public async Task Generate_GivenVersionedEvent_GeneratedAttributeTemplateContainsVersionProperty( CancellationToken cancellationToken diff --git a/src/tests/EventSourcing.SourceGenerator.UnitTests/AggregateSourceGeneratorValueObjectTests.cs b/src/tests/SourceGenerator.UnitTests/AggregateSourceGeneratorValueObjectTests.cs similarity index 100% rename from src/tests/EventSourcing.SourceGenerator.UnitTests/AggregateSourceGeneratorValueObjectTests.cs rename to src/tests/SourceGenerator.UnitTests/AggregateSourceGeneratorValueObjectTests.cs diff --git a/src/tests/EventSourcing.SourceGenerator.UnitTests/EventNamingTests.cs b/src/tests/SourceGenerator.UnitTests/EventNamingTests.cs similarity index 100% rename from src/tests/EventSourcing.SourceGenerator.UnitTests/EventNamingTests.cs rename to src/tests/SourceGenerator.UnitTests/EventNamingTests.cs diff --git a/src/tests/EventSourcing.SourceGenerator.UnitTests/EventSourcing.SourceGenerator.UnitTests.csproj b/src/tests/SourceGenerator.UnitTests/SourceGenerator.UnitTests.csproj similarity index 100% rename from src/tests/EventSourcing.SourceGenerator.UnitTests/EventSourcing.SourceGenerator.UnitTests.csproj rename to src/tests/SourceGenerator.UnitTests/SourceGenerator.UnitTests.csproj diff --git a/src/tests/EventSourcing.SourceGenerator.UnitTests/SourceGeneratorTestBase.cs b/src/tests/SourceGenerator.UnitTests/SourceGeneratorTestBase.cs similarity index 98% rename from src/tests/EventSourcing.SourceGenerator.UnitTests/SourceGeneratorTestBase.cs rename to src/tests/SourceGenerator.UnitTests/SourceGeneratorTestBase.cs index 3bf46339..852f1877 100644 --- a/src/tests/EventSourcing.SourceGenerator.UnitTests/SourceGeneratorTestBase.cs +++ b/src/tests/SourceGenerator.UnitTests/SourceGeneratorTestBase.cs @@ -15,6 +15,7 @@ public abstract class SourceGeneratorTestBase(bool throwOnLogError = "GenerateAggregateAttribute.g.cs", "GenerateAggregateCollectionEventAttribute.g.cs", "GenerateAggregateDefaultsAttribute.g.cs", + "GenerateAggregateDefaultBaseAttribute.g.cs", "GenerateAggregateEventAttribute.g.cs", "MetadataAttribute.g.cs", "ComputedAttribute.g.cs", diff --git a/src/tests/EventSourcing.SourceGenerator.UnitTests/ValueObjectSourceGeneratorTests.cs b/src/tests/SourceGenerator.UnitTests/ValueObjectSourceGeneratorTests.cs similarity index 86% rename from src/tests/EventSourcing.SourceGenerator.UnitTests/ValueObjectSourceGeneratorTests.cs rename to src/tests/SourceGenerator.UnitTests/ValueObjectSourceGeneratorTests.cs index 5ed45372..25afce1b 100644 --- a/src/tests/EventSourcing.SourceGenerator.UnitTests/ValueObjectSourceGeneratorTests.cs +++ b/src/tests/SourceGenerator.UnitTests/ValueObjectSourceGeneratorTests.cs @@ -583,6 +583,38 @@ await Assert ); } + [Test] + public async Task ComplexValueObjectGeneration_PlainStructImplementsSelfEquatable( + CancellationToken cancellationToken + ) + { + const string source = """ + namespace Testing + { + [Purview.EventSourcing.Serialization.ValueObject] + public partial struct UserCaptureStruct + { + public UserDetails User { get; } + + public System.DateTimeOffset OccurredAt { get; } + } + + [Purview.EventSourcing.Serialization.ValueObject] + public partial class UserDetails(System.Guid id, string displayName); + } + """; + + var (result, _) = await GenerateAsync(source, cancellationToken); + var generatedSource = GetGeneratedSource(result); + + await Assert.That(generatedSource).Contains("global::System.IEquatable"); + + var assembly = await CompileToAssemblyAsync(source, cancellationToken); + var generatedType = assembly.GetType("Testing.UserCaptureStruct")!; + + await Assert.That(typeof(IEquatable<>).MakeGenericType(generatedType).IsAssignableFrom(generatedType)).IsTrue(); + } + [Test] public async Task ComplexValueObjectGeneration_WithoutProperties_GeneratesValidCreateAndJsonData( CancellationToken cancellationToken @@ -802,6 +834,9 @@ await Assert .Contains( "public static bool operator !=(global::Testing.ReportProcessingStatus left, global::Testing.ReportProcessingStatus right)" ); + await Assert + .That(generatedSource) + .Contains("global::System.IEquatable"); var assembly = await CompileToAssemblyAsync(source, cancellationToken); var harnessType = assembly.GetType("Testing.StatusHarness")!; @@ -1025,6 +1060,80 @@ public static int CompareUserDetails2() => await Assert.That(compareUserDetails2).IsEqualTo(-1); } + [Test] + public async Task ComplexValueObjectGeneration_GeneratesEfConstructorsForAllUserCaptureShapes( + CancellationToken cancellationToken + ) + { + const string source = """ + namespace Testing + { + [Purview.EventSourcing.Serialization.ValueObject] + public sealed partial record UserCaptureRecord(UserDetails User, System.DateTimeOffset OccurredAt); + + [Purview.EventSourcing.Serialization.ValueObject] + public partial record struct UserCaptureRecordStruct(UserDetails User, System.DateTimeOffset OccurredAt); + + [Purview.EventSourcing.Serialization.ValueObject] + public readonly partial record struct UserCaptureRecordStruct1(UserDetails User, System.DateTimeOffset OccurredAt); + + [Purview.EventSourcing.Serialization.ValueObject] + public sealed partial record class UserCaptureRecordClass(UserDetails User, System.DateTimeOffset OccurredAt); + + [Purview.EventSourcing.Serialization.ValueObject] + public sealed partial class UserCaptureClass(UserDetails User, System.DateTimeOffset OccurredAt); + + [Purview.EventSourcing.Serialization.ValueObject] + public partial struct UserCaptureStruct(UserDetails User, System.DateTimeOffset OccurredAt); + + [Purview.EventSourcing.Serialization.ValueObject] + public partial class UserDetails + { + public System.Guid Id { get; } + + public string DisplayName { get; } + } + + public static class UserCaptureHarness + { + public static object[] CreateAll() + { + var user = UserDetails.Create( + System.Guid.Parse("11111111-1111-1111-1111-111111111111"), + "Alice" + ); + + return + [ + UserCaptureRecord.Create(user, System.DateTimeOffset.UnixEpoch), + UserCaptureRecordStruct.Create(user, System.DateTimeOffset.UnixEpoch), + UserCaptureRecordStruct1.Create(user, System.DateTimeOffset.UnixEpoch), + UserCaptureRecordClass.Create(user, System.DateTimeOffset.UnixEpoch), + UserCaptureClass.Create(), + UserCaptureStruct.Create() + ]; + } + } + } + """; + + var (result, _) = await GenerateAsync(source, cancellationToken); + var generatedSource = GetGeneratedSource(result); + + await Assert.That(generatedSource).Contains("private UserCaptureRecord() : this(null!, default)"); + await Assert.That(generatedSource).Contains("public UserCaptureRecordStruct() : this(null!, default)"); + await Assert.That(generatedSource).Contains("public UserCaptureRecordStruct1() : this(null!, default)"); + await Assert.That(generatedSource).Contains("private UserCaptureRecordClass() : this(null!, default)"); + await Assert.That(generatedSource).Contains("private UserCaptureClass() : this(null!, default)"); + await Assert.That(generatedSource).Contains("public UserCaptureStruct() : this(null!, default)"); + + var assembly = await CompileToAssemblyAsync(source, cancellationToken); + var harnessType = assembly.GetType("Testing.UserCaptureHarness")!; + var created = (object[])harnessType.GetMethod("CreateAll")!.Invoke(null, null)!; + + await Assert.That(created.Length).IsEqualTo(6); + } + [Test] public async Task ComplexValueObjectGeneration_SupportsNormalizeHook(CancellationToken cancellationToken) { @@ -1094,4 +1203,62 @@ public static bool ActiveBlankDisplayNameThrows() await Assert.That(inactiveDisplayNameIsNull).IsTrue(); await Assert.That(activeBlankDisplayNameThrows).IsTrue(); } + + [Test] + public async Task ComplexValueObjectGeneration_RespectsReadOnlyOnValidateForStruct( + CancellationToken cancellationToken + ) + { + const string source = """ + namespace Testing + { + [Purview.EventSourcing.Serialization.ValueObject] + public partial record struct UserDetails(System.Guid Id, string? DisplayName, bool IsActive = true) + { + readonly partial void OnValidate(System.Guid id, string? displayName, bool isActive) + { + if (id == System.Guid.Empty) + throw new System.ArgumentException("Id must be a valid GUID.", nameof(id)); + + if (isActive && string.IsNullOrWhiteSpace(displayName)) + throw new System.ArgumentException( + "DisplayName cannot be null or empty when a user is active.", + nameof(displayName) + ); + } + } + + public static class UserDetailsReadOnlyHarness + { + public static bool ActiveBlankDisplayNameThrows() + { + try + { + _ = UserDetails.Create(System.Guid.Parse("11111111-1111-1111-1111-111111111111"), " ", true); + return false; + } + catch (System.ArgumentException) + { + return true; + } + } + } + } + """; + + var (result, _) = await GenerateAsync(source, cancellationToken); + var generatedSource = GetGeneratedSource(result); + + await Assert + .That(generatedSource) + .Contains("readonly partial void OnValidate(global::System.Guid id, string? displayName, bool isActive)"); + + var assembly = await CompileToAssemblyAsync(source, cancellationToken); + var harnessType = assembly.GetType("Testing.UserDetailsReadOnlyHarness")!; + + var activeBlankDisplayNameThrows = (bool) + harnessType.GetMethod("ActiveBlankDisplayNameThrows")!.Invoke(null, null)!; + + await Assert.That(activeBlankDisplayNameThrows).IsTrue(); + } } diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.DeleteAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.DeleteAsync.cs similarity index 83% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.DeleteAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.DeleteAsync.cs index 5baa9ded..27e7765f 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.DeleteAsync.cs +++ b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.DeleteAsync.cs @@ -1,5 +1,3 @@ -using Purview.EventSourcing.ChangeFeed; - namespace Purview.EventSourcing.SqlServer.Events; partial class GenericSqlServerEventStoreTests @@ -41,32 +39,37 @@ await eventStore.GetAsync(aggregateId, cancellationToken: cancellationToken) var result = await eventStore.DeleteAsync(aggregateResult, cancellationToken: cancellationToken); await Assert.That(result).IsTrue(); - await cache.Received(1).RemoveAsync(cacheKey, Arg.Any()); + cache.RemoveAsync(cacheKey, Any()).WasCalled(Times.Once); } public async Task DeleteAsync_GivenDelete_NotifiesChangeFeed(CancellationToken cancellationToken) { - var aggregateChangeNotifier = Substitute.For>(); + var aggregateChangeNotifier = TestHelpers.CreateAggregateChangeFeedNotified(); var beforeWasCalled = false; var afterWasCalled = false; var aggregateId = $"{Guid.NewGuid()}"; + var aggregate = TestHelpers.Aggregate(aggregateId: aggregateId); aggregate.IncrementInt32Value(); - var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); + + var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier.Object); + aggregateChangeNotifier - .When(m => m.BeforeDeleteAsync(aggregate, Arg.Any())) - .Do(_ => beforeWasCalled = true); + .BeforeDeleteAsync(aggregate, Any()) + .Callback(() => beforeWasCalled = true); aggregateChangeNotifier - .When(m => m.AfterDeleteAsync(aggregate, Arg.Any())) - .Do(_ => afterWasCalled = true); + .AfterDeleteAsync(aggregate, Any()) + .Callback(() => afterWasCalled = true); + await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); var result = await eventStore.DeleteAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(beforeWasCalled).IsTrue(); await Assert.That(afterWasCalled).IsTrue(); - await aggregateChangeNotifier.Received(1).BeforeDeleteAsync(aggregate, Arg.Any()); - await aggregateChangeNotifier.Received(1).AfterDeleteAsync(aggregate, Arg.Any()); + + aggregateChangeNotifier.BeforeDeleteAsync(aggregate, Any()).WasCalled(Times.Once); + aggregateChangeNotifier.AfterDeleteAsync(aggregate, Any()).WasCalled(Times.Once); } public async Task DeleteAsync_GivenAggregateExists_PermanentlyDeletesAllData(CancellationToken cancellationToken) diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.ExistsAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.ExistsAsync.cs similarity index 100% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.ExistsAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.ExistsAsync.cs diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAggregateIdsAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAggregateIdsAsync.cs similarity index 100% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAggregateIdsAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAggregateIdsAsync.cs diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAsync.cs similarity index 95% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAsync.cs index 691bc3b4..1e8add87 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAsync.cs +++ b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAsync.cs @@ -121,15 +121,15 @@ CancellationToken cancellationToken ); telemetry - .Received(numberOfOldEventsToCreate) .CannotApplyEvent( aggregateId, - Arg.Any(), - Arg.Any(), - Arg.Any(), - Arg.Is(eventType => eventType.Contains(typeof(OldEvent).Name, StringComparison.Ordinal)), - Arg.Any() - ); + Any(), + Any(), + Any(), + Is(eventType => eventType!.Contains(typeof(OldEvent).Name, StringComparison.Ordinal)), + Any() + ) + .WasCalled(Times.Exactly(numberOfOldEventsToCreate)); await Assert.That(result).IsNotNull(); await Assert.That(result.IsNew()).IsFalse(); @@ -199,8 +199,8 @@ await client.UpsertAsync( ); telemetry - .Received(numberOfOldEventsToCreate) - .SkippedUnknownEvent(aggregateId, Arg.Any(), Arg.Any(), unknownEventType, Arg.Any()); + .SkippedUnknownEvent(aggregateId, Any(), Any(), unknownEventType, Any()) + .WasCalled(Times.Exactly(numberOfOldEventsToCreate)); await Assert.That(result).IsNotNull(); await Assert.That(result.IsNew()).IsFalse(); diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAtAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAtAsync.cs similarity index 100% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAtAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetAtAsync.cs diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetDeletedAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetDeletedAsync.cs similarity index 100% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetDeletedAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetDeletedAsync.cs diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetEventRangeAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetEventRangeAsync.cs similarity index 100% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetEventRangeAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetEventRangeAsync.cs diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetOrCreateAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetOrCreateAsync.cs similarity index 100% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetOrCreateAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.GetOrCreateAsync.cs diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.IsDeletedAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.IsDeletedAsync.cs similarity index 100% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.IsDeletedAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.IsDeletedAsync.cs diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.RestoreAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.RestoreAsync.cs similarity index 100% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.RestoreAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.RestoreAsync.cs diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync.cs similarity index 97% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync.cs index add8dea6..1ecef455 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync.cs +++ b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync.cs @@ -52,7 +52,7 @@ public async Task SaveAsync_GivenAggregateWithNoChanges_DoesNotSave(Cancellation bool result = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(result).IsFalse(); - telemetry.Received(1).SaveContainedNoChanges(aggregateId, Arg.Any(), Arg.Any()); + telemetry.SaveContainedNoChanges(aggregateId, Any(), Any()).WasCalled(Times.Once); } public async Task SaveAsync_GivenNewAggregateWithChanges_SavesAggregate(CancellationToken cancellationToken) diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync_Notify.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync_Notify.cs similarity index 56% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync_Notify.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync_Notify.cs index 2a9cb9d7..f2a932e4 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync_Notify.cs +++ b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.SaveAsync_Notify.cs @@ -1,5 +1,4 @@ using Purview.EventSourcing.Aggregates.Events; -using Purview.EventSourcing.ChangeFeed; namespace Purview.EventSourcing.SqlServer.Events; @@ -10,7 +9,7 @@ public async Task SaveAsync_GivenAggregateWithChanges_NotifiesChangeFeed( CancellationToken cancellationToken ) { - var aggregateChangeNotifier = Substitute.For>(); + var aggregateChangeNotifier = TestHelpers.CreateAggregateChangeFeedNotified(); var beforeWasCalled = false; var afterWasCalled = false; var aggregateId = $"{Guid.NewGuid()}"; @@ -21,13 +20,11 @@ CancellationToken cancellationToken var eventStore = fixture.CreateEventStore(aggregateChangeNotifier: aggregateChangeNotifier); aggregateChangeNotifier - .When(m => m.BeforeSaveAsync(aggregate, true, Arg.Any())) - .Do(_ => beforeWasCalled = true); + .BeforeSaveAsync(aggregate, true, Any()) + .Callback(() => beforeWasCalled = true); aggregateChangeNotifier - .When(m => - m.AfterSaveAsync(aggregate, Arg.Any(), true, Arg.Any(), Arg.Any()) - ) - .Do(_ => afterWasCalled = true); + .AfterSaveAsync(aggregate, Any(), true, Any(), Any()) + .Callback(() => afterWasCalled = true); var result = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); @@ -35,15 +32,15 @@ CancellationToken cancellationToken await Assert.That(beforeWasCalled).IsTrue(); await Assert.That(afterWasCalled).IsTrue(); - await aggregateChangeNotifier.Received(1).BeforeSaveAsync(aggregate, true, Arg.Any()); - await aggregateChangeNotifier - .Received(1) - .AfterSaveAsync(aggregate, Arg.Any(), true, Arg.Any(), Arg.Any()); + aggregateChangeNotifier.BeforeSaveAsync(aggregate, true, Any()).WasCalled(Times.Once); + aggregateChangeNotifier + .AfterSaveAsync(aggregate, Any(), true, Any(), Any()) + .WasCalled(Times.Once); } public async Task SaveAsync_GivenAggregateWithNoChanges_DoesNotNotifyChangeFeed(CancellationToken cancellationToken) { - var aggregateChangeNotifier = Substitute.For>(); + var aggregateChangeNotifier = TestHelpers.CreateAggregateChangeFeedNotified(); var aggregateId = $"{Guid.NewGuid()}"; var aggregate = TestHelpers.Aggregate(aggregateId: aggregateId); @@ -53,17 +50,11 @@ public async Task SaveAsync_GivenAggregateWithNoChanges_DoesNotNotifyChangeFeed( await Assert.That(result.Saved).IsFalse(); - await aggregateChangeNotifier - .DidNotReceive() - .BeforeSaveAsync(Arg.Any(), Arg.Any(), Arg.Any()); - await aggregateChangeNotifier - .DidNotReceive() - .AfterSaveAsync( - Arg.Any(), - Arg.Any(), - Arg.Any(), - Arg.Any(), - Arg.Any() - ); + aggregateChangeNotifier + .BeforeSaveAsync(Any(), Any(), Any()) + .WasNeverCalled(); + aggregateChangeNotifier + .AfterSaveAsync(Any(), Any(), Any(), Any(), Any()) + .WasNeverCalled(); } } diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.cs b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.cs similarity index 98% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.cs rename to src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.cs index dd8b665b..b52e770e 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.cs +++ b/src/tests/SqlServer.IntegrationTests/Events/GenericSqlServerEventStoreTests.cs @@ -4,7 +4,7 @@ namespace Purview.EventSourcing.SqlServer.Events; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public partial class GenericSqlServerEventStoreTests(SqlServerEventStoreFixture fixture) : ISqlServerEventStoreTests where TAggregate : class, IAggregateTest, new() diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/ISqlServerEventStoreTests.cs b/src/tests/SqlServer.IntegrationTests/Events/ISqlServerEventStoreTests.cs similarity index 100% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/ISqlServerEventStoreTests.cs rename to src/tests/SqlServer.IntegrationTests/Events/ISqlServerEventStoreTests.cs diff --git a/src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.IndexCreation.cs b/src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.IndexCreation.cs new file mode 100644 index 00000000..708aa104 --- /dev/null +++ b/src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.IndexCreation.cs @@ -0,0 +1,217 @@ +using System.Globalization; +using Microsoft.Data.SqlClient; +using Purview.EventSourcing.Aggregates.Persistence; + +namespace Purview.EventSourcing.SqlServer.Events; + +partial class SqlServerEventStoreTests +{ + [Test] + public async Task SaveAsync_GivenDefaultIndexes_CreatesCoreIndexesWithQueryAlignedKeyColumns( + CancellationToken cancellationToken + ) + { + var runId = Guid.NewGuid(); + var tableName = $"EventStoreEvents_{runId:N}"; + var aggregateLookupIndexName = $"IX_{tableName}_AggregateId_EntityType"; + var eventRangeIndexName = $"IX_{tableName}_EventRange"; + + var store = fixture.CreateEventStore(runId: runId); + var aggregate = await store.CreateAsync($"agg_{Guid.NewGuid():N}", cancellationToken); + aggregate.AppendString("core-index-shape"); + + var saved = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); + + await Assert.That(saved.Saved).IsTrue(); + + var aggregateLookupKeyColumns = await GetIndexKeyColumnsAsync( + fixture.ConnectionString, + tableName, + aggregateLookupIndexName, + cancellationToken + ); + var eventRangeKeyColumns = await GetIndexKeyColumnsAsync( + fixture.ConnectionString, + tableName, + eventRangeIndexName, + cancellationToken + ); + var eventRangeIncludeColumns = await GetIndexIncludeColumnsAsync( + fixture.ConnectionString, + tableName, + eventRangeIndexName, + cancellationToken + ); + + await Assert + .That(string.Join(',', aggregateLookupKeyColumns)) + .IsEqualTo("AggregateId,AggregateType,EntityType"); + await Assert.That(string.Join(',', eventRangeKeyColumns)).IsEqualTo("AggregateId,AggregateType,Version"); + await Assert + .That(string.Join(',', eventRangeIncludeColumns)) + .IsEqualTo("Payload,EventType,IdempotencyId,Timestamp"); + } + + [Test] + public async Task SaveAsync_GivenConfiguredJsonIndex_CreatesEventComputedColumnAndIndex( + CancellationToken cancellationToken + ) + { + var runId = Guid.NewGuid(); + var tableName = $"EventStoreEvents_{runId:N}"; + const string indexName = "IX_Event_Value"; + const string computedColumnName = "Json_Value"; + var store = fixture.CreateEventStore( + runId: runId, + configureOptions: options => + options.JsonIndexOptions = new SqlServerJsonIndexOptions + { + Enabled = true, + Indexes = + [ + new SqlServerJsonIndexDefinition + { + JsonPath = "$.Value", + ComputedColumnName = computedColumnName, + IndexName = indexName, + IncludeColumns = ["AggregateId", "Version"], + Filter = "[EntityType] = 1", + }, + ], + } + ); + + var aggregate = await store.CreateAsync($"agg_{Guid.NewGuid():N}", cancellationToken); + aggregate.AppendString("event-json-index"); + + var saved = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); + + await Assert.That(saved.Saved).IsTrue(); + await Assert + .That(await ColumnExistsAsync(fixture.ConnectionString, tableName, computedColumnName, cancellationToken)) + .IsTrue(); + await Assert + .That(await IndexExistsAsync(fixture.ConnectionString, tableName, indexName, cancellationToken)) + .IsTrue(); + } + + static async Task ColumnExistsAsync( + string connectionString, + string tableName, + string columnName, + CancellationToken cancellationToken + ) + { + await using var connection = new SqlConnection(connectionString); + await connection.OpenAsync(cancellationToken); + await using var command = new SqlCommand( + """ + SELECT COUNT(1) + FROM sys.columns c + INNER JOIN sys.tables t ON t.object_id = c.object_id + INNER JOIN sys.schemas s ON s.schema_id = t.schema_id + WHERE s.name = 'dbo' AND t.name = @tableName AND c.name = @columnName; + """, + connection + ); + command.Parameters.AddWithValue("@tableName", tableName); + command.Parameters.AddWithValue("@columnName", columnName); + return Convert.ToInt32(await command.ExecuteScalarAsync(cancellationToken), CultureInfo.InvariantCulture) > 0; + } + + static async Task IndexExistsAsync( + string connectionString, + string tableName, + string indexName, + CancellationToken cancellationToken + ) + { + await using var connection = new SqlConnection(connectionString); + await connection.OpenAsync(cancellationToken); + await using var command = new SqlCommand( + """ + SELECT COUNT(1) + FROM sys.indexes i + INNER JOIN sys.tables t ON t.object_id = i.object_id + INNER JOIN sys.schemas s ON s.schema_id = t.schema_id + WHERE s.name = 'dbo' AND t.name = @tableName AND i.name = @indexName; + """, + connection + ); + command.Parameters.AddWithValue("@tableName", tableName); + command.Parameters.AddWithValue("@indexName", indexName); + return Convert.ToInt32(await command.ExecuteScalarAsync(cancellationToken), CultureInfo.InvariantCulture) > 0; + } + + static async Task> GetIndexKeyColumnsAsync( + string connectionString, + string tableName, + string indexName, + CancellationToken cancellationToken + ) + { + await using var connection = new SqlConnection(connectionString); + await connection.OpenAsync(cancellationToken); + await using var command = new SqlCommand( + """ + SELECT c.name + FROM sys.indexes i + INNER JOIN sys.tables t ON t.object_id = i.object_id + INNER JOIN sys.schemas s ON s.schema_id = t.schema_id + INNER JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id + INNER JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id + WHERE s.name = 'dbo' + AND t.name = @tableName + AND i.name = @indexName + AND ic.is_included_column = 0 + ORDER BY ic.key_ordinal; + """, + connection + ); + command.Parameters.AddWithValue("@tableName", tableName); + command.Parameters.AddWithValue("@indexName", indexName); + + var result = new List(); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + while (await reader.ReadAsync(cancellationToken)) + result.Add(reader.GetString(0)); + + return result; + } + + static async Task> GetIndexIncludeColumnsAsync( + string connectionString, + string tableName, + string indexName, + CancellationToken cancellationToken + ) + { + await using var connection = new SqlConnection(connectionString); + await connection.OpenAsync(cancellationToken); + await using var command = new SqlCommand( + """ + SELECT c.name + FROM sys.indexes i + INNER JOIN sys.tables t ON t.object_id = i.object_id + INNER JOIN sys.schemas s ON s.schema_id = t.schema_id + INNER JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id + INNER JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id + WHERE s.name = 'dbo' + AND t.name = @tableName + AND i.name = @indexName + AND ic.is_included_column = 1 + ORDER BY ic.index_column_id; + """, + connection + ); + command.Parameters.AddWithValue("@tableName", tableName); + command.Parameters.AddWithValue("@indexName", indexName); + + var result = new List(); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + while (await reader.ReadAsync(cancellationToken)) + result.Add(reader.GetString(0)); + + return result; + } +} diff --git a/src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.TestData.cs b/src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.TestData.cs new file mode 100644 index 00000000..80545bd8 --- /dev/null +++ b/src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.TestData.cs @@ -0,0 +1,105 @@ +namespace Purview.EventSourcing.SqlServer.Events; + +partial class SqlServerEventStoreTests +{ + public static IEnumerable> TooManyEventCountTestData() + { + foreach (var aggregateType in GetAggregateTypes()) + { + yield return () => (aggregateType, 1_001); + yield return () => (aggregateType, 10_000); + yield return () => (aggregateType, 100_000); + } + } + + public static IEnumerable> SteppedAggregateCountWithDeletedAggregateIdCountTestData() + { + foreach (var aggregateType in GetAggregateTypes()) + { + yield return () => (aggregateType, 1, 1); + yield return () => (aggregateType, 1, 10); + yield return () => (aggregateType, 5, 5); + yield return () => (aggregateType, 5, 10); + yield return () => (aggregateType, 10, 10); + yield return () => (aggregateType, 10, 20); + yield return () => (aggregateType, 20, 20); + yield return () => (aggregateType, 20, 40); + } + } + + public static IEnumerable> RequestedRangeOfEventsTestData() + { + foreach (var aggregateType in GetAggregateTypes()) + { + yield return () => (aggregateType, 5, 1, 5); + yield return () => (aggregateType, 5, 1, null); + yield return () => (aggregateType, 10, 2, 5); + yield return () => (aggregateType, 10, 2, null); + yield return () => (aggregateType, 15, 15, null); + yield return () => (aggregateType, 15, 15, 15); + yield return () => (aggregateType, 5, 1, 20); + yield return () => (aggregateType, 5, 1, 20000); + } + } + + public static IEnumerable> RequestedRangeOfEventsWithExpectedEventCountTestData() + { + foreach (var aggregateType in GetAggregateTypes()) + { + yield return () => (aggregateType, 5, 1, 5, 5); + yield return () => (aggregateType, 5, 1, null, 5); + yield return () => (aggregateType, 10, 2, 5, 4); + yield return () => (aggregateType, 10, 2, null, 9); + yield return () => (aggregateType, 15, 15, null, 1); + yield return () => (aggregateType, 15, 15, 15, 1); + yield return () => (aggregateType, 5, 1, 20, 5); + yield return () => (aggregateType, 5, 1, 20000, 5); + } + } + + public static IEnumerable> SteppedCountTestData() + { + foreach (var aggregateType in GetAggregateTypes()) + { + yield return () => (aggregateType, 1); + yield return () => (aggregateType, 10); + yield return () => (aggregateType, 20); + yield return () => (aggregateType, 50); + } + } + + public static IEnumerable> SteppedEventCountWithOldEventCountTestData() + { + foreach (var aggregateType in GetAggregateTypes()) + { + yield return () => (aggregateType, 1, 1); + yield return () => (aggregateType, 5, 2); + yield return () => (aggregateType, 10, 5); + yield return () => (aggregateType, 20, 20); + } + } + + public static IEnumerable> SnapshotEventCountTestData() + { + foreach (var aggregateType in GetAggregateTypes()) + { + yield return () => (aggregateType, 10); + yield return () => (aggregateType, 20); + yield return () => (aggregateType, 50); + yield return () => (aggregateType, 80); + yield return () => (aggregateType, 100); + } + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1024:Use properties where appropriate")] + public static IEnumerable GetAggregateTypes() + { + yield return typeof(Aggregates.Persistence.PersistenceAggregate); + } + + internal ISqlServerEventStoreTests CreateSqlServerStoreTests(Type aggregateType) + { + var testType = typeof(GenericSqlServerEventStoreTests<>).MakeGenericType(aggregateType); + return (ISqlServerEventStoreTests)Activator.CreateInstance(testType, args: [fixture])!; + } +} diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.cs b/src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.cs similarity index 93% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.cs rename to src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.cs index 549ed30b..315e5717 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.cs +++ b/src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTests.cs @@ -2,11 +2,11 @@ namespace Purview.EventSourcing.SqlServer.Events; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public sealed partial class SqlServerEventStoreTests(SqlServerEventStoreFixture fixture) { [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task DeleteAsync_GivenAggregateExists_PermanentlyDeletesAllData( Type aggregateType, CancellationToken cancellationToken @@ -17,7 +17,7 @@ CancellationToken cancellationToken } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task DeleteAsync_GivenDelete_NotifiesChangeFeed( Type aggregateType, CancellationToken cancellationToken @@ -28,7 +28,7 @@ CancellationToken cancellationToken } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task DeleteAsync_GivenPreviouslySavedAggregate_MarksAsDeleted( Type aggregateType, CancellationToken cancellationToken @@ -39,7 +39,7 @@ CancellationToken cancellationToken } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task DeleteAsync_WhenTableStoreConfigRemoveDeletedFromCacheIsTrueAndPreviouslySavedAggregate_RemovesFromCache( Type aggregateType, CancellationToken cancellationToken @@ -101,7 +101,7 @@ await tests.GetAggregateIdsAsync_GivenNonDeletedAggregatesAndDeletedAggregatesIn } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task GetAsync_GivenAggregateIsDeletedAndDeletedModeIsSetToThrow_ThrowsEventStoreAggregateDeletedException( Type aggregateType, CancellationToken cancellationToken @@ -193,7 +193,7 @@ await tests.GetAtAsync_GivenAnAggregateWithSavedEvents_RecreatesAggregateToPrevi } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task GetDeletedAsync_GivenDeletedAggregate_ReturnsAggregate( Type aggregateType, CancellationToken cancellationToken @@ -244,7 +244,7 @@ await tests.GetEventRangeAsync_GivenARequestedRangeOfEvents_GetsEventsRequested( } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task GetOrCreateAsync_GivenAggregateDoesNotExist_CreatesNewAggregate( Type aggregateType, CancellationToken cancellationToken @@ -255,7 +255,7 @@ CancellationToken cancellationToken } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task IsDeletedAsync_GivenDeletedAggregates_ReturnsTrue( Type aggregateType, CancellationToken cancellationToken @@ -266,7 +266,7 @@ CancellationToken cancellationToken } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task IsDeletedAsync_GivenNonDeletedAggregates_ReturnsFalse( Type aggregateType, CancellationToken cancellationToken @@ -277,7 +277,7 @@ CancellationToken cancellationToken } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task RestoreAsync_GivenPreviouslySavedAndDeletedAggregate_MarksAsNotDeleted( Type aggregateType, CancellationToken cancellationToken @@ -300,7 +300,7 @@ CancellationToken cancellationToken } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task SaveAsync_GivenAggregateWithDataAnnotationsAndInvalidProperties_NoChangesAreMadeAndNotSaved( Type aggregateType, CancellationToken cancellationToken @@ -313,7 +313,7 @@ await tests.SaveAsync_GivenAggregateWithDataAnnotationsAndInvalidProperties_NoCh } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task SaveAsync_GivenAggregateWithNoChanges_DoesNotNotifyChangeFeed( Type aggregateType, CancellationToken cancellationToken @@ -324,7 +324,7 @@ CancellationToken cancellationToken } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task SaveAsync_GivenAggregateWithNoChanges_DoesNotSave( Type aggregateType, CancellationToken cancellationToken @@ -335,7 +335,7 @@ CancellationToken cancellationToken } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task SaveAsync_GivenNewAggregateWithChanges_SavesAggregate( Type aggregateType, CancellationToken cancellationToken @@ -346,7 +346,7 @@ CancellationToken cancellationToken } [Test] - [MethodDataSource(nameof(GetAggregateTestTypes))] + [MethodDataSource(nameof(GetAggregateTypes))] public async Task SaveAsync_GivenAggregateWithComplexProperty_SavesEventWithComplexProperty( Type aggregateType, CancellationToken cancellationToken diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTransactionIntegrationTests.cs b/src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTransactionIntegrationTests.cs similarity index 57% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTransactionIntegrationTests.cs rename to src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTransactionIntegrationTests.cs index 1236ed77..db412574 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Events/SqlServerEventStoreTransactionIntegrationTests.cs +++ b/src/tests/SqlServer.IntegrationTests/Events/SqlServerEventStoreTransactionIntegrationTests.cs @@ -2,13 +2,16 @@ using System.Text.RegularExpressions; using Microsoft.Data.SqlClient; using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Options; using Purview.EventSourcing.Aggregates.Persistence; using Purview.EventSourcing.Fixtures.SqlServer; +using Purview.EventSourcing.SqlServer.Snapshot; +using Purview.EventSourcing.SqlServer.Snapshots; namespace Purview.EventSourcing.SqlServer.Events; -[ClassDataSource(Shared = SharedType.PerAssembly)] -public sealed class SqlServerEventStoreTransactionIntegrationTests(SqlServerEventStoreFixture fixture) +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed partial class SqlServerEventStoreTransactionIntegrationTests(SqlServerEventStoreFixture fixture) { [Test] public async Task CommitAsync_GivenEnlistedRawSqlOperation_CommitsAggregateAndRawSqlTogether( @@ -71,7 +74,7 @@ CancellationToken cancellationToken var factory = new SqlServerEventStoreTransactionFactory(new FixedCorrelationIdProvider("sql-ef")); await using var transaction = factory.CreateSqlServerTransaction(); transaction.Enlist(aggregate, eventStore); - transaction.Enlist( + transaction.Enlist( connection => new TransactionAuditDbContext(connection, tableName), async (dbContext, token) => { @@ -136,6 +139,113 @@ CancellationToken cancellationToken await Assert.That(rowCount).IsEqualTo(0); } + [Test] + public async Task CommitAsync_GivenMultipleCrossImplementationStoresAndRawSql_CommitsAllInSingleTransaction( + CancellationToken cancellationToken + ) + { + var runId = Guid.NewGuid(); + var primaryStore = fixture.CreateEventStore(runId: runId); + var snapshotStore = CreateSnapshotStore(runId); + var firstAggregateId = $"{Guid.NewGuid():N}"; + var secondAggregateId = $"{Guid.NewGuid():N}"; + var tableName = $"TransactionAudit_{Guid.NewGuid():N}"; + + await EnsureAuditTableExistsAsync(fixture.ConnectionString, tableName, cancellationToken); + + var firstAggregate = await primaryStore.CreateAsync(firstAggregateId, cancellationToken); + firstAggregate.AppendString("primary"); + + var secondAggregate = await snapshotStore.CreateAsync(secondAggregateId, cancellationToken); + secondAggregate.AppendString("snapshot"); + + var factory = new SqlServerEventStoreTransactionFactory(new FixedCorrelationIdProvider("sql-cross")); + await using var transaction = factory.CreateSqlServerTransaction(); + transaction.Enlist(firstAggregate, primaryStore); + transaction.Enlist(secondAggregate, snapshotStore); + transaction.Enlist( + async (connection, sqlTransaction, token) => + { + var quotedTableName = QuoteTableName(tableName); +#pragma warning disable CA2100 + await using var command = new SqlCommand( + $"INSERT INTO {quotedTableName} ([CorrelationId], [Value]) VALUES (@correlationId, @value)", + connection, + sqlTransaction + ); +#pragma warning restore CA2100 + command.Parameters.AddWithValue("@correlationId", "sql-cross"); + command.Parameters.AddWithValue("@value", "cross"); + await command.ExecuteNonQueryAsync(token); + } + ); + + var result = await transaction.CommitAsync(cancellationToken); + var savedFirst = await primaryStore.GetAsync(firstAggregateId, null, cancellationToken); + var savedSecond = await snapshotStore.GetAsync(secondAggregateId, null, cancellationToken); + var rowCount = await GetAuditRowCountAsync(fixture.ConnectionString, tableName, cancellationToken); + + await Assert.That(result.Success).IsTrue(); + await Assert.That(savedFirst).IsNotNull(); + await Assert.That(savedFirst!.StringProperty).Contains("primary"); + await Assert.That(savedSecond).IsNotNull(); + await Assert.That(savedSecond!.StringProperty).Contains("snapshot"); + await Assert.That(rowCount).IsEqualTo(1); + } + + [Test] + public async Task CommitAsync_GivenMultipleCrossImplementationStoresAndFailingRawSql_RollsBackAllChanges( + CancellationToken cancellationToken + ) + { + var runId = Guid.NewGuid(); + var primaryStore = fixture.CreateEventStore(runId: runId); + var snapshotStore = CreateSnapshotStore(runId); + var firstAggregateId = $"{Guid.NewGuid():N}"; + var secondAggregateId = $"{Guid.NewGuid():N}"; + var tableName = $"TransactionAudit_{Guid.NewGuid():N}"; + + await EnsureAuditTableExistsAsync(fixture.ConnectionString, tableName, cancellationToken); + + var firstAggregate = await primaryStore.CreateAsync(firstAggregateId, cancellationToken); + firstAggregate.AppendString("primary-rollback"); + + var secondAggregate = await snapshotStore.CreateAsync(secondAggregateId, cancellationToken); + secondAggregate.AppendString("snapshot-rollback"); + + var factory = new SqlServerEventStoreTransactionFactory(new FixedCorrelationIdProvider("sql-cross-rollback")); + await using var transaction = factory.CreateSqlServerTransaction(); + transaction.Enlist(firstAggregate, primaryStore); + transaction.Enlist(secondAggregate, snapshotStore); + transaction.Enlist( + async (connection, sqlTransaction, token) => + { + var quotedTableName = QuoteTableName(tableName); +#pragma warning disable CA2100 + await using var command = new SqlCommand( + $"INSERT INTO {quotedTableName} ([CorrelationId], [Value]) VALUES (@correlationId, @value)", + connection, + sqlTransaction + ); +#pragma warning restore CA2100 + command.Parameters.AddWithValue("@correlationId", "sql-cross-rollback"); + command.Parameters.AddWithValue("@value", "cross-rollback"); + await command.ExecuteNonQueryAsync(token); + throw new InvalidOperationException("forced-cross-failure"); + } + ); + + var result = await transaction.CommitAsync(cancellationToken); + var savedFirst = await primaryStore.GetAsync(firstAggregateId, null, cancellationToken); + var savedSecond = await snapshotStore.GetAsync(secondAggregateId, null, cancellationToken); + var rowCount = await GetAuditRowCountAsync(fixture.ConnectionString, tableName, cancellationToken); + + await Assert.That(result.Success).IsFalse(); + await Assert.That(savedFirst).IsNull(); + await Assert.That(savedSecond).IsNull(); + await Assert.That(rowCount).IsEqualTo(0); + } + static async Task EnsureAuditTableExistsAsync( string connectionString, string tableName, @@ -183,10 +293,9 @@ CancellationToken cancellationToken static string QuoteTableName(string tableName) { - if (!Regex.IsMatch(tableName, "^[A-Za-z0-9_]+$", RegexOptions.CultureInvariant)) - throw new ArgumentException("Audit table name contains unsupported characters.", nameof(tableName)); - - return $"[dbo].[{tableName}]"; + return AzureTableNameRegEx().IsMatch(tableName) + ? $"[dbo].[{tableName}]" + : throw new ArgumentException("Audit table name contains unsupported characters.", nameof(tableName)); } sealed class FixedCorrelationIdProvider(string correlationId) : IEventStoreCorrelationIdProvider @@ -221,4 +330,25 @@ sealed class TransactionAuditEntry public string CorrelationId { get; set; } = string.Empty; public string Value { get; set; } = string.Empty; } + + [GeneratedRegex("^[A-Za-z0-9_]+$", RegexOptions.CultureInvariant)] + private static partial Regex AzureTableNameRegEx(); + + SqlServerSnapshotEventStore CreateSnapshotStore(Guid runId) + { + var backingStore = fixture.CreateEventStore(runId: runId); + var options = new SqlServerSnapshotEventStoreOptions + { + ConnectionString = fixture.ConnectionString, + TableName = $"EventStoreSnapshots_{runId:N}", + SchemaName = "dbo", + AutoCreateTable = true, + }; + + return new SqlServerSnapshotEventStore( + backingStore, + Options.Create(options), + Purview.EventSourcing.TestHelpers.CreateSqlServerSnapshotEventStoreTelemetry() + ); + } } diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/CustomerAggregateSnapshotEventStoreTests.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/CustomerAggregateSnapshotEventStoreTests.cs similarity index 55% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/CustomerAggregateSnapshotEventStoreTests.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/CustomerAggregateSnapshotEventStoreTests.cs index 86f188db..75e6617c 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/CustomerAggregateSnapshotEventStoreTests.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/CustomerAggregateSnapshotEventStoreTests.cs @@ -1,12 +1,9 @@ -using Microsoft.Extensions.Options; using Purview.EventSourcing.Fixtures.SqlServer; -using Purview.EventSourcing.Internal; using Purview.EventSourcing.Samples.Domain; -using Purview.EventSourcing.SqlServer.Snapshot; namespace Purview.EventSourcing.SqlServer.Snapshots; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class CustomerAggregateSnapshotEventStoreTests(SqlServerSnapshotEventStoreFixture fixture) { [Test] @@ -14,30 +11,12 @@ public async Task SnapshotAsync_GivenCustomerAggregateWithEmailAddress_QueriesBy CancellationToken cancellationToken ) { - var context = fixture.CreateContext(tableName: $"Snapshots_{Guid.NewGuid():N}"); + var store = fixture.CreateSnapshotStore(); var email = "updated@test.com"; var aggregate = new CustomerAggregate(); aggregate.Details.Id = Guid.NewGuid().ToString("D"); aggregate.RegisterCustomer("Jane Smith", "jane@test.com"); aggregate.ChangeEmail(email); - var innerEventStore = Substitute.For>(); - innerEventStore - .FulfilRequirements(Arg.Any()) - .Returns(callInfo => callInfo.Arg()); - - var store = new SqlServerSnapshotEventStore( - innerEventStore, - Options.Create( - new SqlServerSnapshotEventStoreOptions - { - ConnectionString = context.SqlServerConnectionString, - TableName = $"Snapshots_{Guid.NewGuid():N}", - SchemaName = "dbo", - AutoCreateTable = true, - } - ), - Substitute.For() - ); await store.SnapshotAsync(aggregate, cancellationToken); @@ -54,26 +33,7 @@ CancellationToken cancellationToken [Test] public async Task QueryAsync_GivenOrderByScalarValueObject_TranslatesAndOrders(CancellationToken cancellationToken) { - var context = fixture.CreateContext(tableName: $"Snapshots_{Guid.NewGuid():N}"); - var innerEventStore = Substitute.For>(); - innerEventStore - .FulfilRequirements(Arg.Any()) - .Returns(callInfo => callInfo.Arg()); - - var store = new SqlServerSnapshotEventStore( - innerEventStore, - Options.Create( - new SqlServerSnapshotEventStoreOptions - { - ConnectionString = context.SqlServerConnectionString, - TableName = $"Snapshots_{Guid.NewGuid():N}", - SchemaName = "dbo", - AutoCreateTable = true, - } - ), - Substitute.For() - ); - + var store = fixture.CreateSnapshotStore(); var charlie = new CustomerAggregate { Details = { Id = Guid.NewGuid().ToString("D") } }; charlie.RegisterCustomer("Charlie", "charlie@test.com"); await store.SnapshotAsync(charlie, cancellationToken); @@ -97,26 +57,7 @@ public async Task QueryAsync_GivenOrderByScalarValueObject_TranslatesAndOrders(C [Test] public async Task QueryAsync_GivenOrderByScalarInnerValue_FailsWithClearMessage(CancellationToken cancellationToken) { - var context = fixture.CreateContext(tableName: $"Snapshots_{Guid.NewGuid():N}"); - var innerEventStore = Substitute.For>(); - innerEventStore - .FulfilRequirements(Arg.Any()) - .Returns(callInfo => callInfo.Arg()); - - var store = new SqlServerSnapshotEventStore( - innerEventStore, - Options.Create( - new SqlServerSnapshotEventStoreOptions - { - ConnectionString = context.SqlServerConnectionString, - TableName = $"Snapshots_{Guid.NewGuid():N}", - SchemaName = "dbo", - AutoCreateTable = true, - } - ), - Substitute.For() - ); - + var store = fixture.CreateSnapshotStore(); var customer = new CustomerAggregate { Details = { Id = Guid.NewGuid().ToString("D") } }; customer.RegisterCustomer("Zed", "zed@test.com"); await store.SnapshotAsync(customer, cancellationToken); diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/OrderAggregateSnapshotEventStoreTests.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/OrderAggregateSnapshotEventStoreTests.cs similarity index 62% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/OrderAggregateSnapshotEventStoreTests.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/OrderAggregateSnapshotEventStoreTests.cs index c7ddbd17..d71416a7 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/OrderAggregateSnapshotEventStoreTests.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/OrderAggregateSnapshotEventStoreTests.cs @@ -1,12 +1,9 @@ -using Microsoft.Extensions.Options; using Purview.EventSourcing.Fixtures.SqlServer; -using Purview.EventSourcing.Internal; using Purview.EventSourcing.Samples.Domain; -using Purview.EventSourcing.SqlServer.Snapshot; namespace Purview.EventSourcing.SqlServer.Snapshots; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class OrderAggregateSnapshotEventStoreTests(SqlServerSnapshotEventStoreFixture fixture) { [Test] @@ -14,7 +11,7 @@ public async Task SnapshotAsync_GivenOrderAggregateWithLineItems_QueriesByLineIt CancellationToken cancellationToken ) { - var context = fixture.CreateContext(tableName: $"Snapshots_{Guid.NewGuid():N}"); + var store = fixture.CreateSnapshotStore(); var id = Guid.NewGuid().ToString("D"); var aggregate = new OrderAggregate(); @@ -24,25 +21,6 @@ CancellationToken cancellationToken .AddLineItem("prod-1", "Widget A", 2, 29.99m) .AddLineItem("prod-2", "Widget B", 1, 49.99m); - var innerEventStore = Substitute.For>(); - innerEventStore - .FulfilRequirements(Arg.Any()) - .Returns(callInfo => callInfo.Arg()); - - var store = new SqlServerSnapshotEventStore( - innerEventStore, - Options.Create( - new SqlServerSnapshotEventStoreOptions - { - ConnectionString = context.SqlServerConnectionString, - TableName = $"Snapshots_{Guid.NewGuid():N}", - SchemaName = "dbo", - AutoCreateTable = true, - } - ), - Substitute.For() - ); - await store.SnapshotAsync(aggregate, cancellationToken); var count = await store.CountAsync( @@ -67,7 +45,7 @@ public async Task SnapshotAsync_GivenOrderAggregateWithLineItems_QueriesAndResto CancellationToken cancellationToken ) { - var context = fixture.CreateContext(tableName: $"Snapshots_{Guid.NewGuid():N}"); + var store = fixture.CreateSnapshotStore(); var id = Guid.NewGuid().ToString("D"); var aggregate = new OrderAggregate(); @@ -77,25 +55,6 @@ CancellationToken cancellationToken .AddLineItem("prod-1", "Widget A", 2, 29.99m) .AddLineItem("prod-2", "Widget B", 1, 49.99m); - var innerEventStore = Substitute.For>(); - innerEventStore - .FulfilRequirements(Arg.Any()) - .Returns(callInfo => callInfo.Arg()); - - var store = new SqlServerSnapshotEventStore( - innerEventStore, - Options.Create( - new SqlServerSnapshotEventStoreOptions - { - ConnectionString = context.SqlServerConnectionString, - TableName = $"Snapshots_{Guid.NewGuid():N}", - SchemaName = "dbo", - AutoCreateTable = true, - } - ), - Substitute.For() - ); - await store.SnapshotAsync(aggregate, cancellationToken); var count = await store.CountAsync(m => m.CustomerId == "customer-1", cancellationToken); diff --git a/src/tests/SqlServer.IntegrationTests/Snapshots/ReportUploadAggregateSnapshotEventStoreTests.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/ReportUploadAggregateSnapshotEventStoreTests.cs new file mode 100644 index 00000000..507bd1d5 --- /dev/null +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/ReportUploadAggregateSnapshotEventStoreTests.cs @@ -0,0 +1,136 @@ +using Purview.EventSourcing.Fixtures.SqlServer; +using Purview.EventSourcing.Samples.Domain.ReportUpload; +using Purview.EventSourcing.Samples.ValueObjects; + +namespace Purview.EventSourcing.SqlServer.Snapshots; + +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class ReportUploadAggregateSnapshotEventStoreTests(SqlServerSnapshotEventStoreFixture fixture) +{ + static readonly Faker Faker = new(); + + static ReportSummary CreateReportSummary() => + ReportSummary.Create( + new() + { + AssetDetails = new AssetDetails( + new Dictionary + { + { PlatformID.Win32NT, Faker.Random.Int(1, 100) }, + { PlatformID.Unix, Faker.Random.Int(1, 100) }, + { PlatformID.Other, Faker.Random.Int(1, 100) }, + } + ), + ParserDetails = new(10, 5, 5, TimeSpan.FromMinutes(1)), + Projects = Faker.Make(2, i => new Project($"Project {i + 1}", $"{i + 1}", $"Team {i + 1}")), + VulnerabilityDetails = new VulnerabilityDetails(100, 10, 10, 20, 30, 40), + } + ); + + static ReportUploadAggregate CreateCompletedAggregate(string id, ReportSummary? reportSummary = null) => + TestHelpers.Aggregate( + id, + agg => + agg.Create( + "a-file-name.json", + "213123", + BlobUri.Create(new Uri("/a/path/to/the/original/json", UriKind.Relative)), + UserCapture.Create( + UserDetails.Create(Guid.NewGuid(), "Testing Account", true), + DateTimeOffset.UtcNow + ) + ) + .AddExcelReport( + GuidObjectId.Create(Guid.NewGuid()), + BlobUri.Create(new Uri("/a/path/to/an/object", UriKind.Relative)) + ) + .MarkAsComplete(reportSummary ?? CreateReportSummary()), + clearEvents: false + ); + + [Test] + public async Task SnapshotAsync_GivenReportUploadAggregateWithLineItems_QueriesByLineItemCount( + CancellationToken cancellationToken + ) + { + var store = fixture.CreateSnapshotStore(); + var id = Guid.NewGuid().ToString("D"); + var aggregate = CreateCompletedAggregate(id); + + await store.SaveAsync(aggregate, cancellationToken); + + var restored = await store.GetAsync(id, cancellationToken: cancellationToken); + + await Assert.That(restored).IsNotNull(); + await Assert.That(restored!.ReportSummary).IsNotNull(); + await Assert.That(restored.ReportSummaryScalar).IsNotNull(); + await Assert.That(restored.ReportSummary!.Value.ParserDetails.TotalLines).IsEqualTo(10); + await Assert.That(restored.ReportSummary.Value.ParserDetails.FailedLines).IsEqualTo(5); + await Assert.That(restored.ReportSummary.Value.Projects.Count()).IsEqualTo(2); + await Assert.That(restored.ReportSummaryScalar!.ParserDetails.TotalLines).IsEqualTo(10); + await Assert.That(restored.ReportSummaryScalar.ParserDetails.FailedLines).IsEqualTo(5); + await Assert.That(restored.ReportSummaryScalar.Projects.Count()).IsEqualTo(2); + + var translatableQuery = await store.QueryAsync( + a => a.ReportSummaryScalar!.ParserDetails.FailedLines > 0, + cancellationToken: cancellationToken + ); + + await Assert.That(translatableQuery.Results).Count().IsEqualTo(1); + await Assert.That(translatableQuery.Results[0].Id()).IsEqualTo(id); + await Assert.That(translatableQuery.Results[0].ReportSummaryScalar).IsNotNull(); + await Assert.That(translatableQuery.Results[0].ReportSummaryScalar!.ParserDetails.FailedLines).IsEqualTo(5); + } + + [Test] + public async Task QueryAsync_GivenFilterOnReportSummaryScalarInnerValue_Translates( + CancellationToken cancellationToken + ) + { + var store = fixture.CreateSnapshotStore(); + var id = Guid.NewGuid().ToString("D"); + var aggregate = CreateCompletedAggregate(id); + + await store.SaveAsync(aggregate, cancellationToken); + + var query = await store.QueryAsync( + a => a.ReportSummaryScalar!.ParserDetails.FailedLines > 0, + cancellationToken: cancellationToken + ); + + await Assert.That(query.Results).Count().IsEqualTo(1); + await Assert.That(query.Results[0].Id()).IsEqualTo(id); + await Assert.That(query.Results[0].ReportSummaryScalar).IsNotNull(); + await Assert.That(query.Results[0].ReportSummaryScalar!.ParserDetails.FailedLines).IsEqualTo(5); + } + + [Test] + public async Task QueryAsync_GivenFilterOnComplexScalarValueInnerMember_ThrowsButMirrorPropertyTranslates( + CancellationToken cancellationToken + ) + { + var store = fixture.CreateSnapshotStore(); + var id = Guid.NewGuid().ToString("D"); + var aggregate = CreateCompletedAggregate(id); + + await store.SaveAsync(aggregate, cancellationToken); + + async Task?> UnsupportedAct() => + await store.QueryAsync( + a => a.ReportSummary!.Value.ParserDetails.FailedLines > 0, + cancellationToken: cancellationToken + ); + + var unsupportedException = await Assert.That(UnsupportedAct).Throws(); + await Assert.That(unsupportedException).IsNotNull(); + await Assert.That(unsupportedException!.Message).Contains("could not be translated"); + + var supportedQuery = await store.QueryAsync( + a => a.ReportSummaryScalar!.ParserDetails.FailedLines > 0, + cancellationToken: cancellationToken + ); + + await Assert.That(supportedQuery.Results).Count().IsEqualTo(1); + await Assert.That(supportedQuery.Results[0].Id()).IsEqualTo(id); + } +} diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.DeleteAsync.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.DeleteAsync.cs similarity index 58% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.DeleteAsync.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.DeleteAsync.cs index 5ef1e37b..e6ccc17b 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.DeleteAsync.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.DeleteAsync.cs @@ -10,26 +10,28 @@ CancellationToken cancellationToken ) { // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); var aggregateId = Guid.NewGuid().ToString(); var aggregate = CreateAggregate(id: aggregateId); aggregate.IncrementInt32Value(); - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); - var aggregateFromSqlServer = await context.SqlServerClient.GetByIdAsync( + var aggregateFromSqlServer = await store.GetAsync( aggregateId, + new EventStoreOperationContext { SnapshotCacheMode = SnapshotCachingOptions.None }, cancellationToken: cancellationToken ); await Assert.That(aggregateFromSqlServer).IsNotNull(); // Act - var deleteResult = await context.EventStore.DeleteAsync(aggregate, cancellationToken: cancellationToken); + var deleteResult = await store.DeleteAsync(aggregate, cancellationToken: cancellationToken); - aggregateFromSqlServer = await context.SqlServerClient.GetByIdAsync( + aggregateFromSqlServer = await store.GetAsync( aggregateId, + new EventStoreOperationContext { SnapshotCacheMode = SnapshotCachingOptions.None }, cancellationToken: cancellationToken ); diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.ExpandedSample.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.ExpandedSample.cs similarity index 71% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.ExpandedSample.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.ExpandedSample.cs index 07a92cad..a9505c9a 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.ExpandedSample.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.ExpandedSample.cs @@ -17,23 +17,25 @@ CancellationToken cancellationToken const int numberOfEvents = 5; // Arrange - var context = fixture.CreateContext(correlationIdsToGenerate: numberOfAggregates); - - var eventStore = context.EventStore; + var store = fixture.CreateSnapshotStore(); for (var aggregateIndex = 0; aggregateIndex < numberOfAggregates; aggregateIndex++) { - var aggregate = CreateAggregate($"{aggregateIndex}_{context.RunId}"); + var aggregate = CreateAggregate($"agg_{aggregateIndex}"); for (var eventIndex = 0; eventIndex < numberOfEvents; eventIndex++) aggregate.IncrementInt32Value(); - bool saveResult = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync( + aggregate, + operationContext: new() { CorrelationId = $"{Guid.NewGuid()}" }, + cancellationToken: cancellationToken + ); await Assert.That(saveResult).IsTrue(); } // Act - var count = await eventStore.CountAsync( + var count = await store.CountAsync( m => m.IncrementInt32 == numberOfEvents, cancellationToken: cancellationToken ); @@ -46,19 +48,16 @@ CancellationToken cancellationToken public async Task CountAsync_GivenNoMatchingAggregates_ReturnsZero(CancellationToken cancellationToken) { // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); var aggregate = CreateAggregate(); aggregate.IncrementInt32Value(); - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); // Act - var count = await context.EventStore.CountAsync( - m => m.IncrementInt32 == -1, - cancellationToken: cancellationToken - ); + var count = await store.CountAsync(m => m.IncrementInt32 == -1, cancellationToken: cancellationToken); // Assert await Assert.That(count).IsEqualTo(0); @@ -76,25 +75,27 @@ CancellationToken cancellationToken const int numberOfEvents = 5; // Arrange - var context = fixture.CreateContext(correlationIdsToGenerate: numberOfAggregates); - - var eventStore = context.EventStore; + var store = fixture.CreateSnapshotStore(); for (var aggregateIndex = 0; aggregateIndex < numberOfAggregates; aggregateIndex++) { - var aggregate = CreateAggregate($"{aggregateIndex}_{context.RunId}"); + var aggregate = CreateAggregate($"agg_{aggregateIndex}"); for (var eventIndex = 0; eventIndex < numberOfEvents; eventIndex++) aggregate.IncrementInt32Value(); - bool saveResult = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync( + aggregate, + new EventStoreOperationContext() { CorrelationId = $"{Guid.NewGuid()}" }, + cancellationToken: cancellationToken + ); await Assert.That(saveResult).IsTrue(); } // Act List aggregates = []; await foreach ( - var aggregate in eventStore.GetQueryEnumerableAsync( + var aggregate in store.GetQueryEnumerableAsync( m => m.IncrementInt32 == numberOfEvents, cancellationToken: cancellationToken ) @@ -117,24 +118,26 @@ CancellationToken cancellationToken const int numberOfEvents = 5; // Arrange - var context = fixture.CreateContext(correlationIdsToGenerate: numberOfAggregates); - - var eventStore = context.EventStore; + var store = fixture.CreateSnapshotStore(); for (var aggregateIndex = 0; aggregateIndex < numberOfAggregates; aggregateIndex++) { - var aggregate = CreateAggregate($"{aggregateIndex}_{context.RunId}"); + var aggregate = CreateAggregate($"agg_{aggregateIndex}"); for (var eventIndex = 0; eventIndex < numberOfEvents; eventIndex++) aggregate.IncrementInt32Value(); - bool saveResult = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync( + aggregate, + new EventStoreOperationContext() { CorrelationId = $"{Guid.NewGuid()}" }, + cancellationToken: cancellationToken + ); await Assert.That(saveResult).IsTrue(); } // Act List aggregates = []; - await foreach (var aggregate in eventStore.GetListEnumerableAsync(cancellationToken: cancellationToken)) + await foreach (var aggregate in store.GetListEnumerableAsync(cancellationToken: cancellationToken)) aggregates.Add(aggregate); // Assert @@ -147,7 +150,7 @@ CancellationToken cancellationToken ) { // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); var aggregateId = Guid.NewGuid().ToString(); var aggregate = CreateAggregate(id: aggregateId); @@ -170,16 +173,18 @@ CancellationToken cancellationToken ); // Act - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync( + aggregate, + new EventStoreOperationContext() { CorrelationId = $"{Guid.NewGuid()}" }, + cancellationToken: cancellationToken + ); // Assert await Assert.That(saveResult).IsTrue(); // Verify via direct SQL Server read - var fromDb = await context.SqlServerClient.GetByIdAsync( - aggregateId, - cancellationToken: cancellationToken - ); + var fromDb = await store.GetAsync(aggregateId, cancellationToken: cancellationToken); + await Assert.That(fromDb).IsNotNull(); await Assert.That(fromDb.IncrementInt32).IsEqualTo(3); await Assert.That(fromDb.Int32Value).IsEqualTo(42); @@ -191,10 +196,7 @@ CancellationToken cancellationToken await Assert.That(fromDb.ComplexTestType.StringProperty).IsEqualTo("complex-test"); // Also verify via LINQ query - var queried = await context.EventStore.SingleOrDefaultAsync( - m => m.Int32Value == 42, - cancellationToken: cancellationToken - ); + var queried = await store.SingleOrDefaultAsync(m => m.Int32Value == 42, cancellationToken: cancellationToken); await Assert.That(queried).IsNotNull(); await Assert.That(queried!.Id()).IsEqualTo(aggregateId); await Assert.That(queried.ComplexTestType).IsNotNull(); @@ -205,13 +207,17 @@ CancellationToken cancellationToken public async Task SaveAsync_GivenMultipleSavesOfSameAggregate_UpdatesSnapshot(CancellationToken cancellationToken) { // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); var aggregateId = Guid.NewGuid().ToString(); var aggregate = CreateAggregate(id: aggregateId); aggregate.IncrementInt32Value(); - bool firstSave = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool firstSave = await store.SaveAsync( + aggregate, + new EventStoreOperationContext() { CorrelationId = $"{Guid.NewGuid()}" }, + cancellationToken: cancellationToken + ); await Assert.That(firstSave).IsTrue(); var firstVersion = aggregate.Details.CurrentVersion; @@ -220,14 +226,15 @@ public async Task SaveAsync_GivenMultipleSavesOfSameAggregate_UpdatesSnapshot(Ca aggregate.IncrementInt32Value(); aggregate.SetInt32Value(99); - bool secondSave = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool secondSave = await store.SaveAsync( + aggregate, + new EventStoreOperationContext() { CorrelationId = $"{Guid.NewGuid()}" }, + cancellationToken: cancellationToken + ); await Assert.That(secondSave).IsTrue(); // Act - Read from SQL Server - var fromDb = await context.SqlServerClient.GetByIdAsync( - aggregateId, - cancellationToken: cancellationToken - ); + var fromDb = await store.GetAsync(aggregateId, cancellationToken: cancellationToken); // Assert - Should have the latest state await Assert.That(fromDb).IsNotNull(); diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.FirstOrDefaultAsync.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.FirstOrDefaultAsync.cs similarity index 72% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.FirstOrDefaultAsync.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.FirstOrDefaultAsync.cs index de049d1f..9fbb9f36 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.FirstOrDefaultAsync.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.FirstOrDefaultAsync.cs @@ -1,4 +1,6 @@ -namespace Purview.EventSourcing.SqlServer.Snapshots; +using Purview.EventSourcing.Aggregates.Persistence; + +namespace Purview.EventSourcing.SqlServer.Snapshots; partial class SqlServerSnapshotEventStoreTests { @@ -11,7 +13,7 @@ CancellationToken cancellationToken const int matchingIncrement = 10; // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); for (var i = 0; i < aggregateCount; i++) { @@ -21,13 +23,17 @@ CancellationToken cancellationToken aggregate.SetInt32Value(i + 1); - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync( + aggregate, + new EventStoreOperationContext() { CorrelationId = $"{Guid.NewGuid()}" }, + cancellationToken: cancellationToken + ); await Assert.That(saveResult).IsTrue(); } // Act - var result = await context.EventStore.FirstOrDefaultAsync( + var result = await store.FirstOrDefaultAsync( m => m.IncrementInt32 == matchingIncrement, orderByClause: m => m.OrderByDescending(p => p.Int32Value), cancellationToken: cancellationToken @@ -47,7 +53,7 @@ CancellationToken cancellationToken const int matchingIncrement = 10; // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); for (var i = 0; i < aggregateCount; i++) { @@ -57,13 +63,13 @@ CancellationToken cancellationToken aggregate.SetInt32Value(i + 1); - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); } // Act - var result = await context.EventStore.FirstOrDefaultAsync( + var result = await store.FirstOrDefaultAsync( m => m.IncrementInt32 == matchingIncrement, orderByClause: m => m.OrderBy(p => p.Int32Value), cancellationToken: cancellationToken @@ -83,7 +89,7 @@ CancellationToken cancellationToken const int matchingIncrement = 10; // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); for (var i = 0; i < aggregateCount; i++) { @@ -93,14 +99,14 @@ CancellationToken cancellationToken aggregate.IncrementInt32Value(); } - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); } // Act async Task Func() => - await context.EventStore.FirstOrDefaultAsync( + await store.FirstOrDefaultAsync( m => m.IncrementInt32 == matchingIncrement, cancellationToken: cancellationToken ); @@ -117,7 +123,7 @@ CancellationToken cancellationToken const int matchingIncrement = 10; // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); for (var i = 0; i < 10; i++) { @@ -125,13 +131,13 @@ CancellationToken cancellationToken for (var x = 0; x < matchingIncrement; x++) aggregate.IncrementInt32Value(); - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); } // Act - var result = await context.EventStore.FirstOrDefaultAsync( + var result = await store.FirstOrDefaultAsync( m => m.IncrementInt32 == matchingIncrement, cancellationToken: cancellationToken ); @@ -148,19 +154,19 @@ CancellationToken cancellationToken const int matchingIncrement = 10; // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); var aggregateId = Guid.NewGuid().ToString(); var aggregate = CreateAggregate(id: aggregateId); for (var x = 0; x < matchingIncrement; x++) aggregate.IncrementInt32Value(); - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); // Act - var result = await context.EventStore.FirstOrDefaultAsync( + var result = await store.FirstOrDefaultAsync( m => m.IncrementInt32 == matchingIncrement, cancellationToken: cancellationToken ); @@ -176,7 +182,7 @@ public async Task FirstOrDefaultAsync_GivenNoMatchingAggregates_ReturnsNull(Canc const int matchingIncrement = 10; // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); for (var i = 0; i < 10; i++) { @@ -184,16 +190,13 @@ public async Task FirstOrDefaultAsync_GivenNoMatchingAggregates_ReturnsNull(Canc for (var x = 0; x < matchingIncrement; x++) aggregate.IncrementInt32Value(); - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); } // Act - var result = await context.EventStore.FirstOrDefaultAsync( - m => m.IncrementInt32 == -1, - cancellationToken: cancellationToken - ); + var result = await store.FirstOrDefaultAsync(m => m.IncrementInt32 == -1, cancellationToken: cancellationToken); // Assert await Assert.That(result).IsNull(); diff --git a/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.IndexCreation.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.IndexCreation.cs new file mode 100644 index 00000000..42b62a26 --- /dev/null +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.IndexCreation.cs @@ -0,0 +1,97 @@ +using System.Globalization; +using Microsoft.Data.SqlClient; +using Purview.EventSourcing.Aggregates.Persistence; + +namespace Purview.EventSourcing.SqlServer.Snapshots; + +partial class SqlServerSnapshotEventStoreTests +{ + [Test] + public async Task SaveAsync_GivenConfiguredJsonIndex_CreatesSnapshotComputedColumnAndIndex( + CancellationToken cancellationToken + ) + { + var runId = Guid.NewGuid(); + var tableName = $"EventStoreSnapshots_{runId:N}"; + const string indexName = "IX_Snapshot_StringProperty"; + const string computedColumnName = "Json_StringProperty"; + var store = fixture.CreateSnapshotStore( + runId: runId, + configureOptions: options => + options.JsonIndexOptions = new SqlServerJsonIndexOptions + { + Enabled = true, + Indexes = + [ + new SqlServerJsonIndexDefinition + { + JsonPath = "$.StringProperty", + ComputedColumnName = computedColumnName, + IndexName = indexName, + IncludeColumns = ["Id"], + }, + ], + } + ); + + var aggregate = CreateAggregate($"agg_{Guid.NewGuid():N}", static x => x.AppendString("snapshot-json-index")); + + var saved = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); + + await Assert.That(saved.Saved).IsTrue(); + await Assert + .That(await ColumnExistsAsync(fixture.ConnectionString, tableName, computedColumnName, cancellationToken)) + .IsTrue(); + await Assert + .That(await IndexExistsAsync(fixture.ConnectionString, tableName, indexName, cancellationToken)) + .IsTrue(); + } + + static async Task ColumnExistsAsync( + string connectionString, + string tableName, + string columnName, + CancellationToken cancellationToken + ) + { + await using var connection = new SqlConnection(connectionString); + await connection.OpenAsync(cancellationToken); + await using var command = new SqlCommand( + """ + SELECT COUNT(1) + FROM sys.columns c + INNER JOIN sys.tables t ON t.object_id = c.object_id + INNER JOIN sys.schemas s ON s.schema_id = t.schema_id + WHERE s.name = 'dbo' AND t.name = @tableName AND c.name = @columnName; + """, + connection + ); + command.Parameters.AddWithValue("@tableName", tableName); + command.Parameters.AddWithValue("@columnName", columnName); + return Convert.ToInt32(await command.ExecuteScalarAsync(cancellationToken), CultureInfo.InvariantCulture) > 0; + } + + static async Task IndexExistsAsync( + string connectionString, + string tableName, + string indexName, + CancellationToken cancellationToken + ) + { + await using var connection = new SqlConnection(connectionString); + await connection.OpenAsync(cancellationToken); + await using var command = new SqlCommand( + """ + SELECT COUNT(1) + FROM sys.indexes i + INNER JOIN sys.tables t ON t.object_id = i.object_id + INNER JOIN sys.schemas s ON s.schema_id = t.schema_id + WHERE s.name = 'dbo' AND t.name = @tableName AND i.name = @indexName; + """, + connection + ); + command.Parameters.AddWithValue("@tableName", tableName); + command.Parameters.AddWithValue("@indexName", indexName); + return Convert.ToInt32(await command.ExecuteScalarAsync(cancellationToken), CultureInfo.InvariantCulture) > 0; + } +} diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryAsync.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryAsync.cs similarity index 66% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryAsync.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryAsync.cs index 994c7721..48f746a7 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryAsync.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryAsync.cs @@ -1,4 +1,6 @@ -namespace Purview.EventSourcing.SqlServer.Snapshots; +using Purview.EventSourcing.Aggregates.Persistence; + +namespace Purview.EventSourcing.SqlServer.Snapshots; partial class SqlServerSnapshotEventStoreTests { @@ -19,25 +21,23 @@ CancellationToken cancellationToken ) { // Arrange - var context = fixture.CreateContext(correlationIdsToGenerate: numberOfAggregates); - - var eventStore = context.EventStore; + var store = fixture.CreateSnapshotStore(); for (var aggregateIndex = 0; aggregateIndex < numberOfAggregates; aggregateIndex++) { - var aggregate = CreateAggregate($"{aggregateIndex}_{context.RunId}"); + var aggregate = CreateAggregate($"agg_{aggregateIndex}"); for (var eventIndex = 0; eventIndex < numberOfEvents; eventIndex++) aggregate.IncrementInt32Value(); - bool saveResult = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); } // Act var aggregates = ( - await eventStore.QueryAsync(m => m.IncrementInt32 == numberOfEvents, cancellationToken: cancellationToken) + await store.QueryAsync(m => m.IncrementInt32 == numberOfEvents, cancellationToken: cancellationToken) ).Results; // Assert @@ -54,23 +54,23 @@ CancellationToken cancellationToken ) { // Arrange - var context = fixture.CreateContext(correlationIdsToGenerate: numberOfAggregates); + var store = fixture.CreateSnapshotStore(); var aggregateType = CreateAggregate().AggregateType; for (var aggregateIndex = 0; aggregateIndex < numberOfAggregates; aggregateIndex++) { - var aggregate = CreateAggregate($"{aggregateIndex}_{context.RunId}"); + var aggregate = CreateAggregate($"agg_{aggregateIndex}"); aggregate.IncrementInt32Value(); - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); } // Act var aggregates = ( - await context.EventStore.QueryAsync( + await store.QueryAsync( m => m.AggregateType == aggregateType, maxRecordCount: numberOfAggregates + 1, cancellationToken: cancellationToken diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryWithContinuationAsync.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryWithContinuationAsync.cs similarity index 71% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryWithContinuationAsync.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryWithContinuationAsync.cs index 4fc991f1..0698b2e6 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryWithContinuationAsync.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.QueryWithContinuationAsync.cs @@ -22,18 +22,15 @@ CancellationToken cancellationToken const int numberOfEvents = 10; // Arrange - var context = fixture.CreateContext(correlationIdsToGenerate: numberOfAggregates); - - var eventStore = context.EventStore; - + var store = fixture.CreateSnapshotStore(); for (var aggregateIndex = 0; aggregateIndex < numberOfAggregates; aggregateIndex++) { - var aggregate = CreateAggregate($"{aggregateIndex}_{context.RunId}"); + var aggregate = CreateAggregate($"agg_{aggregateIndex}"); for (var eventIndex = 0; eventIndex < numberOfEvents; eventIndex++) aggregate.IncrementInt32Value(); - bool saveResult = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); } @@ -41,15 +38,12 @@ CancellationToken cancellationToken // Act List aggregates = []; - var aggregateResponse = await eventStore.ListAsync( - maxRecordCount: pageCount, - cancellationToken: cancellationToken - ); + var aggregateResponse = await store.ListAsync(maxRecordCount: pageCount, cancellationToken: cancellationToken); aggregates.AddRange(aggregateResponse.Results); while (aggregateResponse.ContinuationToken != null) { - aggregateResponse = await eventStore.ListAsync( + aggregateResponse = await store.ListAsync( aggregateResponse.ToRequest(), cancellationToken: cancellationToken ); @@ -77,17 +71,16 @@ CancellationToken cancellationToken const int numberOfEvents = 10; // Arrange - var context = fixture.CreateContext(correlationIdsToGenerate: numberOfAggregates * 2); - var eventStore = context.EventStore; + var store = fixture.CreateSnapshotStore(); // These are matching. for (var aggregateIndex = 0; aggregateIndex < numberOfAggregates; aggregateIndex++) { - var aggregate = CreateAggregate($"{aggregateIndex}_{context.RunId}"); + var aggregate = CreateAggregate($"agg_{aggregateIndex}"); for (var eventIndex = 0; eventIndex < numberOfEvents; eventIndex++) aggregate.IncrementInt32Value(); - bool saveResult = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); } @@ -95,13 +88,13 @@ CancellationToken cancellationToken // These are non-matching. for (var aggregateIndex = 0; aggregateIndex < numberOfAggregates; aggregateIndex++) { - var aggregate = CreateAggregate($"{aggregateIndex + (numberOfAggregates + 100000)}_{context.RunId}"); + var aggregate = CreateAggregate($"agg_{aggregateIndex + (numberOfAggregates + 100000)}"); // We're changing the event count so as to make the query not match these updated records. for (var eventIndex = 0; eventIndex < (numberOfEvents * 2); eventIndex++) aggregate.IncrementInt32Value(); - bool saveResult = await eventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); } @@ -111,7 +104,7 @@ CancellationToken cancellationToken Expression> query = a => a.IncrementInt32 == numberOfEvents; - var aggregateResponse = await eventStore.QueryAsync( + var aggregateResponse = await store.QueryAsync( query, maxRecordCount: pageCount, cancellationToken: cancellationToken @@ -120,7 +113,7 @@ CancellationToken cancellationToken while (aggregateResponse.ContinuationToken != null) { - aggregateResponse = await eventStore.QueryAsync( + aggregateResponse = await store.QueryAsync( query, aggregateResponse.ToRequest(), cancellationToken: cancellationToken diff --git a/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.RestoreAsync.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.RestoreAsync.cs new file mode 100644 index 00000000..67012629 --- /dev/null +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.RestoreAsync.cs @@ -0,0 +1,40 @@ +using Purview.EventSourcing.Aggregates.Persistence; + +namespace Purview.EventSourcing.SqlServer.Snapshots; + +partial class SqlServerSnapshotEventStoreTests +{ + [Test] + public async Task RestoreAsync_GivenExistingAggregateMarkedAsDeletedAndDoesNotExistInSqlServerWhenRestore_SnapshotCreatedInSqlServer( + CancellationToken cancellationToken + ) + { + // Arrange + var store = fixture.CreateSnapshotStore(); + + var aggregateId = Guid.NewGuid().ToString(); + var aggregate = CreateAggregate(id: aggregateId); + aggregate.IncrementInt32Value(); + + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); + await Assert.That(saveResult).IsTrue(); + + var aggregateFromSqlServer = await store.GetAsync(aggregateId, cancellationToken: cancellationToken); + await Assert.That(aggregateFromSqlServer).IsNotNull(); + + var deleteResult = await store.DeleteAsync(aggregate, cancellationToken: cancellationToken); + await Assert.That(deleteResult).IsTrue(); + + aggregateFromSqlServer = await store.GetAsync(aggregateId, cancellationToken: cancellationToken); + await Assert.That(aggregateFromSqlServer).IsNull(); + + // Act + var restoreResult = await store.RestoreAsync(aggregate, cancellationToken: cancellationToken); + + aggregateFromSqlServer = await store.GetAsync(aggregateId, cancellationToken: cancellationToken); + + // Assert + await Assert.That(restoreResult).IsTrue(); + await Assert.That(aggregateFromSqlServer).IsNotNull(); + } +} diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SaveAsync.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SaveAsync.cs similarity index 82% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SaveAsync.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SaveAsync.cs index c91317cf..c1198027 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SaveAsync.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SaveAsync.cs @@ -8,7 +8,7 @@ partial class SqlServerSnapshotEventStoreTests public async Task SaveAsync_GivenNewAggregateWithChanges_SavesAggregate(CancellationToken cancellationToken) { // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); var aggregateId = Guid.NewGuid().ToString(); var aggregate = CreateAggregate(id: aggregateId); @@ -16,17 +16,14 @@ public async Task SaveAsync_GivenNewAggregateWithChanges_SavesAggregate(Cancella aggregate.AppendString(aggregateId); // Act - bool result = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool result = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); // Assert await Assert.That(result).IsTrue(); await Assert.That(aggregate.IsNew()).IsFalse(); // Verify by re-getting the aggregate directly from SQL Server, not via the event store. - var aggregateFromSqlServer = await context.SqlServerClient.GetByIdAsync( - aggregateId, - cancellationToken: cancellationToken - ); + var aggregateFromSqlServer = await store.GetAsync(aggregateId, cancellationToken: cancellationToken); await Assert.That(aggregateFromSqlServer).IsNotNull(); await Assert.That(aggregateFromSqlServer.Id()).IsEqualTo(aggregate.Id()); diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SingleOrDefaultAsync.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SingleOrDefaultAsync.cs similarity index 73% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SingleOrDefaultAsync.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SingleOrDefaultAsync.cs index 106b8a73..eb111713 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SingleOrDefaultAsync.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.SingleOrDefaultAsync.cs @@ -1,4 +1,6 @@ -namespace Purview.EventSourcing.SqlServer.Snapshots; +using Purview.EventSourcing.Aggregates.Persistence; + +namespace Purview.EventSourcing.SqlServer.Snapshots; partial class SqlServerSnapshotEventStoreTests { @@ -10,7 +12,7 @@ CancellationToken cancellationToken const int matchingIncrement = 10; // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); for (var i = 0; i < matchingIncrement; i++) { @@ -18,7 +20,7 @@ CancellationToken cancellationToken for (var x = 0; x < matchingIncrement; x++) aggregate.IncrementInt32Value(); - var saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + var saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult.ToBoolean()).IsTrue(); await Assert.That(saveResult.Skipped).IsFalse(); @@ -26,7 +28,7 @@ CancellationToken cancellationToken // Act async Task Func() => - await context.EventStore.SingleOrDefaultAsync( + await store.SingleOrDefaultAsync( m => m.IncrementInt32 == matchingIncrement, cancellationToken: cancellationToken ); @@ -46,18 +48,18 @@ CancellationToken cancellationToken const int matchingIncrement = 10; // Arrange - var context = fixture.CreateContext(); + var store = fixture.CreateSnapshotStore(); var aggregateId = Guid.NewGuid().ToString(); var aggregate = CreateAggregate(id: aggregateId); for (var x = 0; x < matchingIncrement; x++) aggregate.IncrementInt32Value(); - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); // Act - var result = await context.EventStore.SingleOrDefaultAsync( + var result = await store.SingleOrDefaultAsync( m => m.IncrementInt32 == matchingIncrement, cancellationToken: cancellationToken ); @@ -73,20 +75,19 @@ public async Task SingleOrDefaultAsync_GivenNoMatchingAggregates_ReturnsNull(Can const int eventsToCreate = 10; // Arrange - var context = fixture.CreateContext(); - + var store = fixture.CreateSnapshotStore(); for (var i = 0; i < aggregatesToCreate; i++) { var aggregate = CreateAggregate(); for (var x = 0; x < eventsToCreate; x++) aggregate.IncrementInt32Value(); - bool saveResult = await context.EventStore.SaveAsync(aggregate, cancellationToken: cancellationToken); + bool saveResult = await store.SaveAsync(aggregate, cancellationToken: cancellationToken); await Assert.That(saveResult).IsTrue(); } // Act - var result = await context.EventStore.SingleOrDefaultAsync( + var result = await store.SingleOrDefaultAsync( m => m.IncrementInt32 == -1, cancellationToken: cancellationToken ); diff --git a/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.UnsupportedPayload.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.UnsupportedPayload.cs new file mode 100644 index 00000000..b5471a82 --- /dev/null +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.UnsupportedPayload.cs @@ -0,0 +1,47 @@ +using Purview.EventSourcing.Aggregates; +using Purview.EventSourcing.Aggregates.Events; + +namespace Purview.EventSourcing.SqlServer.Snapshots; + +partial class SqlServerSnapshotEventStoreTests +{ + [Test] + public async Task GetByIdAsync_GivenUnsupportedPayloadShape_ThrowsEarly() + { + var client = new Client.SqlServerClient( + new Client.SqlServerClientOptions(fixture.ConnectionString, false) + { + SchemaName = "dbo", + TableName = $"Snapshots_{Guid.NewGuid():N}", + AutoCreateTable = false, + } + ); + + Task Act() => client.GetByIdAsync("id"); + + var ex = await Assert.That(Act).Throws(); + await Assert.That(ex).IsNotNull(); + await Assert.That(ex.Message).Contains(nameof(UnsupportedPayloadAggregate.UnsupportedMap)); + } + + sealed class UnsupportedPayloadAggregate : IAggregate + { + public string AggregateType => nameof(UnsupportedPayloadAggregate); + + public AggregateDetails Details { get; init; } = new(); + + public IReadOnlyList UnsupportedMap { get; init; } = []; + + public IEnumerable GetUnsavedEvents() => []; + + public bool HasUnsavedEvents() => false; + + public IEnumerable GetRegisteredEventTypes() => []; + + public bool CanApplyEvent(IEvent aggregateEvent) => false; + + public void ClearUnsavedEvents(int? upToVersion = null) { } + + void IAggregate.ApplyEvent(IEvent @event) { } + } +} diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.cs similarity index 95% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.cs index 1f2e4cfd..8b07c2be 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotEventStoreTests.cs @@ -3,7 +3,7 @@ namespace Purview.EventSourcing.SqlServer.Snapshots; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public partial class SqlServerSnapshotEventStoreTests(SqlServerSnapshotEventStoreFixture fixture) { static PersistenceAggregate CreateAggregate(string? id = null, Action? action = null) diff --git a/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotQueryTranslationBoundaryTests.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotQueryTranslationBoundaryTests.cs new file mode 100644 index 00000000..3e296fdd --- /dev/null +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotQueryTranslationBoundaryTests.cs @@ -0,0 +1,88 @@ +using Purview.EventSourcing.Aggregates.Persistence; +using Purview.EventSourcing.Fixtures.SqlServer; +using Purview.EventSourcing.Samples.Domain; +using Purview.EventSourcing.Samples.ValueObjects; + +namespace Purview.EventSourcing.SqlServer.Snapshots; + +[ClassDataSource(Shared = SharedType.PerTestSession)] +public sealed class SqlServerSnapshotQueryTranslationBoundaryTests(SqlServerSnapshotEventStoreFixture fixture) +{ + [Test] + public async Task QueryAsync_GivenPrimitiveScalarValueObjectMembers_Translates(CancellationToken cancellationToken) + { + var store = fixture.CreateSnapshotStore(); + var customer = new CustomerAggregate { Details = { Id = Guid.NewGuid().ToString("D") } }; + customer.RegisterCustomer("Jane Smith", "jane@test.com"); + customer.ChangeEmail("updated@test.com"); + + await store.SnapshotAsync(customer, cancellationToken); + + var query = await store.QueryAsync( + m => m.Email == "updated@test.com" && m.Name == "Jane Smith", + cancellationToken: cancellationToken + ); + + await Assert.That(query.Results).Count().IsEqualTo(1); + await Assert.That(query.Results[0].Id()).IsEqualTo(customer.Id()); + await Assert.That(query.Results[0].Email).IsEqualTo("updated@test.com"); + await Assert.That(query.Results[0].Name).IsEqualTo("Jane Smith"); + } + + [Test] + public async Task QueryAsync_GivenNonScalarValueObjectMembers_Translates(CancellationToken cancellationToken) + { + var store = fixture.CreateSnapshotStore(); + var aggregate = new SnapshotValueObjectsAggregate(); + aggregate.Details.Id = Guid.NewGuid().ToString("D"); + aggregate.CaptureUserDetails( + UserDetails.Create(Guid.Parse("11111111-1111-1111-1111-111111111111"), "Jane Snapshot", true), + UserDetails2.Create(Guid.Parse("22222222-2222-2222-2222-222222222222"), "Jane Snapshot 2") + ); + + await store.SaveAsync(aggregate, operationContext: null, cancellationToken); + + var query = await store.QueryAsync( + m => m.UserDetails.DisplayName == "Jane Snapshot" && m.UserDetails2.DisplayName == "Jane Snapshot 2", + cancellationToken: cancellationToken + ); + + await Assert.That(query.Results).Count().IsEqualTo(1); + await Assert.That(query.Results[0].Id()).IsEqualTo(aggregate.Id()); + await Assert.That(query.Results[0].UserDetails.DisplayName).IsEqualTo("Jane Snapshot"); + await Assert.That(query.Results[0].UserDetails2.DisplayName).IsEqualTo("Jane Snapshot 2"); + } + + [Test] + public async Task QueryAsync_GivenDirectlyMappedComplexNestedMembers_Translates(CancellationToken cancellationToken) + { + var store = fixture.CreateSnapshotStore(); + var aggregate = new PersistenceAggregate { Details = { Id = Guid.NewGuid().ToString("D") } }; + aggregate.SetComplexProperty( + new Aggregates.ComplexTestType + { + Int16Property = 16, + Int32Property = 32, + Int64Property = 64, + StringProperty = "complex-test", + DateTimeOffsetProperty = DateTimeOffset.UtcNow, + } + ); + + await store.SaveAsync(aggregate, cancellationToken: cancellationToken); + + var query = await store.QueryAsync( + m => + m.ComplexTestType != null + && m.ComplexTestType.StringProperty == "complex-test" + && m.ComplexTestType.Int32Property == 32, + cancellationToken: cancellationToken + ); + + await Assert.That(query.Results).Count().IsEqualTo(1); + await Assert.That(query.Results[0].Id()).IsEqualTo(aggregate.Id()); + await Assert.That(query.Results[0].ComplexTestType).IsNotNull(); + await Assert.That(query.Results[0].ComplexTestType!.StringProperty).IsEqualTo("complex-test"); + await Assert.That(query.Results[0].ComplexTestType!.Int32Property).IsEqualTo(32); + } +} diff --git a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotValueObjectPersistenceTests.cs b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotValueObjectPersistenceTests.cs similarity index 61% rename from src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotValueObjectPersistenceTests.cs rename to src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotValueObjectPersistenceTests.cs index d2516f50..066dae09 100644 --- a/src/tests/EventSourcing.SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotValueObjectPersistenceTests.cs +++ b/src/tests/SqlServer.IntegrationTests/Snapshots/SqlServerSnapshotValueObjectPersistenceTests.cs @@ -1,17 +1,11 @@ -using Microsoft.Extensions.Caching.Distributed; -using Microsoft.Extensions.Options; using Purview.EventSourcing.Aggregates.Events; -using Purview.EventSourcing.ChangeFeed; using Purview.EventSourcing.Fixtures.SqlServer; using Purview.EventSourcing.Samples.Domain; using Purview.EventSourcing.Samples.ValueObjects; -using Purview.EventSourcing.Services; -using Purview.EventSourcing.SqlServer.Events; -using Purview.EventSourcing.SqlServer.Snapshot; namespace Purview.EventSourcing.SqlServer.Snapshots; -[ClassDataSource(Shared = SharedType.PerAssembly)] +[ClassDataSource(Shared = SharedType.PerTestSession)] public sealed class SqlServerSnapshotValueObjectPersistenceTests(SqlServerSnapshotEventStoreFixture fixture) { [Test] @@ -19,44 +13,12 @@ public async Task SaveAsync_GivenComplexValueObjects_PersistsEventSnapshotAndSup CancellationToken cancellationToken ) { - var context = fixture.CreateContext(tableName: $"Snapshots_{Guid.NewGuid():N}"); + var store = fixture.CreateSnapshotStore(); var aggregateId = Guid.NewGuid().ToString("D"); var eventTableName = $"EventStore_{Guid.NewGuid():N}"; var displayName = "Jane Snapshot"; var displayName2 = "Jane Snapshot 2"; - var innerEventStore = new SqlServerEventStore( - eventNameMapper: new AggregateEventNameMapper(), - sqlServerOptions: Options.Create( - new SqlServerEventStoreOptions - { - ConnectionString = context.SqlServerConnectionString, - TableName = eventTableName, - SchemaName = "dbo", - AutoCreateTable = true, - TimeoutInSeconds = 60, - } - ), - distributedCache: Substitute.For(), - eventStoreTelemetry: Substitute.For(), - aggregateChangeNotifier: Substitute.For>(), - aggregateRequirementsManager: Substitute.For() - ); - - var store = new SqlServerSnapshotEventStore( - innerEventStore, - Options.Create( - new SqlServerSnapshotEventStoreOptions - { - ConnectionString = context.SqlServerConnectionString, - TableName = $"Snapshots_{Guid.NewGuid():N}", - SchemaName = "dbo", - AutoCreateTable = true, - } - ), - Substitute.For() - ); - var aggregate = new SnapshotValueObjectsAggregate(); aggregate.Details.Id = aggregateId; aggregate.CaptureUserDetails( @@ -74,12 +36,7 @@ CancellationToken cancellationToken var events = new List<(IEvent @event, string eventType)>(); await foreach ( - var @event in innerEventStore.GetEventRangeAsync( - aggregateId, - versionFrom: 1, - versionTo: null, - cancellationToken - ) + var @event in store.GetEventRangeAsync(aggregateId, versionFrom: 1, versionTo: null, cancellationToken) ) { events.Add(@event); diff --git a/src/tests/SqlServer.IntegrationTests/SqlServer.IntegrationTests.csproj b/src/tests/SqlServer.IntegrationTests/SqlServer.IntegrationTests.csproj new file mode 100644 index 00000000..0e1a8e99 --- /dev/null +++ b/src/tests/SqlServer.IntegrationTests/SqlServer.IntegrationTests.csproj @@ -0,0 +1,5 @@ + + + + + diff --git a/src/tests/SqlServer.PerformanceTests/Program.cs b/src/tests/SqlServer.PerformanceTests/Program.cs new file mode 100644 index 00000000..54e3229b --- /dev/null +++ b/src/tests/SqlServer.PerformanceTests/Program.cs @@ -0,0 +1,32 @@ +var runBenchmark = Array.Exists( + args, + static arg => string.Equals(arg, "--benchmark", StringComparison.OrdinalIgnoreCase) +); + +SqlServerStorePerformanceRunner runner = new(); +SqlServerStorePerformanceHistoryStore store = new(); + +using CancellationTokenSource cancellationTokenSource = new(); +Console.CancelKeyPress += (s, e) => cancellationTokenSource.Cancel(); + +var previousRun = store.TryLoadLatest(); +var run = await ( + runBenchmark + ? runner.RunBenchmarkAsync(cancellationTokenSource.Token) + : runner.RunQuickAsync(cancellationTokenSource.Token) +); +var savedPath = await store.SaveAsync(run, cancellationTokenSource.Token); + +await Console.Out.WriteLineAsync($"Saved {run.Mode} results to {savedPath}"); +await Console.Out.WriteLineAsync(); + +foreach (var line in run.FormatSummary(previousRun)) + await Console.Out.WriteLineAsync(line); + +if (run.Passed) + return 0; + +await Console.Out.WriteLineAsync(); +await Console.Error.WriteLineAsync("Performance thresholds were not met."); + +return 1; diff --git a/src/tests/EventSourcing.SqlServer.PerformanceTests/EventSourcing.SqlServer.PerformanceTests.csproj b/src/tests/SqlServer.PerformanceTests/SqlServer.PerformanceTests.csproj similarity index 60% rename from src/tests/EventSourcing.SqlServer.PerformanceTests/EventSourcing.SqlServer.PerformanceTests.csproj rename to src/tests/SqlServer.PerformanceTests/SqlServer.PerformanceTests.csproj index 393173dc..c3219f49 100644 --- a/src/tests/EventSourcing.SqlServer.PerformanceTests/EventSourcing.SqlServer.PerformanceTests.csproj +++ b/src/tests/SqlServer.PerformanceTests/SqlServer.PerformanceTests.csproj @@ -3,14 +3,13 @@ Exe false true - true false $(NoWarn);TUnit0034 - - + + diff --git a/src/tests/SqlServer.PerformanceTests/SqlServerPerformanceWorkload.cs b/src/tests/SqlServer.PerformanceTests/SqlServerPerformanceWorkload.cs new file mode 100644 index 00000000..e64bd8db --- /dev/null +++ b/src/tests/SqlServer.PerformanceTests/SqlServerPerformanceWorkload.cs @@ -0,0 +1,10 @@ +namespace Purview.EventSourcing.SqlServer; + +sealed class SqlServerPerformanceWorkload +{ + public int AggregateCount { get; set; } + + public int EventsPerAggregate { get; set; } + + public int QueryIterations { get; set; } +} diff --git a/src/tests/EventSourcing.SqlServer.PerformanceTests/SqlServerStorePerformanceHistoryStore.cs b/src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceHistoryStore.cs similarity index 82% rename from src/tests/EventSourcing.SqlServer.PerformanceTests/SqlServerStorePerformanceHistoryStore.cs rename to src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceHistoryStore.cs index 3b619e40..f0433ca9 100644 --- a/src/tests/EventSourcing.SqlServer.PerformanceTests/SqlServerStorePerformanceHistoryStore.cs +++ b/src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceHistoryStore.cs @@ -1,7 +1,7 @@ using System.Globalization; using System.Text.Json; -namespace Purview.EventSourcing.SqlServer.PerformanceTests; +namespace Purview.EventSourcing.SqlServer; sealed class SqlServerStorePerformanceHistoryStore { @@ -18,7 +18,7 @@ sealed class SqlServerStorePerformanceHistoryStore ? JsonSerializer.Deserialize(File.ReadAllText(LatestPath), SerializerOptions) : null; - public string Save(SqlServerStorePerformanceRun run) + public async Task SaveAsync(SqlServerStorePerformanceRun run, CancellationToken cancellationToken) { Directory.CreateDirectory(HistoryDirectory); @@ -26,8 +26,8 @@ public string Save(SqlServerStorePerformanceRun run) var historyPath = Path.Combine(HistoryDirectory, $"{timestamp}-{run.Mode.ToUpperInvariant()}.json"); var json = JsonSerializer.Serialize(run, SerializerOptions); - File.WriteAllText(historyPath, json); - File.WriteAllText(LatestPath, json); + await File.WriteAllTextAsync(historyPath, json, cancellationToken); + await File.WriteAllTextAsync(LatestPath, json, cancellationToken); return historyPath; } diff --git a/src/tests/EventSourcing.SqlServer.PerformanceTests/PerformanceModels.cs b/src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceRun.cs similarity index 50% rename from src/tests/EventSourcing.SqlServer.PerformanceTests/PerformanceModels.cs rename to src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceRun.cs index 7439f3af..dffeae1f 100644 --- a/src/tests/EventSourcing.SqlServer.PerformanceTests/PerformanceModels.cs +++ b/src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceRun.cs @@ -1,4 +1,4 @@ -namespace Purview.EventSourcing.SqlServer.PerformanceTests; +namespace Purview.EventSourcing.SqlServer; sealed class SqlServerStorePerformanceRun { @@ -41,44 +41,3 @@ public IEnumerable FormatSummary(SqlServerStorePerformanceRun? previousR yield return Passed ? "Result: PASS" : "Result: FAIL"; } } - -sealed class SqlServerPerformanceWorkload -{ - public int AggregateCount { get; set; } - - public int EventsPerAggregate { get; set; } - - public int QueryIterations { get; set; } -} - -sealed class SqlServerStorePerformanceScenarioRun -{ - public string Name { get; set; } = string.Empty; - - public int OperationCount { get; set; } - - public double TotalMilliseconds { get; set; } - - public double AverageMilliseconds { get; set; } - - public double OperationsPerSecond { get; set; } - - public double MaxAllowedAverageMilliseconds { get; set; } - - public bool Passed { get; set; } - - public string FormatCurrent() - { - var status = Passed ? "PASS" : "FAIL"; - return $"{Name} {status} total={TotalMilliseconds:F2}ms ops={OperationCount} avg={AverageMilliseconds:F2}ms ops/s={OperationsPerSecond:F2} threshold(avg)<={MaxAllowedAverageMilliseconds:F2}ms"; - } - - public string FormatComparison(SqlServerStorePerformanceScenarioRun previous) => - $" vs previous: avg={FormatDelta(AverageMilliseconds - previous.AverageMilliseconds, previous.AverageMilliseconds)} ops/s={FormatDelta(OperationsPerSecond - previous.OperationsPerSecond, previous.OperationsPerSecond)}"; - - static string FormatDelta(double delta, double previous) - { - var percent = previous <= 0 ? 0 : (delta / previous) * 100; - return $"{delta:+0.00;-0.00;0.00} ({percent:+0.0;-0.0;0.0}%)"; - } -} diff --git a/src/tests/EventSourcing.SqlServer.PerformanceTests/SqlServerStorePerformanceRunner.cs b/src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceRunner.cs similarity index 94% rename from src/tests/EventSourcing.SqlServer.PerformanceTests/SqlServerStorePerformanceRunner.cs rename to src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceRunner.cs index 0f740c06..931fec83 100644 --- a/src/tests/EventSourcing.SqlServer.PerformanceTests/SqlServerStorePerformanceRunner.cs +++ b/src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceRunner.cs @@ -7,7 +7,6 @@ using Purview.EventSourcing.Aggregates.Events; using Purview.EventSourcing.Aggregates.Persistence; using Purview.EventSourcing.ChangeFeed; -using Purview.EventSourcing.Internal; using Purview.EventSourcing.Samples.Domain; using Purview.EventSourcing.Samples.ValueObjects; using Purview.EventSourcing.Services; @@ -15,11 +14,11 @@ using Purview.EventSourcing.SqlServer.Snapshot; using Purview.EventSourcing.SqlServer.Snapshots; -namespace Purview.EventSourcing.SqlServer.PerformanceTests; +namespace Purview.EventSourcing.SqlServer; sealed class SqlServerStorePerformanceRunner { - public Task RunQuickAsync() => + public Task RunQuickAsync(CancellationToken cancellationToken) => RunAsync( mode: "Quick", workload: new SqlServerPerformanceWorkload @@ -33,10 +32,11 @@ public Task RunQuickAsync() => EventGetAverageMs: 30, SnapshotWriteAverageMs: 35, SnapshotQueryAverageMs: 40 - ) + ), + cancellationToken ); - public Task RunBenchmarkAsync() => + public Task RunBenchmarkAsync(CancellationToken cancellationToken) => RunAsync( mode: "Benchmark", workload: new SqlServerPerformanceWorkload @@ -50,20 +50,22 @@ public Task RunBenchmarkAsync() => EventGetAverageMs: 70, SnapshotWriteAverageMs: 80, SnapshotQueryAverageMs: 90 - ) + ), + cancellationToken ); async Task RunAsync( string mode, SqlServerPerformanceWorkload workload, - ScenarioThresholds thresholds + ScenarioThresholds thresholds, + CancellationToken cancellationToken ) { var previousRequiresPrincipal = EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault; EventStoreOperationContext.RequiresValidPrincipalIdentifierDefault = false; await using var msSqlContainer = ContainerHelper.CreateMsSql(); - await msSqlContainer.StartAsync(); + await msSqlContainer.StartAsync(cancellationToken); try { @@ -92,7 +94,8 @@ ScenarioThresholds thresholds if (!result.Saved || !result.IsValid) throw new InvalidOperationException($"Save failed for aggregate '{aggregateIds[i]}'."); } - } + }, + cancellationToken ); var loadedAggregates = new List(aggregateIds.Length); @@ -105,18 +108,15 @@ ScenarioThresholds thresholds loadedAggregates.Clear(); for (var i = 0; i < aggregateIds.Length; i++) { - var aggregate = await eventStore.GetAsync( - aggregateIds[i], - operationContext: null, - cancellationToken - ); - if (aggregate is null) - throw new InvalidOperationException($"Aggregate '{aggregateIds[i]}' was not found."); + var aggregate = + await eventStore.GetAsync(aggregateIds[i], operationContext: null, cancellationToken) + ?? throw new InvalidOperationException($"Aggregate '{aggregateIds[i]}' was not found."); ValidateAggregate(aggregate, i, workload.EventsPerAggregate); loadedAggregates.Add(aggregate); } - } + }, + cancellationToken ); var snapshotWriteScenario = await MeasureAsync( @@ -127,10 +127,14 @@ ScenarioThresholds thresholds { foreach (var aggregate in loadedAggregates) await snapshotStore.SnapshotAsync(aggregate, cancellationToken); - } + }, + cancellationToken ); - var count = await snapshotStore.CountAsync(static aggregate => aggregate.IncrementInt32 > 0); + var count = await snapshotStore.CountAsync( + static aggregate => aggregate.IncrementInt32 > 0, + cancellationToken + ); if (count != workload.AggregateCount) { throw new InvalidOperationException( @@ -160,13 +164,15 @@ ScenarioThresholds thresholds $"Snapshot total count mismatch. Expected at least {workload.AggregateCount}, got {page.TotalCount}." ); } - } + }, + cancellationToken ); var complexSnapshotQueryScenario = await RunComplexSnapshotQueryScenarioAsync( connectionString, $"PerfComplexSnapshots_{runId}", - workload.QueryIterations + workload.QueryIterations, + cancellationToken ); return new SqlServerStorePerformanceRun @@ -280,6 +286,7 @@ async Task RunComplexSnapshotQueryScenario && aggregate.UserDetails2.DisplayName.StartsWith(matchingDisplayName2Prefix), cancellationToken ); + if (valueObjectMatchCount != expectedValueObjectMatches) { throw new InvalidOperationException( @@ -287,6 +294,7 @@ async Task RunComplexSnapshotQueryScenario ); } + // Valid up to this point, so run the test... return await MeasureAsync( "SnapshotStore.Query.ComplexAggregate", queryIterations * 2, @@ -404,7 +412,7 @@ static SqlServerEventStore CreateEventStore(string conne SchemaName = "dbo", AutoCreateTable = true, TimeoutInSeconds = 120, - CacheMode = EventStoreCachingOptions.None, + CacheMode = SnapshotCachingOptions.None, RequiresValidPrincipalIdentifier = false, }; @@ -600,10 +608,7 @@ class NoOpDispatchProxy : DispatchProxy return method.Invoke(null, [value]); } - if (returnType.IsValueType) - return Activator.CreateInstance(returnType); - - return null; + return returnType.IsValueType ? Activator.CreateInstance(returnType) : null; } } } diff --git a/src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceScenarioRun.cs b/src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceScenarioRun.cs new file mode 100644 index 00000000..36ad1f6b --- /dev/null +++ b/src/tests/SqlServer.PerformanceTests/SqlServerStorePerformanceScenarioRun.cs @@ -0,0 +1,33 @@ +namespace Purview.EventSourcing.SqlServer; + +sealed class SqlServerStorePerformanceScenarioRun +{ + public string Name { get; set; } = string.Empty; + + public int OperationCount { get; set; } + + public double TotalMilliseconds { get; set; } + + public double AverageMilliseconds { get; set; } + + public double OperationsPerSecond { get; set; } + + public double MaxAllowedAverageMilliseconds { get; set; } + + public bool Passed { get; set; } + + public string FormatCurrent() + { + var status = Passed ? "PASS" : "FAIL"; + return $"{Name} {status} total={TotalMilliseconds:F2}ms ops={OperationCount} avg={AverageMilliseconds:F2}ms ops/s={OperationsPerSecond:F2} threshold(avg)<={MaxAllowedAverageMilliseconds:F2}ms"; + } + + public string FormatComparison(SqlServerStorePerformanceScenarioRun previous) => + $" vs previous: avg={FormatDelta(AverageMilliseconds - previous.AverageMilliseconds, previous.AverageMilliseconds)} ops/s={FormatDelta(OperationsPerSecond - previous.OperationsPerSecond, previous.OperationsPerSecond)}"; + + static string FormatDelta(double delta, double previous) + { + var percent = previous <= 0 ? 0 : (delta / previous) * 100; + return $"{delta:+0.00;-0.00;0.00} ({percent:+0.0;-0.0;0.0}%)"; + } +} diff --git a/src/tests/ZodSharpImpl.UnitTests/Services/ZodSharpValidationAggregateValidatorTests.cs b/src/tests/ZodSharpImpl.UnitTests/Services/ZodSharpValidationAggregateValidatorTests.cs new file mode 100644 index 00000000..cf3e6e5e --- /dev/null +++ b/src/tests/ZodSharpImpl.UnitTests/Services/ZodSharpValidationAggregateValidatorTests.cs @@ -0,0 +1,94 @@ +using Purview.EventSourcing.Aggregates; +using ZodSharp.Core; + +namespace Purview.EventSourcing.ZodSharp.Services; + +public sealed class ZodSharpAggregateValidatorTests +{ + [Test] + public async Task ValidateAsync_UsesAsyncRules(CancellationToken cancellationToken) + { + TestAggregate aggregate = new() { Name = "valid" }; + var validator = IZodSchemaValidator.Mock(); + validator.ValidateAsync(Any(), Any()).Returns(ValidationResult.Success(aggregate)); + + ZodSharpAggregateValidator adapter = new(validator); + + await adapter.ValidateAsync(aggregate, cancellationToken); + + validator.ValidateAsync(AnyArgs()).WasCalled(Times.Once); + } + + [Test] + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Performance", + "CA1849:Call async methods when in an async method" + )] + public async Task Validate_UsesNonAsyncRules() + { + TestAggregate aggregate = new() { Name = "valid" }; + var validator = IZodSchemaValidator.Mock(); + validator.Validate(Any()).Returns(ValidationResult.Success(aggregate)); + + ZodSharpAggregateValidator adapter = new(validator); + + adapter.Validate(aggregate); + + validator.Validate(Any()).WasCalled(Times.Once); + } + + [Test] + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Performance", + "CA1849:Call async methods when in an async method" + )] + public async Task Validate_WhenValidationFails_MapsToCoreValidationResult() + { + TestAggregate aggregate = new() { Name = "" }; + var validator = IZodSchemaValidator.Mock(); + validator + .Validate(Any()) + .Returns( + ValidationResult.Failure( + ValidationError.Create("any", "error", [nameof(TestAggregate.Name)]) + ) + ); + + ZodSharpAggregateValidator adapter = new(validator); + + var result = adapter.Validate(aggregate); + + await Assert.That(result.IsValid).IsFalse(); + await Assert.That(result.Errors).Count().IsEqualTo(1); + await Assert.That(result.Errors[0].PropertyName).IsEqualTo(nameof(TestAggregate.Name)); + } + + [Test] + public async Task ValidateAsync_WhenValidationFails_MapsToCoreValidationResult() + { + TestAggregate aggregate = new() { Name = "" }; + var validator = IZodSchemaValidator.Mock(); + validator + .ValidateAsync(AnyArgs()) + .Returns( + ValidationResult.Failure( + ValidationError.Create("any", "error", [nameof(TestAggregate.Name)]) + ) + ); + + ZodSharpAggregateValidator adapter = new(validator); + + var result = await adapter.ValidateAsync(aggregate); + + await Assert.That(result.IsValid).IsFalse(); + await Assert.That(result.Errors).Count().IsEqualTo(1); + await Assert.That(result.Errors[0].PropertyName).IsEqualTo(nameof(TestAggregate.Name)); + } + + sealed class TestAggregate : AggregateBase + { + public string Name { get; set; } = string.Empty; + + protected override void RegisterEvents() { } + } +} diff --git a/src/tests/ZodSharpImpl.UnitTests/ZodSharpImpl.UnitTests.csproj b/src/tests/ZodSharpImpl.UnitTests/ZodSharpImpl.UnitTests.csproj new file mode 100644 index 00000000..211041f7 --- /dev/null +++ b/src/tests/ZodSharpImpl.UnitTests/ZodSharpImpl.UnitTests.csproj @@ -0,0 +1,5 @@ + + + Purview.EventSourcing.ZodSharp + +