Wiki

bit Boilerplate built-in wiki
Each project created from bit Boilerplate includes comprehensive documentation in markdown format. These files are located in the .docs folder of your project and cover all aspects of the boilerplate architecture, features, and best practices.

You can read these markdown files directly in your IDE (Visual Studio Code is recommended) or browse them on GitHub after pushing your project to a repository.


Wiki's Comprehensive Stages:

The Wiki guide covers your entire project architecture across 25 detailed stages. Each stage provides real examples from your own project:
Stage 1: Entity Framework Core

Learn about DbContext, entity models, entity type configurations, and migrations. Understand nullable reference types in EF Core relationships and client-side offline database support.

Stage 2: DTOs, Mappers, and Mapperly

Explore Data Transfer Objects, `AppJsonContext`, and how Mapperly simplifies object mapping. Learn the difference between Project() and Map() methods, and how Patch() updates client-side objects.

Stage 3: API Controllers and OData

Understand controller architecture, [AutoInject] attribute, and OData query support ($filter, $top, $skip, $orderby). Learn about PagedResult for total counts, data security, and optimized performance patterns.

Stage 4: Background Jobs and CancellationToken Management

Discover automatic request cancellation, CancellationToken usage, NavigationLock for critical operations, and Hangfire for reliable background job processing with persistence.

Stage 5: Localization and Multi-language Support

Master resource files (resx), `DtoResourceType` attribute, `AppDataAnnotationsValidator`, IStringLocalizer usage, and the `bit-resx` tool for managing translations.

Stage 6: Exception Handling and Error Management

Learn about Known vs Unknown exceptions, safe exception throwing, `WithData()` and `WithExtensionData()` methods, automatic exception handling in Blazor, and `WrapHandled()` for event handlers.

Stage 7: ASP.NET Core Identity / Authentication & Authorization

Comprehensive coverage of JWT tokens (access/refresh), session management, SSO integration (Google, GitHub, Azure AD, etc.), role-based and policy-based authorization, and identity configuration.

Stage 8: Blazor Pages, Components, Styling & Navigation

Understand the three-file structure (.razor, .razor.cs, .razor.scss), isolated component styles, global styles, ::deep selector, Bit.BlazorUI components, and navigation with `PageUrls`.

Stage 9: Dependency Injection & Service Registration

Explore service registration patterns across different projects, `AddSessioned` method for session-scoped services, and appropriate service lifetimes (Singleton, Scoped, Transient, `Sessioned`).

Stage 10: Configuration (appsettings.json)

Learn about configuration hierarchy across projects, appsettings.{environment}.json files, configuration priority, and how to use *__Comment for JSON comments.

Stage 11: TypeScript, Build Process & JavaScript Interop

Understand TypeScript integration, MSBuild targets for JavaScript compilation, `IJSRuntimeExtensions` for C#-to-JS calls, and how to add npm packages with type definitions.

Stage 12: Blazor Modes, PreRendering & PWA

Explore Blazor Server, WebAssembly, and Auto modes, pre-rendering configuration for SEO and performance, PWA capabilities, service workers, and `IPrerenderStateService`.

Stage 13: Force Update System

Learn how `ForceUpdateMiddleware` validates app versions on every request, supports platform-specific update behaviors (auto-update for web/Windows, store redirect for mobile), and ensures all users run supported versions.

Stage 14: Response Caching System

Master multi-layer caching: client-side memory cache, browser HTTP cache, CDN edge cache, and ASP.NET Core Output Cache. Learn about `AppResponseCache` attribute, cache purging with `ResponseCacheService`, and optimizing performance.

Stage 15: Logging, OpenTelemetry and Health Checks

Understand ILogger for logging, `ActivitySource` and `Meter` for tracking operations, in-app Diagnostic Modal, integration with Sentry and Azure App Insights, Aspire Dashboard, and built-in health checks.

Stage 16: CI/CD Pipeline and Environments

Explore workflow files, environment configuration (Development, Staging, Production), build and deployment pipelines for client platforms, and best practices for secure backend deployment.

Stage 17: Automated Testing (Unitigration Tests)

Learn about the Unitigration Test approach that combines the benefits of Unit Tests and Integration Tests, UI tests with real server behavior, and flexible test architecture.

Stage 18: Other Available Prompt Templates

Discover additional specialized prompt templates available in the .github/prompts/ directory for specific development tasks and scenarios.

Stage 19: Project Miscellaneous Files

Review important configuration files: Clean scripts, global.json, vs-spell.dic, settings.VisualStudio.json, mcp.json, Directory.Build.props, Directory.Packages.props, and .vsconfig.

Stage 20: .NET Aspire

Understand .NET Aspire benefits for development (dashboard monitoring) and deployment (Azure, Docker Compose, Kubernetes). Learn database persistence configuration and Linux testing with Dev Containers.

Stage 21: .NET MAUI / Blazor Hybrid

Explore native platform capabilities on Android, iOS, macOS, and Windows. Learn about Deep Links/Universal Links, `ApplicationVersion` for app stores, Windows project advantages, and WebView considerations.

Stage 22: Messaging

Master in-app messaging with `PubSubService`, JavaScript-to-C# communication with `AppJsBridge`, real-time server-to-client messaging with SignalR, and push notifications with deep linking.

Stage 23: Diagnostic Modal

Explore the powerful in-app diagnostic tools, including browser DevTools that work on mobile devices and real-time log viewing capabilities.

Stage 24: WebAuthn and Passwordless Authentication (Advanced)

Learn about biometric authentication (fingerprint, Face ID, PIN) that's more secure than native implementations, cross-platform support.

Stage 25: RAG / Semantic Search with Vector Embeddings (Advanced)

Understand vector embeddings for semantic search, cross-language search capabilities, embedding models (OpenAI, Azure, Hugging Face), and how to implement RAG (Retrieval-Augmented Generation) patterns.


AI-Powered Wiki
You can also visit wiki.bitplatform.dev anytime to ask questions about bit Boilerplate and the entire bitplatform ecosystem.

To enhance the understanding of our Open Source Project Repository, all documentation is maintained within a single mono repo. This approach ensures that the AI Wiki can cohesively analyze the entire set of documents, README files, in-code comments, and source code to provide comprehensive insights when queried.

Here are some example questions that can be answered by wiki.bitplatform.dev:
  • What is the optimal way to load page data using StateHasChanged in conjunction with a Skeleton UI or Shimmer? Link

  • How can I remove google reCAPTCHA from a project I created from bit Boilerplate? Link

  • What is the difference between Patch and Map, and what is their relationship with Entity Framework Core and Blazor change tracking? Link

  • How can I implement a Grid System and layout using BitGrid and BitStack components, especially if I'm familiar with the Bootstrap grid system? Link

  • How does a refresh token function in a Boilerplate project template? Link

  • How does passwordless authentication work in Boilerplate, particularly in Blazor Hybrid versions of the app, given that this feature is browser-only? Link

  • How does using embeddings with the PostgreSQL vector extension enable product search functionality via LINQ and Entity Framework Core? Link