Avanade/Liquid-Application-Framework

This release marks a significant modernization of the Liquid Application Framework, upgrading all components to target .NET 8.0 and introducing a comprehensive set of new features across caching, messaging, and data access layers. Key additions include robust distributed cache integrations for Memory, Redis, SQL Server, and NCache, alongside new messaging adapters for Kafka, RabbitMQ, and Azure Service Bus. The framework also expands its data access capabilities with new repositories for Entity Framework, MongoDB, and OData, while introducing GenAI, Dataverse, and Azure Storage integrations. To support these changes, the release provides extensive unit test coverage for the new and refactored components, ensuring reliability across the updated codebase.

The Liquid.Messaging.ServiceBus package now provides a complete implementation for Azure Service Bus, introducing the \IServiceBusFactory\ interface and its \ServiceBusFactory\ concrete class to manage client creation for senders, receivers, and processors. The \ServiceBusConsumer\ class implements \ILiquidConsumer\ to handle incoming messages using \JsonSerializer\ for body deserialization, while \ServiceBusProducer\ serializes outgoing messages to UTF-8 JSON bytes. Configuration is driven by \ServiceBusSettings\ and \ServiceBusSettingsItem\ entities, allowing users to configure connection strings, entity paths, and receive modes.

src/Liquid.Messaging.ServiceBus · high confidence

Introduces a new Dataverse integration layer that provides a factory for creating client connections, a mapper for converting JSON strings to Dataverse entities, and a service implementation for standard CRUD operations (Create, Read, Update, Delete) and metadata retrieval. The change also registers these components via dependency injection, allowing the application to interact with Microsoft Dataverse using configuration-driven settings.

src/Liquid.Dataverse · high confidence

The Liquid.Core.Telemetry.ElasticApm module now provides initial support for Elastic APM telemetry. This includes an IApplicationBuilder extension to conditionally enable the Elastic APM middleware, and an IServiceCollection extension to register the core telemetry interceptor and a MediatR pipeline behavior for request/response tracing. The implementation uses configuration checks to ensure telemetry is only active when Elastic APM is explicitly enabled.

src/Liquid.Core.Telemetry.ElasticApm · medium confidence

The \Liquid.Cache.SqlServer\ package now provides a new \AddLiquidSqlServerDistributedCache\ extension method. This method registers the standard \SqlServerCache\ service and wraps it with the \LiquidCache\ decorator, which includes a \LiquidTelemetryInterceptor\ for telemetry. Users can enable or disable telemetry registration via the \withTelemetry\ parameter.

src/Liquid.Cache.SqlServer · medium confidence

A new extension method, AddLiquidMemoryDistributedCache, has been added to register the memory-based distributed cache. This method configures the standard MemoryDistributedCache and registers the LiquidCache decorator with the LiquidTelemetryInterceptor, allowing users to easily integrate Liquid's caching and telemetry features into their .NET applications.

src/Liquid.Cache.Memory · high confidence

A new configuration class, MongoEntitySettings, has been added to the Liquid.Repository.Mongo project. This class defines the settings for MongoDB repository data entities, including properties for the collection name, shard key, database connection string, and database name. This change introduces the necessary settings structure to support MongoDB repository operations.

src/Liquid.Repository.Mongo/Settings · high confidence

Users can now register NCache as a distributed cache provider via the new \AddLiquidNCacheDistributedCache\ extension method. This registers the \NCacheDistributedCache\ service along with the \LiquidCache\ decorator and \LiquidTelemetryInterceptor\, enabling distributed caching with built-in telemetry when the \withTelemetry\ flag is enabled.

src/Liquid.Cache.NCache · high confidence

Introduces a new OpenAI adapter implementation that handles chat completions and function calling via the OpenAI client library. The change adds a client factory to manage and cache OpenAI chat clients based on configuration settings, and registers these services via a new extension method for dependency injection. Users can now configure OpenAI connections through standard configuration sections and utilize the new adapter for text and function-based chat interactions.

src/Liquid.GenAi.OpenAi · high confidence

The sample application now includes new domain handlers for retrieving (GET) and updating (PUT) sample entities. The GET handler uses MediatR to fetch a sample entity by ID via the repository, while the PUT handler updates an existing entity's properties. Both sets of handlers include request validators to ensure the provided IDs are not empty or null.

samples/src/Liquid.Sample.Domain/Handlers/SampleGet, samples/src/Liquid.Sample.Domain/Handlers/SamplePut · medium confidence

A new extension method, AddLiquidRedisDistributedCache, is now available in the Liquid.Cache.Redis library. This method registers the Redis-based distributed cache alongside a LiquidCache decorator and a LiquidTelemetryInterceptor, providing built-in telemetry support for cache operations.

src/Liquid.Cache.Redis · high confidence

A new exception class, DatabaseDoesNotExistException, has been introduced in the Entity Framework repository layer to handle cases where a SQL Server database is not found. This change improves error handling by providing a specific exception type for this scenario, allowing callers to catch and handle this condition explicitly rather than relying on generic or less specific exceptions.

src/Liquid.Repository.EntityFramework/Exceptions · high confidence

The localization module now includes new entity classes (LocalizationCollection, LocalizationItem, LocalizationValue) and a JsonFileLocalization implementation that reads resource strings from JSON files. The existing ILocalization interface and its implementation are marked as obsolete, indicating that this JSON-based approach is the new direction while the previous methods are scheduled for removal in a future release.

src/Liquid.Core/Localization · high confidence

New pipeline behaviors have been introduced for the MediatR request pipeline. The LiquidValidationBehavior enforces FluentValidation on incoming requests, throwing a ValidationException if any validator fails. The LiquidTelemetryBehavior wraps request execution to log start/end states and execution duration, providing structured logging for all handled requests.

src/Liquid.Core/PipelineBehaviors · high confidence

The Liquid.Messaging.Kafka package now provides new extension methods for configuring Kafka producers and consumers via the .NET dependency injection container. Users can register Kafka services using AddLiquidKafkaProducer and AddLiquidKafkaConsumer, which handle service registration, configuration binding, and optional telemetry interception. Additionally, header extension methods (AddCustomHeaders, GetCustomHeaders) are available for managing Kafka message headers.

src/Liquid.Messaging.Kafka/Extensions · medium confidence

Introduces new HTTP middleware components to the ASP.NET Core pipeline: LiquidContextMiddleware for managing request context keys, LiquidCultureMiddleware for setting thread culture, LiquidScopedLoggingMiddleware for structured logging scopes, and LiquidExceptionMiddleware for standardized error responses. Additionally, it adds Swagger integration via IServiceCollection and IApplicationBuilder extensions, Swagger operation filters (AddHeaderParameterFilter, DefaultResponseFilter, OverloadMethodsSameVerb, DocumentSortFilter), and supporting attributes (SwaggerBaseHeaderAttribute and derived classes) to automatically document custom headers in the API documentation.

src/Liquid.WebApi.Http · high confidence

The core library introduces a hierarchy of custom exceptions under the Liquid.Core.Exceptions namespace, including LiquidException as the base, along with specific types for data mapping (DataMappingException), database context issues (DatabaseContextException), serialization failures (SerializerFailException), and messaging errors (MessagingConsumerException, MessagingProducerException, etc.). Additionally, abstract mapper base classes (LiquidMapper, OcrResultMapper) are added to standardize data transformation logic, wrapping implementation details in consistent error handling.

src/Liquid.Core/Exceptions · high confidence

New settings classes have been introduced to support application configuration. These include CultureSettings for default culture, DatabaseSettings for connection strings and database names, GenAiOptions for chat completion requests, OcrOptions for OCR service connections, and scoped settings for context and logging. Each class defines the properties required to configure these specific functionalities within the Liquid.Core module.

src/Liquid.Core/Settings · high confidence

The repository was initialized with essential project configuration files, including \.editorconfig\ for code formatting, a comprehensive \.gitignore\ for build artifacts and IDE files, and a \nuget.config\ pointing to the official NuGet feed. Additionally, \README.md\ was updated with extensive documentation about the Liquid Application Framework, including feature lists, package versioning, and usage instructions, while \CONTRIBUTING.md\ was added to outline the project's engineering guidelines, code of conduct, and contribution process.

(repo-wide) · high confidence

Added new classes in the Entity Framework cartridge: EntityFrameworkDataContext and EntityFrameworkRepository, which implement the Liquid repository interfaces. The repository now supports generic DbContext injection, transaction management (StartTransactionAsync, CommitAsync, RollbackTransactionAsync), and query methods including FindAllAsync, FindByIdAsync, RemoveByIdAsync, UpdateAsync, WhereAsync, and WhereInclude for loading related entities. The EntityFrameworkDataContext implements IDisposable to properly dispose of the underlying DbContext.

src/Liquid.Repository.EntityFramework · medium confidence

Added new entities (LiquidChatMessage, LiquidChatContent, LiquidChatMessages) and enums (LiquidContentKind, LiquidMessageRole) to model chat interactions, alongside the ILiquidGenAi and ILiquidGenAiHandler interfaces and CompletionsOptions configuration class, enabling users to request chat completions and handle real-time updates.

src/Liquid.Core/GenAi · high confidence

Added the \Liquid.Repository.OData\ cartridge, providing an \ODataRepository\ that performs CRUD operations via OData clients. The \ODataClientFactory\ now retrieves the authentication token from the \ILiquidContext\ (key \OdataToken\) and attaches it to requests via the \Authorization\ header. The repository is registered via \AddLiquidOdataRepository\, which also configures \ODataOptions\ from the application's configuration section.

src/Liquid.Repository.OData · high confidence

Adds new concrete classes in the Liquid.Core.Implementations namespace to provide functional defaults for the framework's abstractions. This includes LiquidBackgroundService for handling message consumption with cancellation support, LiquidCache for distributed caching operations, LiquidContext for managing scoped state, and LiquidContextNotifications for managing notification lists. Additionally, the update introduces LiquidJsonSerializer and LiquidXmlSerializer to handle data serialization, a LiquidSerializerProvider to manage available serializers, a LiquidTelemetryInterceptor for logging method execution times and errors, and a LiquidUnitOfWork to manage database transactions across multiple data contexts.

src/Liquid.Core/Implementations · high confidence

Added extension methods for Entity Framework Core to simplify repository configuration and querying. The IServiceCollectionExtensions class now registers the EntityFrameworkRepository and its associated DbContext, including a telemetry interceptor. The ILiquidRepositoryExtensions class provides a WhereInclude method that allows filtering and eager-loading related entities in a single call. Additionally, a new DbContextExtensions class provides a Detach method to untrack entities from the DbContext's change tracker.

src/Liquid.Repository.EntityFramework/Extensions · high confidence

Added new classes and interfaces for Apache Kafka integration, including IKafkaFactory, KafkaConsumer, and KafkaProducer. The implementation supports consuming and producing messages with configurable settings such as group ID, auto-commit, and connection details.

src/Liquid.Messaging.Kafka · high confidence

Developers can now generate new projects using a comprehensive set of Liquid Framework templates, including \Liquid.Crud.AddEntity\, \Liquid.Crud.Solution\, \Liquid.WebApi.AddEntity\, \Liquid.WebApi.Solution\, \Liquid.DbContext.AddEntity\, \Liquid.Domain.AddHandler\, \Liquid.WorkerService.Project\, and more. These templates scaffold ready-to-use code structures for building WebAPIs and background workers, featuring pre-configured controllers, MediatR handlers, domain entities, and solution files, significantly reducing the initial setup time for new Liquid applications.

templates · high confidence

Added the \Enumeration\ abstract base class, which provides a reusable pattern for strongly-typed enumerations with value and display name mapping, plus static helpers to retrieve all instances or find by value/display name. Also added \LiquidSectionNameAttribute\ to mark configuration sections in JSON files, and \LiquidInterceptorBase\ to simplify implementing Castle DynamicProxy interceptors with before/after/exception handling. These changes introduce new foundational types in \Liquid.Core.Base\ and \Liquid.Core.Attributes\ that developers can extend to standardize enumeration usage and cross-cutting interceptor logic.

src/Liquid.Core/Base · high confidence

The library now exposes a set of new interfaces in the \Liquid.Core.Interfaces\ namespace, defining the core abstractions for the framework. These include \ILiquidCache\ for distributed caching, \ILiquidConsumer\ and \ILiquidProducer\ for message handling, \ILiquidStorage\ for blob storage operations, and \ILiquidRepository\ for data access patterns. Additionally, new interfaces for serialization (\ILiquidSerializer\, \ILiquidSerializerProvider\), context management (\ILiquidContext\, \ILiquidContextNotifications\), object mapping (\ILiquidMapper\), and unit of work (\ILiquidUnitOfWork\) have been introduced to support the unified base project structure.

src/Liquid.Core/Interfaces · high confidence

Added new extension methods to the dependency injection container: \LiquidAddAutoMapper\ for scanning and registering AutoMapper profiles and mappings, \AddLiquidHandlers\ and \AddLiquidDomain\ for registering MediatR handlers, validators, and domain services, and \AddLiquidTelemetryInterceptor\ (along with scoped/transient/singleton variants) for injecting telemetry into services. These additions provide a unified way to configure core Liquid.Core features via the standard \IServiceCollection\ interface.

src/Liquid.Core/Extensions/DependencyInjection · high confidence

Added several new entity classes to the core library: ChatCompletionResult for AI chat completions, OcrResult with supporting PageInfo, WordData, and LineData structures for optical character recognition, FunctionBody for function definitions, LiquidEntity as a generic base class, ClientDictionary for managing client instances, and event argument classes (ConsumerErrorEventArgs, ConsumerMessageEventArgs) for messaging and error handling.

src/Liquid.Core/Entities · high confidence

Added three new sample projects to demonstrate Liquid framework capabilities. The Dataverse sample provides a serverless function that creates records in Dataverse using the Liquid adapter. The WebAPI sample demonstrates a RESTful API that persists data to MongoDB and publishes events to a Service Bus queue. The Messaging Consumer sample implements a background worker that consumes messages from a Service Bus queue and processes them via MediatR handlers.

samples · high confidence

Added two new utility classes, TypeUtils and ZipUtils, to the Liquid.Core library. TypeUtils provides helper methods for reflection, including retrieving types to register and finding field or property information across inheritance hierarchies. ZipUtils introduces static methods for compressing and decompressing strings using Gzip and Deflate algorithms, supporting both UTF8 and custom encodings.

src/Liquid.Core/Utils · high confidence

The Liquid.Core.Extensions namespace now includes new extension classes for Byte, DateTime, Enum, IEnumerable, Int, Object, Stream, String, and Type. These additions provide utility methods such as byte array size calculation, date/time conversions, enum description retrieval, collection iteration and sorting, number checks, object type conversion, stream encoding, string hashing and JSON parsing, and type reflection helpers.

src/Liquid.Core/Extensions · high confidence

The Liquid templates have been updated to target .NET 8.0 and align with Liquid v8.0 beta. This includes new domain handler templates for CRUD operations (Create, Read, Update, Delete, List) and custom commands across the Liquid.Crud, Liquid.Domain, Liquid.WebApi, and Liquid.WorkerService project templates. These templates now use MediatR for command and query handling, FluentValidation for request validation, and the ILiquidRepository interface for data access, providing a modernized starting point for new Liquid-based applications.

(repo-wide) · high confidence

Three new decorators have been introduced to the Liquid.Core worker pipeline to handle cross-cutting concerns before message processing. LiquidContextDecorator injects configured context keys from message headers into the ILiquidContext service, while LiquidCultureDecorator sets the thread's default culture based on header values or configuration. Additionally, LiquidScopedLoggingDecorator creates a logging scope containing configured header keys, enabling structured logging of message metadata. These changes rely on IOptions for configuration rather than the previous LiquidConfiguration approach.

src/Liquid.Core/Decorators · high confidence

The ServiceBusSettings class is introduced to hold a list of ServiceBusEntitySettings, each representing the configuration for a specific Service Bus entity (topic, queue, or subscription). This change replaces the previous multi-entity collection approach with a unified settings structure, allowing users to define connection strings, entity paths, subscription names, and consumer behavior (such as max concurrent calls and peek-lock mode) in a single, cohesive configuration object.

src/Liquid.Messaging.ServiceBus/Settings · high confidence

The custom exception classes in the Mongo repository have been updated to implement ISerializable. This ensures that these exceptions can be properly serialized and deserialized across application domains or during remote calls, preventing serialization-related failures when these specific errors are thrown.

src/Liquid.Repository.Mongo/Exceptions · high confidence

The Azure Storage adapter for Liquid has been refactored to use a dedicated \BlobClientFactory\ and a new \IServiceCollectionExtensions\ registration method (\AddLiquidAzureStorageAdapter\). This change adds explicit dependency injection support for the Azure Storage implementation, allowing the storage service to be registered and configured via \StorageSettings\ and \ContainerSettings\ configuration sections. The \LiquidStorageAzure\ class now depends on the \IBlobClientFactory\ interface, which manages the lifecycle and retrieval of Azure Blob Container clients.

src/Liquid.Storage.AzureStorage · high confidence

The Kafka configuration model has been updated to include new properties for client identification and group management. Users can now configure the client identifier via the ConnectionId property, set a timeout for network requests via the Timeout property, and assign a group ID for consumer groups via the GroupId property. These additions allow for more granular control over Kafka client behavior and consumer group assignment.

src/Liquid.Messaging.Kafka/Settings · high confidence

The Liquid.Messaging.RabbitMq package has been rebuilt, introducing new configuration classes (RabbitMqConsumerSettings, RabbitMqProducerSettings, AdvancedSettings, and QueueAckModeSettings) and corresponding dependency injection extensions. This change provides explicit control over message acknowledgment modes (BasicAck/BasicReject) and queue properties, while updating the internal factory and consumer/producer implementations to use these new settings.

src/Liquid.Messaging.RabbitMq · medium confidence

The Mongo repository layer has been refactored to replace the previous attribute-based configuration with a standard IOptions-based approach, allowing settings to be injected directly rather than relying on custom attributes. A new IMongoClientFactory and its implementation (MongoClientFactory) manage the creation and caching of MongoDB client instances, while the MongoDataContext now implements IDisposable to properly clean up session handles and transactions. These changes improve dependency injection compatibility and resource management for MongoDB operations.

src/Liquid.Repository.Mongo · medium confidence

The dependency injection extensions for Azure Service Bus have been updated to include an \activateTelemetry\ boolean parameter in the \AddLiquidServiceBusProducer\ and \AddLiquidServiceBusConsumer\ methods. This allows users to explicitly disable the registration of telemetry interceptors and related services, providing more control over the application's monitoring overhead.

src/Liquid.Messaging.ServiceBus/Extensions · high confidence

The library now provides a streamlined way to register Mongo repositories via \AddLiquidMongoRepository\, which automatically configures \IOptions\-based settings and registers the repository with optional telemetry. Additionally, new extension methods on \IMongoCollection\ (such as \InsertOneAsync\, \FindAsync\, \DeleteOneAsync\, and \ReplaceOneAsync\) are introduced to handle database operations with optional transaction sessions.

src/Liquid.Repository.Mongo/Extensions · high confidence

Added code coverage configuration for tests; Added mock entity classes for testing; Added mock implementations for testing RabbitMQ messaging handlers; Added mock test entities and cursor for MongoDB repository tests; Added mock test helpers for Kafka messaging; Added tests for Liquid.Core components; Added tests for the Elastic APM telemetry component; Added unit tests and configuration files for NCache integration; Added unit tests for Azure Service Bus components; Added unit tests for Azure Storage adapter and BlobClientFactory; Added unit tests for Dataverse client and service components; Added unit tests for Entity Framework repository and data context; Added unit tests for Liquid.WebApi.Http controllers and helpers; Added unit tests for OpenAiClientFactory; Added unit tests for RabbitMQ messaging components; Added unit tests for cache service collection extensions; Added unit tests for the Liquid.Messaging.Kafka package; Added unit tests for the Mongo repository layer; Added unit tests for the OData repository and client factory; Added unit tests for the SqlServer cache extension.

The Liquid Application Framework components and sample projects have been upgraded to target .NET 8.0, with many core packages (such as Liquid.Core, Liquid.WebApi.Http, and various cache and messaging adapters) updated to version 8.0.0 or 8.1.0. This change aligns the framework with the latest .NET runtime, ensuring compatibility with modern .NET features and performance improvements. Users should ensure their projects target .NET 8.0 to leverage these updates.

(dependencies) · high confidence

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

• CAI 50 → 50 (-0.2)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 75 → 46 (-29.1)
• Architecture 64 → 64 (+0.1)
• Maturity 59 → 59 (+0.0)
• Readiness 52 → 61 (+9.6)
• Security 42 → 45 (+3.5)
• Performance 60 → 60 (+0.0)

• BarePragmaDisable repeated across 11 files (src/Liquid.Repository.EntityFramework/EntityFrameworkRepository.cs)
• Boundary-crossing change coupling: DatabaseContextException.cs ↔ EntityFrameworkRepository.cs (src/Liquid.Core/Exceptions/DatabaseContextException.cs)
• Boundary-crossing change coupling: IServiceCollectionExtensions.cs ↔ MongoRepository.cs (src/Liquid.Repository.EntityFramework/Extensions/IServiceCollectionExtensions.cs)
• Boundary-crossing change coupling: LiquidCultureDecorator.cs ↔ ServiceBusConsumer.cs (src/Liquid.Core/Decorators/LiquidCultureDecorator.cs)
• Bounded contexts not declared
• Build action pinned to a mutable branch
• Change coupling: IMongoClientFactory.cs ↔ MongoRepository.cs (src/Liquid.Repository.Mongo/IMongoClientFactory.cs)
• Change coupling: LiquidCultureDecorator.cs ↔ LiquidScopedLoggingDecorator.cs (src/Liquid.Core/Decorators/LiquidCultureDecorator.cs)
• Change coupling: MongoClientFactory.cs ↔ MongoRepository.cs (src/Liquid.Repository.Mongo/MongoClientFactory.cs)
• Duplicated block (9 lines × 2) (src/Liquid.Core/Extensions/DependencyInjection/IServiceCollectionLiquidExtension.cs)
• High CVE: System.Security.Cryptography.Xml 8.0.2
• High CVE: System.Security.Cryptography.Xml 8.0.2
• High CVE: System.Security.Cryptography.Xml 8.0.2
• High CVE: System.Security.Cryptography.Xml 8.0.2
• High CVE: System.Security.Cryptography.Xml 8.0.2
• High CVE: System.Security.Cryptography.Xml 8.0.2
• High CVE: System.Security.Cryptography.Xml 8.0.2
• High CVE: System.Security.Cryptography.Xml 8.0.2
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 28 more

• Assertions commented out: AddElasticApmTelemetry_WhenEnvironement_Enabled (test/Liquid.Core.Telemetry.ElasticApm.Tests/IServiceCollectionExtensionsTests.cs)
• Assertions commented out: AddElasticApmTelemetry_WhenEnvironement_NotEnabled (test/Liquid.Core.Telemetry.ElasticApm.Tests/IServiceCollectionExtensionsTests.cs)
• Assertions commented out: AddLiquidNCacheDistributedCache_WhenWithTelemetryTrue_GetServicesReturnLiqudCache (test/Liquid.Cache.NCache.Tests/IServiceCollectionExtensionTest.cs)
• Assertions commented out: AddLiquidNCacheDistributedCache_WhenWithTelemetryfalse_GetServicesReturnLiqudCache (test/Liquid.Cache.NCache.Tests/IServiceCollectionExtensionTest.cs)
• CoverageExclusion (src/Liquid.Core/AbstractMappers/LiquidMapper.cs)
• CoverageExclusion (src/Liquid.Core/AbstractMappers/OcrResultMapper.cs)
• CoverageExclusion (src/Liquid.Core/Base/Enumeration.cs)
• CoverageExclusion (src/Liquid.Core/Entities/ClientDictionary.cs)
• CoverageExclusion (src/Liquid.Core/Entities/FunctionBody.cs)
• CoverageExclusion (src/Liquid.Core/Entities/LiquidBlob.cs)
• CoverageExclusion (src/Liquid.Core/Entities/LiquidEntity.cs)
• CoverageExclusion (src/Liquid.Core/Entities/OcrResult.cs)
• CoverageExclusion (src/Liquid.Core/Entities/OcrResult.cs)
• CoverageExclusion (src/Liquid.Core/Entities/OcrResult.cs)
• CoverageExclusion (src/Liquid.Core/Entities/OcrResult.cs)
• CoverageExclusion (src/Liquid.Core/Exceptions/DataMappingException.cs)
• CoverageExclusion (src/Liquid.Core/Exceptions/DatabaseContextException.cs)
• CoverageExclusion (src/Liquid.Core/Exceptions/ExceptionCustomCodes.cs)
• CoverageExclusion (src/Liquid.Core/Exceptions/LiquidCustomException.cs)
• CoverageExclusion (src/Liquid.Core/Exceptions/LiquidDatabaseSettingsDoesNotExistException.cs)
• …and 165 more

• Unchanged — 7 HTTP endpoints

• Unchanged — 3 containers · 0 contexts · 0 edges

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

Avanade/Liquid-Application-Framework 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.