Skill UI

A comprehensive set of abstractions, hooks, and components for building robust administrative dashboards and complex applications using the Webiny framework. It provides foundational tools like `createFeature`, `createProvider`, and various context utilities, enabling developers to manage application state, features, and UI components in a highly structured and scalable manner.

This module serves as the centralized catalog for administrative configurations within the Webiny API context. It provides key abstractions, such as AdminConfig, allowing developers to reliably access and manage application settings. Developers must import the specific abstraction and review the source file for accurate interfaces and types to ensure proper implementation.

This utility provides key abstractions for integrating with the webiny administration API using GraphQL. It serves as a centralized catalog, guiding developers on how to correctly import and utilize pre-defined GraphQL client structures. By enforcing standardized interfaces and types, it ensures type safety and consistent data interaction patterns across the application's administrative features, streamlining data fetching in complex admin contexts.

This module provides multiple abstractions and hooks for interacting with the browser's LocalStorage API within an administrative context. It offers specialized utilities, including direct service access (LocalStorage instance) and advanced React hooks (useLocalStorage, useLocalStorageValues). These tools enable component developers to imperatively call services or efficiently observe single or multiple keys, ensuring consistent state management and proper re-rendering when local state changes.

This catalog provides core abstractions and hooks for robust security management in administrative applications. It includes essential tools for handling identity context, user authentication flows (login/logout), and granular authorization checks. Developers can use these components to build secure, feature-rich administrative panels with reliable access control.

This catalog provides essential TypeScript abstractions, types, and hooks for implementing robust multi-tenancy features in administrative interfaces. It helps developers manage the current tenant context, check tenant roles (e.g., root vs. non-root), and handle tenant state changes (enable/disable) across various modules. It is crucial for building scalable, secure, and multi-tenant SaaS platforms.

This catalog provides critical abstractions for managing build-time configuration parameters within the Webiny API context. It offers `BuildParam` for accessing single configuration values and `BuildParams` for handling multiple parameters, ensuring that all API interactions utilize a structured, type-safe approach for development.

This module provides the core `Logger` abstraction for structured logging within the Webiny API context. It supports multiple logging levels (e.g., debug, info, warn, error), ensuring that developers can record application events and operational data systematically. Using this abstraction helps in centralized logging, which is crucial for debugging, monitoring, and maintaining system health.

This module provides multiple standardized abstractions for interacting with the OpenSearch API. It includes dedicated abstractions for clients, factories, and operational contexts, allowing developers to implement robust, scalable, and type-safe interactions with OpenSearch within the webiny ecosystem. Use these patterns to ensure consistent data access regardless of the specific usage pattern.

This module provides core abstractions for handling long-running, asynchronous background tasks within an API context. It introduces `TaskDefinition` to define the complete lifecycle and hooks for a background task, and `TaskService` to programmatically trigger and manage these operations. It is essential for backend development requiring robust, non-instantaneous processing.

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 guide explains the universal Dependency Injection (DI) pattern used across all Webiny extensions (API, Admin, CLI, Infrastructure). It details how to correctly implement constructor injection using the `dependencies` array to access core services like Logger, BuildParams, CMS use-cases, and IdentityContext. Mastering this pattern is crucial for building maintainable, type-safe, and cohesive Webiny extensions.