Skill UI

This skill details the universal Dependency Injection (DI) pattern for Webiny web extensions. It is the foundational pattern used across all extension types (API, Admin, CLI, Infrastructure) to ensure type safety and automatic service provision. Learn how to use constructor injection, declare dependencies (like Logger, BuildParams, or CMS use-cases), and utilize the `createImplementation` factory to build robust, decoupled services.

Add custom HTTP endpoints (GET, POST, PUT, etc.) to the Webiny API alongside the GraphQL handler using <Api.Route> and HttpRouteHandler, with full dependency injection support.

This guide details the Use Case pattern for structuring robust business logic. Learn how to encapsulate specific operations, utilize Dependency Injection (DI), and enforce type-safe result and error handling using the Result monad. It covers best practices for creating, injecting, and overriding UseCases and defining domain-specific errors.

This guide details the architectural shifts when migrating existing Webiny v5 plugins to the v6 feature-based Dependency Injection (DI) model. It covers key patterns, such as converting ContextPlugins to DI Services, adapting event subscriptions to EventHandler features, and restructuring plugin arrays into feature registrations.

This guide details the usage of go.uber.org/dig, a powerful reflection-based container for Dependency Injection in Golang. It covers advanced patterns like using `Provide`/`Invoke` for service registration, grouping parameters with `dig.In`, managing multiple outputs with `dig.Out`, and handling named/grouped dependencies. This is essential for reliably wiring complex application graphs at startup.

A robust application framework for Go that combines a reflection-based Dependency Injection container (built on dig) with advanced features. It provides lifecycle hooks (OnStart/OnStop), a module system, and signal-aware run loops. It is ideal for building complex, long-running services like HTTP servers, daemons, and workers that require structured startup and graceful shutdown.

Google Wire is a robust tool for managing dependency injection in Go. It resolves the application's entire dependency graph at compile time, generating plain, type-safe Go constructor calls. This approach eliminates the need for runtime reflection or heavy dependency containers, ensuring that dependency errors are caught immediately during the build process rather than during application execution. Ideal for building large, scalable, and maintainable Go microservices.

This guide outlines architectural patterns and best practices for building scalable, production-ready APIs with FastAPI. It covers proper project structure, separating concerns using routers, services, and CRUD layers, implementing dependency injection for database sessions and authentication, defining Pydantic schemas for request/response, handling asynchronous operations, and managing custom error responses.

This skill guides developers on integrating CommunityToolkit.Mvvm ViewModels with Microsoft's Dependency Injection system. It covers setting up the composition root using the .NET Generic Host, managing service lifetimes (Singleton, Transient, Scoped), implementing constructor injection, and correctly registering messaging services (IMessenger) for robust, cross-platform XAML applications (WPF, MAUI, Uno, Avalonia).

This comprehensive guide covers best practices for building modern Angular applications. It provides detailed instructions on component architecture, state management using Signals, advanced routing, dependency injection, handling forms (prioritizing Signal Forms), and implementing accessibility (ARIA). It also details setup procedures for new projects and modern rendering strategies like SSR.

This comprehensive guide covers best practices for building modern Angular applications. It provides detailed instructions on component architecture, state management using Signals, advanced routing, dependency injection, handling forms (prioritizing Signal Forms), and implementing accessibility (ARIA). It also details setup procedures for new projects and modern rendering strategies like SSR.

This comprehensive guide covers idiomatic C# and modern .NET best practices for building robust, high-performance, and maintainable applications. Topics include immutability, dependency injection, explicit coding, proper async/await usage, the Options pattern, and the Result pattern. Essential reading for developers designing services with ASP.NET Core.