neozhu/cleanaspire

CleanAspire is a multi-tenant inventory management system built on .NET 10 and Aspire, designed to handle product cataloging and stock operations across different organizations. It provides a comprehensive API and Blazor-based web interface for managing products, tracking inventory movements, and administering tenant accounts, with robust support for offline data synchronization and push notifications. The system enforces strict data validation and audit trails while supporting multiple database backends and file storage options.

A new Breadcrumbs component has been introduced to display navigation breadcrumbs alongside action buttons for saving, editing, deleting, and printing. This component allows parent pages to bind breadcrumb items and wire up event callbacks for these actions, providing a consistent UI pattern for page-level operations.

src/CleanAspire.ClientApp/Components/Breadcrumbs · high confidence

A new PaginatedResult generic class has been introduced in the application's common models to support paginated data responses. This model encapsulates the current page index, total item count, total page count, and the collection of items, providing properties to easily determine if previous or next pages are available. This change enables UI components, such as MudDataGrid, to properly handle and display paginated data sets.

src/CleanAspire.Application/Common/Models · high confidence

Introduces new application-layer queries for the Products feature, enabling users to retrieve product lists with pagination, filtering, and sorting, fetch individual products by ID, and export filtered products to a CSV stream. These queries implement FusionCache for performance optimization and map database entities to ProductDto objects for consistent data transfer.

src/CleanAspire.Application/Features/Products/Queries · high confidence

Users can now view, create, edit, and delete products via the new Products section. The Index page provides a paginated, searchable, and sortable data grid with multi-selection support for bulk deletion, as well as CSV import and export capabilities. The Edit page allows users to modify product details including SKU, name, category, unit of measure, price, currency, and description, with validation and offline status checks for export actions.

src/CleanAspire.ClientApp/Pages/Products · high confidence

Users can now dispatch and receive stock items through new application features. Dispatching reduces available inventory for a specific product and location, removing the stock record if the quantity reaches zero, while receiving increases inventory or creates a new stock entry if none exists. These operations are supported by validation rules ensuring product IDs, quantities, and locations are provided and valid, and are exposed via a paginated query that allows searching stocks by keywords across location, product name, SKU, and description.

src/CleanAspire.Application/Features/Stocks · high confidence

Introduced a new ProductDto class and ProductCategory enumeration in the application's product feature DTOs. This change defines the data structure for transferring product details, including fields for ID, SKU, name, category, description, price, currency, and unit of measure, enabling consistent data representation across application layers.

src/CleanAspire.Application/Features/Products/DTOs · high confidence

The new \src/CleanAspire.ServiceDefaults\ project provides a shared extension method, \AddServiceDefaults\, which centralizes the configuration of common .NET Aspire infrastructure. When referenced by service projects, this library automatically configures OpenTelemetry (including ASP.NET Core, HTTP client, and runtime instrumentation with OTLP export), enables service discovery and standard resilience handlers for HTTP clients, and registers default health checks. It also exposes \MapDefaultEndpoints\ to expose \/health\ and \/alive\ endpoints during development.

src/CleanAspire.ServiceDefaults · high confidence

The application layer now includes new pipeline behaviors to handle caching and request validation. FusionCacheBehaviour intercepts requests implementing IFusionCacheRequest to serve responses from FusionCache, while FusionCacheRefreshBehaviour clears cache entries by key or tag after write operations. Additionally, MessageValidatorBehaviour automatically validates messages implementing IRequiresValidation using FluentValidation before processing, throwing a ValidationException if constraints are violated.

src/CleanAspire.Application/Pipeline · high confidence

The domain layer now includes foundational base classes and interfaces for entity management. BaseEntity provides a string-based identifier (using GUID v7) and a domain event collection for tracking changes. BaseAuditableEntity adds standard audit fields (Created, CreatedBy, LastModified, LastModifiedBy), while BaseAuditableSoftDeleteEntity extends this with soft-delete capabilities (Deleted, DeletedBy). Supporting interfaces include IEntity, IAuditableEntity, ISoftDelete, and tenant-aware interfaces (IMustHaveTenant, IMayHaveTenant).

src/CleanAspire.Domain/Common · high confidence

The domain model in CleanAspire.Domain now includes new entity classes to support core business capabilities. A Product entity has been added with properties for SKU, name, category, description, price, currency, and unit of measure, along with a ProductCategory enum. Stock tracking is introduced via a Stock entity that links to a Product and records quantity and location. Multi-tenancy support is provided by a new Tenant entity. Additionally, an AuditTrail entity and AuditType enum have been added to record create, update, and delete operations on domain objects.

src/CleanAspire.Domain/Entities · high confidence

A new QueryableExtensions class has been added to the application layer, providing utility methods to simplify data retrieval. It introduces dynamic sorting capabilities (OrderBy, OrderByDescending, ThenBy, ThenByDescending) that resolve property names at runtime, and a ProjectToPaginatedDataAsync method that applies optional filters, handles pagination (skip/take), counts total records, and maps entities to result DTOs in a single async operation.

src/CleanAspire.Application/Common/QueryableExtensions · high confidence

The client application now includes new resource files (App.de-DE.resx, App.es-ES.resx, App.fr-FR.resx, App.ja-JP.resx, App.ko-KR.resx, App.pt-BR.resx) in the Resources directory, providing translated UI strings for German, Spanish, French, Japanese, Korean, and Brazilian Portuguese. This enables the application to display interface text in these languages when the user's locale is set accordingly.

src/CleanAspire.ClientApp/Resources · high confidence

The application now supports full CRUD operations for products through new command handlers. Users can create, update, and delete products, as well as import them in bulk via CSV files. Each operation triggers specific domain events (ProductCreatedEvent, ProductUpdatedEvent, ProductDeletedEvent) to notify subscribers of changes.

src/CleanAspire.Application/Features/Products/Commands · high confidence

This change introduces the application-layer logic for managing tenants, enabling users to create, update, delete, and retrieve tenant records. It includes commands for creating a new tenant with a name and description, updating existing tenant details, and deleting tenants by ID, as well as queries to fetch all tenants or a specific tenant by ID, returning data via a TenantDto.

src/CleanAspire.Application/Features/Tenants · high confidence

The application now includes structured configuration support via new \DatabaseSettings\ and \MinioOptions\ classes, allowing database providers, connection strings, and Minio storage endpoints to be explicitly configured and validated. Additionally, Serilog is integrated as the logging provider, automatically enriching logs with UTC timestamps, user identity, client IP, and activity IDs, while writing output to daily rolling text files and the console with specific minimum log levels for framework and third-party libraries.

src/CleanAspire.Infrastructure/Configurations · high confidence

This change introduces several new service implementations in the infrastructure layer to support core application capabilities. It adds a current user context mechanism (CurrentUserAccessor, CurrentUserContext, CurrentUserContextSetter) along with ClaimsPrincipal extensions to extract user identity and profile details from security tokens. It also implements file upload capabilities via two providers: a local FileUploadService for on-disk storage and a MinioUploadService for S3-compatible object storage, which includes automatic image resizing and format conversion. Finally, it provides a UtcDateTime service to abstract system time, ensuring consistent UTC handling across the application.

src/CleanAspire.Infrastructure/Services · high confidence

The client application now includes auto-generated Kiota request builders for the /account API surface, enabling direct programmatic access to user account operations. This adds support for email confirmation, password recovery, two-factor authentication (enable, disable, generate authenticator, and recovery codes), account deletion, profile updates, and social logins via Google and Microsoft.

src/CleanAspire.ClientApp/Client · high confidence

The CleanAspire.Api project is introduced with a new Dockerfile targeting .NET 10, establishing the runtime environment. The application now supports user signup, profile management, and account deletion via custom identity endpoints, replacing the standard register flow. Email verification and password recovery are enabled through a new SendGrid-based email sender. Additionally, Google authentication is configured, and Webpushr integration is added for push notifications. OpenAPI schema handling is improved with a custom transformer for numeric types, and Serilog is integrated for structured logging.

src/CleanAspire.Api · high confidence

The CleanAspire.ClientApp is introduced as a standalone Blazor WebAssembly application. It provides offline capabilities through IndexedDB caching and an offline sync service, persistent user preferences via local storage, and push notifications integrated with Webpushr. The client is configured for OIDC authentication and includes a Dockerfile with Nginx to serve the app over HTTPS.

src/CleanAspire.ClientApp · high confidence

The client application is initialized with a complete static asset structure. The \index.html\ entry point now includes comprehensive SEO metadata (Open Graph, Twitter Cards, JSON-LD) and integrates Google Analytics for tracking. The app is configured as a Progressive Web App (PWA) via \manifest.webmanifest\ and service workers (\service-worker.js\ for development, \service-worker.published.js\ for production offline caching). Configuration is externalized into \appsettings.json\ and \appsettings.Development.json\, defining the app name, version, and service base URL. The UI is enhanced with new SVG assets, including a branded icon, a loading spinner, a syncing indicator, and status point indicators.

src/CleanAspire.ClientApp/wwwroot · high confidence

The application now includes the initial database migration scripts for SQL Server, PostgreSQL, and SQLite, establishing the foundational schema. This update introduces core entities including Products (with SKU, price, and category), Stock (tracking quantity and location per product), Tenants (for multi-tenancy support), and AuditTrails. It also sets up the standard ASP.NET Core Identity tables for users, roles, and claims, ensuring the database structure is ready for the new product and tenant features.

src/Migrators · high confidence

The application now automatically initializes the database and populates it with default data upon startup. This includes creating two default tenant organizations, setting up an Administrator and Demo user with a standard password, and inserting sample product inventory (such as furniture and electronics) along with their initial stock levels, ensuring the system is ready for immediate use without manual data entry.

src/CleanAspire.Infrastructure/Persistence/Seed · high confidence

The repository has been initialized with the core solution structure, including the CleanAspire.sln and CleanAspire.slnx files defining the project hierarchy (Api, WebApp, ClientApp, Domain, etc.). A comprehensive .editorconfig has been added to enforce consistent code formatting and naming conventions across the codebase. To facilitate local development and debugging, a new Docker Compose setup is provided, featuring a debug configuration (docker-compose.debug.yml) and a production-ready compose file (docker-compose.yml) that orchestrates the API, WebApp, and ClientApp services. Additionally, a sample.env file and DEBUG-DEPLOYMENT.md guide have been added to help developers configure environment variables and run the application locally with minimal effort.

(repo-wide) · high confidence

This change introduces the new CleanAspire.WebApp project, which serves as the primary entry point for the Blazor Aspire application. It configures a hybrid rendering pipeline using both Interactive Server and Interactive WebAssembly components, integrates core services including authentication, localization, and HTTP clients, and enables antiforgery protection. The application is configured to run on .NET 10, with a dedicated Dockerfile that builds the app using .NET 10 SDK images and generates a self-signed HTTPS certificate for local development. The app version is set to v0.97 in the production settings.

src/CleanAspire.WebApp · high confidence

The application now supports a structured, dynamic navigation menu defined in the client-side navigation service. This change introduces a new \MenuItem\ model that includes optional descriptions and a \PageStatus\ enum (Completed, New, Coming Soon), allowing the UI to visually indicate the availability of features. The \NavbarMenu\ service provides a default hierarchical configuration for sections like Application, Reports, and Help, enabling users to see contextual information and status indicators for each navigation item.

src/CleanAspire.ClientApp/Services/Navigation · high confidence

Adds Entity Framework Core configuration classes to define the database schema for newly introduced domain entities. This includes configurations for Tenant (with unique name constraints), Product (with unique name indexing and string-based category storage), Stock (linked to Product with cascade deletion), AuditTrail (with JSON conversion for change tracking data), and ApplicationUser (extending identity with tenant, superior, and profile fields). These configurations ensure proper data integrity, relationship mapping, and storage behavior for the new multi-tenant and inventory management capabilities.

src/CleanAspire.Infrastructure/Persistence/Configurations · high confidence

The API now uses a new \IEndpointRegistrar\ interface and \EndpointExtensions\ to dynamically discover and register route groups, replacing the previous static registration approach. This change introduces several new capabilities: a full CRUD product management API with pagination and CSV import/export; a stock management API for dispatching and receiving inventory; a tenant management API for multi-tenancy operations; a file upload service supporting document uploads, image cropping, and antiforgery token generation; and a Webpushr configuration endpoint for push notification settings.

src/CleanAspire.Api/Endpoints · high confidence

A new abstract DomainEvent class has been added to the domain layer, implementing the INotification interface from the Mediator library. This class provides a standard base for domain events, automatically setting the occurrence timestamp to the current UTC time and tracking whether the event has been published, enabling consistent handling of domain notifications within the application.

src/CleanAspire.Domain/Events · high confidence

The application now exposes two new interfaces, IFusionCacheRequest and IFusionCacheRefreshRequest, within the Common/Interfaces/FusionCache namespace. These interfaces extend the MediatR IRequest pattern to standardize how commands and queries declare their cache keys and associated tags, enabling consistent caching behavior across the application's command and query handlers.

src/CleanAspire.Application/Common/Interfaces/FusionCache · high confidence

A new MudLoadingButton component has been added to the client application, providing a button wrapper that automatically handles loading states during asynchronous operations. Users can now display an indeterminate circular progress indicator (configurable as start or end adornment) while a button action is in progress, with options to disable the button during loading, customize the loading icon color, and provide custom loading content. The component inherits from MudBaseButton and manages the disabled state automatically based on the loading status.

src/CleanAspire.ClientApp/Components/LoadingButton · high confidence

Users can now manage their profile and account security through a new Settings page at /profile/setting. This includes updating personal details (nickname, username, language, time zone) and uploading an avatar image in the Profile tab, changing email addresses and deleting accounts in the Account tab, enabling offline mode for local data caching in the Offline Mode tab, and configuring two-factor authentication (authenticator app and recovery codes) in the Security tab.

src/CleanAspire.ClientApp/Pages/Account/Profile · high confidence

Users can now view stock levels and manage inventory movements directly within the client application. A new Stock Inquiry page displays a paginated, sortable, and searchable grid of stock items, including SKU, product details, location, quantity, and calculated amount. From this view, users can initiate stock receiving (inbound) or dispatching (outbound) operations via dialog forms that validate product selection, location, and quantity before submitting the changes to the backend.

src/CleanAspire.ClientApp/Pages/Stocks · high confidence

This update introduces several new Blazor components to the client application. A new \OfflineSyncStatus\ component provides visual feedback on the application's synchronization state, displaying idle, completed, or syncing indicators to the user. Additionally, new UI elements include a \Carousel\ for displaying testimonials, a \Thumbnail\ component for rendering file previews (images, PDFs, or generic files), a \PasswordInput\ with visibility toggle, a \LanguageSelector\ for switching localization, a \ConfirmationDialog\ for user confirmations, a \FileSizeFormatter\ for displaying file sizes, a \MudEnumSelect\ for handling enum-based selections (including flags), and a \WebpushrSetup\ component to initialize web push notifications when online.

src/CleanAspire.ClientApp/Components · high confidence

The Account area now includes a complete set of new Razor pages for user lifecycle management and third-party authentication. Users can sign up with organization selection, confirm email verification, and recover forgotten passwords via a multi-step reset flow. The sign-in experience has been expanded to support two-factor authentication and direct login via Google and Microsoft, with dedicated callback pages handling the external provider redirects.

src/CleanAspire.ClientApp/Pages/Account · high confidence

This change introduces a set of new interfaces in the application layer that define the core capabilities available to the system. IApplicationDbContext establishes the data model by exposing DbSets for Products, AuditTrails, Tenants, and Stocks, along with the SaveChangesAsync method. ICurrentUserAccessor, ICurrentUserContext, and ICurrentUserContextSetter provide the mechanism to retrieve and manage the current user's session information, including their ClaimsPrincipal, UserId, and TenantId. Additionally, IUploadService and its associated UploadRequest and UploadType definitions enable file upload functionality, supporting specific upload types such as Products, Images, Profile Pictures, and Documents, with options for folder placement and image resizing.

src/CleanAspire.Application/Common/Interfaces · high confidence

The application now includes a set of specialized autocomplete components in the ClientApp to streamline data selection. Users can search and select languages, time zones, and tenants (with tenant data fetched via the API client and cached for 60 minutes). Product selection is supported with fuzzy search across name, SKU, and description, and allows setting a default product. Additionally, picklist autocompletes provide predefined options for Units of Measure (e.g., EA, KG) and Currencies (e.g., USD, EUR), enabling consistent data entry for these specific fields.

src/CleanAspire.ClientApp/Components/Autocompletes · high confidence

This change introduces several new services in the client application to enhance user experience and resilience. The OfflineModeState and OfflineSyncService provide the foundation for offline capabilities, allowing users to toggle offline mode and track synchronization status. The LayoutService centralizes management of dark/light themes and right-to-left layout preferences, persisting them to local storage. Additionally, the LanguageService and SupportedLocalization class enable multi-language support for English, Chinese, German, French, Japanese, Spanish, Korean, and Portuguese. The ApiClientServiceProxy adds local caching via IndexedDB and robust error handling for API calls, while the DialogServiceHelper simplifies confirmation and custom dialog interactions.

src/CleanAspire.ClientApp/Services · high confidence

The application now includes a new infrastructure layer that centralizes dependency injection, database configuration, and caching. Users can now connect to PostgreSQL, SQL Server, or SQLite databases, with automatic migration assembly resolution and global query filters for soft-delete patterns. The system also integrates FusionCache for improved performance, featuring automatic fail-safe mechanisms, stale-while-revalidate strategies, and configurable timeouts to handle backend flakiness gracefully.

src/CleanAspire.Infrastructure · high confidence

The client application now includes a new Home page that serves as a marketing landing page, highlighting features such as .NET 10, Aspire, offline support, and AI code generation, along with links to the live demo and GitHub repository. Additionally, new Authentication, Privacy Policy, and Terms of Service pages have been added to handle user authentication flows and display legal information, while the global layout for pages has been updated to use ApplicationLayout.

src/CleanAspire.ClientApp/Pages · high confidence

A new dialog component has been introduced to allow users to create products directly from the interface. This dialog collects essential product details including SKU, name, category, unit of measure (UOM), price, currency, and description. It integrates with the existing product service to submit the new product data and provides immediate feedback via notifications for successful creation or validation errors.

src/CleanAspire.ClientApp/Pages/Products/Components · high confidence

The product service layer now includes a new \ProductCacheService\ and an updated \ProductServiceProxy\ that enable offline capabilities for product data. When the application is offline, product listings and individual product details are served from a local IndexedDB cache, ensuring the UI remains functional without a network connection. Additionally, create, update, and delete operations performed while offline are queued in local storage and automatically synchronized with the server once connectivity is restored, maintaining data consistency across devices.

src/CleanAspire.ClientApp/Services/Products · high confidence

A new app.css file has been added to the wwwroot directory to provide custom styling for the MudBlazor UI framework. This stylesheet overrides default component behaviors, specifically enforcing consistent typography sizes across inputs, tables, and chips, and adjusting layout properties for navigation links and grid items. It also introduces visual enhancements such as a rotating border animation for avatar containers to indicate status, and specific styling for the application's side menu and app bar special menus.

src/CleanAspire.WebApp/wwwroot · high confidence

The application now includes several new JavaScript modules in the wwwroot/js directory to enhance client-side capabilities. A new IndexedDB storage layer (indexeddbstorage.js) provides local caching with support for tags and expiration, replacing the previous Tavenem.Blazor.IndexedDB dependency. Additional utilities include a carousel initializer using Swiper (carousel.js), a file download helper (downloadfile.js), and a media previewer supporting images and PDFs via Fancybox (fancybox.js). Connectivity is improved with an online status monitor (onlinestatus.js) that bridges browser events to .NET, and push notification integration via Webpushr (webpushr.js).

src/CleanAspire.ClientApp/wwwroot/js · high confidence

The application layer now registers its core services via a new DependencyInjection setup. This includes configuring the Mediator library for scoped service lifetime, integrating FluentValidation, and adding pipeline behaviors for Fusion caching and message validation. Global imports have been updated to include these dependencies, enabling the use of mediator-based command/query handling and validation across the application.

src/CleanAspire.Application · high confidence

The client application now implements a new identity service layer that allows users to log in and maintain their session state even when offline. By integrating with IndexedDB, the system caches user credentials and profile data locally, enabling authentication checks and login attempts without an active network connection. This change introduces a \CookieAuthenticationStateProvider\ that manages online/offline states, a \CookieHandler\ to ensure credentials are sent with requests, and a \UserProfileStore\ to manage user profile events, effectively shifting authentication logic from purely server-driven to a hybrid client-side model.

src/CleanAspire.ClientApp/Services/Identity · high confidence

The application's root layout now includes comprehensive SEO optimizations, including Open Graph and Twitter Card meta tags, JSON-LD structured data, and a descriptive page title to improve search engine visibility and social media link previews. Additionally, Google Analytics (gtag.js) has been integrated into the head section for user tracking, and the Blazor render mode has been updated to InteractiveAutoRenderMode with prerendering disabled.

src/CleanAspire.WebApp/Components · high confidence

The application now enforces strict validation rules when managing products. Creating or updating a product requires a non-empty SKU (max 50 chars), name (max 100 chars), category, a positive price, a valid currency code (currently restricted to USD, EUR, GBP, CNY), and a unit of measure (max 10 chars). Deleting products requires at least one non-empty, non-whitespace product ID. These validators ensure data integrity before commands are processed.

src/CleanAspire.Application/Features/Products/Validators · high confidence

The application now uses a new \ApplicationDbContext\ that extends \IdentityDbContext\ to support user identity alongside domain entities including Tenants, AuditTrails, Products, and Stocks. This context is configured to apply entity configurations from the assembly and sets a default maximum length of 450 characters for string properties. Additionally, a \BlazorContextFactory\ has been added to provide \IDbContextFactory\ support, enabling scoped database context creation for Blazor Server-side scenarios.

src/CleanAspire.Infrastructure/Persistence · high confidence

The domain layer now includes a new ApplicationUser class that extends the standard IdentityUser to support additional user profile attributes (such as nickname, provider, avatar URL, timezone, and language code) and organizational hierarchy (superior ID). It also incorporates audit tracking fields (created, last modified) and token management properties (refresh token and expiry), enabling more detailed user management and session handling within the application.

src/CleanAspire.Domain/Identities · high confidence

The client app now includes dedicated JavaScript interop wrappers that enable new capabilities and replace previous dependencies. A new IndexedDbCache service provides local data caching with support for tags and expiration, replacing the external Tavenem.Blazor.IndexedDB library. OnlineStatusInterop allows the application to detect and react to network connectivity changes. Webpushr interop enables push notification integration. Additionally, new interop classes have been added to support UI features: DisplayModeInterop for detecting display modes, DownloadFileInterop for file downloads, Fancybox for image previews, and Swiper for carousel initialization.

src/CleanAspire.ClientApp/Services/JsInterop · high confidence

The application now uses a new theme definition in \Theme.cs\ for MudBlazor, introducing a modern visual style inspired by shadcn/ui. This includes a complete redefinition of the light and dark color palettes (e.g., primary colors shifted to slate/gray tones, specific hex codes for success/info/warning/error states), updated typography settings (font sizes, weights, and families), and new shadow/elevation definitions. Users will see a refreshed UI with updated colors, spacing, and text styling across both light and dark modes.

src/CleanAspire.ClientApp/Themes · high confidence

The application now uses a new layout hierarchy centered around MainLayout, ApplicationLayout, and AuthenticationLayout. The top bar (Appbar) includes a MudBlazor logo, language selector, dark mode toggle, RTL toggle, and a user menu. The sidebar (Navbar) features dynamic menu generation with support for special menus, sub-items, and badges for 'New' and 'Coming Soon' pages. User authentication is handled via AuthorizeView, redirecting unauthenticated users to sign-in and authenticated users to the home page. The user menu displays the user's avatar, name, email, and provides links to profile, settings, and logout. Online/offline status is displayed in the user menu and navbar.

src/CleanAspire.ClientApp/Layout · high confidence

A new app.css file has been added to define global styles for the MudBlazor-based UI. This includes adjustments for typography sizes across inputs, tables, and chips, as well as specific styling for the navigation menu, data grid toolbars, and user avatar containers with online status indicators.

src/CleanAspire.ClientApp/wwwroot/css · high confidence

The infrastructure layer now includes new EF Core interceptors to handle cross-cutting concerns automatically. The \AuditableEntityInterceptor\ automatically populates creation, modification, and deletion metadata (such as user ID, tenant ID, and timestamps) on entities implementing audit interfaces, and records detailed change trails for auditing purposes. Additionally, the \DispatchDomainEventsInterceptor\ ensures that domain events attached to entities are published via the Mediator pattern immediately after database changes are saved, wrapping the operation in a transaction to maintain consistency.

src/CleanAspire.Infrastructure/Persistence/Interceptors · high confidence

The API now returns standardized ProblemDetails responses for common error scenarios, including validation failures (422), database constraint violations (400), and not-found errors (404). This ensures clients receive consistent, machine-readable error information instead of generic server errors.

src/CleanAspire.Api/ExceptionHandlers · high confidence

New integration tests have been added to verify the application's core functionality and accessibility. StockEndpointTests validates the complete stock lifecycle—including pagination, receiving, and dispatching operations—against the API service, while WebTests ensures the Blazor web frontend returns a successful status code on the root path. Both test suites are configured to bypass server certificate validation to support local development and CI environments.

tests · high confidence

The application has been upgraded to target .NET 10.0 across all projects, including the API, WebApp, ClientApp, and infrastructure layers. The Blazor UI framework MudBlazor has been upgraded to version 9.6.0 in the client application. Additionally, the Aspire hosting infrastructure has been updated to version 13.4.6, and various other dependencies such as EF Core, Serilog, and FluentValidation have been updated to their latest compatible versions for the new runtime.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 57 (-3.6)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 73 → 71 (-2.0)
• Architecture 63 → 63 (+0.0)
• Maturity 66 → 67 (+0.8)
• Readiness 60 → 52 (-7.7)
• Security 56 → 56 (-0.3)
• Accessibility 73 → 61 (-11.7)
• Performance 73 → 72 (-0.6)

• Bounded contexts not declared
• High CVE: Scriban 6.5.0
• High CVE: Scriban 6.5.0
• High CVE: Scriban 6.5.0
• High CVE: Scriban 6.5.0
• High CVE: Scriban 6.5.0
• High CVE: Scriban 6.5.0
• High CVE: Scriban 6.5.0
• High CVE: Scriban 6.5.0
• High CVE: Scriban 6.5.0
• Medium CVE: Scriban 6.5.0
• Medium CVE: Scriban 6.5.0
• Medium CVE: Scriban 6.5.0
• Medium CVE: Scriban 6.5.0
• No exposed public API
• Off-boarding risk: anonymized user #1
• Split CleanAspire.ClientApp

• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AuditableEntityInterceptor.CreateAuditTrail (cognitive 21) (src/CleanAspire.Infrastructure/Persistence/Interceptors/AuditableEntityInterceptor.cs)
• ClassTooLong: IdentityApiAdditionalEndpointsExtensions (src/CleanAspire.Api/IdentityApiAdditionalEndpointsExtensions.cs)
• CommentedOutCode (src/CleanAspire.Api/IdentityApiAdditionalEndpointsExtensions.cs)
• CommentedOutCode (src/CleanAspire.Application/Features/Products/EventHandlers/ProductCreatedEvent.cs)
• CommentedOutCode (src/CleanAspire.Application/Features/Products/EventHandlers/ProductDeletedEvent.cs)
• CommentedOutCode (src/CleanAspire.Application/Features/Products/EventHandlers/ProductUpdatedEvent.cs)
• CommentedOutCode (src/CleanAspire.ClientApp/Pages/Account/EmailChangeConfirm.razor)
• CommentedOutCode (src/CleanAspire.ServiceDefaults/Extensions.cs)
• Critical IaC: DS-0031 (src/CleanAspire.Api/Dockerfile)
• Critical IaC: DS-0031 (src/CleanAspire.WebApp/Dockerfile)
• Dead code: GenerateChangeEmailContent (src/CleanAspire.Api/IdentityApiAdditionalEndpointsExtensions.cs)
• Dead code: GenerateSignupEmailContent (src/CleanAspire.Api/IdentityApiAdditionalEndpointsExtensions.cs)
• Dead code: GoogleAuthResponse (src/CleanAspire.Api/IdentityApiAdditionalEndpointsExtensions.cs)
• Dead code: MicrosoftUserInfo (src/CleanAspire.Api/IdentityApiAdditionalEndpointsExtensions.cs)
• …and 85 more

• Unchanged — 39 HTTP endpoints

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

neozhu/cleanaspire was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.