vietnam-devs/coolstore-microservices

This system is a cloud-native e-commerce reference application, known as CoolStore, designed to demonstrate a polyglot microservices architecture. It comprises distinct services for identity, product catalog, inventory, shopping cart, and sales, implemented in .NET, Rust, Go, and TypeScript. The platform supports full-stack operations including product browsing, cart management, and checkout, while providing comprehensive infrastructure for local development and deployment to Azure via Kubernetes or Container Apps.

9 changes.

This period established the foundational architecture for a polyglot microservices application, integrating Dapr, Tye, and Istio across .NET, Rust, and Go services. It involved creating the initial web frontend with Remix, defining comprehensive Kubernetes Helm charts for deployment, and setting up local development environments with Docker Compose and Envoy proxy configurations.

9 changes.

This period focused on establishing the foundational architecture of the CoolStore application by implementing initial microservices in Rust, Go, and .NET, alongside a React-based web client. The work included setting up core e-commerce features such as product cataloging, inventory management, shopping cart logic, and order processing via Dapr pub/sub. Additionally, the infrastructure was defined using Azure Bicep to provision the necessary cloud resources for deployment.

The application now includes a standard page layout structure in the web client. Users will see a consistent header displaying the brand logo, user sign-in/sign-out controls, and a shopping cart icon that dynamically shows the item count. A footer with copyright information is also present. This layout wraps the main content area, providing the foundational UI for the store.

src/web/app/components · high confidence

This change introduces new Docker deployment assets for the local development environment. It adds an Envoy proxy configuration (envoy.yaml) that routes HTTP/gRPC traffic to backend services (catalog, cart, inventory, rating, open-api, graphql), along with the necessary Dockerfiles and build scripts for the proxy. It also includes Dockerfiles and initialization scripts for MSSQL and MySQL database containers, and a Dockerfile for setting up pnpm. These files enable running the full stack locally via docker-compose.

deploys/dockers · high confidence

The application now includes core e-commerce UI routes: a home page that lists products with category and inventory filters and allows adding items to the cart, a dedicated product detail page showing product information and options to add to cart or wishlist, and a cart page that displays selected items, quantities, order summary, and a checkout action. These routes are implemented in src/web/app/routes using Remix loader/action patterns to fetch user info, product data, and cart state, and to handle cart updates and checkout redirection.

src/web/app/routes · high confidence

A new XML diagram file (demo-cloud-native.xml) has been added to the assets folder, providing a visual representation of the cloud-native architecture for users.

assets · high confidence

Added a new Go microservice for the 'sale' domain, structured according to the golang-standards project layout. The application uses the Dapr Go SDK to subscribe to the 'processing-order' topic on the 'pubsub' component, exposing an HTTP endpoint at port 5005 to handle incoming events. The entry point is located at cmd/sale/main.go, and the service is containerized via a multi-stage Dockerfile (docker/Dockerfile-sale) that builds a static binary from Go 1.17.3. Development is supported by VS Code devcontainer configurations (.devcontainer/) that provision a Go environment with PostgreSQL.

src/go · high confidence

This change introduces the complete set of Kubernetes deployment and service templates for the Coolstore application, defining the infrastructure for all core microservices (SPA, GraphQL, Catalog, Cart, Inventory, Rating, Backoffice, and IDP) along with their required database backends (MongoDB and MySQL). It includes configuration for an Nginx Ingress to route external traffic, helper templates for naming, and a post-installation notes file to guide users on accessing the application via the gateway IP.

deploys/charts/coolstore/templates · high confidence

The web application in src/web/app has been initialized using the Remix framework, introducing client-side hydration (entry.client.tsx) and server-side rendering (entry.server.tsx) capabilities. The root layout (root.tsx) establishes the core user experience by integrating Tailwind CSS, setting the page title to 'CoolStore Web', and implementing an authentication loader that retrieves user info and creates a session cookie upon access. Additionally, the application now includes dedicated error boundaries to display user-friendly messages for 401 (unauthorized), 404 (not found), and 500 (server error) states, as well as a generic error boundary that prompts users to log in.

src/web/app · high confidence

This change introduces the complete set of Bicep infrastructure-as-code files for deploying the Coolstore microservices application to Azure. The main template and its modules provision the necessary Azure Container Apps environment, along with supporting services including Azure Cache for Redis, Azure Service Bus, and Azure Database for PostgreSQL flexible servers. It also configures Dapr components for state management (using Redis) and pub/sub messaging (using Service Bus), and defines the container app modules for the various microservices (Web API Gateway, Inventory, Product Catalog, Shopping Cart, Sale, Web App, and Identity) with their specific ports, images, and environment variables.

deploys/bicep · high confidence

This change introduces the core library functions for user authentication and shopping cart management within the web application. It establishes session handling via Remix's cookie storage, implements user info retrieval, and provides functions to search products, fetch product details, and manage the shopping cart (including creating, updating, and checking out). The code also defines TypeScript interfaces for products, carts, and search results, and configures an Axios client to communicate with the backend API endpoints for product catalog and shopping cart services.

src/web/app/lib · high confidence

The repository has been initialized with a complete microservices architecture centered around Dapr and Tye. This includes a solution file defining services for Identity, Product Catalog (Rust), Inventory (Rust), Shopping Cart (.NET 6), and Sales (Go), along with a Web API Gateway. The setup provides local development and deployment configurations via Docker Compose and Tye YAML files, enabling services to run with Dapr sidecars for features like service invocation, state management, and pub/sub. Supporting infrastructure includes a .NET 6 shopping cart service, Rust-based catalog and inventory services, and a Go-based sales service, all orchestrated to run locally or in containers.

(repo-wide) · high confidence

This change introduces the initial implementation of the Rust backend services for the Inventory and Product Catalog domains. The Inventory service exposes endpoints to retrieve inventory details by ID or a list of IDs, backed by a PostgreSQL database with schema migrations. The Product Catalog service provides product search and retrieval capabilities, including pagination and filtering by price, and enriches product data by calling the Inventory service to fetch location details. Both services share a common library for configuration, database connection pooling via sqlx, error handling, and logging, and are containerized with Dockerfiles for deployment.

src/rust · high confidence

This change introduces the initial version (0.1.0) of the \coolstore-istio\ Helm chart, providing the necessary structure to deploy the CoolStore application with Istio integration. The chart includes default configuration values for local development (\values.yaml\) and Azure Kubernetes Service (\values.aks.yaml\), defining hostnames for the web, API, backoffice, and identity provider services. It also sets up the initial Istio identity provider configuration, including the issuer and JWKS URI, and establishes standard Helm packaging rules via a \.helmignore\ file.

deploys/charts/coolstore, deploys/charts/coolstore-istio · high confidence

The src/web directory has been initialized as a new web application using the Remix framework, configured with TypeScript and Tailwind CSS (including the forms plugin). The setup includes standard project configuration files such as eslintrc, tsconfig, and a Dockerfile based on Node 16, establishing the foundational build and development environment for the web client.

src/web · high confidence

The web client directory has been initialized with a React-based frontend structure, including Docker configuration files (Dockerfile, .dockerignore) and an alternative Nginx-based build setup (Dockerfile.tye). The application features a React Router-based layout with authentication handling (callback and silent renew pages), a home page for product browsing with filtering, product detail views, a shopping cart, and an order history page. Key components include a header with user navigation, a footer, and notification displays, along with higher-order components for authentication and layout wrapping.

src/dotnet · high confidence

Added a suite of shell and PowerShell scripts to streamline the build, deployment, and maintenance of the containerized microservices architecture. The new \build-images.sh\ and \build-dotnet-images.sh\ scripts automate the Docker image creation for infrastructure components (MySQL, Envoy, Docker Volume) and .NET services (IdP, Inventory, Cart, Catalog, Rating, Open API, GraphQL, SPA, BackOffice). Deployment is simplified via \deploy-aks.ps1\ for Azure Kubernetes Service and \inject-istio.sh\ for local development with Istio sidecar injection. Additional utilities include \gen-protos.sh\ for protocol buffer generation, \helm-template.sh\ and \init-helm.sh\ for Helm chart management, \start.sh\ for CI/CD integration with Docker Hub, and \clean-images.sh\ for removing unused images.

deploys/scripts · high confidence

Added the core use-case logic for the shopping cart service, including the ability to update product quantities and complete a checkout. The UpdateAmountOfProductInShoppingCart handler manages adding new items or adjusting existing quantities, leveraging product, promo, and shipping gateways to calculate totals before persisting the cart state via Dapr. The CheckOut handler retrieves the user's cart, publishes a ShoppingCartCheckedOut event to the 'processing-order' topic for downstream order processing, and resets the cart for the user.

src/dotnet/shopping-cart/UseCases/Checkout, src/dotnet/shopping-cart/UseCases/UpdateAmountOfProductInShoppingCart · high confidence

The Coolstore Istio Helm chart templates now define the complete Istio networking layer, including a Gateway (\cs-gateway\) and VirtualServices that route web, API, backoffice, and IDP traffic to their respective backend services (catalog, cart, inventory, rating, spa, idp). Additionally, an EnvoyFilter is introduced to enable gRPC-JSON transcoding for the Cart, Inventory, Catalog, and Rating services, allowing HTTP/JSON clients to interact with gRPC endpoints, while a ConfigMap updates the sidecar injector template to support the required volume mounts for proto descriptors.

deploys/charts/coolstore-istio/templates · high confidence

This change introduces the initial dependency configuration files for the project's various service components. The web frontend is set up with a React application using Remix, Tailwind CSS, and Heroicons, alongside a separate VuePress instance for documentation. Backend services are defined across three languages: .NET services (API Gateway, Identity Server, Shopping Cart, and shared building blocks) targeting .NET 6.0 with packages like MassTransit, Dapper, and EF Core; a Go module for Dapr integration; and Rust crates for inventory and product catalog APIs using Axum, SQLx, and Tower. These manifests establish the foundational libraries and tooling for the microservices architecture.

(dependencies) · high confidence

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

• CAI 41 → 38 (-3.1)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 65 → 65 (+0.1)
• Architecture 77 → 77 (+0.0)
• Maturity 54 → 54 (+0.0)
• Readiness 27 → 24 (-3.2)
• Security 74 → 53 (-20.5)
• Domain Modelling 100 → 70 (-30.4)
• Event-Driven 100 → 100 (+0.0)
• Accessibility 38 → 37 (-0.7)
• Performance 72 → 72 (+0.0)

• Bounded contexts not declared
• Change coupling: AppLayout.tsx ↔ Home.tsx (src/bak/web/src/components/App/AppLayout.tsx)
• Change coupling: AppLayout.tsx ↔ ProductItemDetail.tsx (src/bak/web/src/components/App/AppLayout.tsx)
• Change coupling: Header.tsx ↔ Home.tsx (src/bak/web/src/components/App/Header.tsx)
• Change coupling: Header.tsx ↔ store.tsx (src/bak/web/src/components/App/Header.tsx)
• Change coupling: ProductItem.tsx ↔ Home.tsx (src/bak/web/src/components/Product/ProductItem.tsx)
• Change coupling: ProductItem.tsx ↔ ProductItemDetail.tsx (src/bak/web/src/components/Product/ProductItem.tsx)
• Change coupling: ProductItem.tsx ↔ store.tsx (src/bak/web/src/components/Product/ProductItem.tsx)
• Change coupling: ProductItemDetail.tsx ↔ Home.tsx (src/bak/web/src/components/Product/ProductItemDetail.tsx)
• Duplicated block (6 lines × 2) (src/dotnet/shopping-cart/UseCases/CreateShoppingCartWithProduct/CreateShoppingCartWithProductHandler.cs)
• High IaC: DS-0002 (.gitpod.Dockerfile)
• High IaC: DS-0002 (src/go/.devcontainer/Dockerfile)
• High IaC: DS-0002 (src/rust/.devcontainer/Dockerfile)
• High IaC: DS-0029 (src/rust/.devcontainer/Dockerfile)
• High IaC: KSV-0014 (deploys/charts/coolstore/templates/catalog-dep.yaml)
• High IaC: KSV-0014 (deploys/charts/coolstore/templates/rating-dep.yaml)
• High IaC: KSV-0014 (deploys/linkerd/coolstore-infrastructure.yaml)
• High IaC: KSV-0014 (deploys/linkerd/coolstore.yaml)
• LLM evaluation failed
• Medium CVE: SharpCompress 0.23.0
• …and 17 more

• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/web/yarn.lock)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/bak/web/yarn.lock)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/bak/web/yarn.lock)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/bak/web/yarn.lock)
• Critical CVE: [GHSA redacted] (src/web/yarn.lock)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/web/yarn.lock)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/web/yarn.lock)
• Critical CVE: [GHSA redacted] (src/web/yarn.lock)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• Critical CVE: [GHSA redacted] (src/bak/web/package-lock.json)
• …and 642 more

• Unchanged — 12 HTTP endpoints

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

vietnam-devs/coolstore-microservices 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.