Skill UI

This comprehensive API catalog provides a set of abstractions, including Use Cases and Event Handlers, for managing the core components of a website builder. It enables developers to perform essential operations such as creating, retrieving, updating, and deleting pages, managing page revisions, and handling URL redirects. It serves as the foundational layer for building structured web application logic.

This skill provides a detailed guide on extending the Webiny Command Line Interface (CLI) by implementing custom commands. It utilizes the `CliCommandFactory` pattern to define structured commands, manage typed parameters, and execute complex logic. Use cases include automating data migrations, generating boilerplate code, executing custom deployment workflows, and performing CMS content exports.

This pattern provides a robust method for extending and customizing existing GraphQL APIs. Developers can implement `GraphQLSchemaFactory` to add custom root queries and mutations, injecting complex business logic and use cases directly into the API layer. It fully supports per-resolver dependency injection (DI), ensuring that every resolver has access to critical request-scoped context, such as identity and tenancy, making it ideal for building modular, enterprise-grade backend services.

This pattern provides a comprehensive guide to implementing domain event handlers (before/after hooks) within the Webiny framework. It emphasizes the 'thin orchestrator' principle, requiring handlers to delegate all business logic to reusable service abstractions or UseCases for maximum reusability. Furthermore, it details the process of defining, publishing, and reacting to custom domain events, ensuring a clean, decoupled architecture.

This module provides essential architectural abstractions for structuring complex applications using the Webiny framework. It defines core types for various system components, including Admin panels, APIs, Command Line Interfaces (CLI), Infrastructure management, and Project logic. Developers must utilize these imported abstractions to ensure strict type safety and clear separation of concerns in their code.

Provides a standardized and robust skeleton for developing full-stack extensions that integrate both a backend API service and a frontend Admin UI. This pattern enforces clear separation of concerns, utilizing shared domain layers for data consistency while ensuring that API and Admin code are correctly registered using specific entry points. Ideal for complex applications requiring unified management interfaces and robust backend logic.

This skill provides a robust mechanism for extending an existing API gateway by adding custom, non-GraphQL HTTP endpoints (GET, POST, PUT, etc.). Developers can implement the Route.Interface and register it using the <Api.Route> component. It supports full Dependency Injection (DI), providing framework-agnostic Request and Reply objects, making it ideal for integrating complex business logic directly into the API structure.

This catalog provides comprehensive infrastructure abstractions and hooks for the Webiny ecosystem. It includes standardized lifecycle hooks (Before/After Build/Deploy/Watch) and specialized services (Logger, UI, AWS interactions) for various modules (Admin, API, Core). Use these standardized interfaces to seamlessly integrate custom logic into your build and deployment pipelines, ensuring modularity and consistency.

This guide details the UseCase pattern, an architectural pattern used to encapsulate specific business operations within the Webiny framework. Learn how to define UseCases as injectable dependencies, manage input and output using the structured Result<T, E> type, and implement robust, domain-specific error handling. Mastering this pattern is crucial for building highly modular, testable, and maintainable backend APIs.

This tool analyzes and refactors code to detect and correct anemic domain models. It enforces rich domain modeling patterns (Entities, Value Objects, Aggregates, Domain Events), improving encapsulation and business logic ownership. Use it when validating, reviewing, or refactoring core domain logic to ensure adherence to Domain-Driven Design (DDD) principles.

Logic Lens is an advanced AI skill that performs deep, formal logic-driven code review. Unlike standard linters, it analyzes code for complex issues like race conditions, security vulnerabilities (SQL injection, XSS), type safety flaws, and algorithmic errors across 9 critical risk categories. It is ideal for pre-merge PR reviews, auditing sensitive code paths, and refactoring complex business logic.

This router guides the testing of systemic flaws in business processes and state machines. It is essential when vulnerabilities stem from workflow abuse, race conditions, pricing flaws, or multi-step state attacks, rather than simple input sanitation issues. Use it to test complex business flows like payments, inventory management, and approval sequences.