More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    E-commerce Engineering Kit — Angular 22 + .NET 10 LTS

    1

    Full-stack e-commerce engineering kit for Angular 22 and .NET 10 using Clean Architecture and Vertical Slices.

    $14.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    E-commerce Engineering Kit — Angular 22 + .NET 10 LTS

    E-commerce Engineering Kit — Angular 22 + .NET 10 LTS

    Example session with this skill installed

    Create a new Vertical Slice for adding a product to the shopping cart, including the backend Command, the Angular service update using Signals, and the corresponding xUnit test.

    • Read your context and instructions
    • Compiled the e-commerce engineering kit

    I have implemented the AddCartItem vertical slice. This includes the backend command handler, the frontend signal-based service, and an integration test.

    AddCartItem Vertical Slice Implementation

    Backend: Application Command

    namespace ECommerce.Application.Cart.Commands;
    
    public record AddCartItemCommand(Guid ProductId, int Quantity) : IRequest<CartDto>;
    
    public class AddCartItemHandler(ICartRepository repository, IProductService products) 
        : IRequestHandler<AddCartItemCommand, CartDto>
    {
        public async Task<CartDto> Handle(AddCartItemCommand request, CancellationToken ct)
        {
            var cart = await repository.GetActiveCartAsync(ct);
            var product = await products.GetByIdAsync(request.ProductId, ct);
            
            cart.AddItem(product.Id, request.Quantity, product.Price);
            await repository.SaveChangesAsync(ct);
            
            return cart.ToDto();
        }
    }
    

    Frontend: Angular Cart Service

    import { Injectable, signal, computed } from '@angular/core';
    import { HttpClient } from '@angular/common/http';
    
    @Injectable({ providedIn: 'root' })
    export class CartService {
      private cartState = signal<Cart | null>(null);
      
      cart = this.cartState.asReadonly();
      totalItems = computed(() => this.cartState()?.items.length ?? 0);
    
      constructor(private http: HttpClient) {}
    
      addToCart(productId: string, quantity: number) {
        this.http.post<Cart>('/api/cart/items', { productId, quantity })
          .subscribe(updatedCart => this.cartState.set(updatedCart));
      }
    }
    

    Testing: xUnit Integration Test

    [Fact]
    public async Task AddItem_ShouldUpdateTotals_WhenProductIsValid()
    {
        // Arrange
        var command = new AddCartItemCommand(Guid.NewGuid(), 2);
        
        // Act
        var result = await _sender.Send(command);
        
        // Assert
        Assert.Equal(2, result.Items.Count);
        Assert.True(result.TotalPrice > 0);
    }
    

    Next steps

    1. Register the new command in the CartModule dependency injection container.
    2. Update the ProductDetailComponent to inject CartService and call addToCart.
    3. Run dotnet test to verify the persistence logic against the Testcontainer.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Maintaining architectural integrity across a full-stack e-commerce platform is difficult when domain logic, frontend state, and backend infrastructure start to leak into one another. This engineering kit provides a structured framework for building enterprise-grade retail systems using Angular 22 and .NET 10 LTS.

    What it does

    • Architectural Guardrails enforces Clean Architecture and Vertical Slice patterns to keep the codebase modular and maintainable.
    • Domain Modeling manages complex e-commerce logic for product catalogs, inventory reservations, and pricing engines.
    • Frontend Orchestration builds storefront and backoffice interfaces using Angular Signals and Material.
    • Security & Identity implements OAuth 2.0 and OIDC using Keycloak for customer accounts and administrative RBAC.
    • Reliability Engineering automates layered testing with Playwright and Testcontainers, alongside OpenTelemetry for observability.

    How it works

    1. Define Domain Boundaries by mapping modules, aggregates, and invariants within the e-commerce context.
    2. Implement Vertical Slices to build features like cart persistence or stock reservations across all layers.
    3. Configure API Contracts using OpenAPI schemas to ensure type-safety between the .NET backend and Angular frontend.
    4. Deploy and Observe using Docker Compose and Nginx, with Prometheus and Grafana for operational monitoring.

    Frameworks & tools

    Built for Angular 22, TypeScript, and Angular Material on the frontend. The backend utilizes .NET 10 LTS, C# 14, EF Core 10, and ASP.NET Core. Infrastructure includes PostgreSQL 18, Keycloak, Docker, and OpenTelemetry.

    Why this beats prompting it yourself

    Generic prompts often produce monolithic code that fails to handle concurrent inventory locks or complex checkout states. This kit forces the agent to follow strict e-commerce domain boundaries and specific LTS framework versions, preventing technical debt in high-stakes transaction flows.

    Use cases

    • Building a multi-tenant backoffice for catalog and order management.
    • Implementing a persistent shopping cart with session consolidation.
    • Integrating third-party payment providers with robust webhook and retry logic.
    • Developing a search-optimized storefront with categories and faceted filters.

    Known limitations

    Requires an environment capable of running Docker and .NET 10 LTS. The kit is strictly scoped to the provided tech stack and does not support alternative frontend frameworks like React or Vue.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for APIs & Backend.

    Requires Docker for deployment and testing. Limited to Angular 22, .NET 10 LTS, and PostgreSQL 18 stack. Does not include pre-built UI components for third-party payment provider gateways.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 11 days ago

    Software
    PlaywrightNode.js

    Permissions

    Terminal / Shell
    Browser
    Network Access
    Write Files

    Allowed Hosts

    %2A
    Listed11 days ago

    What's inside

    Frequently Asked Questions

    This kit provides the architectural foundation for enterprise retail systems, specifically solving the problem of domain logic leakage and unmaintainable monolithic code by enforcing Clean Architecture and Vertical Slice patterns.

    The skill is optimized for AI agents capable of interpreting C# 14 and Angular 22 syntax, provided they have access to a local or cloud environment running .NET 10 LTS and Docker.

    The purchase includes the full-stack engineering framework, pre-configured Docker Compose files, domain-specific module templates, and automated testing suites using Playwright and Testcontainers.

    Yes, the kit features a dedicated Security & Identity layer using Keycloak for OAuth 2.0/OIDC, supporting both customer accounts and complex administrative Role-Based Access Control (RBAC).

    Because it utilizes .NET 10 LTS (Long Term Support), this kit is designed for stability and will receive architectural guidance relevant to the full lifecycle of the .NET 10 and Angular 22 versions.

    No, this skill is strictly opinionated for the Angular 22 and .NET 10 LTS stack to ensure architectural integrity; it does not support React, Vue, or alternative backend frameworks.

    New in APIs & Backend