@webiny/mcp 0.0.0-unstable.6844005670

package/skills/dependency-injection/SKILL.md

@@ -0,0 +1,252 @@
+---
+name: webiny-dependency-injection
+context: webiny-extensions
+description: >
+  The universal createImplementation DI pattern and all injectable services.
+  Use this skill when the developer is writing any Webiny extension and needs to understand
+  dependency injection, constructor injection, how to access Logger/BuildParams/IdentityContext,
+  how to inject CMS use-cases (list/get/create/update/delete entries), or how the dependencies
+  array works. This is the connective tissue across all extension types -- API, Admin, CLI,
+  and Infrastructure.
+---
+
+# Dependency Injection Patterns
+
+## TL;DR
+
+Every Webiny extension type uses the same DI pattern: define a class implementing `*.Interface`, declare dependencies in the constructor, and export via `*.createImplementation({ implementation, dependencies })`. The DI container automatically provides the required services, ensures type safety, and validates at compile time. This pattern is the connective tissue across all extension types -- API, Admin, CLI, and Infrastructure.
+
+## The Universal Pattern
+
+```typescript
+import { SomeFactory } from "webiny/some/path";
+import { Logger } from "webiny/api/logger";
+import { BuildParams } from "webiny/api/build-params";
+
+class MyImplementation implements SomeFactory.Interface {
+    constructor(
+        private logger: Logger.Interface,
+        private buildParams: BuildParams.Interface
+    ) {}
+
+    execute(/* factory-specific params */) {
+        this.logger.info("Doing something...");
+        const value = this.buildParams.get<string>("MY_PARAM");
+    }
+}
+
+export default SomeFactory.createImplementation({
+    implementation: MyImplementation,
+    dependencies: [Logger, BuildParams]
+});
+```
+
+Key rules:
+1. **One class per file** -- each extension file exports a single implementation.
+2. **Constructor injection** -- dependencies are received as constructor parameters, in the same order as the `dependencies` array.
+3. **Dependencies array** -- must exactly match the constructor parameter order and types.
+4. **Interface types** -- always type constructor params as `Feature.Interface`.
+
+## Where This Pattern Appears
+
+| Extension Type | Factory | Import Path |
+|---|---|---|
+| Content Models | `ModelFactory` | `"webiny/api/cms/model"` |
+| GraphQL Schemas | `GraphQLSchemaFactory` | `"webiny/api/graphql"` |
+| CMS Entry Hooks | `EntryBeforeCreateEventHandler`, etc. | `"webiny/api/cms/entry"` |
+| API Key Hooks | `ApiKeyAfterUpdateHandler` | `"webiny/api/security/apiKey"` |
+| API Keys | `ApiKeyFactory` | `"webiny/api/security"` |
+| CLI Commands | `CliCommandFactory` | `"webiny/cli/command"` |
+| Pulumi Handlers | `CorePulumi` | `"webiny/infra/core"` |
+
+## Injectable Services
+
+### Utility Services
+
+| Service | Import                      | Interface | Available In | Purpose |
+|---|-----------------------------|---|---|---|
+| `Logger` | `"webiny/api/logger"`       | `Logger.Interface` | API | Logging (persists to CloudWatch) |
+| `BuildParams` | `"webiny/api/build-params"` | `BuildParams.Interface` | API | Access build-time parameters |
+| `Ui` (CLI) | `"webiny/cli"`              | `Ui.Interface` | CLI | Terminal output formatting |
+| `Ui` (Infra) | `"webiny/infra"`            | `Ui.Interface` | Infra | Terminal output during deploy |
+
+### Logger Methods
+
+```typescript
+this.logger.info("Informational message");
+this.logger.warn("Warning message");
+this.logger.error("Error message");
+this.logger.debug("Debug message");
+```
+
+### BuildParams Methods
+
+```typescript
+// Get a string parameter
+const value = this.buildParams.get<string>("MY_PARAM");
+
+// Get a complex parameter
+const config = this.buildParams.get<{ myKey: number; nested: { foo: string } }>("MY_CONFIG");
+```
+
+Parameters are set in `webiny.config.tsx`:
+
+```tsx
+<Api.BuildParam paramName="MY_PARAM" value="customValue" />
+<Api.BuildParam paramName="MY_CONFIG" value={{ myKey: 2, nested: { foo: "bar" } }} />
+```
+
+### Core Context Features
+
+| Feature | Import Path | Purpose |
+|---|---|---|
+| `IdentityContext` | `"webiny/api/security"` or `"@webiny/api-core/features/IdentityContext"` | Current user identity and permissions |
+| `TenantContext` | `"@webiny/api-core/features/TenantContext"` | Current tenant information |
+| `EventPublisher` | `"@webiny/api-core/features/EventPublisher"` | Publish domain events |
+| `WcpContext` | `"@webiny/api-core/features/WcpContext"` | Webiny Control Panel integration |
+| `GetSettings` | `"@webiny/api-core/features/settings/GetSettings"` | Retrieve settings records |
+| `UpdateSettings` | `"@webiny/api-core/features/settings/UpdateSettings"` | Create/update settings records |
+
+### Headless CMS Use-Cases
+
+| Feature | Import Path | Purpose |
+|---|---|---|
+| `GetEntryByIdUseCase` | `"@webiny/api-headless-cms/features/contentEntry/GetEntryById"` | Fetch entry by revision ID |
+| `GetEntryUseCase` | `"@webiny/api-headless-cms/features/contentEntry/GetEntry"` | Get entry by query |
+| `ListLatestEntriesUseCase` | `"@webiny/api-headless-cms/features/contentEntry/ListEntries"` | List latest entries |
+| `ListPublishedEntriesUseCase` | `"@webiny/api-headless-cms/features/contentEntry/ListEntries"` | List published entries |
+| `ListDeletedEntriesUseCase` | `"@webiny/api-headless-cms/features/contentEntry/ListEntries"` | List deleted entries |
+| `CreateEntryUseCase` | `"@webiny/api-headless-cms/features/contentEntry/CreateEntry"` | Create entry |
+| `UpdateEntryUseCase` | `"@webiny/api-headless-cms/features/contentEntry/UpdateEntry"` | Update entry |
+| `DeleteEntryUseCase` | `"@webiny/api-headless-cms/features/contentEntry/DeleteEntry"` | Delete entry |
+| `GetModelUseCase` | `"@webiny/api-headless-cms/features/contentModel/GetModel"` | Get model by ID |
+| `ListModelsUseCase` | `"@webiny/api-headless-cms/features/contentModel/ListModels"` | List all models |
+| `GetModelRepository` | `"@webiny/api-headless-cms/features/contentModel/GetModel"` | Fetch model from cache |
+| `ListModelsRepository` | `"@webiny/api-headless-cms/features/contentModel/ListModels"` | Fetch all models from cache |
+| `ModelsFetcher` | `"@webiny/api-headless-cms/features/contentModel/shared"` | Centralized model fetching |
+| `ListEntriesRepository` | `"@webiny/api-headless-cms/features/contentEntry/ListEntries"` | Storage-level entry fetching |
+
+### Tenancy Use-Cases
+
+| Feature | Import Path | Purpose |
+|---|---|---|
+| `GetTenantByIdUseCase` | `"@webiny/api-core/features/tenancy/GetTenantById"` | Fetch tenant by ID |
+| `CreateTenantUseCase` | `"@webiny/api-core/features/tenancy/CreateTenant"` | Create a tenant |
+| `UpdateTenantUseCase` | `"@webiny/api-core/features/tenancy/UpdateTenant"` | Update a tenant |
+| `DeleteTenantUseCase` | `"@webiny/api-core/features/tenancy/DeleteTenant"` | Delete a tenant |
+| `InstallTenantUseCase` | `"@webiny/api-core/features/tenancy/InstallTenant"` | Install a tenant |
+
+## Examples Across Extension Types
+
+### API Extension (GraphQL Schema with DI)
+
+```typescript
+import { GraphQLSchemaFactory } from "webiny/api/graphql";
+import { IdentityContext } from "webiny/api/security";
+
+class SchemaImpl implements GraphQLSchemaFactory.Interface {
+    constructor(private identityContext: IdentityContext.Interface) {}
+
+    execute(): GraphQLSchemaFactory.Return {
+        return [{
+            typeDefs: /* GraphQL */ `
+                type Query { whoAmI: String }
+            `,
+            resolvers: {
+                Query: {
+                    whoAmI: () => {
+                        const identity = this.identityContext.getIdentity();
+                        return `Hello, ${identity.displayName}!`;
+                    }
+                }
+            }
+        }];
+    }
+}
+
+export default GraphQLSchemaFactory.createImplementation({
+    implementation: SchemaImpl,
+    dependencies: [IdentityContext]
+});
+```
+
+### CMS Lifecycle Hook with DI
+
+```typescript
+import { EntryBeforeCreateEventHandler as Handler } from "webiny/api/cms/entry";
+import { Logger } from "webiny/api/logger";
+
+class MyHookImpl implements Handler.Interface {
+    constructor(private logger: Logger.Interface) {}
+
+    async handle(event: Handler.Event): Promise<void> {
+        this.logger.info(`Entry created for model: ${event.modelId}`);
+    }
+}
+
+export default Handler.createImplementation({
+    implementation: MyHookImpl,
+    dependencies: [Logger]
+});
+```
+
+### CLI Command with DI
+
+```typescript
+import { Ui } from "webiny/cli";
+import { CliCommandFactory } from "webiny/cli/command";
+
+class MyCommandImpl implements CliCommandFactory.Interface<{ name: string }> {
+    constructor(private ui: Ui.Interface) {}
+
+    execute(): CliCommandFactory.CommandDefinition<{ name: string }> {
+        return {
+            name: "greet",
+            description: "Greet someone",
+            params: [{ name: "name", description: "Name", type: "string" }],
+            handler: async params => {
+                this.ui.success(`Hello, ${params.name}!`);
+            }
+        };
+    }
+}
+
+export default CliCommandFactory.createImplementation({
+    implementation: MyCommandImpl,
+    dependencies: [Ui]
+});
+```
+
+### Pulumi Handler with DI
+
+```typescript
+import { Ui } from "webiny/infra";
+import { CorePulumi } from "webiny/infra/core";
+
+class MyPulumiImpl implements CorePulumi.Interface {
+    constructor(private ui: Ui.Interface) {}
+
+    execute(app: any) {
+        this.ui.info("Deploying with environment:", app.env);
+    }
+}
+
+export default CorePulumi.createImplementation({
+    implementation: MyPulumiImpl,
+    dependencies: [Ui]
+});
+```
+
+## Key Rules
+
+1. Always import from the **feature path**, not the package root.
+2. Use `Feature.Interface` for constructor parameter types.
+3. The `dependencies` array order must match the constructor parameter order.
+4. Read the `abstractions.ts` file in the feature folder to see available methods.
+5. Extensions with no dependencies use `dependencies: []`.
+
+## Related Skills
+
+- `custom-graphql-api` -- DI in GraphQL schema extensions
+- `lifecycle-events` -- DI in lifecycle event handlers
+- `cli-extensions` -- DI in CLI command extensions

package/skills/infrastructure-extensions/SKILL.md

@@ -0,0 +1,192 @@
+---
+name: webiny-infrastructure-extensions
+context: webiny-extensions
+description: >
+  Modifying AWS infrastructure using Pulumi handlers and declarative Infra components.
+  Use this skill when the developer wants to customize AWS infrastructure, add Pulumi handlers,
+  configure OpenSearch, VPC, resource tags, regions, custom domains, blue-green deployments,
+  environment-conditional config, or manage production vs development infrastructure modes.
+  Covers CorePulumi.Interface, all <Infra.*> declarative components, and <Infra.Env.Is>.
+---
+
+# Infrastructure Extensions
+
+## TL;DR
+
+Infrastructure extensions modify your AWS infrastructure using Pulumi handlers and declarative `<Infra.*>` components in `webiny.config.tsx`. Pulumi handlers implement `CorePulumi.Interface` and are registered via `<Infra.Core.Pulumi>`. Declarative components configure OpenSearch, VPC, tags, regions, custom domains, blue-green deployments, and environment-specific settings.
+
+## Pulumi Handler Pattern
+
+Write custom Pulumi code that runs during infrastructure deployment:
+
+```typescript
+// extensions/MyCorePulumiHandler.ts
+import { Ui } from "webiny/infra";
+import { CorePulumi } from "webiny/infra/core";
+
+class MyCorePulumiHandlerImpl implements CorePulumi.Interface {
+    constructor(private ui: Ui.Interface) {}
+
+    execute(app: any) {
+        this.ui.info("Executing MyCorePulumiHandler with environment:", app.env);
+
+        // Access and modify Pulumi resources here
+        // app.resources gives you access to all provisioned resources
+    }
+}
+
+export default CorePulumi.createImplementation({
+    implementation: MyCorePulumiHandlerImpl,
+    dependencies: [Ui]
+});
+```
+
+Register:
+
+```tsx
+<Infra.Core.Pulumi src={"/extensions/MyCorePulumiHandler.ts"} />
+```
+
+### Use Cases for Pulumi Handlers
+
+- Add custom AWS resources (CloudWatch alarms, extra S3 buckets, Lambda functions)
+- Modify existing resource properties (Lambda memory, timeouts, environment variables)
+- Add conditional infrastructure based on environment
+- Integrate with third-party infrastructure providers
+
+## Declarative Infrastructure Components
+
+These components go directly in `webiny.config.tsx` -- no separate extension file needed:
+
+### AWS Configuration
+
+```tsx
+{/* Set the AWS region */}
+<Infra.Aws.DefaultRegion name={"us-east-1"} />
+
+{/* Apply tags to all AWS resources -- multiple calls are merged */}
+<Infra.Aws.Tags tags={{ OWNER: "me", PROJECT: "my-project" }} />
+<Infra.Aws.Tags tags={{ COST_CENTER: "engineering" }} />
+```
+
+### Search & Networking
+
+```tsx
+{/* Enable/disable OpenSearch */}
+<Infra.OpenSearch enabled={true} />
+
+{/* Enable/disable VPC deployment */}
+<Infra.Vpc enabled={false} />
+```
+
+### Resource Naming
+
+```tsx
+{/* Prefix all Pulumi resource names */}
+<Infra.PulumiResourceNamePrefix prefix={"myproj-"} />
+
+{/* Define which environments use production-grade infrastructure */}
+<Infra.ProductionEnvironments environments={["prod", "staging"]} />
+```
+
+### Custom Domains
+
+```tsx
+<Infra.Admin.CustomDomains
+    domains={["admin.example.com"]}
+    sslMethod="sni-only"
+    certificateArn="arn:aws:acm:us-east-1:123456789:certificate/abc-123"
+/>
+```
+
+### Blue-Green Deployments
+
+```tsx
+<Infra.BlueGreenDeployments
+    enabled={true}
+    domains={{
+        acmCertificateArn: "arn:aws:acm:us-east-1:123456789:certificate/abc-123",
+        sslSupportMethod: "sni-only",
+        domains: {
+            api: ["api.example.com"],
+            admin: ["admin.example.com"],
+            website: ["website.example.com"],
+            preview: ["preview.example.com"]
+        }
+    }}
+    deployments={[
+        { name: "green", env: "dev", variant: "green" },
+        { name: "blue", env: "dev", variant: "blue" }
+    ]}
+/>
+```
+
+## Environment-Conditional Configuration
+
+Use `<Infra.Env.Is>` to apply settings only in specific environments:
+
+```tsx
+{/* Production only */}
+<Infra.Env.Is env="prod">
+    <Infra.Aws.Tags tags={{ ENV: "production" }} />
+    <Infra.OpenSearch enabled={true} />
+</Infra.Env.Is>
+
+{/* Non-production (accepts array) */}
+<Infra.Env.Is env={["dev", "staging"]}>
+    <Infra.Aws.Tags tags={{ ENV: "non-production" }} />
+    <Infra.OpenSearch enabled={false} />
+</Infra.Env.Is>
+```
+
+## Project-Level Settings
+
+```tsx
+{/* Disable telemetry */}
+<Project.Telemetry enabled={false} />
+
+{/* Auto-install for CI/CD (skip the installation wizard) */}
+{process.env.WEBINY_CLI_AUTO_INSTALL && (
+    <Project.AutoInstall
+        adminUser={{
+            firstName: "Ad",
+            lastName: "Min",
+            email: "admin@webiny.com",
+            password: "12345678"
+        }}
+    />
+)}
+```
+
+## All Infrastructure Components Reference
+
+| Component | Purpose |
+|---|---|
+| `<Infra.Aws.DefaultRegion name="..." />` | Set the AWS region |
+| `<Infra.Aws.Tags tags={{ ... }} />` | Tag all AWS resources |
+| `<Infra.OpenSearch enabled={bool} />` | Enable/disable OpenSearch cluster |
+| `<Infra.Vpc enabled={bool} />` | Enable/disable VPC deployment |
+| `<Infra.PulumiResourceNamePrefix prefix="..." />` | Prefix Pulumi resource names |
+| `<Infra.ProductionEnvironments environments={[...]} />` | Define production-grade environments |
+| `<Infra.Admin.CustomDomains ... />` | Custom domains for Admin app |
+| `<Infra.BlueGreenDeployments ... />` | Blue-green deployment configuration |
+| `<Infra.Env.Is env="..." />` | Conditional config per environment |
+| `<Infra.Core.Pulumi src="..." />` | Register a custom Pulumi handler |
+| `<Project.Telemetry enabled={bool} />` | Enable/disable telemetry |
+| `<Project.AutoInstall adminUser={{ ... }} />` | Auto-install for CI/CD |
+
+## Quick Reference
+
+```
+Pulumi import:   import { CorePulumi } from "webiny/infra/core";
+Ui import:       import { Ui } from "webiny/infra";
+Interface:       CorePulumi.Interface
+Export:          CorePulumi.createImplementation({ implementation, dependencies })
+Register:        <Infra.Core.Pulumi src={"/extensions/MyHandler.ts"} />
+Deploy:          yarn webiny deploy core  (infrastructure changes)
+```
+
+## Related Skills
+
+- `project-structure` -- Full `webiny.config.tsx` anatomy
+- `local-development` -- Deployment commands and environment management

package/skills/lifecycle-events/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: webiny-lifecycle-events
+context: webiny-extensions
+description: >
+  CMS entry lifecycle hooks and security event handlers.
+  Use this skill when the developer wants to intercept content entry operations
+  (create, update, delete, publish, unpublish), validate data before save, auto-calculate
+  fields, send notifications after operations, enforce security policies, sync with external
+  systems, or hook into API key updates. Covers before/after hooks, event filtering by modelId,
+  payload mutation, and the Logger/BuildParams DI services.
+---
+
+# Lifecycle Events
+
+## TL;DR
+
+Webiny fires lifecycle events before and after CMS entry operations (create, update, delete, publish, unpublish) and security operations (API key updates). You hook into these by implementing the corresponding `EventHandler.Interface`, filtering by `modelId`, and optionally mutating `payload.values` before data is saved. Register as `<Api.Extension>`.
+
+## CMS Entry Lifecycle Events
+
+### Available Hooks
+
+| Hook | Import From | Fires When |
+|---|---|---|
+| `EntryBeforeCreateEventHandler` | `"webiny/api/cms/entry"` | Before a new entry is saved |
+| `EntryAfterCreateEventHandler` | `"webiny/api/cms/entry"` | After a new entry is saved |
+| `EntryBeforeUpdateEventHandler` | `"webiny/api/cms/entry"` | Before an existing entry is updated |
+| `EntryAfterUpdateEventHandler` | `"webiny/api/cms/entry"` | After an existing entry is updated |
+| `EntryBeforeDeleteEventHandler` | `"webiny/api/cms/entry"` | Before an entry is deleted |
+| `EntryAfterDeleteEventHandler` | `"webiny/api/cms/entry"` | After an entry is deleted |
+| `EntryBeforePublishEventHandler` | `"webiny/api/cms/entry"` | Before an entry is published |
+| `EntryAfterPublishEventHandler` | `"webiny/api/cms/entry"` | After an entry is published |
+
+### The Event Object
+
+Every handler receives an `event` with:
+
+- `event.modelId` -- The model ID string (e.g., `"contactSubmission"`)
+- `event.payload` -- The entry data object
+  - `event.payload.values` -- The field values (can be mutated in `before` hooks)
+
+### Pattern
+
+```typescript
+import { EntryBeforeCreateEventHandler as Handler } from "webiny/api/cms/entry";
+
+class MyHookImpl implements Handler.Interface {
+    async handle(event: Handler.Event): Promise<void> {
+        const { payload, modelId } = event;
+
+        // 1. Filter by model -- handlers fire for ALL models
+        if (modelId !== "myTargetModel") {
+            return;
+        }
+
+        // 2. Read values
+        const someField = payload.values?.someField as string;
+
+        // 3. Mutate values (before hooks only)
+        if (!payload.values) {
+            payload.values = {};
+        }
+        payload.values.computedField = "computed value";
+    }
+}
+
+export default Handler.createImplementation({
+    implementation: MyHookImpl,
+    dependencies: []
+});
+```
+
+Register in `webiny.config.tsx`:
+
+```tsx
+<Api.Extension src={"/extensions/MyHook.ts"} />
+```
+
+### When to Use Before vs After
+
+| Use Case | Hook Type | Why |
+|---|---|---|
+| Validate data | `Before` | Reject or modify before persistence |
+| Auto-calculate fields | `Before` | Set computed values before save |
+| Send email notification | `After` | Ensure data is persisted first |
+| Sync with external CRM | `After` | Side effect after successful save |
+| Enforce security policies | `Before` | Block operations before they happen |
+
+## Full Example: Email Classification Hook
+
+This hook intercepts contact form submissions, checks the email domain, and automatically classifies it as "work" or "personal":
+
+```typescript
+// extensions/contactSubmission/ContactSubmissionHook.ts
+import { EntryBeforeCreateEventHandler as Handler } from "webiny/api/cms/entry";
+import { Logger } from "webiny/api/logger";
+
+const PERSONAL_EMAIL_DOMAINS = [
+    "gmail.com",
+    "yahoo.com",
+    "hotmail.com",
+    "outlook.com",
+    "aol.com",
+    "icloud.com",
+    "protonmail.com"
+];
+
+class ContactSubmissionHookImpl implements Handler.Interface {
+    public constructor(private logger: Logger.Interface) {}
+
+    public async handle(event: Handler.Event): Promise<void> {
+        const { payload, modelId } = event;
+
+        // Only run for Contact Submission entries
+        if (modelId !== "contactSubmission") {
+            return;
+        }
+
+        this.logger.info(`Processing contact submission for model: ${modelId}`);
+
+        const email = payload.values?.email as string;
+        if (!email) {
+            this.logger.warn("No email found in contact submission");
+            return;
+        }
+
+        // Classify the email
+        const domain = email.split("@")[1]?.toLowerCase();
+        let type = "work";
+        if (domain && PERSONAL_EMAIL_DOMAINS.includes(domain)) {
+            type = "personal";
+        }
+
+        this.logger.info(`Classified email ${email} as ${type}`);
+
+        // Set the emailType field before the entry is saved
+        if (!payload.values) {
+            payload.values = {};
+        }
+        payload.values.emailType = type;
+    }
+}
+
+export default Handler.createImplementation({
+    implementation: ContactSubmissionHookImpl,
+    dependencies: [Logger]
+});
+```
+
+## Security Lifecycle Events
+
+### API Key After Update
+
+```typescript
+// extensions/MyApiKeyAfterUpdate.ts
+import { ApiKeyAfterUpdateHandler } from "webiny/api/security/api-key";
+import { Logger } from "webiny/api/logger";
+import { BuildParams } from "webiny/api/build-params";
+
+class MyApiKeyAfterUpdateImpl implements ApiKeyAfterUpdateHandler.Interface {
+    constructor(
+        private logger: Logger.Interface,
+        private buildParams: BuildParams.Interface
+    ) {}
+
+    async handle() {
+        this.logger.warn("An API key was updated!");
+
+        const param1 = this.buildParams.get<string>("MY_CUSTOM_BUILD_PARAM");
+        console.log(`Build param 1: ${param1}`);
+    }
+}
+
+const MyApiKeyAfterUpdate = ApiKeyAfterUpdateHandler.createImplementation({
+    implementation: MyApiKeyAfterUpdateImpl,
+    dependencies: [Logger, BuildParams]
+});
+
+export default MyApiKeyAfterUpdate;
+```
+
+Register with a dedicated JSX element:
+
+```tsx
+<Security.ApiKey.AfterUpdate src={"/extensions/MyApiKeyAfterUpdate.ts"} />
+```
+
+## Quick Reference
+
+```
+CMS hooks import:   import { EntryBeforeCreateEventHandler } from "webiny/api/cms/entry";
+Security import:    import { ApiKeyAfterUpdateHandler } from "webiny/api/security/apiKey";
+Event shape:        event.modelId (string), event.payload (object), event.payload.values (object)
+Export:             Handler.createImplementation({ implementation, dependencies })
+Register CMS:       <Api.Extension src={"/extensions/MyHook.ts"} />
+Register Security:  <Security.ApiKey.AfterUpdate src={"/extensions/MyHook.ts"} />
+Deploy:             yarn webiny deploy api
+```
+
+## Related Skills
+
+- `content-models` -- Define the models your hooks target
+- `dependency-injection` -- Inject Logger, BuildParams, and other services