This is a submission for the GitHub Finish-Up-A-Thon Challenge
What I Built
Code Property Graph is a full-stack system designed to map any software project into a relational graph model. It allows you to visualize and navigate through your code's architecture—such as layers, projects, namespaces, and elements (classes, interfaces, records)—in a fully interactive way.
The project's biggest innovation is combining the Relational Paradigm (SQL Server + EF Core) with a Graph Vision (Knowledge Graph). There is no need to migrate to a native graph database; the backend models nodes and edges using classic tables and foreign keys, while the frontend translates all of this into a real-time mind map.
Beyond visually documenting the architecture, it features a Clean Architecture violation detection engine, immediately alerting you if a dependency rule is broken (for example, a Domain element depending on Infrastructure). All of this was built using the latest ecosystem versions: .NET 9.0 on the backend (using CQRS, MediatR, and Rich Entities) and React 18 + TypeScript + React Flow on the frontend.
Demo
The complete source code is available on my GitHub:
Code Property Graph Repository
Here is a glimpse of the interface mapping a system's dependencies:
The Comeback Story
The original idea for the Code Property Graph was born from a real pain point I've faced over years of dealing with complex systems. Designing solutions using Domain-Driven Design (DDD), patterns like CQRS, and Clean Architecture requires strict team discipline. I always felt the lack of a visual and pragmatic tool to validate these dependencies in real time, without the bureaucracy of parsing hundreds of .csproj files.
The project was sitting "in the drawer" as a conceptual proof of concept. For this Finish-Up-A-Thon, I finally decided to dust it off and finish the solution, elevating the technical level of the stack. The main changes to revive and complete the project included:
Backend Update: I refactored the core to use .NET 9.0, ensuring the entities were extremely rich (Rich Entities without Data Annotations) and implementing the Result Pattern to avoid exceptions in flow control.
React Flow Adoption: The old frontend didn't properly support rendering directional nodes. Integrating React Flow (@xyflow/react) with strict TypeScript typing completely changed the usability, allowing real-time filters and dependency highlighting (IMPLEMENTS and DEPENDS_ON).
Violation Engine: I completed the most important feature: the complex SQL queries via EF Core (AsSplitQuery) that automatically detect components bypassing Clean Architecture rules.
My Experience with GitHub Copilot
GitHub Copilot acted as a true senior pair programmer throughout the entire journey of finishing the project, accelerating the development cycle on essential fronts.
On the backend (.NET), it was brilliant at inferring the structure of my Fluent API in Entity Framework Core. When I needed to map composite keys for edges (like ElementImplementation and ElementDependency), Copilot auto-completed the relationship configurations and IEntityTypeConfiguration, respecting the AsNoTracking rule I had established. It also accelerated the creation of MediatR Handlers and validations via FluentValidation.
On the frontend, the biggest challenge was state management and the complex rendering of nodes. Copilot saved me hours of reading documentation by helping type custom React Flow nodes and writing Zustand selectors to manage filter options (layers, directories, and selected elements). Having this AI by my side eliminated repetitive boilerplate work and allowed me to focus entirely on the architecture and engineering of the data model.
Top comments (0)