Skip to content

EF Core Explorer ​

The EF Core Explorer (/efcore) lists every EF Core DbContext registered across your fleet, with its provider and database identity, how it relates to Wolverine, its entity map, and an on-demand pending-migrations probe.

Route: /efcore. It is the relational peer of the Document Store Explorer and the Event Store Explorer: EF Core persistence fits neither of those, so it gets its own surface.

Scope ​

Fleet-wide by default, grouped under a per-service heading with each service's context count. Narrow to one service with the global service selector in the header — the same control the other explorers read. When scoped, the per-service headings disappear (they would just repeat the header).

A ?service= deep link wins on arrival and is written back to the URL as you change scope, so the link you copy is the view you are looking at. A pick that names a service with no DbContext says so ("TripService reports no EF Core DbContexts") and tells you to clear the header selector to see the whole fleet, rather than rendering the whole fleet under a header that names one service.

Only services reporting at least one DbContext appear; if none do, the page reads "No services report an EF Core DbContext yet."

Overview ​

With nothing selected the page opens on Overview: every service, context and entity, as a tree or as a table you can sort and filter. It is the same view as the Document Store Explorer's Overview, and Wolverine's own inbox and outbox tables are left out of it. Choosing an entity opens its rows on the Contexts tab.

Row counts are on demand, for the same reason: each one reads a table. A multi-tenanted context offers no count, because it is read one tenant at a time and refuses a read across tenants.

A link can name a context and an entity:

text
/efcore?service=ItemService&context=efcore://ItemsDbContext&entity=ItemService.Item&tenant=acme

The page brings that context into view with its rows open on the entity. tenant only matters on a multi-tenanted context. The URL follows what you browse, so the link you copy is the view you are looking at. A projection that writes through a DbContext links here the way a document projection links to the Document Store Explorer, as long as exactly one context maps its type.

The DbContext card ​

Each context renders as a card — the same renderer the per-service surface uses, so the two never drift.

Badges ​

Along the header, next to the context's subject URI:

BadgeMeaning
Wolverine / PlainWhether Wolverine's envelope storage shares this context's connection. On Wolverine, domain events and outgoing messages publish atomically with SaveChangesAsync. On Plain, Wolverine is not driving this context's transaction.
TenancyThe context's tenancy style; Single when it is not multi-tenanted.
Tx:The transaction mode in force.
Domain eventsThe domain-events mode, when it is anything other than None.
Outbox:The outbox integration, when it is anything other than None.
Wolverine-managedPresent when Wolverine owns this context's migrations.

Identity and migrations ​

A description row carries the Provider, the Database name and the Server, plus a Pending migrations cell.

The pending-migrations count shown at rest comes from the service's reported summary. The Check pending migrations button asks the service to look right now — the result replaces the summary count and expands into a list of the actual migration names. This is a live probe against the service's database, not a cached value, which is what makes it worth clicking before a deploy.

Sagas ​

When the context stores sagas, its saga types render as chips. The Saga Explorer is the fleet-wide view of the same information.

Configuration ​

The generic configuration block renders the context's full options description, with per-property tooltips sourced from the underlying library's XML docs.

Entities ​

A table of the context's entities: Type (tagged Saga, Owned or View where that applies), Table, Primary key, and index / foreign-key counts. Expanding a row shows its CLR type, full table name, primary key, concurrency token and discriminator, then two nested tables — every index (name, uniqueness, columns) and every foreign key (name, target table, key columns).

This is the mapping EF Core actually built, read back from the running service — so it answers "did my configuration take effect?" without attaching a debugger.

CREATE script ​

Show CREATE script in an expanded entity, or in the Entity configuration drawer over its rows, asks the service for the script that creates the entity's table: the CREATE TABLE with its keys and foreign keys, then each CREATE INDEX. The service builds it from the model, so it is the model's script and not the database's: a database behind on its migrations will differ. Check pending migrations above is what asks the database.

It is fetched when asked for, as a document's DDL is, because a context's scripts are too large to send with every snapshot of the service. One context is answered whole, so the next entity of that context shows at once. The console keeps the answer until the service's version changes.

Not every entity has a script, and the panel says which case you are looking at:

  • A view has none, so the panel says that without asking the service.
  • A provider with no SQL, such as Cosmos or InMemory, has none for any entity.
  • An entity with no table of its own to create has none: one excluded from migrations, or mapped to a SQL query or a function.

An entity that shares a table, such as an owned type or a subclass in a hierarchy, shows that table's script. When the service cannot answer, the panel shows the reason and offers Try again. That also covers a service that reports two contexts under one short name, which it refuses to guess between.

Browsing rows ​

Browse rows reads the entity's rows through the Document Store Explorer's page, so filtering, ordering, saved filters, columns, exports and Explain work the same way. What differs:

  • Entity configuration shows the entity's table, keys, indexes and foreign keys, as reported, and its CREATE script on request.
  • Index advice speaks EF Core. A filter nothing covers suggests modelBuilder.Entity<T>().HasIndex(...), to add to OnModelCreating and build with a migration. A path through an owned type or a navigation gets no line, because its index belongs on that entity. EF Core reports column names and a filter names properties, so a column renamed with HasColumnName can read as uncovered: the estimate says "probably", and Explain is the database's own answer.
  • Nothing that needs a document's metadata. An entity has no last-modified, version or soft-delete columns of its own, so Newest first, Include deleted, Health and the metadata filters are not offered.
  • A multi-tenanted context needs a tenant before it reads anything, entered above the rows.