Bundles

The problem

Granit ships 164 packages. That level of granularity is great for control, but overwhelming when you just want to start a new project. You should not have to know the full module graph to get a working API up.

Bundles solve this. A bundle is a meta-package that pulls in a curated set of related modules. One package reference, one Add*() call, and the entire group is wired.

Available bundles

Bundle	Includes	Use case
Essentials	Core, Timing, Guids, Validation, ExceptionHandling, Observability	Every project
Api	Essentials + ApiVersioning, ApiDocumentation, Cors, Idempotency, Cookies	REST API projects
Documents	Templating.Scriban, DocumentGeneration.Pdf, DocumentGeneration.Excel	Document generation
Notifications	Notifications + Email.Smtp, Sms, Push, SignalR	Multi-channel notifications
SaaS	Api + MultiTenancy, Settings, Features, Localization, BackgroundJobs, Caching.Hybrid	Full SaaS platform

Each bundle is a NuGet meta-package with no code of its own. It only declares dependencies on the modules it groups.

Bundle contents at a glance

Package	Essentials	Api	Notifications	Documents	SaaS
`Granit.Core`	✓	✓	✓		✓
`Granit.Timing`	✓	✓	✓		✓
`Granit.Guids`	✓	✓	✓		✓
`Granit.Validation`	✓	✓	✓		✓
`Granit.ExceptionHandling`	✓	✓	✓		✓
`Granit.Observability`	✓	✓	✓		✓
`Granit.ApiVersioning`		✓			✓
`Granit.ApiDocumentation`		✓			✓
`Granit.Cors`		✓			✓
`Granit.Idempotency`		✓			✓
`Granit.Cookies`		✓			✓
`Granit.Notifications`			✓		✓
`Granit.Notifications.Email.Smtp`			✓
`Granit.Notifications.Sms`			✓
`Granit.Notifications.Push`			✓
`Granit.Notifications.SignalR`			✓
`Granit.Templating.Scriban`				✓
`Granit.DocumentGeneration.Pdf`				✓
`Granit.DocumentGeneration.Excel`				✓
`Granit.MultiTenancy`					✓
`Granit.Settings`					✓
`Granit.Features`					✓
`Granit.Localization`					✓
`Granit.BackgroundJobs`					✓
`Granit.Caching.Hybrid`					✓

SaaS inherits everything in Api, which inherits everything in Essentials. The Notifications and Documents bundles are standalone — add them on top of any base.

Usage

Reference the bundle package and call the corresponding method on the Granit builder:

Single bundle
Multiple bundles

builder.AddGranit<AppModule>(granit => granit
    .AddSaaS());

builder.AddGranit<AppModule>(granit => granit
    .AddApi()
    .AddNotifications()
    .AddDocuments());

GranitBuilder fluent API

Bundles are built on the same GranitBuilder fluent API that individual modules use. If a bundle groups more than you need, skip it and pick modules directly:

builder.AddGranit<AppModule>(granit => granit
    .AddEssentials()
    .AddModule<GranitTemplatingScribanModule>()
    .AddModule<GranitDocumentGenerationPdfModule>());

This gives you full control without losing the ergonomics of the builder pattern.

Bundles are additive

You can combine any number of bundles in a single call. Deduplication is automatic: the module dependency graph tracks what is already registered and skips duplicates. Calling .AddSaaS() (which includes Api, which includes Essentials) and then .AddNotifications() works without conflict.

// SaaS already includes Api and Essentials — no duplicates
builder.AddGranit<AppModule>(granit => granit
    .AddSaaS()
    .AddNotifications()
    .AddDocuments());

When NOT to use bundles

Bundles are convenience, not requirement. If your project only needs two or three specific packages, reference them directly:

<PackageReference Include="Granit.Core" />
<PackageReference Include="Granit.Observability" />
<PackageReference Include="Granit.ExceptionHandling" />

This keeps your dependency footprint minimal and avoids pulling in modules you will never configure.