hdimitrieski/e-shop

This is a microservices-based e-commerce platform that manages product catalogs, shopping baskets, and order processing. It provides a unified API gateway and GraphQL interface for frontend clients to browse products, manage carts, and place orders. The system relies on Kafka for asynchronous event-driven communication between services and uses Redis for stateful operations like basket management. Additionally, it includes administrative tools for managing inventory and order status, supported by infrastructure for authentication, logging, and image storage.

48 changes.

This period focused on building out the core microservices architecture, introducing services for catalog, basket, payment, and order processing, each integrated via Kafka and Eureka. The infrastructure was established with a centralized configuration and discovery layer, while the API gateway and GraphQL gateway were implemented to route and secure requests. Shared components for security, event handling, and validation were also developed to support the distributed system.

6 changes.

This period established the foundational architecture of the project, migrating the build system to Gradle and initializing the multi-module structure. It also introduced the first client applications, including an Angular REST client and a React GraphQL client, alongside administrative features for managing catalog items and orders.

The clients directory now contains two new client applications: an Angular-based REST client (ng-rest-client) and a React-based GraphQL client (react-graphql-client). The Angular project includes standard configuration files (angular.json, tsconfig, etc.) and end-to-end tests using Protractor. The React project is bootstrapped with Create React App, includes environment variables for local development endpoints, and provides a GraphQL schema file (schema.graphql) that defines the available queries and mutations for the e-shop backend.

clients · high confidence

The repository now includes the necessary Dockerfile and configuration files for the ELK (Elasticsearch, Logstash, Kibana) stack. This adds the base Docker images (version 7.12.0) and specific configuration files for each component, enabling users to run the full logging and monitoring stack via Docker.

docker/elk · high confidence

Introduced new security classes to handle JWT processing: EshopJwtDecoder validates token audience and issuer, EshopJwtAuthenticationConverter extracts granted authorities from both scopes and roles, and EshopAudienceValidator enforces audience claims. Additionally, EshopRole defines standard role constants, and GrantedAuthoritiesUtils provides helper methods for scope and role prefix formatting.

shared/security · high confidence

The docker/postgres directory now includes a Dockerfile and four initialization scripts (01-04) that automatically create databases and users for the order, catalog, keycloak, and rating services, each configured with the Europe/Amsterdam timezone.

docker/postgres · high confidence

The API gateway now includes new services for managing shopping baskets, including adding items, updating quantities, and performing full basket updates. These services coordinate with the catalog and basket APIs to handle basket state, while also introducing an analytics service interface to fetch top-selling products.

infrastructure/gateway/src/main/java/com/eshop/gateway/services · high confidence

A new validation constraint for card expiration dates has been added to the shared validation package. This includes a custom annotation and its corresponding validator, which ensures that the provided expiration date is not in the past. This allows developers to enforce expiration date validity in their models using standard Java Bean Validation.

shared/validation · high confidence

A new centralized configuration service has been introduced, consisting of a Spring Boot application entry point annotated with @EnableConfigServer to serve external configuration via a REST API, along with a security configuration that disables CSRF, permits unauthenticated access to /actuator/\\, and requires HTTP Basic authentication for all other requests.

infrastructure/config/src/main/java · high confidence

Added three new integration event classes—OrderStarted, ProductPriceChanged, and UserCheckoutAccepted—to the basket service. These classes define the data contracts for cross-service communication, carrying details such as user and basket information, price change data, and checkout acceptance details.

services/basket/src/main/java/com/eshop/basket/integrationevents/events · high confidence

A new discovery service has been introduced to the infrastructure, implementing a Spring Boot application that acts as an Eureka server for service discovery. The service includes security configurations that enforce HTTP basic authentication, with specific role-based access controls for admin and system users, and in-memory authentication setup. The service is configured to run on port 8761 and connects to a centralized configuration service for externalized configuration management. Logging is configured via Logback with support for ELK stack integration.

infrastructure/discovery · high confidence

The order-notifications service now listens for Kafka integration events (awaiting validation, submitted, paid, stock confirmed, shipped, and cancelled) and pushes real-time status updates to the corresponding WebSocket queues (e.g., /queue/order-shipped). This enables users to receive live notifications about their order progress without needing to manually refresh the page.

services/order-notifications/src/main/java/com/eshop/signaler/integrationevents · high confidence

A new event handler has been added to the payment service to process 'OrderStatusChangedToStockConfirmed' Kafka messages. When this event is received, the handler randomly publishes either a success or failure payment status event, allowing the system to react to stock confirmation events.

services/payment/src/main/java/com/eshop/payment/eventhandling · high confidence

New Java record classes were added to the gateway's models package to support basket and order data transfer. This includes request and data models for adding and updating basket items (AddBasketItemRequest, UpdateBasketItemRequest, UpdateBasketItemData, UpdateBasketRequest, UpdateBasketRequestItemData), as well as data models for basket state (BasketData, BasketDataItem), catalog items (CatalogItem), and order details (OrderData, OrderItemData). These models enable the gateway to handle basket management and order processing requests.

infrastructure/gateway/src/main/java/com/eshop/gateway/models · high confidence

The API gateway now includes new data transfer objects to support order draft creation and basket item handling. Specifically, the gateway introduces \BasketItem\ to represent individual items in a shopping basket, \CreateOrderDraftRequest\ to accept basket data for order drafting, \OrderDraftDTO\ to represent the resulting order draft with items and total, and \OrderItemDTO\ to define the structure of individual items within an order draft. These classes enable the gateway to serialize and deserialize request and response payloads for these specific e-commerce operations.

infrastructure/gateway/src/main/java/com/eshop/gateway/services/dtos · high confidence

New shell scripts (start.sh, start-infra.sh, start-services.sh, stop.sh, stop-infra.sh, stop-services.sh) have been added to automate the lifecycle of the application. The start scripts build all services using Gradle, launch each service (config, discovery, gateway, image, order-processing, catalog, basket, analytics, payment, order-notifications, order-grace-period-task, and rating) as background Java processes with logs directed to a 'target' directory, and manage Docker containers for infrastructure components. The stop scripts terminate all running services and infrastructure processes.

scripts · high confidence

The basket service now includes new configuration classes for Kafka (KafkaConfig, KafkaTopics) to handle event publishing and topic management, Redis (RedisConfig) to support in-memory basket data caching with transaction support, and security (SecurityConfig) to enforce JWT-based authentication and scope-based access control on basket endpoints.

services/basket/src/main/java/com/eshop/basket/config · high confidence

The basket service now listens to Kafka topics to handle two new integration events: when an order is placed, the corresponding customer's basket is marked as checked out; when a product price changes, the service updates the unit price in all affected baskets. This enables the basket service to stay synchronized with catalog and order events.

services/basket/src/main/java/com/eshop/basket/integrationevents/eventhandling · high confidence

The order-processing service now includes explicit configuration for Kafka-based event handling, defining topics for order states (e.g., paid, shipped, cancelled) and setting up message producers/consumers with error handling. Additionally, the service enforces OAuth2/JWT-based security on its REST endpoints, requiring specific roles (Admin) or 'orders' scope for order management operations.

services/order-processing/src/main/java/com/eshop/ordering/config · medium confidence

Added Dockerfiles and documentation for the Config, Discovery, Gateway, GraphQL Gateway, and Image services, enabling containerized deployment. The Discovery service now uses a wait-for-it script to ensure the Config service is available before starting, addressing startup ordering dependencies.

infrastructure · high confidence

The basket service now includes a Redis-backed repository for persisting customer baskets and a Kafka-based event bus for publishing integration events. The \BasketRepositoryImpl\ manages basket data in Redis using hash operations, while \KafkaEventBus\ and \OrderCheckoutsEventBus\ handle event publishing to Kafka topics, enabling reliable communication with other microservices.

services/basket/src/main/java/com/eshop/basket/infrastructure · high confidence

The e-shop Keycloak realm configuration has been added, defining the identity provider's structure including roles (user, admin, offline\_access), client management permissions, and session timeout policies. This establishes the foundational authentication and authorization settings for the e-shop application.

docker/keycloak · high confidence

The order-processing service now includes its primary configuration files: application.yml and bootstrap.yml define Spring Boot settings, Flyway migration paths, and external config server connectivity. A logback-spring.xml file configures structured logging to the console and, in the 'elk' profile, to Logstash. Additionally, a seed.sql script provides initial test data for buyers, payment methods, and orders to support development and testing.

services/order-processing/src/main/resources · high confidence

The order notifications service is now configured with the necessary infrastructure to operate. This includes a Kafka producer setup for sending order-related events, a WebSocket endpoint for real-time notifications, and security configurations for both HTTP and WebSocket connections. The service also defines the data models and topic mappings required to process and broadcast order status updates.

services/order-notifications/src/main/java/com/eshop/signaler/config · high confidence

The \clients/react-graphql-client\ directory now contains a complete React application built with Apollo Client. This includes the main application shell with routing, a catalog page for browsing products, a basket page for managing cart items, a checkout flow with address and payment forms, an orders history page, and shared UI components like a loader and image renderer. The client implements GraphQL queries and mutations for all these features, along with the necessary TypeScript interfaces and hooks to manage state and data fetching.

clients/react-graphql-client · high confidence

The eShop Gateway application is initialized with Spring Boot, enabling Eureka client discovery and WebFlux support, which allows the gateway to register with the service registry and handle reactive web requests.

infrastructure/gateway/src/main/java/com/eshop/gateway · high confidence

The GraphQL gateway now provides a unified API for querying and mutating e-commerce entities. Users can retrieve and modify baskets, orders, products, and ratings through new data fetchers and mutations. The implementation includes a node resolver for generic lookups, data loaders for efficient batched fetching of products and ratings, and specific mutations for adding items to the basket, updating quantities, and submitting ratings. This establishes the core data access layer for the GraphQL interface.

infrastructure/gql-gateway · high confidence

A new Spring Boot application class, OrderNotificationsApplication, has been added to the order-notifications service. This class serves as the entry point for the service, enabling it to run as a standalone Spring Boot application and register with the Eureka service discovery client.

services/order-notifications/src/main/java/com/eshop/signaler · high confidence

Users with admin privileges can now access a new Admin Panel to manage the product catalog and process orders. The admin section includes a catalog management page where administrators can add, edit, and delete catalog items, as well as update item names and prices inline. Additionally, the admin panel provides a dedicated page to cancel or ship orders by order number. This functionality is gated behind an AdminGuard, ensuring only authorized users can access these administrative features.

clients/ng-rest-client · high confidence

Added new domain models for the basket service, including CustomerBasket, BasketItem, and BasketCheckout, along with the BasketRepository interface. These changes establish the core data structures for managing shopping carts and checkout information, enabling the service to persist and retrieve basket states and associated items.

services/basket/src/main/java/com/eshop/basket/model · high confidence

The basket service now exposes REST endpoints for managing customer baskets, including retrieving a basket by customer ID or ID, updating a basket, checking out, and deleting a basket. Additionally, a test configuration and controller are added to expose test configuration properties via a /test endpoint.

services/basket/src/main/java/com/eshop/basket/controller · high confidence

The catalog command service now implements a CQRS architecture using Axon Framework, enabling commands to create products, and change product names, prices, and stock levels. The service also publishes integration events via Kafka for price changes and order status transitions, allowing downstream systems to react to catalog updates and inventory changes.

services/catalog/catalog-command · high confidence

The new image-service provides an HTTP endpoint (POST /images/upload) that accepts image uploads and stores them in a Minio bucket. The service includes security configuration requiring Admin role via JWT, a configuration initializer that pre-loads images from the classpath in development, and a global exception handler. This introduces a new microservice responsible for image storage operations.

infrastructure/image-service · high confidence

A new background task, GracePeriodManagerTask, has been added to the order-grace-period-task service. Running every 20 seconds, it queries the database for orders in 'Submitted' status that have exceeded the grace period, and publishes a GracePeriodConfirmedIntegrationEvent via Kafka. This enables downstream systems to react to orders that have passed their grace period, replacing the previous approach of dispatching commands directly.

services/order-grace-period-task/src/main/java · high confidence

A new Rating service has been added to the e-shop platform, enabling users to submit and view ratings for catalog items. The service exposes endpoints to add a rating for a specific item and to retrieve ratings by item ID or a list of IDs. It includes a database schema for storing ratings, a command/query architecture for handling requests, and security configurations that allow unauthenticated users to view ratings while requiring authorization to submit them.

services/rating · high confidence

Added a new shared outbox module (com.eshop.shared.outbox) that provides the core components for reliable event sourcing. This includes the @EnableOutbox annotation, an IntegrationEventLogEntry entity to track event states (NotPublished, InProgress, Published, PublishedFailed), a repository and service layer to manage event logs, and a scheduled IntegrationEventProcessor that periodically publishes pending events. This change establishes the foundational infrastructure for decoupled, reliable event processing across the application.

shared/outbox · high confidence

The order-processing service now includes a full set of command handlers for creating, canceling, and shipping orders, as well as handling status updates (paid, stock confirmed, awaiting validation). Each command is paired with an 'Identified' variant to ensure idempotency. Additionally, domain event handlers are added to react to order lifecycle events, such as sending integration events to Kafka topics for status changes (e.g., OrderStatusChangedToPaidIntegrationEvent, OrderStatusChangedToShippedIntegrationEvent).

services/order-processing/src/main/java/com/eshop/ordering/api · high confidence

The payment service now includes a GlobalControllerExceptionHandler to standardize error responses across the application, and a PaymentStatusEventBus that publishes integration events to a Kafka topic (spring.kafka.consumer.topic.paymentStatus) using Spring's KafkaTemplate with transactional support. This enables reliable, transactional delivery of payment status events to downstream consumers.

services/payment/src/main/java/com/eshop/payment/infrastructure · high confidence

The payment service now includes explicit configuration for Kafka integration. A new \KafkaConfig\ class defines beans for the Kafka producer template, error handling with a dead-letter queue for failed messages, and message conversion. Additionally, \KafkaTopics\ is introduced to manage topic names for payment status and stock confirmation events, enabling the service to publish and consume Kafka messages reliably.

services/payment/src/main/java/com/eshop/payment/config · high confidence

A new Payment service has been introduced to the e-shop platform, providing the core functionality for processing payments. The service is built on Spring Boot and integrates with the Eureka service discovery, enabling it to register itself within the microservices architecture.

services/payment/src/main/java/com/eshop/payment · high confidence

The API gateway now exposes new REST endpoints for managing the user's shopping basket, retrieving top-selling catalog items, and generating order drafts. The basket controller enforces that the authenticated user's identity is used to identify the basket, rather than accepting a basket ID from the frontend. The catalog controller provides an endpoint to fetch the top five best-selling products, and the order controller allows users to view a draft of their order based on their current basket.

infrastructure/gateway/src/main/java/com/eshop/gateway/controllers · high confidence

A new analytics service has been introduced to process real-time order and payment events via Kafka Streams. The service exposes REST endpoints to retrieve metrics such as total checkouts, top-selling products, order details, total income, and payment counts. Internally, it utilizes Kafka Streams to aggregate data into state stores (e.g., \checkouts-by-user-store\, \top-five-products-store\) and provides interactive query capabilities to fetch these aggregated results.

services/analytics/src/main/java · high confidence

A new catalog query service has been introduced to handle read operations for the catalog domain. It exposes a REST API via CatalogController to retrieve catalog items, brands, and categories, supporting filtering by name, ID, and pagination. The service implements a CQRS pattern using a custom QueryBus to route queries to specific handlers. Additionally, it includes event-driven projections (e.g., CreateCatalogItemProjection, ProductNameChangedProjection) that update the read model in response to domain events, ensuring the query side stays synchronized with the latest state.

services/catalog/catalog-query · high confidence

The payment service now defines a PaymentStatus enum with SUCCESS and FAILED states, alongside three new integration events: OrderPaymentSucceededIntegrationEvent, OrderPaymentFailedIntegrationEvent, and OrderStatusChangedToStockConfirmedIntegrationEvent. These changes enable the service to publish and handle specific order and payment outcomes, supporting the broader order processing domain.

services/payment/src/main/java/com/eshop/payment/events · high confidence

The project now uses Gradle as the build tool, introduced via the addition of the Gradle wrapper scripts (gradlew, gradlew.bat) and configuration files (.editorconfig, lombok.config, .gitignore). The README.md has been updated to document the microservices architecture, including Spring Cloud, Kafka, Keycloak, and various client applications, providing users with comprehensive instructions on how to run the system.

(repo-wide) · high confidence

The API gateway now enforces OAuth2/JWT-based authentication, allowing public access to specific GET endpoints (catalog, rating) while requiring a 'SCOPE\_webshoppingagg' authority for all other routes. It configures load-balanced WebClients for each microservice (analytics, basket, catalog, order, rating) and applies Resilience4j circuit breakers and time limiters to each service's route. Additionally, global CORS headers are enabled for the client address, and a composite health check monitors the status of the Catalog, Basket, and Order services.

infrastructure/gateway/src/main/java/com/eshop/gateway/config · high confidence

The gateway now includes new service implementations for Analytics, Basket, Catalog, and Ordering, each using Spring WebFlux WebClient to call downstream microservices. These services are configured with Resilience4j circuit breakers and retry policies to handle failures gracefully: the analytics service falls back to fetching the first five catalog items if the analytics service is unavailable, the basket service returns an empty basket on failure, and the ordering service throws a ServiceCallFailedException on 5xx errors. This improves gateway reliability by preventing cascading failures when downstream services are slow or down.

infrastructure/gateway/src/main/java/com/eshop/gateway/infrastructure · medium confidence

The Docker base image has been updated to support HTTPS communication with the Keycloak authorization service. New shell scripts are included to download the server's TLS certificate from \authorization-service:8443\ and import it into the Java truststore, ensuring secure connections to the auth server.

docker/base · high confidence

The shared REST module now provides a unified approach to handling HTTP errors and configuring Jackson for Java 14+ records. A new \ControllerExceptionHandler\ intercepts \NotFoundException\ and \BadRequestException\ to return standardized \HttpErrorInfo\ responses with appropriate HTTP status codes. Additionally, a \GlobalConfiguration\ bean customizes Jackson to properly serialize Java records as JSON, ensuring consistent error payloads across the application.

shared/rest · high confidence

The basket service's main application class now includes annotations to enable Eureka client registration for service discovery and activates Spring's transaction management. This allows the basket service to register with the Eureka server and manage database transactions, which are prerequisites for reliable e-commerce operations.

services/basket/src/main/java/com/eshop/basket · high confidence

A new initial database migration (V1\_0\0\\_initial\_schema.sql) introduces the core schema for the order processing service, including tables for clients, outbox, buyers, payment methods, orders, and order items, along with their primary keys and foreign key relationships. Additionally, a test data script (afterMigrate.sql) is added to populate the database with sample buyer, payment method, order, and order item records for development use.

services/order-processing/src/main/resources/db · high confidence

The basket service now enforces transactional consistency during checkout, ensuring the basket status is updated and the order-processing event is published within a single transaction. It also resolves the current user's identity via a new IdentityService that extracts the username from the JWT token, enabling the service to associate the basket with the correct customer.

services/basket/src/main/java/com/eshop/basket/services · high confidence

Added new shared components for event handling: the EventBus interface for publishing IntegrationEvent instances, the IntegrationEvent base class carrying an ID and creation date, and the IntegrationEventHandler interface for processing events. These changes support the refactoring of the order processing domain by centralizing event-handling contracts in the shared package.

shared/event-handling · medium confidence

The project has been migrated to use Gradle as the build tool. This introduces new Gradle convention plugins (java-conventions, lib-conventions, spring-conventions) that standardize Java 17 toolchains, JUnit 5 testing, Lombok configuration, and Spring Boot packaging. The Gradle wrapper is also added to ensure consistent build tooling across environments.

buildSrc/conventions, gradle · high confidence

The ordering service module has been renamed to order-processing, reflecting a shift in the project's naming convention for this component. This change is accompanied by the addition of the Outbox pattern support via the @EnableOutbox annotation, which ensures reliable message delivery for order processing events.

services/order-processing/src/main/java/com/eshop/ordering · high confidence

The repository is initialized with a Gradle-based multi-module architecture. The build system is configured using \build.gradle.kts\ and \settings.gradle.kts\, which define the project structure for shared libraries, infrastructure services, and business services. A central version catalog (\libs.versions.toml\) manages dependencies for the Spring Boot, Spring Cloud, and DGS frameworks. Additionally, frontend client projects for Angular and React are introduced with their respective \package.json\ and lock files, establishing the initial state of the application's client-side dependencies.

(dependencies) · high confidence

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

• CAI 43 → 36 (-7.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 93 → 97 (+3.5)
• Architecture 100 → 78 (-21.7)
• Maturity 53 → 55 (+2.1)
• Readiness 31 → 20 (-11.8)
• Security 42 → 38 (-3.3)
• Domain Modelling 93 → 73 (-19.7)
• Event-Driven 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 47 → 48 (+0.9)

• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• …and 89 more

• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/react-graphql-client/yarn.lock)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• Critical CVE: [GHSA redacted] (clients/ng-rest-client/package-lock.json)
• …and 250 more

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

hdimitrieski/e-shop 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.