PASSED Generated 2026-06-29 20:41:23 UTC
Deterministic rule-pack matching from your schema — not AI inference. Rel types, traversal intents, and ontology export reflect active packs.
| Active packs | core.v1, hr-payroll.v1 |
|---|---|
| Semantic coverage | 9/9 FK edges typed (100%) |
| Golden schema | contoso-erp-hr — PASS |
| Traversal intents | included in Queries/ |
| Ontology export | Ontology/ folder included |
Each pass is one step in the compile pipeline. Included means files were produced; Skipped or Not enabled explains what to expect on a later run.
Turns each entity in your spreadsheet into a graph object your application can load, save, and display. This is the shared vocabulary every other part of the delivery builds on.
Names how records connect — for example who reports to whom or which team someone belongs to. Everyone on the project uses the same relationship words in queries, APIs, and documentation.
Provides the data-access layer that reads and writes the graph without hand-writing database queries in every feature. Your developers inject these services and focus on business logic.
Delivers ready-made screens and REST endpoints so people and other systems can browse and update the graph on day one. Shortens the path from model to working product.
Wires the graph database and all generated services into your app with a single registration call. Reduces setup mistakes and keeps deployment repeatable across environments.
Defines the database rules that keep IDs unique and lookups fast. Applying this once gives you a trustworthy foundation before any data is loaded.
When your model changes, shows what is new, removed, or altered so you can upgrade production safely. Avoids silent drift between spreadsheets, code, and live databases.
Gives front-end teams typed models and a ready API client so web apps can call the graph without guesswork. Speeds UI delivery and reduces integration bugs.
Produces visual maps of entities and relationships for stakeholders, onboarding, and design reviews. Helps non-developers understand the system without reading code.
Keeps the graph aligned when your main SQL or ERP database changes — no manual double-entry. Critical for hybrid deployments where the graph is a live mirror, not a one-off export.
Bulk-loads initial data in the correct order so foreign keys and relationships resolve on first run. Gets you from empty database to demo-ready quickly.
Pre-built analytics that are awkward in SQL — org hierarchies, impact analysis, shortest paths, orphan detection. Delivers immediate business value from the graph shape.
Interactive API documentation your team can try in a browser. Speeds QA, partner integrations, and internal discovery of what the graph can do.
Importable test suite covering every endpoint with sample payloads. Lets integrators validate the API before your UI is finished.
Copy-paste graph queries for dashboards, reports, and ad-hoc exploration — including named business questions when the semantic layer is on. Bridges the gap between IT and analysts who think in org charts, not Cypher.
A standalone database package with import scripts and Docker setup — run Neo4j without deploying the full application. Useful for data teams, pilots, and offline analytics.
Machine-readable map of your domain concepts, rule packs, and relationship meanings for governance and AI tooling. Turns the graph from a code artifact into an enterprise asset others can discover and trust.
None — the model passed validation cleanly.
Each spreadsheet entity becomes a concrete graph object your app can display and update. This is the foundation the rest of the delivery — APIs, sync, queries — all reference.
POCO classes mapped to Neo4j node labels (one per entity), each with the SqlId sync key and FromINode / FromRecord factories.
How to use: Returned by the graph repositories; bind them to your DTOs or views.
Standardizes connection names so org charts, roll-ups, and traversals mean the same thing in every layer. Prevents teams from inventing conflicting labels as the project grows.
Constant string definitions per entity — domain semantic types (e.g. REPORTS_TO, HOLDS_ROLE) when the semantic layer is enabled, plus optional HAS_* structural aliases for migration.
How to use: Reference these constants instead of hard-coding Cypher relationship names.
Defines the contract for how features talk to the graph — stable, testable, and swappable. Product owners get predictable CRUD and navigation without caring about Cypher.
Async repository contracts per entity: CRUD plus CreateRelTo… (outgoing FKs) and Get…List (incoming traversals).
How to use: Inject I{Entity}GraphRepository; implementations are registered by AddNeo4jGraphDb().
The working engine behind the interfaces — safe reads and writes your developers call from business code. Delivers data access ready for production, not prototype scripts.
Cypher-backed implementations of the repository interfaces (parameterised, async, session-scoped).
How to use: Resolved automatically through DI — no manual wiring.
Optional browser UI scaffolding for internal tools and demos. Gives stakeholders something clickable while a custom front end is still in progress.
Server-rendered CRUD controllers per entity, plus link/traversal actions.
How to use: Add Razor views, or use them as a reference for your own UI.
Self-service API discovery for QA, partners, and new developers. Reduces back-and-forth about which endpoints exist and what they accept.
The AddGraphApiSwagger() DI extension that registers OpenAPI docs for the graph API.
How to use: Call it in Program.cs and add app.UseSwagger()/UseSwaggerUI(); needs Swashbuckle.AspNetCore.
The integration surface other systems and mobile apps connect to. Turns your graph into a product other teams can consume on day one.
REST controllers at api/graph/{entity} with CRUD, relationship-link, and traversal routes and [ProducesResponseType] metadata.
How to use: Call from any client; the Postman collection and TypeScript client below match these routes.
One registration call wires the entire graph stack into your application. Makes deployment repeatable and lowers the bar for any developer to run the graph locally.
GraphDbContext (the Neo4j IDriver wrapper) and GraphServiceExtensions (the one-call AddNeo4jGraphDb registration of the driver, repositories, sync services, seeders, insights and schema).
How to use: builder.Services.AddNeo4jGraphDb(builder.Configuration); add a "Neo4j" section (Uri/Username/Password) to appsettings.json.
Database guardrails that prevent duplicate records and speed up everyday lookups. Applying this once protects data quality before users or batch jobs load anything.
schema.cypher (uniqueness on SqlId + Code/Name indexes) and GraphSchemaInitializer for applying the same statements from code.
How to use: Run schema.cypher once per database, or call GraphSchemaInitializer.ApplyAsync() at startup (statements are idempotent).
Keeps the graph current when your ERP or SQL database changes — no manual re-export. Essential when the graph is a live operational view, not a one-time migration.
Per-entity services that mirror relational writes into Neo4j (MERGE on SqlId) and refresh outgoing relationships.
How to use: Call I{Entity}GraphSyncService.SyncAsync(entity) after your ORM SaveChanges, and DeleteAsync(sqlId) after deletes.
Ordered first-load path from existing relational data to a populated graph. Gets pilots and demos to a credible state without writing custom import scripts.
SeedOrder (FK-topologically sorted), GraphSeeder (relational → Neo4j bulk load via the sync services) and SqlSeeder (ordered key-data hook skeleton).
How to use: await graphSeeder.SeedAllAsync() for the first-time bulk load; subclass SqlSeeder for key data.
Ready-made answers to questions executives ask — who rolls up to whom, what breaks if X changes, what is orphaned. Delivers graph ROI without waiting for a data science team.
GraphInsightsRepository — the cross-entity queries SQL is bad at: hierarchy up/down, impact analysis, shortest path, orphan detection (identifier-whitelisted, injection-safe).
How to use: Inject IGraphInsightsRepository and call e.g. GetHierarchyUpAsync / GetShortestPathAsync.
Analyst-friendly query cookbook for dashboards and ad-hoc exploration. Bridges IT and business users who think in org charts and reporting lines, not database syntax.
sample-queries.cypher (ready-to-run Cypher organized by visualization, CRUD, traversals, hierarchy, impact, data quality) and GraphQueryRepository (typed async methods). Includes named traversal intents when the semantic layer is on.
How to use: Run sections in Neo4j Browser or call GraphQueryRepository from your app; Starter+ plans gate this folder in API downloads.
A shareable map of what your domain means — concepts, packs, and relationship semantics. Supports governance, search, and AI tools that need to understand your business vocabulary.
ontology.json (concepts, active packs, traversal intents), semantic-coverage.json, and README — machine-readable taxonomy from the rule-engine overlay.
How to use: Feed ontology.json to governance catalogs, GraphRAG tooling, or alignment checks. Pro+ plans gate this folder in API downloads.
Click-to-run API tests for integrators and QA before the UI exists. Shortens partner onboarding and regression cycles.
An importable collection with one folder per entity covering every endpoint, with typed sample bodies and a {{baseUrl}} variable.
How to use: Import into Postman and set the baseUrl variable.
Front-end ready types and HTTP client so web teams ship faster with fewer integration defects. Keeps UI and API in sync as the model evolves.
models.ts (node interfaces) and graphApiClient.ts (a framework-agnostic typed fetch client matching the API routes).
How to use: Drop into an Angular/React/Node project: new GraphApi(baseUrl).
Visual documentation generator output for stakeholders who will never open the ZIP. Supports onboarding, architecture reviews, and alignment workshops.
Mermaid ER diagram, a grouped graph model, one per-feature view each, and a GraphViz DOT.
How to use: Render the .mmd files on GitHub / mermaid.live; render the .dot with graphviz (dot -Tsvg).
A self-contained database you can stand up without the full application — ideal for data teams, pilots, and offline analytics. Proves the graph works end-to-end even when app deployment is later.
A neo4j-admin import blueprint: header CSVs + data templates, import scripts (ps1/sh), docker-compose, and post-import.cypher.
How to use: docker compose up, run neo4j-import, then apply post-import.cypher — see the bundle's README.md.
| Entity | Feature | Scalars | Outgoing | Incoming |
|---|---|---|---|---|
| Company | Administration | 4 | 0 | 1 |
| Department | Organization | 3 | 1 | 2 |
| Designation | HR | 2 | 2 | 1 |
| Employee | HR | 5 | 5 | 0 |
| EmployeeType | Administration | 2 | 0 | 0 |
| Team | Organization | 2 | 1 | 1 |