Tags from Trax.Samples

v1.29.0

2026-06-02T20:42:22Z

feat: multi-server keyed GraphQL client sample (#67)

* feat: multi-server keyed GraphQL client sample

Extend the GraphQLClient sample with two real Trax GraphQL servers that expose
different schemas (inventory: discover.inventory.getProduct, billing:
discover.billing.getInvoice), both on in-memory effects so no database is
needed. A Gateway console starts both servers in-process and drives them through
two keyed clients registered in a single container, printing both results and
the rejected cross-schema query.

The E2E suite boots both servers via WebApplicationFactory, registers the two
keyed clients in one container, and proves each client queries its own server,
that a query for one server is rejected through the other key, and that both
resolve to distinct executors from the same container.

* test: cover the not-found path in the sample train junctions

The inventory and billing junctions fall back to an "Unknown" result when the
SKU/invoice id is missing; only the found branch was exercised. Add E2E cases
that query a missing id through each keyed client and assert the fallback.

Leaves the Gateway console Program uncovered, consistent with the other console
sample entry points (PersistedOperations.Client, ContentShield.Runner,
EnergyHub.Worker), none of which are tested or excluded from coverage.

v1.28.0

2026-05-21T20:38:47Z

feat(persisted-ops sample): demonstrate [TraxAuthorize] coexistence (#62

)

* feat(persisted-ops sample): demonstrate [TraxAuthorize] coexistence

* test(persisted-ops sample): cover UserNote round-trip and drop bootstrap try/catch

v1.27.0

2026-05-21T14:42:07Z

feat(graphql-client sample): nested-path typed request via Path attri…

…bute (#61)

Adds LookupPlayerByNestedPathRequest to the GraphQLClient sample, demonstrating
Path = "discover.players" + RootField = "lookupPlayer" against an envelope that
mirrors the shape Trax itself produces server-side for
[TraxQuery(Namespace = "players")]-decorated trains. The same player is fetched
through both the flat typed request (mode D) and the nested-path variant to
show consumers don't need to fall back to raw-string mode when targeting a
namespaced schema.

PlayerSchemaConfiguration now exposes a discover.players.lookupPlayer surface
alongside the existing flat fields so the sample remains self-hosted (server +
client in one process). The existing flat-mode comparisons (A == E, A ~ D) are
unchanged.

v1.26.0

2026-05-19T22:56:53Z

feat(GameServer): demonstrate [TraxAllowAnonymous] on a [TraxQueryMod…

…el] entity (#60)

Adds PublicAnnouncement to the GameServer sample: anonymously readable
"news feed" entries with an optional FK to MatchRecord (admin-gated)
so the Option B no-cascade contract is exercised against a real host.

E2E suite (8 tests) covers anonymous + authenticated direct reads,
Connection-scalar reachability, the cascade-from-anonymous-to-gated
rejection path, and a regression check that the pre-existing
MatchRecord Admin gate still holds.

v1.25.0

2026-05-15T14:30:40Z

feat: Blazor Server sample exercising the SignalR sink (#58)

A single-process Blazor Server sample that wires UseSignalRHub end-to-end:

- A PingTrain scheduled every 10 seconds, executed by the scheduler's
default LocalWorkerService
- UseBroadcaster(b => b.UseSignalRHub(opts => opts.OnlyForEvents(...)))
so every lifecycle event flows to connected clients
- MapTraxTrainEventHub() at /hubs/trax-events
- A /events Blazor page that opens its own HubConnection, subscribes to
TrainEvent, and renders a rolling list of the last 50 events
- The Trax dashboard at /trax for parity with other samples

Verified end-to-end against a standalone Microsoft.AspNetCore.SignalR.Client
console: scheduled IPingTrain events arrive at the client with the default
TraxClientEvent shape and event types (Started / Completed).

Listens on http://localhost:5210. Uses the workspace Postgres from
docker-compose. No RabbitMQ needed — this is the standalone topology the
SignalR sink supports via its no-op transport fallbacks.

v1.24.0

2026-05-14T21:12:28Z

feat(GameServer): demonstrate [TraxAuthorize] on a [TraxQueryModel] e…

…ntity (#57)

* feat(GameServer): demonstrate [TraxAuthorize] on a [TraxQueryModel] entity

Gates MatchRecord with [TraxAuthorize(Roles = nameof(GameRole.Admin))] so
the sample shows how to expose a query-model entity to admins only. The
attribute attaches @authorize at both the entry field and ObjectType, so
top-level discover.matches.matchRecords and any transitive navigation
that resolves a MatchRecord are gated uniformly; totalCount and pageInfo
side channels are blocked too.

Pins the default authentication scheme to api-key so HC's @authorize
directive sees an authenticated principal when more than one scheme is
registered. With a single scheme, ASP.NET Core auto-selects it as
default; with multiple, no scheme is auto-default and HC reads an
anonymous principal — every gated query rejects every caller, including
admins. The pin is conditional on neither scheme nor environment, so it
applies consistently regardless of whether the Google JWT scheme is
configured.

Tests:
- Existing MatchRecord query / filter / pagination tests now use the
Admin key.
- New rejection tests cover Player and anonymous direct access plus
the totalCount-only side-channel case (proves field-level gating
closes the loophole that type-level alone would leave open).

* feat(GameServer): demonstrate [TraxAuthorize] on a [TraxQueryModel] entity

Gate MatchRecord with [TraxAuthorize(Roles = Admin)] so the sample demonstrates
per-model authorization end-to-end. The attribute attaches the @authorize
directive at both the entry field (discover.matches.matchRecords) and the
ObjectType level — Connection scalars like totalCount and pageInfo are blocked
too, so a Player API key cannot even enumerate match cardinality.

Existing MatchRecord query tests switched from PlayerKey to AdminKey. Three
new rejection-path tests pin the contract: Player and anonymous callers see
TRAX_AUTHORIZATION; totalCount-only queries are blocked even though they
never resolve a node of the gated type.

* test(GameServer.E2E): warmup MatchRecord auth cache before assertions

The three MatchRecords_*_ReturnsAuthorizationError tests fired the first
request against a [TraxAuthorize]-gated entity in the fixture lifecycle.
HotChocolate validates and caches operation documents on first execution.
If the validation pipeline runs while any part of the request pipeline
is still settling, the cached operation can capture a pre-gated state,
and that specific document permanently bypasses the directive. This
showed up in CI as a deterministic-on-cold-start, passes-on-rerun flake:
3 failures clustered in the first 400ms of GameServer.E2E execution,
then 102 other tests against the same entity passed for the next 2 min.

WarmupAuthorizationCache polls both gated query shapes with an anonymous
caller in [OneTimeSetUp]. Each shape is exercised until it returns
"Not authorized." once, which proves the directive is wired AND seeds
the operation cache with a validated entry that enforces it. Tests then
assert against a known steady-state cache.

Bounded by a 30s timeout that throws TimeoutException with a clear
diagnostic if the directive never attaches. Per the project's
determinism rule: polls the actual condition, fails loudly on timeout,
never sleeps as a stand-in for synchronisation.

Verified: 8 consecutive runs of the fixture pass in 253-273ms with no
variance.

v1.23.1

2026-05-12T17:13:37Z

fix(persisted-operations sample): demo a genuinely different hot-fix …

…doc (#56)

The hot-fix demo re-uploaded the same document text from manifest.json,
so it would have passed even if the underlying cache-invalidation path
in Trax.Api.GraphQL.PersistedOperations had been silently broken (and
in fact it was — see the matching fix in Trax.Api). The client now
re-uploads a shape-changed document (adds __typename) with
bypassShapeDiff and asserts the new field appears in the response, so
the sample fails loudly if HC's IDocumentCache / IPreparedOperationCache
are not invalidated on upsert.

Also extend POSTGRES_MULTIPLE_DATABASES with the trax_api_* databases
the Trax.Api integration tests need; CI creates these out-of-band and
local dev was the only place they were missing.

v1.23.0

2026-05-12T15:52:06Z

feat: wire dashboard into persisted-ops sample, route client through …

…GraphQL (#55)

- The persisted-ops sample API now hosts Trax.Dashboard at /trax,
giving the new Persisted Operations page a real backend to drive.
Adds the scheduler builder (no-op) so the dashboard's existing pages
(manifest groups, work queue, dead letters) compose, and scopes
UsePersistedOperationsEnforcement to /trax/graphql so it does not
buffer Blazor's SignalR traffic.
- The sample client drops its ServiceCollection + IPersistedOperationStore
bootstrap entirely. Manifest uploads now go through the
uploadPersistedOperation GraphQL mutation, which is what real shipped
clients and the dashboard both do. The client csproj loses every
Trax package reference.
- New MutationFlowTests E2E covering upload happy path, schema-mismatch
error projection, shape-diff with and without bypass, and deactivation
blocking future executions by id.

v1.22.0

2026-05-08T19:53:07Z

feat: persisted-operations sample + E2E test project (#53)

* feat: persisted-operations sample + E2E test project

Two-process sample under samples/PersistedOperations:
- Trax.Samples.PersistedOperations.Api: GraphQL host with persisted-op
enforcement enabled. Demonstrates AllowOperationsMatching for dev_*
carve-outs and shadow-mode logging.
- Trax.Samples.PersistedOperations.Client: console client that uploads
a manifest, sends a request by id, hot-fixes the document, and
re-queries to demonstrate the no-redeploy flow.

E2E test project under tests/Trax.Samples.PersistedOperations.E2E:
- WebApplicationFactory<Program>-hosted in-process API, real Postgres
via the docker-compose container.
- Enforcement, dev-prefix bypass, deactivate/restore lifecycle, hot-fix
flow tests. The persisted-id resolution path (3 tests) is currently
Ignored pending follow-up on HC v15's IOperationDocumentStorage
pipeline wiring; the storage layer itself is fully exercised by the
Trax.Api integration suite.

* fix: align rabbitmq creds with CI and reformat E2E tests

Switch the dev broker to trax/trax123 so local docker-compose mirrors
the CI service container, and apply csharpier formatting to two E2E
test files that were failing the format check.

v1.21.0

2026-05-06T16:59:36Z

ci: add postgres and rabbitmq services to release workflow (#52)

Release runs were failing in JobHunt.E2E because the workflow had no
Postgres available, so DatabaseMigrator.Migrate() couldn't open a
connection. PR builds already wire up both services; mirror the same
setup in nuget_release.yml so coverage uploads to Codecov on main.