Skill UI

This API module provides comprehensive tools and abstractions for managing scheduled actions within the webiny ecosystem. It covers the entire lifecycle of asynchronous tasks, including scheduling actions for future execution, retrieving details, listing existing tasks, executing them immediately, and canceling them. Key components include dedicated Use Cases and a core SchedulerService, enabling robust background processing and reliable task management for enterprise applications.

This comprehensive catalog provides essential abstractions for securing web APIs. It covers the entire lifecycle of authentication, including handling roles, users, and teams. Features include robust mechanisms for managing API keys (before/after events) and dedicated use cases for user and role creation/deletion, ensuring highly scalable and secure backend development.

This API provides core abstractions for managing system initialization and lifecycle events. It includes `InstallSystemUseCase` for running system-wide setup logic, and `SystemInstalledEventHandler` for implementing hooks that execute immediately after the system is successfully installed. It is essential for developing robust, modular, and reliable large-scale applications requiring structured bootstrapping.

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.

A comprehensive API catalog for managing the entire tenant lifecycle in multi-tenant applications. It provides structured abstractions, including Use Cases, Repositories, and various Event Handlers (before/after hooks), facilitating the creation of robust, scalable, and loosely coupled multi-tenant backend systems.

This module provides comprehensive API abstractions and use cases for managing multi-tenant systems. It covers the entire tenant lifecycle, including creation, installation, enabling, disabling, retrieval by ID, and model extension. Developers can use these structured patterns to ensure robust, scalable, and maintainable multi-tenancy implementation within their services.

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 guide details how to integrate Auth0 as an external Identity Provider (IDP) for Webiny, replacing the default Cognito authentication. It involves creating an API config class to map Auth0's JWT claims to Webiny identities and implementing a React extension component. Users must set environment variables (AUTH0_ISSUER, AUTH0_CLIENT_ID) and register the necessary extensions for successful OIDC authentication flow.

This skill guides developers on integrating Okta as an external Identity Provider (IDP) for Webiny. It replaces default authentication methods (like Cognito) by utilizing the OpenID Connect (OIDC) standard. The process involves setting up an API configuration class to map Okta's JWT claims to Webiny identities, and creating a React extension component to wire the issuer URL, client ID, and configuration path, enabling seamless Single Sign-On (SSO) using Okta.

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.

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.