From 6138505ee0e9fef86809be64b7bc5c1f9c80dbba Mon Sep 17 00:00:00 2001 From: KeelMatrix Date: Sun, 5 Oct 2025 12:21:21 +0500 Subject: [PATCH 1/2] docs/samples: consolidate quickstart+budgets+wiring in root README; add package READMEs; fix samples NuGet path; de-duplicate sample docs --- .github/workflows/samples-ci.yml | 4 + README.md | 170 ++++++++++++------ samples/README.md | 57 ++---- .../KeelMatrix.QueryWatch.EfCore.csproj | 4 +- src/KeelMatrix.QueryWatch.EfCore/README.md | 112 ++---------- .../KeelMatrix.QueryWatch.csproj | 4 +- src/KeelMatrix.QueryWatch/README.md | 18 +- 7 files changed, 165 insertions(+), 204 deletions(-) diff --git a/.github/workflows/samples-ci.yml b/.github/workflows/samples-ci.yml index 6d1717f..322d66d 100644 --- a/.github/workflows/samples-ci.yml +++ b/.github/workflows/samples-ci.yml @@ -42,6 +42,10 @@ jobs: run: dotnet pack ./src/KeelMatrix.QueryWatch/KeelMatrix.QueryWatch.csproj -c Release --no-build --include-symbols --p:SymbolPackageFormat=snupkg --output ./artifacts/packages - name: Pack QueryWatch.EfCore run: dotnet pack ./src/KeelMatrix.QueryWatch.EfCore/KeelMatrix.QueryWatch.EfCore.csproj -c Release --no-build --include-symbols --p:SymbolPackageFormat=snupkg --output ./artifacts/packages + - name: Build QueryWatch.Redaction (Release) + run: dotnet build ./src/KeelMatrix.QueryWatch.Redaction/KeelMatrix.QueryWatch.Redaction.csproj -c Release --no-restore + - name: Pack QueryWatch.Redaction + run: dotnet pack ./src/KeelMatrix.QueryWatch.Redaction/KeelMatrix.QueryWatch.Redaction.csproj -c Release --no-build --include-symbols --p:SymbolPackageFormat=snupkg --output ./artifacts/packages # 3) Restore samples using their NuGet.config (pins KeelMatrix.QueryWatch* to ../artifacts/packages) - name: Restore samples diff --git a/README.md b/README.md index ebaef73..5cad80b 100644 --- a/README.md +++ b/README.md @@ -1,51 +1,133 @@ - > The project is currently under development. Keep an eye out for its release! +# QueryWatch -# KeelMatrix.QueryWatch +Guardrail your **database queries** in tests & CI. Capture executed SQL, enforce **budgets** (counts & timings), and fail builds on regressions. Works with **ADO.NET**, **Dapper**, and **EF Core**. -> Catch N+1 queries and slow SQL in tests. Fail builds when query budgets are exceeded. +**Quick links:** +- 👉 [Quick Start — Samples (local)](#quick-start--samples-local) +- 👉 [EF Core wiring](#ef-core-wiring) · [Dapper wiring](#dapper-wiring) · [ADO.NET wiring](#adonet-wiring) +- 👉 [CLI flags](#cli) · [Troubleshooting](#troubleshooting) -[![Build](https://github.com/OWNER/REPO/actions/workflows/ci.yml/badge.svg)](https://github.com/OWNER/REPO/actions/workflows/ci.yml) [![NuGet](https://img.shields.io/nuget/v/KeelMatrix.QueryWatch.svg)](https://www.nuget.org/packages/KeelMatrix.QueryWatch/) +--- -## Install +## 5‑minute success (tests) -```bash -dotnet add package KeelMatrix.QueryWatch -# EF Core users: -dotnet add package KeelMatrix.QueryWatch.EfCore -``` - -## 5‑minute success (with JSON for CI) - -**Per‑test scope → export JSON:** +Use the disposable scope to **export JSON** and enforce **budgets** in your test or smoke app. ```csharp using KeelMatrix.QueryWatch.Testing; -// JSON is written even if assertions fail (helps CI). -using var q = QueryWatchScope.Start( - maxQueries: 5, - maxAverage: TimeSpan.FromMilliseconds(50), +using var scope = QueryWatchScope.Start( + maxQueries: 50, + maxAverage: TimeSpan.FromMilliseconds(25), exportJsonPath: "artifacts/qwatch.report.json", - sampleTop: 50); // increase if you plan to use per‑pattern budgets in CLI + sampleTop: 200); + +// ... run your code that hits the DB ... ``` -**Gate in CI (already wired in ci.yml):** +The file `artifacts/qwatch.report.json` is now ready for the CLI gate. -```pwsh -dotnet run --project tools/KeelMatrix.QueryWatch.Cli -- --input artifacts/qwatch.report.json --max-queries 50 -``` +--- + +## Quick Start — Samples (local) + +This repo ships three tiny sample apps (EF Core, ADO.NET, Dapper) that **consume local packages** you build from source. + +1. **Pack the libraries** (run **at repo root**): + ```bash + dotnet pack ./src/KeelMatrix.QueryWatch/KeelMatrix.QueryWatch.csproj -c Release --include-symbols --p:SymbolPackageFormat=snupkg --output ./artifacts/packages + dotnet pack ./src/KeelMatrix.QueryWatch.EfCore/KeelMatrix.QueryWatch.EfCore.csproj -c Release --include-symbols --p:SymbolPackageFormat=snupkg --output ./artifacts/packages + ``` +2. **Install local packages to samples** (pins to `./artifacts/packages` via `samples/NuGet.config`): + - Windows (PowerShell): `./samples/init.ps1` + - Linux/macOS (bash): `./samples/init.sh` +3. **Run a sample** (EF example shown): + ```bash + dotnet run --project ./samples/EFCore.Sqlite/EFCore.Sqlite.csproj -c Release + ``` +4. **Gate with the CLI**: + ```bash + dotnet run --project ./tools/KeelMatrix.QueryWatch.Cli -- --input ./samples/EFCore.Sqlite/bin/Release/net8.0/artifacts/qwatch.ef.json --max-queries 50 + ``` + +> CI uses the same flow and restores using `samples/NuGet.config` so **samples build after `dotnet pack` with no tweaks**. + +--- ## EF Core wiring ```csharp -using KeelMatrix.QueryWatch.EfCore; // extension lives in the EfCore adapter package using Microsoft.EntityFrameworkCore; +using KeelMatrix.QueryWatch.EfCore; +using KeelMatrix.QueryWatch.Testing; + +using var q = QueryWatchScope.Start(exportJsonPath: "artifacts/ef.json", sampleTop: 200); var options = new DbContextOptionsBuilder() .UseSqlite("Data Source=:memory:") .UseQueryWatch(q.Session) // adds the interceptor .Options; ``` +> Interceptor only records **executed** commands. Use `QueryWatchOptions` on the session to tune capture (text, parameter shapes, etc.). + +--- + +## Dapper wiring + +```csharp +using Dapper; +using Microsoft.Data.Sqlite; +using KeelMatrix.QueryWatch.Dapper; +using KeelMatrix.QueryWatch.Testing; + +using var q = QueryWatchScope.Start(exportJsonPath: "artifacts/dapper.json", sampleTop: 200); + +await using var raw = new SqliteConnection("Data Source=:memory:"); +await raw.OpenAsync(); + +// Wrap the provider connection so Dapper commands are recorded +using var conn = raw.WithQueryWatch(q.Session); + +var rows = await conn.QueryAsync("SELECT 1"); +``` + +> The extension returns the **ADO wrapper** when possible for high‑fidelity recording; otherwise it falls back to a Dapper‑specific wrapper. + +--- + +## ADO.NET wiring + +```csharp +using Microsoft.Data.Sqlite; +using KeelMatrix.QueryWatch.Ado; +using KeelMatrix.QueryWatch.Testing; + +using var q = QueryWatchScope.Start(exportJsonPath: "artifacts/ado.json", sampleTop: 200); +await using var raw = new SqliteConnection("Data Source=:memory:"); +await raw.OpenAsync(); + +using var conn = new QueryWatchConnection(raw, q.Session); +using var cmd = conn.CreateCommand(); +cmd.CommandText = "SELECT 1"; +await cmd.ExecuteNonQueryAsync(); +``` + +--- + +## Budgets (counts & timing) + +At **test time** (scope) you can enforce `maxQueries`, `maxAverage`, `maxTotal`. At **CI time** use the CLI for stronger rules including **per‑pattern budgets**. Patterns support wildcards (`*`, `?`) or `regex:` prefix. + +Example per‑pattern budgets: + +```bash +--budget "SELECT * FROM Users*=1" +--budget "regex:^UPDATE Orders SET=3" +``` + +> If your JSON is **top‑N sampled**, budgets evaluate only over those events. Increase `sampleTop` in your export to tighten guarantees. + +--- ## CLI @@ -67,40 +149,22 @@ var options = new DbContextOptionsBuilder() ### Multi‑file support - Repeat `--input` to aggregate multiple JSONs (e.g., per‑project reports in a mono‑repo). Budgets evaluate on the aggregate. ### GitHub PR summary +When run inside GitHub Actions, the CLI writes a Markdown table to the **Step Summary** automatically. -When run inside GitHub Actions, the CLI writes a Markdown table to the **Step Summary** automatically, so reviewers see metrics and any violations at a glance. - -### Note on per‑pattern budgets - -Budgets match against the `events` captured in the JSON file(s). These are the top‑N slowest events by duration to keep files small. If you want strict coverage, export with a higher `sampleTop` in `QueryWatchJson.ExportToFile`, or pass a larger `sampleTop` to `QueryWatchScope.Start(...)`. - -## Redactor ordering tips - -If you use multiple redactors, **order matters**. A safe, effective default is: - -1. **Whitespace normalizer** – make SQL text stable across environments/providers. -2. **High‑entropy token masks** – long hex tokens, JWTs, API keys. -3. **PII masks** – emails, phone numbers, IPs. -4. **Custom rules** – your app–specific patterns (use `AddRegexRedactor(...)`). - -> Put *broad* rules (like whitespace) first, and *specific* rules (like PII) after. This lowers the chance one rule prevents another from matching. - -## Typical budgets for Dapper‑heavy solutions - -Dapper often issues *fewer, more targeted* commands than ORMs. Reasonable starting points (tune per project): +--- -- **End‑to‑end web test:** `--max-queries 40`, `--max-average-ms 50`, `--max-total-ms 1500`. -- **Repository‑level test:** `--max-queries 10`, `--max-average-ms 25`, `--max-total-ms 250`. -- **Per‑pattern budgets:** cap hot spots explicitly, e.g.: +## Troubleshooting - ``` - --budget "SELECT * FROM Users*=5" --budget "regex:^UPDATE Orders SET=3" - ``` +- **“Budget violations:” but no pattern table** → you didn’t pass any `--budget`, or your JSON was **heavily sampled**. Re‑export with higher `sampleTop` (e.g., 200–500). +- **Baselines seem too strict** → tolerances are **percent of baseline**. Ensure your baseline is representative; use `--baseline-allow-percent` to allow small drift. +- **CLI help in README looks stale** → run `./build/Update-ReadmeFlags.ps1` (or `--print-flags-md`) to refresh the block between markers. +- **Hot path text capture** → disable per‑adapter: `QueryWatchOptions.Disable{Ado|Dapper|EfCore}TextCapture=true`. +- **Parameter metadata** → set `QueryWatchOptions.CaptureParameterShape=true` (emits `event.meta.parameters`), never values. -- Increase `sampleTop` in code (`QueryWatchScope.Start(..., sampleTop: 200)`) if you rely on many per‑pattern budgets. +--- -Treat these as **guardrails**: keep design flexible but catch accidental N+1s or slow queries early. +## License +MIT diff --git a/samples/README.md b/samples/README.md index a6323fa..f25c4e7 100644 --- a/samples/README.md +++ b/samples/README.md @@ -1,53 +1,22 @@ # QueryWatch Samples -This folder contains small **sample projects** that consume the `KeelMatrix.QueryWatch` NuGet package -from your local build. They are intentionally minimal so you can understand and test the core behaviors -quickly in different situations (EF Core + SQLite, and raw ADO). - -> **Important:** These samples expect you to build the package(s) locally first and then add them to each sample. -> See the "Quick Start" below. +Tiny apps that consume the local `KeelMatrix.QueryWatch*` packages so you can see EF Core, ADO.NET, and Dapper wiring in action. ## Layout -- `EFCore.Sqlite/` – EF Core (SQLite provider) showing interceptor wiring and basic budgets. -- `Ado.Sqlite/` – plain ADO.NET over `Microsoft.Data.Sqlite` wrapped by `QueryWatchConnection`. -- `Dapper.Sqlite/` – tiny Dapper example over SQLite showing **async** and **transaction** usage with QueryWatch. -- `cli-examples.ps1` / `cli-examples.sh` – example commands for running the QueryWatch CLI gate. -- `NuGet.config` – forces the `KeelMatrix.QueryWatch*` packages to come from your local `../artifacts/packages`. -- `.gitignore` – ignores local build outputs and DB files for samples only. +- `EFCore.Sqlite/` – EF Core (SQLite) with interceptor wiring and basic budgets. +- `Ado.Sqlite/` – plain ADO.NET over `Microsoft.Data.Sqlite` via `QueryWatchConnection`. +- `Dapper.Sqlite/` – Dapper (async + transactions) via `WithQueryWatch(...)`. +- `cli-examples.ps1` / `cli-examples.sh` – quick commands to run the CLI gate. +- `NuGet.config` – pins `KeelMatrix.QueryWatch*` to `../artifacts/packages` (local build). -## Quick Start (local, step-by-step) -1. **Pack the libraries** at the repository root (one level *above* this folder): - ```bash - dotnet pack ./src/KeelMatrix.QueryWatch/KeelMatrix.QueryWatch.csproj -c Release --include-symbols --p:SymbolPackageFormat=snupkg --output ./artifacts/packages - dotnet pack ./src/KeelMatrix.QueryWatch.EfCore/KeelMatrix.QueryWatch.EfCore.csproj -c Release --include-symbols --p:SymbolPackageFormat=snupkg --output ./artifacts/packages - ``` -2. **Install the packages into each sample** (runs the add+restore for you): - - Windows (PowerShell): `./init.ps1` - - Linux/macOS (bash): `./init.sh` - These scripts run: - ```bash - dotnet add ./EFCore.Sqlite/EFCore.Sqlite.csproj package KeelMatrix.QueryWatch - dotnet add ./EFCore.Sqlite/EFCore.Sqlite.csproj package KeelMatrix.QueryWatch.EfCore - dotnet add ./Ado.Sqlite/Ado.Sqlite.csproj package KeelMatrix.QueryWatch - ``` - The included `NuGet.config` pins `KeelMatrix.QueryWatch*` to the local `../artifacts/packages` folder. -3. **Run a sample** (EF Core example shown): - ```bash - dotnet run --project ./EFCore.Sqlite/EFCore.Sqlite.csproj - ``` - You should see console output and a file at `./EFCore.Sqlite/bin/Debug/net8.0/artifacts/qwatch.ef.json`. -4. **Gate with the CLI** (from repo root or here): - ```bash - dotnet run --project ../tools/KeelMatrix.QueryWatch.Cli -- --input ./EFCore.Sqlite/bin/Debug/net8.0/artifacts/qwatch.ef.json --max-queries 50 - ``` +## Start here +Follow the **[Quick Start — Samples (local)](../README.md#quick-start--samples-local)** in the root README. -### Notes -- These samples **compile only after** you add the `KeelMatrix.QueryWatch` and (for EF) `KeelMatrix.QueryWatch.EfCore` packages (Step 2). -- If you get restore errors, confirm that `../artifacts/packages` exists and contains your `*.nupkg` files. -- The EF Core sample uses a file-based SQLite DB under `./EFCore.Sqlite/app.db`. You can delete it safely. +> After you run `dotnet pack ...` at the repo root, use `./init.ps1` (or `./init.sh`) once to add local packages. No other tweaks are needed. -### Dapper sample -Run the Dapper sample: +### Run a sample ```bash -dotnet run --project ./Dapper.Sqlite/Dapper.Sqlite.csproj +dotnet run --project ./EFCore.Sqlite/EFCore.Sqlite.csproj -c Release ``` + +For CLI usage examples, see `cli-examples.ps1` / `cli-examples.sh`. diff --git a/src/KeelMatrix.QueryWatch.EfCore/KeelMatrix.QueryWatch.EfCore.csproj b/src/KeelMatrix.QueryWatch.EfCore/KeelMatrix.QueryWatch.EfCore.csproj index cd0a770..24bbe65 100644 --- a/src/KeelMatrix.QueryWatch.EfCore/KeelMatrix.QueryWatch.EfCore.csproj +++ b/src/KeelMatrix.QueryWatch.EfCore/KeelMatrix.QueryWatch.EfCore.csproj @@ -12,8 +12,8 @@ KeelMatrix.QueryWatch.EfCore EF Core adapter for KeelMatrix.QueryWatch: wires a DbCommand interceptor and a UseQueryWatch(...) extension. queries;performance;testing;efcore;interceptor;ci;gate - https://github.com/your-org/KeelMatrix.QueryWatch - https://github.com/your-org/KeelMatrix.QueryWatch#readme + https://github.com/KeelMatrix/QueryWatch + https://github.com/KeelMatrix/QueryWatch#readme README.md MIT icon.png diff --git a/src/KeelMatrix.QueryWatch.EfCore/README.md b/src/KeelMatrix.QueryWatch.EfCore/README.md index 30ab32e..4e7dec4 100644 --- a/src/KeelMatrix.QueryWatch.EfCore/README.md +++ b/src/KeelMatrix.QueryWatch.EfCore/README.md @@ -1,106 +1,16 @@ -# QueryWatch +# KeelMatrix.QueryWatch.EfCore -**Status:** core ready to use in tests. Adapters: EF Core and ADO/Dapper wrappers. JSON export for CI included. +EF Core adapter for QueryWatch (adds a DbCommand interceptor and `UseQueryWatch(...)` extension). -## Quickstart (per‑test scope + JSON) +- ✅ **Docs & wiring live in the repo root:** + https://github.com/KeelMatrix/QueryWatch#ef-core-wiring -```csharp -using KeelMatrix.QueryWatch; -using KeelMatrix.QueryWatch.Testing; - -// Fail if more than 5 queries OR avg > 50ms; also export JSON for CI gate. -using var q = QueryWatch.Testing.QueryWatchScope.Start( - maxQueries: 5, - maxAverage: TimeSpan.FromMilliseconds(50), - exportJsonPath: "artifacts/qwatch.report.json", - sampleTop: 50); // increase if you rely on CLI per‑pattern budgets - -// Wire EF Core to q.Session (optional): -// var opts = new DbContextOptionsBuilder() -// .UseInMemoryDatabase("test") -// .UseQueryWatch(q.Session) -// .Options; - -// ... run code under test ... -// disposal writes JSON and enforces the budgets -``` - -## JSON API - -```csharp -using KeelMatrix.QueryWatch.Reporting; - -var report = session.Stop(); -QueryWatchJson.ExportToFile(report, "artifacts/qwatch.report.json", sampleTop: 50); -``` - -The JSON includes a `meta.sampleTop` value to document how many events were sampled. - -## CLI gate - -Run after tests (ci.yml already contains a guarded step): - -```pwsh -dotnet run --project tools/KeelMatrix.QueryWatch.Cli -- --input artifacts/qwatch.report.json --max-queries 50 -# Allow +10% vs baseline and enforce a per‑pattern budget: -dotnet run --project tools/KeelMatrix.QueryWatch.Cli -- --input artifacts/qwatch.report.json --baseline artifacts/qwatch.base.json --baseline-allow-percent 10 --budget "SELECT * FROM Users*=1" -``` - -## Built‑in redactors (opt‑in) - -To avoid leaking sensitive data in recorded SQL and to make pattern matching more stable across OS/providers, you can enable the built‑in redactors. - -```csharp -using KeelMatrix.QueryWatch; -using KeelMatrix.QueryWatch.Redaction; -using KeelMatrix.QueryWatch.Testing; - -var opts = new QueryWatchOptions() - .UseRecommendedRedactors(); // whitespace normalize + mask emails, long hex tokens, JWTs - -using var scope = QueryWatchScope.Start( - maxQueries: 5, - maxAverage: TimeSpan.FromMilliseconds(50), - options: opts, - exportJsonPath: "artifacts/qwatch.report.json", - sampleTop: 50); - -// ...execute code under test... +### Install +```bash +dotnet add package KeelMatrix.QueryWatch.EfCore ``` -> The recommended set runs a whitespace normalizer first, then masks emails, long hex strings and JWT‑like tokens with "***". -> You can add your own rules via `AddRegexRedactor(pattern)` and control ordering by pushing items into `QueryWatchOptions.Redactors`. - -### Additional built‑in redactors (opt‑in) -These are off by default. Add them explicitly if your logs/SQL contain these artifacts: - -```csharp -using KeelMatrix.QueryWatch.Redaction; - -var opts = new QueryWatchOptions().UseRecommendedRedactors(); -// Opt into specific extras: -opts.Redactors.Add(new ApiKeyRedactor()); // X-Api-Key / ApiKey headers & params -opts.Redactors.Add(new UuidNoDashRedactor()); // 32-hex UUIDs without dashes -opts.Redactors.Add(new CookieRedactor()); // Cookie / Set-Cookie headers -opts.Redactors.Add(new GoogleApiKeyRedactor()); // AIza... Google API keys -``` - -> You can control ordering by the sequence you add them (normalize first, then PII/secrets, then noise). -> Consider adding stronger shapes next (credit cards with Luhn, IBAN, Slack/GitHub tokens) if you see them in reports. - -## Dapper adapter - -For Dapper scenarios, wrap your connection before use: - -```csharp -using KeelMatrix.QueryWatch.Dapper; - -// If provider derives from DbConnection, async is preserved via QueryWatchConnection; -// otherwise we fallback to a pure IDbConnection wrapper. -using var scope = QueryWatch.Testing.QueryWatchScope.Start(maxQueries: 50, exportJsonPath: "artifacts/qwatch.report.json"); -using var raw = new Microsoft.Data.Sqlite.SqliteConnection("Data Source=:memory:"); -raw.Open(); -using var conn = raw.WithQueryWatch(scope.Session); - -var rows = conn.Query<(int Id, string Name)>("SELECT 1 AS Id, 'X' AS Name"); -``` +### See also +- [Core package](https://github.com/KeelMatrix/QueryWatch/blob/main/src/KeelMatrix.QueryWatch/README.md) +- [EF Core wiring](https://github.com/KeelMatrix/QueryWatch#ef-core-wiring) +- [Troubleshooting](https://github.com/KeelMatrix/QueryWatch#troubleshooting) diff --git a/src/KeelMatrix.QueryWatch/KeelMatrix.QueryWatch.csproj b/src/KeelMatrix.QueryWatch/KeelMatrix.QueryWatch.csproj index 931080f..6db631a 100644 --- a/src/KeelMatrix.QueryWatch/KeelMatrix.QueryWatch.csproj +++ b/src/KeelMatrix.QueryWatch/KeelMatrix.QueryWatch.csproj @@ -14,8 +14,8 @@ KeelMatrix.QueryWatch Catch N+1 queries and slow SQL in tests. Export JSON summaries for CI gates. queries;performance;testing;efcore;dapper;ado;ci;gate - https://github.com/your-org/KeelMatrix.QueryWatch - https://github.com/your-org/KeelMatrix.QueryWatch#readme + https://github.com/KeelMatrix/QueryWatch + https://github.com/KeelMatrix/QueryWatch#readme README.md MIT icon.png diff --git a/src/KeelMatrix.QueryWatch/README.md b/src/KeelMatrix.QueryWatch/README.md index 4d55f47..3162cf4 100644 --- a/src/KeelMatrix.QueryWatch/README.md +++ b/src/KeelMatrix.QueryWatch/README.md @@ -1,4 +1,18 @@ +# KeelMatrix.QueryWatch (core) -## Event metadata policy +Core library for QueryWatch. -For a detailed overview of parameter-shape capture, failure envelopes, and per-adapter text capture toggles, see **docs/METADATA_POLICY.md**. +- ✅ **Docs, quickstart, budgets, and wiring (ADO/Dapper/EF Core)** live in the repo root: + https://github.com/KeelMatrix/QueryWatch#readme + +### Install +```bash +dotnet add package KeelMatrix.QueryWatch +``` + +### See also +- [Quick Start — Samples (local)](https://github.com/KeelMatrix/QueryWatch#quick-start--samples-local) +- [EF Core wiring](https://github.com/KeelMatrix/QueryWatch#ef-core-wiring) +- [Dapper wiring](https://github.com/KeelMatrix/QueryWatch#dapper-wiring) +- [CLI](https://github.com/KeelMatrix/QueryWatch#cli) +- [Troubleshooting](https://github.com/KeelMatrix/QueryWatch#troubleshooting) From 67234122a1d78b4a81bc4a987dd54fca2b185abc Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 5 Oct 2025 09:07:04 +0000 Subject: [PATCH 2/2] Bump Microsoft.EntityFrameworkCore from 8.0.8 to 9.0.9 --- updated-dependencies: - dependency-name: Microsoft.EntityFrameworkCore dependency-version: 9.0.9 dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- Directory.Packages.props | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Directory.Packages.props b/Directory.Packages.props index 83a6020..f586012 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -15,7 +15,7 @@ - +