gayankanishka/graphql-clean-architecture

This system is a conference management platform that enables the organization of sessions, speakers, and tracks, along with attendee registration and check-in. It exposes a GraphQL API for querying and mutating these entities, supported by a clean architecture with distinct application, domain, and infrastructure layers. The backend utilizes Entity Framework Core for persistence, supporting both in-memory and PostgreSQL databases, while real-time updates are handled via GraphQL subscriptions.

New GraphQL mutation endpoints have been introduced to manage Attendees, Sessions, Speakers, and Tracks. Users can now register and check in attendees, add, schedule, and rename sessions, add and modify speakers, and add or rename tracks through the GraphQL API.

src/GraphQL/Mutations · high confidence

New GraphQL node resolvers and field extensions have been added for Attendee, Session, Speaker, and Track entities, enabling object identification and relationship queries (e.g., a speaker's sessions, a session's attendees and speakers, a track's sessions). Additionally, a \UseUpperCase\ attribute and extension are introduced to automatically uppercase string fields in the GraphQL response.

src/GraphQL/Nodes · high confidence

Users can now subscribe to real-time updates for attendee check-ins and session scheduling events via GraphQL subscriptions. The new \AttendeeSubscriptions\ class enables live notifications when an attendee checks in to a session, while \SessionSubscriptions\ allows clients to receive updates when a session is scheduled. These changes introduce HotChocolate-based subscription endpoints that push events to connected clients.

src/GraphQL/Subscriptions · medium confidence

Users can now register new attendees, check them in for specific sessions, and retrieve attendee information. The update introduces commands for registering an attendee and checking them in for a session, alongside queries to fetch a single attendee by ID, a list of all attendees, attendees by session, and a count of check-ins for a session. This adds the core application logic for managing attendee data and session participation.

src/Application/Attendees · high confidence

Introduced new data loaders for Attendee, Session, Speaker, and Track entities, enabling efficient batch loading and caching of these resources within the persistence layer.

src/Infrastructure/Persistence/DataLoaders · high confidence

New repository implementations have been added to the infrastructure layer to handle data access for Attendee, Session, Speaker, and Track entities. Each repository provides standard CRUD operations (add, find by ID, update, and list all) using Entity Framework Core, enabling the application to persist and retrieve these core conference data types.

src/Infrastructure/Persistence/Repositories · high confidence

The application now supports creating, renaming, and scheduling sessions. New commands allow users to add a session with title, abstract, and speakers; rename an existing session; and schedule a session on a track with start and end times. A session filter input type is also introduced to allow filtering sessions by specific attributes, excluding the Id and TrackId fields.

src/Application/Sessions/Commands · high confidence

The application now supports creating and modifying speakers, as well as retrieving speaker data. Users can add a new speaker via the AddSpeaker command, update an existing speaker's name, bio, or website through the ModifySpeaker command, and fetch speaker details using several new queries: GetSpeakerById, GetSpeakers, GetSpeakersByIds, GetSpeakersBySessionId, and GetSessionSpeakers. These changes introduce the full set of application-layer operations for speaker entities.

src/Application/Speakers · medium confidence

Users can now create, rename, and retrieve tracks through new application-layer commands and queries. This includes the AddTrack and RenameTrack commands, along with queries to fetch a single track by ID or name, retrieve all tracks, and fetch multiple tracks by IDs or names.

src/Application/Tracks · high confidence

A new data import mechanism has been introduced to automatically populate the database with conference data (sessions, tracks, and speakers) from a JSON source. The \DataImporter\ class handles the parsing and mapping of this data, while \DataImporterExtensions\ integrates this import process into the application's startup sequence, ensuring the database is seeded with initial content when the schema is first created.

src/Infrastructure/Persistence/Imports · high confidence

The application now supports querying sessions through several new endpoints: fetching a single session by its ID, retrieving all sessions, listing sessions associated with a specific attendee, fetching sessions by speaker ID, and filtering sessions by track. These additions enable the UI or API consumers to retrieve session data in various contexts, supporting features like personal schedules, speaker listings, and track-based navigation.

src/Application/Sessions/Queries · high confidence

The initial database migration has been added to the persistence layer, establishing the foundational schema for the application. This includes tables for Attendees, Speakers, Tracks, and Sessions, along with join tables for SessionAttendee and SessionSpeaker. The migration defines the relationships between these entities, such as linking sessions to tracks and attendees to sessions, ensuring the database structure aligns with the domain model.

src/Infrastructure/Persistence/Migrations · high confidence

The GraphQL service is introduced with a new Dockerfile for containerization, a Program.cs entry point configuring HotChocolate with in-memory subscriptions and automatic persisted queries, and environment-specific appsettings files (Development, Staging, Production) that control logging levels and database configuration. The default configuration uses an in-memory database (UseInMemoryDatabase: true), while Staging and Production profiles explicitly disable it, implying a switch to a persistent database like PostgreSQL in those environments.

src/GraphQL · high confidence

A new ApplicationDbContext class has been added to the Infrastructure/Persistence layer, establishing the Entity Framework Core database context for the application. This class configures the database schema by defining DbSets for Session, Track, Speaker, and Attendee entities, and applies specific mappings for unique constraints and composite keys for many-to-many relationships (Session-Attendee and Speaker-Session).

src/Infrastructure/Persistence · high confidence

The project now includes a formalized solution structure with separate projects for GraphQL, Application, Domain, and Infrastructure, alongside a test project. A new GraphQL schema is defined in schema.graphql, and the application supports both In-Memory and PostgreSQL databases. Additionally, Docker Compose support is added with environment-specific configurations for development, staging, and production, allowing users to easily run the application in different environments.

(repo-wide) · high confidence

Users can now retrieve data for Attendees, Sessions, Speakers, and Tracks via new GraphQL query endpoints. Each entity exposes methods to fetch lists (with paging, filtering, and sorting where applicable) and specific items by ID or name, delegating to corresponding MediatR handlers.

src/GraphQL/Queries · high confidence

Added new interfaces in the application layer to support data access for Attendee, Session, Speaker, and Track entities. Each entity now has a corresponding repository interface (e.g., IAttendeeRepository, ISessionRepository) defining standard CRUD operations, alongside specific DataLoaders (e.g., IAttendeeByIdDataLoader, ISessionBySpeakerIdDataLoader) for optimized data fetching.

src/Application/Common/Interfaces · high confidence

The Application layer now includes a new DependencyInjection.cs file that registers MediatR and adds pipeline behaviors for unhandled exceptions and performance tracking. This enables the application to resolve MediatR handlers and apply cross-cutting concerns via MediatR's pipeline behavior pattern.

src/Application · high confidence

Introduced new domain models to support the application's data structure. This includes the \Payload\ and \UserError\ classes in the \Common\ namespace for handling results and errors, alongside new entity classes (\Attendee\, \Session\, \Speaker\, \Track\) and their associated join tables (\SessionAttendee\, \SessionSpeaker\) in the \Entities\ namespace. These files establish the core data contracts for the domain layer.

src/Domain · high confidence

The application now includes structured logging and performance monitoring for MediatR requests. A new LoggingBehaviour logs incoming requests, a PerformanceBehaviour logs warnings for requests taking longer than 500ms, and an UnhandledExceptionBehaviour captures unhandled exceptions. Additionally, the infrastructure layer provides Serilog configuration with console and Application Insights support.

src/Application/Common/Behaviours, src/Infrastructure/Logger · high confidence

The Infrastructure layer now registers the application's DbContext and repository implementations using the .NET dependency injection container. The system supports both an in-memory database (for testing or lightweight scenarios) and PostgreSQL (via Npgsql) for persistent storage, with the active store selected by the 'UseInMemoryDatabase' configuration flag. Additionally, GraphQL data loaders for attendees, sessions, speakers, and tracks are registered to optimize data fetching.

src/Infrastructure · medium confidence

Added new test cases in the GraphQL.Tests project that verify the Attendee schema structure and the behavior of the registerAttendee mutation. The tests use snapshot testing to ensure the GraphQL schema definition and mutation responses remain consistent.

tests · high confidence

The project's five .csproj files (Application, Domain, GraphQL, Infrastructure, and GraphQL.Tests) have been updated to use newer versions of their NuGet packages. Notable upgrades include HotChocolate packages (AspNetCore, Data, Execution, Types, PersistedQueries.InMemory) and GreenDonut all moving to version 12.12.1, Microsoft.EntityFrameworkCore to 6.0.7, Serilog.AspNetCore to 6.0.1, and xunit to 2.4.2. This ensures the application and its tests rely on the latest stable releases for these libraries.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 39 → 39 (+0.9)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 77 → 77 (+0.0)
• Architecture 93 → 93 (+0.0)
• Maturity 50 → 50 (+0.0)
• Readiness 45 → 46 (+1.5)
• Security 20 → 22 (+1.1)

• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium IaC: CKV2_GHA_1 (.github/workflows/docker-publish.yml)
• Medium IaC: CKV2_GHA_1 (.github/workflows/pr-build.yml)
• Medium IaC: CKV_DOCKER_3 (src/GraphQL/Dockerfile)
• Medium IaC: CKV_DOCKER_7 (src/GraphQL/Dockerfile)
• No exposed public API
• No tests discovered
• The README mentions Docker container orchestration but does not explain how to build and run the application from source, which is critical for a CLI project. (README.md)
• dormant codebase — no living knowledge left to concentrate
• redundant comment (src/Domain/Entities/Session.cs)

• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)
• End-of-life runtime: .NET net6.0
• High IaC: WD-COMPOSE-0002 (docker-compose.staging.yml)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium IaC: WD-DOCKER-0003 (src/GraphQL/Dockerfile)
• Medium IaC: WD-DOCKER-0003 (src/GraphQL/Dockerfile)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• …and 1 more

• Unchanged — 1 HTTP endpoints

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

gayankanishka/graphql-clean-architecture was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.